From e8dcdc590f8ec65807268b6cf0f7e776044bcb96 Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Mon, 22 Sep 2025 22:14:44 -0500
Subject: [PATCH 01/23] feat(lib): optional nullable traits

---
 include/mrdocs/ADT/Nullable.hpp               | 318 +++++++++++++++++
 include/mrdocs/ADT/Optional.hpp               | 335 ++++++++++++++----
 include/mrdocs/Dom/Value.hpp                  |  16 +
 include/mrdocs/Metadata/Info.hpp              |   2 +-
 include/mrdocs/Metadata/Source.hpp            |  52 ++-
 src/lib/AST/ASTVisitor.cpp                    |  11 +-
 src/lib/Gen/adoc/AdocEscape.cpp               |   1 +
 src/lib/Gen/hbs/TagfileWriter.cpp             |   7 +-
 src/lib/Gen/xml/CXXTags.hpp                   |   4 +-
 .../Metadata/Finalizers/Javadoc/Function.hpp  |  32 +-
 .../Metadata/Finalizers/JavadocFinalizer.cpp  |   1 +
 src/lib/Metadata/Info/Function.cpp            |   4 +-
 src/lib/Metadata/Source.cpp                   |   6 +-
 src/test/ADT/Nullable.cpp                     | 239 +++++++++++++
 src/test/ADT/Optional.cpp                     | 233 ++++++++++++
 src/test_suite/detail/decomposer.hpp          |   2 +-
 src/test_suite/diff.cpp                       |  27 +-
 17 files changed, 1167 insertions(+), 123 deletions(-)
 create mode 100644 include/mrdocs/ADT/Nullable.hpp
 create mode 100644 src/test/ADT/Nullable.cpp
 create mode 100644 src/test/ADT/Optional.cpp

diff --git a/include/mrdocs/ADT/Nullable.hpp b/include/mrdocs/ADT/Nullable.hpp
new file mode 100644
index 000000000..bca755b80
--- /dev/null
+++ b/include/mrdocs/ADT/Nullable.hpp
@@ -0,0 +1,318 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_ADT_NULLABLE_HPP
+#define MRDOCS_API_ADT_NULLABLE_HPP
+
+#include <mrdocs/Platform.hpp>
+
+#include <type_traits>
+#include <utility>
+#include <memory>
+#include <concepts>
+#include <cmath>
+
+namespace clang::mrdocs {
+
+/** Defines a customization point for types that have an intrinsic sentinel
+    value denoting “null”.
+
+    Users may specialize this trait for their own types to declare a
+    sentinel-based null representation.
+
+    When enabled, nullable semantics can be implemented in terms of the
+    sentinel without storing a separate engaged/disengaged flag.
+
+    Contract for specializations:
+    - Provide static constexpr T sentinel() noexcept; which returns the distinguished null value.
+    - Provide static constexpr bool is_sentinel(const T&) noexcept; which recognizes the null value.
+
+    If a type does not have a well-defined sentinel, leave the primary template in effect.
+
+    Notes
+    - Built-in pointer types and std::nullptr_t are pre-specialized to use nullptr as the sentinel.
+**/
+template <class T>
+struct sentinel_traits
+{
+    // No sentinel() or is_sentinel() in the primary template.
+};
+
+/** sentinel_traits specialization for raw pointers.
+
+    Uses nullptr as the sentinel value.
+**/
+template <class T>
+struct sentinel_traits<T*> {
+    static constexpr T*
+    sentinel() noexcept
+    {
+        return nullptr;
+    }
+
+    static constexpr bool
+    is_sentinel(T const* p) noexcept
+    {
+        return p == nullptr;
+    }
+};
+
+/** sentinel_traits specialization for std::nullptr_t.
+**/
+template<>
+struct sentinel_traits<std::nullptr_t>
+{
+    static constexpr std::nullptr_t
+    sentinel() noexcept
+    {
+        return nullptr;
+    }
+
+    static constexpr bool
+    is_sentinel(std::nullptr_t) noexcept
+    {
+        return true;
+    }
+};
+
+// -----------------------------------------------------------------------------
+// Sentinel traits for numeric and enum types
+// -----------------------------------------------------------------------------
+
+/** sentinel_traits specialization for unsigned integral types.
+
+    Uses the maximum representable value (~0u) as the sentinel,
+    which corresponds to -1 when converted.
+**/
+template <std::unsigned_integral T>
+struct sentinel_traits<T>
+{
+    static constexpr T
+    sentinel() noexcept
+    {
+        return static_cast<T>(-1);
+    }
+
+    static constexpr bool
+    is_sentinel(T v) noexcept
+    {
+        return v == static_cast<T>(-1);
+    }
+};
+
+/** sentinel_traits specialization for floating-point types.
+
+    Uses a quiet NaN as the sentinel value. This assumes that T
+    supports NaN and that it is distinguishable from all ordinary values.
+**/
+template <std::floating_point T>
+struct sentinel_traits<T>
+{
+    static constexpr T
+    sentinel() noexcept
+    {
+        return std::numeric_limits<T>::quiet_NaN();
+    }
+
+    static constexpr bool
+    is_sentinel(T v) noexcept
+    {
+        return std::isnan(v);
+    }
+};
+
+/** sentinel_traits specialization for enums with a well-known "null" enumerator.
+
+    If the enum defines Unknown, UNKNOWN, None, or NONE, this trait uses
+    that enumerator as the sentinel. This requires that such an enumerator
+    exists and is accessible from the scope of T.
+**/
+template <typename T>
+requires std::is_enum_v<T> &&
+         (requires { T::Unknown; } ||
+          requires { T::UNKNOWN; } ||
+          requires { T::None; } ||
+          requires { T::NONE; })
+struct sentinel_traits<T>
+{
+    static constexpr T
+    sentinel() noexcept
+    {
+        if constexpr (requires { T::Unknown; })
+            return T::Unknown;
+        else if constexpr (requires { T::UNKNOWN; })
+            return T::UNKNOWN;
+        else if constexpr (requires { T::None; })
+            return T::None;
+        else
+            return T::NONE;
+    }
+
+    static constexpr bool
+    is_sentinel(T v) noexcept
+    {
+        return v == sentinel();
+    }
+};
+
+/** Concept that is satisfied when sentinel_traits<T> declares a usable sentinel.
+**/
+template<class T>
+concept HasSentinel =
+    requires
+    {
+        { sentinel_traits<T>::sentinel() } -> std::same_as<T>;
+        { sentinel_traits<T>::is_sentinel(std::declval<const T&>()) } -> std::convertible_to<bool>;
+    };
+
+/** Internal concept that matches “empty-clear default-constructible” types.
+
+    This captures the common case of containers and data structures that
+    can be default-constructed to empty, tested with .empty(), and
+    reset with .clear().
+
+    Common cases of such containers include std::string, std::vector,
+    std::optional, std::unique_ptr, std::shared_ptr, and many more.
+**/
+template<class T>
+concept ClearableEmpty =
+    std::default_initializable<T> &&
+    requires(T& t, const T& ct)
+    {
+        { ct.empty() } -> std::convertible_to<bool>;
+        { t.clear() } -> std::same_as<void>;
+    };
+
+/** nullable_traits<T> defines how to treat a T as “nullable” without an
+   external engaged bit.
+
+    This trait is the canonical place to encode nullability semantics used
+    by any optional-like type.
+
+    It exposes the minimal operations needed by an optional:
+    - is_null(const T&): test if a value is null.
+    - null(): create a null value.
+    - make_null(T&): turn an existing value into null.
+
+    Users may explicitly specialize nullable_traits for their types to define
+    the desired semantics.
+**/
+template<class T>
+struct nullable_traits
+{
+    // No interface in the primary template.
+    // Provide a specialization to enable.
+};
+
+/** nullable_traits for types with a sentinel.
+
+    Delegates null handling to sentinel_traits<T>.
+**/
+template<class T>
+requires HasSentinel<T>
+struct nullable_traits<T>
+{
+    static constexpr bool
+    is_null(T const& v) noexcept
+    {
+        return sentinel_traits<T>::is_sentinel(v);
+    }
+
+    static constexpr T
+    null() noexcept
+    {
+        return sentinel_traits<T>::sentinel();
+    }
+
+    static constexpr void
+    make_null(T& v) noexcept
+    {
+        v = sentinel_traits<T>::sentinel();
+    }
+};
+
+/** nullable_traits for clearable empty types.
+
+    Treats the empty state as null, creates null via default construction,
+    and erases via clear().
+**/
+template<class T>
+requires (!HasSentinel<T> && ClearableEmpty<T>)
+struct nullable_traits<T>
+{
+    static constexpr bool
+    is_null(T const& v) noexcept(noexcept(v.empty()))
+    {
+        return v.empty();
+    }
+
+    static constexpr T
+    null() noexcept(std::is_nothrow_default_constructible_v<T>)
+    {
+        return T();
+    }
+
+    static constexpr void
+    make_null(T& v) noexcept(noexcept(v.clear()))
+    {
+        v.clear();
+    }
+};
+
+/** Utility function that returns true if T has a nullable_traits
+    specialization enabled.
+**/
+template<class T>
+concept has_nullable_traits_v  =
+    requires
+    {
+        { nullable_traits<T>::is_null(std::declval<const T&>()) } -> std::convertible_to<bool>;
+        { nullable_traits<T>::null() } -> std::same_as<T>;
+        { nullable_traits<T>::make_null(std::declval<T&>()) } -> std::same_as<void>;
+    };
+
+/** make_null helper that uses nullable_traits<T> if available.
+
+    @param v The value to make null.
+**/
+template <has_nullable_traits_v T>
+inline void
+make_null(T& v) noexcept(noexcept(nullable_traits<T>::make_null(v)))
+{
+    nullable_traits<T>::make_null(v);
+}
+
+/** is_null helper that uses nullable_traits<T> if available.
+
+    @param v The value to test for null.
+    @return true if v is null, false otherwise.
+**/
+template <has_nullable_traits_v T>
+inline bool
+is_null(T const& v) noexcept(noexcept(nullable_traits<T>::is_null(v)))
+{
+    return nullable_traits<T>::is_null(v);
+}
+
+/** null_of helper that constructs a null T using nullable_traits<T>.
+
+    @return A null T value.
+**/
+template <has_nullable_traits_v T>
+inline T
+null_of() noexcept(noexcept(nullable_traits<T>::null()))
+{
+    return nullable_traits<T>::null();
+}
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/ADT/Optional.hpp b/include/mrdocs/ADT/Optional.hpp
index ddbc80602..a3e3205fb 100644
--- a/include/mrdocs/ADT/Optional.hpp
+++ b/include/mrdocs/ADT/Optional.hpp
@@ -5,6 +5,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 // Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Alan de Freitas (alandefreitas@gmail.com)
 //
 // Official repository: https://github.com/cppalliance/mrdocs
 //
@@ -13,151 +14,331 @@
 #define MRDOCS_API_ADT_OPTIONAL_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <concepts>
+#include <mrdocs/ADT/Nullable.hpp>
+#include <optional>
 #include <type_traits>
 #include <utility>
-#include <ranges>
 
 namespace clang::mrdocs {
 
-/** The default empty predicate.
+/** A compact optional that automatically uses nullable_traits<T> when
+    available.
 
-    This predicate is true when t.empty() returns
-    `true` where `t` is a `T`.
-*/
-struct DefaultEmptyPredicate
-{
-    template <std::ranges::range T>
-    constexpr
-    bool
-    operator()(T const& t) const noexcept
+    Design
+    - If nullable_traits<T> exists, the null state is encoded inside T
+      (via sentinel or clearable-empty semantics). Storage is exactly one T.
+    - Otherwise, this falls back to std::optional<T> and uses its discriminator.
+
+    This single implementation uses a conditional storage type plus if constexpr
+    on has_nullable_traits_v<T> to select the appropriate behavior at compile
+    time.
+**/
+template <class T>
+class Optional {
+    using storage_t = std::conditional_t<
+        has_nullable_traits_v<T>, T, std::optional<T>>;
+
+    static constexpr bool uses_nullable_traits = has_nullable_traits_v<T>;
+
+    // --- noexcept helpers (avoid instantiating both branches) ---
+    static consteval bool default_ctor_noex_()
     {
-        return std::ranges::empty(t);
+        if constexpr (uses_nullable_traits)
+            return noexcept(nullable_traits<T>::null());
+        else
+            return noexcept(storage_t{}); // std::optional<T>{} is noexcept
     }
 
-    template<class T>
-    constexpr
-    bool
-    operator()(T const& t) const noexcept
+    static consteval bool reset_noex_()
     {
-        return !t;
+        if constexpr (uses_nullable_traits)
+            return noexcept(nullable_traits<T>::make_null(std::declval<T&>()));
+        else
+            return noexcept(std::declval<std::optional<T>&>().reset());
     }
-};
 
-/** A compact optional.
+    static consteval bool has_value_noex_()
+    {
+        if constexpr (uses_nullable_traits)
+            return noexcept(nullable_traits<T>::is_null(std::declval<T const&>()));
+        else
+            return noexcept(std::declval<std::optional<T> const&>().has_value());
+    }
 
-    This works like std::optional except the
-    predicate is invoked to determine whether
-    the optional is engaged. This is a space
-    optimization.
-*/
-template<
-    class T,
-    class EmptyPredicate = DefaultEmptyPredicate>
-class Optional
-{
-    T t_;
+    storage_t s_;
 
 public:
     using value_type = T;
 
-    constexpr Optional() = default;
-    constexpr Optional(Optional const& other) = default;
+    /// Default-constructs to the “null” state.
+    constexpr Optional() noexcept(default_ctor_noex_())
+        : s_([&] {
+            if constexpr (uses_nullable_traits)
+            {
+                return storage_t(nullable_traits<T>::null());
+            } else
+            {
+                return storage_t(std::nullopt);
+            }
+        }())
+    {}
 
-    template<class U>
-    requires std::is_constructible_v<T, U>
-    constexpr explicit
-    Optional(U&& u)
-        : t_(std::forward<U>(u))
-    {
-    }
+    /// Copy constructor
+    constexpr Optional(Optional const&) = default;
+
+    /// Move constructor
+    constexpr Optional(Optional&&) = default;
+
+    /// Copy assignment
+    constexpr Optional&
+    operator=(Optional const&) = default;
+
+    /// Move assignment
+    constexpr Optional&
+    operator=(Optional&&) = default;
 
-    constexpr Optional& operator=(Optional const& other) = default;
-    constexpr Optional& operator=(Optional&& other) = default;
+    /** Construct from a value.
 
+        @param u The value to store. It must be convertible to T.
+     **/
     template <class U>
     requires std::is_constructible_v<T, U>
-    constexpr
-    Optional& operator=(U&& u)
+    constexpr explicit Optional(U&& u) noexcept(
+        std::is_nothrow_constructible_v<T, U>)
+        : s_([&] {
+            if constexpr (uses_nullable_traits)
+            {
+                return storage_t(static_cast<T>(std::forward<U>(u)));
+            }
+            else
+            {
+                return storage_t(std::forward<U>(u));
+            }
+        }())
+    {}
+
+    /** Assign from a value.
+
+        @param u The value to store. It must be convertible to T.
+     **/
+    template <class U>
+    requires std::is_constructible_v<T, U> && std::is_assignable_v<T&, U>
+    constexpr Optional&
+    operator=(U&& u) noexcept(std::is_nothrow_assignable_v<T&, U>)
     {
-        t_ = std::forward<U>(u);
+        s_ = std::forward<U>(u);
         return *this;
     }
 
-    constexpr
-    Optional& operator=(std::nullptr_t)
+    /// Assign null (disengage).
+    constexpr Optional&
+    operator=(std::nullptr_t) noexcept(reset_noex_())
     {
-        t_ = T();
-        MRDOCS_ASSERT(!this->operator bool());
+        reset();
+        MRDOCS_ASSERT(!has_value());
         return *this;
     }
 
-    constexpr void reset()
+    /** Reset to the null state. **/
+    constexpr void
+    reset() noexcept(reset_noex_())
     {
-        *this = Optional();
-        MRDOCS_ASSERT(!this->operator bool());
+        if constexpr (uses_nullable_traits)
+        {
+            nullable_traits<T>::make_null(s_);
+        }
+        else
+        {
+            s_.reset();
+        }
+        MRDOCS_ASSERT(!has_value());
     }
 
-    template<typename... Args>
+    /** In-place construct a new value, replacing any existing one.
+
+        @param args The arguments to forward to T's constructor.
+
+        @return A reference to the newly constructed value.
+     **/
+    template <class... Args>
     requires std::is_constructible_v<T, Args...>
-    constexpr value_type& emplace(Args&&... args)
+    constexpr value_type&
+    emplace(Args&&... args) noexcept(
+        std::is_nothrow_constructible_v<T, Args...>)
     {
-        return t_ = T(std::forward<Args>(args)...);
+        if constexpr (uses_nullable_traits)
+        {
+            s_ = T(std::forward<Args>(args)...);
+            return s_;
+        }
+        else
+        {
+            return s_.emplace(std::forward<Args>(args)...);
+        }
     }
 
-    constexpr value_type& value() & noexcept
+    /** True if engaged (contains a value).
+
+        @return `true` if the optional contains a value.
+     **/
+    constexpr bool
+    has_value() const noexcept(has_value_noex_())
     {
-        return t_;
+        if constexpr (uses_nullable_traits)
+        {
+            return !nullable_traits<T>::is_null(s_);
+        }
+        else
+        {
+            return s_.has_value();
+        }
     }
 
-    constexpr value_type const& value() const & noexcept
+    /** Contextual bool.
+     **/
+    constexpr explicit
+    operator bool() const noexcept(noexcept(this->has_value()))
     {
-        return t_;
+        return has_value();
     }
 
-    constexpr value_type&& value() && noexcept
+    /** Value access. Preconditions: has_value() is true.
+
+        @return A reference to the contained value.
+     **/
+    constexpr value_type&
+    value() & noexcept
     {
-        return std::move(t_);
+        MRDOCS_ASSERT(has_value());
+        if constexpr (uses_nullable_traits)
+        {
+            return s_;
+        }
+        else
+        {
+            return *s_;
+        }
     }
 
-    constexpr value_type const&& value() const && noexcept
+    /// @copydoc value() &
+    constexpr value_type const&
+    value() const& noexcept
     {
-        return std::move(t_);
+        MRDOCS_ASSERT(has_value());
+        if constexpr (uses_nullable_traits)
+        {
+            return s_;
+        }
+        else
+        {
+            return *s_;
+        }
     }
 
-    constexpr value_type& operator*() noexcept
+    /// @copydoc value() &
+    constexpr value_type&&
+    value() && noexcept
     {
-        return t_;
+        MRDOCS_ASSERT(has_value());
+        if constexpr (uses_nullable_traits)
+        {
+            return std::move(s_);
+        }
+        else
+        {
+            return std::move(*s_);
+        }
     }
 
-    constexpr value_type const& operator*() const noexcept
+    /// @copydoc value() &
+    constexpr value_type const&&
+    value() const&& noexcept
     {
-        return t_;
+        MRDOCS_ASSERT(has_value());
+        if constexpr (uses_nullable_traits)
+        {
+            return std::move(s_);
+        }
+        else
+        {
+            return std::move(*s_);
+        }
     }
 
-    constexpr value_type* operator->() noexcept
+    /** Pointer-like access.
+
+        @return A pointer to the contained value.
+     **/
+    constexpr value_type*
+    operator->() noexcept
     {
-        return &t_;
+        MRDOCS_ASSERT(has_value());
+        if constexpr (uses_nullable_traits)
+        {
+            return std::addressof(s_);
+        }
+        else
+        {
+            return std::addressof(*s_);
+        }
     }
 
-    constexpr value_type const* operator->() const noexcept
+    /// @copydoc operator->() noexcept
+    constexpr value_type const*
+    operator->() const noexcept
     {
-        return &t_;
+        MRDOCS_ASSERT(has_value());
+        if constexpr (uses_nullable_traits)
+        {
+            return std::addressof(s_);
+        }
+        else
+        {
+            return std::addressof(*s_);
+        }
     }
 
-    constexpr explicit operator bool() const noexcept
+    /** Dereference-like access.
+
+        @return A reference to the contained value.
+     **/
+    constexpr value_type&
+    operator*() noexcept
     {
-        return has_value();
+        MRDOCS_ASSERT(has_value());
+        if constexpr (uses_nullable_traits)
+        {
+            return s_;
+        }
+        else
+        {
+            return *s_;
+        }
     }
 
-    constexpr bool has_value() const noexcept
+    /// @copydoc operator*() noexcept
+    constexpr value_type const&
+    operator*() const noexcept
     {
-        return ! EmptyPredicate()(t_);
+        MRDOCS_ASSERT(has_value());
+        if constexpr (uses_nullable_traits)
+        {
+            return s_;
+        }
+        else
+        {
+            return *s_;
+        }
     }
 
-    auto operator<=>(Optional const&) const = default;
+    /** Three-way comparison defaults when supported by the underlying
+        T/std::optional.
+     **/
+    auto
+    operator<=>(Optional const&) const
+        = default;
 };
 
-} // clang::mrdocs
+} // namespace clang::mrdocs
 
 #endif
diff --git a/include/mrdocs/Dom/Value.hpp b/include/mrdocs/Dom/Value.hpp
index 0511f1bf7..c2c6a24e3 100644
--- a/include/mrdocs/Dom/Value.hpp
+++ b/include/mrdocs/Dom/Value.hpp
@@ -626,6 +626,22 @@ stringOrNull(
     return nullptr;
 }
 
+/** Return a non-empty string, or a null.
+
+    @param s The string to check.
+*/
+inline
+Value
+stringOrNull(
+    Optional<std::string> s)
+{
+    if(s.has_value())
+    {
+        return {*s};
+    }
+    return nullptr;
+}
+
 //------------------------------------------------
 
 /** Customization point tag.
diff --git a/include/mrdocs/Metadata/Info.hpp b/include/mrdocs/Metadata/Info.hpp
index cbb129aea..de2100452 100644
--- a/include/mrdocs/Metadata/Info.hpp
+++ b/include/mrdocs/Metadata/Info.hpp
@@ -418,7 +418,7 @@ tag_invoke(
 }
 
 inline
-OptionalLocation
+Optional<Location>
 getPrimaryLocation(Info const& I)
 {
     return getPrimaryLocation(
diff --git a/include/mrdocs/Metadata/Source.hpp b/include/mrdocs/Metadata/Source.hpp
index 4c887b62c..737f2433e 100644
--- a/include/mrdocs/Metadata/Source.hpp
+++ b/include/mrdocs/Metadata/Source.hpp
@@ -94,18 +94,50 @@ tag_invoke(
     dom::Value& v,
     Location const& loc);
 
-struct LocationEmptyPredicate
+/** nullable_traits specialization for Location.
+
+    Semantics
+    - The “null” (sentinel) state is any Location whose ShortPath is empty.
+    - Creating a null value produces a Location with all fields defaulted
+      and ShortPath empty.
+    - Making an existing value null clears ShortPath and resets the other
+      fields to their defaults.
+
+    Rationale
+    - This mirrors the old LocationEmptyPredicate, which treated an empty
+      ShortPath as “empty/null.”
+**/
+template<>
+struct nullable_traits<Location>
 {
-    constexpr bool operator()(
-        Location const& loc) const noexcept
+    static constexpr bool
+    is_null(Location const& v) noexcept
     {
-        return loc.ShortPath.empty();
+        return v.ShortPath.empty();
     }
-};
 
-/** Like std::optional<Location>
-*/
-using OptionalLocation = Optional<Location, LocationEmptyPredicate>;
+    static constexpr Location
+    null() noexcept
+    {
+        return Location{
+            /*full_path*/   {},
+            /*short_path*/  {},
+            /*source_path*/ {},
+            /*line*/        0u,
+            /*documented*/  false
+        };
+    }
+
+    static constexpr void
+    make_null(Location& v) noexcept
+    {
+        v.FullPath.clear();
+        v.ShortPath.clear();    // sentinel condition
+        v.SourcePath.clear();
+        v.LineNumber  = 0;
+        v.Documented  = false;
+    }
+};
 
 /** Stores source information for a declaration.
 */
@@ -119,7 +151,7 @@ struct MRDOCS_DECL
         actually a definition (e.g. alias-declarations and
         typedef declarations are never definition).
     */
-    OptionalLocation DefLoc;
+    Optional<Location> DefLoc;
 
     /** Locations where the entity was declared.
 
@@ -154,7 +186,7 @@ void
 merge(SourceInfo& I, SourceInfo&& Other);
 
 MRDOCS_DECL
-OptionalLocation
+Optional<Location>
 getPrimaryLocation(SourceInfo const& I, bool preferDefinition);
 
 void
diff --git a/src/lib/AST/ASTVisitor.cpp b/src/lib/AST/ASTVisitor.cpp
index a33826061..b014400bf 100644
--- a/src/lib/AST/ASTVisitor.cpp
+++ b/src/lib/AST/ASTVisitor.cpp
@@ -883,11 +883,14 @@ populate(
         if (!param.Default && default_arg)
         {
             param.Default = getSourceCode(default_arg->getSourceRange());
-            param.Default = trim(*param.Default);
-            if (param.Default->starts_with("= "))
+            if (param.Default)
             {
-                param.Default->erase(0, 2);
-                param.Default = ltrim(*param.Default);
+                param.Default = trim(*param.Default);
+                if (param.Default->starts_with("= "))
+                {
+                    param.Default->erase(0, 2);
+                    param.Default = ltrim(*param.Default);
+                }
             }
         }
     }
diff --git a/src/lib/Gen/adoc/AdocEscape.cpp b/src/lib/Gen/adoc/AdocEscape.cpp
index ca00fe28d..0044d71eb 100644
--- a/src/lib/Gen/adoc/AdocEscape.cpp
+++ b/src/lib/Gen/adoc/AdocEscape.cpp
@@ -11,6 +11,7 @@
 
 #include "AdocEscape.hpp"
 #include <mrdocs/Support/Handlebars.hpp>
+#include <ranges>
 
 namespace clang::mrdocs::adoc {
 
diff --git a/src/lib/Gen/hbs/TagfileWriter.cpp b/src/lib/Gen/hbs/TagfileWriter.cpp
index 7496de64c..cedb20d99 100644
--- a/src/lib/Gen/hbs/TagfileWriter.cpp
+++ b/src/lib/Gen/hbs/TagfileWriter.cpp
@@ -211,8 +211,11 @@ writeFunctionMember(FunctionInfo const& I)
     for(auto const& J : I.Params)
     {
         arglist += toString(*J.Type);
-        arglist += " ";
-        arglist += *J.Name;
+        if (J.Name)
+        {
+            arglist += " ";
+            arglist += *J.Name;
+        }
         arglist += ", ";
     }
     if (arglist.size() > 2) {
diff --git a/src/lib/Gen/xml/CXXTags.hpp b/src/lib/Gen/xml/CXXTags.hpp
index a9d74a7d0..c09e42f7a 100644
--- a/src/lib/Gen/xml/CXXTags.hpp
+++ b/src/lib/Gen/xml/CXXTags.hpp
@@ -260,8 +260,8 @@ inline void writeReturnType(TypeInfo const& I, XMLTags& tags)
 inline void writeParam(Param const& P, XMLTags& tags)
 {
     tags.open(paramTagName, {
-        { "name", *P.Name, P.Name.has_value() },
-        { "default", *P.Default, P.Default.has_value() },
+        { "name", P.Name.has_value() ? *P.Name : "", P.Name.has_value() },
+        { "default", P.Default.has_value() ? *P.Default : "", P.Default.has_value() },
         });
     writeType(*P.Type, tags);
     tags.close(paramTagName);
diff --git a/src/lib/Metadata/Finalizers/Javadoc/Function.hpp b/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
index a8b0c3f24..353557e28 100644
--- a/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
+++ b/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
@@ -534,10 +534,13 @@ setCntrOrAssignParamName(
         I.Class == FunctionClass::Constructor ||
         I.OverloadedOperator == OperatorKind::Equal,
         false);
-    auto paramNames = std::views::
-        transform(I.Params, [](Param const& p) -> std::string_view {
-        return *p.Name;
-    });
+    auto paramNames =
+        std::views::filter(I.Params, [](Param const& p) -> bool {
+            return p.Name.has_value();
+        }) |
+        std::views::transform([](Param const& p) -> std::string_view {
+            return *p.Name;
+        });
     auto& innerP = innermostType(param.Type);
     std::string_view paramName = "value";
     if (innerP->namedSymbol() == I.Parent)
@@ -557,8 +560,11 @@ setStreamOperatorParamName(
 {
     MRDOCS_CHECK_OR(index < 2, false);
     MRDOCS_CHECK_OR(isStreamInsertion(I), false);
-    auto paramNames = std::views::
-        transform(I.Params, [](Param const& p) -> std::string_view {
+    auto paramNames =
+        std::views::filter(I.Params, [](Param const& p) -> bool {
+        return p.Name.has_value();
+    }) |
+        std::views::transform([](Param const& p) -> std::string_view {
         return *p.Name;
     });
     std::string_view paramName =
@@ -579,8 +585,11 @@ setBinaryOpParamName(
     std::size_t const sizeFree = I.IsRecordMethod ? I.Params.size() + 1 : I.Params.size();
     MRDOCS_CHECK_OR(sizeFree == 2, false);
 
-    auto const paramNames = std::views::
-        transform(I.Params, [](Param const& p) -> std::string_view {
+    auto paramNames =
+        std::views::filter(I.Params, [](Param const& p) -> bool {
+        return p.Name.has_value();
+    }) |
+        std::views::transform([](Param const& p) -> std::string_view {
         return *p.Name;
     });
     std::size_t const indexFree = I.IsRecordMethod ? index + 1 : index;
@@ -601,8 +610,11 @@ setUnaryOpParamName(
     MRDOCS_CHECK_OR(isUnaryOperator(I.OverloadedOperator), false);
     MRDOCS_CHECK_OR(I.Params.size() == 1, false);
 
-    auto const paramNames = std::views::
-        transform(I.Params, [](Param const& p) -> std::string_view {
+    auto paramNames =
+        std::views::filter(I.Params, [](Param const& p) -> bool {
+        return p.Name.has_value();
+    }) |
+        std::views::transform([](Param const& p) -> std::string_view {
         return *p.Name;
     });
     std::string_view paramName = "value";
diff --git a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp b/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
index 7230aaaec..4b7a16446 100644
--- a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
@@ -1760,6 +1760,7 @@ warnNoParamDocs(FunctionInfo const& I)
     auto javadocParamNames = getJavadocParamNames(*I.javadoc);
     auto paramNames =
         std::views::transform(I.Params, &Param::Name) |
+        std::views::filter([](Optional<std::string> const& name) { return name.has_value(); }) |
         std::views::transform([](Optional<std::string> const& name) -> std::string_view { return *name; }) |
         std::views::filter([](std::string_view const& name) { return !name.empty(); });
     for (auto const& paramName: paramNames)
diff --git a/src/lib/Metadata/Info/Function.cpp b/src/lib/Metadata/Info/Function.cpp
index 702cd5082..12e6912a6 100644
--- a/src/lib/Metadata/Info/Function.cpp
+++ b/src/lib/Metadata/Info/Function.cpp
@@ -314,9 +314,9 @@ tag_invoke(
     Param const& p,
     DomCorpus const*)
 {
-    io.map("name", dom::stringOrNull(*p.Name));
+    io.map("name", dom::stringOrNull(p.Name));
     io.map("type", p.Type);
-    io.map("default", dom::stringOrNull(*p.Default));
+    io.map("default", dom::stringOrNull(p.Default));
 }
 
 void
diff --git a/src/lib/Metadata/Source.cpp b/src/lib/Metadata/Source.cpp
index 04f19902f..55e0427da 100644
--- a/src/lib/Metadata/Source.cpp
+++ b/src/lib/Metadata/Source.cpp
@@ -80,7 +80,7 @@ merge(SourceInfo& I, SourceInfo&& Other)
     mergeImpl<true>(I, Other);
 }
 
-OptionalLocation
+Optional<Location>
 getPrimaryLocation(SourceInfo const& I, bool const preferDefinition)
 {
     if (I.Loc.empty() ||
@@ -93,9 +93,9 @@ getPrimaryLocation(SourceInfo const& I, bool const preferDefinition)
             I.Loc, &Location::Documented);
     if (documentedIt != I.Loc.end())
     {
-        return OptionalLocation(*documentedIt);
+        return Optional<Location>(*documentedIt);
     }
-    return OptionalLocation(I.Loc.front());
+    return Optional<Location>(I.Loc.front());
 }
 
 template <class IO>
diff --git a/src/test/ADT/Nullable.cpp b/src/test/ADT/Nullable.cpp
new file mode 100644
index 000000000..fe4ed346d
--- /dev/null
+++ b/src/test/ADT/Nullable.cpp
@@ -0,0 +1,239 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#include <mrdocs/ADT/Nullable.hpp>
+#include <cmath>
+#include <optional>
+#include <string>
+#include <vector>
+#include <test_suite/test_suite.hpp>
+
+namespace clang::mrdocs {
+
+struct NullableTest {
+    // Types for testing
+    struct NoTraits {
+        int v{};
+    };
+
+    enum class EUnknown {
+        A,
+        B,
+        Unknown
+    };
+    enum class EUNKNOWN {
+        A,
+        B,
+        UNKNOWN
+    };
+    enum class ENone {
+        A,
+        B,
+        None
+    };
+    enum class ENONE {
+        A,
+        B,
+        NONE
+    };
+
+    void
+    test_concepts_and_detection()
+    {
+        // HasSentinel: pointers, nullptr_t, unsigned, floating, enums with
+        // known nuller
+        static_assert(HasSentinel<int*>);
+        static_assert(HasSentinel<std::nullptr_t>);
+        static_assert(HasSentinel<unsigned>);
+        static_assert(HasSentinel<double>);
+        static_assert(HasSentinel<EUnknown>);
+        static_assert(HasSentinel<EUNKNOWN>);
+        static_assert(HasSentinel<ENone>);
+        static_assert(HasSentinel<ENONE>);
+
+        // HasSentinel should NOT hold for std::string or NoTraits
+        static_assert(!HasSentinel<std::string>);
+        static_assert(!HasSentinel<NoTraits>);
+
+        // ClearableEmpty: string, vector qualify
+        static_assert(ClearableEmpty<std::string>);
+        static_assert(ClearableEmpty<std::vector<int>>);
+
+        // ClearableEmpty should NOT hold for primitive or pointer
+        static_assert(!ClearableEmpty<int>);
+        static_assert(!ClearableEmpty<int*>);
+
+        // has_nullable_traits_v (the concept) should be true when either
+        // sentinel or clearable-empty applies
+        static_assert(has_nullable_traits_v<int*>);
+        static_assert(has_nullable_traits_v<std::nullptr_t>);
+        static_assert(has_nullable_traits_v<unsigned>);
+        static_assert(has_nullable_traits_v<double>);
+        static_assert(has_nullable_traits_v<EUnknown>);
+        static_assert(has_nullable_traits_v<std::string>);
+        static_assert(has_nullable_traits_v<std::vector<int>>);
+        static_assert(!has_nullable_traits_v<NoTraits>);
+    }
+
+    void
+    test_sentinel_traits_pointers()
+    {
+        int* p = nullptr;
+        BOOST_TEST(sentinel_traits<int*>::is_sentinel(p));
+        BOOST_TEST(sentinel_traits<int*>::sentinel() == nullptr);
+
+        int x = 0;
+        p = &x;
+        BOOST_TEST(!sentinel_traits<int*>::is_sentinel(p));
+
+        // nullable_traits uses sentinel for pointers
+        BOOST_TEST(is_null<int*>(nullptr));
+        int* q = &x;
+        BOOST_TEST(!is_null(q));
+        make_null(q);
+        BOOST_TEST(is_null(q));
+        auto n = null_of<int*>();
+        BOOST_TEST(n == nullptr);
+    }
+
+    void
+    test_sentinel_traits_nullptr_t()
+    {
+        std::nullptr_t z = nullptr;
+        BOOST_TEST(sentinel_traits<std::nullptr_t>::is_sentinel(z));
+        BOOST_TEST(sentinel_traits<std::nullptr_t>::sentinel() == nullptr);
+
+        // nullable_traits via sentinel
+        BOOST_TEST(is_null(z));
+        auto n = null_of<std::nullptr_t>();
+        (void) n; // always null
+        std::nullptr_t t = nullptr;
+        make_null(t);
+        BOOST_TEST(is_null(t));
+    }
+
+    void
+    test_sentinel_traits_unsigned()
+    {
+        using U = unsigned;
+        U s = sentinel_traits<U>::sentinel();
+        BOOST_TEST(s == static_cast<U>(-1));
+        BOOST_TEST(sentinel_traits<U>::is_sentinel(s));
+        BOOST_TEST(!sentinel_traits<U>::is_sentinel(static_cast<U>(0)));
+
+        // nullable_traits via sentinel
+        U v = 7u;
+        BOOST_TEST(!is_null(v));
+        make_null(v);
+        BOOST_TEST(is_null(v));
+        BOOST_TEST(sentinel_traits<U>::is_sentinel(v));
+        BOOST_TEST(is_null(null_of<U>()));
+    }
+
+    void
+    test_sentinel_traits_floating()
+    {
+        using F = double;
+        F s = sentinel_traits<F>::sentinel();
+        BOOST_TEST(std::isnan(s));
+        BOOST_TEST(sentinel_traits<F>::is_sentinel(s));
+        BOOST_TEST(!sentinel_traits<F>::is_sentinel(0.0));
+
+        // nullable_traits via sentinel (NaN)
+        F v = 0.5;
+        BOOST_TEST(!is_null(v));
+        make_null(v);
+        BOOST_TEST(is_null(v));
+        BOOST_TEST(std::isnan(null_of<F>()));
+    }
+
+    void
+    test_sentinel_traits_enums_all_variants()
+    {
+        // EUnknown
+        BOOST_TEST(sentinel_traits<EUnknown>::is_sentinel(EUnknown::Unknown));
+        BOOST_TEST(sentinel_traits<EUnknown>::sentinel() == EUnknown::Unknown);
+        EUnknown eu = EUnknown::A;
+        BOOST_TEST(!is_null(eu));
+        make_null(eu);
+        BOOST_TEST(is_null(eu));
+        BOOST_TEST(null_of<EUnknown>() == EUnknown::Unknown);
+
+        // EUNKNOWN
+        BOOST_TEST(sentinel_traits<EUNKNOWN>::is_sentinel(EUNKNOWN::UNKNOWN));
+        BOOST_TEST(sentinel_traits<EUNKNOWN>::sentinel() == EUNKNOWN::UNKNOWN);
+
+        // ENone
+        BOOST_TEST(sentinel_traits<ENone>::is_sentinel(ENone::None));
+        BOOST_TEST(sentinel_traits<ENone>::sentinel() == ENone::None);
+
+        // ENONE
+        BOOST_TEST(sentinel_traits<ENONE>::is_sentinel(ENONE::NONE));
+        BOOST_TEST(sentinel_traits<ENONE>::sentinel() == ENONE::NONE);
+    }
+
+    void
+    test_nullable_traits_clearable_empty_string()
+    {
+        std::string s;
+        BOOST_TEST(has_nullable_traits_v<std::string>);
+        BOOST_TEST(is_null(s)); // empty
+        s = "abc";
+        BOOST_TEST(!is_null(s));
+        make_null(s); // clear()
+        BOOST_TEST(is_null(s));
+
+        auto z = null_of<std::string>(); // default empty
+        BOOST_TEST(is_null(z));
+    }
+
+    void
+    test_nullable_traits_clearable_empty_vector()
+    {
+        std::vector<int> v;
+        BOOST_TEST(has_nullable_traits_v<std::vector<int>>);
+        BOOST_TEST(is_null(v));
+        v.push_back(1);
+        BOOST_TEST(!is_null(v));
+        make_null(v);
+        BOOST_TEST(is_null(v));
+        auto z = null_of<std::vector<int>>();
+        BOOST_TEST(is_null(z));
+    }
+
+    void
+    test_negative_no_traits()
+    {
+        // No traits ⇒ helpers are not available by constraints; we only assert
+        // detection.
+        static_assert(!has_nullable_traits_v<NoTraits>);
+        BOOST_TEST(true);
+    }
+
+    void
+    run()
+    {
+        test_concepts_and_detection();
+        test_sentinel_traits_pointers();
+        test_sentinel_traits_nullptr_t();
+        test_sentinel_traits_unsigned();
+        test_sentinel_traits_floating();
+        test_sentinel_traits_enums_all_variants();
+        test_nullable_traits_clearable_empty_string();
+        test_nullable_traits_clearable_empty_vector();
+        test_negative_no_traits();
+
+        BOOST_TEST(true);
+    }
+};
+
+TEST_SUITE(NullableTest, "clang.mrdocs.ADT.Nullable");
+
+} // namespace clang::mrdocs
diff --git a/src/test/ADT/Optional.cpp b/src/test/ADT/Optional.cpp
new file mode 100644
index 000000000..80b4ea757
--- /dev/null
+++ b/src/test/ADT/Optional.cpp
@@ -0,0 +1,233 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#include <mrdocs/ADT/Optional.hpp>
+#include <mrdocs/Metadata/Source.hpp>
+#include <test_suite/test_suite.hpp>
+
+namespace clang::mrdocs {
+
+struct OptionalTest {
+    // A fallback-only payload type (no sentinel, no empty()/clear()).
+    struct NoTraits {
+        int x = 0;
+        int
+        forty_two() const
+        {
+            return 42;
+        }
+        auto
+        operator<=>(NoTraits const&) const
+            = default;
+    };
+
+    // An enum that should pick up sentinel via Unknown
+    enum class Color {
+        Red,
+        Green,
+        Unknown
+    };
+
+    void
+    test_nullable_string()
+    {
+        static_assert(
+            has_nullable_traits_v<std::string>,
+            "string should use nullable_traits");
+        Optional<std::string> o;
+        BOOST_TEST(!o.has_value()); // default-null via empty()
+
+        o.emplace("hi");
+        BOOST_TEST(o.has_value());
+        BOOST_TEST(*o == "hi");
+        BOOST_TEST(o->size() == 2u);
+
+        // value() overloads
+        {
+            std::string& lref = o.value();
+            BOOST_TEST(&lref == &*o);
+
+            std::string const& clref = std::as_const(o).value();
+            BOOST_TEST(&clref == &*std::as_const(o));
+
+            std::string moved = std::move(o).value(); // value() &&
+            BOOST_TEST(moved == "hi");
+        }
+
+        // assign null
+        o = nullptr;
+        BOOST_TEST(!o.has_value());
+
+        // reset()
+        o.reset();
+        BOOST_TEST(!o.has_value());
+
+        // construct from value
+        Optional<std::string> o2{ "abc" };
+        BOOST_TEST(o2.has_value());
+        BOOST_TEST(o2.value() == "abc");
+
+        // comparisons (spaceship defaults)
+        Optional<std::string> a{ "abc" }, b{ "abc" }, c{ "abd" };
+        BOOST_TEST(a == b);
+        BOOST_TEST(a < c);
+    }
+
+    void
+    test_nullable_unsigned()
+    {
+        static_assert(
+            has_nullable_traits_v<unsigned>,
+            "unsigned should use sentinel -1");
+        Optional<unsigned> id; // sentinel == max
+        BOOST_TEST(!id.has_value());
+
+        id = 7u;
+        BOOST_TEST(id.has_value());
+        BOOST_TEST(*id == 7u);
+
+        id = static_cast<unsigned>(-1); // assign sentinel -> null
+        BOOST_TEST(!id.has_value());
+
+        id.reset();
+        BOOST_TEST(!id.has_value());
+
+        id.emplace(42u);
+        BOOST_TEST(id.has_value());
+        BOOST_TEST(id.value() == 42u);
+    }
+
+    void
+    test_nullable_double()
+    {
+        static_assert(
+            has_nullable_traits_v<double>,
+            "double should use NaN sentinel");
+        Optional<double> dop; // NaN -> null
+        BOOST_TEST(!dop.has_value());
+
+        dop = 0.0;
+        BOOST_TEST(dop.has_value());
+        BOOST_TEST(*dop == 0.0);
+
+        dop = nullptr; // back to null
+        BOOST_TEST(!dop.has_value());
+    }
+
+    void
+    test_nullable_enum()
+    {
+        static_assert(
+            has_nullable_traits_v<Color>,
+            "enum with Unknown should have sentinel");
+        Optional<Color> c;
+        BOOST_TEST(!c.has_value()); // default to Unknown sentinel
+
+        c = Color::Red;
+        BOOST_TEST(c.has_value());
+        BOOST_TEST(*c == Color::Red);
+
+        c.reset();
+        BOOST_TEST(!c.has_value());
+    }
+
+    void
+    test_nullable_location()
+    {
+        // Location is nullable when ShortPath is empty (trait specialization
+        // provided by user)
+        static_assert(
+            has_nullable_traits_v<Location>,
+            "Location should use nullable_traits");
+        Optional<Location> loc;
+        BOOST_TEST(!loc.has_value()); // default has empty ShortPath
+
+        Location L{ "full.cpp", "short.cpp", "src.cpp", 10u, true };
+        Optional<Location> a{ L };
+        BOOST_TEST(a.has_value());
+        BOOST_TEST(a->ShortPath == "short.cpp");
+        BOOST_TEST(a->LineNumber == 10u);
+        BOOST_TEST((*a).Documented == true);
+
+        a = nullptr;
+        BOOST_TEST(!a.has_value());
+        // Invalid: BOOST_TEST(a.value().ShortPath.empty());
+    }
+
+    void
+    test_fallback_notraits()
+    {
+        static_assert(
+            !has_nullable_traits_v<NoTraits>,
+            "NoTraits must fall back to std::optional");
+        Optional<NoTraits> o;
+        BOOST_TEST(!o.has_value()); // default disengaged
+
+        o.emplace(NoTraits{ 7 });
+        BOOST_TEST(o.has_value());
+        BOOST_TEST((*o).x == 7);
+        BOOST_TEST(o->forty_two() == 42);
+
+        // copy / move
+        Optional<NoTraits> copy = o;
+        BOOST_TEST(copy.has_value());
+        BOOST_TEST(copy->x == 7);
+
+        Optional<NoTraits> moved = std::move(o);
+        BOOST_TEST(moved.has_value());
+        BOOST_TEST(moved->x == 7);
+
+        // assign value
+        o = NoTraits{ 9 };
+        BOOST_TEST(o.has_value());
+        BOOST_TEST(o->x == 9);
+
+        // value() overloads
+        {
+            NoTraits& lref = o.value();
+            BOOST_TEST(&lref == &*o);
+
+            NoTraits const& clref = std::as_const(o).value();
+            BOOST_TEST(&clref == &*std::as_const(o));
+
+            NoTraits moved_val = std::move(o).value();
+            BOOST_TEST(moved_val.x == 9);
+        }
+
+        // reset and null-assign
+        o.reset();
+        BOOST_TEST(!o.has_value());
+        o = nullptr;
+        BOOST_TEST(!o.has_value());
+
+        // comparisons
+        Optional<NoTraits> a, b;
+        BOOST_TEST(a == b); // both disengaged
+        a.emplace(NoTraits{ 1 });
+        b.emplace(NoTraits{ 2 });
+        BOOST_TEST(a != b);
+        BOOST_TEST(a < b);
+    }
+
+    void
+    run()
+    {
+        test_nullable_string();
+        test_nullable_unsigned();
+        test_nullable_double();
+        test_nullable_enum();
+        test_nullable_location();
+        test_fallback_notraits();
+    }
+};
+
+TEST_SUITE(OptionalTest, "clang.mrdocs.ADT.Optional");
+
+} // namespace clang::mrdocs
diff --git a/src/test_suite/detail/decomposer.hpp b/src/test_suite/detail/decomposer.hpp
index 21d2a7011..1f30f96e2 100644
--- a/src/test_suite/detail/decomposer.hpp
+++ b/src/test_suite/detail/decomposer.hpp
@@ -117,7 +117,7 @@ namespace test_suite::detail
         binary_operands<T, U const &>
         operator==(first_operand &&lhs, U &&rhs)
         {
-            if constexpr (integral_comparison<U>)
+            if constexpr (integral_comparison<U> && !std::same_as<bool, std::decay_t<U>>)
             {
                 return {std::cmp_equal( lhs.lhs_, rhs ), lhs.lhs_, "==", rhs};
             }
diff --git a/src/test_suite/diff.cpp b/src/test_suite/diff.cpp
index 341bba588..3d0b8f794 100644
--- a/src/test_suite/diff.cpp
+++ b/src/test_suite/diff.cpp
@@ -31,7 +31,8 @@ diffStrings(std::string_view str1, std::string_view str2, std::size_t context_si
             {
                 newPos = text.length();
             }
-            lines.push_back(text.substr(pos, newPos - pos));
+            auto line = text.substr(pos, newPos - pos);
+            lines.push_back(line);
             pos = newPos + 1;
         }
     };
@@ -81,7 +82,9 @@ diffStrings(std::string_view str1, std::string_view str2, std::size_t context_si
     {
         for (size_t j = 0; j < lines2.size(); ++j)
         {
-            if (trim_spaces(lines1[i]) == trim_spaces(lines2[j]))
+            auto line1 = trim_spaces(lines1[i]);
+            auto line2 = trim_spaces(lines2[j]);
+            if (line1 == line2)
             {
                 // If the lines are equal, it means they contribute to the common subsequence.
                 // In this case, the value in the current cell lcsTable[i + 1][j + 1] is set
@@ -119,12 +122,14 @@ diffStrings(std::string_view str1, std::string_view str2, std::size_t context_si
     // the adjacent cells to determine the direction of the LCS
     while (i > 0 && j > 0)
     {
-        if (lines1[i - 1] == lines2[j - 1])
+        auto line1 = trim_spaces(lines1[i - 1]);
+        auto line2 = trim_spaces(lines2[j - 1]);
+        if (line1 == line2)
         {
             // If the current lines lines1[i-1] and lines2[j-1] are equal,
             // it means the line is common to both multiline strings. It
             // is added to diffLines with a space prefix, indicating no change.
-            diffLines.push_back({std::string(lines1[i - 1]), false, false});
+            diffLines.push_back({std::string(line1), false, false});
             --i;
             --j;
             result.unmodified++;
@@ -136,7 +141,7 @@ diffStrings(std::string_view str1, std::string_view str2, std::size_t context_si
             // lcsTable[i-1][j], it means the line in lines2[j-1] is
             // part of the LCS. Thus, it is added to diffLines with
             // a "+" prefix to indicate an addition.
-            diffLines.push_back({std::string(lines2[j - 1]), true, false});
+            diffLines.push_back({std::string(line2), true, false});
             --j;
             result.added++;
         }
@@ -144,7 +149,7 @@ diffStrings(std::string_view str1, std::string_view str2, std::size_t context_si
         {
             // Otherwise, the line in lines1[i-1] is part of the LCS, and it
             // is added to diffLines with a "-" prefix to indicate a deletion.
-            diffLines.push_back({std::string(lines1[i - 1]), false, true});
+            diffLines.push_back({std::string(line1), false, true});
             --i;
             result.removed++;
         }
@@ -152,14 +157,16 @@ diffStrings(std::string_view str1, std::string_view str2, std::size_t context_si
 
     while (i > 0)
     {
-        diffLines.push_back({std::string(lines1[i - 1]), false, true});
+        auto line1 = lines1[i - 1];
+        diffLines.push_back({std::string(line1), false, true});
         --i;
         result.removed++;
     }
 
     while (j > 0)
     {
-        diffLines.push_back({std::string(lines2[j - 1]), true, false});
+        auto line2 = lines2[j - 1];
+        diffLines.push_back({std::string(line2), true, false});
         --j;
         result.added++;
     }
@@ -196,7 +203,7 @@ diffStrings(std::string_view str1, std::string_view str2, std::size_t context_si
         }
     }
 
-    // Concatenate diff lines into a single string considering number
+    // Concatenate diff lines into a single string considering the number
     // of unmodified lines in the context
     std::size_t out_of_context = 0;
     for (auto diffLine : diffLines)
@@ -265,8 +272,6 @@ BOOST_TEST_DIFF(
             BOOST_TEST(diff.added == 0);
             BOOST_TEST(diff.removed == 0);
         }
-        BOOST_TEST(rendered_contents.size() == expected_contents.size());
-        BOOST_TEST((rendered_contents == expected_contents));
     }
 }
 

From b3305373412fb7a9db7664b2d7e3414fd5200346 Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Wed, 24 Sep 2025 01:15:44 -0500
Subject: [PATCH 02/23] refactor(lib): polymorphic is value-type

This commit adjusts the Polymorphic class so that it becomes a value-type that matches the standard std::polymorphic. It also implements an implementation detail shared with Optional, allowing the private nullable state to be used for storage optimization.

The semantics become less convenient in the case of optional polymorphic objects, but the application becomes much safer because non-nullable objects are never in an invalid state. After adapting all objects, most polymorphic objects are, in fact, not nullable.

As future work, we can define a custom type for nullable polymorphic objects that has simpler semantics.
---
 include/mrdocs/ADT/Optional.hpp    | 338 ++++++++++++++++++++++++++++-
 include/mrdocs/ADT/Polymorphic.hpp | 303 +++++++++++++++-----------
 2 files changed, 499 insertions(+), 142 deletions(-)

diff --git a/include/mrdocs/ADT/Optional.hpp b/include/mrdocs/ADT/Optional.hpp
index a3e3205fb..a898114c9 100644
--- a/include/mrdocs/ADT/Optional.hpp
+++ b/include/mrdocs/ADT/Optional.hpp
@@ -15,6 +15,7 @@
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Nullable.hpp>
+#include <compare>
 #include <optional>
 #include <type_traits>
 #include <utility>
@@ -83,6 +84,11 @@ class Optional {
         }())
     {}
 
+    /** Construct from std::nullopt
+     */
+    constexpr Optional(std::nullopt_t) noexcept(default_ctor_noex_())
+        : Optional() {}
+
     /// Copy constructor
     constexpr Optional(Optional const&) = default;
 
@@ -102,15 +108,18 @@ class Optional {
         @param u The value to store. It must be convertible to T.
      **/
     template <class U>
-    requires std::is_constructible_v<T, U>
+    requires(
+        !std::same_as<std::remove_cvref_t<U>, Optional>
+        && !std::same_as<std::remove_cvref_t<U>, std::in_place_t>
+        && !std::same_as<std::remove_cvref_t<U>, std::nullopt_t>
+        && std::is_constructible_v<T, U>)
     constexpr explicit Optional(U&& u) noexcept(
         std::is_nothrow_constructible_v<T, U>)
         : s_([&] {
             if constexpr (uses_nullable_traits)
             {
                 return storage_t(static_cast<T>(std::forward<U>(u)));
-            }
-            else
+            } else
             {
                 return storage_t(std::forward<U>(u));
             }
@@ -122,11 +131,20 @@ class Optional {
         @param u The value to store. It must be convertible to T.
      **/
     template <class U>
-    requires std::is_constructible_v<T, U> && std::is_assignable_v<T&, U>
-    constexpr Optional&
+    requires(
+        !std::same_as<std::remove_cvref_t<U>, Optional>
+        && std::is_constructible_v<T, U> && std::is_assignable_v<T&, U>)
+    constexpr
+    Optional&
     operator=(U&& u) noexcept(std::is_nothrow_assignable_v<T&, U>)
     {
-        s_ = std::forward<U>(u);
+        if constexpr (uses_nullable_traits)
+        {
+            s_ = std::forward<U>(u);
+        } else
+        {
+            s_ = std::forward<U>(u);
+        }
         return *this;
     }
 
@@ -330,15 +348,311 @@ class Optional {
             return *s_;
         }
     }
+};
 
-    /** Three-way comparison defaults when supported by the underlying
-        T/std::optional.
-     **/
-    auto
-    operator<=>(Optional const&) const
-        = default;
+namespace detail {
+template<typename T>
+inline constexpr bool isOptionalV = false;
+
+template<typename T>
+inline constexpr bool isOptionalV<Optional<T>> = true;
+
+template <typename T>
+using OptionalRelopT = std::enable_if_t<std::is_convertible_v<T, bool>, bool>;
+
+template <typename T, typename U>
+using OptionalEqT = OptionalRelopT<
+    decltype(std::declval<T const&>() == std::declval<U const&>())>;
+
+template <typename T, typename U>
+using OptionalNeT = OptionalRelopT<
+    decltype(std::declval<T const&>() != std::declval<U const&>())>;
+
+template <typename T, typename U>
+using OptionalLtT = OptionalRelopT<
+    decltype(std::declval<T const&>() < std::declval<U const&>())>;
+
+template <typename T, typename U>
+using OptionalGtT = OptionalRelopT<
+    decltype(std::declval<T const&>() > std::declval<U const&>())>;
+
+template <typename T, typename U>
+using OptionalLeT = OptionalRelopT<
+    decltype(std::declval<T const&>() <= std::declval<U const&>())>;
+
+template <typename T, typename U>
+using OptionalGeT = detail::OptionalRelopT<
+    decltype(std::declval<T const&>() >= std::declval<U const&>())>;
+
+template <typename T>
+concept isDerivedFromOptional = requires(T const& __t) {
+    []<typename U>(Optional<U> const&) {
+    }(__t);
 };
 
+} // namespace detail
+
+/** Compares two Optional values for equality.
+
+    Returns true if both are engaged and their contained values are equal, or both are disengaged.
+*/
+template <typename T, typename U>
+constexpr detail::OptionalEqT<T, U>
+operator==(Optional<T> const& lhs, Optional<U> const& rhs)
+{
+    return static_cast<bool>(lhs) == static_cast<bool>(rhs)
+           && (!lhs || *lhs == *rhs);
+}
+
+/** Compares two Optional values for inequality.
+
+    Returns true if their engagement states differ or their contained values are not equal.
+*/
+template <typename T, typename U>
+constexpr detail::OptionalNeT<T, U>
+operator!=(Optional<T> const& lhs, Optional<U> const& rhs)
+{
+    return static_cast<bool>(lhs) != static_cast<bool>(rhs)
+           || (static_cast<bool>(lhs) && *lhs != *rhs);
+}
+
+/** Checks if the left Optional is less than the right Optional.
+
+    Returns true if the right is engaged and either the left is disengaged or its value is less.
+*/
+template <typename T, typename U>
+constexpr detail::OptionalLtT<T, U>
+operator<(Optional<T> const& lhs, Optional<U> const& rhs)
+{
+    return static_cast<bool>(rhs) && (!lhs || *lhs < *rhs);
+}
+
+/** Checks if the left Optional is greater than the right Optional.
+
+    Returns true if the left is engaged and either the right is disengaged or its value is greater.
+*/
+template <typename T, typename U>
+constexpr detail::OptionalGtT<T, U>
+operator>(Optional<T> const& lhs, Optional<U> const& rhs)
+{
+    return static_cast<bool>(lhs) && (!rhs || *lhs > *rhs);
+}
+
+/** Checks if the left Optional is less than or equal to the right Optional.
+
+    Returns true if the left is disengaged or the right is engaged and the left's value is less or equal.
+*/
+template <typename T, typename U>
+constexpr detail::OptionalLeT<T, U>
+operator<=(Optional<T> const& lhs, Optional<U> const& rhs)
+{
+    return !lhs || (static_cast<bool>(rhs) && *lhs <= *rhs);
+}
+
+/** Checks if the left Optional is greater than or equal to the right Optional.
+
+    Returns true if the right is disengaged or the left is engaged and its value is greater or equal.
+*/
+template <typename T, typename U>
+constexpr detail::OptionalGeT<T, U>
+operator>=(Optional<T> const& lhs, Optional<U> const& rhs)
+{
+    return !rhs || (static_cast<bool>(lhs) && *lhs >= *rhs);
+}
+
+/** Performs a three-way comparison between two Optional values.
+
+    If both are engaged, compares their contained values; otherwise, compares engagement state.
+*/
+template <typename T, std::three_way_comparable_with<T> U>
+[[nodiscard]]
+constexpr std::compare_three_way_result_t<T, U>
+operator<=>(Optional<T> const& x, Optional<U> const& y)
+{
+    return x && y ? *x <=> *y : bool(x) <=> bool(y);
+}
+
+/** Checks if the Optional is disengaged (equal to std::nullopt).
+
+    Returns true if the Optional does not contain a value.
+*/
+template <typename T>
+[[nodiscard]]
+constexpr bool
+operator==(Optional<T> const& lhs, std::nullopt_t) noexcept
+{
+    return !lhs;
+}
+
+/** Performs a three-way comparison between an Optional and std::nullopt.
+
+    Returns std::strong_ordering::greater if engaged, std::strong_ordering::equal if disengaged.
+*/
+template <typename T>
+[[nodiscard]]
+constexpr std::strong_ordering
+operator<=>(Optional<T> const& x, std::nullopt_t) noexcept
+{
+    return bool(x) <=> false;
+}
+
+/** Compares an engaged Optional to a value for equality.
+
+    Returns true if the Optional is engaged and its value equals rhs.
+*/
+template <typename T, typename U>
+requires(!detail::isOptionalV<U>)
+constexpr detail::OptionalEqT<T, U>
+operator== [[nodiscard]] (Optional<T> const& lhs, U const& rhs)
+{
+    return lhs && *lhs == rhs;
+}
+
+/** Compares a value to an engaged Optional for equality.
+
+    Returns true if the Optional is engaged and its value equals lhs.
+*/
+template <typename T, typename U>
+requires(!detail::isOptionalV<T>)
+constexpr detail::OptionalEqT<T, U>
+operator== [[nodiscard]] (T const& lhs, Optional<U> const& rhs)
+{
+    return rhs && lhs == *rhs;
+}
+
+/** Compares an Optional to a value for inequality.
+
+    Returns true if the Optional is disengaged or its value does not equal rhs.
+*/
+template <typename T, typename U>
+requires(!detail::isOptionalV<U>)
+constexpr detail::OptionalNeT<T, U>
+operator!= [[nodiscard]] (Optional<T> const& lhs, U const& rhs)
+{
+    return !lhs || *lhs != rhs;
+}
+
+/** Compares a value to an Optional for inequality.
+
+    Returns true if the Optional is disengaged or its value does not equal lhs.
+*/
+template <typename T, typename U>
+requires(!detail::isOptionalV<T>)
+constexpr detail::OptionalNeT<T, U>
+operator!= [[nodiscard]] (T const& lhs, Optional<U> const& rhs)
+{
+    return !rhs || lhs != *rhs;
+}
+
+/** Checks if the Optional is less than a value.
+
+    Returns true if the Optional is disengaged or its value is less than rhs.
+*/
+template <typename T, typename U>
+requires(!detail::isOptionalV<U>)
+constexpr detail::OptionalLtT<T, U>
+operator<[[nodiscard]] (Optional<T> const& lhs, U const& rhs)
+{
+    return !lhs || *lhs < rhs;
+}
+
+/** Checks if a value is less than an engaged Optional.
+
+    Returns true if the Optional is engaged and lhs is less than its value.
+*/
+template <typename T, typename U>
+requires(!detail::isOptionalV<T>)
+constexpr detail::OptionalLtT<T, U>
+operator<[[nodiscard]] (T const& lhs, Optional<U> const& rhs)
+{
+    return rhs && lhs < *rhs;
+}
+
+/** Checks if the Optional is greater than a value.
+
+    Returns true if the Optional is engaged and its value is greater than rhs.
+*/
+template <typename T, typename U>
+requires(!detail::isOptionalV<U>)
+constexpr detail::OptionalGtT<T, U>
+operator> [[nodiscard]] (Optional<T> const& lhs, U const& rhs)
+{
+    return lhs && *lhs > rhs;
+}
+
+/** Checks if a value is greater than an Optional.
+
+    Returns true if the Optional is disengaged or lhs is greater than its value.
+*/
+template <typename T, typename U>
+requires(!detail::isOptionalV<T>)
+constexpr detail::OptionalGtT<T, U>
+operator> [[nodiscard]] (T const& lhs, Optional<U> const& rhs)
+{
+    return !rhs || lhs > *rhs;
+}
+
+/** Checks if the Optional is less than or equal to a value.
+
+    Returns true if the Optional is disengaged or its value is less than or equal to rhs.
+*/
+template <typename T, typename U>
+requires(!detail::isOptionalV<U>)
+constexpr detail::OptionalLeT<T, U>
+operator<= [[nodiscard]] (Optional<T> const& lhs, U const& rhs)
+{
+    return !lhs || *lhs <= rhs;
+}
+
+/** Checks if a value is less than or equal to an engaged Optional.
+
+    Returns true if the Optional is engaged and lhs is less than or equal to its value.
+*/
+template <typename T, typename U>
+requires(!detail::isOptionalV<T>)
+constexpr detail::OptionalLeT<T, U>
+operator<= [[nodiscard]] (T const& lhs, Optional<U> const& rhs)
+{
+    return rhs && lhs <= *rhs;
+}
+
+/** Checks if the Optional is greater than or equal to a value.
+
+    Returns true if the Optional is engaged and its value is greater than or equal to rhs.
+*/
+template <typename T, typename U>
+requires(!detail::isOptionalV<U>)
+constexpr detail::OptionalGeT<T, U>
+operator>= [[nodiscard]] (Optional<T> const& lhs, U const& rhs)
+{
+    return lhs && *lhs >= rhs;
+}
+
+/** Checks if a value is greater than or equal to an Optional.
+
+    Returns true if the Optional is disengaged or lhs is greater than or equal to its value.
+*/
+template <typename T, typename U>
+requires(!detail::isOptionalV<T>)
+constexpr detail::OptionalGeT<T, U>
+operator>= [[nodiscard]] (T const& lhs, Optional<U> const& rhs)
+{
+    return !rhs || lhs >= *rhs;
+}
+
+/** Performs a three-way comparison between an Optional and a value.
+
+    If the Optional is engaged, compares its value to v; otherwise, returns less.
+*/
+template <typename T, typename U>
+requires(!detail::isDerivedFromOptional<U>)
+        && requires { typename std::compare_three_way_result_t<T, U>; }
+        && std::three_way_comparable_with<T, U>
+constexpr std::compare_three_way_result_t<T, U>
+operator<=> [[nodiscard]] (Optional<T> const& x, U const& v)
+{
+    return bool(x) ? *x <=> v : std::strong_ordering::less;
+}
 } // namespace clang::mrdocs
 
 #endif
diff --git a/include/mrdocs/ADT/Polymorphic.hpp b/include/mrdocs/ADT/Polymorphic.hpp
index f1ccca143..9273c1e1f 100644
--- a/include/mrdocs/ADT/Polymorphic.hpp
+++ b/include/mrdocs/ADT/Polymorphic.hpp
@@ -14,7 +14,7 @@
 
 #include <concepts>
 #include <mrdocs/Support/Assert.hpp>
-#include <optional>
+#include <mrdocs/ADT/Nullable.hpp>
 #include <utility>
 
 namespace clang::mrdocs {
@@ -42,133 +42,148 @@ namespace clang::mrdocs {
     the owned derived-type object in the
     destructor.
 */
-template <class T> class Polymorphic {
-  struct WrapperBase {
-    virtual constexpr ~WrapperBase() = default;
-    virtual T &getValue() = 0;
-    virtual constexpr WrapperBase *clone() = 0;
-  };
+template <class T>
+class Polymorphic {
+    struct WrapperBase {
+        virtual constexpr ~WrapperBase() = default;
+        virtual T& getValue() = 0;
+        virtual constexpr WrapperBase* clone() = 0;
+    };
+
+    template <class U>
+    class Wrapper final : public WrapperBase {
+        U Value;
+        U& getValue() override { return Value; }
+    public:
+        template <class... Ts>
+        constexpr Wrapper(Ts&&... ts) : Value(std::forward<Ts>(ts)...) {}
+        constexpr ~Wrapper() override = default;
+        constexpr WrapperBase* clone() override { return new Wrapper(Value); }
+    };
+
+    WrapperBase* WB; // nullptr only when constructed/reset by nullable_traits
+
+    // Private null token and constructor: only the friend traits can call this.
+    struct _null_t { explicit constexpr _null_t(int) {} };
+    explicit constexpr Polymorphic(_null_t) noexcept : WB(nullptr) {}
+
+    // Allow the traits specialization to access private members/ctors.
+    friend struct nullable_traits<Polymorphic<T>>;
+
+// std::polymorphic has a default constructor that
+// default-constructs the base type T if it's default-constructible.
+// We disable this constructor because this is always an error
+// in MrDocs.
+//    constexpr explicit Polymorphic()
+//    requires std::is_default_constructible_v<T>
+//             && std::is_copy_constructible_v<T>
+//        : WB(new Wrapper<T>())
+//    {}
 
-  template <class U> class Wrapper final : public WrapperBase {
-    U Value;
+public:
+    using value_type = T;
+    using pointer = T*;
+    using const_pointer = T const*;
+
+    /// Default constructs the value type (never null via public API).
+    /// explicit constexpr Polymorphic() : Polymorphic(std::in_place_type<T>) {}
+
+    /** Forwarding constructor from a derived U. */
+    template <class U>
+    constexpr explicit Polymorphic(U&& u)
+        requires (!std::same_as<Polymorphic, std::remove_cvref_t<U>>) &&
+                 std::copy_constructible<std::remove_cvref_t<U>> &&
+                 std::derived_from<std::remove_cvref_t<U>, T>
+        : WB(new Wrapper<std::remove_cvref_t<U>>(std::forward<U>(u))) {}
+
+    /** In-place constructor for a specific derived U. */
+    template <class U, class... Ts>
+    explicit constexpr Polymorphic(std::in_place_type_t<U>, Ts&&... ts)
+        requires std::same_as<std::remove_cvref_t<U>, U> &&
+                 std::constructible_from<U, Ts&&...> &&
+                 std::copy_constructible<U> && std::derived_from<U, T>
+        : WB(new Wrapper<U>(std::forward<Ts>(ts)...)) {}
+
+    constexpr Polymorphic(Polymorphic const& V)
+        : WB(V.WB ? V.WB->clone() : nullptr) {}
+
+    constexpr Polymorphic(Polymorphic&& V) noexcept
+        : WB(std::exchange(V.WB, nullptr)) {}
+
+    constexpr ~Polymorphic() { delete WB; }
+
+    constexpr Polymorphic& operator=(Polymorphic const& V) {
+        if (this != &V) {
+            Polymorphic Temp(V);
+            swap(*this, Temp);
+        }
+        return *this;
+    }
+
+    constexpr Polymorphic& operator=(Polymorphic&& V) noexcept {
+        if (this != &V) {
+            delete WB;
+            WB = std::exchange(V.WB, nullptr);
+        }
+        return *this;
+    }
 
-    U &getValue() override { return Value; }
+    [[nodiscard]] constexpr pointer operator->() noexcept {
+        MRDOCS_ASSERT(WB != nullptr);
+        return &WB->getValue();
+    }
 
-  public:
-    template <class... Ts>
-    constexpr Wrapper(Ts &&...ts) : Value(std::forward<Ts>(ts)...) {}
-    constexpr ~Wrapper() override = default;
-    constexpr WrapperBase *clone() override { return new Wrapper(getValue()); }
-  };
+    [[nodiscard]] constexpr const_pointer operator->() const noexcept {
+        MRDOCS_ASSERT(WB != nullptr);
+        return &WB->getValue();
+    }
 
-  WrapperBase *WB;
+    [[nodiscard]] constexpr T& operator*() noexcept {
+        MRDOCS_ASSERT(WB != nullptr);
+        return WB->getValue();
+    }
 
-public:
-  using value_type = T;
-  using pointer = T *;
-  using const_pointer = T const *;
-
-  /** Empty constructor.
-
-      Ensures: *this is empty.
-   */
-  constexpr Polymorphic(std::nullopt_t) : WB(nullptr) {}
-
-  /// Default constructs the value type.
-  explicit constexpr Polymorphic() : Polymorphic(std::in_place_type<T>) {}
-
-  /** Forwarding constructor.
-   * @param u The object to copy.
-   */
-  template <class U>
-  constexpr explicit Polymorphic(U &&u)
-    requires(not std::same_as<Polymorphic, std::remove_cvref_t<U>>) &&
-            std::copy_constructible<std::remove_cvref_t<U>> &&
-            std::derived_from<std::remove_cvref_t<U>, T>
-      : WB(new Wrapper<std::remove_cvref_t<U>>(std::forward<U>(u))) {}
-
-  /** In place constructor
-   * @param ts Arguments to forward to the constructor of U.
-   */
-  template <class U, class... Ts>
-  explicit constexpr Polymorphic(std::in_place_type_t<U>, Ts &&...ts)
-    requires std::same_as<std::remove_cvref_t<U>, U> &&
-             std::constructible_from<U, Ts &&...> &&
-             std::copy_constructible<U> && std::derived_from<U, T>
-      : WB(new Wrapper<U>(std::forward<Ts>(ts)...)) {}
-
-  constexpr Polymorphic(const Polymorphic &V)
-      : WB(V ? V.WB->clone() : nullptr) {}
-
-  constexpr Polymorphic(Polymorphic &&V) noexcept
-      : WB(std::exchange(V.WB, nullptr)) {}
-
-  constexpr ~Polymorphic() { delete WB; }
-
-  constexpr Polymorphic &operator=(const Polymorphic &V) {
-    if (this != &V) {
-      Polymorphic Temp(V);
-      swap(*this, Temp);
+    [[nodiscard]] constexpr T const& operator*() const noexcept {
+        MRDOCS_ASSERT(WB != nullptr);
+        return WB->getValue();
     }
-    return *this;
-  }
-
-  constexpr Polymorphic &operator=(Polymorphic &&V) noexcept {
-    if (this != &V) {
-      swap(*this, V);
-      Polymorphic Temp = std::nullopt;
-      swap(V, Temp);
+
+    constexpr bool
+    valueless_after_move() const noexcept
+    {
+        return WB == nullptr;
+    }
+
+    friend constexpr void
+    swap(Polymorphic& lhs, Polymorphic& rhs) noexcept
+    {
+        std::swap(lhs.WB, rhs.WB);
     }
-    return *this;
-  }
-
-  [[nodiscard]] constexpr pointer operator->() noexcept {
-    MRDOCS_ASSERT(WB != nullptr);
-    return &WB->getValue();
-  }
-
-  [[nodiscard]] constexpr const_pointer operator->() const noexcept {
-    MRDOCS_ASSERT(WB != nullptr);
-    return &WB->getValue();
-  }
-
-  [[nodiscard]] constexpr T &operator*() noexcept {
-    MRDOCS_ASSERT(WB != nullptr);
-    return WB->getValue();
-  }
-
-  [[nodiscard]] constexpr const T &operator*() const noexcept {
-    MRDOCS_ASSERT(WB != nullptr);
-    return WB->getValue();
-  }
-
-  [[nodiscard]] explicit constexpr operator bool() const noexcept {
-    return WB != nullptr;
-  }
-
-  friend constexpr void swap(Polymorphic &lhs, Polymorphic &rhs) noexcept {
-    std::swap(lhs.WB, rhs.WB);
-  }
 };
 
 namespace detail {
 
 // A function to compare two polymorphic objects that
 // store the same derived type
-template <class Base> struct VisitCompareFn {
-  Base const &rhs;
+template <class Base>
+struct VisitCompareFn
+{
+    Base const& rhs;
 
-  template <class Derived> auto operator()(Derived const &lhsDerived) {
-    auto const &rhsDerived = dynamic_cast<Derived const &>(rhs);
-    return lhsDerived <=> rhsDerived;
-  }
+    template <class Derived>
+    auto
+    operator()(Derived const& lhsDerived)
+    {
+        auto const& rhsDerived = dynamic_cast<Derived const&>(rhs);
+        return lhsDerived <=> rhsDerived;
+    }
 };
 
-/** Determines if a type can be visited with VisitCompareFn
- */
 template <class Base>
-concept CanVisitCompare =
-    requires(Base const &b) { visit(b, VisitCompareFn<Base>{b}); };
+concept CanVisitCompare = requires(Base const& b)
+{
+    visit(b, VisitCompareFn<Base>{ b });
+};
 
 template <class T> inline constexpr bool IsPolymorphic = false;
 template <class T> inline constexpr bool IsPolymorphic<Polymorphic<T>> = true;
@@ -197,11 +212,9 @@ template <class T> inline constexpr bool IsPolymorphic<Polymorphic<T>> = true;
 template <class Base>
 requires detail::CanVisitCompare<Base>
 auto
-CompareDerived(
-    Polymorphic<Base> const& lhs,
-    Polymorphic<Base> const& rhs)
+CompareDerived(Polymorphic<Base> const& lhs, Polymorphic<Base> const& rhs)
 {
-    if (lhs && rhs)
+    if (!lhs.valueless_after_move() && !rhs.valueless_after_move())
     {
         if (lhs->Kind == rhs->Kind)
         {
@@ -209,26 +222,28 @@ CompareDerived(
         }
         return lhs->Kind <=> rhs->Kind;
     }
-    return !lhs ? std::strong_ordering::less
-            : std::strong_ordering::greater;
+    return lhs.valueless_after_move() ?
+               std::strong_ordering::less :
+               std::strong_ordering::greater;
 }
 
 /// @copydoc CompareDerived(Polymorphic<Base> const&, Polymorphic<Base> const&)
 template <class Base>
-  requires(!detail::IsPolymorphic<Base>) && detail::CanVisitCompare<Base>
-auto CompareDerived(Base const &lhs, Base const &rhs) {
-  if (lhs.Kind == rhs.Kind) {
-    return visit(lhs, detail::VisitCompareFn<Base>(rhs));
-  }
-  return lhs.Kind <=> rhs.Kind;
+requires(!detail::IsPolymorphic<Base>) && detail::CanVisitCompare<Base>
+auto
+CompareDerived(Base const& lhs, Base const& rhs)
+{
+    if (lhs.Kind == rhs.Kind)
+    {
+        return visit(lhs, detail::VisitCompareFn<Base>(rhs));
+    }
+    return lhs.Kind <=> rhs.Kind;
 }
 
 template <class Base>
 requires detail::CanVisitCompare<Base>
 auto
-operator<=>(
-    Polymorphic<Base> const& lhs,
-    Polymorphic<Base> const& rhs)
+operator<=>(Polymorphic<Base> const& lhs, Polymorphic<Base> const& rhs)
 {
     return CompareDerived(lhs, rhs);
 }
@@ -236,13 +251,41 @@ operator<=>(
 template <class Base>
 requires detail::CanVisitCompare<Base>
 bool
-operator==(
-    Polymorphic<Base> const& lhs,
-    Polymorphic<Base> const& rhs)
+operator==(Polymorphic<Base> const& lhs, Polymorphic<Base> const& rhs)
 {
     return lhs <=> rhs == std::strong_ordering::equal;
 }
 
-} // clang::mrdocs
+// -------------------- nullable_traits specialization --------------------
+
+/** nullable_traits for Polymorphic<T>.
+
+    Only this friend specialization can create/reset the null state.
+*/
+template<class T>
+struct nullable_traits<Polymorphic<T>>
+{
+    static constexpr bool
+    is_null(Polymorphic<T> const& v) noexcept
+    {
+        return v.valueless_after_move();
+    }
+
+    static constexpr Polymorphic<T>
+    null() noexcept
+    {
+        // Use the private null constructor
+        return Polymorphic<T>(typename Polymorphic<T>::_null_t{0});
+    }
+
+    static constexpr void
+    make_null(Polymorphic<T>& v) noexcept
+    {
+        delete v.WB;
+        v.WB = nullptr;
+    }
+};
+
+} // namespace clang::mrdocs
 
 #endif

From 149190f313a19b1d5257bacbb2c13161cf4b9060 Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Wed, 24 Sep 2025 02:29:15 -0500
Subject: [PATCH 03/23] docs(contribute): style guide

---
 .clang-format                           | 226 ++++++++++++++
 .gitignore                              |   1 -
 bootstrap.py                            |   6 +
 docs/modules/ROOT/pages/contribute.adoc |  20 ++
 util/reformat.py                        | 388 ++++++++++++++++++++++++
 5 files changed, 640 insertions(+), 1 deletion(-)
 create mode 100644 .clang-format
 create mode 100644 util/reformat.py

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 000000000..beac5f6b1
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,226 @@
+#
+# Copyright (c) 2023 Alan de Freitas (alandefreitas@gmail.com)
+#
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt
+#
+
+# ---------------------------------------------------------------------------
+# MrDocs Formatting Guidelines (Clang-Format Reference)
+#
+# This file encodes the formatting style we generally follow in MrDocs,
+# based on conventions we have been using in Boost projects.
+#
+# Important:
+# - Do not run clang-format across entire files or the whole project.
+# - This configuration is provided as a *reference* to help new contributors
+#   understand the style rules and configure their editors/IDEs.
+# - You may use clang-format to format only the *new code you add or modify*
+#   in a commit. Never reformat unrelated code.
+#
+# The goal is to keep the codebase consistent and allow new contributors
+# to follow the same style, while minimizing churn and noise, and
+# without introducing large, style-only changes in version history.
+#
+# If in doubt, look at the surrounding code in the file and follow its style.
+# This file is here to make that easier, not to replace careful review.
+# ---------------------------------------------------------------------------
+
+Language: Cpp
+Standard: Latest
+BasedOnStyle: Microsoft
+
+# Columns and Lines
+ColumnLimit: 80
+ReflowComments: Always
+TabWidth: 8
+UseCRLF: false
+UseTab: Never
+DeriveLineEnding: true
+
+# Breaking around braces
+InsertBraces: true
+BreakBeforeBraces: Custom
+BraceWrapping:
+  # Control
+  AfterControlStatement: Always
+  AfterCaseLabel: true
+  BeforeCatch: true
+  BeforeElse: true
+  BeforeWhile: true
+  # Definition
+  AfterNamespace: false
+  AfterStruct: false
+  AfterClass: false
+  SplitEmptyRecord: false
+  AfterFunction: true
+  SplitEmptyFunction: false
+  BeforeLambdaBody: false
+  AfterEnum: false
+  SplitEmptyNamespace: true
+  AfterUnion: false
+  AfterExternBlock: true
+  # Extra
+  IndentBraces: false
+
+# Breaking around specifiers
+#     Namespaces
+CompactNamespaces: false
+#     Templates
+AlwaysBreakTemplateDeclarations: Yes
+BreakBeforeConceptDeclarations: true
+#     Classes
+BreakInheritanceList: BeforeComma
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: Leave
+#     Functions
+AlwaysBreakAfterDefinitionReturnType: All
+AlwaysBreakAfterReturnType: All
+MaxEmptyLinesToKeep: 2
+#     Strings
+AlwaysBreakBeforeMultilineStrings: false
+BreakStringLiterals: true
+#     Expressions
+BreakConstructorInitializers: BeforeComma
+BreakBeforeBinaryOperators: All
+BreakBeforeTernaryOperators: false
+
+# Breaking single line blocks
+#     Control
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+#     Declarations
+AllowShortEnumsOnASingleLine: false
+#     Function
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortLambdasOnASingleLine: Inline
+#     Expressions
+AllowAllArgumentsOnNextLine: false
+
+# Indentation
+#    Parameters
+IndentWidth: 4
+#    Definitions
+NamespaceIndentation: None
+IndentExternBlock: NoIndent
+IndentPPDirectives: AfterHash
+#    Classes
+AccessModifierOffset: -4
+IndentAccessModifiers: false
+#    Templates
+IndentRequires: false
+#    Functions
+IndentWrappedFunctionNames: false
+LambdaBodyIndentation: OuterScope
+#    Control
+ConstructorInitializerIndentWidth: 4
+IndentCaseBlocks: false
+IndentCaseLabels: false
+IndentGotoLabels: true
+#    Expressions
+ContinuationIndentWidth: 4
+InsertTrailingCommas: None
+KeepEmptyLinesAtTheStartOfBlocks: false
+
+# Alignment
+#    Macros
+AlignConsecutiveMacros: Consecutive
+AttributeMacros: [ 'FUTURES_CONSTEXPR', 'FUTURES_NODISCARD' ]
+IfMacros: [ 'FUTURES_IF_CONSTEXPR', 'SECTION', 'TEST_CASE' ]
+TypenameMacros: [ 'FUTURES_DETAIL' ]
+#    Declaration
+PointerAlignment: Left
+ReferenceAlignment: Pointer
+DerivePointerAlignment: true
+AlignConsecutiveDeclarations: None
+QualifierAlignment: Custom
+QualifierOrder: [ 'inline', 'static', 'constexpr', 'type', 'const' ]
+#    Namespace
+ShortNamespaceLines: 0
+#    Brackets
+AlignAfterOpenBracket: AlwaysBreak
+#    Expressions
+AlignArrayOfStructures: Right
+AlignConsecutiveAssignments: None
+AlignConsecutiveBitFields: None
+AlignEscapedNewlines: Left
+AlignOperands: Align
+AlignTrailingComments: true
+
+# Spaces
+SpaceAfterCStyleCast: true
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: false
+SpacesInSquareBrackets: false
+SpaceBeforeSquareBrackets: false
+SpacesBeforeTrailingComments: 1
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesInAngles: Never
+SpacesInCStyleCastParentheses: false
+SpacesInConditionalStatement: false
+SpacesInParentheses: false
+Cpp11BracedListStyle: false
+
+# BinPack
+BinPackArguments: false
+BinPackParameters: false
+BitFieldColonSpacing: After
+ExperimentalAutoDetectBinPacking: true
+PackConstructorInitializers: CurrentLine
+
+# Penalties
+PenaltyBreakAssignment: 512
+PenaltyBreakBeforeFirstCallParameter: 512
+PenaltyBreakComment: 512
+PenaltyBreakFirstLessLess: 512
+PenaltyBreakString: 512
+PenaltyBreakTemplateDeclaration: 512
+PenaltyExcessCharacter: 256
+PenaltyIndentedWhitespace: 8
+PenaltyReturnTypeOnItsOwnLine: 2
+
+# Sorting
+SortIncludes: CaseInsensitive
+SortUsingDeclarations: true
+IncludeBlocks: Merge
+IncludeCategories:
+  - Regex: '^<mrdocs/Platform\.hpp>$'            # always first
+    Priority: 0
+  - Regex: '^".*"'                               # quoted includes come next
+    Priority: 1
+  - Regex: '^<lib/.*>'                        # internal project headers
+    Priority: 2
+  - Regex: '^<mrdocs/.*>'                        # internal project headers
+    Priority: 3
+  - Regex: '^<test_suite/.*>'                    # test suite headers
+    Priority: 4
+  - Regex: '^<clang/.*>'                         # clang headers
+    Priority: 5
+  - Regex: '^<llvm/.*>'                          # llvm headers
+    Priority: 6
+  - Regex: '^<fmt/.*>'                           # fmt headers
+    Priority: 7
+  - Regex: '^<duktape/.*>'                       # duktape headers
+    Priority: 8
+  - Regex: '^<(?!mrdocs/|clang/|llvm/|test_suite/|fmt/|duktape/)[^/]+/.*>' # other angle-bracket includes
+    Priority: 9
+  - Regex: '^<[^/]+>'                            # C++ standard headers like <vector>
+    Priority: 10
+  - Regex: '.*'                                  # fallback
+    Priority: 11
+
+# Comments
+FixNamespaceComments: true
+CommentPragmas: '^ clang-format'
diff --git a/.gitignore b/.gitignore
index 098519ed9..9b6623007 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,6 +20,5 @@
 /share/mrdocs/libcxx/
 /share/mrdocs/clang/
 /docs/modules/reference
-/.clang-format
 /.gdbinit
 /.lldbinit
\ No newline at end of file
diff --git a/bootstrap.py b/bootstrap.py
index 9a2f79d5d..7a5f8c5bd 100644
--- a/bootstrap.py
+++ b/bootstrap.py
@@ -2369,6 +2369,12 @@ def generate_run_configs(self):
             "args": [],
             "cwd": self.options.mrdocs_src_dir
         })
+        configs.append({
+            "name": f"MrDocs Reformat Source Files",
+            "script": os.path.join(self.options.mrdocs_src_dir, 'util', 'reformat.py'),
+            "args": [],
+            "cwd": self.options.mrdocs_src_dir
+        })
 
         # Documentation generation targets
         mrdocs_docs_dir = os.path.join(self.options.mrdocs_src_dir, "docs")
diff --git a/docs/modules/ROOT/pages/contribute.adoc b/docs/modules/ROOT/pages/contribute.adoc
index 5530b8546..364844d64 100644
--- a/docs/modules/ROOT/pages/contribute.adoc
+++ b/docs/modules/ROOT/pages/contribute.adoc
@@ -233,6 +233,26 @@ The fixtures for golden testing are defined in `test-files/golden-tests`, where
 * `<filename>.bad.xml`: The test output file generated when the test fails.
 * `<filename>.yml`: Extra configuration options for this specific file.
 
+== Style Guide
+
+This project follows informal formatting conventions established by previous Boost projects.
+To help contributors, we provide a `.clang-format` file that encodes these rules.
+
+* Do *not* apply clang-format across entire files or the whole project.
+* Use the config only as a *reference* for your IDE/editor, or to format the code you **personally add or modify** in a commit.
+* Always check the surrounding code and keep consistent with it.
+* Do not create style-only commits that introduce large diffs without functional changes.
+
+Why This Approach:
+
+* Keeps history clean: avoids large, style-only commits.
+* Ensures new contributors are not lost when adapting to project style.
+* Encourages consistency without rigid automation.
+
+General Advice: When in doubt, copy the style of the surrounding code. The `.clang-format` file is a tool to help you, not a rule to enforce blindly.
+
+The utility script `./util/reformat.sh` can also be used to check a few project invariants, such as header guards and include order.
+
 == Contributing
 
 If you find a bug or have a feature request, please open an issue on the MrDocs GitHub repository: https://github.com/cppalliance/mrdocs/issues
diff --git a/util/reformat.py b/util/reformat.py
new file mode 100644
index 000000000..696f858f5
--- /dev/null
+++ b/util/reformat.py
@@ -0,0 +1,388 @@
+#!/usr/bin/env python3
+import os
+import re
+import subprocess
+import shutil
+from typing import List, Optional, Tuple
+
+# ---------- configuration ----------
+PROCESS_EXTS = {".hpp", ".cpp"}  # extend as needed
+CLANG_FORMAT_EXE = shutil.which("clang-format")  # resolve once
+
+# ---------- guard name ----------
+def make_guard(abs_path: str, base: str, guard_prefix: str) -> str:
+    rel = os.path.relpath(abs_path, base).replace(os.sep, "/")
+    suffix = re.sub(r'[^0-9A-Za-z]+', '_', rel).upper().strip('_')
+    guard = f"{guard_prefix}{suffix}" if guard_prefix else suffix
+    if not re.match(r'[A-Z_]', guard[0]):
+        guard = f"_{guard}"
+    return guard
+
+# ---------- comment handling ----------
+def strip_line_comments_and_blocks(line: str, in_block: bool) -> Tuple[str, bool]:
+    i, n = 0, len(line)
+    out = []
+    while i < n:
+        if in_block:
+            end = line.find("*/", i)
+            if end == -1:
+                return "".join(out), True
+            i = end + 2
+            in_block = False
+        else:
+            if line.startswith("/*", i):
+                in_block = True
+                i += 2
+                continue
+            if line.startswith("//", i):
+                break
+            out.append(line[i])
+            i += 1
+    return "".join(out), in_block
+
+def iter_significant(lines: List[str]) -> List[Tuple[int, str]]:
+    sig = []
+    in_block = False
+    for idx, raw in enumerate(lines):
+        text, in_block = strip_line_comments_and_blocks(raw, in_block)
+        s = text.strip()
+        if s:
+            sig.append((idx, s))
+    return sig
+
+# ---------- guard structure detection ----------
+RE_IFNDEF = re.compile(r'^#\s*ifndef\s+([A-Za-z_][A-Za-z0-9_]*)\s*$')
+def match_define(s: str, name: str) -> bool:
+    return re.match(rf'^#\s*define\s+{re.escape(name)}(\s+.*)?$', s) is not None
+
+def detect_guard_structure(lines: List[str]) -> Optional[Tuple[int, str, int, int]]:
+    """
+    Returns (ifndef_idx, name, define_idx, endif_idx) iff:
+    - first significant token is '#ifndef NAME'
+    - next significant token is '#define NAME'
+    - last significant token is '#endif'
+    """
+    sig = iter_significant(lines)
+    if not sig:
+        return None
+    m = RE_IFNDEF.match(sig[0][1])
+    if not m:
+        return None
+    name = m.group(1)
+    if len(sig) < 2 or not match_define(sig[1][1], name):
+        return None
+    if not sig[-1][1].startswith("#endif"):
+        return None
+    return sig[0][0], name, sig[1][0], sig[-1][0]
+
+# ---------- misc utils ----------
+def detect_eol(s: str) -> str:
+    if s.endswith("\r\n"): return "\r\n"
+    if s.endswith("\n"):   return "\n"
+    if s.endswith("\r"):   return "\r"
+    return ""
+
+def leading_ws(s: str) -> str:
+    m = re.match(r'^[ \t]*', s)
+    return m.group(0) if m else ""
+
+def _normalize_slashes(p: str) -> str:
+    return p.replace("\\", "/")
+
+def _is_path_within(child: str, parent: str) -> bool:
+    try:
+        child = os.path.realpath(child)
+        parent = os.path.realpath(parent)
+        return os.path.commonpath([child, parent]) == parent
+    except Exception:
+        return False
+
+# ---------- include handling ----------
+INCLUDE_RE = re.compile(r'^(\s*#\s*include\s*)([<"])([^>"]+)([>"])(.*?)(\r?\n|\r)?$')
+
+def _resolve_from(token: str, root: str) -> Optional[str]:
+    p = os.path.normpath(os.path.join(root, token))
+    return p if os.path.isfile(p) else None
+
+def _same_dir_exists(token: str, cur_dir: str) -> bool:
+    p = os.path.normpath(os.path.join(cur_dir, token))
+    return os.path.isfile(p) and (os.path.dirname(p) == os.path.normpath(cur_dir))
+
+def _detect_include_blocks(lines: List[str]) -> List[Tuple[int, int]]:
+    blocks: List[Tuple[int, int]] = []
+    in_block_comment = False
+    block_start: Optional[int] = None
+    last_include: Optional[int] = None
+
+    def is_blank_or_comment(i: int) -> bool:
+        nonlocal in_block_comment
+        visible, in_block_comment = strip_line_comments_and_blocks(lines[i], in_block_comment)
+        s = visible.strip()
+        return (s == "" or s.startswith("//"))
+
+    for i in range(len(lines)):
+        raw = lines[i]
+        visible, in_block_comment = strip_line_comments_and_blocks(raw, in_block_comment)
+        if in_block_comment:
+            continue
+
+        is_inc = INCLUDE_RE.match(raw) is not None
+        if is_inc:
+            if block_start is None:
+                block_start = i
+            last_include = i
+            continue
+
+        if block_start is not None:
+            if is_blank_or_comment(i):
+                continue
+            blocks.append((block_start + 1, last_include + 1))
+            block_start = None
+            last_include = None
+
+    if block_start is not None and last_include is not None:
+        blocks.append((block_start + 1, last_include + 1))
+
+    # merge adjacent
+    merged: List[Tuple[int, int]] = []
+    for s, e in blocks:
+        if not merged or s > merged[-1][1] + 1:
+            merged.append((s, e))
+        else:
+            merged[-1] = (merged[-1][0], max(merged[-1][1], e))
+    return merged
+
+def _clang_format_ranges_if_changed(path: str, ranges: List[Tuple[int, int]]) -> str:
+    """
+    Run clang-format once on multiple ranges, but only report 'changed'
+    if file content actually changed.
+    Returns: 'changed' | 'unchanged' | 'not-found' | 'error: ...' | 'no-op'
+    """
+    if not ranges:
+        return "no-op"
+    if CLANG_FORMAT_EXE is None:
+        return "not-found"
+
+    with open(path, "rb") as f:
+        before = f.read()
+
+    cmd = [CLANG_FORMAT_EXE, "-i", "-style", "file", "--sort-includes"]
+    for s, e in ranges:
+        cmd.append(f"-lines={s}:{e}")
+    cmd.append(path)
+
+    try:
+        subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    except subprocess.CalledProcessError as e:
+        return f"error: clang-format failed: {e}"
+
+    with open(path, "rb") as f:
+        after = f.read()
+
+    return "changed" if after != before else "unchanged"
+
+def _rewrite_includes(lines: List[str], path: str, include_root: str, is_header: bool) -> bool:
+    """
+    Normalize #include directives:
+
+      - Headers (.hpp):
+          * Any quoted include becomes angle brackets.
+          * If the header resolves under 'include_root' (either from the current
+            directory or directly under include_root), rewrite token to the path
+            relative to 'include_root':  #include <REL/FROM/INCLUDE_ROOT.hpp>
+            (POSIX slashes). Example: src/lib header "ConfigImpl.hpp" -> <lib/ConfigImpl.hpp>.
+          * Otherwise, just flip quotes to angles without touching the token.
+      - .cpp:
+          * Quoted -> angle brackets ONLY if target is NOT same-dir (exact FS check).
+          * Same-dir quoted includes are left as-is.
+          * Never modify the token content for .cpp.
+    """
+    changed = False
+    in_block = False
+    cur_dir = os.path.dirname(path)
+
+    for i, raw in enumerate(lines):
+        visible, in_block = strip_line_comments_and_blocks(raw, in_block)
+        if in_block:
+            continue
+        if visible.strip().startswith("//"):
+            continue
+
+        m = INCLUDE_RE.match(raw)
+        if not m:
+            continue
+
+        prefix, open_ch, token, close_ch, tail, eol = m.groups()
+        eol = eol or ""
+        token_stripped = token.strip()
+
+        if is_header:
+            # Try to resolve under include_root. Prefer resolution from cur_dir if it exists,
+            # but the final output is always include_root-relative.
+            target_abs = None
+            cur_abs = _resolve_from(token_stripped, cur_dir)
+            if cur_abs and _is_path_within(cur_abs, include_root):
+                target_abs = cur_abs
+            else:
+                root_abs = _resolve_from(token_stripped, include_root)
+                if root_abs and _is_path_within(root_abs, include_root):
+                    target_abs = root_abs
+
+            if target_abs and _is_path_within(target_abs, include_root):
+                rel_from_root = _normalize_slashes(os.path.relpath(target_abs, include_root))
+                new_line = f"{prefix}<{rel_from_root}>{tail}{eol}"
+            else:
+                # Could be system/external. Still convert quotes to angles per rule.
+                if open_ch == '"' and close_ch == '"':
+                    new_line = f"{prefix}<{token_stripped}>{tail}{eol}"
+                else:
+                    new_line = raw  # already angled; leave token as-is
+
+            if new_line != raw:
+                lines[i] = new_line
+                changed = True
+            continue
+
+        # .cpp policy
+        if _same_dir_exists(token_stripped, cur_dir):
+            continue  # keep same-dir quoted includes
+        if open_ch == '"' and close_ch == '"':
+            new_line = f"{prefix}<{token_stripped}>{tail}{eol}"
+            if new_line != raw:
+                lines[i] = new_line
+                changed = True
+
+    return changed
+
+# ---------- per-file transform ----------
+def process_file(path: str, guard_base: str, guard_prefix: str, include_root: str) -> str:
+    """
+    1) For .hpp: If canonical guard exists AND name differs, update; otherwise leave guard as-is.
+    2) For .hpp & .cpp: normalize includes per rules (using include_root).
+    3) clang-format: run once per file on all include blocks; only report if bytes changed.
+    """
+    ext = os.path.splitext(path)[1].lower()
+    is_header = (ext == ".hpp")
+
+    with open(path, "r", encoding="utf-8-sig", newline="") as f:
+        lines = f.readlines()
+    if not lines:
+        return "empty"
+
+    changed = False
+    guard_changed = False
+    guard_msg = None
+
+    # Optional guard canonicalization (headers only) — only if new name differs
+    if is_header:
+        structure = detect_guard_structure(lines)
+        if structure is not None:
+            ifndef_idx, old_name, define_idx, endif_idx = structure
+            new_name = make_guard(path, guard_base, guard_prefix)
+            if old_name != new_name:
+                eol = detect_eol(lines[ifndef_idx]); pre = leading_ws(lines[ifndef_idx])
+                new_ifndef = f"{pre}#ifndef {new_name}{eol}"
+                if lines[ifndef_idx] != new_ifndef:
+                    lines[ifndef_idx] = new_ifndef; changed = True; guard_changed = True
+
+                eol = detect_eol(lines[define_idx]); pre = leading_ws(lines[define_idx])
+                new_define = f"{pre}#define {new_name}{eol}"
+                if lines[define_idx] != new_define:
+                    lines[define_idx] = new_define; changed = True; guard_changed = True
+
+                eol = detect_eol(lines[endif_idx]); pre = leading_ws(lines[endif_idx])
+                new_endif = f"{pre}#endif // {new_name}{eol}"
+                if lines[endif_idx] != new_endif:
+                    lines[endif_idx] = new_endif; changed = True; guard_changed = True
+
+                if guard_changed:
+                    guard_msg = f"guard {old_name} -> {new_name}"
+
+    # Include normalization across whole file
+    inc_changed = _rewrite_includes(lines, path, include_root, is_header)
+    if inc_changed:
+        changed = True
+
+    # If buffer changed, write prior to clang-format
+    if changed:
+        with open(path, "w", encoding="utf-8", newline="") as f:
+            f.writelines(lines)
+
+    # clang-format once per file; only report if bytes changed
+    blocks = _detect_include_blocks(lines)
+    fmt_status = _clang_format_ranges_if_changed(path, blocks)
+    fmt_note = ""
+    fmt_changed = (fmt_status == "changed")
+    if fmt_status == "not-found":
+        fmt_note = " (clang-format not found)"
+    elif fmt_status.startswith("error"):
+        fmt_note = f" ({fmt_status})"
+
+    # Reload if clang-format changed the file
+    if fmt_changed:
+        with open(path, "r", encoding="utf-8-sig", newline="") as f:
+            lines = f.readlines()
+
+    # Status message
+    parts = []
+    if guard_changed and guard_msg:
+        parts.append(guard_msg)
+    if inc_changed:
+        parts.append("includes normalized")
+    if fmt_changed:
+        parts.append("include blocks clang-formatted")
+
+    if parts:
+        return "updated (" + "; ".join(parts) + ")" + fmt_note
+    return "ok" + fmt_note
+
+# ---------- walk requested trees ----------
+def main():
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    include_root_public = os.path.normpath(os.path.join(script_dir, "..", "include"))
+    include_root_src    = os.path.normpath(os.path.join(script_dir, "..", "src"))
+
+    targets = [
+        # (guard_base, guard_prefix, include_root)
+        (os.path.join(script_dir, "..", "include", "mrdocs"), "MRDOCS_API_",        include_root_public),
+        (os.path.join(script_dir, "..", "src", "lib"),        "MRDOCS_LIB_",        include_root_src),
+        (os.path.join(script_dir, "..", "src", "test"),       "MRDOCS_TEST_",       include_root_src),
+        (os.path.join(script_dir, "..", "src", "test_suite"), "MRDOCS_TEST_SUITE_", include_root_src),
+        (os.path.join(script_dir, "..", "src", "tool"),       "MRDOCS_TOOL_",       include_root_src),
+    ]
+
+    grand_total = grand_updated = grand_skipped = 0
+
+    for base, prefix, inc_root in targets:
+        if not os.path.isdir(base):
+            print(f"[skip dir] {base} (not found)")
+            continue
+
+        total = updated = skipped = 0
+        print(f"\n== Processing: {base}  (prefix: {prefix}; include_root: {inc_root}) ==")
+        for root, _, files in os.walk(base):
+            for fn in files:
+                ext = os.path.splitext(fn)[1].lower()
+                if ext not in PROCESS_EXTS:
+                    continue
+                total += 1
+                path = os.path.join(root, fn)
+                try:
+                    result = process_file(path, base, prefix, inc_root)
+                except Exception as e:
+                    result = f"skipped (error: {e})"
+                if result.startswith("updated"):
+                    updated += 1
+                elif result.startswith("skipped"):
+                    skipped += 1
+                print(f"{os.path.relpath(path, base)}: {result}")
+
+        grand_total += total
+        grand_updated += updated
+        grand_skipped += skipped
+        print(f"-- Dir summary: {total} files, {updated} updated, {skipped} skipped.")
+
+    print(f"\nAll done. {grand_total} files total, {grand_updated} updated, {grand_skipped} skipped.")
+
+if __name__ == "__main__":
+    main()

From 47464ad847ab871bbf4bd305afa717da5b407940 Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Wed, 24 Sep 2025 02:29:38 -0500
Subject: [PATCH 04/23] build: bootstrap enables libcxx hardening mode

---
 CMakeUserPresets.json.example | 12 +++++++-----
 bootstrap.py                  | 16 ++++++++++++++++
 2 files changed, 23 insertions(+), 5 deletions(-)

diff --git a/CMakeUserPresets.json.example b/CMakeUserPresets.json.example
index a555db542..e04454a03 100644
--- a/CMakeUserPresets.json.example
+++ b/CMakeUserPresets.json.example
@@ -133,7 +133,8 @@
                 "MRDOCS_BUILD_DOCS": false,
                 "MRDOCS_GENERATE_REFERENCE": false,
                 "MRDOCS_GENERATE_ANTORA_REFERENCE": false,
-                "CMAKE_MAKE_PROGRAM": "${sourceDir}/build/third-party/ninja/ninja"
+                "CMAKE_MAKE_PROGRAM": "${sourceDir}/build/third-party/ninja/ninja",
+                "CMAKE_CXX_FLAGS": "-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_EXTENSIVE"
             },
             "condition": {
                 "type": "equals",
@@ -163,7 +164,8 @@
                 "MRDOCS_BUILD_DOCS": false,
                 "MRDOCS_GENERATE_REFERENCE": false,
                 "MRDOCS_GENERATE_ANTORA_REFERENCE": false,
-                "CMAKE_MAKE_PROGRAM": "${sourceDir}/build/third-party/ninja/ninja"
+                "CMAKE_MAKE_PROGRAM": "${sourceDir}/build/third-party/ninja/ninja",
+                "CMAKE_CXX_FLAGS": "-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_EXTENSIVE"
             },
             "warnings": {
                 "unusedCli": false
@@ -360,9 +362,9 @@
                 "Clang_ROOT": "${sourceDir}/build/third-party/llvm-project/install/debug-clang-asan",
                 "duktape_ROOT": "${sourceDir}/build/third-party/duktape/install/debug-clang-asan",
                 "Duktape_ROOT": "${sourceDir}/build/third-party/duktape/install/debug-clang-asan",
-                "libxml2_ROOT": "",
-                "LibXml2_ROOT": "",
-                "MRDOCS_BUILD_TESTS": false,
+                "libxml2_ROOT": "${sourceDir}/build/third-party/libxml2/install/release-clang",
+                "LibXml2_ROOT": "${sourceDir}/build/third-party/libxml2/install/release-clang",
+                "MRDOCS_BUILD_TESTS": true,
                 "MRDOCS_BUILD_DOCS": false,
                 "MRDOCS_GENERATE_REFERENCE": false,
                 "MRDOCS_GENERATE_ANTORA_REFERENCE": false,
diff --git a/bootstrap.py b/bootstrap.py
index 7a5f8c5bd..face0b58f 100644
--- a/bootstrap.py
+++ b/bootstrap.py
@@ -1412,6 +1412,22 @@ def create_cmake_presets(self):
         if cxx_flags:
             new_preset["cacheVariables"]['CMAKE_CXX_FLAGS'] = cxx_flags.strip()
 
+        # if build type is debug and compiler is clang (default macos or explicitly clang),
+        # add "CMAKE_CXX_FLAGS": "-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_EXTENSIVE"
+        # or append it to existing CMAKE_CXX_FLAGS
+        if self.options.mrdocs_build_type.lower() == "debug":
+            is_clang = False
+            if self.options.cxx and "clang" in os.path.basename(self.options.cxx).lower():
+                is_clang = True
+            elif "CMAKE_CXX_COMPILER_ID" in self.compiler_info and self.compiler_info["CMAKE_CXX_COMPILER_ID"].lower() == "clang":
+                is_clang = True
+            if is_clang:
+                hardening_flag = "-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_EXTENSIVE"
+                if "CMAKE_CXX_FLAGS" in new_preset["cacheVariables"]:
+                    new_preset["cacheVariables"]["CMAKE_CXX_FLAGS"] += " " + hardening_flag
+                else:
+                    new_preset["cacheVariables"]["CMAKE_CXX_FLAGS"] = hardening_flag
+
         if self.is_windows():
             if self.options.python_path:
                 new_preset["cacheVariables"]["PYTHON_EXECUTABLE"] = self.options.python_path

From e926ee90e03af557195904eaf5356055f7d49e19 Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Wed, 24 Sep 2025 17:53:51 -0500
Subject: [PATCH 05/23] refactor: split base and derived classes

Split base and derived classes into their own headers to remove circular dependencies in the code.
---
 CMakeLists.txt                                |    4 +-
 docs/modules/ROOT/pages/contribute.adoc       |   11 +
 include/mrdocs/ADT/Nullable.hpp               |    9 +-
 include/mrdocs/ADT/Polymorphic.hpp            |   39 +-
 include/mrdocs/ADT/UnorderedStringMap.hpp     |    4 +-
 include/mrdocs/Config.hpp                     |    4 +-
 .../mrdocs/Config/ReferenceDirectories.hpp    |    6 +-
 include/mrdocs/Corpus.hpp                     |    4 +-
 include/mrdocs/Dom.hpp                        |    2 +-
 include/mrdocs/Dom/LazyArray.hpp              |    8 +-
 include/mrdocs/Dom/LazyObject.hpp             |    6 +-
 include/mrdocs/Dom/String.hpp                 |    2 +-
 include/mrdocs/Dom/Value.hpp                  |    8 +-
 include/mrdocs/Generator.hpp                  |    2 +-
 include/mrdocs/Generators.hpp                 |    4 +-
 include/mrdocs/Metadata.hpp                   |   12 +-
 include/mrdocs/Metadata/DomCorpus.hpp         |    6 +-
 include/mrdocs/Metadata/Info.hpp              |  296 +--
 include/mrdocs/Metadata/Info/Concept.hpp      |   13 +-
 include/mrdocs/Metadata/Info/Enum.hpp         |   13 +-
 include/mrdocs/Metadata/Info/EnumConstant.hpp |    8 +-
 .../Metadata/{ => Info}/ExtractionMode.hpp    |    6 +-
 include/mrdocs/Metadata/Info/Friend.hpp       |   10 +-
 include/mrdocs/Metadata/Info/Function.hpp     |  151 +-
 .../mrdocs/Metadata/Info/FunctionClass.hpp    |   53 +
 include/mrdocs/Metadata/Info/Guide.hpp        |   14 +-
 include/mrdocs/Metadata/Info/InfoBase.hpp     |  277 +++
 include/mrdocs/Metadata/Info/InfoKind.hpp     |   60 +
 include/mrdocs/Metadata/Info/Namespace.hpp    |   10 +-
 .../mrdocs/Metadata/Info/NamespaceAlias.hpp   |   10 +-
 include/mrdocs/Metadata/Info/Overloads.hpp    |    8 +-
 include/mrdocs/Metadata/Info/Param.hpp        |   74 +
 include/mrdocs/Metadata/Info/Record.hpp       |  270 +--
 include/mrdocs/Metadata/Info/RecordBase.hpp   |   52 +
 .../mrdocs/Metadata/Info/RecordInterface.hpp  |  121 ++
 .../mrdocs/Metadata/Info/RecordKeyKind.hpp    |   49 +
 .../mrdocs/Metadata/Info/RecordTranche.hpp    |  121 ++
 include/mrdocs/Metadata/{ => Info}/Source.hpp |    6 +-
 .../mrdocs/Metadata/{ => Info}/SymbolID.hpp   |   12 +-
 include/mrdocs/Metadata/Info/Typedef.hpp      |   12 +-
 include/mrdocs/Metadata/Info/Using.hpp        |   14 +-
 include/mrdocs/Metadata/Info/Variable.hpp     |   16 +-
 include/mrdocs/Metadata/Javadoc.hpp           | 1855 +----------------
 include/mrdocs/Metadata/Javadoc/Block.hpp     |  136 ++
 .../Metadata/Javadoc/Block/Admonish.hpp       |   59 +
 .../Metadata/Javadoc/Block/Admonition.hpp     |   89 +
 .../Metadata/Javadoc/Block/BlockBase.hpp      |  146 ++
 .../mrdocs/Metadata/Javadoc/Block/Brief.hpp   |   98 +
 .../mrdocs/Metadata/Javadoc/Block/Code.hpp    |   80 +
 .../mrdocs/Metadata/Javadoc/Block/Heading.hpp |   80 +
 .../Metadata/Javadoc/Block/ListItem.hpp       |   88 +
 .../Metadata/Javadoc/Block/Paragraph.hpp      |   85 +
 .../mrdocs/Metadata/Javadoc/Block/Param.hpp   |  116 ++
 .../Metadata/Javadoc/Block/ParamDirection.hpp |   55 +
 .../Metadata/Javadoc/Block/Postcondition.hpp  |   85 +
 .../Metadata/Javadoc/Block/Precondition.hpp   |   85 +
 .../mrdocs/Metadata/Javadoc/Block/Returns.hpp |  100 +
 include/mrdocs/Metadata/Javadoc/Block/See.hpp |   81 +
 .../mrdocs/Metadata/Javadoc/Block/TParam.hpp  |   81 +
 .../mrdocs/Metadata/Javadoc/Block/Throws.hpp  |   88 +
 .../Metadata/Javadoc/Block/UnorderedList.hpp  |  112 +
 include/mrdocs/Metadata/Javadoc/Node.hpp      |  160 ++
 .../mrdocs/Metadata/Javadoc/Node/NodeBase.hpp |   93 +
 .../mrdocs/Metadata/Javadoc/Node/NodeKind.hpp |  132 ++
 include/mrdocs/Metadata/Javadoc/Text.hpp      |  122 ++
 .../Metadata/Javadoc/Text/CopyDetails.hpp     |   80 +
 include/mrdocs/Metadata/Javadoc/Text/Link.hpp |   82 +
 .../mrdocs/Metadata/Javadoc/Text/Parts.hpp    |   57 +
 .../Metadata/Javadoc/Text/Reference.hpp       |   89 +
 .../mrdocs/Metadata/Javadoc/Text/Style.hpp    |   58 +
 .../mrdocs/Metadata/Javadoc/Text/Styled.hpp   |   82 +
 .../mrdocs/Metadata/Javadoc/Text/TextBase.hpp |  100 +
 include/mrdocs/Metadata/Name.hpp              |  158 +-
 .../Metadata/Name/IdentifierNameInfo.hpp      |   48 +
 include/mrdocs/Metadata/Name/NameBase.hpp     |  105 +
 include/mrdocs/Metadata/Name/NameKind.hpp     |   43 +
 .../Metadata/Name/SpecializationNameInfo.hpp  |   53 +
 include/mrdocs/Metadata/Specifiers.hpp        |  393 +---
 .../mrdocs/Metadata/Specifiers/AccessKind.hpp |   62 +
 .../Metadata/Specifiers/ConstexprKind.hpp     |   54 +
 .../Metadata/Specifiers/ExplicitInfo.hpp      |   75 +
 .../Metadata/Specifiers/ExplicitKind.hpp      |   42 +
 .../Metadata/Specifiers/NoexceptInfo.hpp      |   74 +
 .../Metadata/Specifiers/NoexceptKind.hpp      |   42 +
 .../Metadata/Specifiers/OperatorKind.hpp      |  206 ++
 .../Metadata/Specifiers/ReferenceKind.hpp     |   49 +
 .../Metadata/Specifiers/StorageClassKind.hpp  |   61 +
 include/mrdocs/Metadata/TArg.hpp              |   77 +
 include/mrdocs/Metadata/TArg/NonTypeTArg.hpp  |   34 +
 include/mrdocs/Metadata/TArg/TArgBase.hpp     |   78 +
 include/mrdocs/Metadata/TArg/TArgKind.hpp     |   51 +
 include/mrdocs/Metadata/TArg/TemplateTArg.hpp |   38 +
 include/mrdocs/Metadata/TArg/TypeTArg.hpp     |   34 +
 include/mrdocs/Metadata/TParam.hpp            |   85 +
 .../mrdocs/Metadata/TParam/NonTypeTParam.hpp  |   36 +
 include/mrdocs/Metadata/TParam/TParamBase.hpp |   86 +
 .../mrdocs/Metadata/TParam/TParamKeyKind.hpp  |   48 +
 include/mrdocs/Metadata/TParam/TParamKind.hpp |   36 +
 .../mrdocs/Metadata/TParam/TemplateTParam.hpp |   36 +
 include/mrdocs/Metadata/TParam/TypeTParam.hpp |   40 +
 include/mrdocs/Metadata/Template.hpp          |  359 +---
 include/mrdocs/Metadata/Type.hpp              |  548 +----
 .../mrdocs/Metadata/Type/ArrayTypeInfo.hpp    |   33 +
 include/mrdocs/Metadata/Type/AutoKind.hpp     |   47 +
 include/mrdocs/Metadata/Type/AutoTypeInfo.hpp |   34 +
 .../mrdocs/Metadata/Type/DecltypeTypeInfo.hpp |   29 +
 .../mrdocs/Metadata/Type/FunctionTypeInfo.hpp |   37 +
 .../Metadata/Type/FundamentalTypeKind.hpp     |  196 ++
 .../Metadata/Type/LValueReferenceTypeInfo.hpp |   32 +
 .../Metadata/Type/MemberPointerTypeInfo.hpp   |   33 +
 .../mrdocs/Metadata/Type/NamedTypeInfo.hpp    |   38 +
 .../mrdocs/Metadata/Type/PointerTypeInfo.hpp  |   31 +
 .../mrdocs/Metadata/Type/QualifierKind.hpp    |   55 +
 .../Metadata/Type/RValueReferenceTypeInfo.hpp |   31 +
 include/mrdocs/Metadata/Type/TypeBase.hpp     |  125 ++
 include/mrdocs/Metadata/Type/TypeKind.hpp     |   57 +
 include/mrdocs/Platform.hpp                   |    2 +-
 include/mrdocs/Support/Algorithm.hpp          |    2 +-
 include/mrdocs/Support/Error.hpp              |    4 +-
 include/mrdocs/Support/ExecutorGroup.hpp      |    2 +-
 include/mrdocs/Support/Expected.hpp           |    6 +-
 include/mrdocs/Support/Glob.hpp               |    6 +-
 include/mrdocs/Support/Handlebars.hpp         |   10 +-
 include/mrdocs/Support/JavaScript.hpp         |    2 +-
 include/mrdocs/Support/Lua.hpp                |   12 +-
 include/mrdocs/Support/Report.hpp             |    6 +-
 include/mrdocs/Support/ThreadPool.hpp         |    8 +-
 include/mrdocs/Support/TypeTraits.hpp         |    6 +-
 include/mrdocs/Support/Visitor.hpp            |    8 +-
 include/mrdocs/Support/source_location.hpp    |    4 +-
 src/lib/AST/ASTAction.cpp                     |    8 +-
 src/lib/AST/ASTAction.hpp                     |   11 +-
 src/lib/AST/ASTVisitor.cpp                    |  101 +-
 src/lib/AST/ASTVisitor.hpp                    |   14 +-
 src/lib/AST/ASTVisitorConsumer.cpp            |    6 +-
 src/lib/AST/ASTVisitorConsumer.hpp            |    8 +-
 src/lib/AST/ClangHelpers.cpp                  |    4 +-
 src/lib/AST/ClangHelpers.hpp                  |   17 +-
 src/lib/AST/FrontendActionFactory.cpp         |    2 +-
 src/lib/AST/FrontendActionFactory.hpp         |    8 +-
 src/lib/AST/MissingSymbolSink.hpp             |   24 +-
 src/lib/AST/MrDocsFileSystem.hpp              |   20 +-
 src/lib/AST/NameInfoBuilder.cpp               |   30 +-
 src/lib/AST/NameInfoBuilder.hpp               |   13 +-
 src/lib/AST/ParseJavadoc.cpp                  |   19 +-
 src/lib/AST/ParseJavadoc.hpp                  |    4 +-
 src/lib/AST/ParseRef.cpp                      |  102 +-
 src/lib/AST/ParseRef.hpp                      |   10 +-
 src/lib/AST/TypeInfoBuilder.cpp               |   74 +-
 src/lib/AST/TypeInfoBuilder.hpp               |   14 +-
 src/lib/ConfigImpl.cpp                        |    6 +-
 src/lib/ConfigImpl.hpp                        |    4 +-
 src/lib/Corpus.cpp                            |    2 +-
 src/lib/CorpusImpl.cpp                        |   62 +-
 src/lib/CorpusImpl.hpp                        |   18 +-
 src/lib/Diagnostics.hpp                       |   10 +-
 src/lib/Dom/Object.cpp                        |    4 +-
 src/lib/Dom/String.cpp                        |    2 +-
 src/lib/Dom/Value.cpp                         |    2 +-
 src/lib/Gen/adoc/AdocGenerator.hpp            |    2 +-
 src/lib/Gen/hbs/Builder.cpp                   |    6 +-
 src/lib/Gen/hbs/Builder.hpp                   |    6 +-
 src/lib/Gen/hbs/HandlebarsCorpus.cpp          |    4 +-
 src/lib/Gen/hbs/HandlebarsCorpus.hpp          |    6 +-
 src/lib/Gen/hbs/HandlebarsGenerator.cpp       |   12 +-
 src/lib/Gen/hbs/HandlebarsGenerator.hpp       |    2 +-
 src/lib/Gen/hbs/MultiPageVisitor.cpp          |    2 +-
 src/lib/Gen/hbs/MultiPageVisitor.hpp          |    6 +-
 src/lib/Gen/hbs/SinglePageVisitor.hpp         |    2 +-
 src/lib/Gen/hbs/TagfileWriter.cpp             |   28 +-
 src/lib/Gen/hbs/TagfileWriter.hpp             |   11 +-
 src/lib/Gen/hbs/VisitorHelpers.cpp            |   13 +-
 src/lib/Gen/hbs/VisitorHelpers.hpp            |    3 +-
 src/lib/Gen/html/HTMLGenerator.hpp            |    2 +-
 src/lib/Gen/xml/CXXTags.cpp                   |    2 +-
 src/lib/Gen/xml/CXXTags.hpp                   |  160 +-
 src/lib/Gen/xml/XMLGenerator.cpp              |    6 +-
 src/lib/Gen/xml/XMLTags.cpp                   |    2 +-
 src/lib/Gen/xml/XMLTags.hpp                   |   12 +-
 src/lib/Gen/xml/XMLWriter.cpp                 |   37 +-
 src/lib/Gen/xml/XMLWriter.hpp                 |    6 +-
 src/lib/Metadata/DomCorpus.cpp                |   10 +-
 .../Finalizers/BaseMembersFinalizer.cpp       |    4 +-
 .../Finalizers/BaseMembersFinalizer.hpp       |   10 +-
 .../Metadata/Finalizers/DerivedFinalizer.cpp  |    9 +-
 .../Metadata/Finalizers/DerivedFinalizer.hpp  |   10 +-
 .../Metadata/Finalizers/Javadoc/Function.hpp  |   98 +-
 .../Metadata/Finalizers/Javadoc/Overloads.hpp |   12 +-
 .../Metadata/Finalizers/JavadocFinalizer.cpp  |   96 +-
 .../Metadata/Finalizers/JavadocFinalizer.hpp  |   33 +-
 .../Finalizers/NamespacesFinalizer.hpp        |   10 +-
 .../Finalizers/OverloadsFinalizer.cpp         |    7 +-
 .../Finalizers/OverloadsFinalizer.hpp         |   10 +-
 .../Finalizers/SortMembersFinalizer.cpp       |   16 +-
 .../Finalizers/SortMembersFinalizer.hpp       |   10 +-
 src/lib/Metadata/Info.cpp                     |   10 +-
 src/lib/Metadata/Info/Concept.cpp             |    2 +-
 src/lib/Metadata/Info/Enum.cpp                |    2 +-
 src/lib/Metadata/Info/EnumConstant.cpp        |    2 +-
 src/lib/Metadata/Info/Friend.cpp              |    2 +-
 src/lib/Metadata/Info/Function.cpp            |    2 +-
 src/lib/Metadata/Info/Guide.cpp               |   14 +-
 src/lib/Metadata/Info/Namespace.cpp           |    2 +-
 src/lib/Metadata/Info/NamespaceAlias.cpp      |    2 +-
 src/lib/Metadata/Info/Overloads.cpp           |    8 +-
 src/lib/Metadata/Info/Record.cpp              |    7 +-
 src/lib/Metadata/Info/Typedef.cpp             |    4 +-
 src/lib/Metadata/Info/Using.cpp               |    5 +-
 src/lib/Metadata/Info/Variable.cpp            |    2 +-
 src/lib/Metadata/InfoSet.hpp                  |   10 +-
 src/lib/Metadata/Javadoc.cpp                  |   20 +-
 src/lib/Metadata/Name.cpp                     |   45 +-
 src/lib/Metadata/Source.cpp                   |    4 +-
 src/lib/Metadata/Specifiers.cpp               |    4 +-
 src/lib/Metadata/SymbolID.cpp                 |    6 +-
 src/lib/Metadata/Template.cpp                 |   29 +-
 src/lib/Metadata/Type.cpp                     |   37 +-
 src/lib/MrDocsCompilationDatabase.cpp         |   12 +-
 src/lib/MrDocsCompilationDatabase.hpp         |    6 +-
 src/lib/MrDocsSettingsDB.hpp                  |    2 +-
 src/lib/Support/Assert.cpp                    |    4 +-
 src/lib/Support/CMakeExecution.cpp            |    3 +-
 src/lib/Support/CMakeExecution.hpp            |    6 +-
 src/lib/Support/Debug.cpp                     |   10 +-
 src/lib/Support/Debug.hpp                     |   12 +-
 src/lib/Support/ExecuteAndWaitWithLogging.cpp |    4 +-
 src/lib/Support/ExecuteAndWaitWithLogging.hpp |    6 +-
 src/lib/Support/ExecutionContext.cpp          |    4 +-
 src/lib/Support/ExecutionContext.hpp          |   12 +-
 src/lib/Support/Generator.cpp                 |    8 +-
 src/lib/Support/GeneratorsImpl.hpp            |    2 +-
 src/lib/Support/Glob.cpp                      |    6 +-
 src/lib/Support/Handlebars.cpp                |    4 +-
 src/lib/Support/JavaScript.cpp                |    8 +-
 src/lib/Support/LegibleNames.cpp              |   12 +-
 src/lib/Support/LegibleNames.hpp              |    2 +-
 src/lib/Support/Lua.cpp                       |    9 +-
 src/lib/Support/LuaHandlebars.hpp             |    6 +-
 src/lib/Support/Radix.cpp                     |    4 +-
 src/lib/Support/Report.cpp                    |   18 +-
 src/lib/Support/Report.hpp                    |   12 +-
 src/lib/Support/Yaml.cpp                      |    4 +-
 src/lib/lua.cpp                               |   68 +-
 src/test/ADT/Optional.cpp                     |    2 +-
 src/test/ADT/Polymorphic.cpp                  |  142 +-
 src/test/Support/JavaScript.cpp               |    4 +-
 src/test/TestArgs.hpp                         |    2 +-
 src/test/TestMain.cpp                         |   12 +-
 src/test/TestRunner.cpp                       |   22 +-
 src/test/TestRunner.hpp                       |    4 +-
 src/test/lib/AST/ParseRef.cpp                 |    2 +-
 src/test/lib/Dom/Dom.cpp                      |    2 +-
 src/test/lib/Support/Handlebars.cpp           |   10 +-
 src/test/lib/Support/Path.cpp                 |    2 +-
 src/test_suite/detail/decomposer.cpp          |    2 +-
 src/test_suite/detail/decomposer.hpp          |    6 +-
 src/test_suite/diff.hpp                       |    6 +-
 src/test_suite/test_suite.cpp                 |    1 -
 src/test_suite/test_suite.hpp                 |    8 +-
 src/tool/CompilerInfo.cpp                     |    3 +-
 src/tool/CompilerInfo.hpp                     |   13 +-
 src/tool/GenerateAction.cpp                   |   10 +-
 src/tool/ToolArgs.cpp                         |    4 +-
 src/tool/ToolArgs.hpp                         |    4 +-
 src/tool/ToolCompilationDatabase.cpp          |    6 +-
 src/tool/ToolCompilationDatabase.hpp          |   10 +-
 src/tool/ToolMain.cpp                         |    6 +-
 .../symbols/concept/requires-clause.cpp       |    6 +-
 .../symbols/concept/requires-clause.xml       |    6 +-
 269 files changed, 7391 insertions(+), 4919 deletions(-)
 rename include/mrdocs/Metadata/{ => Info}/ExtractionMode.hpp (95%)
 create mode 100644 include/mrdocs/Metadata/Info/FunctionClass.hpp
 create mode 100644 include/mrdocs/Metadata/Info/InfoBase.hpp
 create mode 100644 include/mrdocs/Metadata/Info/InfoKind.hpp
 create mode 100644 include/mrdocs/Metadata/Info/Param.hpp
 create mode 100644 include/mrdocs/Metadata/Info/RecordBase.hpp
 create mode 100644 include/mrdocs/Metadata/Info/RecordInterface.hpp
 create mode 100644 include/mrdocs/Metadata/Info/RecordKeyKind.hpp
 create mode 100644 include/mrdocs/Metadata/Info/RecordTranche.hpp
 rename include/mrdocs/Metadata/{ => Info}/Source.hpp (97%)
 rename include/mrdocs/Metadata/{ => Info}/SymbolID.hpp (97%)
 create mode 100644 include/mrdocs/Metadata/Javadoc/Block.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Block/Admonish.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Block/Admonition.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Block/BlockBase.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Block/Brief.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Block/Code.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Block/Heading.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Block/ListItem.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Block/Paragraph.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Block/Param.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Block/ParamDirection.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Block/Postcondition.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Block/Precondition.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Block/Returns.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Block/See.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Block/TParam.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Block/Throws.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Block/UnorderedList.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Node.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Node/NodeBase.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Node/NodeKind.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Text.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Text/CopyDetails.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Text/Link.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Text/Parts.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Text/Reference.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Text/Style.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Text/Styled.hpp
 create mode 100644 include/mrdocs/Metadata/Javadoc/Text/TextBase.hpp
 create mode 100644 include/mrdocs/Metadata/Name/IdentifierNameInfo.hpp
 create mode 100644 include/mrdocs/Metadata/Name/NameBase.hpp
 create mode 100644 include/mrdocs/Metadata/Name/NameKind.hpp
 create mode 100644 include/mrdocs/Metadata/Name/SpecializationNameInfo.hpp
 create mode 100644 include/mrdocs/Metadata/Specifiers/AccessKind.hpp
 create mode 100644 include/mrdocs/Metadata/Specifiers/ConstexprKind.hpp
 create mode 100644 include/mrdocs/Metadata/Specifiers/ExplicitInfo.hpp
 create mode 100644 include/mrdocs/Metadata/Specifiers/ExplicitKind.hpp
 create mode 100644 include/mrdocs/Metadata/Specifiers/NoexceptInfo.hpp
 create mode 100644 include/mrdocs/Metadata/Specifiers/NoexceptKind.hpp
 create mode 100644 include/mrdocs/Metadata/Specifiers/OperatorKind.hpp
 create mode 100644 include/mrdocs/Metadata/Specifiers/ReferenceKind.hpp
 create mode 100644 include/mrdocs/Metadata/Specifiers/StorageClassKind.hpp
 create mode 100644 include/mrdocs/Metadata/TArg.hpp
 create mode 100644 include/mrdocs/Metadata/TArg/NonTypeTArg.hpp
 create mode 100644 include/mrdocs/Metadata/TArg/TArgBase.hpp
 create mode 100644 include/mrdocs/Metadata/TArg/TArgKind.hpp
 create mode 100644 include/mrdocs/Metadata/TArg/TemplateTArg.hpp
 create mode 100644 include/mrdocs/Metadata/TArg/TypeTArg.hpp
 create mode 100644 include/mrdocs/Metadata/TParam.hpp
 create mode 100644 include/mrdocs/Metadata/TParam/NonTypeTParam.hpp
 create mode 100644 include/mrdocs/Metadata/TParam/TParamBase.hpp
 create mode 100644 include/mrdocs/Metadata/TParam/TParamKeyKind.hpp
 create mode 100644 include/mrdocs/Metadata/TParam/TParamKind.hpp
 create mode 100644 include/mrdocs/Metadata/TParam/TemplateTParam.hpp
 create mode 100644 include/mrdocs/Metadata/TParam/TypeTParam.hpp
 create mode 100644 include/mrdocs/Metadata/Type/ArrayTypeInfo.hpp
 create mode 100644 include/mrdocs/Metadata/Type/AutoKind.hpp
 create mode 100644 include/mrdocs/Metadata/Type/AutoTypeInfo.hpp
 create mode 100644 include/mrdocs/Metadata/Type/DecltypeTypeInfo.hpp
 create mode 100644 include/mrdocs/Metadata/Type/FunctionTypeInfo.hpp
 create mode 100644 include/mrdocs/Metadata/Type/FundamentalTypeKind.hpp
 create mode 100644 include/mrdocs/Metadata/Type/LValueReferenceTypeInfo.hpp
 create mode 100644 include/mrdocs/Metadata/Type/MemberPointerTypeInfo.hpp
 create mode 100644 include/mrdocs/Metadata/Type/NamedTypeInfo.hpp
 create mode 100644 include/mrdocs/Metadata/Type/PointerTypeInfo.hpp
 create mode 100644 include/mrdocs/Metadata/Type/QualifierKind.hpp
 create mode 100644 include/mrdocs/Metadata/Type/RValueReferenceTypeInfo.hpp
 create mode 100644 include/mrdocs/Metadata/Type/TypeBase.hpp
 create mode 100644 include/mrdocs/Metadata/Type/TypeKind.hpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9631325e8..9d2537463 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -321,7 +321,9 @@ target_include_directories(mrdocs-core
     "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
     PRIVATE
     "${PROJECT_SOURCE_DIR}/src"
-    "${PROJECT_BINARY_DIR}/src")
+    "${PROJECT_BINARY_DIR}/src"
+    "${PROJECT_SOURCE_DIR}/third-party/lua/src"
+)
 target_compile_definitions(
     mrdocs-core
     PUBLIC
diff --git a/docs/modules/ROOT/pages/contribute.adoc b/docs/modules/ROOT/pages/contribute.adoc
index 364844d64..b9eba5be6 100644
--- a/docs/modules/ROOT/pages/contribute.adoc
+++ b/docs/modules/ROOT/pages/contribute.adoc
@@ -46,6 +46,15 @@ Thus, after the command line and configuration file options are parsed, they are
 
 As a last step, `DoGenerateAction` converts the public `Config` settings into a `ConfigImpl` object, which is used by the rest of the program with the parsed options.
 
+[#representing_symbols]
+== Representing Symbols
+
+MrDocs has many categories of objects, where we utilize polymorphism with a fixed set of valid derived types, including Symbols (functions, classes, and enums), Javadoc blocks, template parameters, template arguments, and data types. For each such family, we follow a consistent file layout. Most of these families are defined in the `mrdocs/Metadata` directory.
+
+Each base class is defined in its own header and, when necessary, implementation file. Each derived class also has its own header and implementation file. Finally, there is a single aggregator header file that includes all the derived headers. This file centralizes logic that requires knowledge of the full set of variants, such as visitors, comparison operators, and other operations that depend on the discriminator.
+
+This pattern keeps the individual derived types self-contained while making cross-variant operations explicit and localized. When adding a new derived type, contributors should create its header and source file alongside the existing ones and update the corresponding aggregator file to register the new variant. This keeps the codebase predictable, avoids scattering logic, and ensures that operations over polymorphic families remain easy to find and maintain.
+
 [#extract_symbols]
 === Extracting Symbols
 
@@ -201,6 +210,8 @@ This directory contains build scripts and configuration files for third-party li
 ** `third-party/duktape/`—CMake scripts for Duktape
 ** `third-party/lua/`—A bundled Lua interpreter
 
+== Polymorphism
+
 == Coding Standards
 
 === Paths
diff --git a/include/mrdocs/ADT/Nullable.hpp b/include/mrdocs/ADT/Nullable.hpp
index bca755b80..bd5038402 100644
--- a/include/mrdocs/ADT/Nullable.hpp
+++ b/include/mrdocs/ADT/Nullable.hpp
@@ -13,12 +13,11 @@
 #define MRDOCS_API_ADT_NULLABLE_HPP
 
 #include <mrdocs/Platform.hpp>
-
+#include <cmath>
+#include <concepts>
+#include <memory>
 #include <type_traits>
 #include <utility>
-#include <memory>
-#include <concepts>
-#include <cmath>
 
 namespace clang::mrdocs {
 
@@ -315,4 +314,4 @@ null_of() noexcept(noexcept(nullable_traits<T>::null()))
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_ADT_NULLABLE_HPP
diff --git a/include/mrdocs/ADT/Polymorphic.hpp b/include/mrdocs/ADT/Polymorphic.hpp
index 9273c1e1f..ee5d33a8c 100644
--- a/include/mrdocs/ADT/Polymorphic.hpp
+++ b/include/mrdocs/ADT/Polymorphic.hpp
@@ -12,9 +12,9 @@
 #ifndef MRDOCS_API_ADT_POLYMORPHIC_HPP
 #define MRDOCS_API_ADT_POLYMORPHIC_HPP
 
-#include <concepts>
-#include <mrdocs/Support/Assert.hpp>
 #include <mrdocs/ADT/Nullable.hpp>
+#include <mrdocs/Support/Assert.hpp>
+#include <concepts>
 #include <utility>
 
 namespace clang::mrdocs {
@@ -26,9 +26,7 @@ namespace clang::mrdocs {
 
     It implements a tweaked version of std::polymorphic, based on the
     reference implementation for P3019R14. Differences are:
-    * It supports nullability, which was originally supported in P3019 through
-      std::optional specializations, but was later removed from the paper.
-    * It implements comparison operators with a very project specific design.
+    * It implements comparison operators with a very project-specific design.
     * Fixed allocator, not parametrizable.
     * No initializer_list constructor.
 
@@ -37,13 +35,14 @@ namespace clang::mrdocs {
     To copy polymorphic objects, the class uses the
     copy constructor of the owned derived-type
     object when copying to another value.
-    Similarly, to allow correct destruction of
+    Similarly, to allow the correct destruction of
     derived objects, it uses the destructor of
     the owned derived-type object in the
     destructor.
 */
 template <class T>
 class Polymorphic {
+    // Base class for type-erasure.
     struct WrapperBase {
         virtual constexpr ~WrapperBase() = default;
         virtual T& getValue() = 0;
@@ -61,7 +60,8 @@ class Polymorphic {
         constexpr WrapperBase* clone() override { return new Wrapper(Value); }
     };
 
-    WrapperBase* WB; // nullptr only when constructed/reset by nullable_traits
+    // nullptr only when constructed/reset by nullable_traits
+    WrapperBase* WB = nullptr;
 
     // Private null token and constructor: only the friend traits can call this.
     struct _null_t { explicit constexpr _null_t(int) {} };
@@ -70,15 +70,15 @@ class Polymorphic {
     // Allow the traits specialization to access private members/ctors.
     friend struct nullable_traits<Polymorphic<T>>;
 
-// std::polymorphic has a default constructor that
-// default-constructs the base type T if it's default-constructible.
-// We disable this constructor because this is always an error
-// in MrDocs.
-//    constexpr explicit Polymorphic()
-//    requires std::is_default_constructible_v<T>
-//             && std::is_copy_constructible_v<T>
-//        : WB(new Wrapper<T>())
-//    {}
+    // std::polymorphic has a default constructor that
+    // default-constructs the base type T if it's default-constructible.
+    // We disable this constructor because this is always an error
+    // in MrDocs.
+    // constexpr explicit Polymorphic()
+    // requires std::is_default_constructible_v<T>
+    //          && std::is_copy_constructible_v<T>
+    //     : WB(new Wrapper<T>())
+    // {}
 
 public:
     using value_type = T;
@@ -96,7 +96,10 @@ class Polymorphic {
                  std::derived_from<std::remove_cvref_t<U>, T>
         : WB(new Wrapper<std::remove_cvref_t<U>>(std::forward<U>(u))) {}
 
-    /** In-place constructor for a specific derived U. */
+    /** In-place constructor for a specific derived U.
+
+        @param ts Arguments to forward to U's constructor.
+     */
     template <class U, class... Ts>
     explicit constexpr Polymorphic(std::in_place_type_t<U>, Ts&&... ts)
         requires std::same_as<std::remove_cvref_t<U>, U> &&
@@ -288,4 +291,4 @@ struct nullable_traits<Polymorphic<T>>
 
 } // namespace clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_ADT_POLYMORPHIC_HPP
diff --git a/include/mrdocs/ADT/UnorderedStringMap.hpp b/include/mrdocs/ADT/UnorderedStringMap.hpp
index 71c086c59..557af2950 100644
--- a/include/mrdocs/ADT/UnorderedStringMap.hpp
+++ b/include/mrdocs/ADT/UnorderedStringMap.hpp
@@ -12,8 +12,8 @@
 #ifndef MRDOCS_API_ADT_UNORDEREDSTRINGMAP_HPP
 #define MRDOCS_API_ADT_UNORDEREDSTRINGMAP_HPP
 
-#include <unordered_map>
 #include <string>
+#include <unordered_map>
 
 namespace clang::mrdocs {
 
@@ -34,4 +34,4 @@ using UnorderedStringMultiMap = std::unordered_multimap<std::string, T, StringHa
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_ADT_UNORDEREDSTRINGMAP_HPP
diff --git a/include/mrdocs/Config.hpp b/include/mrdocs/Config.hpp
index 5fdeb915f..636acb24f 100644
--- a/include/mrdocs/Config.hpp
+++ b/include/mrdocs/Config.hpp
@@ -13,9 +13,9 @@
 #define MRDOCS_API_CONFIG_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Support/Error.hpp>
 #include <mrdocs/Dom/Object.hpp>
 #include <mrdocs/PublicSettings.hpp>
+#include <mrdocs/Support/Error.hpp>
 #include <functional>
 #include <memory>
 #include <string>
@@ -225,4 +225,4 @@ class MRDOCS_DECL
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_API_CONFIG_HPP
diff --git a/include/mrdocs/Config/ReferenceDirectories.hpp b/include/mrdocs/Config/ReferenceDirectories.hpp
index 2e8e61665..c3bc626e3 100644
--- a/include/mrdocs/Config/ReferenceDirectories.hpp
+++ b/include/mrdocs/Config/ReferenceDirectories.hpp
@@ -9,8 +9,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_CONFIG_REFERENCE_DIRECTORIES_HPP
-#define MRDOCS_API_CONFIG_REFERENCE_DIRECTORIES_HPP
+#ifndef MRDOCS_API_CONFIG_REFERENCEDIRECTORIES_HPP
+#define MRDOCS_API_CONFIG_REFERENCEDIRECTORIES_HPP
 
 #include <string>
 
@@ -34,4 +34,4 @@ struct ReferenceDirectories
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_API_CONFIG_REFERENCEDIRECTORIES_HPP
diff --git a/include/mrdocs/Corpus.hpp b/include/mrdocs/Corpus.hpp
index d50ee6e35..2244039b2 100644
--- a/include/mrdocs/Corpus.hpp
+++ b/include/mrdocs/Corpus.hpp
@@ -17,11 +17,11 @@
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Config.hpp>
 #include <mrdocs/Metadata.hpp>
+#include <algorithm>
 #include <string>
 #include <type_traits>
 #include <utility>
 #include <vector>
-#include <algorithm>
 
 namespace clang::mrdocs {
 
@@ -500,4 +500,4 @@ getParents(Corpus const& C, Info const& I);
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_CORPUS_HPP
diff --git a/include/mrdocs/Dom.hpp b/include/mrdocs/Dom.hpp
index 87b0309ad..edf7ac264 100644
--- a/include/mrdocs/Dom.hpp
+++ b/include/mrdocs/Dom.hpp
@@ -13,4 +13,4 @@
 
 #include <mrdocs/Dom/Value.hpp>
 
-#endif
+#endif // MRDOCS_API_DOM_HPP
diff --git a/include/mrdocs/Dom/LazyArray.hpp b/include/mrdocs/Dom/LazyArray.hpp
index 06a445bbe..a787ed63f 100644
--- a/include/mrdocs/Dom/LazyArray.hpp
+++ b/include/mrdocs/Dom/LazyArray.hpp
@@ -8,11 +8,11 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_DOM_LAZY_ARRAY_HPP
-#define MRDOCS_LIB_DOM_LAZY_ARRAY_HPP
+#ifndef MRDOCS_API_DOM_LAZYARRAY_HPP
+#define MRDOCS_API_DOM_LAZYARRAY_HPP
 
-#include <mrdocs/Dom.hpp>
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
 #include <mrdocs/Support/Error.hpp>
 #include <ranges>
 #include <string_view>
@@ -195,4 +195,4 @@ TransformArray(T const& arr, F const& f)
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_API_DOM_LAZYARRAY_HPP
diff --git a/include/mrdocs/Dom/LazyObject.hpp b/include/mrdocs/Dom/LazyObject.hpp
index de913e8de..dcef64fa3 100644
--- a/include/mrdocs/Dom/LazyObject.hpp
+++ b/include/mrdocs/Dom/LazyObject.hpp
@@ -8,8 +8,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_DOM_LAZY_OBJECT_HPP
-#define MRDOCS_LIB_DOM_LAZY_OBJECT_HPP
+#ifndef MRDOCS_API_DOM_LAZYOBJECT_HPP
+#define MRDOCS_API_DOM_LAZYOBJECT_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom.hpp>
@@ -458,4 +458,4 @@ LazyObject(T const& arr, Context const& context)
 
 } // clang::mrdocs::dom
 
-#endif
+#endif // MRDOCS_API_DOM_LAZYOBJECT_HPP
diff --git a/include/mrdocs/Dom/String.hpp b/include/mrdocs/Dom/String.hpp
index da09155d0..c91ce3dc0 100644
--- a/include/mrdocs/Dom/String.hpp
+++ b/include/mrdocs/Dom/String.hpp
@@ -11,9 +11,9 @@
 #ifndef MRDOCS_API_DOM_STRING_HPP
 #define MRDOCS_API_DOM_STRING_HPP
 
-#include <format>
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Support/String.hpp>
+#include <format>
 
 namespace clang {
 namespace mrdocs {
diff --git a/include/mrdocs/Dom/Value.hpp b/include/mrdocs/Dom/Value.hpp
index c2c6a24e3..c9cc97f82 100644
--- a/include/mrdocs/Dom/Value.hpp
+++ b/include/mrdocs/Dom/Value.hpp
@@ -11,17 +11,17 @@
 #ifndef MRDOCS_API_DOM_VALUE_HPP
 #define MRDOCS_API_DOM_VALUE_HPP
 
-#include <charconv>
-#include <compare>
-#include <format>
+#include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/Dom/Array.hpp>
 #include <mrdocs/Dom/Function.hpp>
 #include <mrdocs/Dom/Kind.hpp>
 #include <mrdocs/Dom/Object.hpp>
 #include <mrdocs/Dom/String.hpp>
-#include <mrdocs/Platform.hpp>
 #include <mrdocs/Support/Error.hpp>
+#include <charconv>
+#include <compare>
+#include <format>
 #include <optional> // BAD
 #include <string>
 
diff --git a/include/mrdocs/Generator.hpp b/include/mrdocs/Generator.hpp
index a4c4b7b33..b731c5111 100644
--- a/include/mrdocs/Generator.hpp
+++ b/include/mrdocs/Generator.hpp
@@ -209,4 +209,4 @@ getSinglePageFullPath(
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_API_GENERATOR_HPP
diff --git a/include/mrdocs/Generators.hpp b/include/mrdocs/Generators.hpp
index 55441e80f..bedf614fe 100644
--- a/include/mrdocs/Generators.hpp
+++ b/include/mrdocs/Generators.hpp
@@ -19,7 +19,7 @@
 namespace clang {
 namespace mrdocs {
 
-/** A dynamic list of Generator
+/** A dynamic list of @ref Generator elements.
 */
 class MRDOCS_VISIBLE
     Generators
@@ -79,4 +79,4 @@ getGenerators() noexcept;
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_API_GENERATORS_HPP
diff --git a/include/mrdocs/Metadata.hpp b/include/mrdocs/Metadata.hpp
index c13449d4f..94bd5719e 100644
--- a/include/mrdocs/Metadata.hpp
+++ b/include/mrdocs/Metadata.hpp
@@ -13,7 +13,7 @@
 #define MRDOCS_API_METADATA_HPP
 
 #include <mrdocs/Platform.hpp>
-
+#include <mrdocs/Metadata/Expression.hpp>
 #include <mrdocs/Metadata/Info.hpp>
 #include <mrdocs/Metadata/Info/Concept.hpp>
 #include <mrdocs/Metadata/Info/Enum.hpp>
@@ -25,16 +25,14 @@
 #include <mrdocs/Metadata/Info/NamespaceAlias.hpp>
 #include <mrdocs/Metadata/Info/Overloads.hpp>
 #include <mrdocs/Metadata/Info/Record.hpp>
+#include <mrdocs/Metadata/Info/Source.hpp>
+#include <mrdocs/Metadata/Info/SymbolID.hpp>
 #include <mrdocs/Metadata/Info/Typedef.hpp>
-#include <mrdocs/Metadata/Info/Variable.hpp>
 #include <mrdocs/Metadata/Info/Using.hpp>
-
-#include <mrdocs/Metadata/Expression.hpp>
+#include <mrdocs/Metadata/Info/Variable.hpp>
 #include <mrdocs/Metadata/Javadoc.hpp>
 #include <mrdocs/Metadata/Name.hpp>
-#include <mrdocs/Metadata/Source.hpp>
-#include <mrdocs/Metadata/SymbolID.hpp>
 #include <mrdocs/Metadata/Template.hpp>
 #include <mrdocs/Metadata/Type.hpp>
 
-#endif
+#endif // MRDOCS_API_METADATA_HPP
diff --git a/include/mrdocs/Metadata/DomCorpus.hpp b/include/mrdocs/Metadata/DomCorpus.hpp
index 0ab8ed7dd..7e145e2de 100644
--- a/include/mrdocs/Metadata/DomCorpus.hpp
+++ b/include/mrdocs/Metadata/DomCorpus.hpp
@@ -10,8 +10,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_DOM_DOMCORPUS_HPP
-#define MRDOCS_API_DOM_DOMCORPUS_HPP
+#ifndef MRDOCS_API_METADATA_DOMCORPUS_HPP
+#define MRDOCS_API_METADATA_DOMCORPUS_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom.hpp>
@@ -114,4 +114,4 @@ getParents(DomCorpus const& C, Info const& I);
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_DOMCORPUS_HPP
diff --git a/include/mrdocs/Metadata/Info.hpp b/include/mrdocs/Metadata/Info.hpp
index de2100452..e26641d54 100644
--- a/include/mrdocs/Metadata/Info.hpp
+++ b/include/mrdocs/Metadata/Info.hpp
@@ -13,219 +13,10 @@
 #define MRDOCS_API_METADATA_INFO_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Dom.hpp>
-#include <mrdocs/Dom/LazyObject.hpp>
-#include <mrdocs/Metadata/ExtractionMode.hpp>
-#include <mrdocs/Metadata/Javadoc.hpp>
-#include <mrdocs/Metadata/Specifiers.hpp>
-#include <mrdocs/Metadata/SymbolID.hpp>
-#include <mrdocs/Metadata/Source.hpp>
-#include <mrdocs/Metadata/DomCorpus.hpp>
-#include <mrdocs/Support/Concepts.hpp>
-#include <mrdocs/Support/Visitor.hpp>
-#include <string>
+#include <mrdocs/Metadata/Info/InfoBase.hpp>
 
 namespace clang::mrdocs {
 
-/* Forward declarations
- */
-#define INFO(Type) struct Type##Info;
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
-
-/** Info variant discriminator
-*/
-enum class InfoKind
-{
-    /// Kind is not specified.
-    None = 0,
-    #define INFO(Type) Type,
-    #include <mrdocs/Metadata/Info/InfoNodes.inc>
-};
-
-/** Return the name of the InfoKind as a string.
- */
-MRDOCS_DECL
-dom::String
-toString(InfoKind kind) noexcept;
-
-/** Return the InfoKind from a @ref dom::Value string.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    InfoKind const kind)
-{
-    v = toString(kind);
-}
-
-consteval
-std::underlying_type_t<InfoKind>
-countInfoKind()
-{
-    std::underlying_type_t<InfoKind> count = 0;
-#define INFO(Type) count++;
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
-    return count;
-}
-
-/** Base class with common properties of all symbols
-*/
-struct MRDOCS_VISIBLE Info
-    : SourceInfo
-{
-    /** The unique identifier for this symbol.
-    */
-    SymbolID id;
-
-    /** The unqualified name.
-    */
-    std::string Name;
-
-    /** Kind of declaration.
-    */
-    InfoKind Kind = InfoKind::None;
-
-    /** Declaration access.
-
-        Class members use:
-        @li `AccessKind::Public`,
-        @li `AccessKind::Protected`, and
-        @li `AccessKind::Private`.
-
-        Namespace members use `AccessKind::None`.
-    */
-    AccessKind Access = AccessKind::None;
-
-    /** Determine why a symbol is extracted.
-
-        This flag distinguishes `Info` from its dependencies and
-        indicates why it was extracted.
-
-        Non-dependencies can be extracted in normal mode,
-        see-below mode, or implementation-defined mode.
-
-        A dependency is a symbol which does not meet the configured
-        conditions for extraction, but had to be extracted due to it
-        being used transitively by a primary `Info`.
-    */
-    ExtractionMode Extraction = ExtractionMode::Dependency;
-
-    /** The parent symbol, if any.
-
-        This is the parent namespace or record
-        where the symbol is defined.
-     */
-    SymbolID Parent;
-
-    /** The extracted javadoc for this declaration.
-     */
-    std::optional<Javadoc> javadoc;
-
-    //--------------------------------------------
-
-    ~Info() override = default;
-
-    Info(Info const& Other) = default;
-
-    /** Move constructor.
-     */
-    Info(Info&& Other) = default;
-
-    /** Construct an Info.
-
-        @param kind The kind of symbol
-        @param ID The unique identifier for this symbol
-    */
-    explicit
-    Info(
-        InfoKind const kind,
-        SymbolID const& ID) noexcept
-        : id(ID)
-        , Kind(kind)
-    {
-    }
-
-    #define INFO(Type) constexpr bool is##Type() const noexcept { \
-        return Kind == InfoKind::Type; \
-    }
-    #include <mrdocs/Metadata/Info/InfoNodes.inc>
-
-    constexpr Info const& asInfo() const noexcept
-    {
-        return *this;
-    }
-
-    constexpr Info& asInfo() noexcept
-    {
-        return *this;
-    }
-
-    #define INFO(Type) \
-    constexpr Type##Info const& as##Type() const noexcept { \
-        if (Kind == InfoKind::Type) \
-            return reinterpret_cast<Type##Info const&>(*this); \
-        MRDOCS_UNREACHABLE(); \
-    }
-    #include <mrdocs/Metadata/Info/InfoNodes.inc>
-
-    #define INFO(Type) \
-    constexpr Type##Info & as##Type() noexcept { \
-        if (Kind == InfoKind::Type) \
-            return reinterpret_cast<Type##Info&>(*this); \
-        MRDOCS_UNREACHABLE(); \
-    }
-    #include <mrdocs/Metadata/Info/InfoNodes.inc>
-
-    #define INFO(Type) \
-    constexpr Type##Info const* as##Type##Ptr() const noexcept { \
-        if (Kind == InfoKind::Type) { return reinterpret_cast<Type##Info const*>(this); } \
-        return nullptr; \
-    }
-    #include <mrdocs/Metadata/Info/InfoNodes.inc>
-
-    #define INFO(Type) \
-    constexpr Type##Info * as##Type##Ptr() noexcept { \
-        if (Kind == InfoKind::Type) { return reinterpret_cast<Type##Info *>(this); } \
-        return nullptr; \
-    }
-    #include <mrdocs/Metadata/Info/InfoNodes.inc>
-
-    auto operator<=>(Info const&) const = default;
-};
-
-//------------------------------------------------
-
-/** Base class for providing variant discriminator functions.
-
-    This offers functions that return a boolean at
-    compile-time, indicating if the most-derived
-    class is a certain type.
-*/
-template <InfoKind K>
-struct InfoCommonBase : Info
-{
-    /** The variant discriminator constant of the most-derived class.
-
-        It only distinguishes from `Info::kind` in that it is a constant.
-
-     */
-    static constexpr InfoKind kind_id = K;
-
-    #define INFO(Kind) \
-    static constexpr bool is##Kind() noexcept { return K == InfoKind::Kind; }
-    #include <mrdocs/Metadata/Info/InfoNodes.inc>
-
-    auto operator<=>(InfoCommonBase const&) const = default;
-
-protected:
-    constexpr explicit InfoCommonBase(SymbolID const& ID)
-        : Info(K, ID)
-    {
-    }
-};
-
 /** Invoke a function object with a type derived from Info
 
     This function will invoke the function object `fn` with
@@ -256,25 +47,12 @@ visit(
     #define INFO(Type) \
     case InfoKind::Type: \
         return visitor.template visit<Type##Info>();
-    #include <mrdocs/Metadata/Info/InfoNodes.inc>
+#include <mrdocs/Metadata/Info/InfoNodes.inc>
     default:
         MRDOCS_UNREACHABLE();
     }
 }
 
-/** Merges two Info objects.
-
-    This function is used to merge two Info objects with the same SymbolID.
-    The function assumes that the two Info objects are of the same type.
-    If they are not, the function will fail.
-
-    @param I The Info object to merge into.
-    @param Other The Info object to merge from.
-*/
-MRDOCS_DECL
-void
-merge(Info& I, Info&& Other);
-
 /** Merges two Info objects according to the behavior of the derived class.
 
     @param I The Info object to merge into.
@@ -294,15 +72,6 @@ merge(InfoTy& I, InfoTy&& Other)
     });
 }
 
-inline
-bool
-canMerge(Info const& I, Info const& Other)
-{
-    return
-        I.Kind == Other.Kind &&
-        I.id == Other.id;
-}
-
 /** A concept for types that have `Info` members.
 
     In most cases `T` is another `Info` type that
@@ -315,45 +84,6 @@ concept InfoParent = requires(InfoTy const& I)
     { allMembers(I) } -> range_of<SymbolID>;
 };
 
-/** Map the Info to a @ref dom::Object.
-
-    @param io The output parameter to receive the dom::Object.
-    @param I The Info to convert.
-    @param domCorpus The DomCorpus used to resolve references.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag,
-    IO& io,
-    Info const& I,
-    DomCorpus const* domCorpus)
-{
-    MRDOCS_ASSERT(domCorpus);
-    io.map("class", std::string("symbol"));
-    io.map("kind", I.Kind);
-    io.map("id", I.id);
-    if (!I.Name.empty())
-    {
-        io.map("name", I.Name);
-    }
-    io.map("access", I.Access);
-    io.map("extraction", I.Extraction);
-    io.map("isRegular", I.Extraction == ExtractionMode::Regular);
-    io.map("isSeeBelow", I.Extraction == ExtractionMode::SeeBelow);
-    io.map("isImplementationDefined", I.Extraction == ExtractionMode::ImplementationDefined);
-    io.map("isDependency", I.Extraction == ExtractionMode::Dependency);
-    if (I.Parent)
-    {
-        io.map("parent", I.Parent);
-    }
-    if (I.javadoc)
-    {
-        io.map("doc", *I.javadoc);
-    }
-    io.map("loc", dynamic_cast<SourceInfo const&>(I));
-}
-
 /** Map the Polymorphic Info to a @ref dom::Object.
 
     @param io The output parameter to receive the dom::Object.
@@ -379,19 +109,6 @@ tag_invoke(
     });
 }
 
-/** Return the Info as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Info const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
 /** Map the Polymorphic Info as a @ref dom::Value object.
 
     @param io The output parameter to receive the dom::Value.
@@ -417,15 +134,6 @@ tag_invoke(
     });
 }
 
-inline
-Optional<Location>
-getPrimaryLocation(Info const& I)
-{
-    return getPrimaryLocation(
-        dynamic_cast<SourceInfo const&>(I),
-        I.isRecord() || I.isEnum());
-}
-
 } // clang::mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Info/Concept.hpp b/include/mrdocs/Metadata/Info/Concept.hpp
index 6a70fa066..65618e157 100644
--- a/include/mrdocs/Metadata/Info/Concept.hpp
+++ b/include/mrdocs/Metadata/Info/Concept.hpp
@@ -8,14 +8,15 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_CONCEPT_HPP
-#define MRDOCS_API_METADATA_CONCEPT_HPP
+#ifndef MRDOCS_API_METADATA_INFO_CONCEPT_HPP
+#define MRDOCS_API_METADATA_INFO_CONCEPT_HPP
 
-#include <mrdocs/Metadata/Info.hpp>
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Metadata/Expression.hpp>
-#include <mrdocs/Metadata/Source.hpp>
+#include <mrdocs/Metadata/Info.hpp>
+#include <mrdocs/Metadata/Info/Source.hpp>
 #include <mrdocs/Metadata/Template.hpp>
-#include <mrdocs/ADT/Polymorphic.hpp>
 
 namespace clang::mrdocs {
 
@@ -85,4 +86,4 @@ tag_invoke(
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_INFO_CONCEPT_HPP
diff --git a/include/mrdocs/Metadata/Info/Enum.hpp b/include/mrdocs/Metadata/Info/Enum.hpp
index b78825428..fc8550548 100644
--- a/include/mrdocs/Metadata/Info/Enum.hpp
+++ b/include/mrdocs/Metadata/Info/Enum.hpp
@@ -9,14 +9,15 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_ENUM_HPP
-#define MRDOCS_API_METADATA_ENUM_HPP
+#ifndef MRDOCS_API_METADATA_INFO_ENUM_HPP
+#define MRDOCS_API_METADATA_INFO_ENUM_HPP
 
+#include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Dom/LazyArray.hpp>
 #include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/Source.hpp>
+#include <mrdocs/Metadata/Info/Source.hpp>
 #include <mrdocs/Metadata/Type.hpp>
-#include <mrdocs/Dom/LazyArray.hpp>
 
 namespace clang::mrdocs {
 
@@ -29,7 +30,7 @@ struct EnumInfo final
     // Set too nonempty to the type when this is an explicitly typed enum. For
     //   enum Foo : short { ... };
     // this will be "short".
-    Polymorphic<TypeInfo> UnderlyingType = std::nullopt;
+    Optional<Polymorphic<TypeInfo>> UnderlyingType = std::nullopt;
 
     /** The members of this scope.
 
@@ -96,4 +97,4 @@ tag_invoke(
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_INFO_ENUM_HPP
diff --git a/include/mrdocs/Metadata/Info/EnumConstant.hpp b/include/mrdocs/Metadata/Info/EnumConstant.hpp
index c84681b87..32cc6ce22 100644
--- a/include/mrdocs/Metadata/Info/EnumConstant.hpp
+++ b/include/mrdocs/Metadata/Info/EnumConstant.hpp
@@ -8,12 +8,12 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_ENUMCONSTANT_HPP
-#define MRDOCS_API_METADATA_ENUMCONSTANT_HPP
+#ifndef MRDOCS_API_METADATA_INFO_ENUMCONSTANT_HPP
+#define MRDOCS_API_METADATA_INFO_ENUMCONSTANT_HPP
 
 #include <mrdocs/Metadata/Expression.hpp>
 #include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/Source.hpp>
+#include <mrdocs/Metadata/Info/Source.hpp>
 
 namespace clang::mrdocs {
 
@@ -75,4 +75,4 @@ tag_invoke(
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_INFO_ENUMCONSTANT_HPP
diff --git a/include/mrdocs/Metadata/ExtractionMode.hpp b/include/mrdocs/Metadata/Info/ExtractionMode.hpp
similarity index 95%
rename from include/mrdocs/Metadata/ExtractionMode.hpp
rename to include/mrdocs/Metadata/Info/ExtractionMode.hpp
index 9d2b7b832..862a6ae25 100644
--- a/include/mrdocs/Metadata/ExtractionMode.hpp
+++ b/include/mrdocs/Metadata/Info/ExtractionMode.hpp
@@ -9,8 +9,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_EXTRACTIONMODE_HPP
-#define MRDOCS_API_METADATA_EXTRACTIONMODE_HPP
+#ifndef MRDOCS_API_METADATA_INFO_EXTRACTIONMODE_HPP
+#define MRDOCS_API_METADATA_INFO_EXTRACTIONMODE_HPP
 
 #include <mrdocs/Dom.hpp>
 
@@ -121,4 +121,4 @@ mostSpecific(ExtractionMode const a, ExtractionMode const b) noexcept
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_INFO_EXTRACTIONMODE_HPP
diff --git a/include/mrdocs/Metadata/Info/Friend.hpp b/include/mrdocs/Metadata/Info/Friend.hpp
index 36b2948ac..ef76e3ff6 100644
--- a/include/mrdocs/Metadata/Info/Friend.hpp
+++ b/include/mrdocs/Metadata/Info/Friend.hpp
@@ -8,11 +8,11 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_FRIEND_HPP
-#define MRDOCS_API_METADATA_FRIEND_HPP
+#ifndef MRDOCS_API_METADATA_INFO_FRIEND_HPP
+#define MRDOCS_API_METADATA_INFO_FRIEND_HPP
 
 #include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/Source.hpp>
+#include <mrdocs/Metadata/Info/Source.hpp>
 #include <mrdocs/Metadata/Type.hpp>
 
 namespace clang::mrdocs {
@@ -31,7 +31,7 @@ struct FriendInfo final
 
     /** Befriended type.
     */
-    Polymorphic<TypeInfo> Type = std::nullopt;
+    Optional<Polymorphic<TypeInfo>> Type = std::nullopt;
 };
 
 MRDOCS_DECL
@@ -84,4 +84,4 @@ tag_invoke(
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_INFO_FRIEND_HPP
diff --git a/include/mrdocs/Metadata/Info/Function.hpp b/include/mrdocs/Metadata/Info/Function.hpp
index 7e6df927e..e3e5c3420 100644
--- a/include/mrdocs/Metadata/Info/Function.hpp
+++ b/include/mrdocs/Metadata/Info/Function.hpp
@@ -11,163 +11,26 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_FUNCTION_HPP
-#define MRDOCS_API_METADATA_FUNCTION_HPP
+#ifndef MRDOCS_API_METADATA_INFO_FUNCTION_HPP
+#define MRDOCS_API_METADATA_INFO_FUNCTION_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Specifiers.hpp>
-#include <mrdocs/Metadata/Type.hpp>
-#include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/Source.hpp>
+#include <mrdocs/Metadata/Info/FunctionClass.hpp>
+#include <mrdocs/Metadata/Info/InfoBase.hpp>
+#include <mrdocs/Metadata/Info/Param.hpp>
 #include <mrdocs/Metadata/Template.hpp>
-#include <mrdocs/Dom/LazyArray.hpp>
-#include <mrdocs/ADT/Polymorphic.hpp>
 #include <string>
 #include <vector>
 
 namespace clang::mrdocs {
 
-/** Return the name of an operator as a string.
-
-    @param kind The kind of operator.
-    @param include_keyword Whether the name
-    should be prefixed with the `operator` keyword.
-*/
-MRDOCS_DECL
-std::string_view
-getOperatorName(
-    OperatorKind kind,
-    bool include_keyword = false) noexcept;
-
-/** Return the short name of an operator as a string.
-*/
-MRDOCS_DECL
-std::string_view
-getShortOperatorName(
-    OperatorKind kind) noexcept;
-
-/** Return the short name of an operator as a string.
-
-    @param name The operator name, e.g. `operator+`, `operator++`, `operator[]`, etc.
-    @return The OperatorKind, or OperatorKind::None if not recognized.
-*/
-MRDOCS_DECL
-OperatorKind
-getOperatorKind(std::string_view name) noexcept;
-
-/** Return the short name of an operator as a string.
-
-    @param suffix The operator suffix, e.g. `+`, `++`, `[]`, etc.
-    @return The OperatorKind, or OperatorKind::None if not recognized.
-*/
-MRDOCS_DECL
-OperatorKind
-getOperatorKindFromSuffix(std::string_view suffix) noexcept;
-
-/** Return the safe name of an operator as a string.
-
-    @param kind The kind of operator.
-    @param include_keyword Whether the name
-    should be prefixed with `operator_`.
-*/
-MRDOCS_DECL
-std::string_view
-getSafeOperatorName(
-    OperatorKind kind,
-    bool include_keyword = false) noexcept;
-
-/** Return the human-readable name of the operator
-
-    @param kind The kind of operator.
-    @param nParams The number of parameters the operator takes.
-    @return The readable name, or nullopt if the operator is not recognized.
- */
-std::optional<std::string_view>
-getOperatorReadableName(
-    OperatorKind kind,
-    int nParams);
-
-/** Function classifications */
-enum class FunctionClass
-{
-    /// The function is a normal function.
-    Normal = 0,
-    /// The function is a constructor.
-    Constructor,
-    /// The function is a conversion operator.
-    Conversion,
-    /// The function is a destructor.
-    Destructor
-};
-
-MRDOCS_DECL dom::String toString(FunctionClass kind) noexcept;
-
-/** Return the FunctionClass from a @ref dom::Value string.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    FunctionClass const kind)
-{
-    v = toString(kind);
-}
-
-
-// KRYSTIAN TODO: attributes (nodiscard, deprecated, and carries_dependency)
-// KRYSTIAN TODO: flag to indicate whether this is a function parameter pack
-/** Represents a single function parameter */
-struct Param final
-{
-    /** The type of this parameter
-     */
-    Polymorphic<TypeInfo> Type = std::nullopt;
-
-    /** The parameter name.
-     */
-    Optional<std::string> Name;
-
-    /** The default argument for this parameter, if any
-      */
-    Optional<std::string> Default;
-
-    Param() = default;
-
-    Param(
-        Polymorphic<TypeInfo>&& type,
-        std::string&& name,
-        std::string&& def_arg)
-        : Type(std::move(type))
-        , Name(std::move(name))
-        , Default(std::move(def_arg))
-    {}
-
-    auto
-    operator<=>(Param const&) const = default;
-};
-
-MRDOCS_DECL
-void
-merge(Param& I, Param&& Other);
-
-/** Return the Param as a @ref dom::Value object.
- */
-MRDOCS_DECL
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Param const& p,
-    DomCorpus const* domCorpus);
-
 // TODO: Expand to allow for documenting templating and default args.
 // Info for functions.
 struct FunctionInfo final
     : InfoCommonBase<InfoKind::Function>
 {
     /// Info about the return type of this function.
-    Polymorphic<TypeInfo> ReturnType = std::nullopt;
+    Optional<Polymorphic<TypeInfo>> ReturnType = std::nullopt;
 
     /// List of parameters.
     std::vector<Param> Params;
@@ -307,4 +170,4 @@ overrides(FunctionInfo const& base, FunctionInfo const& derived);
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_INFO_FUNCTION_HPP
diff --git a/include/mrdocs/Metadata/Info/FunctionClass.hpp b/include/mrdocs/Metadata/Info/FunctionClass.hpp
new file mode 100644
index 000000000..929efca43
--- /dev/null
+++ b/include/mrdocs/Metadata/Info/FunctionClass.hpp
@@ -0,0 +1,53 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2024 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_INFO_FUNCTIONCLASS_HPP
+#define MRDOCS_API_METADATA_INFO_FUNCTIONCLASS_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+
+namespace clang::mrdocs {
+
+/** Function classifications */
+enum class FunctionClass
+{
+    /// The function is a normal function.
+    Normal = 0,
+    /// The function is a constructor.
+    Constructor,
+    /// The function is a conversion operator.
+    Conversion,
+    /// The function is a destructor.
+    Destructor
+};
+
+MRDOCS_DECL
+dom::String
+toString(FunctionClass kind) noexcept;
+
+/** Return the FunctionClass from a @ref dom::Value string.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    FunctionClass const kind)
+{
+    v = toString(kind);
+}
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Info/Guide.hpp b/include/mrdocs/Metadata/Info/Guide.hpp
index 934c8e590..869ef653d 100644
--- a/include/mrdocs/Metadata/Info/Guide.hpp
+++ b/include/mrdocs/Metadata/Info/Guide.hpp
@@ -8,16 +8,16 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_GUIDE_HPP
-#define MRDOCS_API_METADATA_GUIDE_HPP
+#ifndef MRDOCS_API_METADATA_INFO_GUIDE_HPP
+#define MRDOCS_API_METADATA_INFO_GUIDE_HPP
 
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/Source.hpp>
-#include <mrdocs/Metadata/Template.hpp>
 #include <mrdocs/Metadata/Info/Function.hpp>
+#include <mrdocs/Metadata/Info/Source.hpp>
+#include <mrdocs/Metadata/Template.hpp>
 #include <mrdocs/Metadata/Type.hpp>
-#include <mrdocs/ADT/Polymorphic.hpp>
 #include <vector>
 
 namespace clang::mrdocs {
@@ -31,7 +31,7 @@ struct GuideInfo final
 
         This is always a SpecializationTypeInfo.
     */
-    Polymorphic<TypeInfo> Deduced = std::nullopt;
+    Optional<Polymorphic<TypeInfo>> Deduced = std::nullopt;
 
     /** Template head, if any.
     */
@@ -96,4 +96,4 @@ tag_invoke(
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_INFO_GUIDE_HPP
diff --git a/include/mrdocs/Metadata/Info/InfoBase.hpp b/include/mrdocs/Metadata/Info/InfoBase.hpp
new file mode 100644
index 000000000..ac0336e9c
--- /dev/null
+++ b/include/mrdocs/Metadata/Info/InfoBase.hpp
@@ -0,0 +1,277 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_INFO_INFOBASE_HPP
+#define MRDOCS_API_METADATA_INFO_INFOBASE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Info/ExtractionMode.hpp>
+#include <mrdocs/Metadata/Info/InfoKind.hpp>
+#include <mrdocs/Metadata/Info/Source.hpp>
+#include <mrdocs/Metadata/Info/SymbolID.hpp>
+#include <mrdocs/Metadata/Javadoc.hpp>
+#include <mrdocs/Metadata/Specifiers/AccessKind.hpp>
+
+namespace clang::mrdocs {
+
+/* Forward declarations
+ */
+#define INFO(Type) struct Type##Info;
+#include <mrdocs/Metadata/Info/InfoNodes.inc>
+
+/** Base class with common properties of all symbols
+*/
+struct MRDOCS_VISIBLE Info
+    : SourceInfo
+{
+    /** The unique identifier for this symbol.
+    */
+    SymbolID id;
+
+    /** The unqualified name.
+    */
+    std::string Name;
+
+    /** Kind of declaration.
+    */
+    InfoKind Kind = InfoKind::None;
+
+    /** Declaration access.
+
+        Class members use:
+        @li `AccessKind::Public`,
+        @li `AccessKind::Protected`, and
+        @li `AccessKind::Private`.
+
+        Namespace members use `AccessKind::None`.
+    */
+    AccessKind Access = AccessKind::None;
+
+    /** Determine why a symbol is extracted.
+
+        This flag distinguishes `Info` from its dependencies and
+        indicates why it was extracted.
+
+        Non-dependencies can be extracted in normal mode,
+        see-below mode, or implementation-defined mode.
+
+        A dependency is a symbol that does not meet the configured
+        conditions for extraction, but had to be extracted due to it
+        being used transitively by a primary `Info`.
+    */
+    ExtractionMode Extraction = ExtractionMode::Dependency;
+
+    /** The parent symbol, if any.
+
+        This is the parent namespace or record
+        where the symbol is defined.
+     */
+    SymbolID Parent;
+
+    /** The extracted javadoc for this declaration.
+     */
+    std::optional<Javadoc> javadoc;
+
+    //--------------------------------------------
+
+    ~Info() override = default;
+
+    Info(Info const& Other) = default;
+
+    /** Move constructor.
+     */
+    Info(Info&& Other) = default;
+
+    /** Construct an Info.
+
+        @param kind The kind of symbol
+        @param ID The unique identifier for this symbol
+    */
+    explicit
+    Info(
+        InfoKind const kind,
+        SymbolID const& ID) noexcept
+        : id(ID)
+        , Kind(kind)
+    {
+    }
+
+    #define INFO(Type) constexpr bool is##Type() const noexcept { \
+        return Kind == InfoKind::Type; \
+    }
+#include <mrdocs/Metadata/Info/InfoNodes.inc>
+
+    constexpr Info const& asInfo() const noexcept
+    {
+        return *this;
+    }
+
+    constexpr Info& asInfo() noexcept
+    {
+        return *this;
+    }
+
+    #define INFO(Type) \
+    constexpr Type##Info const& as##Type() const noexcept { \
+        if (Kind == InfoKind::Type) \
+            return reinterpret_cast<Type##Info const&>(*this); \
+        MRDOCS_UNREACHABLE(); \
+    }
+#include <mrdocs/Metadata/Info/InfoNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##Info & as##Type() noexcept { \
+        if (Kind == InfoKind::Type) \
+            return reinterpret_cast<Type##Info&>(*this); \
+        MRDOCS_UNREACHABLE(); \
+    }
+#include <mrdocs/Metadata/Info/InfoNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##Info const* as##Type##Ptr() const noexcept { \
+        if (Kind == InfoKind::Type) { return reinterpret_cast<Type##Info const*>(this); } \
+        return nullptr; \
+    }
+#include <mrdocs/Metadata/Info/InfoNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##Info * as##Type##Ptr() noexcept { \
+        if (Kind == InfoKind::Type) { return reinterpret_cast<Type##Info *>(this); } \
+        return nullptr; \
+    }
+#include <mrdocs/Metadata/Info/InfoNodes.inc>
+
+    auto operator<=>(Info const&) const = default;
+
+protected:
+    Info() = default;
+
+};
+
+//------------------------------------------------
+
+/** Base class for providing variant discriminator functions.
+
+    This offers functions that return a boolean at
+    compile-time, indicating if the most-derived
+    class is a certain type.
+*/
+template <InfoKind K>
+struct InfoCommonBase : Info
+{
+    /** The variant discriminator constant of the most-derived class.
+
+        It only distinguishes from `Info::kind` in that it is a constant.
+
+     */
+    static constexpr InfoKind kind_id = K;
+
+    #define INFO(Kind) \
+    static constexpr bool is##Kind() noexcept { return K == InfoKind::Kind; }
+#include <mrdocs/Metadata/Info/InfoNodes.inc>
+
+    auto operator<=>(InfoCommonBase const&) const = default;
+
+protected:
+    InfoCommonBase() = default;
+
+    constexpr explicit InfoCommonBase(SymbolID const& ID)
+        : Info(K, ID)
+    {
+    }
+};
+
+/** Merges two Info objects.
+
+    This function is used to merge two Info objects with the same SymbolID.
+    The function assumes that the two Info objects are of the same type.
+    If they are not, the function will fail.
+
+    @param I The Info object to merge into.
+    @param Other The Info object to merge from.
+*/
+MRDOCS_DECL
+void
+merge(Info& I, Info&& Other);
+
+inline
+bool
+canMerge(Info const& I, Info const& Other)
+{
+    return
+        I.Kind == Other.Kind &&
+        I.id == Other.id;
+}
+
+/** Map the Info to a @ref dom::Object.
+
+    @param io The output parameter to receive the dom::Object.
+    @param I The Info to convert.
+    @param domCorpus The DomCorpus used to resolve references.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag,
+    IO& io,
+    Info const& I,
+    DomCorpus const* domCorpus)
+{
+    MRDOCS_ASSERT(domCorpus);
+    io.map("class", std::string("symbol"));
+    io.map("kind", I.Kind);
+    io.map("id", I.id);
+    if (!I.Name.empty())
+    {
+        io.map("name", I.Name);
+    }
+    io.map("access", I.Access);
+    io.map("extraction", I.Extraction);
+    io.map("isRegular", I.Extraction == ExtractionMode::Regular);
+    io.map("isSeeBelow", I.Extraction == ExtractionMode::SeeBelow);
+    io.map("isImplementationDefined", I.Extraction == ExtractionMode::ImplementationDefined);
+    io.map("isDependency", I.Extraction == ExtractionMode::Dependency);
+    if (I.Parent)
+    {
+        io.map("parent", I.Parent);
+    }
+    if (I.javadoc)
+    {
+        io.map("doc", *I.javadoc);
+    }
+    io.map("loc", dynamic_cast<SourceInfo const&>(I));
+}
+
+/** Return the Info as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Info const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+inline
+Optional<Location>
+getPrimaryLocation(Info const& I)
+{
+    return getPrimaryLocation(
+        dynamic_cast<SourceInfo const&>(I),
+        I.isRecord() || I.isEnum());
+}
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Info/InfoKind.hpp b/include/mrdocs/Metadata/Info/InfoKind.hpp
new file mode 100644
index 000000000..6fb3a0f80
--- /dev/null
+++ b/include/mrdocs/Metadata/Info/InfoKind.hpp
@@ -0,0 +1,60 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_INFO_INFOKIND_HPP
+#define MRDOCS_API_METADATA_INFO_INFOKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+
+namespace clang::mrdocs {
+
+/** Info variant discriminator
+*/
+enum class InfoKind
+{
+    /// Kind is not specified.
+    None = 0,
+    #define INFO(Type) Type,
+#include <mrdocs/Metadata/Info/InfoNodes.inc>
+};
+
+/** Return the name of the InfoKind as a string.
+ */
+MRDOCS_DECL
+dom::String
+toString(InfoKind kind) noexcept;
+
+/** Return the InfoKind from a @ref dom::Value string.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    InfoKind const kind)
+{
+    v = toString(kind);
+}
+
+consteval
+std::underlying_type_t<InfoKind>
+countInfoKind()
+{
+    std::underlying_type_t<InfoKind> count = 0;
+#define INFO(Type) count++;
+#include <mrdocs/Metadata/Info/InfoNodes.inc>
+    return count;
+}
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Info/Namespace.hpp b/include/mrdocs/Metadata/Info/Namespace.hpp
index 01f44d3ba..9e5f66e59 100644
--- a/include/mrdocs/Metadata/Info/Namespace.hpp
+++ b/include/mrdocs/Metadata/Info/Namespace.hpp
@@ -9,14 +9,14 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_NAMESPACE_HPP
-#define MRDOCS_API_METADATA_NAMESPACE_HPP
+#ifndef MRDOCS_API_METADATA_INFO_NAMESPACE_HPP
+#define MRDOCS_API_METADATA_INFO_NAMESPACE_HPP
 
+#include <mrdocs/Dom/LazyArray.hpp>
 #include <mrdocs/Metadata/Info.hpp>
 #include <mrdocs/Metadata/Name.hpp>
-#include <mrdocs/Dom/LazyArray.hpp>
-#include <vector>
 #include <ranges>
+#include <vector>
 
 namespace clang::mrdocs {
 
@@ -177,4 +177,4 @@ tag_invoke(
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_INFO_NAMESPACE_HPP
diff --git a/include/mrdocs/Metadata/Info/NamespaceAlias.hpp b/include/mrdocs/Metadata/Info/NamespaceAlias.hpp
index df93ea841..ba0d4a00d 100644
--- a/include/mrdocs/Metadata/Info/NamespaceAlias.hpp
+++ b/include/mrdocs/Metadata/Info/NamespaceAlias.hpp
@@ -8,13 +8,13 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_NAMESPACEALIAS_HPP
-#define MRDOCS_API_METADATA_NAMESPACEALIAS_HPP
+#ifndef MRDOCS_API_METADATA_INFO_NAMESPACEALIAS_HPP
+#define MRDOCS_API_METADATA_INFO_NAMESPACEALIAS_HPP
 
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Metadata/Info.hpp>
 #include <mrdocs/Metadata/Name.hpp>
-#include <mrdocs/ADT/Polymorphic.hpp>
 
 namespace clang::mrdocs {
 
@@ -28,7 +28,7 @@ struct NamespaceAliasInfo final
         This is another namespace that might or might
         not be in the same project.
      */
-    Polymorphic<NameInfo> AliasedSymbol;
+    Optional<Polymorphic<NameInfo>> AliasedSymbol;
 
     //--------------------------------------------
 
@@ -76,4 +76,4 @@ tag_invoke(
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_INFO_NAMESPACEALIAS_HPP
diff --git a/include/mrdocs/Metadata/Info/Overloads.hpp b/include/mrdocs/Metadata/Info/Overloads.hpp
index d88e3f79b..d76c541f6 100644
--- a/include/mrdocs/Metadata/Info/Overloads.hpp
+++ b/include/mrdocs/Metadata/Info/Overloads.hpp
@@ -8,8 +8,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_OVERLOADS_HPP
-#define MRDOCS_API_METADATA_OVERLOADS_HPP
+#ifndef MRDOCS_API_METADATA_INFO_OVERLOADS_HPP
+#define MRDOCS_API_METADATA_INFO_OVERLOADS_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Metadata/Info.hpp>
@@ -32,7 +32,7 @@ struct OverloadsInfo final
     std::vector<SymbolID> Members;
 
     /// Info about the return type of this function.
-    Polymorphic<TypeInfo> ReturnType = std::nullopt;
+    Optional<Polymorphic<TypeInfo>> ReturnType = std::nullopt;
 
     //--------------------------------------------
 
@@ -95,4 +95,4 @@ tag_invoke(
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_INFO_OVERLOADS_HPP
diff --git a/include/mrdocs/Metadata/Info/Param.hpp b/include/mrdocs/Metadata/Info/Param.hpp
new file mode 100644
index 000000000..9463a3496
--- /dev/null
+++ b/include/mrdocs/Metadata/Info/Param.hpp
@@ -0,0 +1,74 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2024 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_INFO_PARAM_HPP
+#define MRDOCS_API_METADATA_INFO_PARAM_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Optional.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/Type.hpp>
+#include <string>
+
+namespace clang::mrdocs {
+
+/** Represents a single function parameter */
+struct Param final
+{
+    /** The type of this parameter
+     */
+    Optional<Polymorphic<TypeInfo>> Type = std::nullopt;
+
+    /** The parameter name.
+     */
+    Optional<std::string> Name;
+
+    /** The default argument for this parameter, if any
+      */
+    Optional<std::string> Default;
+
+    // KRYSTIAN TODO: attributes (nodiscard, deprecated, and carries_dependency)
+    // KRYSTIAN TODO: flag to indicate whether this is a function parameter pack
+
+    Param() = default;
+
+    Param(
+        Polymorphic<TypeInfo>&& type,
+        std::string&& name,
+        std::string&& def_arg)
+        : Type(std::move(type))
+        , Name(std::move(name))
+        , Default(std::move(def_arg))
+    {}
+
+    auto
+    operator<=>(Param const&) const  = default;
+};
+
+MRDOCS_DECL
+void
+merge(Param& I, Param&& Other);
+
+/** Return the Param as a @ref dom::Value object.
+ */
+MRDOCS_DECL
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Param const& p,
+    DomCorpus const* domCorpus);
+
+} // clang::mrdocs
+
+#endif // MRDOCS_API_METADATA_INFO_PARAM_HPP
diff --git a/include/mrdocs/Metadata/Info/Record.hpp b/include/mrdocs/Metadata/Info/Record.hpp
index db83088d9..1c76e4a05 100644
--- a/include/mrdocs/Metadata/Info/Record.hpp
+++ b/include/mrdocs/Metadata/Info/Record.hpp
@@ -9,272 +9,18 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_RECORD_HPP
-#define MRDOCS_API_METADATA_RECORD_HPP
+#ifndef MRDOCS_API_METADATA_INFO_RECORD_HPP
+#define MRDOCS_API_METADATA_INFO_RECORD_HPP
 
-#include <mrdocs/Metadata/Type.hpp>
-#include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/Source.hpp>
-#include <mrdocs/Metadata/Template.hpp>
+#include <mrdocs/Platform.hpp>
 #include <mrdocs/Metadata/Info/Friend.hpp>
-#include <mrdocs/Dom.hpp>
-#include <mrdocs/Dom/LazyObject.hpp>
-#include <mrdocs/Dom/LazyArray.hpp>
-#include <mrdocs/ADT/Polymorphic.hpp>
-#include <vector>
-#include <ranges>
+#include <mrdocs/Metadata/Info/RecordBase.hpp>
+#include <mrdocs/Metadata/Info/RecordInterface.hpp>
+#include <mrdocs/Metadata/Info/RecordKeyKind.hpp>
+#include <mrdocs/Metadata/Template.hpp>
 
 namespace clang::mrdocs {
 
-/** A group of members that have the same access specifier.
-
-    This struct represents a collection of symbols that share
-    the same access specifier within a record.
-
-    It includes one vector for each info type allowed in a
-    record, and individual vectors for static functions, types,
-    and function overloads.
-*/
-struct RecordTranche
-{
-    std::vector<SymbolID> NamespaceAliases;
-    std::vector<SymbolID> Typedefs;
-    std::vector<SymbolID> Records;
-    std::vector<SymbolID> Enums;
-    std::vector<SymbolID> Functions;
-    std::vector<SymbolID> StaticFunctions;
-    std::vector<SymbolID> Variables;
-    std::vector<SymbolID> StaticVariables;
-    std::vector<SymbolID> Concepts;
-    std::vector<SymbolID> Guides;
-    std::vector<SymbolID> Usings;
-};
-
-MRDOCS_DECL
-void
-merge(RecordTranche& I, RecordTranche&& Other);
-
-inline
-auto
-allMembers(RecordTranche const& T)
-{
-    // This is a trick to emulate views::concat in C++20
-    return std::views::transform(
-        std::views::iota(0, 11),
-        [&T](int const i) -> auto const&
-        {
-            switch (i) {
-                case 0: return T.NamespaceAliases;
-                case 1: return T.Typedefs;
-                case 2: return T.Records;
-                case 3: return T.Enums;
-                case 4: return T.Functions;
-                case 5: return T.StaticFunctions;
-                case 6: return T.Variables;
-                case 7: return T.StaticVariables;
-                case 8: return T.Concepts;
-                case 9: return T.Guides;
-                case 10: return T.Usings;
-                default: throw std::out_of_range("Invalid index");
-            }
-        }
-    ) | std::ranges::views::join;
-}
-
-/** Map a RecordTranche to a dom::Object.
-
-    @param io The output parameter to receive the dom::Object.
-    @param I The RecordTranche to convert.
-    @param domCorpus The DomCorpus used to resolve references.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag,
-    IO& io,
-    RecordTranche const& I,
-    DomCorpus const* domCorpus)
-{
-    io.map("namespaceAliases", dom::LazyArray(I.NamespaceAliases, domCorpus));
-    io.map("typedefs", dom::LazyArray(I.Typedefs, domCorpus));
-    io.map("records", dom::LazyArray(I.Records, domCorpus));
-    io.map("enums", dom::LazyArray(I.Enums, domCorpus));
-    io.map("functions", dom::LazyArray(I.Functions, domCorpus));
-    io.map("staticFunctions", dom::LazyArray(I.StaticFunctions, domCorpus));
-    io.map("variables", dom::LazyArray(I.Variables, domCorpus));
-    io.map("staticVariables", dom::LazyArray(I.StaticVariables, domCorpus));
-    io.map("concepts", dom::LazyArray(I.Concepts, domCorpus));
-    io.map("guides", dom::LazyArray(I.Guides, domCorpus));
-    io.map("usings", dom::LazyArray(I.Usings, domCorpus));
-}
-
-/** Map the RecordTranche to a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    RecordTranche const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-/** The aggregated interface for a given struct, class, or union.
-
-    This class represents the public, protected, and private
-    interfaces of a record. It is used to generate the
-    "interface" value of the DOM for symbols that represent
-    records or namespaces.
-
-    The interface is not part of the Corpus. It is a temporary
-    structure generated to aggregate the symbols of a record.
-    This structure is provided to the user via the DOM.
-
-    While the members of a Namespace are directly represented
-    with a Tranche, the members of a Record are represented
-    with an Interface.
-
-*/
-class RecordInterface
-{
-public:
-    /** The aggregated public interfaces.
-
-        This tranche contains all public members of a record
-        or namespace.
-
-     */
-    RecordTranche Public;
-
-    /** The aggregated protected interfaces.
-
-        This tranche contains all protected members of a record
-        or namespace.
-
-     */
-    RecordTranche Protected;
-
-    /** The aggregated private interfaces.
-
-        This tranche contains all private members of a record
-        or namespace.
-
-     */
-    RecordTranche Private;
-};
-
-MRDOCS_DECL
-void
-merge(RecordInterface& I, RecordInterface&& Other);
-
-/** Map a RecordInterface to a dom::Object.
-
-    @param io The output parameter to receive the dom::Object.
-    @param I The RecordInterface to convert.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag,
-    IO& io,
-    RecordInterface const& I,
-    DomCorpus const*)
-{
-    io.map("public", I.Public);
-    io.map("protected", I.Protected);
-    io.map("private", I.Private);
-}
-
-/** Map the RecordInterface to a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    RecordInterface const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-
-inline
-auto
-allMembers(RecordInterface const& T)
-{
-    // This is a trick to emulate views::concat in C++20
-    return
-        std::views::iota(0, 3) |
-        std::views::transform(
-            [&T](int i) -> auto {
-                switch (i) {
-                    case 0: return allMembers(T.Public);
-                    case 1: return allMembers(T.Protected);
-                    case 2: return allMembers(T.Private);
-                    default: throw std::out_of_range("Invalid index");
-                }
-            }) |
-        std::ranges::views::join;
-}
-
-/** Metadata for a direct base.
-*/
-struct BaseInfo
-{
-    Polymorphic<TypeInfo> Type;
-    AccessKind Access = AccessKind::Public;
-    bool IsVirtual = false;
-
-    BaseInfo() = default;
-
-    BaseInfo(
-        Polymorphic<TypeInfo>&& type,
-        AccessKind const access,
-        bool const is_virtual)
-        : Type(std::move(type))
-        , Access(access)
-        , IsVirtual(is_virtual)
-    {
-    }
-};
-
-MRDOCS_DECL
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    BaseInfo const& I,
-    DomCorpus const* domCorpus);
-
-/** The kind of record: struct, class, or union.
-*/
-enum class RecordKeyKind
-{
-    /// A struct.
-    Struct,
-    /// A C++ class.
-    Class,
-    /// A C-style Union
-    Union
-};
-
-MRDOCS_DECL
-dom::String
-toString(RecordKeyKind kind) noexcept;
-
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    RecordKeyKind kind)
-{
-    v = toString(kind);
-}
-
 /** Metadata for struct, class, or union.
 */
 struct RecordInfo final
@@ -394,4 +140,4 @@ tag_invoke(
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_INFO_RECORD_HPP
diff --git a/include/mrdocs/Metadata/Info/RecordBase.hpp b/include/mrdocs/Metadata/Info/RecordBase.hpp
new file mode 100644
index 000000000..6981db72a
--- /dev/null
+++ b/include/mrdocs/Metadata/Info/RecordBase.hpp
@@ -0,0 +1,52 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_INFO_RECORDBASE_HPP
+#define MRDOCS_API_METADATA_INFO_RECORDBASE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Specifiers/AccessKind.hpp>
+#include <mrdocs/Metadata/Type.hpp>
+
+namespace clang::mrdocs {
+
+/** Metadata for a direct base.
+*/
+struct BaseInfo
+{
+    Optional<Polymorphic<TypeInfo>> Type;
+    AccessKind Access = AccessKind::Public;
+    bool IsVirtual = false;
+
+    BaseInfo() = default;
+
+    BaseInfo(
+        Polymorphic<TypeInfo>&& type,
+        AccessKind const access,
+        bool const is_virtual)
+        : Type(std::move(type))
+        , Access(access)
+        , IsVirtual(is_virtual)
+    {
+    }
+};
+
+MRDOCS_DECL
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    BaseInfo const& I,
+    DomCorpus const* domCorpus);
+
+} // clang::mrdocs
+
+#endif // MRDOCS_API_METADATA_INFO_RECORDBASE_HPP
diff --git a/include/mrdocs/Metadata/Info/RecordInterface.hpp b/include/mrdocs/Metadata/Info/RecordInterface.hpp
new file mode 100644
index 000000000..acfdbe32a
--- /dev/null
+++ b/include/mrdocs/Metadata/Info/RecordInterface.hpp
@@ -0,0 +1,121 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_INFO_RECORDINTERFACE_HPP
+#define MRDOCS_API_METADATA_INFO_RECORDINTERFACE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Info/RecordTranche.hpp>
+
+namespace clang::mrdocs {
+
+/** The aggregated interface for a given struct, class, or union.
+
+    This class represents the public, protected, and private
+    interfaces of a record. It is used to generate the
+    "interface" value of the DOM for symbols that represent
+    records or namespaces.
+
+    The interface is not part of the Corpus. It is a temporary
+    structure generated to aggregate the symbols of a record.
+    This structure is provided to the user via the DOM.
+
+    While the members of a Namespace are directly represented
+    with a Tranche, the members of a Record are represented
+    with an Interface.
+
+*/
+class RecordInterface
+{
+public:
+    /** The aggregated public interfaces.
+
+        This tranche contains all public members of a record
+        or namespace.
+
+     */
+    RecordTranche Public;
+
+    /** The aggregated protected interfaces.
+
+        This tranche contains all protected members of a record
+        or namespace.
+
+     */
+    RecordTranche Protected;
+
+    /** The aggregated private interfaces.
+
+        This tranche contains all private members of a record
+        or namespace.
+
+     */
+    RecordTranche Private;
+};
+
+MRDOCS_DECL
+void
+merge(RecordInterface& I, RecordInterface&& Other);
+
+/** Map a RecordInterface to a dom::Object.
+
+    @param io The output parameter to receive the dom::Object.
+    @param I The RecordInterface to convert.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag,
+    IO& io,
+    RecordInterface const& I,
+    DomCorpus const*)
+{
+    io.map("public", I.Public);
+    io.map("protected", I.Protected);
+    io.map("private", I.Private);
+}
+
+/** Map the RecordInterface to a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    RecordInterface const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+
+inline
+auto
+allMembers(RecordInterface const& T)
+{
+    // This is a trick to emulate views::concat in C++20
+    return
+        std::views::iota(0, 3) |
+        std::views::transform(
+            [&T](int i) -> auto {
+                switch (i) {
+                    case 0: return allMembers(T.Public);
+                    case 1: return allMembers(T.Protected);
+                    case 2: return allMembers(T.Private);
+                    default: throw std::out_of_range("Invalid index");
+                }
+            }) |
+        std::ranges::views::join;
+}
+
+} // clang::mrdocs
+
+#endif // MRDOCS_API_METADATA_INFO_RECORDINTERFACE_HPP
diff --git a/include/mrdocs/Metadata/Info/RecordKeyKind.hpp b/include/mrdocs/Metadata/Info/RecordKeyKind.hpp
new file mode 100644
index 000000000..c48726341
--- /dev/null
+++ b/include/mrdocs/Metadata/Info/RecordKeyKind.hpp
@@ -0,0 +1,49 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2023 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_INFO_RECORDKEYKIND_HPP
+#define MRDOCS_API_METADATA_INFO_RECORDKEYKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+#include <string>
+
+namespace clang::mrdocs {
+
+/** The kind of record: struct, class, or union.
+*/
+enum class RecordKeyKind
+{
+    /// A struct.
+    Struct,
+    /// A C++ class.
+    Class,
+    /// A C-style Union
+    Union
+};
+
+MRDOCS_DECL
+dom::String
+toString(RecordKeyKind kind) noexcept;
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    RecordKeyKind kind)
+{
+    v = toString(kind);
+}
+
+} // clang::mrdocs
+
+#endif // MRDOCS_API_METADATA_INFO_RECORDKEYKIND_HPP
diff --git a/include/mrdocs/Metadata/Info/RecordTranche.hpp b/include/mrdocs/Metadata/Info/RecordTranche.hpp
new file mode 100644
index 000000000..c83b87b1f
--- /dev/null
+++ b/include/mrdocs/Metadata/Info/RecordTranche.hpp
@@ -0,0 +1,121 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_INFO_RECORDTRANCHE_HPP
+#define MRDOCS_API_METADATA_INFO_RECORDTRANCHE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom/LazyArray.hpp>
+#include <mrdocs/Dom/LazyObject.hpp>
+#include <mrdocs/Metadata/Info/SymbolID.hpp>
+#include <vector>
+
+namespace clang::mrdocs {
+
+/** A group of members that have the same access specifier.
+
+    This struct represents a collection of symbols that share
+    the same access specifier within a record.
+
+    It includes one vector for each info type allowed in a
+    record, and individual vectors for static functions, types,
+    and function overloads.
+*/
+struct RecordTranche
+{
+    std::vector<SymbolID> NamespaceAliases;
+    std::vector<SymbolID> Typedefs;
+    std::vector<SymbolID> Records;
+    std::vector<SymbolID> Enums;
+    std::vector<SymbolID> Functions;
+    std::vector<SymbolID> StaticFunctions;
+    std::vector<SymbolID> Variables;
+    std::vector<SymbolID> StaticVariables;
+    std::vector<SymbolID> Concepts;
+    std::vector<SymbolID> Guides;
+    std::vector<SymbolID> Usings;
+};
+
+MRDOCS_DECL
+void
+merge(RecordTranche& I, RecordTranche&& Other);
+
+inline
+auto
+allMembers(RecordTranche const& T)
+{
+    // This is a trick to emulate views::concat in C++20
+    return std::views::transform(
+        std::views::iota(0, 11),
+        [&T](int const i) -> auto const&
+        {
+            switch (i) {
+                case 0: return T.NamespaceAliases;
+                case 1: return T.Typedefs;
+                case 2: return T.Records;
+                case 3: return T.Enums;
+                case 4: return T.Functions;
+                case 5: return T.StaticFunctions;
+                case 6: return T.Variables;
+                case 7: return T.StaticVariables;
+                case 8: return T.Concepts;
+                case 9: return T.Guides;
+                case 10: return T.Usings;
+                default: throw std::out_of_range("Invalid index");
+            }
+        }
+    ) | std::ranges::views::join;
+}
+
+/** Map a RecordTranche to a dom::Object.
+
+    @param io The output parameter to receive the dom::Object.
+    @param I The RecordTranche to convert.
+    @param domCorpus The DomCorpus used to resolve references.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag,
+    IO& io,
+    RecordTranche const& I,
+    DomCorpus const* domCorpus)
+{
+    io.map("namespaceAliases", dom::LazyArray(I.NamespaceAliases, domCorpus));
+    io.map("typedefs", dom::LazyArray(I.Typedefs, domCorpus));
+    io.map("records", dom::LazyArray(I.Records, domCorpus));
+    io.map("enums", dom::LazyArray(I.Enums, domCorpus));
+    io.map("functions", dom::LazyArray(I.Functions, domCorpus));
+    io.map("staticFunctions", dom::LazyArray(I.StaticFunctions, domCorpus));
+    io.map("variables", dom::LazyArray(I.Variables, domCorpus));
+    io.map("staticVariables", dom::LazyArray(I.StaticVariables, domCorpus));
+    io.map("concepts", dom::LazyArray(I.Concepts, domCorpus));
+    io.map("guides", dom::LazyArray(I.Guides, domCorpus));
+    io.map("usings", dom::LazyArray(I.Usings, domCorpus));
+}
+
+/** Map the RecordTranche to a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    RecordTranche const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+
+} // clang::mrdocs
+
+#endif // MRDOCS_API_METADATA_INFO_RECORDTRANCHE_HPP
diff --git a/include/mrdocs/Metadata/Source.hpp b/include/mrdocs/Metadata/Info/Source.hpp
similarity index 97%
rename from include/mrdocs/Metadata/Source.hpp
rename to include/mrdocs/Metadata/Info/Source.hpp
index 737f2433e..8e4f75d01 100644
--- a/include/mrdocs/Metadata/Source.hpp
+++ b/include/mrdocs/Metadata/Info/Source.hpp
@@ -10,8 +10,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_SOURCE_HPP
-#define MRDOCS_API_METADATA_SOURCE_HPP
+#ifndef MRDOCS_API_METADATA_INFO_SOURCE_HPP
+#define MRDOCS_API_METADATA_INFO_SOURCE_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Optional.hpp>
@@ -197,4 +197,4 @@ tag_invoke(
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_INFO_SOURCE_HPP
diff --git a/include/mrdocs/Metadata/SymbolID.hpp b/include/mrdocs/Metadata/Info/SymbolID.hpp
similarity index 97%
rename from include/mrdocs/Metadata/SymbolID.hpp
rename to include/mrdocs/Metadata/Info/SymbolID.hpp
index 9f28a188c..6d5380930 100644
--- a/include/mrdocs/Metadata/SymbolID.hpp
+++ b/include/mrdocs/Metadata/Info/SymbolID.hpp
@@ -10,17 +10,17 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_SYMBOLID_HPP
-#define MRDOCS_API_METADATA_SYMBOLID_HPP
+#ifndef MRDOCS_API_METADATA_INFO_SYMBOLID_HPP
+#define MRDOCS_API_METADATA_INFO_SYMBOLID_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Optional.hpp>
+#include <compare>
 #include <cstdint>
 #include <cstring>
-#include <compare>
-#include <string_view>
-#include <string>
 #include <memory>
+#include <string>
+#include <string_view>
 
 namespace clang::mrdocs {
 class DomCorpus;
@@ -227,4 +227,4 @@ struct std::hash<clang::mrdocs::SymbolID>
     }
 };
 
-#endif
+#endif // MRDOCS_API_METADATA_INFO_SYMBOLID_HPP
diff --git a/include/mrdocs/Metadata/Info/Typedef.hpp b/include/mrdocs/Metadata/Info/Typedef.hpp
index 96431d1cc..8ff148635 100644
--- a/include/mrdocs/Metadata/Info/Typedef.hpp
+++ b/include/mrdocs/Metadata/Info/Typedef.hpp
@@ -10,14 +10,14 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_TYPEDEF_HPP
-#define MRDOCS_API_METADATA_TYPEDEF_HPP
+#ifndef MRDOCS_API_METADATA_INFO_TYPEDEF_HPP
+#define MRDOCS_API_METADATA_INFO_TYPEDEF_HPP
 
+#include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Metadata/Info.hpp>
+#include <mrdocs/Metadata/Name.hpp>
 #include <mrdocs/Metadata/Template.hpp>
 #include <mrdocs/Metadata/Type.hpp>
-#include <mrdocs/Metadata/Name.hpp>
-#include <mrdocs/ADT/Polymorphic.hpp>
 
 namespace clang::mrdocs {
 
@@ -25,7 +25,7 @@ namespace clang::mrdocs {
 struct TypedefInfo final
     : InfoCommonBase<InfoKind::Typedef>
 {
-    Polymorphic<TypeInfo> Type = std::nullopt;
+    Optional<Polymorphic<TypeInfo>> Type = std::nullopt;
 
     /** Indicates if this is a new C++ "using"-style typedef
 
@@ -99,4 +99,4 @@ tag_invoke(
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_INFO_TYPEDEF_HPP
diff --git a/include/mrdocs/Metadata/Info/Using.hpp b/include/mrdocs/Metadata/Info/Using.hpp
index 5308b000d..d2a2d01b6 100644
--- a/include/mrdocs/Metadata/Info/Using.hpp
+++ b/include/mrdocs/Metadata/Info/Using.hpp
@@ -8,15 +8,15 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_USING_HPP
-#define MRDOCS_API_METADATA_USING_HPP
+#ifndef MRDOCS_API_METADATA_INFO_USING_HPP
+#define MRDOCS_API_METADATA_INFO_USING_HPP
 
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom/LazyArray.hpp>
 #include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/Source.hpp>
-#include <mrdocs/Metadata/Type.hpp>
+#include <mrdocs/Metadata/Info/Source.hpp>
 #include <mrdocs/Metadata/Name.hpp>
-#include <mrdocs/Dom/LazyArray.hpp>
+#include <mrdocs/Metadata/Type.hpp>
 #include <vector>
 
 namespace clang::mrdocs {
@@ -98,7 +98,7 @@ struct UsingInfo final
         Note that this can be a qualified name, such as
         `A::f` in the example above.
      */
-    Polymorphic<NameInfo> IntroducedName;
+    Polymorphic<NameInfo> IntroducedName = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
 
     /** The shadow declarations.
 
@@ -176,4 +176,4 @@ tag_invoke(
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_INFO_USING_HPP
diff --git a/include/mrdocs/Metadata/Info/Variable.hpp b/include/mrdocs/Metadata/Info/Variable.hpp
index 973e0a5a5..5f9b8b5a3 100644
--- a/include/mrdocs/Metadata/Info/Variable.hpp
+++ b/include/mrdocs/Metadata/Info/Variable.hpp
@@ -9,16 +9,16 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_VARIABLE_HPP
-#define MRDOCS_API_METADATA_VARIABLE_HPP
+#ifndef MRDOCS_API_METADATA_INFO_VARIABLE_HPP
+#define MRDOCS_API_METADATA_INFO_VARIABLE_HPP
 
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Dom/LazyArray.hpp>
 #include <mrdocs/Metadata/Expression.hpp>
-#include <mrdocs/Metadata/Source.hpp>
-#include <mrdocs/Metadata/Template.hpp>
 #include <mrdocs/Metadata/Info.hpp>
+#include <mrdocs/Metadata/Info/Source.hpp>
+#include <mrdocs/Metadata/Template.hpp>
 #include <mrdocs/Metadata/Type.hpp>
-#include <mrdocs/Dom/LazyArray.hpp>
-#include <mrdocs/ADT/Polymorphic.hpp>
 
 namespace clang::mrdocs {
 
@@ -31,7 +31,7 @@ struct VariableInfo final
     : InfoCommonBase<InfoKind::Variable>
 {
     /** The type of the variable */
-    Polymorphic<TypeInfo> Type = std::nullopt;
+    Optional<Polymorphic<TypeInfo>> Type = std::nullopt;
 
     std::optional<TemplateInfo> Template;
 
@@ -148,4 +148,4 @@ tag_invoke(
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_INFO_VARIABLE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc.hpp b/include/mrdocs/Metadata/Javadoc.hpp
index c927c06d7..63bf2ace7 100644
--- a/include/mrdocs/Metadata/Javadoc.hpp
+++ b/include/mrdocs/Metadata/Javadoc.hpp
@@ -13,1852 +13,39 @@
 #ifndef MRDOCS_API_METADATA_JAVADOC_HPP
 #define MRDOCS_API_METADATA_JAVADOC_HPP
 
-#include <algorithm>
-#include <memory>
-#include <mrdocs/ADT/Polymorphic.hpp>
-#include <mrdocs/Dom/LazyArray.hpp>
-#include <mrdocs/Dom/LazyObject.hpp>
-#include <mrdocs/Dom/String.hpp>
-#include <mrdocs/Metadata/SymbolID.hpp>
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Support/Concepts.hpp>
-#include <mrdocs/Support/Visitor.hpp>
-#include <string>
-#include <type_traits>
-#include <utility>
-#include <vector>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/Javadoc/Node.hpp>
 
 namespace clang::mrdocs {
 
-/** Javadoc related types and functions.
-
-    Javadoc is a documentation generator originally
-    created for the Java language from source code.
-
-    The Javadoc documentation generator tool can interpret
-    text in the "doc comments" format included
-    directly in the source code.
-
-    The same "doc comments" format has been replicated
-    and extended by documentation systems for other
-    languages, including the cross-language Doxygen
-    and the JSDoc system for JavaScript.
-
-    Because Clang can already parse and extract
-    blocks of Javadoc-style comments from source
-    code, these classes are used to represent the
-    parsed documentation in a structured form.
-
-    @see https://en.wikipedia.org/wiki/Javadoc
-    @see https://www.doxygen.nl
-
- */
-namespace doc {
-
-struct Node;
-
-/** The kind of node.
-
-    This includes tags and block types.
-
-    Some of the available tags are:
-
-    @li `@author Author Name`
-    @li `{@docRoot}`
-    @li `@version version`
-    @li `@since since-text `
-    @li `@see reference`
-    @li `@param name description`
-    @li `@return description`
-    @li `@exception classname description`
-    @li `@throws classname description`
-    @li `@deprecated description`
-    @li `{@inheritDoc}`
-    @li `{@link reference}`
-    @li `{@linkplain reference}`
-    @li `{@value #STATIC_FIELD}`
-    @li `{@code literal}`
-    @li `{@literal literal}`
-    @li `{@serial literal}`
-    @li `{@serialData literal}`
-    @li `{@serialField literal}`
-
-    Doxygen also introduces a number of additional tags on top
-    of the the doc comment specification.
-
-    @note When a new tag is added, the `visit` function overloads
-    must be updated to handle the new tag.
-
-    @see https://en.wikipedia.org/wiki/Javadoc[Javadoc - Wikipedia]
-    @see https://docs.oracle.com/javase/1.5.0/docs/tooldocs/solaris/javadoc.html[Javadoc Documentation]
-    @see https://docs.oracle.com/en/java/javase/13/docs/specs/javadoc/doc-comment-spec.html[Doc Comment Specification]
-    @see https://www.oracle.com/java/technologies/javase/javadoc-tool.html[Javadoc Tool]
-    @see https://www.oracle.com/technical-resources/articles/java/javadoc-tool.html[How to Write Doc Comments]
-    @see https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html[Javadoc Package]
-    @see https://web.archive.org/web/20170714215721/http://agile.csc.ncsu.edu:80/SEMaterials/tutorials/javadoc[Javadoc Tutorial]
-    @see https://en.wikipedia.org/wiki/Doxygen[Doxygen - Wikipedia]
-    @see https://www.doxygen.nl/manual/commands.html[Doxygen Special Tags]
-
- */
-enum class NodeKind
-{
-    // VFALCO Don't forget to update
-    // Node::isText() and Node::isBlock()
-    // when changing this enum!
-
-    /// A text tag
-    text = 1, // needed by bitstream
-    /// An admonition tag
-    admonition,
-    /// A brief tag
-    brief,
-    /// A code tag
-    code,
-    /// A heading tag
-    heading,
-    /// A link tag
-    link,
-    /// A list_item tag
-    list_item,
-    /// An unordered_list tag
-    unordered_list,
-    /// A paragraph tag
-    paragraph,
-    /// A param tag
-    param,
-    /// A returns tag
-    returns,
-    /// A styled tag
-    styled,
-    /// A tparam tag
-    tparam,
-    /// A reference tag
-    reference,
-    /// A copy_details tag
-    copy_details,
-    /// A throws tag
-    throws,
-    /// A details tag
-    details,
-    /// A see tag
-    see,
-    /// A general tag.
-    precondition,
-    /// A postcondition tag.
-    postcondition
-};
-
-/** Return the name of the NodeKind as a string.
- */
-MRDOCS_DECL
-dom::String
-toString(NodeKind kind) noexcept;
-
-/** Return the NodeKind from a @ref dom::Value string.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    NodeKind const kind)
-{
-    v = toString(kind);
-}
-
-/** The text style.
-*/
-enum class Style
-{
-    /// No style
-    none = 1, // needed by bitstream
-    /// Monospaced text
-    mono,
-    /// Bold text
-    bold,
-    /// Italic text
-    italic
-};
-
-/** Return the name of the @ref Style as a string.
-
-    @param kind The style kind.
-    @return The string representation of the style.
- */
-MRDOCS_DECL
-dom::String
-toString(Style kind) noexcept;
-
-/** Return the @ref Style from a @ref dom::Value string.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Style const kind)
-{
-    v = toString(kind);
-}
-
-/** An admonishment style.
-*/
-enum class Admonish
-{
-    /// No admonishment
-    none = 1, // needed by bitstream
-    /// A general note
-    note,
-    /// A tip to the reader
-    tip,
-    /// Something important
-    important,
-    /// A caution admonishment
-    caution,
-    /// A warning admonishment
-    warning
-};
-
-/** Return the name of the Admonish as a string.
- */
-MRDOCS_DECL
-dom::String
-toString(Admonish kind) noexcept;
-
-/** Return the Admonish from a @ref dom::Value string.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Admonish const kind)
-{
-    v = toString(kind);
-}
-
-
-/** Parameter pass direction.
-*/
-enum class ParamDirection
-{
-    /// No direction specified
-    none,
-    /// Parameter is passed
-    in,
-    /// Parameter is passed back to the caller
-    out,
-    /// Parameter is passed and passed back to the caller
-    inout
-};
-
-/** Return the name of the ParamDirection as a string.
- */
-MRDOCS_DECL
-dom::String
-toString(ParamDirection kind) noexcept;
-
-/** Return the ParamDirection from a @ref dom::Value string.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    ParamDirection const kind)
-{
-    v = toString(kind);
-}
-
-/** Which parts of the documentation to copy.
-
-    @li `all`: copy the brief and the description.
-    @li `brief`: only copy the brief.
-    @li `description`: only copy the description.
-*/
-enum class Parts
-{
-    /// Copy the brief and the description
-    all = 1, // needed by bitstream
-    /// Copy the brief
-    brief,
-    /// Copy the description
-    description
-};
-
-/** Return the name of the Parts as a string.
- */
-MRDOCS_DECL
-dom::String
-toString(Parts kind) noexcept;
-
-/** Return the Parts from a @ref dom::Value string.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Parts const kind)
-{
-    v = toString(kind);
-}
-
-//--------------------------------------------
-
-/** This is a variant-like list element.
-
-    There are two types of nodes: text and block.
-
-    - The javadoc is a list of blocks.
-    - A block contains a list of text elements.
-    - A text element contains a string.
-*/
-struct MRDOCS_DECL
-    Node
-{
-    NodeKind Kind;
-
-    virtual ~Node() = default;
-
-    explicit Node(NodeKind const kind_) noexcept
-        : Kind(kind_)
-    {
-    }
-
-    virtual bool isBlock() const noexcept = 0;
-
-    bool isText() const noexcept
-    {
-        return ! isBlock();
-    }
-
-    auto operator<=>(Node const&) const = default;
-    bool operator==(Node const&)const noexcept = default;
-    virtual bool equals(Node const& other) const noexcept
-    {
-        return Kind == other.Kind;
-    }
-};
-
-/** Map the @ref Node to a @ref dom::Object.
-
-    @param io The output parameter to receive the dom::Object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag,
-    IO& io,
-    Node const& I,
-    DomCorpus const* domCorpus)
-{
-    MRDOCS_ASSERT(domCorpus);
-    io.map("kind", I.Kind);
-}
-
-/** Return the @ref Node as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Node const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-/** Map the Polymorphic Node as a @ref dom::Value object.
-
-    @param io The output parameter to receive the dom::Object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO, polymorphic_storage_for<Node> NodeTy>
-void
-tag_invoke(
-    dom::ValueFromTag,
-    IO& io,
-    NodeTy const& I,
-    DomCorpus const* domCorpus)
-{
-    visit(*I, [&](auto const& U)
-    {
-        tag_invoke(
-            dom::ValueFromTag{},
-            io,
-            U,
-            domCorpus);
-    });
-}
-
-//------------------------------------------------
-//
-// Text nodes
-//
-//------------------------------------------------
-
-/** A Node containing a string of text.
-
-    There will be no newlines in the text. Otherwise,
-    this would be represented as multiple text nodes
-    within a Paragraph node.
-*/
-struct Text : Node
-{
-    std::string string;
-
-    static constexpr auto static_kind = NodeKind::text;
-
-    explicit
-    Text(
-        std::string string_ = std::string()) noexcept
-        : Node(NodeKind::text)
-        , string(std::move(string_))
-    {
-    }
-
-    bool
-    isBlock() const noexcept final
-    {
-        return false;
-    }
-
-    auto operator<=>(Text const&) const = default;
-    bool operator==(Text const&) const noexcept = default;
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Text const&>(other);
-    }
-
-protected:
-    Text(
-        std::string string_,
-        NodeKind kind_)
-        : Node(kind_)
-        , string(std::move(string_))
-    {
-    }
-};
-
-/** Map the @ref Text to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Text const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Node const&>(I), domCorpus);
-    io.map("string", I.string);
-}
-
-/** Return the @ref Text as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Text const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-MRDOCS_DECL
-std::strong_ordering
-operator<=>(Polymorphic<Text> const& lhs, Polymorphic<Text> const& rhs);
-
-inline
-bool
-operator==(Polymorphic<Text> const& lhs, Polymorphic<Text> const& rhs) {
-    return std::is_eq(lhs <=> rhs);
-}
-
-/** A piece of styled text.
-*/
-struct Styled final : Text
-{
-    Style style;
-
-    static constexpr auto static_kind = NodeKind::styled;
-
-    Styled(
-        std::string string_ = std::string(),
-        Style style_ = Style::none) noexcept
-        : Text(std::move(string_), NodeKind::styled)
-        , style(style_)
-    {
-    }
-
-    auto operator<=>(Styled const&) const = default;
-    bool operator==(Styled const&) const noexcept = default;
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Styled const&>(other);
-    }
-};
-
-/** Map the @ref Styled to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Styled const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Text const&>(I), domCorpus);
-    io.map("style", I.style);
-}
-
-/** Return the @ref Styled as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Styled const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
+/** A processed documentation comment attached to a declaration.
 
+    A complete documentation comment consists of a
+    sequence of text blocks.
 
-/** A hyperlink.
-*/
-struct Link final : Text
-{
-    std::string href;
+    Some blocks are used to contain regular text,
+    such as paragraphs and lists. These are
+    analogous to markdown blocks.
 
-    static constexpr auto static_kind = NodeKind::link;
+    Other blocks contain metadata about the declaration,
+    such as parameters and return values. These
+    blocks are stored separately in the
+    @ref Javadoc structure.
 
-    explicit
-    Link(
-        std::string string_ = std::string(),
-        std::string href_ = std::string()) noexcept
-        : Text(std::move(string_), NodeKind::link)
-        , href(std::move(href_))
-    {
-    }
+    Each block in the document might contain:
 
-    auto operator<=>(Link const&) const = default;
-    bool operator==(Link const&) const noexcept = default;
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Link const&>(other);
-    }
-};
+    - No other blocks (leaf blocks)
+    - Other blocks (container blocks: e.g. lists)
 
-/** Map the @ref Link to a @ref dom::Object.
+    When they contain no other blocks, they might be:
 
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Link const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Text const&>(I), domCorpus);
-    io.map("href", I.href);
-}
+    - Inlines only (e.g. paragraphs)
+    - No inlines (e.g. horizontal rule)
 
-/** Return the @ref Link as a @ref dom::Value object.
+    Inline content elements contain other inlines
+    but cannot contain blocks.
  */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Link const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-/** A reference to a symbol.
-*/
-struct Reference : Text
-{
-    SymbolID id = SymbolID::invalid;
-
-    static constexpr auto static_kind = NodeKind::reference;
-
-    explicit
-    Reference(
-        std::string string_ = std::string()) noexcept
-        : Text(std::move(string_), NodeKind::reference)
-    {
-    }
-
-    auto operator<=>(Reference const&) const = default;
-    bool operator==(Reference const&) const noexcept = default;
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Reference const&>(other);
-    }
-
-protected:
-    Reference(
-        std::string string_,
-        NodeKind const kind_) noexcept
-        : Text(std::move(string_), kind_)
-    {
-    }
-};
-
-/** Map the @ref Reference to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Reference const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Text const&>(I), domCorpus);
-    io.map("symbol", I.id);
-}
-
-/** Return the @ref Reference as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Reference const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-/** Documentation copied from another symbol.
-*/
-struct CopyDetails final : Reference
-{
-    static constexpr auto static_kind = NodeKind::copy_details;
-
-    CopyDetails(std::string string_ = std::string()) noexcept
-        : Reference(std::move(string_), NodeKind::copy_details)
-    {
-    }
-
-    auto operator<=>(CopyDetails const&) const = default;
-    bool operator==(CopyDetails const&) const noexcept = default;
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<CopyDetails const&>(other);
-    }
-};
-
-/** Map the @ref CopyDetails to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    CopyDetails const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Reference const&>(I), domCorpus);
-}
-
-/** Return the @ref CopyDetails as a @ref dom::Value object.
-
-    @param v The output value.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    CopyDetails const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-//------------------------------------------------
-//
-// Block nodes
-//
-//------------------------------------------------
-
-/** A piece of block content
-
-    The top level is a list of blocks.
-
-    There are two types of blocks: headings and paragraphs
-*/
-struct MRDOCS_DECL
-    Block : Node
-{
-    std::vector<Polymorphic<Text>> children;
-
-    bool isBlock() const noexcept final
-    {
-        return true;
-    }
-
-    bool empty() const noexcept
-    {
-        return children.empty();
-    }
-
-    auto operator<=>(Block const& other) const {
-        if (auto const cmp = children.size() <=> other.children.size();
-            !std::is_eq(cmp))
-        {
-            return cmp;
-        }
-        for (std::size_t i = 0; i < children.size(); ++i)
-        {
-            if (auto const cmp = *children[i] <=> *other.children[i];
-                !std::is_eq(cmp))
-            {
-                return cmp;
-            }
-        }
-        return std::strong_ordering::equal;
-    }
-
-    bool operator==(Block const& other) const noexcept
-    {
-        if (Kind != other.Kind)
-        {
-            return false;
-        }
-        return std::ranges::
-            equal(children, other.children,
-            [](auto const& a, auto const& b)
-            {
-                return a->equals(*b);
-            });
-    }
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Block const&>(other);
-    }
-
-    template<std::derived_from<Text> T>
-    T& emplace_back(T&& text)
-    {
-        return static_cast<T&>(emplace_back(
-            std::make_unique<T>(std::forward<T>(text))));
-    }
-
-    void append(std::vector<Polymorphic<Node>>&& blocks);
-
-    void append(std::vector<Polymorphic<Text>> const& otherChildren);
-
-protected:
-    explicit
-    Block(
-        NodeKind const kind_,
-        std::vector<Polymorphic<Text>> children_ = {}) noexcept
-        : Node(kind_)
-        , children(std::move(children_))
-    {
-    }
-
-private:
-    Text& emplace_back(Polymorphic<Text> text);
-};
-
-/** Map the @ref Block to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Block const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Node const&>(I), domCorpus);
-    io.defer("children", [&I, domCorpus] {
-        return dom::LazyArray(I.children, domCorpus);
-    });
-}
-
-/** Return the @ref Block as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Block const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-/** A manually specified section heading.
-*/
-struct Heading final : Block
-{
-    static constexpr auto static_kind = NodeKind::heading;
-
-    std::string string;
-
-    Heading(
-        std::string string_ = std::string()) noexcept
-        : Block(NodeKind::heading)
-        , string(std::move(string_))
-    {
-    }
-
-    auto operator<=>(Heading const&) const = default;
-    bool operator==(Heading const&) const noexcept = default;
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Heading const&>(other);
-    }
-};
-
-/** Map the @ref Heading to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Heading const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
-    io.map("string", I.string);
-}
-
-/** Return the @ref Heading as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Heading const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-/** A sequence of text nodes.
-*/
-struct Paragraph : Block
-{
-    static constexpr auto static_kind = NodeKind::paragraph;
-
-    Paragraph() noexcept : Block(NodeKind::paragraph) {}
-
-    virtual
-    Paragraph&
-    operator=(std::string_view str);
-
-    auto operator<=>(Paragraph const&) const = default;
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Paragraph const&>(other);
-    }
-
-protected:
-    explicit
-    Paragraph(
-        NodeKind const kind,
-        std::vector<Polymorphic<Text>> children_ = {}) noexcept
-        : Block(kind, std::move(children_))
-    {
-    }
-};
-
-/** Map the @ref Paragraph to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Paragraph const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
-}
-
-/** Return the @ref Paragraph as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Paragraph const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-
-/** The brief description
-*/
-struct Brief final : Paragraph
-{
-    static constexpr NodeKind static_kind = NodeKind::brief;
-
-    std::vector<std::string> copiedFrom;
-
-    Brief() noexcept
-        : Paragraph(NodeKind::brief)
-    {
-    }
-
-    explicit
-    Brief(std::string_view const text)
-        : Brief()
-    {
-        operator=(text);
-    }
-
-    Brief(Brief const& other) = default;
-
-    Brief&
-    operator=(Brief const& other) = default;
-
-    Brief&
-    operator=(std::string_view const text) override
-    {
-        Paragraph::operator=(text);
-        return *this;
-    }
-
-    auto operator<=>(Brief const&) const = default;
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Brief const&>(other);
-    }
-};
-
-/** Map the @ref Brief to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Brief const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
-}
-
-/** Return the @ref Brief as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Brief const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-/** An admonition.
-
-    This paragraph represents an admonition, such as
-    a note, tip, important, caution, or warning.
-
-*/
-struct Admonition final : Paragraph
-{
-    Admonish admonish;
-
-    explicit
-    Admonition(
-        Admonish const admonish_ = Admonish::none) noexcept
-        : Paragraph(NodeKind::admonition)
-        , admonish(admonish_)
-    {
-    }
-
-    using Paragraph::operator=;
-
-    auto operator<=>(Admonition const&) const = default;
-
-    bool operator==(Admonition const&) const noexcept = default;
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Admonition const&>(other);
-    }
-};
-
-/** Map the @ref Admonition to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Admonition const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
-    io.map("admonish", I.admonish);
-}
-
-/** Return the @ref Admonition as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Admonition const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-/** Preformatted source code.
-*/
-struct Code final : Paragraph
-{
-    // VFALCO we can add a language (e.g., C++),
-    //        then emit attributes in the generator.
-
-    static constexpr auto static_kind = NodeKind::code;
-
-    Code() noexcept
-        : Paragraph(NodeKind::code)
-    {
-    }
-
-    using Paragraph::operator=;
-    auto operator<=>(Code const&) const = default;
-    bool operator==(Code const&) const noexcept = default;
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Code const&>(other);
-    }
-};
-
-/** Map the @ref Code to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Code const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
-}
-
-/** Return the @ref Code as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Code const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-/** An item in a list
-*/
-struct ListItem final : Paragraph
-{
-    static constexpr auto static_kind = NodeKind::list_item;
-
-    ListItem()
-        : Paragraph(static_kind)
-    {}
-
-    using Paragraph::operator=;
-
-    auto operator<=>(ListItem const&) const = default;
-    bool
-    operator==(ListItem const&) const noexcept = default;
-
-    bool
-    equals(Node const& other) const noexcept override
-    {
-        auto* p = dynamic_cast<ListItem const*>(&other);
-        if (!p)
-        {
-            return false;
-        }
-        if (this == &other)
-        {
-            return true;
-        }
-        return *this == *p;
-    }
-};
-
-/** Map the @ref ListItem to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    ListItem const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
-}
-
-/** Return the @ref ListItem as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    ListItem const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-/** A list of list items
-*/
-struct UnorderedList final : Paragraph
-{
-    static constexpr auto static_kind = NodeKind::unordered_list;
-
-    std::vector<ListItem> items;
-
-    UnorderedList()
-        : Paragraph(static_kind)
-    {
-    }
-
-    using Paragraph::operator=;
-
-    auto operator<=>(UnorderedList const& other) const {
-        if (auto const cmp = items.size() <=> other.items.size();
-            !std::is_eq(cmp))
-        {
-            return cmp;
-        }
-        for (std::size_t i = 0; i < items.size(); ++i)
-        {
-            if (auto const cmp = items[i] <=> other.items[i];
-                !std::is_eq(cmp))
-            {
-                return cmp;
-            }
-        }
-        return std::strong_ordering::equal;
-    }
-
-    bool
-    operator==(UnorderedList const&) const noexcept = default;
-
-    bool
-    equals(Node const& other) const noexcept override
-    {
-        auto* p = dynamic_cast<UnorderedList const*>(&other);
-        if (!p)
-        {
-            return false;
-        }
-        if (this == &other)
-        {
-            return true;
-        }
-        return *this == *p;
-    }
-};
-
-/** Map the @ref UnorderedList to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    UnorderedList const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
-    io.defer("items", [&I, domCorpus] {
-        return dom::LazyArray(I.items, domCorpus);
-    });
-}
-
-/** Return the @ref UnorderedList as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    UnorderedList const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-/** A @see paragraph
-*/
-struct See final : Paragraph
-{
-    static constexpr auto static_kind = NodeKind::see;
-
-    See()
-        : Paragraph(static_kind)
-    {
-    }
-
-    using Paragraph::operator=;
-
-    auto operator<=>(See const&) const = default;
-
-    bool operator==(See const&)
-        const noexcept = default;
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<See const&>(other);
-    }
-};
-
-/** Map the @ref See to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    See const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
-}
-
-/** Return the @ref See as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    See const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-/** Documentation for a function parameter
-*/
-struct Param final : Paragraph
-{
-    std::string name;
-    ParamDirection direction;
-
-    static constexpr auto static_kind = NodeKind::param;
-
-    Param(
-        std::string name_ = std::string(),
-        Paragraph details_ = Paragraph(),
-        ParamDirection const direction_ = ParamDirection::none)
-        : Paragraph(
-            NodeKind::param,
-            std::move(details_.children))
-        , name(std::move(name_))
-        , direction(direction_)
-    {
-    }
-
-    explicit
-    Param(
-        std::string_view const name,
-        std::string_view const text)
-    : Param()
-    {
-        this->name = name;
-        this->operator=(text);
-    }
-
-    explicit
-    Param(Paragraph const& other)
-        : Param()
-    {
-        children = other.children;
-    }
-
-    Param&
-    operator=(std::string_view const text) override
-    {
-        Paragraph::operator=(text);
-        return *this;
-    }
-
-    auto operator<=>(Param const&) const = default;
-
-    bool operator==(Param const&)
-        const noexcept = default;
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Param const&>(other);
-    }
-};
-
-/** Map the @ref Param to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Param const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
-    io.map("name", I.name);
-    io.map("direction", I.direction);
-}
-
-/** Return the @ref Param as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Param const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-/** Documentation for a function return type
-*/
-struct Returns final : Paragraph
-{
-    static constexpr NodeKind static_kind = NodeKind::returns;
-
-    Returns()
-        : Paragraph(NodeKind::returns)
-    {
-    }
-
-    explicit
-    Returns(std::string_view const text)
-        : Returns()
-    {
-        operator=(text);
-    }
-
-    explicit
-    Returns(Paragraph const& other)
-        : Returns()
-    {
-        children = other.children;
-    }
-
-    Returns&
-    operator=(std::string_view const text) override
-    {
-        Paragraph::operator=(text);
-        return *this;
-    }
-
-    auto operator<=>(Returns const&) const = default;
-
-    bool operator==(Returns const&)
-        const noexcept = default;
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Returns const&>(other);
-    }
-};
-
-/** Map the @ref Returns to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Returns const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
-}
-
-/** Return the @ref Returns as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Returns const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-/** Documentation for a template parameter
-*/
-struct TParam final : Paragraph
-{
-    std::string name;
-
-    static constexpr NodeKind static_kind = NodeKind::tparam;
-
-    TParam()
-        : Paragraph(NodeKind::tparam)
-    {
-    }
-
-    using Paragraph::operator=;
-
-    auto operator<=>(TParam const&) const = default;
-    bool operator==(TParam const&) const noexcept = default;
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<TParam const&>(other);
-    }
-};
-
-/** Map the @ref TParam to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    TParam const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
-    io.map("name", I.name);
-}
-
-/** Return the @ref TParam as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    TParam const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-/** Documentation for a function parameter
-*/
-struct Throws final : Paragraph
-{
-    Reference exception;
-
-    static constexpr NodeKind static_kind = NodeKind::throws;
-
-    Throws(
-        std::string exception_ = std::string(),
-        Paragraph details_ = Paragraph())
-        : Paragraph(
-            NodeKind::throws,
-            std::move(details_.children))
-        , exception(std::move(exception_))
-    {
-    }
-
-    using Paragraph::operator=;
-
-    auto operator<=>(Throws const&) const = default;
-
-    bool operator==(Throws const&)
-        const noexcept = default;
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Throws const&>(other);
-    }
-};
-
-/** Map the @ref Throws to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Throws const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
-    io.map("exception", I.exception);
-}
-
-/** Return the @ref Throws as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Throws const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-struct Precondition final : Paragraph
-{
-    static constexpr NodeKind static_kind = NodeKind::precondition;
-
-    Precondition(
-        Paragraph details_ = Paragraph())
-        : Paragraph(
-            NodeKind::precondition,
-            std::move(details_.children))
-    {
-    }
-
-    using Paragraph::operator=;
-
-    auto operator<=>(Precondition const&) const = default;
-
-    bool operator==(Precondition const&)
-        const noexcept = default;
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Precondition const&>(other);
-    }
-};
-
-/** Map the @ref Precondition to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Precondition const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
-}
-
-/** Return the @ref Precondition as a @ref dom::Value object.
-
-    @param v The value to assign to.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Precondition const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-struct Postcondition : Paragraph
-{
-    static constexpr auto static_kind = NodeKind::postcondition;
-
-    Postcondition(
-        Paragraph details_ = Paragraph())
-        : Paragraph(
-            NodeKind::postcondition,
-            std::move(details_.children))
-    {
-    }
-
-    using Paragraph::operator=;
-
-    auto operator<=>(Postcondition const&) const = default;
-
-    bool operator==(Postcondition const&)
-        const noexcept = default;
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Postcondition const&>(other);
-    }
-};
-
-/** Map the @ref Postcondition to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Postcondition const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
-}
-
-/** Return the @ref Postcondition as a @ref dom::Value object.
-
-    @param v The value to assign to.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Postcondition const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-//------------------------------------------------
-
-/** Visit a node.
-
-    @param node The node to visit.
-    @param fn The function to call for each node.
-    @param args Additional arguments to pass to the function.
-    @return The result of calling the function.
- */
-template<
-    class NodeTy,
-    class Fn,
-    class... Args>
-    requires std::derived_from<NodeTy, Node>
-decltype(auto)
-visit(
-    NodeTy& node,
-    Fn&& fn,
-    Args&&... args)
-{
-    auto visitor = makeVisitor<Node>(
-        node, std::forward<Fn>(fn),
-        std::forward<Args>(args)...);
-    switch(node.Kind)
-    {
-    case NodeKind::admonition:
-        return visitor.template visit<Admonition>();
-    case NodeKind::brief:
-        return visitor.template visit<Brief>();
-    case NodeKind::code:
-        return visitor.template visit<Code>();
-    case NodeKind::heading:
-        return visitor.template visit<Heading>();
-    case NodeKind::paragraph:
-        return visitor.template visit<Paragraph>();
-    case NodeKind::link:
-        return visitor.template visit<Link>();
-    case NodeKind::reference:
-        return visitor.template visit<Reference>();
-    case NodeKind::copy_details:
-        return visitor.template visit<CopyDetails>();
-    case NodeKind::list_item:
-        return visitor.template visit<ListItem>();
-    case NodeKind::unordered_list:
-        return visitor.template visit<UnorderedList>();
-    case NodeKind::param:
-        return visitor.template visit<Param>();
-    case NodeKind::returns:
-        return visitor.template visit<Returns>();
-    case NodeKind::styled:
-        return visitor.template visit<Styled>();
-    case NodeKind::text:
-        return visitor.template visit<Text>();
-    case NodeKind::tparam:
-        return visitor.template visit<TParam>();
-    case NodeKind::throws:
-        return visitor.template visit<Throws>();
-    case NodeKind::see:
-        return visitor.template visit<See>();
-    case NodeKind::precondition:
-        return visitor.template visit<Precondition>();
-    case NodeKind::postcondition:
-        return visitor.template visit<Postcondition>();
-    default:
-        MRDOCS_UNREACHABLE();
-    }
-}
-
-/** Traverse a list of nodes.
-
-    @param list The list of nodes to traverse.
-    @param f The function to call for each node.
-    @param args Additional arguments to pass to the function.
- */
-template<class F, class T, class... Args>
-requires std::derived_from<T, Node>
-void traverse(
-    std::vector<std::unique_ptr<T>> const& list,
-    F&& f, Args&&... args)
-{
-    for(auto const& node : list)
-        visit(*node,
-            std::forward<F>(f),
-            std::forward<Args>(args)...);
-}
-
-} // doc
-
-//------------------------------------------------
-
-class Corpus;
-
-/** A processed Doxygen-style comment attached to a declaration.
-*/
 struct MRDOCS_DECL
     Javadoc
 {
@@ -2023,7 +210,7 @@ inline
 void merge(Javadoc& I, Javadoc&& other)
 {
     // FIXME: this doesn't merge parameter information;
-    // parameters with the same name but different direction
+    // parameters with the same name but different directions
     // or descriptions end up being duplicated
     if(other != I)
     {
diff --git a/include/mrdocs/Metadata/Javadoc/Block.hpp b/include/mrdocs/Metadata/Javadoc/Block.hpp
new file mode 100644
index 000000000..d874d6b98
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Block.hpp
@@ -0,0 +1,136 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_HPP
+#define MRDOCS_API_METADATA_JAVADOC_BLOCK_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Admonish.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Admonition.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Brief.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Code.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Heading.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/ListItem.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Param.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/ParamDirection.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Postcondition.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Precondition.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Returns.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/See.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/TParam.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Throws.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/UnorderedList.hpp>
+#include <mrdocs/Support/Visitor.hpp>
+
+namespace clang::mrdocs::doc {
+/** Visit a block.
+
+    @param block The block to visit.
+    @param fn The function to call for each block.
+    @param args Additional arguments to pass to the function.
+    @return The result of calling the function.
+ */
+template<
+    class BlockTy,
+    class Fn,
+    class... Args>
+    requires std::derived_from<BlockTy, Block>
+decltype(auto)
+visit(
+    BlockTy& block,
+    Fn&& fn,
+    Args&&... args)
+{
+    auto visitor = makeVisitor<Block>(
+        block, std::forward<Fn>(fn),
+        std::forward<Args>(args)...);
+    switch(block.Kind)
+    {
+    case NodeKind::admonition:
+        return visitor.template visit<Admonition>();
+    case NodeKind::brief:
+        return visitor.template visit<Brief>();
+    case NodeKind::code:
+        return visitor.template visit<Code>();
+    case NodeKind::heading:
+        return visitor.template visit<Heading>();
+    case NodeKind::paragraph:
+        return visitor.template visit<Paragraph>();
+    case NodeKind::list_item:
+        return visitor.template visit<ListItem>();
+    case NodeKind::unordered_list:
+        return visitor.template visit<UnorderedList>();
+    case NodeKind::param:
+        return visitor.template visit<Param>();
+    case NodeKind::returns:
+        return visitor.template visit<Returns>();
+    case NodeKind::tparam:
+        return visitor.template visit<TParam>();
+    case NodeKind::throws:
+        return visitor.template visit<Throws>();
+    case NodeKind::see:
+        return visitor.template visit<See>();
+    case NodeKind::precondition:
+        return visitor.template visit<Precondition>();
+    case NodeKind::postcondition:
+        return visitor.template visit<Postcondition>();
+    default:
+        MRDOCS_UNREACHABLE();
+    }
+}
+
+/** Traverse a list of blocks.
+
+    @param list The list of blocks to traverse.
+    @param f The function to call for each block.
+    @param args Additional arguments to pass to the function.
+ */
+template<class F, class T, class... Args>
+requires std::derived_from<T, Block>
+void traverse(
+    std::vector<std::unique_ptr<T>> const& list,
+    F&& f, Args&&... args)
+{
+    for(auto const& block : list)
+        visit(*block,
+            std::forward<F>(f),
+            std::forward<Args>(args)...);
+}
+
+/** Map the Polymorphic Block as a @ref dom::Value object.
+
+    @param io The output parameter to receive the dom::Object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO, polymorphic_storage_for<Block> BlockTy>
+void
+tag_invoke(
+    dom::ValueFromTag,
+    IO& io,
+    BlockTy const& I,
+    DomCorpus const* domCorpus)
+{
+    visit(*I, [&](auto const& U)
+    {
+        tag_invoke(
+            dom::ValueFromTag{},
+            io,
+            U,
+            domCorpus);
+    });
+}
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Admonish.hpp b/include/mrdocs/Metadata/Javadoc/Block/Admonish.hpp
new file mode 100644
index 000000000..2004a0e1b
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Block/Admonish.hpp
@@ -0,0 +1,59 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_ADMONISH_HPP
+#define MRDOCS_API_METADATA_JAVADOC_BLOCK_ADMONISH_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+
+namespace clang::mrdocs::doc {
+
+/** An admonishment style.
+ */
+enum class Admonish
+{
+    /// No admonishment
+    none = 1, // needed by bitstream
+    /// A general note
+    note,
+    /// A tip to the reader
+    tip,
+    /// Something important
+    important,
+    /// A caution admonishment
+    caution,
+    /// A warning admonishment
+    warning
+};
+
+/** Return the name of the Admonish as a string.
+ */
+MRDOCS_DECL
+dom::String
+toString(Admonish kind) noexcept;
+
+/** Return the Admonish from a @ref dom::Value string.
+ */
+inline
+    void
+    tag_invoke(
+        dom::ValueFromTag,
+        dom::Value& v,
+        Admonish const kind)
+{
+    v = toString(kind);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_ADMONISH_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Admonition.hpp b/include/mrdocs/Metadata/Javadoc/Block/Admonition.hpp
new file mode 100644
index 000000000..62e8142b6
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Block/Admonition.hpp
@@ -0,0 +1,89 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_ADMONITION_HPP
+#define MRDOCS_API_METADATA_JAVADOC_BLOCK_ADMONITION_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Admonish.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+/** An admonition.
+
+    This paragraph represents an admonition, such as
+    a note, tip, important, caution, or warning.
+
+*/
+struct Admonition final : Paragraph
+{
+    Admonish admonish;
+
+    explicit
+    Admonition(
+        Admonish const admonish_ = Admonish::none) noexcept
+        : Paragraph(NodeKind::admonition)
+        , admonish(admonish_)
+    {
+    }
+
+    using Paragraph::operator=;
+
+    auto operator<=>(Admonition const&) const = default;
+
+    bool operator==(Admonition const&) const noexcept = default;
+
+    bool equals(Node const& other) const noexcept override
+    {
+        return Kind == other.Kind &&
+            *this == dynamic_cast<Admonition const&>(other);
+    }
+};
+
+/** Map the @ref Admonition to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    Admonition const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
+    io.map("admonish", I.admonish);
+}
+
+/** Return the @ref Admonition as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Admonition const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_ADMONITION_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/BlockBase.hpp b/include/mrdocs/Metadata/Javadoc/Block/BlockBase.hpp
new file mode 100644
index 000000000..4fd0568b0
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Block/BlockBase.hpp
@@ -0,0 +1,146 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_BLOCKBASE_HPP
+#define MRDOCS_API_METADATA_JAVADOC_BLOCK_BLOCKBASE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+#include <mrdocs/Dom/LazyArray.hpp>
+#include <mrdocs/Dom/LazyObject.hpp>
+#include <mrdocs/Metadata/Javadoc/Node/NodeBase.hpp>
+#include <mrdocs/Metadata/Javadoc/Text.hpp>
+#include <algorithm>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+/** A piece of block content
+
+    The top level is a list of blocks.
+
+    There are two types of blocks: headings and paragraphs
+*/
+struct MRDOCS_DECL
+    Block : Node
+{
+    std::vector<Polymorphic<Text>> children;
+
+    bool isBlock() const noexcept final
+    {
+        return true;
+    }
+
+    bool empty() const noexcept
+    {
+        return children.empty();
+    }
+
+    auto operator<=>(Block const& other) const {
+        if (auto const cmp = children.size() <=> other.children.size();
+            !std::is_eq(cmp))
+        {
+            return cmp;
+        }
+        for (std::size_t i = 0; i < children.size(); ++i)
+        {
+            if (auto const cmp = *children[i] <=> *other.children[i];
+                !std::is_eq(cmp))
+            {
+                return cmp;
+            }
+        }
+        return std::strong_ordering::equal;
+    }
+
+    bool operator==(Block const& other) const noexcept
+    {
+        if (Kind != other.Kind)
+        {
+            return false;
+        }
+        return std::ranges::
+            equal(children, other.children,
+            [](auto const& a, auto const& b)
+            {
+                return a->equals(*b);
+            });
+    }
+
+    bool equals(Node const& other) const noexcept override
+    {
+        return Kind == other.Kind &&
+            *this == dynamic_cast<Block const&>(other);
+    }
+
+    template<std::derived_from<Text> T>
+    T& emplace_back(T&& text)
+    {
+        return static_cast<T&>(emplace_back(
+            std::make_unique<T>(std::forward<T>(text))));
+    }
+
+    void append(std::vector<Polymorphic<Node>>&& blocks);
+
+    void append(std::vector<Polymorphic<Text>> const& otherChildren);
+
+protected:
+    explicit
+    Block(
+        NodeKind const kind_,
+        std::vector<Polymorphic<Text>> children_ = {}) noexcept
+        : Node(kind_)
+        , children(std::move(children_))
+    {
+    }
+
+private:
+    Text& emplace_back(Polymorphic<Text> text);
+};
+
+/** Map the @ref Block to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    Block const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Node const&>(I), domCorpus);
+    io.defer("children", [&I, domCorpus] {
+        return dom::LazyArray(I.children, domCorpus);
+    });
+}
+
+/** Return the @ref Block as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Block const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_BLOCKBASE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Brief.hpp b/include/mrdocs/Metadata/Javadoc/Block/Brief.hpp
new file mode 100644
index 000000000..8a1b0b3a5
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Block/Brief.hpp
@@ -0,0 +1,98 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_BRIEF_HPP
+#define MRDOCS_API_METADATA_JAVADOC_BLOCK_BRIEF_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <mrdocs/Metadata/Javadoc/Node/NodeBase.hpp>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+/** The brief description
+*/
+struct Brief final : Paragraph
+{
+    static constexpr NodeKind static_kind = NodeKind::brief;
+
+    std::vector<std::string> copiedFrom;
+
+    Brief() noexcept
+        : Paragraph(NodeKind::brief)
+    {
+    }
+
+    explicit
+    Brief(std::string_view const text)
+        : Brief()
+    {
+        operator=(text);
+    }
+
+    Brief(Brief const& other) = default;
+
+    Brief&
+    operator=(Brief const& other) = default;
+
+    Brief&
+    operator=(std::string_view const text) override
+    {
+        Paragraph::operator=(text);
+        return *this;
+    }
+
+    auto operator<=>(Brief const&) const = default;
+
+    bool equals(Node const& other) const noexcept override
+    {
+        return Kind == other.Kind &&
+            *this == dynamic_cast<Brief const&>(other);
+    }
+};
+
+/** Map the @ref Brief to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    Brief const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
+}
+
+/** Return the @ref Brief as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Brief const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_BRIEF_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Code.hpp b/include/mrdocs/Metadata/Javadoc/Block/Code.hpp
new file mode 100644
index 000000000..6d3655cb2
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Block/Code.hpp
@@ -0,0 +1,80 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_CODE_HPP
+#define MRDOCS_API_METADATA_JAVADOC_BLOCK_CODE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+/** Preformatted source code.
+ */
+struct Code final : Paragraph
+{
+    // VFALCO we can add a language (e.g., C++),
+    //        then emit attributes in the generator.
+
+    static constexpr auto static_kind = NodeKind::code;
+
+    Code() noexcept
+        : Paragraph(NodeKind::code)
+    {
+    }
+
+    using Paragraph::operator=;
+    auto operator<=>(Code const&) const = default;
+    bool operator==(Code const&) const noexcept = default;
+    bool equals(Node const& other) const noexcept override
+    {
+        return Kind == other.Kind &&
+               *this == dynamic_cast<Code const&>(other);
+    }
+};
+
+/** Map the @ref Code to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    Code const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
+}
+
+/** Return the @ref Code as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Code const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_CODE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Heading.hpp b/include/mrdocs/Metadata/Javadoc/Block/Heading.hpp
new file mode 100644
index 000000000..5a761e3ca
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Block/Heading.hpp
@@ -0,0 +1,80 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_HEADING_HPP
+#define MRDOCS_API_METADATA_JAVADOC_BLOCK_HEADING_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+/** A manually specified section heading.
+*/
+struct Heading final : Block
+{
+    static constexpr auto static_kind = NodeKind::heading;
+
+    std::string string;
+
+    Heading(
+        std::string string_ = std::string()) noexcept
+        : Block(NodeKind::heading)
+        , string(std::move(string_))
+    {
+    }
+
+    auto operator<=>(Heading const&) const = default;
+    bool operator==(Heading const&) const noexcept = default;
+    bool equals(Node const& other) const noexcept override
+    {
+        return Kind == other.Kind &&
+            *this == dynamic_cast<Heading const&>(other);
+    }
+};
+
+/** Map the @ref Heading to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    Heading const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
+    io.map("string", I.string);
+}
+
+/** Return the @ref Heading as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Heading const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_HEADING_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/ListItem.hpp b/include/mrdocs/Metadata/Javadoc/Block/ListItem.hpp
new file mode 100644
index 000000000..ce51557a8
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Block/ListItem.hpp
@@ -0,0 +1,88 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_LISTITEM_HPP
+#define MRDOCS_API_METADATA_JAVADOC_BLOCK_LISTITEM_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+/** An item in a list
+*/
+struct ListItem final : Paragraph
+{
+    static constexpr auto static_kind = NodeKind::list_item;
+
+    ListItem()
+        : Paragraph(static_kind)
+    {}
+
+    using Paragraph::operator=;
+
+    auto operator<=>(ListItem const&) const = default;
+    bool
+    operator==(ListItem const&) const noexcept = default;
+
+    bool
+    equals(Node const& other) const noexcept override
+    {
+        auto* p = dynamic_cast<ListItem const*>(&other);
+        if (!p)
+        {
+            return false;
+        }
+        if (this == &other)
+        {
+            return true;
+        }
+        return *this == *p;
+    }
+};
+
+/** Map the @ref ListItem to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    ListItem const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
+}
+
+/** Return the @ref ListItem as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    ListItem const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_LISTITEM_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Paragraph.hpp b/include/mrdocs/Metadata/Javadoc/Block/Paragraph.hpp
new file mode 100644
index 000000000..aa9c2eef5
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Block/Paragraph.hpp
@@ -0,0 +1,85 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAGRAPH_HPP
+#define MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAGRAPH_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+/** A sequence of text nodes.
+*/
+struct Paragraph : Block
+{
+    static constexpr auto static_kind = NodeKind::paragraph;
+
+    Paragraph() noexcept : Block(NodeKind::paragraph) {}
+
+    virtual
+    Paragraph&
+    operator=(std::string_view str);
+
+    auto operator<=>(Paragraph const&) const = default;
+
+    bool equals(Node const& other) const noexcept override
+    {
+        return Kind == other.Kind &&
+            *this == dynamic_cast<Paragraph const&>(other);
+    }
+
+protected:
+    explicit
+    Paragraph(
+        NodeKind const kind,
+        std::vector<Polymorphic<Text>> children_ = {}) noexcept
+        : Block(kind, std::move(children_))
+    {
+    }
+};
+
+/** Map the @ref Paragraph to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    Paragraph const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
+}
+
+/** Return the @ref Paragraph as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Paragraph const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAGRAPH_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Param.hpp b/include/mrdocs/Metadata/Javadoc/Block/Param.hpp
new file mode 100644
index 000000000..8844a3b2a
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Block/Param.hpp
@@ -0,0 +1,116 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAM_HPP
+#define MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAM_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/ParamDirection.hpp>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+/** Documentation for a function parameter
+*/
+struct Param final : Paragraph
+{
+    std::string name;
+    ParamDirection direction;
+
+    static constexpr auto static_kind = NodeKind::param;
+
+    Param(
+        std::string name_ = std::string(),
+        Paragraph details_ = Paragraph(),
+        ParamDirection const direction_ = ParamDirection::none)
+        : Paragraph(
+            NodeKind::param,
+            std::move(details_.children))
+        , name(std::move(name_))
+        , direction(direction_)
+    {
+    }
+
+    explicit
+    Param(
+        std::string_view const name,
+        std::string_view const text)
+    : Param()
+    {
+        this->name = name;
+        this->operator=(text);
+    }
+
+    explicit
+    Param(Paragraph const& other)
+        : Param()
+    {
+        children = other.children;
+    }
+
+    Param&
+    operator=(std::string_view const text) override
+    {
+        Paragraph::operator=(text);
+        return *this;
+    }
+
+    auto operator<=>(Param const&) const = default;
+
+    bool operator==(Param const&)
+        const noexcept = default;
+
+    bool equals(Node const& other) const noexcept override
+    {
+        return Kind == other.Kind &&
+            *this == dynamic_cast<Param const&>(other);
+    }
+};
+
+/** Map the @ref Param to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    Param const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
+    io.map("name", I.name);
+    io.map("direction", I.direction);
+}
+
+/** Return the @ref Param as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Param const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAM_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/ParamDirection.hpp b/include/mrdocs/Metadata/Javadoc/Block/ParamDirection.hpp
new file mode 100644
index 000000000..16e3b9b97
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Block/ParamDirection.hpp
@@ -0,0 +1,55 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAMDIRECTION_HPP
+#define MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAMDIRECTION_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+
+namespace clang::mrdocs::doc {
+
+/** Parameter pass direction.
+*/
+enum class ParamDirection
+{
+    /// No direction specified
+    none,
+    /// Parameter is passed
+    in,
+    /// Parameter is passed back to the caller
+    out,
+    /// Parameter is passed and passed back to the caller
+    inout
+};
+
+/** Return the name of the ParamDirection as a string.
+ */
+MRDOCS_DECL
+dom::String
+toString(ParamDirection kind) noexcept;
+
+/** Return the ParamDirection from a @ref dom::Value string.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    ParamDirection const kind)
+{
+    v = toString(kind);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAMDIRECTION_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Postcondition.hpp b/include/mrdocs/Metadata/Javadoc/Block/Postcondition.hpp
new file mode 100644
index 000000000..251bfa5be
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Block/Postcondition.hpp
@@ -0,0 +1,85 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_POSTCONDITION_HPP
+#define MRDOCS_API_METADATA_JAVADOC_BLOCK_POSTCONDITION_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+struct Postcondition : Paragraph
+{
+    static constexpr auto static_kind = NodeKind::postcondition;
+
+    Postcondition(
+        Paragraph details_ = Paragraph())
+        : Paragraph(
+            NodeKind::postcondition,
+            std::move(details_.children))
+    {
+    }
+
+    using Paragraph::operator=;
+
+    auto operator<=>(Postcondition const&) const = default;
+
+    bool operator==(Postcondition const&)
+        const noexcept = default;
+
+    bool equals(Node const& other) const noexcept override
+    {
+        return Kind == other.Kind &&
+            *this == dynamic_cast<Postcondition const&>(other);
+    }
+};
+
+/** Map the @ref Postcondition to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    Postcondition const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
+}
+
+/** Return the @ref Postcondition as a @ref dom::Value object.
+
+    @param v The value to assign to.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Postcondition const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_POSTCONDITION_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Precondition.hpp b/include/mrdocs/Metadata/Javadoc/Block/Precondition.hpp
new file mode 100644
index 000000000..39c606155
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Block/Precondition.hpp
@@ -0,0 +1,85 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_PRECONDITION_HPP
+#define MRDOCS_API_METADATA_JAVADOC_BLOCK_PRECONDITION_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+struct Precondition final : Paragraph
+{
+    static constexpr NodeKind static_kind = NodeKind::precondition;
+
+    Precondition(
+        Paragraph details_ = Paragraph())
+        : Paragraph(
+            NodeKind::precondition,
+            std::move(details_.children))
+    {
+    }
+
+    using Paragraph::operator=;
+
+    auto operator<=>(Precondition const&) const = default;
+
+    bool operator==(Precondition const&)
+        const noexcept = default;
+
+    bool equals(Node const& other) const noexcept override
+    {
+        return Kind == other.Kind &&
+            *this == dynamic_cast<Precondition const&>(other);
+    }
+};
+
+/** Map the @ref Precondition to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    Precondition const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
+}
+
+/** Return the @ref Precondition as a @ref dom::Value object.
+
+    @param v The value to assign to.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Precondition const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_PRECONDITION_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Returns.hpp b/include/mrdocs/Metadata/Javadoc/Block/Returns.hpp
new file mode 100644
index 000000000..2108db015
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Block/Returns.hpp
@@ -0,0 +1,100 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_RETURNS_HPP
+#define MRDOCS_API_METADATA_JAVADOC_BLOCK_RETURNS_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+/** Documentation for a function return type
+*/
+struct Returns final : Paragraph
+{
+    static constexpr NodeKind static_kind = NodeKind::returns;
+
+    Returns()
+        : Paragraph(NodeKind::returns)
+    {
+    }
+
+    explicit
+    Returns(std::string_view const text)
+        : Returns()
+    {
+        operator=(text);
+    }
+
+    explicit
+    Returns(Paragraph const& other)
+        : Returns()
+    {
+        children = other.children;
+    }
+
+    Returns&
+    operator=(std::string_view const text) override
+    {
+        Paragraph::operator=(text);
+        return *this;
+    }
+
+    auto operator<=>(Returns const&) const = default;
+
+    bool operator==(Returns const&)
+        const noexcept = default;
+
+    bool equals(Node const& other) const noexcept override
+    {
+        return Kind == other.Kind &&
+            *this == dynamic_cast<Returns const&>(other);
+    }
+};
+
+/** Map the @ref Returns to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    Returns const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
+}
+
+/** Return the @ref Returns as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Returns const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_RETURNS_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/See.hpp b/include/mrdocs/Metadata/Javadoc/Block/See.hpp
new file mode 100644
index 000000000..27ba2b974
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Block/See.hpp
@@ -0,0 +1,81 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_SEE_HPP
+#define MRDOCS_API_METADATA_JAVADOC_BLOCK_SEE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+/** A @see paragraph
+*/
+struct See final : Paragraph
+{
+    static constexpr auto static_kind = NodeKind::see;
+
+    See()
+        : Paragraph(static_kind)
+    {
+    }
+
+    using Paragraph::operator=;
+
+    auto operator<=>(See const&) const = default;
+
+    bool operator==(See const&)
+        const noexcept = default;
+
+    bool equals(Node const& other) const noexcept override
+    {
+        return Kind == other.Kind &&
+            *this == dynamic_cast<See const&>(other);
+    }
+};
+
+/** Map the @ref See to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    See const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
+}
+
+/** Return the @ref See as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    See const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_SEE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/TParam.hpp b/include/mrdocs/Metadata/Javadoc/Block/TParam.hpp
new file mode 100644
index 000000000..6a999fa94
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Block/TParam.hpp
@@ -0,0 +1,81 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_TPARAM_HPP
+#define MRDOCS_API_METADATA_JAVADOC_BLOCK_TPARAM_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+/** Documentation for a template parameter
+*/
+struct TParam final : Paragraph
+{
+    std::string name;
+
+    static constexpr NodeKind static_kind = NodeKind::tparam;
+
+    TParam()
+        : Paragraph(NodeKind::tparam)
+    {
+    }
+
+    using Paragraph::operator=;
+
+    auto operator<=>(TParam const&) const = default;
+    bool operator==(TParam const&) const noexcept = default;
+    bool equals(Node const& other) const noexcept override
+    {
+        return Kind == other.Kind &&
+            *this == dynamic_cast<TParam const&>(other);
+    }
+};
+
+/** Map the @ref TParam to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    TParam const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
+    io.map("name", I.name);
+}
+
+/** Return the @ref TParam as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    TParam const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_TPARAM_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Throws.hpp b/include/mrdocs/Metadata/Javadoc/Block/Throws.hpp
new file mode 100644
index 000000000..bc6187bb9
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Block/Throws.hpp
@@ -0,0 +1,88 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_THROWS_HPP
+#define MRDOCS_API_METADATA_JAVADOC_BLOCK_THROWS_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+/** Documentation for a function parameter
+*/
+struct Throws final : Paragraph
+{
+    Reference exception;
+
+    static constexpr NodeKind static_kind = NodeKind::throws;
+
+    Throws(
+        std::string exception_ = std::string(),
+        Paragraph details_ = Paragraph())
+        : Paragraph(
+            NodeKind::throws,
+            std::move(details_.children))
+        , exception(std::move(exception_))
+    {
+    }
+
+    using Paragraph::operator=;
+
+    auto operator<=>(Throws const&) const = default;
+
+    bool operator==(Throws const&)
+        const noexcept = default;
+
+    bool equals(Node const& other) const noexcept override
+    {
+        return Kind == other.Kind &&
+            *this == dynamic_cast<Throws const&>(other);
+    }
+};
+
+/** Map the @ref Throws to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    Throws const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
+    io.map("exception", I.exception);
+}
+
+/** Return the @ref Throws as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Throws const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_THROWS_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/UnorderedList.hpp b/include/mrdocs/Metadata/Javadoc/Block/UnorderedList.hpp
new file mode 100644
index 000000000..1d87c368f
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Block/UnorderedList.hpp
@@ -0,0 +1,112 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_UNORDEREDLIST_HPP
+#define MRDOCS_API_METADATA_JAVADOC_BLOCK_UNORDEREDLIST_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/ListItem.hpp>
+#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <string>
+#include <vector>
+
+namespace clang::mrdocs::doc {
+
+/** A list of list items
+*/
+struct UnorderedList final : Paragraph
+{
+    static constexpr auto static_kind = NodeKind::unordered_list;
+
+    std::vector<ListItem> items;
+
+    UnorderedList()
+        : Paragraph(static_kind)
+    {
+    }
+
+    using Paragraph::operator=;
+
+    auto operator<=>(UnorderedList const& other) const {
+        if (auto const cmp = items.size() <=> other.items.size();
+            !std::is_eq(cmp))
+        {
+            return cmp;
+        }
+        for (std::size_t i = 0; i < items.size(); ++i)
+        {
+            if (auto const cmp = items[i] <=> other.items[i];
+                !std::is_eq(cmp))
+            {
+                return cmp;
+            }
+        }
+        return std::strong_ordering::equal;
+    }
+
+    bool
+    operator==(UnorderedList const&) const noexcept = default;
+
+    bool
+    equals(Node const& other) const noexcept override
+    {
+        auto* p = dynamic_cast<UnorderedList const*>(&other);
+        if (!p)
+        {
+            return false;
+        }
+        if (this == &other)
+        {
+            return true;
+        }
+        return *this == *p;
+    }
+};
+
+/** Map the @ref UnorderedList to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    UnorderedList const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
+    io.defer("items", [&I, domCorpus] {
+        return dom::LazyArray(I.items, domCorpus);
+    });
+}
+
+/** Return the @ref UnorderedList as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    UnorderedList const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_UNORDEREDLIST_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Node.hpp b/include/mrdocs/Metadata/Javadoc/Node.hpp
new file mode 100644
index 000000000..c1d49caa8
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Node.hpp
@@ -0,0 +1,160 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_NODE_HPP
+#define MRDOCS_API_METADATA_JAVADOC_NODE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Block.hpp>
+#include <mrdocs/Metadata/Javadoc/Node/NodeBase.hpp>
+#include <mrdocs/Metadata/Javadoc/Text.hpp>
+#include <mrdocs/Support/Concepts.hpp>
+#include <mrdocs/Support/Visitor.hpp>
+
+/** Javadoc related types and functions.
+
+    Javadoc is a documentation generator originally
+    created for the Java language from source code.
+
+    The Javadoc documentation generator tool can interpret
+    text in the "doc comments" format included
+    directly in the source code.
+
+    The same "doc comments" format has been replicated
+    and extended by documentation systems for other
+    languages, including the cross-language Doxygen
+    and the JSDoc system for JavaScript.
+
+    Because Clang can already parse and extract
+    blocks of Javadoc-style comments from source
+    code, these classes are used to represent the
+    parsed documentation in a structured form.
+
+    @see https://en.wikipedia.org/wiki/Javadoc
+    @see https://www.doxygen.nl
+
+ */
+namespace clang::mrdocs::doc {
+
+/** Visit a node.
+
+    @param node The node to visit.
+    @param fn The function to call for each node.
+    @param args Additional arguments to pass to the function.
+    @return The result of calling the function.
+ */
+template<
+    class NodeTy,
+    class Fn,
+    class... Args>
+requires
+    std::same_as<std::remove_cvref_t<NodeTy>, Node>
+decltype(auto)
+visit(
+    NodeTy& node,
+    Fn&& fn,
+    Args&&... args)
+{
+    auto visitor = makeVisitor<Node>(
+        node, std::forward<Fn>(fn),
+        std::forward<Args>(args)...);
+    switch(node.Kind)
+    {
+    case NodeKind::admonition:
+        return visitor.template visit<Admonition>();
+    case NodeKind::brief:
+        return visitor.template visit<Brief>();
+    case NodeKind::code:
+        return visitor.template visit<Code>();
+    case NodeKind::heading:
+        return visitor.template visit<Heading>();
+    case NodeKind::paragraph:
+        return visitor.template visit<Paragraph>();
+    case NodeKind::link:
+        return visitor.template visit<Link>();
+    case NodeKind::reference:
+        return visitor.template visit<Reference>();
+    case NodeKind::copy_details:
+        return visitor.template visit<CopyDetails>();
+    case NodeKind::list_item:
+        return visitor.template visit<ListItem>();
+    case NodeKind::unordered_list:
+        return visitor.template visit<UnorderedList>();
+    case NodeKind::param:
+        return visitor.template visit<Param>();
+    case NodeKind::returns:
+        return visitor.template visit<Returns>();
+    case NodeKind::styled:
+        return visitor.template visit<Styled>();
+    case NodeKind::text:
+        return visitor.template visit<Text>();
+    case NodeKind::tparam:
+        return visitor.template visit<TParam>();
+    case NodeKind::throws:
+        return visitor.template visit<Throws>();
+    case NodeKind::see:
+        return visitor.template visit<See>();
+    case NodeKind::precondition:
+        return visitor.template visit<Precondition>();
+    case NodeKind::postcondition:
+        return visitor.template visit<Postcondition>();
+    default:
+        MRDOCS_UNREACHABLE();
+    }
+}
+
+/** Traverse a list of nodes.
+
+    @param list The list of nodes to traverse.
+    @param f The function to call for each node.
+    @param args Additional arguments to pass to the function.
+ */
+template<class F, class T, class... Args>
+requires std::derived_from<T, Node>
+void traverse(
+    std::vector<std::unique_ptr<T>> const& list,
+    F&& f, Args&&... args)
+{
+    for(auto const& node : list)
+        visit(*node,
+            std::forward<F>(f),
+            std::forward<Args>(args)...);
+}
+
+/** Map the Polymorphic Node as a @ref dom::Value object.
+
+    @param io The output parameter to receive the dom::Object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::ValueFromTag,
+    IO& io,
+    Polymorphic<Node> const& I,
+    DomCorpus const* domCorpus)
+{
+    visit(*I, [&](auto const& U)
+    {
+        tag_invoke(
+            dom::ValueFromTag{},
+            io,
+            U,
+            domCorpus);
+    });
+}
+
+
+} // clang::mrdocs::doc
+
+#endif
diff --git a/include/mrdocs/Metadata/Javadoc/Node/NodeBase.hpp b/include/mrdocs/Metadata/Javadoc/Node/NodeBase.hpp
new file mode 100644
index 000000000..20a4c35cb
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Node/NodeBase.hpp
@@ -0,0 +1,93 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_NODE_NODEBASE_HPP
+#define MRDOCS_API_METADATA_JAVADOC_NODE_NODEBASE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom/LazyObject.hpp>
+#include <mrdocs/Metadata/DomCorpus.hpp>
+#include <mrdocs/Metadata/Javadoc/Node/NodeKind.hpp>
+
+namespace clang::mrdocs::doc {
+
+//--------------------------------------------
+
+/** This is a variant-like list element.
+
+    There are two types of nodes: text and block.
+
+    - The javadoc is a list of blocks.
+    - A block contains a list of text elements.
+    - A text element contains a string.
+*/
+struct MRDOCS_DECL
+    Node
+{
+    NodeKind Kind;
+
+    virtual ~Node() = default;
+
+    explicit Node(NodeKind const kind_) noexcept
+        : Kind(kind_)
+    {
+    }
+
+    virtual bool isBlock() const noexcept = 0;
+
+    bool isText() const noexcept
+    {
+        return ! isBlock();
+    }
+
+    auto operator<=>(Node const&) const = default;
+    bool operator==(Node const&)const noexcept = default;
+    virtual bool equals(Node const& other) const noexcept
+    {
+        return Kind == other.Kind;
+    }
+};
+
+/** Map the @ref Node to a @ref dom::Object.
+
+    @param io The output parameter to receive the dom::Object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag,
+    IO& io,
+    Node const& I,
+    DomCorpus const* domCorpus)
+{
+    MRDOCS_ASSERT(domCorpus);
+    io.map("kind", I.Kind);
+}
+
+/** Return the @ref Node as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Node const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_NODE_NODEBASE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Node/NodeKind.hpp b/include/mrdocs/Metadata/Javadoc/Node/NodeKind.hpp
new file mode 100644
index 000000000..12f6800c0
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Node/NodeKind.hpp
@@ -0,0 +1,132 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_NODE_NODEKIND_HPP
+#define MRDOCS_API_METADATA_JAVADOC_NODE_NODEKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+
+namespace clang::mrdocs::doc {
+
+/** The kind of node.
+
+    This includes tags and block types.
+
+    Some of the available tags are:
+
+    @li `@author Author Name`
+    @li `{@docRoot}`
+    @li `@version version`
+    @li `@since since-text `
+    @li `@see reference`
+    @li `@param name description`
+    @li `@return description`
+    @li `@exception classname description`
+    @li `@throws classname description`
+    @li `@deprecated description`
+    @li `{@inheritDoc}`
+    @li `{@link reference}`
+    @li `{@linkplain reference}`
+    @li `{@value #STATIC_FIELD}`
+    @li `{@code literal}`
+    @li `{@literal literal}`
+    @li `{@serial literal}`
+    @li `{@serialData literal}`
+    @li `{@serialField literal}`
+
+    Doxygen also introduces a number of additional tags on top
+    of the the doc comment specification.
+
+    @note When a new tag is added, the `visit` function overloads
+    must be updated to handle the new tag.
+
+    @see https://en.wikipedia.org/wiki/Javadoc[Javadoc - Wikipedia]
+    @see https://docs.oracle.com/javase/1.5.0/docs/tooldocs/solaris/javadoc.html[Javadoc Documentation]
+    @see https://docs.oracle.com/en/java/javase/13/docs/specs/javadoc/doc-comment-spec.html[Doc Comment Specification]
+    @see https://www.oracle.com/java/technologies/javase/javadoc-tool.html[Javadoc Tool]
+    @see https://www.oracle.com/technical-resources/articles/java/javadoc-tool.html[How to Write Doc Comments]
+    @see https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html[Javadoc Package]
+    @see https://web.archive.org/web/20170714215721/http://agile.csc.ncsu.edu:80/SEMaterials/tutorials/javadoc[Javadoc Tutorial]
+    @see https://en.wikipedia.org/wiki/Doxygen[Doxygen - Wikipedia]
+    @see https://www.doxygen.nl/manual/commands.html[Doxygen Special Tags]
+
+ */
+enum class NodeKind
+{
+    // VFALCO Don't forget to update
+    // Node::isText() and Node::isBlock()
+    // when changing this enum!
+
+    /// A text tag
+    text = 1, // needed by bitstream
+    /// An admonition tag
+    admonition,
+    /// A brief tag
+    brief,
+    /// A code tag
+    code,
+    /// A heading tag
+    heading,
+    /// A link tag
+    link,
+    /// A list_item tag
+    list_item,
+    /// An unordered_list tag
+    unordered_list,
+    /// A paragraph tag
+    paragraph,
+    /// A param tag
+    param,
+    /// A returns tag
+    returns,
+    /// A styled tag
+    styled,
+    /// A tparam tag
+    tparam,
+    /// A reference tag
+    reference,
+    /// A copy_details tag
+    copy_details,
+    /// A throws tag
+    throws,
+    /// A details tag
+    details,
+    /// A see tag
+    see,
+    /// A general tag.
+    precondition,
+    /// A postcondition tag.
+    postcondition
+};
+
+/** Return the name of the NodeKind as a string.
+ */
+MRDOCS_DECL
+dom::String
+toString(NodeKind kind) noexcept;
+
+/** Return the NodeKind from a @ref dom::Value string.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    NodeKind const kind)
+{
+    v = toString(kind);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_NODE_NODEKIND_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Text.hpp b/include/mrdocs/Metadata/Javadoc/Text.hpp
new file mode 100644
index 000000000..5dc97981f
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Text.hpp
@@ -0,0 +1,122 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_TEXT_HPP
+#define MRDOCS_API_METADATA_JAVADOC_TEXT_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/Javadoc/Text/CopyDetails.hpp>
+#include <mrdocs/Metadata/Javadoc/Text/Link.hpp>
+#include <mrdocs/Metadata/Javadoc/Text/Reference.hpp>
+#include <mrdocs/Metadata/Javadoc/Text/Style.hpp>
+#include <mrdocs/Metadata/Javadoc/Text/Styled.hpp>
+#include <mrdocs/Metadata/Javadoc/Text/TextBase.hpp>
+#include <mrdocs/Support/Concepts.hpp>
+#include <mrdocs/Support/Visitor.hpp>
+#include <compare>
+
+namespace clang::mrdocs::doc {
+
+/** Visit a text.
+
+    @param text The text to visit.
+    @param fn The function to call for each text.
+    @param args Additional arguments to pass to the function.
+    @return The result of calling the function.
+ */
+template<
+    class TextTy,
+    class Fn,
+    class... Args>
+    requires std::derived_from<TextTy, Text>
+decltype(auto)
+visit(
+    TextTy& text,
+    Fn&& fn,
+    Args&&... args)
+{
+    auto visitor = makeVisitor<Text>(
+        text, std::forward<Fn>(fn),
+        std::forward<Args>(args)...);
+    switch(text.Kind)
+    {
+    case NodeKind::link:
+        return visitor.template visit<Link>();
+    case NodeKind::reference:
+        return visitor.template visit<Reference>();
+    case NodeKind::copy_details:
+        return visitor.template visit<CopyDetails>();
+    case NodeKind::styled:
+        return visitor.template visit<Styled>();
+    case NodeKind::text:
+        return visitor.template visit<Text>();
+    default:
+        MRDOCS_UNREACHABLE();
+    }
+}
+
+/** Traverse a list of texts.
+
+    @param list The list of texts to traverse.
+    @param f The function to call for each text.
+    @param args Additional arguments to pass to the function.
+ */
+template<class F, class T, class... Args>
+requires std::derived_from<T, Text>
+void traverse(
+    std::vector<std::unique_ptr<T>> const& list,
+    F&& f, Args&&... args)
+{
+    for(auto const& text : list)
+        visit(*text,
+            std::forward<F>(f),
+            std::forward<Args>(args)...);
+}
+
+/** Map the Polymorphic Text as a @ref dom::Value object.
+
+    @param io The output parameter to receive the dom::Object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO, polymorphic_storage_for<Text> TextTy>
+void
+tag_invoke(
+    dom::ValueFromTag,
+    IO& io,
+    TextTy const& I,
+    DomCorpus const* domCorpus)
+{
+    visit(*I, [&](auto const& U)
+    {
+        tag_invoke(
+            dom::ValueFromTag{},
+            io,
+            U,
+            domCorpus);
+    });
+}
+
+MRDOCS_DECL
+std::strong_ordering
+operator<=>(Polymorphic<Text> const& lhs, Polymorphic<Text> const& rhs);
+
+inline
+bool
+operator==(Polymorphic<Text> const& lhs, Polymorphic<Text> const& rhs) {
+    return std::is_eq(lhs <=> rhs);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_TEXT_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Text/CopyDetails.hpp b/include/mrdocs/Metadata/Javadoc/Text/CopyDetails.hpp
new file mode 100644
index 000000000..9fcaa3e5a
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Text/CopyDetails.hpp
@@ -0,0 +1,80 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_TEXT_COPYDETAILS_HPP
+#define MRDOCS_API_METADATA_JAVADOC_TEXT_COPYDETAILS_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Text/Reference.hpp>
+#include <mrdocs/Metadata/Javadoc/Text/TextBase.hpp>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+/** Documentation copied from another symbol.
+*/
+struct CopyDetails final : Reference
+{
+    static constexpr auto static_kind = NodeKind::copy_details;
+
+    CopyDetails(std::string string_ = std::string()) noexcept
+        : Reference(std::move(string_), NodeKind::copy_details)
+    {
+    }
+
+    auto operator<=>(CopyDetails const&) const = default;
+    bool operator==(CopyDetails const&) const noexcept = default;
+    bool equals(Node const& other) const noexcept override
+    {
+        return Kind == other.Kind &&
+            *this == dynamic_cast<CopyDetails const&>(other);
+    }
+};
+
+/** Map the @ref CopyDetails to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    CopyDetails const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Reference const&>(I), domCorpus);
+}
+
+/** Return the @ref CopyDetails as a @ref dom::Value object.
+
+    @param v The output value.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    CopyDetails const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_TEXT_COPYDETAILS_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Text/Link.hpp b/include/mrdocs/Metadata/Javadoc/Text/Link.hpp
new file mode 100644
index 000000000..0020f98d9
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Text/Link.hpp
@@ -0,0 +1,82 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_TEXT_LINK_HPP
+#define MRDOCS_API_METADATA_JAVADOC_TEXT_LINK_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Text/TextBase.hpp>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+/** A hyperlink.
+*/
+struct Link final : Text
+{
+    std::string href;
+
+    static constexpr auto static_kind = NodeKind::link;
+
+    explicit
+    Link(
+        std::string string_ = std::string(),
+        std::string href_ = std::string()) noexcept
+        : Text(std::move(string_), NodeKind::link)
+        , href(std::move(href_))
+    {
+    }
+
+    auto operator<=>(Link const&) const = default;
+    bool operator==(Link const&) const noexcept = default;
+    bool equals(Node const& other) const noexcept override
+    {
+        return Kind == other.Kind &&
+            *this == dynamic_cast<Link const&>(other);
+    }
+};
+
+/** Map the @ref Link to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    Link const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Text const&>(I), domCorpus);
+    io.map("href", I.href);
+}
+
+/** Return the @ref Link as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Link const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_TEXT_LINK_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Text/Parts.hpp b/include/mrdocs/Metadata/Javadoc/Text/Parts.hpp
new file mode 100644
index 000000000..b7f94b39d
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Text/Parts.hpp
@@ -0,0 +1,57 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_TEXT_PARTS_HPP
+#define MRDOCS_API_METADATA_JAVADOC_TEXT_PARTS_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+
+namespace clang::mrdocs::doc {
+
+/** Which parts of the documentation to copy.
+
+    @li `all`: copy the brief and the description.
+    @li `brief`: only copy the brief.
+    @li `description`: only copy the description.
+*/
+enum class Parts
+{
+    /// Copy the brief and the description
+    all = 1, // needed by bitstream
+    /// Copy the brief
+    brief,
+    /// Copy the description
+    description
+};
+
+/** Return the name of the Parts as a string.
+ */
+MRDOCS_DECL
+dom::String
+toString(Parts kind) noexcept;
+
+/** Return the Parts from a @ref dom::Value string.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Parts const kind)
+{
+    v = toString(kind);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_TEXT_PARTS_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Text/Reference.hpp b/include/mrdocs/Metadata/Javadoc/Text/Reference.hpp
new file mode 100644
index 000000000..d1131d82e
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Text/Reference.hpp
@@ -0,0 +1,89 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_TEXT_REFERENCE_HPP
+#define MRDOCS_API_METADATA_JAVADOC_TEXT_REFERENCE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Info/SymbolID.hpp>
+#include <mrdocs/Metadata/Javadoc/Text/TextBase.hpp>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+/** A reference to a symbol.
+*/
+struct Reference : Text
+{
+    SymbolID id = SymbolID::invalid;
+
+    static constexpr auto static_kind = NodeKind::reference;
+
+    explicit
+    Reference(
+        std::string string_ = std::string()) noexcept
+        : Text(std::move(string_), NodeKind::reference)
+    {
+    }
+
+    auto operator<=>(Reference const&) const = default;
+    bool operator==(Reference const&) const noexcept = default;
+    bool equals(Node const& other) const noexcept override
+    {
+        return Kind == other.Kind &&
+            *this == dynamic_cast<Reference const&>(other);
+    }
+
+protected:
+    Reference(
+        std::string string_,
+        NodeKind const kind_) noexcept
+        : Text(std::move(string_), kind_)
+    {
+    }
+};
+
+/** Map the @ref Reference to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    Reference const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Text const&>(I), domCorpus);
+    io.map("symbol", I.id);
+}
+
+/** Return the @ref Reference as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Reference const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_TEXT_REFERENCE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Text/Style.hpp b/include/mrdocs/Metadata/Javadoc/Text/Style.hpp
new file mode 100644
index 000000000..acdfeb094
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Text/Style.hpp
@@ -0,0 +1,58 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_TEXT_STYLE_HPP
+#define MRDOCS_API_METADATA_JAVADOC_TEXT_STYLE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+
+namespace clang::mrdocs::doc {
+
+/** The text style.
+*/
+enum class Style
+{
+    /// No style
+    none = 1, // needed by bitstream
+    /// Monospaced text
+    mono,
+    /// Bold text
+    bold,
+    /// Italic text
+    italic
+};
+
+/** Return the name of the @ref Style as a string.
+
+    @param kind The style kind.
+    @return The string representation of the style.
+ */
+MRDOCS_DECL
+dom::String
+toString(Style kind) noexcept;
+
+/** Return the @ref Style from a @ref dom::Value string.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Style const kind)
+{
+    v = toString(kind);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_TEXT_STYLE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Text/Styled.hpp b/include/mrdocs/Metadata/Javadoc/Text/Styled.hpp
new file mode 100644
index 000000000..5cc4e2c4b
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Text/Styled.hpp
@@ -0,0 +1,82 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_TEXT_STYLED_HPP
+#define MRDOCS_API_METADATA_JAVADOC_TEXT_STYLED_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Text/Style.hpp>
+#include <mrdocs/Metadata/Javadoc/Text/TextBase.hpp>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+/** A piece of styled text.
+*/
+struct Styled final : Text
+{
+    Style style;
+
+    static constexpr auto static_kind = NodeKind::styled;
+
+    Styled(
+        std::string string_ = std::string(),
+        Style style_ = Style::none) noexcept
+        : Text(std::move(string_), NodeKind::styled)
+        , style(style_)
+    {
+    }
+
+    auto operator<=>(Styled const&) const = default;
+    bool operator==(Styled const&) const noexcept = default;
+    bool equals(Node const& other) const noexcept override
+    {
+        return Kind == other.Kind &&
+            *this == dynamic_cast<Styled const&>(other);
+    }
+};
+
+/** Map the @ref Styled to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    Styled const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Text const&>(I), domCorpus);
+    io.map("style", I.style);
+}
+
+/** Return the @ref Styled as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Styled const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_TEXT_STYLED_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Text/TextBase.hpp b/include/mrdocs/Metadata/Javadoc/Text/TextBase.hpp
new file mode 100644
index 000000000..e2a4e2ddf
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Text/TextBase.hpp
@@ -0,0 +1,100 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_TEXT_TEXTBASE_HPP
+#define MRDOCS_API_METADATA_JAVADOC_TEXT_TEXTBASE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Node/NodeBase.hpp>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+/** A Node containing a string of text.
+
+    There will be no newlines in the text. Otherwise,
+    this would be represented as multiple text nodes
+    within a Paragraph node.
+*/
+struct Text : Node
+{
+    std::string string;
+
+    static constexpr auto static_kind = NodeKind::text;
+
+    explicit
+    Text(
+        std::string string_ = std::string()) noexcept
+        : Node(NodeKind::text)
+        , string(std::move(string_))
+    {
+    }
+
+    bool
+    isBlock() const noexcept final
+    {
+        return false;
+    }
+
+    auto operator<=>(Text const&) const = default;
+    bool operator==(Text const&) const noexcept = default;
+    bool equals(Node const& other) const noexcept override
+    {
+        return Kind == other.Kind &&
+            *this == dynamic_cast<Text const&>(other);
+    }
+
+protected:
+    Text(
+        std::string string_,
+        NodeKind kind_)
+        : Node(kind_)
+        , string(std::move(string_))
+    {
+    }
+};
+
+/** Map the @ref Text to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    Text const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Node const&>(I), domCorpus);
+    io.map("string", I.string);
+}
+
+/** Return the @ref Text as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Text const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_TEXT_TEXTBASE_HPP
diff --git a/include/mrdocs/Metadata/Name.hpp b/include/mrdocs/Metadata/Name.hpp
index 9ea25520d..d4505c251 100644
--- a/include/mrdocs/Metadata/Name.hpp
+++ b/include/mrdocs/Metadata/Name.hpp
@@ -13,133 +13,13 @@
 #define MRDOCS_API_METADATA_NAME_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Type.hpp>
-#include <mrdocs/Metadata/Template.hpp>
+#include <mrdocs/Metadata/Name/IdentifierNameInfo.hpp>
+#include <mrdocs/Metadata/Name/NameBase.hpp>
+#include <mrdocs/Metadata/Name/SpecializationNameInfo.hpp>
 #include <mrdocs/Support/Visitor.hpp>
 
 namespace clang::mrdocs {
 
-enum class NameKind
-{
-    /// A simple identifier
-    Identifier = 1, // for bitstream
-    /// A template instantiation
-    Specialization
-};
-
-MRDOCS_DECL
-dom::String
-toString(NameKind kind) noexcept;
-
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    NameKind const kind)
-{
-    v = toString(kind);
-}
-
-/** Represents a name for a named `TypeInfo`
-
-    When the `TypeInfo` is a named type, this class
-    represents the name of the type.
-
-    It also includes the symbol ID of the named type,
-    so that it can be referenced in the documentation.
-
-    This allows the `TypeInfo` to store either a
-    `NameInfo` or a `SpecializationNameInfo`,
-    which contains the arguments for a template specialization
-    without requiring the application to extract an
-    unnecessary symbol.
- */
-struct NameInfo
-{
-    /** The kind of name this is.
-    */
-    NameKind Kind;
-
-    /** The SymbolID of the named symbol, if it exists.
-    */
-    SymbolID id = SymbolID::invalid;
-
-    /** The unqualified name.
-    */
-    std::string Name;
-
-    /** The parent name info, if any.
-
-        This recursively includes information about
-        the parent, such as the symbol ID and
-        potentially template arguments, when
-        the parent is a SpecializationNameInfo.
-
-        This is particularly useful because the
-        parent of `id` could be a primary template.
-        In this case, the Prefix will contain
-        this primary template information
-        and the template arguments.
-
-     */
-    Polymorphic<NameInfo> Prefix = std::nullopt;
-
-    constexpr bool isIdentifier()     const noexcept { return Kind == NameKind::Identifier; }
-    constexpr bool isSpecialization() const noexcept { return Kind == NameKind::Specialization; }
-
-    constexpr
-    NameInfo() noexcept
-        : NameInfo(NameKind::Identifier) {}
-
-    explicit
-    constexpr
-    NameInfo(NameKind const kind) noexcept
-        : Kind(kind) {}
-
-    constexpr virtual ~NameInfo() = default;
-
-    std::strong_ordering
-    operator<=>(NameInfo const& other) const;
-
-    bool
-    operator==(NameInfo const& other) const
-    {
-        return std::is_eq(*this <=> other);
-    }
-};
-
-/** Represents a (possibly qualified) symbol name with template arguments.
-*/
-struct SpecializationNameInfo final
-    : NameInfo
-{
-    /** The template arguments.
-    */
-    std::vector<Polymorphic<TArg>> TemplateArgs;
-
-    /** The SymbolID of the named symbol, if it exists.
-    */
-    SymbolID specializationID = SymbolID::invalid;
-
-    constexpr
-    SpecializationNameInfo() noexcept
-        : NameInfo(NameKind::Specialization)
-    {}
-
-    auto
-    operator<=>(SpecializationNameInfo const& other) const
-    {
-        if (auto const r =
-            dynamic_cast<NameInfo const&>(*this) <=> dynamic_cast<NameInfo const&>(other);
-            !std::is_eq(r))
-        {
-            return r;
-        }
-        return TemplateArgs <=> other.TemplateArgs;
-    }
-};
-
 template<
     std::derived_from<NameInfo> NameInfoTy,
     class Fn,
@@ -155,7 +35,7 @@ visit(
     switch(info.Kind)
     {
     case NameKind::Identifier:
-        return visitor.template visit<NameInfo>();
+        return visitor.template visit<IdentifierNameInfo>();
     case NameKind::Specialization:
         return visitor.template visit<SpecializationNameInfo>();
     default:
@@ -167,41 +47,45 @@ MRDOCS_DECL
 std::strong_ordering
 operator<=>(Polymorphic<NameInfo> const& lhs, Polymorphic<NameInfo> const& rhs);
 
-inline
-bool
-operator==(Polymorphic<NameInfo> const& lhs, Polymorphic<NameInfo> const& rhs) {
+inline bool
+operator==(Polymorphic<NameInfo> const& lhs, Polymorphic<NameInfo> const& rhs)
+{
     return lhs <=> rhs == std::strong_ordering::equal;
 }
 
-MRDOCS_DECL
-std::string
-toString(NameInfo const& N);
-
-MRDOCS_DECL
+inline
 void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    NameInfo const& I,
-    DomCorpus const* domCorpus);
+    Polymorphic<NameInfo> const& I,
+    DomCorpus const* domCorpus)
+{
+    if(I.valueless_after_move())
+    {
+        v = nullptr;
+        return;
+    }
+    tag_invoke(dom::ValueFromTag{}, v, *I, domCorpus);
+}
 
 inline
 void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    Polymorphic<NameInfo> const& I,
+    Optional<Polymorphic<NameInfo>> const& I,
     DomCorpus const* domCorpus)
 {
-    if(! I)
+    if (!I)
     {
         v = nullptr;
         return;
     }
+    MRDOCS_ASSERT(!I->valueless_after_move());
     tag_invoke(dom::ValueFromTag{}, v, *I, domCorpus);
 }
 
-
 } // clang::mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Name/IdentifierNameInfo.hpp b/include/mrdocs/Metadata/Name/IdentifierNameInfo.hpp
new file mode 100644
index 000000000..093bedd4f
--- /dev/null
+++ b/include/mrdocs/Metadata/Name/IdentifierNameInfo.hpp
@@ -0,0 +1,48 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_NAME_IDENTIFIERNAMEINFO_HPP
+#define MRDOCS_API_METADATA_NAME_IDENTIFIERNAMEINFO_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Name/NameBase.hpp>
+
+namespace clang::mrdocs {
+
+/** Represents an identifier
+
+    This class is used to represent an identifier
+    that could be in the corpus or not.
+
+    When the symbol is in the corpus, the `id`
+    field will be set to the symbol ID of the
+    symbol.
+
+    When the symbol is not in the corpus,
+    the `id` field will be set to `SymbolID::invalid`.
+*/
+struct IdentifierNameInfo final
+    : NameInfo
+{
+    constexpr
+    IdentifierNameInfo() noexcept
+        : NameInfo(NameKind::Identifier)
+    {}
+
+    auto
+    operator<=>(IdentifierNameInfo const& other) const
+    {
+        return dynamic_cast<NameInfo const&>(*this) <=> dynamic_cast<NameInfo const&>(other);
+    }
+};
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Name/NameBase.hpp b/include/mrdocs/Metadata/Name/NameBase.hpp
new file mode 100644
index 000000000..3a9971705
--- /dev/null
+++ b/include/mrdocs/Metadata/Name/NameBase.hpp
@@ -0,0 +1,105 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_NAME_NAMEBASE_HPP
+#define MRDOCS_API_METADATA_NAME_NAMEBASE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/Info/SymbolID.hpp>
+#include <mrdocs/Metadata/Name/NameKind.hpp>
+
+namespace clang::mrdocs {
+
+/** Represents a name for a named `TypeInfo`
+
+    When the `TypeInfo` is a named type, this class
+    represents the name of the type.
+
+    It also includes the symbol ID of the named type,
+    so that it can be referenced in the documentation.
+
+    This allows the `TypeInfo` to store either a
+    `NameInfo` or a `SpecializationNameInfo`,
+    which contains the arguments for a template specialization
+    without requiring the application to extract an
+    unnecessary symbol.
+ */
+struct NameInfo
+{
+    /** The kind of name this is.
+    */
+    NameKind Kind;
+
+    /** The SymbolID of the named symbol, if it exists.
+    */
+    SymbolID id = SymbolID::invalid;
+
+    /** The unqualified name.
+    */
+    std::string Name;
+
+    /** The parent name info, if any.
+
+        This recursively includes information about
+        the parent, such as the symbol ID and
+        potentially template arguments, when
+        the parent is a SpecializationNameInfo.
+
+        This is particularly useful because the
+        parent of `id` could be a primary template.
+        In this case, the Prefix will contain
+        this primary template information
+        and the template arguments.
+
+     */
+    Optional<Polymorphic<NameInfo>> Prefix = std::nullopt;
+
+    constexpr bool isIdentifier()     const noexcept { return Kind == NameKind::Identifier; }
+    constexpr bool isSpecialization() const noexcept { return Kind == NameKind::Specialization; }
+
+
+    explicit
+    constexpr
+    NameInfo(NameKind const kind) noexcept
+        : Kind(kind) {}
+
+    constexpr virtual ~NameInfo() = default;
+
+    std::strong_ordering
+    operator<=>(NameInfo const& other) const;
+
+    bool
+    operator==(NameInfo const& other) const
+    {
+        return std::is_eq(*this <=> other);
+    }
+
+protected:
+    constexpr
+    NameInfo() noexcept
+        : NameInfo(NameKind::Identifier) {};
+};
+
+MRDOCS_DECL
+std::string
+toString(NameInfo const& N);
+
+MRDOCS_DECL
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    NameInfo const& I,
+    DomCorpus const* domCorpus);
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Name/NameKind.hpp b/include/mrdocs/Metadata/Name/NameKind.hpp
new file mode 100644
index 000000000..716c73a32
--- /dev/null
+++ b/include/mrdocs/Metadata/Name/NameKind.hpp
@@ -0,0 +1,43 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_NAME_NAMEKIND_HPP
+#define MRDOCS_API_METADATA_NAME_NAMEKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+
+namespace clang::mrdocs {
+
+enum class NameKind
+{
+    /// A simple identifier
+    Identifier = 1, // for bitstream
+    /// A template instantiation
+    Specialization
+};
+
+MRDOCS_DECL
+dom::String
+toString(NameKind kind) noexcept;
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    NameKind const kind)
+{
+    v = toString(kind);
+}
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Name/SpecializationNameInfo.hpp b/include/mrdocs/Metadata/Name/SpecializationNameInfo.hpp
new file mode 100644
index 000000000..9b1199254
--- /dev/null
+++ b/include/mrdocs/Metadata/Name/SpecializationNameInfo.hpp
@@ -0,0 +1,53 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_NAME_SPECIALIZATIONNAMEINFO_HPP
+#define MRDOCS_API_METADATA_NAME_SPECIALIZATIONNAMEINFO_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Name/NameBase.hpp>
+#include <mrdocs/Metadata/TArg.hpp>
+
+namespace clang::mrdocs {
+
+/** Represents a (possibly qualified) symbol name with template arguments.
+*/
+struct SpecializationNameInfo final
+    : NameInfo
+{
+    /** The template arguments.
+    */
+    std::vector<Polymorphic<TArg>> TemplateArgs;
+
+    /** The SymbolID of the named symbol, if it exists.
+    */
+    SymbolID specializationID = SymbolID::invalid;
+
+    constexpr
+    SpecializationNameInfo() noexcept
+        : NameInfo(NameKind::Specialization)
+    {}
+
+    auto
+    operator<=>(SpecializationNameInfo const& other) const
+    {
+        if (auto const r =
+            dynamic_cast<NameInfo const&>(*this) <=> dynamic_cast<NameInfo const&>(other);
+            !std::is_eq(r))
+        {
+            return r;
+        }
+        return TemplateArgs <=> other.TemplateArgs;
+    }
+};
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Specifiers.hpp b/include/mrdocs/Metadata/Specifiers.hpp
index 9d8429228..1d0fd86b0 100644
--- a/include/mrdocs/Metadata/Specifiers.hpp
+++ b/include/mrdocs/Metadata/Specifiers.hpp
@@ -4,6 +4,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 // Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2023 Alan de Freitas (alandefreitas@gmail.com)
 //
 // Official repository: https://github.com/cppalliance/mrdocs
 //
@@ -11,388 +12,14 @@
 #ifndef MRDOCS_API_METADATA_SPECIFIERS_HPP
 #define MRDOCS_API_METADATA_SPECIFIERS_HPP
 
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/Dom.hpp>
-#include <string>
-
-namespace clang::mrdocs {
-
-/** Access specifier.
-
-    None is set to zero since it is the most
-    frequently occurring access, and it is
-    elided by the bitstream encoder because it
-    has an all-zero bit pattern. This improves
-    compression in the bitstream.
-
-    None is used for namespace members and friend;
-    such declarations have no access.
-*/
-enum class AccessKind
-{
-    /// Unspecified access
-    None = 0,
-    /// Public access
-    Public,
-    /// Protected access
-    Protected,
-    /// Private access
-    Private,
-};
-
-/** `constexpr`/`consteval` specifier kinds
-
-    [dcl.spec.general] p2: At most one of the `constexpr`, `consteval`,
-    and `constinit` keywords shall appear in a decl-specifier-seq
-*/
-enum class ConstexprKind
-{
-    /// No `constexpr` or `consteval` specifier
-    None = 0,
-    /// The `constexpr` specifier
-    Constexpr,
-    /// The `consteval` specifier
-    /// only valid for functions
-    Consteval,
-};
-
-/** Explicit specifier kinds
-*/
-enum class ExplicitKind
-{
-    /** No explicit-specifier or explicit-specifier evaluated to false
-    */
-    False = 0,
-    /** explicit-specifier evaluates to true
-    */
-    True,
-    /** Dependent explicit-specifier
-    */
-    Dependent
-};
-
-// KRYSTIAN FIXME: this needs to be improved (a lot)
-struct ExplicitInfo
-{
-    /** Whether an explicit-specifier was user-written.
-    */
-    bool Implicit = true;
-
-    /** The evaluated exception specification.
-    */
-    ExplicitKind Kind = ExplicitKind::False;
-
-    /** The operand of the explicit-specifier, if any.
-    */
-    std::string Operand;
-
-    auto operator<=>(ExplicitInfo const&) const = default;
-};
-
-/** Exception specification kinds
-*/
-enum class NoexceptKind
-{
-    /** Potentially-throwing exception specification
-    */
-    False = 0,
-    /** Non-throwing exception specification
-    */
-    True,
-    /** Dependent exception specification
-    */
-    Dependent
-};
-
-// KRYSTIAN FIXME: this needs to be improved (a lot)
-struct NoexceptInfo
-{
-    /** Whether a noexcept-specifier was user-written.
-    */
-    bool Implicit = true;
-
-    /** The evaluated exception specification.
-    */
-    NoexceptKind Kind = NoexceptKind::False;
-
-    /** The operand of the noexcept-specifier, if any.
-    */
-    std::string Operand;
-
-    auto operator<=>(NoexceptInfo const&) const = default;
-};
-
-/** Operator kinds
-*/
-enum class OperatorKind
-{
-    /// No operator
-    None = 0,
-    /// The `new` Operator
-    New,
-    /// The `delete` Operator
-    Delete,
-    /// The `new[]` Operator
-    ArrayNew,
-    /// The `delete[]` Operator
-    ArrayDelete,
-    /// The + Operator
-    Plus,
-    /// The - Operator
-    Minus,
-    /// The * Operator
-    Star,
-    /// The / Operator
-    Slash,
-    /// The % Operator
-    Percent,
-    /// The ^ Operator
-    Caret,
-    /// The & Operator
-    Amp,
-    /// The | Operator
-    Pipe,
-    /// The ~ Operator
-    Tilde,
-    /// The ! Operator
-    Equal,
-    /// The += Operator
-    PlusEqual,
-    /// The -= Operator
-    MinusEqual,
-    /// The *= Operator
-    StarEqual,
-    /// The /= Operator
-    SlashEqual,
-    /// The %= Operator
-    PercentEqual,
-    /// The ^= Operator
-    CaretEqual,
-    /// The &= Operator
-    AmpEqual,
-    /// The |= Operator
-    PipeEqual,
-    /// The << Operator
-    LessLess,
-    /// The >> Operator
-    GreaterGreater,
-    /// The <<= Operator
-    LessLessEqual,
-    /// The >>= Operator
-    GreaterGreaterEqual,
-
-    // Relational operators
-    /// The ! Operator
-    Exclaim,
-    /// The == Operator
-    EqualEqual,
-    /// The != Operator
-    ExclaimEqual,
-    /// The < Operator
-    Less,
-    /// The <= Operator
-    LessEqual,
-    /// The > Operator
-    Greater,
-    /// The >= Operator
-    GreaterEqual,
-    /// The <=> Operator
-    Spaceship,
-
-    /// The && Operator
-    AmpAmp,
-    /// The || Operator
-    PipePipe,
-    /// The ++ Operator
-    PlusPlus,
-    /// The -- Operator
-    MinusMinus,
-    /// The , Operator
-    Comma,
-    /// The ->* Operator
-    ArrowStar,
-    /// The -> Operator
-    Arrow,
-    /// The () Operator
-    Call,
-    /// The [] Operator
-    Subscript,
-    /// The `? :` Operator
-    Conditional,
-    /// The `coawait` Operator
-    Coawait,
-};
-
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    OperatorKind kind)
-{
-    v = static_cast<std::underlying_type_t<OperatorKind>>(kind);
-}
-
-/** Determines whether the operator is potentially unary.
- */
-MRDOCS_DECL
-bool
-isUnaryOperator(OperatorKind kind) noexcept;
-
-/** Determines whether the operator is potentially binary.
- */
-MRDOCS_DECL
-bool
-isBinaryOperator(OperatorKind kind) noexcept;
-
-/** Reference type kinds
-*/
-enum class ReferenceKind
-{
-    /// Not a reference
-    None = 0,
-    /// An L-Value reference
-    LValue,
-    /// An R-Value reference
-    RValue
-};
-
-/** Storage class kinds
-
-    [dcl.stc] p1: At most one storage-class-specifier shall appear
-    in a given decl-specifier-seq, except that `thread_local`
-    may appear with `static` or `extern`.
-*/
-enum class StorageClassKind
-{
-    /// No storage class specifier
-    None = 0,
-    /// thread_local storage-class-specifier
-    Extern,
-    /// mutable storage-class-specifier
-    Static,
-    /// auto storage-class-specifier (removed in C++11)
-    /// only valid for variables
-    Auto,
-    /// register storage-class-specifier (removed in C++17)
-    /// only valid for variables
-    Register
-};
-
-MRDOCS_DECL dom::String toString(AccessKind kind) noexcept;
-MRDOCS_DECL dom::String toString(ConstexprKind kind) noexcept;
-MRDOCS_DECL dom::String toString(ExplicitKind kind) noexcept;
-MRDOCS_DECL dom::String toString(NoexceptKind kind) noexcept;
-MRDOCS_DECL dom::String toString(ReferenceKind kind) noexcept;
-MRDOCS_DECL dom::String toString(StorageClassKind kind) noexcept;
-
-/** Convert NoexceptInfo to a string.
-
-    @param info The noexcept-specifier information.
-
-    @param resolved If true, the operand is not shown when
-    the exception specification is non-dependent.
-
-    @param implicit If true, implicit exception specifications
-    are shown.
-
-    @return The string representation of the noexcept-specifier.
-*/
-MRDOCS_DECL
-dom::String
-toString(
-    NoexceptInfo const& info,
-    bool resolved = false,
-    bool implicit = false);
-
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    NoexceptInfo const& info)
-{
-    v = toString(info, false, false);
-}
-
-/** Convert ExplicitInfo to a string.
-
-    @param info The explicit-specifier information.
-    @param resolved If true, the operand is not shown when
-    the explicit-specifier is non-dependent.
-    @param implicit If true, implicit explicit-specifiers are shown.
-    @return The string representation of the explicit-specifier.
-*/
-MRDOCS_DECL
-dom::String
-toString(
-    ExplicitInfo const& info,
-    bool resolved = false,
-    bool implicit = false);
-
-/** Return the ExplicitInfo as a @ref dom::Value string.
-
-    @param v The output parameter to receive the dom::Value.
-    @param I The ExplicitInfo to convert.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    ExplicitInfo const& I)
-{
-    v = toString(I);
-}
-
-/** Return the AccessKind as a @ref dom::Value string.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    AccessKind const kind)
-{
-    v = toString(kind);
-}
-
-/** Return the ConstexprKind as a @ref dom::Value string.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    ConstexprKind const kind)
-{
-    v = toString(kind);
-}
-
-/** Return the StorageClassKind as a @ref dom::Value string.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    StorageClassKind const kind)
-{
-    v = toString(kind);
-}
-
-/** Return the ReferenceKind as a @ref dom::Value string.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    ReferenceKind kind)
-{
-    v = toString(kind);
-}
-
-} // clang::mrdocs
+#include <mrdocs/Metadata/Specifiers/AccessKind.hpp>
+#include <mrdocs/Metadata/Specifiers/ConstexprKind.hpp>
+#include <mrdocs/Metadata/Specifiers/ExplicitInfo.hpp>
+#include <mrdocs/Metadata/Specifiers/ExplicitKind.hpp>
+#include <mrdocs/Metadata/Specifiers/NoexceptInfo.hpp>
+#include <mrdocs/Metadata/Specifiers/NoexceptKind.hpp>
+#include <mrdocs/Metadata/Specifiers/OperatorKind.hpp>
+#include <mrdocs/Metadata/Specifiers/ReferenceKind.hpp>
+#include <mrdocs/Metadata/Specifiers/StorageClassKind.hpp>
 
 #endif
diff --git a/include/mrdocs/Metadata/Specifiers/AccessKind.hpp b/include/mrdocs/Metadata/Specifiers/AccessKind.hpp
new file mode 100644
index 000000000..d75bb5b38
--- /dev/null
+++ b/include/mrdocs/Metadata/Specifiers/AccessKind.hpp
@@ -0,0 +1,62 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2023 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_SPECIFIERS_ACCESSKIND_HPP
+#define MRDOCS_API_METADATA_SPECIFIERS_ACCESSKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+#include <string>
+
+namespace clang::mrdocs {
+
+/** Access specifier.
+
+    None is set to zero since it is the most
+    frequently occurring access, and it is
+    elided by the bitstream encoder because it
+    has an all-zero bit pattern. This improves
+    compression in the bitstream.
+
+    None is used for namespace members and friend;
+    such declarations have no access.
+*/
+enum class AccessKind
+{
+    /// Unspecified access
+    None = 0,
+    /// Public access
+    Public,
+    /// Protected access
+    Protected,
+    /// Private access
+    Private,
+};
+
+MRDOCS_DECL
+dom::String
+toString(AccessKind kind) noexcept;
+
+/** Return the AccessKind as a @ref dom::Value string.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    AccessKind const kind)
+{
+    v = toString(kind);
+}
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Specifiers/ConstexprKind.hpp b/include/mrdocs/Metadata/Specifiers/ConstexprKind.hpp
new file mode 100644
index 000000000..9e1297229
--- /dev/null
+++ b/include/mrdocs/Metadata/Specifiers/ConstexprKind.hpp
@@ -0,0 +1,54 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2023 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_SPECIFIERS_CONSTEXPRKIND_HPP
+#define MRDOCS_API_METADATA_SPECIFIERS_CONSTEXPRKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <string>
+
+namespace clang::mrdocs {
+
+/** `constexpr`/`consteval` specifier kinds
+
+    [dcl.spec.general] p2: At most one of the `constexpr`, `consteval`,
+    and `constinit` keywords shall appear in a decl-specifier-seq
+*/
+enum class ConstexprKind
+{
+    /// No `constexpr` or `consteval` specifier
+    None = 0,
+    /// The `constexpr` specifier
+    Constexpr,
+    /// The `consteval` specifier
+    /// only valid for functions
+    Consteval,
+};
+
+MRDOCS_DECL
+dom::String
+toString(ConstexprKind kind) noexcept;
+
+/** Return the ConstexprKind as a @ref dom::Value string.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    ConstexprKind const kind)
+{
+    v = toString(kind);
+}
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Specifiers/ExplicitInfo.hpp b/include/mrdocs/Metadata/Specifiers/ExplicitInfo.hpp
new file mode 100644
index 000000000..68df0c813
--- /dev/null
+++ b/include/mrdocs/Metadata/Specifiers/ExplicitInfo.hpp
@@ -0,0 +1,75 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2023 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_SPECIFIERS_EXPLICITINFO_HPP
+#define MRDOCS_API_METADATA_SPECIFIERS_EXPLICITINFO_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Specifiers/ExplicitKind.hpp>
+#include <string>
+
+namespace clang::mrdocs {
+
+/**
+    Stores only the operand of the explicit-specifier or noexcept-specifier as a string.
+    The complete expression is not preserved at this time.
+    This is a temporary design and may be improved in the future.
+*/
+struct ExplicitInfo
+{
+    /** Whether an explicit-specifier was user-written.
+    */
+    bool Implicit = true;
+
+    /** The evaluated exception specification.
+    */
+    ExplicitKind Kind = ExplicitKind::False;
+
+    /** The operand of the explicit-specifier, if any.
+    */
+    std::string Operand;
+
+    auto operator<=>(ExplicitInfo const&) const = default;
+};
+
+/** Convert ExplicitInfo to a string.
+
+    @param info The explicit-specifier information.
+    @param resolved If true, the operand is not shown when
+    the explicit-specifier is non-dependent.
+    @param implicit If true, implicit explicit-specifiers are shown.
+    @return The string representation of the explicit-specifier.
+*/
+MRDOCS_DECL
+dom::String
+toString(
+    ExplicitInfo const& info,
+    bool resolved = false,
+    bool implicit = false);
+
+/** Return the ExplicitInfo as a @ref dom::Value string.
+
+    @param v The output parameter to receive the dom::Value.
+    @param I The ExplicitInfo to convert.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    ExplicitInfo const& I)
+{
+    v = toString(I);
+}
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Specifiers/ExplicitKind.hpp b/include/mrdocs/Metadata/Specifiers/ExplicitKind.hpp
new file mode 100644
index 000000000..ca3669637
--- /dev/null
+++ b/include/mrdocs/Metadata/Specifiers/ExplicitKind.hpp
@@ -0,0 +1,42 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2023 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_SPECIFIERS_EXPLICITKIND_HPP
+#define MRDOCS_API_METADATA_SPECIFIERS_EXPLICITKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom/String.hpp>
+#include <string>
+
+namespace clang::mrdocs {
+
+/** Explicit specifier kinds
+*/
+enum class ExplicitKind
+{
+    /** No explicit-specifier or explicit-specifier evaluated to false
+    */
+    False = 0,
+    /** explicit-specifier evaluates to true
+    */
+    True,
+    /** Dependent explicit-specifier
+    */
+    Dependent
+};
+
+MRDOCS_DECL
+dom::String
+toString(ExplicitKind kind) noexcept;
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Specifiers/NoexceptInfo.hpp b/include/mrdocs/Metadata/Specifiers/NoexceptInfo.hpp
new file mode 100644
index 000000000..dd98b4deb
--- /dev/null
+++ b/include/mrdocs/Metadata/Specifiers/NoexceptInfo.hpp
@@ -0,0 +1,74 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2023 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_SPECIFIERS_NOEXCEPTINFO_HPP
+#define MRDOCS_API_METADATA_SPECIFIERS_NOEXCEPTINFO_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Specifiers/AccessKind.hpp>
+#include <mrdocs/Metadata/Specifiers/ConstexprKind.hpp>
+#include <mrdocs/Metadata/Specifiers/ExplicitInfo.hpp>
+#include <mrdocs/Metadata/Specifiers/ExplicitKind.hpp>
+#include <mrdocs/Metadata/Specifiers/NoexceptKind.hpp>
+#include <string>
+
+namespace clang::mrdocs {
+
+// KRYSTIAN FIXME: this needs to be improved (a lot)
+struct NoexceptInfo
+{
+    /** Whether a noexcept-specifier was user-written.
+    */
+    bool Implicit = true;
+
+    /** The evaluated exception specification.
+    */
+    NoexceptKind Kind = NoexceptKind::False;
+
+    /** The operand of the noexcept-specifier, if any.
+    */
+    std::string Operand;
+
+    auto operator<=>(NoexceptInfo const&) const = default;
+};
+
+/** Convert NoexceptInfo to a string.
+
+    @param info The noexcept-specifier information.
+
+    @param resolved If true, the operand is not shown when
+    the exception specification is non-dependent.
+
+    @param implicit If true, implicit exception specifications
+    are shown.
+
+    @return The string representation of the noexcept-specifier.
+*/
+MRDOCS_DECL
+dom::String
+toString(
+    NoexceptInfo const& info,
+    bool resolved = false,
+    bool implicit = false);
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    NoexceptInfo const& info)
+{
+    v = toString(info, false, false);
+}
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Specifiers/NoexceptKind.hpp b/include/mrdocs/Metadata/Specifiers/NoexceptKind.hpp
new file mode 100644
index 000000000..08544d496
--- /dev/null
+++ b/include/mrdocs/Metadata/Specifiers/NoexceptKind.hpp
@@ -0,0 +1,42 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2023 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_SPECIFIERS_NOEXCEPTKIND_HPP
+#define MRDOCS_API_METADATA_SPECIFIERS_NOEXCEPTKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom/String.hpp>
+#include <string>
+
+namespace clang::mrdocs {
+
+/** Exception specification kinds
+*/
+enum class NoexceptKind
+{
+    /** Potentially-throwing exception specification
+    */
+    False = 0,
+    /** Non-throwing exception specification
+    */
+    True,
+    /** Dependent exception specification
+    */
+    Dependent
+};
+
+MRDOCS_DECL
+dom::String
+toString(NoexceptKind kind) noexcept;
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Specifiers/OperatorKind.hpp b/include/mrdocs/Metadata/Specifiers/OperatorKind.hpp
new file mode 100644
index 000000000..879a35424
--- /dev/null
+++ b/include/mrdocs/Metadata/Specifiers/OperatorKind.hpp
@@ -0,0 +1,206 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2023 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_SPECIFIERS_OPERATORKIND_HPP
+#define MRDOCS_API_METADATA_SPECIFIERS_OPERATORKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom/String.hpp>
+#include <string>
+
+namespace clang::mrdocs {
+
+/** Operator kinds
+*/
+enum class OperatorKind
+{
+    /// No operator
+    None = 0,
+    /// The `new` Operator
+    New,
+    /// The `delete` Operator
+    Delete,
+    /// The `new[]` Operator
+    ArrayNew,
+    /// The `delete[]` Operator
+    ArrayDelete,
+    /// The + Operator
+    Plus,
+    /// The - Operator
+    Minus,
+    /// The * Operator
+    Star,
+    /// The / Operator
+    Slash,
+    /// The % Operator
+    Percent,
+    /// The ^ Operator
+    Caret,
+    /// The & Operator
+    Amp,
+    /// The | Operator
+    Pipe,
+    /// The ~ Operator
+    Tilde,
+    /// The ! Operator
+    Equal,
+    /// The += Operator
+    PlusEqual,
+    /// The -= Operator
+    MinusEqual,
+    /// The *= Operator
+    StarEqual,
+    /// The /= Operator
+    SlashEqual,
+    /// The %= Operator
+    PercentEqual,
+    /// The ^= Operator
+    CaretEqual,
+    /// The &= Operator
+    AmpEqual,
+    /// The |= Operator
+    PipeEqual,
+    /// The << Operator
+    LessLess,
+    /// The >> Operator
+    GreaterGreater,
+    /// The <<= Operator
+    LessLessEqual,
+    /// The >>= Operator
+    GreaterGreaterEqual,
+
+    // Relational operators
+    /// The ! Operator
+    Exclaim,
+    /// The == Operator
+    EqualEqual,
+    /// The != Operator
+    ExclaimEqual,
+    /// The < Operator
+    Less,
+    /// The <= Operator
+    LessEqual,
+    /// The > Operator
+    Greater,
+    /// The >= Operator
+    GreaterEqual,
+    /// The <=> Operator
+    Spaceship,
+
+    /// The && Operator
+    AmpAmp,
+    /// The || Operator
+    PipePipe,
+    /// The ++ Operator
+    PlusPlus,
+    /// The -- Operator
+    MinusMinus,
+    /// The , Operator
+    Comma,
+    /// The ->* Operator
+    ArrowStar,
+    /// The -> Operator
+    Arrow,
+    /// The () Operator
+    Call,
+    /// The [] Operator
+    Subscript,
+    /// The `? :` Operator
+    Conditional,
+    /// The `coawait` Operator
+    Coawait,
+};
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    OperatorKind kind)
+{
+    v = static_cast<std::underlying_type_t<OperatorKind>>(kind);
+}
+
+/** Determines whether the operator is potentially unary.
+ */
+MRDOCS_DECL
+bool
+isUnaryOperator(OperatorKind kind) noexcept;
+
+/** Determines whether the operator is potentially binary.
+ */
+MRDOCS_DECL
+bool
+isBinaryOperator(OperatorKind kind) noexcept;
+
+/** Return the name of an operator as a string.
+
+    @param kind The kind of operator.
+    @param include_keyword Whether the name
+    should be prefixed with the `operator` keyword.
+*/
+MRDOCS_DECL
+std::string_view
+getOperatorName(
+    OperatorKind kind,
+    bool include_keyword = false) noexcept;
+
+/** Return the short name of an operator as a string.
+*/
+MRDOCS_DECL
+std::string_view
+getShortOperatorName(
+    OperatorKind kind) noexcept;
+
+/** Return the short name of an operator as a string.
+
+    @param name The operator name, e.g. `operator+`, `operator++`, `operator[]`, etc.
+    @return The OperatorKind, or OperatorKind::None if not recognized.
+*/
+MRDOCS_DECL
+OperatorKind
+getOperatorKind(std::string_view name) noexcept;
+
+/** Return the short name of an operator as a string.
+
+    @param suffix The operator suffix, e.g. `+`, `++`, `[]`, etc.
+    @return The OperatorKind, or OperatorKind::None if not recognized.
+*/
+MRDOCS_DECL
+OperatorKind
+getOperatorKindFromSuffix(std::string_view suffix) noexcept;
+
+/** Return the safe name of an operator as a string.
+
+    @param kind The kind of operator.
+    @param include_keyword Whether the name
+    should be prefixed with `operator_`.
+*/
+MRDOCS_DECL
+std::string_view
+getSafeOperatorName(
+    OperatorKind kind,
+    bool include_keyword = false) noexcept;
+
+/** Return the human-readable name of the operator
+
+    @param kind The kind of operator.
+    @param nParams The number of parameters the operator takes.
+    @return The readable name, or nullopt if the operator is not recognized.
+ */
+std::optional<std::string_view>
+getOperatorReadableName(
+    OperatorKind kind,
+    int nParams);
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Specifiers/ReferenceKind.hpp b/include/mrdocs/Metadata/Specifiers/ReferenceKind.hpp
new file mode 100644
index 000000000..f5b526e68
--- /dev/null
+++ b/include/mrdocs/Metadata/Specifiers/ReferenceKind.hpp
@@ -0,0 +1,49 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2023 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_SPECIFIERS_REFERENCEKIND_HPP
+#define MRDOCS_API_METADATA_SPECIFIERS_REFERENCEKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+#include <string>
+
+namespace clang::mrdocs {
+
+/** Reference type kinds
+*/
+enum class ReferenceKind
+{
+    /// Not a reference
+    None = 0,
+    /// An L-Value reference
+    LValue,
+    /// An R-Value reference
+    RValue
+};
+
+MRDOCS_DECL dom::String toString(ReferenceKind kind) noexcept;
+
+/** Return the ReferenceKind as a @ref dom::Value string.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    ReferenceKind kind)
+{
+    v = toString(kind);
+}
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Specifiers/StorageClassKind.hpp b/include/mrdocs/Metadata/Specifiers/StorageClassKind.hpp
new file mode 100644
index 000000000..44a241d7f
--- /dev/null
+++ b/include/mrdocs/Metadata/Specifiers/StorageClassKind.hpp
@@ -0,0 +1,61 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2023 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_SPECIFIERS_STORAGECLASSKIND_HPP
+#define MRDOCS_API_METADATA_SPECIFIERS_STORAGECLASSKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+#include <string>
+
+namespace clang::mrdocs {
+
+/** Storage class kinds
+
+    [dcl.stc] p1: At most one storage-class-specifier shall appear
+    in a given decl-specifier-seq, except that `thread_local`
+    may appear with `static` or `extern`.
+*/
+enum class StorageClassKind
+{
+    /// No storage class specifier
+    None = 0,
+    /// thread_local storage-class-specifier
+    Extern,
+    /// mutable storage-class-specifier
+    Static,
+    /// auto storage-class-specifier (removed in C++11)
+    /// only valid for variables
+    Auto,
+    /// register storage-class-specifier (removed in C++17)
+    /// only valid for variables
+    Register
+};
+
+MRDOCS_DECL
+dom::String
+toString(StorageClassKind kind) noexcept;
+
+/** Return the StorageClassKind as a @ref dom::Value string.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    StorageClassKind const kind)
+{
+    v = toString(kind);
+}
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/TArg.hpp b/include/mrdocs/Metadata/TArg.hpp
new file mode 100644
index 000000000..0094ce2ea
--- /dev/null
+++ b/include/mrdocs/Metadata/TArg.hpp
@@ -0,0 +1,77 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2024 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TARG_HPP
+#define MRDOCS_API_METADATA_TARG_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/TArg/NonTypeTArg.hpp>
+#include <mrdocs/Metadata/TArg/TArgBase.hpp>
+#include <mrdocs/Metadata/TArg/TemplateTArg.hpp>
+#include <mrdocs/Metadata/TArg/TypeTArg.hpp>
+
+namespace clang::mrdocs {
+
+template<
+    std::derived_from<TArg> TArgTy,
+    class F,
+    class... Args>
+constexpr
+decltype(auto)
+visit(
+    TArgTy& A,
+    F&& f,
+    Args&&... args)
+{
+    switch(A.Kind)
+    {
+    case TArgKind::Type:
+        return f(static_cast<add_cv_from_t<
+            TArgTy, TypeTArg>&>(A),
+            std::forward<Args>(args)...);
+    case TArgKind::NonType:
+        return f(static_cast<add_cv_from_t<
+            TArgTy, NonTypeTArg>&>(A),
+            std::forward<Args>(args)...);
+    case TArgKind::Template:
+        return f(static_cast<add_cv_from_t<
+            TArgTy, TemplateTArg>&>(A),
+            std::forward<Args>(args)...);
+    default:
+        MRDOCS_UNREACHABLE();
+    }
+}
+
+MRDOCS_DECL
+std::strong_ordering
+operator<=>(Polymorphic<TArg> const& lhs, Polymorphic<TArg> const& rhs);
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Polymorphic<TArg> const& I,
+    DomCorpus const* domCorpus)
+{
+    if (I.valueless_after_move())
+    {
+        v = nullptr;
+        return;
+    }
+    tag_invoke(dom::ValueFromTag{}, v, *I, domCorpus);
+}
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/TArg/NonTypeTArg.hpp b/include/mrdocs/Metadata/TArg/NonTypeTArg.hpp
new file mode 100644
index 000000000..f3cad9dcd
--- /dev/null
+++ b/include/mrdocs/Metadata/TArg/NonTypeTArg.hpp
@@ -0,0 +1,34 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2024 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TARG_NONTYPETARG_HPP
+#define MRDOCS_API_METADATA_TARG_NONTYPETARG_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Expression.hpp>
+#include <mrdocs/Metadata/TArg/TArgBase.hpp>
+
+namespace clang::mrdocs {
+
+struct NonTypeTArg final
+    : TArgCommonBase<TArgKind::NonType>
+{
+    /** Template argument expression. */
+    ExprInfo Value;
+
+    auto operator<=>(NonTypeTArg const&) const = default;
+};
+
+} // clang::mrdocs
+
+#endif // MRDOCS_API_METADATA_TARG_NONTYPETARG_HPP
diff --git a/include/mrdocs/Metadata/TArg/TArgBase.hpp b/include/mrdocs/Metadata/TArg/TArgBase.hpp
new file mode 100644
index 000000000..2aadc8d7f
--- /dev/null
+++ b/include/mrdocs/Metadata/TArg/TArgBase.hpp
@@ -0,0 +1,78 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2024 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TARG_TARGBASE_HPP
+#define MRDOCS_API_METADATA_TARG_TARGBASE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/TArg/TArgKind.hpp>
+
+namespace clang::mrdocs {
+
+struct TArg
+{
+    /** The kind of template argument this is. */
+    TArgKind Kind;
+
+    /** Whether this template argument is a parameter expansion. */
+    bool IsPackExpansion = false;
+
+    constexpr virtual ~TArg() = default;
+
+    constexpr bool isType()     const noexcept { return Kind == TArgKind::Type; }
+    constexpr bool isNonType()  const noexcept { return Kind == TArgKind::NonType; }
+    constexpr bool isTemplate() const noexcept { return Kind == TArgKind::Template; }
+
+    auto operator<=>(TArg const&) const = default;
+
+protected:
+    constexpr
+    TArg(
+        TArgKind kind) noexcept
+        : Kind(kind)
+    {
+    }
+};
+
+template<TArgKind K>
+struct TArgCommonBase : TArg
+{
+    static constexpr TArgKind kind_id = K;
+
+    static constexpr bool isType()     noexcept { return K == TArgKind::Type; }
+    static constexpr bool isNonType()  noexcept { return K == TArgKind::NonType; }
+    static constexpr bool isTemplate() noexcept { return K == TArgKind::Template; }
+
+protected:
+    constexpr
+    TArgCommonBase() noexcept
+        : TArg(K)
+    {
+    }
+};
+
+MRDOCS_DECL
+std::string
+toString(TArg const& arg) noexcept;
+
+MRDOCS_DECL
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    TArg const& I,
+    DomCorpus const* domCorpus);
+
+} // clang::mrdocs
+
+#endif // MRDOCS_API_METADATA_TARG_TARGBASE_HPP
diff --git a/include/mrdocs/Metadata/TArg/TArgKind.hpp b/include/mrdocs/Metadata/TArg/TArgKind.hpp
new file mode 100644
index 000000000..d14174765
--- /dev/null
+++ b/include/mrdocs/Metadata/TArg/TArgKind.hpp
@@ -0,0 +1,51 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2024 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TARG_TARGKIND_HPP
+#define MRDOCS_API_METADATA_TARG_TARGKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+#include <string_view>
+
+namespace clang::mrdocs {
+
+/** The kind of template argument.
+*/
+enum class TArgKind : int
+{
+    /// type arguments
+    Type = 1, // for bitstream
+    /// non-type arguments, i.e. expressions
+    NonType,
+    /// template template arguments, i.e. template names
+    Template
+};
+
+MRDOCS_DECL
+std::string_view
+toString(TArgKind kind) noexcept;
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    TArgKind kind)
+{
+    v = toString(kind);
+}
+
+} // clang::mrdocs
+
+#endif // MRDOCS_API_METADATA_TARG_TARGKIND_HPP
diff --git a/include/mrdocs/Metadata/TArg/TemplateTArg.hpp b/include/mrdocs/Metadata/TArg/TemplateTArg.hpp
new file mode 100644
index 000000000..29db0c23d
--- /dev/null
+++ b/include/mrdocs/Metadata/TArg/TemplateTArg.hpp
@@ -0,0 +1,38 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2024 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TARG_TEMPLATETARG_HPP
+#define MRDOCS_API_METADATA_TARG_TEMPLATETARG_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/TArg/NonTypeTArg.hpp>
+#include <mrdocs/Metadata/TArg/TArgBase.hpp>
+#include <mrdocs/Metadata/TArg/TypeTArg.hpp>
+
+namespace clang::mrdocs {
+
+struct TemplateTArg final
+    : TArgCommonBase<TArgKind::Template>
+{
+    /** SymbolID of the referenced template. */
+    SymbolID Template;
+
+    /** Name of the referenced template. */
+    std::string Name;
+
+    auto operator<=>(TemplateTArg const&) const = default;
+};
+
+} // clang::mrdocs
+
+#endif // MRDOCS_API_METADATA_TARG_TEMPLATETARG_HPP
diff --git a/include/mrdocs/Metadata/TArg/TypeTArg.hpp b/include/mrdocs/Metadata/TArg/TypeTArg.hpp
new file mode 100644
index 000000000..642ec2d4a
--- /dev/null
+++ b/include/mrdocs/Metadata/TArg/TypeTArg.hpp
@@ -0,0 +1,34 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2024 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TARG_TYPETARG_HPP
+#define MRDOCS_API_METADATA_TARG_TYPETARG_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/TArg/TArgBase.hpp>
+#include <mrdocs/Metadata/Type.hpp>
+
+namespace clang::mrdocs {
+
+struct TypeTArg final
+    : TArgCommonBase<TArgKind::Type>
+{
+    /** Template argument type. */
+    Optional<Polymorphic<TypeInfo>> Type = std::nullopt;
+
+    auto operator<=>(TypeTArg const&) const = default;
+};
+
+} // clang::mrdocs
+
+#endif // MRDOCS_API_METADATA_TARG_TYPETARG_HPP
diff --git a/include/mrdocs/Metadata/TParam.hpp b/include/mrdocs/Metadata/TParam.hpp
new file mode 100644
index 000000000..9831a87f5
--- /dev/null
+++ b/include/mrdocs/Metadata/TParam.hpp
@@ -0,0 +1,85 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2024 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TPARAM_HPP
+#define MRDOCS_API_METADATA_TPARAM_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/TParam/NonTypeTParam.hpp>
+#include <mrdocs/Metadata/TParam/TParamBase.hpp>
+#include <mrdocs/Metadata/TParam/TemplateTParam.hpp>
+#include <mrdocs/Metadata/TParam/TypeTParam.hpp>
+
+namespace clang::mrdocs {
+
+template<
+    typename TParamTy,
+    typename F,
+    typename... Args>
+    requires std::derived_from<TParamTy, TParam>
+constexpr
+decltype(auto)
+visit(
+    TParamTy& P,
+    F&& f,
+    Args&&... args)
+{
+    switch(P.Kind)
+    {
+    case TParamKind::Type:
+        return f(static_cast<add_cv_from_t<
+            TParamTy, TypeTParam>&>(P),
+            std::forward<Args>(args)...);
+    case TParamKind::NonType:
+        return f(static_cast<add_cv_from_t<
+            TParamTy, NonTypeTParam>&>(P),
+            std::forward<Args>(args)...);
+    case TParamKind::Template:
+        return f(static_cast<add_cv_from_t<
+            TParamTy, TemplateTParam>&>(P),
+            std::forward<Args>(args)...);
+    default:
+        MRDOCS_UNREACHABLE();
+    }
+}
+
+MRDOCS_DECL
+std::strong_ordering
+operator<=>(Polymorphic<TParam> const& lhs, Polymorphic<TParam> const& rhs);
+
+inline
+bool
+operator==(Polymorphic<TParam> const& lhs, Polymorphic<TParam> const& rhs) {
+    return lhs <=> rhs == std::strong_ordering::equal;
+}
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Polymorphic<TParam> const& I,
+    DomCorpus const* domCorpus)
+{
+    if (I.valueless_after_move())
+    {
+        v = nullptr;
+        return;
+    }
+    tag_invoke(dom::ValueFromTag{}, v, *I, domCorpus);
+}
+
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/TParam/NonTypeTParam.hpp b/include/mrdocs/Metadata/TParam/NonTypeTParam.hpp
new file mode 100644
index 000000000..2bd1e70f7
--- /dev/null
+++ b/include/mrdocs/Metadata/TParam/NonTypeTParam.hpp
@@ -0,0 +1,36 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2024 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TPARAM_NONTYPETPARAM_HPP
+#define MRDOCS_API_METADATA_TPARAM_NONTYPETPARAM_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Optional.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/TParam/TParamBase.hpp>
+#include <mrdocs/Metadata/Type/TypeBase.hpp>
+
+namespace clang::mrdocs {
+
+struct NonTypeTParam final
+    : TParamCommonBase<TParamKind::NonType>
+{
+    /** Type of the non-type template parameter */
+    Optional<Polymorphic<TypeInfo>> Type = std::nullopt;
+
+    std::strong_ordering operator<=>(NonTypeTParam const&) const;
+};
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/TParam/TParamBase.hpp b/include/mrdocs/Metadata/TParam/TParamBase.hpp
new file mode 100644
index 000000000..a58d91435
--- /dev/null
+++ b/include/mrdocs/Metadata/TParam/TParamBase.hpp
@@ -0,0 +1,86 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2024 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TPARAM_TPARAMBASE_HPP
+#define MRDOCS_API_METADATA_TPARAM_TPARAMBASE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/TArg/TArgBase.hpp>
+#include <mrdocs/Metadata/TParam/TParamKind.hpp>
+#include <string>
+
+namespace clang::mrdocs {
+
+class DomCorpus;
+
+struct TParam
+{
+    /** The kind of template parameter this is */
+    TParamKind Kind;
+
+    /** The template parameters name, if any */
+    std::string Name;
+
+    /** Whether this template parameter is a parameter pack */
+    bool IsParameterPack = false;
+
+    /** The default template argument, if any */
+    Optional<Polymorphic<TArg>> Default = std::nullopt;
+
+    constexpr virtual ~TParam() = default;
+
+    constexpr bool isType()     const noexcept { return Kind == TParamKind::Type; }
+    constexpr bool isNonType()  const noexcept { return Kind == TParamKind::NonType; }
+    constexpr bool isTemplate() const noexcept { return Kind == TParamKind::Template; }
+
+    std::strong_ordering operator<=>(TParam const&) const;
+
+protected:
+    constexpr
+    TParam(
+        TParamKind kind) noexcept
+        : Kind(kind)
+    {
+    }
+};
+
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    TParam const& I,
+    DomCorpus const* domCorpus);
+
+template<TParamKind K>
+struct TParamCommonBase : TParam
+{
+    static constexpr TParamKind kind_id = K;
+
+    static constexpr bool isType()     noexcept { return K == TParamKind::Type; }
+    static constexpr bool isNonType()  noexcept { return K == TParamKind::NonType; }
+    static constexpr bool isTemplate() noexcept { return K == TParamKind::Template; }
+
+    auto operator<=>(TParamCommonBase const&) const = default;
+
+protected:
+    constexpr
+    TParamCommonBase() noexcept
+        : TParam(K)
+    {
+    }
+};
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/TParam/TParamKeyKind.hpp b/include/mrdocs/Metadata/TParam/TParamKeyKind.hpp
new file mode 100644
index 000000000..53dd13e15
--- /dev/null
+++ b/include/mrdocs/Metadata/TParam/TParamKeyKind.hpp
@@ -0,0 +1,48 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2024 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TPARAM_TPARAMKEYKIND_HPP
+#define MRDOCS_API_METADATA_TPARAM_TPARAMKEYKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+#include <string_view>
+
+namespace clang::mrdocs {
+
+/** The keyword a template parameter was declared with */
+enum class TParamKeyKind : int
+{
+    /// Class keyword
+    Class = 0,
+    /// Typename keyword
+    Typename
+};
+
+MRDOCS_DECL
+std::string_view
+toString(TParamKeyKind kind) noexcept;
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    TParamKeyKind kind)
+{
+    v = toString(kind);
+}
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/TParam/TParamKind.hpp b/include/mrdocs/Metadata/TParam/TParamKind.hpp
new file mode 100644
index 000000000..8af7b910b
--- /dev/null
+++ b/include/mrdocs/Metadata/TParam/TParamKind.hpp
@@ -0,0 +1,36 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2024 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TPARAM_TPARAMKIND_HPP
+#define MRDOCS_API_METADATA_TPARAM_TPARAMKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <string_view>
+
+namespace clang::mrdocs {
+
+enum class TParamKind : int
+{
+    /// Template type parameter, e.g. "typename T" or "class T"
+    Type = 1, // for bitstream
+    /// Template non-type parameter, e.g. "int N" or "auto N"
+    NonType,
+    /// Template-template parameter, e.g. "template<typename> typename T"
+    Template
+};
+
+MRDOCS_DECL std::string_view toString(TParamKind kind) noexcept;
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/TParam/TemplateTParam.hpp b/include/mrdocs/Metadata/TParam/TemplateTParam.hpp
new file mode 100644
index 000000000..77daee36c
--- /dev/null
+++ b/include/mrdocs/Metadata/TParam/TemplateTParam.hpp
@@ -0,0 +1,36 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2024 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TPARAM_TEMPLATETPARAM_HPP
+#define MRDOCS_API_METADATA_TPARAM_TEMPLATETPARAM_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/TParam/TParamBase.hpp>
+#include <vector>
+
+namespace clang::mrdocs {
+
+struct TemplateTParam final
+    : TParamCommonBase<TParamKind::Template>
+{
+    /** Template parameters for the template-template parameter */
+    std::vector<Polymorphic<TParam>> Params;
+
+    std::strong_ordering
+    operator<=>(TemplateTParam const& other) const;
+};
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/TParam/TypeTParam.hpp b/include/mrdocs/Metadata/TParam/TypeTParam.hpp
new file mode 100644
index 000000000..796dd682d
--- /dev/null
+++ b/include/mrdocs/Metadata/TParam/TypeTParam.hpp
@@ -0,0 +1,40 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2024 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TPARAM_TYPETPARAM_HPP
+#define MRDOCS_API_METADATA_TPARAM_TYPETPARAM_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Optional.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/Name/NameBase.hpp>
+#include <mrdocs/Metadata/TParam/TParamBase.hpp>
+#include <mrdocs/Metadata/TParam/TParamKeyKind.hpp>
+
+namespace clang::mrdocs {
+
+struct TypeTParam final
+    : TParamCommonBase<TParamKind::Type>
+{
+    /** Keyword (class/typename) the parameter uses */
+    TParamKeyKind KeyKind = TParamKeyKind::Class;
+
+    /** The type-constraint for the parameter, if any. */
+    Optional<Polymorphic<NameInfo>> Constraint = std::nullopt;
+
+    std::strong_ordering operator<=>(TypeTParam const&) const;
+};
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Template.hpp b/include/mrdocs/Metadata/Template.hpp
index bc2836bec..47ad0180b 100644
--- a/include/mrdocs/Metadata/Template.hpp
+++ b/include/mrdocs/Metadata/Template.hpp
@@ -16,359 +16,14 @@
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
-#include <mrdocs/Metadata/Type.hpp>
-#include <mrdocs/Support/TypeTraits.hpp>
-#include <optional>
-#include <string>
+#include <mrdocs/Metadata/Expression.hpp>
+#include <mrdocs/Metadata/Info/SymbolID.hpp>
+#include <mrdocs/Metadata/TArg.hpp>
+#include <mrdocs/Metadata/TParam.hpp>
 #include <vector>
 
 namespace clang::mrdocs {
 
-/** The kind of template argument.
-*/
-enum class TArgKind : int
-{
-    /// type arguments
-    Type = 1, // for bitstream
-    /// non-type arguments, i.e. expressions
-    NonType,
-    /// template template arguments, i.e. template names
-    Template
-};
-
-MRDOCS_DECL
-std::string_view
-toString(TArgKind kind) noexcept;
-
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    TArgKind kind)
-{
-    v = toString(kind);
-}
-
-struct TArg
-{
-    /** The kind of template argument this is. */
-    TArgKind Kind;
-
-    /** Whether this template argument is a parameter expansion. */
-    bool IsPackExpansion = false;
-
-    constexpr virtual ~TArg() = default;
-
-    constexpr bool isType()     const noexcept { return Kind == TArgKind::Type; }
-    constexpr bool isNonType()  const noexcept { return Kind == TArgKind::NonType; }
-    constexpr bool isTemplate() const noexcept { return Kind == TArgKind::Template; }
-
-    auto operator<=>(TArg const&) const = default;
-
-protected:
-    constexpr
-    TArg(
-        TArgKind kind) noexcept
-        : Kind(kind)
-    {
-    }
-};
-
-template<TArgKind K>
-struct IsTArg : TArg
-{
-    static constexpr TArgKind kind_id = K;
-
-    static constexpr bool isType()     noexcept { return K == TArgKind::Type; }
-    static constexpr bool isNonType()  noexcept { return K == TArgKind::NonType; }
-    static constexpr bool isTemplate() noexcept { return K == TArgKind::Template; }
-
-protected:
-    constexpr
-    IsTArg() noexcept
-        : TArg(K)
-    {
-    }
-};
-
-struct TypeTArg final
-    : IsTArg<TArgKind::Type>
-{
-    /** Template argument type. */
-    Polymorphic<TypeInfo> Type = std::nullopt;
-
-    auto operator<=>(TypeTArg const&) const = default;
-};
-
-
-struct NonTypeTArg final
-    : IsTArg<TArgKind::NonType>
-{
-    /** Template argument expression. */
-    ExprInfo Value;
-
-    auto operator<=>(NonTypeTArg const&) const = default;
-};
-
-struct TemplateTArg final
-    : IsTArg<TArgKind::Template>
-{
-    /** SymbolID of the referenced template. */
-    SymbolID Template;
-
-    /** Name of the referenced template. */
-    std::string Name;
-
-    auto operator<=>(TemplateTArg const&) const = default;
-};
-
-template<
-    std::derived_from<TArg> TArgTy,
-    class F,
-    class... Args>
-constexpr
-decltype(auto)
-visit(
-    TArgTy& A,
-    F&& f,
-    Args&&... args)
-{
-    switch(A.Kind)
-    {
-    case TArgKind::Type:
-        return f(static_cast<add_cv_from_t<
-            TArgTy, TypeTArg>&>(A),
-            std::forward<Args>(args)...);
-    case TArgKind::NonType:
-        return f(static_cast<add_cv_from_t<
-            TArgTy, NonTypeTArg>&>(A),
-            std::forward<Args>(args)...);
-    case TArgKind::Template:
-        return f(static_cast<add_cv_from_t<
-            TArgTy, TemplateTArg>&>(A),
-            std::forward<Args>(args)...);
-    default:
-        MRDOCS_UNREACHABLE();
-    }
-}
-
-MRDOCS_DECL
-std::strong_ordering
-operator<=>(Polymorphic<TArg> const& lhs, Polymorphic<TArg> const& rhs);
-
-MRDOCS_DECL
-std::string
-toString(TArg const& arg) noexcept;
-
-MRDOCS_DECL
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    TArg const& I,
-    DomCorpus const* domCorpus);
-
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Polymorphic<TArg> const& I,
-    DomCorpus const* domCorpus)
-{
-    if (!I)
-    {
-        v = nullptr;
-        return;
-    }
-    tag_invoke(dom::ValueFromTag{}, v, *I, domCorpus);
-}
-
-// ----------------------------------------------------------------
-
-enum class TParamKind : int
-{
-    /// Template type parameter, e.g. "typename T" or "class T"
-    Type = 1, // for bitstream
-    /// Template non-type parameter, e.g. "int N" or "auto N"
-    NonType,
-    /// Template-template parameter, e.g. "template<typename> typename T"
-    Template
-};
-
-MRDOCS_DECL std::string_view toString(TParamKind kind) noexcept;
-
-struct TParam
-{
-    /** The kind of template parameter this is */
-    TParamKind Kind;
-
-    /** The template parameters name, if any */
-    std::string Name;
-
-    /** Whether this template parameter is a parameter pack */
-    bool IsParameterPack = false;
-
-    /** The default template argument, if any */
-    Polymorphic<TArg> Default = std::nullopt;
-
-    constexpr virtual ~TParam() = default;
-
-    constexpr bool isType()     const noexcept { return Kind == TParamKind::Type; }
-    constexpr bool isNonType()  const noexcept { return Kind == TParamKind::NonType; }
-    constexpr bool isTemplate() const noexcept { return Kind == TParamKind::Template; }
-
-    std::strong_ordering operator<=>(TParam const&) const;
-
-protected:
-    constexpr
-    TParam(
-        TParamKind kind) noexcept
-        : Kind(kind)
-    {
-    }
-};
-
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    TParam const& I,
-    DomCorpus const* domCorpus);
-
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Polymorphic<TParam> const& I,
-    DomCorpus const* domCorpus)
-{
-    if (!I)
-    {
-        v = nullptr;
-        return;
-    }
-    tag_invoke(dom::ValueFromTag{}, v, *I, domCorpus);
-}
-
-
-template<TParamKind K>
-struct TParamCommonBase : TParam
-{
-    static constexpr TParamKind kind_id = K;
-
-    static constexpr bool isType()     noexcept { return K == TParamKind::Type; }
-    static constexpr bool isNonType()  noexcept { return K == TParamKind::NonType; }
-    static constexpr bool isTemplate() noexcept { return K == TParamKind::Template; }
-
-    auto operator<=>(TParamCommonBase const&) const = default;
-
-protected:
-    constexpr
-    TParamCommonBase() noexcept
-        : TParam(K)
-    {
-    }
-};
-
-/** The keyword a template parameter was declared with */
-enum class TParamKeyKind : int
-{
-    /// Class keyword
-    Class = 0,
-    /// Typename keyword
-    Typename
-};
-
-MRDOCS_DECL std::string_view toString(TParamKeyKind kind) noexcept;
-
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    TParamKeyKind kind)
-{
-    v = toString(kind);
-}
-
-struct TypeTParam final
-    : TParamCommonBase<TParamKind::Type>
-{
-    /** Keyword (class/typename) the parameter uses */
-    TParamKeyKind KeyKind = TParamKeyKind::Class;
-
-    /** The type-constraint for the parameter, if any. */
-    Polymorphic<NameInfo> Constraint = std::nullopt;
-
-    std::strong_ordering operator<=>(TypeTParam const&) const;
-};
-
-struct NonTypeTParam final
-    : TParamCommonBase<TParamKind::NonType>
-{
-    /** Type of the non-type template parameter */
-    Polymorphic<TypeInfo> Type = std::nullopt;
-
-    std::strong_ordering operator<=>(NonTypeTParam const&) const;
-};
-
-struct TemplateTParam final
-    : TParamCommonBase<TParamKind::Template>
-{
-    /** Template parameters for the template-template parameter */
-    std::vector<Polymorphic<TParam>> Params;
-
-    std::strong_ordering
-    operator<=>(TemplateTParam const& other) const;
-};
-
-template<
-    typename TParamTy,
-    typename F,
-    typename... Args>
-    requires std::derived_from<TParamTy, TParam>
-constexpr
-decltype(auto)
-visit(
-    TParamTy& P,
-    F&& f,
-    Args&&... args)
-{
-    switch(P.Kind)
-    {
-    case TParamKind::Type:
-        return f(static_cast<add_cv_from_t<
-            TParamTy, TypeTParam>&>(P),
-            std::forward<Args>(args)...);
-    case TParamKind::NonType:
-        return f(static_cast<add_cv_from_t<
-            TParamTy, NonTypeTParam>&>(P),
-            std::forward<Args>(args)...);
-    case TParamKind::Template:
-        return f(static_cast<add_cv_from_t<
-            TParamTy, TemplateTParam>&>(P),
-            std::forward<Args>(args)...);
-    default:
-        MRDOCS_UNREACHABLE();
-    }
-}
-
-MRDOCS_DECL
-std::strong_ordering
-operator<=>(Polymorphic<TParam> const& lhs, Polymorphic<TParam> const& rhs);
-
-inline
-bool
-operator==(Polymorphic<TParam> const& lhs, Polymorphic<TParam> const& rhs) {
-    return lhs <=> rhs == std::strong_ordering::equal;
-}
-
-
-// ----------------------------------------------------------------
-
 /** The kind of template or specialization.
 */
 enum class TemplateSpecKind
@@ -385,9 +40,10 @@ MRDOCS_DECL
 std::string_view
 toString(TemplateSpecKind kind);
 
-/** Information pertaining to templates and specializations thereof.
+
+/** Information about templates and specializations thereof.
 */
-struct TemplateInfo
+struct TemplateInfo final
 {
     std::vector<Polymorphic<TParam>> Params;
     std::vector<Polymorphic<TArg>> Args;
@@ -475,6 +131,7 @@ tag_invoke(
     tag_invoke(dom::ValueFromTag{}, v, *I, domCorpus);
 }
 
+
 } // clang::mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Type.hpp b/include/mrdocs/Metadata/Type.hpp
index 4a855513e..674f11889 100644
--- a/include/mrdocs/Metadata/Type.hpp
+++ b/include/mrdocs/Metadata/Type.hpp
@@ -11,489 +11,23 @@
 #ifndef MRDOCS_API_METADATA_TYPE_HPP
 #define MRDOCS_API_METADATA_TYPE_HPP
 
-#include <string>
-#include <vector>
-#include <mrdocs/ADT/Polymorphic.hpp>
-#include <mrdocs/Dom.hpp>
-#include <mrdocs/Metadata/Expression.hpp>
-#include <mrdocs/Metadata/Specifiers.hpp>
-#include <mrdocs/Metadata/SymbolID.hpp>
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Optional.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/Type/ArrayTypeInfo.hpp>
+#include <mrdocs/Metadata/Type/AutoTypeInfo.hpp>
+#include <mrdocs/Metadata/Type/DecltypeTypeInfo.hpp>
+#include <mrdocs/Metadata/Type/FunctionTypeInfo.hpp>
+#include <mrdocs/Metadata/Type/LValueReferenceTypeInfo.hpp>
+#include <mrdocs/Metadata/Type/MemberPointerTypeInfo.hpp>
+#include <mrdocs/Metadata/Type/NamedTypeInfo.hpp>
+#include <mrdocs/Metadata/Type/PointerTypeInfo.hpp>
+#include <mrdocs/Metadata/Type/RValueReferenceTypeInfo.hpp>
+#include <mrdocs/Metadata/Type/TypeBase.hpp>
 #include <mrdocs/Support/TypeTraits.hpp>
 
 namespace clang::mrdocs {
 
-struct NameInfo;
-struct TypeInfo;
-
-std::strong_ordering
-operator<=>(Polymorphic<NameInfo> const& lhs, Polymorphic<NameInfo> const& rhs);
-
-std::strong_ordering
-operator<=>(Polymorphic<TypeInfo> const& lhs, Polymorphic<TypeInfo> const& rhs);
-
-/** Type qualifiers
-*/
-enum QualifierKind
-{
-    /// No qualifiers
-    None,
-    /// The const qualifier
-    Const,
-    /// The volatile qualifier
-    Volatile
-};
-
-MRDOCS_DECL dom::String toString(QualifierKind kind) noexcept;
-
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    QualifierKind kind)
-{
-    v = toString(kind);
-}
-
-enum class TypeKind
-{
-    /// A Named type
-    Named = 1, // for bitstream
-    /// A decltype type
-    Decltype,
-    /// An auto type
-    Auto,
-    /// An LValueReference type
-    LValueReference,
-    /// An RValueReference type
-    RValueReference,
-    /// A Pointer type
-    Pointer,
-    /// A MemberPointer type
-    MemberPointer,
-    /// An Array type
-    Array,
-    /// A Function type
-    Function,
-};
-
-MRDOCS_DECL dom::String toString(TypeKind kind) noexcept;
-
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    TypeKind kind)
-{
-    v = toString(kind);
-}
-
-/** The kind of `auto` keyword used in a declaration.
-
-    This is either `auto` or `decltype(auto)`.
-*/
-enum class AutoKind
-{
-    /// The `auto` keyword
-    Auto,
-    /// The `decltype(auto)` keyword
-    DecltypeAuto
-};
-
-MRDOCS_DECL dom::String toString(AutoKind kind) noexcept;
-
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    AutoKind kind)
-{
-    v = toString(kind);
-}
-
-/** A possibly qualified type.
-
-    This class represents a type that may have
-    qualifiers (e.g. const, volatile).
-
-    This base class is used to store the kind
-    of type. Derived classes are used to store
-    the type information according to the kind.
- */
-struct TypeInfo
-{
-    /** The kind of TypeInfo this is
-    */
-    TypeKind Kind;
-
-    /** Whether this is the pattern of a pack expansion.
-    */
-    bool IsPackExpansion = false;
-
-    /** The const qualifier
-     */
-    bool IsConst = false;
-
-    /** The volatile qualifier
-     */
-    bool IsVolatile = false;
-
-    /** The constraints associated with the type
-
-        This represents the constraints associated with the type,
-        such as SFINAE constraints.
-
-        For instance, if SFINAE detection is enabled, the
-        expression `std::enable_if_t<std::is_integral_v<T>, T>`
-        will have type `T` (NamedType) and constraints
-        `{std::is_integral_v<T>}`.
-     */
-    std::vector<ExprInfo> Constraints;
-
-    constexpr virtual ~TypeInfo() = default;
-
-    constexpr bool isNamed()           const noexcept { return Kind == TypeKind::Named; }
-    constexpr bool isDecltype()        const noexcept { return Kind == TypeKind::Decltype; }
-    constexpr bool isAuto()            const noexcept { return Kind == TypeKind::Auto; }
-    constexpr bool isLValueReference() const noexcept { return Kind == TypeKind::LValueReference; }
-    constexpr bool isRValueReference() const noexcept { return Kind == TypeKind::RValueReference; }
-    constexpr bool isPointer()         const noexcept { return Kind == TypeKind::Pointer; }
-    constexpr bool isMemberPointer()   const noexcept { return Kind == TypeKind::MemberPointer; }
-    constexpr bool isArray()           const noexcept { return Kind == TypeKind::Array; }
-    constexpr bool isFunction()        const noexcept { return Kind == TypeKind::Function; }
-
-    /** Return the symbol named by this type.
-    */
-    SymbolID
-    namedSymbol() const noexcept;
-
-    auto operator<=>(TypeInfo const&) const = default;
-
-protected:
-    constexpr
-    TypeInfo(
-        TypeKind kind) noexcept
-        : Kind(kind)
-    {
-    }
-};
-
-MRDOCS_DECL
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    TypeInfo const& I,
-    DomCorpus const* domCorpus);
-
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Polymorphic<TypeInfo> const& I,
-    DomCorpus const* domCorpus)
-{
-    if (!I)
-    {
-        v = nullptr;
-        return;
-    }
-    tag_invoke(dom::ValueFromTag{}, v, *I, domCorpus);
-}
-
-template<TypeKind K>
-struct TypeInfoCommonBase : TypeInfo
-{
-    static constexpr TypeKind kind_id = K;
-
-    static constexpr bool isNamed()           noexcept { return K == TypeKind::Named; }
-    static constexpr bool isDecltype()        noexcept { return K == TypeKind::Decltype; }
-    static constexpr bool isAuto()            noexcept { return K == TypeKind::Auto; }
-    static constexpr bool isLValueReference() noexcept { return K == TypeKind::LValueReference; }
-    static constexpr bool isRValueReference() noexcept { return K == TypeKind::RValueReference; }
-    static constexpr bool isPointer()         noexcept { return K == TypeKind::Pointer; }
-    static constexpr bool isMemberPointer()   noexcept { return K == TypeKind::MemberPointer; }
-    static constexpr bool isArray()           noexcept { return K == TypeKind::Array; }
-    static constexpr bool isFunction()        noexcept { return K == TypeKind::Function; }
-
-    auto operator<=>(TypeInfoCommonBase const&) const = default;
-
-protected:
-    constexpr
-    TypeInfoCommonBase() noexcept
-        : TypeInfo(K)
-    {
-    }
-};
-
-/** Categorically describes a fundamental type.
-
-    @see https://en.cppreference.com/w/cpp/language/types
-*/
-enum class FundamentalTypeKind
-{
-    /// void
-    Void,
-    /// std::nullptr_t
-    Nullptr,
-    /// bool
-    Bool,
-    /// char
-    Char,
-    /// signed char
-    SignedChar,
-    /// unsigned char
-    UnsignedChar,
-    /// char8_t
-    Char8,
-    /// char16_t
-    Char16,
-    /// char32_t
-    Char32,
-    /// wchar_t
-    WChar,
-    /// short / short int / signed short / signed short int
-    Short,
-    /// unsigned short / unsigned short int
-    UnsignedShort,
-    /// int / signed / signed int
-    Int,
-    /// unsigned / unsigned int
-    UnsignedInt,
-    /// long / long int / signed long / signed long int
-    Long,
-    /// unsigned long / unsigned long int
-    UnsignedLong,
-    /// long long / long long int / signed long long / signed long long int
-    LongLong,
-    /// unsigned long long / unsigned long long int
-    UnsignedLongLong,
-    /// float
-    Float,
-    /// double
-    Double,
-    /// long double
-    LongDouble
-};
-
-/** Convert a FundamentalTypeKind to a string.
-
-    This function converts a FundamentalTypeKind to
-    the shortest canonical string representing the type.
-
-    @return The string representation of the kind
- */
-MRDOCS_DECL
-std::string_view
-toString(FundamentalTypeKind kind) noexcept;
-
-/** Convert a string to a FundamentalTypeKind.
-
-    This function converts a string to a FundamentalTypeKind.
-
-    All variations of the type specifiers are supported.
-
-    However, the "long long" specifier cannot be split
-    into two separate specifiers.
-
-    @param str The string to convert
-    @param[out] kind The resulting FundamentalTypeKind
-
-    @return true if the string was successfully converted
- */
-MRDOCS_DECL
-bool
-fromString(std::string_view str, FundamentalTypeKind& kind) noexcept;
-
-/** Apply the "long" specifier to the type
-
-    If applying "long" the specifier is a valid operation
-    the function changes the type and returns true.
-
-    For instance, applying "long" to
-    `FundamentalTypeKind::Int` ("int") results in
-    `FundamentalTypeKind::Long` ("long int").
-
-    @param[in/out] kind The type to modify
-    @return Whether the operation was successful
- */
-MRDOCS_DECL
-bool
-makeLong(FundamentalTypeKind& kind) noexcept;
-
-/** Apply the "short" specifier to the type
-
-    If applying "short" the specifier is a valid operation
-    the function changes the type and returns true.
-
-    For instance, applying "short" to
-    `FundamentalTypeKind::Int` ("int") results in
-    `FundamentalTypeKind::Short` ("short int").
-
-    @param[in/out] kind The type to modify
-    @return Whether the operation was successful
- */
-MRDOCS_DECL
-bool
-makeShort(FundamentalTypeKind& kind) noexcept;
-
-/** Apply the "signed" specifier to the type
-
-    If applying the "signed" specifier is a valid operation
-    the function changes the type and returns true.
-
-    For instance, applying "signed" to
-    `FundamentalTypeKind::Char` ("char") results in
-    `FundamentalTypeKind::SignedChar` ("signed char").
-
-    It also returns true if applying the "signed" specifier
-    is a valid operation but doesn't affect the
-    type.
-
-    For instance, applying "signed" to
-    `FundamentalTypeKind::Int` ("int") doesn't change the type
-    but returns `true`, even though `FundamentalTypeKind::Int`
-    could be declared as "int" or "signed" and multiple
-    "signed" specifiers are not allowed.
-
-    @param[in/out] kind The type to modify
-    @return Whether the operation was successful
- */
-MRDOCS_DECL
-bool
-makeSigned(FundamentalTypeKind& kind) noexcept;
-
-/** Apply the "unsigned" specifier to the type
-
-    If applying the "unsigned" specifier is a valid operation
-    the function changes the type and returns true.
-
-    For instance, applying "unsigned" to
-    `FundamentalTypeKind::Char` ("char") results in
-    `FundamentalTypeKind::UnsignedChar` ("unsigned char")
-    and applying "unsigned" to
-    `FundamentalTypeKind::Int` ("int") results in
-    `FundamentalTypeKind::UnsignedInt` ("unsigned int").
-
-    @param[in/out] kind The type to modify
-    @return Whether the operation was successful
- */
-MRDOCS_DECL
-bool
-makeUnsigned(FundamentalTypeKind& kind) noexcept;
-
-/** Apply the "char" specifier to the type
-
-    If applying the "char" specifier to a type
-    that might have been declared only with "signed/unsigned"
-    or "short/long" specifiers, the function changes the type
-    and returns true.
-
-    For instance, applying "char" to
-    `FundamentalTypeKind::Int` ("int", which could be declared
-    as "signed") results in
-    `FundamentalTypeKind::SignedChar` ("signed char").
-
-    @param[in/out] kind The type to modify
-    @return Whether the operation was successful
- */
-MRDOCS_DECL
-bool
-makeChar(FundamentalTypeKind& kind) noexcept;
-
-struct NamedTypeInfo final
-    : TypeInfoCommonBase<TypeKind::Named>
-{
-    Polymorphic<NameInfo> Name = std::nullopt;
-
-    std::optional<FundamentalTypeKind> FundamentalType;
-
-    std::strong_ordering
-    operator<=>(NamedTypeInfo const& other) const;
-};
-
-struct DecltypeTypeInfo final
-    : TypeInfoCommonBase<TypeKind::Decltype>
-{
-    ExprInfo Operand;
-
-    auto operator<=>(DecltypeTypeInfo const&) const = default;
-};
-
-struct AutoTypeInfo final
-    : TypeInfoCommonBase<TypeKind::Auto>
-{
-    AutoKind Keyword = AutoKind::Auto;
-    Polymorphic<NameInfo> Constraint = std::nullopt;
-
-    std::strong_ordering
-    operator<=>(AutoTypeInfo const&) const;
-};
-
-struct LValueReferenceTypeInfo final
-    : TypeInfoCommonBase<TypeKind::LValueReference>
-{
-    Polymorphic<TypeInfo> PointeeType = std::nullopt;
-
-    std::strong_ordering
-    operator<=>(LValueReferenceTypeInfo const&) const;
-};
-
-struct RValueReferenceTypeInfo final
-    : TypeInfoCommonBase<TypeKind::RValueReference>
-{
-    Polymorphic<TypeInfo> PointeeType = std::nullopt;
-
-    std::strong_ordering
-    operator<=>(RValueReferenceTypeInfo const&) const;
-};
-
-struct PointerTypeInfo final
-    : TypeInfoCommonBase<TypeKind::Pointer>
-{
-    Polymorphic<TypeInfo> PointeeType = std::nullopt;
-
-    std::strong_ordering
-    operator<=>(PointerTypeInfo const&) const;
-};
-
-struct MemberPointerTypeInfo final
-    : TypeInfoCommonBase<TypeKind::MemberPointer>
-{
-    Polymorphic<TypeInfo> ParentType = std::nullopt;
-    Polymorphic<TypeInfo> PointeeType = std::nullopt;
-
-    std::strong_ordering
-    operator<=>(MemberPointerTypeInfo const&) const;
-};
-
-struct ArrayTypeInfo final
-    : TypeInfoCommonBase<TypeKind::Array>
-{
-    Polymorphic<TypeInfo> ElementType = std::nullopt;
-    ConstantExprInfo<std::uint64_t> Bounds;
-
-    std::strong_ordering
-    operator<=>(ArrayTypeInfo const&) const;
-};
-
-struct FunctionTypeInfo final
-    : TypeInfoCommonBase<TypeKind::Function>
-{
-    Polymorphic<TypeInfo> ReturnType = std::nullopt;
-    std::vector<Polymorphic<TypeInfo>> ParamTypes;
-    ReferenceKind RefQualifier = ReferenceKind::None;
-    NoexceptInfo ExceptionSpec;
-    bool IsVariadic = false;
-
-    std::strong_ordering
-    operator<=>(FunctionTypeInfo const&) const;
-};
-
 template<
     std::derived_from<TypeInfo> TypeTy,
     class F,
@@ -558,6 +92,30 @@ operator==(Polymorphic<TypeInfo> const& lhs, Polymorphic<TypeInfo> const& rhs) {
     return lhs <=> rhs == std::strong_ordering::equal;
 }
 
+inline std::strong_ordering
+operator<=>(
+    Optional<Polymorphic<TypeInfo>> const& lhs,
+    Optional<Polymorphic<TypeInfo>> const& rhs)
+{
+    if (lhs && rhs)
+    {
+        return *lhs <=> *rhs;
+    }
+    if (!lhs && !rhs)
+    {
+        return std::strong_ordering::equal;
+    }
+    return bool(lhs) <=> bool(rhs);
+}
+
+inline bool
+operator==(
+    Optional<Polymorphic<TypeInfo>> const& lhs,
+    Optional<Polymorphic<TypeInfo>> const& rhs)
+{
+    return lhs <=> rhs == std::strong_ordering::equal;
+}
+
 /** Return the inner type.
 
     The inner type is the type which is modified
@@ -609,6 +167,40 @@ toString(
     TypeInfo const& T,
     std::string_view Name = "");
 
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Polymorphic<TypeInfo> const& I,
+    DomCorpus const* domCorpus)
+{
+    if (I.valueless_after_move())
+    {
+        v = nullptr;
+        return;
+    }
+    tag_invoke(dom::ValueFromTag{}, v, *I, domCorpus);
+}
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Optional<Polymorphic<TypeInfo>> const& I,
+    DomCorpus const* domCorpus)
+{
+    if (!I)
+    {
+        v = nullptr;
+        return;
+    }
+    MRDOCS_ASSERT(!I->valueless_after_move());
+    tag_invoke(dom::ValueFromTag{}, v, **I, domCorpus);
+}
+
+
 } // clang::mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Type/ArrayTypeInfo.hpp b/include/mrdocs/Metadata/Type/ArrayTypeInfo.hpp
new file mode 100644
index 000000000..da746e2b2
--- /dev/null
+++ b/include/mrdocs/Metadata/Type/ArrayTypeInfo.hpp
@@ -0,0 +1,33 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TYPE_ARRAYTYPEINFO_HPP
+#define MRDOCS_API_METADATA_TYPE_ARRAYTYPEINFO_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Optional.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/Type/TypeBase.hpp>
+
+namespace clang::mrdocs {
+
+struct ArrayTypeInfo final
+    : TypeInfoCommonBase<TypeKind::Array>
+{
+    Optional<Polymorphic<TypeInfo>> ElementType = std::nullopt;
+    ConstantExprInfo<std::uint64_t> Bounds;
+
+    std::strong_ordering
+    operator<=>(ArrayTypeInfo const&) const;
+};
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Type/AutoKind.hpp b/include/mrdocs/Metadata/Type/AutoKind.hpp
new file mode 100644
index 000000000..c59817b98
--- /dev/null
+++ b/include/mrdocs/Metadata/Type/AutoKind.hpp
@@ -0,0 +1,47 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TYPE_AUTOKIND_HPP
+#define MRDOCS_API_METADATA_TYPE_AUTOKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+
+namespace clang::mrdocs {
+
+/** The kind of `auto` keyword used in a declaration.
+
+    This is either `auto` or `decltype(auto)`.
+*/
+enum class AutoKind
+{
+    /// The `auto` keyword
+    Auto,
+    /// The `decltype(auto)` keyword
+    DecltypeAuto
+};
+
+MRDOCS_DECL
+dom::String
+toString(AutoKind kind) noexcept;
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    AutoKind kind)
+{
+    v = toString(kind);
+}
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Type/AutoTypeInfo.hpp b/include/mrdocs/Metadata/Type/AutoTypeInfo.hpp
new file mode 100644
index 000000000..4522e72d8
--- /dev/null
+++ b/include/mrdocs/Metadata/Type/AutoTypeInfo.hpp
@@ -0,0 +1,34 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TYPE_AUTOTYPEINFO_HPP
+#define MRDOCS_API_METADATA_TYPE_AUTOTYPEINFO_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/Name/NameBase.hpp>
+#include <mrdocs/Metadata/Type/AutoKind.hpp>
+#include <mrdocs/Metadata/Type/TypeBase.hpp>
+
+namespace clang::mrdocs {
+
+struct AutoTypeInfo final
+    : TypeInfoCommonBase<TypeKind::Auto>
+{
+    AutoKind Keyword = AutoKind::Auto;
+    Optional<Polymorphic<NameInfo>> Constraint = std::nullopt;
+
+    std::strong_ordering
+    operator<=>(AutoTypeInfo const&) const;
+};
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Type/DecltypeTypeInfo.hpp b/include/mrdocs/Metadata/Type/DecltypeTypeInfo.hpp
new file mode 100644
index 000000000..648d40e75
--- /dev/null
+++ b/include/mrdocs/Metadata/Type/DecltypeTypeInfo.hpp
@@ -0,0 +1,29 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TYPE_DECLTYPETYPEINFO_HPP
+#define MRDOCS_API_METADATA_TYPE_DECLTYPETYPEINFO_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Type/TypeBase.hpp>
+
+namespace clang::mrdocs {
+
+struct DecltypeTypeInfo final
+    : TypeInfoCommonBase<TypeKind::Decltype>
+{
+    ExprInfo Operand;
+
+    auto operator<=>(DecltypeTypeInfo const&) const = default;
+};
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Type/FunctionTypeInfo.hpp b/include/mrdocs/Metadata/Type/FunctionTypeInfo.hpp
new file mode 100644
index 000000000..2c1658ba8
--- /dev/null
+++ b/include/mrdocs/Metadata/Type/FunctionTypeInfo.hpp
@@ -0,0 +1,37 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TYPE_FUNCTIONTYPEINFO_HPP
+#define MRDOCS_API_METADATA_TYPE_FUNCTIONTYPEINFO_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Optional.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/Specifiers.hpp>
+#include <mrdocs/Metadata/Type/TypeBase.hpp>
+
+namespace clang::mrdocs {
+
+struct FunctionTypeInfo final
+    : TypeInfoCommonBase<TypeKind::Function>
+{
+    Optional<Polymorphic<TypeInfo>> ReturnType = std::nullopt;
+    std::vector<Polymorphic<TypeInfo>> ParamTypes;
+    ReferenceKind RefQualifier = ReferenceKind::None;
+    NoexceptInfo ExceptionSpec;
+    bool IsVariadic = false;
+
+    std::strong_ordering
+    operator<=>(FunctionTypeInfo const&) const;
+};
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Type/FundamentalTypeKind.hpp b/include/mrdocs/Metadata/Type/FundamentalTypeKind.hpp
new file mode 100644
index 000000000..fa35717e6
--- /dev/null
+++ b/include/mrdocs/Metadata/Type/FundamentalTypeKind.hpp
@@ -0,0 +1,196 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TYPE_FUNDAMENTALTYPEKIND_HPP
+#define MRDOCS_API_METADATA_TYPE_FUNDAMENTALTYPEKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <string_view>
+
+namespace clang::mrdocs {
+
+/** Categorically describes a fundamental type.
+
+    @see https://en.cppreference.com/w/cpp/language/types
+*/
+enum class FundamentalTypeKind
+{
+    /// void
+    Void,
+    /// std::nullptr_t
+    Nullptr,
+    /// bool
+    Bool,
+    /// char
+    Char,
+    /// signed char
+    SignedChar,
+    /// unsigned char
+    UnsignedChar,
+    /// char8_t
+    Char8,
+    /// char16_t
+    Char16,
+    /// char32_t
+    Char32,
+    /// wchar_t
+    WChar,
+    /// short / short int / signed short / signed short int
+    Short,
+    /// unsigned short / unsigned short int
+    UnsignedShort,
+    /// int / signed / signed int
+    Int,
+    /// unsigned / unsigned int
+    UnsignedInt,
+    /// long / long int / signed long / signed long int
+    Long,
+    /// unsigned long / unsigned long int
+    UnsignedLong,
+    /// long long / long long int / signed long long / signed long long int
+    LongLong,
+    /// unsigned long long / unsigned long long int
+    UnsignedLongLong,
+    /// float
+    Float,
+    /// double
+    Double,
+    /// long double
+    LongDouble
+};
+
+/** Convert a FundamentalTypeKind to a string.
+
+    This function converts a FundamentalTypeKind to
+    the shortest canonical string representing the type.
+
+    @return The string representation of the kind
+ */
+MRDOCS_DECL
+std::string_view
+toString(FundamentalTypeKind kind) noexcept;
+
+/** Convert a string to a FundamentalTypeKind.
+
+    This function converts a string to a FundamentalTypeKind.
+
+    All variations of the type specifiers are supported.
+
+    However, the "long long" specifier cannot be split
+    into two separate specifiers.
+
+    @param str The string to convert
+    @param[out] kind The resulting FundamentalTypeKind
+
+    @return true if the string was successfully converted
+ */
+MRDOCS_DECL
+bool
+fromString(std::string_view str, FundamentalTypeKind& kind) noexcept;
+
+/** Apply the "long" specifier to the type
+
+    If applying "long" the specifier is a valid operation
+    the function changes the type and returns true.
+
+    For instance, applying "long" to
+    `FundamentalTypeKind::Int` ("int") results in
+    `FundamentalTypeKind::Long` ("long int").
+
+    @param[in/out] kind The type to modify
+    @return Whether the operation was successful
+ */
+MRDOCS_DECL
+bool
+makeLong(FundamentalTypeKind& kind) noexcept;
+
+/** Apply the "short" specifier to the type
+
+    If applying "short" the specifier is a valid operation
+    the function changes the type and returns true.
+
+    For instance, applying "short" to
+    `FundamentalTypeKind::Int` ("int") results in
+    `FundamentalTypeKind::Short` ("short int").
+
+    @param[in/out] kind The type to modify
+    @return Whether the operation was successful
+ */
+MRDOCS_DECL
+bool
+makeShort(FundamentalTypeKind& kind) noexcept;
+
+/** Apply the "signed" specifier to the type
+
+    If applying the "signed" specifier is a valid operation
+    the function changes the type and returns true.
+
+    For instance, applying "signed" to
+    `FundamentalTypeKind::Char` ("char") results in
+    `FundamentalTypeKind::SignedChar` ("signed char").
+
+    It also returns true if applying the "signed" specifier
+    is a valid operation but doesn't affect the
+    type.
+
+    For instance, applying "signed" to
+    `FundamentalTypeKind::Int` ("int") doesn't change the type
+    but returns `true`, even though `FundamentalTypeKind::Int`
+    could be declared as "int" or "signed" and multiple
+    "signed" specifiers are not allowed.
+
+    @param[in/out] kind The type to modify
+    @return Whether the operation was successful
+ */
+MRDOCS_DECL
+bool
+makeSigned(FundamentalTypeKind& kind) noexcept;
+
+/** Apply the "unsigned" specifier to the type
+
+    If applying the "unsigned" specifier is a valid operation
+    the function changes the type and returns true.
+
+    For instance, applying "unsigned" to
+    `FundamentalTypeKind::Char` ("char") results in
+    `FundamentalTypeKind::UnsignedChar` ("unsigned char")
+    and applying "unsigned" to
+    `FundamentalTypeKind::Int` ("int") results in
+    `FundamentalTypeKind::UnsignedInt` ("unsigned int").
+
+    @param[in/out] kind The type to modify
+    @return Whether the operation was successful
+ */
+MRDOCS_DECL
+bool
+makeUnsigned(FundamentalTypeKind& kind) noexcept;
+
+/** Apply the "char" specifier to the type
+
+    If applying the "char" specifier to a type
+    that might have been declared only with "signed/unsigned"
+    or "short/long" specifiers, the function changes the type
+    and returns true.
+
+    For instance, applying "char" to
+    `FundamentalTypeKind::Int` ("int", which could be declared
+    as "signed") results in
+    `FundamentalTypeKind::SignedChar` ("signed char").
+
+    @param[in/out] kind The type to modify
+    @return Whether the operation was successful
+ */
+MRDOCS_DECL
+bool
+makeChar(FundamentalTypeKind& kind) noexcept;
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Type/LValueReferenceTypeInfo.hpp b/include/mrdocs/Metadata/Type/LValueReferenceTypeInfo.hpp
new file mode 100644
index 000000000..d1eea06e2
--- /dev/null
+++ b/include/mrdocs/Metadata/Type/LValueReferenceTypeInfo.hpp
@@ -0,0 +1,32 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TYPE_LVALUEREFERENCETYPEINFO_HPP
+#define MRDOCS_API_METADATA_TYPE_LVALUEREFERENCETYPEINFO_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Optional.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/Type/TypeBase.hpp>
+
+namespace clang::mrdocs {
+
+struct LValueReferenceTypeInfo final
+    : TypeInfoCommonBase<TypeKind::LValueReference>
+{
+    Optional<Polymorphic<TypeInfo>> PointeeType = std::nullopt;
+
+    std::strong_ordering
+    operator<=>(LValueReferenceTypeInfo const&) const;
+};
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Type/MemberPointerTypeInfo.hpp b/include/mrdocs/Metadata/Type/MemberPointerTypeInfo.hpp
new file mode 100644
index 000000000..3fd3ab1fc
--- /dev/null
+++ b/include/mrdocs/Metadata/Type/MemberPointerTypeInfo.hpp
@@ -0,0 +1,33 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TYPE_MEMBERPOINTERTYPEINFO_HPP
+#define MRDOCS_API_METADATA_TYPE_MEMBERPOINTERTYPEINFO_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Optional.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/Type/TypeBase.hpp>
+
+namespace clang::mrdocs {
+
+struct MemberPointerTypeInfo final
+    : TypeInfoCommonBase<TypeKind::MemberPointer>
+{
+    Optional<Polymorphic<TypeInfo>> ParentType = std::nullopt;
+    Optional<Polymorphic<TypeInfo>> PointeeType = std::nullopt;
+
+    std::strong_ordering
+    operator<=>(MemberPointerTypeInfo const&) const;
+};
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Type/NamedTypeInfo.hpp b/include/mrdocs/Metadata/Type/NamedTypeInfo.hpp
new file mode 100644
index 000000000..363890bf1
--- /dev/null
+++ b/include/mrdocs/Metadata/Type/NamedTypeInfo.hpp
@@ -0,0 +1,38 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TYPE_NAMEDTYPEINFO_HPP
+#define MRDOCS_API_METADATA_TYPE_NAMEDTYPEINFO_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/Name/IdentifierNameInfo.hpp>
+#include <mrdocs/Metadata/Name/NameBase.hpp>
+#include <mrdocs/Metadata/Type/FundamentalTypeKind.hpp>
+#include <mrdocs/Metadata/Type/TypeBase.hpp>
+#include <mrdocs/Metadata/Type/TypeKind.hpp>
+#include <optional>
+
+namespace clang::mrdocs {
+
+struct NamedTypeInfo final
+    : TypeInfoCommonBase<TypeKind::Named>
+{
+    Polymorphic<NameInfo> Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
+
+    std::optional<FundamentalTypeKind> FundamentalType;
+
+    std::strong_ordering
+    operator<=>(NamedTypeInfo const& other) const;
+};
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Type/PointerTypeInfo.hpp b/include/mrdocs/Metadata/Type/PointerTypeInfo.hpp
new file mode 100644
index 000000000..ffb070f8e
--- /dev/null
+++ b/include/mrdocs/Metadata/Type/PointerTypeInfo.hpp
@@ -0,0 +1,31 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TYPE_POINTERTYPEINFO_HPP
+#define MRDOCS_API_METADATA_TYPE_POINTERTYPEINFO_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Optional.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/Type/TypeBase.hpp>
+
+namespace clang::mrdocs {
+
+struct PointerTypeInfo final
+    : TypeInfoCommonBase<TypeKind::Pointer>
+{
+    Optional<Polymorphic<TypeInfo>> PointeeType = std::nullopt;
+    std::strong_ordering
+    operator<=>(PointerTypeInfo const&) const;
+};
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Type/QualifierKind.hpp b/include/mrdocs/Metadata/Type/QualifierKind.hpp
new file mode 100644
index 000000000..03a81766d
--- /dev/null
+++ b/include/mrdocs/Metadata/Type/QualifierKind.hpp
@@ -0,0 +1,55 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TYPE_QUALIFIERKIND_HPP
+#define MRDOCS_API_METADATA_TYPE_QUALIFIERKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Dom.hpp>
+#include <mrdocs/Metadata/Expression.hpp>
+#include <mrdocs/Metadata/Info/SymbolID.hpp>
+#include <mrdocs/Metadata/Name/NameBase.hpp>
+#include <mrdocs/Metadata/Specifiers.hpp>
+#include <mrdocs/Support/TypeTraits.hpp>
+#include <string>
+#include <vector>
+
+namespace clang::mrdocs {
+
+/** Type qualifiers
+*/
+enum QualifierKind
+{
+    /// No qualifiers
+    None,
+    /// The const qualifier
+    Const,
+    /// The volatile qualifier
+    Volatile
+};
+
+MRDOCS_DECL
+dom::String
+toString(QualifierKind kind) noexcept;
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    QualifierKind kind)
+{
+    v = toString(kind);
+}
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Type/RValueReferenceTypeInfo.hpp b/include/mrdocs/Metadata/Type/RValueReferenceTypeInfo.hpp
new file mode 100644
index 000000000..03d41575a
--- /dev/null
+++ b/include/mrdocs/Metadata/Type/RValueReferenceTypeInfo.hpp
@@ -0,0 +1,31 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TYPE_RVALUEREFERENCETYPEINFO_HPP
+#define MRDOCS_API_METADATA_TYPE_RVALUEREFERENCETYPEINFO_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Optional.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/Type/TypeBase.hpp>
+
+namespace clang::mrdocs {
+
+struct RValueReferenceTypeInfo final
+    : TypeInfoCommonBase<TypeKind::RValueReference>
+{
+    Optional<Polymorphic<TypeInfo>> PointeeType = std::nullopt;
+    std::strong_ordering
+    operator<=>(RValueReferenceTypeInfo const&) const;
+};
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Type/TypeBase.hpp b/include/mrdocs/Metadata/Type/TypeBase.hpp
new file mode 100644
index 000000000..bf393c131
--- /dev/null
+++ b/include/mrdocs/Metadata/Type/TypeBase.hpp
@@ -0,0 +1,125 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TYPE_TYPEBASE_HPP
+#define MRDOCS_API_METADATA_TYPE_TYPEBASE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/Expression.hpp>
+#include <mrdocs/Metadata/Info/SymbolID.hpp>
+#include <mrdocs/Metadata/Type/TypeKind.hpp>
+#include <vector>
+
+namespace clang::mrdocs {
+
+/** A possibly qualified type.
+
+    This class represents a type that may have
+    qualifiers (e.g. const, volatile).
+
+    This base class is used to store the kind
+    of type. Derived classes are used to store
+    the type information according to the kind.
+ */
+struct TypeInfo
+{
+    /** The kind of TypeInfo this is
+    */
+    TypeKind Kind;
+
+    /** Whether this is the pattern of a pack expansion.
+    */
+    bool IsPackExpansion = false;
+
+    /** The const qualifier
+     */
+    bool IsConst = false;
+
+    /** The volatile qualifier
+     */
+    bool IsVolatile = false;
+
+    /** The constraints associated with the type
+
+        This represents the constraints associated with the type,
+        such as SFINAE constraints.
+
+        For instance, if SFINAE detection is enabled, the
+        expression `std::enable_if_t<std::is_integral_v<T>, T>`
+        will have type `T` (NamedType) and constraints
+        `{std::is_integral_v<T>}`.
+     */
+    std::vector<ExprInfo> Constraints;
+
+    constexpr virtual ~TypeInfo() = default;
+
+    constexpr bool isNamed()           const noexcept { return Kind == TypeKind::Named; }
+    constexpr bool isDecltype()        const noexcept { return Kind == TypeKind::Decltype; }
+    constexpr bool isAuto()            const noexcept { return Kind == TypeKind::Auto; }
+    constexpr bool isLValueReference() const noexcept { return Kind == TypeKind::LValueReference; }
+    constexpr bool isRValueReference() const noexcept { return Kind == TypeKind::RValueReference; }
+    constexpr bool isPointer()         const noexcept { return Kind == TypeKind::Pointer; }
+    constexpr bool isMemberPointer()   const noexcept { return Kind == TypeKind::MemberPointer; }
+    constexpr bool isArray()           const noexcept { return Kind == TypeKind::Array; }
+    constexpr bool isFunction()        const noexcept { return Kind == TypeKind::Function; }
+
+    /** Return the symbol named by this type.
+    */
+    SymbolID
+    namedSymbol() const noexcept;
+
+    auto operator<=>(TypeInfo const&) const = default;
+
+protected:
+    constexpr
+    TypeInfo(
+        TypeKind kind) noexcept
+        : Kind(kind)
+    {
+    }
+};
+
+MRDOCS_DECL
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    TypeInfo const& I,
+    DomCorpus const* domCorpus);
+
+template<TypeKind K>
+struct TypeInfoCommonBase : TypeInfo
+{
+    static constexpr TypeKind kind_id = K;
+
+    static constexpr bool isNamed()           noexcept { return K == TypeKind::Named; }
+    static constexpr bool isDecltype()        noexcept { return K == TypeKind::Decltype; }
+    static constexpr bool isAuto()            noexcept { return K == TypeKind::Auto; }
+    static constexpr bool isLValueReference() noexcept { return K == TypeKind::LValueReference; }
+    static constexpr bool isRValueReference() noexcept { return K == TypeKind::RValueReference; }
+    static constexpr bool isPointer()         noexcept { return K == TypeKind::Pointer; }
+    static constexpr bool isMemberPointer()   noexcept { return K == TypeKind::MemberPointer; }
+    static constexpr bool isArray()           noexcept { return K == TypeKind::Array; }
+    static constexpr bool isFunction()        noexcept { return K == TypeKind::Function; }
+
+    auto operator<=>(TypeInfoCommonBase const&) const = default;
+
+protected:
+    constexpr
+    TypeInfoCommonBase() noexcept
+        : TypeInfo(K)
+    {
+    }
+};
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Metadata/Type/TypeKind.hpp b/include/mrdocs/Metadata/Type/TypeKind.hpp
new file mode 100644
index 000000000..4ec6bd8fd
--- /dev/null
+++ b/include/mrdocs/Metadata/Type/TypeKind.hpp
@@ -0,0 +1,57 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TYPE_TYPEKIND_HPP
+#define MRDOCS_API_METADATA_TYPE_TYPEKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+
+namespace clang::mrdocs {
+
+enum class TypeKind
+{
+    /// A Named type
+    Named = 1, // for bitstream
+    /// A decltype type
+    Decltype,
+    /// An auto type
+    Auto,
+    /// An LValueReference type
+    LValueReference,
+    /// An RValueReference type
+    RValueReference,
+    /// A Pointer type
+    Pointer,
+    /// A MemberPointer type
+    MemberPointer,
+    /// An Array type
+    Array,
+    /// A Function type
+    Function,
+};
+
+MRDOCS_DECL
+dom::String
+toString(TypeKind kind) noexcept;
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    TypeKind kind)
+{
+    v = toString(kind);
+}
+
+} // clang::mrdocs
+
+#endif
diff --git a/include/mrdocs/Platform.hpp b/include/mrdocs/Platform.hpp
index 4c7f77e29..70e8d5c67 100644
--- a/include/mrdocs/Platform.hpp
+++ b/include/mrdocs/Platform.hpp
@@ -87,4 +87,4 @@ namespace mrdocs {
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_API_PLATFORM_HPP
diff --git a/include/mrdocs/Support/Algorithm.hpp b/include/mrdocs/Support/Algorithm.hpp
index 9bc8a1218..ccbf88cb9 100644
--- a/include/mrdocs/Support/Algorithm.hpp
+++ b/include/mrdocs/Support/Algorithm.hpp
@@ -12,8 +12,8 @@
 #define MRDOCS_API_SUPPORT_ALGORITHM_HPP
 
 #include <mrdocs/Support/Concepts.hpp>
-#include <cstdint>
 #include <algorithm>
+#include <cstdint>
 
 namespace clang::mrdocs {
 
diff --git a/include/mrdocs/Support/Error.hpp b/include/mrdocs/Support/Error.hpp
index 1cffb2768..aaae56ef5 100644
--- a/include/mrdocs/Support/Error.hpp
+++ b/include/mrdocs/Support/Error.hpp
@@ -12,12 +12,12 @@
 #ifndef MRDOCS_API_SUPPORT_ERROR_HPP
 #define MRDOCS_API_SUPPORT_ERROR_HPP
 
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Support/source_location.hpp>
 #include <exception>
 #include <format>
 #include <functional>
 #include <memory>
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/Support/source_location.hpp>
 #include <string>
 #include <string_view>
 #include <system_error>
diff --git a/include/mrdocs/Support/ExecutorGroup.hpp b/include/mrdocs/Support/ExecutorGroup.hpp
index 0e3032693..940fe65e7 100644
--- a/include/mrdocs/Support/ExecutorGroup.hpp
+++ b/include/mrdocs/Support/ExecutorGroup.hpp
@@ -12,9 +12,9 @@
 #define MRDOCS_API_SUPPORT_EXECUTORGROUP_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Support/any_callable.hpp>
 #include <mrdocs/Support/Error.hpp>
 #include <mrdocs/Support/ThreadPool.hpp>
+#include <mrdocs/Support/any_callable.hpp>
 #include <deque>
 #include <memory>
 #include <mutex>
diff --git a/include/mrdocs/Support/Expected.hpp b/include/mrdocs/Support/Expected.hpp
index f40f74919..28e239977 100644
--- a/include/mrdocs/Support/Expected.hpp
+++ b/include/mrdocs/Support/Expected.hpp
@@ -12,13 +12,13 @@
 #ifndef MRDOCS_API_SUPPORT_EXPECTED_HPP
 #define MRDOCS_API_SUPPORT_EXPECTED_HPP
 
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Support/Error.hpp>
+#include <mrdocs/Support/source_location.hpp>
 #include <exception>
 #include <functional>
 #include <iterator>
 #include <memory>
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/Support/Error.hpp>
-#include <mrdocs/Support/source_location.hpp>
 #include <string>
 #include <string_view>
 #include <type_traits>
diff --git a/include/mrdocs/Support/Glob.hpp b/include/mrdocs/Support/Glob.hpp
index 2b02b71a1..3de603a2e 100644
--- a/include/mrdocs/Support/Glob.hpp
+++ b/include/mrdocs/Support/Glob.hpp
@@ -8,8 +8,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_SUPPORT_GLOBPATTERN_HPP
-#define MRDOCS_API_SUPPORT_GLOBPATTERN_HPP
+#ifndef MRDOCS_API_SUPPORT_GLOB_HPP
+#define MRDOCS_API_SUPPORT_GLOB_HPP
 
 #include <mrdocs/Support/Expected.hpp>
 #include <memory>
@@ -331,4 +331,4 @@ class SymbolGlobPattern {
 
 } // clang::mrdocs
 
-#endif // MRDOCS_API_SUPPORT_GLOBPATTERN_HPP
\ No newline at end of file
+#endif // MRDOCS_API_SUPPORT_GLOB_HPP
\ No newline at end of file
diff --git a/include/mrdocs/Support/Handlebars.hpp b/include/mrdocs/Support/Handlebars.hpp
index 250bfce04..d2705bf1c 100644
--- a/include/mrdocs/Support/Handlebars.hpp
+++ b/include/mrdocs/Support/Handlebars.hpp
@@ -8,13 +8,13 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_TOOL_SUPPORT_PATH_HPP
-#define MRDOCS_TOOL_SUPPORT_PATH_HPP
+#ifndef MRDOCS_API_SUPPORT_HANDLEBARS_HPP
+#define MRDOCS_API_SUPPORT_HANDLEBARS_HPP
 
-#include <format>
-#include <functional>
 #include <mrdocs/Dom.hpp>
 #include <mrdocs/Support/String.hpp>
+#include <format>
+#include <functional>
 #include <string_view>
 #include <type_traits>
 #include <unordered_map>
@@ -1332,4 +1332,4 @@ year_fn();
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_API_SUPPORT_HANDLEBARS_HPP
diff --git a/include/mrdocs/Support/JavaScript.hpp b/include/mrdocs/Support/JavaScript.hpp
index b2bc036e4..d230cdc16 100644
--- a/include/mrdocs/Support/JavaScript.hpp
+++ b/include/mrdocs/Support/JavaScript.hpp
@@ -15,8 +15,8 @@
 #include <mrdocs/Dom.hpp>
 #include <mrdocs/Support/Error.hpp>
 #include <cstdlib>
-#include <string_view>
 #include <span>
+#include <string_view>
 
 namespace clang {
 namespace mrdocs {
diff --git a/include/mrdocs/Support/Lua.hpp b/include/mrdocs/Support/Lua.hpp
index d8587335a..82c9ab4ee 100644
--- a/include/mrdocs/Support/Lua.hpp
+++ b/include/mrdocs/Support/Lua.hpp
@@ -8,15 +8,15 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_SUPPORT_LUA_HPP
-#define MRDOCS_SUPPORT_LUA_HPP
+#ifndef MRDOCS_API_SUPPORT_LUA_HPP
+#define MRDOCS_API_SUPPORT_LUA_HPP
 
-#include <cstdlib>
-#include <memory>
-#include <mrdocs/Dom.hpp>
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
 #include <mrdocs/Support/Error.hpp>
 #include <mrdocs/Support/source_location.hpp>
+#include <cstdlib>
+#include <memory>
 #include <string>
 #include <string_view>
 
@@ -507,4 +507,4 @@ struct std::formatter<clang::mrdocs::lua::Value> : std::formatter<std::string> {
   }
 };
 
-#endif
+#endif // MRDOCS_API_SUPPORT_LUA_HPP
diff --git a/include/mrdocs/Support/Report.hpp b/include/mrdocs/Support/Report.hpp
index 022686480..c8da3716f 100644
--- a/include/mrdocs/Support/Report.hpp
+++ b/include/mrdocs/Support/Report.hpp
@@ -12,14 +12,14 @@
 #ifndef MRDOCS_API_SUPPORT_REPORT_HPP
 #define MRDOCS_API_SUPPORT_REPORT_HPP
 
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Support/Error.hpp>
+#include <mrdocs/Support/source_location.hpp>
 #include <exception>
 #include <format>
 #include <functional>
 #include <iterator>
 #include <memory>
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/Support/Error.hpp>
-#include <mrdocs/Support/source_location.hpp>
 #include <string>
 #include <string_view>
 #include <type_traits>
diff --git a/include/mrdocs/Support/ThreadPool.hpp b/include/mrdocs/Support/ThreadPool.hpp
index f679be9e7..041607c46 100644
--- a/include/mrdocs/Support/ThreadPool.hpp
+++ b/include/mrdocs/Support/ThreadPool.hpp
@@ -9,12 +9,12 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_SUPPORT_THREAD_HPP
-#define MRDOCS_API_SUPPORT_THREAD_HPP
+#ifndef MRDOCS_API_SUPPORT_THREADPOOL_HPP
+#define MRDOCS_API_SUPPORT_THREADPOOL_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Support/any_callable.hpp>
 #include <mrdocs/Support/Error.hpp>
+#include <mrdocs/Support/any_callable.hpp>
 #include <memory>
 #include <type_traits>
 #include <utility>
@@ -188,4 +188,4 @@ forEach(
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_API_SUPPORT_THREADPOOL_HPP
diff --git a/include/mrdocs/Support/TypeTraits.hpp b/include/mrdocs/Support/TypeTraits.hpp
index 937508189..d7a61170d 100644
--- a/include/mrdocs/Support/TypeTraits.hpp
+++ b/include/mrdocs/Support/TypeTraits.hpp
@@ -9,8 +9,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_TOOL_SUPPORT_TYPE_TRAITS_HPP
-#define MRDOCS_TOOL_SUPPORT_TYPE_TRAITS_HPP
+#ifndef MRDOCS_API_SUPPORT_TYPETRAITS_HPP
+#define MRDOCS_API_SUPPORT_TYPETRAITS_HPP
 
 #include <type_traits>
 
@@ -124,4 +124,4 @@ using add_cvref_from_t =
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_API_SUPPORT_TYPETRAITS_HPP
diff --git a/include/mrdocs/Support/Visitor.hpp b/include/mrdocs/Support/Visitor.hpp
index 959300298..8a3e36988 100644
--- a/include/mrdocs/Support/Visitor.hpp
+++ b/include/mrdocs/Support/Visitor.hpp
@@ -8,12 +8,12 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_TOOL_SUPPORT_VISITOR_HPP
-#define MRDOCS_TOOL_SUPPORT_VISITOR_HPP
+#ifndef MRDOCS_API_SUPPORT_VISITOR_HPP
+#define MRDOCS_API_SUPPORT_VISITOR_HPP
 
 #include <mrdocs/Support/TypeTraits.hpp>
-#include <utility>
 #include <tuple>
+#include <utility>
 
 namespace clang::mrdocs {
 
@@ -126,4 +126,4 @@ makeVisitor(
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_SUPPORT_VISITOR_HPP
diff --git a/include/mrdocs/Support/source_location.hpp b/include/mrdocs/Support/source_location.hpp
index 7b98535a8..cca423a59 100644
--- a/include/mrdocs/Support/source_location.hpp
+++ b/include/mrdocs/Support/source_location.hpp
@@ -15,7 +15,7 @@
 
 #if __cpp_lib_source_location >= 201907L && \
     __has_include(<source_location>)
-    #include <source_location>
+#    include <source_location>
 
     namespace clang {
     namespace mrdocs {
@@ -25,7 +25,7 @@
     } // mrdocs
     } // clang
 #else
-    #include <cstdint>
+#    include <cstdint>
 
     namespace clang {
     namespace mrdocs {
diff --git a/src/lib/AST/ASTAction.cpp b/src/lib/AST/ASTAction.cpp
index c8468014f..44d6b902c 100644
--- a/src/lib/AST/ASTAction.cpp
+++ b/src/lib/AST/ASTAction.cpp
@@ -11,12 +11,12 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "lib/AST/ASTAction.hpp"
-#include "lib/AST/MrDocsFileSystem.hpp"
-#include "lib/AST/ASTVisitorConsumer.hpp"
+#include <lib/AST/ASTAction.hpp>
+#include <lib/AST/ASTVisitorConsumer.hpp>
+#include <lib/AST/MrDocsFileSystem.hpp>
 #include <clang/Frontend/CompilerInstance.h>
-#include <clang/Parse/ParseAST.h>
 #include <clang/Lex/PreprocessorOptions.h>
+#include <clang/Parse/ParseAST.h>
 
 namespace clang {
 namespace mrdocs {
diff --git a/src/lib/AST/ASTAction.hpp b/src/lib/AST/ASTAction.hpp
index b06154924..bc61e870b 100644
--- a/src/lib/AST/ASTAction.hpp
+++ b/src/lib/AST/ASTAction.hpp
@@ -14,12 +14,11 @@
 #ifndef MRDOCS_LIB_AST_ASTACTION_HPP
 #define MRDOCS_LIB_AST_ASTACTION_HPP
 
-#include "lib/ConfigImpl.hpp"
-#include "lib/Support/ExecutionContext.hpp"
-#include <clang/Tooling/Tooling.h>
 #include <mrdocs/Platform.hpp>
-#include "MissingSymbolSink.hpp"
-
+#include <lib/AST/MissingSymbolSink.hpp>
+#include <lib/ConfigImpl.hpp>
+#include <lib/Support/ExecutionContext.hpp>
+#include <clang/Tooling/Tooling.h>
 
 namespace clang {
 namespace mrdocs {
@@ -98,4 +97,4 @@ class ASTAction
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_LIB_AST_ASTACTION_HPP
diff --git a/src/lib/AST/ASTVisitor.cpp b/src/lib/AST/ASTVisitor.cpp
index b014400bf..9b5be1dfd 100644
--- a/src/lib/AST/ASTVisitor.cpp
+++ b/src/lib/AST/ASTVisitor.cpp
@@ -11,18 +11,18 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "lib/AST/ASTVisitor.hpp"
-#include "lib/AST/NameInfoBuilder.hpp"
-#include "lib/AST/ClangHelpers.hpp"
-#include "lib/AST/ParseJavadoc.hpp"
-#include "lib/AST/TypeInfoBuilder.hpp"
-#include "lib/Support/Path.hpp"
-#include "lib/Support/Debug.hpp"
-#include "lib/Support/Radix.hpp"
-#include "lib/Diagnostics.hpp"
+#include <mrdocs/Platform.hpp>
+#include <lib/AST/ASTVisitor.hpp>
+#include <lib/AST/ClangHelpers.hpp>
+#include <lib/AST/NameInfoBuilder.hpp>
+#include <lib/AST/ParseJavadoc.hpp>
+#include <lib/AST/TypeInfoBuilder.hpp>
+#include <lib/Diagnostics.hpp>
+#include <lib/Support/Path.hpp>
+#include <lib/Support/Radix.hpp>
 #include <mrdocs/Metadata.hpp>
-#include <mrdocs/Support/ScopeExit.hpp>
 #include <mrdocs/Support/Algorithm.hpp>
+#include <mrdocs/Support/ScopeExit.hpp>
 #include <clang/AST/AST.h>
 #include <clang/AST/Attr.h>
 #include <clang/AST/ODRHash.h>
@@ -35,8 +35,8 @@
 #include <clang/Sema/Template.h>
 #include <llvm/ADT/StringExtras.h>
 #include <llvm/Support/Error.h>
-#include <llvm/Support/SHA1.h>
 #include <llvm/Support/Process.h>
+#include <llvm/Support/SHA1.h>
 #include <memory>
 #include <optional>
 #include <ranges>
@@ -179,7 +179,7 @@ traverse(UsingDirectiveDecl const* D)
     MRDOCS_CHECK_OR(NDI, nullptr);
 
     auto res = toNameInfo(ND);
-    MRDOCS_ASSERT(res);
+    MRDOCS_ASSERT(!res.valueless_after_move());
     MRDOCS_ASSERT(res->isIdentifier());
     if (NameInfo NI = *res;
         !contains(PNI.UsingDirectives, NI))
@@ -707,7 +707,8 @@ populate(
             // CXXBaseSpecifier::getEllipsisLoc indicates whether the
             // base was a pack expansion; a PackExpansionType is not built
             // for base-specifiers
-            if (BaseType && B.getEllipsisLoc().isValid())
+            if (!BaseType.valueless_after_move() &&
+                B.getEllipsisLoc().isValid())
             {
                 BaseType->IsPackExpansion = true;
             }
@@ -912,9 +913,9 @@ populate(
     {
         // Return type SFINAE constraints
         if (I.ReturnType &&
-            !I.ReturnType->Constraints.empty())
+            !(*I.ReturnType)->Constraints.empty())
         {
-            for (ExprInfo const& constraint: I.ReturnType->Constraints)
+            for (ExprInfo const& constraint: (*I.ReturnType)->Constraints)
             {
                 if (!I.Requires.Written.empty())
                 {
@@ -928,9 +929,9 @@ populate(
         for (auto it = I.Params.begin(); it != I.Params.end(); )
         {
             if (it->Type &&
-                !it->Type->Constraints.empty())
+                !(*it->Type)->Constraints.empty())
             {
-                for (ExprInfo const& constraint: it->Type->Constraints)
+                for (ExprInfo const& constraint: (*it->Type)->Constraints)
                 {
                     if (!I.Requires.Written.empty())
                     {
@@ -1181,8 +1182,8 @@ populate(
     if (TypeSourceInfo const* TSI = D->getFriendType())
     {
         I.Type = toTypeInfo(TSI->getType());
-        MRDOCS_CHECK_OR(I.Type->isNamed());
-        auto const& NTI = dynamic_cast<NamedTypeInfo&>(*I.Type);
+        MRDOCS_CHECK_OR((*I.Type)->isNamed());
+        auto const& NTI = dynamic_cast<NamedTypeInfo&>(**I.Type);
         MRDOCS_CHECK_OR(NTI.Name);
         I.id = NTI.Name->id;
     }
@@ -1331,7 +1332,7 @@ populate(
         for (auto it = Template.Args.begin(); it != Template.Args.end();)
         {
             auto& arg = *it;
-            if (!arg)
+            if (arg.valueless_after_move())
             {
                 ++it;
                 continue;
@@ -1339,9 +1340,9 @@ populate(
             if (auto* T = dynamic_cast<TypeTArg*>(arg.operator->());
                 T &&
                 T->Type &&
-                !T->Type->Constraints.empty())
+                !(*T->Type)->Constraints.empty())
             {
-                for (ExprInfo const& constraint: T->Type->Constraints)
+                for (ExprInfo const& constraint: (*T->Type)->Constraints)
                 {
                     if (!Template.Requires.Written.empty())
                     {
@@ -1492,7 +1493,7 @@ populate(
 
         if constexpr(kind == Decl::TemplateTypeParm)
         {
-            if (!I)
+            if (I.valueless_after_move())
             {
                 I = Polymorphic<TParam>(std::in_place_type<TypeTParam>);
             }
@@ -1521,7 +1522,7 @@ populate(
         }
         else if constexpr(kind == Decl::NonTypeTemplateParm)
         {
-            if (!I)
+            if (I.valueless_after_move())
             {
                 I = Polymorphic<TParam>(std::in_place_type<NonTypeTParam>);
             }
@@ -1536,7 +1537,7 @@ populate(
         }
         else if constexpr(kind == Decl::TemplateTemplateParm)
         {
-            if (!I)
+            if (I.valueless_after_move())
             {
                 I = Polymorphic<TParam>(std::in_place_type<TemplateTParam>);
             }
@@ -1549,9 +1550,11 @@ populate(
             for (std::size_t i = 0; i < TPL->size(); ++i)
             {
                 NamedDecl const* TP = TPL->getParam(i);
-                auto &Param = i < Result->Params.size()
-                                  ? Result->Params[i]
-                                  : Result->Params.emplace_back(std::nullopt);
+                auto& Param
+                    = i < Result->Params.size() ?
+                          Result->Params[i] :
+                          Result->Params.emplace_back(
+                              nullable_traits<Polymorphic<TParam>>::null());
                 populate(Param, TP);
             }
             if (TTPD->hasDefaultArgument() && !Result->Default)
@@ -1602,9 +1605,10 @@ populate(
     while (explicitIt != ExplicitTemplateParameters.end())
     {
         NamedDecl const* P = TPL->getParam(i);
-        auto &Param = i < TI.Params.size()
-                          ? TI.Params[i]
-                          : TI.Params.emplace_back(std::nullopt);
+        auto& Param = i < TI.Params.size() ?
+                          TI.Params[i] :
+                          TI.Params.emplace_back(
+                              nullable_traits<Polymorphic<TParam>>::null());
         populate(Param, P);
         ++explicitIt;
         ++i;
@@ -1624,9 +1628,9 @@ populate(
             if (auto const* T = dynamic_cast<NonTypeTParam*>(param.operator->());
                 T &&
                 T->Type &&
-                !T->Type->Constraints.empty())
+                !(*T->Type)->Constraints.empty())
             {
-                for (ExprInfo const& constraint: T->Type->Constraints)
+                for (ExprInfo const& constraint: (*T->Type)->Constraints)
                 {
                     if (!TI.Requires.Written.empty())
                     {
@@ -1639,14 +1643,14 @@ populate(
             }
 
             if (param->Default &&
-                param->Default->isType())
+                (*param->Default)->isType())
             {
-                if (auto const* T = dynamic_cast<TypeTArg*>(param->Default.operator->());
+                if (auto const* T = dynamic_cast<TypeTArg*>((*param->Default).operator->());
                     T &&
                     T->Type &&
-                    !T->Type->Constraints.empty())
+                    !(*T->Type)->Constraints.empty())
                 {
-                    for (ExprInfo const& constraint: T->Type->Constraints)
+                    for (ExprInfo const& constraint: (*T->Type)->Constraints)
                     {
                         if (!TI.Requires.Written.empty())
                         {
@@ -2039,13 +2043,14 @@ toTypeInfo(QualType const qt, TraversalMode const mode)
     return Builder.result();
 }
 
-Polymorphic<NameInfo> ASTVisitor::toNameInfo(NestedNameSpecifier NNS)
+Polymorphic<NameInfo>
+ASTVisitor::toNameInfo(NestedNameSpecifier NNS)
 {
     MRDOCS_SYMBOL_TRACE(NNS, context_);
     ScopeExitRestore scope(mode_, Dependency);
     switch(NNS.getKind()) {
     case NestedNameSpecifier::Kind::Null:
-        return std::nullopt;
+        return nullable_traits<Polymorphic<NameInfo>>::null();
     case NestedNameSpecifier::Kind::Type: {
         const Type *T = NNS.getAsType();
         NameInfoBuilder Builder(*this);
@@ -2053,7 +2058,7 @@ Polymorphic<NameInfo> ASTVisitor::toNameInfo(NestedNameSpecifier NNS)
         return Builder.result();
     }
     case NestedNameSpecifier::Kind::Namespace: {
-        auto I = Polymorphic<NameInfo>();
+        auto I = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
         auto [ND, Prefix] = NNS.getAsNamespaceAndPrefix();
         I->Name = ND->getIdentifier()->getName();
         I->Prefix = toNameInfo(Prefix);
@@ -2067,7 +2072,7 @@ Polymorphic<NameInfo> ASTVisitor::toNameInfo(NestedNameSpecifier NNS)
     case NestedNameSpecifier::Kind::Global:
     case NestedNameSpecifier::Kind::MicrosoftSuper:
         // FIXME: Unimplemented.
-        return std::nullopt;
+        return nullable_traits<Polymorphic<NameInfo>>::null();
     }
     MRDOCS_UNREACHABLE();
 }
@@ -2081,9 +2086,9 @@ toNameInfo(DeclarationName const Name,
 {
     if (Name.isEmpty())
     {
-        return std::nullopt;
+        return nullable_traits<Polymorphic<NameInfo>>::null();
     }
-    Polymorphic<NameInfo> I = std::nullopt;
+    Polymorphic<NameInfo> I = nullable_traits<Polymorphic<NameInfo>>::null();
     if(TArgs)
     {
         I = Polymorphic<NameInfo>(std::in_place_type<SpecializationNameInfo>);
@@ -2091,7 +2096,7 @@ toNameInfo(DeclarationName const Name,
     }
     else
     {
-        I = Polymorphic<NameInfo>();
+        I = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
     }
     I->Name = extractName(Name);
     I->Prefix = toNameInfo(NNS);
@@ -2109,13 +2114,13 @@ toNameInfo(
     auto const* ND = dyn_cast_if_present<NamedDecl>(D);
     if (!ND)
     {
-        return std::nullopt;
+        return nullable_traits<Polymorphic<NameInfo>>::null();
     }
     auto I = toNameInfo(
         ND->getDeclName(), std::move(TArgs), NNS);
-    if (!I)
+    if (I.valueless_after_move())
     {
-        return std::nullopt;
+        return nullable_traits<Polymorphic<NameInfo>>::null();
     }
     ScopeExitRestore scope(mode_, Dependency);
     auto* ID = getInstantiatedFrom(D);
@@ -2234,7 +2239,7 @@ toTArg(TemplateArgument const& A)
     default:
         MRDOCS_UNREACHABLE();
     }
-    return std::nullopt;
+    return nullable_traits<Polymorphic<TArg>>::null();
 }
 
 
diff --git a/src/lib/AST/ASTVisitor.hpp b/src/lib/AST/ASTVisitor.hpp
index a06e557fb..0de087200 100644
--- a/src/lib/AST/ASTVisitor.hpp
+++ b/src/lib/AST/ASTVisitor.hpp
@@ -14,15 +14,15 @@
 #ifndef MRDOCS_LIB_AST_ASTVISITOR_HPP
 #define MRDOCS_LIB_AST_ASTVISITOR_HPP
 
-#include "lib/ConfigImpl.hpp"
-#include "lib/Support/ExecutionContext.hpp"
-#include "lib/AST/ClangHelpers.hpp"
-#include <mrdocs/Metadata/ExtractionMode.hpp>
-#include <mrdocs/Metadata/Source.hpp>
+#include <lib/AST/ClangHelpers.hpp>
+#include <lib/ConfigImpl.hpp>
+#include <lib/Support/ExecutionContext.hpp>
+#include <mrdocs/Metadata/Info/ExtractionMode.hpp>
+#include <mrdocs/Metadata/Info/Source.hpp>
 #include <mrdocs/Metadata/Name.hpp>
 #include <mrdocs/Support/Concepts.hpp>
-#include <clang/Tooling/Tooling.h>
 #include <clang/AST/ODRHash.h>
+#include <clang/Tooling/Tooling.h>
 #include <llvm/ADT/SmallBitVector.h>
 
 namespace clang::mrdocs {
@@ -1215,4 +1215,4 @@ class ASTVisitor
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_LIB_AST_ASTVISITOR_HPP
diff --git a/src/lib/AST/ASTVisitorConsumer.cpp b/src/lib/AST/ASTVisitorConsumer.cpp
index 91b049e7e..c4e328113 100644
--- a/src/lib/AST/ASTVisitorConsumer.cpp
+++ b/src/lib/AST/ASTVisitorConsumer.cpp
@@ -11,9 +11,9 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "lib/AST/ASTVisitorConsumer.hpp"
-#include "lib/AST/ASTVisitor.hpp"
-#include "lib/Support/Path.hpp"
+#include <lib/AST/ASTVisitor.hpp>
+#include <lib/AST/ASTVisitorConsumer.hpp>
+#include <lib/Support/Path.hpp>
 
 namespace clang::mrdocs {
 
diff --git a/src/lib/AST/ASTVisitorConsumer.hpp b/src/lib/AST/ASTVisitorConsumer.hpp
index 559707ac5..191cd14de 100644
--- a/src/lib/AST/ASTVisitorConsumer.hpp
+++ b/src/lib/AST/ASTVisitorConsumer.hpp
@@ -14,11 +14,11 @@
 #ifndef MRDOCS_LIB_AST_ASTVISITORCONSUMER_HPP
 #define MRDOCS_LIB_AST_ASTVISITORCONSUMER_HPP
 
-#include "lib/ConfigImpl.hpp"
-#include "lib/Support/ExecutionContext.hpp"
 #include <mrdocs/Platform.hpp>
-#include <clang/Tooling/Tooling.h>
+#include <lib/ConfigImpl.hpp>
+#include <lib/Support/ExecutionContext.hpp>
 #include <clang/Sema/SemaConsumer.h>
+#include <clang/Tooling/Tooling.h>
 
 namespace clang {
 namespace mrdocs {
@@ -263,4 +263,4 @@ class ASTVisitorConsumer
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_LIB_AST_ASTVISITORCONSUMER_HPP
diff --git a/src/lib/AST/ClangHelpers.cpp b/src/lib/AST/ClangHelpers.cpp
index 8de956239..fe29dd6cd 100644
--- a/src/lib/AST/ClangHelpers.cpp
+++ b/src/lib/AST/ClangHelpers.cpp
@@ -10,11 +10,11 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "lib/AST/ClangHelpers.hpp"
+#include <lib/AST/ClangHelpers.hpp>
 #include <mrdocs/Support/Assert.hpp>
 #include <mrdocs/Support/Report.hpp>
-#include <clang/Sema/Template.h>
 #include <clang/Index/USRGeneration.h>
+#include <clang/Sema/Template.h>
 #include <ranges>
 
 namespace clang::mrdocs {
diff --git a/src/lib/AST/ClangHelpers.hpp b/src/lib/AST/ClangHelpers.hpp
index 2cd2cbf0e..e0770c5b9 100644
--- a/src/lib/AST/ClangHelpers.hpp
+++ b/src/lib/AST/ClangHelpers.hpp
@@ -14,17 +14,18 @@
 #ifndef MRDOCS_LIB_AST_CLANGHELPERS_HPP
 #define MRDOCS_LIB_AST_CLANGHELPERS_HPP
 
-#include <mrdocs/Metadata/SymbolID.hpp>
-#include <mrdocs/Support/Error.hpp>
-#include <lib/AST/InstantiatedFromVisitor.hpp>
-#include <clang/AST/Expr.h>
-#include <clang/Sema/Sema.h>
 #include <mrdocs/Platform.hpp>
+#include <lib/AST/InstantiatedFromVisitor.hpp>
 #include <mrdocs/Metadata.hpp>
+#include <mrdocs/Metadata/Info/SymbolID.hpp>
+#include <mrdocs/Metadata/Type/QualifierKind.hpp>
+#include <mrdocs/Support/Error.hpp>
 #include <mrdocs/Support/TypeTraits.hpp>
 #include <clang/AST/AST.h>
 #include <clang/AST/DeclFriend.h>
 #include <clang/AST/DeclOpenMP.h>
+#include <clang/AST/Expr.h>
+#include <clang/Sema/Sema.h>
 #include <type_traits>
 
 namespace clang::mrdocs {
@@ -594,7 +595,7 @@ visit(
         else \
             MRDOCS_UNREACHABLE();
 
-    #include <clang/AST/DeclNodes.inc>
+#include <clang/AST/DeclNodes.inc>
 
     default:
         MRDOCS_UNREACHABLE();
@@ -654,7 +655,7 @@ visit(
         else \
             MRDOCS_UNREACHABLE();
 
-    #include <clang/AST/TypeNodes.inc>
+#include <clang/AST/TypeNodes.inc>
 
     default:
         MRDOCS_UNREACHABLE();
@@ -712,7 +713,7 @@ visit(
         else \
             MRDOCS_UNREACHABLE();
 
-    #include <clang/AST/TypeLocNodes.def>
+#include <clang/AST/TypeLocNodes.def>
 
     default:
         MRDOCS_UNREACHABLE();
diff --git a/src/lib/AST/FrontendActionFactory.cpp b/src/lib/AST/FrontendActionFactory.cpp
index 1956321fe..3d7a3f16c 100644
--- a/src/lib/AST/FrontendActionFactory.cpp
+++ b/src/lib/AST/FrontendActionFactory.cpp
@@ -12,7 +12,7 @@
 //
 
 #include "FrontendActionFactory.hpp"
-#include "lib/AST/ASTAction.hpp"
+#include <lib/AST/ASTAction.hpp>
 
 namespace clang {
 namespace mrdocs {
diff --git a/src/lib/AST/FrontendActionFactory.hpp b/src/lib/AST/FrontendActionFactory.hpp
index 1111b5db9..3c4ec99a1 100644
--- a/src/lib/AST/FrontendActionFactory.hpp
+++ b/src/lib/AST/FrontendActionFactory.hpp
@@ -14,9 +14,9 @@
 #ifndef MRDOCS_LIB_AST_FRONTENDACTIONFACTORY_HPP
 #define MRDOCS_LIB_AST_FRONTENDACTIONFACTORY_HPP
 
-#include "lib/ConfigImpl.hpp"
-#include "lib/Support/ExecutionContext.hpp"
-#include "lib/AST/MissingSymbolSink.hpp"
+#include <lib/AST/MissingSymbolSink.hpp>
+#include <lib/ConfigImpl.hpp>
+#include <lib/Support/ExecutionContext.hpp>
 #include <clang/Tooling/Tooling.h>
 
 namespace clang {
@@ -46,4 +46,4 @@ class ASTActionFactory :
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_LIB_AST_FRONTENDACTIONFACTORY_HPP
diff --git a/src/lib/AST/MissingSymbolSink.hpp b/src/lib/AST/MissingSymbolSink.hpp
index 1fb8319bc..fa634a3e2 100644
--- a/src/lib/AST/MissingSymbolSink.hpp
+++ b/src/lib/AST/MissingSymbolSink.hpp
@@ -8,18 +8,18 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_AST_MISSING_SYMBOL_SINK_HPP
-#define MRDOCS_LIB_AST_MISSING_SYMBOL_SINK_HPP
-
-#include "clang/Basic/Diagnostic.h"
-#include "clang/Basic/DiagnosticSema.h"
-#include "clang/Basic/SourceManager.h"
-#include "lib/ConfigImpl.hpp"
-#include "lib/Support/ExecutionContext.hpp"
-#include "lib/Support/Report.hpp"
-#include "llvm/ADT/StringExtras.h"
-#include "llvm/ADT/StringSet.h"
+#ifndef MRDOCS_LIB_AST_MISSINGSYMBOLSINK_HPP
+#define MRDOCS_LIB_AST_MISSINGSYMBOLSINK_HPP
+
 #include <mrdocs/Platform.hpp>
+#include <lib/ConfigImpl.hpp>
+#include <lib/Support/ExecutionContext.hpp>
+#include <lib/Support/Report.hpp>
+#include <clang/Basic/Diagnostic.h>
+#include <clang/Basic/DiagnosticSema.h>
+#include <clang/Basic/SourceManager.h>
+#include <llvm/ADT/StringExtras.h>
+#include <llvm/ADT/StringSet.h>
 #include <format>
 #include <mutex>
 #include <set>
@@ -438,4 +438,4 @@ class CollectingDiagConsumer : public clang::DiagnosticConsumer {
 } // namespace mrdocs
 } // namespace clang
 
-#endif
+#endif // MRDOCS_LIB_AST_MISSINGSYMBOLSINK_HPP
diff --git a/src/lib/AST/MrDocsFileSystem.hpp b/src/lib/AST/MrDocsFileSystem.hpp
index 268114507..558c6957d 100644
--- a/src/lib/AST/MrDocsFileSystem.hpp
+++ b/src/lib/AST/MrDocsFileSystem.hpp
@@ -8,15 +8,15 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_AST_MRDOCS_FILESYSTEM_HPP
-#define MRDOCS_LIB_AST_MRDOCS_FILESYSTEM_HPP
-
-#include "lib/ConfigImpl.hpp"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/VirtualFileSystem.h"
-#include "clang/Lex/HeaderSearch.h"
+#ifndef MRDOCS_LIB_AST_MRDOCSFILESYSTEM_HPP
+#define MRDOCS_LIB_AST_MRDOCSFILESYSTEM_HPP
+
+#include <lib/ConfigImpl.hpp>
+#include <clang/Lex/HeaderSearch.h>
+#include <llvm/ADT/SmallVector.h>
+#include <llvm/ADT/StringRef.h>
+#include <llvm/Support/MemoryBuffer.h>
+#include <llvm/Support/VirtualFileSystem.h>
 #include <atomic>
 #include <mutex>
 #include <string>
@@ -339,4 +339,4 @@ createMrDocsFileSystem(ConfigImpl const &Cfg)
 
 } // namespace clang::mrdocs
 
-#endif
+#endif // MRDOCS_LIB_AST_MRDOCSFILESYSTEM_HPP
diff --git a/src/lib/AST/NameInfoBuilder.cpp b/src/lib/AST/NameInfoBuilder.cpp
index 70bb3f60a..c0817ad63 100644
--- a/src/lib/AST/NameInfoBuilder.cpp
+++ b/src/lib/AST/NameInfoBuilder.cpp
@@ -11,7 +11,7 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "lib/AST/NameInfoBuilder.hpp"
+#include <lib/AST/NameInfoBuilder.hpp>
 
 namespace clang::mrdocs {
 
@@ -33,8 +33,8 @@ buildTerminal(
     unsigned,
     bool)
 {
-    Result = Polymorphic<NameInfo>();
-    Result->Name = getASTVisitor().toString(T);
+    Result = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
+    (*Result)->Name = getASTVisitor().toString(T);
 }
 
 void
@@ -52,22 +52,23 @@ buildTerminal(
             Polymorphic<NameInfo>(std::in_place_type<SpecializationNameInfo>);
         if (II)
         {
-            Result->Name = II->getName();
+            (*Result)->Name = II->getName();
         }
         getASTVisitor().populate(
-            static_cast<SpecializationNameInfo &>(*Result).TemplateArgs, *TArgs);
+            static_cast<SpecializationNameInfo&>(**Result).TemplateArgs,
+            *TArgs);
     }
     else
     {
-        Result = Polymorphic<NameInfo>();
+        Result = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
         if (II)
         {
-            Result->Name = II->getName();
+            (*Result)->Name = II->getName();
         }
     }
     if (NNS)
     {
-        Result->Prefix = getASTVisitor().toNameInfo(NNS);
+        (*Result)->Prefix = getASTVisitor().toNameInfo(NNS);
     }
 }
 
@@ -103,16 +104,17 @@ buildTerminal(
 
     if (!TArgs)
     {
-        Result = Polymorphic<NameInfo>();
-        populateNameInfo(*Result, D);
+        Result = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
+        populateNameInfo(**Result, D);
     }
     else
     {
-        Result =
-            Polymorphic<NameInfo>(std::in_place_type<SpecializationNameInfo>);
-        populateNameInfo(*Result, D);
+        Result = Polymorphic<NameInfo>(
+            std::in_place_type<SpecializationNameInfo>);
+        populateNameInfo(**Result, D);
         getASTVisitor().populate(
-            static_cast<SpecializationNameInfo &>(*Result).TemplateArgs, *TArgs);
+            static_cast<SpecializationNameInfo&>(**Result).TemplateArgs,
+            *TArgs);
     }
 }
 
diff --git a/src/lib/AST/NameInfoBuilder.hpp b/src/lib/AST/NameInfoBuilder.hpp
index 515a093bd..4de3b1b84 100644
--- a/src/lib/AST/NameInfoBuilder.hpp
+++ b/src/lib/AST/NameInfoBuilder.hpp
@@ -14,8 +14,8 @@
 #ifndef MRDOCS_LIB_AST_NAMEINFOBUILDER_HPP
 #define MRDOCS_LIB_AST_NAMEINFOBUILDER_HPP
 
-#include <mrdocs/ADT/Polymorphic.hpp>
 #include <lib/AST/TerminalTypeVisitor.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
 #include <clang/AST/TypeVisitor.h>
 
 namespace clang::mrdocs {
@@ -23,7 +23,7 @@ namespace clang::mrdocs {
 class NameInfoBuilder
     : public TerminalTypeVisitor<NameInfoBuilder>
 {
-    Polymorphic<NameInfo> Result;
+    Optional<Polymorphic<NameInfo>> Result;
 
 public:
     using TerminalTypeVisitor::TerminalTypeVisitor;
@@ -31,7 +31,14 @@ class NameInfoBuilder
     Polymorphic<NameInfo>
     result()
     {
-        return std::move(Result);
+        MRDOCS_ASSERT(Result.has_value());
+        return std::move(*Result);
+    }
+
+    constexpr bool
+    hasResult() const noexcept
+    {
+        return Result.has_value();
     }
 
     void
diff --git a/src/lib/AST/ParseJavadoc.cpp b/src/lib/AST/ParseJavadoc.cpp
index 70bde23cb..4e435c9eb 100644
--- a/src/lib/AST/ParseJavadoc.cpp
+++ b/src/lib/AST/ParseJavadoc.cpp
@@ -13,20 +13,21 @@
 //
 
 #include "ParseJavadoc.hpp"
-#include "lib/AST/ParseRef.hpp"
-#include <cctype>
-#include <clang/AST/ASTContext.h>
-#include <clang/AST/CommentCommandTraits.h>
-#include <clang/AST/RawCommentList.h>
-#include <clang/Basic/SourceLocation.h>
-#include <clang/Lex/Lexer.h>
-#include <format>
+#include <lib/AST/ParseRef.hpp>
 #include <mrdocs/Metadata/Javadoc.hpp>
+#include <mrdocs/Metadata/Javadoc/Text/Parts.hpp>
 #include <mrdocs/Support/Algorithm.hpp>
 #include <mrdocs/Support/Error.hpp>
 #include <mrdocs/Support/Path.hpp>
 #include <mrdocs/Support/ScopeExit.hpp>
 #include <mrdocs/Support/String.hpp>
+#include <clang/AST/ASTContext.h>
+#include <clang/AST/CommentCommandTraits.h>
+#include <clang/AST/RawCommentList.h>
+#include <clang/Basic/SourceLocation.h>
+#include <clang/Lex/Lexer.h>
+#include <cctype>
+#include <format>
 
 #ifdef _MSC_VER
 #pragma warning(push)
@@ -38,8 +39,8 @@
 #pragma warning(pop)
 #endif
 #include <clang/Basic/SourceManager.h>
-#include <llvm/Support/JSON.h>
 #include <llvm/ADT/StringExtras.h>
+#include <llvm/Support/JSON.h>
 #include <ranges>
 
 #ifdef NDEBUG
diff --git a/src/lib/AST/ParseJavadoc.hpp b/src/lib/AST/ParseJavadoc.hpp
index 2af42be28..429bcf81d 100644
--- a/src/lib/AST/ParseJavadoc.hpp
+++ b/src/lib/AST/ParseJavadoc.hpp
@@ -12,8 +12,8 @@
 #ifndef MRDOCS_LIB_AST_PARSEJAVADOC_HPP
 #define MRDOCS_LIB_AST_PARSEJAVADOC_HPP
 
-#include "lib/Diagnostics.hpp"
 #include <mrdocs/Platform.hpp>
+#include <lib/Diagnostics.hpp>
 #include <mrdocs/Config.hpp>
 #include <mrdocs/Metadata/Javadoc.hpp>
 
@@ -60,4 +60,4 @@ parseJavadoc(
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_LIB_AST_PARSEJAVADOC_HPP
diff --git a/src/lib/AST/ParseRef.cpp b/src/lib/AST/ParseRef.cpp
index 1a974ae20..a5ffdc3fa 100644
--- a/src/lib/AST/ParseRef.cpp
+++ b/src/lib/AST/ParseRef.cpp
@@ -8,14 +8,14 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "lib/AST/ParseRef.hpp"
+#include <lib/AST/ParseRef.hpp>
 #include <mrdocs/Metadata/Info/Function.hpp>
 #include <mrdocs/Metadata/Name.hpp>
+#include <mrdocs/Metadata/Type.hpp>
 #include <mrdocs/Support/Algorithm.hpp>
 #include <mrdocs/Support/Expected.hpp>
 #include <mrdocs/Support/Report.hpp>
 #include <llvm/ADT/StringExtras.h>
-
 #include <format>
 
 namespace clang::mrdocs {
@@ -42,13 +42,38 @@ isIdentifierContinuation(char const c)
     return isIdentifierStart(c) || isDigit(c);
 }
 
+/* Holds information about a parsed function suffix during reference parsing.
+
+   Used internally by RefParser to accumulate details about function parameters,
+   variadic status, and exception specifications while parsing C++ symbol
+   references.
+
+   Example: In 'void foo(int, double, ...)', Params holds 'int' and 'double',
+   IsVariadic is true, HasVoid is false.
+*/
 struct ParsedFunctionSuffix
 {
+    /* List of parsed function parameter types.
+       Example: For 'void foo(int, double)', Params contains 'int' and 'double'.
+    */
     llvm::SmallVector<Polymorphic<TypeInfo>, 8> Params;
+
+    /* True if the parameter list contains only 'void'.
+       Example: For 'void foo(void)', HasVoid is true.
+    */
     bool HasVoid{false};
+
+    /* True if the function is variadic (contains ...).
+       Example: For 'void foo(int, ...)', IsVariadic is true.
+    */
     bool IsVariadic{false};
+
+    /* Exception specification for the function.
+       Example: For 'void foo() noexcept', ExceptionSpec holds 'noexcept'.
+    */
     NoexceptInfo ExceptionSpec;
 
+    /* Virtual destructor for safe polymorphic deletion. */
     virtual ~ParsedFunctionSuffix() = default;
 };
 
@@ -448,9 +473,9 @@ class RefParser
             return false;
         }
         skipWhitespace();
-        Polymorphic<TypeInfo> conversionType = std::nullopt;
+        Polymorphic<TypeInfo> conversionType = nullable_traits<Polymorphic<TypeInfo>>::null();
         if (!parseDeclarationSpecifier(conversionType) ||
-            !conversionType)
+            conversionType.valueless_after_move())
         {
             ptr_ = start;
             return false;
@@ -585,14 +610,17 @@ class RefParser
             return false;
         }
         skipWhitespace();
-        TemplateArguments.emplace_back(std::nullopt);
+        // Add an empty slot for the first template argument
+        TemplateArguments.emplace_back(nullable_traits<Polymorphic<TArg>>::null());
         while (parseTemplateArgument(TemplateArguments.back()))
         {
             skipWhitespace();
             if (parseLiteral(','))
             {
                 skipWhitespace();
-                TemplateArguments.emplace_back(std::nullopt);
+                // Add another empty slot for the next argument after each comma
+                // This allows parseTemplateArgument to fill the new slot
+                TemplateArguments.emplace_back(nullable_traits<Polymorphic<TArg>>::null());
             }
             else
             {
@@ -622,16 +650,16 @@ class RefParser
         }
         skipWhitespace();
         char const* start = ptr_;
-        Polymorphic<TypeInfo> type = std::nullopt;
+        Polymorphic<TypeInfo> type = nullable_traits<Polymorphic<TypeInfo>>::null();
         if (parseTypeId(type))
         {
             dest = Polymorphic<TArg>(std::in_place_type<TypeTArg>);
-            static_cast<TypeTArg &>(*dest).Type = std::move(type);
+            dynamic_cast<TypeTArg &>(*dest).Type = std::move(type);
             return true;
         }
 
         // If the argument is not a type-id, it is an expression
-        // The expression is internally balanced in regards to '<'
+        // The expression is internally balanced regarding '<'
         // and '>' and ends with a comma
         char const* exprStart = ptr_;
         while (parseBalanced("<", ">", {",", ">"}))
@@ -790,7 +818,7 @@ class RefParser
 
         // https://en.cppreference.com/w/cpp/language/function#Parameter_list
         // decl-specifier-seq
-        auto &curParam = dest.Params.emplace_back(std::nullopt);
+        auto &curParam = dest.Params.emplace_back(nullable_traits<Polymorphic<TypeInfo>>::null());
         if (!parseTypeId(curParam))
         {
             ptr_ = start;
@@ -885,7 +913,7 @@ class RefParser
                 // If we have one of the "long", "short", "signed", "unsigned"
                 // specifiers, then we don't have an error because
                 // we can later infer the type from these.
-                if (!dest &&
+                if (dest.valueless_after_move() &&
                     !contains_any(specifiers, typeModifiers))
                 {
                     setError(specStart, "expected declaration specifier");
@@ -908,7 +936,7 @@ class RefParser
                 break;
             }
         }
-        if (!dest && specifiers.empty())
+        if (dest.valueless_after_move() && specifiers.empty())
         {
             // We need at least one type declarator or specifier
             ptr_ = start;
@@ -979,11 +1007,10 @@ class RefParser
             std::string_view signStr = explicitlySigned ? "signed" : "unsigned";
             // Infer basic fundamental type from "signed" or "unsigned",
             // which is "int"
-            if (!dest)
+            if (dest.valueless_after_move())
             {
                 dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-                auto &NTI = static_cast<NamedTypeInfo &>(*dest);
-                NTI.Name = Polymorphic<NameInfo>();
+                auto &NTI = dynamic_cast<NamedTypeInfo &>(*dest);
                 NTI.Name->Name = "int";
                 NTI.FundamentalType = FundamentalTypeKind::Int;
             }
@@ -1023,11 +1050,11 @@ class RefParser
         if (contains(specifiers, "short"))
         {
             // Infer basic fundamental type for "short", which is "int"
-            if (!dest)
+            if (dest.valueless_after_move())
             {
                 dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-                auto &NTI = static_cast<NamedTypeInfo &>(*dest);
-                NTI.Name = Polymorphic<NameInfo>();
+                auto &NTI = dynamic_cast<NamedTypeInfo &>(*dest);
+                NTI.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
                 NTI.Name->Name = "int";
                 NTI.FundamentalType = FundamentalTypeKind::Int;
             }
@@ -1062,11 +1089,11 @@ class RefParser
         if (contains(specifiers, "long"))
         {
             // Infer basic fundamental type for "long", which is "int"
-            if (!dest)
+            if (dest.valueless_after_move())
             {
                 dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-                auto &NTI = static_cast<NamedTypeInfo &>(*dest);
-                NTI.Name = Polymorphic<NameInfo>();
+                auto &NTI = dynamic_cast<NamedTypeInfo &>(*dest);
+                NTI.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
                 NTI.Name->Name = "int";
                 NTI.FundamentalType = FundamentalTypeKind::Int;
             }
@@ -1106,7 +1133,7 @@ class RefParser
         }
 
         // Final check: if dest is still empty, we have an error
-        if (!dest)
+        if (dest.valueless_after_move())
         {
             ptr_ = start;
             setError("expected parameter type");
@@ -1126,7 +1153,7 @@ class RefParser
         char const* start = ptr_;
 
         // Some rules are only valid if dest was initially empty
-        auto checkDestWasEmpty = [destWasEmpty=!dest, start, this]() {
+        auto checkDestWasEmpty = [destWasEmpty=dest.valueless_after_move(), start, this]() {
             if (!destWasEmpty)
             {
                 setError(start, "multiple type declaration specifiers");
@@ -1178,8 +1205,8 @@ class RefParser
             MRDOCS_CHECK_OR(checkDestWasEmpty(), false);
 
             dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-            auto &NTI = static_cast<NamedTypeInfo &>(*dest);
-            NTI.Name = Polymorphic<NameInfo>();
+            auto &NTI = dynamic_cast<NamedTypeInfo &>(*dest);
+            MRDOCS_ASSERT(!NTI.Name.valueless_after_move());
             NTI.Name->Name = std::string_view(start, ptr_ - start);
             if (FundamentalTypeKind k;
                 fromString(NTI.Name->Name, k))
@@ -1353,7 +1380,7 @@ class RefParser
         bool const allowTemplateDisambiguation,
         bool const allowTemplateArguments)
     {
-        if (dest)
+        if (!dest.valueless_after_move())
         {
             setError("type specifier is already set");
             return false;
@@ -1372,12 +1399,13 @@ class RefParser
 
             // Populate dest
             auto const idStr = std::string_view(idStart, ptr_ - idStart);
-            Polymorphic<NameInfo> ParentName =
-                dest ? dynamic_cast<NamedTypeInfo *>(&*dest)->Name
-                     : std::nullopt;
+            Optional<Polymorphic<NameInfo>>
+                ParentName = !dest.valueless_after_move() ?
+                                 Optional<Polymorphic<NameInfo>>(dynamic_cast<NamedTypeInfo*>(&*dest)->Name) :
+                                 Optional<Polymorphic<NameInfo>>(std::nullopt);
             dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-            auto &NTI = static_cast<NamedTypeInfo &>(*dest);
-            NTI.Name = Polymorphic<NameInfo>();
+            auto &NTI = dynamic_cast<NamedTypeInfo &>(*dest);
+            NTI.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
             NTI.Name->Name = idStr;
             NTI.Name->Prefix = std::move(ParentName);
 
@@ -1391,7 +1419,7 @@ class RefParser
             }
             skipWhitespace();
         }
-        if (!dest)
+        if (dest.valueless_after_move())
         {
             ptr_ = start;
             return false;
@@ -1481,7 +1509,7 @@ class RefParser
             ptr_ = start;
             return false;
         }
-        if (!dest)
+        if (dest.valueless_after_move())
         {
             setError("no type defined by specifiers and declarator");
             ptr_ = start;
@@ -1522,7 +1550,7 @@ class RefParser
             // For instance, in "int (*)[3][6]", we have a pointer to an
             // array of 3 arrays of 6 ints.
             std::size_t curSuffixLevel = suffixLevel;
-            while (curSuffixLevel > 0 && inner && inner->get())
+            while (curSuffixLevel > 0 && inner && !inner->get().valueless_after_move())
             {
                 auto& ref = inner->get();
                 inner = innerType(*ref);
@@ -1551,7 +1579,7 @@ class RefParser
         // https://en.cppreference.com/w/cpp/language/declarations#Declarators
         char const* start = ptr_;
 
-        if (!dest)
+        if (dest.valueless_after_move())
         {
             setError("expected parameter type for '...'");
             ptr_ = start;
@@ -1722,7 +1750,7 @@ class RefParser
             // Assemble the parent type for the NNS
             NamedTypeInfo ParentType;
             auto NNSString = std::string_view(start, NNSEnd - start);
-            NameInfo NNS;
+            IdentifierNameInfo NNS;
             auto const NNSRange = llvm::split(NNSString, "::");
             MRDOCS_ASSERT(!NNSRange.empty());
             auto NNSIt = NNSRange.begin();
@@ -1736,7 +1764,7 @@ class RefParser
                 {
                     break;
                 }
-                NameInfo NewNNS;
+                IdentifierNameInfo NewNNS;
                 NewNNS.Name = std::string(unqualID);
                 NewNNS.Prefix = Polymorphic<NameInfo>(std::move(NNS));
                 NNS = NewNNS;
diff --git a/src/lib/AST/ParseRef.hpp b/src/lib/AST/ParseRef.hpp
index 03091ba90..34fc7218f 100644
--- a/src/lib/AST/ParseRef.hpp
+++ b/src/lib/AST/ParseRef.hpp
@@ -8,13 +8,13 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_PARSEREF_HPP
-#define MRDOCS_LIB_PARSEREF_HPP
+#ifndef MRDOCS_LIB_AST_PARSEREF_HPP
+#define MRDOCS_LIB_AST_PARSEREF_HPP
 
+#include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Metadata/Specifiers.hpp>
 #include <mrdocs/Metadata/Type.hpp>
 #include <mrdocs/Support/Parse.hpp>
-#include <mrdocs/ADT/Polymorphic.hpp>
 #include <llvm/ADT/SmallVector.h>
 #include <string_view>
 
@@ -36,7 +36,7 @@ struct ParsedRefComponent {
 
     // If not empty, this is a conversion operator
     // Only the last component can be a conversion operator
-    Polymorphic<TypeInfo> ConversionType = std::nullopt;
+    Optional<Polymorphic<TypeInfo>> ConversionType = std::nullopt;
 
     constexpr
     bool
@@ -82,4 +82,4 @@ parse(
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_LIB_AST_PARSEREF_HPP
diff --git a/src/lib/AST/TypeInfoBuilder.cpp b/src/lib/AST/TypeInfoBuilder.cpp
index 30527d5de..76bc6512d 100644
--- a/src/lib/AST/TypeInfoBuilder.cpp
+++ b/src/lib/AST/TypeInfoBuilder.cpp
@@ -11,7 +11,7 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "lib/AST/TypeInfoBuilder.hpp"
+#include <lib/AST/TypeInfoBuilder.hpp>
 
 namespace clang::mrdocs {
 
@@ -20,7 +20,7 @@ TypeInfoBuilder::
 buildPointer(PointerType const*, unsigned quals)
 {
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<PointerTypeInfo>);
-    auto &I = static_cast<PointerTypeInfo &>(**Inner);
+    auto &I = dynamic_cast<PointerTypeInfo &>(***Inner);
     I.IsConst = quals & Qualifiers::Const;
     I.IsVolatile = quals & Qualifiers::Volatile;
     Inner = &I.PointeeType;
@@ -31,7 +31,7 @@ TypeInfoBuilder::
 buildLValueReference(LValueReferenceType const*)
 {
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<LValueReferenceTypeInfo>);
-    Inner = &static_cast<LValueReferenceTypeInfo &>(**Inner).PointeeType;
+    Inner = &dynamic_cast<LValueReferenceTypeInfo &>(***Inner).PointeeType;
 }
 
 void
@@ -39,7 +39,7 @@ TypeInfoBuilder::
 buildRValueReference(RValueReferenceType const*)
 {
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<RValueReferenceTypeInfo>);
-    Inner = &static_cast<RValueReferenceTypeInfo &>(**Inner).PointeeType;
+    Inner = &dynamic_cast<RValueReferenceTypeInfo &>(***Inner).PointeeType;
 }
 
 void
@@ -49,7 +49,7 @@ buildMemberPointer(
     unsigned const quals)
 {
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<MemberPointerTypeInfo>);
-    auto &I = static_cast<MemberPointerTypeInfo &>(**Inner);
+    auto &I = dynamic_cast<MemberPointerTypeInfo &>(***Inner);
     I.IsConst = quals & Qualifiers::Const;
     I.IsVolatile = quals & Qualifiers::Volatile;
     // do not set NNS because the parent type is *not*
@@ -64,7 +64,7 @@ TypeInfoBuilder::
 buildArray(ArrayType const* T)
 {
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<ArrayTypeInfo>);
-    auto &I = static_cast<ArrayTypeInfo &>(**Inner);
+    auto &I = dynamic_cast<ArrayTypeInfo &>(***Inner);
     if (auto* CAT = dyn_cast<ConstantArrayType>(T))
     {
         getASTVisitor().populate(I.Bounds, CAT->getSizeExpr(), CAT->getSize());
@@ -82,7 +82,7 @@ populate(FunctionType const* T)
 {
     auto* FPT = cast<FunctionProtoType>(T);
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<FunctionTypeInfo>);
-    auto &I = static_cast<FunctionTypeInfo &>(**Inner);
+    auto &I = dynamic_cast<FunctionTypeInfo &>(***Inner);
     for (QualType const PT : FPT->getParamTypes())
     {
         I.ParamTypes.emplace_back(getASTVisitor().toTypeInfo(PT));
@@ -105,16 +105,16 @@ buildDecltype(
     bool pack)
 {
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<DecltypeTypeInfo>);
-    (*Inner)->Constraints = this->Constraints;
-    (*Inner)->IsPackExpansion = pack;
+    (**Inner)->Constraints = this->Constraints;
+    (**Inner)->IsPackExpansion = pack;
 
-    auto &I = static_cast<DecltypeTypeInfo &>(**Inner);
+    auto &I = dynamic_cast<DecltypeTypeInfo &>(***Inner);
     getASTVisitor().populate(I.Operand, T->getUnderlyingExpr());
     I.IsConst = quals & Qualifiers::Const;
     I.IsVolatile = quals & Qualifiers::Volatile;
 
-    Result->Constraints = this->Constraints;
-    Result->IsPackExpansion = pack;
+    (*Result)->Constraints = this->Constraints;
+    (*Result)->IsPackExpansion = pack;
 }
 
 void
@@ -125,10 +125,10 @@ buildAuto(
     bool const pack)
 {
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<AutoTypeInfo>);
-    (*Inner)->Constraints = this->Constraints;
-    (*Inner)->IsPackExpansion = pack;
+    (**Inner)->Constraints = this->Constraints;
+    (**Inner)->IsPackExpansion = pack;
 
-    auto &I = static_cast<AutoTypeInfo &>(**Inner);
+    auto &I = dynamic_cast<AutoTypeInfo &>(***Inner);
     I.IsConst = quals & Qualifiers::Const;
     I.IsVolatile = quals & Qualifiers::Volatile;
     I.Keyword = toAutoKind(T->getKeyword());
@@ -145,8 +145,8 @@ buildAuto(
         // Constraint->Prefix = getASTVisitor().buildNameInfo(
         //     cast<Decl>(CD->getDeclContext()));
     }
-    Result->Constraints = this->Constraints;
-    Result->IsPackExpansion = pack;
+    (*Result)->Constraints = this->Constraints;
+    (*Result)->IsPackExpansion = pack;
 }
 
 void
@@ -158,21 +158,21 @@ buildTerminal(
 {
     MRDOCS_SYMBOL_TRACE(T, getASTVisitor().context_);
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-    (*Inner)->IsPackExpansion = pack;
-    (*Inner)->Constraints = this->Constraints;
+    (**Inner)->IsPackExpansion = pack;
+    (**Inner)->Constraints = this->Constraints;
 
-    auto &TI = static_cast<NamedTypeInfo &>(**Inner);
+    auto &TI = dynamic_cast<NamedTypeInfo &>(***Inner);
     TI.IsConst = quals & Qualifiers::Const;
     TI.IsVolatile = quals & Qualifiers::Volatile;
-    TI.Name = Polymorphic<NameInfo>();
+    TI.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
     TI.Name->Name = getASTVisitor().toString(T);
     if (isa<BuiltinType>(T))
     {
         auto const* FT = cast<BuiltinType>(T);
         TI.FundamentalType = toFundamentalTypeKind(FT->getKind());
     }
-    Result->Constraints = this->Constraints;
-    Result->IsPackExpansion = pack;
+    (*Result)->Constraints = this->Constraints;
+    (*Result)->IsPackExpansion = pack;
 }
 
 void
@@ -185,17 +185,17 @@ buildTerminal(
     bool pack)
 {
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-    (*Inner)->IsPackExpansion = pack;
-    (*Inner)->Constraints = this->Constraints;
+    (**Inner)->IsPackExpansion = pack;
+    (**Inner)->Constraints = this->Constraints;
 
-    auto &I = static_cast<NamedTypeInfo &>(**Inner);
+    auto &I = dynamic_cast<NamedTypeInfo &>(***Inner);
     I.IsConst = quals & Qualifiers::Const;
     I.IsVolatile = quals & Qualifiers::Volatile;
 
     if (TArgs)
     {
         I.Name = Polymorphic<NameInfo>(std::in_place_type<SpecializationNameInfo>);
-        auto &Name = static_cast<SpecializationNameInfo &>(*I.Name);
+        auto &Name = dynamic_cast<SpecializationNameInfo &>(*I.Name);
         if (II)
         {
             Name.Name = II->getName();
@@ -205,7 +205,7 @@ buildTerminal(
     }
     else
     {
-        I.Name = Polymorphic<NameInfo>();
+        I.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
         auto &Name = *I.Name;
         if (II)
         {
@@ -213,8 +213,8 @@ buildTerminal(
         }
         Name.Prefix = getASTVisitor().toNameInfo(NNS);
     }
-    Result->Constraints = this->Constraints;
-    Result->IsPackExpansion = pack;
+    (*Result)->Constraints = this->Constraints;
+    (*Result)->IsPackExpansion = pack;
 }
 
 void
@@ -236,10 +236,10 @@ buildTerminal(
     MRDOCS_SYMBOL_TRACE(ID, getASTVisitor().context_);
 
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-    (*Inner)->IsPackExpansion = pack;
-    (*Inner)->Constraints = this->Constraints;
+    (**Inner)->IsPackExpansion = pack;
+    (**Inner)->Constraints = this->Constraints;
 
-    auto &TI = static_cast<NamedTypeInfo &>(**Inner);
+    auto &TI = dynamic_cast<NamedTypeInfo &>(***Inner);
     TI.IsConst = quals & Qualifiers::Const;
     TI.IsVolatile = quals & Qualifiers::Volatile;
 
@@ -261,19 +261,19 @@ buildTerminal(
 
     if (!TArgs)
     {
-        TI.Name = Polymorphic<NameInfo>();
+        TI.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
         populateNameInfo(*TI.Name, D);
     }
     else
     {
         TI.Name =
             Polymorphic<NameInfo>(std::in_place_type<SpecializationNameInfo>);
-        auto &Name = static_cast<SpecializationNameInfo &>(*TI.Name);
+        auto &Name = dynamic_cast<SpecializationNameInfo &>(*TI.Name);
         populateNameInfo(Name, D);
         getASTVisitor().populate(Name.TemplateArgs, *TArgs);
     }
-    Result->Constraints = this->Constraints;
-    Result->IsPackExpansion = pack;
+    (*Result)->Constraints = this->Constraints;
+    (*Result)->IsPackExpansion = pack;
 }
 
 } // clang::mrdocs
diff --git a/src/lib/AST/TypeInfoBuilder.hpp b/src/lib/AST/TypeInfoBuilder.hpp
index 7d103f253..d1bb7c5e6 100644
--- a/src/lib/AST/TypeInfoBuilder.hpp
+++ b/src/lib/AST/TypeInfoBuilder.hpp
@@ -40,7 +40,7 @@ class TypeInfoBuilder
        as a polymorphic `TypeInfo` object.
 
      */
-    Polymorphic<TypeInfo> Result = std::nullopt;
+    Optional<Polymorphic<TypeInfo>> Result = std::nullopt;
 
     /*  A pointer to the inner type of result currently being populated.
 
@@ -61,7 +61,7 @@ class TypeInfoBuilder
         `NamedTypeInfo` object, and the visiting process continues
         populating the `Inner` object.
      */
-    Polymorphic<TypeInfo>* Inner = &Result;
+    Optional<Polymorphic<TypeInfo>>* Inner = &Result;
 
 public:
     using TerminalTypeVisitor::TerminalTypeVisitor;
@@ -76,7 +76,15 @@ class TypeInfoBuilder
     Polymorphic<TypeInfo>
     result()
     {
-        return std::move(Result);
+        MRDOCS_ASSERT(hasResult());
+        return std::move(*Result);
+    }
+
+    constexpr
+    bool
+    hasResult() const noexcept
+    {
+        return Result.has_value();
     }
 
     /** Build type information for a pointer type.
diff --git a/src/lib/ConfigImpl.cpp b/src/lib/ConfigImpl.cpp
index 795be704c..73bcd9c55 100644
--- a/src/lib/ConfigImpl.cpp
+++ b/src/lib/ConfigImpl.cpp
@@ -11,10 +11,10 @@
 //
 
 #include "ConfigImpl.hpp"
-#include "lib/Support/Glob.hpp"
-#include "lib/Support/Path.hpp"
-#include <mrdocs/Support/Path.hpp>
+#include <lib/Support/Glob.hpp>
+#include <lib/Support/Path.hpp>
 #include <mrdocs/Support/Concepts.hpp>
+#include <mrdocs/Support/Path.hpp>
 #include <clang/Tooling/AllTUsExecution.h>
 #include <llvm/Support/FileSystem.h>
 #include <llvm/Support/Path.h>
diff --git a/src/lib/ConfigImpl.hpp b/src/lib/ConfigImpl.hpp
index b3a839286..495653210 100644
--- a/src/lib/ConfigImpl.hpp
+++ b/src/lib/ConfigImpl.hpp
@@ -13,7 +13,7 @@
 #ifndef MRDOCS_LIB_CONFIGIMPL_HPP
 #define MRDOCS_LIB_CONFIGIMPL_HPP
 
-#include "lib/Support/YamlFwd.hpp"
+#include <lib/Support/YamlFwd.hpp>
 #include <mrdocs/Config.hpp>
 #include <mrdocs/Support/Error.hpp>
 #include <llvm/Support/ThreadPool.h>
@@ -161,4 +161,4 @@ class ConfigImpl
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_LIB_CONFIGIMPL_HPP
diff --git a/src/lib/Corpus.cpp b/src/lib/Corpus.cpp
index 159a02938..2d2bd391f 100644
--- a/src/lib/Corpus.cpp
+++ b/src/lib/Corpus.cpp
@@ -9,7 +9,7 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "ConfigImpl.hpp"
+#include <lib/ConfigImpl.hpp>
 #include <mrdocs/Corpus.hpp>
 #include <mrdocs/Metadata.hpp>
 #include <mrdocs/Support/Error.hpp>
diff --git a/src/lib/CorpusImpl.cpp b/src/lib/CorpusImpl.cpp
index 258c4c8e6..1975164dc 100644
--- a/src/lib/CorpusImpl.cpp
+++ b/src/lib/CorpusImpl.cpp
@@ -12,17 +12,17 @@
 //
 
 #include "CorpusImpl.hpp"
-#include "lib/AST/FrontendActionFactory.hpp"
-#include "lib/AST/MissingSymbolSink.hpp"
-#include "lib/AST/MrDocsFileSystem.hpp"
-#include "lib/Metadata/Finalizers/BaseMembersFinalizer.hpp"
-#include "lib/Metadata/Finalizers/DerivedFinalizer.hpp"
-#include "lib/Metadata/Finalizers/JavadocFinalizer.hpp"
-#include "lib/Metadata/Finalizers/NamespacesFinalizer.hpp"
-#include "lib/Metadata/Finalizers/OverloadsFinalizer.hpp"
-#include "lib/Metadata/Finalizers/SortMembersFinalizer.hpp"
-#include "lib/Support/Chrono.hpp"
-#include "lib/Support/Report.hpp"
+#include <lib/AST/FrontendActionFactory.hpp>
+#include <lib/AST/MissingSymbolSink.hpp>
+#include <lib/AST/MrDocsFileSystem.hpp>
+#include <lib/Metadata/Finalizers/BaseMembersFinalizer.hpp>
+#include <lib/Metadata/Finalizers/DerivedFinalizer.hpp>
+#include <lib/Metadata/Finalizers/JavadocFinalizer.hpp>
+#include <lib/Metadata/Finalizers/NamespacesFinalizer.hpp>
+#include <lib/Metadata/Finalizers/OverloadsFinalizer.hpp>
+#include <lib/Metadata/Finalizers/SortMembersFinalizer.hpp>
+#include <lib/Support/Chrono.hpp>
+#include <lib/Support/Report.hpp>
 #include <mrdocs/Metadata.hpp>
 #include <mrdocs/Support/Algorithm.hpp>
 #include <mrdocs/Support/Error.hpp>
@@ -140,7 +140,7 @@ qualifiedNameCompare(
     Info const& context,
     CorpusImpl const& corpus)
 {
-    MRDOCS_CHECK_OR(lhs0 && rhs0, false);
+    MRDOCS_CHECK_OR(!lhs0.valueless_after_move() && !rhs0.valueless_after_move(), false);
     // Compare each component of the qualified name
     NameInfo const* lhs = &*lhs0;
     NameInfo const* rhs = &*rhs0;
@@ -150,8 +150,8 @@ qualifiedNameCompare(
         {
             return false;
         }
-        lhs = lhs->Prefix ? &*lhs->Prefix : nullptr;
-        rhs = rhs->Prefix ? &*rhs->Prefix : nullptr;
+        lhs = lhs->Prefix ? &**lhs->Prefix : nullptr;
+        rhs = rhs->Prefix ? &**rhs->Prefix : nullptr;
     }
     // We consumed all components of both names
     if (!lhs && !rhs)
@@ -184,13 +184,21 @@ qualifiedNameCompare(
             continue;
         }
         // Names matches, match next component
-        curName = curName->Prefix ? &*curName->Prefix : nullptr;
+        curName = curName->Prefix ? &**curName->Prefix : nullptr;
         curContext = curContext->Parent ? corpus.find(curContext->Parent) : nullptr;
     }
     // We should have consumed all components of the name with the context
     return !curName;
 }
 
+template <bool isInner>
+bool
+isDecayedEqualImpl(
+    Optional<Polymorphic<TypeInfo>> const& lhs,
+    Optional<Polymorphic<TypeInfo>> const& rhs,
+    Info const& context,
+    CorpusImpl const& corpus);
+
 template <bool isInner>
 bool
 isDecayedEqualImpl(
@@ -200,8 +208,8 @@ isDecayedEqualImpl(
     CorpusImpl const& corpus)
 {
     // Polymorphic
-    MRDOCS_CHECK_OR(static_cast<bool>(lhs) == static_cast<bool>(rhs), false);
-    MRDOCS_CHECK_OR(static_cast<bool>(lhs) && static_cast<bool>(rhs), true);
+    MRDOCS_CHECK_OR(lhs.valueless_after_move() == lhs.valueless_after_move(), false);
+    MRDOCS_CHECK_OR(!lhs.valueless_after_move() && !rhs.valueless_after_move(), true);
     // TypeInfo
     bool const decayToPointer = !isInner && (lhs->isArray() || rhs->isArray());
     if (!decayToPointer)
@@ -303,6 +311,19 @@ isDecayedEqualImpl(
     return true;
 }
 
+template <bool isInner>
+bool
+isDecayedEqualImpl(
+    Optional<Polymorphic<TypeInfo>> const& lhs,
+    Optional<Polymorphic<TypeInfo>> const& rhs,
+    Info const& context,
+    CorpusImpl const& corpus)
+{
+    MRDOCS_CHECK_OR(static_cast<bool>(lhs) == static_cast<bool>(rhs), false);
+    MRDOCS_CHECK_OR(static_cast<bool>(lhs) && static_cast<bool>(rhs), true);
+    return isDecayedEqualImpl<isInner>(*lhs, *rhs, context, corpus);
+}
+
 /* Compare two types for equality for the purposes of
    overload resolution.
  */
@@ -470,7 +491,8 @@ lookupImpl(
     if (auto* TI = contextPtr->asTypedefPtr())
     {
         MRDOCS_CHECK_OR(TI->Type, nullptr);
-        SymbolID resolvedSymbolID = TI->Type->namedSymbol();
+        MRDOCS_ASSERT(!TI->Type->valueless_after_move());
+        SymbolID resolvedSymbolID = (*TI->Type)->namedSymbol();
         contextPtr = this->find(resolvedSymbolID);
         MRDOCS_CHECK_OR(contextPtr, nullptr);
     }
@@ -619,7 +641,9 @@ lookupImpl(
             MRDOCS_CHECK_OR(F.IsExplicitObjectMemberFunction == ref.IsExplicitObjectMemberFunction, matchRes);
             for (std::size_t i = 0; i < F.Params.size(); ++i)
             {
-                auto& lhsType = F.Params[i].Type;
+                auto& lhsTypeOpt = F.Params[i].Type;
+                MRDOCS_CHECK_OR(lhsTypeOpt, matchRes);
+                auto& lhsType = *lhsTypeOpt;
                 auto& rhsType  = ref.FunctionParameters[i];
                 MRDOCS_CHECK_OR(isDecayedEqual(lhsType, rhsType, context, *this), matchRes);
             }
diff --git a/src/lib/CorpusImpl.hpp b/src/lib/CorpusImpl.hpp
index c8d70d0cf..0e628264b 100644
--- a/src/lib/CorpusImpl.hpp
+++ b/src/lib/CorpusImpl.hpp
@@ -12,21 +12,21 @@
 #ifndef MRDOCS_LIB_CORPUSIMPL_HPP
 #define MRDOCS_LIB_CORPUSIMPL_HPP
 
-#include "lib/AST/ParseRef.hpp"
-#include "ConfigImpl.hpp"
-#include "lib/Metadata/InfoSet.hpp"
-#include "lib/Support/Debug.hpp"
-#include <clang/Tooling/CompilationDatabase.h>
+#include <mrdocs/Platform.hpp>
+#include <lib/AST/ParseRef.hpp>
+#include <lib/ConfigImpl.hpp>
+#include <lib/Metadata/InfoSet.hpp>
+#include <lib/Support/Debug.hpp>
 #include <mrdocs/ADT/UnorderedStringMap.hpp>
 #include <mrdocs/Corpus.hpp>
 #include <mrdocs/Metadata.hpp>
-#include <mrdocs/Platform.hpp>
 #include <mrdocs/Support/Error.hpp>
+#include <clang/Tooling/CompilationDatabase.h>
+#include <functional>
 #include <map>
 #include <mutex>
-#include <string>
 #include <set>
-#include <functional>
+#include <string>
 
 namespace clang::mrdocs {
 
@@ -258,4 +258,4 @@ get(
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_LIB_CORPUSIMPL_HPP
diff --git a/src/lib/Diagnostics.hpp b/src/lib/Diagnostics.hpp
index c3f6c0141..010b35bda 100644
--- a/src/lib/Diagnostics.hpp
+++ b/src/lib/Diagnostics.hpp
@@ -8,12 +8,12 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_TOOL_DIAGNOSTICS_HPP
-#define MRDOCS_LIB_TOOL_DIAGNOSTICS_HPP
+#ifndef MRDOCS_LIB_DIAGNOSTICS_HPP
+#define MRDOCS_LIB_DIAGNOSTICS_HPP
 
-#include <format>
-#include <llvm/Support/raw_ostream.h>
 #include <mrdocs/Support/Report.hpp>
+#include <llvm/Support/raw_ostream.h>
+#include <format>
 #include <string>
 #include <unordered_map>
 
@@ -141,4 +141,4 @@ class Diagnostics
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_LIB_DIAGNOSTICS_HPP
diff --git a/src/lib/Dom/Object.cpp b/src/lib/Dom/Object.cpp
index fcdab886a..379ad5e99 100644
--- a/src/lib/Dom/Object.cpp
+++ b/src/lib/Dom/Object.cpp
@@ -8,10 +8,10 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <atomic>
-#include <format>
 #include <mrdocs/Dom/Object.hpp>
 #include <mrdocs/Support/RangeFor.hpp>
+#include <atomic>
+#include <format>
 #include <ranges>
 
 namespace clang {
diff --git a/src/lib/Dom/String.cpp b/src/lib/Dom/String.cpp
index 6e1b5d147..538f457e0 100644
--- a/src/lib/Dom/String.cpp
+++ b/src/lib/Dom/String.cpp
@@ -8,9 +8,9 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
+#include <mrdocs/Dom/String.hpp>
 #include <atomic>
 #include <cstring>
-#include <mrdocs/Dom/String.hpp>
 
 namespace clang {
 namespace mrdocs {
diff --git a/src/lib/Dom/Value.cpp b/src/lib/Dom/Value.cpp
index 7927f95b2..83eb6ce1e 100644
--- a/src/lib/Dom/Value.cpp
+++ b/src/lib/Dom/Value.cpp
@@ -9,8 +9,8 @@
 //
 
 #include <mrdocs/Dom/Value.hpp>
-#include <unordered_set>
 #include <algorithm>
+#include <unordered_set>
 
 namespace clang {
 namespace mrdocs {
diff --git a/src/lib/Gen/adoc/AdocGenerator.hpp b/src/lib/Gen/adoc/AdocGenerator.hpp
index a604be9ca..e35f2b28b 100644
--- a/src/lib/Gen/adoc/AdocGenerator.hpp
+++ b/src/lib/Gen/adoc/AdocGenerator.hpp
@@ -14,8 +14,8 @@
 #define MRDOCS_LIB_GEN_ADOC_ADOCGENERATOR_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Generator.hpp>
 #include <lib/Gen/hbs/HandlebarsGenerator.hpp>
+#include <mrdocs/Generator.hpp>
 
 namespace clang::mrdocs::adoc {
 
diff --git a/src/lib/Gen/hbs/Builder.cpp b/src/lib/Gen/hbs/Builder.cpp
index 7468013f0..a41ff4831 100644
--- a/src/lib/Gen/hbs/Builder.cpp
+++ b/src/lib/Gen/hbs/Builder.cpp
@@ -10,12 +10,12 @@
 //
 
 #include "Builder.hpp"
-#include "lib/ConfigImpl.hpp"
-#include <filesystem>
-#include <format>
+#include <lib/ConfigImpl.hpp>
 #include <mrdocs/Metadata/DomCorpus.hpp>
 #include <mrdocs/Support/Path.hpp>
 #include <mrdocs/Support/Report.hpp>
+#include <filesystem>
+#include <format>
 
 namespace clang {
 namespace mrdocs {
diff --git a/src/lib/Gen/hbs/Builder.hpp b/src/lib/Gen/hbs/Builder.hpp
index e2cc3894f..8b0ab4bfd 100644
--- a/src/lib/Gen/hbs/Builder.hpp
+++ b/src/lib/Gen/hbs/Builder.hpp
@@ -12,8 +12,8 @@
 #ifndef MRDOCS_LIB_GEN_HBS_BUILDER_HPP
 #define MRDOCS_LIB_GEN_HBS_BUILDER_HPP
 
-#include "HandlebarsCorpus.hpp"
-#include "lib/Support/Radix.hpp"
+#include <lib/Gen/hbs/HandlebarsCorpus.hpp>
+#include <lib/Support/Radix.hpp>
 #include <mrdocs/Metadata/DomCorpus.hpp>
 #include <mrdocs/Support/Error.hpp>
 #include <mrdocs/Support/Handlebars.hpp>
@@ -128,4 +128,4 @@ class Builder
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_LIB_GEN_HBS_BUILDER_HPP
diff --git a/src/lib/Gen/hbs/HandlebarsCorpus.cpp b/src/lib/Gen/hbs/HandlebarsCorpus.cpp
index 5e4314025..3535dd01b 100644
--- a/src/lib/Gen/hbs/HandlebarsCorpus.cpp
+++ b/src/lib/Gen/hbs/HandlebarsCorpus.cpp
@@ -12,11 +12,9 @@
 
 #include "HandlebarsCorpus.hpp"
 #include "VisitorHelpers.hpp"
-#include <iterator>
-#include <llvm/Support/raw_ostream.h>
-#include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Support/RangeFor.hpp>
 #include <mrdocs/Support/String.hpp>
+#include <iterator>
 
 namespace clang::mrdocs::hbs {
 
diff --git a/src/lib/Gen/hbs/HandlebarsCorpus.hpp b/src/lib/Gen/hbs/HandlebarsCorpus.hpp
index 3567d9590..0515901f6 100644
--- a/src/lib/Gen/hbs/HandlebarsCorpus.hpp
+++ b/src/lib/Gen/hbs/HandlebarsCorpus.hpp
@@ -13,10 +13,10 @@
 #define MRDOCS_LIB_GEN_HBS_HANDLEBARSCORPUS_HPP
 
 #include <mrdocs/Platform.hpp>
-#include "lib/Support/LegibleNames.hpp"
+#include <lib/Support/LegibleNames.hpp>
+#include <mrdocs/Corpus.hpp>
 #include <mrdocs/Metadata/DomCorpus.hpp>
 #include <mrdocs/Metadata/Javadoc.hpp>
-#include <mrdocs/Corpus.hpp>
 
 namespace clang::mrdocs::hbs {
 
@@ -72,4 +72,4 @@ class HandlebarsCorpus final : public DomCorpus
 
 } // clang::mrdocs::hbs
 
-#endif
+#endif // MRDOCS_LIB_GEN_HBS_HANDLEBARSCORPUS_HPP
diff --git a/src/lib/Gen/hbs/HandlebarsGenerator.cpp b/src/lib/Gen/hbs/HandlebarsGenerator.cpp
index fef070e24..64b018606 100644
--- a/src/lib/Gen/hbs/HandlebarsGenerator.cpp
+++ b/src/lib/Gen/hbs/HandlebarsGenerator.cpp
@@ -11,21 +11,17 @@
 //
 
 #include "HandlebarsGenerator.hpp"
-#include "HandlebarsCorpus.hpp"
 #include "Builder.hpp"
+#include "HandlebarsCorpus.hpp"
 #include "MultiPageVisitor.hpp"
 #include "SinglePageVisitor.hpp"
-
 #include "TagfileWriter.hpp"
-#include "lib/Support/RawOstream.hpp"
-
+#include <lib/Support/RawOstream.hpp>
+#include <mrdocs/Support/Path.hpp>
+#include <mrdocs/Support/Report.hpp>
 #include <llvm/ADT/SmallString.h>
 #include <llvm/Support/FileSystem.h>
 #include <llvm/Support/Path.h>
-
-#include <mrdocs/Support/Path.hpp>
-#include <mrdocs/Support/Report.hpp>
-
 #include <fstream>
 #include <sstream>
 
diff --git a/src/lib/Gen/hbs/HandlebarsGenerator.hpp b/src/lib/Gen/hbs/HandlebarsGenerator.hpp
index 3248517c6..5aa4ffc21 100644
--- a/src/lib/Gen/hbs/HandlebarsGenerator.hpp
+++ b/src/lib/Gen/hbs/HandlebarsGenerator.hpp
@@ -13,9 +13,9 @@
 #define MRDOCS_LIB_GEN_HBS_HANDLEBARSGENERATOR_HPP
 
 #include <mrdocs/Platform.hpp>
+#include <lib/Gen/hbs/HandlebarsCorpus.hpp>
 #include <mrdocs/Generator.hpp>
 #include <mrdocs/Metadata/DomCorpus.hpp>
-#include <lib/Gen/hbs/HandlebarsCorpus.hpp>
 #include <utility>
 
 namespace clang::mrdocs {
diff --git a/src/lib/Gen/hbs/MultiPageVisitor.cpp b/src/lib/Gen/hbs/MultiPageVisitor.cpp
index 09bb15a85..b77a578dd 100644
--- a/src/lib/Gen/hbs/MultiPageVisitor.cpp
+++ b/src/lib/Gen/hbs/MultiPageVisitor.cpp
@@ -11,9 +11,9 @@
 
 #include "MultiPageVisitor.hpp"
 #include "VisitorHelpers.hpp"
-#include <fstream>
 #include <mrdocs/Support/Path.hpp>
 #include <mrdocs/Support/Report.hpp>
+#include <fstream>
 
 namespace clang::mrdocs::hbs {
 
diff --git a/src/lib/Gen/hbs/MultiPageVisitor.hpp b/src/lib/Gen/hbs/MultiPageVisitor.hpp
index d2dfd7df2..13b306edf 100644
--- a/src/lib/Gen/hbs/MultiPageVisitor.hpp
+++ b/src/lib/Gen/hbs/MultiPageVisitor.hpp
@@ -12,14 +12,14 @@
 #ifndef MRDOCS_LIB_GEN_HBS_MULTIPAGEVISITOR_HPP
 #define MRDOCS_LIB_GEN_HBS_MULTIPAGEVISITOR_HPP
 
-#include "Builder.hpp"
-#include <mrdocs/Support/ExecutorGroup.hpp>
+#include <lib/Gen/hbs/Builder.hpp>
 #include <mrdocs/Metadata/Info.hpp>
+#include <mrdocs/Support/ExecutorGroup.hpp>
+#include <atomic>
 #include <mutex>
 #include <ostream>
 #include <string>
 #include <vector>
-#include <atomic>
 
 namespace clang::mrdocs::hbs {
 
diff --git a/src/lib/Gen/hbs/SinglePageVisitor.hpp b/src/lib/Gen/hbs/SinglePageVisitor.hpp
index 797da308a..9d938819b 100644
--- a/src/lib/Gen/hbs/SinglePageVisitor.hpp
+++ b/src/lib/Gen/hbs/SinglePageVisitor.hpp
@@ -12,7 +12,7 @@
 #ifndef MRDOCS_LIB_GEN_HBS_SINGLEPAGEVISITOR_HPP
 #define MRDOCS_LIB_GEN_HBS_SINGLEPAGEVISITOR_HPP
 
-#include "Builder.hpp"
+#include <lib/Gen/hbs/Builder.hpp>
 #include <mrdocs/Support/ExecutorGroup.hpp>
 #include <mutex>
 #include <ostream>
diff --git a/src/lib/Gen/hbs/TagfileWriter.cpp b/src/lib/Gen/hbs/TagfileWriter.cpp
index cedb20d99..01c8519b9 100644
--- a/src/lib/Gen/hbs/TagfileWriter.cpp
+++ b/src/lib/Gen/hbs/TagfileWriter.cpp
@@ -9,15 +9,13 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "lib/Gen/xml/CXXTags.hpp"
 #include "TagfileWriter.hpp"
-#include "lib/Gen/hbs/VisitorHelpers.hpp"
-#include "lib/ConfigImpl.hpp"
-#include "lib/Support/RawOstream.hpp"
-
-#include <llvm/Support/FileSystem.h>
-
+#include <lib/ConfigImpl.hpp>
+#include <lib/Gen/hbs/VisitorHelpers.hpp>
+#include <lib/Gen/xml/CXXTags.hpp>
+#include <lib/Support/RawOstream.hpp>
 #include <mrdocs/Support/Path.hpp>
+#include <llvm/Support/FileSystem.h>
 
 namespace clang::mrdocs {
 
@@ -202,7 +200,11 @@ TagfileWriter::
 writeFunctionMember(FunctionInfo const& I)
 {
     tags_.open("member", {{"kind", "function"}});
-    tags_.write("type", toString(*I.ReturnType));
+    if (I.ReturnType)
+    {
+        MRDOCS_ASSERT(!I.ReturnType->valueless_after_move());
+        tags_.write("type", toString(**I.ReturnType));
+    }
     tags_.write("name", I.Name);
     auto [anchorFile, anchor] = generateFileAndAnchor(I);
     tags_.write("anchorfile", anchorFile);
@@ -210,10 +212,16 @@ writeFunctionMember(FunctionInfo const& I)
     std::string arglist = "(";
     for(auto const& J : I.Params)
     {
-        arglist += toString(*J.Type);
+        if (J.Type)
+        {
+            arglist += toString(**J.Type);
+            if (J.Name)
+            {
+                arglist += " ";
+            }
+        }
         if (J.Name)
         {
-            arglist += " ";
             arglist += *J.Name;
         }
         arglist += ", ";
diff --git a/src/lib/Gen/hbs/TagfileWriter.hpp b/src/lib/Gen/hbs/TagfileWriter.hpp
index c571f5a6a..83f424976 100644
--- a/src/lib/Gen/hbs/TagfileWriter.hpp
+++ b/src/lib/Gen/hbs/TagfileWriter.hpp
@@ -9,14 +9,13 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_TAGFILEWRITER_HPP
-#define MRDOCS_LIB_TAGFILEWRITER_HPP
+#ifndef MRDOCS_LIB_GEN_HBS_TAGFILEWRITER_HPP
+#define MRDOCS_LIB_GEN_HBS_TAGFILEWRITER_HPP
 
-#include "lib/Gen/xml/XMLTags.hpp"
-#include "lib/Gen/hbs/HandlebarsCorpus.hpp"
+#include <lib/Gen/hbs/HandlebarsCorpus.hpp>
+#include <lib/Gen/xml/XMLTags.hpp>
 #include <mrdocs/Metadata.hpp>
 #include <mrdocs/Support/Error.hpp>
-
 #include <fstream>
 #include <string>
 
@@ -142,4 +141,4 @@ class TagfileWriter
 } // mrdocs
 } // clang
 
-#endif
\ No newline at end of file
+#endif // MRDOCS_LIB_GEN_HBS_TAGFILEWRITER_HPP
\ No newline at end of file
diff --git a/src/lib/Gen/hbs/VisitorHelpers.cpp b/src/lib/Gen/hbs/VisitorHelpers.cpp
index 5464e1f40..48b62d8a1 100644
--- a/src/lib/Gen/hbs/VisitorHelpers.cpp
+++ b/src/lib/Gen/hbs/VisitorHelpers.cpp
@@ -50,8 +50,10 @@ resolveTypedef(Corpus const& c, Info const& I)
     if (I.isTypedef())
     {
         auto const& TI = I.asTypedef();
-        Polymorphic<TypeInfo> const& T = TI.Type;
-        MRDOCS_CHECK_OR(T && T->Kind == TypeKind::Named, &I);
+        MRDOCS_CHECK_OR(TI.Type, &I);
+        MRDOCS_ASSERT(!TI.Type->valueless_after_move());
+        Polymorphic<TypeInfo> const& T = *TI.Type;
+        MRDOCS_CHECK_OR(!T.valueless_after_move() && T->Kind == TypeKind::Named, &I);
         auto const& NT = dynamic_cast<NamedTypeInfo const&>(*T);
         MRDOCS_CHECK_OR(NT.Name, &I);
         Info const* resolved = c.find(NT.Name->id);
@@ -168,8 +170,11 @@ findResolvedPrimarySiblingWithUrl(Corpus const& c, Info const& I)
         // The symbol is a typedef to a specialization
         if constexpr (std::same_as<InfoTy, TypedefInfo>)
         {
-            Polymorphic<TypeInfo> const& T = U.Type;
-            MRDOCS_CHECK_OR(T && T->Kind == TypeKind::Named, false);
+            auto const& TOpt = U.Type;
+            MRDOCS_CHECK_OR(TOpt, false);
+            Polymorphic<TypeInfo> const& T = *TOpt;
+            MRDOCS_CHECK_OR(!T.valueless_after_move(), false);
+            MRDOCS_CHECK_OR(T->Kind == TypeKind::Named, false);
             auto const& NT = dynamic_cast<NamedTypeInfo const&>(*T);
             MRDOCS_CHECK_OR(NT.Name, false);
             MRDOCS_CHECK_OR(NT.Name->Kind == NameKind::Specialization, false);
diff --git a/src/lib/Gen/hbs/VisitorHelpers.hpp b/src/lib/Gen/hbs/VisitorHelpers.hpp
index 8a1341ae1..67d007ba1 100644
--- a/src/lib/Gen/hbs/VisitorHelpers.hpp
+++ b/src/lib/Gen/hbs/VisitorHelpers.hpp
@@ -11,8 +11,9 @@
 #ifndef MRDOCS_LIB_GEN_HBS_VISITORHELPERS_HPP
 #define MRDOCS_LIB_GEN_HBS_VISITORHELPERS_HPP
 
-#include <mrdocs/Metadata/Info.hpp>
 #include <mrdocs/Config.hpp>
+#include <mrdocs/Corpus.hpp>
+#include <mrdocs/Metadata/Info.hpp>
 
 namespace clang::mrdocs::hbs {
 
diff --git a/src/lib/Gen/html/HTMLGenerator.hpp b/src/lib/Gen/html/HTMLGenerator.hpp
index 0b66f532b..921decdd6 100644
--- a/src/lib/Gen/html/HTMLGenerator.hpp
+++ b/src/lib/Gen/html/HTMLGenerator.hpp
@@ -14,8 +14,8 @@
 #define MRDOCS_LIB_GEN_HTML_HTMLGENERATOR_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Generator.hpp>
 #include <lib/Gen/hbs/HandlebarsGenerator.hpp>
+#include <mrdocs/Generator.hpp>
 
 namespace clang::mrdocs::html {
 
diff --git a/src/lib/Gen/xml/CXXTags.cpp b/src/lib/Gen/xml/CXXTags.cpp
index a5ea3bbfd..e80682f30 100644
--- a/src/lib/Gen/xml/CXXTags.cpp
+++ b/src/lib/Gen/xml/CXXTags.cpp
@@ -10,8 +10,8 @@
 //
 
 #include "CXXTags.hpp"
-#include <mrdocs/Metadata/Info/Typedef.hpp>
 #include <mrdocs/Metadata/Info/Record.hpp>
+#include <mrdocs/Metadata/Info/Typedef.hpp>
 #include <mrdocs/Support/String.hpp>
 
 namespace clang::mrdocs::xml {
diff --git a/src/lib/Gen/xml/CXXTags.hpp b/src/lib/Gen/xml/CXXTags.hpp
index c09e42f7a..28eb954e9 100644
--- a/src/lib/Gen/xml/CXXTags.hpp
+++ b/src/lib/Gen/xml/CXXTags.hpp
@@ -13,9 +13,10 @@
 #ifndef MRDOCS_LIB_GEN_XML_CXXTAGS_HPP
 #define MRDOCS_LIB_GEN_XML_CXXTAGS_HPP
 
-#include "XMLTags.hpp"
+#include <lib/Gen/xml/XMLTags.hpp>
 #include <mrdocs/Metadata/Info/Function.hpp>
 #include <mrdocs/Metadata/Name.hpp>
+#include <mrdocs/Metadata/TParam.hpp>
 #include <mrdocs/Metadata/Type.hpp>
 
 /*
@@ -137,13 +138,16 @@ writeType(
             // KRYSTIAN FIXME: parent should is a type itself
             if constexpr(requires { t.ParentType; })
             {
-                if(t.ParentType)
-                    attrs.push({"parent", toString(*t.ParentType)});
+                if (t.ParentType)
+                {
+                    MRDOCS_ASSERT(!t.ParentType->valueless_after_move());
+                    attrs.push({ "parent", toString(**t.ParentType) });
+                }
             }
 
             if constexpr(T::isNamed())
             {
-                if(t.Name)
+                if(!t.Name.valueless_after_move())
                 {
                     attrs.push({t.Name->id});
                     attrs.push({"name", toString(*t.Name)});
@@ -184,9 +188,13 @@ writeType(
 
             if constexpr(T::isAuto())
             {
-                attrs.push({"keyword", toString(t.Keyword)});
-                if(t.Constraint)
-                    attrs.push({"constraint", toString(*t.Constraint)});
+                AutoTypeInfo const& at = t;
+                attrs.push({"keyword", toString(at.Keyword)});
+                if(at.Constraint)
+                {
+                    MRDOCS_ASSERT(!at.Constraint->valueless_after_move());
+                    attrs.push({"constraint", toString(**t.Constraint)});
+                }
             }
 
             if constexpr(T::isFunction())
@@ -215,19 +223,36 @@ writeType(
 
             if constexpr(requires { t.PointeeType; })
             {
-                writeType(*t.PointeeType, tags, "pointee-type");
+                Optional<Polymorphic<TypeInfo>> pointee = t.PointeeType;
+                if (pointee)
+                {
+                    MRDOCS_ASSERT(!pointee->valueless_after_move());
+                    writeType(**t.PointeeType, tags, "pointee-type");
+                }
             }
 
             if constexpr(T::isArray())
             {
-                writeType(*t.ElementType, tags, "element-type");
+                ArrayTypeInfo const& at = t;
+                if (at.ElementType)
+                {
+                    MRDOCS_ASSERT(!at.ElementType->valueless_after_move());
+                    writeType(**t.ElementType, tags, "element-type");
+                }
             }
 
             if constexpr(T::isFunction())
             {
-                writeType(*t.ReturnType, tags, "return-type");
-                for(auto const& p : t.ParamTypes)
-                    writeType(*p, tags, "param-type");
+                FunctionTypeInfo const& ft = t;
+                if (ft.ReturnType)
+                {
+                    MRDOCS_ASSERT(!ft.ReturnType->valueless_after_move());
+                    writeType(**t.ReturnType, tags, "return-type");
+                    for (auto const& p: t.ParamTypes)
+                    {
+                        writeType(*p, tags, "param-type");
+                    }
+                }
             }
 
             tags.close(type_tag);
@@ -240,11 +265,26 @@ writeType(
     Polymorphic<TypeInfo> const& type,
     XMLTags& tags)
 {
-    if(! type)
+    if (type.valueless_after_move())
+    {
         return;
+    }
     writeType(*type, tags);
 }
 
+inline
+void
+writeType(
+    Optional<Polymorphic<TypeInfo>> const& type,
+    XMLTags& tags)
+{
+    if (type)
+    {
+        writeType(*type, tags);
+    }
+}
+
+
 inline void writeReturnType(TypeInfo const& I, XMLTags& tags)
 {
     // KRYSTIAN NOTE: we don't *have* to do this...
@@ -269,60 +309,72 @@ inline void writeParam(Param const& P, XMLTags& tags)
 
 inline void writeTemplateParam(TParam const& I, XMLTags& tags)
 {
-    visit(I, [&]<typename T>(T const& P)
+    visit(I, [&]<typename T>(T const& P) {
+        TParam const & tp = P;
+        Attributes attrs = {
+            { "name", tp.Name, !tp.Name.empty() },
+            { "class", toString(T::kind_id) }
+        };
+
+        if constexpr (T::isNonType())
         {
-            Attributes attrs = {
-                {"name", P.Name, ! P.Name.empty()},
-                {"class", toString(T::kind_id)}
-            };
-
-            if constexpr(T::isNonType())
-                attrs.push({"type", toString(*P.Type)});
-
-            if(P.Default)
-                attrs.push({"default", toString(*P.Default)});
-
-            if constexpr(T::isTemplate())
+            NonTypeTParam const& nt = P;
+            if (nt.Type)
             {
-                tags.open(tparamTagName,
-                    std::move(attrs));
-                for(auto const& tparam : P.Params)
-                    writeTemplateParam(*tparam, tags);
-                tags.close(tparamTagName);
+                MRDOCS_ASSERT(!nt.Type->valueless_after_move());
+                attrs.push({ "type", toString(**nt.Type) });
             }
-            else
+        }
+
+        if (tp.Default)
+        {
+            MRDOCS_ASSERT(!tp.Default->valueless_after_move());
+            attrs.push({ "default", toString(**P.Default) });
+        }
+
+        if constexpr (T::isTemplate())
+        {
+            tags.open(tparamTagName, std::move(attrs));
+            for (auto const& tparam: P.Params)
             {
-                tags.write(tparamTagName, {},
-                    std::move(attrs));
+                writeTemplateParam(*tparam, tags);
             }
-        });
+            tags.close(tparamTagName);
+        } else
+        {
+            tags.write(tparamTagName, {}, std::move(attrs));
+        }
+    });
 }
 
 inline void writeTemplateArg(TArg const& I, XMLTags& tags)
 {
-    visit(I, [&]<typename T>(T const& A)
-        {
-            Attributes attrs = {
-                {"class", toString(T::kind_id)}
-            };
+    visit(I, [&]<typename T>(T const& A) {
+        Attributes attrs = {
+            { "class", toString(T::kind_id) }
+        };
 
-            if constexpr(T::isType())
-            {
-                attrs.push({"type", toString(*A.Type)});
-            }
-            if constexpr(T::isNonType())
-            {
-                attrs.push({"value", A.Value.Written});
-            }
-            if constexpr(T::isTemplate())
+        if constexpr (T::isType())
+        {
+            TypeTArg const& at = A;
+            if (at.Type)
             {
-                attrs.push({"name", A.Name});
-                attrs.push({A.Template});
+                MRDOCS_ASSERT(!at.Type->valueless_after_move());
+                attrs.push({ "type", toString(**A.Type) });
             }
+        }
+        if constexpr (T::isNonType())
+        {
+            attrs.push({ "value", A.Value.Written });
+        }
+        if constexpr (T::isTemplate())
+        {
+            attrs.push({ "name", A.Name });
+            attrs.push({ A.Template });
+        }
 
-            tags.write(targTagName, {},
-                std::move(attrs));
-        });
+        tags.write(targTagName, {}, std::move(attrs));
+    });
 }
 
 /** Return the xml tag name for the Info.
diff --git a/src/lib/Gen/xml/XMLGenerator.cpp b/src/lib/Gen/xml/XMLGenerator.cpp
index d4b5b0a90..42e4ab749 100644
--- a/src/lib/Gen/xml/XMLGenerator.cpp
+++ b/src/lib/Gen/xml/XMLGenerator.cpp
@@ -11,10 +11,10 @@
 
 #include "XMLGenerator.hpp"
 #include "XMLWriter.hpp"
-#include "lib/Support/Radix.hpp"
-#include "lib/Support/RawOstream.hpp"
-#include <mrdocs/Support/Error.hpp>
+#include <lib/Support/Radix.hpp>
+#include <lib/Support/RawOstream.hpp>
 #include <mrdocs/Metadata.hpp>
+#include <mrdocs/Support/Error.hpp>
 
 namespace clang {
 namespace mrdocs {
diff --git a/src/lib/Gen/xml/XMLTags.cpp b/src/lib/Gen/xml/XMLTags.cpp
index 2885bdf12..d93448d1d 100644
--- a/src/lib/Gen/xml/XMLTags.cpp
+++ b/src/lib/Gen/xml/XMLTags.cpp
@@ -10,8 +10,8 @@
 //
 
 #include "XMLTags.hpp"
-#include "lib/Support/Radix.hpp"
 #include <mrdocs/Platform.hpp>
+#include <lib/Support/Radix.hpp>
 
 namespace clang {
 namespace mrdocs {
diff --git a/src/lib/Gen/xml/XMLTags.hpp b/src/lib/Gen/xml/XMLTags.hpp
index 6dbc01247..450b726d9 100644
--- a/src/lib/Gen/xml/XMLTags.hpp
+++ b/src/lib/Gen/xml/XMLTags.hpp
@@ -12,15 +12,15 @@
 #ifndef MRDOCS_LIB_GEN_XML_XMLTAGS_HPP
 #define MRDOCS_LIB_GEN_XML_XMLTAGS_HPP
 
-#include <optional>
-#include <vector>
-#include <clang/Basic/Specifiers.h>
-#include <llvm/ADT/StringRef.h>
-#include <llvm/Support/raw_ostream.h>
 #include <mrdocs/Dom.hpp>
+#include <mrdocs/Metadata/Info/SymbolID.hpp>
 #include <mrdocs/Metadata/Javadoc.hpp>
-#include <mrdocs/Metadata/SymbolID.hpp>
 #include <mrdocs/Metadata/Type.hpp>
+#include <clang/Basic/Specifiers.h>
+#include <llvm/ADT/StringRef.h>
+#include <llvm/Support/raw_ostream.h>
+#include <optional>
+#include <vector>
 
 /*
     Object for assisting with generating
diff --git a/src/lib/Gen/xml/XMLWriter.cpp b/src/lib/Gen/xml/XMLWriter.cpp
index d39f58345..48ac28a9a 100644
--- a/src/lib/Gen/xml/XMLWriter.cpp
+++ b/src/lib/Gen/xml/XMLWriter.cpp
@@ -10,13 +10,13 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "CXXTags.hpp"
 #include "XMLWriter.hpp"
-#include "lib/ConfigImpl.hpp"
-#include "lib/Support/Yaml.hpp"
-#include "lib/Support/LegibleNames.hpp"
-#include "lib/Support/Radix.hpp"
 #include <mrdocs/Platform.hpp>
+#include "CXXTags.hpp"
+#include <lib/ConfigImpl.hpp>
+#include <lib/Support/LegibleNames.hpp>
+#include <lib/Support/Radix.hpp>
+#include <lib/Support/Yaml.hpp>
 #include <llvm/Support/YAMLParser.h>
 #include <llvm/Support/YAMLTraits.h>
 
@@ -99,7 +99,7 @@ operator()(
         return;
     }
     #define INFO(Type) if constexpr(T::is##Type()) write##Type(I);
-    #include <mrdocs/Metadata/Info/InfoNodes.inc>
+#include <mrdocs/Metadata/Info/InfoNodes.inc>
 }
 
 //------------------------------------------------
@@ -197,7 +197,7 @@ writeFriend(
     }
     else if (I.Type)
     {
-        attrs.push({ "type", toString(*I.Type) });
+        attrs.push({ "type", toString(**I.Type) });
     }
 
     tags_.write("befriended", {}, attrs);
@@ -251,10 +251,15 @@ writeFunction(
     writeAttr(I.IsNodiscard,           "nodiscard", tags_);
     writeAttr(I.IsExplicitObjectMemberFunction, "is-explicit-object-member-function", tags_);
 
-    writeReturnType(*I.ReturnType, tags_);
+    if (I.ReturnType)
+    {
+        writeReturnType(**I.ReturnType, tags_);
+    }
 
-    for(auto const& J : I.Params)
+    for (auto const& J: I.Params)
+    {
         writeParam(J, tags_);
+    }
 
     writeJavadoc(I.javadoc);
 
@@ -345,10 +350,14 @@ writeNamespaceAlias(
 
     writeJavadoc(I.javadoc);
 
-    tags_.write("aliased", {}, {
-        {"name", toString(*I.AliasedSymbol)},
-        { I.AliasedSymbol->id }
-    });
+    if (I.AliasedSymbol)
+    {
+        tags_.write("aliased", {}, {
+            {"name", toString(**I.AliasedSymbol)},
+            { (*I.AliasedSymbol)->id }
+        });
+    }
+
     tags_.close(namespaceAliasTagName);
 }
 
@@ -373,7 +382,7 @@ XMLWriter::
     }
 
     std::string qualifierStr;
-    if (I.IntroducedName)
+    if (!I.IntroducedName.valueless_after_move())
     {
         qualifierStr = toString(*I.IntroducedName);
     }
diff --git a/src/lib/Gen/xml/XMLWriter.hpp b/src/lib/Gen/xml/XMLWriter.hpp
index 05c5ecda2..75e45752b 100644
--- a/src/lib/Gen/xml/XMLWriter.hpp
+++ b/src/lib/Gen/xml/XMLWriter.hpp
@@ -12,8 +12,8 @@
 #ifndef MRDOCS_LIB_GEN_XML_XMLWRITER_HPP
 #define MRDOCS_LIB_GEN_XML_XMLWRITER_HPP
 
-#include "XMLTags.hpp"
-#include "lib/Support/YamlFwd.hpp"
+#include <lib/Gen/xml/XMLTags.hpp>
+#include <lib/Support/YamlFwd.hpp>
 #include <mrdocs/Corpus.hpp>
 #include <mrdocs/Metadata.hpp>
 #include <mrdocs/Support/Error.hpp>
@@ -109,4 +109,4 @@ class XMLWriter
 
 } // clang::mrdocs::xml
 
-#endif
+#endif // MRDOCS_LIB_GEN_XML_XMLWRITER_HPP
diff --git a/src/lib/Metadata/DomCorpus.cpp b/src/lib/Metadata/DomCorpus.cpp
index db12ba844..45e523b0e 100644
--- a/src/lib/Metadata/DomCorpus.cpp
+++ b/src/lib/Metadata/DomCorpus.cpp
@@ -10,16 +10,16 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
+#include <lib/Support/LegibleNames.hpp>
+#include <lib/Support/Radix.hpp>
+#include <mrdocs/Corpus.hpp>
 #include <mrdocs/Dom/LazyArray.hpp>
 #include <mrdocs/Dom/LazyObject.hpp>
-#include "lib/Support/LegibleNames.hpp"
-#include "lib/Support/Radix.hpp"
+#include <mrdocs/Metadata.hpp>
+#include <mrdocs/Metadata/DomCorpus.hpp>
 #include <memory>
 #include <mutex>
 #include <variant>
-#include <mrdocs/Metadata.hpp>
-#include <mrdocs/Corpus.hpp>
-#include <mrdocs/Metadata/DomCorpus.hpp>
 
 namespace clang::mrdocs {
 
diff --git a/src/lib/Metadata/Finalizers/BaseMembersFinalizer.cpp b/src/lib/Metadata/Finalizers/BaseMembersFinalizer.cpp
index 40b944618..ad214cf13 100644
--- a/src/lib/Metadata/Finalizers/BaseMembersFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/BaseMembersFinalizer.cpp
@@ -9,9 +9,9 @@
 //
 
 #include "BaseMembersFinalizer.hpp"
-#include <format>
 #include <mrdocs/Support/Algorithm.hpp>
 #include <mrdocs/Support/Report.hpp>
+#include <format>
 
 namespace clang::mrdocs {
 
@@ -228,7 +228,7 @@ operator()(RecordInfo& I)
     for (BaseInfo const& baseI: I.Bases)
     {
         auto const *baseNameType =
-            dynamic_cast<NamedTypeInfo const *>(&*baseI.Type);
+            dynamic_cast<NamedTypeInfo const *>(&**baseI.Type);
         MRDOCS_CHECK_OR_CONTINUE(baseNameType);
         auto const *baseName =
             dynamic_cast<NameInfo const *>(&*baseNameType->Name);
diff --git a/src/lib/Metadata/Finalizers/BaseMembersFinalizer.hpp b/src/lib/Metadata/Finalizers/BaseMembersFinalizer.hpp
index 1b6659352..a6607fb49 100644
--- a/src/lib/Metadata/Finalizers/BaseMembersFinalizer.hpp
+++ b/src/lib/Metadata/Finalizers/BaseMembersFinalizer.hpp
@@ -8,11 +8,11 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_METADATA_FINALIZER_BASEMEMBERSFINALIZER_HPP
-#define MRDOCS_LIB_METADATA_FINALIZER_BASEMEMBERSFINALIZER_HPP
+#ifndef MRDOCS_LIB_METADATA_FINALIZERS_BASEMEMBERSFINALIZER_HPP
+#define MRDOCS_LIB_METADATA_FINALIZERS_BASEMEMBERSFINALIZER_HPP
 
-#include "lib/Metadata/InfoSet.hpp"
-#include "lib/CorpusImpl.hpp"
+#include <lib/CorpusImpl.hpp>
+#include <lib/Metadata/InfoSet.hpp>
 
 namespace clang::mrdocs {
 
@@ -83,4 +83,4 @@ class BaseMembersFinalizer
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_LIB_METADATA_FINALIZERS_BASEMEMBERSFINALIZER_HPP
diff --git a/src/lib/Metadata/Finalizers/DerivedFinalizer.cpp b/src/lib/Metadata/Finalizers/DerivedFinalizer.cpp
index 2c106c563..31daac914 100644
--- a/src/lib/Metadata/Finalizers/DerivedFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/DerivedFinalizer.cpp
@@ -8,9 +8,9 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "DerivedFinalizer.hpp"
-#include <mrdocs/Support/Report.hpp>
+#include <lib/Metadata/Finalizers/DerivedFinalizer.hpp>
 #include <mrdocs/Support/Algorithm.hpp>
+#include <mrdocs/Support/Report.hpp>
 #include <algorithm>
 
 namespace clang::mrdocs {
@@ -30,8 +30,9 @@ build()
         {
             MRDOCS_CHECK_OR_CONTINUE(base.Access == AccessKind::Public);
             MRDOCS_CHECK_OR_CONTINUE(base.Type);
-            MRDOCS_CHECK_OR_CONTINUE(base.Type->isNamed());
-            auto& namedType = dynamic_cast<NamedTypeInfo&>(*base.Type);
+            MRDOCS_ASSERT(!base.Type->valueless_after_move());
+            MRDOCS_CHECK_OR_CONTINUE((*base.Type)->isNamed());
+            auto& namedType = dynamic_cast<NamedTypeInfo&>(**base.Type);
             MRDOCS_CHECK_OR_CONTINUE(namedType.Name);
             SymbolID const namedSymbolID = namedType.Name->id;
             MRDOCS_CHECK_OR_CONTINUE(namedSymbolID != SymbolID::invalid);
diff --git a/src/lib/Metadata/Finalizers/DerivedFinalizer.hpp b/src/lib/Metadata/Finalizers/DerivedFinalizer.hpp
index 01b07c973..11c802e87 100644
--- a/src/lib/Metadata/Finalizers/DerivedFinalizer.hpp
+++ b/src/lib/Metadata/Finalizers/DerivedFinalizer.hpp
@@ -9,11 +9,11 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_METADATA_FINALIZER_DERIVEDFINALIZER_HPP
-#define MRDOCS_LIB_METADATA_FINALIZER_DERIVEDFINALIZER_HPP
+#ifndef MRDOCS_LIB_METADATA_FINALIZERS_DERIVEDFINALIZER_HPP
+#define MRDOCS_LIB_METADATA_FINALIZERS_DERIVEDFINALIZER_HPP
 
-#include "lib/CorpusImpl.hpp"
-#include "lib/Metadata/InfoSet.hpp"
+#include <lib/CorpusImpl.hpp>
+#include <lib/Metadata/InfoSet.hpp>
 #include <utility>
 
 namespace clang::mrdocs {
@@ -39,4 +39,4 @@ class DerivedFinalizer
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_LIB_METADATA_FINALIZERS_DERIVEDFINALIZER_HPP
diff --git a/src/lib/Metadata/Finalizers/Javadoc/Function.hpp b/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
index 353557e28..cfff7267c 100644
--- a/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
+++ b/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
@@ -8,13 +8,13 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_METADATA_FINALIZER_JAVADOCFINALIZER_FUNCTION_HPP
-#define MRDOCS_LIB_METADATA_FINALIZER_JAVADOCFINALIZER_FUNCTION_HPP
+#ifndef MRDOCS_LIB_METADATA_FINALIZERS_JAVADOC_FUNCTION_HPP
+#define MRDOCS_LIB_METADATA_FINALIZERS_JAVADOC_FUNCTION_HPP
 
-#include "lib/CorpusImpl.hpp"
-#include "lib/Metadata/InfoSet.hpp"
-#include <format>
+#include <lib/CorpusImpl.hpp>
+#include <lib/Metadata/InfoSet.hpp>
 #include <mrdocs/Support/Algorithm.hpp>
+#include <format>
 #include <utility>
 
 namespace clang::mrdocs {
@@ -47,8 +47,10 @@ isCopyOrMoveConstructorOrAssignment(FunctionInfo const& I)
     }
     MRDOCS_CHECK_OR(I.Params.size() == 1, false);
     auto const& param = I.Params[0];
-    auto const& paramType = param.Type;
-    MRDOCS_CHECK_OR(paramType, false);
+    auto const& paramTypeOpt = param.Type;
+    MRDOCS_CHECK_OR(paramTypeOpt, false);
+    auto const& paramType = *paramTypeOpt;
+    MRDOCS_CHECK_OR(!paramType.valueless_after_move(), false);
     if constexpr (!move)
     {
         MRDOCS_CHECK_OR(paramType->isLValueReference(), false);
@@ -59,8 +61,10 @@ isCopyOrMoveConstructorOrAssignment(FunctionInfo const& I)
     }
     using RefType = std::conditional_t<move, RValueReferenceTypeInfo, LValueReferenceTypeInfo>;
     auto const& paramRefType = static_cast<RefType const &>(*paramType);
-    auto const& paramRefPointee = paramRefType.PointeeType;
-    MRDOCS_CHECK_OR(paramRefPointee, false);
+    auto const& paramRefPointeeOpt = paramRefType.PointeeType;
+    MRDOCS_CHECK_OR(paramRefPointeeOpt, false);
+    auto const& paramRefPointee = *paramRefPointeeOpt;
+    MRDOCS_CHECK_OR(!paramRefPointee.valueless_after_move(), false);
     auto const *paramRefPointeeNamed =
         static_cast<NamedTypeInfo const *>(&*paramRefPointee);
     if (!paramRefPointeeNamed)
@@ -111,6 +115,13 @@ innermostTypenameString(Polymorphic<TypeInfo> const& T)
     return RStr;
 }
 
+std::optional<std::string_view>
+innermostTypenameString(Optional<Polymorphic<TypeInfo>> const& T)
+{
+    MRDOCS_CHECK_OR(T, {});
+    return innermostTypenameString(*T);
+}
+
 bool
 populateFunctionBriefFromClass(FunctionInfo& I, CorpusImpl const& corpus)
 {
@@ -196,13 +207,15 @@ isStreamInsertion(FunctionInfo const& function)
     // Check first param is mutable left reference
     auto& firstParam = function.Params[0];
     MRDOCS_CHECK_OR(firstParam, false);
-    auto& firstQualType = firstParam.Type;
-    MRDOCS_CHECK_OR(firstQualType, false);
+    auto& firstQualTypeOpt = firstParam.Type;
+    MRDOCS_CHECK_OR(firstQualTypeOpt, false);
+    auto& firstQualType = *firstQualTypeOpt;
     MRDOCS_CHECK_OR(firstQualType->isLValueReference(), false);
-    auto& firstNamedType =
+    auto& firstNamedTypeOpt =
         static_cast<LValueReferenceTypeInfo const &>(*firstQualType)
             .PointeeType;
-    MRDOCS_CHECK_OR(firstNamedType, false);
+    MRDOCS_CHECK_OR(firstNamedTypeOpt, false);
+    auto& firstNamedType = *firstNamedTypeOpt;
     MRDOCS_CHECK_OR(firstNamedType->isNamed(), false);
     // Check return type
     return firstQualType == function.ReturnType;
@@ -343,7 +356,8 @@ populateFunctionReturnsForSpecial(
     }
 
     // Special functions that should return a reference to self
-    if (I.ReturnType->isLValueReference())
+    if (I.ReturnType &&
+        (*I.ReturnType)->isLValueReference())
     {
         Info const* RInfo = getInfo(innerR, corpus);
         MRDOCS_CHECK_OR(RInfo, false);
@@ -353,7 +367,8 @@ populateFunctionReturnsForSpecial(
     }
 
     // Special functions that should return a pointer to self
-    if (I.ReturnType->isPointer())
+    if (I.ReturnType &&
+        (*I.ReturnType)->isPointer())
     {
         Info const* RInfo = getInfo(innerR, corpus);
         MRDOCS_CHECK_OR(RInfo, false);
@@ -373,9 +388,11 @@ populateFunctionReturnsForSpecial(
               OperatorKind::GreaterEqual,
               OperatorKind::Exclaim }))
     {
-        MRDOCS_CHECK_OR(I.ReturnType->isNamed(), false);
+        MRDOCS_CHECK_OR(I.ReturnType, false);
+        MRDOCS_CHECK_OR((*I.ReturnType)->isNamed(), false);
+        MRDOCS_ASSERT(!I.ReturnType->valueless_after_move());
         MRDOCS_CHECK_OR(
-            static_cast<NamedTypeInfo &>(*I.ReturnType).FundamentalType ==
+            static_cast<NamedTypeInfo &>(**I.ReturnType).FundamentalType ==
                 FundamentalTypeKind::Bool,
             false);
         doc::Returns r;
@@ -428,21 +445,25 @@ populateFunctionReturnsForSpecial(
     }
 
     // Special function that return the same type as the parent
-    if (I.IsRecordMethod && innerR->isNamed() &&
-        static_cast<NamedTypeInfo const &>(*innerR).Name &&
+    if (I.IsRecordMethod &&
+        !innerR.valueless_after_move() &&
+        innerR->isNamed() &&
+        !static_cast<NamedTypeInfo const &>(*innerR).Name.valueless_after_move() &&
         static_cast<NamedTypeInfo const &>(*innerR).Name->id &&
         static_cast<NamedTypeInfo const &>(*innerR).Name->id == I.Parent)
     {
-        if (I.ReturnType->isLValueReference())
+        MRDOCS_CHECK_OR(I.ReturnType, false);
+        MRDOCS_ASSERT(!I.ReturnType->valueless_after_move());
+        if ((*I.ReturnType)->isLValueReference())
         {
             I.javadoc->returns.emplace_back("Reference to the current object");
         }
-        else if (I.ReturnType->isRValueReference())
+        else if ((*I.ReturnType)->isRValueReference())
         {
             I.javadoc->returns.emplace_back(
                 "Rvalue reference to the current object");
         }
-        else if (I.ReturnType->isPointer())
+        else if ((*I.ReturnType)->isPointer())
         {
             I.javadoc->returns.emplace_back("Pointer to the current object");
         }
@@ -481,7 +502,8 @@ populateFunctionReturns(FunctionInfo& I, CorpusImpl const& corpus)
 
     // Check if we have a named return type
     MRDOCS_CHECK_OR(I.ReturnType);
-    auto& inner = innermostType(I.ReturnType);
+    MRDOCS_CHECK_OR(!I.ReturnType->valueless_after_move());
+    auto& inner = innermostType(*I.ReturnType);
     MRDOCS_CHECK_OR(inner);
     if (inner->isNamed())
     {
@@ -541,7 +563,9 @@ setCntrOrAssignParamName(
         std::views::transform([](Param const& p) -> std::string_view {
             return *p.Name;
         });
-    auto& innerP = innermostType(param.Type);
+    MRDOCS_CHECK_OR(param.Type, false);
+    MRDOCS_ASSERT(!param.Type->valueless_after_move());
+    auto& innerP = innermostType(*param.Type);
     std::string_view paramName = "value";
     if (innerP->namedSymbol() == I.Parent)
     {
@@ -651,7 +675,9 @@ setCntrOrAssignParamDoc(
 
     // Set the parameter description if we can
     MRDOCS_CHECK_OR(param, false);
-    auto& innerParam = innermostType(param.Type);
+    MRDOCS_CHECK_OR(param.Type, false);
+    MRDOCS_ASSERT(!param.Type->valueless_after_move());
+    auto& innerParam = innermostType(*param.Type);
     MRDOCS_CHECK_OR(innerParam, false);
     MRDOCS_CHECK_OR(innerParam->isNamed(), false);
     std::string_view const paramNoun
@@ -663,13 +689,17 @@ setCntrOrAssignParamDoc(
         {
             return !isAssign ? "construct" : "assign";
         }
-        if (param.Type->isLValueReference())
+        if (param.Type)
         {
-            return !isAssign ? "copy construct" : "copy assign";
-        }
-        if (param.Type->isRValueReference())
-        {
-            return !isAssign ? "move construct" : "move assign";
+            MRDOCS_ASSERT(!param.Type->valueless_after_move());
+            if ((*param.Type)->isLValueReference())
+            {
+                return !isAssign ? "copy construct" : "copy assign";
+            }
+            if ((*param.Type)->isRValueReference())
+            {
+                return !isAssign ? "move construct" : "move assign";
+            }
         }
         return !isAssign ? "construct" : "assign";
     }();
@@ -759,7 +789,9 @@ setFunctionParamDoc(
 
     // param is a named parameter: use the brief of the type
     // as a description for the parameter
-    auto const& innerParam = innermostType(param.Type);
+    MRDOCS_CHECK_OR(param.Type);
+    MRDOCS_ASSERT(!param.Type->valueless_after_move());
+    auto const& innerParam = innermostType(*param.Type);
     doc::Brief const* paramBrief = getInfoBrief(innerParam, corpus);
     MRDOCS_CHECK_OR(paramBrief);
     I.javadoc->params.emplace_back(*param.Name, *paramBrief);
@@ -798,4 +830,4 @@ populateFunctionParams(FunctionInfo& I, CorpusImpl const& corpus)
 }
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_LIB_METADATA_FINALIZERS_JAVADOC_FUNCTION_HPP
diff --git a/src/lib/Metadata/Finalizers/Javadoc/Overloads.hpp b/src/lib/Metadata/Finalizers/Javadoc/Overloads.hpp
index a907edd76..9b8ef1ff1 100644
--- a/src/lib/Metadata/Finalizers/Javadoc/Overloads.hpp
+++ b/src/lib/Metadata/Finalizers/Javadoc/Overloads.hpp
@@ -8,12 +8,12 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_METADATA_FINALIZER_JAVADOCFINALIZER_OVERLOADS_HPP
-#define MRDOCS_LIB_METADATA_FINALIZER_JAVADOCFINALIZER_OVERLOADS_HPP
+#ifndef MRDOCS_LIB_METADATA_FINALIZERS_JAVADOC_OVERLOADS_HPP
+#define MRDOCS_LIB_METADATA_FINALIZERS_JAVADOC_OVERLOADS_HPP
 
-#include "lib/CorpusImpl.hpp"
-#include "lib/Metadata/InfoSet.hpp"
-#include "Function.hpp"
+#include <lib/CorpusImpl.hpp>
+#include <lib/Metadata/Finalizers/Javadoc/Function.hpp>
+#include <lib/Metadata/InfoSet.hpp>
 #include <utility>
 
 namespace clang::mrdocs {
@@ -367,4 +367,4 @@ populateOverloadsPostconditions(OverloadsInfo& I, Range& functions) {
 }
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_LIB_METADATA_FINALIZERS_JAVADOC_OVERLOADS_HPP
diff --git a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp b/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
index 4b7a16446..0b3ae2dd1 100644
--- a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
@@ -9,13 +9,13 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "JavadocFinalizer.hpp"
-#include "Javadoc/Function.hpp"
-#include "Javadoc/Overloads.hpp"
-#include <algorithm>
-#include <format>
+#include <lib/Metadata/Finalizers/Javadoc/Function.hpp>
+#include <lib/Metadata/Finalizers/Javadoc/Overloads.hpp>
+#include <lib/Metadata/Finalizers/JavadocFinalizer.hpp>
 #include <mrdocs/Support/Algorithm.hpp>
 #include <mrdocs/Support/ScopeExit.hpp>
+#include <algorithm>
+#include <format>
 
 namespace clang::mrdocs {
 
@@ -233,7 +233,8 @@ setAutoBrief(Javadoc& javadoc) const
     MRDOCS_CHECK_OR(!javadoc.blocks.empty());
 
     auto isInvalidBriefText = [](Polymorphic<doc::Text> const& text) {
-        return !text || text->string.empty()
+        return text.valueless_after_move()
+               || text->string.empty()
                || text->Kind == doc::NodeKind::copy_details
                || isWhitespace(text->string);
     };
@@ -718,7 +719,10 @@ finalizeInfoData(InfoTy& I)
     }
     if constexpr (requires { I.ReturnType; })
     {
-        finalize(I.ReturnType);
+        if (I.ReturnType)
+        {
+            finalize(**I.ReturnType);
+        }
     }
     if constexpr (requires { I.Params; })
     {
@@ -726,11 +730,17 @@ finalizeInfoData(InfoTy& I)
     }
     if constexpr (requires { I.Type; })
     {
-        finalize(I.Type);
+        if (I.Type)
+        {
+            finalize(**I.Type);
+        }
     }
     if constexpr (requires { I.UnderlyingType; })
     {
-        finalize(I.UnderlyingType);
+        if (I.UnderlyingType)
+        {
+            finalize(**I.UnderlyingType);
+        }
     }
     if constexpr (requires { I.FriendSymbol; })
     {
@@ -742,11 +752,17 @@ finalizeInfoData(InfoTy& I)
     }
     if constexpr (requires { I.AliasedSymbol; })
     {
-        finalize(I.AliasedSymbol);
+        if (I.AliasedSymbol)
+        {
+            finalize(**I.AliasedSymbol);
+        }
     }
     if constexpr (requires { I.IntroducedName; })
     {
-        finalize(I.IntroducedName);
+        if (!I.IntroducedName.valueless_after_move())
+        {
+            finalize(*I.IntroducedName);
+        }
     }
     if constexpr (requires { I.ShadowDeclarations; })
     {
@@ -754,7 +770,10 @@ finalizeInfoData(InfoTy& I)
     }
     if constexpr (requires { I.Deduced; })
     {
-        finalize(I.Deduced);
+        if (I.Deduced)
+        {
+            finalize(**I.Deduced);
+        }
     }
 }
 
@@ -1245,7 +1264,7 @@ setAutoRelates()
     // 1) Inner type of the first parameter
     [&] {
         MRDOCS_CHECK_OR(!I.Params.empty());
-        auto* firstParamInfo = toRecordOrEnum(I.Params.front().Type);
+        auto* firstParamInfo = toRecordOrEnum(*I.Params.front().Type);
         MRDOCS_CHECK_OR(firstParamInfo);
         if (firstParamInfo->Extraction == ExtractionMode::Regular)
         {
@@ -1256,15 +1275,15 @@ setAutoRelates()
         MRDOCS_CHECK_OR(firstParamInfo->isRecord());
         auto const* firstParamRecord = dynamic_cast<RecordInfo*>(firstParamInfo);
         MRDOCS_CHECK_OR(
-            I.Params.front().Type->isLValueReference() ||
-            I.Params.front().Type->isRValueReference() ||
-            I.Params.front().Type->isPointer());
+            (*I.Params.front().Type)->isLValueReference() ||
+            (*I.Params.front().Type)->isRValueReference() ||
+            (*I.Params.front().Type)->isPointer());
         // Get all transitively derived classes of firstParamRecord
        pushAllDerivedClasses(firstParamRecord, relatedRecordsOrEnums, corpus_);
     }();
 
     // 3) The return type of the function
-    if (auto* returnTypeInfo = toRecordOrEnum(I.ReturnType))
+    if (auto* returnTypeInfo = toRecordOrEnum(*I.ReturnType))
     {
         if (returnTypeInfo->Extraction == ExtractionMode::Regular)
         {
@@ -1275,16 +1294,16 @@ setAutoRelates()
         // each template parameter is also a related record
         [&] {
             MRDOCS_CHECK_OR(I.ReturnType);
-            MRDOCS_CHECK_OR(I.ReturnType->isNamed());
-            auto& NTI = static_cast<NamedTypeInfo &>(*I.ReturnType);
+            MRDOCS_CHECK_OR((*I.ReturnType)->isNamed());
+            auto& NTI = dynamic_cast<NamedTypeInfo &>(**I.ReturnType);
             MRDOCS_CHECK_OR(NTI.Name);
             MRDOCS_CHECK_OR(NTI.Name->isSpecialization());
-            auto const& NTIS = static_cast<SpecializationNameInfo &>(*NTI.Name);
+            auto const& NTIS = dynamic_cast<SpecializationNameInfo &>(*NTI.Name);
             MRDOCS_CHECK_OR(!NTIS.TemplateArgs.empty());
             Polymorphic<TArg> const& firstArg = NTIS.TemplateArgs.front();
             MRDOCS_CHECK_OR(firstArg->isType());
-            auto const& typeArg = static_cast<TypeTArg const &>(*firstArg);
-            if (auto* argInfo = toRecordOrEnum(typeArg.Type))
+            auto const& typeArg = dynamic_cast<TypeTArg const &>(*firstArg);
+            if (auto* argInfo = toRecordOrEnum(*typeArg.Type))
             {
                 if (argInfo->Extraction == ExtractionMode::Regular)
                 {
@@ -1532,7 +1551,10 @@ finalize(TArg& arg)
     {
         if constexpr (Ty::isType())
         {
-            finalize(A.Type);
+            if (A.Type)
+            {
+                finalize(**A.Type);
+            }
         }
         if constexpr (Ty::isTemplate())
         {
@@ -1545,18 +1567,26 @@ void
 JavadocFinalizer::
 finalize(TParam& param)
 {
-    finalize(param.Default);
-
+    if (param.Default)
+    {
+        finalize(**param.Default);
+    }
     visit(param, [this]<typename Ty>(Ty& P)
     {
         if constexpr (Ty::isType())
         {
-            finalize(P.Constraint);
+            if (P.Constraint)
+            {
+                finalize(**P.Constraint);
+            }
         }
 
         if constexpr (Ty::isNonType())
         {
-            finalize(P.Type);
+            if (P.Type)
+            {
+                finalize(**P.Type);
+            }
         }
 
         if constexpr (Ty::isTemplate())
@@ -1570,14 +1600,20 @@ void
 JavadocFinalizer::
 finalize(Param& param)
 {
-    finalize(param.Type);
+    if (param.Type)
+    {
+        finalize(**param.Type);
+    }
 }
 
 void
 JavadocFinalizer::
 finalize(BaseInfo& info)
 {
-    finalize(info.Type);
+    if (info.Type)
+    {
+        finalize(**info.Type);
+    }
 }
 
 void
@@ -1787,7 +1823,7 @@ warnNoParamDocs(FunctionInfo const& I)
             }
             return false;
         };
-        if (!isVoid(*I.ReturnType))
+        if (!isVoid(**I.ReturnType))
         {
             this->warn(
                 *getPrimaryLocation(I),
diff --git a/src/lib/Metadata/Finalizers/JavadocFinalizer.hpp b/src/lib/Metadata/Finalizers/JavadocFinalizer.hpp
index 6b3743564..b0814aab8 100644
--- a/src/lib/Metadata/Finalizers/JavadocFinalizer.hpp
+++ b/src/lib/Metadata/Finalizers/JavadocFinalizer.hpp
@@ -9,14 +9,14 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_METADATA_FINALIZER_JAVADOCFINALIZER_HPP
-#define MRDOCS_LIB_METADATA_FINALIZER_JAVADOCFINALIZER_HPP
+#ifndef MRDOCS_LIB_METADATA_FINALIZERS_JAVADOCFINALIZER_HPP
+#define MRDOCS_LIB_METADATA_FINALIZERS_JAVADOCFINALIZER_HPP
 
-#include "lib/CorpusImpl.hpp"
-#include "lib/Metadata/InfoSet.hpp"
-#include <format>
+#include <lib/CorpusImpl.hpp>
+#include <lib/Metadata/InfoSet.hpp>
 #include <mrdocs/Support/Report.hpp>
 #include <mrdocs/Support/ScopeExit.hpp>
+#include <format>
 #include <set>
 #include <utility>
 
@@ -337,6 +337,27 @@ class JavadocFinalizer
     void
     finalize(NameInfo& name);
 
+    /// Finalize polymorphic
+    template <class T>
+    void
+    finalize(Polymorphic<T>&& val)
+    {
+        if (!val.valueless_after_move())
+        {
+            finalize(*val);
+        }
+    }
+
+    template <class T>
+    void
+    finalize(Polymorphic<T>& val)
+    {
+        if (!val.valueless_after_move())
+        {
+            finalize(*val);
+        }
+    }
+
     /// Finalize optional and pointer-like members
     template <dereferenceable T>
     void
@@ -431,4 +452,4 @@ class JavadocFinalizer
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_LIB_METADATA_FINALIZERS_JAVADOCFINALIZER_HPP
diff --git a/src/lib/Metadata/Finalizers/NamespacesFinalizer.hpp b/src/lib/Metadata/Finalizers/NamespacesFinalizer.hpp
index 421e3aa46..30e040384 100644
--- a/src/lib/Metadata/Finalizers/NamespacesFinalizer.hpp
+++ b/src/lib/Metadata/Finalizers/NamespacesFinalizer.hpp
@@ -8,11 +8,11 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_METADATA_FINALIZER_NAMESPACESFINALIZER_HPP
-#define MRDOCS_LIB_METADATA_FINALIZER_NAMESPACESFINALIZER_HPP
+#ifndef MRDOCS_LIB_METADATA_FINALIZERS_NAMESPACESFINALIZER_HPP
+#define MRDOCS_LIB_METADATA_FINALIZERS_NAMESPACESFINALIZER_HPP
 
-#include "lib/Metadata/InfoSet.hpp"
-#include "lib/CorpusImpl.hpp"
+#include <lib/CorpusImpl.hpp>
+#include <lib/Metadata/InfoSet.hpp>
 
 namespace clang::mrdocs {
 
@@ -54,4 +54,4 @@ class NamespacesFinalizer
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_LIB_METADATA_FINALIZERS_NAMESPACESFINALIZER_HPP
diff --git a/src/lib/Metadata/Finalizers/OverloadsFinalizer.cpp b/src/lib/Metadata/Finalizers/OverloadsFinalizer.cpp
index eca1d1096..3d377dd2c 100644
--- a/src/lib/Metadata/Finalizers/OverloadsFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/OverloadsFinalizer.cpp
@@ -27,7 +27,8 @@ findBaseClassPermutation(
     for (auto const& base: info->asRecordPtr()->Bases)
     {
         // Find the i-th base class
-        auto const baseInfo = corpus.find(base.Type->namedSymbol());
+        MRDOCS_CHECK_OR(base.Type, SymbolID::invalid);
+        auto const baseInfo = corpus.find((*base.Type)->namedSymbol());
         MRDOCS_CHECK_OR_CONTINUE(baseInfo);
         auto const baseRecord = baseInfo->asRecordPtr();
         MRDOCS_CHECK_OR_CONTINUE(baseRecord);
@@ -290,8 +291,8 @@ operator()(RecordInfo& I)
     {
         auto& BT = b.Type;
         MRDOCS_CHECK_OR(BT);
-        MRDOCS_CHECK_OR(BT->isNamed());
-        auto& NT = dynamic_cast<NamedTypeInfo&>(*BT);
+        MRDOCS_CHECK_OR((*BT)->isNamed());
+        auto& NT = dynamic_cast<NamedTypeInfo&>(**BT);
         MRDOCS_CHECK_OR(NT.Name);
         auto& NI = dynamic_cast<NameInfo&>(*NT.Name);
         MRDOCS_CHECK_OR(NI.id);
diff --git a/src/lib/Metadata/Finalizers/OverloadsFinalizer.hpp b/src/lib/Metadata/Finalizers/OverloadsFinalizer.hpp
index 189417538..10b3c2e53 100644
--- a/src/lib/Metadata/Finalizers/OverloadsFinalizer.hpp
+++ b/src/lib/Metadata/Finalizers/OverloadsFinalizer.hpp
@@ -8,11 +8,11 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_METADATA_FINALIZER_OVERLOADSFINALIZER_HPP
-#define MRDOCS_LIB_METADATA_FINALIZER_OVERLOADSFINALIZER_HPP
+#ifndef MRDOCS_LIB_METADATA_FINALIZERS_OVERLOADSFINALIZER_HPP
+#define MRDOCS_LIB_METADATA_FINALIZERS_OVERLOADSFINALIZER_HPP
 
-#include "lib/Metadata/InfoSet.hpp"
-#include "lib/CorpusImpl.hpp"
+#include <lib/CorpusImpl.hpp>
+#include <lib/Metadata/InfoSet.hpp>
 
 namespace clang::mrdocs {
 
@@ -72,4 +72,4 @@ class OverloadsFinalizer
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_LIB_METADATA_FINALIZERS_OVERLOADSFINALIZER_HPP
diff --git a/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp b/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp
index 3045ab1bd..f8b36b38e 100644
--- a/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp
@@ -9,8 +9,8 @@
 //
 
 #include "SortMembersFinalizer.hpp"
-#include <ranges>
 #include <algorithm>
+#include <ranges>
 
 namespace clang::mrdocs {
 
@@ -171,18 +171,22 @@ struct SymbolIDCompareFn
                     if (I.Params.size() == 1)
                     {
                         auto const& param = I.Params[0];
-                        auto const& paramType = param.Type;
+                        auto const& paramTypeOpt = param.Type;
+                        MRDOCS_CHECK_OR(paramTypeOpt, false);
+                        auto const& paramType = *paramTypeOpt;
                         if (!paramType->isLValueReference()
                             && !paramType->isRValueReference())
                         {
                             return false;
                         }
-                        auto const &paramRefPointee =
+                        auto const &paramRefPointeeOpt =
                             paramType->isLValueReference()
                                 ? static_cast<LValueReferenceTypeInfo const &>(*paramType)
                                     .PointeeType
                                 : static_cast<RValueReferenceTypeInfo const &>(*paramType)
                                     .PointeeType;
+                        MRDOCS_CHECK_OR(paramRefPointeeOpt, false);
+                        auto const& paramRefPointee = *paramRefPointeeOpt;
                         if (!paramRefPointee->isNamed())
                         {
                             return false;
@@ -202,8 +206,10 @@ struct SymbolIDCompareFn
                 // Ensure move comes after copy
                 if (lhsIsCopyOrMove && rhsIsCopyOrMove)
                 {
-                    bool const lhsIsMove = lhsF.Params[0].Type->isRValueReference();
-                    bool const rhsIsMove = rhsF.Params[0].Type->isRValueReference();
+                    MRDOCS_CHECK_OR(!lhsF.Params[0].Type, false);
+                    MRDOCS_CHECK_OR(!rhsF.Params[0].Type, true);
+                    bool const lhsIsMove = (*lhsF.Params[0].Type)->isRValueReference();
+                    bool const rhsIsMove = (*rhsF.Params[0].Type)->isRValueReference();
                     if (lhsIsMove != rhsIsMove)
                     {
                         return !lhsIsMove;
diff --git a/src/lib/Metadata/Finalizers/SortMembersFinalizer.hpp b/src/lib/Metadata/Finalizers/SortMembersFinalizer.hpp
index be01754d7..283dc0187 100644
--- a/src/lib/Metadata/Finalizers/SortMembersFinalizer.hpp
+++ b/src/lib/Metadata/Finalizers/SortMembersFinalizer.hpp
@@ -8,11 +8,11 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_METADATA_FINALIZER_SORTMEMBERSFINALIZER_HPP
-#define MRDOCS_LIB_METADATA_FINALIZER_SORTMEMBERSFINALIZER_HPP
+#ifndef MRDOCS_LIB_METADATA_FINALIZERS_SORTMEMBERSFINALIZER_HPP
+#define MRDOCS_LIB_METADATA_FINALIZERS_SORTMEMBERSFINALIZER_HPP
 
-#include "lib/Metadata/InfoSet.hpp"
-#include "lib/CorpusImpl.hpp"
+#include <lib/CorpusImpl.hpp>
+#include <lib/Metadata/InfoSet.hpp>
 
 namespace clang::mrdocs {
 
@@ -78,4 +78,4 @@ class SortMembersFinalizer
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_LIB_METADATA_FINALIZERS_SORTMEMBERSFINALIZER_HPP
diff --git a/src/lib/Metadata/Info.cpp b/src/lib/Metadata/Info.cpp
index aecbce349..20c52b5c6 100644
--- a/src/lib/Metadata/Info.cpp
+++ b/src/lib/Metadata/Info.cpp
@@ -10,17 +10,17 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
+#include <lib/Support/Radix.hpp>
 #include <mrdocs/Dom/LazyArray.hpp>
 #include <mrdocs/Dom/LazyObject.hpp>
-#include "lib/Support/Radix.hpp"
-#include <clang/AST/Type.h>
-#include <llvm/ADT/STLExtras.h>
-#include <llvm/Support/FileSystem.h>
-#include <llvm/Support/Path.h>
 #include <mrdocs/Metadata.hpp>
 #include <mrdocs/Metadata/DomCorpus.hpp>
 #include <mrdocs/Metadata/Info/Record.hpp>
 #include <mrdocs/Support/String.hpp>
+#include <clang/AST/Type.h>
+#include <llvm/ADT/STLExtras.h>
+#include <llvm/Support/FileSystem.h>
+#include <llvm/Support/Path.h>
 
 namespace clang::mrdocs {
 
diff --git a/src/lib/Metadata/Info/Concept.cpp b/src/lib/Metadata/Info/Concept.cpp
index a0cdb3a9c..e3762af31 100644
--- a/src/lib/Metadata/Info/Concept.cpp
+++ b/src/lib/Metadata/Info/Concept.cpp
@@ -9,8 +9,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <mrdocs/Metadata/Info/Concept.hpp>
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Info/Concept.hpp>
 #include <llvm/ADT/STLExtras.h>
 
 namespace clang::mrdocs {
diff --git a/src/lib/Metadata/Info/Enum.cpp b/src/lib/Metadata/Info/Enum.cpp
index 47405e1f5..e94e789dc 100644
--- a/src/lib/Metadata/Info/Enum.cpp
+++ b/src/lib/Metadata/Info/Enum.cpp
@@ -9,8 +9,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <mrdocs/Metadata/Info/Enum.hpp>
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Info/Enum.hpp>
 #include <llvm/ADT/STLExtras.h>
 
 namespace clang::mrdocs {
diff --git a/src/lib/Metadata/Info/EnumConstant.cpp b/src/lib/Metadata/Info/EnumConstant.cpp
index 558ed222b..08979b448 100644
--- a/src/lib/Metadata/Info/EnumConstant.cpp
+++ b/src/lib/Metadata/Info/EnumConstant.cpp
@@ -9,8 +9,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <mrdocs/Metadata/Info/EnumConstant.hpp>
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Info/EnumConstant.hpp>
 #include <llvm/ADT/STLExtras.h>
 
 namespace clang::mrdocs {
diff --git a/src/lib/Metadata/Info/Friend.cpp b/src/lib/Metadata/Info/Friend.cpp
index 167304de6..4dbe59d49 100644
--- a/src/lib/Metadata/Info/Friend.cpp
+++ b/src/lib/Metadata/Info/Friend.cpp
@@ -9,8 +9,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <mrdocs/Metadata/Info/Friend.hpp>
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Info/Friend.hpp>
 #include <llvm/ADT/STLExtras.h>
 
 namespace clang::mrdocs {
diff --git a/src/lib/Metadata/Info/Function.cpp b/src/lib/Metadata/Info/Function.cpp
index 12e6912a6..3a79a95fe 100644
--- a/src/lib/Metadata/Info/Function.cpp
+++ b/src/lib/Metadata/Info/Function.cpp
@@ -10,10 +10,10 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <utility>
 #include <mrdocs/Dom/LazyObject.hpp>
 #include <mrdocs/Metadata/Info/Function.hpp>
 #include <mrdocs/Support/TypeTraits.hpp>
+#include <utility>
 
 namespace clang::mrdocs {
 
diff --git a/src/lib/Metadata/Info/Guide.cpp b/src/lib/Metadata/Info/Guide.cpp
index 391f0bb95..ef3b232e5 100644
--- a/src/lib/Metadata/Info/Guide.cpp
+++ b/src/lib/Metadata/Info/Guide.cpp
@@ -9,9 +9,11 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <mrdocs/Metadata/Info/Guide.hpp>
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Info/Guide.hpp>
+#include <mrdocs/Metadata/Info/Param.hpp>
 #include <llvm/ADT/STLExtras.h>
+#include <vector>
 
 namespace clang::mrdocs {
 
@@ -47,11 +49,19 @@ operator<=>(GuideInfo const& other) const
             return cmp;
         }
     }
-    if (auto const cmp = Params <=> other.Params;
+    if (auto const cmp = Params.size() <=> other.Params.size();
         !std::is_eq(cmp))
     {
         return cmp;
     }
+    for (size_t i = 0; i < Params.size(); ++i)
+    {
+        if (auto const cmp = Params[i] <=> other.Params[i];
+            !std::is_eq(cmp))
+        {
+            return cmp;
+        }
+    }
     if (Template && other.Template)
     {
         if (auto const cmp = Template->Args <=> other.Template->Args;
diff --git a/src/lib/Metadata/Info/Namespace.cpp b/src/lib/Metadata/Info/Namespace.cpp
index 5ae737ac8..3fcebcee2 100644
--- a/src/lib/Metadata/Info/Namespace.cpp
+++ b/src/lib/Metadata/Info/Namespace.cpp
@@ -9,8 +9,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <mrdocs/Metadata/Info/Namespace.hpp>
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Info/Namespace.hpp>
 #include <llvm/ADT/STLExtras.h>
 
 namespace clang::mrdocs {
diff --git a/src/lib/Metadata/Info/NamespaceAlias.cpp b/src/lib/Metadata/Info/NamespaceAlias.cpp
index a8afd5897..ee20ac9bc 100644
--- a/src/lib/Metadata/Info/NamespaceAlias.cpp
+++ b/src/lib/Metadata/Info/NamespaceAlias.cpp
@@ -9,8 +9,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <mrdocs/Metadata/Info/NamespaceAlias.hpp>
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Info/NamespaceAlias.hpp>
 #include <llvm/ADT/STLExtras.h>
 
 namespace clang::mrdocs {
diff --git a/src/lib/Metadata/Info/Overloads.cpp b/src/lib/Metadata/Info/Overloads.cpp
index fb27ba057..a8f567ddd 100644
--- a/src/lib/Metadata/Info/Overloads.cpp
+++ b/src/lib/Metadata/Info/Overloads.cpp
@@ -8,16 +8,16 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "lib/Support/Radix.hpp"
-#include <format>
-#include <llvm/ADT/STLExtras.h>
-#include <llvm/ADT/StringRef.h>
+#include <lib/Support/Radix.hpp>
 #include <mrdocs/Corpus.hpp>
 #include <mrdocs/Dom/LazyArray.hpp>
 #include <mrdocs/Metadata/DomCorpus.hpp>
 #include <mrdocs/Metadata/Info/Function.hpp>
 #include <mrdocs/Metadata/Info/Namespace.hpp>
 #include <mrdocs/Metadata/Info/Overloads.hpp>
+#include <llvm/ADT/STLExtras.h>
+#include <llvm/ADT/StringRef.h>
+#include <format>
 
 namespace clang::mrdocs {
 
diff --git a/src/lib/Metadata/Info/Record.cpp b/src/lib/Metadata/Info/Record.cpp
index 2d95ca8ff..89216ea30 100644
--- a/src/lib/Metadata/Info/Record.cpp
+++ b/src/lib/Metadata/Info/Record.cpp
@@ -170,7 +170,12 @@ tag_invoke(
     io.map("isPrivate", I.Access == AccessKind::Private);
     io.map("isVirtual", I.IsVirtual);
     io.map("type", dom::ValueFrom(I.Type, domCorpus));
-    io.map("symbol", I.Type->namedSymbol());
+    if (I.Type)
+    {
+        MRDOCS_ASSERT(!I.Type->valueless_after_move());
+        io.map("symbol", (*I.Type)->namedSymbol());
+    }
+
 }
 
 void
diff --git a/src/lib/Metadata/Info/Typedef.cpp b/src/lib/Metadata/Info/Typedef.cpp
index 47f13cd2b..22809f4b9 100644
--- a/src/lib/Metadata/Info/Typedef.cpp
+++ b/src/lib/Metadata/Info/Typedef.cpp
@@ -9,9 +9,9 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <mrdocs/Metadata/Info/Typedef.hpp>
-#include <mrdocs/Metadata/Info.hpp>
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Info.hpp>
+#include <mrdocs/Metadata/Info/Typedef.hpp>
 #include <llvm/ADT/STLExtras.h>
 
 namespace clang::mrdocs {
diff --git a/src/lib/Metadata/Info/Using.cpp b/src/lib/Metadata/Info/Using.cpp
index 583d7f44d..6b24d8f6e 100644
--- a/src/lib/Metadata/Info/Using.cpp
+++ b/src/lib/Metadata/Info/Using.cpp
@@ -9,8 +9,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <mrdocs/Metadata/Info/Using.hpp>
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Info/Using.hpp>
 #include <llvm/ADT/STLExtras.h>
 
 namespace clang::mrdocs {
@@ -44,7 +44,8 @@ merge(UsingInfo& I, UsingInfo&& Other)
     {
         I.Class = Other.Class;
     }
-    if (!I.IntroducedName)
+    if (I.IntroducedName.valueless_after_move() ||
+        I.IntroducedName->Name.empty())
     {
         I.IntroducedName = std::move(Other.IntroducedName);
     }
diff --git a/src/lib/Metadata/Info/Variable.cpp b/src/lib/Metadata/Info/Variable.cpp
index 76474bcaf..5a6d6435b 100644
--- a/src/lib/Metadata/Info/Variable.cpp
+++ b/src/lib/Metadata/Info/Variable.cpp
@@ -9,8 +9,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <mrdocs/Metadata/Info/Variable.hpp>
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Info/Variable.hpp>
 #include <llvm/ADT/STLExtras.h>
 
 namespace clang::mrdocs {
diff --git a/src/lib/Metadata/InfoSet.hpp b/src/lib/Metadata/InfoSet.hpp
index 5573304cb..e6919ad30 100644
--- a/src/lib/Metadata/InfoSet.hpp
+++ b/src/lib/Metadata/InfoSet.hpp
@@ -10,11 +10,11 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_TOOL_INFOSET_HPP
-#define MRDOCS_LIB_TOOL_INFOSET_HPP
+#ifndef MRDOCS_LIB_METADATA_INFOSET_HPP
+#define MRDOCS_LIB_METADATA_INFOSET_HPP
 
-#include "mrdocs/Platform.hpp"
-#include "mrdocs/Metadata/Info.hpp"
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Info.hpp>
 #include <memory>
 #include <unordered_set>
 
@@ -181,4 +181,4 @@ using UndocumentedInfoSet = std::unordered_set<
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_LIB_METADATA_INFOSET_HPP
diff --git a/src/lib/Metadata/Javadoc.cpp b/src/lib/Metadata/Javadoc.cpp
index 700884f25..668442b7e 100644
--- a/src/lib/Metadata/Javadoc.cpp
+++ b/src/lib/Metadata/Javadoc.cpp
@@ -10,13 +10,14 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "lib/Support/Debug.hpp"
-#include <format>
-#include <llvm/Support/Error.h>
-#include <llvm/Support/Path.h>
+#include <lib/Support/Debug.hpp>
 #include <mrdocs/Corpus.hpp>
 #include <mrdocs/Metadata/DomCorpus.hpp>
 #include <mrdocs/Metadata/Javadoc.hpp>
+#include <mrdocs/Metadata/Javadoc/Text/Parts.hpp>
+#include <llvm/Support/Error.h>
+#include <llvm/Support/Path.h>
+#include <format>
 
 namespace clang {
 namespace mrdocs {
@@ -182,7 +183,7 @@ append(std::vector<Polymorphic<Text>> const& otherChildren)
 std::strong_ordering
 operator<=>(Polymorphic<Text> const& lhs, Polymorphic<Text> const& rhs)
 {
-    if (lhs && rhs)
+    if (!lhs.valueless_after_move() && !rhs.valueless_after_move())
     {
         if (lhs->Kind == rhs->Kind)
         {
@@ -190,12 +191,13 @@ operator<=>(Polymorphic<Text> const& lhs, Polymorphic<Text> const& rhs)
         }
         return lhs->Kind <=> rhs->Kind;
     }
-    if (!lhs && !rhs)
+    if (lhs.valueless_after_move() && rhs.valueless_after_move())
     {
         return std::strong_ordering::equal;
     }
-    return !lhs ? std::strong_ordering::less
-            : std::strong_ordering::greater;
+    return lhs.valueless_after_move() ?
+               std::strong_ordering::less :
+               std::strong_ordering::greater;
 }
 
 Paragraph&
@@ -384,7 +386,7 @@ append(std::vector<Polymorphic<doc::Node>>&& blocks)
         }
         else
         {
-            blockAsNode = std::nullopt;
+            Polymorphic<doc::Node> tmp = std::move(blockAsNode);
         }
     }
 }
diff --git a/src/lib/Metadata/Name.cpp b/src/lib/Metadata/Name.cpp
index e9e0e97ee..6202f5f30 100644
--- a/src/lib/Metadata/Name.cpp
+++ b/src/lib/Metadata/Name.cpp
@@ -9,11 +9,11 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <span>
 #include <mrdocs/Dom/LazyArray.hpp>
 #include <mrdocs/Dom/LazyObject.hpp>
 #include <mrdocs/Metadata/DomCorpus.hpp>
 #include <mrdocs/Metadata/Name.hpp>
+#include <span>
 
 namespace clang::mrdocs {
 
@@ -43,15 +43,33 @@ std::strong_ordering
 NameInfo::
 operator<=>(NameInfo const& other) const
 {
-    return
-        std::tie(Kind, Name, Prefix) <=>
-        std::tie(other.Kind, other.Name, other.Prefix);
+    if (this == &other)
+    {
+        return std::strong_ordering::equal;
+    }
+    if (Kind != other.Kind)
+    {
+        return Kind <=> other.Kind;
+    }
+    if (Name != other.Name)
+    {
+        return Name <=> other.Name;
+    }
+    if (bool(Prefix) != bool(other.Prefix))
+    {
+        return bool(Prefix) <=> bool(other.Prefix);
+    }
+    if (Prefix && other.Prefix)
+    {
+        return *Prefix <=> *other.Prefix;
+    }
+    return std::strong_ordering::equal;
 }
 
 std::strong_ordering
 operator<=>(Polymorphic<NameInfo> const& lhs, Polymorphic<NameInfo> const& rhs)
 {
-    if (lhs && rhs)
+    if (!lhs.valueless_after_move() && !rhs.valueless_after_move())
     {
         if (lhs->Kind == rhs->Kind)
         {
@@ -63,12 +81,14 @@ operator<=>(Polymorphic<NameInfo> const& lhs, Polymorphic<NameInfo> const& rhs)
         }
         return lhs->Kind <=> rhs->Kind;
     }
-    if (!lhs && !rhs)
+    if (lhs.valueless_after_move() &&
+        rhs.valueless_after_move())
     {
         return std::strong_ordering::equal;
     }
-    return !lhs ? std::strong_ordering::less
-            : std::strong_ordering::greater;
+    return lhs.valueless_after_move() ?
+               std::strong_ordering::less :
+               std::strong_ordering::greater;
 }
 
 static
@@ -79,7 +99,7 @@ toStringImpl(
 {
     if (N.Prefix)
     {
-        toStringImpl(result, *N.Prefix);
+        toStringImpl(result, **N.Prefix);
         writeTo(result, "::");
     }
 
@@ -99,8 +119,11 @@ toStringImpl(
             {
                 if constexpr(U::isType())
                 {
-                    if(u.Type)
-                        writeTo(result, toString(*u.Type));
+                    if (u.Type)
+                    {
+                        MRDOCS_ASSERT(!u.Type->valueless_after_move());
+                        writeTo(result, toString(**u.Type));
+                    }
                 }
                 if constexpr(U::isNonType())
                 {
diff --git a/src/lib/Metadata/Source.cpp b/src/lib/Metadata/Source.cpp
index 55e0427da..ae8e402f7 100644
--- a/src/lib/Metadata/Source.cpp
+++ b/src/lib/Metadata/Source.cpp
@@ -11,9 +11,9 @@
 
 #include <mrdocs/Dom/LazyArray.hpp>
 #include <mrdocs/Dom/LazyObject.hpp>
-#include <ranges>
+#include <mrdocs/Metadata/Info/Source.hpp>
 #include <llvm/ADT/STLExtras.h>
-#include <mrdocs/Metadata/Source.hpp>
+#include <ranges>
 
 namespace clang::mrdocs {
 
diff --git a/src/lib/Metadata/Specifiers.cpp b/src/lib/Metadata/Specifiers.cpp
index 38b7b97f6..dce87235e 100644
--- a/src/lib/Metadata/Specifiers.cpp
+++ b/src/lib/Metadata/Specifiers.cpp
@@ -8,9 +8,9 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "mrdocs/Support/Algorithm.hpp"
-#include <format>
 #include <mrdocs/Metadata/Specifiers.hpp>
+#include <mrdocs/Support/Algorithm.hpp>
+#include <format>
 
 namespace clang {
 namespace mrdocs {
diff --git a/src/lib/Metadata/SymbolID.cpp b/src/lib/Metadata/SymbolID.cpp
index d9aca9eda..442978797 100644
--- a/src/lib/Metadata/SymbolID.cpp
+++ b/src/lib/Metadata/SymbolID.cpp
@@ -9,13 +9,13 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <mrdocs/Metadata/SymbolID.hpp>
+#include <lib/Support/Radix.hpp>
 #include <mrdocs/Dom.hpp>
 #include <mrdocs/Metadata/DomCorpus.hpp>
-#include <lib/Support/Radix.hpp>
+#include <mrdocs/Metadata/Info/SymbolID.hpp>
+#include <llvm/Support/SHA1.h>
 #include <climits>
 #include <ranges>
-#include <llvm/Support/SHA1.h>
 
 namespace clang {
 namespace mrdocs {
diff --git a/src/lib/Metadata/Template.cpp b/src/lib/Metadata/Template.cpp
index 51cd3d15d..5aad05a58 100644
--- a/src/lib/Metadata/Template.cpp
+++ b/src/lib/Metadata/Template.cpp
@@ -73,7 +73,7 @@ toString(
 std::strong_ordering
 operator<=>(Polymorphic<TParam> const& lhs, Polymorphic<TParam> const& rhs)
 {
-    if (lhs && rhs)
+    if (!lhs.valueless_after_move() && !rhs.valueless_after_move())
     {
         if (lhs->Kind == rhs->Kind)
         {
@@ -81,8 +81,9 @@ operator<=>(Polymorphic<TParam> const& lhs, Polymorphic<TParam> const& rhs)
         }
         return lhs->Kind <=> rhs->Kind;
     }
-    return !lhs ? std::strong_ordering::less
-            : std::strong_ordering::greater;
+    return lhs.valueless_after_move() ?
+               std::strong_ordering::less :
+               std::strong_ordering::greater;
 }
 
 std::string_view
@@ -105,7 +106,7 @@ toString(
 std::strong_ordering
 operator<=>(Polymorphic<TArg> const& lhs, Polymorphic<TArg> const& rhs)
 {
-    if (lhs && rhs)
+    if (!lhs.valueless_after_move() && !rhs.valueless_after_move())
     {
         if (lhs->Kind == rhs->Kind)
         {
@@ -113,8 +114,9 @@ operator<=>(Polymorphic<TArg> const& lhs, Polymorphic<TArg> const& rhs)
         }
         return lhs->Kind <=> rhs->Kind;
     }
-    return !lhs ? std::strong_ordering::less
-            : std::strong_ordering::greater;
+    return lhs.valueless_after_move() ?
+               std::strong_ordering::less :
+               std::strong_ordering::greater;
 }
 
 std::string
@@ -127,8 +129,11 @@ toString(
         std::string result;
         if constexpr(T::isType())
         {
-            if(t.Type)
-                result += toString(*t.Type);
+            if (t.Type)
+            {
+                MRDOCS_ASSERT(!t.Type->valueless_after_move());
+                result += toString(**t.Type);
+            }
         }
         if constexpr(T::isNonType())
         {
@@ -225,7 +230,7 @@ tag_invoke(
     visit(I, [domCorpus, &io]<typename T>(T const& t) {
         if(t.Default)
         {
-            io.map("default", t.Default);
+            io.map("default", **t.Default);
         }
         if constexpr(T::isType())
         {
@@ -279,7 +284,8 @@ merge(TemplateInfo& I, TemplateInfo&& Other)
     std::size_t const pn = std::min(I.Params.size(), Other.Params.size());
     for (std::size_t i = 0; i < pn; ++i)
     {
-        if (!I.Params[i] || I.Params[i]->Kind != Other.Params[i]->Kind)
+        if (I.Params[i].valueless_after_move() ||
+            I.Params[i]->Kind != Other.Params[i]->Kind)
         {
             I.Params[i] = std::move(Other.Params[i]);
         }
@@ -306,7 +312,8 @@ merge(TemplateInfo& I, TemplateInfo&& Other)
     std::size_t const an = std::min(I.Args.size(), Other.Args.size());
     for (std::size_t i = 0; i < an; ++i)
     {
-        if (!I.Args[i] || I.Args[i]->Kind != Other.Args[i]->Kind)
+        if (I.Args[i].valueless_after_move() ||
+            I.Args[i]->Kind != Other.Args[i]->Kind)
         {
             I.Args[i] = std::move(Other.Args[i]);
         }
diff --git a/src/lib/Metadata/Type.cpp b/src/lib/Metadata/Type.cpp
index 0a9d2c262..ffd067b91 100644
--- a/src/lib/Metadata/Type.cpp
+++ b/src/lib/Metadata/Type.cpp
@@ -12,6 +12,7 @@
 #include <mrdocs/Dom/LazyObject.hpp>
 #include <mrdocs/Metadata/Name.hpp>
 #include <mrdocs/Metadata/Type.hpp>
+#include <mrdocs/Metadata/Type/QualifierKind.hpp>
 
 namespace clang::mrdocs {
 
@@ -87,7 +88,7 @@ namedSymbol() const noexcept
         return SymbolID::invalid;
     }
     auto const* NT = dynamic_cast<NamedTypeInfo const*>(this);
-    if (!NT->Name)
+    if (NT->Name.valueless_after_move())
     {
         return SymbolID::invalid;
     }
@@ -173,7 +174,7 @@ operator()(
     {
         if(t.ParentType)
         {
-            writeFullType(*t.ParentType, write);
+            writeFullType(**t.ParentType, write);
             write("::");
         }
     }
@@ -183,8 +184,10 @@ operator()(
 
     if constexpr(T::isAuto())
     {
-        if(t.Constraint)
-            write(toString(*t.Constraint), ' ');
+        if (t.Constraint)
+        {
+            write(toString(**t.Constraint), ' ');
+        }
         switch(t.Keyword)
         {
         case AutoKind::Auto:
@@ -756,7 +759,7 @@ makeChar(FundamentalTypeKind& kind) noexcept
 std::strong_ordering
 operator<=>(Polymorphic<TypeInfo> const& lhs, Polymorphic<TypeInfo> const& rhs)
 {
-    if (lhs && rhs)
+    if (!lhs.valueless_after_move() && !rhs.valueless_after_move())
     {
         auto& lhsRef = *lhs;
         auto& rhsRef = *rhs;
@@ -766,8 +769,9 @@ operator<=>(Polymorphic<TypeInfo> const& lhs, Polymorphic<TypeInfo> const& rhs)
         }
         return lhsRef.Kind <=> rhsRef.Kind;
     }
-    return !lhs ? std::strong_ordering::less
-            : std::strong_ordering::greater;
+    return lhs.valueless_after_move() ?
+               std::strong_ordering::less :
+               std::strong_ordering::greater;
 }
 
 namespace {
@@ -786,15 +790,24 @@ innerTypeImpl(TypeInfoTy&& TI) noexcept
     {
         if constexpr(requires { t.PointeeType; })
         {
-            return &t.PointeeType;
+            if (t.PointeeType)
+            {
+                return &*t.PointeeType;
+            }
         }
         if constexpr(requires { t.ElementType; })
         {
-            return &t.ElementType;
+            if (t.ElementType)
+            {
+                return &*t.ElementType;
+            }
         }
         if constexpr(requires { t.ReturnType; })
         {
-            return &t.ReturnType;
+            if (t.ReturnType)
+            {
+                return &*t.ReturnType;
+            }
         }
         return nullptr;
     });
@@ -835,7 +848,7 @@ requires std::same_as<std::remove_cvref_t<PolymorphicTypeInfoTy>, Polymorphic<Ty
 auto&
 innermostTypeImpl(PolymorphicTypeInfoTy&& TI) noexcept
 {
-    if (!TI)
+    if (TI.valueless_after_move())
     {
         return TI;
     }
@@ -847,7 +860,7 @@ innermostTypeImpl(PolymorphicTypeInfoTy&& TI) noexcept
     while (inner)
     {
         /* polymorphic */ auto& ref = inner->get();
-        if (!ref ||
+        if (ref.valueless_after_move() ||
             ref->isNamed())
         {
             return ref;
diff --git a/src/lib/MrDocsCompilationDatabase.cpp b/src/lib/MrDocsCompilationDatabase.cpp
index e565db784..ef5e0f315 100644
--- a/src/lib/MrDocsCompilationDatabase.cpp
+++ b/src/lib/MrDocsCompilationDatabase.cpp
@@ -10,21 +10,21 @@
 //
 
 #include "MrDocsCompilationDatabase.hpp"
-#include "lib/ConfigImpl.hpp"
-#include "lib/Support/Debug.hpp"
-#include "lib/Support/ExecuteAndWaitWithLogging.hpp"
-#include "lib/Support/Path.hpp"
+#include <lib/ConfigImpl.hpp>
+#include <lib/Support/Debug.hpp>
+#include <lib/Support/ExecuteAndWaitWithLogging.hpp>
+#include <lib/Support/Path.hpp>
+#include <mrdocs/Support/Report.hpp>
 #include <clang/Basic/LangStandard.h>
 #include <clang/Driver/Driver.h>
 #include <clang/Driver/Options.h>
 #include <clang/Driver/Types.h>
-#include <format>
 #include <llvm/Option/ArgList.h>
 #include <llvm/Option/OptTable.h>
 #include <llvm/Support/FileSystem.h>
 #include <llvm/Support/Program.h>
 #include <llvm/TargetParser/Host.h>
-#include <mrdocs/Support/Report.hpp>
+#include <format>
 #include <ranges>
 
 namespace clang {
diff --git a/src/lib/MrDocsCompilationDatabase.hpp b/src/lib/MrDocsCompilationDatabase.hpp
index 490955ad2..097ae5c0a 100644
--- a/src/lib/MrDocsCompilationDatabase.hpp
+++ b/src/lib/MrDocsCompilationDatabase.hpp
@@ -8,8 +8,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_TOOL_MR_DOCS_COMPILATION_DATABASE_HPP
-#define MRDOCS_LIB_TOOL_MR_DOCS_COMPILATION_DATABASE_HPP
+#ifndef MRDOCS_LIB_MRDOCSCOMPILATIONDATABASE_HPP
+#define MRDOCS_LIB_MRDOCSCOMPILATIONDATABASE_HPP
 
 #include <mrdocs/Config.hpp>
 #include <clang/Tooling/JSONCompilationDatabase.h>
@@ -85,5 +85,5 @@ class MrDocsCompilationDatabase
 } // mrdocs
 } // clang
 
-#endif // MRDOCS_LIB_TOOL_MR_DOCS_COMPILATION_DATABASE_HPP
+#endif // MRDOCS_LIB_MRDOCSCOMPILATIONDATABASE_HPP
 
diff --git a/src/lib/MrDocsSettingsDB.hpp b/src/lib/MrDocsSettingsDB.hpp
index ad3f14fe1..1e8477842 100644
--- a/src/lib/MrDocsSettingsDB.hpp
+++ b/src/lib/MrDocsSettingsDB.hpp
@@ -11,9 +11,9 @@
 #ifndef MRDOCS_LIB_MRDOCSSETTINGSDB_HPP
 #define MRDOCS_LIB_MRDOCSSETTINGSDB_HPP
 
+#include <lib/ConfigImpl.hpp>
 #include <mrdocs/Support/Path.hpp>
 #include <clang/Tooling/CompilationDatabase.h>
-#include "ConfigImpl.hpp"
 #include <string>
 #include <utility>
 #include <vector>
diff --git a/src/lib/Support/Assert.cpp b/src/lib/Support/Assert.cpp
index d54ba7bac..8347a34fe 100644
--- a/src/lib/Support/Assert.cpp
+++ b/src/lib/Support/Assert.cpp
@@ -8,10 +8,10 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <format>
-#include <llvm/Support/raw_ostream.h>
 #include <mrdocs/Support/Assert.hpp>
 #include <mrdocs/Support/Path.hpp>
+#include <llvm/Support/raw_ostream.h>
+#include <format>
 
 namespace SourceFileNames {
 extern char const* getFileName(char const*) noexcept;
diff --git a/src/lib/Support/CMakeExecution.cpp b/src/lib/Support/CMakeExecution.cpp
index ec78d0057..db0cc4c79 100644
--- a/src/lib/Support/CMakeExecution.cpp
+++ b/src/lib/Support/CMakeExecution.cpp
@@ -10,8 +10,7 @@
 
 #include "CMakeExecution.hpp"
 #include "ExecuteAndWaitWithLogging.hpp"
-#include "lib/Support/Path.hpp"
-
+#include <lib/Support/Path.hpp>
 #include <llvm/Support/FileSystem.h>
 #include <llvm/Support/MemoryBuffer.h>
 #include <llvm/Support/Path.h>
diff --git a/src/lib/Support/CMakeExecution.hpp b/src/lib/Support/CMakeExecution.hpp
index b0184f534..c22c554f3 100644
--- a/src/lib/Support/CMakeExecution.hpp
+++ b/src/lib/Support/CMakeExecution.hpp
@@ -8,8 +8,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_TOOL_CMAKE_EXECUTION_HPP
-#define MRDOCS_LIB_TOOL_CMAKE_EXECUTION_HPP
+#ifndef MRDOCS_LIB_SUPPORT_CMAKEEXECUTION_HPP
+#define MRDOCS_LIB_SUPPORT_CMAKEEXECUTION_HPP
 
 #include <mrdocs/Support/Expected.hpp>
 #include <llvm/ADT/StringRef.h>
@@ -36,5 +36,5 @@ executeCmakeExportCompileCommands(llvm::StringRef projectPath, llvm::StringRef c
 } // mrdocs
 } // clang
 
-#endif // MRDOCS_LIB_TOOL_CMAKE_EXECUTION_HPP
+#endif // MRDOCS_LIB_SUPPORT_CMAKEEXECUTION_HPP
 
diff --git a/src/lib/Support/Debug.cpp b/src/lib/Support/Debug.cpp
index f3218166d..2beec1b05 100644
--- a/src/lib/Support/Debug.cpp
+++ b/src/lib/Support/Debug.cpp
@@ -9,13 +9,13 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "lib/Support/Debug.hpp"
-#include "lib/Support/Radix.hpp"
-#include <format>
-#include <memory>
+#include <lib/Support/Debug.hpp>
+#include <lib/Support/Radix.hpp>
 #include <mrdocs/Metadata/Info.hpp>
 #include <mrdocs/Metadata/Info/Record.hpp>
-#include <mrdocs/Metadata/SymbolID.hpp>
+#include <mrdocs/Metadata/Info/SymbolID.hpp>
+#include <format>
+#include <memory>
 
 namespace clang {
 namespace mrdocs {
diff --git a/src/lib/Support/Debug.hpp b/src/lib/Support/Debug.hpp
index 084e21d47..bc964526b 100644
--- a/src/lib/Support/Debug.hpp
+++ b/src/lib/Support/Debug.hpp
@@ -14,13 +14,13 @@
 
 #include <mrdocs/Platform.hpp>
 #if ! defined(NDEBUG)
-#include <llvm/Support/ErrorHandling.h>
+#    include <llvm/Support/ErrorHandling.h>
 #endif
-#include "lib/Support/Radix.hpp"
-#include <format>
-#include <llvm/Support/raw_ostream.h>
+#include <lib/Support/Radix.hpp>
 #include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/SymbolID.hpp>
+#include <mrdocs/Metadata/Info/SymbolID.hpp>
+#include <llvm/Support/raw_ostream.h>
+#include <format>
 #include <string>
 
 template <>
@@ -77,4 +77,4 @@ MRDOCS_DECL void debugEnableHeapChecking();
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_LIB_SUPPORT_DEBUG_HPP
diff --git a/src/lib/Support/ExecuteAndWaitWithLogging.cpp b/src/lib/Support/ExecuteAndWaitWithLogging.cpp
index cf1c00a77..392c9aa06 100644
--- a/src/lib/Support/ExecuteAndWaitWithLogging.cpp
+++ b/src/lib/Support/ExecuteAndWaitWithLogging.cpp
@@ -9,8 +9,8 @@
 //
 
 #include "ExecuteAndWaitWithLogging.hpp"
-#include "lib/Support/Report.hpp"
-#include "mrdocs/Support/Assert.hpp"
+#include <lib/Support/Report.hpp>
+#include <mrdocs/Support/Assert.hpp>
 
 namespace clang::mrdocs {
 
diff --git a/src/lib/Support/ExecuteAndWaitWithLogging.hpp b/src/lib/Support/ExecuteAndWaitWithLogging.hpp
index ab9d79b21..4bbfde16b 100644
--- a/src/lib/Support/ExecuteAndWaitWithLogging.hpp
+++ b/src/lib/Support/ExecuteAndWaitWithLogging.hpp
@@ -8,8 +8,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_EXECUTE_AND_WAIT_WITH_LOGGING_HPP
-#define MRDOCS_LIB_EXECUTE_AND_WAIT_WITH_LOGGING_HPP
+#ifndef MRDOCS_LIB_SUPPORT_EXECUTEANDWAITWITHLOGGING_HPP
+#define MRDOCS_LIB_SUPPORT_EXECUTEANDWAITWITHLOGGING_HPP
 
 #include <llvm/Support/Program.h>
 
@@ -39,4 +39,4 @@ int ExecuteAndWaitWithLogging(
 
 } // clang::mrdocs
 
-#endif // MRDOCS_LIB_EXECUTE_AND_WAIT_WITH_LOGGING_HPP
+#endif // MRDOCS_LIB_SUPPORT_EXECUTEANDWAITWITHLOGGING_HPP
diff --git a/src/lib/Support/ExecutionContext.cpp b/src/lib/Support/ExecutionContext.cpp
index 337d5b943..309acd448 100644
--- a/src/lib/Support/ExecutionContext.cpp
+++ b/src/lib/Support/ExecutionContext.cpp
@@ -12,10 +12,10 @@
 //
 
 #include "ExecutionContext.hpp"
-#include "lib/Metadata/Reduce.hpp"
-#include "mrdocs/Support/Assert.hpp"
+#include <lib/Metadata/Reduce.hpp>
 #include <mrdocs/Metadata.hpp>
 #include <mrdocs/Metadata/Info/Namespace.hpp>
+#include <mrdocs/Support/Assert.hpp>
 #include <ranges>
 
 namespace clang {
diff --git a/src/lib/Support/ExecutionContext.hpp b/src/lib/Support/ExecutionContext.hpp
index bf793efaf..b34f9d48d 100644
--- a/src/lib/Support/ExecutionContext.hpp
+++ b/src/lib/Support/ExecutionContext.hpp
@@ -10,12 +10,12 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_TOOL_EXECUTIONCONTEXT_HPP
-#define MRDOCS_LIB_TOOL_EXECUTIONCONTEXT_HPP
+#ifndef MRDOCS_LIB_SUPPORT_EXECUTIONCONTEXT_HPP
+#define MRDOCS_LIB_SUPPORT_EXECUTIONCONTEXT_HPP
 
-#include "lib/ConfigImpl.hpp"
-#include "lib/Diagnostics.hpp"
-#include "lib/Metadata/InfoSet.hpp"
+#include <lib/ConfigImpl.hpp>
+#include <lib/Diagnostics.hpp>
+#include <lib/Metadata/InfoSet.hpp>
 #include <mrdocs/Support/Error.hpp>
 #include <llvm/ADT/SmallString.h>
 #include <mutex>
@@ -159,4 +159,4 @@ class InfoExecutionContext
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_LIB_SUPPORT_EXECUTIONCONTEXT_HPP
diff --git a/src/lib/Support/Generator.cpp b/src/lib/Support/Generator.cpp
index c496e1843..d2b1e89a4 100644
--- a/src/lib/Support/Generator.cpp
+++ b/src/lib/Support/Generator.cpp
@@ -9,11 +9,11 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "lib/AST/ParseJavadoc.hpp"
-#include "lib/Support/Path.hpp"
-#include "lib/Support/Chrono.hpp"
-#include <mrdocs/Support/Error.hpp>
+#include <lib/AST/ParseJavadoc.hpp>
+#include <lib/Support/Chrono.hpp>
+#include <lib/Support/Path.hpp>
 #include <mrdocs/Generator.hpp>
+#include <mrdocs/Support/Error.hpp>
 #include <llvm/ADT/SmallString.h>
 #include <llvm/Support/FileSystem.h>
 #include <llvm/Support/Path.h>
diff --git a/src/lib/Support/GeneratorsImpl.hpp b/src/lib/Support/GeneratorsImpl.hpp
index 8fae493a8..73de003f4 100644
--- a/src/lib/Support/GeneratorsImpl.hpp
+++ b/src/lib/Support/GeneratorsImpl.hpp
@@ -11,9 +11,9 @@
 #ifndef MRDOCS_LIB_SUPPORT_GENERATORSIMPL_HPP
 #define MRDOCS_LIB_SUPPORT_GENERATORSIMPL_HPP
 
-#include <mrdocs/Support/Error.hpp>
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Generators.hpp>
+#include <mrdocs/Support/Error.hpp>
 #include <llvm/ADT/SmallVector.h>
 #include <memory>
 #include <vector>
diff --git a/src/lib/Support/Glob.cpp b/src/lib/Support/Glob.cpp
index 6b445a2e7..9f840fbe7 100644
--- a/src/lib/Support/Glob.cpp
+++ b/src/lib/Support/Glob.cpp
@@ -8,13 +8,13 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <ranges>
+#include <mrdocs/Support/Glob.hpp>
+#include <mrdocs/Support/Report.hpp>
 #include <llvm/ADT/BitVector.h>
 #include <llvm/ADT/SmallVector.h>
 #include <llvm/Support/GlobPattern.h>
-#include <mrdocs/Support/Glob.hpp>
-#include <mrdocs/Support/Report.hpp>
 #include <llvm/Support/YAMLTraits.h>
+#include <ranges>
 
 namespace clang::mrdocs {
 
diff --git a/src/lib/Support/Handlebars.cpp b/src/lib/Support/Handlebars.cpp
index 7aa16e3f4..b5fb3db5b 100644
--- a/src/lib/Support/Handlebars.cpp
+++ b/src/lib/Support/Handlebars.cpp
@@ -8,14 +8,14 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
+#include <mrdocs/Support/Handlebars.hpp>
+#include <mrdocs/Support/Path.hpp>
 #include <algorithm>
 #include <array>
 #include <charconv>
 #include <chrono>
 #include <filesystem>
 #include <format>
-#include <mrdocs/Support/Handlebars.hpp>
-#include <mrdocs/Support/Path.hpp>
 #include <print>
 #include <ranges>
 #include <unordered_set>
diff --git a/src/lib/Support/JavaScript.cpp b/src/lib/Support/JavaScript.cpp
index e7fc49a4f..47ecc1dbf 100644
--- a/src/lib/Support/JavaScript.cpp
+++ b/src/lib/Support/JavaScript.cpp
@@ -9,13 +9,13 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "lib/Support/Report.hpp"
-#include <duktape.h>
-#include <format>
-#include <llvm/Support/raw_ostream.h>
+#include <lib/Support/Report.hpp>
 #include <mrdocs/Support/Error.hpp>
 #include <mrdocs/Support/Handlebars.hpp>
 #include <mrdocs/Support/JavaScript.hpp>
+#include <llvm/Support/raw_ostream.h>
+#include <duktape.h>
+#include <format>
 #include <utility>
 #include <variant>
 
diff --git a/src/lib/Support/LegibleNames.cpp b/src/lib/Support/LegibleNames.cpp
index c0cde8593..d3f9052c6 100644
--- a/src/lib/Support/LegibleNames.cpp
+++ b/src/lib/Support/LegibleNames.cpp
@@ -10,17 +10,17 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "lib/Support/LegibleNames.hpp"
-#include "lib/Support/Debug.hpp"
-#include "lib/Support/Radix.hpp"
-#include "lib/Support/Validate.hpp"
-#include <algorithm>
+#include <mrdocs/Platform.hpp>
+#include <lib/Support/Debug.hpp>
+#include <lib/Support/LegibleNames.hpp>
+#include <lib/Support/Radix.hpp>
+#include <lib/Support/Validate.hpp>
 #include <mrdocs/ADT/UnorderedStringMap.hpp>
 #include <mrdocs/Corpus.hpp>
 #include <mrdocs/Metadata.hpp>
-#include <mrdocs/Platform.hpp>
 #include <mrdocs/Support/Concepts.hpp>
 #include <mrdocs/Support/TypeTraits.hpp>
+#include <algorithm>
 #include <ranges>
 #include <string_view>
 #include <unordered_map>
diff --git a/src/lib/Support/LegibleNames.hpp b/src/lib/Support/LegibleNames.hpp
index a5ca1ee41..1dd9c043c 100644
--- a/src/lib/Support/LegibleNames.hpp
+++ b/src/lib/Support/LegibleNames.hpp
@@ -12,8 +12,8 @@
 #ifndef MRDOCS_LIB_SUPPORT_LEGIBLENAMES_HPP
 #define MRDOCS_LIB_SUPPORT_LEGIBLENAMES_HPP
 
-#include <mrdocs/Metadata/SymbolID.hpp>
 #include <mrdocs/Corpus.hpp>
+#include <mrdocs/Metadata/Info/SymbolID.hpp>
 #include <memory>
 #include <string>
 
diff --git a/src/lib/Support/Lua.cpp b/src/lib/Support/Lua.cpp
index 9499f070a..57482fc5d 100644
--- a/src/lib/Support/Lua.cpp
+++ b/src/lib/Support/Lua.cpp
@@ -8,15 +8,14 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "../../../third-party/lua/src/lua.hpp"
-#include <format>
+#include <lib/Support/LuaHandlebars.hpp>
 #include <mrdocs/Support/Lua.hpp>
 #include <mrdocs/Support/Path.hpp>
 #include <mrdocs/Support/Report.hpp>
-#include <print>
-
 #include <llvm/Support/raw_ostream.h>
-#include "lib/Support/LuaHandlebars.hpp"
+#include <format>
+#include <lua.hpp>
+#include <print>
 
 namespace clang {
 namespace mrdocs {
diff --git a/src/lib/Support/LuaHandlebars.hpp b/src/lib/Support/LuaHandlebars.hpp
index 7e32b0202..958b48d56 100644
--- a/src/lib/Support/LuaHandlebars.hpp
+++ b/src/lib/Support/LuaHandlebars.hpp
@@ -8,8 +8,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_SUPPORT_LUAHANDLEBARS_HPP
-#define MRDOCS_API_SUPPORT_LUAHANDLEBARS_HPP
+#ifndef MRDOCS_LIB_SUPPORT_LUAHANDLEBARS_HPP
+#define MRDOCS_LIB_SUPPORT_LUAHANDLEBARS_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Support/Lua.hpp>
@@ -27,4 +27,4 @@ tryLoadHandlebars(
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_LIB_SUPPORT_LUAHANDLEBARS_HPP
diff --git a/src/lib/Support/Radix.cpp b/src/lib/Support/Radix.cpp
index d98b04283..7f656ef0d 100644
--- a/src/lib/Support/Radix.cpp
+++ b/src/lib/Support/Radix.cpp
@@ -9,9 +9,9 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "lib/Support/Radix.hpp"
-#include "lib/Support/Debug.hpp"
 #include <mrdocs/Platform.hpp>
+#include <lib/Support/Debug.hpp>
+#include <lib/Support/Radix.hpp>
 #include <llvm/ADT/StringExtras.h>
 #include <algorithm>
 #include <vector>
diff --git a/src/lib/Support/Report.cpp b/src/lib/Support/Report.cpp
index ae0e0b4d8..afeefb023 100644
--- a/src/lib/Support/Report.cpp
+++ b/src/lib/Support/Report.cpp
@@ -8,22 +8,22 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "lib/Support/Report.hpp"
-#include <cstdlib>
-#include <format>
+#include <lib/Support/Report.hpp>
+#include <mrdocs/Support/Path.hpp>
+#include <mrdocs/Version.hpp>
 #include <llvm/Support/Mutex.h>
 #include <llvm/Support/Signals.h>
 #include <llvm/Support/raw_ostream.h>
-#include <mrdocs/Support/Path.hpp>
-#include <mrdocs/Version.hpp>
+#include <cstdlib>
+#include <format>
 #include <mutex>
 
 #ifdef _MSC_VER
 #define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#include <debugapi.h>
-#include <crtdbg.h>
-#include <sstream>
+#    include <crtdbg.h>
+#    include <debugapi.h>
+#    include <sstream>
+#    include <windows.h>
 #endif
 
 namespace SourceFileNames {
diff --git a/src/lib/Support/Report.hpp b/src/lib/Support/Report.hpp
index d8800a8a2..ab49e4dc0 100644
--- a/src/lib/Support/Report.hpp
+++ b/src/lib/Support/Report.hpp
@@ -8,15 +8,15 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_SUPPORT_ERROR_HPP
-#define MRDOCS_LIB_SUPPORT_ERROR_HPP
+#ifndef MRDOCS_LIB_SUPPORT_REPORT_HPP
+#define MRDOCS_LIB_SUPPORT_REPORT_HPP
 
-#include <format>
-#include <functional>
+#include <mrdocs/Support/Report.hpp>
 #include <llvm/ADT/SmallString.h>
 #include <llvm/ADT/StringRef.h>
 #include <llvm/Support/raw_ostream.h>
-#include <mrdocs/Support/Report.hpp>
+#include <format>
+#include <functional>
 #include <ostream>
 #include <utility>
 
@@ -149,4 +149,4 @@ struct std::formatter<llvm::SmallString<InternalLen>>
   }
 };
 
-#endif
+#endif // MRDOCS_LIB_SUPPORT_REPORT_HPP
diff --git a/src/lib/Support/Yaml.cpp b/src/lib/Support/Yaml.cpp
index 3b908fcf3..958a28068 100644
--- a/src/lib/Support/Yaml.cpp
+++ b/src/lib/Support/Yaml.cpp
@@ -9,8 +9,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "lib/Support/Report.hpp"
-#include "lib/Support/Yaml.hpp"
+#include <lib/Support/Report.hpp>
+#include <lib/Support/Yaml.hpp>
 
 namespace clang {
 namespace mrdocs {
diff --git a/src/lib/lua.cpp b/src/lib/lua.cpp
index 5e4982776..b6810dd9b 100644
--- a/src/lib/lua.cpp
+++ b/src/lib/lua.cpp
@@ -13,40 +13,40 @@ extern "C" {
 # pragma warning(disable: 4334) // result of 32-bit shift implicitly converted to 64 bits (was 64-bit shift intended?)
 #endif
 
-#include "../third-party/lua/src/lapi.c"
-#include "../third-party/lua/src/lauxlib.c"
-#include "../third-party/lua/src/lbaselib.c"
-#include "../third-party/lua/src/lcode.c"
-#include "../third-party/lua/src/lcorolib.c"
-#include "../third-party/lua/src/lctype.c"
-#include "../third-party/lua/src/ldblib.c"
-#include "../third-party/lua/src/ldebug.c"
-#include "../third-party/lua/src/ldo.c"
-#include "../third-party/lua/src/ldump.c"
-#include "../third-party/lua/src/lfunc.c"
-#include "../third-party/lua/src/lgc.c"
-#include "../third-party/lua/src/linit.c"
-#include "../third-party/lua/src/liolib.c"
-#include "../third-party/lua/src/llex.c"
-#include "../third-party/lua/src/lmathlib.c"
-#include "../third-party/lua/src/lmem.c"
-#include "../third-party/lua/src/loadlib.c"
-#include "../third-party/lua/src/lobject.c"
-#include "../third-party/lua/src/lopcodes.c"
-#include "../third-party/lua/src/loslib.c"
-#include "../third-party/lua/src/lparser.c"
-#include "../third-party/lua/src/lstate.c"
-#include "../third-party/lua/src/lstring.c"
-#include "../third-party/lua/src/lstrlib.c"
-#include "../third-party/lua/src/ltable.c"
-#include "../third-party/lua/src/ltablib.c"
-#include "../third-party/lua/src/ltm.c"
-//#include "../third-party/lua/src/lua.c"
-//#include "../third-party/lua/src/luac.c"
-#include "../third-party/lua/src/lundump.c"
-#include "../third-party/lua/src/lutf8lib.c"
-#include "../third-party/lua/src/lvm.c"
-#include "../third-party/lua/src/lzio.c"
+#include <../third-party/lua/src/lapi.c>
+#include <../third-party/lua/src/lauxlib.c>
+#include <../third-party/lua/src/lbaselib.c>
+#include <../third-party/lua/src/lcode.c>
+#include <../third-party/lua/src/lcorolib.c>
+#include <../third-party/lua/src/lctype.c>
+#include <../third-party/lua/src/ldblib.c>
+#include <../third-party/lua/src/ldebug.c>
+#include <../third-party/lua/src/ldo.c>
+#include <../third-party/lua/src/ldump.c>
+#include <../third-party/lua/src/lfunc.c>
+#include <../third-party/lua/src/lgc.c>
+#include <../third-party/lua/src/linit.c>
+#include <../third-party/lua/src/liolib.c>
+#include <../third-party/lua/src/llex.c>
+#include <../third-party/lua/src/lmathlib.c>
+#include <../third-party/lua/src/lmem.c>
+#include <../third-party/lua/src/loadlib.c>
+#include <../third-party/lua/src/lobject.c>
+#include <../third-party/lua/src/lopcodes.c>
+#include <../third-party/lua/src/loslib.c>
+#include <../third-party/lua/src/lparser.c>
+#include <../third-party/lua/src/lstate.c>
+#include <../third-party/lua/src/lstring.c>
+#include <../third-party/lua/src/lstrlib.c>
+#include <../third-party/lua/src/ltable.c>
+#include <../third-party/lua/src/ltablib.c>
+#include <../third-party/lua/src/ltm.c>
+// #include "../third-party/lua/src/lua.c"
+// #include "../third-party/lua/src/luac.c"
+#include <../third-party/lua/src/lundump.c>
+#include <../third-party/lua/src/lutf8lib.c>
+#include <../third-party/lua/src/lvm.c>
+#include <../third-party/lua/src/lzio.c>
 
 #if defined(__clang__)
 # pragma clang diagnostic pop
diff --git a/src/test/ADT/Optional.cpp b/src/test/ADT/Optional.cpp
index 80b4ea757..08c32b3fc 100644
--- a/src/test/ADT/Optional.cpp
+++ b/src/test/ADT/Optional.cpp
@@ -9,7 +9,7 @@
 //
 
 #include <mrdocs/ADT/Optional.hpp>
-#include <mrdocs/Metadata/Source.hpp>
+#include <mrdocs/Metadata/Info/Source.hpp>
 #include <test_suite/test_suite.hpp>
 
 namespace clang::mrdocs {
diff --git a/src/test/ADT/Polymorphic.cpp b/src/test/ADT/Polymorphic.cpp
index 20ebe29d3..21fd36e7d 100644
--- a/src/test/ADT/Polymorphic.cpp
+++ b/src/test/ADT/Polymorphic.cpp
@@ -33,16 +33,16 @@ struct Polymorphic_test
     void
     testConstructors()
     {
-        // nullopt constructor
-        {
-          Polymorphic<X> constexpr v(std::nullopt);
-          BOOST_TEST_NOT(v);
-        }
+        // nullopt constructor (removed)
+        // {
+        //     constexpr Polymorphic<X> v(std::nullopt);
+        //     BOOST_TEST_NOT(v);
+        // }
 
         // from derived object
         {
             Polymorphic<X> x(Y{});
-            BOOST_TEST(x);
+            BOOST_TEST(!x.valueless_after_move());
             BOOST_TEST(x->a == 42);
             BOOST_TEST(dynamic_cast<Y*>(&*x)->b == 43);
         }
@@ -50,7 +50,7 @@ struct Polymorphic_test
         // from derived
         {
             auto x = Polymorphic<X>(std::in_place_type<Y>);
-            BOOST_TEST(x);
+            BOOST_TEST(!x.valueless_after_move());
             BOOST_TEST(x->a == 42);
             BOOST_TEST(dynamic_cast<Y *>(&*x)->b == 43);
         }
@@ -58,18 +58,18 @@ struct Polymorphic_test
         // Copy constructor
         {
             // from empty
-            {
-                Polymorphic<X> x = std::nullopt;
-                Polymorphic<X> y(x);
-                BOOST_TEST_NOT(y);
-            }
+            // {
+            //     Polymorphic<X> x = std::nullopt;
+            //     Polymorphic<X> y(x);
+            //     BOOST_TEST_NOT(y);
+            // }
 
             // from valid
             {
                 Polymorphic<X> x(std::in_place_type<Y>);
                 x->a = 45;
                 Polymorphic<X> y(x);
-                BOOST_TEST(y);
+                BOOST_TEST(!y.valueless_after_move());
                 BOOST_TEST(y->a == 45);
                 BOOST_TEST(dynamic_cast<Y *>(&*y)->b == 43);
             }
@@ -80,26 +80,26 @@ struct Polymorphic_test
             auto x = Polymorphic<X>(std::in_place_type<Y>);
             x->a = 45;
             Polymorphic<X> y(std::move(x));
-            BOOST_TEST_NOT(x);
-            BOOST_TEST(y);
+            BOOST_TEST_NOT(!x.valueless_after_move());
+            BOOST_TEST(!y.valueless_after_move());
             BOOST_TEST(y->a == 45);
             BOOST_TEST(dynamic_cast<Y *>(&*y)->b == 43);
         }
 
         // Copy from derived value constructor
-        {
-            Polymorphic<Y> x;
-            x->a = 45;
-            Polymorphic<X> y(std::in_place_type<Y>, *x);
-            BOOST_TEST(y);
-            BOOST_TEST(y->a == 45);
-            BOOST_TEST(dynamic_cast<Y *>(&*y)->b == 43);
-        }
+        // {
+        //     Polymorphic<Y> x;
+        //     x->a = 45;
+        //     Polymorphic<X> y(std::in_place_type<Y>, *x);
+        //     BOOST_TEST(y);
+        //     BOOST_TEST(y->a == 45);
+        //     BOOST_TEST(dynamic_cast<Y *>(&*y)->b == 43);
+        // }
 
         // In-place constructor
         {
             Polymorphic<X> x(std::in_place_type<Y>);
-            BOOST_TEST(x);
+            BOOST_TEST(!x.valueless_after_move());
             BOOST_TEST(x->a == 42);
             BOOST_TEST(dynamic_cast<Y*>(&*x)->b == 43);
         }
@@ -123,7 +123,7 @@ struct Polymorphic_test
             {
                 Polymorphic<X> lhs(std::in_place_type<Y>);
                 lhs = lhs;
-                BOOST_TEST(lhs);
+                BOOST_TEST(!lhs.valueless_after_move());
                 BOOST_TEST(lhs->a == 42);
             }
 #if defined(__clang__)
@@ -133,12 +133,12 @@ struct Polymorphic_test
 #pragma GCC diagnostic pop
 #endif
             // from empty
-            {
-                Polymorphic<X> lhs;
-                Polymorphic<X> rhs = std::nullopt;
-                lhs = rhs;
-                BOOST_TEST_NOT(lhs);
-            }
+            // {
+            //     Polymorphic<X> lhs;
+            //     Polymorphic<X> rhs = std::nullopt;
+            //     lhs = rhs;
+            //     BOOST_TEST_NOT(lhs);
+            // }
 
             // from valid
             {
@@ -149,10 +149,10 @@ struct Polymorphic_test
                 BOOST_TEST(lhs->a == 45);
                 BOOST_TEST(rhs->a == 46);
                 lhs = rhs;
-                BOOST_TEST(lhs);
+                BOOST_TEST(!lhs.valueless_after_move());
                 BOOST_TEST(lhs->a == 46);
                 BOOST_TEST(rhs->a == 46);
-                BOOST_TEST(static_cast<Y &>(*lhs).b == 43);
+                BOOST_TEST(dynamic_cast<Y &>(*lhs).b == 43);
             }
         }
 
@@ -170,7 +170,7 @@ struct Polymorphic_test
             {
                 Polymorphic<X> lhs(std::in_place_type<Y>);
                 lhs = std::move(lhs);
-                BOOST_TEST(lhs);
+                BOOST_TEST(!lhs.valueless_after_move());
                 BOOST_TEST(lhs->a == 42);
             }
 #if defined(__clang__)
@@ -181,13 +181,13 @@ struct Polymorphic_test
 #endif
 
             // from empty
-            {
-                Polymorphic<X> lhs;
-                Polymorphic<X> rhs = std::nullopt;
-                lhs = std::move(rhs);
-                BOOST_TEST_NOT(lhs);
-                BOOST_TEST_NOT(rhs);
-            }
+            // {
+            //     Polymorphic<X> lhs;
+            //     Polymorphic<X> rhs = std::nullopt;
+            //     lhs = std::move(rhs);
+            //     BOOST_TEST_NOT(lhs);
+            //     BOOST_TEST_NOT(rhs);
+            // }
 
             // from valid
             {
@@ -199,8 +199,8 @@ struct Polymorphic_test
                 BOOST_TEST(rhs->a == 46);
                 lhs = std::move(rhs);
                 BOOST_TEST(lhs->a == 46);
-                BOOST_TEST_NOT(rhs);
-                BOOST_TEST(static_cast<Y &>(*lhs).b == 43);
+                BOOST_TEST_NOT(!rhs.valueless_after_move());
+                BOOST_TEST(dynamic_cast<Y &>(*lhs).b == 43);
             }
         }
 
@@ -213,9 +213,9 @@ struct Polymorphic_test
             BOOST_TEST(lhs->a == 45);
             BOOST_TEST(rhs.a == 46);
             lhs = Polymorphic<X>(std::in_place_type<Y>, rhs);
-            BOOST_TEST(lhs);
+            BOOST_TEST(!lhs.valueless_after_move());
             BOOST_TEST(lhs->a == 46);
-            BOOST_TEST(static_cast<Y &>(*lhs).b == 43);
+            BOOST_TEST(dynamic_cast<Y &>(*lhs).b == 43);
         }
 
         // copy from derived
@@ -227,9 +227,9 @@ struct Polymorphic_test
             BOOST_TEST(lhs->a == 45);
             BOOST_TEST(rhs.a == 46);
             lhs = Polymorphic<X>(std::in_place_type<Y>, std::move(rhs));
-            BOOST_TEST(lhs);
+            BOOST_TEST(!lhs.valueless_after_move());
             BOOST_TEST(lhs->a == 46);
-            BOOST_TEST(static_cast<Y &>(*lhs).b == 43);
+            BOOST_TEST(dynamic_cast<Y &>(*lhs).b == 43);
         }
     }
 
@@ -257,36 +257,36 @@ struct Polymorphic_test
     testSwap()
     {
         // default constructor
-        {
-            Polymorphic<X> lhs = std::nullopt;
-            Polymorphic<X> rhs(std::in_place_type<Y>);
-            swap(lhs, rhs);
-            BOOST_TEST(lhs);
-            BOOST_TEST(lhs->a == 42);
-            BOOST_TEST(dynamic_cast<Y *>(&*lhs)->b == 43);
-            BOOST_TEST_NOT(rhs);
-        }
+        // {
+        //     Polymorphic<X> lhs = std::nullopt;
+        //     Polymorphic<X> rhs(std::in_place_type<Y>);
+        //     swap(lhs, rhs);
+        //     BOOST_TEST(lhs);
+        //     BOOST_TEST(lhs->a == 42);
+        //     BOOST_TEST(dynamic_cast<Y *>(&*lhs)->b == 43);
+        //     BOOST_TEST_NOT(rhs);
+        // }
 
         // rhs: default constructor
-        {
-            Polymorphic<X> lhs(std::in_place_type<Y>);
-            Polymorphic<X> rhs = std::nullopt;
-            swap(lhs, rhs);
-            BOOST_TEST_NOT(lhs);
-            BOOST_TEST(rhs);
-            BOOST_TEST(rhs->a == 42);
-            BOOST_TEST(dynamic_cast<Y *>(&*rhs)->b == 43);
-        }
+        // {
+        //     Polymorphic<X> lhs(std::in_place_type<Y>);
+        //     Polymorphic<X> rhs = std::nullopt;
+        //     swap(lhs, rhs);
+        //     BOOST_TEST_NOT(lhs);
+        //     BOOST_TEST(rhs);
+        //     BOOST_TEST(rhs->a == 42);
+        //     BOOST_TEST(dynamic_cast<Y *>(&*rhs)->b == 43);
+        // }
 
         // lhs: from derived object
         {
             Polymorphic<X> lhs(Y{});
             Polymorphic<X> rhs(std::in_place_type<Y>);
             swap(lhs, rhs);
-            BOOST_TEST(rhs);
+            BOOST_TEST(!rhs.valueless_after_move());
             BOOST_TEST(rhs->a == 42);
             BOOST_TEST(dynamic_cast<Y*>(&*rhs)->b == 43);
-            BOOST_TEST(lhs);
+            BOOST_TEST(!lhs.valueless_after_move());
             BOOST_TEST(lhs->a == 42);
             BOOST_TEST(dynamic_cast<Y*>(&*lhs)->b == 43);
         }
@@ -296,10 +296,10 @@ struct Polymorphic_test
             Polymorphic<X> lhs(std::in_place_type<Y>);
             Polymorphic<X> rhs(Y{});
             swap(lhs, rhs);
-            BOOST_TEST(lhs);
+            BOOST_TEST(!lhs.valueless_after_move());
             BOOST_TEST(lhs->a == 42);
             BOOST_TEST(dynamic_cast<Y *>(&*lhs)->b == 43);
-            BOOST_TEST(rhs);
+            BOOST_TEST(!rhs.valueless_after_move());
             BOOST_TEST(rhs->a == 42);
             BOOST_TEST(dynamic_cast<Y *>(&*rhs)->b == 43);
         }
@@ -309,10 +309,10 @@ struct Polymorphic_test
             Polymorphic<X> lhs(std::in_place_type<Y>);
             Polymorphic<X> rhs(std::in_place_type<Y>);
             swap(lhs, rhs);
-            BOOST_TEST(rhs);
+            BOOST_TEST(!rhs.valueless_after_move());
             BOOST_TEST(rhs->a == 42);
             BOOST_TEST(dynamic_cast<Y *>(&*rhs)->b == 43);
-            BOOST_TEST(lhs);
+            BOOST_TEST(!lhs.valueless_after_move());
             BOOST_TEST(lhs->a == 42);
             BOOST_TEST(dynamic_cast<Y *>(&*lhs)->b == 43);
         }
diff --git a/src/test/Support/JavaScript.cpp b/src/test/Support/JavaScript.cpp
index e8e7ec9e3..369b0609a 100644
--- a/src/test/Support/JavaScript.cpp
+++ b/src/test/Support/JavaScript.cpp
@@ -8,10 +8,10 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <mrdocs/Support/JavaScript.hpp>
 #include <mrdocs/Support/Handlebars.hpp>
-#include <test_suite/test_suite.hpp>
+#include <mrdocs/Support/JavaScript.hpp>
 #include <array>
+#include <test_suite/test_suite.hpp>
 
 namespace clang {
 namespace mrdocs {
diff --git a/src/test/TestArgs.hpp b/src/test/TestArgs.hpp
index 2ee9f2b17..9deb8cf39 100644
--- a/src/test/TestArgs.hpp
+++ b/src/test/TestArgs.hpp
@@ -12,8 +12,8 @@
 #define MRDOCS_TEST_TESTARGS_HPP
 
 #include <llvm/Support/CommandLine.h>
-#include <tool/PublicToolArgs.hpp>
 #include <string>
+#include <tool/PublicToolArgs.hpp>
 
 namespace clang {
 namespace mrdocs {
diff --git a/src/test/TestMain.cpp b/src/test/TestMain.cpp
index 4b7e52f66..4a144a6db 100644
--- a/src/test/TestMain.cpp
+++ b/src/test/TestMain.cpp
@@ -8,20 +8,20 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
+#include <mrdocs/Platform.hpp>
 #include "TestArgs.hpp"
 #include "TestRunner.hpp"
-#include "lib/Support/Debug.hpp"
-#include "lib/Support/Report.hpp"
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/Version.hpp>
+#include <lib/Support/Debug.hpp>
+#include <lib/Support/Report.hpp>
 #include <mrdocs/Support/Error.hpp>
 #include <mrdocs/Support/Path.hpp>
-#include <test_suite/test_suite.hpp>
+#include <mrdocs/Version.hpp>
 #include <llvm/Support/FileSystem.h>
-#include <llvm/Support/raw_ostream.h>
 #include <llvm/Support/PrettyStackTrace.h>
 #include <llvm/Support/Signals.h>
+#include <llvm/Support/raw_ostream.h>
 #include <stdlib.h>
+#include <test_suite/test_suite.hpp>
 
 int main(int argc, char const** argv);
 
diff --git a/src/test/TestRunner.cpp b/src/test/TestRunner.cpp
index 31ea0e38d..9c2785f97 100644
--- a/src/test/TestRunner.cpp
+++ b/src/test/TestRunner.cpp
@@ -8,20 +8,19 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "TestRunner.hpp"
+#include <mrdocs/Platform.hpp>
 #include "TestArgs.hpp"
-#include "lib/Support/Report.hpp"
-#include "lib/Support/Path.hpp"
-#include "lib/ConfigImpl.hpp"
-#include "lib/CorpusImpl.hpp"
-#include "lib/Support/ExecuteAndWaitWithLogging.hpp"
-#include "lib/MrDocsCompilationDatabase.hpp"
-#include "lib/SingleFileDB.hpp"
-#include "lib/Gen/hbs/HandlebarsGenerator.hpp"
-#include "test_suite/diff.hpp"
+#include "TestRunner.hpp"
+#include <lib/ConfigImpl.hpp>
+#include <lib/CorpusImpl.hpp>
+#include <lib/Gen/hbs/HandlebarsGenerator.hpp>
+#include <lib/MrDocsCompilationDatabase.hpp>
+#include <lib/SingleFileDB.hpp>
+#include <lib/Support/ExecuteAndWaitWithLogging.hpp>
+#include <lib/Support/Path.hpp>
+#include <lib/Support/Report.hpp>
 #include <mrdocs/Config.hpp>
 #include <mrdocs/Generators.hpp>
-#include <mrdocs/Platform.hpp>
 #include <mrdocs/Support/Error.hpp>
 #include <llvm/Support/CommandLine.h>
 #include <llvm/Support/FileSystem.h>
@@ -29,6 +28,7 @@
 #include <llvm/Support/Program.h>
 #include <atomic>
 #include <iostream>
+#include <test_suite/diff.hpp>
 
 namespace clang::mrdocs {
 
diff --git a/src/test/TestRunner.hpp b/src/test/TestRunner.hpp
index 2642a2262..1a437cb3e 100644
--- a/src/test/TestRunner.hpp
+++ b/src/test/TestRunner.hpp
@@ -11,7 +11,7 @@
 #ifndef MRDOCS_TEST_TESTRUNNER_HPP
 #define MRDOCS_TEST_TESTRUNNER_HPP
 
-#include "lib/ConfigImpl.hpp"
+#include <lib/ConfigImpl.hpp>
 #include <mrdocs/Generator.hpp>
 #include <mrdocs/Support/ThreadPool.hpp>
 #include <llvm/ADT/StringRef.h>
@@ -86,4 +86,4 @@ class TestRunner
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_TEST_TESTRUNNER_HPP
diff --git a/src/test/lib/AST/ParseRef.cpp b/src/test/lib/AST/ParseRef.cpp
index a7837e711..25f8140cb 100644
--- a/src/test/lib/AST/ParseRef.cpp
+++ b/src/test/lib/AST/ParseRef.cpp
@@ -5,10 +5,10 @@
 // https://www.boost.org/LICENSE_1_0.txt
 //
 
+#include <lib/AST/ParseRef.hpp>
 #include <test_suite/detail/decomposer.hpp>
 #include <test_suite/diff.hpp>
 #include <test_suite/test_suite.hpp>
-#include "lib/AST/ParseRef.hpp"
 
 namespace clang::mrdocs {
 
diff --git a/src/test/lib/Dom/Dom.cpp b/src/test/lib/Dom/Dom.cpp
index 4e5f17861..c06e4e990 100644
--- a/src/test/lib/Dom/Dom.cpp
+++ b/src/test/lib/Dom/Dom.cpp
@@ -8,8 +8,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <format>
 #include <mrdocs/Dom.hpp>
+#include <format>
 #include <test_suite/test_suite.hpp>
 
 namespace clang {
diff --git a/src/test/lib/Support/Handlebars.cpp b/src/test/lib/Support/Handlebars.cpp
index 7a0a10c74..1547a96d3 100644
--- a/src/test/lib/Support/Handlebars.cpp
+++ b/src/test/lib/Support/Handlebars.cpp
@@ -5,18 +5,18 @@
 // https://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <filesystem>
-#include <format>
-#include <llvm/Support/JSON.h>
-#include <llvm/Support/MemoryBuffer.h>
 #include <mrdocs/Dom.hpp>
 #include <mrdocs/Support/Handlebars.hpp>
 #include <mrdocs/Support/Path.hpp>
 #include <mrdocs/Support/String.hpp>
+#include <llvm/Support/JSON.h>
+#include <llvm/Support/MemoryBuffer.h>
+#include <filesystem>
+#include <format>
+#include <utility>
 #include <test_suite/detail/decomposer.hpp>
 #include <test_suite/diff.hpp>
 #include <test_suite/test_suite.hpp>
-#include <utility>
 
 namespace clang {
 namespace mrdocs {
diff --git a/src/test/lib/Support/Path.cpp b/src/test/lib/Support/Path.cpp
index 80649d59a..56da2d001 100644
--- a/src/test/lib/Support/Path.cpp
+++ b/src/test/lib/Support/Path.cpp
@@ -8,7 +8,7 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include "lib/Support/Path.hpp"
+#include <lib/Support/Path.hpp>
 #include <test_suite/test_suite.hpp>
 
 namespace clang {
diff --git a/src/test_suite/detail/decomposer.cpp b/src/test_suite/detail/decomposer.cpp
index 97a11fc86..d3f937b1b 100644
--- a/src/test_suite/detail/decomposer.cpp
+++ b/src/test_suite/detail/decomposer.cpp
@@ -10,7 +10,7 @@
 #include "decomposer.hpp"
 
 #if __has_include(<cxxabi.h>)
-#include <cxxabi.h>
+#    include <cxxabi.h>
 #endif
 
 namespace test_suite {
diff --git a/src/test_suite/detail/decomposer.hpp b/src/test_suite/detail/decomposer.hpp
index 1f30f96e2..d678e0d97 100644
--- a/src/test_suite/detail/decomposer.hpp
+++ b/src/test_suite/detail/decomposer.hpp
@@ -5,8 +5,8 @@
 // https://www.boost.org/LICENSE_1_0.txt
 //
 
-#ifndef MRDOCS_TEST_DECOMPOSER_HPP
-#define MRDOCS_TEST_DECOMPOSER_HPP
+#ifndef MRDOCS_TEST_SUITE_DETAIL_DECOMPOSER_HPP
+#define MRDOCS_TEST_SUITE_DETAIL_DECOMPOSER_HPP
 
 #include <format>
 #include <sstream>
@@ -287,4 +287,4 @@ namespace test_suite::detail
 #    define DETAIL_SUPPRESS_PARENTHESES_WARNINGS
 #endif
 
-#endif //MRDOCS_TEST_DECOMPOSER_HPP
+#endif // MRDOCS_TEST_SUITE_DETAIL_DECOMPOSER_HPP
diff --git a/src/test_suite/diff.hpp b/src/test_suite/diff.hpp
index 50665b457..4af4e4c60 100644
--- a/src/test_suite/diff.hpp
+++ b/src/test_suite/diff.hpp
@@ -5,8 +5,8 @@
 // https://www.boost.org/LICENSE_1_0.txt
 //
 
-#ifndef MRDOCS_TEST_DIFF_HPP
-#define MRDOCS_TEST_DIFF_HPP
+#ifndef MRDOCS_TEST_SUITE_DIFF_HPP
+#define MRDOCS_TEST_SUITE_DIFF_HPP
 
 #include <string>
 #include <string_view>
@@ -76,4 +76,4 @@ BOOST_TEST_DIFF(
 
 }
 
-#endif //MRDOCS_TEST_DIFF_HPP
+#endif // MRDOCS_TEST_SUITE_DIFF_HPP
diff --git a/src/test_suite/test_suite.cpp b/src/test_suite/test_suite.cpp
index d502b7840..65ed8845a 100644
--- a/src/test_suite/test_suite.cpp
+++ b/src/test_suite/test_suite.cpp
@@ -8,7 +8,6 @@
 //
 
 #include "test_suite.hpp"
-
 #include <algorithm>
 #include <atomic>
 #include <chrono>
diff --git a/src/test_suite/test_suite.hpp b/src/test_suite/test_suite.hpp
index ec16adbd3..256005fc2 100644
--- a/src/test_suite/test_suite.hpp
+++ b/src/test_suite/test_suite.hpp
@@ -7,8 +7,8 @@
 // Official repository: https://github.com/boostorg/url
 //
 
-#ifndef MRDOCS_TEST_HPP
-#define MRDOCS_TEST_HPP
+#ifndef MRDOCS_TEST_SUITE_TEST_SUITE_HPP
+#define MRDOCS_TEST_SUITE_TEST_SUITE_HPP
 
 #if defined(_MSC_VER)
 # pragma once
@@ -18,7 +18,7 @@
 #include <cctype>
 #include <sstream>
 #include <type_traits>
-#include "detail/decomposer.hpp"
+#include <test_suite/detail/decomposer.hpp>
 
 //  This is a derivative work
 //  Copyright 2002-2018 Peter Dimov
@@ -385,4 +385,4 @@ extern int unit_test_main(int argc, char const* const* argv);
 
 } // test_suite
 
-#endif
+#endif // MRDOCS_TEST_SUITE_TEST_SUITE_HPP
diff --git a/src/tool/CompilerInfo.cpp b/src/tool/CompilerInfo.cpp
index c81e381ac..2cee25fa5 100644
--- a/src/tool/CompilerInfo.cpp
+++ b/src/tool/CompilerInfo.cpp
@@ -10,9 +10,8 @@
 //
 
 #include "CompilerInfo.hpp"
-#include "lib/Support/ExecuteAndWaitWithLogging.hpp"
+#include <lib/Support/ExecuteAndWaitWithLogging.hpp>
 #include <mrdocs/Support/Error.hpp>
-
 #include <llvm/Support/Program.h>
 
 namespace clang {
diff --git a/src/tool/CompilerInfo.hpp b/src/tool/CompilerInfo.hpp
index f0cdae0b0..fa8138ae7 100644
--- a/src/tool/CompilerInfo.hpp
+++ b/src/tool/CompilerInfo.hpp
@@ -8,16 +8,15 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_TOOL_COMPILER_HPP
-#define MRDOCS_TOOL_COMPILER_HPP
+#ifndef MRDOCS_TOOL_COMPILERINFO_HPP
+#define MRDOCS_TOOL_COMPILERINFO_HPP
 
+#include <clang/Tooling/CompilationDatabase.h>
+#include <llvm/ADT/StringRef.h>
 #include <optional>
 #include <string>
-#include <vector>
 #include <unordered_map>
-
-#include <clang/Tooling/CompilationDatabase.h>
-#include <llvm/ADT/StringRef.h>
+#include <vector>
 
 namespace clang {
 namespace mrdocs {
@@ -53,4 +52,4 @@ getCompilersDefaultIncludeDir(clang::tooling::CompilationDatabase const& compDb,
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_TOOL_COMPILERINFO_HPP
diff --git a/src/tool/GenerateAction.cpp b/src/tool/GenerateAction.cpp
index 91a4dc813..670047a94 100644
--- a/src/tool/GenerateAction.cpp
+++ b/src/tool/GenerateAction.cpp
@@ -12,13 +12,13 @@
 
 #include "ToolArgs.hpp"
 #include "ToolCompilationDatabase.hpp"
-#include "lib/ConfigImpl.hpp"
-#include "lib/CorpusImpl.hpp"
-#include "lib/MrDocsCompilationDatabase.hpp"
-#include "lib/Support/Path.hpp"
+#include <lib/ConfigImpl.hpp>
+#include <lib/CorpusImpl.hpp>
+#include <lib/MrDocsCompilationDatabase.hpp>
+#include <lib/Support/Path.hpp>
 #include <mrdocs/Generators.hpp>
-#include <mrdocs/Support/Report.hpp>
 #include <mrdocs/Support/Path.hpp>
+#include <mrdocs/Support/Report.hpp>
 #include <mrdocs/Support/ThreadPool.hpp>
 
 namespace clang::mrdocs {
diff --git a/src/tool/ToolArgs.cpp b/src/tool/ToolArgs.cpp
index 561f141e8..f556d87af 100644
--- a/src/tool/ToolArgs.cpp
+++ b/src/tool/ToolArgs.cpp
@@ -11,9 +11,9 @@
 #include "ToolArgs.hpp"
 #include <lib/Support/Path.hpp>
 #include <cstddef>
-#include <vector>
-#include <string>
 #include <ranges>
+#include <string>
+#include <vector>
 
 namespace clang {
 namespace mrdocs {
diff --git a/src/tool/ToolArgs.hpp b/src/tool/ToolArgs.hpp
index aed5016f8..2510703f9 100644
--- a/src/tool/ToolArgs.hpp
+++ b/src/tool/ToolArgs.hpp
@@ -11,10 +11,10 @@
 #ifndef MRDOCS_TOOL_TOOLARGS_HPP
 #define MRDOCS_TOOL_TOOLARGS_HPP
 
-#include <llvm/Support/CommandLine.h>
-#include <tool/PublicToolArgs.hpp>
 #include <mrdocs/Config.hpp>
+#include <llvm/Support/CommandLine.h>
 #include <string>
+#include <tool/PublicToolArgs.hpp>
 
 namespace clang {
 namespace mrdocs {
diff --git a/src/tool/ToolCompilationDatabase.cpp b/src/tool/ToolCompilationDatabase.cpp
index 08bb1e225..9e3d25fef 100644
--- a/src/tool/ToolCompilationDatabase.cpp
+++ b/src/tool/ToolCompilationDatabase.cpp
@@ -10,9 +10,9 @@
 
 #include "ToolCompilationDatabase.hpp"
 #include "CompilerInfo.hpp"
-#include "lib/MrDocsSettingsDB.hpp"
-#include "lib/Support/CMakeExecution.hpp"
-#include "lib/Support/Path.hpp"
+#include <lib/MrDocsSettingsDB.hpp>
+#include <lib/Support/CMakeExecution.hpp>
+#include <lib/Support/Path.hpp>
 #include <mrdocs/Support/Report.hpp>
 
 namespace clang {
diff --git a/src/tool/ToolCompilationDatabase.hpp b/src/tool/ToolCompilationDatabase.hpp
index 366b5ec35..3abadc91d 100644
--- a/src/tool/ToolCompilationDatabase.hpp
+++ b/src/tool/ToolCompilationDatabase.hpp
@@ -8,11 +8,11 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_TOOL_COMPILATIONDATABASE_HPP
-#define MRDOCS_TOOL_COMPILATIONDATABASE_HPP
+#ifndef MRDOCS_TOOL_TOOLCOMPILATIONDATABASE_HPP
+#define MRDOCS_TOOL_TOOLCOMPILATIONDATABASE_HPP
 
-#include "lib/MrDocsCompilationDatabase.hpp"
-#include "lib/ConfigImpl.hpp"
+#include <lib/ConfigImpl.hpp>
+#include <lib/MrDocsCompilationDatabase.hpp>
 
 namespace clang {
 namespace mrdocs {
@@ -26,4 +26,4 @@ generateCompilationDatabase(
 } // mrdocs
 } // clang
 
-#endif
+#endif // MRDOCS_TOOL_TOOLCOMPILATIONDATABASE_HPP
diff --git a/src/tool/ToolMain.cpp b/src/tool/ToolMain.cpp
index 46bbeca11..7be66d202 100644
--- a/src/tool/ToolMain.cpp
+++ b/src/tool/ToolMain.cpp
@@ -10,14 +10,14 @@
 //
 
 #include "ToolArgs.hpp"
-#include "lib/Support/Debug.hpp"
-#include "lib/Support/Report.hpp"
+#include <lib/Support/Debug.hpp>
+#include <lib/Support/Report.hpp>
 #include <mrdocs/Support/Path.hpp>
 #include <mrdocs/Version.hpp>
 #include <llvm/Support/FileSystem.h>
-#include <llvm/Support/raw_ostream.h>
 #include <llvm/Support/PrettyStackTrace.h>
 #include <llvm/Support/Signals.h>
+#include <llvm/Support/raw_ostream.h>
 #include <cstdlib>
 #include <ranges>
 
diff --git a/test-files/golden-tests/symbols/concept/requires-clause.cpp b/test-files/golden-tests/symbols/concept/requires-clause.cpp
index e8e84f926..99acf6fcd 100644
--- a/test-files/golden-tests/symbols/concept/requires-clause.cpp
+++ b/test-files/golden-tests/symbols/concept/requires-clause.cpp
@@ -7,15 +7,15 @@ void f() requires (sizeof(T) == 2);
 template<typename U>
 void f() requires (sizeof(U) == 2);
 
-template<typename T> requires (sizeof(T) == 4)
-void g();
-
 template<typename T> requires (sizeof(T) == 2)
 void g();
 
 template<typename U> requires (sizeof(U) == 2)
 void g();
 
+template<typename T> requires (sizeof(T) == 4)
+void g();
+
 template<typename T> requires (sizeof(T) == 2)
 struct A;
 
diff --git a/test-files/golden-tests/symbols/concept/requires-clause.xml b/test-files/golden-tests/symbols/concept/requires-clause.xml
index b699c46b6..f433a13bc 100644
--- a/test-files/golden-tests/symbols/concept/requires-clause.xml
+++ b/test-files/golden-tests/symbols/concept/requires-clause.xml
@@ -25,19 +25,19 @@
   <template requires="(sizeof(T) == 2)">
     <tparam name="T" class="type"/>
     <function name="g" id="7Ov3IFMO4O2wudrNvj6ZhEsu2MQ=">
-      <file short-path="requires-clause.cpp" source-path="requires-clause.cpp" line="13"/>
+      <file short-path="requires-clause.cpp" source-path="requires-clause.cpp" line="10"/>
     </function>
   </template>
   <template requires="(sizeof(T) == 4)">
     <tparam name="T" class="type"/>
     <function name="g" id="J+et9OIVQ+q49DcYMZXSH0YynQk=">
-      <file short-path="requires-clause.cpp" source-path="requires-clause.cpp" line="10"/>
+      <file short-path="requires-clause.cpp" source-path="requires-clause.cpp" line="16"/>
     </function>
   </template>
   <template requires="(sizeof(U) == 2)">
     <tparam name="U" class="type"/>
     <function name="g" id="jpU7wlh5sMsmxjW1m7bvmfv/iec=">
-      <file short-path="requires-clause.cpp" source-path="requires-clause.cpp" line="16"/>
+      <file short-path="requires-clause.cpp" source-path="requires-clause.cpp" line="13"/>
     </function>
   </template>
 </namespace>

From dd2df35af6882bffca002b058c21659711d72c07 Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Wed, 24 Sep 2025 19:17:50 -0500
Subject: [PATCH 06/23] refactor: metadata base classes do not expose
 constructors

---
 include/mrdocs/Corpus.hpp                     |  4 +-
 include/mrdocs/Metadata/Info/InfoBase.hpp     | 41 +++++----
 .../Metadata/Javadoc/Block/BlockBase.hpp      |  5 +-
 .../Metadata/Javadoc/{Text.hpp => Inline.hpp} | 54 +++++------
 .../Javadoc/{Text => Inline}/CopyDetails.hpp  | 10 +--
 .../Metadata/Javadoc/Inline/InlineBase.hpp    | 89 +++++++++++++++++++
 .../Javadoc/{Text => Inline}/Link.hpp         |  8 +-
 .../Javadoc/{Text => Inline}/Parts.hpp        |  6 +-
 .../Javadoc/{Text => Inline}/Reference.hpp    |  8 +-
 .../Javadoc/{Text => Inline}/Style.hpp        |  6 +-
 .../Javadoc/{Text => Inline}/Styled.hpp       | 10 +--
 .../{Text/TextBase.hpp => Inline/Text.hpp}    | 30 +++----
 include/mrdocs/Metadata/Javadoc/Node.hpp      |  2 +-
 .../mrdocs/Metadata/Javadoc/Node/NodeBase.hpp | 12 +--
 include/mrdocs/Metadata/Name/NameBase.hpp     | 11 ++-
 include/mrdocs/Metadata/TArg/TArgBase.hpp     |  2 +
 include/mrdocs/Metadata/TParam/TParamBase.hpp |  5 +-
 include/mrdocs/Metadata/Type/TypeBase.hpp     |  3 +-
 src/lib/AST/ParseJavadoc.cpp                  |  4 +-
 .../Metadata/Finalizers/JavadocFinalizer.cpp  |  2 +-
 src/lib/Metadata/Javadoc.cpp                  |  2 +-
 21 files changed, 203 insertions(+), 111 deletions(-)
 rename include/mrdocs/Metadata/Javadoc/{Text.hpp => Inline.hpp} (65%)
 rename include/mrdocs/Metadata/Javadoc/{Text => Inline}/CopyDetails.hpp (87%)
 create mode 100644 include/mrdocs/Metadata/Javadoc/Inline/InlineBase.hpp
 rename include/mrdocs/Metadata/Javadoc/{Text => Inline}/Link.hpp (89%)
 rename include/mrdocs/Metadata/Javadoc/{Text => Inline}/Parts.hpp (88%)
 rename include/mrdocs/Metadata/Javadoc/{Text => Inline}/Reference.hpp (90%)
 rename include/mrdocs/Metadata/Javadoc/{Text => Inline}/Style.hpp (87%)
 rename include/mrdocs/Metadata/Javadoc/{Text => Inline}/Styled.hpp (87%)
 rename include/mrdocs/Metadata/Javadoc/{Text/TextBase.hpp => Inline/Text.hpp} (80%)

diff --git a/include/mrdocs/Corpus.hpp b/include/mrdocs/Corpus.hpp
index 2244039b2..1e9fd5243 100644
--- a/include/mrdocs/Corpus.hpp
+++ b/include/mrdocs/Corpus.hpp
@@ -272,9 +272,7 @@ class MRDOCS_VISIBLE
                         {
                             return std::is_lt(cmp);
                         }
-                        return std::is_lt(
-                            CompareDerived(Polymorphic<Info>(lhsInfo),
-                                           Polymorphic<Info>(rhsInfo)));
+                        return std::is_lt(CompareDerived(lhsInfo, rhsInfo));
                     });
                 if (!opts.skipInherited)
                 {
diff --git a/include/mrdocs/Metadata/Info/InfoBase.hpp b/include/mrdocs/Metadata/Info/InfoBase.hpp
index ac0336e9c..9b22ef314 100644
--- a/include/mrdocs/Metadata/Info/InfoBase.hpp
+++ b/include/mrdocs/Metadata/Info/InfoBase.hpp
@@ -84,26 +84,6 @@ struct MRDOCS_VISIBLE Info
 
     ~Info() override = default;
 
-    Info(Info const& Other) = default;
-
-    /** Move constructor.
-     */
-    Info(Info&& Other) = default;
-
-    /** Construct an Info.
-
-        @param kind The kind of symbol
-        @param ID The unique identifier for this symbol
-    */
-    explicit
-    Info(
-        InfoKind const kind,
-        SymbolID const& ID) noexcept
-        : id(ID)
-        , Kind(kind)
-    {
-    }
-
     #define INFO(Type) constexpr bool is##Type() const noexcept { \
         return Kind == InfoKind::Type; \
     }
@@ -152,8 +132,27 @@ struct MRDOCS_VISIBLE Info
     auto operator<=>(Info const&) const = default;
 
 protected:
-    Info() = default;
+    constexpr Info() = default;
 
+    Info(Info const& Other) = default;
+
+    /** Move constructor.
+     */
+    Info(Info&& Other) = default;
+
+    /** Construct an Info.
+
+        @param kind The kind of symbol
+        @param ID The unique identifier for this symbol
+    */
+    explicit
+        Info(
+            InfoKind const kind,
+            SymbolID const& ID) noexcept
+        : id(ID)
+        , Kind(kind)
+    {
+    }
 };
 
 //------------------------------------------------
diff --git a/include/mrdocs/Metadata/Javadoc/Block/BlockBase.hpp b/include/mrdocs/Metadata/Javadoc/Block/BlockBase.hpp
index 4fd0568b0..32cd0abf7 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/BlockBase.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Block/BlockBase.hpp
@@ -17,8 +17,8 @@
 #include <mrdocs/Dom.hpp>
 #include <mrdocs/Dom/LazyArray.hpp>
 #include <mrdocs/Dom/LazyObject.hpp>
+#include <mrdocs/Metadata/Javadoc/Inline.hpp>
 #include <mrdocs/Metadata/Javadoc/Node/NodeBase.hpp>
-#include <mrdocs/Metadata/Javadoc/Text.hpp>
 #include <algorithm>
 #include <string>
 
@@ -94,6 +94,9 @@ struct MRDOCS_DECL
     void append(std::vector<Polymorphic<Text>> const& otherChildren);
 
 protected:
+    constexpr
+    Block() = default;
+
     explicit
     Block(
         NodeKind const kind_,
diff --git a/include/mrdocs/Metadata/Javadoc/Text.hpp b/include/mrdocs/Metadata/Javadoc/Inline.hpp
similarity index 65%
rename from include/mrdocs/Metadata/Javadoc/Text.hpp
rename to include/mrdocs/Metadata/Javadoc/Inline.hpp
index 5dc97981f..7efea7b68 100644
--- a/include/mrdocs/Metadata/Javadoc/Text.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Inline.hpp
@@ -10,45 +10,45 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_TEXT_HPP
-#define MRDOCS_API_METADATA_JAVADOC_TEXT_HPP
+#ifndef MRDOCS_API_METADATA_JAVADOC_INLINE_HPP
+#define MRDOCS_API_METADATA_JAVADOC_INLINE_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
-#include <mrdocs/Metadata/Javadoc/Text/CopyDetails.hpp>
-#include <mrdocs/Metadata/Javadoc/Text/Link.hpp>
-#include <mrdocs/Metadata/Javadoc/Text/Reference.hpp>
-#include <mrdocs/Metadata/Javadoc/Text/Style.hpp>
-#include <mrdocs/Metadata/Javadoc/Text/Styled.hpp>
-#include <mrdocs/Metadata/Javadoc/Text/TextBase.hpp>
+#include <mrdocs/Metadata/Javadoc/Inline/CopyDetails.hpp>
+#include <mrdocs/Metadata/Javadoc/Inline/Link.hpp>
+#include <mrdocs/Metadata/Javadoc/Inline/Reference.hpp>
+#include <mrdocs/Metadata/Javadoc/Inline/Style.hpp>
+#include <mrdocs/Metadata/Javadoc/Inline/Styled.hpp>
+#include <mrdocs/Metadata/Javadoc/Inline/Text.hpp>
 #include <mrdocs/Support/Concepts.hpp>
 #include <mrdocs/Support/Visitor.hpp>
 #include <compare>
 
 namespace clang::mrdocs::doc {
 
-/** Visit a text.
+/** Visit an inline.
 
-    @param text The text to visit.
-    @param fn The function to call for each text.
+    @param inline The inline to visit.
+    @param fn The function to call for each inline.
     @param args Additional arguments to pass to the function.
     @return The result of calling the function.
  */
 template<
-    class TextTy,
+    class InlineTy,
     class Fn,
     class... Args>
-    requires std::derived_from<TextTy, Text>
+    requires std::derived_from<InlineTy, Inline>
 decltype(auto)
 visit(
-    TextTy& text,
+    InlineTy& el,
     Fn&& fn,
     Args&&... args)
 {
-    auto visitor = makeVisitor<Text>(
-        text, std::forward<Fn>(fn),
+    auto visitor = makeVisitor<Inline>(
+        el, std::forward<Fn>(fn),
         std::forward<Args>(args)...);
-    switch(text.Kind)
+    switch(el.Kind)
     {
     case NodeKind::link:
         return visitor.template visit<Link>();
@@ -65,36 +65,36 @@ visit(
     }
 }
 
-/** Traverse a list of texts.
+/** Traverse a list of inlines.
 
     @param list The list of texts to traverse.
     @param f The function to call for each text.
     @param args Additional arguments to pass to the function.
  */
 template<class F, class T, class... Args>
-requires std::derived_from<T, Text>
+requires std::derived_from<T, Inline>
 void traverse(
     std::vector<std::unique_ptr<T>> const& list,
     F&& f, Args&&... args)
 {
-    for(auto const& text : list)
-        visit(*text,
+    for(auto const& el : list)
+        visit(*el,
             std::forward<F>(f),
             std::forward<Args>(args)...);
 }
 
-/** Map the Polymorphic Text as a @ref dom::Value object.
+/** Map the Polymorphic Inline as a @ref dom::Value object.
 
     @param io The output parameter to receive the dom::Object.
     @param I The input object.
     @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
  */
-template <class IO, polymorphic_storage_for<Text> TextTy>
+template <class IO, polymorphic_storage_for<Inline> InlineTy>
 void
 tag_invoke(
     dom::ValueFromTag,
     IO& io,
-    TextTy const& I,
+    InlineTy const& I,
     DomCorpus const* domCorpus)
 {
     visit(*I, [&](auto const& U)
@@ -109,14 +109,14 @@ tag_invoke(
 
 MRDOCS_DECL
 std::strong_ordering
-operator<=>(Polymorphic<Text> const& lhs, Polymorphic<Text> const& rhs);
+operator<=>(Polymorphic<Inline> const& lhs, Polymorphic<Inline> const& rhs);
 
 inline
 bool
-operator==(Polymorphic<Text> const& lhs, Polymorphic<Text> const& rhs) {
+operator==(Polymorphic<Inline> const& lhs, Polymorphic<Inline> const& rhs) {
     return std::is_eq(lhs <=> rhs);
 }
 
 } // clang::mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_TEXT_HPP
+#endif // MRDOCS_API_METADATA_JAVADOC_INLINE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Text/CopyDetails.hpp b/include/mrdocs/Metadata/Javadoc/Inline/CopyDetails.hpp
similarity index 87%
rename from include/mrdocs/Metadata/Javadoc/Text/CopyDetails.hpp
rename to include/mrdocs/Metadata/Javadoc/Inline/CopyDetails.hpp
index 9fcaa3e5a..58bc27a34 100644
--- a/include/mrdocs/Metadata/Javadoc/Text/CopyDetails.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Inline/CopyDetails.hpp
@@ -10,12 +10,12 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_TEXT_COPYDETAILS_HPP
-#define MRDOCS_API_METADATA_JAVADOC_TEXT_COPYDETAILS_HPP
+#ifndef MRDOCS_API_METADATA_JAVADOC_INLINE_COPYDETAILS_HPP
+#define MRDOCS_API_METADATA_JAVADOC_INLINE_COPYDETAILS_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Text/Reference.hpp>
-#include <mrdocs/Metadata/Javadoc/Text/TextBase.hpp>
+#include <mrdocs/Metadata/Javadoc/Inline/Reference.hpp>
+#include <mrdocs/Metadata/Javadoc/Inline/Text.hpp>
 #include <string>
 
 namespace clang::mrdocs::doc {
@@ -77,4 +77,4 @@ tag_invoke(
 
 } // clang::mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_TEXT_COPYDETAILS_HPP
+#endif // MRDOCS_API_METADATA_JAVADOC_INLINE_COPYDETAILS_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Inline/InlineBase.hpp b/include/mrdocs/Metadata/Javadoc/Inline/InlineBase.hpp
new file mode 100644
index 000000000..db924c584
--- /dev/null
+++ b/include/mrdocs/Metadata/Javadoc/Inline/InlineBase.hpp
@@ -0,0 +1,89 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_JAVADOC_INLINE_INLINEBASE_HPP
+#define MRDOCS_API_METADATA_JAVADOC_INLINE_INLINEBASE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Javadoc/Node/NodeBase.hpp>
+#include <string>
+
+namespace clang::mrdocs::doc {
+
+/** A Node containing a string of text.
+
+    There will be no newlines in the text. Otherwise,
+    this would be represented as multiple text nodes
+    within a Paragraph node.
+*/
+struct Inline : Node
+{
+    constexpr ~Inline() override = default;
+
+    bool
+    isBlock() const noexcept final
+    {
+        return false;
+    }
+
+    auto operator<=>(Inline const&) const = default;
+    bool operator==(Inline const&) const noexcept = default;
+    bool equals(Node const& other) const noexcept override
+    {
+        return Kind == other.Kind &&
+            *this == dynamic_cast<Inline const&>(other);
+    }
+
+protected:
+    constexpr Inline() noexcept = default;
+
+    Inline(
+        NodeKind kind_)
+        : Node(kind_)
+    {
+    }
+};
+
+/** Map the @ref Inline to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    Inline const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Node const&>(I), domCorpus);
+}
+
+/** Return the @ref Inline as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Inline const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // clang::mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_JAVADOC_INLINE_INLINEBASE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Text/Link.hpp b/include/mrdocs/Metadata/Javadoc/Inline/Link.hpp
similarity index 89%
rename from include/mrdocs/Metadata/Javadoc/Text/Link.hpp
rename to include/mrdocs/Metadata/Javadoc/Inline/Link.hpp
index 0020f98d9..e3500016a 100644
--- a/include/mrdocs/Metadata/Javadoc/Text/Link.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Inline/Link.hpp
@@ -10,11 +10,11 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_TEXT_LINK_HPP
-#define MRDOCS_API_METADATA_JAVADOC_TEXT_LINK_HPP
+#ifndef MRDOCS_API_METADATA_JAVADOC_INLINE_LINK_HPP
+#define MRDOCS_API_METADATA_JAVADOC_INLINE_LINK_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Text/TextBase.hpp>
+#include <mrdocs/Metadata/Javadoc/Inline/Text.hpp>
 #include <string>
 
 namespace clang::mrdocs::doc {
@@ -79,4 +79,4 @@ tag_invoke(
 
 } // clang::mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_TEXT_LINK_HPP
+#endif // MRDOCS_API_METADATA_JAVADOC_INLINE_LINK_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Text/Parts.hpp b/include/mrdocs/Metadata/Javadoc/Inline/Parts.hpp
similarity index 88%
rename from include/mrdocs/Metadata/Javadoc/Text/Parts.hpp
rename to include/mrdocs/Metadata/Javadoc/Inline/Parts.hpp
index b7f94b39d..63e37f043 100644
--- a/include/mrdocs/Metadata/Javadoc/Text/Parts.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Inline/Parts.hpp
@@ -10,8 +10,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_TEXT_PARTS_HPP
-#define MRDOCS_API_METADATA_JAVADOC_TEXT_PARTS_HPP
+#ifndef MRDOCS_API_METADATA_JAVADOC_INLINE_PARTS_HPP
+#define MRDOCS_API_METADATA_JAVADOC_INLINE_PARTS_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom.hpp>
@@ -54,4 +54,4 @@ tag_invoke(
 
 } // clang::mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_TEXT_PARTS_HPP
+#endif // MRDOCS_API_METADATA_JAVADOC_INLINE_PARTS_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Text/Reference.hpp b/include/mrdocs/Metadata/Javadoc/Inline/Reference.hpp
similarity index 90%
rename from include/mrdocs/Metadata/Javadoc/Text/Reference.hpp
rename to include/mrdocs/Metadata/Javadoc/Inline/Reference.hpp
index d1131d82e..8a93125f4 100644
--- a/include/mrdocs/Metadata/Javadoc/Text/Reference.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Inline/Reference.hpp
@@ -10,12 +10,12 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_TEXT_REFERENCE_HPP
-#define MRDOCS_API_METADATA_JAVADOC_TEXT_REFERENCE_HPP
+#ifndef MRDOCS_API_METADATA_JAVADOC_INLINE_REFERENCE_HPP
+#define MRDOCS_API_METADATA_JAVADOC_INLINE_REFERENCE_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Metadata/Info/SymbolID.hpp>
-#include <mrdocs/Metadata/Javadoc/Text/TextBase.hpp>
+#include <mrdocs/Metadata/Javadoc/Inline/Text.hpp>
 #include <string>
 
 namespace clang::mrdocs::doc {
@@ -86,4 +86,4 @@ tag_invoke(
 
 } // clang::mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_TEXT_REFERENCE_HPP
+#endif // MRDOCS_API_METADATA_JAVADOC_INLINE_REFERENCE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Text/Style.hpp b/include/mrdocs/Metadata/Javadoc/Inline/Style.hpp
similarity index 87%
rename from include/mrdocs/Metadata/Javadoc/Text/Style.hpp
rename to include/mrdocs/Metadata/Javadoc/Inline/Style.hpp
index acdfeb094..2be1a17c0 100644
--- a/include/mrdocs/Metadata/Javadoc/Text/Style.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Inline/Style.hpp
@@ -10,8 +10,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_TEXT_STYLE_HPP
-#define MRDOCS_API_METADATA_JAVADOC_TEXT_STYLE_HPP
+#ifndef MRDOCS_API_METADATA_JAVADOC_INLINE_STYLE_HPP
+#define MRDOCS_API_METADATA_JAVADOC_INLINE_STYLE_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom.hpp>
@@ -55,4 +55,4 @@ tag_invoke(
 
 } // clang::mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_TEXT_STYLE_HPP
+#endif // MRDOCS_API_METADATA_JAVADOC_INLINE_STYLE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Text/Styled.hpp b/include/mrdocs/Metadata/Javadoc/Inline/Styled.hpp
similarity index 87%
rename from include/mrdocs/Metadata/Javadoc/Text/Styled.hpp
rename to include/mrdocs/Metadata/Javadoc/Inline/Styled.hpp
index 5cc4e2c4b..94fcbdf8c 100644
--- a/include/mrdocs/Metadata/Javadoc/Text/Styled.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Inline/Styled.hpp
@@ -10,12 +10,12 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_TEXT_STYLED_HPP
-#define MRDOCS_API_METADATA_JAVADOC_TEXT_STYLED_HPP
+#ifndef MRDOCS_API_METADATA_JAVADOC_INLINE_STYLED_HPP
+#define MRDOCS_API_METADATA_JAVADOC_INLINE_STYLED_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Text/Style.hpp>
-#include <mrdocs/Metadata/Javadoc/Text/TextBase.hpp>
+#include <mrdocs/Metadata/Javadoc/Inline/Style.hpp>
+#include <mrdocs/Metadata/Javadoc/Inline/Text.hpp>
 #include <string>
 
 namespace clang::mrdocs::doc {
@@ -79,4 +79,4 @@ tag_invoke(
 
 } // clang::mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_TEXT_STYLED_HPP
+#endif // MRDOCS_API_METADATA_JAVADOC_INLINE_STYLED_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Text/TextBase.hpp b/include/mrdocs/Metadata/Javadoc/Inline/Text.hpp
similarity index 80%
rename from include/mrdocs/Metadata/Javadoc/Text/TextBase.hpp
rename to include/mrdocs/Metadata/Javadoc/Inline/Text.hpp
index e2a4e2ddf..0571e31d2 100644
--- a/include/mrdocs/Metadata/Javadoc/Text/TextBase.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Inline/Text.hpp
@@ -10,11 +10,11 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_TEXT_TEXTBASE_HPP
-#define MRDOCS_API_METADATA_JAVADOC_TEXT_TEXTBASE_HPP
+#ifndef MRDOCS_API_METADATA_JAVADOC_INLINE_TEXT_HPP
+#define MRDOCS_API_METADATA_JAVADOC_INLINE_TEXT_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Node/NodeBase.hpp>
+#include <mrdocs/Metadata/Javadoc/Inline/InlineBase.hpp>
 #include <string>
 
 namespace clang::mrdocs::doc {
@@ -25,25 +25,21 @@ namespace clang::mrdocs::doc {
     this would be represented as multiple text nodes
     within a Paragraph node.
 */
-struct Text : Node
+struct Text : Inline
 {
     std::string string;
 
     static constexpr auto static_kind = NodeKind::text;
 
-    explicit
-    Text(
-        std::string string_ = std::string()) noexcept
-        : Node(NodeKind::text)
+    constexpr ~Text() override = default;
+
+    constexpr Text() noexcept = default;
+
+    explicit Text(std::string string_ = std::string()) noexcept
+        : Inline(NodeKind::text)
         , string(std::move(string_))
-    {
-    }
+    {}
 
-    bool
-    isBlock() const noexcept final
-    {
-        return false;
-    }
 
     auto operator<=>(Text const&) const = default;
     bool operator==(Text const&) const noexcept = default;
@@ -57,7 +53,7 @@ struct Text : Node
     Text(
         std::string string_,
         NodeKind kind_)
-        : Node(kind_)
+        : Inline(kind_)
         , string(std::move(string_))
     {
     }
@@ -97,4 +93,4 @@ tag_invoke(
 
 } // clang::mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_TEXT_TEXTBASE_HPP
+#endif // MRDOCS_API_METADATA_JAVADOC_INLINE_TEXT_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Node.hpp b/include/mrdocs/Metadata/Javadoc/Node.hpp
index c1d49caa8..565c73427 100644
--- a/include/mrdocs/Metadata/Javadoc/Node.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Node.hpp
@@ -15,8 +15,8 @@
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Metadata/Javadoc/Block.hpp>
+#include <mrdocs/Metadata/Javadoc/Inline.hpp>
 #include <mrdocs/Metadata/Javadoc/Node/NodeBase.hpp>
-#include <mrdocs/Metadata/Javadoc/Text.hpp>
 #include <mrdocs/Support/Concepts.hpp>
 #include <mrdocs/Support/Visitor.hpp>
 
diff --git a/include/mrdocs/Metadata/Javadoc/Node/NodeBase.hpp b/include/mrdocs/Metadata/Javadoc/Node/NodeBase.hpp
index 20a4c35cb..22400db60 100644
--- a/include/mrdocs/Metadata/Javadoc/Node/NodeBase.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Node/NodeBase.hpp
@@ -37,11 +37,6 @@ struct MRDOCS_DECL
 
     virtual ~Node() = default;
 
-    explicit Node(NodeKind const kind_) noexcept
-        : Kind(kind_)
-    {
-    }
-
     virtual bool isBlock() const noexcept = 0;
 
     bool isText() const noexcept
@@ -55,6 +50,13 @@ struct MRDOCS_DECL
     {
         return Kind == other.Kind;
     }
+protected:
+    constexpr Node() noexcept = default;
+
+    explicit Node(NodeKind const kind_) noexcept
+        : Kind(kind_)
+    {
+    }
 };
 
 /** Map the @ref Node to a @ref dom::Object.
diff --git a/include/mrdocs/Metadata/Name/NameBase.hpp b/include/mrdocs/Metadata/Name/NameBase.hpp
index 3a9971705..b0e43ddf9 100644
--- a/include/mrdocs/Metadata/Name/NameBase.hpp
+++ b/include/mrdocs/Metadata/Name/NameBase.hpp
@@ -65,12 +65,6 @@ struct NameInfo
     constexpr bool isIdentifier()     const noexcept { return Kind == NameKind::Identifier; }
     constexpr bool isSpecialization() const noexcept { return Kind == NameKind::Specialization; }
 
-
-    explicit
-    constexpr
-    NameInfo(NameKind const kind) noexcept
-        : Kind(kind) {}
-
     constexpr virtual ~NameInfo() = default;
 
     std::strong_ordering
@@ -86,6 +80,11 @@ struct NameInfo
     constexpr
     NameInfo() noexcept
         : NameInfo(NameKind::Identifier) {};
+
+    explicit
+        constexpr
+        NameInfo(NameKind const kind) noexcept
+        : Kind(kind) {}
 };
 
 MRDOCS_DECL
diff --git a/include/mrdocs/Metadata/TArg/TArgBase.hpp b/include/mrdocs/Metadata/TArg/TArgBase.hpp
index 2aadc8d7f..0ce2269cf 100644
--- a/include/mrdocs/Metadata/TArg/TArgBase.hpp
+++ b/include/mrdocs/Metadata/TArg/TArgBase.hpp
@@ -36,6 +36,8 @@ struct TArg
     auto operator<=>(TArg const&) const = default;
 
 protected:
+    constexpr TArg() noexcept = default;
+
     constexpr
     TArg(
         TArgKind kind) noexcept
diff --git a/include/mrdocs/Metadata/TParam/TParamBase.hpp b/include/mrdocs/Metadata/TParam/TParamBase.hpp
index a58d91435..5b201035d 100644
--- a/include/mrdocs/Metadata/TParam/TParamBase.hpp
+++ b/include/mrdocs/Metadata/TParam/TParamBase.hpp
@@ -27,7 +27,7 @@ class DomCorpus;
 struct TParam
 {
     /** The kind of template parameter this is */
-    TParamKind Kind;
+    TParamKind Kind = TParamKind::Type;
 
     /** The template parameters name, if any */
     std::string Name;
@@ -47,6 +47,9 @@ struct TParam
     std::strong_ordering operator<=>(TParam const&) const;
 
 protected:
+    constexpr
+    TParam() noexcept = default;
+
     constexpr
     TParam(
         TParamKind kind) noexcept
diff --git a/include/mrdocs/Metadata/Type/TypeBase.hpp b/include/mrdocs/Metadata/Type/TypeBase.hpp
index bf393c131..80fff732f 100644
--- a/include/mrdocs/Metadata/Type/TypeBase.hpp
+++ b/include/mrdocs/Metadata/Type/TypeBase.hpp
@@ -59,7 +59,6 @@ struct TypeInfo
      */
     std::vector<ExprInfo> Constraints;
 
-    constexpr virtual ~TypeInfo() = default;
 
     constexpr bool isNamed()           const noexcept { return Kind == TypeKind::Named; }
     constexpr bool isDecltype()        const noexcept { return Kind == TypeKind::Decltype; }
@@ -79,6 +78,8 @@ struct TypeInfo
     auto operator<=>(TypeInfo const&) const = default;
 
 protected:
+    constexpr virtual ~TypeInfo() = default;
+
     constexpr
     TypeInfo(
         TypeKind kind) noexcept
diff --git a/src/lib/AST/ParseJavadoc.cpp b/src/lib/AST/ParseJavadoc.cpp
index 4e435c9eb..b65980e6b 100644
--- a/src/lib/AST/ParseJavadoc.cpp
+++ b/src/lib/AST/ParseJavadoc.cpp
@@ -15,7 +15,7 @@
 #include "ParseJavadoc.hpp"
 #include <lib/AST/ParseRef.hpp>
 #include <mrdocs/Metadata/Javadoc.hpp>
-#include <mrdocs/Metadata/Javadoc/Text/Parts.hpp>
+#include <mrdocs/Metadata/Javadoc/Inline/Parts.hpp>
 #include <mrdocs/Support/Algorithm.hpp>
 #include <mrdocs/Support/Error.hpp>
 #include <mrdocs/Support/Path.hpp>
@@ -742,7 +742,7 @@ visitTextComment(
     }
 
     // Only insert non-empty text nodes
-    if(! s.empty())
+    if (!s.empty())
     {
         emplaceText<doc::Text>(
             C->hasTrailingNewline(),
diff --git a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp b/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
index 0b3ae2dd1..887ef651d 100644
--- a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
@@ -898,7 +898,7 @@ processRelates(Javadoc& javadoc)
 
     Info const* currentPtr = corpus_.find(current_context_->id);
     MRDOCS_ASSERT(currentPtr);
-    Info const current = *currentPtr;
+    Info const& current = *currentPtr;
 
     if (!current.isFunction())
     {
diff --git a/src/lib/Metadata/Javadoc.cpp b/src/lib/Metadata/Javadoc.cpp
index 668442b7e..bf7d94434 100644
--- a/src/lib/Metadata/Javadoc.cpp
+++ b/src/lib/Metadata/Javadoc.cpp
@@ -14,7 +14,7 @@
 #include <mrdocs/Corpus.hpp>
 #include <mrdocs/Metadata/DomCorpus.hpp>
 #include <mrdocs/Metadata/Javadoc.hpp>
-#include <mrdocs/Metadata/Javadoc/Text/Parts.hpp>
+#include <mrdocs/Metadata/Javadoc/Inline/Parts.hpp>
 #include <llvm/Support/Error.h>
 #include <llvm/Support/Path.h>
 #include <format>

From 6aa8b57516a027bdebef9c97cf8a62271854f623 Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Wed, 24 Sep 2025 20:33:17 -0500
Subject: [PATCH 07/23] style: version printer mimics clang

---
 src/tool/ToolMain.cpp | 46 +++++++++++++++++++++----------------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/src/tool/ToolMain.cpp b/src/tool/ToolMain.cpp
index 7be66d202..3e4717d89 100644
--- a/src/tool/ToolMain.cpp
+++ b/src/tool/ToolMain.cpp
@@ -16,8 +16,9 @@
 #include <mrdocs/Version.hpp>
 #include <llvm/Support/FileSystem.h>
 #include <llvm/Support/PrettyStackTrace.h>
-#include <llvm/Support/Signals.h>
 #include <llvm/Support/raw_ostream.h>
+#include <llvm/Support/Signals.h>
+#include <llvm/TargetParser/Host.h>
 #include <cstdlib>
 #include <ranges>
 
@@ -36,16 +37,6 @@ DoGenerateAction(
     ReferenceDirectories const& dirs,
     char const** argv);
 
-void
-print_version(llvm::raw_ostream& os)
-{
-    os << project_name
-       << "\n    " << project_description
-       << "\n    version: " << project_version_with_build
-       << "\n    build: " << project_version_build
-       << "\n    built with LLVM " << LLVM_VERSION_STRING
-       << "\n";
-}
 
 Expected<ReferenceDirectories>
 getReferenceDirectories(std::string const& execPath)
@@ -99,8 +90,28 @@ mrdocs_main(int argc, char const** argv)
     llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
     llvm::setBugReportMsg("PLEASE submit a bug report to https://github.com/cppalliance/mrdocs/issues/ and include the crash backtrace.\n");
 
+    // Set up addons directory
+#ifdef __GNUC__
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wpedantic"
+    // error: ISO C++ forbids taking address of function ‘::main’
+#endif
+    void* addressOfMain = reinterpret_cast<void*>(&main);
+#ifdef __GNUC__
+#    pragma GCC diagnostic pop
+#endif
+    std::string execPath = llvm::sys::fs::
+        getMainExecutable(argv[0], addressOfMain);
+
     // Parse command line options
-    llvm::cl::SetVersionPrinter(&print_version);
+    llvm::cl::SetVersionPrinter([execPath](llvm::raw_ostream& os) {
+        os << project_name << " version " << project_version_with_build << "\n";
+        os << "Built with LLVM " << LLVM_VERSION_STRING << "\n";
+        os << "Build SHA: " << project_version_build << "\n";
+        os << "Target: " << llvm::sys::getDefaultTargetTriple() << "\n";
+        os << "InstalledDir: " << files::getParentDir(execPath) << "\n";
+    });
+
     toolArgs.hideForeignOptions();
     if (!llvm::cl::ParseCommandLineOptions(
         argc, argv, toolArgs.usageText))
@@ -108,17 +119,6 @@ mrdocs_main(int argc, char const** argv)
         return EXIT_FAILURE;
     }
 
-    // Set up addons directory
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
-// error: ISO C++ forbids taking address of function ‘::main’
-#endif
-    void* addressOfMain = reinterpret_cast<void*>(&main);
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-    std::string execPath = llvm::sys::fs::getMainExecutable(argv[0], addressOfMain);
 
     // Before `DoGenerateAction`, we use an error reporting level.
     // DoGenerateAction will set the level to whatever is specified in

From 569bc116796d3215ac8cac2f42a84bac9bb0b9cb Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Wed, 24 Sep 2025 21:46:02 -0500
Subject: [PATCH 08/23] feat: show-enum-constants option

Since an EnumConstant is a regular information type according to the Clang AST, it supports all Javadoc features. For consistency, we create an option analogous to 'show-namespaces' for 'enum-constants', so the user has the ability to render their own doc comments instead of discarding them. The logic is also important because it opens the possibility of conditionally rendering enum constants.
---
 docs/mrdocs.schema.json                       |  10 +
 .../generator/adoc/partials/markup/a.adoc.hbs |   4 +-
 .../generator/adoc/partials/symbol.adoc.hbs   |  15 +-
 .../generator/html/partials/markup/a.html.hbs |   6 +-
 .../generator/html/partials/symbol.html.hbs   |  20 +-
 src/lib/ConfigOptions.json                    |   7 +
 src/lib/Gen/hbs/VisitorHelpers.cpp            |   2 +-
 .../config/auto-brief/auto-brief.html         |  64 +-
 .../config/auto-brief/no-auto-brief.html      |  64 +-
 .../brief-from-function-class.html            |  26 +-
 .../brief-from-operator.html                  |  20 +-
 .../param-from-function-class.html            |  30 +-
 .../param-from-operator.html                  |  16 +-
 .../returns-from-brief.html                   |  10 +-
 .../returns-from-return-brief.html            |   6 +-
 .../returns-from-special.html                 |  58 +-
 .../config/auto-relates/auto-relates.html     |  16 +-
 .../config/auto-relates/derived.html          |  22 +-
 .../config/auto-relates/enum.html             |  27 +-
 .../config/auto-relates/no-auto-relates.html  |  16 +-
 .../config/auto-relates/qualified.html        |  24 +-
 .../config/auto-relates/remove-friend.html    |   8 +-
 .../config/auto-relates/return-type.html      |  14 +-
 .../config/extract-all/no-extract-all.html    |   6 +-
 .../no-extract-empty-namespaces.html          |  28 +-
 .../extract-friends/extract-friends.html      |  12 +-
 .../extract-friends/no-extract-friends.html   |  12 +-
 .../base.html                                 |   8 +-
 .../extract-implicit-specializations.html     |  10 +-
 .../no-extract-implicit-specializations.html  |   8 +-
 .../extract-local-classes.html                |   8 +-
 .../no-extract-local-classes.html             |   4 +-
 .../extract-private-virtual.html              |   8 +-
 .../no-extract-private-virtual.html           |   6 +-
 .../base-overload-set.html                    |  16 +-
 .../copy-dependencies.html                    |  52 +-
 .../config/inherit-base-members/copy.html     |  86 +-
 .../config/inherit-base-members/never.html    |  40 +-
 .../inherit-base-members/reference.html       |  40 +-
 .../inherit-base-members/skip-special.html    |  72 +-
 .../config/legible-names/constructor.html     |  16 +-
 .../config/missing-include-prefixes/main.html |   6 +-
 .../config/missing-include-shims/main.html    |   4 +-
 .../config/overloads/const-mutable.html       |  10 +-
 .../config/overloads/visibility.html          |  28 +-
 .../golden-tests/config/sfinae/redeclare.html |   4 +-
 .../config/sfinae/return-based.html           |   4 +-
 .../show-enum-constants-false.adoc            |  46 +
 .../show-enum-constants-false.cpp             |   9 +
 .../show-enum-constants-false.html            |  68 ++
 .../show-enum-constants-false.xml             |  41 +
 .../show-enum-constants-false.yml             |   1 +
 .../show-enum-constants-true.adoc             |  88 ++
 .../show-enum-constants-true.cpp              |   9 +
 .../show-enum-constants-true.html             | 125 +++
 .../show-enum-constants-true.xml              |  41 +
 .../show-enum-constants-true.yml              |   1 +
 .../show-namespaces/show-namespaces.html      |   6 +-
 .../sort-members-by-location.html             |  26 +-
 .../sort-members-by/sort-members-by-name.html |  26 +-
 .../sort-namespace-members-by-location.html   |  66 +-
 .../sort-namespace-members-by-name.html       |  66 +-
 .../config/sort/sort-members.html             |  66 +-
 .../golden-tests/config/sort/unordered.html   |  66 +-
 test-files/golden-tests/core/empty.html       |   2 +-
 test-files/golden-tests/core/libcxx.html      |   4 +-
 test-files/golden-tests/core/utf-8.html       |   4 +-
 .../filters/file/exclude-self.html            |   2 +-
 .../filters/file/include-self.html            |   6 +-
 .../filters/file/include-symlink.html         |   4 +-
 .../filters/file/subdirectories.html          |   4 +-
 .../filters/file/subdirectories2.html         |   4 +-
 .../filters/symbol-name/blacklist_0.html      |  22 +-
 .../symbol-name/excluded-base-class.html      |  24 +-
 .../symbol-name/excluded-namespace-alias.html |   8 +-
 .../filters/symbol-name/extraction-mode.html  |  52 +-
 .../symbol-name/impl-defined-member.html      |  10 +-
 .../filters/symbol-name/whitelist_0.html      |  36 +-
 .../symbol-type/nested-private-template.html  |   8 +-
 .../golden-tests/javadoc/brief/brief-1.html   |   6 +-
 .../golden-tests/javadoc/brief/brief-2.html   |  14 +-
 .../golden-tests/javadoc/brief/brief-3.html   |  12 +-
 .../golden-tests/javadoc/brief/brief-4.html   |  10 +-
 .../golden-tests/javadoc/brief/brief-5.html   |  14 +-
 .../golden-tests/javadoc/brief/brief-6.html   |   4 +-
 .../golden-tests/javadoc/code/code.html       |   4 +-
 .../javadoc/copybrief/copybrief.html          |   8 +-
 .../javadoc/copydetails/copydetails.html      |   8 +-
 .../javadoc/copydoc/conversion.html           |  18 +-
 .../javadoc/copydoc/decay-params.html         |  12 +-
 .../javadoc/copydoc/fundamental.html          |  12 +-
 .../javadoc/copydoc/no-param.html             |  12 +-
 .../javadoc/copydoc/operator-param.html       |  10 +-
 .../javadoc/copydoc/param-types.html          |  69 +-
 .../javadoc/copydoc/qualified.html            |  40 +-
 .../javadoc/copydoc/qualifiers.html           |  30 +-
 .../javadoc/copydoc/template-arguments.html   |  30 +-
 .../golden-tests/javadoc/inline/styled.html   |   6 +-
 .../golden-tests/javadoc/link/link.html       |   4 +-
 test-files/golden-tests/javadoc/lists/li.html |   4 +-
 .../golden-tests/javadoc/lists/listitem.html  |  10 +-
 .../golden-tests/javadoc/paragraph/par-1.html |  10 +-
 .../javadoc/paragraph/para-1.html             |  10 +-
 .../javadoc/paragraph/para-2.html             |   4 +-
 .../javadoc/paragraph/para-3.html             |   4 +-
 .../golden-tests/javadoc/param/param-1.html   |  12 +-
 .../javadoc/param/param-direction.html        |  22 +-
 .../javadoc/param/param-duplicate.html        |  14 +-
 .../golden-tests/javadoc/param/param.html     |  10 +-
 .../golden-tests/javadoc/pre/pre-post.html    |   4 +-
 .../golden-tests/javadoc/ref/broken-ref.html  |   6 +-
 .../golden-tests/javadoc/ref/punctuation.html |   8 +-
 test-files/golden-tests/javadoc/ref/ref.html  | 108 +--
 .../golden-tests/javadoc/relates/relates.html |   8 +-
 .../golden-tests/javadoc/returns/returns.html |  12 +-
 .../golden-tests/javadoc/throw/throw.html     |   4 +-
 .../golden-tests/javadoc/tparam/tparam-1.html |   6 +-
 .../golden-tests/output/canonical_1.html      |  18 +-
 .../golden-tests/snippets/distance.html       |   2 +-
 .../golden-tests/snippets/is_prime.html       |   2 +-
 test-files/golden-tests/snippets/sqrt.html    |   2 +-
 .../golden-tests/snippets/terminate.html      |   2 +-
 .../golden-tests/symbols/concept/concept.html |   8 +-
 .../symbols/concept/requires-clause.html      |  16 +-
 .../golden-tests/symbols/enum/enum.adoc       |  38 +-
 .../golden-tests/symbols/enum/enum.html       |  76 +-
 .../symbols/function/attributes-2.html        |   4 +-
 .../symbols/function/attributes_1.html        |   4 +-
 .../golden-tests/symbols/function/auto.html   |   4 +-
 .../function/explicit-conv-operator.html      |  18 +-
 .../symbols/function/explicit-ctor.html       |  50 +-
 .../function/explicit-object-parameter.html   |  10 +-
 .../symbols/function/function-parm-decay.html |  14 +-
 .../function/function-template-template.html  |   4 +-
 .../symbols/function/function-template.html   |  26 +-
 .../function/function-tparm-decay.html        |  14 +-
 .../golden-tests/symbols/function/mem-fn.html |  78 +-
 .../symbols/function/merge-params.html        |   4 +-
 .../symbols/function/merge-tparams.html       |   4 +-
 .../symbols/function/noreturn.html            |  10 +-
 .../symbols/function/overloaded-op-1.html     |   6 +-
 .../symbols/function/overloaded-op-2.html     |   6 +-
 .../symbols/function/qualified-params.html    |  12 +-
 .../golden-tests/symbols/function/sfinae.html |  38 +-
 .../spec-mem-implicit-instantiation.html      |  62 +-
 .../symbols/function/type-resolution.html     | 102 +--
 .../symbols/function/variadic-function.html   |  12 +-
 .../symbols/guide/explicit-deduct-guide.html  |  12 +-
 .../namespace-alias/namespace-alias-1.html    |   8 +-
 .../namespace-alias/namespace-alias-2.html    |  10 +-
 .../namespace-alias/namespace-alias-3.html    |  10 +-
 .../symbols/namespace/namespace.html          |  36 +-
 .../symbols/overloads/overloads-brief.html    |  48 +-
 .../symbols/overloads/overloads-metadata.html |  10 +-
 .../symbols/overloads/overloads-ostream.html  |  28 +-
 .../symbols/overloads/overloads.html          |  34 +-
 .../symbols/record/class-private-alias.html   |   6 +-
 .../record/class-template-partial-spec.html   |  10 +-
 .../symbols/record/class-template-spec.html   |  38 +-
 .../class-template-specializations-1.html     | 828 +++++++++---------
 .../class-template-specializations-2.html     |  48 +-
 .../class-template-specializations-3.html     | 130 +--
 .../symbols/record/class-template.html        |  46 +-
 .../symbols/record/conditional-explicit.html  |  22 +-
 .../symbols/record/dtor-overloads.html        |  10 +-
 .../symbols/record/final-class.html           |  12 +-
 .../symbols/record/friend-duplicate.html      |   8 +-
 .../symbols/record/friend-excluded.html       |   8 +-
 .../symbols/record/friend-fn-has-docs.html    |   6 +-
 .../symbols/record/friend-fn-member.html      |  12 +-
 .../symbols/record/friend-fn-multi-2nd.html   |   8 +-
 .../symbols/record/friend-fn-multi-free.html  |   8 +-
 .../symbols/record/friend-fn-multi.html       |   8 +-
 .../symbols/record/friend-fn.html             |   6 +-
 .../symbols/record/friend-type.html           |  10 +-
 .../symbols/record/local-class.html           |   6 +-
 .../record/out-of-line-record-def.html        |   6 +-
 .../golden-tests/symbols/record/record-1.html |  20 +-
 .../symbols/record/record-access.html         |  26 +-
 .../symbols/record/record-data.html           |  44 +-
 .../symbols/record/record-inheritance.html    |  34 +-
 .../template-specialization-inheritance.html  |  30 +-
 .../golden-tests/symbols/record/union.html    |  16 +-
 .../golden-tests/symbols/record/unnamed.html  |   4 +-
 .../symbols/typedef/alias-template.html       |  12 +-
 .../symbols/typedef/decay-to-primary.html     |  24 +-
 .../typedef/dependency-propagation.html       |  14 +-
 .../implicit-instantiation-member-ref.html    |  24 +-
 .../symbols/using-directive/using-1.html      |   6 +-
 .../symbols/using-enum/using-enum-in-ns.adoc  |   5 +-
 .../symbols/using-enum/using-enum-in-ns.html  |  19 +-
 .../using-enum/using-enum-in-record.adoc      |   5 +-
 .../using-enum/using-enum-in-record.html      |  21 +-
 .../symbols/using/using-function-after.html   |  12 +-
 .../using/using-function-and-type.html        |  10 +-
 .../using/using-function-excluded.html        |   4 +-
 .../using/using-function-local-overloads.html |  16 +-
 .../using/using-function-overloads.html       |  14 +-
 .../symbols/using/using-function.html         |   8 +-
 .../using/using-member-conversion.html        |  12 +-
 .../symbols/using/using-member-function.html  |  62 +-
 .../symbols/using/using-multi.html            |  12 +-
 .../symbols/using/using-struct-template.html  |  12 +-
 .../symbols/using/using-struct.html           |  12 +-
 .../using/using-template-function.html        |   8 +-
 .../symbols/using/using-typename.html         |   8 +-
 .../symbols/variable/no_unique_address.html   |  10 +-
 .../symbols/variable/ns-variables.html        |  22 +-
 .../variable/static-data-def-constexpr.html   |  10 +-
 .../symbols/variable/static-data-def.html     |  28 +-
 .../variable/static-data-template.html        |  10 +-
 .../variable/var-inline-constexpr.html        |  22 +-
 .../symbols/variable/var-template.html        |  16 +-
 .../templates/c_mct_expl_inline.html          |  12 +-
 .../templates/c_mct_expl_outside.html         |  12 +-
 .../templates/c_mft_expl_inline.html          |  10 +-
 .../templates/c_mft_expl_outside.html         |  10 +-
 .../golden-tests/templates/ct_expl.html       |  10 +-
 .../templates/ct_expl_dependency.html         |   6 +-
 test-files/golden-tests/templates/ct_mc.html  |   8 +-
 .../templates/ct_mc_expl_outside.html         |  14 +-
 test-files/golden-tests/templates/ct_mct.html |   8 +-
 .../templates/ct_mct_expl_inline.html         |  12 +-
 .../templates/ct_mct_expl_outside.html        |  16 +-
 test-files/golden-tests/templates/ct_mf.html  |   6 +-
 .../templates/ct_mf_expl_outside.html         |  10 +-
 test-files/golden-tests/templates/ct_mft.html |   6 +-
 .../templates/ct_mft_expl_inline.html         |  10 +-
 .../templates/ct_mft_expl_outside.html        |  14 +-
 .../golden-tests/templates/ft_expl.html       |   8 +-
 230 files changed, 2853 insertions(+), 2502 deletions(-)
 create mode 100644 test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.adoc
 create mode 100644 test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.cpp
 create mode 100644 test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.html
 create mode 100644 test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.xml
 create mode 100644 test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.yml
 create mode 100644 test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.adoc
 create mode 100644 test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.cpp
 create mode 100644 test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.html
 create mode 100644 test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.xml
 create mode 100644 test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.yml

diff --git a/docs/mrdocs.schema.json b/docs/mrdocs.schema.json
index 8865cd48f..f904ece17 100644
--- a/docs/mrdocs.schema.json
+++ b/docs/mrdocs.schema.json
@@ -425,6 +425,16 @@
       "title": "Detect and reduce SFINAE expressions",
       "type": "boolean"
     },
+    "show-enum-constants": {
+      "default": false,
+      "description": "When set to true, MrDocs creates a page for each enum constant in the documentation.",
+      "enum": [
+        true,
+        false
+      ],
+      "title": "Show enum constant pages in the documentation",
+      "type": "boolean"
+    },
     "show-namespaces": {
       "default": true,
       "description": "When set to true, MrDocs creates a page for each namespace in the documentation.",
diff --git a/share/mrdocs/addons/generator/adoc/partials/markup/a.adoc.hbs b/share/mrdocs/addons/generator/adoc/partials/markup/a.adoc.hbs
index 172ba3efc..429b416be 100644
--- a/share/mrdocs/addons/generator/adoc/partials/markup/a.adoc.hbs
+++ b/share/mrdocs/addons/generator/adoc/partials/markup/a.adoc.hbs
@@ -3,7 +3,9 @@
 
     https://gitlab.com/antora/antora/-/issues/428
 }}
-{{#if (starts_with href "#")~}}
+{{#if (eq href @root.symbol.url)~}}
+    {{{> @partial-block }}}
+{{~else if (starts_with href "#")~}}
     link:{{{ href }}}[{{> @partial-block }}]
 {{~else if (starts_with href "/")~}}
     xref:{{{remove_prefix href "/"}}}[{{> @partial-block }}]
diff --git a/share/mrdocs/addons/generator/adoc/partials/symbol.adoc.hbs b/share/mrdocs/addons/generator/adoc/partials/symbol.adoc.hbs
index abb772c7a..9dcfabc93 100644
--- a/share/mrdocs/addons/generator/adoc/partials/symbol.adoc.hbs
+++ b/share/mrdocs/addons/generator/adoc/partials/symbol.adoc.hbs
@@ -69,20 +69,7 @@
 {{>symbol/tranche tranche=symbol.members label="" is-namespace=true}}
 {{! Enum members }}
 {{else if (eq symbol.kind "enum")}}
-{{#if symbol.constants}}
-{{#> markup/dynamic-level-h }}Members{{/markup/dynamic-level-h}}
-
-[cols=2]
-|===
-| Name
-| Description
-{{#each (filter_by symbol.constants "isRegular" "isSeeBelow")}}
-|`{{>symbol/name-text .}}`
-|{{> javadoc/inline-brief doc.brief }}
-{{/each}}
-|===
-
-{{/if}}
+{{>symbol/members-table members=symbol.constants title="Members"}}
 {{/if}}
 {{! Friends }}
 {{#if symbol.friends}}
diff --git a/share/mrdocs/addons/generator/html/partials/markup/a.html.hbs b/share/mrdocs/addons/generator/html/partials/markup/a.html.hbs
index 03626d5ca..fcfdd3283 100644
--- a/share/mrdocs/addons/generator/html/partials/markup/a.html.hbs
+++ b/share/mrdocs/addons/generator/html/partials/markup/a.html.hbs
@@ -1 +1,5 @@
-<a href="{{{relativize href}}}">{{> @partial-block }}</a>
\ No newline at end of file
+{{#if (eq href @root.symbol.url)~}}
+    {{{> @partial-block }}}
+{{~else~}}
+    <a href="{{{relativize href}}}">{{> @partial-block }}</a>
+{{~/if~}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/html/partials/symbol.html.hbs b/share/mrdocs/addons/generator/html/partials/symbol.html.hbs
index da0093e42..4691fc895 100644
--- a/share/mrdocs/addons/generator/html/partials/symbol.html.hbs
+++ b/share/mrdocs/addons/generator/html/partials/symbol.html.hbs
@@ -93,25 +93,7 @@
 {{>symbol/tranche tranche=symbol.members label="" is-namespace=true}}
 {{! Enum members }}
 {{else if (eq symbol.kind "enum")}}
-<div>
-{{#> markup/dynamic-level-h level=2 }}Members{{/markup/dynamic-level-h}}
-<table>
-<thead>
-<tr>
-<th>Name</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
-{{#each (filter_by symbol.constants "isRegular" "isSeeBelow")}}
-<tr>
-<td>{{>symbol/name-text .}}</td>
-<td>{{> javadoc/inline-brief doc.brief }}</td>
-</tr>
-{{/each}}
-</tbody>
-</table>
-</div>
+{{>symbol/members-table members=symbol.constants title="Members"}}
 {{/if}}
 {{! Friends }}
 {{#if symbol.friends}}
diff --git a/src/lib/ConfigOptions.json b/src/lib/ConfigOptions.json
index a75281f17..dc8212890 100644
--- a/src/lib/ConfigOptions.json
+++ b/src/lib/ConfigOptions.json
@@ -453,6 +453,13 @@
         "type": "bool",
         "default": true
       },
+      {
+        "name": "show-enum-constants",
+        "brief": "Show enum constant pages in the documentation",
+        "details": "When set to true, MrDocs creates a page for each enum constant in the documentation.",
+        "type": "bool",
+        "default": false
+      },
       {
         "name": "global-namespace-index",
         "brief": "Use the global namespace page as an index for all symbols",
diff --git a/src/lib/Gen/hbs/VisitorHelpers.cpp b/src/lib/Gen/hbs/VisitorHelpers.cpp
index 48b62d8a1..ce3629233 100644
--- a/src/lib/Gen/hbs/VisitorHelpers.cpp
+++ b/src/lib/Gen/hbs/VisitorHelpers.cpp
@@ -19,7 +19,7 @@ namespace clang::mrdocs::hbs {
 bool
 shouldGenerate(Info const& I, Config const& config)
 {
-    if (I.isEnumConstant())
+    if (I.isEnumConstant() && !config->showEnumConstants)
     {
         return false;
     }
diff --git a/test-files/golden-tests/config/auto-brief/auto-brief.html b/test-files/golden-tests/config/auto-brief/auto-brief.html
index 4eeac05f7..85b45bcbe 100644
--- a/test-files/golden-tests/config/auto-brief/auto-brief.html
+++ b/test-files/golden-tests/config/auto-brief/auto-brief.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -56,7 +56,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="copyBriefFromCopyBrief"><a href="#copyBriefFromCopyBrief">copyBriefFromCopyBrief</a></h2>
+<h2 id="copyBriefFromCopyBrief">copyBriefFromCopyBrief</h2>
 <div>
 <span>This is the explicit brief.</span>
 
@@ -76,7 +76,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="copyBriefFromExplicitBrief"><a href="#copyBriefFromExplicitBrief">copyBriefFromExplicitBrief</a></h2>
+<h2 id="copyBriefFromExplicitBrief">copyBriefFromExplicitBrief</h2>
 <div>
 <span>This is the explicit brief.</span>
 
@@ -96,7 +96,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="copyBriefFromFirstSentenceAsBrief"><a href="#copyBriefFromFirstSentenceAsBrief">copyBriefFromFirstSentenceAsBrief</a></h2>
+<h2 id="copyBriefFromFirstSentenceAsBrief">copyBriefFromFirstSentenceAsBrief</h2>
 <div>
 <span>This is the brief.</span>
 
@@ -116,7 +116,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="copyBriefFromFirstValid"><a href="#copyBriefFromFirstValid">copyBriefFromFirstValid</a></h2>
+<h2 id="copyBriefFromFirstValid">copyBriefFromFirstValid</h2>
 <div>
 <span>This function has documentation but no brief.</span>
 
@@ -136,7 +136,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="copyDetailsFromCopyBrief"><a href="#copyDetailsFromCopyBrief">copyDetailsFromCopyBrief</a></h2>
+<h2 id="copyDetailsFromCopyBrief">copyDetailsFromCopyBrief</h2>
 <div>
 <span>Details will be copied</span>
 
@@ -156,7 +156,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="copyDetailsFromDocNoBrief"><a href="#copyDetailsFromDocNoBrief">copyDetailsFromDocNoBrief</a></h2>
+<h2 id="copyDetailsFromDocNoBrief">copyDetailsFromDocNoBrief</h2>
 <div>
 <span>Custom brief</span>
 
@@ -176,7 +176,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="copyDetailsFromExplicitBrief"><a href="#copyDetailsFromExplicitBrief">copyDetailsFromExplicitBrief</a></h2>
+<h2 id="copyDetailsFromExplicitBrief">copyDetailsFromExplicitBrief</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -196,7 +196,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="copyDetailsFromFirstSentenceAsBrief"><a href="#copyDetailsFromFirstSentenceAsBrief">copyDetailsFromFirstSentenceAsBrief</a></h2>
+<h2 id="copyDetailsFromFirstSentenceAsBrief">copyDetailsFromFirstSentenceAsBrief</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -216,7 +216,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="copyDetailsFromNoDoc"><a href="#copyDetailsFromNoDoc">copyDetailsFromNoDoc</a></h2>
+<h2 id="copyDetailsFromNoDoc">copyDetailsFromNoDoc</h2>
 <div>
 <span>Custom brief</span>
 
@@ -236,7 +236,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="copyDocFromCopyBrief"><a href="#copyDocFromCopyBrief">copyDocFromCopyBrief</a></h2>
+<h2 id="copyDocFromCopyBrief">copyDocFromCopyBrief</h2>
 <div>
 <span>This is the explicit brief.</span>
 
@@ -260,7 +260,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="copyDocFromExplicitBrief"><a href="#copyDocFromExplicitBrief">copyDocFromExplicitBrief</a></h2>
+<h2 id="copyDocFromExplicitBrief">copyDocFromExplicitBrief</h2>
 <div>
 <span>This is the explicit brief.</span>
 
@@ -284,7 +284,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="copyDocFromFirstSentenceAsBrief"><a href="#copyDocFromFirstSentenceAsBrief">copyDocFromFirstSentenceAsBrief</a></h2>
+<h2 id="copyDocFromFirstSentenceAsBrief">copyDocFromFirstSentenceAsBrief</h2>
 <div>
 <span>This is the brief.</span>
 
@@ -308,7 +308,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="docNoBriefFunction"><a href="#docNoBriefFunction">docNoBriefFunction</a></h2>
+<h2 id="docNoBriefFunction">docNoBriefFunction</h2>
 <div>
 <span>This function has documentation but no brief.</span>
 
@@ -328,7 +328,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="explicitBriefFunction"><a href="#explicitBriefFunction">explicitBriefFunction</a></h2>
+<h2 id="explicitBriefFunction">explicitBriefFunction</h2>
 <div>
 <span>This is the explicit brief.</span>
 
@@ -352,7 +352,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="explicitBriefFunction2"><a href="#explicitBriefFunction2">explicitBriefFunction2</a></h2>
+<h2 id="explicitBriefFunction2">explicitBriefFunction2</h2>
 <div>
 <span>This is the explicit brief.</span>
 
@@ -376,7 +376,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="failCircularReferenceCopyFunction"><a href="#failCircularReferenceCopyFunction">failCircularReferenceCopyFunction</a></h2>
+<h2 id="failCircularReferenceCopyFunction">failCircularReferenceCopyFunction</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -392,7 +392,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="failCircularSourceFunctionA"><a href="#failCircularSourceFunctionA">failCircularSourceFunctionA</a></h2>
+<h2 id="failCircularSourceFunctionA">failCircularSourceFunctionA</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -408,7 +408,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="failCircularSourceFunctionB"><a href="#failCircularSourceFunctionB">failCircularSourceFunctionB</a></h2>
+<h2 id="failCircularSourceFunctionB">failCircularSourceFunctionB</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -424,7 +424,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="failCopyBriefFromDocNoBrief"><a href="#failCopyBriefFromDocNoBrief">failCopyBriefFromDocNoBrief</a></h2>
+<h2 id="failCopyBriefFromDocNoBrief">failCopyBriefFromDocNoBrief</h2>
 <div>
 <span>This function has documentation but no brief.</span>
 
@@ -444,7 +444,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="failCopyBriefFromInvalidReference"><a href="#failCopyBriefFromInvalidReference">failCopyBriefFromInvalidReference</a></h2>
+<h2 id="failCopyBriefFromInvalidReference">failCopyBriefFromInvalidReference</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -460,7 +460,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="failCopyBriefFromNoDoc"><a href="#failCopyBriefFromNoDoc">failCopyBriefFromNoDoc</a></h2>
+<h2 id="failCopyBriefFromNoDoc">failCopyBriefFromNoDoc</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -476,7 +476,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="failCopyDetailsFromInvalidReference"><a href="#failCopyDetailsFromInvalidReference">failCopyDetailsFromInvalidReference</a></h2>
+<h2 id="failCopyDetailsFromInvalidReference">failCopyDetailsFromInvalidReference</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -492,7 +492,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="failCopyDocFromDocNoBrief"><a href="#failCopyDocFromDocNoBrief">failCopyDocFromDocNoBrief</a></h2>
+<h2 id="failCopyDocFromDocNoBrief">failCopyDocFromDocNoBrief</h2>
 <div>
 <span>This function has documentation but no brief.</span>
 
@@ -512,7 +512,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="failCopyDocFromInvalidReference"><a href="#failCopyDocFromInvalidReference">failCopyDocFromInvalidReference</a></h2>
+<h2 id="failCopyDocFromInvalidReference">failCopyDocFromInvalidReference</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -528,7 +528,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="failCopyDocFromNoDoc"><a href="#failCopyDocFromNoDoc">failCopyDocFromNoDoc</a></h2>
+<h2 id="failCopyDocFromNoDoc">failCopyDocFromNoDoc</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -544,7 +544,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="failInvalidReferenceCopyFunctions"><a href="#failInvalidReferenceCopyFunctions">failInvalidReferenceCopyFunctions</a></h2>
+<h2 id="failInvalidReferenceCopyFunctions">failInvalidReferenceCopyFunctions</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -560,7 +560,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="firstSentenceAsBriefFunction"><a href="#firstSentenceAsBriefFunction">firstSentenceAsBriefFunction</a></h2>
+<h2 id="firstSentenceAsBriefFunction">firstSentenceAsBriefFunction</h2>
 <div>
 <span>This is the brief.</span>
 
@@ -584,7 +584,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="noDocFunction"><a href="#noDocFunction">noDocFunction</a></h2>
+<h2 id="noDocFunction">noDocFunction</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -600,7 +600,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="recursiveReferenceCopyFunction"><a href="#recursiveReferenceCopyFunction">recursiveReferenceCopyFunction</a></h2>
+<h2 id="recursiveReferenceCopyFunction">recursiveReferenceCopyFunction</h2>
 <div>
 <span>Final recursive brief</span>
 
@@ -620,7 +620,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="recursiveSourceFunctionA"><a href="#recursiveSourceFunctionA">recursiveSourceFunctionA</a></h2>
+<h2 id="recursiveSourceFunctionA">recursiveSourceFunctionA</h2>
 <div>
 <span>Final recursive brief</span>
 
@@ -640,7 +640,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="recursiveSourceFunctionB"><a href="#recursiveSourceFunctionB">recursiveSourceFunctionB</a></h2>
+<h2 id="recursiveSourceFunctionB">recursiveSourceFunctionB</h2>
 <div>
 <span>Final recursive brief</span>
 
diff --git a/test-files/golden-tests/config/auto-brief/no-auto-brief.html b/test-files/golden-tests/config/auto-brief/no-auto-brief.html
index bfeb14222..9e0553b81 100644
--- a/test-files/golden-tests/config/auto-brief/no-auto-brief.html
+++ b/test-files/golden-tests/config/auto-brief/no-auto-brief.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -56,7 +56,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="copyBriefFromCopyBrief"><a href="#copyBriefFromCopyBrief">copyBriefFromCopyBrief</a></h2>
+<h2 id="copyBriefFromCopyBrief">copyBriefFromCopyBrief</h2>
 <div>
 <span>This is the explicit brief.</span>
 
@@ -76,7 +76,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="copyBriefFromExplicitBrief"><a href="#copyBriefFromExplicitBrief">copyBriefFromExplicitBrief</a></h2>
+<h2 id="copyBriefFromExplicitBrief">copyBriefFromExplicitBrief</h2>
 <div>
 <span>This is the explicit brief.</span>
 
@@ -96,7 +96,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="copyBriefFromFirstSentenceAsBrief"><a href="#copyBriefFromFirstSentenceAsBrief">copyBriefFromFirstSentenceAsBrief</a></h2>
+<h2 id="copyBriefFromFirstSentenceAsBrief">copyBriefFromFirstSentenceAsBrief</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -112,7 +112,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="copyBriefFromFirstValid"><a href="#copyBriefFromFirstValid">copyBriefFromFirstValid</a></h2>
+<h2 id="copyBriefFromFirstValid">copyBriefFromFirstValid</h2>
 <div>
 <span>This is the explicit brief.</span>
 
@@ -132,7 +132,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="copyDetailsFromCopyBrief"><a href="#copyDetailsFromCopyBrief">copyDetailsFromCopyBrief</a></h2>
+<h2 id="copyDetailsFromCopyBrief">copyDetailsFromCopyBrief</h2>
 <div>
 <span>Details will be copied</span>
 
@@ -152,7 +152,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="copyDetailsFromDocNoBrief"><a href="#copyDetailsFromDocNoBrief">copyDetailsFromDocNoBrief</a></h2>
+<h2 id="copyDetailsFromDocNoBrief">copyDetailsFromDocNoBrief</h2>
 <div>
 <span>Custom brief</span>
 
@@ -172,7 +172,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="copyDetailsFromExplicitBrief"><a href="#copyDetailsFromExplicitBrief">copyDetailsFromExplicitBrief</a></h2>
+<h2 id="copyDetailsFromExplicitBrief">copyDetailsFromExplicitBrief</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -192,7 +192,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="copyDetailsFromFirstSentenceAsBrief"><a href="#copyDetailsFromFirstSentenceAsBrief">copyDetailsFromFirstSentenceAsBrief</a></h2>
+<h2 id="copyDetailsFromFirstSentenceAsBrief">copyDetailsFromFirstSentenceAsBrief</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -213,7 +213,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="copyDetailsFromNoDoc"><a href="#copyDetailsFromNoDoc">copyDetailsFromNoDoc</a></h2>
+<h2 id="copyDetailsFromNoDoc">copyDetailsFromNoDoc</h2>
 <div>
 <span>Custom brief</span>
 
@@ -233,7 +233,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="copyDocFromCopyBrief"><a href="#copyDocFromCopyBrief">copyDocFromCopyBrief</a></h2>
+<h2 id="copyDocFromCopyBrief">copyDocFromCopyBrief</h2>
 <div>
 <span>This is the explicit brief.</span>
 
@@ -257,7 +257,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="copyDocFromExplicitBrief"><a href="#copyDocFromExplicitBrief">copyDocFromExplicitBrief</a></h2>
+<h2 id="copyDocFromExplicitBrief">copyDocFromExplicitBrief</h2>
 <div>
 <span>This is the explicit brief.</span>
 
@@ -281,7 +281,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="copyDocFromFirstSentenceAsBrief"><a href="#copyDocFromFirstSentenceAsBrief">copyDocFromFirstSentenceAsBrief</a></h2>
+<h2 id="copyDocFromFirstSentenceAsBrief">copyDocFromFirstSentenceAsBrief</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -302,7 +302,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="docNoBriefFunction"><a href="#docNoBriefFunction">docNoBriefFunction</a></h2>
+<h2 id="docNoBriefFunction">docNoBriefFunction</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -322,7 +322,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="explicitBriefFunction"><a href="#explicitBriefFunction">explicitBriefFunction</a></h2>
+<h2 id="explicitBriefFunction">explicitBriefFunction</h2>
 <div>
 <span>This is the explicit brief.</span>
 
@@ -346,7 +346,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="explicitBriefFunction2"><a href="#explicitBriefFunction2">explicitBriefFunction2</a></h2>
+<h2 id="explicitBriefFunction2">explicitBriefFunction2</h2>
 <div>
 <span>This is the explicit brief.</span>
 
@@ -370,7 +370,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="failCircularReferenceCopyFunction"><a href="#failCircularReferenceCopyFunction">failCircularReferenceCopyFunction</a></h2>
+<h2 id="failCircularReferenceCopyFunction">failCircularReferenceCopyFunction</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -386,7 +386,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="failCircularSourceFunctionA"><a href="#failCircularSourceFunctionA">failCircularSourceFunctionA</a></h2>
+<h2 id="failCircularSourceFunctionA">failCircularSourceFunctionA</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -402,7 +402,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="failCircularSourceFunctionB"><a href="#failCircularSourceFunctionB">failCircularSourceFunctionB</a></h2>
+<h2 id="failCircularSourceFunctionB">failCircularSourceFunctionB</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -418,7 +418,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="failCopyBriefFromDocNoBrief"><a href="#failCopyBriefFromDocNoBrief">failCopyBriefFromDocNoBrief</a></h2>
+<h2 id="failCopyBriefFromDocNoBrief">failCopyBriefFromDocNoBrief</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -434,7 +434,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="failCopyBriefFromInvalidReference"><a href="#failCopyBriefFromInvalidReference">failCopyBriefFromInvalidReference</a></h2>
+<h2 id="failCopyBriefFromInvalidReference">failCopyBriefFromInvalidReference</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -450,7 +450,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="failCopyBriefFromNoDoc"><a href="#failCopyBriefFromNoDoc">failCopyBriefFromNoDoc</a></h2>
+<h2 id="failCopyBriefFromNoDoc">failCopyBriefFromNoDoc</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -466,7 +466,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="failCopyDetailsFromInvalidReference"><a href="#failCopyDetailsFromInvalidReference">failCopyDetailsFromInvalidReference</a></h2>
+<h2 id="failCopyDetailsFromInvalidReference">failCopyDetailsFromInvalidReference</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -482,7 +482,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="failCopyDocFromDocNoBrief"><a href="#failCopyDocFromDocNoBrief">failCopyDocFromDocNoBrief</a></h2>
+<h2 id="failCopyDocFromDocNoBrief">failCopyDocFromDocNoBrief</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -502,7 +502,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="failCopyDocFromInvalidReference"><a href="#failCopyDocFromInvalidReference">failCopyDocFromInvalidReference</a></h2>
+<h2 id="failCopyDocFromInvalidReference">failCopyDocFromInvalidReference</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -518,7 +518,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="failCopyDocFromNoDoc"><a href="#failCopyDocFromNoDoc">failCopyDocFromNoDoc</a></h2>
+<h2 id="failCopyDocFromNoDoc">failCopyDocFromNoDoc</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -534,7 +534,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="failInvalidReferenceCopyFunctions"><a href="#failInvalidReferenceCopyFunctions">failInvalidReferenceCopyFunctions</a></h2>
+<h2 id="failInvalidReferenceCopyFunctions">failInvalidReferenceCopyFunctions</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -550,7 +550,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="firstSentenceAsBriefFunction"><a href="#firstSentenceAsBriefFunction">firstSentenceAsBriefFunction</a></h2>
+<h2 id="firstSentenceAsBriefFunction">firstSentenceAsBriefFunction</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -571,7 +571,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="noDocFunction"><a href="#noDocFunction">noDocFunction</a></h2>
+<h2 id="noDocFunction">noDocFunction</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -587,7 +587,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="recursiveReferenceCopyFunction"><a href="#recursiveReferenceCopyFunction">recursiveReferenceCopyFunction</a></h2>
+<h2 id="recursiveReferenceCopyFunction">recursiveReferenceCopyFunction</h2>
 <div>
 <span>Final recursive brief</span>
 
@@ -607,7 +607,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="recursiveSourceFunctionA"><a href="#recursiveSourceFunctionA">recursiveSourceFunctionA</a></h2>
+<h2 id="recursiveSourceFunctionA">recursiveSourceFunctionA</h2>
 <div>
 <span>Final recursive brief</span>
 
@@ -627,7 +627,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="recursiveSourceFunctionB"><a href="#recursiveSourceFunctionB">recursiveSourceFunctionB</a></h2>
+<h2 id="recursiveSourceFunctionB">recursiveSourceFunctionB</h2>
 <div>
 <span>Final recursive brief</span>
 
diff --git a/test-files/golden-tests/config/auto-function-metadata/brief-from-function-class.html b/test-files/golden-tests/config/auto-function-metadata/brief-from-function-class.html
index c805d70c3..75326725d 100644
--- a/test-files/golden-tests/config/auto-function-metadata/brief-from-function-class.html
+++ b/test-files/golden-tests/config/auto-function-metadata/brief-from-function-class.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -27,7 +27,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 <div>
 <span>A helper tag</span>
 
@@ -48,7 +48,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X"><a href="#X">X</a></h2>
+<h2 id="X">X</h2>
 <div>
 <span>Test class</span>
 
@@ -86,7 +86,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor-08"><a href="#X-2constructor-08">X::X</a></h2>
+<h2 id="X-2constructor-08">X::X</h2>
 <div>
 <span>Constructors</span>
 
@@ -146,7 +146,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor-0e8"><a href="#X-2constructor-0e8">X::X</a></h2>
+<h2 id="X-2constructor-0e8">X::X</h2>
 <div>
 <span>Default constructor</span>
 
@@ -166,7 +166,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor-0e0"><a href="#X-2constructor-0e0">X::X</a></h2>
+<h2 id="X-2constructor-0e0">X::X</h2>
 <div>
 <span>Copy constructor</span>
 
@@ -203,7 +203,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor-06"><a href="#X-2constructor-06">X::X</a></h2>
+<h2 id="X-2constructor-06">X::X</h2>
 <div>
 <span>Move constructor</span>
 
@@ -240,7 +240,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor-07"><a href="#X-2constructor-07">X::X</a></h2>
+<h2 id="X-2constructor-07">X::X</h2>
 <div>
 <span>Construct from <code>int</code></span>
 
@@ -276,7 +276,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor-0b"><a href="#X-2constructor-0b">X::X</a></h2>
+<h2 id="X-2constructor-0b">X::X</h2>
 <div>
 <span>Construct from <code>A</code></span>
 
@@ -312,7 +312,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor-00"><a href="#X-2constructor-00">X::X</a></h2>
+<h2 id="X-2constructor-00">X::X</h2>
 <div>
 <span>Construct from <code>A</code></span>
 
@@ -348,7 +348,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2destructor"><a href="#X-2destructor">X::~X</a></h2>
+<h2 id="X-2destructor">X::~X</h2>
 <div>
 <span>Destructor</span>
 
@@ -367,7 +367,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2conversion-00"><a href="#X-2conversion-00">X::operator A</a></h2>
+<h2 id="X-2conversion-00">X::operator A</h2>
 <div>
 <span>Conversion to <code>A</code></span>
 
@@ -390,7 +390,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2conversion-0b"><a href="#X-2conversion-0b">X::operator int</a></h2>
+<h2 id="X-2conversion-0b">X::operator int</h2>
 <div>
 <span>Conversion to <code>int</code></span>
 
diff --git a/test-files/golden-tests/config/auto-function-metadata/brief-from-operator.html b/test-files/golden-tests/config/auto-function-metadata/brief-from-operator.html
index e494d0fcd..99f4a1f7d 100644
--- a/test-files/golden-tests/config/auto-function-metadata/brief-from-operator.html
+++ b/test-files/golden-tests/config/auto-function-metadata/brief-from-operator.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -42,7 +42,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 <div>
 <span>A helper tag</span>
 
@@ -63,7 +63,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X"><a href="#X">X</a></h2>
+<h2 id="X">X</h2>
 <div>
 <span>Test class</span>
 
@@ -99,7 +99,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="X-operator_assign-0a"><a href="#X-operator_assign-0a">X::operator&#x3D;</a></h2>
+<h2 id="X-operator_assign-0a">X::operator&#x3D;</h2>
 <div>
 <span>Assignment operators</span>
 
@@ -138,7 +138,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_assign-06"><a href="#X-operator_assign-06">X::operator&#x3D;</a></h2>
+<h2 id="X-operator_assign-06">X::operator&#x3D;</h2>
 <div>
 <span>Copy assignment operator</span>
 
@@ -179,7 +179,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_assign-0e"><a href="#X-operator_assign-0e">X::operator&#x3D;</a></h2>
+<h2 id="X-operator_assign-0e">X::operator&#x3D;</h2>
 <div>
 <span>Move assignment operator</span>
 
@@ -220,7 +220,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_assign-0d"><a href="#X-operator_assign-0d">X::operator&#x3D;</a></h2>
+<h2 id="X-operator_assign-0d">X::operator&#x3D;</h2>
 <div>
 <span>Assignment operator</span>
 
@@ -261,7 +261,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_plus_eq"><a href="#X-operator_plus_eq">X::operator+&#x3D;</a></h2>
+<h2 id="X-operator_plus_eq">X::operator+&#x3D;</h2>
 <div>
 <span>Addition assignment operator</span>
 
@@ -302,7 +302,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="ostream"><a href="#ostream">ostream</a></h2>
+<h2 id="ostream">ostream</h2>
 <div>
 <span>A dumb ostream class</span>
 
@@ -323,7 +323,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_lshift"><a href="#operator_lshift">operator&lt;&lt;</a></h2>
+<h2 id="operator_lshift">operator&lt;&lt;</h2>
 <div>
 <span>Stream insertion operator</span>
 
diff --git a/test-files/golden-tests/config/auto-function-metadata/param-from-function-class.html b/test-files/golden-tests/config/auto-function-metadata/param-from-function-class.html
index bdcfd1f52..4c17e06fc 100644
--- a/test-files/golden-tests/config/auto-function-metadata/param-from-function-class.html
+++ b/test-files/golden-tests/config/auto-function-metadata/param-from-function-class.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -27,7 +27,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 <div>
 <span>A helper tag</span>
 
@@ -48,7 +48,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X"><a href="#X">X</a></h2>
+<h2 id="X">X</h2>
 <div>
 <span>Test class</span>
 
@@ -84,7 +84,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor-08"><a href="#X-2constructor-08">X::X</a></h2>
+<h2 id="X-2constructor-08">X::X</h2>
 <div>
 <span>Constructors</span>
 
@@ -134,7 +134,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor-0e"><a href="#X-2constructor-0e">X::X</a></h2>
+<h2 id="X-2constructor-0e">X::X</h2>
 <div>
 <span>Copy constructor</span>
 
@@ -170,7 +170,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor-06"><a href="#X-2constructor-06">X::X</a></h2>
+<h2 id="X-2constructor-06">X::X</h2>
 <div>
 <span>Move constructor</span>
 
@@ -206,7 +206,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor-07"><a href="#X-2constructor-07">X::X</a></h2>
+<h2 id="X-2constructor-07">X::X</h2>
 <div>
 <span>Construct from <code>int</code></span>
 
@@ -242,7 +242,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor-0b"><a href="#X-2constructor-0b">X::X</a></h2>
+<h2 id="X-2constructor-0b">X::X</h2>
 <div>
 <span>Construct from <code>A</code></span>
 
@@ -278,7 +278,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor-00"><a href="#X-2constructor-00">X::X</a></h2>
+<h2 id="X-2constructor-00">X::X</h2>
 <div>
 <span>Construct from <code>A</code></span>
 
@@ -314,7 +314,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_assign-0a"><a href="#X-operator_assign-0a">X::operator&#x3D;</a></h2>
+<h2 id="X-operator_assign-0a">X::operator&#x3D;</h2>
 <div>
 <span>Assignment operators</span>
 
@@ -369,7 +369,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_assign-06"><a href="#X-operator_assign-06">X::operator&#x3D;</a></h2>
+<h2 id="X-operator_assign-06">X::operator&#x3D;</h2>
 <div>
 <span>Copy assignment operator</span>
 
@@ -410,7 +410,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_assign-0e"><a href="#X-operator_assign-0e">X::operator&#x3D;</a></h2>
+<h2 id="X-operator_assign-0e">X::operator&#x3D;</h2>
 <div>
 <span>Move assignment operator</span>
 
@@ -451,7 +451,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_assign-07f"><a href="#X-operator_assign-07f">X::operator&#x3D;</a></h2>
+<h2 id="X-operator_assign-07f">X::operator&#x3D;</h2>
 <div>
 <span>Assignment operator</span>
 
@@ -492,7 +492,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_assign-0d"><a href="#X-operator_assign-0d">X::operator&#x3D;</a></h2>
+<h2 id="X-operator_assign-0d">X::operator&#x3D;</h2>
 <div>
 <span>Assignment operator</span>
 
@@ -533,7 +533,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_assign-07e"><a href="#X-operator_assign-07e">X::operator&#x3D;</a></h2>
+<h2 id="X-operator_assign-07e">X::operator&#x3D;</h2>
 <div>
 <span>Assignment operator</span>
 
diff --git a/test-files/golden-tests/config/auto-function-metadata/param-from-operator.html b/test-files/golden-tests/config/auto-function-metadata/param-from-operator.html
index 02d6797e8..bf8d60a2a 100644
--- a/test-files/golden-tests/config/auto-function-metadata/param-from-operator.html
+++ b/test-files/golden-tests/config/auto-function-metadata/param-from-operator.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -44,7 +44,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 <div>
 <span>A helper tag</span>
 
@@ -65,7 +65,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X"><a href="#X">X</a></h2>
+<h2 id="X">X</h2>
 <div>
 <span>Test class</span>
 
@@ -100,7 +100,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="X-operator_plus"><a href="#X-operator_plus">X::operator+</a></h2>
+<h2 id="X-operator_plus">X::operator+</h2>
 <div>
 <span>Addition operator</span>
 
@@ -141,7 +141,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="ostream"><a href="#ostream">ostream</a></h2>
+<h2 id="ostream">ostream</h2>
 <div>
 <span>A dumb ostream class</span>
 
@@ -162,7 +162,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_minus"><a href="#operator_minus">operator-</a></h2>
+<h2 id="operator_minus">operator-</h2>
 <div>
 <span>Subtraction operator</span>
 
@@ -209,7 +209,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_lshift"><a href="#operator_lshift">operator&lt;&lt;</a></h2>
+<h2 id="operator_lshift">operator&lt;&lt;</h2>
 <div>
 <span>Stream insertion operator</span>
 
@@ -256,7 +256,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_not"><a href="#operator_not">operator!</a></h2>
+<h2 id="operator_not">operator!</h2>
 <div>
 <span>Negation operator</span>
 
diff --git a/test-files/golden-tests/config/auto-function-metadata/returns-from-brief.html b/test-files/golden-tests/config/auto-function-metadata/returns-from-brief.html
index a96ba4557..ae649787b 100644
--- a/test-files/golden-tests/config/auto-function-metadata/returns-from-brief.html
+++ b/test-files/golden-tests/config/auto-function-metadata/returns-from-brief.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="X"><a href="#X">X</a></h2>
+<h2 id="X">X</h2>
 <div>
 <span>Test class</span>
 
@@ -63,7 +63,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="X-empty"><a href="#X-empty">X::empty</a></h2>
+<h2 id="X-empty">X::empty</h2>
 <div>
 <span>Determines whether the range is empty.</span>
 
@@ -87,7 +87,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="X-front"><a href="#X-front">X::front</a></h2>
+<h2 id="X-front">X::front</h2>
 <div>
 <span>Returns the first element of the range.</span>
 
@@ -111,7 +111,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="X-size"><a href="#X-size">X::size</a></h2>
+<h2 id="X-size">X::size</h2>
 <div>
 <span>Get the range size.</span>
 
diff --git a/test-files/golden-tests/config/auto-function-metadata/returns-from-return-brief.html b/test-files/golden-tests/config/auto-function-metadata/returns-from-return-brief.html
index 9c628cf83..ca2b4f66b 100644
--- a/test-files/golden-tests/config/auto-function-metadata/returns-from-return-brief.html
+++ b/test-files/golden-tests/config/auto-function-metadata/returns-from-return-brief.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -40,7 +40,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="R"><a href="#R">R</a></h2>
+<h2 id="R">R</h2>
 <div>
 <span>The return type of the function</span>
 
@@ -75,7 +75,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="getR"><a href="#getR">getR</a></h2>
+<h2 id="getR">getR</h2>
 <div>
 <span>Test function</span>
 
diff --git a/test-files/golden-tests/config/auto-function-metadata/returns-from-special.html b/test-files/golden-tests/config/auto-function-metadata/returns-from-special.html
index 98024861f..0fa92a3a6 100644
--- a/test-files/golden-tests/config/auto-function-metadata/returns-from-special.html
+++ b/test-files/golden-tests/config/auto-function-metadata/returns-from-special.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -51,7 +51,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 <div>
 <span>A helper class</span>
 
@@ -72,7 +72,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Undoc"><a href="#Undoc">Undoc</a></h2>
+<h2 id="Undoc">Undoc</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -89,7 +89,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X"><a href="#X">X</a></h2>
+<h2 id="X">X</h2>
 <div>
 <span>Test class</span>
 
@@ -136,7 +136,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="X-operator_assign-0a"><a href="#X-operator_assign-0a">X::operator&#x3D;</a></h2>
+<h2 id="X-operator_assign-0a">X::operator&#x3D;</h2>
 <div>
 <span>Assignment operators</span>
 
@@ -167,7 +167,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_assign-0d"><a href="#X-operator_assign-0d">X::operator&#x3D;</a></h2>
+<h2 id="X-operator_assign-0d">X::operator&#x3D;</h2>
 <div>
 <span>Assignment operator</span>
 
@@ -208,7 +208,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_assign-07"><a href="#X-operator_assign-07">X::operator&#x3D;</a></h2>
+<h2 id="X-operator_assign-07">X::operator&#x3D;</h2>
 <div>
 <span>Assignment operator</span>
 
@@ -249,7 +249,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_plus"><a href="#X-operator_plus">X::operator+</a></h2>
+<h2 id="X-operator_plus">X::operator+</h2>
 <div>
 <span>Addition operator</span>
 
@@ -290,7 +290,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_ptr"><a href="#X-operator_ptr">X::operator-&gt;</a></h2>
+<h2 id="X-operator_ptr">X::operator-&gt;</h2>
 <div>
 <span>Member access operator</span>
 
@@ -314,7 +314,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2conversion-00"><a href="#X-2conversion-00">X::operator A</a></h2>
+<h2 id="X-2conversion-00">X::operator A</h2>
 <div>
 <span>Conversion to <code>A</code></span>
 
@@ -337,7 +337,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2conversion-03"><a href="#X-2conversion-03">X::operator Undoc</a></h2>
+<h2 id="X-2conversion-03">X::operator Undoc</h2>
 <div>
 <span>Conversion to <code>Undoc</code></span>
 
@@ -360,7 +360,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_not"><a href="#X-operator_not">X::operator!</a></h2>
+<h2 id="X-operator_not">X::operator!</h2>
 <div>
 <span>Negation operator</span>
 
@@ -384,7 +384,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_eq"><a href="#X-operator_eq">X::operator&#x3D;&#x3D;</a></h2>
+<h2 id="X-operator_eq">X::operator&#x3D;&#x3D;</h2>
 <div>
 <span>Equality operator</span>
 
@@ -425,7 +425,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_not_eq"><a href="#X-operator_not_eq">X::operator!&#x3D;</a></h2>
+<h2 id="X-operator_not_eq">X::operator!&#x3D;</h2>
 <div>
 <span>Inequality operator</span>
 
@@ -466,7 +466,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_lt"><a href="#X-operator_lt">X::operator&lt;</a></h2>
+<h2 id="X-operator_lt">X::operator&lt;</h2>
 <div>
 <span>Less-than operator</span>
 
@@ -507,7 +507,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_le"><a href="#X-operator_le">X::operator&lt;&#x3D;</a></h2>
+<h2 id="X-operator_le">X::operator&lt;&#x3D;</h2>
 <div>
 <span>Less-than-or-equal operator</span>
 
@@ -548,7 +548,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_gt"><a href="#X-operator_gt">X::operator&gt;</a></h2>
+<h2 id="X-operator_gt">X::operator&gt;</h2>
 <div>
 <span>Greater-than operator</span>
 
@@ -589,7 +589,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_ge"><a href="#X-operator_ge">X::operator&gt;&#x3D;</a></h2>
+<h2 id="X-operator_ge">X::operator&gt;&#x3D;</h2>
 <div>
 <span>Greater-than-or-equal operator</span>
 
@@ -630,7 +630,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-operator_3way"><a href="#X-operator_3way">X::operator&lt;&#x3D;&gt;</a></h2>
+<h2 id="X-operator_3way">X::operator&lt;&#x3D;&gt;</h2>
 <div>
 <span>Three-way comparison operator</span>
 
@@ -671,7 +671,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="ostream"><a href="#ostream">ostream</a></h2>
+<h2 id="ostream">ostream</h2>
 <div>
 <span>A fake output stream</span>
 
@@ -692,7 +692,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_lshift"><a href="#operator_lshift">operator&lt;&lt;</a></h2>
+<h2 id="operator_lshift">operator&lt;&lt;</h2>
 <div>
 <span>Stream insertion operator</span>
 
@@ -739,7 +739,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_not"><a href="#operator_not">operator!</a></h2>
+<h2 id="operator_not">operator!</h2>
 <div>
 <span>Negation operator</span>
 
@@ -780,7 +780,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_eq"><a href="#operator_eq">operator&#x3D;&#x3D;</a></h2>
+<h2 id="operator_eq">operator&#x3D;&#x3D;</h2>
 <div>
 <span>Equality operator</span>
 
@@ -827,7 +827,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_not_eq"><a href="#operator_not_eq">operator!&#x3D;</a></h2>
+<h2 id="operator_not_eq">operator!&#x3D;</h2>
 <div>
 <span>Inequality operator</span>
 
@@ -874,7 +874,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_lt"><a href="#operator_lt">operator&lt;</a></h2>
+<h2 id="operator_lt">operator&lt;</h2>
 <div>
 <span>Less-than operator</span>
 
@@ -921,7 +921,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_le"><a href="#operator_le">operator&lt;&#x3D;</a></h2>
+<h2 id="operator_le">operator&lt;&#x3D;</h2>
 <div>
 <span>Less-than-or-equal operator</span>
 
@@ -968,7 +968,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_gt"><a href="#operator_gt">operator&gt;</a></h2>
+<h2 id="operator_gt">operator&gt;</h2>
 <div>
 <span>Greater-than operator</span>
 
@@ -1015,7 +1015,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_ge"><a href="#operator_ge">operator&gt;&#x3D;</a></h2>
+<h2 id="operator_ge">operator&gt;&#x3D;</h2>
 <div>
 <span>Greater-than-or-equal operator</span>
 
@@ -1062,7 +1062,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_3way"><a href="#operator_3way">operator&lt;&#x3D;&gt;</a></h2>
+<h2 id="operator_3way">operator&lt;&#x3D;&gt;</h2>
 <div>
 <span>Three-way comparison operator</span>
 
diff --git a/test-files/golden-tests/config/auto-relates/auto-relates.html b/test-files/golden-tests/config/auto-relates/auto-relates.html
index fc7d27d70..864536adf 100644
--- a/test-files/golden-tests/config/auto-relates/auto-relates.html
+++ b/test-files/golden-tests/config/auto-relates/auto-relates.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -45,7 +45,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 <div>
 <span>A class with non-member functions</span>
 
@@ -85,7 +85,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 <div>
 <span>A non-member function of A</span>
 
@@ -105,7 +105,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f2"><a href="#f2">f2</a></h2>
+<h2 id="f2">f2</h2>
 <div>
 <span>A non-member function of A</span>
 
@@ -125,7 +125,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f3"><a href="#f3">f3</a></h2>
+<h2 id="f3">f3</h2>
 <div>
 <span>A non-member function of A</span>
 
@@ -145,7 +145,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f4"><a href="#f4">f4</a></h2>
+<h2 id="f4">f4</h2>
 <div>
 <span>A non-member function of A</span>
 
@@ -165,7 +165,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f5"><a href="#f5">f5</a></h2>
+<h2 id="f5">f5</h2>
 <div>
 <span>A non-member function of A</span>
 
@@ -185,7 +185,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f6"><a href="#f6">f6</a></h2>
+<h2 id="f6">f6</h2>
 <div>
 <span>A non-member function of A</span>
 
diff --git a/test-files/golden-tests/config/auto-relates/derived.html b/test-files/golden-tests/config/auto-relates/derived.html
index d4789cb95..eec4965d0 100644
--- a/test-files/golden-tests/config/auto-relates/derived.html
+++ b/test-files/golden-tests/config/auto-relates/derived.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -48,7 +48,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 <div>
 <span>A concrete implementation for ABase</span>
 
@@ -102,7 +102,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="ABase"><a href="#ABase">ABase</a></h2>
+<h2 id="ABase">ABase</h2>
 <div>
 <span>A base class for non-member functions</span>
 
@@ -159,7 +159,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="AView"><a href="#AView">AView</a></h2>
+<h2 id="AView">AView</h2>
 <div>
 <span>A view of A</span>
 
@@ -228,7 +228,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="AView2"><a href="#AView2">AView2</a></h2>
+<h2 id="AView2">AView2</h2>
 <div>
 <span>Another view of A</span>
 
@@ -286,7 +286,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 <div>
 <span>A non-member function of ABase</span>
 
@@ -306,7 +306,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f2"><a href="#f2">f2</a></h2>
+<h2 id="f2">f2</h2>
 <div>
 <span>A non-member function of ABase</span>
 
@@ -326,7 +326,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f3"><a href="#f3">f3</a></h2>
+<h2 id="f3">f3</h2>
 <div>
 <span>A non-member function of ABase</span>
 
@@ -346,7 +346,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f4"><a href="#f4">f4</a></h2>
+<h2 id="f4">f4</h2>
 <div>
 <span>A non-member function of ABase</span>
 
@@ -366,7 +366,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f5"><a href="#f5">f5</a></h2>
+<h2 id="f5">f5</h2>
 <div>
 <span>A non-member function of ABase</span>
 
@@ -386,7 +386,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="n"><a href="#n">n</a></h2>
+<h2 id="n">n</h2>
 <div>
 <span>A non-member function of ABase only</span>
 
diff --git a/test-files/golden-tests/config/auto-relates/enum.html b/test-files/golden-tests/config/auto-relates/enum.html
index 3cab62b65..d7067e504 100644
--- a/test-files/golden-tests/config/auto-relates/enum.html
+++ b/test-files/golden-tests/config/auto-relates/enum.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -57,7 +57,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="Result"><a href="#Result">Result</a></h2>
+<h2 id="Result">Result</h2>
 <div>
 <span>Helper result class</span>
 
@@ -93,7 +93,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="SmallVector"><a href="#SmallVector">SmallVector</a></h2>
+<h2 id="SmallVector">SmallVector</h2>
 <div>
 <span>Helper result class</span>
 
@@ -131,7 +131,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="E"><a href="#E">E</a></h2>
+<h2 id="E">E</h2>
 <div>
 <span>An enum with non-member functions</span>
 
@@ -148,19 +148,6 @@ <h3>Synopsis</h3>
 </pre>
 </div>
 <div>
-<h3>Members</h3>
-<table>
-<thead>
-<tr>
-<th>Name</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
-</tbody>
-</table>
-</div>
-<div>
 <h2>Non-Member Functions</h2>
 <table>
 <thead>
@@ -179,7 +166,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="makeE"><a href="#makeE">makeE</a></h2>
+<h2 id="makeE">makeE</h2>
 <div>
 <span>Function that returns A</span>
 
@@ -203,7 +190,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="makeEs"><a href="#makeEs">makeEs</a></h2>
+<h2 id="makeEs">makeEs</h2>
 <div>
 <span>Function that returns template on A</span>
 
@@ -227,7 +214,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="tryMakeE"><a href="#tryMakeE">tryMakeE</a></h2>
+<h2 id="tryMakeE">tryMakeE</h2>
 <div>
 <span>Function that returns template on A</span>
 
diff --git a/test-files/golden-tests/config/auto-relates/no-auto-relates.html b/test-files/golden-tests/config/auto-relates/no-auto-relates.html
index 53634c315..cf48c0f84 100644
--- a/test-files/golden-tests/config/auto-relates/no-auto-relates.html
+++ b/test-files/golden-tests/config/auto-relates/no-auto-relates.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -45,7 +45,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 <div>
 <span>A class with non-member functions</span>
 
@@ -66,7 +66,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 <div>
 <span>A non-member function of A</span>
 
@@ -86,7 +86,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f2"><a href="#f2">f2</a></h2>
+<h2 id="f2">f2</h2>
 <div>
 <span>A non-member function of A</span>
 
@@ -106,7 +106,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f3"><a href="#f3">f3</a></h2>
+<h2 id="f3">f3</h2>
 <div>
 <span>A non-member function of A</span>
 
@@ -126,7 +126,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f4"><a href="#f4">f4</a></h2>
+<h2 id="f4">f4</h2>
 <div>
 <span>A non-member function of A</span>
 
@@ -146,7 +146,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f5"><a href="#f5">f5</a></h2>
+<h2 id="f5">f5</h2>
 <div>
 <span>A non-member function of A</span>
 
@@ -166,7 +166,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f6"><a href="#f6">f6</a></h2>
+<h2 id="f6">f6</h2>
 <div>
 <span>A non-member function of A</span>
 
diff --git a/test-files/golden-tests/config/auto-relates/qualified.html b/test-files/golden-tests/config/auto-relates/qualified.html
index 7accb4138..78c5c329d 100644
--- a/test-files/golden-tests/config/auto-relates/qualified.html
+++ b/test-files/golden-tests/config/auto-relates/qualified.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -55,7 +55,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="N"><a href="#N">N</a></h2>
+<h2 id="N">N</h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -102,7 +102,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="N-M"><a href="#N-M">N::M</a></h2>
+<h2 id="N-M">N::M</h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -121,7 +121,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="N-M-f4"><a href="#N-M-f4">N::M::f4</a></h2>
+<h2 id="N-M-f4">N::M::f4</h2>
 <div>
 <span>A non-member function of ::N::B</span>
 
@@ -141,7 +141,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="N-B"><a href="#N-B">N::B</a></h2>
+<h2 id="N-B">N::B</h2>
 <div>
 <span>A nested class with non-member functions</span>
 
@@ -179,7 +179,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="N-f2"><a href="#N-f2">N::f2</a></h2>
+<h2 id="N-f2">N::f2</h2>
 <div>
 <span>A non-member function of A</span>
 
@@ -199,7 +199,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="N-f3"><a href="#N-f3">N::f3</a></h2>
+<h2 id="N-f3">N::f3</h2>
 <div>
 <span>A non-member function of B</span>
 
@@ -219,7 +219,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="O"><a href="#O">O</a></h2>
+<h2 id="O">O</h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -238,7 +238,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="O-f6"><a href="#O-f6">O::f6</a></h2>
+<h2 id="O-f6">O::f6</h2>
 <div>
 <span>A non-member function of ::N::B</span>
 
@@ -258,7 +258,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 <div>
 <span>A class with non-member functions</span>
 
@@ -294,7 +294,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 <div>
 <span>A non-member function of A</span>
 
@@ -314,7 +314,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f5"><a href="#f5">f5</a></h2>
+<h2 id="f5">f5</h2>
 <div>
 <span>A non-member function of ::N::B</span>
 
diff --git a/test-files/golden-tests/config/auto-relates/remove-friend.html b/test-files/golden-tests/config/auto-relates/remove-friend.html
index 241554ef4..d1420b279 100644
--- a/test-files/golden-tests/config/auto-relates/remove-friend.html
+++ b/test-files/golden-tests/config/auto-relates/remove-friend.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -41,7 +41,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 <div>
 <span>A record with non-member functions</span>
 
@@ -94,7 +94,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="to_string"><a href="#to_string">to_string</a></h2>
+<h2 id="to_string">to_string</h2>
 <div>
 <span>Non-member function of A</span>
 
@@ -135,7 +135,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_eq"><a href="#operator_eq">operator&#x3D;&#x3D;</a></h2>
+<h2 id="operator_eq">operator&#x3D;&#x3D;</h2>
 <div>
 <span>Friend function not listed as non-member</span>
 
diff --git a/test-files/golden-tests/config/auto-relates/return-type.html b/test-files/golden-tests/config/auto-relates/return-type.html
index 5144ec6fb..da9cdc6dc 100644
--- a/test-files/golden-tests/config/auto-relates/return-type.html
+++ b/test-files/golden-tests/config/auto-relates/return-type.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -44,7 +44,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 <div>
 <span>A class with non-member functions</span>
 
@@ -81,7 +81,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="Result"><a href="#Result">Result</a></h2>
+<h2 id="Result">Result</h2>
 <div>
 <span>Helper result class</span>
 
@@ -117,7 +117,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="SmallVector"><a href="#SmallVector">SmallVector</a></h2>
+<h2 id="SmallVector">SmallVector</h2>
 <div>
 <span>Helper result class</span>
 
@@ -155,7 +155,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="makeA"><a href="#makeA">makeA</a></h2>
+<h2 id="makeA">makeA</h2>
 <div>
 <span>Function that returns A</span>
 
@@ -179,7 +179,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="makeAs"><a href="#makeAs">makeAs</a></h2>
+<h2 id="makeAs">makeAs</h2>
 <div>
 <span>Function that returns template on A</span>
 
@@ -203,7 +203,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="tryMakeA"><a href="#tryMakeA">tryMakeA</a></h2>
+<h2 id="tryMakeA">tryMakeA</h2>
 <div>
 <span>Function that returns template on A</span>
 
diff --git a/test-files/golden-tests/config/extract-all/no-extract-all.html b/test-files/golden-tests/config/extract-all/no-extract-all.html
index c3cc86fa6..9e1d32b46 100644
--- a/test-files/golden-tests/config/extract-all/no-extract-all.html
+++ b/test-files/golden-tests/config/extract-all/no-extract-all.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -27,7 +27,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="docFunction"><a href="#docFunction">docFunction</a></h2>
+<h2 id="docFunction">docFunction</h2>
 <div>
 <span>Documented function</span>
 
@@ -47,7 +47,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="sometimesDocFunction"><a href="#sometimesDocFunction">sometimesDocFunction</a></h2>
+<h2 id="sometimesDocFunction">sometimesDocFunction</h2>
 <div>
 <span>Sometimes documented function</span>
 
diff --git a/test-files/golden-tests/config/extract-empty-namespaces/no-extract-empty-namespaces.html b/test-files/golden-tests/config/extract-empty-namespaces/no-extract-empty-namespaces.html
index e5c32d76a..f86f17833 100644
--- a/test-files/golden-tests/config/extract-empty-namespaces/no-extract-empty-namespaces.html
+++ b/test-files/golden-tests/config/extract-empty-namespaces/no-extract-empty-namespaces.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -63,7 +63,7 @@ <h2>Using Namespace Directives</h2>
 </div>
 <div>
 <div>
-<h2 id="documented_ns"><a href="#documented_ns">documented_ns</a></h2>
+<h2 id="documented_ns">documented_ns</h2>
 <div>
 <span>Namespace documentation</span>
 
@@ -72,7 +72,7 @@ <h2 id="documented_ns"><a href="#documented_ns">documented_ns</a></h2>
 </div>
 <div>
 <div>
-<h2 id="mixed_ns"><a href="#mixed_ns">mixed_ns</a></h2>
+<h2 id="mixed_ns">mixed_ns</h2>
 <div>
 <span>Should decay to see-below</span>
 
@@ -94,7 +94,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="mixed_ns-SeeBelowStructA"><a href="#mixed_ns-SeeBelowStructA">mixed_ns::SeeBelowStructA</a></h2>
+<h2 id="mixed_ns-SeeBelowStructA">mixed_ns::SeeBelowStructA</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -111,7 +111,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="mixed_regular_ns"><a href="#mixed_regular_ns">mixed_regular_ns</a></h2>
+<h2 id="mixed_regular_ns">mixed_regular_ns</h2>
 <div>
 <span>Should decay to regular</span>
 
@@ -134,7 +134,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="mixed_regular_ns-RegularStructA"><a href="#mixed_regular_ns-RegularStructA">mixed_regular_ns::RegularStructA</a></h2>
+<h2 id="mixed_regular_ns-RegularStructA">mixed_regular_ns::RegularStructA</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -151,7 +151,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="mixed_regular_ns-SeeBelowStructB"><a href="#mixed_regular_ns-SeeBelowStructB">mixed_regular_ns::SeeBelowStructB</a></h2>
+<h2 id="mixed_regular_ns-SeeBelowStructB">mixed_regular_ns::SeeBelowStructB</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -168,7 +168,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="regular_ns"><a href="#regular_ns">regular_ns</a></h2>
+<h2 id="regular_ns">regular_ns</h2>
 <div>
 <span>Regular namespace</span>
 
@@ -190,7 +190,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="regular_ns-A"><a href="#regular_ns-A">regular_ns::A</a></h2>
+<h2 id="regular_ns-A">regular_ns::A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -207,7 +207,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="see_below_ns"><a href="#see_below_ns">see_below_ns</a></h2>
+<h2 id="see_below_ns">see_below_ns</h2>
 <div>
 <span>Should decay to see-below</span>
 
@@ -230,7 +230,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="see_below_ns-SeeBelowStructA"><a href="#see_below_ns-SeeBelowStructA">see_below_ns::SeeBelowStructA</a></h2>
+<h2 id="see_below_ns-SeeBelowStructA">see_below_ns::SeeBelowStructA</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -247,7 +247,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="see_below_ns-SeeBelowStructB"><a href="#see_below_ns-SeeBelowStructB">see_below_ns::SeeBelowStructB</a></h2>
+<h2 id="see_below_ns-SeeBelowStructB">see_below_ns::SeeBelowStructB</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -264,7 +264,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="empty_ns_alias"><a href="#empty_ns_alias">empty_ns_alias</a></h2>
+<h2 id="empty_ns_alias">empty_ns_alias</h2>
 <div>
 <span>Should still work</span>
 
@@ -283,7 +283,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="regular_ns_alias"><a href="#regular_ns_alias">regular_ns_alias</a></h2>
+<h2 id="regular_ns_alias">regular_ns_alias</h2>
 <div>
 <span>Should work</span>
 
diff --git a/test-files/golden-tests/config/extract-friends/extract-friends.html b/test-files/golden-tests/config/extract-friends/extract-friends.html
index 742f55901..a3d3a6dcd 100644
--- a/test-files/golden-tests/config/extract-friends/extract-friends.html
+++ b/test-files/golden-tests/config/extract-friends/extract-friends.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -38,7 +38,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="std"><a href="#std">std</a></h2>
+<h2 id="std">std</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -57,7 +57,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="std-hash-03"><a href="#std-hash-03">std::hash</a></h2>
+<h2 id="std-hash-03">std::hash</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -75,7 +75,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="std-hash-08"><a href="#std-hash-08">std::hash&lt;A&gt;</a></h2>
+<h2 id="std-hash-08">std::hash&lt;A&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -106,7 +106,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="std-hash-08-operator_call"><a href="#std-hash-08-operator_call">std::hash&lt;A&gt;::operator()</a></h2>
+<h2 id="std-hash-08-operator_call">std::hash&lt;A&gt;::operator()</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -122,7 +122,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/config/extract-friends/no-extract-friends.html b/test-files/golden-tests/config/extract-friends/no-extract-friends.html
index 3731e0aaf..39b59f654 100644
--- a/test-files/golden-tests/config/extract-friends/no-extract-friends.html
+++ b/test-files/golden-tests/config/extract-friends/no-extract-friends.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -38,7 +38,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="std"><a href="#std">std</a></h2>
+<h2 id="std">std</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -57,7 +57,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="std-hash-03"><a href="#std-hash-03">std::hash</a></h2>
+<h2 id="std-hash-03">std::hash</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -75,7 +75,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="std-hash-08"><a href="#std-hash-08">std::hash&lt;A&gt;</a></h2>
+<h2 id="std-hash-08">std::hash&lt;A&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -106,7 +106,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="std-hash-08-operator_call"><a href="#std-hash-08-operator_call">std::hash&lt;A&gt;::operator()</a></h2>
+<h2 id="std-hash-08-operator_call">std::hash&lt;A&gt;::operator()</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -122,7 +122,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/config/extract-implicit-specializations/base.html b/test-files/golden-tests/config/extract-implicit-specializations/base.html
index 5e2905ddd..080cd6166 100644
--- a/test-files/golden-tests/config/extract-implicit-specializations/base.html
+++ b/test-files/golden-tests/config/extract-implicit-specializations/base.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -71,7 +71,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -116,7 +116,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="B-value"><a href="#B-value">B::value</a></h2>
+<h2 id="B-value">B::value</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/config/extract-implicit-specializations/extract-implicit-specializations.html b/test-files/golden-tests/config/extract-implicit-specializations/extract-implicit-specializations.html
index ad404c9c2..a0445f7d8 100644
--- a/test-files/golden-tests/config/extract-implicit-specializations/extract-implicit-specializations.html
+++ b/test-files/golden-tests/config/extract-implicit-specializations/extract-implicit-specializations.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -71,7 +71,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-value"><a href="#A-value">A::value</a></h2>
+<h2 id="A-value">A::value</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -87,7 +87,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-00"><a href="#B-00">B</a></h2>
+<h2 id="B-00">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -133,7 +133,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="B-00-value"><a href="#B-00-value">B::value</a></h2>
+<h2 id="B-00-value">B::value</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/config/extract-implicit-specializations/no-extract-implicit-specializations.html b/test-files/golden-tests/config/extract-implicit-specializations/no-extract-implicit-specializations.html
index 59225a6f8..a74e7f1bd 100644
--- a/test-files/golden-tests/config/extract-implicit-specializations/no-extract-implicit-specializations.html
+++ b/test-files/golden-tests/config/extract-implicit-specializations/no-extract-implicit-specializations.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -71,7 +71,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -117,7 +117,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="B-value"><a href="#B-value">B::value</a></h2>
+<h2 id="B-value">B::value</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/config/extract-local-classes/extract-local-classes.html b/test-files/golden-tests/config/extract-local-classes/extract-local-classes.html
index ce9cb036d..76f34a006 100644
--- a/test-files/golden-tests/config/extract-local-classes/extract-local-classes.html
+++ b/test-files/golden-tests/config/extract-local-classes/extract-local-classes.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -39,7 +39,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="local_class"><a href="#local_class">local_class</a></h2>
+<h2 id="local_class">local_class</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -56,7 +56,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="local_struct"><a href="#local_struct">local_struct</a></h2>
+<h2 id="local_struct">local_struct</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -73,7 +73,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="local_function"><a href="#local_function">local_function</a></h2>
+<h2 id="local_function">local_function</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/config/extract-local-classes/no-extract-local-classes.html b/test-files/golden-tests/config/extract-local-classes/no-extract-local-classes.html
index 1d1fbd801..cd05f7b23 100644
--- a/test-files/golden-tests/config/extract-local-classes/no-extract-local-classes.html
+++ b/test-files/golden-tests/config/extract-local-classes/no-extract-local-classes.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="local_function"><a href="#local_function">local_function</a></h2>
+<h2 id="local_function">local_function</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/config/extract-private-virtual/extract-private-virtual.html b/test-files/golden-tests/config/extract-private-virtual/extract-private-virtual.html
index 2395664d6..6e01f1352 100644
--- a/test-files/golden-tests/config/extract-private-virtual/extract-private-virtual.html
+++ b/test-files/golden-tests/config/extract-private-virtual/extract-private-virtual.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -68,7 +68,7 @@ <h2>Private Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-f"><a href="#A-f">A::f</a></h2>
+<h2 id="A-f">A::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -85,7 +85,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-g"><a href="#A-g">A::g</a></h2>
+<h2 id="A-g">A::g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/config/extract-private-virtual/no-extract-private-virtual.html b/test-files/golden-tests/config/extract-private-virtual/no-extract-private-virtual.html
index cae3b7be9..a793a0559 100644
--- a/test-files/golden-tests/config/extract-private-virtual/no-extract-private-virtual.html
+++ b/test-files/golden-tests/config/extract-private-virtual/no-extract-private-virtual.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -55,7 +55,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-f"><a href="#A-f">A::f</a></h2>
+<h2 id="A-f">A::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/config/inherit-base-members/base-overload-set.html b/test-files/golden-tests/config/inherit-base-members/base-overload-set.html
index b03a96e25..52b355ad6 100644
--- a/test-files/golden-tests/config/inherit-base-members/base-overload-set.html
+++ b/test-files/golden-tests/config/inherit-base-members/base-overload-set.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -27,7 +27,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="Base"><a href="#Base">Base</a></h2>
+<h2 id="Base">Base</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -88,7 +88,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="Base-foo-04"><a href="#Base-foo-04">Base::foo</a></h2>
+<h2 id="Base-foo-04">Base::foo</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -115,7 +115,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="Base-foo-0a"><a href="#Base-foo-0a">Base::foo</a></h2>
+<h2 id="Base-foo-0a">Base::foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -131,7 +131,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Base-foo-08"><a href="#Base-foo-08">Base::foo</a></h2>
+<h2 id="Base-foo-08">Base::foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -147,7 +147,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C"><a href="#C">C</a></h2>
+<h2 id="C">C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -193,7 +193,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="ConstBase"><a href="#ConstBase">ConstBase</a></h2>
+<h2 id="ConstBase">ConstBase</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -238,7 +238,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="ConstBase-foo"><a href="#ConstBase-foo">ConstBase::foo</a></h2>
+<h2 id="ConstBase-foo">ConstBase::foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/config/inherit-base-members/copy-dependencies.html b/test-files/golden-tests/config/inherit-base-members/copy-dependencies.html
index a1576424a..049110be7 100644
--- a/test-files/golden-tests/config/inherit-base-members/copy-dependencies.html
+++ b/test-files/golden-tests/config/inherit-base-members/copy-dependencies.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -30,7 +30,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="base"><a href="#base">base</a></h2>
+<h2 id="base">base</h2>
 <div>
 <span>A base class to test inheritance and shadowing</span>
 
@@ -115,7 +115,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="base-base_inherited"><a href="#base-base_inherited">base::base_inherited</a></h2>
+<h2 id="base-base_inherited">base::base_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -139,7 +139,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-base_shadowed"><a href="#base-base_shadowed">base::base_shadowed</a></h2>
+<h2 id="base-base_shadowed">base::base_shadowed</h2>
 <div>
 <span>This function should shadow the excluded_base function.</span>
 
@@ -163,7 +163,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-derived_shadowed"><a href="#base-derived_shadowed">base::derived_shadowed</a></h2>
+<h2 id="base-derived_shadowed">base::derived_shadowed</h2>
 <div>
 <span>This function should be shadowed by derived classes.</span>
 
@@ -187,7 +187,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-do_base_inherited"><a href="#base-do_base_inherited">base::do_base_inherited</a></h2>
+<h2 id="base-do_base_inherited">base::do_base_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -211,7 +211,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-do_base_shadowed"><a href="#base-do_base_shadowed">base::do_base_shadowed</a></h2>
+<h2 id="base-do_base_shadowed">base::do_base_shadowed</h2>
 <div>
 <span>This function should shadow the excluded_base function.</span>
 
@@ -235,7 +235,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-do_derived_shadowed"><a href="#base-do_derived_shadowed">base::do_derived_shadowed</a></h2>
+<h2 id="base-do_derived_shadowed">base::do_derived_shadowed</h2>
 <div>
 <span>This function should be shadowed by derived classes.</span>
 
@@ -259,7 +259,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base_base"><a href="#base_base">base_base</a></h2>
+<h2 id="base_base">base_base</h2>
 <div>
 <span>A second-order base class to test indirect inheritance</span>
 
@@ -310,7 +310,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="base_base-base_base_inherited"><a href="#base_base-base_base_inherited">base_base::base_base_inherited</a></h2>
+<h2 id="base_base-base_base_inherited">base_base::base_base_inherited</h2>
 <div>
 <span>This function should be indirectly inherited by derived classes.</span>
 
@@ -334,7 +334,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base_base-do_base_base_inherited"><a href="#base_base-do_base_base_inherited">base_base::do_base_base_inherited</a></h2>
+<h2 id="base_base-do_base_base_inherited">base_base::do_base_base_inherited</h2>
 <div>
 <span>This function should be indirectly inherited by derived classes.</span>
 
@@ -358,7 +358,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="derived"><a href="#derived">derived</a></h2>
+<h2 id="derived">derived</h2>
 <div>
 <span>A class that derives from base and excluded_base</span>
 
@@ -434,7 +434,7 @@ <h2>Protected Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="derived-derived_shadowed"><a href="#derived-derived_shadowed">derived::derived_shadowed</a></h2>
+<h2 id="derived-derived_shadowed">derived::derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -458,7 +458,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-do_derived_shadowed"><a href="#derived-do_derived_shadowed">derived::do_derived_shadowed</a></h2>
+<h2 id="derived-do_derived_shadowed">derived::do_derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -482,7 +482,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-excluded_inherited"><a href="#derived-excluded_inherited">derived::excluded_inherited</a></h2>
+<h2 id="derived-excluded_inherited">derived::excluded_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -502,7 +502,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-do_excluded_inherited"><a href="#derived-do_excluded_inherited">derived::do_excluded_inherited</a></h2>
+<h2 id="derived-do_excluded_inherited">derived::do_excluded_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -522,7 +522,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-do_shadowed"><a href="#derived-do_shadowed">derived::do_shadowed</a></h2>
+<h2 id="derived-do_shadowed">derived::do_shadowed</h2>
 <div>
 <span>This function should be shadowed by derived classes.</span>
 
@@ -542,7 +542,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="private_derived"><a href="#private_derived">private_derived</a></h2>
+<h2 id="private_derived">private_derived</h2>
 <div>
 <span>A class that uses private inheritance only</span>
 
@@ -580,7 +580,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="private_derived-derived_shadowed"><a href="#private_derived-derived_shadowed">private_derived::derived_shadowed</a></h2>
+<h2 id="private_derived-derived_shadowed">private_derived::derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -604,7 +604,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="private_derived-do_derived_shadowed"><a href="#private_derived-do_derived_shadowed">private_derived::do_derived_shadowed</a></h2>
+<h2 id="private_derived-do_derived_shadowed">private_derived::do_derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -628,7 +628,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived"><a href="#protected_derived">protected_derived</a></h2>
+<h2 id="protected_derived">protected_derived</h2>
 <div>
 <span>A class that should inherit functions as protected.</span>
 
@@ -705,7 +705,7 @@ <h2>Protected Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-derived_shadowed"><a href="#protected_derived-derived_shadowed">protected_derived::derived_shadowed</a></h2>
+<h2 id="protected_derived-derived_shadowed">protected_derived::derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -729,7 +729,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-do_derived_shadowed"><a href="#protected_derived-do_derived_shadowed">protected_derived::do_derived_shadowed</a></h2>
+<h2 id="protected_derived-do_derived_shadowed">protected_derived::do_derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -753,7 +753,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-do_excluded_inherited"><a href="#protected_derived-do_excluded_inherited">protected_derived::do_excluded_inherited</a></h2>
+<h2 id="protected_derived-do_excluded_inherited">protected_derived::do_excluded_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -773,7 +773,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-do_shadowed"><a href="#protected_derived-do_shadowed">protected_derived::do_shadowed</a></h2>
+<h2 id="protected_derived-do_shadowed">protected_derived::do_shadowed</h2>
 <div>
 <span>This function should be shadowed by derived classes.</span>
 
@@ -793,7 +793,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-excluded_inherited"><a href="#protected_derived-excluded_inherited">protected_derived::excluded_inherited</a></h2>
+<h2 id="protected_derived-excluded_inherited">protected_derived::excluded_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
diff --git a/test-files/golden-tests/config/inherit-base-members/copy.html b/test-files/golden-tests/config/inherit-base-members/copy.html
index 781fd9edf..8e6d67daf 100644
--- a/test-files/golden-tests/config/inherit-base-members/copy.html
+++ b/test-files/golden-tests/config/inherit-base-members/copy.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -30,7 +30,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="base"><a href="#base">base</a></h2>
+<h2 id="base">base</h2>
 <div>
 <span>A base class to test inheritance and shadowing</span>
 
@@ -115,7 +115,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="base-base_base_inherited"><a href="#base-base_base_inherited">base::base_base_inherited</a></h2>
+<h2 id="base-base_base_inherited">base::base_base_inherited</h2>
 <div>
 <span>This function should be indirectly inherited by derived classes.</span>
 
@@ -139,7 +139,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-base_inherited"><a href="#base-base_inherited">base::base_inherited</a></h2>
+<h2 id="base-base_inherited">base::base_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -163,7 +163,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-base_shadowed"><a href="#base-base_shadowed">base::base_shadowed</a></h2>
+<h2 id="base-base_shadowed">base::base_shadowed</h2>
 <div>
 <span>This function should shadow the excluded_base function.</span>
 
@@ -187,7 +187,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-derived_shadowed"><a href="#base-derived_shadowed">base::derived_shadowed</a></h2>
+<h2 id="base-derived_shadowed">base::derived_shadowed</h2>
 <div>
 <span>This function should be shadowed by derived classes.</span>
 
@@ -211,7 +211,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-do_base_base_inherited"><a href="#base-do_base_base_inherited">base::do_base_base_inherited</a></h2>
+<h2 id="base-do_base_base_inherited">base::do_base_base_inherited</h2>
 <div>
 <span>This function should be indirectly inherited by derived classes.</span>
 
@@ -235,7 +235,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-do_base_inherited"><a href="#base-do_base_inherited">base::do_base_inherited</a></h2>
+<h2 id="base-do_base_inherited">base::do_base_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -259,7 +259,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-do_base_shadowed"><a href="#base-do_base_shadowed">base::do_base_shadowed</a></h2>
+<h2 id="base-do_base_shadowed">base::do_base_shadowed</h2>
 <div>
 <span>This function should shadow the excluded_base function.</span>
 
@@ -283,7 +283,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-do_derived_shadowed"><a href="#base-do_derived_shadowed">base::do_derived_shadowed</a></h2>
+<h2 id="base-do_derived_shadowed">base::do_derived_shadowed</h2>
 <div>
 <span>This function should be shadowed by derived classes.</span>
 
@@ -307,7 +307,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base_base"><a href="#base_base">base_base</a></h2>
+<h2 id="base_base">base_base</h2>
 <div>
 <span>A second-order base class to test indirect inheritance</span>
 
@@ -358,7 +358,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="base_base-base_base_inherited"><a href="#base_base-base_base_inherited">base_base::base_base_inherited</a></h2>
+<h2 id="base_base-base_base_inherited">base_base::base_base_inherited</h2>
 <div>
 <span>This function should be indirectly inherited by derived classes.</span>
 
@@ -382,7 +382,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base_base-do_base_base_inherited"><a href="#base_base-do_base_base_inherited">base_base::do_base_base_inherited</a></h2>
+<h2 id="base_base-do_base_base_inherited">base_base::do_base_base_inherited</h2>
 <div>
 <span>This function should be indirectly inherited by derived classes.</span>
 
@@ -406,7 +406,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="derived"><a href="#derived">derived</a></h2>
+<h2 id="derived">derived</h2>
 <div>
 <span>A class that derives from base and excluded_base</span>
 
@@ -482,7 +482,7 @@ <h2>Protected Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="derived-base_base_inherited"><a href="#derived-base_base_inherited">derived::base_base_inherited</a></h2>
+<h2 id="derived-base_base_inherited">derived::base_base_inherited</h2>
 <div>
 <span>This function should be indirectly inherited by derived classes.</span>
 
@@ -506,7 +506,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-base_inherited"><a href="#derived-base_inherited">derived::base_inherited</a></h2>
+<h2 id="derived-base_inherited">derived::base_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -530,7 +530,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-base_shadowed"><a href="#derived-base_shadowed">derived::base_shadowed</a></h2>
+<h2 id="derived-base_shadowed">derived::base_shadowed</h2>
 <div>
 <span>This function should shadow the excluded_base function.</span>
 
@@ -554,7 +554,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-derived_shadowed"><a href="#derived-derived_shadowed">derived::derived_shadowed</a></h2>
+<h2 id="derived-derived_shadowed">derived::derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -578,7 +578,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-do_base_base_inherited"><a href="#derived-do_base_base_inherited">derived::do_base_base_inherited</a></h2>
+<h2 id="derived-do_base_base_inherited">derived::do_base_base_inherited</h2>
 <div>
 <span>This function should be indirectly inherited by derived classes.</span>
 
@@ -602,7 +602,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-do_derived_shadowed-0a"><a href="#derived-do_derived_shadowed-0a">derived::do_derived_shadowed</a></h2>
+<h2 id="derived-do_derived_shadowed-0a">derived::do_derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -626,7 +626,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-excluded_inherited"><a href="#derived-excluded_inherited">derived::excluded_inherited</a></h2>
+<h2 id="derived-excluded_inherited">derived::excluded_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -646,7 +646,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-do_base_inherited"><a href="#derived-do_base_inherited">derived::do_base_inherited</a></h2>
+<h2 id="derived-do_base_inherited">derived::do_base_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -670,7 +670,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-do_base_shadowed"><a href="#derived-do_base_shadowed">derived::do_base_shadowed</a></h2>
+<h2 id="derived-do_base_shadowed">derived::do_base_shadowed</h2>
 <div>
 <span>This function should shadow the excluded_base function.</span>
 
@@ -694,7 +694,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-do_derived_shadowed-0d"><a href="#derived-do_derived_shadowed-0d">derived::do_derived_shadowed</a></h2>
+<h2 id="derived-do_derived_shadowed-0d">derived::do_derived_shadowed</h2>
 <div>
 <span>This function should be shadowed by derived classes.</span>
 
@@ -718,7 +718,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-do_excluded_inherited"><a href="#derived-do_excluded_inherited">derived::do_excluded_inherited</a></h2>
+<h2 id="derived-do_excluded_inherited">derived::do_excluded_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -738,7 +738,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-do_shadowed"><a href="#derived-do_shadowed">derived::do_shadowed</a></h2>
+<h2 id="derived-do_shadowed">derived::do_shadowed</h2>
 <div>
 <span>This function should be shadowed by derived classes.</span>
 
@@ -758,7 +758,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="private_derived"><a href="#private_derived">private_derived</a></h2>
+<h2 id="private_derived">private_derived</h2>
 <div>
 <span>A class that uses private inheritance only</span>
 
@@ -796,7 +796,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="private_derived-derived_shadowed"><a href="#private_derived-derived_shadowed">private_derived::derived_shadowed</a></h2>
+<h2 id="private_derived-derived_shadowed">private_derived::derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -820,7 +820,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="private_derived-do_derived_shadowed"><a href="#private_derived-do_derived_shadowed">private_derived::do_derived_shadowed</a></h2>
+<h2 id="private_derived-do_derived_shadowed">private_derived::do_derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -844,7 +844,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived"><a href="#protected_derived">protected_derived</a></h2>
+<h2 id="protected_derived">protected_derived</h2>
 <div>
 <span>A class that should inherit functions as protected.</span>
 
@@ -921,7 +921,7 @@ <h2>Protected Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-derived_shadowed-0a"><a href="#protected_derived-derived_shadowed-0a">protected_derived::derived_shadowed</a></h2>
+<h2 id="protected_derived-derived_shadowed-0a">protected_derived::derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -945,7 +945,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-do_derived_shadowed-0e"><a href="#protected_derived-do_derived_shadowed-0e">protected_derived::do_derived_shadowed</a></h2>
+<h2 id="protected_derived-do_derived_shadowed-0e">protected_derived::do_derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -969,7 +969,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-base_base_inherited"><a href="#protected_derived-base_base_inherited">protected_derived::base_base_inherited</a></h2>
+<h2 id="protected_derived-base_base_inherited">protected_derived::base_base_inherited</h2>
 <div>
 <span>This function should be indirectly inherited by derived classes.</span>
 
@@ -993,7 +993,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-base_inherited"><a href="#protected_derived-base_inherited">protected_derived::base_inherited</a></h2>
+<h2 id="protected_derived-base_inherited">protected_derived::base_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -1017,7 +1017,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-base_shadowed"><a href="#protected_derived-base_shadowed">protected_derived::base_shadowed</a></h2>
+<h2 id="protected_derived-base_shadowed">protected_derived::base_shadowed</h2>
 <div>
 <span>This function should shadow the excluded_base function.</span>
 
@@ -1041,7 +1041,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-derived_shadowed-0f"><a href="#protected_derived-derived_shadowed-0f">protected_derived::derived_shadowed</a></h2>
+<h2 id="protected_derived-derived_shadowed-0f">protected_derived::derived_shadowed</h2>
 <div>
 <span>This function should be shadowed by derived classes.</span>
 
@@ -1065,7 +1065,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-do_base_base_inherited"><a href="#protected_derived-do_base_base_inherited">protected_derived::do_base_base_inherited</a></h2>
+<h2 id="protected_derived-do_base_base_inherited">protected_derived::do_base_base_inherited</h2>
 <div>
 <span>This function should be indirectly inherited by derived classes.</span>
 
@@ -1089,7 +1089,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-do_base_inherited"><a href="#protected_derived-do_base_inherited">protected_derived::do_base_inherited</a></h2>
+<h2 id="protected_derived-do_base_inherited">protected_derived::do_base_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -1113,7 +1113,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-do_base_shadowed"><a href="#protected_derived-do_base_shadowed">protected_derived::do_base_shadowed</a></h2>
+<h2 id="protected_derived-do_base_shadowed">protected_derived::do_base_shadowed</h2>
 <div>
 <span>This function should shadow the excluded_base function.</span>
 
@@ -1137,7 +1137,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-do_derived_shadowed-06"><a href="#protected_derived-do_derived_shadowed-06">protected_derived::do_derived_shadowed</a></h2>
+<h2 id="protected_derived-do_derived_shadowed-06">protected_derived::do_derived_shadowed</h2>
 <div>
 <span>This function should be shadowed by derived classes.</span>
 
@@ -1161,7 +1161,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-do_excluded_inherited"><a href="#protected_derived-do_excluded_inherited">protected_derived::do_excluded_inherited</a></h2>
+<h2 id="protected_derived-do_excluded_inherited">protected_derived::do_excluded_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -1181,7 +1181,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-do_shadowed"><a href="#protected_derived-do_shadowed">protected_derived::do_shadowed</a></h2>
+<h2 id="protected_derived-do_shadowed">protected_derived::do_shadowed</h2>
 <div>
 <span>This function should be shadowed by derived classes.</span>
 
@@ -1201,7 +1201,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-excluded_inherited"><a href="#protected_derived-excluded_inherited">protected_derived::excluded_inherited</a></h2>
+<h2 id="protected_derived-excluded_inherited">protected_derived::excluded_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
diff --git a/test-files/golden-tests/config/inherit-base-members/never.html b/test-files/golden-tests/config/inherit-base-members/never.html
index dd80b4f49..24a2a51a2 100644
--- a/test-files/golden-tests/config/inherit-base-members/never.html
+++ b/test-files/golden-tests/config/inherit-base-members/never.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -30,7 +30,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="base"><a href="#base">base</a></h2>
+<h2 id="base">base</h2>
 <div>
 <span>A base class to test inheritance and shadowing</span>
 
@@ -113,7 +113,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="base-base_inherited"><a href="#base-base_inherited">base::base_inherited</a></h2>
+<h2 id="base-base_inherited">base::base_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -137,7 +137,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-base_shadowed"><a href="#base-base_shadowed">base::base_shadowed</a></h2>
+<h2 id="base-base_shadowed">base::base_shadowed</h2>
 <div>
 <span>This function should shadow the excluded_base function.</span>
 
@@ -161,7 +161,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-derived_shadowed"><a href="#base-derived_shadowed">base::derived_shadowed</a></h2>
+<h2 id="base-derived_shadowed">base::derived_shadowed</h2>
 <div>
 <span>This function should be shadowed by derived classes.</span>
 
@@ -185,7 +185,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-do_base_inherited"><a href="#base-do_base_inherited">base::do_base_inherited</a></h2>
+<h2 id="base-do_base_inherited">base::do_base_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -209,7 +209,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-do_base_shadowed"><a href="#base-do_base_shadowed">base::do_base_shadowed</a></h2>
+<h2 id="base-do_base_shadowed">base::do_base_shadowed</h2>
 <div>
 <span>This function should shadow the excluded_base function.</span>
 
@@ -233,7 +233,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-do_derived_shadowed"><a href="#base-do_derived_shadowed">base::do_derived_shadowed</a></h2>
+<h2 id="base-do_derived_shadowed">base::do_derived_shadowed</h2>
 <div>
 <span>This function should be shadowed by derived classes.</span>
 
@@ -257,7 +257,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base_base"><a href="#base_base">base_base</a></h2>
+<h2 id="base_base">base_base</h2>
 <div>
 <span>A second-order base class to test indirect inheritance</span>
 
@@ -308,7 +308,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="base_base-base_base_inherited"><a href="#base_base-base_base_inherited">base_base::base_base_inherited</a></h2>
+<h2 id="base_base-base_base_inherited">base_base::base_base_inherited</h2>
 <div>
 <span>This function should be indirectly inherited by derived classes.</span>
 
@@ -332,7 +332,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base_base-do_base_base_inherited"><a href="#base_base-do_base_base_inherited">base_base::do_base_base_inherited</a></h2>
+<h2 id="base_base-do_base_base_inherited">base_base::do_base_base_inherited</h2>
 <div>
 <span>This function should be indirectly inherited by derived classes.</span>
 
@@ -356,7 +356,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="derived"><a href="#derived">derived</a></h2>
+<h2 id="derived">derived</h2>
 <div>
 <span>A class that derives from base and excluded_base</span>
 
@@ -409,7 +409,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="derived-derived_shadowed"><a href="#derived-derived_shadowed">derived::derived_shadowed</a></h2>
+<h2 id="derived-derived_shadowed">derived::derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -433,7 +433,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-do_derived_shadowed"><a href="#derived-do_derived_shadowed">derived::do_derived_shadowed</a></h2>
+<h2 id="derived-do_derived_shadowed">derived::do_derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -457,7 +457,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="private_derived"><a href="#private_derived">private_derived</a></h2>
+<h2 id="private_derived">private_derived</h2>
 <div>
 <span>A class that uses private inheritance only</span>
 
@@ -495,7 +495,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="private_derived-derived_shadowed"><a href="#private_derived-derived_shadowed">private_derived::derived_shadowed</a></h2>
+<h2 id="private_derived-derived_shadowed">private_derived::derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -519,7 +519,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="private_derived-do_derived_shadowed"><a href="#private_derived-do_derived_shadowed">private_derived::do_derived_shadowed</a></h2>
+<h2 id="private_derived-do_derived_shadowed">private_derived::do_derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -543,7 +543,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived"><a href="#protected_derived">protected_derived</a></h2>
+<h2 id="protected_derived">protected_derived</h2>
 <div>
 <span>A class that should inherit functions as protected.</span>
 
@@ -596,7 +596,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-derived_shadowed"><a href="#protected_derived-derived_shadowed">protected_derived::derived_shadowed</a></h2>
+<h2 id="protected_derived-derived_shadowed">protected_derived::derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -620,7 +620,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-do_derived_shadowed"><a href="#protected_derived-do_derived_shadowed">protected_derived::do_derived_shadowed</a></h2>
+<h2 id="protected_derived-do_derived_shadowed">protected_derived::do_derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
diff --git a/test-files/golden-tests/config/inherit-base-members/reference.html b/test-files/golden-tests/config/inherit-base-members/reference.html
index 731d0faae..51f3458e8 100644
--- a/test-files/golden-tests/config/inherit-base-members/reference.html
+++ b/test-files/golden-tests/config/inherit-base-members/reference.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -30,7 +30,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="base"><a href="#base">base</a></h2>
+<h2 id="base">base</h2>
 <div>
 <span>A base class to test inheritance and shadowing</span>
 
@@ -115,7 +115,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="base-base_inherited"><a href="#base-base_inherited">base::base_inherited</a></h2>
+<h2 id="base-base_inherited">base::base_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -139,7 +139,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-base_shadowed"><a href="#base-base_shadowed">base::base_shadowed</a></h2>
+<h2 id="base-base_shadowed">base::base_shadowed</h2>
 <div>
 <span>This function should shadow the excluded_base function.</span>
 
@@ -163,7 +163,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-derived_shadowed"><a href="#base-derived_shadowed">base::derived_shadowed</a></h2>
+<h2 id="base-derived_shadowed">base::derived_shadowed</h2>
 <div>
 <span>This function should be shadowed by derived classes.</span>
 
@@ -187,7 +187,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-do_base_inherited"><a href="#base-do_base_inherited">base::do_base_inherited</a></h2>
+<h2 id="base-do_base_inherited">base::do_base_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -211,7 +211,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-do_base_shadowed"><a href="#base-do_base_shadowed">base::do_base_shadowed</a></h2>
+<h2 id="base-do_base_shadowed">base::do_base_shadowed</h2>
 <div>
 <span>This function should shadow the excluded_base function.</span>
 
@@ -235,7 +235,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base-do_derived_shadowed"><a href="#base-do_derived_shadowed">base::do_derived_shadowed</a></h2>
+<h2 id="base-do_derived_shadowed">base::do_derived_shadowed</h2>
 <div>
 <span>This function should be shadowed by derived classes.</span>
 
@@ -259,7 +259,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base_base"><a href="#base_base">base_base</a></h2>
+<h2 id="base_base">base_base</h2>
 <div>
 <span>A second-order base class to test indirect inheritance</span>
 
@@ -310,7 +310,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="base_base-base_base_inherited"><a href="#base_base-base_base_inherited">base_base::base_base_inherited</a></h2>
+<h2 id="base_base-base_base_inherited">base_base::base_base_inherited</h2>
 <div>
 <span>This function should be indirectly inherited by derived classes.</span>
 
@@ -334,7 +334,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="base_base-do_base_base_inherited"><a href="#base_base-do_base_base_inherited">base_base::do_base_base_inherited</a></h2>
+<h2 id="base_base-do_base_base_inherited">base_base::do_base_base_inherited</h2>
 <div>
 <span>This function should be indirectly inherited by derived classes.</span>
 
@@ -358,7 +358,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="derived"><a href="#derived">derived</a></h2>
+<h2 id="derived">derived</h2>
 <div>
 <span>A class that derives from base and excluded_base</span>
 
@@ -431,7 +431,7 @@ <h2>Protected Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="derived-derived_shadowed"><a href="#derived-derived_shadowed">derived::derived_shadowed</a></h2>
+<h2 id="derived-derived_shadowed">derived::derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -455,7 +455,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-do_derived_shadowed"><a href="#derived-do_derived_shadowed">derived::do_derived_shadowed</a></h2>
+<h2 id="derived-do_derived_shadowed">derived::do_derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -479,7 +479,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="private_derived"><a href="#private_derived">private_derived</a></h2>
+<h2 id="private_derived">private_derived</h2>
 <div>
 <span>A class that uses private inheritance only</span>
 
@@ -517,7 +517,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="private_derived-derived_shadowed"><a href="#private_derived-derived_shadowed">private_derived::derived_shadowed</a></h2>
+<h2 id="private_derived-derived_shadowed">private_derived::derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -541,7 +541,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="private_derived-do_derived_shadowed"><a href="#private_derived-do_derived_shadowed">private_derived::do_derived_shadowed</a></h2>
+<h2 id="private_derived-do_derived_shadowed">private_derived::do_derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -565,7 +565,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived"><a href="#protected_derived">protected_derived</a></h2>
+<h2 id="protected_derived">protected_derived</h2>
 <div>
 <span>A class that should inherit functions as protected.</span>
 
@@ -639,7 +639,7 @@ <h2>Protected Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-derived_shadowed"><a href="#protected_derived-derived_shadowed">protected_derived::derived_shadowed</a></h2>
+<h2 id="protected_derived-derived_shadowed">protected_derived::derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -663,7 +663,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-do_derived_shadowed"><a href="#protected_derived-do_derived_shadowed">protected_derived::do_derived_shadowed</a></h2>
+<h2 id="protected_derived-do_derived_shadowed">protected_derived::do_derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
diff --git a/test-files/golden-tests/config/inherit-base-members/skip-special.html b/test-files/golden-tests/config/inherit-base-members/skip-special.html
index a047bd876..5f0a10951 100644
--- a/test-files/golden-tests/config/inherit-base-members/skip-special.html
+++ b/test-files/golden-tests/config/inherit-base-members/skip-special.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -30,7 +30,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="base"><a href="#base">base</a></h2>
+<h2 id="base">base</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -113,7 +113,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="base-2constructor"><a href="#base-2constructor">base::base</a></h2>
+<h2 id="base-2constructor">base::base</h2>
 <div>
 <span>Constructor should not be inherited</span>
 
@@ -132,7 +132,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="base-2destructor"><a href="#base-2destructor">base::~base</a></h2>
+<h2 id="base-2destructor">base::~base</h2>
 <div>
 <span>Destructor should not be inherited</span>
 
@@ -151,7 +151,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="base-base_inherited"><a href="#base-base_inherited">base::base_inherited</a></h2>
+<h2 id="base-base_inherited">base::base_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -171,7 +171,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="base-base_shadowed"><a href="#base-base_shadowed">base::base_shadowed</a></h2>
+<h2 id="base-base_shadowed">base::base_shadowed</h2>
 <div>
 <span>This function should shadow the excluded_base function.</span>
 
@@ -191,7 +191,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="base-derived_shadowed"><a href="#base-derived_shadowed">base::derived_shadowed</a></h2>
+<h2 id="base-derived_shadowed">base::derived_shadowed</h2>
 <div>
 <span>This function should be shadowed by derived classes.</span>
 
@@ -211,7 +211,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="base-do_base_inherited"><a href="#base-do_base_inherited">base::do_base_inherited</a></h2>
+<h2 id="base-do_base_inherited">base::do_base_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -231,7 +231,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="base-do_base_shadowed"><a href="#base-do_base_shadowed">base::do_base_shadowed</a></h2>
+<h2 id="base-do_base_shadowed">base::do_base_shadowed</h2>
 <div>
 <span>This function should shadow the excluded_base function.</span>
 
@@ -251,7 +251,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="base-do_derived_shadowed"><a href="#base-do_derived_shadowed">base::do_derived_shadowed</a></h2>
+<h2 id="base-do_derived_shadowed">base::do_derived_shadowed</h2>
 <div>
 <span>This function should be shadowed by derived classes.</span>
 
@@ -271,7 +271,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="base_base"><a href="#base_base">base_base</a></h2>
+<h2 id="base_base">base_base</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -320,7 +320,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="base_base-2constructor"><a href="#base_base-2constructor">base_base::base_base</a></h2>
+<h2 id="base_base-2constructor">base_base::base_base</h2>
 <div>
 <span>Constructor should not be inherited</span>
 
@@ -339,7 +339,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="base_base-2destructor"><a href="#base_base-2destructor">base_base::~base_base</a></h2>
+<h2 id="base_base-2destructor">base_base::~base_base</h2>
 <div>
 <span>Destructor should not be inherited</span>
 
@@ -358,7 +358,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="base_base-base_base_inherited"><a href="#base_base-base_base_inherited">base_base::base_base_inherited</a></h2>
+<h2 id="base_base-base_base_inherited">base_base::base_base_inherited</h2>
 <div>
 <span>This function should be indirectly inherited by derived classes.</span>
 
@@ -378,7 +378,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="base_base-do_base_base_inherited"><a href="#base_base-do_base_base_inherited">base_base::do_base_base_inherited</a></h2>
+<h2 id="base_base-do_base_base_inherited">base_base::do_base_base_inherited</h2>
 <div>
 <span>This function should be indirectly inherited by derived classes.</span>
 
@@ -398,7 +398,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="derived"><a href="#derived">derived</a></h2>
+<h2 id="derived">derived</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -472,7 +472,7 @@ <h2>Protected Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="derived-2constructor"><a href="#derived-2constructor">derived::derived</a></h2>
+<h2 id="derived-2constructor">derived::derived</h2>
 <div>
 <span>Constructor should not be inherited</span>
 
@@ -491,7 +491,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-2destructor"><a href="#derived-2destructor">derived::~derived</a></h2>
+<h2 id="derived-2destructor">derived::~derived</h2>
 <div>
 <span>Destructor should not be inherited</span>
 
@@ -510,7 +510,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-derived_shadowed"><a href="#derived-derived_shadowed">derived::derived_shadowed</a></h2>
+<h2 id="derived-derived_shadowed">derived::derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -530,7 +530,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-do_derived_shadowed"><a href="#derived-do_derived_shadowed">derived::do_derived_shadowed</a></h2>
+<h2 id="derived-do_derived_shadowed">derived::do_derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -550,7 +550,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-excluded_inherited"><a href="#derived-excluded_inherited">derived::excluded_inherited</a></h2>
+<h2 id="derived-excluded_inherited">derived::excluded_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -570,7 +570,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-do_excluded_inherited"><a href="#derived-do_excluded_inherited">derived::do_excluded_inherited</a></h2>
+<h2 id="derived-do_excluded_inherited">derived::do_excluded_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -590,7 +590,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="derived-do_shadowed"><a href="#derived-do_shadowed">derived::do_shadowed</a></h2>
+<h2 id="derived-do_shadowed">derived::do_shadowed</h2>
 <div>
 <span>This function should be shadowed by derived classes.</span>
 
@@ -610,7 +610,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="private_derived"><a href="#private_derived">private_derived</a></h2>
+<h2 id="private_derived">private_derived</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -646,7 +646,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="private_derived-2constructor"><a href="#private_derived-2constructor">private_derived::private_derived</a></h2>
+<h2 id="private_derived-2constructor">private_derived::private_derived</h2>
 <div>
 <span>Constructor should not be inherited</span>
 
@@ -665,7 +665,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="private_derived-2destructor"><a href="#private_derived-2destructor">private_derived::~private_derived</a></h2>
+<h2 id="private_derived-2destructor">private_derived::~private_derived</h2>
 <div>
 <span>Destructor should not be inherited</span>
 
@@ -684,7 +684,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="private_derived-derived_shadowed"><a href="#private_derived-derived_shadowed">private_derived::derived_shadowed</a></h2>
+<h2 id="private_derived-derived_shadowed">private_derived::derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -704,7 +704,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="private_derived-do_derived_shadowed"><a href="#private_derived-do_derived_shadowed">private_derived::do_derived_shadowed</a></h2>
+<h2 id="private_derived-do_derived_shadowed">private_derived::do_derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -724,7 +724,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived"><a href="#protected_derived">protected_derived</a></h2>
+<h2 id="protected_derived">protected_derived</h2>
 <div>
 <span>Should inherit functions as protected.</span>
 
@@ -803,7 +803,7 @@ <h2>Protected Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-2constructor"><a href="#protected_derived-2constructor">protected_derived::protected_derived</a></h2>
+<h2 id="protected_derived-2constructor">protected_derived::protected_derived</h2>
 <div>
 <span>Constructor should not be inherited</span>
 
@@ -822,7 +822,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-2destructor"><a href="#protected_derived-2destructor">protected_derived::~protected_derived</a></h2>
+<h2 id="protected_derived-2destructor">protected_derived::~protected_derived</h2>
 <div>
 <span>Destructor should not be inherited</span>
 
@@ -841,7 +841,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-derived_shadowed"><a href="#protected_derived-derived_shadowed">protected_derived::derived_shadowed</a></h2>
+<h2 id="protected_derived-derived_shadowed">protected_derived::derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -865,7 +865,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-do_derived_shadowed"><a href="#protected_derived-do_derived_shadowed">protected_derived::do_derived_shadowed</a></h2>
+<h2 id="protected_derived-do_derived_shadowed">protected_derived::do_derived_shadowed</h2>
 <div>
 <span>This function should shadow the base class function.</span>
 
@@ -889,7 +889,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-do_excluded_inherited"><a href="#protected_derived-do_excluded_inherited">protected_derived::do_excluded_inherited</a></h2>
+<h2 id="protected_derived-do_excluded_inherited">protected_derived::do_excluded_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
@@ -909,7 +909,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-do_shadowed"><a href="#protected_derived-do_shadowed">protected_derived::do_shadowed</a></h2>
+<h2 id="protected_derived-do_shadowed">protected_derived::do_shadowed</h2>
 <div>
 <span>This function should be shadowed by derived classes.</span>
 
@@ -929,7 +929,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="protected_derived-excluded_inherited"><a href="#protected_derived-excluded_inherited">protected_derived::excluded_inherited</a></h2>
+<h2 id="protected_derived-excluded_inherited">protected_derived::excluded_inherited</h2>
 <div>
 <span>This function should be inherited by derived classes.</span>
 
diff --git a/test-files/golden-tests/config/legible-names/constructor.html b/test-files/golden-tests/config/legible-names/constructor.html
index 897c3fdf4..bb40070c9 100644
--- a/test-files/golden-tests/config/legible-names/constructor.html
+++ b/test-files/golden-tests/config/legible-names/constructor.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="X"><a href="#X">X</a></h2>
+<h2 id="X">X</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -56,7 +56,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor-08"><a href="#X-2constructor-08">X::X</a></h2>
+<h2 id="X-2constructor-08">X::X</h2>
 <div>
 <span>Constructors</span>
 
@@ -106,7 +106,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor-0e8"><a href="#X-2constructor-0e8">X::X</a></h2>
+<h2 id="X-2constructor-0e8">X::X</h2>
 <div>
 <span>Default constructor</span>
 
@@ -125,7 +125,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor-0e0"><a href="#X-2constructor-0e0">X::X</a></h2>
+<h2 id="X-2constructor-0e0">X::X</h2>
 <div>
 <span>Copy constructor</span>
 
@@ -161,7 +161,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor-069"><a href="#X-2constructor-069">X::X</a></h2>
+<h2 id="X-2constructor-069">X::X</h2>
 <div>
 <span>Move constructor</span>
 
@@ -197,7 +197,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor-07"><a href="#X-2constructor-07">X::X</a></h2>
+<h2 id="X-2constructor-07">X::X</h2>
 <div>
 <span>Construct from <code>int</code></span>
 
@@ -233,7 +233,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor-06f"><a href="#X-2constructor-06f">X::X</a></h2>
+<h2 id="X-2constructor-06f">X::X</h2>
 <div>
 <span>Construct from <code>double</code></span>
 
diff --git a/test-files/golden-tests/config/missing-include-prefixes/main.html b/test-files/golden-tests/config/missing-include-prefixes/main.html
index dc2bb0d2e..08f392245 100644
--- a/test-files/golden-tests/config/missing-include-prefixes/main.html
+++ b/test-files/golden-tests/config/missing-include-prefixes/main.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -42,7 +42,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g"><a href="#g">g</a></h2>
+<h2 id="g">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/config/missing-include-shims/main.html b/test-files/golden-tests/config/missing-include-shims/main.html
index cb7d1d50b..f40715328 100644
--- a/test-files/golden-tests/config/missing-include-shims/main.html
+++ b/test-files/golden-tests/config/missing-include-shims/main.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>Function satisfied by missing-include-shims</span>
 
diff --git a/test-files/golden-tests/config/overloads/const-mutable.html b/test-files/golden-tests/config/overloads/const-mutable.html
index a23f7b019..1edc7e2ce 100644
--- a/test-files/golden-tests/config/overloads/const-mutable.html
+++ b/test-files/golden-tests/config/overloads/const-mutable.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="C"><a href="#C">C</a></h2>
+<h2 id="C">C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -56,7 +56,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="C-foo-0e"><a href="#C-foo-0e">C::foo</a></h2>
+<h2 id="C-foo-0e">C::foo</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -83,7 +83,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="C-foo-0b"><a href="#C-foo-0b">C::foo</a></h2>
+<h2 id="C-foo-0b">C::foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -99,7 +99,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-foo-07"><a href="#C-foo-07">C::foo</a></h2>
+<h2 id="C-foo-07">C::foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/config/overloads/visibility.html b/test-files/golden-tests/config/overloads/visibility.html
index db1619027..41883e144 100644
--- a/test-files/golden-tests/config/overloads/visibility.html
+++ b/test-files/golden-tests/config/overloads/visibility.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="C"><a href="#C">C</a></h2>
+<h2 id="C">C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -98,7 +98,7 @@ <h2>Protected Static Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="C-foo-0e"><a href="#C-foo-0e">C::foo</a></h2>
+<h2 id="C-foo-0e">C::foo</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -125,7 +125,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="C-foo-0b"><a href="#C-foo-0b">C::foo</a></h2>
+<h2 id="C-foo-0b">C::foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -141,7 +141,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-foo-06"><a href="#C-foo-06">C::foo</a></h2>
+<h2 id="C-foo-06">C::foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -157,7 +157,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-foo-03"><a href="#C-foo-03">C::foo</a></h2>
+<h2 id="C-foo-03">C::foo</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -188,7 +188,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="C-foo-0fc"><a href="#C-foo-0fc">C::foo</a></h2>
+<h2 id="C-foo-0fc">C::foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -205,7 +205,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-foo-05"><a href="#C-foo-05">C::foo</a></h2>
+<h2 id="C-foo-05">C::foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -224,7 +224,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-foo-04c"><a href="#C-foo-04c">C::foo</a></h2>
+<h2 id="C-foo-04c">C::foo</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -256,7 +256,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="C-foo-0a"><a href="#C-foo-0a">C::foo</a></h2>
+<h2 id="C-foo-0a">C::foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -274,7 +274,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-foo-0c"><a href="#C-foo-0c">C::foo</a></h2>
+<h2 id="C-foo-0c">C::foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -293,7 +293,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-foo-048"><a href="#C-foo-048">C::foo</a></h2>
+<h2 id="C-foo-048">C::foo</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -329,7 +329,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="C-foo-00"><a href="#C-foo-00">C::foo</a></h2>
+<h2 id="C-foo-00">C::foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -349,7 +349,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-foo-0f5"><a href="#C-foo-0f5">C::foo</a></h2>
+<h2 id="C-foo-0f5">C::foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/config/sfinae/redeclare.html b/test-files/golden-tests/config/sfinae/redeclare.html
index 8db003587..207f80385 100644
--- a/test-files/golden-tests/config/sfinae/redeclare.html
+++ b/test-files/golden-tests/config/sfinae/redeclare.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/config/sfinae/return-based.html b/test-files/golden-tests/config/sfinae/return-based.html
index 97acc194f..a64428920 100644
--- a/test-files/golden-tests/config/sfinae/return-based.html
+++ b/test-files/golden-tests/config/sfinae/return-based.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.adoc b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.adoc
new file mode 100644
index 000000000..8b7c9d7db
--- /dev/null
+++ b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.adoc
@@ -0,0 +1,46 @@
+= Reference
+:mrdocs:
+
+[#index]
+== Global namespace
+
+=== Enums
+
+[cols=2]
+|===
+| Name
+| Description
+| link:#Color[`Color`] 
+| A simple enum
+|===
+
+[#Color]
+== Color
+
+A simple enum
+
+=== Synopsis
+
+Declared in `&lt;show&hyphen;enum&hyphen;constants&hyphen;false&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+enum class Color : int;
+----
+
+=== Members
+
+[cols=2]
+|===
+| Name
+| Description
+| `Red` 
+| The color red
+| `Green` 
+| The color green
+| `Blue` 
+| The color blue
+|===
+
+
+[.small]#Created with https://www.mrdocs.com[MrDocs]#
diff --git a/test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.cpp b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.cpp
new file mode 100644
index 000000000..59e40099a
--- /dev/null
+++ b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.cpp
@@ -0,0 +1,9 @@
+/// A simple enum
+enum class Color {
+    /// The color red
+    Red,
+    /// The color green
+    Green,
+    /// The color blue
+    Blue
+};
\ No newline at end of file
diff --git a/test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.html b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.html
new file mode 100644
index 000000000..8c07c4e70
--- /dev/null
+++ b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.html
@@ -0,0 +1,68 @@
+<html lang="en">
+<head>
+<title>Reference</title>
+</head>
+<body>
+<div>
+<h1>Reference</h1>
+<div>
+<div>
+<h2 id="index"></h2>
+</div>
+<h2>Enums</h2>
+<table style="table-layout: fixed; width: 100%;">
+<thead>
+<tr>
+<th>Name</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><a href="#Color"><code>Color</code></a> </td><td><span>A simple enum</span></td></tr>
+</tbody>
+</table>
+
+</div>
+<div>
+<div>
+<h2 id="Color">Color</h2>
+<div>
+<span>A simple enum</span>
+
+</div>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;show-enum-constants-false.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">enum class Color : int;
+
+</code>
+</pre>
+</div>
+<h2>Members</h2>
+<table style="table-layout: fixed; width: 100%;">
+<thead>
+<tr>
+<th>Name</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><code>Red</code> </td><td><span>The color red</span></td></tr><tr>
+<td><code>Green</code> </td><td><span>The color green</span></td></tr><tr>
+<td><code>Blue</code> </td><td><span>The color blue</span></td></tr>
+</tbody>
+</table>
+
+</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/config/show-enum-constants/show-enum-constants-false.xml b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.xml
new file mode 100644
index 000000000..0de4ffdcd
--- /dev/null
+++ b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.xml
@@ -0,0 +1,41 @@
+<?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=">
+  <enum name="Color" class="scoped" id="8ys5YHCZzogRGq/E/f61InZlmOE=">
+    <base>
+      <type name="int"/>
+    </base>
+    <file short-path="show-enum-constants-false.cpp" source-path="show-enum-constants-false.cpp" line="2" class="def"/>
+    <doc>
+      <brief>
+        <text>A simple enum</text>
+      </brief>
+    </doc>
+    <enum-constant name="Red" initializer="0" id="BBOAF6yhnTvCHkG9Jr5y9fvtD58=">
+      <file short-path="show-enum-constants-false.cpp" source-path="show-enum-constants-false.cpp" line="4"/>
+      <doc>
+        <brief>
+          <text>The color red</text>
+        </brief>
+      </doc>
+    </enum-constant>
+    <enum-constant name="Green" initializer="1" id="Lx0D7a81JkdDRHL9+a9QPTM4Np0=">
+      <file short-path="show-enum-constants-false.cpp" source-path="show-enum-constants-false.cpp" line="6"/>
+      <doc>
+        <brief>
+          <text>The color green</text>
+        </brief>
+      </doc>
+    </enum-constant>
+    <enum-constant name="Blue" initializer="2" id="kd2nnOQJJwznL3PIvdJxDbGUmr4=">
+      <file short-path="show-enum-constants-false.cpp" source-path="show-enum-constants-false.cpp" line="8"/>
+      <doc>
+        <brief>
+          <text>The color blue</text>
+        </brief>
+      </doc>
+    </enum-constant>
+  </enum>
+</namespace>
+</mrdocs>
diff --git a/test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.yml b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.yml
new file mode 100644
index 000000000..d3f51abf4
--- /dev/null
+++ b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.yml
@@ -0,0 +1 @@
+show-enum-constants: false
\ No newline at end of file
diff --git a/test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.adoc b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.adoc
new file mode 100644
index 000000000..557a038d8
--- /dev/null
+++ b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.adoc
@@ -0,0 +1,88 @@
+= Reference
+:mrdocs:
+
+[#index]
+== Global namespace
+
+=== Enums
+
+[cols=2]
+|===
+| Name
+| Description
+| link:#Color[`Color`] 
+| A simple enum
+|===
+
+[#Color]
+== Color
+
+A simple enum
+
+=== Synopsis
+
+Declared in `&lt;show&hyphen;enum&hyphen;constants&hyphen;true&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+enum class Color : int;
+----
+
+=== Members
+
+[cols=2]
+|===
+| Name
+| Description
+| link:#Color-Red[`Red`] 
+| The color red
+| link:#Color-Green[`Green`] 
+| The color green
+| link:#Color-Blue[`Blue`] 
+| The color blue
+|===
+
+[#Color-Red]
+== link:#Color[Color]::Red
+
+The color red
+
+=== Synopsis
+
+Declared in `&lt;show&hyphen;enum&hyphen;constants&hyphen;true&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+Red
+----
+
+[#Color-Green]
+== link:#Color[Color]::Green
+
+The color green
+
+=== Synopsis
+
+Declared in `&lt;show&hyphen;enum&hyphen;constants&hyphen;true&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+Green
+----
+
+[#Color-Blue]
+== link:#Color[Color]::Blue
+
+The color blue
+
+=== Synopsis
+
+Declared in `&lt;show&hyphen;enum&hyphen;constants&hyphen;true&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+Blue
+----
+
+
+[.small]#Created with https://www.mrdocs.com[MrDocs]#
diff --git a/test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.cpp b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.cpp
new file mode 100644
index 000000000..59e40099a
--- /dev/null
+++ b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.cpp
@@ -0,0 +1,9 @@
+/// A simple enum
+enum class Color {
+    /// The color red
+    Red,
+    /// The color green
+    Green,
+    /// The color blue
+    Blue
+};
\ No newline at end of file
diff --git a/test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.html b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.html
new file mode 100644
index 000000000..6dde51084
--- /dev/null
+++ b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.html
@@ -0,0 +1,125 @@
+<html lang="en">
+<head>
+<title>Reference</title>
+</head>
+<body>
+<div>
+<h1>Reference</h1>
+<div>
+<div>
+<h2 id="index"></h2>
+</div>
+<h2>Enums</h2>
+<table style="table-layout: fixed; width: 100%;">
+<thead>
+<tr>
+<th>Name</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><a href="#Color"><code>Color</code></a> </td><td><span>A simple enum</span></td></tr>
+</tbody>
+</table>
+
+</div>
+<div>
+<div>
+<h2 id="Color">Color</h2>
+<div>
+<span>A simple enum</span>
+
+</div>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;show-enum-constants-true.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">enum class Color : int;
+
+</code>
+</pre>
+</div>
+<h2>Members</h2>
+<table style="table-layout: fixed; width: 100%;">
+<thead>
+<tr>
+<th>Name</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><a href="#Color-Red"><code>Red</code></a> </td><td><span>The color red</span></td></tr><tr>
+<td><a href="#Color-Green"><code>Green</code></a> </td><td><span>The color green</span></td></tr><tr>
+<td><a href="#Color-Blue"><code>Blue</code></a> </td><td><span>The color blue</span></td></tr>
+</tbody>
+</table>
+
+</div>
+<div>
+<div>
+<h2 id="Color-Red">Color::Red</h2>
+<div>
+<span>The color red</span>
+
+</div>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;show-enum-constants-true.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">Red
+
+</code>
+</pre>
+</div>
+</div>
+<div>
+<div>
+<h2 id="Color-Green">Color::Green</h2>
+<div>
+<span>The color green</span>
+
+</div>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;show-enum-constants-true.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">Green
+
+</code>
+</pre>
+</div>
+</div>
+<div>
+<div>
+<h2 id="Color-Blue">Color::Blue</h2>
+<div>
+<span>The color blue</span>
+
+</div>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;show-enum-constants-true.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">Blue
+
+</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/config/show-enum-constants/show-enum-constants-true.xml b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.xml
new file mode 100644
index 000000000..2b7260588
--- /dev/null
+++ b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.xml
@@ -0,0 +1,41 @@
+<?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=">
+  <enum name="Color" class="scoped" id="8ys5YHCZzogRGq/E/f61InZlmOE=">
+    <base>
+      <type name="int"/>
+    </base>
+    <file short-path="show-enum-constants-true.cpp" source-path="show-enum-constants-true.cpp" line="2" class="def"/>
+    <doc>
+      <brief>
+        <text>A simple enum</text>
+      </brief>
+    </doc>
+    <enum-constant name="Red" initializer="0" id="BBOAF6yhnTvCHkG9Jr5y9fvtD58=">
+      <file short-path="show-enum-constants-true.cpp" source-path="show-enum-constants-true.cpp" line="4"/>
+      <doc>
+        <brief>
+          <text>The color red</text>
+        </brief>
+      </doc>
+    </enum-constant>
+    <enum-constant name="Green" initializer="1" id="Lx0D7a81JkdDRHL9+a9QPTM4Np0=">
+      <file short-path="show-enum-constants-true.cpp" source-path="show-enum-constants-true.cpp" line="6"/>
+      <doc>
+        <brief>
+          <text>The color green</text>
+        </brief>
+      </doc>
+    </enum-constant>
+    <enum-constant name="Blue" initializer="2" id="kd2nnOQJJwznL3PIvdJxDbGUmr4=">
+      <file short-path="show-enum-constants-true.cpp" source-path="show-enum-constants-true.cpp" line="8"/>
+      <doc>
+        <brief>
+          <text>The color blue</text>
+        </brief>
+      </doc>
+    </enum-constant>
+  </enum>
+</namespace>
+</mrdocs>
diff --git a/test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.yml b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.yml
new file mode 100644
index 000000000..6b9718466
--- /dev/null
+++ b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.yml
@@ -0,0 +1 @@
+show-enum-constants: true
\ No newline at end of file
diff --git a/test-files/golden-tests/config/show-namespaces/show-namespaces.html b/test-files/golden-tests/config/show-namespaces/show-namespaces.html
index af2b0caec..1ed532aeb 100644
--- a/test-files/golden-tests/config/show-namespaces/show-namespaces.html
+++ b/test-files/golden-tests/config/show-namespaces/show-namespaces.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="A-B-c"><a href="#A-B-c">A::B::c</a></h2>
+<h2 id="A-B-c">A::B::c</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -23,7 +23,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-b"><a href="#A-b">A::b</a></h2>
+<h2 id="A-b">A::b</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -39,7 +39,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="a"><a href="#a">a</a></h2>
+<h2 id="a">a</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/config/sort-members-by/sort-members-by-location.html b/test-files/golden-tests/config/sort-members-by/sort-members-by-location.html
index 3acbf2191..e6fd0d68d 100644
--- a/test-files/golden-tests/config/sort-members-by/sort-members-by-location.html
+++ b/test-files/golden-tests/config/sort-members-by/sort-members-by-location.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="Z"><a href="#Z">Z</a></h2>
+<h2 id="Z">Z</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -64,7 +64,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="Z-2constructor-00"><a href="#Z-2constructor-00">Z::Z</a></h2>
+<h2 id="Z-2constructor-00">Z::Z</h2>
 <div>
 <span>Constructors</span>
 
@@ -93,7 +93,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2constructor-06"><a href="#Z-2constructor-06">Z::Z</a></h2>
+<h2 id="Z-2constructor-06">Z::Z</h2>
 <div>
 <span>Construct from <code>int</code></span>
 
@@ -129,7 +129,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2constructor-05"><a href="#Z-2constructor-05">Z::Z</a></h2>
+<h2 id="Z-2constructor-05">Z::Z</h2>
 <div>
 <span>Default constructor</span>
 
@@ -148,7 +148,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2destructor"><a href="#Z-2destructor">Z::~Z</a></h2>
+<h2 id="Z-2destructor">Z::~Z</h2>
 <div>
 <span>Destructor</span>
 
@@ -167,7 +167,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-foo"><a href="#Z-foo">Z::foo</a></h2>
+<h2 id="Z-foo">Z::foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -183,7 +183,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-bar"><a href="#Z-bar">Z::bar</a></h2>
+<h2 id="Z-bar">Z::bar</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -199,7 +199,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2conversion"><a href="#Z-2conversion">Z::operator bool</a></h2>
+<h2 id="Z-2conversion">Z::operator bool</h2>
 <div>
 <span>Conversion to <code>bool</code></span>
 
@@ -222,7 +222,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_not"><a href="#Z-operator_not">Z::operator!</a></h2>
+<h2 id="Z-operator_not">Z::operator!</h2>
 <div>
 <span>Negation operator</span>
 
@@ -246,7 +246,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_eq"><a href="#Z-operator_eq">Z::operator&#x3D;&#x3D;</a></h2>
+<h2 id="Z-operator_eq">Z::operator&#x3D;&#x3D;</h2>
 <div>
 <span>Equality operator</span>
 
@@ -287,7 +287,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_not_eq"><a href="#Z-operator_not_eq">Z::operator!&#x3D;</a></h2>
+<h2 id="Z-operator_not_eq">Z::operator!&#x3D;</h2>
 <div>
 <span>Inequality operator</span>
 
@@ -328,7 +328,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_3way"><a href="#Z-operator_3way">Z::operator&lt;&#x3D;&gt;</a></h2>
+<h2 id="Z-operator_3way">Z::operator&lt;&#x3D;&gt;</h2>
 <div>
 <span>Three-way comparison operator</span>
 
diff --git a/test-files/golden-tests/config/sort-members-by/sort-members-by-name.html b/test-files/golden-tests/config/sort-members-by/sort-members-by-name.html
index 839f92eca..575e608a3 100644
--- a/test-files/golden-tests/config/sort-members-by/sort-members-by-name.html
+++ b/test-files/golden-tests/config/sort-members-by/sort-members-by-name.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="Z"><a href="#Z">Z</a></h2>
+<h2 id="Z">Z</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -64,7 +64,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="Z-2constructor-00"><a href="#Z-2constructor-00">Z::Z</a></h2>
+<h2 id="Z-2constructor-00">Z::Z</h2>
 <div>
 <span>Constructors</span>
 
@@ -93,7 +93,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2constructor-05"><a href="#Z-2constructor-05">Z::Z</a></h2>
+<h2 id="Z-2constructor-05">Z::Z</h2>
 <div>
 <span>Default constructor</span>
 
@@ -112,7 +112,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2constructor-06"><a href="#Z-2constructor-06">Z::Z</a></h2>
+<h2 id="Z-2constructor-06">Z::Z</h2>
 <div>
 <span>Construct from <code>int</code></span>
 
@@ -148,7 +148,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2destructor"><a href="#Z-2destructor">Z::~Z</a></h2>
+<h2 id="Z-2destructor">Z::~Z</h2>
 <div>
 <span>Destructor</span>
 
@@ -167,7 +167,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-bar"><a href="#Z-bar">Z::bar</a></h2>
+<h2 id="Z-bar">Z::bar</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -183,7 +183,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-foo"><a href="#Z-foo">Z::foo</a></h2>
+<h2 id="Z-foo">Z::foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -199,7 +199,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2conversion"><a href="#Z-2conversion">Z::operator bool</a></h2>
+<h2 id="Z-2conversion">Z::operator bool</h2>
 <div>
 <span>Conversion to <code>bool</code></span>
 
@@ -222,7 +222,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_not"><a href="#Z-operator_not">Z::operator!</a></h2>
+<h2 id="Z-operator_not">Z::operator!</h2>
 <div>
 <span>Negation operator</span>
 
@@ -246,7 +246,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_eq"><a href="#Z-operator_eq">Z::operator&#x3D;&#x3D;</a></h2>
+<h2 id="Z-operator_eq">Z::operator&#x3D;&#x3D;</h2>
 <div>
 <span>Equality operator</span>
 
@@ -287,7 +287,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_not_eq"><a href="#Z-operator_not_eq">Z::operator!&#x3D;</a></h2>
+<h2 id="Z-operator_not_eq">Z::operator!&#x3D;</h2>
 <div>
 <span>Inequality operator</span>
 
@@ -328,7 +328,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_3way"><a href="#Z-operator_3way">Z::operator&lt;&#x3D;&gt;</a></h2>
+<h2 id="Z-operator_3way">Z::operator&lt;&#x3D;&gt;</h2>
 <div>
 <span>Three-way comparison operator</span>
 
diff --git a/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-location.html b/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-location.html
index e90718cb6..2a7014d68 100644
--- a/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-location.html
+++ b/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-location.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -52,7 +52,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="D"><a href="#D">D</a></h2>
+<h2 id="D">D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -69,7 +69,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-0f"><a href="#C-0f">C</a></h2>
+<h2 id="C-0f">C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -89,7 +89,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-0d"><a href="#C-0d">C&lt;int, char&gt;</a></h2>
+<h2 id="C-0d">C&lt;int, char&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -107,7 +107,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-03"><a href="#C-03">C&lt;int&gt;</a></h2>
+<h2 id="C-03">C&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -125,7 +125,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-0b"><a href="#B-0b">B</a></h2>
+<h2 id="B-0b">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -145,7 +145,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-04"><a href="#B-04">B&lt;int, char&gt;</a></h2>
+<h2 id="B-04">B&lt;int, char&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -163,7 +163,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-05"><a href="#B-05">B&lt;int, U&gt;</a></h2>
+<h2 id="B-05">B&lt;int, U&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -181,7 +181,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -198,7 +198,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z"><a href="#Z">Z</a></h2>
+<h2 id="Z">Z</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -236,7 +236,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="Z-2constructor-00"><a href="#Z-2constructor-00">Z::Z</a></h2>
+<h2 id="Z-2constructor-00">Z::Z</h2>
 <div>
 <span>Constructors</span>
 
@@ -265,7 +265,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2constructor-05"><a href="#Z-2constructor-05">Z::Z</a></h2>
+<h2 id="Z-2constructor-05">Z::Z</h2>
 <div>
 <span>Default constructor</span>
 
@@ -284,7 +284,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2constructor-06"><a href="#Z-2constructor-06">Z::Z</a></h2>
+<h2 id="Z-2constructor-06">Z::Z</h2>
 <div>
 <span>Construct from <code>int</code></span>
 
@@ -320,7 +320,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2destructor"><a href="#Z-2destructor">Z::~Z</a></h2>
+<h2 id="Z-2destructor">Z::~Z</h2>
 <div>
 <span>Destructor</span>
 
@@ -339,7 +339,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-foo"><a href="#Z-foo">Z::foo</a></h2>
+<h2 id="Z-foo">Z::foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -355,7 +355,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2conversion"><a href="#Z-2conversion">Z::operator bool</a></h2>
+<h2 id="Z-2conversion">Z::operator bool</h2>
 <div>
 <span>Conversion to <code>bool</code></span>
 
@@ -378,7 +378,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_not"><a href="#Z-operator_not">Z::operator!</a></h2>
+<h2 id="Z-operator_not">Z::operator!</h2>
 <div>
 <span>Negation operator</span>
 
@@ -402,7 +402,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_eq"><a href="#Z-operator_eq">Z::operator&#x3D;&#x3D;</a></h2>
+<h2 id="Z-operator_eq">Z::operator&#x3D;&#x3D;</h2>
 <div>
 <span>Equality operator</span>
 
@@ -443,7 +443,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_not_eq"><a href="#Z-operator_not_eq">Z::operator!&#x3D;</a></h2>
+<h2 id="Z-operator_not_eq">Z::operator!&#x3D;</h2>
 <div>
 <span>Inequality operator</span>
 
@@ -484,7 +484,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_3way"><a href="#Z-operator_3way">Z::operator&lt;&#x3D;&gt;</a></h2>
+<h2 id="Z-operator_3way">Z::operator&lt;&#x3D;&gt;</h2>
 <div>
 <span>Three-way comparison operator</span>
 
@@ -525,7 +525,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="h"><a href="#h">h</a></h2>
+<h2 id="h">h</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -541,7 +541,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0f"><a href="#g-0f">g</a></h2>
+<h2 id="g-0f">g</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -621,7 +621,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="g-03c"><a href="#g-03c">g</a></h2>
+<h2 id="g-03c">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -641,7 +641,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0e4"><a href="#g-0e4">g&lt;int&gt;</a></h2>
+<h2 id="g-0e4">g&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -661,7 +661,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0a"><a href="#g-0a">g</a></h2>
+<h2 id="g-0a">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -680,7 +680,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-03a"><a href="#g-03a">g</a></h2>
+<h2 id="g-03a">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -698,7 +698,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-06"><a href="#g-06">g</a></h2>
+<h2 id="g-06">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -714,7 +714,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-04"><a href="#g-04">g</a></h2>
+<h2 id="g-04">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -730,7 +730,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0e3"><a href="#g-0e3">g</a></h2>
+<h2 id="g-0e3">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -746,7 +746,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -762,7 +762,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_not"><a href="#operator_not">operator!</a></h2>
+<h2 id="operator_not">operator!</h2>
 <div>
 <span>Negation operator</span>
 
@@ -803,7 +803,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_eq"><a href="#operator_eq">operator&#x3D;&#x3D;</a></h2>
+<h2 id="operator_eq">operator&#x3D;&#x3D;</h2>
 <div>
 <span>Equality operator</span>
 
@@ -850,7 +850,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_not_eq"><a href="#operator_not_eq">operator!&#x3D;</a></h2>
+<h2 id="operator_not_eq">operator!&#x3D;</h2>
 <div>
 <span>Inequality operator</span>
 
diff --git a/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-name.html b/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-name.html
index 399b5f869..d0c60f782 100644
--- a/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-name.html
+++ b/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-name.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -52,7 +52,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -69,7 +69,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-0b"><a href="#B-0b">B</a></h2>
+<h2 id="B-0b">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -89,7 +89,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-04"><a href="#B-04">B&lt;int, char&gt;</a></h2>
+<h2 id="B-04">B&lt;int, char&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -107,7 +107,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-05"><a href="#B-05">B&lt;int, U&gt;</a></h2>
+<h2 id="B-05">B&lt;int, U&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -125,7 +125,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-0f"><a href="#C-0f">C</a></h2>
+<h2 id="C-0f">C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -145,7 +145,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-03"><a href="#C-03">C&lt;int&gt;</a></h2>
+<h2 id="C-03">C&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -163,7 +163,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-0d"><a href="#C-0d">C&lt;int, char&gt;</a></h2>
+<h2 id="C-0d">C&lt;int, char&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -181,7 +181,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="D"><a href="#D">D</a></h2>
+<h2 id="D">D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -198,7 +198,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z"><a href="#Z">Z</a></h2>
+<h2 id="Z">Z</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -236,7 +236,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="Z-2constructor-00"><a href="#Z-2constructor-00">Z::Z</a></h2>
+<h2 id="Z-2constructor-00">Z::Z</h2>
 <div>
 <span>Constructors</span>
 
@@ -265,7 +265,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2constructor-05"><a href="#Z-2constructor-05">Z::Z</a></h2>
+<h2 id="Z-2constructor-05">Z::Z</h2>
 <div>
 <span>Default constructor</span>
 
@@ -284,7 +284,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2constructor-06"><a href="#Z-2constructor-06">Z::Z</a></h2>
+<h2 id="Z-2constructor-06">Z::Z</h2>
 <div>
 <span>Construct from <code>int</code></span>
 
@@ -320,7 +320,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2destructor"><a href="#Z-2destructor">Z::~Z</a></h2>
+<h2 id="Z-2destructor">Z::~Z</h2>
 <div>
 <span>Destructor</span>
 
@@ -339,7 +339,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-foo"><a href="#Z-foo">Z::foo</a></h2>
+<h2 id="Z-foo">Z::foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -355,7 +355,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2conversion"><a href="#Z-2conversion">Z::operator bool</a></h2>
+<h2 id="Z-2conversion">Z::operator bool</h2>
 <div>
 <span>Conversion to <code>bool</code></span>
 
@@ -378,7 +378,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_not"><a href="#Z-operator_not">Z::operator!</a></h2>
+<h2 id="Z-operator_not">Z::operator!</h2>
 <div>
 <span>Negation operator</span>
 
@@ -402,7 +402,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_eq"><a href="#Z-operator_eq">Z::operator&#x3D;&#x3D;</a></h2>
+<h2 id="Z-operator_eq">Z::operator&#x3D;&#x3D;</h2>
 <div>
 <span>Equality operator</span>
 
@@ -443,7 +443,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_not_eq"><a href="#Z-operator_not_eq">Z::operator!&#x3D;</a></h2>
+<h2 id="Z-operator_not_eq">Z::operator!&#x3D;</h2>
 <div>
 <span>Inequality operator</span>
 
@@ -484,7 +484,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_3way"><a href="#Z-operator_3way">Z::operator&lt;&#x3D;&gt;</a></h2>
+<h2 id="Z-operator_3way">Z::operator&lt;&#x3D;&gt;</h2>
 <div>
 <span>Three-way comparison operator</span>
 
@@ -525,7 +525,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -541,7 +541,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0f"><a href="#g-0f">g</a></h2>
+<h2 id="g-0f">g</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -621,7 +621,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0e3"><a href="#g-0e3">g</a></h2>
+<h2 id="g-0e3">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -637,7 +637,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-04"><a href="#g-04">g</a></h2>
+<h2 id="g-04">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -653,7 +653,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-06"><a href="#g-06">g</a></h2>
+<h2 id="g-06">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -669,7 +669,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-03a"><a href="#g-03a">g</a></h2>
+<h2 id="g-03a">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -687,7 +687,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0a"><a href="#g-0a">g</a></h2>
+<h2 id="g-0a">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -706,7 +706,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-03c"><a href="#g-03c">g</a></h2>
+<h2 id="g-03c">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -726,7 +726,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0e4"><a href="#g-0e4">g&lt;int&gt;</a></h2>
+<h2 id="g-0e4">g&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -746,7 +746,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="h"><a href="#h">h</a></h2>
+<h2 id="h">h</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -762,7 +762,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_not"><a href="#operator_not">operator!</a></h2>
+<h2 id="operator_not">operator!</h2>
 <div>
 <span>Negation operator</span>
 
@@ -803,7 +803,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_eq"><a href="#operator_eq">operator&#x3D;&#x3D;</a></h2>
+<h2 id="operator_eq">operator&#x3D;&#x3D;</h2>
 <div>
 <span>Equality operator</span>
 
@@ -850,7 +850,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_not_eq"><a href="#operator_not_eq">operator!&#x3D;</a></h2>
+<h2 id="operator_not_eq">operator!&#x3D;</h2>
 <div>
 <span>Inequality operator</span>
 
diff --git a/test-files/golden-tests/config/sort/sort-members.html b/test-files/golden-tests/config/sort/sort-members.html
index d2563ae5a..53e1ac6bf 100644
--- a/test-files/golden-tests/config/sort/sort-members.html
+++ b/test-files/golden-tests/config/sort/sort-members.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -52,7 +52,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -69,7 +69,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-0b"><a href="#B-0b">B</a></h2>
+<h2 id="B-0b">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -89,7 +89,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-04"><a href="#B-04">B&lt;int, char&gt;</a></h2>
+<h2 id="B-04">B&lt;int, char&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -107,7 +107,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-05"><a href="#B-05">B&lt;int, U&gt;</a></h2>
+<h2 id="B-05">B&lt;int, U&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -125,7 +125,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-0f"><a href="#C-0f">C</a></h2>
+<h2 id="C-0f">C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -145,7 +145,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-03"><a href="#C-03">C&lt;int&gt;</a></h2>
+<h2 id="C-03">C&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -163,7 +163,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-0d"><a href="#C-0d">C&lt;int, char&gt;</a></h2>
+<h2 id="C-0d">C&lt;int, char&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -181,7 +181,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="D"><a href="#D">D</a></h2>
+<h2 id="D">D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -198,7 +198,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z"><a href="#Z">Z</a></h2>
+<h2 id="Z">Z</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -236,7 +236,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="Z-2constructor-00"><a href="#Z-2constructor-00">Z::Z</a></h2>
+<h2 id="Z-2constructor-00">Z::Z</h2>
 <div>
 <span>Constructors</span>
 
@@ -265,7 +265,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2constructor-05"><a href="#Z-2constructor-05">Z::Z</a></h2>
+<h2 id="Z-2constructor-05">Z::Z</h2>
 <div>
 <span>Default constructor</span>
 
@@ -284,7 +284,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2constructor-06"><a href="#Z-2constructor-06">Z::Z</a></h2>
+<h2 id="Z-2constructor-06">Z::Z</h2>
 <div>
 <span>Construct from <code>int</code></span>
 
@@ -320,7 +320,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2destructor"><a href="#Z-2destructor">Z::~Z</a></h2>
+<h2 id="Z-2destructor">Z::~Z</h2>
 <div>
 <span>Destructor</span>
 
@@ -339,7 +339,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-foo"><a href="#Z-foo">Z::foo</a></h2>
+<h2 id="Z-foo">Z::foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -355,7 +355,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2conversion"><a href="#Z-2conversion">Z::operator bool</a></h2>
+<h2 id="Z-2conversion">Z::operator bool</h2>
 <div>
 <span>Conversion to <code>bool</code></span>
 
@@ -378,7 +378,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_not"><a href="#Z-operator_not">Z::operator!</a></h2>
+<h2 id="Z-operator_not">Z::operator!</h2>
 <div>
 <span>Negation operator</span>
 
@@ -402,7 +402,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_eq"><a href="#Z-operator_eq">Z::operator&#x3D;&#x3D;</a></h2>
+<h2 id="Z-operator_eq">Z::operator&#x3D;&#x3D;</h2>
 <div>
 <span>Equality operator</span>
 
@@ -443,7 +443,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_not_eq"><a href="#Z-operator_not_eq">Z::operator!&#x3D;</a></h2>
+<h2 id="Z-operator_not_eq">Z::operator!&#x3D;</h2>
 <div>
 <span>Inequality operator</span>
 
@@ -484,7 +484,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_3way"><a href="#Z-operator_3way">Z::operator&lt;&#x3D;&gt;</a></h2>
+<h2 id="Z-operator_3way">Z::operator&lt;&#x3D;&gt;</h2>
 <div>
 <span>Three-way comparison operator</span>
 
@@ -525,7 +525,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -541,7 +541,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0f"><a href="#g-0f">g</a></h2>
+<h2 id="g-0f">g</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -621,7 +621,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0e3"><a href="#g-0e3">g</a></h2>
+<h2 id="g-0e3">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -637,7 +637,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-04"><a href="#g-04">g</a></h2>
+<h2 id="g-04">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -653,7 +653,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-06"><a href="#g-06">g</a></h2>
+<h2 id="g-06">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -669,7 +669,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-03a"><a href="#g-03a">g</a></h2>
+<h2 id="g-03a">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -687,7 +687,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0a"><a href="#g-0a">g</a></h2>
+<h2 id="g-0a">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -706,7 +706,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-03c"><a href="#g-03c">g</a></h2>
+<h2 id="g-03c">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -726,7 +726,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0e4"><a href="#g-0e4">g&lt;int&gt;</a></h2>
+<h2 id="g-0e4">g&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -746,7 +746,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="h"><a href="#h">h</a></h2>
+<h2 id="h">h</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -762,7 +762,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_not"><a href="#operator_not">operator!</a></h2>
+<h2 id="operator_not">operator!</h2>
 <div>
 <span>Negation operator</span>
 
@@ -803,7 +803,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_eq"><a href="#operator_eq">operator&#x3D;&#x3D;</a></h2>
+<h2 id="operator_eq">operator&#x3D;&#x3D;</h2>
 <div>
 <span>Equality operator</span>
 
@@ -850,7 +850,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_not_eq"><a href="#operator_not_eq">operator!&#x3D;</a></h2>
+<h2 id="operator_not_eq">operator!&#x3D;</h2>
 <div>
 <span>Inequality operator</span>
 
diff --git a/test-files/golden-tests/config/sort/unordered.html b/test-files/golden-tests/config/sort/unordered.html
index 6dc210a0f..99c3fe256 100644
--- a/test-files/golden-tests/config/sort/unordered.html
+++ b/test-files/golden-tests/config/sort/unordered.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -52,7 +52,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="D"><a href="#D">D</a></h2>
+<h2 id="D">D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -69,7 +69,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-0f"><a href="#C-0f">C</a></h2>
+<h2 id="C-0f">C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -89,7 +89,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-0d"><a href="#C-0d">C&lt;int, char&gt;</a></h2>
+<h2 id="C-0d">C&lt;int, char&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -107,7 +107,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-03"><a href="#C-03">C&lt;int&gt;</a></h2>
+<h2 id="C-03">C&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -125,7 +125,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-0b"><a href="#B-0b">B</a></h2>
+<h2 id="B-0b">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -145,7 +145,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-04"><a href="#B-04">B&lt;int, char&gt;</a></h2>
+<h2 id="B-04">B&lt;int, char&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -163,7 +163,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-05"><a href="#B-05">B&lt;int, U&gt;</a></h2>
+<h2 id="B-05">B&lt;int, U&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -181,7 +181,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -198,7 +198,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z"><a href="#Z">Z</a></h2>
+<h2 id="Z">Z</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -236,7 +236,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_3way"><a href="#Z-operator_3way">Z::operator&lt;&#x3D;&gt;</a></h2>
+<h2 id="Z-operator_3way">Z::operator&lt;&#x3D;&gt;</h2>
 <div>
 <span>Three-way comparison operator</span>
 
@@ -277,7 +277,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_not_eq"><a href="#Z-operator_not_eq">Z::operator!&#x3D;</a></h2>
+<h2 id="Z-operator_not_eq">Z::operator!&#x3D;</h2>
 <div>
 <span>Inequality operator</span>
 
@@ -318,7 +318,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_eq"><a href="#Z-operator_eq">Z::operator&#x3D;&#x3D;</a></h2>
+<h2 id="Z-operator_eq">Z::operator&#x3D;&#x3D;</h2>
 <div>
 <span>Equality operator</span>
 
@@ -359,7 +359,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-operator_not"><a href="#Z-operator_not">Z::operator!</a></h2>
+<h2 id="Z-operator_not">Z::operator!</h2>
 <div>
 <span>Negation operator</span>
 
@@ -383,7 +383,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2conversion"><a href="#Z-2conversion">Z::operator bool</a></h2>
+<h2 id="Z-2conversion">Z::operator bool</h2>
 <div>
 <span>Conversion to <code>bool</code></span>
 
@@ -406,7 +406,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-foo"><a href="#Z-foo">Z::foo</a></h2>
+<h2 id="Z-foo">Z::foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -422,7 +422,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2destructor"><a href="#Z-2destructor">Z::~Z</a></h2>
+<h2 id="Z-2destructor">Z::~Z</h2>
 <div>
 <span>Destructor</span>
 
@@ -441,7 +441,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2constructor-00"><a href="#Z-2constructor-00">Z::Z</a></h2>
+<h2 id="Z-2constructor-00">Z::Z</h2>
 <div>
 <span>Constructors</span>
 
@@ -470,7 +470,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2constructor-05"><a href="#Z-2constructor-05">Z::Z</a></h2>
+<h2 id="Z-2constructor-05">Z::Z</h2>
 <div>
 <span>Default constructor</span>
 
@@ -489,7 +489,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Z-2constructor-06"><a href="#Z-2constructor-06">Z::Z</a></h2>
+<h2 id="Z-2constructor-06">Z::Z</h2>
 <div>
 <span>Construct from <code>int</code></span>
 
@@ -525,7 +525,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_not_eq"><a href="#operator_not_eq">operator!&#x3D;</a></h2>
+<h2 id="operator_not_eq">operator!&#x3D;</h2>
 <div>
 <span>Inequality operator</span>
 
@@ -572,7 +572,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_eq"><a href="#operator_eq">operator&#x3D;&#x3D;</a></h2>
+<h2 id="operator_eq">operator&#x3D;&#x3D;</h2>
 <div>
 <span>Equality operator</span>
 
@@ -619,7 +619,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_not"><a href="#operator_not">operator!</a></h2>
+<h2 id="operator_not">operator!</h2>
 <div>
 <span>Negation operator</span>
 
@@ -660,7 +660,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="h"><a href="#h">h</a></h2>
+<h2 id="h">h</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -676,7 +676,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0f"><a href="#g-0f">g</a></h2>
+<h2 id="g-0f">g</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -756,7 +756,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="g-03c"><a href="#g-03c">g</a></h2>
+<h2 id="g-03c">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -776,7 +776,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0e4"><a href="#g-0e4">g&lt;int&gt;</a></h2>
+<h2 id="g-0e4">g&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -796,7 +796,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0a"><a href="#g-0a">g</a></h2>
+<h2 id="g-0a">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -815,7 +815,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-03a"><a href="#g-03a">g</a></h2>
+<h2 id="g-03a">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -833,7 +833,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-06"><a href="#g-06">g</a></h2>
+<h2 id="g-06">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -849,7 +849,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-04"><a href="#g-04">g</a></h2>
+<h2 id="g-04">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -865,7 +865,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0e3"><a href="#g-0e3">g</a></h2>
+<h2 id="g-0e3">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -881,7 +881,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/core/empty.html b/test-files/golden-tests/core/empty.html
index 1ee3b8055..135e79d40 100644
--- a/test-files/golden-tests/core/empty.html
+++ b/test-files/golden-tests/core/empty.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 </div>
 
diff --git a/test-files/golden-tests/core/libcxx.html b/test-files/golden-tests/core/libcxx.html
index a0ff234ed..33d4df60d 100644
--- a/test-files/golden-tests/core/libcxx.html
+++ b/test-files/golden-tests/core/libcxx.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="sqrt"><a href="#sqrt">sqrt</a></h2>
+<h2 id="sqrt">sqrt</h2>
 <div>
 <span>Computes the square root of an integral value.</span>
 
diff --git a/test-files/golden-tests/core/utf-8.html b/test-files/golden-tests/core/utf-8.html
index 0f513fe38..a032af748 100644
--- a/test-files/golden-tests/core/utf-8.html
+++ b/test-files/golden-tests/core/utf-8.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="Христос_воскрес"><a href="#Христос_воскрес">Христос_воскрес</a></h2>
+<h2 id="Христос_воскрес">Христос_воскрес</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/filters/file/exclude-self.html b/test-files/golden-tests/filters/file/exclude-self.html
index 1ee3b8055..135e79d40 100644
--- a/test-files/golden-tests/filters/file/exclude-self.html
+++ b/test-files/golden-tests/filters/file/exclude-self.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 </div>
 
diff --git a/test-files/golden-tests/filters/file/include-self.html b/test-files/golden-tests/filters/file/include-self.html
index 0974c6f3f..274afee73 100644
--- a/test-files/golden-tests/filters/file/include-self.html
+++ b/test-files/golden-tests/filters/file/include-self.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Namespaces</h2>
 </div>
 <div>
 <div>
-<h2 id="TEST"><a href="#TEST">TEST</a></h2>
+<h2 id="TEST">TEST</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -43,7 +43,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="TEST-SUCCESS"><a href="#TEST-SUCCESS">TEST::SUCCESS</a></h2>
+<h2 id="TEST-SUCCESS">TEST::SUCCESS</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/filters/file/include-symlink.html b/test-files/golden-tests/filters/file/include-symlink.html
index ed51751e7..a4f6f953a 100644
--- a/test-files/golden-tests/filters/file/include-symlink.html
+++ b/test-files/golden-tests/filters/file/include-symlink.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>A brief.</span>
 
diff --git a/test-files/golden-tests/filters/file/subdirectories.html b/test-files/golden-tests/filters/file/subdirectories.html
index e94b202e7..eed814455 100644
--- a/test-files/golden-tests/filters/file/subdirectories.html
+++ b/test-files/golden-tests/filters/file/subdirectories.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>A brief.</span>
 
diff --git a/test-files/golden-tests/filters/file/subdirectories2.html b/test-files/golden-tests/filters/file/subdirectories2.html
index e94b202e7..eed814455 100644
--- a/test-files/golden-tests/filters/file/subdirectories2.html
+++ b/test-files/golden-tests/filters/file/subdirectories2.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>A brief.</span>
 
diff --git a/test-files/golden-tests/filters/symbol-name/blacklist_0.html b/test-files/golden-tests/filters/symbol-name/blacklist_0.html
index f4e2e9c1e..9d0cceee2 100644
--- a/test-files/golden-tests/filters/symbol-name/blacklist_0.html
+++ b/test-files/golden-tests/filters/symbol-name/blacklist_0.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -27,7 +27,7 @@ <h2>Namespaces</h2>
 </div>
 <div>
 <div>
-<h2 id="N0"><a href="#N0">N0</a></h2>
+<h2 id="N0">N0</h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -45,7 +45,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="N0-f0"><a href="#N0-f0">N0::f0</a></h2>
+<h2 id="N0-f0">N0::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -61,7 +61,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="N4"><a href="#N4">N4</a></h2>
+<h2 id="N4">N4</h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -80,7 +80,7 @@ <h2>Namespaces</h2>
 </div>
 <div>
 <div>
-<h2 id="N4-N5"><a href="#N4-N5">N4::N5</a></h2>
+<h2 id="N4-N5">N4::N5</h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -98,7 +98,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="N4-N5-f1"><a href="#N4-N5-f1">N4::N5::f1</a></h2>
+<h2 id="N4-N5-f1">N4::N5::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -114,7 +114,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="N4-N6"><a href="#N4-N6">N4::N6</a></h2>
+<h2 id="N4-N6">N4::N6</h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -132,7 +132,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="N4-N6-f1"><a href="#N4-N6-f1">N4::N6::f1</a></h2>
+<h2 id="N4-N6-f1">N4::N6::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -148,7 +148,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="N7"><a href="#N7">N7</a></h2>
+<h2 id="N7">N7</h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -166,7 +166,7 @@ <h2>Namespaces</h2>
 </div>
 <div>
 <div>
-<h2 id="N7-N9"><a href="#N7-N9">N7::N9</a></h2>
+<h2 id="N7-N9">N7::N9</h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -184,7 +184,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="N7-N9-g0"><a href="#N7-N9-g0">N7::N9::g0</a></h2>
+<h2 id="N7-N9-g0">N7::N9::g0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/filters/symbol-name/excluded-base-class.html b/test-files/golden-tests/filters/symbol-name/excluded-base-class.html
index 0157aa71a..3c3f80243 100644
--- a/test-files/golden-tests/filters/symbol-name/excluded-base-class.html
+++ b/test-files/golden-tests/filters/symbol-name/excluded-base-class.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Namespaces</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -44,7 +44,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-D"><a href="#A-D">A::D</a></h2>
+<h2 id="A-D">A::D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -92,7 +92,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-D-f"><a href="#A-D-f">A::D::f</a></h2>
+<h2 id="A-D-f">A::D::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -108,7 +108,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-D-g"><a href="#A-D-g">A::D::g</a></h2>
+<h2 id="A-D-g">A::D::g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -125,7 +125,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-D-h"><a href="#A-D-h">A::D::h</a></h2>
+<h2 id="A-D-h">A::D::h</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -142,7 +142,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-D-i"><a href="#A-D-i">A::D::i</a></h2>
+<h2 id="A-D-i">A::D::i</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -158,7 +158,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-E"><a href="#A-E">A::E</a></h2>
+<h2 id="A-E">A::E</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -206,7 +206,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-E-f"><a href="#A-E-f">A::E::f</a></h2>
+<h2 id="A-E-f">A::E::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -222,7 +222,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-E-g"><a href="#A-E-g">A::E::g</a></h2>
+<h2 id="A-E-g">A::E::g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -239,7 +239,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-E-h"><a href="#A-E-h">A::E::h</a></h2>
+<h2 id="A-E-h">A::E::h</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -256,7 +256,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-E-i"><a href="#A-E-i">A::E::i</a></h2>
+<h2 id="A-E-i">A::E::i</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/filters/symbol-name/excluded-namespace-alias.html b/test-files/golden-tests/filters/symbol-name/excluded-namespace-alias.html
index 0ab80d792..dff0319e5 100644
--- a/test-files/golden-tests/filters/symbol-name/excluded-namespace-alias.html
+++ b/test-files/golden-tests/filters/symbol-name/excluded-namespace-alias.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Namespaces</h2>
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -43,7 +43,7 @@ <h2>Namespaces</h2>
 </div>
 <div>
 <div>
-<h2 id="B-U"><a href="#B-U">B::U</a></h2>
+<h2 id="B-U">B::U</h2>
 </div>
 <h2>Namespace Aliases</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -61,7 +61,7 @@ <h2>Namespace Aliases</h2>
 </div>
 <div>
 <div>
-<h2 id="B-U-E"><a href="#B-U-E">B::U::E</a></h2>
+<h2 id="B-U-E">B::U::E</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/filters/symbol-name/extraction-mode.html b/test-files/golden-tests/filters/symbol-name/extraction-mode.html
index 56606c8db..9e1d1f0df 100644
--- a/test-files/golden-tests/filters/symbol-name/extraction-mode.html
+++ b/test-files/golden-tests/filters/symbol-name/extraction-mode.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -75,7 +75,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="regular_ns"><a href="#regular_ns">regular_ns</a></h2>
+<h2 id="regular_ns">regular_ns</h2>
 <div>
 <span>A regular namespace with different filters for members</span>
 
@@ -116,7 +116,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="regular_ns-regular"><a href="#regular_ns-regular">regular_ns::regular</a></h2>
+<h2 id="regular_ns-regular">regular_ns::regular</h2>
 <div>
 <span>A symbol that passes the filters</span>
 
@@ -169,7 +169,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="regular_ns-regular-also_regular"><a href="#regular_ns-regular-also_regular">regular_ns::regular::also_regular</a></h2>
+<h2 id="regular_ns-regular-also_regular">regular_ns::regular::also_regular</h2>
 <div>
 <span>Child of a regular symbol extracted as regular</span>
 
@@ -204,7 +204,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="regular_ns-regular-also_regular-regular_as_well"><a href="#regular_ns-regular-also_regular-regular_as_well">regular_ns::regular::also_regular::regular_as_well</a></h2>
+<h2 id="regular_ns-regular-also_regular-regular_as_well">regular_ns::regular::also_regular::regular_as_well</h2>
 <div>
 <span>Grandchild of a regular symbol extracted as regular</span>
 
@@ -225,7 +225,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="regular_ns-see_below"><a href="#regular_ns-see_below">regular_ns::see_below</a></h2>
+<h2 id="regular_ns-see_below">regular_ns::see_below</h2>
 <div>
 <span>A symbol that passes the see-below filter</span>
 
@@ -250,7 +250,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="regular_ns-get_dependency"><a href="#regular_ns-get_dependency">regular_ns::get_dependency</a></h2>
+<h2 id="regular_ns-get_dependency">regular_ns::get_dependency</h2>
 <div>
 <span>A function to get an excluded symbol</span>
 
@@ -274,7 +274,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="regular_ns-get_implementation_defined"><a href="#regular_ns-get_implementation_defined">regular_ns::get_implementation_defined</a></h2>
+<h2 id="regular_ns-get_implementation_defined">regular_ns::get_implementation_defined</h2>
 <div>
 <span>A function to get an implementation-defined symbol</span>
 
@@ -303,7 +303,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="regular_ns-get_regular"><a href="#regular_ns-get_regular">regular_ns::get_regular</a></h2>
+<h2 id="regular_ns-get_regular">regular_ns::get_regular</h2>
 <div>
 <span>A function to get a regular symbol</span>
 
@@ -331,7 +331,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="regular_ns-get_see_below"><a href="#regular_ns-get_see_below">regular_ns::get_see_below</a></h2>
+<h2 id="regular_ns-get_see_below">regular_ns::get_see_below</h2>
 <div>
 <span>A function to get a see-below symbol</span>
 
@@ -359,7 +359,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="see_below_ns"><a href="#see_below_ns">see_below_ns</a></h2>
+<h2 id="see_below_ns">see_below_ns</h2>
 <div>
 <span>A see-below namespace</span>
 
@@ -403,7 +403,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="see_below_ns-regular"><a href="#see_below_ns-regular">see_below_ns::regular</a></h2>
+<h2 id="see_below_ns-regular">see_below_ns::regular</h2>
 <div>
 <span>Regular symbol in a see-below namespace</span>
 
@@ -428,7 +428,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="see_below_ns-see_below"><a href="#see_below_ns-see_below">see_below_ns::see_below</a></h2>
+<h2 id="see_below_ns-see_below">see_below_ns::see_below</h2>
 <div>
 <span>See-below symbol in a see-below namespace</span>
 
@@ -453,7 +453,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="see_below_ns-get_dependency"><a href="#see_below_ns-get_dependency">see_below_ns::get_dependency</a></h2>
+<h2 id="see_below_ns-get_dependency">see_below_ns::get_dependency</h2>
 <div>
 <span>A function to get a dependency symbol in a see-below namespace</span>
 
@@ -478,7 +478,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="see_below_ns-get_implementation_defined"><a href="#see_below_ns-get_implementation_defined">see_below_ns::get_implementation_defined</a></h2>
+<h2 id="see_below_ns-get_implementation_defined">see_below_ns::get_implementation_defined</h2>
 <div>
 <span>A function to get an implementation-defined symbol in a see-below namespace</span>
 
@@ -507,7 +507,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="dependency_ns_alias"><a href="#dependency_ns_alias">dependency_ns_alias</a></h2>
+<h2 id="dependency_ns_alias">dependency_ns_alias</h2>
 <div>
 <span>Namespace alias to form the dependency on dependency_ns</span>
 
@@ -526,7 +526,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="implementation_defined_ns_alias"><a href="#implementation_defined_ns_alias">implementation_defined_ns_alias</a></h2>
+<h2 id="implementation_defined_ns_alias">implementation_defined_ns_alias</h2>
 <div>
 <span>Namespace alias to form a dependency on the implementation-defined namespace</span>
 
@@ -545,7 +545,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="see_below_ns_alias"><a href="#see_below_ns_alias">see_below_ns_alias</a></h2>
+<h2 id="see_below_ns_alias">see_below_ns_alias</h2>
 <div>
 <span>Namespace alias to form a dependency on the see-below namespace</span>
 
@@ -568,7 +568,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="regular"><a href="#regular">regular</a></h2>
+<h2 id="regular">regular</h2>
 <div>
 <span>A regular symbol in the global namespace</span>
 
@@ -621,7 +621,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="regular-also_regular"><a href="#regular-also_regular">regular::also_regular</a></h2>
+<h2 id="regular-also_regular">regular::also_regular</h2>
 <div>
 <span>Child of a regular symbol: should be traversed as usual</span>
 
@@ -656,7 +656,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="regular-also_regular-regular_as_well"><a href="#regular-also_regular-regular_as_well">regular::also_regular::regular_as_well</a></h2>
+<h2 id="regular-also_regular-regular_as_well">regular::also_regular::regular_as_well</h2>
 <div>
 <span>Grandchild of a regular symbol: should be traversed as usual</span>
 
@@ -677,7 +677,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="see_below"><a href="#see_below">see_below</a></h2>
+<h2 id="see_below">see_below</h2>
 <div>
 <span>A see-below symbol in the global namespace</span>
 
@@ -703,7 +703,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="get_dependency"><a href="#get_dependency">get_dependency</a></h2>
+<h2 id="get_dependency">get_dependency</h2>
 <div>
 <span>A function to get a dependency symbol on the global namespace</span>
 
@@ -727,7 +727,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="get_implementation_defined"><a href="#get_implementation_defined">get_implementation_defined</a></h2>
+<h2 id="get_implementation_defined">get_implementation_defined</h2>
 <div>
 <span>A function to get an implementation-defined symbol in the global namespace</span>
 
@@ -756,7 +756,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="get_regular"><a href="#get_regular">get_regular</a></h2>
+<h2 id="get_regular">get_regular</h2>
 <div>
 <span>A function to get a regular symbol in the global namespace</span>
 
@@ -784,7 +784,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="get_see_below"><a href="#get_see_below">get_see_below</a></h2>
+<h2 id="get_see_below">get_see_below</h2>
 <div>
 <span>A function to get a see-below symbol in the global namespace</span>
 
diff --git a/test-files/golden-tests/filters/symbol-name/impl-defined-member.html b/test-files/golden-tests/filters/symbol-name/impl-defined-member.html
index cb8f26140..92b08bc7d 100644
--- a/test-files/golden-tests/filters/symbol-name/impl-defined-member.html
+++ b/test-files/golden-tests/filters/symbol-name/impl-defined-member.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -39,7 +39,7 @@ <h2>Variables</h2>
 </div>
 <div>
 <div>
-<h2 id="regular"><a href="#regular">regular</a></h2>
+<h2 id="regular">regular</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -57,7 +57,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="regular-absolute_uri_rule_t"><a href="#regular-absolute_uri_rule_t">regular::absolute_uri_rule_t</a></h2>
+<h2 id="regular-absolute_uri_rule_t">regular::absolute_uri_rule_t</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -74,7 +74,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="absolute_uri_rule"><a href="#absolute_uri_rule">absolute_uri_rule</a></h2>
+<h2 id="absolute_uri_rule">absolute_uri_rule</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -89,7 +89,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="regular_absolute_uri_rule"><a href="#regular_absolute_uri_rule">regular_absolute_uri_rule</a></h2>
+<h2 id="regular_absolute_uri_rule">regular_absolute_uri_rule</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/filters/symbol-name/whitelist_0.html b/test-files/golden-tests/filters/symbol-name/whitelist_0.html
index f2b02e598..2f46d7230 100644
--- a/test-files/golden-tests/filters/symbol-name/whitelist_0.html
+++ b/test-files/golden-tests/filters/symbol-name/whitelist_0.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -42,7 +42,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="N0"><a href="#N0">N0</a></h2>
+<h2 id="N0">N0</h2>
 <div>
 <span>This namespace should extracted because it&#x27;s implied by <code>N0::f0_WL</code></span>
 
@@ -65,7 +65,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="N0-f0_WL"><a href="#N0-f0_WL">N0::f0_WL</a></h2>
+<h2 id="N0-f0_WL">N0::f0_WL</h2>
 <div>
 <span>This function should be included because it matches <code>N0::f0_WL</code></span>
 
@@ -85,7 +85,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="N1"><a href="#N1">N1</a></h2>
+<h2 id="N1">N1</h2>
 <div>
 <span>This namespace should extracted because it&#x27;s implied by <code>N1::N3_WL</code> and <code>N1::N4::f1_WL</code></span>
 
@@ -109,7 +109,7 @@ <h2>Namespaces</h2>
 </div>
 <div>
 <div>
-<h2 id="N1-N3_WL"><a href="#N1-N3_WL">N1::N3_WL</a></h2>
+<h2 id="N1-N3_WL">N1::N3_WL</h2>
 <div>
 <span>This namespace should extracted because it&#x27;s explicitly included by <code>N1::N3_WL</code></span>
 
@@ -132,7 +132,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="N1-N3_WL-f1_WL"><a href="#N1-N3_WL-f1_WL">N1::N3_WL::f1_WL</a></h2>
+<h2 id="N1-N3_WL-f1_WL">N1::N3_WL::f1_WL</h2>
 <div>
 <span>This function should extracted because the namespace <code>N1::N3_WL</code> is included as a literal.</span>
 
@@ -152,7 +152,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="N1-N4"><a href="#N1-N4">N1::N4</a></h2>
+<h2 id="N1-N4">N1::N4</h2>
 <div>
 <span>This namespace should extracted because it&#x27;s implied by <code>N1::N4::f1_WL</code></span>
 
@@ -175,7 +175,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="N1-N4-f1_WL"><a href="#N1-N4-f1_WL">N1::N4::f1_WL</a></h2>
+<h2 id="N1-N4-f1_WL">N1::N4::f1_WL</h2>
 <div>
 <span>This function should extracted because it matches <code>N1::N4::f1_WL</code></span>
 
@@ -195,7 +195,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="N5"><a href="#N5">N5</a></h2>
+<h2 id="N5">N5</h2>
 <div>
 <span>This namespace should extracted because it&#x27;s implied by <code>N5::N6::*7</code></span>
 
@@ -218,7 +218,7 @@ <h2>Namespaces</h2>
 </div>
 <div>
 <div>
-<h2 id="N5-N6"><a href="#N5-N6">N5::N6</a></h2>
+<h2 id="N5-N6">N5::N6</h2>
 <div>
 <span>This namespace should extracted because it&#x27;s implied by <code>N5::N6::*7</code></span>
 
@@ -242,7 +242,7 @@ <h2>Namespaces</h2>
 </div>
 <div>
 <div>
-<h2 id="N5-N6-M7"><a href="#N5-N6-M7">N5::N6::M7</a></h2>
+<h2 id="N5-N6-M7">N5::N6::M7</h2>
 <div>
 <span>This namespace should be included because it matches <code>N5::N6::*7</code></span>
 
@@ -265,7 +265,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="N5-N6-M7-f2_WL"><a href="#N5-N6-M7-f2_WL">N5::N6::M7::f2_WL</a></h2>
+<h2 id="N5-N6-M7-f2_WL">N5::N6::M7::f2_WL</h2>
 <div>
 <span>This function should be included because it&#x27;s a member of <code>M7</code>, which matches <code>N5::N6::*7</code></span>
 
@@ -285,7 +285,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="N5-N6-N7"><a href="#N5-N6-N7">N5::N6::N7</a></h2>
+<h2 id="N5-N6-N7">N5::N6::N7</h2>
 <div>
 <span>This namespace should be included because it matches <code>N5::N6::*7</code></span>
 
@@ -308,7 +308,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="N5-N6-N7-f2_WL"><a href="#N5-N6-N7-f2_WL">N5::N6::N7::f2_WL</a></h2>
+<h2 id="N5-N6-N7-f2_WL">N5::N6::N7::f2_WL</h2>
 <div>
 <span>This function should be included because it&#x27;s a member of <code>N7</code>, which matches <code>N5::N6::*7</code></span>
 
@@ -328,7 +328,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C"><a href="#C">C</a></h2>
+<h2 id="C">C</h2>
 <div>
 <span>This namespace should be included because it strictly matches <code>C</code></span>
 
@@ -377,7 +377,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="C-D"><a href="#C-D">C::D</a></h2>
+<h2 id="C-D">C::D</h2>
 <div>
 <span>This struct should be included because it&#x27;s a member of <code>C</code></span>
 
@@ -412,7 +412,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="C-D-f1_WL"><a href="#C-D-f1_WL">C::D::f1_WL</a></h2>
+<h2 id="C-D-f1_WL">C::D::f1_WL</h2>
 <div>
 <span>This function should be included because it&#x27;s a member of <code>D</code></span>
 
@@ -432,7 +432,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-f0_WL"><a href="#C-f0_WL">C::f0_WL</a></h2>
+<h2 id="C-f0_WL">C::f0_WL</h2>
 <div>
 <span>This function should be included because it&#x27;s a member of <code>C</code></span>
 
diff --git a/test-files/golden-tests/filters/symbol-type/nested-private-template.html b/test-files/golden-tests/filters/symbol-type/nested-private-template.html
index 85405ef6c..e5de5fe34 100644
--- a/test-files/golden-tests/filters/symbol-type/nested-private-template.html
+++ b/test-files/golden-tests/filters/symbol-type/nested-private-template.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="range"><a href="#range">range</a></h2>
+<h2 id="range">range</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -57,7 +57,7 @@ <h2>Private Types</h2>
 </div>
 <div>
 <div>
-<h2 id="range-impl-0e"><a href="#range-impl-0e">range::impl</a></h2>
+<h2 id="range-impl-0e">range::impl</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -77,7 +77,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="range-impl-00"><a href="#range-impl-00">range::impl&lt;R, false&gt;</a></h2>
+<h2 id="range-impl-00">range::impl&lt;R, false&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/javadoc/brief/brief-1.html b/test-files/golden-tests/javadoc/brief/brief-1.html
index 7305d4783..0b14485e0 100644
--- a/test-files/golden-tests/javadoc/brief/brief-1.html
+++ b/test-files/golden-tests/javadoc/brief/brief-1.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -27,7 +27,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f5"><a href="#f5">f5</a></h2>
+<h2 id="f5">f5</h2>
 <div>
 <span>brief bold it continues to the line.</span>
 
@@ -47,7 +47,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f6"><a href="#f6">f6</a></h2>
+<h2 id="f6">f6</h2>
 <div>
 <span>brief</span>
 
diff --git a/test-files/golden-tests/javadoc/brief/brief-2.html b/test-files/golden-tests/javadoc/brief/brief-2.html
index e3771c03d..07c8b1579 100644
--- a/test-files/golden-tests/javadoc/brief/brief-2.html
+++ b/test-files/golden-tests/javadoc/brief/brief-2.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -31,7 +31,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 <div>
 <span>brief</span>
 
@@ -51,7 +51,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f2"><a href="#f2">f2</a></h2>
+<h2 id="f2">f2</h2>
 <div>
 <span>brief</span>
 
@@ -71,7 +71,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f3"><a href="#f3">f3</a></h2>
+<h2 id="f3">f3</h2>
 <div>
 <span>brief</span>
 
@@ -91,7 +91,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f4"><a href="#f4">f4</a></h2>
+<h2 id="f4">f4</h2>
 <div>
 <span>brief x</span>
 
@@ -115,7 +115,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="f5"><a href="#f5">f5</a></h2>
+<h2 id="f5">f5</h2>
 <div>
 <span>brief</span>
 
@@ -135,7 +135,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f6"><a href="#f6">f6</a></h2>
+<h2 id="f6">f6</h2>
 <div>
 <span>brief</span>
 
diff --git a/test-files/golden-tests/javadoc/brief/brief-3.html b/test-files/golden-tests/javadoc/brief/brief-3.html
index e0447c8d7..009ac67db 100644
--- a/test-files/golden-tests/javadoc/brief/brief-3.html
+++ b/test-files/golden-tests/javadoc/brief/brief-3.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f-0c"><a href="#f-0c">f</a></h2>
+<h2 id="f-0c">f</h2>
 <div>
 <span><code>f</code> overloads</span>
 
@@ -73,7 +73,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="f-06"><a href="#f-06">f</a></h2>
+<h2 id="f-06">f</h2>
 <div>
 <span>Integer overload.</span>
 
@@ -97,7 +97,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="f-0f"><a href="#f-0f">f</a></h2>
+<h2 id="f-0f">f</h2>
 <div>
 <span>Integer overload.</span>
 
@@ -117,7 +117,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f-07"><a href="#f-07">f</a></h2>
+<h2 id="f-07">f</h2>
 <div>
 <span>C string overload.</span>
 
@@ -141,7 +141,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="f-0b"><a href="#f-0b">f</a></h2>
+<h2 id="f-0b">f</h2>
 <div>
 <span>C string overload.</span>
 
diff --git a/test-files/golden-tests/javadoc/brief/brief-4.html b/test-files/golden-tests/javadoc/brief/brief-4.html
index b348da779..d92240515 100644
--- a/test-files/golden-tests/javadoc/brief/brief-4.html
+++ b/test-files/golden-tests/javadoc/brief/brief-4.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -28,7 +28,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f0"><a href="#f0">f0</a></h2>
+<h2 id="f0">f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -44,7 +44,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -60,7 +60,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f2"><a href="#f2">f2</a></h2>
+<h2 id="f2">f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -76,7 +76,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f3"><a href="#f3">f3</a></h2>
+<h2 id="f3">f3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/javadoc/brief/brief-5.html b/test-files/golden-tests/javadoc/brief/brief-5.html
index b107cdcc1..2020cff37 100644
--- a/test-files/golden-tests/javadoc/brief/brief-5.html
+++ b/test-files/golden-tests/javadoc/brief/brief-5.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -31,7 +31,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f0"><a href="#f0">f0</a></h2>
+<h2 id="f0">f0</h2>
 <div>
 <span>brief</span>
 
@@ -51,7 +51,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -67,7 +67,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f2"><a href="#f2">f2</a></h2>
+<h2 id="f2">f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -83,7 +83,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f3"><a href="#f3">f3</a></h2>
+<h2 id="f3">f3</h2>
 <div>
 <span>brief</span>
 
@@ -103,7 +103,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f4"><a href="#f4">f4</a></h2>
+<h2 id="f4">f4</h2>
 <div>
 <span>brief</span>
 
@@ -123,7 +123,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f5"><a href="#f5">f5</a></h2>
+<h2 id="f5">f5</h2>
 <div>
 <span>brief</span>
 
diff --git a/test-files/golden-tests/javadoc/brief/brief-6.html b/test-files/golden-tests/javadoc/brief/brief-6.html
index cc163be7f..76f44e7bf 100644
--- a/test-files/golden-tests/javadoc/brief/brief-6.html
+++ b/test-files/golden-tests/javadoc/brief/brief-6.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f0"><a href="#f0">f0</a></h2>
+<h2 id="f0">f0</h2>
 <div>
 <span>brief</span>
 
diff --git a/test-files/golden-tests/javadoc/code/code.html b/test-files/golden-tests/javadoc/code/code.html
index c01d80ae4..351de615c 100644
--- a/test-files/golden-tests/javadoc/code/code.html
+++ b/test-files/golden-tests/javadoc/code/code.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>brief</span>
 
diff --git a/test-files/golden-tests/javadoc/copybrief/copybrief.html b/test-files/golden-tests/javadoc/copybrief/copybrief.html
index a39ed9c94..fedbf564a 100644
--- a/test-files/golden-tests/javadoc/copybrief/copybrief.html
+++ b/test-files/golden-tests/javadoc/copybrief/copybrief.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -28,7 +28,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 <div>
 <span>brief1</span>
 
@@ -48,7 +48,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f2"><a href="#f2">f2</a></h2>
+<h2 id="f2">f2</h2>
 <div>
 <span>brief1</span>
 
@@ -68,7 +68,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f3"><a href="#f3">f3</a></h2>
+<h2 id="f3">f3</h2>
 <div>
 <span>brief1</span>
 
diff --git a/test-files/golden-tests/javadoc/copydetails/copydetails.html b/test-files/golden-tests/javadoc/copydetails/copydetails.html
index f2d2eb176..6cc9d5da8 100644
--- a/test-files/golden-tests/javadoc/copydetails/copydetails.html
+++ b/test-files/golden-tests/javadoc/copydetails/copydetails.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -28,7 +28,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="dest"><a href="#dest">dest</a></h2>
+<h2 id="dest">dest</h2>
 <div>
 <span>Destination doc function</span>
 
@@ -121,7 +121,7 @@ <h3>See Also</h3>
 </div>
 <div>
 <div>
-<h2 id="destOverride"><a href="#destOverride">destOverride</a></h2>
+<h2 id="destOverride">destOverride</h2>
 <div>
 <span>Destination doc function</span>
 
@@ -242,7 +242,7 @@ <h3>See Also</h3>
 </div>
 <div>
 <div>
-<h2 id="source"><a href="#source">source</a></h2>
+<h2 id="source">source</h2>
 <div>
 <span>Source doc function</span>
 
diff --git a/test-files/golden-tests/javadoc/copydoc/conversion.html b/test-files/golden-tests/javadoc/copydoc/conversion.html
index 5850bb2f0..77aba528e 100644
--- a/test-files/golden-tests/javadoc/copydoc/conversion.html
+++ b/test-files/golden-tests/javadoc/copydoc/conversion.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -27,7 +27,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -60,7 +60,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-operator_assign-04"><a href="#A-operator_assign-04">A::operator&#x3D;</a></h2>
+<h2 id="A-operator_assign-04">A::operator&#x3D;</h2>
 <div>
 <span>Convert a string to A</span>
 
@@ -112,7 +112,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-operator_assign-08"><a href="#A-operator_assign-08">A::operator&#x3D;</a></h2>
+<h2 id="A-operator_assign-08">A::operator&#x3D;</h2>
 <div>
 <span>Convert a string to A</span>
 
@@ -153,7 +153,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-operator_assign-00"><a href="#A-operator_assign-00">A::operator&#x3D;</a></h2>
+<h2 id="A-operator_assign-00">A::operator&#x3D;</h2>
 <div>
 <span>Convert a string to A</span>
 
@@ -194,7 +194,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-2conversion-02"><a href="#A-2conversion-02">A::operator string_type</a></h2>
+<h2 id="A-2conversion-02">A::operator string_type</h2>
 <div>
 <span>Convert A to a string</span>
 
@@ -217,7 +217,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="A-2conversion-00"><a href="#A-2conversion-00">A::operator string_view_type</a></h2>
+<h2 id="A-2conversion-00">A::operator string_view_type</h2>
 <div>
 <span>Convert A to a string</span>
 
@@ -240,7 +240,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="string_type"><a href="#string_type">string_type</a></h2>
+<h2 id="string_type">string_type</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -257,7 +257,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="string_view_type"><a href="#string_view_type">string_view_type</a></h2>
+<h2 id="string_view_type">string_view_type</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/javadoc/copydoc/decay-params.html b/test-files/golden-tests/javadoc/copydoc/decay-params.html
index 1527d8f91..4cd0cb61c 100644
--- a/test-files/golden-tests/javadoc/copydoc/decay-params.html
+++ b/test-files/golden-tests/javadoc/copydoc/decay-params.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -27,7 +27,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="bar"><a href="#bar">bar</a></h2>
+<h2 id="bar">bar</h2>
 <div>
 <span>Brief from <code>foo()</code></span>
 
@@ -73,7 +73,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="foo-02"><a href="#foo-02">foo</a></h2>
+<h2 id="foo-02">foo</h2>
 <div>
 <span><code>foo</code> overloads</span>
 
@@ -134,7 +134,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="foo-0c"><a href="#foo-0c">foo</a></h2>
+<h2 id="foo-0c">foo</h2>
 <div>
 <span>We should not copy this doc</span>
 
@@ -158,7 +158,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="foo-01"><a href="#foo-01">foo</a></h2>
+<h2 id="foo-01">foo</h2>
 <div>
 <span>We should not copy this doc</span>
 
@@ -199,7 +199,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="foo-0e"><a href="#foo-0e">foo</a></h2>
+<h2 id="foo-0e">foo</h2>
 <div>
 <span>Brief from <code>foo()</code></span>
 
diff --git a/test-files/golden-tests/javadoc/copydoc/fundamental.html b/test-files/golden-tests/javadoc/copydoc/fundamental.html
index 8cd3583fe..73b03a9af 100644
--- a/test-files/golden-tests/javadoc/copydoc/fundamental.html
+++ b/test-files/golden-tests/javadoc/copydoc/fundamental.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -28,7 +28,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f-0c"><a href="#f-0c">f</a></h2>
+<h2 id="f-0c">f</h2>
 <div>
 <span><code>f</code> overloads</span>
 
@@ -76,7 +76,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="f-06"><a href="#f-06">f</a></h2>
+<h2 id="f-06">f</h2>
 <div>
 <span>Fail</span>
 
@@ -113,7 +113,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="f-04"><a href="#f-04">f</a></h2>
+<h2 id="f-04">f</h2>
 <div>
 <span>Brief</span>
 
@@ -154,7 +154,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="g"><a href="#g">g</a></h2>
+<h2 id="g">g</h2>
 <div>
 <span>Brief</span>
 
@@ -195,7 +195,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="h"><a href="#h">h</a></h2>
+<h2 id="h">h</h2>
 <div>
 <span>Brief</span>
 
diff --git a/test-files/golden-tests/javadoc/copydoc/no-param.html b/test-files/golden-tests/javadoc/copydoc/no-param.html
index cba11cdda..3151a787f 100644
--- a/test-files/golden-tests/javadoc/copydoc/no-param.html
+++ b/test-files/golden-tests/javadoc/copydoc/no-param.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -28,7 +28,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="copyFromNoParam"><a href="#copyFromNoParam">copyFromNoParam</a></h2>
+<h2 id="copyFromNoParam">copyFromNoParam</h2>
 <div>
 <span>Brief from <code>foo()</code></span>
 
@@ -58,7 +58,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="copyfromOverloads"><a href="#copyfromOverloads">copyfromOverloads</a></h2>
+<h2 id="copyfromOverloads">copyfromOverloads</h2>
 <div>
 <span>Brief from <code>foo()</code></span>
 
@@ -87,7 +87,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="foo-02"><a href="#foo-02">foo</a></h2>
+<h2 id="foo-02">foo</h2>
 <div>
 <span>Brief from <code>foo()</code></span>
 
@@ -141,7 +141,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="foo-0c"><a href="#foo-0c">foo</a></h2>
+<h2 id="foo-0c">foo</h2>
 <div>
 <span>Brief from <code>foo()</code></span>
 
@@ -170,7 +170,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="foo-0a"><a href="#foo-0a">foo</a></h2>
+<h2 id="foo-0a">foo</h2>
 <div>
 <span>Brief from <code>foo()</code></span>
 
diff --git a/test-files/golden-tests/javadoc/copydoc/operator-param.html b/test-files/golden-tests/javadoc/copydoc/operator-param.html
index 69beb6df7..62c5ec86b 100644
--- a/test-files/golden-tests/javadoc/copydoc/operator-param.html
+++ b/test-files/golden-tests/javadoc/copydoc/operator-param.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -56,7 +56,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-operator_call-08"><a href="#A-operator_call-08">A::operator()</a></h2>
+<h2 id="A-operator_call-08">A::operator()</h2>
 <div>
 <span>Return true if ch is in the character set.</span>
 
@@ -110,7 +110,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-operator_call-0f"><a href="#A-operator_call-0f">A::operator()</a></h2>
+<h2 id="A-operator_call-0f">A::operator()</h2>
 <div>
 <span>Return true if ch is in the character set.</span>
 
@@ -156,7 +156,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-operator_call-0b"><a href="#A-operator_call-0b">A::operator()</a></h2>
+<h2 id="A-operator_call-0b">A::operator()</h2>
 <div>
 <span>Return true if ch is in the character set.</span>
 
diff --git a/test-files/golden-tests/javadoc/copydoc/param-types.html b/test-files/golden-tests/javadoc/copydoc/param-types.html
index d9c0037c5..66e84ee33 100644
--- a/test-files/golden-tests/javadoc/copydoc/param-types.html
+++ b/test-files/golden-tests/javadoc/copydoc/param-types.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -70,7 +70,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="N"><a href="#N">N</a></h2>
+<h2 id="N">N</h2>
 <div>
 <span>Namespace to test qualified identifier parameters.</span>
 
@@ -93,7 +93,7 @@ <h2>Namespaces</h2>
 </div>
 <div>
 <div>
-<h2 id="N-M"><a href="#N-M">N::M</a></h2>
+<h2 id="N-M">N::M</h2>
 <div>
 <span>Namespace to test qualified identifier parameters.</span>
 
@@ -116,7 +116,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="N-M-Q"><a href="#N-M-Q">N::M::Q</a></h2>
+<h2 id="N-M-Q">N::M::Q</h2>
 <div>
 <span>Struct to test qualified identifier parameters.</span>
 
@@ -151,7 +151,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 <div>
 <span>Struct to test explicit object member functions.</span>
 
@@ -201,7 +201,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-f"><a href="#A-f">A::f</a></h2>
+<h2 id="A-f">A::f</h2>
 <div>
 <span>Reference member function.</span>
 
@@ -243,7 +243,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-g"><a href="#A-g">A::g</a></h2>
+<h2 id="A-g">A::g</h2>
 <div>
 <span>Reference member function.</span>
 
@@ -290,7 +290,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="paramType"><a href="#paramType">paramType</a></h2>
+<h2 id="paramType">paramType</h2>
 <div>
 <span>Struct used to vary the parameter type.</span>
 
@@ -334,7 +334,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="testEnum"><a href="#testEnum">testEnum</a></h2>
+<h2 id="testEnum">testEnum</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -347,19 +347,6 @@ <h3>Synopsis</h3>
 </pre>
 </div>
 <div>
-<h3>Members</h3>
-<table>
-<thead>
-<tr>
-<th>Name</th>
-<th>Description</th>
-</tr>
-</thead>
-<tbody>
-</tbody>
-</table>
-</div>
-<div>
 <h2>Non-Member Functions</h2>
 <table>
 <thead>
@@ -376,7 +363,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f-0c7"><a href="#f-0c7">f</a></h2>
+<h2 id="f-0c7">f</h2>
 <div>
 <span><code>f</code> overloads</span>
 
@@ -488,7 +475,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="f-0b3"><a href="#f-0b3">f</a></h2>
+<h2 id="f-0b3">f</h2>
 <div>
 <span>Reference function.</span>
 
@@ -512,7 +499,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="f-00"><a href="#f-00">f</a></h2>
+<h2 id="f-00">f</h2>
 <div>
 <span>Reference function.</span>
 
@@ -554,7 +541,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="f-08c"><a href="#f-08c">f</a></h2>
+<h2 id="f-08c">f</h2>
 <div>
 <span>Reference function.</span>
 
@@ -596,7 +583,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="f-012"><a href="#f-012">f</a></h2>
+<h2 id="f-012">f</h2>
 <div>
 <span>Variadic function</span>
 
@@ -638,7 +625,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="f-0c1"><a href="#f-0c1">f</a></h2>
+<h2 id="f-0c1">f</h2>
 <div>
 <span>Non-variadic function</span>
 
@@ -680,7 +667,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="f-03"><a href="#f-03">f</a></h2>
+<h2 id="f-03">f</h2>
 <div>
 <span>struct param function</span>
 
@@ -722,7 +709,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="f-04"><a href="#f-04">f</a></h2>
+<h2 id="f-04">f</h2>
 <div>
 <span>Decltype function</span>
 
@@ -764,7 +751,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="f-0b5"><a href="#f-0b5">f</a></h2>
+<h2 id="f-0b5">f</h2>
 <div>
 <span>struct param function</span>
 
@@ -806,7 +793,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="f-010"><a href="#f-010">f</a></h2>
+<h2 id="f-010">f</h2>
 <div>
 <span>Enum param function</span>
 
@@ -848,7 +835,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="f-081"><a href="#f-081">f</a></h2>
+<h2 id="f-081">f</h2>
 <div>
 <span>Qualified identifier param function</span>
 
@@ -890,7 +877,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0f"><a href="#g-0f">g</a></h2>
+<h2 id="g-0f">g</h2>
 <div>
 <span><code>g</code> overloads</span>
 
@@ -984,7 +971,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="g-05"><a href="#g-05">g</a></h2>
+<h2 id="g-05">g</h2>
 <div>
 <span>struct param function</span>
 
@@ -1025,7 +1012,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="g-09c"><a href="#g-09c">g</a></h2>
+<h2 id="g-09c">g</h2>
 <div>
 <span>Qualified identifier param function</span>
 
@@ -1066,7 +1053,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0b"><a href="#g-0b">g</a></h2>
+<h2 id="g-0b">g</h2>
 <div>
 <span>Auto function</span>
 
@@ -1107,7 +1094,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="g-04c"><a href="#g-04c">g</a></h2>
+<h2 id="g-04c">g</h2>
 <div>
 <span>Enum param function</span>
 
@@ -1148,7 +1135,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="g-096"><a href="#g-096">g</a></h2>
+<h2 id="g-096">g</h2>
 <div>
 <span>Variadic function</span>
 
@@ -1189,7 +1176,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="g-04a"><a href="#g-04a">g</a></h2>
+<h2 id="g-04a">g</h2>
 <div>
 <span>Non-variadic function</span>
 
@@ -1230,7 +1217,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0c"><a href="#g-0c">g</a></h2>
+<h2 id="g-0c">g</h2>
 <div>
 <span>Decltype function</span>
 
diff --git a/test-files/golden-tests/javadoc/copydoc/qualified.html b/test-files/golden-tests/javadoc/copydoc/qualified.html
index 9765eeece..32607e767 100644
--- a/test-files/golden-tests/javadoc/copydoc/qualified.html
+++ b/test-files/golden-tests/javadoc/copydoc/qualified.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -39,7 +39,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="N"><a href="#N">N</a></h2>
+<h2 id="N">N</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -57,7 +57,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="N-A"><a href="#N-A">N::A</a></h2>
+<h2 id="N-A">N::A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -103,7 +103,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="N-A-B"><a href="#N-A-B">N::A::B</a></h2>
+<h2 id="N-A-B">N::A::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -120,7 +120,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="N-A-f-05"><a href="#N-A-f-05">N::A::f</a></h2>
+<h2 id="N-A-f-05">N::A::f</h2>
 <div>
 <span>Reference function</span>
 
@@ -216,7 +216,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="N-A-f-0a"><a href="#N-A-f-0a">N::A::f</a></h2>
+<h2 id="N-A-f-0a">N::A::f</h2>
 <div>
 <span>Reference function</span>
 
@@ -257,7 +257,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="N-A-f-0b"><a href="#N-A-f-0b">N::A::f</a></h2>
+<h2 id="N-A-f-0b">N::A::f</h2>
 <div>
 <span>Reference function</span>
 
@@ -298,7 +298,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="N-A-f-0e"><a href="#N-A-f-0e">N::A::f</a></h2>
+<h2 id="N-A-f-0e">N::A::f</h2>
 <div>
 <span>Reference function</span>
 
@@ -339,7 +339,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="N-A-f-00"><a href="#N-A-f-00">N::A::f</a></h2>
+<h2 id="N-A-f-00">N::A::f</h2>
 <div>
 <span>Reference function</span>
 
@@ -380,7 +380,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="N-A-f-02"><a href="#N-A-f-02">N::A::f</a></h2>
+<h2 id="N-A-f-02">N::A::f</h2>
 <div>
 <span>Reference function</span>
 
@@ -421,7 +421,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="N-A-f-092"><a href="#N-A-f-092">N::A::f</a></h2>
+<h2 id="N-A-f-092">N::A::f</h2>
 <div>
 <span>Reference function</span>
 
@@ -462,7 +462,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="N-A-f-097"><a href="#N-A-f-097">N::A::f</a></h2>
+<h2 id="N-A-f-097">N::A::f</h2>
 <div>
 <span>Reference function</span>
 
@@ -503,7 +503,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="N-A-f-07"><a href="#N-A-f-07">N::A::f</a></h2>
+<h2 id="N-A-f-07">N::A::f</h2>
 <div>
 <span>Reference function</span>
 
@@ -544,7 +544,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="N-A-g-06e"><a href="#N-A-g-06e">N::A::g</a></h2>
+<h2 id="N-A-g-06e">N::A::g</h2>
 <div>
 <span><code>g</code> overloads</span>
 
@@ -592,7 +592,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="N-A-g-0a"><a href="#N-A-g-0a">N::A::g</a></h2>
+<h2 id="N-A-g-0a">N::A::g</h2>
 <div>
 <span>Reference function</span>
 
@@ -633,7 +633,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="N-A-g-06c"><a href="#N-A-g-06c">N::A::g</a></h2>
+<h2 id="N-A-g-06c">N::A::g</h2>
 <div>
 <span>Fail</span>
 
@@ -674,7 +674,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="N-A-h-05"><a href="#N-A-h-05">N::A::h</a></h2>
+<h2 id="N-A-h-05">N::A::h</h2>
 <div>
 <span><code>h</code> overloads</span>
 
@@ -722,7 +722,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="N-A-h-0f"><a href="#N-A-h-0f">N::A::h</a></h2>
+<h2 id="N-A-h-0f">N::A::h</h2>
 <div>
 <span>Reference function</span>
 
@@ -763,7 +763,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="N-A-h-06"><a href="#N-A-h-06">N::A::h</a></h2>
+<h2 id="N-A-h-06">N::A::h</h2>
 <div>
 <span>Fail</span>
 
@@ -804,7 +804,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="param_t"><a href="#param_t">param_t</a></h2>
+<h2 id="param_t">param_t</h2>
 <div>
 <span>Helper class for distinct parameter types</span>
 
diff --git a/test-files/golden-tests/javadoc/copydoc/qualifiers.html b/test-files/golden-tests/javadoc/copydoc/qualifiers.html
index 61a628437..0f2a7feb7 100644
--- a/test-files/golden-tests/javadoc/copydoc/qualifiers.html
+++ b/test-files/golden-tests/javadoc/copydoc/qualifiers.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -74,7 +74,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-const_iterator"><a href="#A-const_iterator">A::const_iterator</a></h2>
+<h2 id="A-const_iterator">A::const_iterator</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -91,7 +91,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-iterator"><a href="#A-iterator">A::iterator</a></h2>
+<h2 id="A-iterator">A::iterator</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -108,7 +108,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-begin-03"><a href="#A-begin-03">A::begin</a></h2>
+<h2 id="A-begin-03">A::begin</h2>
 <div>
 <span><code>begin</code> overloads</span>
 
@@ -146,7 +146,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="A-begin-06"><a href="#A-begin-06">A::begin</a></h2>
+<h2 id="A-begin-06">A::begin</h2>
 <div>
 <span>Returns an iterator to the beginning</span>
 
@@ -174,7 +174,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="A-begin-0c"><a href="#A-begin-0c">A::begin</a></h2>
+<h2 id="A-begin-0c">A::begin</h2>
 <div>
 <span>Return a const iterator to the beginning</span>
 
@@ -202,7 +202,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="A-cbegin"><a href="#A-cbegin">A::cbegin</a></h2>
+<h2 id="A-cbegin">A::cbegin</h2>
 <div>
 <span>Return a const iterator to the beginning</span>
 
@@ -230,7 +230,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="A-crvalue"><a href="#A-crvalue">A::crvalue</a></h2>
+<h2 id="A-crvalue">A::crvalue</h2>
 <div>
 <span>An const rvalue reference to A</span>
 
@@ -254,7 +254,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="A-ref-05f"><a href="#A-ref-05f">A::ref</a></h2>
+<h2 id="A-ref-05f">A::ref</h2>
 <div>
 <span><code>ref</code> overloads</span>
 
@@ -305,7 +305,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="A-ref-051"><a href="#A-ref-051">A::ref</a></h2>
+<h2 id="A-ref-051">A::ref</h2>
 <div>
 <span>An lvalue reference to A</span>
 
@@ -329,7 +329,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="A-ref-0e"><a href="#A-ref-0e">A::ref</a></h2>
+<h2 id="A-ref-0e">A::ref</h2>
 <div>
 <span>An rvalue reference to A</span>
 
@@ -353,7 +353,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="A-ref-04"><a href="#A-ref-04">A::ref</a></h2>
+<h2 id="A-ref-04">A::ref</h2>
 <div>
 <span>An const lvalue reference to A</span>
 
@@ -377,7 +377,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="A-ref-07"><a href="#A-ref-07">A::ref</a></h2>
+<h2 id="A-ref-07">A::ref</h2>
 <div>
 <span>An const rvalue reference to A</span>
 
@@ -401,7 +401,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="A-rvalue"><a href="#A-rvalue">A::rvalue</a></h2>
+<h2 id="A-rvalue">A::rvalue</h2>
 <div>
 <span>An rvalue reference to A</span>
 
diff --git a/test-files/golden-tests/javadoc/copydoc/template-arguments.html b/test-files/golden-tests/javadoc/copydoc/template-arguments.html
index 8cf977bff..c83844de5 100644
--- a/test-files/golden-tests/javadoc/copydoc/template-arguments.html
+++ b/test-files/golden-tests/javadoc/copydoc/template-arguments.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Namespaces</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -56,7 +56,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-BInt"><a href="#A-BInt">A::BInt</a></h2>
+<h2 id="A-BInt">A::BInt</h2>
 <div>
 <span>Specialization of B for int.</span>
 
@@ -75,7 +75,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-BInt2"><a href="#A-BInt2">A::BInt2</a></h2>
+<h2 id="A-BInt2">A::BInt2</h2>
 <div>
 <span>Specialization of B for int with value 2.</span>
 
@@ -94,7 +94,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-B_t"><a href="#A-B_t">A::B_t</a></h2>
+<h2 id="A-B_t">A::B_t</h2>
 <div>
 <span>Main class template for B.</span>
 
@@ -133,7 +133,7 @@ <h3>Template Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-CDTrue"><a href="#A-CDTrue">A::CDTrue</a></h2>
+<h2 id="A-CDTrue">A::CDTrue</h2>
 <div>
 <span>Specialization of C for D with true.</span>
 
@@ -152,7 +152,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-CIntTrue"><a href="#A-CIntTrue">A::CIntTrue</a></h2>
+<h2 id="A-CIntTrue">A::CIntTrue</h2>
 <div>
 <span>Specialization of C for D with true.</span>
 
@@ -171,7 +171,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-C_t"><a href="#A-C_t">A::C_t</a></h2>
+<h2 id="A-C_t">A::C_t</h2>
 <div>
 <span>Main class template for C.</span>
 
@@ -210,7 +210,7 @@ <h3>Template Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-B-08"><a href="#A-B-08">A::B</a></h2>
+<h2 id="A-B-08">A::B</h2>
 <div>
 <span>Main class template for B.</span>
 
@@ -255,7 +255,7 @@ <h3>Template Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-B-09"><a href="#A-B-09">A::B&lt;int&gt;</a></h2>
+<h2 id="A-B-09">A::B&lt;int&gt;</h2>
 <div>
 <span>Specialization of B for int.</span>
 
@@ -277,7 +277,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-B-0c"><a href="#A-B-0c">A::B&lt;int, 2&gt;</a></h2>
+<h2 id="A-B-0c">A::B&lt;int, 2&gt;</h2>
 <div>
 <span>Specialization of B for int with value 2.</span>
 
@@ -299,7 +299,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-C-05"><a href="#A-C-05">A::C</a></h2>
+<h2 id="A-C-05">A::C</h2>
 <div>
 <span>Main class template for C.</span>
 
@@ -344,7 +344,7 @@ <h3>Template Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-C-0f"><a href="#A-C-0f">A::C&lt;D, true&gt;</a></h2>
+<h2 id="A-C-0f">A::C&lt;D, true&gt;</h2>
 <div>
 <span>Specialization of C for D with true.</span>
 
@@ -366,7 +366,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-C-0c"><a href="#A-C-0c">A::C&lt;int, true&gt;</a></h2>
+<h2 id="A-C-0c">A::C&lt;int, true&gt;</h2>
 <div>
 <span>Specialization of C for int with true.</span>
 
@@ -388,7 +388,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-D"><a href="#A-D">A::D</a></h2>
+<h2 id="A-D">A::D</h2>
 <div>
 <span>Helper struct D.</span>
 
diff --git a/test-files/golden-tests/javadoc/inline/styled.html b/test-files/golden-tests/javadoc/inline/styled.html
index 28502eee5..0a91b8585 100644
--- a/test-files/golden-tests/javadoc/inline/styled.html
+++ b/test-files/golden-tests/javadoc/inline/styled.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 <div>
 <span>Brief for A</span>
 
@@ -66,7 +66,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="A-compare"><a href="#A-compare">A::compare</a></h2>
+<h2 id="A-compare">A::compare</h2>
 <div>
 <span>Compare function</span>
 
diff --git a/test-files/golden-tests/javadoc/link/link.html b/test-files/golden-tests/javadoc/link/link.html
index 091056aca..d639a73a7 100644
--- a/test-files/golden-tests/javadoc/link/link.html
+++ b/test-files/golden-tests/javadoc/link/link.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>A function with a link</span>
 
diff --git a/test-files/golden-tests/javadoc/lists/li.html b/test-files/golden-tests/javadoc/lists/li.html
index db9c61ae9..99eba04f3 100644
--- a/test-files/golden-tests/javadoc/lists/li.html
+++ b/test-files/golden-tests/javadoc/lists/li.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>A function</span>
 
diff --git a/test-files/golden-tests/javadoc/lists/listitem.html b/test-files/golden-tests/javadoc/lists/listitem.html
index 8ffb85609..b559e68dd 100644
--- a/test-files/golden-tests/javadoc/lists/listitem.html
+++ b/test-files/golden-tests/javadoc/lists/listitem.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -29,7 +29,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f0"><a href="#f0">f0</a></h2>
+<h2 id="f0">f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -51,7 +51,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -74,7 +74,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="f2"><a href="#f2">f2</a></h2>
+<h2 id="f2">f2</h2>
 <div>
 <span>brief</span>
 
@@ -101,7 +101,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="f3"><a href="#f3">f3</a></h2>
+<h2 id="f3">f3</h2>
 <div>
 <span>brief</span>
 
diff --git a/test-files/golden-tests/javadoc/paragraph/par-1.html b/test-files/golden-tests/javadoc/paragraph/par-1.html
index 04f98ed43..fef4b8892 100644
--- a/test-files/golden-tests/javadoc/paragraph/par-1.html
+++ b/test-files/golden-tests/javadoc/paragraph/par-1.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -29,7 +29,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 <div>
 <span>Brief</span>
 
@@ -57,7 +57,7 @@ <h3>Custom par</h3>
 </div>
 <div>
 <div>
-<h2 id="f2"><a href="#f2">f2</a></h2>
+<h2 id="f2">f2</h2>
 <div>
 <span>Brief</span>
 
@@ -85,7 +85,7 @@ <h3>Custom par</h3>
 </div>
 <div>
 <div>
-<h2 id="f3"><a href="#f3">f3</a></h2>
+<h2 id="f3">f3</h2>
 <div>
 <span>Brief</span>
 
@@ -112,7 +112,7 @@ <h3>Custom par</h3>
 </div>
 <div>
 <div>
-<h2 id="f4"><a href="#f4">f4</a></h2>
+<h2 id="f4">f4</h2>
 <div>
 <span>Brief</span>
 
diff --git a/test-files/golden-tests/javadoc/paragraph/para-1.html b/test-files/golden-tests/javadoc/paragraph/para-1.html
index 2b892b712..55e6b1514 100644
--- a/test-files/golden-tests/javadoc/paragraph/para-1.html
+++ b/test-files/golden-tests/javadoc/paragraph/para-1.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -29,7 +29,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -45,7 +45,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f2"><a href="#f2">f2</a></h2>
+<h2 id="f2">f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -61,7 +61,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f3"><a href="#f3">f3</a></h2>
+<h2 id="f3">f3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -77,7 +77,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f4"><a href="#f4">f4</a></h2>
+<h2 id="f4">f4</h2>
 <div>
 <span>brief</span>
 
diff --git a/test-files/golden-tests/javadoc/paragraph/para-2.html b/test-files/golden-tests/javadoc/paragraph/para-2.html
index 33e5bfdfa..1f8acbc3e 100644
--- a/test-files/golden-tests/javadoc/paragraph/para-2.html
+++ b/test-files/golden-tests/javadoc/paragraph/para-2.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 <div>
 <span>brief</span>
 
diff --git a/test-files/golden-tests/javadoc/paragraph/para-3.html b/test-files/golden-tests/javadoc/paragraph/para-3.html
index 25e78bbce..be604e693 100644
--- a/test-files/golden-tests/javadoc/paragraph/para-3.html
+++ b/test-files/golden-tests/javadoc/paragraph/para-3.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="my_function"><a href="#my_function">my_function</a></h2>
+<h2 id="my_function">my_function</h2>
 <div>
 <span>A function</span>
 
diff --git a/test-files/golden-tests/javadoc/param/param-1.html b/test-files/golden-tests/javadoc/param/param-1.html
index 9e31acd50..38e59035d 100644
--- a/test-files/golden-tests/javadoc/param/param-1.html
+++ b/test-files/golden-tests/javadoc/param/param-1.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -30,7 +30,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f0"><a href="#f0">f0</a></h2>
+<h2 id="f0">f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -63,7 +63,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -96,7 +96,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="f2"><a href="#f2">f2</a></h2>
+<h2 id="f2">f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -129,7 +129,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="f3"><a href="#f3">f3</a></h2>
+<h2 id="f3">f3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -162,7 +162,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="f4"><a href="#f4">f4</a></h2>
+<h2 id="f4">f4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/javadoc/param/param-direction.html b/test-files/golden-tests/javadoc/param/param-direction.html
index 6aa33ac94..32b08d7ed 100644
--- a/test-files/golden-tests/javadoc/param/param-direction.html
+++ b/test-files/golden-tests/javadoc/param/param-direction.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -35,7 +35,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -68,7 +68,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="g"><a href="#g">g</a></h2>
+<h2 id="g">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -107,7 +107,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="h"><a href="#h">h</a></h2>
+<h2 id="h">h</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -146,7 +146,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="i"><a href="#i">i</a></h2>
+<h2 id="i">i</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -185,7 +185,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="j"><a href="#j">j</a></h2>
+<h2 id="j">j</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -224,7 +224,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="k"><a href="#k">k</a></h2>
+<h2 id="k">k</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -268,7 +268,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="l"><a href="#l">l</a></h2>
+<h2 id="l">l</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -313,7 +313,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="m"><a href="#m">m</a></h2>
+<h2 id="m">m</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -352,7 +352,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="n"><a href="#n">n</a></h2>
+<h2 id="n">n</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -385,7 +385,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="o"><a href="#o">o</a></h2>
+<h2 id="o">o</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/javadoc/param/param-duplicate.html b/test-files/golden-tests/javadoc/param/param-duplicate.html
index 2b42b5652..e8079c271 100644
--- a/test-files/golden-tests/javadoc/param/param-duplicate.html
+++ b/test-files/golden-tests/javadoc/param/param-duplicate.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -31,7 +31,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f0"><a href="#f0">f0</a></h2>
+<h2 id="f0">f0</h2>
 <div>
 <span>f0 brief</span>
 
@@ -58,7 +58,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 <div>
 <span>f1 brief</span>
 
@@ -85,7 +85,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="g0"><a href="#g0">g0</a></h2>
+<h2 id="g0">g0</h2>
 <div>
 <span>g0 brief</span>
 
@@ -126,7 +126,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="g1"><a href="#g1">g1</a></h2>
+<h2 id="g1">g1</h2>
 <div>
 <span>g1 brief</span>
 
@@ -167,7 +167,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="h0"><a href="#h0">h0</a></h2>
+<h2 id="h0">h0</h2>
 <div>
 <span>h0 brief</span>
 
@@ -209,7 +209,7 @@ <h3>Template Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="h1"><a href="#h1">h1</a></h2>
+<h2 id="h1">h1</h2>
 <div>
 <span>h1 brief</span>
 
diff --git a/test-files/golden-tests/javadoc/param/param.html b/test-files/golden-tests/javadoc/param/param.html
index 81593d299..018cc9243 100644
--- a/test-files/golden-tests/javadoc/param/param.html
+++ b/test-files/golden-tests/javadoc/param/param.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -29,7 +29,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -62,7 +62,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="g"><a href="#g">g</a></h2>
+<h2 id="g">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -101,7 +101,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="h"><a href="#h">h</a></h2>
+<h2 id="h">h</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -145,7 +145,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="i"><a href="#i">i</a></h2>
+<h2 id="i">i</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/javadoc/pre/pre-post.html b/test-files/golden-tests/javadoc/pre/pre-post.html
index cf50c0e88..b54fa0958 100644
--- a/test-files/golden-tests/javadoc/pre/pre-post.html
+++ b/test-files/golden-tests/javadoc/pre/pre-post.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/javadoc/ref/broken-ref.html b/test-files/golden-tests/javadoc/ref/broken-ref.html
index 78a8ea85a..9e98684a5 100644
--- a/test-files/golden-tests/javadoc/ref/broken-ref.html
+++ b/test-files/golden-tests/javadoc/ref/broken-ref.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -27,7 +27,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f0"><a href="#f0">f0</a></h2>
+<h2 id="f0">f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -43,7 +43,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 <div>
 <span>See <a href="#f0"><code>f0</code></a></span>
 
diff --git a/test-files/golden-tests/javadoc/ref/punctuation.html b/test-files/golden-tests/javadoc/ref/punctuation.html
index 962c4314c..ea20b9166 100644
--- a/test-files/golden-tests/javadoc/ref/punctuation.html
+++ b/test-files/golden-tests/javadoc/ref/punctuation.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -28,7 +28,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f0"><a href="#f0">f0</a></h2>
+<h2 id="f0">f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -44,7 +44,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -60,7 +60,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f2"><a href="#f2">f2</a></h2>
+<h2 id="f2">f2</h2>
 <div>
 <span>See <a href="#f0"><code>f0</code></a>, <a href="#f1"><code>f1</code></a>.</span>
 
diff --git a/test-files/golden-tests/javadoc/ref/ref.html b/test-files/golden-tests/javadoc/ref/ref.html
index 115aefdcf..11b42ac3a 100644
--- a/test-files/golden-tests/javadoc/ref/ref.html
+++ b/test-files/golden-tests/javadoc/ref/ref.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -54,7 +54,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -89,7 +89,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-B"><a href="#A-B">A::B</a></h2>
+<h2 id="A-B">A::B</h2>
 <div>
 <span>See <a href="#A-f1"><code>f1</code></a></span>
 
@@ -129,7 +129,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="A-B-f2"><a href="#A-B-f2">A::B::f2</a></h2>
+<h2 id="A-B-f2">A::B::f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -145,7 +145,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-C"><a href="#A-C">A::C</a></h2>
+<h2 id="A-C">A::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -191,7 +191,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="A-C-f3"><a href="#A-C-f3">A::C::f3</a></h2>
+<h2 id="A-C-f3">A::C::f3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -207,7 +207,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-C-f4"><a href="#A-C-f4">A::C::f4</a></h2>
+<h2 id="A-C-f4">A::C::f4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -223,7 +223,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-D"><a href="#A-D">A::D</a></h2>
+<h2 id="A-D">A::D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -283,7 +283,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-D-E"><a href="#A-D-E">A::D::E</a></h2>
+<h2 id="A-D-E">A::D::E</h2>
 <div>
 <span>See <a href="#A-C-f3"><code>f3</code></a></span>
 
@@ -309,7 +309,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="A-D-f4"><a href="#A-D-f4">A::D::f4</a></h2>
+<h2 id="A-D-f4">A::D::f4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -325,7 +325,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f1"><a href="#A-f1">A::f1</a></h2>
+<h2 id="A-f1">A::f1</h2>
 <div>
 <span>See <a href="#f0"><code>f0</code></a></span>
 
@@ -349,7 +349,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="F"><a href="#F">F</a></h2>
+<h2 id="F">F</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -417,7 +417,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="F-operator_assign"><a href="#F-operator_assign">F::operator&#x3D;</a></h2>
+<h2 id="F-operator_assign">F::operator&#x3D;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -433,7 +433,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_mod"><a href="#F-operator_mod">F::operator%</a></h2>
+<h2 id="F-operator_mod">F::operator%</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -449,7 +449,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_mod_eq"><a href="#F-operator_mod_eq">F::operator%&#x3D;</a></h2>
+<h2 id="F-operator_mod_eq">F::operator%&#x3D;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -465,7 +465,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_bitand"><a href="#F-operator_bitand">F::operator&amp;</a></h2>
+<h2 id="F-operator_bitand">F::operator&amp;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -481,7 +481,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_and"><a href="#F-operator_and">F::operator&amp;&amp;</a></h2>
+<h2 id="F-operator_and">F::operator&amp;&amp;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -497,7 +497,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_and_eq"><a href="#F-operator_and_eq">F::operator&amp;&#x3D;</a></h2>
+<h2 id="F-operator_and_eq">F::operator&amp;&#x3D;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -513,7 +513,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_call"><a href="#F-operator_call">F::operator()</a></h2>
+<h2 id="F-operator_call">F::operator()</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -529,7 +529,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_star"><a href="#F-operator_star">F::operator*</a></h2>
+<h2 id="F-operator_star">F::operator*</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -545,7 +545,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_star_eq"><a href="#F-operator_star_eq">F::operator*&#x3D;</a></h2>
+<h2 id="F-operator_star_eq">F::operator*&#x3D;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -561,7 +561,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_plus"><a href="#F-operator_plus">F::operator+</a></h2>
+<h2 id="F-operator_plus">F::operator+</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -577,7 +577,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_inc"><a href="#F-operator_inc">F::operator++</a></h2>
+<h2 id="F-operator_inc">F::operator++</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -593,7 +593,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_plus_eq"><a href="#F-operator_plus_eq">F::operator+&#x3D;</a></h2>
+<h2 id="F-operator_plus_eq">F::operator+&#x3D;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -609,7 +609,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_comma"><a href="#F-operator_comma">F::operator,</a></h2>
+<h2 id="F-operator_comma">F::operator,</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -625,7 +625,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_minus"><a href="#F-operator_minus">F::operator-</a></h2>
+<h2 id="F-operator_minus">F::operator-</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -641,7 +641,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_dec"><a href="#F-operator_dec">F::operator--</a></h2>
+<h2 id="F-operator_dec">F::operator--</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -657,7 +657,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_minus_eq"><a href="#F-operator_minus_eq">F::operator-&#x3D;</a></h2>
+<h2 id="F-operator_minus_eq">F::operator-&#x3D;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -673,7 +673,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_ptr"><a href="#F-operator_ptr">F::operator-&gt;</a></h2>
+<h2 id="F-operator_ptr">F::operator-&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -689,7 +689,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_ptrmem"><a href="#F-operator_ptrmem">F::operator-&gt;*</a></h2>
+<h2 id="F-operator_ptrmem">F::operator-&gt;*</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -705,7 +705,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_slash"><a href="#F-operator_slash">F::operator/</a></h2>
+<h2 id="F-operator_slash">F::operator/</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -721,7 +721,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_slash_eq"><a href="#F-operator_slash_eq">F::operator/&#x3D;</a></h2>
+<h2 id="F-operator_slash_eq">F::operator/&#x3D;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -737,7 +737,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_lshift_eq"><a href="#F-operator_lshift_eq">F::operator&lt;&lt;&#x3D;</a></h2>
+<h2 id="F-operator_lshift_eq">F::operator&lt;&lt;&#x3D;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -753,7 +753,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_rshift"><a href="#F-operator_rshift">F::operator&gt;&gt;</a></h2>
+<h2 id="F-operator_rshift">F::operator&gt;&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -769,7 +769,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_rshift_eq"><a href="#F-operator_rshift_eq">F::operator&gt;&gt;&#x3D;</a></h2>
+<h2 id="F-operator_rshift_eq">F::operator&gt;&gt;&#x3D;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -785,7 +785,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_subs"><a href="#F-operator_subs">F::operator[]</a></h2>
+<h2 id="F-operator_subs">F::operator[]</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -801,7 +801,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_xor"><a href="#F-operator_xor">F::operator^</a></h2>
+<h2 id="F-operator_xor">F::operator^</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -817,7 +817,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_xor_eq"><a href="#F-operator_xor_eq">F::operator^&#x3D;</a></h2>
+<h2 id="F-operator_xor_eq">F::operator^&#x3D;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -833,7 +833,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_bitor"><a href="#F-operator_bitor">F::operator|</a></h2>
+<h2 id="F-operator_bitor">F::operator|</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -849,7 +849,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_or_eq"><a href="#F-operator_or_eq">F::operator|&#x3D;</a></h2>
+<h2 id="F-operator_or_eq">F::operator|&#x3D;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -865,7 +865,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_or"><a href="#F-operator_or">F::operator||</a></h2>
+<h2 id="F-operator_or">F::operator||</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -881,7 +881,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_bitnot"><a href="#F-operator_bitnot">F::operator~</a></h2>
+<h2 id="F-operator_bitnot">F::operator~</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -897,7 +897,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_lshift"><a href="#F-operator_lshift">F::operator&lt;&lt;</a></h2>
+<h2 id="F-operator_lshift">F::operator&lt;&lt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -913,7 +913,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_not"><a href="#F-operator_not">F::operator!</a></h2>
+<h2 id="F-operator_not">F::operator!</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -929,7 +929,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_eq"><a href="#F-operator_eq">F::operator&#x3D;&#x3D;</a></h2>
+<h2 id="F-operator_eq">F::operator&#x3D;&#x3D;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -945,7 +945,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_not_eq"><a href="#F-operator_not_eq">F::operator!&#x3D;</a></h2>
+<h2 id="F-operator_not_eq">F::operator!&#x3D;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -961,7 +961,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_lt"><a href="#F-operator_lt">F::operator&lt;</a></h2>
+<h2 id="F-operator_lt">F::operator&lt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -977,7 +977,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_le"><a href="#F-operator_le">F::operator&lt;&#x3D;</a></h2>
+<h2 id="F-operator_le">F::operator&lt;&#x3D;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -993,7 +993,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_gt"><a href="#F-operator_gt">F::operator&gt;</a></h2>
+<h2 id="F-operator_gt">F::operator&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1009,7 +1009,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_ge"><a href="#F-operator_ge">F::operator&gt;&#x3D;</a></h2>
+<h2 id="F-operator_ge">F::operator&gt;&#x3D;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1025,7 +1025,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F-operator_3way"><a href="#F-operator_3way">F::operator&lt;&#x3D;&gt;</a></h2>
+<h2 id="F-operator_3way">F::operator&lt;&#x3D;&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1041,7 +1041,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f0"><a href="#f0">f0</a></h2>
+<h2 id="f0">f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1057,7 +1057,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f5"><a href="#f5">f5</a></h2>
+<h2 id="f5">f5</h2>
 <div>
 <span>See <a href="#A-f1"><code>A::f1</code></a></span>
 
@@ -1081,7 +1081,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="f6"><a href="#f6">f6</a></h2>
+<h2 id="f6">f6</h2>
 <div>
 <span>See <a href="#F-operator_bitnot"><code>F::operator~</code></a></span>
 
diff --git a/test-files/golden-tests/javadoc/relates/relates.html b/test-files/golden-tests/javadoc/relates/relates.html
index fde26b533..5477de080 100644
--- a/test-files/golden-tests/javadoc/relates/relates.html
+++ b/test-files/golden-tests/javadoc/relates/relates.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -41,7 +41,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 <div>
 <span>A brief for A.</span>
 
@@ -76,7 +76,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 <div>
 <span>A brief for B</span>
 
@@ -97,7 +97,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>A brief for f.</span>
 
diff --git a/test-files/golden-tests/javadoc/returns/returns.html b/test-files/golden-tests/javadoc/returns/returns.html
index a10ab94df..3e04fbaf3 100644
--- a/test-files/golden-tests/javadoc/returns/returns.html
+++ b/test-files/golden-tests/javadoc/returns/returns.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -41,7 +41,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="pair"><a href="#pair">pair</a></h2>
+<h2 id="pair">pair</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -89,7 +89,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="pair-first"><a href="#pair-first">pair::first</a></h2>
+<h2 id="pair-first">pair::first</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -104,7 +104,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="pair-second"><a href="#pair-second">pair::second</a></h2>
+<h2 id="pair-second">pair::second</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -119,7 +119,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>A function with a single return value.</span>
 
@@ -143,7 +143,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="g"><a href="#g">g</a></h2>
+<h2 id="g">g</h2>
 <div>
 <span>A function with multiple return values.</span>
 
diff --git a/test-files/golden-tests/javadoc/throw/throw.html b/test-files/golden-tests/javadoc/throw/throw.html
index acbcdf816..35d763f5e 100644
--- a/test-files/golden-tests/javadoc/throw/throw.html
+++ b/test-files/golden-tests/javadoc/throw/throw.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>brief</span>
 
diff --git a/test-files/golden-tests/javadoc/tparam/tparam-1.html b/test-files/golden-tests/javadoc/tparam/tparam-1.html
index 6cdb746ac..a29cc323d 100644
--- a/test-files/golden-tests/javadoc/tparam/tparam-1.html
+++ b/test-files/golden-tests/javadoc/tparam/tparam-1.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -27,7 +27,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f0"><a href="#f0">f0</a></h2>
+<h2 id="f0">f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -61,7 +61,7 @@ <h3>Template Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 <div>
 <span>brief</span>
 
diff --git a/test-files/golden-tests/output/canonical_1.html b/test-files/golden-tests/output/canonical_1.html
index 487dcca0a..c5b115cc8 100644
--- a/test-files/golden-tests/output/canonical_1.html
+++ b/test-files/golden-tests/output/canonical_1.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -32,7 +32,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -49,7 +49,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -66,7 +66,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Ba"><a href="#Ba">Ba</a></h2>
+<h2 id="Ba">Ba</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -83,7 +83,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Bx"><a href="#Bx">Bx</a></h2>
+<h2 id="Bx">Bx</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -100,7 +100,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="a"><a href="#a">a</a></h2>
+<h2 id="a">a</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -117,7 +117,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="b"><a href="#b">b</a></h2>
+<h2 id="b">b</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -134,7 +134,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="bA"><a href="#bA">bA</a></h2>
+<h2 id="bA">bA</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -151,7 +151,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="ba"><a href="#ba">ba</a></h2>
+<h2 id="ba">ba</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/snippets/distance.html b/test-files/golden-tests/snippets/distance.html
index 03711e3e1..01aeab45e 100644
--- a/test-files/golden-tests/snippets/distance.html
+++ b/test-files/golden-tests/snippets/distance.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="distance"><a href="#distance">distance</a></h2>
+<h2 id="distance">distance</h2>
 <div>
 <span>Return the distance between two points</span>
 
diff --git a/test-files/golden-tests/snippets/is_prime.html b/test-files/golden-tests/snippets/is_prime.html
index 9953d6a86..ff9dc1172 100644
--- a/test-files/golden-tests/snippets/is_prime.html
+++ b/test-files/golden-tests/snippets/is_prime.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="is_prime"><a href="#is_prime">is_prime</a></h2>
+<h2 id="is_prime">is_prime</h2>
 <div>
 <span>Return true if a number is prime.</span>
 
diff --git a/test-files/golden-tests/snippets/sqrt.html b/test-files/golden-tests/snippets/sqrt.html
index ef3f3bbe6..f1b40e706 100644
--- a/test-files/golden-tests/snippets/sqrt.html
+++ b/test-files/golden-tests/snippets/sqrt.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="sqrt"><a href="#sqrt">sqrt</a></h2>
+<h2 id="sqrt">sqrt</h2>
 <div>
 <span>Computes the square root of an integral value.</span>
 
diff --git a/test-files/golden-tests/snippets/terminate.html b/test-files/golden-tests/snippets/terminate.html
index b96f942b5..35523ee81 100644
--- a/test-files/golden-tests/snippets/terminate.html
+++ b/test-files/golden-tests/snippets/terminate.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="terminate"><a href="#terminate">terminate</a></h2>
+<h2 id="terminate">terminate</h2>
 <div>
 <span>Exit the program.</span>
 
diff --git a/test-files/golden-tests/symbols/concept/concept.html b/test-files/golden-tests/symbols/concept/concept.html
index cc30d6c1e..8809d66f0 100644
--- a/test-files/golden-tests/symbols/concept/concept.html
+++ b/test-files/golden-tests/symbols/concept/concept.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -51,7 +51,7 @@ <h2>Concepts</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -68,7 +68,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="x"><a href="#x">x</a></h2>
+<h2 id="x">x</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -83,7 +83,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C"><a href="#C">C</a></h2>
+<h2 id="C">C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/concept/requires-clause.html b/test-files/golden-tests/symbols/concept/requires-clause.html
index 51fb8055c..2e4b2b27b 100644
--- a/test-files/golden-tests/symbols/concept/requires-clause.html
+++ b/test-files/golden-tests/symbols/concept/requires-clause.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -41,7 +41,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-08"><a href="#A-08">A</a></h2>
+<h2 id="A-08">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -60,7 +60,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0b"><a href="#A-0b">A</a></h2>
+<h2 id="A-0b">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -79,7 +79,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -97,7 +97,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0f"><a href="#g-0f">g</a></h2>
+<h2 id="g-0f">g</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -138,7 +138,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="g-0e"><a href="#g-0e">g</a></h2>
+<h2 id="g-0e">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -156,7 +156,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-02"><a href="#g-02">g</a></h2>
+<h2 id="g-02">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -174,7 +174,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g-08"><a href="#g-08">g</a></h2>
+<h2 id="g-08">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/enum/enum.adoc b/test-files/golden-tests/symbols/enum/enum.adoc
index e3afeb014..96972738b 100644
--- a/test-files/golden-tests/symbols/enum/enum.adoc
+++ b/test-files/golden-tests/symbols/enum/enum.adoc
@@ -36,15 +36,14 @@ enum E0;
 
 === Members
 
-
 [cols=2]
 |===
 | Name
 | Description
-|`e0`
-|e0 brief&period;
-|`e1`
-|e1 brief&period;
+| `e0` 
+| e0 brief&period;
+| `e1` 
+| e1 brief&period;
 |===
 
 === Description
@@ -65,15 +64,11 @@ enum E1 : char;
 
 === Members
 
-
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
-|`e2`
-|
-|`e3`
-|
+| `e2` 
+| `e3` 
 |===
 
 [#E2]
@@ -92,15 +87,14 @@ enum class E2 : int;
 
 === Members
 
-
 [cols=2]
 |===
 | Name
 | Description
-|`e4`
-|e4 brief&period;
-|`e5`
-|e5 brief&period;
+| `e4` 
+| e4 brief&period;
+| `e5` 
+| e5 brief&period;
 |===
 
 === Description
@@ -121,15 +115,11 @@ enum class E3 : char;
 
 === Members
 
-
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
-|`e6`
-|
-|`e7`
-|
+| `e6` 
+| `e7` 
 |===
 
 
diff --git a/test-files/golden-tests/symbols/enum/enum.html b/test-files/golden-tests/symbols/enum/enum.html
index 014393e77..28da750e4 100644
--- a/test-files/golden-tests/symbols/enum/enum.html
+++ b/test-files/golden-tests/symbols/enum/enum.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Enums</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -29,7 +29,7 @@ <h2>Enums</h2>
 </div>
 <div>
 <div>
-<h2 id="E0"><a href="#E0">E0</a></h2>
+<h2 id="E0">E0</h2>
 <div>
 <span>E0 brief.</span>
 
@@ -45,9 +45,8 @@ <h3>Synopsis</h3>
 </code>
 </pre>
 </div>
-<div>
-<h3>Members</h3>
-<table>
+<h2>Members</h2>
+<table style="table-layout: fixed; width: 100%;">
 <thead>
 <tr>
 <th>Name</th>
@@ -56,16 +55,11 @@ <h3>Members</h3>
 </thead>
 <tbody>
 <tr>
-<td>e0</td>
-<td><span>e0 brief.</span></td>
-</tr>
-<tr>
-<td>e1</td>
-<td><span>e1 brief.</span></td>
-</tr>
+<td><code>e0</code> </td><td><span>e0 brief.</span></td></tr><tr>
+<td><code>e1</code> </td><td><span>e1 brief.</span></td></tr>
 </tbody>
 </table>
-</div>
+
 <div>
 <h3>Description</h3>
 <p>E0 description.</p>
@@ -73,7 +67,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="E1"><a href="#E1">E1</a></h2>
+<h2 id="E1">E1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -85,31 +79,24 @@ <h3>Synopsis</h3>
 </code>
 </pre>
 </div>
-<div>
-<h3>Members</h3>
-<table>
+<h2>Members</h2>
+<table style="table-layout: fixed; width: 100%;">
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td>e2</td>
-<td><span></span></td>
-</tr>
-<tr>
-<td>e3</td>
-<td><span></span></td>
-</tr>
+<td><code>e2</code> </td></tr><tr>
+<td><code>e3</code> </td></tr>
 </tbody>
 </table>
-</div>
+
 </div>
 <div>
 <div>
-<h2 id="E2"><a href="#E2">E2</a></h2>
+<h2 id="E2">E2</h2>
 <div>
 <span>E2 brief.</span>
 
@@ -125,9 +112,8 @@ <h3>Synopsis</h3>
 </code>
 </pre>
 </div>
-<div>
-<h3>Members</h3>
-<table>
+<h2>Members</h2>
+<table style="table-layout: fixed; width: 100%;">
 <thead>
 <tr>
 <th>Name</th>
@@ -136,16 +122,11 @@ <h3>Members</h3>
 </thead>
 <tbody>
 <tr>
-<td>e4</td>
-<td><span>e4 brief.</span></td>
-</tr>
-<tr>
-<td>e5</td>
-<td><span>e5 brief.</span></td>
-</tr>
+<td><code>e4</code> </td><td><span>e4 brief.</span></td></tr><tr>
+<td><code>e5</code> </td><td><span>e5 brief.</span></td></tr>
 </tbody>
 </table>
-</div>
+
 <div>
 <h3>Description</h3>
 <p>E2 description.</p>
@@ -153,7 +134,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="E3"><a href="#E3">E3</a></h2>
+<h2 id="E3">E3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -165,27 +146,20 @@ <h3>Synopsis</h3>
 </code>
 </pre>
 </div>
-<div>
-<h3>Members</h3>
-<table>
+<h2>Members</h2>
+<table style="table-layout: fixed; width: 100%;">
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td>e6</td>
-<td><span></span></td>
-</tr>
-<tr>
-<td>e7</td>
-<td><span></span></td>
-</tr>
+<td><code>e6</code> </td></tr><tr>
+<td><code>e7</code> </td></tr>
 </tbody>
 </table>
-</div>
+
 </div>
 
 </div>
diff --git a/test-files/golden-tests/symbols/function/attributes-2.html b/test-files/golden-tests/symbols/function/attributes-2.html
index be20c3787..c510ae5a0 100644
--- a/test-files/golden-tests/symbols/function/attributes-2.html
+++ b/test-files/golden-tests/symbols/function/attributes-2.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/function/attributes_1.html b/test-files/golden-tests/symbols/function/attributes_1.html
index 6b37c6d90..cb40440b7 100644
--- a/test-files/golden-tests/symbols/function/attributes_1.html
+++ b/test-files/golden-tests/symbols/function/attributes_1.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/function/auto.html b/test-files/golden-tests/symbols/function/auto.html
index 85f24da73..2dc16e98f 100644
--- a/test-files/golden-tests/symbols/function/auto.html
+++ b/test-files/golden-tests/symbols/function/auto.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>A function that uses auto</span>
 
diff --git a/test-files/golden-tests/symbols/function/explicit-conv-operator.html b/test-files/golden-tests/symbols/function/explicit-conv-operator.html
index 3a8a1b31f..d453de0a0 100644
--- a/test-files/golden-tests/symbols/function/explicit-conv-operator.html
+++ b/test-files/golden-tests/symbols/function/explicit-conv-operator.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -28,7 +28,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="Explicit"><a href="#Explicit">Explicit</a></h2>
+<h2 id="Explicit">Explicit</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -59,7 +59,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="Explicit-2conversion"><a href="#Explicit-2conversion">Explicit::operator bool</a></h2>
+<h2 id="Explicit-2conversion">Explicit::operator bool</h2>
 <div>
 <span>Conversion to <code>bool</code></span>
 
@@ -83,7 +83,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="ExplicitExpression"><a href="#ExplicitExpression">ExplicitExpression</a></h2>
+<h2 id="ExplicitExpression">ExplicitExpression</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -115,7 +115,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="ExplicitExpression-2conversion"><a href="#ExplicitExpression-2conversion">ExplicitExpression::operator bool</a></h2>
+<h2 id="ExplicitExpression-2conversion">ExplicitExpression::operator bool</h2>
 <div>
 <span>Conversion to <code>bool</code></span>
 
@@ -139,7 +139,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="ExplicitFalse"><a href="#ExplicitFalse">ExplicitFalse</a></h2>
+<h2 id="ExplicitFalse">ExplicitFalse</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -170,7 +170,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="ExplicitFalse-2conversion"><a href="#ExplicitFalse-2conversion">ExplicitFalse::operator bool</a></h2>
+<h2 id="ExplicitFalse-2conversion">ExplicitFalse::operator bool</h2>
 <div>
 <span>Conversion to <code>bool</code></span>
 
@@ -194,7 +194,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="ExplicitTrue"><a href="#ExplicitTrue">ExplicitTrue</a></h2>
+<h2 id="ExplicitTrue">ExplicitTrue</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -225,7 +225,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="ExplicitTrue-2conversion"><a href="#ExplicitTrue-2conversion">ExplicitTrue::operator bool</a></h2>
+<h2 id="ExplicitTrue-2conversion">ExplicitTrue::operator bool</h2>
 <div>
 <span>Conversion to <code>bool</code></span>
 
diff --git a/test-files/golden-tests/symbols/function/explicit-ctor.html b/test-files/golden-tests/symbols/function/explicit-ctor.html
index 0c1abfe4f..6927f3756 100644
--- a/test-files/golden-tests/symbols/function/explicit-ctor.html
+++ b/test-files/golden-tests/symbols/function/explicit-ctor.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -28,7 +28,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="Explicit"><a href="#Explicit">Explicit</a></h2>
+<h2 id="Explicit">Explicit</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -59,7 +59,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="Explicit-2constructor-04"><a href="#Explicit-2constructor-04">Explicit::Explicit</a></h2>
+<h2 id="Explicit-2constructor-04">Explicit::Explicit</h2>
 <div>
 <span>Constructors</span>
 
@@ -108,7 +108,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="Explicit-2constructor-02"><a href="#Explicit-2constructor-02">Explicit::Explicit</a></h2>
+<h2 id="Explicit-2constructor-02">Explicit::Explicit</h2>
 <div>
 <span>Default constructor</span>
 
@@ -128,7 +128,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Explicit-2constructor-00"><a href="#Explicit-2constructor-00">Explicit::Explicit</a></h2>
+<h2 id="Explicit-2constructor-00">Explicit::Explicit</h2>
 <div>
 <span>Copy constructor</span>
 
@@ -165,7 +165,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Explicit-2constructor-0b"><a href="#Explicit-2constructor-0b">Explicit::Explicit</a></h2>
+<h2 id="Explicit-2constructor-0b">Explicit::Explicit</h2>
 <div>
 <span>Move constructor</span>
 
@@ -202,7 +202,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="Explicit-2constructor-03"><a href="#Explicit-2constructor-03">Explicit::Explicit</a></h2>
+<h2 id="Explicit-2constructor-03">Explicit::Explicit</h2>
 <div>
 <span>Constructor</span>
 
@@ -224,7 +224,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="ExplicitExpression"><a href="#ExplicitExpression">ExplicitExpression</a></h2>
+<h2 id="ExplicitExpression">ExplicitExpression</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -256,7 +256,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="ExplicitExpression-2constructor-07"><a href="#ExplicitExpression-2constructor-07">ExplicitExpression::ExplicitExpression</a></h2>
+<h2 id="ExplicitExpression-2constructor-07">ExplicitExpression::ExplicitExpression</h2>
 <div>
 <span>Constructors</span>
 
@@ -305,7 +305,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="ExplicitExpression-2constructor-0b"><a href="#ExplicitExpression-2constructor-0b">ExplicitExpression::ExplicitExpression</a></h2>
+<h2 id="ExplicitExpression-2constructor-0b">ExplicitExpression::ExplicitExpression</h2>
 <div>
 <span>Default constructor</span>
 
@@ -325,7 +325,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="ExplicitExpression-2constructor-04"><a href="#ExplicitExpression-2constructor-04">ExplicitExpression::ExplicitExpression</a></h2>
+<h2 id="ExplicitExpression-2constructor-04">ExplicitExpression::ExplicitExpression</h2>
 <div>
 <span>Copy constructor</span>
 
@@ -362,7 +362,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="ExplicitExpression-2constructor-08"><a href="#ExplicitExpression-2constructor-08">ExplicitExpression::ExplicitExpression</a></h2>
+<h2 id="ExplicitExpression-2constructor-08">ExplicitExpression::ExplicitExpression</h2>
 <div>
 <span>Move constructor</span>
 
@@ -399,7 +399,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="ExplicitExpression-2constructor-02"><a href="#ExplicitExpression-2constructor-02">ExplicitExpression::ExplicitExpression</a></h2>
+<h2 id="ExplicitExpression-2constructor-02">ExplicitExpression::ExplicitExpression</h2>
 <div>
 <span>Constructor</span>
 
@@ -421,7 +421,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="ExplicitFalse"><a href="#ExplicitFalse">ExplicitFalse</a></h2>
+<h2 id="ExplicitFalse">ExplicitFalse</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -452,7 +452,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="ExplicitFalse-2constructor-07"><a href="#ExplicitFalse-2constructor-07">ExplicitFalse::ExplicitFalse</a></h2>
+<h2 id="ExplicitFalse-2constructor-07">ExplicitFalse::ExplicitFalse</h2>
 <div>
 <span>Constructors</span>
 
@@ -501,7 +501,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="ExplicitFalse-2constructor-01"><a href="#ExplicitFalse-2constructor-01">ExplicitFalse::ExplicitFalse</a></h2>
+<h2 id="ExplicitFalse-2constructor-01">ExplicitFalse::ExplicitFalse</h2>
 <div>
 <span>Default constructor</span>
 
@@ -521,7 +521,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="ExplicitFalse-2constructor-08"><a href="#ExplicitFalse-2constructor-08">ExplicitFalse::ExplicitFalse</a></h2>
+<h2 id="ExplicitFalse-2constructor-08">ExplicitFalse::ExplicitFalse</h2>
 <div>
 <span>Copy constructor</span>
 
@@ -558,7 +558,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="ExplicitFalse-2constructor-0a"><a href="#ExplicitFalse-2constructor-0a">ExplicitFalse::ExplicitFalse</a></h2>
+<h2 id="ExplicitFalse-2constructor-0a">ExplicitFalse::ExplicitFalse</h2>
 <div>
 <span>Move constructor</span>
 
@@ -595,7 +595,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="ExplicitFalse-2constructor-04"><a href="#ExplicitFalse-2constructor-04">ExplicitFalse::ExplicitFalse</a></h2>
+<h2 id="ExplicitFalse-2constructor-04">ExplicitFalse::ExplicitFalse</h2>
 <div>
 <span>Constructor</span>
 
@@ -617,7 +617,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="ExplicitTrue"><a href="#ExplicitTrue">ExplicitTrue</a></h2>
+<h2 id="ExplicitTrue">ExplicitTrue</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -648,7 +648,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="ExplicitTrue-2constructor-01"><a href="#ExplicitTrue-2constructor-01">ExplicitTrue::ExplicitTrue</a></h2>
+<h2 id="ExplicitTrue-2constructor-01">ExplicitTrue::ExplicitTrue</h2>
 <div>
 <span>Constructors</span>
 
@@ -697,7 +697,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="ExplicitTrue-2constructor-0d"><a href="#ExplicitTrue-2constructor-0d">ExplicitTrue::ExplicitTrue</a></h2>
+<h2 id="ExplicitTrue-2constructor-0d">ExplicitTrue::ExplicitTrue</h2>
 <div>
 <span>Default constructor</span>
 
@@ -717,7 +717,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="ExplicitTrue-2constructor-04"><a href="#ExplicitTrue-2constructor-04">ExplicitTrue::ExplicitTrue</a></h2>
+<h2 id="ExplicitTrue-2constructor-04">ExplicitTrue::ExplicitTrue</h2>
 <div>
 <span>Copy constructor</span>
 
@@ -754,7 +754,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="ExplicitTrue-2constructor-08"><a href="#ExplicitTrue-2constructor-08">ExplicitTrue::ExplicitTrue</a></h2>
+<h2 id="ExplicitTrue-2constructor-08">ExplicitTrue::ExplicitTrue</h2>
 <div>
 <span>Move constructor</span>
 
@@ -791,7 +791,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="ExplicitTrue-2constructor-05"><a href="#ExplicitTrue-2constructor-05">ExplicitTrue::ExplicitTrue</a></h2>
+<h2 id="ExplicitTrue-2constructor-05">ExplicitTrue::ExplicitTrue</h2>
 <div>
 <span>Constructor</span>
 
diff --git a/test-files/golden-tests/symbols/function/explicit-object-parameter.html b/test-files/golden-tests/symbols/function/explicit-object-parameter.html
index eed5310c4..10d983100 100644
--- a/test-files/golden-tests/symbols/function/explicit-object-parameter.html
+++ b/test-files/golden-tests/symbols/function/explicit-object-parameter.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="Optional"><a href="#Optional">Optional</a></h2>
+<h2 id="Optional">Optional</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -56,7 +56,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="Optional-value-0c"><a href="#Optional-value-0c">Optional::value</a></h2>
+<h2 id="Optional-value-0c">Optional::value</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -89,7 +89,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="Optional-value-05"><a href="#Optional-value-05">Optional::value</a></h2>
+<h2 id="Optional-value-05">Optional::value</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -107,7 +107,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Optional-value-06"><a href="#Optional-value-06">Optional::value</a></h2>
+<h2 id="Optional-value-06">Optional::value</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/function/function-parm-decay.html b/test-files/golden-tests/symbols/function/function-parm-decay.html
index c7190bc31..97a0a2a1f 100644
--- a/test-files/golden-tests/symbols/function/function-parm-decay.html
+++ b/test-files/golden-tests/symbols/function/function-parm-decay.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -42,7 +42,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T"><a href="#T">T</a></h2>
+<h2 id="T">T</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -57,7 +57,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="U"><a href="#U">U</a></h2>
+<h2 id="U">U</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -72,7 +72,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -88,7 +88,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g"><a href="#g">g</a></h2>
+<h2 id="g">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -104,7 +104,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="h"><a href="#h">h</a></h2>
+<h2 id="h">h</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -120,7 +120,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="i"><a href="#i">i</a></h2>
+<h2 id="i">i</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/function/function-template-template.html b/test-files/golden-tests/symbols/function/function-template-template.html
index cc1cc699c..8427930fe 100644
--- a/test-files/golden-tests/symbols/function/function-template-template.html
+++ b/test-files/golden-tests/symbols/function/function-template-template.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/function/function-template.html b/test-files/golden-tests/symbols/function/function-template.html
index 8d4f09d27..052d67749 100644
--- a/test-files/golden-tests/symbols/function/function-template.html
+++ b/test-files/golden-tests/symbols/function/function-template.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -36,7 +36,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f0"><a href="#f0">f0</a></h2>
+<h2 id="f0">f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -53,7 +53,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -70,7 +70,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f2"><a href="#f2">f2</a></h2>
+<h2 id="f2">f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -87,7 +87,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f3"><a href="#f3">f3</a></h2>
+<h2 id="f3">f3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -106,7 +106,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g0"><a href="#g0">g0</a></h2>
+<h2 id="g0">g0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -123,7 +123,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g1"><a href="#g1">g1</a></h2>
+<h2 id="g1">g1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -140,7 +140,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g2"><a href="#g2">g2</a></h2>
+<h2 id="g2">g2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -159,7 +159,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="h0"><a href="#h0">h0</a></h2>
+<h2 id="h0">h0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -175,7 +175,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="h1"><a href="#h1">h1</a></h2>
+<h2 id="h1">h1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -193,7 +193,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="i"><a href="#i">i</a></h2>
+<h2 id="i">i</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -212,7 +212,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="j0"><a href="#j0">j0</a></h2>
+<h2 id="j0">j0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -229,7 +229,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="j1"><a href="#j1">j1</a></h2>
+<h2 id="j1">j1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/function/function-tparm-decay.html b/test-files/golden-tests/symbols/function/function-tparm-decay.html
index 576f29575..56e41cbb8 100644
--- a/test-files/golden-tests/symbols/function/function-tparm-decay.html
+++ b/test-files/golden-tests/symbols/function/function-tparm-decay.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -42,7 +42,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T"><a href="#T">T</a></h2>
+<h2 id="T">T</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -57,7 +57,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="U"><a href="#U">U</a></h2>
+<h2 id="U">U</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -72,7 +72,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -89,7 +89,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g"><a href="#g">g</a></h2>
+<h2 id="g">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -106,7 +106,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="h"><a href="#h">h</a></h2>
+<h2 id="h">h</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -123,7 +123,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="i"><a href="#i">i</a></h2>
+<h2 id="i">i</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/function/mem-fn.html b/test-files/golden-tests/symbols/function/mem-fn.html
index 1ccb3b64e..e9a7a6700 100644
--- a/test-files/golden-tests/symbols/function/mem-fn.html
+++ b/test-files/golden-tests/symbols/function/mem-fn.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -42,7 +42,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="T01"><a href="#T01">T01</a></h2>
+<h2 id="T01">T01</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -72,7 +72,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T01-f"><a href="#T01-f">T01::f</a></h2>
+<h2 id="T01-f">T01::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -88,7 +88,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T02"><a href="#T02">T02</a></h2>
+<h2 id="T02">T02</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -118,7 +118,7 @@ <h2>Static Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T02-f"><a href="#T02-f">T02::f</a></h2>
+<h2 id="T02-f">T02::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -135,7 +135,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T03"><a href="#T03">T03</a></h2>
+<h2 id="T03">T03</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -165,7 +165,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T03-f"><a href="#T03-f">T03::f</a></h2>
+<h2 id="T03-f">T03::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -181,7 +181,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T04"><a href="#T04">T04</a></h2>
+<h2 id="T04">T04</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -211,7 +211,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T04-f"><a href="#T04-f">T04::f</a></h2>
+<h2 id="T04-f">T04::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -227,7 +227,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T05"><a href="#T05">T05</a></h2>
+<h2 id="T05">T05</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -257,7 +257,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T05-f"><a href="#T05-f">T05::f</a></h2>
+<h2 id="T05-f">T05::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -273,7 +273,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T06"><a href="#T06">T06</a></h2>
+<h2 id="T06">T06</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -303,7 +303,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T06-f"><a href="#T06-f">T06::f</a></h2>
+<h2 id="T06-f">T06::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -320,7 +320,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T08"><a href="#T08">T08</a></h2>
+<h2 id="T08">T08</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -350,7 +350,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T08-f"><a href="#T08-f">T08::f</a></h2>
+<h2 id="T08-f">T08::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -366,7 +366,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T09"><a href="#T09">T09</a></h2>
+<h2 id="T09">T09</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -396,7 +396,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T09-f"><a href="#T09-f">T09::f</a></h2>
+<h2 id="T09-f">T09::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -412,7 +412,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T10"><a href="#T10">T10</a></h2>
+<h2 id="T10">T10</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -442,7 +442,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T10-f"><a href="#T10-f">T10::f</a></h2>
+<h2 id="T10-f">T10::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -458,7 +458,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T11"><a href="#T11">T11</a></h2>
+<h2 id="T11">T11</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -488,7 +488,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T11-f"><a href="#T11-f">T11::f</a></h2>
+<h2 id="T11-f">T11::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -504,7 +504,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T12"><a href="#T12">T12</a></h2>
+<h2 id="T12">T12</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -534,7 +534,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T12-f"><a href="#T12-f">T12::f</a></h2>
+<h2 id="T12-f">T12::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -550,7 +550,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T13"><a href="#T13">T13</a></h2>
+<h2 id="T13">T13</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -580,7 +580,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T13-f"><a href="#T13-f">T13::f</a></h2>
+<h2 id="T13-f">T13::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -597,7 +597,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T14"><a href="#T14">T14</a></h2>
+<h2 id="T14">T14</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -642,7 +642,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="T14-f"><a href="#T14-f">T14::f</a></h2>
+<h2 id="T14-f">T14::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -659,7 +659,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T15"><a href="#T15">T15</a></h2>
+<h2 id="T15">T15</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -689,7 +689,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T15-f"><a href="#T15-f">T15::f</a></h2>
+<h2 id="T15-f">T15::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -705,7 +705,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T16"><a href="#T16">T16</a></h2>
+<h2 id="T16">T16</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -735,7 +735,7 @@ <h2>Static Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T16-f"><a href="#T16-f">T16::f</a></h2>
+<h2 id="T16-f">T16::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -752,7 +752,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T17"><a href="#T17">T17</a></h2>
+<h2 id="T17">T17</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -797,7 +797,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T17-f"><a href="#T17-f">T17::f</a></h2>
+<h2 id="T17-f">T17::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -814,7 +814,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="U"><a href="#U">U</a></h2>
+<h2 id="U">U</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -873,7 +873,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="U-f1"><a href="#U-f1">U::f1</a></h2>
+<h2 id="U-f1">U::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -890,7 +890,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="U-f3"><a href="#U-f3">U::f3</a></h2>
+<h2 id="U-f3">U::f3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -907,7 +907,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="U-f2"><a href="#U-f2">U::f2</a></h2>
+<h2 id="U-f2">U::f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -925,7 +925,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="V"><a href="#V">V</a></h2>
+<h2 id="V">V</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -984,7 +984,7 @@ <h2>Static Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="V-f3"><a href="#V-f3">V::f3</a></h2>
+<h2 id="V-f3">V::f3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/function/merge-params.html b/test-files/golden-tests/symbols/function/merge-params.html
index 96edd8516..15087f964 100644
--- a/test-files/golden-tests/symbols/function/merge-params.html
+++ b/test-files/golden-tests/symbols/function/merge-params.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>Function</span>
 
diff --git a/test-files/golden-tests/symbols/function/merge-tparams.html b/test-files/golden-tests/symbols/function/merge-tparams.html
index d55d20a3e..7fa1e2b41 100644
--- a/test-files/golden-tests/symbols/function/merge-tparams.html
+++ b/test-files/golden-tests/symbols/function/merge-tparams.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>Function</span>
 
diff --git a/test-files/golden-tests/symbols/function/noreturn.html b/test-files/golden-tests/symbols/function/noreturn.html
index 255a96191..162023d8d 100644
--- a/test-files/golden-tests/symbols/function/noreturn.html
+++ b/test-files/golden-tests/symbols/function/noreturn.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -38,7 +38,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T"><a href="#T">T</a></h2>
+<h2 id="T">T</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -99,7 +99,7 @@ <h2>Friends</h2>
 </div>
 <div>
 <div>
-<h2 id="T-f3"><a href="#T-f3">T::f3</a></h2>
+<h2 id="T-f3">T::f3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -116,7 +116,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T-f2"><a href="#T-f2">T::f2</a></h2>
+<h2 id="T-f2">T::f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -134,7 +134,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/function/overloaded-op-1.html b/test-files/golden-tests/symbols/function/overloaded-op-1.html
index f8dc00942..b5ef87702 100644
--- a/test-files/golden-tests/symbols/function/overloaded-op-1.html
+++ b/test-files/golden-tests/symbols/function/overloaded-op-1.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="T"><a href="#T">T</a></h2>
+<h2 id="T">T</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -56,7 +56,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T-operator_plus"><a href="#T-operator_plus">T::operator+</a></h2>
+<h2 id="T-operator_plus">T::operator+</h2>
 <div>
 <span>Unary plus operator</span>
 
diff --git a/test-files/golden-tests/symbols/function/overloaded-op-2.html b/test-files/golden-tests/symbols/function/overloaded-op-2.html
index 8d3673fe8..56a115b00 100644
--- a/test-files/golden-tests/symbols/function/overloaded-op-2.html
+++ b/test-files/golden-tests/symbols/function/overloaded-op-2.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="T"><a href="#T">T</a></h2>
+<h2 id="T">T</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -56,7 +56,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T-operator_plus"><a href="#T-operator_plus">T::operator+</a></h2>
+<h2 id="T-operator_plus">T::operator+</h2>
 <div>
 <span>Addition operator</span>
 
diff --git a/test-files/golden-tests/symbols/function/qualified-params.html b/test-files/golden-tests/symbols/function/qualified-params.html
index 6bea203b3..1c38f4064 100644
--- a/test-files/golden-tests/symbols/function/qualified-params.html
+++ b/test-files/golden-tests/symbols/function/qualified-params.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -39,7 +39,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="M"><a href="#M">M</a></h2>
+<h2 id="M">M</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -57,7 +57,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="M-D"><a href="#M-D">M::D</a></h2>
+<h2 id="M-D">M::D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -74,7 +74,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="N"><a href="#N">N</a></h2>
+<h2 id="N">N</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -92,7 +92,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="N-C"><a href="#N-C">N::C</a></h2>
+<h2 id="N-C">N::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -109,7 +109,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="foo"><a href="#foo">foo</a></h2>
+<h2 id="foo">foo</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/function/sfinae.html b/test-files/golden-tests/symbols/function/sfinae.html
index ecfc7a5a8..2bc059188 100644
--- a/test-files/golden-tests/symbols/function/sfinae.html
+++ b/test-files/golden-tests/symbols/function/sfinae.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -65,7 +65,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -84,7 +84,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="B-C"><a href="#B-C">B::C</a></h2>
+<h2 id="B-C">B::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -115,7 +115,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-09"><a href="#A-09">A</a></h2>
+<h2 id="A-09">A</h2>
 <div>
 <span>The partial specialization of A is enabled via a template parameter</span>
 
@@ -139,7 +139,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-07"><a href="#A-07">A&lt;T&gt;</a></h2>
+<h2 id="A-07">A&lt;T&gt;</h2>
 <div>
 <span>Specialization for integral types</span>
 
@@ -162,7 +162,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S-02"><a href="#S-02">S</a></h2>
+<h2 id="S-02">S</h2>
 <div>
 <span>SFINAE with std::void_t</span>
 
@@ -199,7 +199,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S-02-store"><a href="#S-02-store">S::store</a></h2>
+<h2 id="S-02-store">S::store</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -215,7 +215,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S-08"><a href="#S-08">S&lt;T, std::void_t&lt;T::a::b&gt;&gt;</a></h2>
+<h2 id="S-08">S&lt;T, std::void_t&lt;T::a::b&gt;&gt;</h2>
 <div>
 <span>SFINAE with std::void_t</span>
 
@@ -250,7 +250,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S-08-store"><a href="#S-08-store">S&lt;T, std::void_t&lt;T::a::b&gt;&gt;::store</a></h2>
+<h2 id="S-08-store">S&lt;T, std::void_t&lt;T::a::b&gt;&gt;::store</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -266,7 +266,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 <div>
 <span>Enabled via return type</span>
 
@@ -288,7 +288,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f10"><a href="#f10">f10</a></h2>
+<h2 id="f10">f10</h2>
 <div>
 <span>Enabled via type template parameter</span>
 
@@ -316,7 +316,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="f2"><a href="#f2">f2</a></h2>
+<h2 id="f2">f2</h2>
 <div>
 <span>Enabling a specified return type</span>
 
@@ -338,7 +338,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f3"><a href="#f3">f3</a></h2>
+<h2 id="f3">f3</h2>
 <div>
 <span>Enabling a specified return type in another namespace</span>
 
@@ -360,7 +360,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f4"><a href="#f4">f4</a></h2>
+<h2 id="f4">f4</h2>
 <div>
 <span>Enabled via return type with std::enable_if</span>
 
@@ -382,7 +382,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f5"><a href="#f5">f5</a></h2>
+<h2 id="f5">f5</h2>
 <div>
 <span>Enabled via a non-type template parameter with helper</span>
 
@@ -404,7 +404,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f6"><a href="#f6">f6</a></h2>
+<h2 id="f6">f6</h2>
 <div>
 <span>Enabled via a non-type template parameter without helper</span>
 
@@ -426,7 +426,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f7"><a href="#f7">f7</a></h2>
+<h2 id="f7">f7</h2>
 <div>
 <span>Enabled via a non-type template parameter using int instead of bool</span>
 
@@ -448,7 +448,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f8"><a href="#f8">f8</a></h2>
+<h2 id="f8">f8</h2>
 <div>
 <span>Enabled via parameter without helper</span>
 
@@ -470,7 +470,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f9"><a href="#f9">f9</a></h2>
+<h2 id="f9">f9</h2>
 <div>
 <span>Enabled via parameter with helper</span>
 
diff --git a/test-files/golden-tests/symbols/function/spec-mem-implicit-instantiation.html b/test-files/golden-tests/symbols/function/spec-mem-implicit-instantiation.html
index d15f3a7fd..9df0e4959 100644
--- a/test-files/golden-tests/symbols/function/spec-mem-implicit-instantiation.html
+++ b/test-files/golden-tests/symbols/function/spec-mem-implicit-instantiation.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -29,7 +29,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e"><a href="#A-0e">A</a></h2>
+<h2 id="A-0e">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -74,7 +74,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e-B"><a href="#A-0e-B">A::B</a></h2>
+<h2 id="A-0e-B">A::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -105,7 +105,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e-B-g"><a href="#A-0e-B-g">A::B::g</a></h2>
+<h2 id="A-0e-B-g">A::B::g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -121,7 +121,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0e-C"><a href="#A-0e-C">A::C</a></h2>
+<h2 id="A-0e-C">A::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -152,7 +152,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e-C-h"><a href="#A-0e-C-h">A::C::h</a></h2>
+<h2 id="A-0e-C-h">A::C::h</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -168,7 +168,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0e-f"><a href="#A-0e-f">A::f</a></h2>
+<h2 id="A-0e-f">A::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -184,7 +184,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0f"><a href="#A-0f">A&lt;bool&gt;</a></h2>
+<h2 id="A-0f">A&lt;bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -231,7 +231,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0f-B"><a href="#A-0f-B">A&lt;bool&gt;::B</a></h2>
+<h2 id="A-0f-B">A&lt;bool&gt;::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -249,7 +249,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0f-C-00"><a href="#A-0f-C-00">A&lt;bool&gt;::C</a></h2>
+<h2 id="A-0f-C-00">A&lt;bool&gt;::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -267,7 +267,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0f-C-01"><a href="#A-0f-C-01">A&lt;bool&gt;::C&lt;double*&gt;</a></h2>
+<h2 id="A-0f-C-01">A&lt;bool&gt;::C&lt;double*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -298,7 +298,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0f-C-01-j"><a href="#A-0f-C-01-j">A&lt;bool&gt;::C&lt;double*&gt;::j</a></h2>
+<h2 id="A-0f-C-01-j">A&lt;bool&gt;::C&lt;double*&gt;::j</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -314,7 +314,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0f-C-0c"><a href="#A-0f-C-0c">A&lt;bool&gt;::C&lt;U*&gt;</a></h2>
+<h2 id="A-0f-C-0c">A&lt;bool&gt;::C&lt;U*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -345,7 +345,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0f-C-0c-j"><a href="#A-0f-C-0c-j">A&lt;bool&gt;::C&lt;U*&gt;::j</a></h2>
+<h2 id="A-0f-C-0c-j">A&lt;bool&gt;::C&lt;U*&gt;::j</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -361,7 +361,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0f-f"><a href="#A-0f-f">A&lt;bool&gt;::f</a></h2>
+<h2 id="A-0f-f">A&lt;bool&gt;::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -377,7 +377,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-00b"><a href="#A-00b">A&lt;short&gt;</a></h2>
+<h2 id="A-00b">A&lt;short&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -422,7 +422,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-00b-B"><a href="#A-00b-B">A&lt;short&gt;::B</a></h2>
+<h2 id="A-00b-B">A&lt;short&gt;::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -440,7 +440,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-00b-C"><a href="#A-00b-C">A&lt;short&gt;::C</a></h2>
+<h2 id="A-00b-C">A&lt;short&gt;::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -471,7 +471,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-00b-C-i"><a href="#A-00b-C-i">A&lt;short&gt;::C::i</a></h2>
+<h2 id="A-00b-C-i">A&lt;short&gt;::C::i</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -487,7 +487,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-00b-f"><a href="#A-00b-f">A&lt;short&gt;::f</a></h2>
+<h2 id="A-00b-f">A&lt;short&gt;::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -503,7 +503,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-000"><a href="#A-000">A&lt;int&gt;</a></h2>
+<h2 id="A-000">A&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -549,7 +549,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-000-B-03"><a href="#A-000-B-03">A&lt;int&gt;::B</a></h2>
+<h2 id="A-000-B-03">A&lt;int&gt;::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -567,7 +567,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-000-B-09"><a href="#A-000-B-09">A&lt;int&gt;::B&lt;long&gt;</a></h2>
+<h2 id="A-000-B-09">A&lt;int&gt;::B&lt;long&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -598,7 +598,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-000-B-09-g"><a href="#A-000-B-09-g">A&lt;int&gt;::B&lt;long&gt;::g</a></h2>
+<h2 id="A-000-B-09-g">A&lt;int&gt;::B&lt;long&gt;::g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -614,7 +614,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-000-C"><a href="#A-000-C">A&lt;int&gt;::C</a></h2>
+<h2 id="A-000-C">A&lt;int&gt;::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -632,7 +632,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-000-f"><a href="#A-000-f">A&lt;int&gt;::f</a></h2>
+<h2 id="A-000-f">A&lt;int&gt;::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -648,7 +648,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="D"><a href="#D">D</a></h2>
+<h2 id="D">D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -679,7 +679,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="D-E-0e"><a href="#D-E-0e">D::E</a></h2>
+<h2 id="D-E-0e">D::E</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -710,7 +710,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="D-E-0e-k"><a href="#D-E-0e-k">D::E::k</a></h2>
+<h2 id="D-E-0e-k">D::E::k</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -726,7 +726,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="D-E-0d"><a href="#D-E-0d">D::E&lt;int&gt;</a></h2>
+<h2 id="D-E-0d">D::E&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -757,7 +757,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="D-E-0d-k"><a href="#D-E-0d-k">D::E&lt;int&gt;::k</a></h2>
+<h2 id="D-E-0d-k">D::E&lt;int&gt;::k</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/function/type-resolution.html b/test-files/golden-tests/symbols/function/type-resolution.html
index e48ed4d13..6f5806efa 100644
--- a/test-files/golden-tests/symbols/function/type-resolution.html
+++ b/test-files/golden-tests/symbols/function/type-resolution.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -86,7 +86,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="C"><a href="#C">C</a></h2>
+<h2 id="C">C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -101,7 +101,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="D"><a href="#D">D</a></h2>
+<h2 id="D">D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -116,7 +116,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="E"><a href="#E">E</a></h2>
+<h2 id="E">E</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -132,7 +132,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -149,7 +149,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -169,7 +169,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f0"><a href="#f0">f0</a></h2>
+<h2 id="f0">f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -185,7 +185,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f1"><a href="#f1">f1</a></h2>
+<h2 id="f1">f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -201,7 +201,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f2"><a href="#f2">f2</a></h2>
+<h2 id="f2">f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -217,7 +217,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f3"><a href="#f3">f3</a></h2>
+<h2 id="f3">f3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -233,7 +233,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f4"><a href="#f4">f4</a></h2>
+<h2 id="f4">f4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -249,7 +249,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f5"><a href="#f5">f5</a></h2>
+<h2 id="f5">f5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -265,7 +265,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f6"><a href="#f6">f6</a></h2>
+<h2 id="f6">f6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -281,7 +281,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f7"><a href="#f7">f7</a></h2>
+<h2 id="f7">f7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -297,7 +297,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f8"><a href="#f8">f8</a></h2>
+<h2 id="f8">f8</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -313,7 +313,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g0"><a href="#g0">g0</a></h2>
+<h2 id="g0">g0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -329,7 +329,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g1"><a href="#g1">g1</a></h2>
+<h2 id="g1">g1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -345,7 +345,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g2"><a href="#g2">g2</a></h2>
+<h2 id="g2">g2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -361,7 +361,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g3"><a href="#g3">g3</a></h2>
+<h2 id="g3">g3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -377,7 +377,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g4"><a href="#g4">g4</a></h2>
+<h2 id="g4">g4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -393,7 +393,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g5"><a href="#g5">g5</a></h2>
+<h2 id="g5">g5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -409,7 +409,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g6"><a href="#g6">g6</a></h2>
+<h2 id="g6">g6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -425,7 +425,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g7"><a href="#g7">g7</a></h2>
+<h2 id="g7">g7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -441,7 +441,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g8"><a href="#g8">g8</a></h2>
+<h2 id="g8">g8</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -457,7 +457,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="h0"><a href="#h0">h0</a></h2>
+<h2 id="h0">h0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -473,7 +473,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="h1"><a href="#h1">h1</a></h2>
+<h2 id="h1">h1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -489,7 +489,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="h2"><a href="#h2">h2</a></h2>
+<h2 id="h2">h2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -505,7 +505,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="h3"><a href="#h3">h3</a></h2>
+<h2 id="h3">h3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -521,7 +521,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="h4"><a href="#h4">h4</a></h2>
+<h2 id="h4">h4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -537,7 +537,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="h5"><a href="#h5">h5</a></h2>
+<h2 id="h5">h5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -553,7 +553,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="h6"><a href="#h6">h6</a></h2>
+<h2 id="h6">h6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -569,7 +569,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="h7"><a href="#h7">h7</a></h2>
+<h2 id="h7">h7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -585,7 +585,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="h8"><a href="#h8">h8</a></h2>
+<h2 id="h8">h8</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -601,7 +601,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="i0"><a href="#i0">i0</a></h2>
+<h2 id="i0">i0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -617,7 +617,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="i1"><a href="#i1">i1</a></h2>
+<h2 id="i1">i1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -633,7 +633,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="i2"><a href="#i2">i2</a></h2>
+<h2 id="i2">i2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -649,7 +649,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="i3"><a href="#i3">i3</a></h2>
+<h2 id="i3">i3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -665,7 +665,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="i4"><a href="#i4">i4</a></h2>
+<h2 id="i4">i4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -681,7 +681,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="i5"><a href="#i5">i5</a></h2>
+<h2 id="i5">i5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -697,7 +697,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="i6"><a href="#i6">i6</a></h2>
+<h2 id="i6">i6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -713,7 +713,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="i7"><a href="#i7">i7</a></h2>
+<h2 id="i7">i7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -729,7 +729,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="i8"><a href="#i8">i8</a></h2>
+<h2 id="i8">i8</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -745,7 +745,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="j0"><a href="#j0">j0</a></h2>
+<h2 id="j0">j0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -761,7 +761,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="j1"><a href="#j1">j1</a></h2>
+<h2 id="j1">j1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -777,7 +777,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="j2"><a href="#j2">j2</a></h2>
+<h2 id="j2">j2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -793,7 +793,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="j3"><a href="#j3">j3</a></h2>
+<h2 id="j3">j3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -809,7 +809,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="j4"><a href="#j4">j4</a></h2>
+<h2 id="j4">j4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -825,7 +825,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="j5"><a href="#j5">j5</a></h2>
+<h2 id="j5">j5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -841,7 +841,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="j6"><a href="#j6">j6</a></h2>
+<h2 id="j6">j6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -857,7 +857,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="j7"><a href="#j7">j7</a></h2>
+<h2 id="j7">j7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -873,7 +873,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="j8"><a href="#j8">j8</a></h2>
+<h2 id="j8">j8</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/function/variadic-function.html b/test-files/golden-tests/symbols/function/variadic-function.html
index 600be59b1..b1908b0b1 100644
--- a/test-files/golden-tests/symbols/function/variadic-function.html
+++ b/test-files/golden-tests/symbols/function/variadic-function.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -41,7 +41,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T"><a href="#T">T</a></h2>
+<h2 id="T">T</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -56,7 +56,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="U"><a href="#U">U</a></h2>
+<h2 id="U">U</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -71,7 +71,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C"><a href="#C">C</a></h2>
+<h2 id="C">C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -91,7 +91,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -107,7 +107,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g"><a href="#g">g</a></h2>
+<h2 id="g">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/guide/explicit-deduct-guide.html b/test-files/golden-tests/symbols/guide/explicit-deduct-guide.html
index 0283187c8..f1794a8ff 100644
--- a/test-files/golden-tests/symbols/guide/explicit-deduct-guide.html
+++ b/test-files/golden-tests/symbols/guide/explicit-deduct-guide.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -41,7 +41,7 @@ <h2>Deduction Guides</h2>
 </div>
 <div>
 <div>
-<h2 id="X-0e"><a href="#X-0e">X</a></h2>
+<h2 id="X-0e">X</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -59,7 +59,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X-0d"><a href="#X-0d">X&lt;0&gt;</a></h2>
+<h2 id="X-0d">X&lt;0&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -74,7 +74,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X-00"><a href="#X-00">X&lt;0&gt;</a></h2>
+<h2 id="X-00">X&lt;0&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -89,7 +89,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X-0b"><a href="#X-0b">X&lt;0&gt;</a></h2>
+<h2 id="X-0b">X&lt;0&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -104,7 +104,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X-06"><a href="#X-06">X&lt;0&gt;</a></h2>
+<h2 id="X-06">X&lt;0&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/namespace-alias/namespace-alias-1.html b/test-files/golden-tests/symbols/namespace-alias/namespace-alias-1.html
index 7ec73f1df..01a94b44a 100644
--- a/test-files/golden-tests/symbols/namespace-alias/namespace-alias-1.html
+++ b/test-files/golden-tests/symbols/namespace-alias/namespace-alias-1.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -38,7 +38,7 @@ <h2>Namespace Aliases</h2>
 </div>
 <div>
 <div>
-<h2 id="LongName"><a href="#LongName">LongName</a></h2>
+<h2 id="LongName">LongName</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -56,7 +56,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="LongName-A"><a href="#LongName-A">LongName::A</a></h2>
+<h2 id="LongName-A">LongName::A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -73,7 +73,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/namespace-alias/namespace-alias-2.html b/test-files/golden-tests/symbols/namespace-alias/namespace-alias-2.html
index fad9267f4..5f9cef62f 100644
--- a/test-files/golden-tests/symbols/namespace-alias/namespace-alias-2.html
+++ b/test-files/golden-tests/symbols/namespace-alias/namespace-alias-2.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -39,7 +39,7 @@ <h2>Namespace Aliases</h2>
 </div>
 <div>
 <div>
-<h2 id="LongName"><a href="#LongName">LongName</a></h2>
+<h2 id="LongName">LongName</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -57,7 +57,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="LongName-A"><a href="#LongName-A">LongName::A</a></h2>
+<h2 id="LongName-A">LongName::A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -74,7 +74,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -89,7 +89,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/namespace-alias/namespace-alias-3.html b/test-files/golden-tests/symbols/namespace-alias/namespace-alias-3.html
index b19115dd0..fb2790f40 100644
--- a/test-files/golden-tests/symbols/namespace-alias/namespace-alias-3.html
+++ b/test-files/golden-tests/symbols/namespace-alias/namespace-alias-3.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -39,7 +39,7 @@ <h2>Namespace Aliases</h2>
 </div>
 <div>
 <div>
-<h2 id="LongName"><a href="#LongName">LongName</a></h2>
+<h2 id="LongName">LongName</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -57,7 +57,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="LongName-A"><a href="#LongName-A">LongName::A</a></h2>
+<h2 id="LongName-A">LongName::A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -74,7 +74,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -89,7 +89,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/namespace/namespace.html b/test-files/golden-tests/symbols/namespace/namespace.html
index 3997fbe77..27c1b20ff 100644
--- a/test-files/golden-tests/symbols/namespace/namespace.html
+++ b/test-files/golden-tests/symbols/namespace/namespace.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -45,7 +45,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -78,7 +78,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-B"><a href="#A-B">A::B</a></h2>
+<h2 id="A-B">A::B</h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -96,7 +96,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-B-f1"><a href="#A-B-f1">A::B::f1</a></h2>
+<h2 id="A-B-f1">A::B::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -112,7 +112,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f0"><a href="#A-f0">A::f0</a></h2>
+<h2 id="A-f0">A::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -128,7 +128,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f2"><a href="#A-f2">A::f2</a></h2>
+<h2 id="A-f2">A::f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -144,7 +144,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f3"><a href="#A-f3">A::f3</a></h2>
+<h2 id="A-f3">A::f3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -160,7 +160,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="E"><a href="#E">E</a></h2>
+<h2 id="E">E</h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -178,7 +178,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="E-f6"><a href="#E-f6">E::f6</a></h2>
+<h2 id="E-f6">E::f6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -194,7 +194,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="G"><a href="#G">G</a></h2>
+<h2 id="G">G</h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -212,7 +212,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="G-f11"><a href="#G-f11">G::f11</a></h2>
+<h2 id="G-f11">G::f11</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -228,7 +228,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="I"><a href="#I">I</a></h2>
+<h2 id="I">I</h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -246,7 +246,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="I-f14"><a href="#I-f14">I::f14</a></h2>
+<h2 id="I-f14">I::f14</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -262,7 +262,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f10"><a href="#f10">f10</a></h2>
+<h2 id="f10">f10</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -278,7 +278,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f12"><a href="#f12">f12</a></h2>
+<h2 id="f12">f12</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -294,7 +294,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f5"><a href="#f5">f5</a></h2>
+<h2 id="f5">f5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -310,7 +310,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f7"><a href="#f7">f7</a></h2>
+<h2 id="f7">f7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -326,7 +326,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f8"><a href="#f8">f8</a></h2>
+<h2 id="f8">f8</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/overloads/overloads-brief.html b/test-files/golden-tests/symbols/overloads/overloads-brief.html
index ea857a675..619d4b9f8 100644
--- a/test-files/golden-tests/symbols/overloads/overloads-brief.html
+++ b/test-files/golden-tests/symbols/overloads/overloads-brief.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -43,7 +43,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 <div>
 <span>Overload briefs from function or operator classes</span>
 
@@ -95,7 +95,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-2constructor-0f"><a href="#A-2constructor-0f">A::A</a></h2>
+<h2 id="A-2constructor-0f">A::A</h2>
 <div>
 <span>Constructors</span>
 
@@ -141,7 +141,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-2constructor-03"><a href="#A-2constructor-03">A::A</a></h2>
+<h2 id="A-2constructor-03">A::A</h2>
 <div>
 <span>First constructor</span>
 
@@ -160,7 +160,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-2constructor-01"><a href="#A-2constructor-01">A::A</a></h2>
+<h2 id="A-2constructor-01">A::A</h2>
 <div>
 <span>Second constructor</span>
 
@@ -196,7 +196,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-operator_assign-04c"><a href="#A-operator_assign-04c">A::operator&#x3D;</a></h2>
+<h2 id="A-operator_assign-04c">A::operator&#x3D;</h2>
 <div>
 <span>Assignment operators</span>
 
@@ -248,7 +248,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-operator_assign-045"><a href="#A-operator_assign-045">A::operator&#x3D;</a></h2>
+<h2 id="A-operator_assign-045">A::operator&#x3D;</h2>
 <div>
 <span>Assign from A</span>
 
@@ -289,7 +289,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-operator_assign-06"><a href="#A-operator_assign-06">A::operator&#x3D;</a></h2>
+<h2 id="A-operator_assign-06">A::operator&#x3D;</h2>
 <div>
 <span>Assign from int</span>
 
@@ -330,7 +330,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-operator_plus-00"><a href="#A-operator_plus-00">A::operator+</a></h2>
+<h2 id="A-operator_plus-00">A::operator+</h2>
 <div>
 <span>Addition operators</span>
 
@@ -382,7 +382,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-operator_plus-0c"><a href="#A-operator_plus-0c">A::operator+</a></h2>
+<h2 id="A-operator_plus-0c">A::operator+</h2>
 <div>
 <span>Addition operator for ints</span>
 
@@ -423,7 +423,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-operator_plus-0e"><a href="#A-operator_plus-0e">A::operator+</a></h2>
+<h2 id="A-operator_plus-0e">A::operator+</h2>
 <div>
 <span>Addition operator for As</span>
 
@@ -464,7 +464,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-operator_minus-09"><a href="#A-operator_minus-09">A::operator-</a></h2>
+<h2 id="A-operator_minus-09">A::operator-</h2>
 <div>
 <span>Unary minus operators</span>
 
@@ -499,7 +499,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="A-operator_minus-02"><a href="#A-operator_minus-02">A::operator-</a></h2>
+<h2 id="A-operator_minus-02">A::operator-</h2>
 <div>
 <span>Unary operator- for A</span>
 
@@ -527,7 +527,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="A-operator_minus-0c"><a href="#A-operator_minus-0c">A::operator-</a></h2>
+<h2 id="A-operator_minus-0c">A::operator-</h2>
 <div>
 <span>Binary operator- for A</span>
 
@@ -572,7 +572,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 <div>
 <span>Auxiliary class</span>
 
@@ -607,7 +607,7 @@ <h2>Non-Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="no_way_to_infer_this_brief-04"><a href="#no_way_to_infer_this_brief-04">no_way_to_infer_this_brief</a></h2>
+<h2 id="no_way_to_infer_this_brief-04">no_way_to_infer_this_brief</h2>
 <div>
 <span><code>no_way_to_infer_this_brief</code> overloads</span>
 
@@ -655,7 +655,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="no_way_to_infer_this_brief-02"><a href="#no_way_to_infer_this_brief-02">no_way_to_infer_this_brief</a></h2>
+<h2 id="no_way_to_infer_this_brief-02">no_way_to_infer_this_brief</h2>
 <div>
 <span>Function with no params</span>
 
@@ -675,7 +675,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="no_way_to_infer_this_brief-01"><a href="#no_way_to_infer_this_brief-01">no_way_to_infer_this_brief</a></h2>
+<h2 id="no_way_to_infer_this_brief-01">no_way_to_infer_this_brief</h2>
 <div>
 <span>Function with single param</span>
 
@@ -712,7 +712,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_plus-09"><a href="#operator_plus-09">operator+</a></h2>
+<h2 id="operator_plus-09">operator+</h2>
 <div>
 <span>Unary plus operators</span>
 
@@ -747,7 +747,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_plus-0d"><a href="#operator_plus-0d">operator+</a></h2>
+<h2 id="operator_plus-0d">operator+</h2>
 <div>
 <span>Unary operator for A</span>
 
@@ -788,7 +788,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_plus-06"><a href="#operator_plus-06">operator+</a></h2>
+<h2 id="operator_plus-06">operator+</h2>
 <div>
 <span>Unary operator for B</span>
 
@@ -829,7 +829,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="sameBrief-07"><a href="#sameBrief-07">sameBrief</a></h2>
+<h2 id="sameBrief-07">sameBrief</h2>
 <div>
 <span>Function with same brief</span>
 
@@ -883,7 +883,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="sameBrief-0a"><a href="#sameBrief-0a">sameBrief</a></h2>
+<h2 id="sameBrief-0a">sameBrief</h2>
 <div>
 <span>Function with same brief</span>
 
@@ -920,7 +920,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="sameBrief-0e"><a href="#sameBrief-0e">sameBrief</a></h2>
+<h2 id="sameBrief-0e">sameBrief</h2>
 <div>
 <span>Function with same brief</span>
 
diff --git a/test-files/golden-tests/symbols/overloads/overloads-metadata.html b/test-files/golden-tests/symbols/overloads/overloads-metadata.html
index 9c7884e06..b481f6ff3 100644
--- a/test-files/golden-tests/symbols/overloads/overloads-metadata.html
+++ b/test-files/golden-tests/symbols/overloads/overloads-metadata.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f-0c"><a href="#f-0c">f</a></h2>
+<h2 id="f-0c">f</h2>
 <div>
 <span>Test function</span>
 
@@ -162,7 +162,7 @@ <h3>See Also</h3>
 </div>
 <div>
 <div>
-<h2 id="f-08"><a href="#f-08">f</a></h2>
+<h2 id="f-08">f</h2>
 <div>
 <span>Test function</span>
 
@@ -254,7 +254,7 @@ <h3>See Also</h3>
 </div>
 <div>
 <div>
-<h2 id="f-04"><a href="#f-04">f</a></h2>
+<h2 id="f-04">f</h2>
 <div>
 <span>Test function</span>
 
@@ -301,7 +301,7 @@ <h3>See Also</h3>
 </div>
 <div>
 <div>
-<h2 id="f-02"><a href="#f-02">f</a></h2>
+<h2 id="f-02">f</h2>
 <div>
 <span>Test function</span>
 
diff --git a/test-files/golden-tests/symbols/overloads/overloads-ostream.html b/test-files/golden-tests/symbols/overloads/overloads-ostream.html
index 619f50cf5..37019a9fc 100644
--- a/test-files/golden-tests/symbols/overloads/overloads-ostream.html
+++ b/test-files/golden-tests/symbols/overloads/overloads-ostream.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Namespaces</h2>
 </div>
 <div>
 <div>
-<h2 id="left_shift"><a href="#left_shift">left_shift</a></h2>
+<h2 id="left_shift">left_shift</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -57,7 +57,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="left_shift-A"><a href="#left_shift-A">left_shift::A</a></h2>
+<h2 id="left_shift-A">left_shift::A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -88,7 +88,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="left_shift-A-operator_lshift-00"><a href="#left_shift-A-operator_lshift-00">left_shift::A::operator&lt;&lt;</a></h2>
+<h2 id="left_shift-A-operator_lshift-00">left_shift::A::operator&lt;&lt;</h2>
 <div>
 <span>Left shift operators</span>
 
@@ -119,7 +119,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="left_shift-A-operator_lshift-0f"><a href="#left_shift-A-operator_lshift-0f">left_shift::A::operator&lt;&lt;</a></h2>
+<h2 id="left_shift-A-operator_lshift-0f">left_shift::A::operator&lt;&lt;</h2>
 <div>
 <span>Left shift operator</span>
 
@@ -160,7 +160,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="left_shift-A-operator_lshift-0b"><a href="#left_shift-A-operator_lshift-0b">left_shift::A::operator&lt;&lt;</a></h2>
+<h2 id="left_shift-A-operator_lshift-0b">left_shift::A::operator&lt;&lt;</h2>
 <div>
 <span>Left shift operator</span>
 
@@ -201,7 +201,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="left_shift-operator_lshift"><a href="#left_shift-operator_lshift">left_shift::operator&lt;&lt;</a></h2>
+<h2 id="left_shift-operator_lshift">left_shift::operator&lt;&lt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -219,7 +219,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="ostream"><a href="#ostream">ostream</a></h2>
+<h2 id="ostream">ostream</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -253,7 +253,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="ostream-B"><a href="#ostream-B">ostream::B</a></h2>
+<h2 id="ostream-B">ostream::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -288,7 +288,7 @@ <h2>Friends</h2>
 </div>
 <div>
 <div>
-<h2 id="ostream-C"><a href="#ostream-C">ostream::C</a></h2>
+<h2 id="ostream-C">ostream::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -305,7 +305,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="ostream-OStream"><a href="#ostream-OStream">ostream::OStream</a></h2>
+<h2 id="ostream-OStream">ostream::OStream</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -322,7 +322,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="ostream-operator_lshift-0f"><a href="#ostream-operator_lshift-0f">ostream::operator&lt;&lt;</a></h2>
+<h2 id="ostream-operator_lshift-0f">ostream::operator&lt;&lt;</h2>
 <div>
 <span>Stream insertion operators</span>
 
@@ -357,7 +357,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="ostream-operator_lshift-0d"><a href="#ostream-operator_lshift-0d">ostream::operator&lt;&lt;</a></h2>
+<h2 id="ostream-operator_lshift-0d">ostream::operator&lt;&lt;</h2>
 <div>
 <span>Stream insertion operator</span>
 
@@ -404,7 +404,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="ostream-operator_lshift-0a"><a href="#ostream-operator_lshift-0a">ostream::operator&lt;&lt;</a></h2>
+<h2 id="ostream-operator_lshift-0a">ostream::operator&lt;&lt;</h2>
 <div>
 <span>Stream insertion operator</span>
 
diff --git a/test-files/golden-tests/symbols/overloads/overloads.html b/test-files/golden-tests/symbols/overloads/overloads.html
index c9a4b2de9..4e9e28895 100644
--- a/test-files/golden-tests/symbols/overloads/overloads.html
+++ b/test-files/golden-tests/symbols/overloads/overloads.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -41,7 +41,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -108,7 +108,7 @@ <h2>Friends</h2>
 </div>
 <div>
 <div>
-<h2 id="A-f-07"><a href="#A-f-07">A::f</a></h2>
+<h2 id="A-f-07">A::f</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -135,7 +135,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f-08"><a href="#A-f-08">A::f</a></h2>
+<h2 id="A-f-08">A::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -151,7 +151,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f-0e"><a href="#A-f-0e">A::f</a></h2>
+<h2 id="A-f-0e">A::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -167,7 +167,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-g-0d"><a href="#A-g-0d">A::g</a></h2>
+<h2 id="A-g-0d">A::g</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -196,7 +196,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="A-g-0a"><a href="#A-g-0a">A::g</a></h2>
+<h2 id="A-g-0a">A::g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -213,7 +213,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-g-01"><a href="#A-g-01">A::g</a></h2>
+<h2 id="A-g-01">A::g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -230,7 +230,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -247,7 +247,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f-0c"><a href="#f-0c">f</a></h2>
+<h2 id="f-0c">f</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -274,7 +274,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="f-0b"><a href="#f-0b">f</a></h2>
+<h2 id="f-0b">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -290,7 +290,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f-06"><a href="#f-06">f</a></h2>
+<h2 id="f-06">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -306,7 +306,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_eq-073"><a href="#operator_eq-073">operator&#x3D;&#x3D;</a></h2>
+<h2 id="operator_eq-073">operator&#x3D;&#x3D;</h2>
 <div>
 <span>Equality operators</span>
 
@@ -361,7 +361,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_eq-0e"><a href="#operator_eq-0e">operator&#x3D;&#x3D;</a></h2>
+<h2 id="operator_eq-0e">operator&#x3D;&#x3D;</h2>
 <div>
 <span>Equality operator</span>
 
@@ -408,7 +408,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_eq-0a"><a href="#operator_eq-0a">operator&#x3D;&#x3D;</a></h2>
+<h2 id="operator_eq-0a">operator&#x3D;&#x3D;</h2>
 <div>
 <span>Equality operator</span>
 
@@ -455,7 +455,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_eq-08"><a href="#operator_eq-08">operator&#x3D;&#x3D;</a></h2>
+<h2 id="operator_eq-08">operator&#x3D;&#x3D;</h2>
 <div>
 <span>Equality operator</span>
 
@@ -502,7 +502,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="operator_eq-071"><a href="#operator_eq-071">operator&#x3D;&#x3D;</a></h2>
+<h2 id="operator_eq-071">operator&#x3D;&#x3D;</h2>
 <div>
 <span>Equality operator</span>
 
diff --git a/test-files/golden-tests/symbols/record/class-private-alias.html b/test-files/golden-tests/symbols/record/class-private-alias.html
index 56c9557b8..733e64feb 100644
--- a/test-files/golden-tests/symbols/record/class-private-alias.html
+++ b/test-files/golden-tests/symbols/record/class-private-alias.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="S"><a href="#S">S</a></h2>
+<h2 id="S">S</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -55,7 +55,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S-f"><a href="#S-f">S::f</a></h2>
+<h2 id="S-f">S::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/record/class-template-partial-spec.html b/test-files/golden-tests/symbols/record/class-template-partial-spec.html
index 60bb7c732..d17e7f87f 100644
--- a/test-files/golden-tests/symbols/record/class-template-partial-spec.html
+++ b/test-files/golden-tests/symbols/record/class-template-partial-spec.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -58,7 +58,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-B-0a"><a href="#A-B-0a">A::B</a></h2>
+<h2 id="A-B-0a">A::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -78,7 +78,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-B-04"><a href="#A-B-04">A::B&lt;T, long&gt;</a></h2>
+<h2 id="A-B-04">A::B&lt;T, long&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -96,7 +96,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-B-06"><a href="#A-B-06">A::B&lt;U*, T&gt;</a></h2>
+<h2 id="A-B-06">A::B&lt;U*, T&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/record/class-template-spec.html b/test-files/golden-tests/symbols/record/class-template-spec.html
index 8e83fedef..eeb7130c7 100644
--- a/test-files/golden-tests/symbols/record/class-template-spec.html
+++ b/test-files/golden-tests/symbols/record/class-template-spec.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -33,7 +33,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e"><a href="#A-0e">A</a></h2>
+<h2 id="A-0e">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -64,7 +64,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e-f"><a href="#A-0e-f">A::f</a></h2>
+<h2 id="A-0e-f">A::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -80,7 +80,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-00"><a href="#A-00">A&lt;int&gt;</a></h2>
+<h2 id="A-00">A&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -111,7 +111,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-00-g"><a href="#A-00-g">A&lt;int&gt;::g</a></h2>
+<h2 id="A-00-g">A&lt;int&gt;::g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -127,7 +127,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0c"><a href="#A-0c">A&lt;long&gt;</a></h2>
+<h2 id="A-0c">A&lt;long&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -158,7 +158,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0c-h"><a href="#A-0c-h">A&lt;long&gt;::h</a></h2>
+<h2 id="A-0c-h">A&lt;long&gt;::h</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -174,7 +174,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-00"><a href="#B-00">B</a></h2>
+<h2 id="B-00">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -205,7 +205,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="B-00-f"><a href="#B-00-f">B::f</a></h2>
+<h2 id="B-00-f">B::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -221,7 +221,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-06"><a href="#B-06">B&lt;T&&gt;</a></h2>
+<h2 id="B-06">B&lt;T&&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -252,7 +252,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="B-06-h"><a href="#B-06-h">B&lt;T&&gt;::h</a></h2>
+<h2 id="B-06-h">B&lt;T&&gt;::h</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -268,7 +268,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-07"><a href="#B-07">B&lt;T*&gt;</a></h2>
+<h2 id="B-07">B&lt;T*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -299,7 +299,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="B-07-g"><a href="#B-07-g">B&lt;T*&gt;::g</a></h2>
+<h2 id="B-07-g">B&lt;T*&gt;::g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -315,7 +315,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-0f"><a href="#C-0f">C</a></h2>
+<h2 id="C-0f">C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -348,7 +348,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="C-0f-f"><a href="#C-0f-f">C::f</a></h2>
+<h2 id="C-0f-f">C::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -364,7 +364,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-0a"><a href="#C-0a">C&lt;int, int&gt;</a></h2>
+<h2 id="C-0a">C&lt;int, int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -395,7 +395,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="C-0a-g"><a href="#C-0a-g">C&lt;int, int&gt;::g</a></h2>
+<h2 id="C-0a-g">C&lt;int, int&gt;::g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -411,7 +411,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-0e"><a href="#C-0e">C&lt;T*, int&gt;</a></h2>
+<h2 id="C-0e">C&lt;T*, int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -442,7 +442,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="C-0e-h"><a href="#C-0e-h">C&lt;T*, int&gt;::h</a></h2>
+<h2 id="C-0e-h">C&lt;T*, int&gt;::h</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/record/class-template-specializations-1.html b/test-files/golden-tests/symbols/record/class-template-specializations-1.html
index 36044b0f7..74e1e7f06 100644
--- a/test-files/golden-tests/symbols/record/class-template-specializations-1.html
+++ b/test-files/golden-tests/symbols/record/class-template-specializations-1.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -115,7 +115,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="R0"><a href="#R0">R0</a></h2>
+<h2 id="R0">R0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -174,7 +174,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="R1"><a href="#R1">R1</a></h2>
+<h2 id="R1">R1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -206,7 +206,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R10"><a href="#R10">R10</a></h2>
+<h2 id="R10">R10</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -238,7 +238,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R11"><a href="#R11">R11</a></h2>
+<h2 id="R11">R11</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -270,7 +270,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R12"><a href="#R12">R12</a></h2>
+<h2 id="R12">R12</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -302,7 +302,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R13"><a href="#R13">R13</a></h2>
+<h2 id="R13">R13</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -334,7 +334,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R14"><a href="#R14">R14</a></h2>
+<h2 id="R14">R14</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -366,7 +366,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R15"><a href="#R15">R15</a></h2>
+<h2 id="R15">R15</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -398,7 +398,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R16"><a href="#R16">R16</a></h2>
+<h2 id="R16">R16</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -430,7 +430,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R17"><a href="#R17">R17</a></h2>
+<h2 id="R17">R17</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -462,7 +462,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R18"><a href="#R18">R18</a></h2>
+<h2 id="R18">R18</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -494,7 +494,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R19"><a href="#R19">R19</a></h2>
+<h2 id="R19">R19</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -526,7 +526,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R2"><a href="#R2">R2</a></h2>
+<h2 id="R2">R2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -585,7 +585,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="R20"><a href="#R20">R20</a></h2>
+<h2 id="R20">R20</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -617,7 +617,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R21"><a href="#R21">R21</a></h2>
+<h2 id="R21">R21</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -649,7 +649,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R22"><a href="#R22">R22</a></h2>
+<h2 id="R22">R22</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -681,7 +681,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R23"><a href="#R23">R23</a></h2>
+<h2 id="R23">R23</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -713,7 +713,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R24"><a href="#R24">R24</a></h2>
+<h2 id="R24">R24</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -745,7 +745,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R25"><a href="#R25">R25</a></h2>
+<h2 id="R25">R25</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -777,7 +777,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R26"><a href="#R26">R26</a></h2>
+<h2 id="R26">R26</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -809,7 +809,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R27"><a href="#R27">R27</a></h2>
+<h2 id="R27">R27</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -841,7 +841,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R28"><a href="#R28">R28</a></h2>
+<h2 id="R28">R28</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -900,7 +900,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="R29"><a href="#R29">R29</a></h2>
+<h2 id="R29">R29</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -959,7 +959,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="R3"><a href="#R3">R3</a></h2>
+<h2 id="R3">R3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -991,7 +991,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R30"><a href="#R30">R30</a></h2>
+<h2 id="R30">R30</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1049,7 +1049,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="R31"><a href="#R31">R31</a></h2>
+<h2 id="R31">R31</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1084,7 +1084,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R32"><a href="#R32">R32</a></h2>
+<h2 id="R32">R32</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1116,7 +1116,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R33"><a href="#R33">R33</a></h2>
+<h2 id="R33">R33</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1148,7 +1148,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R34"><a href="#R34">R34</a></h2>
+<h2 id="R34">R34</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1193,7 +1193,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="R35"><a href="#R35">R35</a></h2>
+<h2 id="R35">R35</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1228,7 +1228,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R36"><a href="#R36">R36</a></h2>
+<h2 id="R36">R36</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1260,7 +1260,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R37"><a href="#R37">R37</a></h2>
+<h2 id="R37">R37</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1292,7 +1292,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R38"><a href="#R38">R38</a></h2>
+<h2 id="R38">R38</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1327,7 +1327,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R39"><a href="#R39">R39</a></h2>
+<h2 id="R39">R39</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1359,7 +1359,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R4"><a href="#R4">R4</a></h2>
+<h2 id="R4">R4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1391,7 +1391,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R40"><a href="#R40">R40</a></h2>
+<h2 id="R40">R40</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1423,7 +1423,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R41"><a href="#R41">R41</a></h2>
+<h2 id="R41">R41</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1481,7 +1481,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="R42"><a href="#R42">R42</a></h2>
+<h2 id="R42">R42</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1516,7 +1516,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R43"><a href="#R43">R43</a></h2>
+<h2 id="R43">R43</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1548,7 +1548,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R44"><a href="#R44">R44</a></h2>
+<h2 id="R44">R44</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1580,7 +1580,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R45"><a href="#R45">R45</a></h2>
+<h2 id="R45">R45</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1625,7 +1625,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="R46"><a href="#R46">R46</a></h2>
+<h2 id="R46">R46</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1660,7 +1660,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R47"><a href="#R47">R47</a></h2>
+<h2 id="R47">R47</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1692,7 +1692,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R48"><a href="#R48">R48</a></h2>
+<h2 id="R48">R48</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1724,7 +1724,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R5"><a href="#R5">R5</a></h2>
+<h2 id="R5">R5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1756,7 +1756,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R6"><a href="#R6">R6</a></h2>
+<h2 id="R6">R6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1788,7 +1788,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R7"><a href="#R7">R7</a></h2>
+<h2 id="R7">R7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1820,7 +1820,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R8"><a href="#R8">R8</a></h2>
+<h2 id="R8">R8</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1852,7 +1852,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R9"><a href="#R9">R9</a></h2>
+<h2 id="R9">R9</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1884,7 +1884,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf"><a href="#S0-0cf">S0</a></h2>
+<h2 id="S0-0cf">S0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1952,7 +1952,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf-S1"><a href="#S0-0cf-S1">S0::S1</a></h2>
+<h2 id="S0-0cf-S1">S0::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1995,7 +1995,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf-S1-S2"><a href="#S0-0cf-S1-S2">S0::S1::S2</a></h2>
+<h2 id="S0-0cf-S1-S2">S0::S1::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2042,7 +2042,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf-S1-S2-S3"><a href="#S0-0cf-S1-S2-S3">S0::S1::S2::S3</a></h2>
+<h2 id="S0-0cf-S1-S2-S3">S0::S1::S2::S3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2072,7 +2072,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf-S1-S2-S3-f3"><a href="#S0-0cf-S1-S2-S3-f3">S0::S1::S2::S3::f3</a></h2>
+<h2 id="S0-0cf-S1-S2-S3-f3">S0::S1::S2::S3::f3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2088,7 +2088,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf-S1-S2-S4"><a href="#S0-0cf-S1-S2-S4">S0::S1::S2::S4</a></h2>
+<h2 id="S0-0cf-S1-S2-S4">S0::S1::S2::S4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2121,7 +2121,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf-S1-S2-S4-f4"><a href="#S0-0cf-S1-S2-S4-f4">S0::S1::S2::S4::f4</a></h2>
+<h2 id="S0-0cf-S1-S2-S4-f4">S0::S1::S2::S4::f4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2137,7 +2137,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf-S1-S2-f2"><a href="#S0-0cf-S1-S2-f2">S0::S1::S2::f2</a></h2>
+<h2 id="S0-0cf-S1-S2-f2">S0::S1::S2::f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2153,7 +2153,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf-S1-f1"><a href="#S0-0cf-S1-f1">S0::S1::f1</a></h2>
+<h2 id="S0-0cf-S1-f1">S0::S1::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2169,7 +2169,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf-S5"><a href="#S0-0cf-S5">S0::S5</a></h2>
+<h2 id="S0-0cf-S5">S0::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2215,7 +2215,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf-S5-S6"><a href="#S0-0cf-S5-S6">S0::S5::S6</a></h2>
+<h2 id="S0-0cf-S5-S6">S0::S5::S6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2258,7 +2258,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf-S5-S6-S7"><a href="#S0-0cf-S5-S6-S7">S0::S5::S6::S7</a></h2>
+<h2 id="S0-0cf-S5-S6-S7">S0::S5::S6::S7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2305,7 +2305,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf-S5-S6-S7-S8"><a href="#S0-0cf-S5-S6-S7-S8">S0::S5::S6::S7::S8</a></h2>
+<h2 id="S0-0cf-S5-S6-S7-S8">S0::S5::S6::S7::S8</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2335,7 +2335,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf-S5-S6-S7-S8-f8"><a href="#S0-0cf-S5-S6-S7-S8-f8">S0::S5::S6::S7::S8::f8</a></h2>
+<h2 id="S0-0cf-S5-S6-S7-S8-f8">S0::S5::S6::S7::S8::f8</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2351,7 +2351,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf-S5-S6-S7-S9"><a href="#S0-0cf-S5-S6-S7-S9">S0::S5::S6::S7::S9</a></h2>
+<h2 id="S0-0cf-S5-S6-S7-S9">S0::S5::S6::S7::S9</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2384,7 +2384,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf-S5-S6-S7-S9-f9"><a href="#S0-0cf-S5-S6-S7-S9-f9">S0::S5::S6::S7::S9::f9</a></h2>
+<h2 id="S0-0cf-S5-S6-S7-S9-f9">S0::S5::S6::S7::S9::f9</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2400,7 +2400,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf-S5-S6-S7-f7"><a href="#S0-0cf-S5-S6-S7-f7">S0::S5::S6::S7::f7</a></h2>
+<h2 id="S0-0cf-S5-S6-S7-f7">S0::S5::S6::S7::f7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2416,7 +2416,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf-S5-S6-f6"><a href="#S0-0cf-S5-S6-f6">S0::S5::S6::f6</a></h2>
+<h2 id="S0-0cf-S5-S6-f6">S0::S5::S6::f6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2432,7 +2432,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf-S5-f5"><a href="#S0-0cf-S5-f5">S0::S5::f5</a></h2>
+<h2 id="S0-0cf-S5-f5">S0::S5::f5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2448,7 +2448,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0cf-f0"><a href="#S0-0cf-f0">S0::f0</a></h2>
+<h2 id="S0-0cf-f0">S0::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2464,7 +2464,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0be"><a href="#S0-0be">S0&lt;0&gt;</a></h2>
+<h2 id="S0-0be">S0&lt;0&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2497,7 +2497,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-08"><a href="#S0-08">S0&lt;10&gt;</a></h2>
+<h2 id="S0-08">S0&lt;10&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2542,7 +2542,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-08-S1"><a href="#S0-08-S1">S0&lt;10&gt;::S1</a></h2>
+<h2 id="S0-08-S1">S0&lt;10&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2586,7 +2586,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-08-S1-S2-0b"><a href="#S0-08-S1-S2-0b">S0&lt;10&gt;::S1::S2</a></h2>
+<h2 id="S0-08-S1-S2-0b">S0&lt;10&gt;::S1::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2606,7 +2606,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-08-S1-S2-08"><a href="#S0-08-S1-S2-08">S0&lt;10&gt;::S1::S2&lt;11&gt;</a></h2>
+<h2 id="S0-08-S1-S2-08">S0&lt;10&gt;::S1::S2&lt;11&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2651,7 +2651,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-08-S1-S2-08-S3"><a href="#S0-08-S1-S2-08-S3">S0&lt;10&gt;::S1::S2&lt;11&gt;::S3</a></h2>
+<h2 id="S0-08-S1-S2-08-S3">S0&lt;10&gt;::S1::S2&lt;11&gt;::S3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2668,7 +2668,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-08-S1-S2-08-S4"><a href="#S0-08-S1-S2-08-S4">S0&lt;10&gt;::S1::S2&lt;11&gt;::S4</a></h2>
+<h2 id="S0-08-S1-S2-08-S4">S0&lt;10&gt;::S1::S2&lt;11&gt;::S4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2703,7 +2703,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-08-S1-S2-08-f2"><a href="#S0-08-S1-S2-08-f2">S0&lt;10&gt;::S1::S2&lt;11&gt;::f2</a></h2>
+<h2 id="S0-08-S1-S2-08-f2">S0&lt;10&gt;::S1::S2&lt;11&gt;::f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2719,7 +2719,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-08-S1-f1"><a href="#S0-08-S1-f1">S0&lt;10&gt;::S1::f1</a></h2>
+<h2 id="S0-08-S1-f1">S0&lt;10&gt;::S1::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2735,7 +2735,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-08-S5"><a href="#S0-08-S5">S0&lt;10&gt;::S5</a></h2>
+<h2 id="S0-08-S5">S0&lt;10&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2755,7 +2755,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-08-f0"><a href="#S0-08-f0">S0&lt;10&gt;::f0</a></h2>
+<h2 id="S0-08-f0">S0&lt;10&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2771,7 +2771,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0e"><a href="#S0-0e">S0&lt;12&gt;</a></h2>
+<h2 id="S0-0e">S0&lt;12&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2816,7 +2816,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0e-S1"><a href="#S0-0e-S1">S0&lt;12&gt;::S1</a></h2>
+<h2 id="S0-0e-S1">S0&lt;12&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2860,7 +2860,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0e-S1-S2-09"><a href="#S0-0e-S1-S2-09">S0&lt;12&gt;::S1::S2</a></h2>
+<h2 id="S0-0e-S1-S2-09">S0&lt;12&gt;::S1::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2880,7 +2880,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0e-S1-S2-02"><a href="#S0-0e-S1-S2-02">S0&lt;12&gt;::S1::S2&lt;13&gt;</a></h2>
+<h2 id="S0-0e-S1-S2-02">S0&lt;12&gt;::S1::S2&lt;13&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2926,7 +2926,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0e-S1-S2-02-S3"><a href="#S0-0e-S1-S2-02-S3">S0&lt;12&gt;::S1::S2&lt;13&gt;::S3</a></h2>
+<h2 id="S0-0e-S1-S2-02-S3">S0&lt;12&gt;::S1::S2&lt;13&gt;::S3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2943,7 +2943,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0e-S1-S2-02-S4-00"><a href="#S0-0e-S1-S2-02-S4-00">S0&lt;12&gt;::S1::S2&lt;13&gt;::S4</a></h2>
+<h2 id="S0-0e-S1-S2-02-S4-00">S0&lt;12&gt;::S1::S2&lt;13&gt;::S4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2963,7 +2963,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0e-S1-S2-02-S4-0c"><a href="#S0-0e-S1-S2-02-S4-0c">S0&lt;12&gt;::S1::S2&lt;13&gt;::S4&lt;14&gt;</a></h2>
+<h2 id="S0-0e-S1-S2-02-S4-0c">S0&lt;12&gt;::S1::S2&lt;13&gt;::S4&lt;14&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -2996,7 +2996,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0e-S1-S2-02-f2"><a href="#S0-0e-S1-S2-02-f2">S0&lt;12&gt;::S1::S2&lt;13&gt;::f2</a></h2>
+<h2 id="S0-0e-S1-S2-02-f2">S0&lt;12&gt;::S1::S2&lt;13&gt;::f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3012,7 +3012,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0e-S1-f1"><a href="#S0-0e-S1-f1">S0&lt;12&gt;::S1::f1</a></h2>
+<h2 id="S0-0e-S1-f1">S0&lt;12&gt;::S1::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3028,7 +3028,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0e-S5"><a href="#S0-0e-S5">S0&lt;12&gt;::S5</a></h2>
+<h2 id="S0-0e-S5">S0&lt;12&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3048,7 +3048,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0e-f0"><a href="#S0-0e-f0">S0&lt;12&gt;::f0</a></h2>
+<h2 id="S0-0e-f0">S0&lt;12&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3064,7 +3064,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09e4"><a href="#S0-09e4">S0&lt;15&gt;</a></h2>
+<h2 id="S0-09e4">S0&lt;15&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3109,7 +3109,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-09e4-S1"><a href="#S0-09e4-S1">S0&lt;15&gt;::S1</a></h2>
+<h2 id="S0-09e4-S1">S0&lt;15&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3153,7 +3153,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-09e4-S1-S2-07"><a href="#S0-09e4-S1-S2-07">S0&lt;15&gt;::S1::S2</a></h2>
+<h2 id="S0-09e4-S1-S2-07">S0&lt;15&gt;::S1::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3173,7 +3173,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09e4-S1-S2-02"><a href="#S0-09e4-S1-S2-02">S0&lt;15&gt;::S1::S2&lt;16&gt;</a></h2>
+<h2 id="S0-09e4-S1-S2-02">S0&lt;15&gt;::S1::S2&lt;16&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3220,7 +3220,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-09e4-S1-S2-02-S3"><a href="#S0-09e4-S1-S2-02-S3">S0&lt;15&gt;::S1::S2&lt;16&gt;::S3</a></h2>
+<h2 id="S0-09e4-S1-S2-02-S3">S0&lt;15&gt;::S1::S2&lt;16&gt;::S3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3237,7 +3237,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09e4-S1-S2-02-S4-00"><a href="#S0-09e4-S1-S2-02-S4-00">S0&lt;15&gt;::S1::S2&lt;16&gt;::S4</a></h2>
+<h2 id="S0-09e4-S1-S2-02-S4-00">S0&lt;15&gt;::S1::S2&lt;16&gt;::S4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3272,7 +3272,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-09e4-S1-S2-02-S4-02"><a href="#S0-09e4-S1-S2-02-S4-02">S0&lt;15&gt;::S1::S2&lt;16&gt;::S4&lt;17, int*&gt;</a></h2>
+<h2 id="S0-09e4-S1-S2-02-S4-02">S0&lt;15&gt;::S1::S2&lt;16&gt;::S4&lt;17, int*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3305,7 +3305,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-09e4-S1-S2-02-S4-07"><a href="#S0-09e4-S1-S2-02-S4-07">S0&lt;15&gt;::S1::S2&lt;16&gt;::S4&lt;17, T*&gt;</a></h2>
+<h2 id="S0-09e4-S1-S2-02-S4-07">S0&lt;15&gt;::S1::S2&lt;16&gt;::S4&lt;17, T*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3323,7 +3323,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09e4-S1-S2-02-f2"><a href="#S0-09e4-S1-S2-02-f2">S0&lt;15&gt;::S1::S2&lt;16&gt;::f2</a></h2>
+<h2 id="S0-09e4-S1-S2-02-f2">S0&lt;15&gt;::S1::S2&lt;16&gt;::f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3339,7 +3339,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09e4-S1-f1"><a href="#S0-09e4-S1-f1">S0&lt;15&gt;::S1::f1</a></h2>
+<h2 id="S0-09e4-S1-f1">S0&lt;15&gt;::S1::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3355,7 +3355,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09e4-S5"><a href="#S0-09e4-S5">S0&lt;15&gt;::S5</a></h2>
+<h2 id="S0-09e4-S5">S0&lt;15&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3375,7 +3375,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09e4-f0"><a href="#S0-09e4-f0">S0&lt;15&gt;::f0</a></h2>
+<h2 id="S0-09e4-f0">S0&lt;15&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3391,7 +3391,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-07a"><a href="#S0-07a">S0&lt;18&gt;</a></h2>
+<h2 id="S0-07a">S0&lt;18&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3436,7 +3436,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-07a-S1"><a href="#S0-07a-S1">S0&lt;18&gt;::S1</a></h2>
+<h2 id="S0-07a-S1">S0&lt;18&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3453,7 +3453,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-07a-S5"><a href="#S0-07a-S5">S0&lt;18&gt;::S5</a></h2>
+<h2 id="S0-07a-S5">S0&lt;18&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3488,7 +3488,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-07a-f0"><a href="#S0-07a-f0">S0&lt;18&gt;::f0</a></h2>
+<h2 id="S0-07a-f0">S0&lt;18&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3504,7 +3504,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0a7"><a href="#S0-0a7">S0&lt;19&gt;</a></h2>
+<h2 id="S0-0a7">S0&lt;19&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3550,7 +3550,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0a7-S1"><a href="#S0-0a7-S1">S0&lt;19&gt;::S1</a></h2>
+<h2 id="S0-0a7-S1">S0&lt;19&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3567,7 +3567,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0a7-S5-03"><a href="#S0-0a7-S5-03">S0&lt;19&gt;::S5</a></h2>
+<h2 id="S0-0a7-S5-03">S0&lt;19&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3587,7 +3587,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0a7-S5-07"><a href="#S0-0a7-S5-07">S0&lt;19&gt;::S5&lt;20&gt;</a></h2>
+<h2 id="S0-0a7-S5-07">S0&lt;19&gt;::S5&lt;20&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3620,7 +3620,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0a7-f0"><a href="#S0-0a7-f0">S0&lt;19&gt;::f0</a></h2>
+<h2 id="S0-0a7-f0">S0&lt;19&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3636,7 +3636,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09c"><a href="#S0-09c">S0&lt;2&gt;</a></h2>
+<h2 id="S0-09c">S0&lt;2&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3681,7 +3681,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-09c-S1"><a href="#S0-09c-S1">S0&lt;2&gt;::S1</a></h2>
+<h2 id="S0-09c-S1">S0&lt;2&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3713,7 +3713,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-09c-S5"><a href="#S0-09c-S5">S0&lt;2&gt;::S5</a></h2>
+<h2 id="S0-09c-S5">S0&lt;2&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3733,7 +3733,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09c-f0"><a href="#S0-09c-f0">S0&lt;2&gt;::f0</a></h2>
+<h2 id="S0-09c-f0">S0&lt;2&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3749,7 +3749,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0314"><a href="#S0-0314">S0&lt;21&gt;</a></h2>
+<h2 id="S0-0314">S0&lt;21&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3796,7 +3796,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0314-S1"><a href="#S0-0314-S1">S0&lt;21&gt;::S1</a></h2>
+<h2 id="S0-0314-S1">S0&lt;21&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3813,7 +3813,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0314-S5-07"><a href="#S0-0314-S5-07">S0&lt;21&gt;::S5</a></h2>
+<h2 id="S0-0314-S5-07">S0&lt;21&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3848,7 +3848,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0314-S5-03"><a href="#S0-0314-S5-03">S0&lt;21&gt;::S5&lt;22, int*&gt;</a></h2>
+<h2 id="S0-0314-S5-03">S0&lt;21&gt;::S5&lt;22, int*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3881,7 +3881,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0314-S5-0b"><a href="#S0-0314-S5-0b">S0&lt;21&gt;::S5&lt;22, T*&gt;</a></h2>
+<h2 id="S0-0314-S5-0b">S0&lt;21&gt;::S5&lt;22, T*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3899,7 +3899,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0314-f0"><a href="#S0-0314-f0">S0&lt;21&gt;::f0</a></h2>
+<h2 id="S0-0314-f0">S0&lt;21&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3915,7 +3915,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-058"><a href="#S0-058">S0&lt;23&gt;</a></h2>
+<h2 id="S0-058">S0&lt;23&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3961,7 +3961,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-058-S1"><a href="#S0-058-S1">S0&lt;23&gt;::S1</a></h2>
+<h2 id="S0-058-S1">S0&lt;23&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3978,7 +3978,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-058-S5-0b"><a href="#S0-058-S5-0b">S0&lt;23&gt;::S5</a></h2>
+<h2 id="S0-058-S5-0b">S0&lt;23&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -3998,7 +3998,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-058-S5-09"><a href="#S0-058-S5-09">S0&lt;23&gt;::S5&lt;24&gt;</a></h2>
+<h2 id="S0-058-S5-09">S0&lt;23&gt;::S5&lt;24&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4042,7 +4042,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-058-S5-09-S6"><a href="#S0-058-S5-09-S6">S0&lt;23&gt;::S5&lt;24&gt;::S6</a></h2>
+<h2 id="S0-058-S5-09-S6">S0&lt;23&gt;::S5&lt;24&gt;::S6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4074,7 +4074,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-058-S5-09-f5"><a href="#S0-058-S5-09-f5">S0&lt;23&gt;::S5&lt;24&gt;::f5</a></h2>
+<h2 id="S0-058-S5-09-f5">S0&lt;23&gt;::S5&lt;24&gt;::f5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4090,7 +4090,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-058-f0"><a href="#S0-058-f0">S0&lt;23&gt;::f0</a></h2>
+<h2 id="S0-058-f0">S0&lt;23&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4106,7 +4106,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0a2"><a href="#S0-0a2">S0&lt;25&gt;</a></h2>
+<h2 id="S0-0a2">S0&lt;25&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4152,7 +4152,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0a2-S1"><a href="#S0-0a2-S1">S0&lt;25&gt;::S1</a></h2>
+<h2 id="S0-0a2-S1">S0&lt;25&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4169,7 +4169,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0a2-S5-04"><a href="#S0-0a2-S5-04">S0&lt;25&gt;::S5</a></h2>
+<h2 id="S0-0a2-S5-04">S0&lt;25&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4189,7 +4189,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0a2-S5-02"><a href="#S0-0a2-S5-02">S0&lt;25&gt;::S5&lt;26&gt;</a></h2>
+<h2 id="S0-0a2-S5-02">S0&lt;25&gt;::S5&lt;26&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4233,7 +4233,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0a2-S5-02-S6"><a href="#S0-0a2-S5-02-S6">S0&lt;25&gt;::S5&lt;26&gt;::S6</a></h2>
+<h2 id="S0-0a2-S5-02-S6">S0&lt;25&gt;::S5&lt;26&gt;::S6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4276,7 +4276,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0a2-S5-02-S6-S7"><a href="#S0-0a2-S5-02-S6-S7">S0&lt;25&gt;::S5&lt;26&gt;::S6::S7</a></h2>
+<h2 id="S0-0a2-S5-02-S6-S7">S0&lt;25&gt;::S5&lt;26&gt;::S6::S7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4311,7 +4311,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0a2-S5-02-S6-f6"><a href="#S0-0a2-S5-02-S6-f6">S0&lt;25&gt;::S5&lt;26&gt;::S6::f6</a></h2>
+<h2 id="S0-0a2-S5-02-S6-f6">S0&lt;25&gt;::S5&lt;26&gt;::S6::f6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4327,7 +4327,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0a2-S5-02-f5"><a href="#S0-0a2-S5-02-f5">S0&lt;25&gt;::S5&lt;26&gt;::f5</a></h2>
+<h2 id="S0-0a2-S5-02-f5">S0&lt;25&gt;::S5&lt;26&gt;::f5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4343,7 +4343,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0a2-f0"><a href="#S0-0a2-f0">S0&lt;25&gt;::f0</a></h2>
+<h2 id="S0-0a2-f0">S0&lt;25&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4359,7 +4359,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09e2"><a href="#S0-09e2">S0&lt;27&gt;</a></h2>
+<h2 id="S0-09e2">S0&lt;27&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4405,7 +4405,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-09e2-S1"><a href="#S0-09e2-S1">S0&lt;27&gt;::S1</a></h2>
+<h2 id="S0-09e2-S1">S0&lt;27&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4422,7 +4422,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09e2-S5-0b"><a href="#S0-09e2-S5-0b">S0&lt;27&gt;::S5</a></h2>
+<h2 id="S0-09e2-S5-0b">S0&lt;27&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4442,7 +4442,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09e2-S5-0c"><a href="#S0-09e2-S5-0c">S0&lt;27&gt;::S5&lt;28&gt;</a></h2>
+<h2 id="S0-09e2-S5-0c">S0&lt;27&gt;::S5&lt;28&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4486,7 +4486,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-09e2-S5-0c-S6"><a href="#S0-09e2-S5-0c-S6">S0&lt;27&gt;::S5&lt;28&gt;::S6</a></h2>
+<h2 id="S0-09e2-S5-0c-S6">S0&lt;27&gt;::S5&lt;28&gt;::S6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4531,7 +4531,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-09e2-S5-0c-S6-S7-0b"><a href="#S0-09e2-S5-0c-S6-S7-0b">S0&lt;27&gt;::S5&lt;28&gt;::S6::S7</a></h2>
+<h2 id="S0-09e2-S5-0c-S6-S7-0b">S0&lt;27&gt;::S5&lt;28&gt;::S6::S7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4566,7 +4566,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-09e2-S5-0c-S6-S7-0d"><a href="#S0-09e2-S5-0c-S6-S7-0d">S0&lt;27&gt;::S5&lt;28&gt;::S6::S7&lt;29, int*&gt;</a></h2>
+<h2 id="S0-09e2-S5-0c-S6-S7-0d">S0&lt;27&gt;::S5&lt;28&gt;::S6::S7&lt;29, int*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4599,7 +4599,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-09e2-S5-0c-S6-S7-0a"><a href="#S0-09e2-S5-0c-S6-S7-0a">S0&lt;27&gt;::S5&lt;28&gt;::S6::S7&lt;29, T*&gt;</a></h2>
+<h2 id="S0-09e2-S5-0c-S6-S7-0a">S0&lt;27&gt;::S5&lt;28&gt;::S6::S7&lt;29, T*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4617,7 +4617,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09e2-S5-0c-S6-f6"><a href="#S0-09e2-S5-0c-S6-f6">S0&lt;27&gt;::S5&lt;28&gt;::S6::f6</a></h2>
+<h2 id="S0-09e2-S5-0c-S6-f6">S0&lt;27&gt;::S5&lt;28&gt;::S6::f6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4633,7 +4633,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09e2-S5-0c-f5"><a href="#S0-09e2-S5-0c-f5">S0&lt;27&gt;::S5&lt;28&gt;::f5</a></h2>
+<h2 id="S0-09e2-S5-0c-f5">S0&lt;27&gt;::S5&lt;28&gt;::f5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4649,7 +4649,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09e2-f0"><a href="#S0-09e2-f0">S0&lt;27&gt;::f0</a></h2>
+<h2 id="S0-09e2-f0">S0&lt;27&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4665,7 +4665,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-073"><a href="#S0-073">S0&lt;3&gt;</a></h2>
+<h2 id="S0-073">S0&lt;3&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4710,7 +4710,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-073-S1"><a href="#S0-073-S1">S0&lt;3&gt;::S1</a></h2>
+<h2 id="S0-073-S1">S0&lt;3&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4753,7 +4753,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-073-S1-S2"><a href="#S0-073-S1-S2">S0&lt;3&gt;::S1::S2</a></h2>
+<h2 id="S0-073-S1-S2">S0&lt;3&gt;::S1::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4788,7 +4788,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-073-S1-f1"><a href="#S0-073-S1-f1">S0&lt;3&gt;::S1::f1</a></h2>
+<h2 id="S0-073-S1-f1">S0&lt;3&gt;::S1::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4804,7 +4804,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-073-S5"><a href="#S0-073-S5">S0&lt;3&gt;::S5</a></h2>
+<h2 id="S0-073-S5">S0&lt;3&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4824,7 +4824,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-073-f0"><a href="#S0-073-f0">S0&lt;3&gt;::f0</a></h2>
+<h2 id="S0-073-f0">S0&lt;3&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4840,7 +4840,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-01"><a href="#S0-01">S0&lt;30&gt;</a></h2>
+<h2 id="S0-01">S0&lt;30&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4886,7 +4886,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-01-S1"><a href="#S0-01-S1">S0&lt;30&gt;::S1</a></h2>
+<h2 id="S0-01-S1">S0&lt;30&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4903,7 +4903,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-01-S5-07"><a href="#S0-01-S5-07">S0&lt;30&gt;::S5</a></h2>
+<h2 id="S0-01-S5-07">S0&lt;30&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4923,7 +4923,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-01-S5-04"><a href="#S0-01-S5-04">S0&lt;30&gt;::S5&lt;31&gt;</a></h2>
+<h2 id="S0-01-S5-04">S0&lt;30&gt;::S5&lt;31&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -4967,7 +4967,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-01-S5-04-S6"><a href="#S0-01-S5-04-S6">S0&lt;30&gt;::S5&lt;31&gt;::S6</a></h2>
+<h2 id="S0-01-S5-04-S6">S0&lt;30&gt;::S5&lt;31&gt;::S6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5011,7 +5011,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-01-S5-04-S6-S7-0c"><a href="#S0-01-S5-04-S6-S7-0c">S0&lt;30&gt;::S5&lt;31&gt;::S6::S7</a></h2>
+<h2 id="S0-01-S5-04-S6-S7-0c">S0&lt;30&gt;::S5&lt;31&gt;::S6::S7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5031,7 +5031,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-01-S5-04-S6-S7-05"><a href="#S0-01-S5-04-S6-S7-05">S0&lt;30&gt;::S5&lt;31&gt;::S6::S7&lt;32&gt;</a></h2>
+<h2 id="S0-01-S5-04-S6-S7-05">S0&lt;30&gt;::S5&lt;31&gt;::S6::S7&lt;32&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5064,7 +5064,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-01-S5-04-S6-f6"><a href="#S0-01-S5-04-S6-f6">S0&lt;30&gt;::S5&lt;31&gt;::S6::f6</a></h2>
+<h2 id="S0-01-S5-04-S6-f6">S0&lt;30&gt;::S5&lt;31&gt;::S6::f6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5080,7 +5080,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-01-S5-04-f5"><a href="#S0-01-S5-04-f5">S0&lt;30&gt;::S5&lt;31&gt;::f5</a></h2>
+<h2 id="S0-01-S5-04-f5">S0&lt;30&gt;::S5&lt;31&gt;::f5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5096,7 +5096,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-01-f0"><a href="#S0-01-f0">S0&lt;30&gt;::f0</a></h2>
+<h2 id="S0-01-f0">S0&lt;30&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5112,7 +5112,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09ee"><a href="#S0-09ee">S0&lt;33&gt;</a></h2>
+<h2 id="S0-09ee">S0&lt;33&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5158,7 +5158,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-09ee-S1"><a href="#S0-09ee-S1">S0&lt;33&gt;::S1</a></h2>
+<h2 id="S0-09ee-S1">S0&lt;33&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5175,7 +5175,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09ee-S5-0b"><a href="#S0-09ee-S5-0b">S0&lt;33&gt;::S5</a></h2>
+<h2 id="S0-09ee-S5-0b">S0&lt;33&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5195,7 +5195,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09ee-S5-02"><a href="#S0-09ee-S5-02">S0&lt;33&gt;::S5&lt;34&gt;</a></h2>
+<h2 id="S0-09ee-S5-02">S0&lt;33&gt;::S5&lt;34&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5239,7 +5239,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-09ee-S5-02-S6"><a href="#S0-09ee-S5-02-S6">S0&lt;33&gt;::S5&lt;34&gt;::S6</a></h2>
+<h2 id="S0-09ee-S5-02-S6">S0&lt;33&gt;::S5&lt;34&gt;::S6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5283,7 +5283,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-09ee-S5-02-S6-S7-09"><a href="#S0-09ee-S5-02-S6-S7-09">S0&lt;33&gt;::S5&lt;34&gt;::S6::S7</a></h2>
+<h2 id="S0-09ee-S5-02-S6-S7-09">S0&lt;33&gt;::S5&lt;34&gt;::S6::S7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5303,7 +5303,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09ee-S5-02-S6-S7-03"><a href="#S0-09ee-S5-02-S6-S7-03">S0&lt;33&gt;::S5&lt;34&gt;::S6::S7&lt;35&gt;</a></h2>
+<h2 id="S0-09ee-S5-02-S6-S7-03">S0&lt;33&gt;::S5&lt;34&gt;::S6::S7&lt;35&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5348,7 +5348,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-09ee-S5-02-S6-S7-03-S8"><a href="#S0-09ee-S5-02-S6-S7-03-S8">S0&lt;33&gt;::S5&lt;34&gt;::S6::S7&lt;35&gt;::S8</a></h2>
+<h2 id="S0-09ee-S5-02-S6-S7-03-S8">S0&lt;33&gt;::S5&lt;34&gt;::S6::S7&lt;35&gt;::S8</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5380,7 +5380,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-09ee-S5-02-S6-S7-03-S9"><a href="#S0-09ee-S5-02-S6-S7-03-S9">S0&lt;33&gt;::S5&lt;34&gt;::S6::S7&lt;35&gt;::S9</a></h2>
+<h2 id="S0-09ee-S5-02-S6-S7-03-S9">S0&lt;33&gt;::S5&lt;34&gt;::S6::S7&lt;35&gt;::S9</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5400,7 +5400,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09ee-S5-02-S6-S7-03-f7"><a href="#S0-09ee-S5-02-S6-S7-03-f7">S0&lt;33&gt;::S5&lt;34&gt;::S6::S7&lt;35&gt;::f7</a></h2>
+<h2 id="S0-09ee-S5-02-S6-S7-03-f7">S0&lt;33&gt;::S5&lt;34&gt;::S6::S7&lt;35&gt;::f7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5416,7 +5416,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09ee-S5-02-S6-f6"><a href="#S0-09ee-S5-02-S6-f6">S0&lt;33&gt;::S5&lt;34&gt;::S6::f6</a></h2>
+<h2 id="S0-09ee-S5-02-S6-f6">S0&lt;33&gt;::S5&lt;34&gt;::S6::f6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5432,7 +5432,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09ee-S5-02-f5"><a href="#S0-09ee-S5-02-f5">S0&lt;33&gt;::S5&lt;34&gt;::f5</a></h2>
+<h2 id="S0-09ee-S5-02-f5">S0&lt;33&gt;::S5&lt;34&gt;::f5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5448,7 +5448,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09ee-f0"><a href="#S0-09ee-f0">S0&lt;33&gt;::f0</a></h2>
+<h2 id="S0-09ee-f0">S0&lt;33&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5464,7 +5464,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-033"><a href="#S0-033">S0&lt;36&gt;</a></h2>
+<h2 id="S0-033">S0&lt;36&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5510,7 +5510,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-033-S1"><a href="#S0-033-S1">S0&lt;36&gt;::S1</a></h2>
+<h2 id="S0-033-S1">S0&lt;36&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5527,7 +5527,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-033-S5-03"><a href="#S0-033-S5-03">S0&lt;36&gt;::S5</a></h2>
+<h2 id="S0-033-S5-03">S0&lt;36&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5547,7 +5547,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-033-S5-0f"><a href="#S0-033-S5-0f">S0&lt;36&gt;::S5&lt;37&gt;</a></h2>
+<h2 id="S0-033-S5-0f">S0&lt;36&gt;::S5&lt;37&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5591,7 +5591,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-033-S5-0f-S6"><a href="#S0-033-S5-0f-S6">S0&lt;36&gt;::S5&lt;37&gt;::S6</a></h2>
+<h2 id="S0-033-S5-0f-S6">S0&lt;36&gt;::S5&lt;37&gt;::S6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5635,7 +5635,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-033-S5-0f-S6-S7-05"><a href="#S0-033-S5-0f-S6-S7-05">S0&lt;36&gt;::S5&lt;37&gt;::S6::S7</a></h2>
+<h2 id="S0-033-S5-0f-S6-S7-05">S0&lt;36&gt;::S5&lt;37&gt;::S6::S7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5655,7 +5655,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-033-S5-0f-S6-S7-0d"><a href="#S0-033-S5-0f-S6-S7-0d">S0&lt;36&gt;::S5&lt;37&gt;::S6::S7&lt;38&gt;</a></h2>
+<h2 id="S0-033-S5-0f-S6-S7-0d">S0&lt;36&gt;::S5&lt;37&gt;::S6::S7&lt;38&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5700,7 +5700,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-033-S5-0f-S6-S7-0d-S8"><a href="#S0-033-S5-0f-S6-S7-0d-S8">S0&lt;36&gt;::S5&lt;37&gt;::S6::S7&lt;38&gt;::S8</a></h2>
+<h2 id="S0-033-S5-0f-S6-S7-0d-S8">S0&lt;36&gt;::S5&lt;37&gt;::S6::S7&lt;38&gt;::S8</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5717,7 +5717,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-033-S5-0f-S6-S7-0d-S9"><a href="#S0-033-S5-0f-S6-S7-0d-S9">S0&lt;36&gt;::S5&lt;37&gt;::S6::S7&lt;38&gt;::S9</a></h2>
+<h2 id="S0-033-S5-0f-S6-S7-0d-S9">S0&lt;36&gt;::S5&lt;37&gt;::S6::S7&lt;38&gt;::S9</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5752,7 +5752,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-033-S5-0f-S6-S7-0d-f7"><a href="#S0-033-S5-0f-S6-S7-0d-f7">S0&lt;36&gt;::S5&lt;37&gt;::S6::S7&lt;38&gt;::f7</a></h2>
+<h2 id="S0-033-S5-0f-S6-S7-0d-f7">S0&lt;36&gt;::S5&lt;37&gt;::S6::S7&lt;38&gt;::f7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5768,7 +5768,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-033-S5-0f-S6-f6"><a href="#S0-033-S5-0f-S6-f6">S0&lt;36&gt;::S5&lt;37&gt;::S6::f6</a></h2>
+<h2 id="S0-033-S5-0f-S6-f6">S0&lt;36&gt;::S5&lt;37&gt;::S6::f6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5784,7 +5784,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-033-S5-0f-f5"><a href="#S0-033-S5-0f-f5">S0&lt;36&gt;::S5&lt;37&gt;::f5</a></h2>
+<h2 id="S0-033-S5-0f-f5">S0&lt;36&gt;::S5&lt;37&gt;::f5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5800,7 +5800,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-033-f0"><a href="#S0-033-f0">S0&lt;36&gt;::f0</a></h2>
+<h2 id="S0-033-f0">S0&lt;36&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5816,7 +5816,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-06"><a href="#S0-06">S0&lt;39&gt;</a></h2>
+<h2 id="S0-06">S0&lt;39&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5862,7 +5862,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-06-S1"><a href="#S0-06-S1">S0&lt;39&gt;::S1</a></h2>
+<h2 id="S0-06-S1">S0&lt;39&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5879,7 +5879,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-06-S5-03"><a href="#S0-06-S5-03">S0&lt;39&gt;::S5</a></h2>
+<h2 id="S0-06-S5-03">S0&lt;39&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5899,7 +5899,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-06-S5-07"><a href="#S0-06-S5-07">S0&lt;39&gt;::S5&lt;40&gt;</a></h2>
+<h2 id="S0-06-S5-07">S0&lt;39&gt;::S5&lt;40&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5943,7 +5943,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-06-S5-07-S6"><a href="#S0-06-S5-07-S6">S0&lt;39&gt;::S5&lt;40&gt;::S6</a></h2>
+<h2 id="S0-06-S5-07-S6">S0&lt;39&gt;::S5&lt;40&gt;::S6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -5987,7 +5987,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-06-S5-07-S6-S7-08"><a href="#S0-06-S5-07-S6-S7-08">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7</a></h2>
+<h2 id="S0-06-S5-07-S6-S7-08">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6007,7 +6007,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-06-S5-07-S6-S7-0a"><a href="#S0-06-S5-07-S6-S7-0a">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;</a></h2>
+<h2 id="S0-06-S5-07-S6-S7-0a">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6054,7 +6054,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-06-S5-07-S6-S7-0a-S8"><a href="#S0-06-S5-07-S6-S7-0a-S8">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;::S8</a></h2>
+<h2 id="S0-06-S5-07-S6-S7-0a-S8">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;::S8</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6071,7 +6071,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-06-S5-07-S6-S7-0a-S9-05"><a href="#S0-06-S5-07-S6-S7-0a-S9-05">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;::S9</a></h2>
+<h2 id="S0-06-S5-07-S6-S7-0a-S9-05">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;::S9</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6106,7 +6106,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-06-S5-07-S6-S7-0a-S9-08"><a href="#S0-06-S5-07-S6-S7-0a-S9-08">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;::S9&lt;42, int*&gt;</a></h2>
+<h2 id="S0-06-S5-07-S6-S7-0a-S9-08">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;::S9&lt;42, int*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6139,7 +6139,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-06-S5-07-S6-S7-0a-S9-00"><a href="#S0-06-S5-07-S6-S7-0a-S9-00">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;::S9&lt;42, T*&gt;</a></h2>
+<h2 id="S0-06-S5-07-S6-S7-0a-S9-00">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;::S9&lt;42, T*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6157,7 +6157,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-06-S5-07-S6-S7-0a-f7"><a href="#S0-06-S5-07-S6-S7-0a-f7">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;::f7</a></h2>
+<h2 id="S0-06-S5-07-S6-S7-0a-f7">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;::f7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6173,7 +6173,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-06-S5-07-S6-f6"><a href="#S0-06-S5-07-S6-f6">S0&lt;39&gt;::S5&lt;40&gt;::S6::f6</a></h2>
+<h2 id="S0-06-S5-07-S6-f6">S0&lt;39&gt;::S5&lt;40&gt;::S6::f6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6189,7 +6189,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-06-S5-07-f5"><a href="#S0-06-S5-07-f5">S0&lt;39&gt;::S5&lt;40&gt;::f5</a></h2>
+<h2 id="S0-06-S5-07-f5">S0&lt;39&gt;::S5&lt;40&gt;::f5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6205,7 +6205,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-06-f0"><a href="#S0-06-f0">S0&lt;39&gt;::f0</a></h2>
+<h2 id="S0-06-f0">S0&lt;39&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6221,7 +6221,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0a1"><a href="#S0-0a1">S0&lt;4&gt;</a></h2>
+<h2 id="S0-0a1">S0&lt;4&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6266,7 +6266,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0a1-S1"><a href="#S0-0a1-S1">S0&lt;4&gt;::S1</a></h2>
+<h2 id="S0-0a1-S1">S0&lt;4&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6310,7 +6310,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0a1-S1-S2-00"><a href="#S0-0a1-S1-S2-00">S0&lt;4&gt;::S1::S2</a></h2>
+<h2 id="S0-0a1-S1-S2-00">S0&lt;4&gt;::S1::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6330,7 +6330,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0a1-S1-S2-0f"><a href="#S0-0a1-S1-S2-0f">S0&lt;4&gt;::S1::S2&lt;5&gt;</a></h2>
+<h2 id="S0-0a1-S1-S2-0f">S0&lt;4&gt;::S1::S2&lt;5&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6363,7 +6363,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0a1-S1-f1"><a href="#S0-0a1-S1-f1">S0&lt;4&gt;::S1::f1</a></h2>
+<h2 id="S0-0a1-S1-f1">S0&lt;4&gt;::S1::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6379,7 +6379,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0a1-S5"><a href="#S0-0a1-S5">S0&lt;4&gt;::S5</a></h2>
+<h2 id="S0-0a1-S5">S0&lt;4&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6399,7 +6399,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0a1-f0"><a href="#S0-0a1-f0">S0&lt;4&gt;::f0</a></h2>
+<h2 id="S0-0a1-f0">S0&lt;4&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6415,7 +6415,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0ba"><a href="#S0-0ba">S0&lt;43&gt;</a></h2>
+<h2 id="S0-0ba">S0&lt;43&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6461,7 +6461,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0ba-S1"><a href="#S0-0ba-S1">S0&lt;43&gt;::S1</a></h2>
+<h2 id="S0-0ba-S1">S0&lt;43&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6478,7 +6478,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0ba-S5-0f"><a href="#S0-0ba-S5-0f">S0&lt;43&gt;::S5</a></h2>
+<h2 id="S0-0ba-S5-0f">S0&lt;43&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6498,7 +6498,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0ba-S5-08"><a href="#S0-0ba-S5-08">S0&lt;43&gt;::S5&lt;44&gt;</a></h2>
+<h2 id="S0-0ba-S5-08">S0&lt;43&gt;::S5&lt;44&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6542,7 +6542,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0ba-S5-08-S6"><a href="#S0-0ba-S5-08-S6">S0&lt;43&gt;::S5&lt;44&gt;::S6</a></h2>
+<h2 id="S0-0ba-S5-08-S6">S0&lt;43&gt;::S5&lt;44&gt;::S6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6586,7 +6586,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0ba-S5-08-S6-S7-04"><a href="#S0-0ba-S5-08-S6-S7-04">S0&lt;43&gt;::S5&lt;44&gt;::S6::S7</a></h2>
+<h2 id="S0-0ba-S5-08-S6-S7-04">S0&lt;43&gt;::S5&lt;44&gt;::S6::S7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6606,7 +6606,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0ba-S5-08-S6-S7-02"><a href="#S0-0ba-S5-08-S6-S7-02">S0&lt;43&gt;::S5&lt;44&gt;::S6::S7&lt;45&gt;</a></h2>
+<h2 id="S0-0ba-S5-08-S6-S7-02">S0&lt;43&gt;::S5&lt;44&gt;::S6::S7&lt;45&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6652,7 +6652,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0ba-S5-08-S6-S7-02-S8"><a href="#S0-0ba-S5-08-S6-S7-02-S8">S0&lt;43&gt;::S5&lt;44&gt;::S6::S7&lt;45&gt;::S8</a></h2>
+<h2 id="S0-0ba-S5-08-S6-S7-02-S8">S0&lt;43&gt;::S5&lt;44&gt;::S6::S7&lt;45&gt;::S8</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6669,7 +6669,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0ba-S5-08-S6-S7-02-S9-0b"><a href="#S0-0ba-S5-08-S6-S7-02-S9-0b">S0&lt;43&gt;::S5&lt;44&gt;::S6::S7&lt;45&gt;::S9</a></h2>
+<h2 id="S0-0ba-S5-08-S6-S7-02-S9-0b">S0&lt;43&gt;::S5&lt;44&gt;::S6::S7&lt;45&gt;::S9</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6689,7 +6689,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0ba-S5-08-S6-S7-02-S9-0f"><a href="#S0-0ba-S5-08-S6-S7-02-S9-0f">S0&lt;43&gt;::S5&lt;44&gt;::S6::S7&lt;45&gt;::S9&lt;46&gt;</a></h2>
+<h2 id="S0-0ba-S5-08-S6-S7-02-S9-0f">S0&lt;43&gt;::S5&lt;44&gt;::S6::S7&lt;45&gt;::S9&lt;46&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6722,7 +6722,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0ba-S5-08-S6-S7-02-f7"><a href="#S0-0ba-S5-08-S6-S7-02-f7">S0&lt;43&gt;::S5&lt;44&gt;::S6::S7&lt;45&gt;::f7</a></h2>
+<h2 id="S0-0ba-S5-08-S6-S7-02-f7">S0&lt;43&gt;::S5&lt;44&gt;::S6::S7&lt;45&gt;::f7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6738,7 +6738,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0ba-S5-08-S6-f6"><a href="#S0-0ba-S5-08-S6-f6">S0&lt;43&gt;::S5&lt;44&gt;::S6::f6</a></h2>
+<h2 id="S0-0ba-S5-08-S6-f6">S0&lt;43&gt;::S5&lt;44&gt;::S6::f6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6754,7 +6754,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0ba-S5-08-f5"><a href="#S0-0ba-S5-08-f5">S0&lt;43&gt;::S5&lt;44&gt;::f5</a></h2>
+<h2 id="S0-0ba-S5-08-f5">S0&lt;43&gt;::S5&lt;44&gt;::f5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6770,7 +6770,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0ba-f0"><a href="#S0-0ba-f0">S0&lt;43&gt;::f0</a></h2>
+<h2 id="S0-0ba-f0">S0&lt;43&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6786,7 +6786,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-07e"><a href="#S0-07e">S0&lt;6&gt;</a></h2>
+<h2 id="S0-07e">S0&lt;6&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6831,7 +6831,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-07e-S1"><a href="#S0-07e-S1">S0&lt;6&gt;::S1</a></h2>
+<h2 id="S0-07e-S1">S0&lt;6&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6876,7 +6876,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-07e-S1-S2-04"><a href="#S0-07e-S1-S2-04">S0&lt;6&gt;::S1::S2</a></h2>
+<h2 id="S0-07e-S1-S2-04">S0&lt;6&gt;::S1::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6911,7 +6911,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-07e-S1-S2-07"><a href="#S0-07e-S1-S2-07">S0&lt;6&gt;::S1::S2&lt;7, int*&gt;</a></h2>
+<h2 id="S0-07e-S1-S2-07">S0&lt;6&gt;::S1::S2&lt;7, int*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6944,7 +6944,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-07e-S1-S2-06"><a href="#S0-07e-S1-S2-06">S0&lt;6&gt;::S1::S2&lt;7, T*&gt;</a></h2>
+<h2 id="S0-07e-S1-S2-06">S0&lt;6&gt;::S1::S2&lt;7, T*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6962,7 +6962,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-07e-S1-f1"><a href="#S0-07e-S1-f1">S0&lt;6&gt;::S1::f1</a></h2>
+<h2 id="S0-07e-S1-f1">S0&lt;6&gt;::S1::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6978,7 +6978,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-07e-S5"><a href="#S0-07e-S5">S0&lt;6&gt;::S5</a></h2>
+<h2 id="S0-07e-S5">S0&lt;6&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -6998,7 +6998,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-07e-f0"><a href="#S0-07e-f0">S0&lt;6&gt;::f0</a></h2>
+<h2 id="S0-07e-f0">S0&lt;6&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7014,7 +7014,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0a3"><a href="#S0-0a3">S0&lt;8&gt;</a></h2>
+<h2 id="S0-0a3">S0&lt;8&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7059,7 +7059,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0a3-S1"><a href="#S0-0a3-S1">S0&lt;8&gt;::S1</a></h2>
+<h2 id="S0-0a3-S1">S0&lt;8&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7103,7 +7103,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0a3-S1-S2-0b"><a href="#S0-0a3-S1-S2-0b">S0&lt;8&gt;::S1::S2</a></h2>
+<h2 id="S0-0a3-S1-S2-0b">S0&lt;8&gt;::S1::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7123,7 +7123,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0a3-S1-S2-0c"><a href="#S0-0a3-S1-S2-0c">S0&lt;8&gt;::S1::S2&lt;9&gt;</a></h2>
+<h2 id="S0-0a3-S1-S2-0c">S0&lt;8&gt;::S1::S2&lt;9&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7168,7 +7168,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0a3-S1-S2-0c-S3"><a href="#S0-0a3-S1-S2-0c-S3">S0&lt;8&gt;::S1::S2&lt;9&gt;::S3</a></h2>
+<h2 id="S0-0a3-S1-S2-0c-S3">S0&lt;8&gt;::S1::S2&lt;9&gt;::S3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7200,7 +7200,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0a3-S1-S2-0c-S4"><a href="#S0-0a3-S1-S2-0c-S4">S0&lt;8&gt;::S1::S2&lt;9&gt;::S4</a></h2>
+<h2 id="S0-0a3-S1-S2-0c-S4">S0&lt;8&gt;::S1::S2&lt;9&gt;::S4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7220,7 +7220,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0a3-S1-S2-0c-f2"><a href="#S0-0a3-S1-S2-0c-f2">S0&lt;8&gt;::S1::S2&lt;9&gt;::f2</a></h2>
+<h2 id="S0-0a3-S1-S2-0c-f2">S0&lt;8&gt;::S1::S2&lt;9&gt;::f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7236,7 +7236,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0a3-S1-f1"><a href="#S0-0a3-S1-f1">S0&lt;8&gt;::S1::f1</a></h2>
+<h2 id="S0-0a3-S1-f1">S0&lt;8&gt;::S1::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7252,7 +7252,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0a3-S5"><a href="#S0-0a3-S5">S0&lt;8&gt;::S5</a></h2>
+<h2 id="S0-0a3-S5">S0&lt;8&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7272,7 +7272,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0a3-f0"><a href="#S0-0a3-f0">S0&lt;8&gt;::f0</a></h2>
+<h2 id="S0-0a3-f0">S0&lt;8&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7288,7 +7288,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-020a"><a href="#S0-020a">S0&lt;1, int*&gt;</a></h2>
+<h2 id="S0-020a">S0&lt;1, int*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7321,7 +7321,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-05a"><a href="#S0-05a">S0&lt;10, bool&gt;</a></h2>
+<h2 id="S0-05a">S0&lt;10, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7366,7 +7366,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-05a-S1"><a href="#S0-05a-S1">S0&lt;10, bool&gt;::S1</a></h2>
+<h2 id="S0-05a-S1">S0&lt;10, bool&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7410,7 +7410,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-05a-S1-S2-07"><a href="#S0-05a-S1-S2-07">S0&lt;10, bool&gt;::S1::S2</a></h2>
+<h2 id="S0-05a-S1-S2-07">S0&lt;10, bool&gt;::S1::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7430,7 +7430,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-05a-S1-S2-0b"><a href="#S0-05a-S1-S2-0b">S0&lt;10, bool&gt;::S1::S2&lt;11, bool&gt;</a></h2>
+<h2 id="S0-05a-S1-S2-0b">S0&lt;10, bool&gt;::S1::S2&lt;11, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7475,7 +7475,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-05a-S1-S2-0b-S3"><a href="#S0-05a-S1-S2-0b-S3">S0&lt;10, bool&gt;::S1::S2&lt;11, bool&gt;::S3</a></h2>
+<h2 id="S0-05a-S1-S2-0b-S3">S0&lt;10, bool&gt;::S1::S2&lt;11, bool&gt;::S3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7492,7 +7492,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-05a-S1-S2-0b-S4"><a href="#S0-05a-S1-S2-0b-S4">S0&lt;10, bool&gt;::S1::S2&lt;11, bool&gt;::S4</a></h2>
+<h2 id="S0-05a-S1-S2-0b-S4">S0&lt;10, bool&gt;::S1::S2&lt;11, bool&gt;::S4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7527,7 +7527,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-05a-S1-S2-0b-f2"><a href="#S0-05a-S1-S2-0b-f2">S0&lt;10, bool&gt;::S1::S2&lt;11, bool&gt;::f2</a></h2>
+<h2 id="S0-05a-S1-S2-0b-f2">S0&lt;10, bool&gt;::S1::S2&lt;11, bool&gt;::f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7543,7 +7543,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-05a-S1-f1"><a href="#S0-05a-S1-f1">S0&lt;10, bool&gt;::S1::f1</a></h2>
+<h2 id="S0-05a-S1-f1">S0&lt;10, bool&gt;::S1::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7559,7 +7559,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-05a-S5"><a href="#S0-05a-S5">S0&lt;10, bool&gt;::S5</a></h2>
+<h2 id="S0-05a-S5">S0&lt;10, bool&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7579,7 +7579,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-05a-f0"><a href="#S0-05a-f0">S0&lt;10, bool&gt;::f0</a></h2>
+<h2 id="S0-05a-f0">S0&lt;10, bool&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7595,7 +7595,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0cd"><a href="#S0-0cd">S0&lt;12, bool&gt;</a></h2>
+<h2 id="S0-0cd">S0&lt;12, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7640,7 +7640,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0cd-S1"><a href="#S0-0cd-S1">S0&lt;12, bool&gt;::S1</a></h2>
+<h2 id="S0-0cd-S1">S0&lt;12, bool&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7684,7 +7684,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0cd-S1-S2-0e"><a href="#S0-0cd-S1-S2-0e">S0&lt;12, bool&gt;::S1::S2</a></h2>
+<h2 id="S0-0cd-S1-S2-0e">S0&lt;12, bool&gt;::S1::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7704,7 +7704,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0cd-S1-S2-05"><a href="#S0-0cd-S1-S2-05">S0&lt;12, bool&gt;::S1::S2&lt;13, bool&gt;</a></h2>
+<h2 id="S0-0cd-S1-S2-05">S0&lt;12, bool&gt;::S1::S2&lt;13, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7749,7 +7749,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0cd-S1-S2-05-S3"><a href="#S0-0cd-S1-S2-05-S3">S0&lt;12, bool&gt;::S1::S2&lt;13, bool&gt;::S3</a></h2>
+<h2 id="S0-0cd-S1-S2-05-S3">S0&lt;12, bool&gt;::S1::S2&lt;13, bool&gt;::S3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7766,7 +7766,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0cd-S1-S2-05-S4"><a href="#S0-0cd-S1-S2-05-S4">S0&lt;12, bool&gt;::S1::S2&lt;13, bool&gt;::S4</a></h2>
+<h2 id="S0-0cd-S1-S2-05-S4">S0&lt;12, bool&gt;::S1::S2&lt;13, bool&gt;::S4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7801,7 +7801,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0cd-S1-S2-05-f2"><a href="#S0-0cd-S1-S2-05-f2">S0&lt;12, bool&gt;::S1::S2&lt;13, bool&gt;::f2</a></h2>
+<h2 id="S0-0cd-S1-S2-05-f2">S0&lt;12, bool&gt;::S1::S2&lt;13, bool&gt;::f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7817,7 +7817,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0cd-S1-f1"><a href="#S0-0cd-S1-f1">S0&lt;12, bool&gt;::S1::f1</a></h2>
+<h2 id="S0-0cd-S1-f1">S0&lt;12, bool&gt;::S1::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7833,7 +7833,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0cd-S5"><a href="#S0-0cd-S5">S0&lt;12, bool&gt;::S5</a></h2>
+<h2 id="S0-0cd-S5">S0&lt;12, bool&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7853,7 +7853,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0cd-f0"><a href="#S0-0cd-f0">S0&lt;12, bool&gt;::f0</a></h2>
+<h2 id="S0-0cd-f0">S0&lt;12, bool&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7869,7 +7869,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-000"><a href="#S0-000">S0&lt;15, bool&gt;</a></h2>
+<h2 id="S0-000">S0&lt;15, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7914,7 +7914,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-000-S1"><a href="#S0-000-S1">S0&lt;15, bool&gt;::S1</a></h2>
+<h2 id="S0-000-S1">S0&lt;15, bool&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7958,7 +7958,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-000-S1-S2-08"><a href="#S0-000-S1-S2-08">S0&lt;15, bool&gt;::S1::S2</a></h2>
+<h2 id="S0-000-S1-S2-08">S0&lt;15, bool&gt;::S1::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -7978,7 +7978,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-000-S1-S2-03"><a href="#S0-000-S1-S2-03">S0&lt;15, bool&gt;::S1::S2&lt;16, bool&gt;</a></h2>
+<h2 id="S0-000-S1-S2-03">S0&lt;15, bool&gt;::S1::S2&lt;16, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8023,7 +8023,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-000-S1-S2-03-S3"><a href="#S0-000-S1-S2-03-S3">S0&lt;15, bool&gt;::S1::S2&lt;16, bool&gt;::S3</a></h2>
+<h2 id="S0-000-S1-S2-03-S3">S0&lt;15, bool&gt;::S1::S2&lt;16, bool&gt;::S3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8040,7 +8040,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-000-S1-S2-03-S4"><a href="#S0-000-S1-S2-03-S4">S0&lt;15, bool&gt;::S1::S2&lt;16, bool&gt;::S4</a></h2>
+<h2 id="S0-000-S1-S2-03-S4">S0&lt;15, bool&gt;::S1::S2&lt;16, bool&gt;::S4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8075,7 +8075,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-000-S1-S2-03-f2"><a href="#S0-000-S1-S2-03-f2">S0&lt;15, bool&gt;::S1::S2&lt;16, bool&gt;::f2</a></h2>
+<h2 id="S0-000-S1-S2-03-f2">S0&lt;15, bool&gt;::S1::S2&lt;16, bool&gt;::f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8091,7 +8091,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-000-S1-f1"><a href="#S0-000-S1-f1">S0&lt;15, bool&gt;::S1::f1</a></h2>
+<h2 id="S0-000-S1-f1">S0&lt;15, bool&gt;::S1::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8107,7 +8107,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-000-S5"><a href="#S0-000-S5">S0&lt;15, bool&gt;::S5</a></h2>
+<h2 id="S0-000-S5">S0&lt;15, bool&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8127,7 +8127,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-000-f0"><a href="#S0-000-f0">S0&lt;15, bool&gt;::f0</a></h2>
+<h2 id="S0-000-f0">S0&lt;15, bool&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8143,7 +8143,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-051"><a href="#S0-051">S0&lt;18, bool&gt;</a></h2>
+<h2 id="S0-051">S0&lt;18, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8188,7 +8188,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-051-S1"><a href="#S0-051-S1">S0&lt;18, bool&gt;::S1</a></h2>
+<h2 id="S0-051-S1">S0&lt;18, bool&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8205,7 +8205,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-051-S5"><a href="#S0-051-S5">S0&lt;18, bool&gt;::S5</a></h2>
+<h2 id="S0-051-S5">S0&lt;18, bool&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8240,7 +8240,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-051-f0"><a href="#S0-051-f0">S0&lt;18, bool&gt;::f0</a></h2>
+<h2 id="S0-051-f0">S0&lt;18, bool&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8256,7 +8256,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-002"><a href="#S0-002">S0&lt;19, bool&gt;</a></h2>
+<h2 id="S0-002">S0&lt;19, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8301,7 +8301,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-002-S1"><a href="#S0-002-S1">S0&lt;19, bool&gt;::S1</a></h2>
+<h2 id="S0-002-S1">S0&lt;19, bool&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8318,7 +8318,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-002-S5"><a href="#S0-002-S5">S0&lt;19, bool&gt;::S5</a></h2>
+<h2 id="S0-002-S5">S0&lt;19, bool&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8353,7 +8353,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-002-f0"><a href="#S0-002-f0">S0&lt;19, bool&gt;::f0</a></h2>
+<h2 id="S0-002-f0">S0&lt;19, bool&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8369,7 +8369,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-03c"><a href="#S0-03c">S0&lt;2, bool&gt;</a></h2>
+<h2 id="S0-03c">S0&lt;2, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8414,7 +8414,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-03c-S1"><a href="#S0-03c-S1">S0&lt;2, bool&gt;::S1</a></h2>
+<h2 id="S0-03c-S1">S0&lt;2, bool&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8472,7 +8472,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-03c-S1-S2"><a href="#S0-03c-S1-S2">S0&lt;2, bool&gt;::S1::S2</a></h2>
+<h2 id="S0-03c-S1-S2">S0&lt;2, bool&gt;::S1::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8492,7 +8492,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-03c-S1-f1"><a href="#S0-03c-S1-f1">S0&lt;2, bool&gt;::S1::f1</a></h2>
+<h2 id="S0-03c-S1-f1">S0&lt;2, bool&gt;::S1::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8508,7 +8508,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-03c-S5"><a href="#S0-03c-S5">S0&lt;2, bool&gt;::S5</a></h2>
+<h2 id="S0-03c-S5">S0&lt;2, bool&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8528,7 +8528,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-03c-f0"><a href="#S0-03c-f0">S0&lt;2, bool&gt;::f0</a></h2>
+<h2 id="S0-03c-f0">S0&lt;2, bool&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8544,7 +8544,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-003"><a href="#S0-003">S0&lt;21, bool&gt;</a></h2>
+<h2 id="S0-003">S0&lt;21, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8589,7 +8589,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-003-S1"><a href="#S0-003-S1">S0&lt;21, bool&gt;::S1</a></h2>
+<h2 id="S0-003-S1">S0&lt;21, bool&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8606,7 +8606,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-003-S5"><a href="#S0-003-S5">S0&lt;21, bool&gt;::S5</a></h2>
+<h2 id="S0-003-S5">S0&lt;21, bool&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8641,7 +8641,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-003-f0"><a href="#S0-003-f0">S0&lt;21, bool&gt;::f0</a></h2>
+<h2 id="S0-003-f0">S0&lt;21, bool&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8657,7 +8657,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0c7"><a href="#S0-0c7">S0&lt;23, bool&gt;</a></h2>
+<h2 id="S0-0c7">S0&lt;23, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8703,7 +8703,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0c7-S1"><a href="#S0-0c7-S1">S0&lt;23, bool&gt;::S1</a></h2>
+<h2 id="S0-0c7-S1">S0&lt;23, bool&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8720,7 +8720,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0c7-S5-03"><a href="#S0-0c7-S5-03">S0&lt;23, bool&gt;::S5</a></h2>
+<h2 id="S0-0c7-S5-03">S0&lt;23, bool&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8740,7 +8740,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0c7-S5-0f"><a href="#S0-0c7-S5-0f">S0&lt;23, bool&gt;::S5&lt;24, bool&gt;</a></h2>
+<h2 id="S0-0c7-S5-0f">S0&lt;23, bool&gt;::S5&lt;24, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8784,7 +8784,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0c7-S5-0f-S6"><a href="#S0-0c7-S5-0f-S6">S0&lt;23, bool&gt;::S5&lt;24, bool&gt;::S6</a></h2>
+<h2 id="S0-0c7-S5-0f-S6">S0&lt;23, bool&gt;::S5&lt;24, bool&gt;::S6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8842,7 +8842,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0c7-S5-0f-S6-S7"><a href="#S0-0c7-S5-0f-S6-S7">S0&lt;23, bool&gt;::S5&lt;24, bool&gt;::S6::S7</a></h2>
+<h2 id="S0-0c7-S5-0f-S6-S7">S0&lt;23, bool&gt;::S5&lt;24, bool&gt;::S6::S7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8862,7 +8862,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0c7-S5-0f-S6-f6"><a href="#S0-0c7-S5-0f-S6-f6">S0&lt;23, bool&gt;::S5&lt;24, bool&gt;::S6::f6</a></h2>
+<h2 id="S0-0c7-S5-0f-S6-f6">S0&lt;23, bool&gt;::S5&lt;24, bool&gt;::S6::f6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8878,7 +8878,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0c7-S5-0f-f5"><a href="#S0-0c7-S5-0f-f5">S0&lt;23, bool&gt;::S5&lt;24, bool&gt;::f5</a></h2>
+<h2 id="S0-0c7-S5-0f-f5">S0&lt;23, bool&gt;::S5&lt;24, bool&gt;::f5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8894,7 +8894,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0c7-f0"><a href="#S0-0c7-f0">S0&lt;23, bool&gt;::f0</a></h2>
+<h2 id="S0-0c7-f0">S0&lt;23, bool&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8910,7 +8910,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0529f"><a href="#S0-0529f">S0&lt;25, bool&gt;</a></h2>
+<h2 id="S0-0529f">S0&lt;25, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8956,7 +8956,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0529f-S1"><a href="#S0-0529f-S1">S0&lt;25, bool&gt;::S1</a></h2>
+<h2 id="S0-0529f-S1">S0&lt;25, bool&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8973,7 +8973,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0529f-S5-051"><a href="#S0-0529f-S5-051">S0&lt;25, bool&gt;::S5</a></h2>
+<h2 id="S0-0529f-S5-051">S0&lt;25, bool&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -8993,7 +8993,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0529f-S5-05c"><a href="#S0-0529f-S5-05c">S0&lt;25, bool&gt;::S5&lt;26, bool&gt;</a></h2>
+<h2 id="S0-0529f-S5-05c">S0&lt;25, bool&gt;::S5&lt;26, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9037,7 +9037,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0529f-S5-05c-S6"><a href="#S0-0529f-S5-05c-S6">S0&lt;25, bool&gt;::S5&lt;26, bool&gt;::S6</a></h2>
+<h2 id="S0-0529f-S5-05c-S6">S0&lt;25, bool&gt;::S5&lt;26, bool&gt;::S6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9080,7 +9080,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0529f-S5-05c-S6-S7"><a href="#S0-0529f-S5-05c-S6-S7">S0&lt;25, bool&gt;::S5&lt;26, bool&gt;::S6::S7</a></h2>
+<h2 id="S0-0529f-S5-05c-S6-S7">S0&lt;25, bool&gt;::S5&lt;26, bool&gt;::S6::S7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9115,7 +9115,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0529f-S5-05c-S6-f6"><a href="#S0-0529f-S5-05c-S6-f6">S0&lt;25, bool&gt;::S5&lt;26, bool&gt;::S6::f6</a></h2>
+<h2 id="S0-0529f-S5-05c-S6-f6">S0&lt;25, bool&gt;::S5&lt;26, bool&gt;::S6::f6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9131,7 +9131,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0529f-S5-05c-f5"><a href="#S0-0529f-S5-05c-f5">S0&lt;25, bool&gt;::S5&lt;26, bool&gt;::f5</a></h2>
+<h2 id="S0-0529f-S5-05c-f5">S0&lt;25, bool&gt;::S5&lt;26, bool&gt;::f5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9147,7 +9147,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0529f-f0"><a href="#S0-0529f-f0">S0&lt;25, bool&gt;::f0</a></h2>
+<h2 id="S0-0529f-f0">S0&lt;25, bool&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9163,7 +9163,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-007"><a href="#S0-007">S0&lt;27, bool&gt;</a></h2>
+<h2 id="S0-007">S0&lt;27, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9209,7 +9209,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-007-S1"><a href="#S0-007-S1">S0&lt;27, bool&gt;::S1</a></h2>
+<h2 id="S0-007-S1">S0&lt;27, bool&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9226,7 +9226,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-007-S5-0f"><a href="#S0-007-S5-0f">S0&lt;27, bool&gt;::S5</a></h2>
+<h2 id="S0-007-S5-0f">S0&lt;27, bool&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9246,7 +9246,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-007-S5-0d"><a href="#S0-007-S5-0d">S0&lt;27, bool&gt;::S5&lt;28, bool&gt;</a></h2>
+<h2 id="S0-007-S5-0d">S0&lt;27, bool&gt;::S5&lt;28, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9290,7 +9290,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-007-S5-0d-S6"><a href="#S0-007-S5-0d-S6">S0&lt;27, bool&gt;::S5&lt;28, bool&gt;::S6</a></h2>
+<h2 id="S0-007-S5-0d-S6">S0&lt;27, bool&gt;::S5&lt;28, bool&gt;::S6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9333,7 +9333,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-007-S5-0d-S6-S7"><a href="#S0-007-S5-0d-S6-S7">S0&lt;27, bool&gt;::S5&lt;28, bool&gt;::S6::S7</a></h2>
+<h2 id="S0-007-S5-0d-S6-S7">S0&lt;27, bool&gt;::S5&lt;28, bool&gt;::S6::S7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9368,7 +9368,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-007-S5-0d-S6-f6"><a href="#S0-007-S5-0d-S6-f6">S0&lt;27, bool&gt;::S5&lt;28, bool&gt;::S6::f6</a></h2>
+<h2 id="S0-007-S5-0d-S6-f6">S0&lt;27, bool&gt;::S5&lt;28, bool&gt;::S6::f6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9384,7 +9384,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-007-S5-0d-f5"><a href="#S0-007-S5-0d-f5">S0&lt;27, bool&gt;::S5&lt;28, bool&gt;::f5</a></h2>
+<h2 id="S0-007-S5-0d-f5">S0&lt;27, bool&gt;::S5&lt;28, bool&gt;::f5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9400,7 +9400,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-007-f0"><a href="#S0-007-f0">S0&lt;27, bool&gt;::f0</a></h2>
+<h2 id="S0-007-f0">S0&lt;27, bool&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9416,7 +9416,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-092"><a href="#S0-092">S0&lt;3, bool&gt;</a></h2>
+<h2 id="S0-092">S0&lt;3, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9461,7 +9461,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-092-S1"><a href="#S0-092-S1">S0&lt;3, bool&gt;::S1</a></h2>
+<h2 id="S0-092-S1">S0&lt;3, bool&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9504,7 +9504,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-092-S1-S2"><a href="#S0-092-S1-S2">S0&lt;3, bool&gt;::S1::S2</a></h2>
+<h2 id="S0-092-S1-S2">S0&lt;3, bool&gt;::S1::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9539,7 +9539,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-092-S1-f1"><a href="#S0-092-S1-f1">S0&lt;3, bool&gt;::S1::f1</a></h2>
+<h2 id="S0-092-S1-f1">S0&lt;3, bool&gt;::S1::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9555,7 +9555,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-092-S5"><a href="#S0-092-S5">S0&lt;3, bool&gt;::S5</a></h2>
+<h2 id="S0-092-S5">S0&lt;3, bool&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9575,7 +9575,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-092-f0"><a href="#S0-092-f0">S0&lt;3, bool&gt;::f0</a></h2>
+<h2 id="S0-092-f0">S0&lt;3, bool&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9591,7 +9591,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-021"><a href="#S0-021">S0&lt;30, bool&gt;</a></h2>
+<h2 id="S0-021">S0&lt;30, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9637,7 +9637,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-021-S1"><a href="#S0-021-S1">S0&lt;30, bool&gt;::S1</a></h2>
+<h2 id="S0-021-S1">S0&lt;30, bool&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9654,7 +9654,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-021-S5-06"><a href="#S0-021-S5-06">S0&lt;30, bool&gt;::S5</a></h2>
+<h2 id="S0-021-S5-06">S0&lt;30, bool&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9674,7 +9674,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-021-S5-0b"><a href="#S0-021-S5-0b">S0&lt;30, bool&gt;::S5&lt;31, bool&gt;</a></h2>
+<h2 id="S0-021-S5-0b">S0&lt;30, bool&gt;::S5&lt;31, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9718,7 +9718,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-021-S5-0b-S6"><a href="#S0-021-S5-0b-S6">S0&lt;30, bool&gt;::S5&lt;31, bool&gt;::S6</a></h2>
+<h2 id="S0-021-S5-0b-S6">S0&lt;30, bool&gt;::S5&lt;31, bool&gt;::S6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9761,7 +9761,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-021-S5-0b-S6-S7"><a href="#S0-021-S5-0b-S6-S7">S0&lt;30, bool&gt;::S5&lt;31, bool&gt;::S6::S7</a></h2>
+<h2 id="S0-021-S5-0b-S6-S7">S0&lt;30, bool&gt;::S5&lt;31, bool&gt;::S6::S7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9796,7 +9796,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-021-S5-0b-S6-f6"><a href="#S0-021-S5-0b-S6-f6">S0&lt;30, bool&gt;::S5&lt;31, bool&gt;::S6::f6</a></h2>
+<h2 id="S0-021-S5-0b-S6-f6">S0&lt;30, bool&gt;::S5&lt;31, bool&gt;::S6::f6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9812,7 +9812,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-021-S5-0b-f5"><a href="#S0-021-S5-0b-f5">S0&lt;30, bool&gt;::S5&lt;31, bool&gt;::f5</a></h2>
+<h2 id="S0-021-S5-0b-f5">S0&lt;30, bool&gt;::S5&lt;31, bool&gt;::f5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9828,7 +9828,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-021-f0"><a href="#S0-021-f0">S0&lt;30, bool&gt;::f0</a></h2>
+<h2 id="S0-021-f0">S0&lt;30, bool&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9844,7 +9844,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0318"><a href="#S0-0318">S0&lt;33, bool&gt;</a></h2>
+<h2 id="S0-0318">S0&lt;33, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9890,7 +9890,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0318-S1"><a href="#S0-0318-S1">S0&lt;33, bool&gt;::S1</a></h2>
+<h2 id="S0-0318-S1">S0&lt;33, bool&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9907,7 +9907,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0318-S5-0f"><a href="#S0-0318-S5-0f">S0&lt;33, bool&gt;::S5</a></h2>
+<h2 id="S0-0318-S5-0f">S0&lt;33, bool&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9927,7 +9927,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0318-S5-0b"><a href="#S0-0318-S5-0b">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;</a></h2>
+<h2 id="S0-0318-S5-0b">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -9971,7 +9971,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0318-S5-0b-S6"><a href="#S0-0318-S5-0b-S6">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6</a></h2>
+<h2 id="S0-0318-S5-0b-S6">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10015,7 +10015,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0318-S5-0b-S6-S7-04"><a href="#S0-0318-S5-0b-S6-S7-04">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6::S7</a></h2>
+<h2 id="S0-0318-S5-0b-S6-S7-04">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6::S7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10035,7 +10035,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0318-S5-0b-S6-S7-05"><a href="#S0-0318-S5-0b-S6-S7-05">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6::S7&lt;35, bool&gt;</a></h2>
+<h2 id="S0-0318-S5-0b-S6-S7-05">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6::S7&lt;35, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10080,7 +10080,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0318-S5-0b-S6-S7-05-S8"><a href="#S0-0318-S5-0b-S6-S7-05-S8">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6::S7&lt;35, bool&gt;::S8</a></h2>
+<h2 id="S0-0318-S5-0b-S6-S7-05-S8">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6::S7&lt;35, bool&gt;::S8</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10125,7 +10125,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0318-S5-0b-S6-S7-05-S8-f8"><a href="#S0-0318-S5-0b-S6-S7-05-S8-f8">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6::S7&lt;35, bool&gt;::S8::f8</a></h2>
+<h2 id="S0-0318-S5-0b-S6-S7-05-S8-f8">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6::S7&lt;35, bool&gt;::S8::f8</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10141,7 +10141,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0318-S5-0b-S6-S7-05-S9"><a href="#S0-0318-S5-0b-S6-S7-05-S9">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6::S7&lt;35, bool&gt;::S9</a></h2>
+<h2 id="S0-0318-S5-0b-S6-S7-05-S9">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6::S7&lt;35, bool&gt;::S9</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10161,7 +10161,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0318-S5-0b-S6-S7-05-f7"><a href="#S0-0318-S5-0b-S6-S7-05-f7">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6::S7&lt;35, bool&gt;::f7</a></h2>
+<h2 id="S0-0318-S5-0b-S6-S7-05-f7">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6::S7&lt;35, bool&gt;::f7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10177,7 +10177,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0318-S5-0b-S6-f6"><a href="#S0-0318-S5-0b-S6-f6">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6::f6</a></h2>
+<h2 id="S0-0318-S5-0b-S6-f6">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6::f6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10193,7 +10193,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0318-S5-0b-f5"><a href="#S0-0318-S5-0b-f5">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::f5</a></h2>
+<h2 id="S0-0318-S5-0b-f5">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::f5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10209,7 +10209,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0318-f0"><a href="#S0-0318-f0">S0&lt;33, bool&gt;::f0</a></h2>
+<h2 id="S0-0318-f0">S0&lt;33, bool&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10225,7 +10225,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0d"><a href="#S0-0d">S0&lt;36, bool&gt;</a></h2>
+<h2 id="S0-0d">S0&lt;36, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10271,7 +10271,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0d-S1"><a href="#S0-0d-S1">S0&lt;36, bool&gt;::S1</a></h2>
+<h2 id="S0-0d-S1">S0&lt;36, bool&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10288,7 +10288,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0d-S5-09"><a href="#S0-0d-S5-09">S0&lt;36, bool&gt;::S5</a></h2>
+<h2 id="S0-0d-S5-09">S0&lt;36, bool&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10308,7 +10308,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0d-S5-0b"><a href="#S0-0d-S5-0b">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;</a></h2>
+<h2 id="S0-0d-S5-0b">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10352,7 +10352,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0d-S5-0b-S6"><a href="#S0-0d-S5-0b-S6">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::S6</a></h2>
+<h2 id="S0-0d-S5-0b-S6">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::S6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10396,7 +10396,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0d-S5-0b-S6-S7-08"><a href="#S0-0d-S5-0b-S6-S7-08">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::S6::S7</a></h2>
+<h2 id="S0-0d-S5-0b-S6-S7-08">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::S6::S7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10416,7 +10416,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0d-S5-0b-S6-S7-0d"><a href="#S0-0d-S5-0b-S6-S7-0d">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::S6::S7&lt;38, bool&gt;</a></h2>
+<h2 id="S0-0d-S5-0b-S6-S7-0d">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::S6::S7&lt;38, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10461,7 +10461,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0d-S5-0b-S6-S7-0d-S8"><a href="#S0-0d-S5-0b-S6-S7-0d-S8">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::S6::S7&lt;38, bool&gt;::S8</a></h2>
+<h2 id="S0-0d-S5-0b-S6-S7-0d-S8">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::S6::S7&lt;38, bool&gt;::S8</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10478,7 +10478,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0d-S5-0b-S6-S7-0d-S9"><a href="#S0-0d-S5-0b-S6-S7-0d-S9">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::S6::S7&lt;38, bool&gt;::S9</a></h2>
+<h2 id="S0-0d-S5-0b-S6-S7-0d-S9">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::S6::S7&lt;38, bool&gt;::S9</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10513,7 +10513,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0d-S5-0b-S6-S7-0d-f7"><a href="#S0-0d-S5-0b-S6-S7-0d-f7">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::S6::S7&lt;38, bool&gt;::f7</a></h2>
+<h2 id="S0-0d-S5-0b-S6-S7-0d-f7">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::S6::S7&lt;38, bool&gt;::f7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10529,7 +10529,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0d-S5-0b-S6-f6"><a href="#S0-0d-S5-0b-S6-f6">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::S6::f6</a></h2>
+<h2 id="S0-0d-S5-0b-S6-f6">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::S6::f6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10545,7 +10545,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0d-S5-0b-f5"><a href="#S0-0d-S5-0b-f5">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::f5</a></h2>
+<h2 id="S0-0d-S5-0b-f5">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::f5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10561,7 +10561,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0d-f0"><a href="#S0-0d-f0">S0&lt;36, bool&gt;::f0</a></h2>
+<h2 id="S0-0d-f0">S0&lt;36, bool&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10577,7 +10577,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0206"><a href="#S0-0206">S0&lt;39, bool&gt;</a></h2>
+<h2 id="S0-0206">S0&lt;39, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10623,7 +10623,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0206-S1"><a href="#S0-0206-S1">S0&lt;39, bool&gt;::S1</a></h2>
+<h2 id="S0-0206-S1">S0&lt;39, bool&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10640,7 +10640,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0206-S5-06"><a href="#S0-0206-S5-06">S0&lt;39, bool&gt;::S5</a></h2>
+<h2 id="S0-0206-S5-06">S0&lt;39, bool&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10660,7 +10660,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0206-S5-08"><a href="#S0-0206-S5-08">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;</a></h2>
+<h2 id="S0-0206-S5-08">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10704,7 +10704,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0206-S5-08-S6"><a href="#S0-0206-S5-08-S6">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::S6</a></h2>
+<h2 id="S0-0206-S5-08-S6">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::S6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10748,7 +10748,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0206-S5-08-S6-S7-06"><a href="#S0-0206-S5-08-S6-S7-06">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::S6::S7</a></h2>
+<h2 id="S0-0206-S5-08-S6-S7-06">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::S6::S7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10768,7 +10768,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0206-S5-08-S6-S7-01"><a href="#S0-0206-S5-08-S6-S7-01">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::S6::S7&lt;41, bool&gt;</a></h2>
+<h2 id="S0-0206-S5-08-S6-S7-01">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::S6::S7&lt;41, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10813,7 +10813,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0206-S5-08-S6-S7-01-S8"><a href="#S0-0206-S5-08-S6-S7-01-S8">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::S6::S7&lt;41, bool&gt;::S8</a></h2>
+<h2 id="S0-0206-S5-08-S6-S7-01-S8">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::S6::S7&lt;41, bool&gt;::S8</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10830,7 +10830,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0206-S5-08-S6-S7-01-S9"><a href="#S0-0206-S5-08-S6-S7-01-S9">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::S6::S7&lt;41, bool&gt;::S9</a></h2>
+<h2 id="S0-0206-S5-08-S6-S7-01-S9">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::S6::S7&lt;41, bool&gt;::S9</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10865,7 +10865,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0206-S5-08-S6-S7-01-f7"><a href="#S0-0206-S5-08-S6-S7-01-f7">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::S6::S7&lt;41, bool&gt;::f7</a></h2>
+<h2 id="S0-0206-S5-08-S6-S7-01-f7">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::S6::S7&lt;41, bool&gt;::f7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10881,7 +10881,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0206-S5-08-S6-f6"><a href="#S0-0206-S5-08-S6-f6">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::S6::f6</a></h2>
+<h2 id="S0-0206-S5-08-S6-f6">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::S6::f6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10897,7 +10897,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0206-S5-08-f5"><a href="#S0-0206-S5-08-f5">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::f5</a></h2>
+<h2 id="S0-0206-S5-08-f5">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::f5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10913,7 +10913,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0206-f0"><a href="#S0-0206-f0">S0&lt;39, bool&gt;::f0</a></h2>
+<h2 id="S0-0206-f0">S0&lt;39, bool&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10929,7 +10929,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0b6"><a href="#S0-0b6">S0&lt;4, bool&gt;</a></h2>
+<h2 id="S0-0b6">S0&lt;4, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -10974,7 +10974,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0b6-S1"><a href="#S0-0b6-S1">S0&lt;4, bool&gt;::S1</a></h2>
+<h2 id="S0-0b6-S1">S0&lt;4, bool&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11017,7 +11017,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0b6-S1-S2"><a href="#S0-0b6-S1-S2">S0&lt;4, bool&gt;::S1::S2</a></h2>
+<h2 id="S0-0b6-S1-S2">S0&lt;4, bool&gt;::S1::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11052,7 +11052,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0b6-S1-f1"><a href="#S0-0b6-S1-f1">S0&lt;4, bool&gt;::S1::f1</a></h2>
+<h2 id="S0-0b6-S1-f1">S0&lt;4, bool&gt;::S1::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11068,7 +11068,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0b6-S5"><a href="#S0-0b6-S5">S0&lt;4, bool&gt;::S5</a></h2>
+<h2 id="S0-0b6-S5">S0&lt;4, bool&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11088,7 +11088,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0b6-f0"><a href="#S0-0b6-f0">S0&lt;4, bool&gt;::f0</a></h2>
+<h2 id="S0-0b6-f0">S0&lt;4, bool&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11104,7 +11104,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-05291"><a href="#S0-05291">S0&lt;43, bool&gt;</a></h2>
+<h2 id="S0-05291">S0&lt;43, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11150,7 +11150,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-05291-S1"><a href="#S0-05291-S1">S0&lt;43, bool&gt;::S1</a></h2>
+<h2 id="S0-05291-S1">S0&lt;43, bool&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11167,7 +11167,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-05291-S5-02"><a href="#S0-05291-S5-02">S0&lt;43, bool&gt;::S5</a></h2>
+<h2 id="S0-05291-S5-02">S0&lt;43, bool&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11187,7 +11187,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-05291-S5-0e"><a href="#S0-05291-S5-0e">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;</a></h2>
+<h2 id="S0-05291-S5-0e">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11231,7 +11231,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-05291-S5-0e-S6"><a href="#S0-05291-S5-0e-S6">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::S6</a></h2>
+<h2 id="S0-05291-S5-0e-S6">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::S6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11275,7 +11275,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-05291-S5-0e-S6-S7-04"><a href="#S0-05291-S5-0e-S6-S7-04">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::S6::S7</a></h2>
+<h2 id="S0-05291-S5-0e-S6-S7-04">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::S6::S7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11295,7 +11295,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-05291-S5-0e-S6-S7-0f"><a href="#S0-05291-S5-0e-S6-S7-0f">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::S6::S7&lt;45, bool&gt;</a></h2>
+<h2 id="S0-05291-S5-0e-S6-S7-0f">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::S6::S7&lt;45, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11340,7 +11340,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-05291-S5-0e-S6-S7-0f-S8"><a href="#S0-05291-S5-0e-S6-S7-0f-S8">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::S6::S7&lt;45, bool&gt;::S8</a></h2>
+<h2 id="S0-05291-S5-0e-S6-S7-0f-S8">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::S6::S7&lt;45, bool&gt;::S8</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11357,7 +11357,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-05291-S5-0e-S6-S7-0f-S9"><a href="#S0-05291-S5-0e-S6-S7-0f-S9">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::S6::S7&lt;45, bool&gt;::S9</a></h2>
+<h2 id="S0-05291-S5-0e-S6-S7-0f-S9">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::S6::S7&lt;45, bool&gt;::S9</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11392,7 +11392,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-05291-S5-0e-S6-S7-0f-f7"><a href="#S0-05291-S5-0e-S6-S7-0f-f7">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::S6::S7&lt;45, bool&gt;::f7</a></h2>
+<h2 id="S0-05291-S5-0e-S6-S7-0f-f7">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::S6::S7&lt;45, bool&gt;::f7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11408,7 +11408,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-05291-S5-0e-S6-f6"><a href="#S0-05291-S5-0e-S6-f6">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::S6::f6</a></h2>
+<h2 id="S0-05291-S5-0e-S6-f6">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::S6::f6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11424,7 +11424,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-05291-S5-0e-f5"><a href="#S0-05291-S5-0e-f5">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::f5</a></h2>
+<h2 id="S0-05291-S5-0e-f5">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::f5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11440,7 +11440,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-05291-f0"><a href="#S0-05291-f0">S0&lt;43, bool&gt;::f0</a></h2>
+<h2 id="S0-05291-f0">S0&lt;43, bool&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11456,7 +11456,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-023"><a href="#S0-023">S0&lt;6, bool&gt;</a></h2>
+<h2 id="S0-023">S0&lt;6, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11501,7 +11501,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-023-S1"><a href="#S0-023-S1">S0&lt;6, bool&gt;::S1</a></h2>
+<h2 id="S0-023-S1">S0&lt;6, bool&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11544,7 +11544,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-023-S1-S2"><a href="#S0-023-S1-S2">S0&lt;6, bool&gt;::S1::S2</a></h2>
+<h2 id="S0-023-S1-S2">S0&lt;6, bool&gt;::S1::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11579,7 +11579,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-023-S1-f1"><a href="#S0-023-S1-f1">S0&lt;6, bool&gt;::S1::f1</a></h2>
+<h2 id="S0-023-S1-f1">S0&lt;6, bool&gt;::S1::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11595,7 +11595,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-023-S5"><a href="#S0-023-S5">S0&lt;6, bool&gt;::S5</a></h2>
+<h2 id="S0-023-S5">S0&lt;6, bool&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11615,7 +11615,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-023-f0"><a href="#S0-023-f0">S0&lt;6, bool&gt;::f0</a></h2>
+<h2 id="S0-023-f0">S0&lt;6, bool&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11631,7 +11631,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-04"><a href="#S0-04">S0&lt;8, bool&gt;</a></h2>
+<h2 id="S0-04">S0&lt;8, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11676,7 +11676,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-04-S1"><a href="#S0-04-S1">S0&lt;8, bool&gt;::S1</a></h2>
+<h2 id="S0-04-S1">S0&lt;8, bool&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11720,7 +11720,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-04-S1-S2-0e"><a href="#S0-04-S1-S2-0e">S0&lt;8, bool&gt;::S1::S2</a></h2>
+<h2 id="S0-04-S1-S2-0e">S0&lt;8, bool&gt;::S1::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11740,7 +11740,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-04-S1-S2-0a"><a href="#S0-04-S1-S2-0a">S0&lt;8, bool&gt;::S1::S2&lt;9, bool&gt;</a></h2>
+<h2 id="S0-04-S1-S2-0a">S0&lt;8, bool&gt;::S1::S2&lt;9, bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11785,7 +11785,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-04-S1-S2-0a-S3"><a href="#S0-04-S1-S2-0a-S3">S0&lt;8, bool&gt;::S1::S2&lt;9, bool&gt;::S3</a></h2>
+<h2 id="S0-04-S1-S2-0a-S3">S0&lt;8, bool&gt;::S1::S2&lt;9, bool&gt;::S3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11830,7 +11830,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-04-S1-S2-0a-S3-f3"><a href="#S0-04-S1-S2-0a-S3-f3">S0&lt;8, bool&gt;::S1::S2&lt;9, bool&gt;::S3::f3</a></h2>
+<h2 id="S0-04-S1-S2-0a-S3-f3">S0&lt;8, bool&gt;::S1::S2&lt;9, bool&gt;::S3::f3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11846,7 +11846,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-04-S1-S2-0a-S4"><a href="#S0-04-S1-S2-0a-S4">S0&lt;8, bool&gt;::S1::S2&lt;9, bool&gt;::S4</a></h2>
+<h2 id="S0-04-S1-S2-0a-S4">S0&lt;8, bool&gt;::S1::S2&lt;9, bool&gt;::S4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11866,7 +11866,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-04-S1-S2-0a-f2"><a href="#S0-04-S1-S2-0a-f2">S0&lt;8, bool&gt;::S1::S2&lt;9, bool&gt;::f2</a></h2>
+<h2 id="S0-04-S1-S2-0a-f2">S0&lt;8, bool&gt;::S1::S2&lt;9, bool&gt;::f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11882,7 +11882,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-04-S1-f1"><a href="#S0-04-S1-f1">S0&lt;8, bool&gt;::S1::f1</a></h2>
+<h2 id="S0-04-S1-f1">S0&lt;8, bool&gt;::S1::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11898,7 +11898,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-04-S5"><a href="#S0-04-S5">S0&lt;8, bool&gt;::S5</a></h2>
+<h2 id="S0-04-S5">S0&lt;8, bool&gt;::S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11918,7 +11918,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-04-f0"><a href="#S0-04-f0">S0&lt;8, bool&gt;::f0</a></h2>
+<h2 id="S0-04-f0">S0&lt;8, bool&gt;::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -11934,7 +11934,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-0c4"><a href="#S0-0c4">S0&lt;1, T*&gt;</a></h2>
+<h2 id="S0-0c4">S0&lt;1, T*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/record/class-template-specializations-2.html b/test-files/golden-tests/symbols/record/class-template-specializations-2.html
index c5bc175fd..c68232673 100644
--- a/test-files/golden-tests/symbols/record/class-template-specializations-2.html
+++ b/test-files/golden-tests/symbols/record/class-template-specializations-2.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -28,7 +28,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e"><a href="#A-0e">A</a></h2>
+<h2 id="A-0e">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -46,7 +46,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-06"><a href="#A-06">A&lt;double&gt;</a></h2>
+<h2 id="A-06">A&lt;double&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -79,7 +79,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-06-D-0b"><a href="#A-06-D-0b">A&lt;double&gt;::D</a></h2>
+<h2 id="A-06-D-0b">A&lt;double&gt;::D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -111,7 +111,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-06-D-0b-E-01"><a href="#A-06-D-0b-E-01">A&lt;double&gt;::D::E</a></h2>
+<h2 id="A-06-D-0b-E-01">A&lt;double&gt;::D::E</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -129,7 +129,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-06-D-0b-E-04"><a href="#A-06-D-0b-E-04">A&lt;double&gt;::D::E&lt;T*&gt;</a></h2>
+<h2 id="A-06-D-0b-E-04">A&lt;double&gt;::D::E&lt;T*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -160,7 +160,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-06-D-0b-E-04-F"><a href="#A-06-D-0b-E-04-F">A&lt;double&gt;::D::E&lt;T*&gt;::F</a></h2>
+<h2 id="A-06-D-0b-E-04-F">A&lt;double&gt;::D::E&lt;T*&gt;::F</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -177,7 +177,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-06-D-07"><a href="#A-06-D-07">A&lt;double&gt;::D&lt;short&gt;</a></h2>
+<h2 id="A-06-D-07">A&lt;double&gt;::D&lt;short&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -209,7 +209,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-06-D-07-E-07"><a href="#A-06-D-07-E-07">A&lt;double&gt;::D&lt;short&gt;::E</a></h2>
+<h2 id="A-06-D-07-E-07">A&lt;double&gt;::D&lt;short&gt;::E</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -227,7 +227,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-06-D-07-E-01"><a href="#A-06-D-07-E-01">A&lt;double&gt;::D&lt;short&gt;::E&lt;int*&gt;</a></h2>
+<h2 id="A-06-D-07-E-01">A&lt;double&gt;::D&lt;short&gt;::E&lt;int*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -258,7 +258,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-06-D-07-E-01-F"><a href="#A-06-D-07-E-01-F">A&lt;double&gt;::D&lt;short&gt;::E&lt;int*&gt;::F</a></h2>
+<h2 id="A-06-D-07-E-01-F">A&lt;double&gt;::D&lt;short&gt;::E&lt;int*&gt;::F</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -275,7 +275,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-06-D-04"><a href="#A-06-D-04">A&lt;double&gt;::D&lt;float&gt;</a></h2>
+<h2 id="A-06-D-04">A&lt;double&gt;::D&lt;float&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -307,7 +307,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-06-D-04-G-06"><a href="#A-06-D-04-G-06">A&lt;double&gt;::D&lt;float&gt;::G</a></h2>
+<h2 id="A-06-D-04-G-06">A&lt;double&gt;::D&lt;float&gt;::G</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -325,7 +325,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-06-D-04-G-0c"><a href="#A-06-D-04-G-0c">A&lt;double&gt;::D&lt;float&gt;::G&lt;T*&gt;</a></h2>
+<h2 id="A-06-D-04-G-0c">A&lt;double&gt;::D&lt;float&gt;::G&lt;T*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -343,7 +343,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-02"><a href="#A-02">A&lt;long*&gt;</a></h2>
+<h2 id="A-02">A&lt;long*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -376,7 +376,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-02-B-06"><a href="#A-02-B-06">A&lt;long*&gt;::B</a></h2>
+<h2 id="A-02-B-06">A&lt;long*&gt;::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -394,7 +394,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-02-B-0d"><a href="#A-02-B-0d">A&lt;long*&gt;::B&lt;int&gt;</a></h2>
+<h2 id="A-02-B-0d">A&lt;long*&gt;::B&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -412,7 +412,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-02-B-05"><a href="#A-02-B-05">A&lt;long*&gt;::B&lt;int*&gt;</a></h2>
+<h2 id="A-02-B-05">A&lt;long*&gt;::B&lt;int*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -443,7 +443,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-02-B-05-C"><a href="#A-02-B-05-C">A&lt;long*&gt;::B&lt;int*&gt;::C</a></h2>
+<h2 id="A-02-B-05-C">A&lt;long*&gt;::B&lt;int*&gt;::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -460,7 +460,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-03"><a href="#A-03">A&lt;T*&gt;</a></h2>
+<h2 id="A-03">A&lt;T*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -493,7 +493,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-03-B-05"><a href="#A-03-B-05">A&lt;T*&gt;::B</a></h2>
+<h2 id="A-03-B-05">A&lt;T*&gt;::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -511,7 +511,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-03-B-0b"><a href="#A-03-B-0b">A&lt;T*&gt;::B&lt;int&gt;</a></h2>
+<h2 id="A-03-B-0b">A&lt;T*&gt;::B&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -529,7 +529,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-03-B-01"><a href="#A-03-B-01">A&lt;T*&gt;::B&lt;U*&gt;</a></h2>
+<h2 id="A-03-B-01">A&lt;T*&gt;::B&lt;U*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -560,7 +560,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-03-B-01-C"><a href="#A-03-B-01-C">A&lt;T*&gt;::B&lt;U*&gt;::C</a></h2>
+<h2 id="A-03-B-01-C">A&lt;T*&gt;::B&lt;U*&gt;::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/record/class-template-specializations-3.html b/test-files/golden-tests/symbols/record/class-template-specializations-3.html
index 19476f69b..e16b4f462 100644
--- a/test-files/golden-tests/symbols/record/class-template-specializations-3.html
+++ b/test-files/golden-tests/symbols/record/class-template-specializations-3.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -30,7 +30,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e"><a href="#A-0e">A</a></h2>
+<h2 id="A-0e">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -62,7 +62,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e-B-07"><a href="#A-0e-B-07">A::B</a></h2>
+<h2 id="A-0e-B-07">A::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -95,7 +95,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e-B-07-C"><a href="#A-0e-B-07-C">A::B::C</a></h2>
+<h2 id="A-0e-B-07-C">A::B::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -112,7 +112,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0e-B-07-D-09"><a href="#A-0e-B-07-D-09">A::B::D</a></h2>
+<h2 id="A-0e-B-07-D-09">A::B::D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -130,7 +130,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0e-B-07-D-0f"><a href="#A-0e-B-07-D-0f">A::B::D&lt;bool&gt;</a></h2>
+<h2 id="A-0e-B-07-D-0f">A::B::D&lt;bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -148,7 +148,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0e-B-00"><a href="#A-0e-B-00">A::B&lt;double&gt;</a></h2>
+<h2 id="A-0e-B-00">A::B&lt;double&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -181,7 +181,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e-B-00-C"><a href="#A-0e-B-00-C">A::B&lt;double&gt;::C</a></h2>
+<h2 id="A-0e-B-00-C">A::B&lt;double&gt;::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -198,7 +198,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0e-B-00-D-09"><a href="#A-0e-B-00-D-09">A::B&lt;double&gt;::D</a></h2>
+<h2 id="A-0e-B-00-D-09">A::B&lt;double&gt;::D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -216,7 +216,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0e-B-00-D-0d"><a href="#A-0e-B-00-D-0d">A::B&lt;double&gt;::D&lt;bool&gt;</a></h2>
+<h2 id="A-0e-B-00-D-0d">A::B&lt;double&gt;::D&lt;bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -234,7 +234,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-00"><a href="#A-00">A&lt;short&gt;</a></h2>
+<h2 id="A-00">A&lt;short&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -267,7 +267,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-00-B-0e"><a href="#A-00-B-0e">A&lt;short&gt;::B</a></h2>
+<h2 id="A-00-B-0e">A&lt;short&gt;::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -285,7 +285,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-00-B-00"><a href="#A-00-B-00">A&lt;short&gt;::B&lt;void&gt;</a></h2>
+<h2 id="A-00-B-00">A&lt;short&gt;::B&lt;void&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -318,7 +318,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-00-B-00-C"><a href="#A-00-B-00-C">A&lt;short&gt;::B&lt;void&gt;::C</a></h2>
+<h2 id="A-00-B-00-C">A&lt;short&gt;::B&lt;void&gt;::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -335,7 +335,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-00-B-00-D-03"><a href="#A-00-B-00-D-03">A&lt;short&gt;::B&lt;void&gt;::D</a></h2>
+<h2 id="A-00-B-00-D-03">A&lt;short&gt;::B&lt;void&gt;::D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -353,7 +353,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-00-B-00-D-07"><a href="#A-00-B-00-D-07">A&lt;short&gt;::B&lt;void&gt;::D&lt;bool&gt;</a></h2>
+<h2 id="A-00-B-00-D-07">A&lt;short&gt;::B&lt;void&gt;::D&lt;bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -371,7 +371,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-00-B-07"><a href="#A-00-B-07">A&lt;short&gt;::B&lt;double&gt;</a></h2>
+<h2 id="A-00-B-07">A&lt;short&gt;::B&lt;double&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -404,7 +404,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-00-B-07-C"><a href="#A-00-B-07-C">A&lt;short&gt;::B&lt;double&gt;::C</a></h2>
+<h2 id="A-00-B-07-C">A&lt;short&gt;::B&lt;double&gt;::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -421,7 +421,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-00-B-07-D-015b"><a href="#A-00-B-07-D-015b">A&lt;short&gt;::B&lt;double&gt;::D</a></h2>
+<h2 id="A-00-B-07-D-015b">A&lt;short&gt;::B&lt;double&gt;::D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -439,7 +439,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-00-B-07-D-0150"><a href="#A-00-B-07-D-0150">A&lt;short&gt;::B&lt;double&gt;::D&lt;bool&gt;</a></h2>
+<h2 id="A-00-B-07-D-0150">A&lt;short&gt;::B&lt;double&gt;::D&lt;bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -457,7 +457,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-07"><a href="#A-07">A&lt;unsigned int&gt;</a></h2>
+<h2 id="A-07">A&lt;unsigned int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -490,7 +490,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-07-B-03a"><a href="#A-07-B-03a">A&lt;unsigned int&gt;::B</a></h2>
+<h2 id="A-07-B-03a">A&lt;unsigned int&gt;::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -508,7 +508,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-07-B-05"><a href="#A-07-B-05">A&lt;unsigned int&gt;::B&lt;float&gt;</a></h2>
+<h2 id="A-07-B-05">A&lt;unsigned int&gt;::B&lt;float&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -541,7 +541,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-07-B-05-C"><a href="#A-07-B-05-C">A&lt;unsigned int&gt;::B&lt;float&gt;::C</a></h2>
+<h2 id="A-07-B-05-C">A&lt;unsigned int&gt;::B&lt;float&gt;::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -558,7 +558,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-07-B-05-D-0e"><a href="#A-07-B-05-D-0e">A&lt;unsigned int&gt;::B&lt;float&gt;::D</a></h2>
+<h2 id="A-07-B-05-D-0e">A&lt;unsigned int&gt;::B&lt;float&gt;::D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -576,7 +576,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-07-B-05-D-01"><a href="#A-07-B-05-D-01">A&lt;unsigned int&gt;::B&lt;float&gt;::D&lt;bool&gt;</a></h2>
+<h2 id="A-07-B-05-D-01">A&lt;unsigned int&gt;::B&lt;float&gt;::D&lt;bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -594,7 +594,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-07-B-03e"><a href="#A-07-B-03e">A&lt;unsigned int&gt;::B&lt;double&gt;</a></h2>
+<h2 id="A-07-B-03e">A&lt;unsigned int&gt;::B&lt;double&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -627,7 +627,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-07-B-03e-C"><a href="#A-07-B-03e-C">A&lt;unsigned int&gt;::B&lt;double&gt;::C</a></h2>
+<h2 id="A-07-B-03e-C">A&lt;unsigned int&gt;::B&lt;double&gt;::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -644,7 +644,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-07-B-03e-D-01"><a href="#A-07-B-03e-D-01">A&lt;unsigned int&gt;::B&lt;double&gt;::D</a></h2>
+<h2 id="A-07-B-03e-D-01">A&lt;unsigned int&gt;::B&lt;double&gt;::D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -662,7 +662,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-07-B-03e-D-0f"><a href="#A-07-B-03e-D-0f">A&lt;unsigned int&gt;::B&lt;double&gt;::D&lt;bool&gt;</a></h2>
+<h2 id="A-07-B-03e-D-0f">A&lt;unsigned int&gt;::B&lt;double&gt;::D&lt;bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -680,7 +680,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0c"><a href="#A-0c">A&lt;long&gt;</a></h2>
+<h2 id="A-0c">A&lt;long&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -713,7 +713,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0c-B-0b"><a href="#A-0c-B-0b">A&lt;long&gt;::B</a></h2>
+<h2 id="A-0c-B-0b">A&lt;long&gt;::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -746,7 +746,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0c-B-0b-C"><a href="#A-0c-B-0b-C">A&lt;long&gt;::B::C</a></h2>
+<h2 id="A-0c-B-0b-C">A&lt;long&gt;::B::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -763,7 +763,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0c-B-0b-D-00"><a href="#A-0c-B-0b-D-00">A&lt;long&gt;::B::D</a></h2>
+<h2 id="A-0c-B-0b-D-00">A&lt;long&gt;::B::D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -781,7 +781,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0c-B-0b-D-0b"><a href="#A-0c-B-0b-D-0b">A&lt;long&gt;::B::D&lt;bool&gt;</a></h2>
+<h2 id="A-0c-B-0b-D-0b">A&lt;long&gt;::B::D&lt;bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -799,7 +799,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0c-B-08"><a href="#A-0c-B-08">A&lt;long&gt;::B&lt;float&gt;</a></h2>
+<h2 id="A-0c-B-08">A&lt;long&gt;::B&lt;float&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -832,7 +832,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0c-B-08-C"><a href="#A-0c-B-08-C">A&lt;long&gt;::B&lt;float&gt;::C</a></h2>
+<h2 id="A-0c-B-08-C">A&lt;long&gt;::B&lt;float&gt;::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -849,7 +849,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0c-B-08-D-08"><a href="#A-0c-B-08-D-08">A&lt;long&gt;::B&lt;float&gt;::D</a></h2>
+<h2 id="A-0c-B-08-D-08">A&lt;long&gt;::B&lt;float&gt;::D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -867,7 +867,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0c-B-08-D-03"><a href="#A-0c-B-08-D-03">A&lt;long&gt;::B&lt;float&gt;::D&lt;bool&gt;</a></h2>
+<h2 id="A-0c-B-08-D-03">A&lt;long&gt;::B&lt;float&gt;::D&lt;bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -885,7 +885,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0c-B-0d"><a href="#A-0c-B-0d">A&lt;long&gt;::B&lt;double&gt;</a></h2>
+<h2 id="A-0c-B-0d">A&lt;long&gt;::B&lt;double&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -918,7 +918,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0c-B-0d-C"><a href="#A-0c-B-0d-C">A&lt;long&gt;::B&lt;double&gt;::C</a></h2>
+<h2 id="A-0c-B-0d-C">A&lt;long&gt;::B&lt;double&gt;::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -935,7 +935,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0c-B-0d-D-0c"><a href="#A-0c-B-0d-D-0c">A&lt;long&gt;::B&lt;double&gt;::D</a></h2>
+<h2 id="A-0c-B-0d-D-0c">A&lt;long&gt;::B&lt;double&gt;::D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -953,7 +953,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0c-B-0d-D-03"><a href="#A-0c-B-0d-D-03">A&lt;long&gt;::B&lt;double&gt;::D&lt;bool&gt;</a></h2>
+<h2 id="A-0c-B-0d-D-03">A&lt;long&gt;::B&lt;double&gt;::D&lt;bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -971,7 +971,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-01"><a href="#A-01">A&lt;float&gt;</a></h2>
+<h2 id="A-01">A&lt;float&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1003,7 +1003,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-01-B-07"><a href="#A-01-B-07">A&lt;float&gt;::B</a></h2>
+<h2 id="A-01-B-07">A&lt;float&gt;::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1021,7 +1021,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-01-B-08"><a href="#A-01-B-08">A&lt;float&gt;::B&lt;double&gt;</a></h2>
+<h2 id="A-01-B-08">A&lt;float&gt;::B&lt;double&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1054,7 +1054,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-01-B-08-C"><a href="#A-01-B-08-C">A&lt;float&gt;::B&lt;double&gt;::C</a></h2>
+<h2 id="A-01-B-08-C">A&lt;float&gt;::B&lt;double&gt;::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1071,7 +1071,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-01-B-08-D-0ae"><a href="#A-01-B-08-D-0ae">A&lt;float&gt;::B&lt;double&gt;::D</a></h2>
+<h2 id="A-01-B-08-D-0ae">A&lt;float&gt;::B&lt;double&gt;::D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1089,7 +1089,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-01-B-08-D-0af"><a href="#A-01-B-08-D-0af">A&lt;float&gt;::B&lt;double&gt;::D&lt;bool&gt;</a></h2>
+<h2 id="A-01-B-08-D-0af">A&lt;float&gt;::B&lt;double&gt;::D&lt;bool&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1107,7 +1107,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="E"><a href="#E">E</a></h2>
+<h2 id="E">E</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1151,7 +1151,7 @@ <h2>Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="E-m0"><a href="#E-m0">E::m0</a></h2>
+<h2 id="E-m0">E::m0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1166,7 +1166,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="E-m1"><a href="#E-m1">E::m1</a></h2>
+<h2 id="E-m1">E::m1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1181,7 +1181,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="E-m10"><a href="#E-m10">E::m10</a></h2>
+<h2 id="E-m10">E::m10</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1196,7 +1196,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="E-m11"><a href="#E-m11">E::m11</a></h2>
+<h2 id="E-m11">E::m11</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1211,7 +1211,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="E-m12"><a href="#E-m12">E::m12</a></h2>
+<h2 id="E-m12">E::m12</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1226,7 +1226,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="E-m13"><a href="#E-m13">E::m13</a></h2>
+<h2 id="E-m13">E::m13</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1241,7 +1241,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="E-m14"><a href="#E-m14">E::m14</a></h2>
+<h2 id="E-m14">E::m14</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1256,7 +1256,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="E-m2"><a href="#E-m2">E::m2</a></h2>
+<h2 id="E-m2">E::m2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1271,7 +1271,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="E-m3"><a href="#E-m3">E::m3</a></h2>
+<h2 id="E-m3">E::m3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1286,7 +1286,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="E-m4"><a href="#E-m4">E::m4</a></h2>
+<h2 id="E-m4">E::m4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1301,7 +1301,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="E-m5"><a href="#E-m5">E::m5</a></h2>
+<h2 id="E-m5">E::m5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1316,7 +1316,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="E-m6"><a href="#E-m6">E::m6</a></h2>
+<h2 id="E-m6">E::m6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1331,7 +1331,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="E-m7"><a href="#E-m7">E::m7</a></h2>
+<h2 id="E-m7">E::m7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1346,7 +1346,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="E-m8"><a href="#E-m8">E::m8</a></h2>
+<h2 id="E-m8">E::m8</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -1361,7 +1361,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="E-m9"><a href="#E-m9">E::m9</a></h2>
+<h2 id="E-m9">E::m9</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/record/class-template.html b/test-files/golden-tests/symbols/record/class-template.html
index 29e8e2414..4c88bc411 100644
--- a/test-files/golden-tests/symbols/record/class-template.html
+++ b/test-files/golden-tests/symbols/record/class-template.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -29,7 +29,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="C0"><a href="#C0">C0</a></h2>
+<h2 id="C0">C0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -75,7 +75,7 @@ <h2>Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="C0-N0"><a href="#C0-N0">C0::N0</a></h2>
+<h2 id="C0-N0">C0::N0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -105,7 +105,7 @@ <h2>Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="C0-N0-z"><a href="#C0-N0-z">C0::N0::z</a></h2>
+<h2 id="C0-N0-z">C0::N0::z</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -120,7 +120,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C0-w"><a href="#C0-w">C0::w</a></h2>
+<h2 id="C0-w">C0::w</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -135,7 +135,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C0-x"><a href="#C0-x">C0::x</a></h2>
+<h2 id="C0-x">C0::x</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -150,7 +150,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C0-y"><a href="#C0-y">C0::y</a></h2>
+<h2 id="C0-y">C0::y</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -165,7 +165,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C1"><a href="#C1">C1</a></h2>
+<h2 id="C1">C1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -208,7 +208,7 @@ <h2>Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="C1-N1"><a href="#C1-N1">C1::N1</a></h2>
+<h2 id="C1-N1">C1::N1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -241,7 +241,7 @@ <h2>Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="C1-N1-x"><a href="#C1-N1-x">C1::N1::x</a></h2>
+<h2 id="C1-N1-x">C1::N1::x</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -256,7 +256,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C1-N1-y"><a href="#C1-N1-y">C1::N1::y</a></h2>
+<h2 id="C1-N1-y">C1::N1::y</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -271,7 +271,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C1-N1-z"><a href="#C1-N1-z">C1::N1::z</a></h2>
+<h2 id="C1-N1-z">C1::N1::z</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -286,7 +286,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C1-w"><a href="#C1-w">C1::w</a></h2>
+<h2 id="C1-w">C1::w</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -301,7 +301,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C2"><a href="#C2">C2</a></h2>
+<h2 id="C2">C2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -345,7 +345,7 @@ <h2>Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="C2-N2"><a href="#C2-N2">C2::N2</a></h2>
+<h2 id="C2-N2">C2::N2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -379,7 +379,7 @@ <h2>Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="C2-N2-w"><a href="#C2-N2-w">C2::N2::w</a></h2>
+<h2 id="C2-N2-w">C2::N2::w</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -394,7 +394,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C2-N2-x"><a href="#C2-N2-x">C2::N2::x</a></h2>
+<h2 id="C2-N2-x">C2::N2::x</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -409,7 +409,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C2-N2-y"><a href="#C2-N2-y">C2::N2::y</a></h2>
+<h2 id="C2-N2-y">C2::N2::y</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -424,7 +424,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C2-N2-z"><a href="#C2-N2-z">C2::N2::z</a></h2>
+<h2 id="C2-N2-z">C2::N2::z</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -439,7 +439,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C2-v"><a href="#C2-v">C2::v</a></h2>
+<h2 id="C2-v">C2::v</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -454,7 +454,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C3"><a href="#C3">C3</a></h2>
+<h2 id="C3">C3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -485,7 +485,7 @@ <h2>Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="C3-v"><a href="#C3-v">C3::v</a></h2>
+<h2 id="C3-v">C3::v</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -500,7 +500,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S"><a href="#S">S</a></h2>
+<h2 id="S">S</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/record/conditional-explicit.html b/test-files/golden-tests/symbols/record/conditional-explicit.html
index 776f3004e..5e1439c06 100644
--- a/test-files/golden-tests/symbols/record/conditional-explicit.html
+++ b/test-files/golden-tests/symbols/record/conditional-explicit.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -61,7 +61,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-2constructor-0f"><a href="#A-2constructor-0f">A::A</a></h2>
+<h2 id="A-2constructor-0f">A::A</h2>
 <div>
 <span>Constructors</span>
 
@@ -108,7 +108,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="A-2constructor-0b"><a href="#A-2constructor-0b">A::A</a></h2>
+<h2 id="A-2constructor-0b">A::A</h2>
 <div>
 <span>Conditionally explicit conversion from char</span>
 
@@ -145,7 +145,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-2constructor-01"><a href="#A-2constructor-01">A::A</a></h2>
+<h2 id="A-2constructor-01">A::A</h2>
 <div>
 <span>Explicit conversion from int</span>
 
@@ -182,7 +182,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-2constructor-00"><a href="#A-2constructor-00">A::A</a></h2>
+<h2 id="A-2constructor-00">A::A</h2>
 <div>
 <span>Implicit conversion from double</span>
 
@@ -218,7 +218,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-2constructor-02"><a href="#A-2constructor-02">A::A</a></h2>
+<h2 id="A-2constructor-02">A::A</h2>
 <div>
 <span>Conditionally explicit conversion from other types</span>
 
@@ -256,7 +256,7 @@ <h3>Parameters</h3>
 </div>
 <div>
 <div>
-<h2 id="A-2conversion-0f"><a href="#A-2conversion-0f">A::operator U</a></h2>
+<h2 id="A-2conversion-0f">A::operator U</h2>
 <div>
 <span>Conditional explicit conversion to other types</span>
 
@@ -281,7 +281,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="A-2conversion-00"><a href="#A-2conversion-00">A::operator bool</a></h2>
+<h2 id="A-2conversion-00">A::operator bool</h2>
 <div>
 <span>Explicit conversion to bool</span>
 
@@ -305,7 +305,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="A-2conversion-04"><a href="#A-2conversion-04">A::operator char</a></h2>
+<h2 id="A-2conversion-04">A::operator char</h2>
 <div>
 <span>Conditionally explicit conversion to char</span>
 
@@ -329,7 +329,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="A-2conversion-01"><a href="#A-2conversion-01">A::operator double</a></h2>
+<h2 id="A-2conversion-01">A::operator double</h2>
 <div>
 <span>Implicit conversion to double</span>
 
diff --git a/test-files/golden-tests/symbols/record/dtor-overloads.html b/test-files/golden-tests/symbols/record/dtor-overloads.html
index e0825614b..8b0378186 100644
--- a/test-files/golden-tests/symbols/record/dtor-overloads.html
+++ b/test-files/golden-tests/symbols/record/dtor-overloads.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -57,7 +57,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-2destructor-02"><a href="#A-2destructor-02">A::~A</a></h2>
+<h2 id="A-2destructor-02">A::~A</h2>
 <div>
 <span>Destructors</span>
 
@@ -88,7 +88,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="A-2destructor-0c"><a href="#A-2destructor-0c">A::~A</a></h2>
+<h2 id="A-2destructor-0c">A::~A</h2>
 <div>
 <span>Destructor</span>
 
@@ -108,7 +108,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-2destructor-07"><a href="#A-2destructor-07">A::~A</a></h2>
+<h2 id="A-2destructor-07">A::~A</h2>
 <div>
 <span>Destructor</span>
 
diff --git a/test-files/golden-tests/symbols/record/final-class.html b/test-files/golden-tests/symbols/record/final-class.html
index 1b94de154..96efd1b9d 100644
--- a/test-files/golden-tests/symbols/record/final-class.html
+++ b/test-files/golden-tests/symbols/record/final-class.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -29,7 +29,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A1"><a href="#A1">A1</a></h2>
+<h2 id="A1">A1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -46,7 +46,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A2"><a href="#A2">A2</a></h2>
+<h2 id="A2">A2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -64,7 +64,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A3"><a href="#A3">A3</a></h2>
+<h2 id="A3">A3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -98,7 +98,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="B1"><a href="#B1">B1</a></h2>
+<h2 id="B1">B1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -130,7 +130,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="B2"><a href="#B2">B2</a></h2>
+<h2 id="B2">B2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/record/friend-duplicate.html b/test-files/golden-tests/symbols/record/friend-duplicate.html
index dab44eff0..6a1417fdd 100644
--- a/test-files/golden-tests/symbols/record/friend-duplicate.html
+++ b/test-files/golden-tests/symbols/record/friend-duplicate.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -39,7 +39,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -78,7 +78,7 @@ <h2>Friends</h2>
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -95,7 +95,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/record/friend-excluded.html b/test-files/golden-tests/symbols/record/friend-excluded.html
index fdcedfc9d..31fb1bd93 100644
--- a/test-files/golden-tests/symbols/record/friend-excluded.html
+++ b/test-files/golden-tests/symbols/record/friend-excluded.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -39,7 +39,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -78,7 +78,7 @@ <h2>Friends</h2>
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -95,7 +95,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/record/friend-fn-has-docs.html b/test-files/golden-tests/symbols/record/friend-fn-has-docs.html
index 609a84bfe..395192bd8 100644
--- a/test-files/golden-tests/symbols/record/friend-fn-has-docs.html
+++ b/test-files/golden-tests/symbols/record/friend-fn-has-docs.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -39,7 +39,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T"><a href="#T">T</a></h2>
+<h2 id="T">T</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -74,7 +74,7 @@ <h2>Friends</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>f</span>
 
diff --git a/test-files/golden-tests/symbols/record/friend-fn-member.html b/test-files/golden-tests/symbols/record/friend-fn-member.html
index ef3d4b2d7..a016b96ac 100644
--- a/test-files/golden-tests/symbols/record/friend-fn-member.html
+++ b/test-files/golden-tests/symbols/record/friend-fn-member.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="U"><a href="#U">U</a></h2>
+<h2 id="U">U</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -69,7 +69,7 @@ <h2>Friends</h2>
 </div>
 <div>
 <div>
-<h2 id="X"><a href="#X">X</a></h2>
+<h2 id="X">X</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -102,7 +102,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="X-2constructor"><a href="#X-2constructor">X::X</a></h2>
+<h2 id="X-2constructor">X::X</h2>
 <div>
 <span>Default constructor</span>
 
@@ -121,7 +121,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X-2destructor"><a href="#X-2destructor">X::~X</a></h2>
+<h2 id="X-2destructor">X::~X</h2>
 <div>
 <span>Destructor</span>
 
@@ -140,7 +140,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X-foo"><a href="#X-foo">X::foo</a></h2>
+<h2 id="X-foo">X::foo</h2>
 <div>
 <span>Friend member-function</span>
 
diff --git a/test-files/golden-tests/symbols/record/friend-fn-multi-2nd.html b/test-files/golden-tests/symbols/record/friend-fn-multi-2nd.html
index 957e1b2fd..a90ac42c5 100644
--- a/test-files/golden-tests/symbols/record/friend-fn-multi-2nd.html
+++ b/test-files/golden-tests/symbols/record/friend-fn-multi-2nd.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -40,7 +40,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T"><a href="#T">T</a></h2>
+<h2 id="T">T</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -75,7 +75,7 @@ <h2>Friends</h2>
 </div>
 <div>
 <div>
-<h2 id="U"><a href="#U">U</a></h2>
+<h2 id="U">U</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -110,7 +110,7 @@ <h2>Friends</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>U::f</span>
 
diff --git a/test-files/golden-tests/symbols/record/friend-fn-multi-free.html b/test-files/golden-tests/symbols/record/friend-fn-multi-free.html
index 4c32324e1..57b7f7299 100644
--- a/test-files/golden-tests/symbols/record/friend-fn-multi-free.html
+++ b/test-files/golden-tests/symbols/record/friend-fn-multi-free.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -40,7 +40,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T"><a href="#T">T</a></h2>
+<h2 id="T">T</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -75,7 +75,7 @@ <h2>Friends</h2>
 </div>
 <div>
 <div>
-<h2 id="U"><a href="#U">U</a></h2>
+<h2 id="U">U</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -110,7 +110,7 @@ <h2>Friends</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>f</span>
 
diff --git a/test-files/golden-tests/symbols/record/friend-fn-multi.html b/test-files/golden-tests/symbols/record/friend-fn-multi.html
index 542695b74..a3fb41f66 100644
--- a/test-files/golden-tests/symbols/record/friend-fn-multi.html
+++ b/test-files/golden-tests/symbols/record/friend-fn-multi.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -40,7 +40,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T"><a href="#T">T</a></h2>
+<h2 id="T">T</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -75,7 +75,7 @@ <h2>Friends</h2>
 </div>
 <div>
 <div>
-<h2 id="U"><a href="#U">U</a></h2>
+<h2 id="U">U</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -110,7 +110,7 @@ <h2>Friends</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>T::f</span>
 
diff --git a/test-files/golden-tests/symbols/record/friend-fn.html b/test-files/golden-tests/symbols/record/friend-fn.html
index ef83619a0..133020c70 100644
--- a/test-files/golden-tests/symbols/record/friend-fn.html
+++ b/test-files/golden-tests/symbols/record/friend-fn.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -39,7 +39,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T"><a href="#T">T</a></h2>
+<h2 id="T">T</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -74,7 +74,7 @@ <h2>Friends</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>f</span>
 
diff --git a/test-files/golden-tests/symbols/record/friend-type.html b/test-files/golden-tests/symbols/record/friend-type.html
index f9562429b..69c654552 100644
--- a/test-files/golden-tests/symbols/record/friend-type.html
+++ b/test-files/golden-tests/symbols/record/friend-type.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -29,7 +29,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="T"><a href="#T">T</a></h2>
+<h2 id="T">T</h2>
 <div>
 <span>Struct T brief</span>
 
@@ -68,7 +68,7 @@ <h2>Friends</h2>
 </div>
 <div>
 <div>
-<h2 id="U"><a href="#U">U</a></h2>
+<h2 id="U">U</h2>
 <div>
 <span>Struct U brief</span>
 
@@ -107,7 +107,7 @@ <h2>Friends</h2>
 </div>
 <div>
 <div>
-<h2 id="V"><a href="#V">V</a></h2>
+<h2 id="V">V</h2>
 <div>
 <span>Struct V brief</span>
 
@@ -146,7 +146,7 @@ <h2>Friends</h2>
 </div>
 <div>
 <div>
-<h2 id="Z"><a href="#Z">Z</a></h2>
+<h2 id="Z">Z</h2>
 <div>
 <span>Friend class Z brief</span>
 
diff --git a/test-files/golden-tests/symbols/record/local-class.html b/test-files/golden-tests/symbols/record/local-class.html
index e6a2a3f0e..b1f5105c1 100644
--- a/test-files/golden-tests/symbols/record/local-class.html
+++ b/test-files/golden-tests/symbols/record/local-class.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -38,7 +38,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -70,7 +70,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/record/out-of-line-record-def.html b/test-files/golden-tests/symbols/record/out-of-line-record-def.html
index 68329ef3f..cac5ff65e 100644
--- a/test-files/golden-tests/symbols/record/out-of-line-record-def.html
+++ b/test-files/golden-tests/symbols/record/out-of-line-record-def.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Namespaces</h2>
 </div>
 <div>
 <div>
-<h2 id="N"><a href="#N">N</a></h2>
+<h2 id="N">N</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -43,7 +43,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="N-S"><a href="#N-S">N::S</a></h2>
+<h2 id="N-S">N::S</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/record/record-1.html b/test-files/golden-tests/symbols/record/record-1.html
index a38f78c13..217757108 100644
--- a/test-files/golden-tests/symbols/record/record-1.html
+++ b/test-files/golden-tests/symbols/record/record-1.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="T"><a href="#T">T</a></h2>
+<h2 id="T">T</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -87,7 +87,7 @@ <h2>Protected Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="T-U1"><a href="#T-U1">T::U1</a></h2>
+<h2 id="T-U1">T::U1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -102,7 +102,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T-U2"><a href="#T-U2">T::U2</a></h2>
+<h2 id="T-U2">T::U2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -117,7 +117,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T-f1"><a href="#T-f1">T::f1</a></h2>
+<h2 id="T-f1">T::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -133,7 +133,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T-f2"><a href="#T-f2">T::f2</a></h2>
+<h2 id="T-f2">T::f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -149,7 +149,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T-f3"><a href="#T-f3">T::f3</a></h2>
+<h2 id="T-f3">T::f3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -165,7 +165,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T-g1"><a href="#T-g1">T::g1</a></h2>
+<h2 id="T-g1">T::g1</h2>
 <div>
 <span>brief-g1</span>
 
@@ -189,7 +189,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="T-g2"><a href="#T-g2">T::g2</a></h2>
+<h2 id="T-g2">T::g2</h2>
 <div>
 <span>brief-g2</span>
 
@@ -213,7 +213,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="T-g3"><a href="#T-g3">T::g3</a></h2>
+<h2 id="T-g3">T::g3</h2>
 <div>
 <span>brief-g3</span>
 
diff --git a/test-files/golden-tests/symbols/record/record-access.html b/test-files/golden-tests/symbols/record/record-access.html
index 6162cddf8..fe9b3caf8 100644
--- a/test-files/golden-tests/symbols/record/record-access.html
+++ b/test-files/golden-tests/symbols/record/record-access.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -27,7 +27,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="C0"><a href="#C0">C0</a></h2>
+<h2 id="C0">C0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -83,7 +83,7 @@ <h2>Private Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="C0-f2"><a href="#C0-f2">C0::f2</a></h2>
+<h2 id="C0-f2">C0::f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -99,7 +99,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C0-f1"><a href="#C0-f1">C0::f1</a></h2>
+<h2 id="C0-f1">C0::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -115,7 +115,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C0-f0"><a href="#C0-f0">C0::f0</a></h2>
+<h2 id="C0-f0">C0::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -131,7 +131,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0"><a href="#S0">S0</a></h2>
+<h2 id="S0">S0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -187,7 +187,7 @@ <h2>Private Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-f0"><a href="#S0-f0">S0::f0</a></h2>
+<h2 id="S0-f0">S0::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -203,7 +203,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-f1"><a href="#S0-f1">S0::f1</a></h2>
+<h2 id="S0-f1">S0::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -219,7 +219,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-f2"><a href="#S0-f2">S0::f2</a></h2>
+<h2 id="S0-f2">S0::f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -235,7 +235,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="U0"><a href="#U0">U0</a></h2>
+<h2 id="U0">U0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -291,7 +291,7 @@ <h2>Private Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="U0-f0"><a href="#U0-f0">U0::f0</a></h2>
+<h2 id="U0-f0">U0::f0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -307,7 +307,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="U0-f1"><a href="#U0-f1">U0::f1</a></h2>
+<h2 id="U0-f1">U0::f1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -323,7 +323,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="U0-f2"><a href="#U0-f2">U0::f2</a></h2>
+<h2 id="U0-f2">U0::f2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/record/record-data.html b/test-files/golden-tests/symbols/record/record-data.html
index 0571f3543..ed8d14f0b 100644
--- a/test-files/golden-tests/symbols/record/record-data.html
+++ b/test-files/golden-tests/symbols/record/record-data.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -29,7 +29,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="T"><a href="#T">T</a></h2>
+<h2 id="T">T</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -63,7 +63,7 @@ <h2>Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="T-i"><a href="#T-i">T::i</a></h2>
+<h2 id="T-i">T::i</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -78,7 +78,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T-j"><a href="#T-j">T::j</a></h2>
+<h2 id="T-j">T::j</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -93,7 +93,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T-k"><a href="#T-k">T::k</a></h2>
+<h2 id="T-k">T::k</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -109,7 +109,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T-l"><a href="#T-l">T::l</a></h2>
+<h2 id="T-l">T::l</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -124,7 +124,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T-m"><a href="#T-m">T::m</a></h2>
+<h2 id="T-m">T::m</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -139,7 +139,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="U"><a href="#U">U</a></h2>
+<h2 id="U">U</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -169,7 +169,7 @@ <h2>Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="U-t"><a href="#U-t">U::t</a></h2>
+<h2 id="U-t">U::t</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -184,7 +184,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="V"><a href="#V">V</a></h2>
+<h2 id="V">V</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -228,7 +228,7 @@ <h2>Private Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="V-j"><a href="#V-j">V::j</a></h2>
+<h2 id="V-j">V::j</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -243,7 +243,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="V-i"><a href="#V-i">V::i</a></h2>
+<h2 id="V-i">V::i</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -258,7 +258,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="V-k"><a href="#V-k">V::k</a></h2>
+<h2 id="V-k">V::k</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -273,7 +273,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="W"><a href="#W">W</a></h2>
+<h2 id="W">W</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -303,7 +303,7 @@ <h2>Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="W-buf"><a href="#W-buf">W::buf</a></h2>
+<h2 id="W-buf">W::buf</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -318,7 +318,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X"><a href="#X">X</a></h2>
+<h2 id="X">X</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -368,7 +368,7 @@ <h2>Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="X-Q"><a href="#X-Q">X::Q</a></h2>
+<h2 id="X-Q">X::Q</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -383,7 +383,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X-x0"><a href="#X-x0">X::x0</a></h2>
+<h2 id="X-x0">X::x0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -398,7 +398,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X-x1"><a href="#X-x1">X::x1</a></h2>
+<h2 id="X-x1">X::x1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -413,7 +413,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X-x2"><a href="#X-x2">X::x2</a></h2>
+<h2 id="X-x2">X::x2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -428,7 +428,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X-x3"><a href="#X-x3">X::x3</a></h2>
+<h2 id="X-x3">X::x3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -443,7 +443,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X-x4"><a href="#X-x4">X::x4</a></h2>
+<h2 id="X-x4">X::x4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/record/record-inheritance.html b/test-files/golden-tests/symbols/record/record-inheritance.html
index 99c061e15..1c5765150 100644
--- a/test-files/golden-tests/symbols/record/record-inheritance.html
+++ b/test-files/golden-tests/symbols/record/record-inheritance.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -40,7 +40,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="C0"><a href="#C0">C0</a></h2>
+<h2 id="C0">C0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -72,7 +72,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="C1"><a href="#C1">C1</a></h2>
+<h2 id="C1">C1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -90,7 +90,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C2"><a href="#C2">C2</a></h2>
+<h2 id="C2">C2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -122,7 +122,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="C3"><a href="#C3">C3</a></h2>
+<h2 id="C3">C3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -154,7 +154,7 @@ <h2>Protected Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="C4"><a href="#C4">C4</a></h2>
+<h2 id="C4">C4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -172,7 +172,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C5"><a href="#C5">C5</a></h2>
+<h2 id="C5">C5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -205,7 +205,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="C6"><a href="#C6">C6</a></h2>
+<h2 id="C6">C6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -238,7 +238,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="C7"><a href="#C7">C7</a></h2>
+<h2 id="C7">C7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -272,7 +272,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0"><a href="#S0">S0</a></h2>
+<h2 id="S0">S0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -304,7 +304,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S1"><a href="#S1">S1</a></h2>
+<h2 id="S1">S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -336,7 +336,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S2"><a href="#S2">S2</a></h2>
+<h2 id="S2">S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -383,7 +383,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S3"><a href="#S3">S3</a></h2>
+<h2 id="S3">S3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -430,7 +430,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S4"><a href="#S4">S4</a></h2>
+<h2 id="S4">S4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -464,7 +464,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S5"><a href="#S5">S5</a></h2>
+<h2 id="S5">S5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -497,7 +497,7 @@ <h2>Protected Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S6"><a href="#S6">S6</a></h2>
+<h2 id="S6">S6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -530,7 +530,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="U0"><a href="#U0">U0</a></h2>
+<h2 id="U0">U0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/record/template-specialization-inheritance.html b/test-files/golden-tests/symbols/record/template-specialization-inheritance.html
index 1462b804f..1f831414e 100644
--- a/test-files/golden-tests/symbols/record/template-specialization-inheritance.html
+++ b/test-files/golden-tests/symbols/record/template-specialization-inheritance.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -35,7 +35,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="U1"><a href="#U1">U1</a></h2>
+<h2 id="U1">U1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -50,7 +50,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="U2"><a href="#U2">U2</a></h2>
+<h2 id="U2">U2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -65,7 +65,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="U3"><a href="#U3">U3</a></h2>
+<h2 id="U3">U3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -80,7 +80,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="R0"><a href="#R0">R0</a></h2>
+<h2 id="R0">R0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -125,7 +125,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="R1"><a href="#R1">R1</a></h2>
+<h2 id="R1">R1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -157,7 +157,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="R2"><a href="#R2">R2</a></h2>
+<h2 id="R2">R2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -189,7 +189,7 @@ <h2>Base Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0c"><a href="#S0-0c">S0</a></h2>
+<h2 id="S0-0c">S0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -237,7 +237,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0c-S1"><a href="#S0-0c-S1">S0::S1</a></h2>
+<h2 id="S0-0c-S1">S0::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -254,7 +254,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09"><a href="#S0-09">S0&lt;2&gt;</a></h2>
+<h2 id="S0-09">S0&lt;2&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -285,7 +285,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-09-S1"><a href="#S0-09-S1">S0&lt;2&gt;::S1</a></h2>
+<h2 id="S0-09-S1">S0&lt;2&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -317,7 +317,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-073"><a href="#S0-073">S0&lt;3&gt;</a></h2>
+<h2 id="S0-073">S0&lt;3&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -350,7 +350,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0e"><a href="#S0-0e">S0&lt;5&gt;</a></h2>
+<h2 id="S0-0e">S0&lt;5&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -381,7 +381,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-0e-S1"><a href="#S0-0e-S1">S0&lt;5&gt;::S1</a></h2>
+<h2 id="S0-0e-S1">S0&lt;5&gt;::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -398,7 +398,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-07e"><a href="#S0-07e">S0&lt;6&gt;</a></h2>
+<h2 id="S0-07e">S0&lt;6&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/record/union.html b/test-files/golden-tests/symbols/record/union.html
index 2ce8d95c7..73c865d34 100644
--- a/test-files/golden-tests/symbols/record/union.html
+++ b/test-files/golden-tests/symbols/record/union.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -57,7 +57,7 @@ <h2>Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="A-x"><a href="#A-x">A::x</a></h2>
+<h2 id="A-x">A::x</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -72,7 +72,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-y"><a href="#A-y">A::y</a></h2>
+<h2 id="A-y">A::y</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -87,7 +87,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -119,7 +119,7 @@ <h2>Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="B-x"><a href="#B-x">B::x</a></h2>
+<h2 id="B-x">B::x</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -134,7 +134,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-y"><a href="#B-y">B::y</a></h2>
+<h2 id="B-y">B::y</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -149,7 +149,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-z"><a href="#B-z">B::z</a></h2>
+<h2 id="B-z">B::z</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/record/unnamed.html b/test-files/golden-tests/symbols/record/unnamed.html
index 161447e57..ed79330bd 100644
--- a/test-files/golden-tests/symbols/record/unnamed.html
+++ b/test-files/golden-tests/symbols/record/unnamed.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -143,7 +143,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F"><a href="#F">F</a></h2>
+<h2 id="F">F</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/typedef/alias-template.html b/test-files/golden-tests/symbols/typedef/alias-template.html
index 5cda8e886..64889d567 100644
--- a/test-files/golden-tests/symbols/typedef/alias-template.html
+++ b/test-files/golden-tests/symbols/typedef/alias-template.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -28,7 +28,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="C"><a href="#C">C</a></h2>
+<h2 id="C">C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -44,7 +44,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -62,7 +62,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -82,7 +82,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="D"><a href="#D">D</a></h2>
+<h2 id="D">D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -113,7 +113,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="D-E"><a href="#D-E">D::E</a></h2>
+<h2 id="D-E">D::E</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/typedef/decay-to-primary.html b/test-files/golden-tests/symbols/typedef/decay-to-primary.html
index d9fe6219e..f747caa70 100644
--- a/test-files/golden-tests/symbols/typedef/decay-to-primary.html
+++ b/test-files/golden-tests/symbols/typedef/decay-to-primary.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -29,7 +29,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A0"><a href="#A0">A0</a></h2>
+<h2 id="A0">A0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -44,7 +44,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A1"><a href="#A1">A1</a></h2>
+<h2 id="A1">A1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -59,7 +59,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-03"><a href="#S0-03">S0</a></h2>
+<h2 id="S0-03">S0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -91,7 +91,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-03-M0"><a href="#S0-03-M0">S0::M0</a></h2>
+<h2 id="S0-03-M0">S0::M0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -106,7 +106,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-03-M1"><a href="#S0-03-M1">S0::M1</a></h2>
+<h2 id="S0-03-M1">S0::M1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -122,7 +122,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-00"><a href="#S0-00">S0&lt;void&gt;</a></h2>
+<h2 id="S0-00">S0&lt;void&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -154,7 +154,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-00-M0"><a href="#S0-00-M0">S0&lt;void&gt;::M0</a></h2>
+<h2 id="S0-00-M0">S0&lt;void&gt;::M0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -169,7 +169,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-00-M1"><a href="#S0-00-M1">S0&lt;void&gt;::M1</a></h2>
+<h2 id="S0-00-M1">S0&lt;void&gt;::M1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -185,7 +185,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09"><a href="#S0-09">S0&lt;short&gt;</a></h2>
+<h2 id="S0-09">S0&lt;short&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -217,7 +217,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-09-M0"><a href="#S0-09-M0">S0&lt;short&gt;::M0</a></h2>
+<h2 id="S0-09-M0">S0&lt;short&gt;::M0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -232,7 +232,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-09-M1"><a href="#S0-09-M1">S0&lt;short&gt;::M1</a></h2>
+<h2 id="S0-09-M1">S0&lt;short&gt;::M1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/typedef/dependency-propagation.html b/test-files/golden-tests/symbols/typedef/dependency-propagation.html
index 6c0a23da1..ee3ddf82a 100644
--- a/test-files/golden-tests/symbols/typedef/dependency-propagation.html
+++ b/test-files/golden-tests/symbols/typedef/dependency-propagation.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -38,7 +38,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="N"><a href="#N">N</a></h2>
+<h2 id="N">N</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -59,7 +59,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="N-B"><a href="#N-B">N::B</a></h2>
+<h2 id="N-B">N::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -75,7 +75,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="N-C"><a href="#N-C">N::C</a></h2>
+<h2 id="N-C">N::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -91,7 +91,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="N-A"><a href="#N-A">N::A</a></h2>
+<h2 id="N-A">N::A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -109,7 +109,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="N-D"><a href="#N-D">N::D</a></h2>
+<h2 id="N-D">N::D</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -126,7 +126,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="E"><a href="#E">E</a></h2>
+<h2 id="E">E</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/typedef/implicit-instantiation-member-ref.html b/test-files/golden-tests/symbols/typedef/implicit-instantiation-member-ref.html
index a35a02dc4..9abefa38e 100644
--- a/test-files/golden-tests/symbols/typedef/implicit-instantiation-member-ref.html
+++ b/test-files/golden-tests/symbols/typedef/implicit-instantiation-member-ref.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -28,7 +28,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A5"><a href="#A5">A5</a></h2>
+<h2 id="A5">A5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -43,7 +43,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A9"><a href="#A9">A9</a></h2>
+<h2 id="A9">A9</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -58,7 +58,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-03"><a href="#S0-03">S0</a></h2>
+<h2 id="S0-03">S0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -89,7 +89,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-03-S2"><a href="#S0-03-S2">S0::S2</a></h2>
+<h2 id="S0-03-S2">S0::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -121,7 +121,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-03-S2-M2"><a href="#S0-03-S2-M2">S0::S2::M2</a></h2>
+<h2 id="S0-03-S2-M2">S0::S2::M2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -136,7 +136,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-03-S2-M3"><a href="#S0-03-S2-M3">S0::S2::M3</a></h2>
+<h2 id="S0-03-S2-M3">S0::S2::M3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -152,7 +152,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-00"><a href="#S0-00">S0&lt;void&gt;</a></h2>
+<h2 id="S0-00">S0&lt;void&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -184,7 +184,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-00-S2-0d"><a href="#S0-00-S2-0d">S0&lt;void&gt;::S2</a></h2>
+<h2 id="S0-00-S2-0d">S0&lt;void&gt;::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -202,7 +202,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-00-S2-02"><a href="#S0-00-S2-02">S0&lt;void&gt;::S2&lt;char&gt;</a></h2>
+<h2 id="S0-00-S2-02">S0&lt;void&gt;::S2&lt;char&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -234,7 +234,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="S0-00-S2-02-M2"><a href="#S0-00-S2-02-M2">S0&lt;void&gt;::S2&lt;char&gt;::M2</a></h2>
+<h2 id="S0-00-S2-02-M2">S0&lt;void&gt;::S2&lt;char&gt;::M2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -249,7 +249,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S0-00-S2-02-M3"><a href="#S0-00-S2-02-M3">S0&lt;void&gt;::S2&lt;char&gt;::M3</a></h2>
+<h2 id="S0-00-S2-02-M3">S0&lt;void&gt;::S2&lt;char&gt;::M3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/using-directive/using-1.html b/test-files/golden-tests/symbols/using-directive/using-1.html
index 11b11ebd6..a4295e1a3 100644
--- a/test-files/golden-tests/symbols/using-directive/using-1.html
+++ b/test-files/golden-tests/symbols/using-directive/using-1.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -42,7 +42,7 @@ <h2>Using Namespace Directives</h2>
 </div>
 <div>
 <div>
-<h2 id="LongName"><a href="#LongName">LongName</a></h2>
+<h2 id="LongName">LongName</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -60,7 +60,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="LongName-A"><a href="#LongName-A">LongName::A</a></h2>
+<h2 id="LongName-A">LongName::A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/using-enum/using-enum-in-ns.adoc b/test-files/golden-tests/symbols/using-enum/using-enum-in-ns.adoc
index b2ab0202b..3f177aa46 100644
--- a/test-files/golden-tests/symbols/using-enum/using-enum-in-ns.adoc
+++ b/test-files/golden-tests/symbols/using-enum/using-enum-in-ns.adoc
@@ -45,13 +45,12 @@ enum class E : int;
 
 === Members
 
-
 [cols=2]
 |===
 | Name
 | Description
-|`e1`
-|The constant to be introduced
+| `e1` 
+| The constant to be introduced
 |===
 
 [#f]
diff --git a/test-files/golden-tests/symbols/using-enum/using-enum-in-ns.html b/test-files/golden-tests/symbols/using-enum/using-enum-in-ns.html
index 32901a0c7..0b58c6fbd 100644
--- a/test-files/golden-tests/symbols/using-enum/using-enum-in-ns.html
+++ b/test-files/golden-tests/symbols/using-enum/using-enum-in-ns.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -38,7 +38,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <h2>Enums</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -56,7 +56,7 @@ <h2>Enums</h2>
 </div>
 <div>
 <div>
-<h2 id="A-E"><a href="#A-E">A::E</a></h2>
+<h2 id="A-E">A::E</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -68,9 +68,8 @@ <h3>Synopsis</h3>
 </code>
 </pre>
 </div>
-<div>
-<h3>Members</h3>
-<table>
+<h2>Members</h2>
+<table style="table-layout: fixed; width: 100%;">
 <thead>
 <tr>
 <th>Name</th>
@@ -79,16 +78,14 @@ <h3>Members</h3>
 </thead>
 <tbody>
 <tr>
-<td>e1</td>
-<td><span>The constant to be introduced</span></td>
-</tr>
+<td><code>e1</code> </td><td><span>The constant to be introduced</span></td></tr>
 </tbody>
 </table>
-</div>
+
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/using-enum/using-enum-in-record.adoc b/test-files/golden-tests/symbols/using-enum/using-enum-in-record.adoc
index db39c38f8..c6bfbdf94 100644
--- a/test-files/golden-tests/symbols/using-enum/using-enum-in-record.adoc
+++ b/test-files/golden-tests/symbols/using-enum/using-enum-in-record.adoc
@@ -53,13 +53,12 @@ enum class E : int;
 
 === Members
 
-
 [cols=2]
 |===
 | Name
 | Description
-|`e1`
-|The constant to be introduced
+| `e1` 
+| The constant to be introduced
 |===
 
 [#B]
diff --git a/test-files/golden-tests/symbols/using-enum/using-enum-in-record.html b/test-files/golden-tests/symbols/using-enum/using-enum-in-record.html
index 384d72904..c10b0f369 100644
--- a/test-files/golden-tests/symbols/using-enum/using-enum-in-record.html
+++ b/test-files/golden-tests/symbols/using-enum/using-enum-in-record.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -51,7 +51,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <h2>Enums</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -69,7 +69,7 @@ <h2>Enums</h2>
 </div>
 <div>
 <div>
-<h2 id="A-E"><a href="#A-E">A::E</a></h2>
+<h2 id="A-E">A::E</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -81,9 +81,8 @@ <h3>Synopsis</h3>
 </code>
 </pre>
 </div>
-<div>
-<h3>Members</h3>
-<table>
+<h2>Members</h2>
+<table style="table-layout: fixed; width: 100%;">
 <thead>
 <tr>
 <th>Name</th>
@@ -92,16 +91,14 @@ <h3>Members</h3>
 </thead>
 <tbody>
 <tr>
-<td>e1</td>
-<td><span>The constant to be introduced</span></td>
-</tr>
+<td><code>e1</code> </td><td><span>The constant to be introduced</span></td></tr>
 </tbody>
 </table>
-</div>
+
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -118,7 +115,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="g"><a href="#g">g</a></h2>
+<h2 id="g">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/using/using-function-after.html b/test-files/golden-tests/symbols/using/using-function-after.html
index fce951903..ae264b91b 100644
--- a/test-files/golden-tests/symbols/using/using-function-after.html
+++ b/test-files/golden-tests/symbols/using/using-function-after.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -39,7 +39,7 @@ <h2>Using Declarations</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -58,7 +58,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-f-08"><a href="#A-f-08">A::f</a></h2>
+<h2 id="A-f-08">A::f</h2>
 <div>
 <span><code>f</code> overloads</span>
 
@@ -89,7 +89,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f-00"><a href="#A-f-00">A::f</a></h2>
+<h2 id="A-f-00">A::f</h2>
 <div>
 <span>A non-shadowing declaration</span>
 
@@ -114,7 +114,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f-01"><a href="#A-f-01">A::f</a></h2>
+<h2 id="A-f-01">A::f</h2>
 <div>
 <span>A shadow declaration</span>
 
@@ -134,7 +134,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>f overloads are also available in the global namespace</span>
 
diff --git a/test-files/golden-tests/symbols/using/using-function-and-type.html b/test-files/golden-tests/symbols/using/using-function-and-type.html
index 157a4c800..4dc3a5ddd 100644
--- a/test-files/golden-tests/symbols/using/using-function-and-type.html
+++ b/test-files/golden-tests/symbols/using/using-function-and-type.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -39,7 +39,7 @@ <h2>Using Declarations</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -72,7 +72,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-f-05"><a href="#A-f-05">A::f</a></h2>
+<h2 id="A-f-05">A::f</h2>
 <div>
 <span>A record</span>
 
@@ -93,7 +93,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f-01"><a href="#A-f-01">A::f</a></h2>
+<h2 id="A-f-01">A::f</h2>
 <div>
 <span>A function</span>
 
@@ -113,7 +113,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>A using declaration that shadows a function and the record.</span>
 
diff --git a/test-files/golden-tests/symbols/using/using-function-excluded.html b/test-files/golden-tests/symbols/using/using-function-excluded.html
index 16e044bcd..3eb65e4b5 100644
--- a/test-files/golden-tests/symbols/using/using-function-excluded.html
+++ b/test-files/golden-tests/symbols/using/using-function-excluded.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Using Declarations</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Using Declarations</h2>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>Using excluded function f</span>
 
diff --git a/test-files/golden-tests/symbols/using/using-function-local-overloads.html b/test-files/golden-tests/symbols/using/using-function-local-overloads.html
index 934cadb18..01f590816 100644
--- a/test-files/golden-tests/symbols/using/using-function-local-overloads.html
+++ b/test-files/golden-tests/symbols/using/using-function-local-overloads.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -52,7 +52,7 @@ <h2>Using Declarations</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -71,7 +71,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-f-08"><a href="#A-f-08">A::f</a></h2>
+<h2 id="A-f-08">A::f</h2>
 <div>
 <span><code>f</code> overloads</span>
 
@@ -112,7 +112,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f-039"><a href="#A-f-039">A::f</a></h2>
+<h2 id="A-f-039">A::f</h2>
 <div>
 <span>Second overload</span>
 
@@ -132,7 +132,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f-01"><a href="#A-f-01">A::f</a></h2>
+<h2 id="A-f-01">A::f</h2>
 <div>
 <span>First overload</span>
 
@@ -152,7 +152,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f-037"><a href="#A-f-037">A::f</a></h2>
+<h2 id="A-f-037">A::f</h2>
 <div>
 <span>Third overload</span>
 
@@ -174,7 +174,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f-0f"><a href="#f-0f">f</a></h2>
+<h2 id="f-0f">f</h2>
 <div>
 <span>Local overload</span>
 
@@ -194,7 +194,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f-02"><a href="#f-02">f</a></h2>
+<h2 id="f-02">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/using/using-function-overloads.html b/test-files/golden-tests/symbols/using/using-function-overloads.html
index 6fc39e276..d8843388c 100644
--- a/test-files/golden-tests/symbols/using/using-function-overloads.html
+++ b/test-files/golden-tests/symbols/using/using-function-overloads.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -39,7 +39,7 @@ <h2>Using Declarations</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -58,7 +58,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-f-08"><a href="#A-f-08">A::f</a></h2>
+<h2 id="A-f-08">A::f</h2>
 <div>
 <span><code>f</code> overloads</span>
 
@@ -99,7 +99,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f-039"><a href="#A-f-039">A::f</a></h2>
+<h2 id="A-f-039">A::f</h2>
 <div>
 <span>Second overload</span>
 
@@ -119,7 +119,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f-01"><a href="#A-f-01">A::f</a></h2>
+<h2 id="A-f-01">A::f</h2>
 <div>
 <span>First overload</span>
 
@@ -139,7 +139,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f-037"><a href="#A-f-037">A::f</a></h2>
+<h2 id="A-f-037">A::f</h2>
 <div>
 <span>Third overload</span>
 
@@ -161,7 +161,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>Using the overloads from namespace A</span>
 
diff --git a/test-files/golden-tests/symbols/using/using-function.html b/test-files/golden-tests/symbols/using/using-function.html
index 86bfdedeb..0db8ae859 100644
--- a/test-files/golden-tests/symbols/using/using-function.html
+++ b/test-files/golden-tests/symbols/using/using-function.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -39,7 +39,7 @@ <h2>Using Declarations</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -58,7 +58,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-f"><a href="#A-f">A::f</a></h2>
+<h2 id="A-f">A::f</h2>
 <div>
 <span>Function being used</span>
 
@@ -78,7 +78,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 <div>
 <span>f is also available in the global namespace</span>
 
diff --git a/test-files/golden-tests/symbols/using/using-member-conversion.html b/test-files/golden-tests/symbols/using/using-member-conversion.html
index b82eeab5b..401abf5a7 100644
--- a/test-files/golden-tests/symbols/using/using-member-conversion.html
+++ b/test-files/golden-tests/symbols/using/using-member-conversion.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -28,7 +28,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="fun_ptr"><a href="#fun_ptr">fun_ptr</a></h2>
+<h2 id="fun_ptr">fun_ptr</h2>
 <div>
 <span>A pointer to function typedef</span>
 
@@ -47,7 +47,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="X"><a href="#X">X</a></h2>
+<h2 id="X">X</h2>
 <div>
 <span>This struct will be inherited as public</span>
 
@@ -97,7 +97,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="X-2conversion"><a href="#X-2conversion">X::operator fun_ptr</a></h2>
+<h2 id="X-2conversion">X::operator fun_ptr</h2>
 <div>
 <span>Conversion operator to function pointer.</span>
 
@@ -120,7 +120,7 @@ <h3>Return Value</h3>
 </div>
 <div>
 <div>
-<h2 id="Y"><a href="#Y">Y</a></h2>
+<h2 id="Y">Y</h2>
 <div>
 <span>This struct inherits from X</span>
 
@@ -184,7 +184,7 @@ <h2>Using Declarations</h2>
 </div>
 <div>
 <div>
-<h2 id="Y-2conversion"><a href="#Y-2conversion">Y::operator void(*)()</a></h2>
+<h2 id="Y-2conversion">Y::operator void(*)()</h2>
 <div>
 <span>Bring X::operator fun_ptr into Y.</span>
 
diff --git a/test-files/golden-tests/symbols/using/using-member-function.html b/test-files/golden-tests/symbols/using/using-member-function.html
index ffcb4752e..08320e940 100644
--- a/test-files/golden-tests/symbols/using/using-member-function.html
+++ b/test-files/golden-tests/symbols/using/using-member-function.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -33,7 +33,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 <div>
 <span>This struct will be inherited as public</span>
 
@@ -83,7 +83,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="A-f"><a href="#A-f">A::f</a></h2>
+<h2 id="A-f">A::f</h2>
 <div>
 <span>Public member function f taking a Tag&lt;0&gt;.</span>
 
@@ -107,7 +107,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 <div>
 <span>This struct will be inherited as public</span>
 
@@ -157,7 +157,7 @@ <h2>Derived Classes</h2>
 </div>
 <div>
 <div>
-<h2 id="B-f"><a href="#B-f">B::f</a></h2>
+<h2 id="B-f">B::f</h2>
 <div>
 <span>Protected member function f taking a Tag&lt;1&gt;.</span>
 
@@ -177,7 +177,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C"><a href="#C">C</a></h2>
+<h2 id="C">C</h2>
 <div>
 <span>This struct will be inherited as protected</span>
 
@@ -212,7 +212,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="C-f"><a href="#C-f">C::f</a></h2>
+<h2 id="C-f">C::f</h2>
 <div>
 <span>Public member function f taking a Tag&lt;2&gt;.</span>
 
@@ -232,7 +232,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="D"><a href="#D">D</a></h2>
+<h2 id="D">D</h2>
 <div>
 <span>This struct will be inherited as protected</span>
 
@@ -267,7 +267,7 @@ <h2>Protected Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="D-f"><a href="#D-f">D::f</a></h2>
+<h2 id="D-f">D::f</h2>
 <div>
 <span>Protected member function f taking a Tag&lt;3&gt;.</span>
 
@@ -287,7 +287,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="E"><a href="#E">E</a></h2>
+<h2 id="E">E</h2>
 <div>
 <span>This struct will be inherited as private</span>
 
@@ -322,7 +322,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="E-f"><a href="#E-f">E::f</a></h2>
+<h2 id="E-f">E::f</h2>
 <div>
 <span>Public member function f taking a Tag&lt;4&gt;.</span>
 
@@ -342,7 +342,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="F"><a href="#F">F</a></h2>
+<h2 id="F">F</h2>
 <div>
 <span>This struct will be inherited as private</span>
 
@@ -377,7 +377,7 @@ <h2>Protected Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="F-f"><a href="#F-f">F::f</a></h2>
+<h2 id="F-f">F::f</h2>
 <div>
 <span>Protected member function f taking a Tag&lt;5&gt;.</span>
 
@@ -397,7 +397,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Tag"><a href="#Tag">Tag</a></h2>
+<h2 id="Tag">Tag</h2>
 <div>
 <span>A tag template to create distinct f functions.</span>
 
@@ -419,7 +419,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="U"><a href="#U">U</a></h2>
+<h2 id="U">U</h2>
 <div>
 <span>This struct inherits from A, B, C, D, E, and F in various ways,</span>
 
@@ -531,7 +531,7 @@ <h3>Description</h3>
 </div>
 <div>
 <div>
-<h2 id="U-U-0a"><a href="#U-U-0a">U::U</a></h2>
+<h2 id="U-U-0a">U::U</h2>
 <div>
 <span>Bring all the A::A constructors into U.</span>
 
@@ -550,7 +550,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="U-U-01b"><a href="#U-U-01b">U::U</a></h2>
+<h2 id="U-U-01b">U::U</h2>
 <div>
 <span>Bring all the B::B constructors into U.</span>
 
@@ -569,7 +569,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="U-U-01d"><a href="#U-U-01d">U::U</a></h2>
+<h2 id="U-U-01d">U::U</h2>
 <div>
 <span>Bring all the C::C constructors into U.</span>
 
@@ -588,7 +588,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="U-U-0c"><a href="#U-U-0c">U::U</a></h2>
+<h2 id="U-U-0c">U::U</h2>
 <div>
 <span>Bring all the D::D constructors into U.</span>
 
@@ -607,7 +607,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="U-U-04"><a href="#U-U-04">U::U</a></h2>
+<h2 id="U-U-04">U::U</h2>
 <div>
 <span>Bring all the E::E constructors into U.</span>
 
@@ -626,7 +626,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="U-U-06"><a href="#U-U-06">U::U</a></h2>
+<h2 id="U-U-06">U::U</h2>
 <div>
 <span>Bring all the F::F constructors into U.</span>
 
@@ -645,7 +645,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="U-f-00c"><a href="#U-f-00c">U::f</a></h2>
+<h2 id="U-f-00c">U::f</h2>
 <div>
 <span>Bring all the A::f functions into U.</span>
 
@@ -682,7 +682,7 @@ <h3>Introduced Symbols</h3>
 </div>
 <div>
 <div>
-<h2 id="U-f-0be"><a href="#U-f-0be">U::f</a></h2>
+<h2 id="U-f-0be">U::f</h2>
 <div>
 <span>Bring all the B::f functions into U.</span>
 
@@ -719,7 +719,7 @@ <h3>Introduced Symbols</h3>
 </div>
 <div>
 <div>
-<h2 id="U-f-0f"><a href="#U-f-0f">U::f</a></h2>
+<h2 id="U-f-0f">U::f</h2>
 <div>
 <span>Bring all the C::f functions into U.</span>
 
@@ -756,7 +756,7 @@ <h3>Introduced Symbols</h3>
 </div>
 <div>
 <div>
-<h2 id="U-f-009"><a href="#U-f-009">U::f</a></h2>
+<h2 id="U-f-009">U::f</h2>
 <div>
 <span>Bring all the D::f functions into U.</span>
 
@@ -793,7 +793,7 @@ <h3>Introduced Symbols</h3>
 </div>
 <div>
 <div>
-<h2 id="U-f-0bd"><a href="#U-f-0bd">U::f</a></h2>
+<h2 id="U-f-0bd">U::f</h2>
 <div>
 <span>Bring all the E::f functions into U.</span>
 
@@ -830,7 +830,7 @@ <h3>Introduced Symbols</h3>
 </div>
 <div>
 <div>
-<h2 id="U-f-02"><a href="#U-f-02">U::f</a></h2>
+<h2 id="U-f-02">U::f</h2>
 <div>
 <span>Bring all the F::f functions into U.</span>
 
@@ -867,7 +867,7 @@ <h3>Introduced Symbols</h3>
 </div>
 <div>
 <div>
-<h2 id="U-f-07"><a href="#U-f-07">U::f</a></h2>
+<h2 id="U-f-07">U::f</h2>
 <div>
 <span><code>f</code> overloads</span>
 
@@ -906,7 +906,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="B-f"><a href="#B-f">B::f</a></h2>
+<h2 id="B-f">B::f</h2>
 <div>
 <span>Protected member function f taking a Tag&lt;1&gt;.</span>
 
@@ -926,7 +926,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="C-f"><a href="#C-f">C::f</a></h2>
+<h2 id="C-f">C::f</h2>
 <div>
 <span>Public member function f taking a Tag&lt;2&gt;.</span>
 
@@ -946,7 +946,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="D-f"><a href="#D-f">D::f</a></h2>
+<h2 id="D-f">D::f</h2>
 <div>
 <span>Protected member function f taking a Tag&lt;3&gt;.</span>
 
diff --git a/test-files/golden-tests/symbols/using/using-multi.html b/test-files/golden-tests/symbols/using/using-multi.html
index 0121adc1d..9c491c5bc 100644
--- a/test-files/golden-tests/symbols/using/using-multi.html
+++ b/test-files/golden-tests/symbols/using/using-multi.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -39,7 +39,7 @@ <h2>Using Declarations</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -58,7 +58,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-f"><a href="#A-f">A::f</a></h2>
+<h2 id="A-f">A::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -74,7 +74,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-g"><a href="#A-g">A::g</a></h2>
+<h2 id="A-g">A::g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -90,7 +90,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -121,7 +121,7 @@ <h3>Introduced Symbols</h3>
 </div>
 <div>
 <div>
-<h2 id="g"><a href="#g">g</a></h2>
+<h2 id="g">g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/using/using-struct-template.html b/test-files/golden-tests/symbols/using/using-struct-template.html
index f4a3bb66a..595ab3f20 100644
--- a/test-files/golden-tests/symbols/using/using-struct-template.html
+++ b/test-files/golden-tests/symbols/using/using-struct-template.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -39,7 +39,7 @@ <h2>Using Declarations</h2>
 </div>
 <div>
 <div>
-<h2 id="LongName"><a href="#LongName">LongName</a></h2>
+<h2 id="LongName">LongName</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -58,7 +58,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="LongName-S1"><a href="#LongName-S1">LongName::S1</a></h2>
+<h2 id="LongName-S1">LongName::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -75,7 +75,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="LongName-S2"><a href="#LongName-S2">LongName::S2</a></h2>
+<h2 id="LongName-S2">LongName::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -92,7 +92,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S1"><a href="#S1">S1</a></h2>
+<h2 id="S1">S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -123,7 +123,7 @@ <h3>Introduced Symbols</h3>
 </div>
 <div>
 <div>
-<h2 id="S2"><a href="#S2">S2</a></h2>
+<h2 id="S2">S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/using/using-struct.html b/test-files/golden-tests/symbols/using/using-struct.html
index 69469395c..ab8036949 100644
--- a/test-files/golden-tests/symbols/using/using-struct.html
+++ b/test-files/golden-tests/symbols/using/using-struct.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -39,7 +39,7 @@ <h2>Using Declarations</h2>
 </div>
 <div>
 <div>
-<h2 id="LongName"><a href="#LongName">LongName</a></h2>
+<h2 id="LongName">LongName</h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -58,7 +58,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="LongName-S1"><a href="#LongName-S1">LongName::S1</a></h2>
+<h2 id="LongName-S1">LongName::S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -75,7 +75,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="LongName-S2"><a href="#LongName-S2">LongName::S2</a></h2>
+<h2 id="LongName-S2">LongName::S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -92,7 +92,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="S1"><a href="#S1">S1</a></h2>
+<h2 id="S1">S1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -123,7 +123,7 @@ <h3>Introduced Symbols</h3>
 </div>
 <div>
 <div>
-<h2 id="S2"><a href="#S2">S2</a></h2>
+<h2 id="S2">S2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/using/using-template-function.html b/test-files/golden-tests/symbols/using/using-template-function.html
index 13e14bf13..9b429bb33 100644
--- a/test-files/golden-tests/symbols/using/using-template-function.html
+++ b/test-files/golden-tests/symbols/using/using-template-function.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Namespaces</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -38,7 +38,7 @@ <h2>Using Declarations</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -56,7 +56,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-f"><a href="#A-f">A::f</a></h2>
+<h2 id="A-f">A::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -72,7 +72,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/using/using-typename.html b/test-files/golden-tests/symbols/using/using-typename.html
index 5b9d4db99..78afc6b1e 100644
--- a/test-files/golden-tests/symbols/using/using-typename.html
+++ b/test-files/golden-tests/symbols/using/using-typename.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="Base"><a href="#Base">Base</a></h2>
+<h2 id="Base">Base</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -57,7 +57,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="Base-V"><a href="#Base-V">Base::V</a></h2>
+<h2 id="Base-V">Base::V</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -72,7 +72,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="Derived"><a href="#Derived">Derived</a></h2>
+<h2 id="Derived">Derived</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/variable/no_unique_address.html b/test-files/golden-tests/symbols/variable/no_unique_address.html
index 5cd49f86e..cfd38a0b4 100644
--- a/test-files/golden-tests/symbols/variable/no_unique_address.html
+++ b/test-files/golden-tests/symbols/variable/no_unique_address.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="Empty"><a href="#Empty">Empty</a></h2>
+<h2 id="Empty">Empty</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -43,7 +43,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T"><a href="#T">T</a></h2>
+<h2 id="T">T</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -74,7 +74,7 @@ <h2>Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="T-e"><a href="#T-e">T::e</a></h2>
+<h2 id="T-e">T::e</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -90,7 +90,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T-i"><a href="#T-i">T::i</a></h2>
+<h2 id="T-i">T::i</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/variable/ns-variables.html b/test-files/golden-tests/symbols/variable/ns-variables.html
index e788cec13..60f0156a8 100644
--- a/test-files/golden-tests/symbols/variable/ns-variables.html
+++ b/test-files/golden-tests/symbols/variable/ns-variables.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -46,7 +46,7 @@ <h2>Variables</h2>
 </div>
 <div>
 <div>
-<h2 id="T"><a href="#T">T</a></h2>
+<h2 id="T">T</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -63,7 +63,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="i"><a href="#i">i</a></h2>
+<h2 id="i">i</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -78,7 +78,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="j"><a href="#j">j</a></h2>
+<h2 id="j">j</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -93,7 +93,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="k"><a href="#k">k</a></h2>
+<h2 id="k">k</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -109,7 +109,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="l"><a href="#l">l</a></h2>
+<h2 id="l">l</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -125,7 +125,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="pi"><a href="#pi">pi</a></h2>
+<h2 id="pi">pi</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -140,7 +140,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="t"><a href="#t">t</a></h2>
+<h2 id="t">t</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -156,7 +156,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="x0"><a href="#x0">x0</a></h2>
+<h2 id="x0">x0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -172,7 +172,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="x1"><a href="#x1">x1</a></h2>
+<h2 id="x1">x1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -189,7 +189,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="x2"><a href="#x2">x2</a></h2>
+<h2 id="x2">x2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/variable/static-data-def-constexpr.html b/test-files/golden-tests/symbols/variable/static-data-def-constexpr.html
index 63e73c399..c72e144fd 100644
--- a/test-files/golden-tests/symbols/variable/static-data-def-constexpr.html
+++ b/test-files/golden-tests/symbols/variable/static-data-def-constexpr.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="S"><a href="#S">S</a></h2>
+<h2 id="S">S</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -56,7 +56,7 @@ <h2>Static Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="S-s"><a href="#S-s">S::s</a></h2>
+<h2 id="S-s">S::s</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -72,7 +72,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="T"><a href="#T">T</a></h2>
+<h2 id="T">T</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -102,7 +102,7 @@ <h2>Static Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="T-t"><a href="#T-t">T::t</a></h2>
+<h2 id="T-t">T::t</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/variable/static-data-def.html b/test-files/golden-tests/symbols/variable/static-data-def.html
index 9e0be09e8..18df33ed5 100644
--- a/test-files/golden-tests/symbols/variable/static-data-def.html
+++ b/test-files/golden-tests/symbols/variable/static-data-def.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -39,7 +39,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -77,7 +77,7 @@ <h2>Static Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="A-v0"><a href="#A-v0">A::v0</a></h2>
+<h2 id="A-v0">A::v0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -93,7 +93,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-v1"><a href="#A-v1">A::v1</a></h2>
+<h2 id="A-v1">A::v1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -109,7 +109,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-v2"><a href="#A-v2">A::v2</a></h2>
+<h2 id="A-v2">A::v2</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -125,7 +125,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-v3"><a href="#A-v3">A::v3</a></h2>
+<h2 id="A-v3">A::v3</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -141,7 +141,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-v4"><a href="#A-v4">A::v4</a></h2>
+<h2 id="A-v4">A::v4</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -157,7 +157,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-v5"><a href="#A-v5">A::v5</a></h2>
+<h2 id="A-v5">A::v5</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -173,7 +173,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-v6"><a href="#A-v6">A::v6</a></h2>
+<h2 id="A-v6">A::v6</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -189,7 +189,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-v7"><a href="#A-v7">A::v7</a></h2>
+<h2 id="A-v7">A::v7</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -205,7 +205,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -236,7 +236,7 @@ <h2>Static Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="B-x0"><a href="#B-x0">B::x0</a></h2>
+<h2 id="B-x0">B::x0</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -253,7 +253,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-x1"><a href="#B-x1">B::x1</a></h2>
+<h2 id="B-x1">B::x1</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -270,7 +270,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f"><a href="#f">f</a></h2>
+<h2 id="f">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/variable/static-data-template.html b/test-files/golden-tests/symbols/variable/static-data-template.html
index be9d5afc7..8b201ee43 100644
--- a/test-files/golden-tests/symbols/variable/static-data-template.html
+++ b/test-files/golden-tests/symbols/variable/static-data-template.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -58,7 +58,7 @@ <h2>Static Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="A-x-05"><a href="#A-x-05">A::x</a></h2>
+<h2 id="A-x-05">A::x</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -77,7 +77,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-x-07"><a href="#A-x-07">A::x&lt;T, long&gt;</a></h2>
+<h2 id="A-x-07">A::x&lt;T, long&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -94,7 +94,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-x-0a"><a href="#A-x-0a">A::x&lt;U*, T&gt;</a></h2>
+<h2 id="A-x-0a">A::x&lt;U*, T&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/variable/var-inline-constexpr.html b/test-files/golden-tests/symbols/variable/var-inline-constexpr.html
index 3dcdf74b1..a2dbe268b 100644
--- a/test-files/golden-tests/symbols/variable/var-inline-constexpr.html
+++ b/test-files/golden-tests/symbols/variable/var-inline-constexpr.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Variables</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -34,7 +34,7 @@ <h2>Variables</h2>
 </div>
 <div>
 <div>
-<h2 id="var"><a href="#var">var</a></h2>
+<h2 id="var">var</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -49,7 +49,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="var_const"><a href="#var_const">var_const</a></h2>
+<h2 id="var_const">var_const</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -64,7 +64,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="var_const_t"><a href="#var_const_t">var_const_t</a></h2>
+<h2 id="var_const_t">var_const_t</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -80,7 +80,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="var_constexpr"><a href="#var_constexpr">var_constexpr</a></h2>
+<h2 id="var_constexpr">var_constexpr</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -95,7 +95,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="var_constexpr_t"><a href="#var_constexpr_t">var_constexpr_t</a></h2>
+<h2 id="var_constexpr_t">var_constexpr_t</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -111,7 +111,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="var_inline_const"><a href="#var_inline_const">var_inline_const</a></h2>
+<h2 id="var_inline_const">var_inline_const</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -126,7 +126,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="var_inline_const_t"><a href="#var_inline_const_t">var_inline_const_t</a></h2>
+<h2 id="var_inline_const_t">var_inline_const_t</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -142,7 +142,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="var_inline_constexpr"><a href="#var_inline_constexpr">var_inline_constexpr</a></h2>
+<h2 id="var_inline_constexpr">var_inline_constexpr</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -157,7 +157,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="var_inline_constexpr_t"><a href="#var_inline_constexpr_t">var_inline_constexpr_t</a></h2>
+<h2 id="var_inline_constexpr_t">var_inline_constexpr_t</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -173,7 +173,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="var_t"><a href="#var_t">var_t</a></h2>
+<h2 id="var_t">var_t</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/symbols/variable/var-template.html b/test-files/golden-tests/symbols/variable/var-template.html
index e25cd2f9a..ea25d99e2 100644
--- a/test-files/golden-tests/symbols/variable/var-template.html
+++ b/test-files/golden-tests/symbols/variable/var-template.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -40,7 +40,7 @@ <h2>Variables</h2>
 </div>
 <div>
 <div>
-<h2 id="B"><a href="#B">B</a></h2>
+<h2 id="B">B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -72,7 +72,7 @@ <h2>Static Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="B-C-09"><a href="#B-C-09">B::C</a></h2>
+<h2 id="B-C-09">B::C</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -89,7 +89,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-C-05"><a href="#B-C-05">B::C&lt;int&gt;</a></h2>
+<h2 id="B-C-05">B::C&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -106,7 +106,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="B-C-0c"><a href="#B-C-0c">B::C&lt;T*&gt;</a></h2>
+<h2 id="B-C-0c">B::C&lt;T*&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -123,7 +123,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-0c"><a href="#A-0c">A</a></h2>
+<h2 id="A-0c">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -139,7 +139,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-08"><a href="#A-08">A&lt;void&gt;</a></h2>
+<h2 id="A-08">A&lt;void&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -155,7 +155,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-01"><a href="#A-01">A&lt;T&&gt;</a></h2>
+<h2 id="A-01">A&lt;T&&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/templates/c_mct_expl_inline.html b/test-files/golden-tests/templates/c_mct_expl_inline.html
index dddaab5b2..e1890e8d6 100644
--- a/test-files/golden-tests/templates/c_mct_expl_inline.html
+++ b/test-files/golden-tests/templates/c_mct_expl_inline.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -56,7 +56,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-B-04"><a href="#A-B-04">A::B</a></h2>
+<h2 id="A-B-04">A::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -87,7 +87,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-B-04-f"><a href="#A-B-04-f">A::B::f</a></h2>
+<h2 id="A-B-04-f">A::B::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -103,7 +103,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-B-01"><a href="#A-B-01">A::B&lt;int&gt;</a></h2>
+<h2 id="A-B-01">A::B&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -134,7 +134,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-B-01-g"><a href="#A-B-01-g">A::B&lt;int&gt;::g</a></h2>
+<h2 id="A-B-01-g">A::B&lt;int&gt;::g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/templates/c_mct_expl_outside.html b/test-files/golden-tests/templates/c_mct_expl_outside.html
index 5bbddc336..6b8fcd3de 100644
--- a/test-files/golden-tests/templates/c_mct_expl_outside.html
+++ b/test-files/golden-tests/templates/c_mct_expl_outside.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -56,7 +56,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-B-04"><a href="#A-B-04">A::B</a></h2>
+<h2 id="A-B-04">A::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -87,7 +87,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-B-04-f"><a href="#A-B-04-f">A::B::f</a></h2>
+<h2 id="A-B-04-f">A::B::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -103,7 +103,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-B-01"><a href="#A-B-01">A::B&lt;int&gt;</a></h2>
+<h2 id="A-B-01">A::B&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -134,7 +134,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-B-01-g"><a href="#A-B-01-g">A::B&lt;int&gt;::g</a></h2>
+<h2 id="A-B-01-g">A::B&lt;int&gt;::g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/templates/c_mft_expl_inline.html b/test-files/golden-tests/templates/c_mft_expl_inline.html
index 264af1109..f310f8428 100644
--- a/test-files/golden-tests/templates/c_mft_expl_inline.html
+++ b/test-files/golden-tests/templates/c_mft_expl_inline.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -56,7 +56,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-f-07"><a href="#A-f-07">A::f</a></h2>
+<h2 id="A-f-07">A::f</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -85,7 +85,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f-0e"><a href="#A-f-0e">A::f</a></h2>
+<h2 id="A-f-0e">A::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -102,7 +102,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f-0b"><a href="#A-f-0b">A::f&lt;int&gt;</a></h2>
+<h2 id="A-f-0b">A::f&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/templates/c_mft_expl_outside.html b/test-files/golden-tests/templates/c_mft_expl_outside.html
index a80adc249..2e5d76e68 100644
--- a/test-files/golden-tests/templates/c_mft_expl_outside.html
+++ b/test-files/golden-tests/templates/c_mft_expl_outside.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -56,7 +56,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-f-07"><a href="#A-f-07">A::f</a></h2>
+<h2 id="A-f-07">A::f</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -85,7 +85,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f-0e"><a href="#A-f-0e">A::f</a></h2>
+<h2 id="A-f-0e">A::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -102,7 +102,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f-0b"><a href="#A-f-0b">A::f&lt;int&gt;</a></h2>
+<h2 id="A-f-0b">A::f&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/templates/ct_expl.html b/test-files/golden-tests/templates/ct_expl.html
index 6f02c6102..b5b3c3979 100644
--- a/test-files/golden-tests/templates/ct_expl.html
+++ b/test-files/golden-tests/templates/ct_expl.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e"><a href="#A-0e">A</a></h2>
+<h2 id="A-0e">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -57,7 +57,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e-f"><a href="#A-0e-f">A::f</a></h2>
+<h2 id="A-0e-f">A::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -73,7 +73,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-00"><a href="#A-00">A&lt;int&gt;</a></h2>
+<h2 id="A-00">A&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -104,7 +104,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-00-g"><a href="#A-00-g">A&lt;int&gt;::g</a></h2>
+<h2 id="A-00-g">A&lt;int&gt;::g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/templates/ct_expl_dependency.html b/test-files/golden-tests/templates/ct_expl_dependency.html
index 91b681dc6..c54867004 100644
--- a/test-files/golden-tests/templates/ct_expl_dependency.html
+++ b/test-files/golden-tests/templates/ct_expl_dependency.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A&lt;int&gt;</a></h2>
+<h2 id="A">A&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -56,7 +56,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-g"><a href="#A-g">A&lt;int&gt;::g</a></h2>
+<h2 id="A-g">A&lt;int&gt;::g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/templates/ct_mc.html b/test-files/golden-tests/templates/ct_mc.html
index 29d7003bc..b9bb24124 100644
--- a/test-files/golden-tests/templates/ct_mc.html
+++ b/test-files/golden-tests/templates/ct_mc.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -56,7 +56,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-B"><a href="#A-B">A::B</a></h2>
+<h2 id="A-B">A::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -86,7 +86,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-B-f"><a href="#A-B-f">A::B::f</a></h2>
+<h2 id="A-B-f">A::B::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/templates/ct_mc_expl_outside.html b/test-files/golden-tests/templates/ct_mc_expl_outside.html
index 5c9db023e..9af63d53c 100644
--- a/test-files/golden-tests/templates/ct_mc_expl_outside.html
+++ b/test-files/golden-tests/templates/ct_mc_expl_outside.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e"><a href="#A-0e">A</a></h2>
+<h2 id="A-0e">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -57,7 +57,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e-B"><a href="#A-0e-B">A::B</a></h2>
+<h2 id="A-0e-B">A::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -87,7 +87,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e-B-f"><a href="#A-0e-B-f">A::B::f</a></h2>
+<h2 id="A-0e-B-f">A::B::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -103,7 +103,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-00"><a href="#A-00">A&lt;int&gt;</a></h2>
+<h2 id="A-00">A&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -134,7 +134,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-00-B"><a href="#A-00-B">A&lt;int&gt;::B</a></h2>
+<h2 id="A-00-B">A&lt;int&gt;::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -164,7 +164,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-00-B-g"><a href="#A-00-B-g">A&lt;int&gt;::B::g</a></h2>
+<h2 id="A-00-B-g">A&lt;int&gt;::B::g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/templates/ct_mct.html b/test-files/golden-tests/templates/ct_mct.html
index 6e0259eb8..2bc7614d4 100644
--- a/test-files/golden-tests/templates/ct_mct.html
+++ b/test-files/golden-tests/templates/ct_mct.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -56,7 +56,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-B"><a href="#A-B">A::B</a></h2>
+<h2 id="A-B">A::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -87,7 +87,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-B-f"><a href="#A-B-f">A::B::f</a></h2>
+<h2 id="A-B-f">A::B::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/templates/ct_mct_expl_inline.html b/test-files/golden-tests/templates/ct_mct_expl_inline.html
index 3b303dbac..ec0559aa8 100644
--- a/test-files/golden-tests/templates/ct_mct_expl_inline.html
+++ b/test-files/golden-tests/templates/ct_mct_expl_inline.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -57,7 +57,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-B-07"><a href="#A-B-07">A::B</a></h2>
+<h2 id="A-B-07">A::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -88,7 +88,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-B-07-f"><a href="#A-B-07-f">A::B::f</a></h2>
+<h2 id="A-B-07-f">A::B::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -104,7 +104,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-B-06"><a href="#A-B-06">A::B&lt;int&gt;</a></h2>
+<h2 id="A-B-06">A::B&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -135,7 +135,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-B-06-g"><a href="#A-B-06-g">A::B&lt;int&gt;::g</a></h2>
+<h2 id="A-B-06-g">A::B&lt;int&gt;::g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/templates/ct_mct_expl_outside.html b/test-files/golden-tests/templates/ct_mct_expl_outside.html
index eac5dd41a..2b3aa4109 100644
--- a/test-files/golden-tests/templates/ct_mct_expl_outside.html
+++ b/test-files/golden-tests/templates/ct_mct_expl_outside.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e"><a href="#A-0e">A</a></h2>
+<h2 id="A-0e">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -57,7 +57,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e-B"><a href="#A-0e-B">A::B</a></h2>
+<h2 id="A-0e-B">A::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -88,7 +88,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e-B-f"><a href="#A-0e-B-f">A::B::f</a></h2>
+<h2 id="A-0e-B-f">A::B::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -104,7 +104,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-00"><a href="#A-00">A&lt;int&gt;</a></h2>
+<h2 id="A-00">A&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -136,7 +136,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-00-B-03"><a href="#A-00-B-03">A&lt;int&gt;::B</a></h2>
+<h2 id="A-00-B-03">A&lt;int&gt;::B</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -154,7 +154,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-00-B-02"><a href="#A-00-B-02">A&lt;int&gt;::B&lt;int&gt;</a></h2>
+<h2 id="A-00-B-02">A&lt;int&gt;::B&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -185,7 +185,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-00-B-02-g"><a href="#A-00-B-02-g">A&lt;int&gt;::B&lt;int&gt;::g</a></h2>
+<h2 id="A-00-B-02-g">A&lt;int&gt;::B&lt;int&gt;::g</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/templates/ct_mf.html b/test-files/golden-tests/templates/ct_mf.html
index 7f8d1cf49..89e884c26 100644
--- a/test-files/golden-tests/templates/ct_mf.html
+++ b/test-files/golden-tests/templates/ct_mf.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -56,7 +56,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-f"><a href="#A-f">A::f</a></h2>
+<h2 id="A-f">A::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/templates/ct_mf_expl_outside.html b/test-files/golden-tests/templates/ct_mf_expl_outside.html
index 6e908420e..a6646dcae 100644
--- a/test-files/golden-tests/templates/ct_mf_expl_outside.html
+++ b/test-files/golden-tests/templates/ct_mf_expl_outside.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e"><a href="#A-0e">A</a></h2>
+<h2 id="A-0e">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -57,7 +57,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e-f"><a href="#A-0e-f">A::f</a></h2>
+<h2 id="A-0e-f">A::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -73,7 +73,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-00"><a href="#A-00">A&lt;int&gt;</a></h2>
+<h2 id="A-00">A&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -104,7 +104,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-00-f"><a href="#A-00-f">A&lt;int&gt;::f</a></h2>
+<h2 id="A-00-f">A&lt;int&gt;::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/templates/ct_mft.html b/test-files/golden-tests/templates/ct_mft.html
index 7a4d4157f..22a329503 100644
--- a/test-files/golden-tests/templates/ct_mft.html
+++ b/test-files/golden-tests/templates/ct_mft.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -56,7 +56,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-f"><a href="#A-f">A::f</a></h2>
+<h2 id="A-f">A::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/templates/ct_mft_expl_inline.html b/test-files/golden-tests/templates/ct_mft_expl_inline.html
index 3ecdab504..cac28653c 100644
--- a/test-files/golden-tests/templates/ct_mft_expl_inline.html
+++ b/test-files/golden-tests/templates/ct_mft_expl_inline.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -25,7 +25,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A"><a href="#A">A</a></h2>
+<h2 id="A">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -57,7 +57,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-f-00"><a href="#A-f-00">A::f</a></h2>
+<h2 id="A-f-00">A::f</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -86,7 +86,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f-07"><a href="#A-f-07">A::f</a></h2>
+<h2 id="A-f-07">A::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -103,7 +103,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-f-04"><a href="#A-f-04">A::f&lt;int&gt;</a></h2>
+<h2 id="A-f-04">A::f&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/templates/ct_mft_expl_outside.html b/test-files/golden-tests/templates/ct_mft_expl_outside.html
index 5ba55f9b4..f8b19fbd5 100644
--- a/test-files/golden-tests/templates/ct_mft_expl_outside.html
+++ b/test-files/golden-tests/templates/ct_mft_expl_outside.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Types</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Types</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e"><a href="#A-0e">A</a></h2>
+<h2 id="A-0e">A</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -57,7 +57,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-0e-f"><a href="#A-0e-f">A::f</a></h2>
+<h2 id="A-0e-f">A::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -74,7 +74,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-00"><a href="#A-00">A&lt;int&gt;</a></h2>
+<h2 id="A-00">A&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -106,7 +106,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="A-00-f-0a"><a href="#A-00-f-0a">A&lt;int&gt;::f</a></h2>
+<h2 id="A-00-f-0a">A&lt;int&gt;::f</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -135,7 +135,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="A-00-f-03"><a href="#A-00-f-03">A&lt;int&gt;::f</a></h2>
+<h2 id="A-00-f-03">A&lt;int&gt;::f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -152,7 +152,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="A-00-f-07"><a href="#A-00-f-07">A&lt;int&gt;::f&lt;int&gt;</a></h2>
+<h2 id="A-00-f-07">A&lt;int&gt;::f&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
diff --git a/test-files/golden-tests/templates/ft_expl.html b/test-files/golden-tests/templates/ft_expl.html
index 4ab21409b..9b51b74cc 100644
--- a/test-files/golden-tests/templates/ft_expl.html
+++ b/test-files/golden-tests/templates/ft_expl.html
@@ -7,7 +7,7 @@
 <h1>Reference</h1>
 <div>
 <div>
-<h2 id="index"><a href="#index"></a></h2>
+<h2 id="index"></h2>
 </div>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
@@ -26,7 +26,7 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="f-0c7"><a href="#f-0c7">f</a></h2>
+<h2 id="f-0c7">f</h2>
 </div>
 <div>
 <h3>Synopses</h3>
@@ -55,7 +55,7 @@ <h3>Synopses</h3>
 </div>
 <div>
 <div>
-<h2 id="f-03"><a href="#f-03">f</a></h2>
+<h2 id="f-03">f</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -72,7 +72,7 @@ <h3>Synopsis</h3>
 </div>
 <div>
 <div>
-<h2 id="f-0ca"><a href="#f-0ca">f&lt;int&gt;</a></h2>
+<h2 id="f-0ca">f&lt;int&gt;</h2>
 </div>
 <div>
 <h3>Synopsis</h3>

From 2e531aa4fc2196641b6899f5d8b36e9908df65de Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Thu, 25 Sep 2025 01:14:25 -0500
Subject: [PATCH 09/23] refactor(lib): use mrdocs::Optional in public API

Use mrdocs::Optional throughout the public API for consistency and extensibility, including the optional reference return types.
---
 include/mrdocs/ADT/Nullable.hpp               |   1 +
 include/mrdocs/ADT/Optional.hpp               | 392 ++++++++++++++----
 include/mrdocs/Dom/Value.hpp                  |  16 +
 include/mrdocs/Metadata/Expression.hpp        |   3 +-
 include/mrdocs/Metadata/Info/Concept.hpp      |   3 +-
 include/mrdocs/Metadata/Info/Function.hpp     |   3 +-
 include/mrdocs/Metadata/Info/Guide.hpp        |   3 +-
 include/mrdocs/Metadata/Info/InfoBase.hpp     |   2 +-
 include/mrdocs/Metadata/Info/Record.hpp       |   3 +-
 include/mrdocs/Metadata/Info/Typedef.hpp      |   3 +-
 include/mrdocs/Metadata/Info/Variable.hpp     |   3 +-
 include/mrdocs/Metadata/Javadoc.hpp           |   2 +-
 include/mrdocs/Metadata/Javadoc/Inline.hpp    |   2 +-
 .../Metadata/Specifiers/OperatorKind.hpp      |   3 +-
 include/mrdocs/Metadata/Template.hpp          |   6 +-
 include/mrdocs/Metadata/Type.hpp              |   4 +-
 .../mrdocs/Metadata/Type/NamedTypeInfo.hpp    |   2 +-
 include/mrdocs/Support/Glob.hpp               |   7 +-
 src/lib/AST/ASTVisitor.cpp                    |  24 +-
 src/lib/AST/ASTVisitor.hpp                    |  24 +-
 src/lib/AST/ClangHelpers.cpp                  |   4 +-
 src/lib/AST/ClangHelpers.hpp                  |   4 +-
 src/lib/AST/MrDocsFileSystem.hpp              |   2 +-
 src/lib/AST/NameInfoBuilder.cpp               |   4 +-
 src/lib/AST/NameInfoBuilder.hpp               |   4 +-
 src/lib/AST/ParseJavadoc.cpp                  |   4 +-
 src/lib/AST/ParseJavadoc.hpp                  |   2 +-
 src/lib/AST/ParseRef.cpp                      |   6 +-
 src/lib/AST/TerminalTypeVisitor.hpp           |   6 +-
 src/lib/AST/TypeInfoBuilder.cpp               |   6 +-
 src/lib/AST/TypeInfoBuilder.hpp               |   4 +-
 src/lib/CorpusImpl.cpp                        |   2 +-
 src/lib/Gen/adoc/AdocEscape.cpp               |   2 +-
 src/lib/Gen/hbs/SinglePageVisitor.hpp         |   2 +-
 src/lib/Gen/hbs/VisitorHelpers.cpp            |   4 +-
 src/lib/Gen/xml/XMLWriter.cpp                 |   6 +-
 src/lib/Gen/xml/XMLWriter.hpp                 |   6 +-
 .../Metadata/Finalizers/Javadoc/Function.hpp  |   4 +-
 .../Metadata/Finalizers/JavadocFinalizer.cpp  |   2 +-
 .../Finalizers/SortMembersFinalizer.cpp       |  16 +-
 src/lib/Metadata/Info/Function.cpp            |   2 +-
 src/lib/Metadata/Type.cpp                     |   6 +-
 src/lib/Support/Glob.cpp                      |   6 +-
 src/lib/Support/Handlebars.cpp                |   2 +-
 src/lib/Support/Report.cpp                    |  11 +-
 src/test/ADT/Optional.cpp                     |   2 +-
 src/test/lib/Dom/Dom.cpp                      |   6 +-
 src/test/lib/Support/Handlebars.cpp           |   8 +-
 src/tool/CompilerInfo.cpp                     |   2 +-
 src/tool/CompilerInfo.hpp                     |   5 +-
 50 files changed, 457 insertions(+), 189 deletions(-)

diff --git a/include/mrdocs/ADT/Nullable.hpp b/include/mrdocs/ADT/Nullable.hpp
index bd5038402..c27fdf95f 100644
--- a/include/mrdocs/ADT/Nullable.hpp
+++ b/include/mrdocs/ADT/Nullable.hpp
@@ -92,6 +92,7 @@ struct sentinel_traits<std::nullptr_t>
     which corresponds to -1 when converted.
 **/
 template <std::unsigned_integral T>
+requires (!std::same_as<T, bool>)
 struct sentinel_traits<T>
 {
     static constexpr T
diff --git a/include/mrdocs/ADT/Optional.hpp b/include/mrdocs/ADT/Optional.hpp
index a898114c9..a743fb9c4 100644
--- a/include/mrdocs/ADT/Optional.hpp
+++ b/include/mrdocs/ADT/Optional.hpp
@@ -22,6 +22,38 @@
 
 namespace clang::mrdocs {
 
+template <class T>
+class Optional;
+
+namespace detail {
+template <typename T, typename U>
+using ConvertsFromAnyCvRef = std::disjunction<
+    std::is_constructible<T, U&>,
+    std::is_convertible<U&, T>,
+    std::is_constructible<T, U>,
+    std::is_convertible<U, T>,
+    std::is_constructible<T, U const&>,
+    std::is_convertible<U const&, T>,
+    std::is_constructible<T, U const>,
+    std::is_convertible<U const, T>>;
+
+template <typename T, typename U>
+using ConvertsFromOptional = ConvertsFromAnyCvRef<T, Optional<U>>;
+
+template <typename T, typename U>
+using AssignsFromOptional = std::disjunction<
+    std::is_assignable<T&, Optional<U> const&>,
+    std::is_assignable<T&, Optional<U>&>,
+    std::is_assignable<T&, Optional<U> const&&>,
+    std::is_assignable<T&, Optional<U>&&>>;
+
+template<typename T>
+inline constexpr bool isOptionalV = false;
+
+template<typename T>
+inline constexpr bool isOptionalV<Optional<T>> = true;
+}
+
 /** A compact optional that automatically uses nullable_traits<T> when
     available.
 
@@ -66,6 +98,23 @@ class Optional {
             return noexcept(std::declval<std::optional<T> const&>().has_value());
     }
 
+    template<typename From, typename = std::remove_cv_t<T>>
+    static constexpr bool NotConstructingBoolFromOptional
+        = true;
+
+    template <typename From>
+    static constexpr bool NotConstructingBoolFromOptional<From, bool>
+        = !detail::isOptionalV<std::remove_cvref_t<From>>;
+
+    template<typename From, typename = std::remove_cv_t<T>>
+    static constexpr bool ConstructFromContainedValue
+        = !detail::ConvertsFromOptional<T, From>::value;
+
+    template<typename From>
+    static constexpr bool ConstructFromContainedValue<From, bool>
+        = true;
+
+
     storage_t s_;
 
 public:
@@ -95,26 +144,17 @@ class Optional {
     /// Move constructor
     constexpr Optional(Optional&&) = default;
 
-    /// Copy assignment
-    constexpr Optional&
-    operator=(Optional const&) = default;
-
-    /// Move assignment
-    constexpr Optional&
-    operator=(Optional&&) = default;
-
     /** Construct from a value.
 
         @param u The value to store. It must be convertible to T.
      **/
-    template <class U>
-    requires(
-        !std::same_as<std::remove_cvref_t<U>, Optional>
-        && !std::same_as<std::remove_cvref_t<U>, std::in_place_t>
-        && !std::same_as<std::remove_cvref_t<U>, std::nullopt_t>
-        && std::is_constructible_v<T, U>)
-    constexpr explicit Optional(U&& u) noexcept(
-        std::is_nothrow_constructible_v<T, U>)
+    template <typename U = std::remove_cv_t<T>>
+    requires(!std::is_same_v<Optional, std::remove_cvref_t<U>>)
+            && (!std::is_same_v<std::in_place_t, std::remove_cvref_t<U>>)
+            && std::is_constructible_v<T, U>
+            && NotConstructingBoolFromOptional<U>
+    constexpr explicit(!std::is_convertible_v<U, T>)
+    Optional(U&& u) noexcept(std::is_nothrow_constructible_v<T, U>)
         : s_([&] {
             if constexpr (uses_nullable_traits)
             {
@@ -126,34 +166,223 @@ class Optional {
         }())
     {}
 
+    template <typename U>
+    requires(!std::is_same_v<T, U>) && std::is_constructible_v<T, U const&>
+            && ConstructFromContainedValue<U>
+    constexpr explicit(!std::is_convertible_v<U const&, T>)
+    Optional(Optional<U> const& t) noexcept(std::is_nothrow_constructible_v<T, U const&>)
+        : s_([&] {
+            if constexpr (uses_nullable_traits)
+            {
+                if (t)
+                    return storage_t(static_cast<T>(*t));
+                else
+                    return storage_t(nullable_traits<T>::null());
+            } else
+            {
+                if (t)
+                    return storage_t(*t);
+                else
+                    return storage_t(std::nullopt);
+            }
+        }())
+    {}
+
+    template <typename U>
+    requires(!std::is_same_v<T, U>)
+            && std::is_constructible_v<T, U> && ConstructFromContainedValue<U>
+    constexpr explicit(!std::is_convertible_v<U, T>)
+    Optional(Optional<U>&& t) noexcept(std::is_nothrow_constructible_v<T, U>)
+        : s_([&] {
+            if constexpr (uses_nullable_traits)
+            {
+                if (t)
+                    return storage_t(static_cast<T>(std::move(*t)));
+                else
+                    return storage_t(nullable_traits<T>::null());
+            } else
+            {
+                if (t)
+                    return storage_t(std::move(*t));
+                else
+                    return storage_t(std::nullopt);
+            }
+        }())
+    {}
+
+    template <typename U>
+    requires
+        std::is_constructible_v<T, U const&> &&
+        ConstructFromContainedValue<U>
+    constexpr explicit(!std::is_convertible_v<U const&, T>)
+    Optional(std::optional<U> const& t) noexcept(std::is_nothrow_constructible_v<T, U const&>)
+        : s_([&] {
+            if constexpr (uses_nullable_traits)
+            {
+                if (t)
+                    return storage_t(static_cast<T>(*t));
+                else
+                    return storage_t(nullable_traits<T>::null());
+            } else
+            {
+                if (t)
+                    return storage_t(*t);
+                else
+                    return storage_t(std::nullopt);
+            }
+        }())
+    {}
+
+    template <typename U>
+    requires
+        std::is_constructible_v<T, U> &&
+        ConstructFromContainedValue<U>
+    constexpr explicit(!std::is_convertible_v<U, T>)
+    Optional(std::optional<U>&& t) noexcept(std::is_nothrow_constructible_v<T, U>)
+        : s_([&] {
+            if constexpr (uses_nullable_traits)
+            {
+                if (t)
+                    return storage_t(static_cast<T>(std::move(*t)));
+                else
+                    return storage_t(nullable_traits<T>::null());
+            } else
+            {
+                if (t)
+                    return storage_t(std::move(*t));
+                else
+                    return storage_t(std::nullopt);
+            }
+        }())
+    {}
+
+    template <typename... Args>
+    requires std::is_constructible_v<T, Args...>
+    explicit constexpr
+    Optional(std::in_place_t, Args&&... args)
+        noexcept(std::is_nothrow_constructible_v<T, Args...>)
+        : s_([&] {
+            if constexpr (uses_nullable_traits)
+            {
+                return storage_t(T(std::forward<Args>(args)...));
+            } else
+            {
+                return storage_t(std::in_place, std::forward<Args>(args)...);
+            }
+        }())
+    {}
+
+    template <typename U, typename... Args>
+    requires std::is_constructible_v<T, std::initializer_list<U>&, Args...>
+    explicit constexpr Optional(
+        std::in_place_t, std::initializer_list<U> il, Args&&... args)
+        noexcept(std::is_nothrow_constructible_v<T, std::initializer_list<U>&, Args...>)
+        : s_([&] {
+            if constexpr (uses_nullable_traits)
+            {
+                return storage_t(T(il, std::forward<Args>(args)...));
+            } else
+            {
+                return storage_t(std::in_place, il, std::forward<Args>(args)...);
+            }
+        }())
+    {}
+
+    /// Copy assignment
+    constexpr Optional&
+    operator=(Optional const&) = default;
+
+    /// Move assignment
+    constexpr Optional&
+    operator=(Optional&&) = default;
+
+    constexpr Optional&
+    operator=(std::nullptr_t) noexcept(reset_noex_())
+    {
+        reset();
+        MRDOCS_ASSERT(!has_value());
+        return *this;
+    }
+
     /** Assign from a value.
 
         @param u The value to store. It must be convertible to T.
      **/
-    template <class U>
-    requires(
-        !std::same_as<std::remove_cvref_t<U>, Optional>
-        && std::is_constructible_v<T, U> && std::is_assignable_v<T&, U>)
-    constexpr
-    Optional&
-    operator=(U&& u) noexcept(std::is_nothrow_assignable_v<T&, U>)
+    template <typename U = std::remove_cv_t<T>>
+    requires(!std::is_same_v<Optional, std::remove_cvref_t<U>>)
+            && std::is_constructible_v<T, U> && std::is_assignable_v<T&, U>
+    constexpr Optional&
+    operator=(U&& u) noexcept(
+        std::is_nothrow_constructible_v<T, U> &&
+        std::is_nothrow_assignable_v <T&, U>)
     {
         if constexpr (uses_nullable_traits)
         {
             s_ = std::forward<U>(u);
-        } else
+        }
+        else
         {
             s_ = std::forward<U>(u);
         }
         return *this;
     }
 
-    /// Assign null (disengage).
+    template<typename U>
+    requires (!std::is_same_v<T, U>)
+            && std::is_constructible_v<T, const U&>
+            && std::is_assignable_v<T&, const U&>
+            && (!detail::ConvertsFromOptional<T, U>::value)
+            && (!detail::AssignsFromOptional<T, U>::value)
     constexpr Optional&
-    operator=(std::nullptr_t) noexcept(reset_noex_())
+    operator=(const Optional<U>& u) noexcept(
+        std::is_nothrow_constructible_v<T, U const&>
+        && std::is_nothrow_assignable_v<T&, U const&>)
     {
-        reset();
-        MRDOCS_ASSERT(!has_value());
+        if (u)
+        {
+            if constexpr (uses_nullable_traits)
+            {
+                s_ = *u;
+            }
+            else
+            {
+                s_ = *u;
+            }
+        }
+        else
+        {
+            reset();
+        }
+        return *this;
+    }
+
+
+    template<typename U>
+    requires (!std::is_same_v<T, U>)
+            && std::is_constructible_v<T, U>
+            && std::is_assignable_v<T&, U>
+            && (!detail::ConvertsFromOptional<T, U>::value)
+            && (!detail::AssignsFromOptional<T, U>::value)
+    constexpr Optional&
+    operator=(Optional<U>&& u) noexcept(
+        std::is_nothrow_constructible_v<T, U>
+        && std::is_nothrow_assignable_v<T&, U>)
+    {
+        if (u)
+        {
+            if constexpr (uses_nullable_traits)
+            {
+                s_ = std::move(*u);
+            }
+            else
+            {
+                s_ = std::move(*u);
+            }
+        }
+        else
+        {
+            reset();
+        }
         return *this;
     }
 
@@ -195,6 +424,23 @@ class Optional {
         }
     }
 
+    /** Determine if the value is inlined via nullable traits.
+
+        This is a compile-time property of T. If nullable_traits<T> is not
+        specialized, this function returns false to indicate that the
+        optional uses std::optional<T> as storage with an extra discriminator.
+        If nullable_traits<T> is specialized, this function returns true
+        to suggest that the null state is encoded inside T and no extra
+        storage is used.
+
+        @return `true` if the optional uses nullable_traits<T> for storage.
+     */
+    static constexpr bool
+    is_inlined() noexcept
+    {
+        return uses_nullable_traits;
+    }
+
     /** True if engaged (contains a value).
 
         @return `true` if the optional contains a value.
@@ -351,50 +597,44 @@ class Optional {
 };
 
 namespace detail {
-template<typename T>
-inline constexpr bool isOptionalV = false;
-
-template<typename T>
-inline constexpr bool isOptionalV<Optional<T>> = true;
-
 template <typename T>
-using OptionalRelopT = std::enable_if_t<std::is_convertible_v<T, bool>, bool>;
+using OptionalRelOpT = std::enable_if_t<std::is_convertible_v<T, bool>, bool>;
 
 template <typename T, typename U>
-using OptionalEqT = OptionalRelopT<
+using OptionalEqT = OptionalRelOpT<
     decltype(std::declval<T const&>() == std::declval<U const&>())>;
 
 template <typename T, typename U>
-using OptionalNeT = OptionalRelopT<
+using OptionalNeT = OptionalRelOpT<
     decltype(std::declval<T const&>() != std::declval<U const&>())>;
 
 template <typename T, typename U>
-using OptionalLtT = OptionalRelopT<
+using OptionalLtT = OptionalRelOpT<
     decltype(std::declval<T const&>() < std::declval<U const&>())>;
 
 template <typename T, typename U>
-using OptionalGtT = OptionalRelopT<
+using OptionalGtT = OptionalRelOpT<
     decltype(std::declval<T const&>() > std::declval<U const&>())>;
 
 template <typename T, typename U>
-using OptionalLeT = OptionalRelopT<
+using OptionalLeT = OptionalRelOpT<
     decltype(std::declval<T const&>() <= std::declval<U const&>())>;
 
 template <typename T, typename U>
-using OptionalGeT = detail::OptionalRelopT<
+using OptionalGeT = detail::OptionalRelOpT<
     decltype(std::declval<T const&>() >= std::declval<U const&>())>;
 
 template <typename T>
-concept isDerivedFromOptional = requires(T const& __t) {
+concept isDerivedFromOptional = requires(T const& t) {
     []<typename U>(Optional<U> const&) {
-    }(__t);
+    }(t);
 };
 
 } // namespace detail
 
 /** Compares two Optional values for equality.
-
     Returns true if both are engaged and their contained values are equal, or both are disengaged.
+    @return `true` if both optionals are engaged and equal, or both are disengaged; otherwise, `false`.
 */
 template <typename T, typename U>
 constexpr detail::OptionalEqT<T, U>
@@ -405,8 +645,8 @@ operator==(Optional<T> const& lhs, Optional<U> const& rhs)
 }
 
 /** Compares two Optional values for inequality.
-
     Returns true if their engagement states differ or their contained values are not equal.
+    @return `true` if the optionals differ in engagement or value; otherwise, `false`.
 */
 template <typename T, typename U>
 constexpr detail::OptionalNeT<T, U>
@@ -417,8 +657,8 @@ operator!=(Optional<T> const& lhs, Optional<U> const& rhs)
 }
 
 /** Checks if the left Optional is less than the right Optional.
-
     Returns true if the right is engaged and either the left is disengaged or its value is less.
+    @return `true` if `lhs` is less than `rhs` according to the described rules; otherwise, `false`.
 */
 template <typename T, typename U>
 constexpr detail::OptionalLtT<T, U>
@@ -428,8 +668,8 @@ operator<(Optional<T> const& lhs, Optional<U> const& rhs)
 }
 
 /** Checks if the left Optional is greater than the right Optional.
-
     Returns true if the left is engaged and either the right is disengaged or its value is greater.
+    @return `true` if `lhs` is greater than `rhs` according to the described rules; otherwise, `false`.
 */
 template <typename T, typename U>
 constexpr detail::OptionalGtT<T, U>
@@ -439,8 +679,8 @@ operator>(Optional<T> const& lhs, Optional<U> const& rhs)
 }
 
 /** Checks if the left Optional is less than or equal to the right Optional.
-
     Returns true if the left is disengaged or the right is engaged and the left's value is less or equal.
+    @return `true` if `lhs` is less than or equal to `rhs` according to the described rules; otherwise, `false`.
 */
 template <typename T, typename U>
 constexpr detail::OptionalLeT<T, U>
@@ -450,8 +690,8 @@ operator<=(Optional<T> const& lhs, Optional<U> const& rhs)
 }
 
 /** Checks if the left Optional is greater than or equal to the right Optional.
-
     Returns true if the right is disengaged or the left is engaged and its value is greater or equal.
+    @return `true` if `lhs` is greater than or equal to `rhs` according to the described rules; otherwise, `false`.
 */
 template <typename T, typename U>
 constexpr detail::OptionalGeT<T, U>
@@ -461,8 +701,8 @@ operator>=(Optional<T> const& lhs, Optional<U> const& rhs)
 }
 
 /** Performs a three-way comparison between two Optional values.
-
     If both are engaged, compares their contained values; otherwise, compares engagement state.
+    @return The result of the three-way comparison between the optionals or their values.
 */
 template <typename T, std::three_way_comparable_with<T> U>
 [[nodiscard]]
@@ -473,8 +713,8 @@ operator<=>(Optional<T> const& x, Optional<U> const& y)
 }
 
 /** Checks if the Optional is disengaged (equal to std::nullopt).
-
     Returns true if the Optional does not contain a value.
+    @return `true` if the optional is disengaged; otherwise, `false`.
 */
 template <typename T>
 [[nodiscard]]
@@ -485,8 +725,8 @@ operator==(Optional<T> const& lhs, std::nullopt_t) noexcept
 }
 
 /** Performs a three-way comparison between an Optional and std::nullopt.
-
     Returns std::strong_ordering::greater if engaged, std::strong_ordering::equal if disengaged.
+    @return The result of the three-way comparison with `std::nullopt`.
 */
 template <typename T>
 [[nodiscard]]
@@ -497,56 +737,56 @@ operator<=>(Optional<T> const& x, std::nullopt_t) noexcept
 }
 
 /** Compares an engaged Optional to a value for equality.
-
     Returns true if the Optional is engaged and its value equals rhs.
+    @return `true` if the optional is engaged and equal to `rhs`; otherwise, `false`.
 */
 template <typename T, typename U>
 requires(!detail::isOptionalV<U>)
 constexpr detail::OptionalEqT<T, U>
-operator== [[nodiscard]] (Optional<T> const& lhs, U const& rhs)
+operator==(Optional<T> const& lhs, U const& rhs)
 {
     return lhs && *lhs == rhs;
 }
 
 /** Compares a value to an engaged Optional for equality.
-
     Returns true if the Optional is engaged and its value equals lhs.
+    @return `true` if the optional is engaged and equal to `lhs`; otherwise, `false`.
 */
 template <typename T, typename U>
 requires(!detail::isOptionalV<T>)
 constexpr detail::OptionalEqT<T, U>
-operator== [[nodiscard]] (T const& lhs, Optional<U> const& rhs)
+operator==(T const& lhs, Optional<U> const& rhs)
 {
     return rhs && lhs == *rhs;
 }
 
 /** Compares an Optional to a value for inequality.
-
     Returns true if the Optional is disengaged or its value does not equal rhs.
+    @return `true` if the optional is disengaged or not equal to `rhs`; otherwise, `false`.
 */
 template <typename T, typename U>
 requires(!detail::isOptionalV<U>)
 constexpr detail::OptionalNeT<T, U>
-operator!= [[nodiscard]] (Optional<T> const& lhs, U const& rhs)
+operator!=(Optional<T> const& lhs, U const& rhs)
 {
     return !lhs || *lhs != rhs;
 }
 
 /** Compares a value to an Optional for inequality.
-
     Returns true if the Optional is disengaged or its value does not equal lhs.
+    @return `true` if the optional is disengaged or not equal to `lhs`; otherwise, `false`.
 */
 template <typename T, typename U>
 requires(!detail::isOptionalV<T>)
 constexpr detail::OptionalNeT<T, U>
-operator!= [[nodiscard]] (T const& lhs, Optional<U> const& rhs)
+operator!=(T const& lhs, Optional<U> const& rhs)
 {
     return !rhs || lhs != *rhs;
 }
 
 /** Checks if the Optional is less than a value.
-
     Returns true if the Optional is disengaged or its value is less than rhs.
+    @return `true` if the optional is disengaged or less than `rhs`; otherwise, `false`.
 */
 template <typename T, typename U>
 requires(!detail::isOptionalV<U>)
@@ -557,8 +797,8 @@ operator<[[nodiscard]] (Optional<T> const& lhs, U const& rhs)
 }
 
 /** Checks if a value is less than an engaged Optional.
-
     Returns true if the Optional is engaged and lhs is less than its value.
+    @return `true` if the optional is engaged and `lhs` is less than its value; otherwise, `false`.
 */
 template <typename T, typename U>
 requires(!detail::isOptionalV<T>)
@@ -569,87 +809,87 @@ operator<[[nodiscard]] (T const& lhs, Optional<U> const& rhs)
 }
 
 /** Checks if the Optional is greater than a value.
-
     Returns true if the Optional is engaged and its value is greater than rhs.
+    @return `true` if the optional is engaged and greater than `rhs`; otherwise, `false`.
 */
 template <typename T, typename U>
 requires(!detail::isOptionalV<U>)
 constexpr detail::OptionalGtT<T, U>
-operator> [[nodiscard]] (Optional<T> const& lhs, U const& rhs)
+operator>(Optional<T> const& lhs, U const& rhs)
 {
     return lhs && *lhs > rhs;
 }
 
 /** Checks if a value is greater than an Optional.
-
     Returns true if the Optional is disengaged or lhs is greater than its value.
+    @return `true` if the optional is disengaged or `lhs` is greater than its value; otherwise, `false`.
 */
 template <typename T, typename U>
 requires(!detail::isOptionalV<T>)
 constexpr detail::OptionalGtT<T, U>
-operator> [[nodiscard]] (T const& lhs, Optional<U> const& rhs)
+operator>(T const& lhs, Optional<U> const& rhs)
 {
     return !rhs || lhs > *rhs;
 }
 
 /** Checks if the Optional is less than or equal to a value.
-
     Returns true if the Optional is disengaged or its value is less than or equal to rhs.
+    @return `true` if the optional is disengaged or less than or equal to `rhs`; otherwise, `false`.
 */
 template <typename T, typename U>
 requires(!detail::isOptionalV<U>)
 constexpr detail::OptionalLeT<T, U>
-operator<= [[nodiscard]] (Optional<T> const& lhs, U const& rhs)
+operator<=(Optional<T> const& lhs, U const& rhs)
 {
     return !lhs || *lhs <= rhs;
 }
 
 /** Checks if a value is less than or equal to an engaged Optional.
-
     Returns true if the Optional is engaged and lhs is less than or equal to its value.
+    @return `true` if the optional is engaged and `lhs` is less than or equal to its value; otherwise, `false`.
 */
 template <typename T, typename U>
 requires(!detail::isOptionalV<T>)
 constexpr detail::OptionalLeT<T, U>
-operator<= [[nodiscard]] (T const& lhs, Optional<U> const& rhs)
+operator<=(T const& lhs, Optional<U> const& rhs)
 {
     return rhs && lhs <= *rhs;
 }
 
 /** Checks if the Optional is greater than or equal to a value.
-
     Returns true if the Optional is engaged and its value is greater than or equal to rhs.
+    @return `true` if the optional is engaged and greater than or equal to `rhs`; otherwise, `false`.
 */
 template <typename T, typename U>
 requires(!detail::isOptionalV<U>)
 constexpr detail::OptionalGeT<T, U>
-operator>= [[nodiscard]] (Optional<T> const& lhs, U const& rhs)
+operator>=(Optional<T> const& lhs, U const& rhs)
 {
     return lhs && *lhs >= rhs;
 }
 
 /** Checks if a value is greater than or equal to an Optional.
-
     Returns true if the Optional is disengaged or lhs is greater than or equal to its value.
+    @return `true` if the optional is disengaged or `lhs` is greater than or equal to its value; otherwise, `false`.
 */
 template <typename T, typename U>
 requires(!detail::isOptionalV<T>)
 constexpr detail::OptionalGeT<T, U>
-operator>= [[nodiscard]] (T const& lhs, Optional<U> const& rhs)
+operator>=(T const& lhs, Optional<U> const& rhs)
 {
     return !rhs || lhs >= *rhs;
 }
 
 /** Performs a three-way comparison between an Optional and a value.
-
     If the Optional is engaged, compares its value to v; otherwise, returns less.
+    @return The result of the three-way comparison with the value.
 */
 template <typename T, typename U>
 requires(!detail::isDerivedFromOptional<U>)
         && requires { typename std::compare_three_way_result_t<T, U>; }
         && std::three_way_comparable_with<T, U>
 constexpr std::compare_three_way_result_t<T, U>
-operator<=> [[nodiscard]] (Optional<T> const& x, U const& v)
+operator<=>(Optional<T> const& x, U const& v)
 {
     return bool(x) ? *x <=> v : std::strong_ordering::less;
 }
diff --git a/include/mrdocs/Dom/Value.hpp b/include/mrdocs/Dom/Value.hpp
index c9cc97f82..468bc4f39 100644
--- a/include/mrdocs/Dom/Value.hpp
+++ b/include/mrdocs/Dom/Value.hpp
@@ -642,6 +642,22 @@ stringOrNull(
     return nullptr;
 }
 
+/** Return a non-empty string, or a null.
+
+    @param s The string to check.
+*/
+inline
+Value
+stringOrNull(
+    std::string const& s)
+{
+    if(!s.empty())
+    {
+        return {s};
+    }
+    return nullptr;
+}
+
 //------------------------------------------------
 
 /** Customization point tag.
diff --git a/include/mrdocs/Metadata/Expression.hpp b/include/mrdocs/Metadata/Expression.hpp
index fb4996eec..76f4cf16a 100644
--- a/include/mrdocs/Metadata/Expression.hpp
+++ b/include/mrdocs/Metadata/Expression.hpp
@@ -12,6 +12,7 @@
 #define MRDOCS_API_METADATA_EXPRESSION_HPP
 
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Optional.hpp>
 #include <concepts>
 #include <optional>
 #include <string>
@@ -44,7 +45,7 @@ struct ConstantExprInfo
         The value of an expression will be unknown
         if it is e.g. dependent on a template parameter
     */
-    std::optional<type> Value;
+    Optional<type> Value;
 
     auto operator<=>(ConstantExprInfo const&) const = default;
 
diff --git a/include/mrdocs/Metadata/Info/Concept.hpp b/include/mrdocs/Metadata/Info/Concept.hpp
index 65618e157..ba6a15d15 100644
--- a/include/mrdocs/Metadata/Info/Concept.hpp
+++ b/include/mrdocs/Metadata/Info/Concept.hpp
@@ -13,6 +13,7 @@
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/Metadata/Expression.hpp>
 #include <mrdocs/Metadata/Info.hpp>
 #include <mrdocs/Metadata/Info/Source.hpp>
@@ -27,7 +28,7 @@ struct ConceptInfo final
 {
     /** The concepts template parameters
     */
-    std::optional<TemplateInfo> Template;
+    Optional<TemplateInfo> Template;
 
     /** The concepts constraint-expression
     */
diff --git a/include/mrdocs/Metadata/Info/Function.hpp b/include/mrdocs/Metadata/Info/Function.hpp
index e3e5c3420..de1b9f09d 100644
--- a/include/mrdocs/Metadata/Info/Function.hpp
+++ b/include/mrdocs/Metadata/Info/Function.hpp
@@ -15,6 +15,7 @@
 #define MRDOCS_API_METADATA_INFO_FUNCTION_HPP
 
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/Metadata/Info/FunctionClass.hpp>
 #include <mrdocs/Metadata/Info/InfoBase.hpp>
 #include <mrdocs/Metadata/Info/Param.hpp>
@@ -36,7 +37,7 @@ struct FunctionInfo final
     std::vector<Param> Params;
 
     /// When present, this function is a template or specialization.
-    std::optional<TemplateInfo> Template;
+    Optional<TemplateInfo> Template;
 
     /// The class of function this is
     FunctionClass Class = FunctionClass::Normal;
diff --git a/include/mrdocs/Metadata/Info/Guide.hpp b/include/mrdocs/Metadata/Info/Guide.hpp
index 869ef653d..67de5f07f 100644
--- a/include/mrdocs/Metadata/Info/Guide.hpp
+++ b/include/mrdocs/Metadata/Info/Guide.hpp
@@ -13,6 +13,7 @@
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/Metadata/Info.hpp>
 #include <mrdocs/Metadata/Info/Function.hpp>
 #include <mrdocs/Metadata/Info/Source.hpp>
@@ -35,7 +36,7 @@ struct GuideInfo final
 
     /** Template head, if any.
     */
-    std::optional<TemplateInfo> Template;
+    Optional<TemplateInfo> Template;
 
     /** The parameters of the deduction guide.
     */
diff --git a/include/mrdocs/Metadata/Info/InfoBase.hpp b/include/mrdocs/Metadata/Info/InfoBase.hpp
index 9b22ef314..7048821b1 100644
--- a/include/mrdocs/Metadata/Info/InfoBase.hpp
+++ b/include/mrdocs/Metadata/Info/InfoBase.hpp
@@ -78,7 +78,7 @@ struct MRDOCS_VISIBLE Info
 
     /** The extracted javadoc for this declaration.
      */
-    std::optional<Javadoc> javadoc;
+    Optional<Javadoc> javadoc;
 
     //--------------------------------------------
 
diff --git a/include/mrdocs/Metadata/Info/Record.hpp b/include/mrdocs/Metadata/Info/Record.hpp
index 1c76e4a05..ab3be600a 100644
--- a/include/mrdocs/Metadata/Info/Record.hpp
+++ b/include/mrdocs/Metadata/Info/Record.hpp
@@ -13,6 +13,7 @@
 #define MRDOCS_API_METADATA_INFO_RECORD_HPP
 
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/Metadata/Info/Friend.hpp>
 #include <mrdocs/Metadata/Info/RecordBase.hpp>
 #include <mrdocs/Metadata/Info/RecordInterface.hpp>
@@ -31,7 +32,7 @@ struct RecordInfo final
     RecordKeyKind KeyKind = RecordKeyKind::Struct;
 
     /// When present, this record is a template or specialization.
-    std::optional<TemplateInfo> Template;
+    Optional<TemplateInfo> Template;
 
     // Indicates if the record was declared using a typedef.
     // Things like anonymous structs in a typedef:
diff --git a/include/mrdocs/Metadata/Info/Typedef.hpp b/include/mrdocs/Metadata/Info/Typedef.hpp
index 8ff148635..a8c66aa6e 100644
--- a/include/mrdocs/Metadata/Info/Typedef.hpp
+++ b/include/mrdocs/Metadata/Info/Typedef.hpp
@@ -14,6 +14,7 @@
 #define MRDOCS_API_METADATA_INFO_TYPEDEF_HPP
 
 #include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/Metadata/Info.hpp>
 #include <mrdocs/Metadata/Name.hpp>
 #include <mrdocs/Metadata/Template.hpp>
@@ -41,7 +42,7 @@ struct TypedefInfo final
       */
     bool IsUsing = false;
 
-    std::optional<TemplateInfo> Template;
+    Optional<TemplateInfo> Template;
 
     //--------------------------------------------
 
diff --git a/include/mrdocs/Metadata/Info/Variable.hpp b/include/mrdocs/Metadata/Info/Variable.hpp
index 5f9b8b5a3..5512318b7 100644
--- a/include/mrdocs/Metadata/Info/Variable.hpp
+++ b/include/mrdocs/Metadata/Info/Variable.hpp
@@ -12,6 +12,7 @@
 #ifndef MRDOCS_API_METADATA_INFO_VARIABLE_HPP
 #define MRDOCS_API_METADATA_INFO_VARIABLE_HPP
 
+#include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Dom/LazyArray.hpp>
 #include <mrdocs/Metadata/Expression.hpp>
@@ -33,7 +34,7 @@ struct VariableInfo final
     /** The type of the variable */
     Optional<Polymorphic<TypeInfo>> Type = std::nullopt;
 
-    std::optional<TemplateInfo> Template;
+    Optional<TemplateInfo> Template;
 
     /** The default member initializer, if any.
      */
diff --git a/include/mrdocs/Metadata/Javadoc.hpp b/include/mrdocs/Metadata/Javadoc.hpp
index 63bf2ace7..ac2e4136a 100644
--- a/include/mrdocs/Metadata/Javadoc.hpp
+++ b/include/mrdocs/Metadata/Javadoc.hpp
@@ -56,7 +56,7 @@ struct MRDOCS_DECL
     // Symbol Metadata
 
     /// A brief description of the symbol.
-    std::optional<doc::Brief> brief;
+    Optional<doc::Brief> brief;
 
     /** The list of return type descriptions.
 
diff --git a/include/mrdocs/Metadata/Javadoc/Inline.hpp b/include/mrdocs/Metadata/Javadoc/Inline.hpp
index 7efea7b68..ee1a8a0b7 100644
--- a/include/mrdocs/Metadata/Javadoc/Inline.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Inline.hpp
@@ -29,7 +29,7 @@ namespace clang::mrdocs::doc {
 
 /** Visit an inline.
 
-    @param inline The inline to visit.
+    @param el The inline element to visit.
     @param fn The function to call for each inline.
     @param args Additional arguments to pass to the function.
     @return The result of calling the function.
diff --git a/include/mrdocs/Metadata/Specifiers/OperatorKind.hpp b/include/mrdocs/Metadata/Specifiers/OperatorKind.hpp
index 879a35424..bd2a70c2d 100644
--- a/include/mrdocs/Metadata/Specifiers/OperatorKind.hpp
+++ b/include/mrdocs/Metadata/Specifiers/OperatorKind.hpp
@@ -13,6 +13,7 @@
 #define MRDOCS_API_METADATA_SPECIFIERS_OPERATORKIND_HPP
 
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/Dom/String.hpp>
 #include <string>
 
@@ -196,7 +197,7 @@ getSafeOperatorName(
     @param nParams The number of parameters the operator takes.
     @return The readable name, or nullopt if the operator is not recognized.
  */
-std::optional<std::string_view>
+Optional<std::string_view>
 getOperatorReadableName(
     OperatorKind kind,
     int nParams);
diff --git a/include/mrdocs/Metadata/Template.hpp b/include/mrdocs/Metadata/Template.hpp
index 47ad0180b..c66712a06 100644
--- a/include/mrdocs/Metadata/Template.hpp
+++ b/include/mrdocs/Metadata/Template.hpp
@@ -83,7 +83,7 @@ merge(TemplateInfo& I, TemplateInfo&& Other);
 
 inline
 auto
-operator<=>(std::optional<TemplateInfo> const& lhs, std::optional<TemplateInfo> const& rhs)
+operator<=>(Optional<TemplateInfo> const& lhs, Optional<TemplateInfo> const& rhs)
 {
     if (!lhs)
     {
@@ -102,7 +102,7 @@ operator<=>(std::optional<TemplateInfo> const& lhs, std::optional<TemplateInfo>
 
 inline
 bool
-operator==(std::optional<TemplateInfo> const& lhs, std::optional<TemplateInfo> const& rhs)
+operator==(Optional<TemplateInfo> const& lhs, Optional<TemplateInfo> const& rhs)
 {
     return lhs <=> rhs == std::strong_ordering::equal;
 }
@@ -120,7 +120,7 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    std::optional<TemplateInfo> const& I,
+    Optional<TemplateInfo> const& I,
     DomCorpus const* domCorpus)
 {
     if (!I)
diff --git a/include/mrdocs/Metadata/Type.hpp b/include/mrdocs/Metadata/Type.hpp
index 674f11889..57a94cfe1 100644
--- a/include/mrdocs/Metadata/Type.hpp
+++ b/include/mrdocs/Metadata/Type.hpp
@@ -122,12 +122,12 @@ operator==(
     by a specifier (e.g. "int" in "pointer to int".
 */
 MRDOCS_DECL
-std::optional<std::reference_wrapper<Polymorphic<TypeInfo> const>>
+Optional<std::reference_wrapper<Polymorphic<TypeInfo> const>>
 innerType(TypeInfo const& TI) noexcept;
 
 /// @copydoc innerType(TypeInfo const&)
 MRDOCS_DECL
-std::optional<std::reference_wrapper<Polymorphic<TypeInfo>>>
+Optional<std::reference_wrapper<Polymorphic<TypeInfo>>>
 innerType(TypeInfo& TI) noexcept;
 
 /// @copydoc innerType(TypeInfo const&)
diff --git a/include/mrdocs/Metadata/Type/NamedTypeInfo.hpp b/include/mrdocs/Metadata/Type/NamedTypeInfo.hpp
index 363890bf1..a9fd234f6 100644
--- a/include/mrdocs/Metadata/Type/NamedTypeInfo.hpp
+++ b/include/mrdocs/Metadata/Type/NamedTypeInfo.hpp
@@ -27,7 +27,7 @@ struct NamedTypeInfo final
 {
     Polymorphic<NameInfo> Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
 
-    std::optional<FundamentalTypeKind> FundamentalType;
+    Optional<FundamentalTypeKind> FundamentalType;
 
     std::strong_ordering
     operator<=>(NamedTypeInfo const& other) const;
diff --git a/include/mrdocs/Support/Glob.hpp b/include/mrdocs/Support/Glob.hpp
index 3de603a2e..4ae383b69 100644
--- a/include/mrdocs/Support/Glob.hpp
+++ b/include/mrdocs/Support/Glob.hpp
@@ -11,6 +11,7 @@
 #ifndef MRDOCS_API_SUPPORT_GLOB_HPP
 #define MRDOCS_API_SUPPORT_GLOB_HPP
 
+#include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/Support/Expected.hpp>
 #include <memory>
 #include <optional>
@@ -45,7 +46,7 @@ class GlobPattern {
      */
     static
     Expected<GlobPattern>
-    create(std::string_view pattern, std::optional<std::size_t> maxSubGlobs);
+    create(std::string_view pattern, Optional<std::size_t> maxSubGlobs);
 
     static
     Expected<GlobPattern>
@@ -138,7 +139,7 @@ class PathGlobPattern {
     Expected<PathGlobPattern>
     create(
         std::string_view const pattern,
-        std::optional<std::size_t> maxSubGlobs)
+        Optional<std::size_t> maxSubGlobs)
     {
         MRDOCS_TRY(auto glob, GlobPattern::create(pattern, maxSubGlobs));
         return PathGlobPattern{std::move(glob)};
@@ -242,7 +243,7 @@ class SymbolGlobPattern {
     Expected<SymbolGlobPattern>
     create(
         std::string_view const pattern,
-        std::optional<std::size_t> maxSubGlobs)
+        Optional<std::size_t> maxSubGlobs)
     {
         MRDOCS_TRY(auto glob, GlobPattern::create(pattern, maxSubGlobs));
         return SymbolGlobPattern{std::move(glob)};
diff --git a/src/lib/AST/ASTVisitor.cpp b/src/lib/AST/ASTVisitor.cpp
index 9b5be1dfd..550b0720e 100644
--- a/src/lib/AST/ASTVisitor.cpp
+++ b/src/lib/AST/ASTVisitor.cpp
@@ -560,7 +560,7 @@ populate(SourceInfo& I, DeclTy const* D)
 bool
 ASTVisitor::
 populate(
-    std::optional<Javadoc>& javadoc,
+    Optional<Javadoc>& javadoc,
     Decl const* D)
 {
     RawComment const* RC = getDocumentation(D);
@@ -1511,7 +1511,7 @@ populate(
             {
                 NestedNameSpecifier NNS =
                     TC->getNestedNameSpecifierLoc().getNestedNameSpecifier();
-                std::optional<ASTTemplateArgumentListInfo const*> TArgs;
+                Optional<ASTTemplateArgumentListInfo const*> TArgs;
                 if (TC->hasExplicitTemplateArgs())
                 {
                     TArgs.emplace(TC->getTemplateArgsAsWritten());
@@ -2081,7 +2081,7 @@ template <class TArgRange>
 Polymorphic<NameInfo>
 ASTVisitor::
 toNameInfo(DeclarationName const Name,
-    std::optional<TArgRange> TArgs,
+    Optional<TArgRange> TArgs,
     NestedNameSpecifier NNS)
 {
     if (Name.isEmpty())
@@ -2108,7 +2108,7 @@ Polymorphic<NameInfo>
 ASTVisitor::
 toNameInfo(
     Decl const* D,
-    std::optional<TArgRange> TArgs,
+    Optional<TArgRange> TArgs,
     NestedNameSpecifier NNS)
 {
     auto const* ND = dyn_cast_if_present<NamedDecl>(D);
@@ -2136,7 +2136,7 @@ Polymorphic<NameInfo>
 ASTVisitor::
 toNameInfo<llvm::ArrayRef<clang::TemplateArgument>>(
     Decl const* D,
-    std::optional<llvm::ArrayRef<clang::TemplateArgument>> TArgs,
+    Optional<llvm::ArrayRef<clang::TemplateArgument>> TArgs,
     NestedNameSpecifier NNS);
 
 Polymorphic<TArg>
@@ -2307,7 +2307,7 @@ getSourceCode(SourceRange const& R) const
         context_.getLangOpts()).str();
 }
 
-std::optional<ASTVisitor::SFINAEInfo>
+Optional<ASTVisitor::SFINAEInfo>
 ASTVisitor::
 extractSFINAEInfo(QualType const T)
 {
@@ -2352,7 +2352,7 @@ extractSFINAEInfo(QualType const T)
     return Result;
 }
 
-std::optional<ASTVisitor::SFINAEControlParams>
+Optional<ASTVisitor::SFINAEControlParams>
 ASTVisitor::
 getSFINAEControlParams(
     TemplateDecl* TD,
@@ -2666,7 +2666,7 @@ getSFINAEControlParams(
     return SFINAEControlParams(CTD->getTemplateParameters(), std::move(ControllingParams), ParamIdx);
 }
 
-std::optional<ASTVisitor::SFINAETemplateInfo>
+Optional<ASTVisitor::SFINAETemplateInfo>
 ASTVisitor::getSFINAETemplateInfo(QualType T, bool const AllowDependentNames) const
 {
     MRDOCS_SYMBOL_TRACE(T, context_);
@@ -2704,7 +2704,7 @@ ASTVisitor::getSFINAETemplateInfo(QualType T, bool const AllowDependentNames) co
     return std::nullopt;
 }
 
-std::optional<TemplateArgument>
+Optional<TemplateArgument>
 ASTVisitor::
 tryGetTemplateArgument(
     TemplateParameterList* Parameters,
@@ -3309,7 +3309,7 @@ buildFileInfo(std::string_view path)
 
     // Attempts to get a relative path for the prefix
     auto tryGetRelativePosixPath = [&file_info](std::string_view const prefix)
-        -> std::optional<std::string_view>
+        -> Optional<std::string_view>
     {
         if (files::startsWith(file_info.full_path, prefix))
         {
@@ -3325,7 +3325,7 @@ buildFileInfo(std::string_view path)
     };
 
     auto tryGetRelativePath = [&tryGetRelativePosixPath](std::string_view const prefix)
-        -> std::optional<std::string_view>
+        -> Optional<std::string_view>
     {
         if (!files::isAbsolute(prefix))
         {
@@ -3376,7 +3376,7 @@ buildFileInfo(std::string_view path)
     }
 
     // Fallback to system search paths in PATH
-    std::optional<std::string> const optEnvPathsStr = llvm::sys::Process::GetEnv("PATH");
+    Optional<std::string> const optEnvPathsStr = llvm::sys::Process::GetEnv("PATH");
     MRDOCS_CHECK_OR(optEnvPathsStr, file_info);
     std::string const& envPathsStr = *optEnvPathsStr;
     for (auto const envPaths = llvm::split(envPathsStr, llvm::sys::EnvPathSeparator);
diff --git a/src/lib/AST/ASTVisitor.hpp b/src/lib/AST/ASTVisitor.hpp
index 0de087200..db292a40c 100644
--- a/src/lib/AST/ASTVisitor.hpp
+++ b/src/lib/AST/ASTVisitor.hpp
@@ -121,7 +121,7 @@ class ASTVisitor
         std::string source_path;
 
         // Whether this file passes the file filters
-        std::optional<bool> passesFilters;
+        Optional<bool> passesFilters;
     };
 
     /*  A map of Clang FileEntry objects to Visitor FileInfo objects
@@ -503,7 +503,7 @@ class ASTVisitor
      */
     bool
     populate(
-        std::optional<Javadoc>& javadoc,
+        Optional<Javadoc>& javadoc,
         Decl const* D);
 
     void
@@ -625,7 +625,7 @@ class ASTVisitor
         std::derived_from<Decl> DeclTy,
         std::derived_from<TemplateDecl> TemplateDeclTy>
     void
-    populate(std::optional<TemplateInfo>& Template, DeclTy const* D, TemplateDeclTy const* VTD)
+    populate(Optional<TemplateInfo>& Template, DeclTy const* D, TemplateDeclTy const* VTD)
     {
         MRDOCS_CHECK_OR(VTD);
         MRDOCS_CHECK_OR(!VTD->isImplicit());
@@ -666,7 +666,7 @@ class ASTVisitor
     populate(Polymorphic<TParam>& I, NamedDecl const* N);
 
     void
-    populate(std::optional<TemplateInfo>& TI, TemplateParameterList const* TPL)
+    populate(Optional<TemplateInfo>& TI, TemplateParameterList const* TPL)
     {
         if (!TI)
         {
@@ -777,14 +777,14 @@ class ASTVisitor
     Polymorphic<NameInfo>
     toNameInfo(
         DeclarationName Name,
-        std::optional<TArgRange> TArgs = std::nullopt,
+        Optional<TArgRange> TArgs = std::nullopt,
         NestedNameSpecifier NNS = std::nullopt);
 
     template <class TArgRange = ArrayRef<TemplateArgument>>
     Polymorphic<NameInfo>
     toNameInfo(
         Decl const* D,
-        std::optional<TArgRange> TArgs = std::nullopt,
+        Optional<TArgRange> TArgs = std::nullopt,
         NestedNameSpecifier NNS = std::nullopt);
 
     Polymorphic<TArg>
@@ -844,11 +844,11 @@ class ASTVisitor
         and the underlying type with the template arguments
         otherwise.
      */
-    std::optional<SFINAEInfo>
+    Optional<SFINAEInfo>
     extractSFINAEInfo(QualType T);
 
     // @copydoc extractSFINAEInfo(QualType)
-    std::optional<SFINAEInfo>
+    Optional<SFINAEInfo>
     extractSFINAEInfo(Type const* T)
     {
         return extractSFINAEInfo(QualType(T, 0));
@@ -894,7 +894,7 @@ class ASTVisitor
         respective to `std::enable_if<B,T>`: `Template` would be `std::enable_if`,
         and `Arguments` would be `{B,T}`.
      */
-    std::optional<SFINAETemplateInfo>
+    Optional<SFINAETemplateInfo>
     getSFINAETemplateInfo(QualType T, bool AllowDependentNames) const;
 
     /* The controlling parameters of a SFINAE template
@@ -935,10 +935,10 @@ class ASTVisitor
        template information of the underlying type
        (such as `typename enable_if<B,T>::type`) will be extract instead.
      */
-    std::optional<SFINAEControlParams>
+    Optional<SFINAEControlParams>
     getSFINAEControlParams(TemplateDecl* TD, IdentifierInfo const* Member);
 
-    std::optional<SFINAEControlParams>
+    Optional<SFINAEControlParams>
     getSFINAEControlParams(SFINAETemplateInfo const& SFINAE) {
         return getSFINAEControlParams(SFINAE.Template, SFINAE.Member);
     }
@@ -953,7 +953,7 @@ class ASTVisitor
         arguments, the function will attempt to get the
         argument from the default template arguments.
      */
-    std::optional<TemplateArgument>
+    Optional<TemplateArgument>
     tryGetTemplateArgument(
         TemplateParameterList* Parameters,
         ArrayRef<TemplateArgument> Arguments,
diff --git a/src/lib/AST/ClangHelpers.cpp b/src/lib/AST/ClangHelpers.cpp
index fe29dd6cd..150e05afe 100644
--- a/src/lib/AST/ClangHelpers.cpp
+++ b/src/lib/AST/ClangHelpers.cpp
@@ -60,7 +60,7 @@ SubstituteConstraintExpressionWithoutSatisfaction(
         }
     }
 
-    std::optional<Sema::CXXThisScopeRAII> ThisScope;
+    Optional<Sema::CXXThisScopeRAII> ThisScope;
 
     // See TreeTransform::RebuildTemplateSpecializationType. A context scope is
     // essential for having an injected class as the canonical type for a template
@@ -69,7 +69,7 @@ SubstituteConstraintExpressionWithoutSatisfaction(
     // template specializations can be profiled to the same value, which makes it
     // possible that e.g. constraints involving C<Class<T>> and C<Class> are
     // perceived identical.
-    std::optional<Sema::ContextRAII> ContextScope;
+    Optional<Sema::ContextRAII> ContextScope;
     if (auto *RD = dyn_cast<CXXRecordDecl>(DeclInfo.getDeclContext()))
     {
         ThisScope.emplace(S, const_cast<CXXRecordDecl *>(RD), Qualifiers());
diff --git a/src/lib/AST/ClangHelpers.hpp b/src/lib/AST/ClangHelpers.hpp
index e0770c5b9..0e8cc31e5 100644
--- a/src/lib/AST/ClangHelpers.hpp
+++ b/src/lib/AST/ClangHelpers.hpp
@@ -512,7 +512,7 @@ toAutoKind(AutoTypeKeyword const kind)
 /** Convert a Clang AutoTypeKeyword into a MrDocs AutoKind
  */
 inline
-std::optional<FundamentalTypeKind>
+Optional<FundamentalTypeKind>
 toFundamentalTypeKind(BuiltinType::Kind const kind)
 {
     switch(kind)
@@ -1060,7 +1060,7 @@ namespace detail {
 
     template <class T>
     void
-    printTraceName(std::optional<T> const& D, ASTContext const& C, std::string& symbol_name)
+    printTraceName(Optional<T> const& D, ASTContext const& C, std::string& symbol_name)
     {
         if (D)
         {
diff --git a/src/lib/AST/MrDocsFileSystem.hpp b/src/lib/AST/MrDocsFileSystem.hpp
index 558c6957d..a622a2a0a 100644
--- a/src/lib/AST/MrDocsFileSystem.hpp
+++ b/src/lib/AST/MrDocsFileSystem.hpp
@@ -73,7 +73,7 @@ class MrDocsFileSystem : public llvm::vfs::FileSystem {
         return matchesPrefixSetImpl(Path, shimParents);
     }
 
-    std::optional<std::pair<std::string_view, std::string_view>>
+    Optional<std::pair<std::string_view, std::string_view>>
     matchShim(llvm::StringRef Path) const
     {
         for (auto const &[K, P]: config_->missingIncludeShims)
diff --git a/src/lib/AST/NameInfoBuilder.cpp b/src/lib/AST/NameInfoBuilder.cpp
index c0817ad63..2d6347692 100644
--- a/src/lib/AST/NameInfoBuilder.cpp
+++ b/src/lib/AST/NameInfoBuilder.cpp
@@ -42,7 +42,7 @@ NameInfoBuilder::
 buildTerminal(
     NestedNameSpecifier NNS,
     IdentifierInfo const* II,
-    std::optional<ArrayRef<TemplateArgument>> TArgs,
+    Optional<ArrayRef<TemplateArgument>> TArgs,
     unsigned,
     bool)
 {
@@ -77,7 +77,7 @@ NameInfoBuilder::
 buildTerminal(
     NestedNameSpecifier NNS,
     NamedDecl const* D,
-    std::optional<ArrayRef<TemplateArgument>> const& TArgs,
+    Optional<ArrayRef<TemplateArgument>> const& TArgs,
     unsigned,
     bool)
 {
diff --git a/src/lib/AST/NameInfoBuilder.hpp b/src/lib/AST/NameInfoBuilder.hpp
index 4de3b1b84..c57ab455d 100644
--- a/src/lib/AST/NameInfoBuilder.hpp
+++ b/src/lib/AST/NameInfoBuilder.hpp
@@ -57,7 +57,7 @@ class NameInfoBuilder
     buildTerminal(
         NestedNameSpecifier NNS,
         IdentifierInfo const* II,
-        std::optional<ArrayRef<TemplateArgument>> TArgs,
+        Optional<ArrayRef<TemplateArgument>> TArgs,
         unsigned quals,
         bool pack);
 
@@ -65,7 +65,7 @@ class NameInfoBuilder
     buildTerminal(
         NestedNameSpecifier NNS,
         NamedDecl const* D,
-        std::optional<ArrayRef<TemplateArgument>> const& TArgs,
+        Optional<ArrayRef<TemplateArgument>> const& TArgs,
         unsigned quals,
         bool pack);
 };
diff --git a/src/lib/AST/ParseJavadoc.cpp b/src/lib/AST/ParseJavadoc.cpp
index b65980e6b..9990dee6e 100644
--- a/src/lib/AST/ParseJavadoc.cpp
+++ b/src/lib/AST/ParseJavadoc.cpp
@@ -1106,7 +1106,7 @@ std::string
 JavadocVisitor::
 fixReference(std::string& ref)
 {
-    auto peekNextIt = [&]() -> std::optional<std::string_view>
+    auto peekNextIt = [&]() -> Optional<std::string_view>
     {
         ++it_;
         if (it_ == end_ ||
@@ -1794,7 +1794,7 @@ initCustomCommentCommands(ASTContext& context)
 
 void
 parseJavadoc(
-    std::optional<Javadoc>& jd,
+    Optional<Javadoc>& jd,
     FullComment const* FC,
     Decl const* D,
     Config const& config,
diff --git a/src/lib/AST/ParseJavadoc.hpp b/src/lib/AST/ParseJavadoc.hpp
index 429bcf81d..ff18d72b3 100644
--- a/src/lib/AST/ParseJavadoc.hpp
+++ b/src/lib/AST/ParseJavadoc.hpp
@@ -51,7 +51,7 @@ initCustomCommentCommands(
 */
 void
 parseJavadoc(
-    std::optional<Javadoc>& jd,
+    Optional<Javadoc>& jd,
     comments::FullComment const* FC,
     Decl const* D,
     Config const& config,
diff --git a/src/lib/AST/ParseRef.cpp b/src/lib/AST/ParseRef.cpp
index a5ffdc3fa..42bfb6cd6 100644
--- a/src/lib/AST/ParseRef.cpp
+++ b/src/lib/AST/ParseRef.cpp
@@ -1931,12 +1931,12 @@ class RefParser
                 // Bounds.Value is an optional integer with the value
                 // Bounds.Written is the original string representation
                 // of the bounds
-                std::optional<std::uint64_t> boundsValue = 0;
+                Optional<std::uint64_t> boundsValue = 0;
                 if (ConstantExprInfo<std::uint64_t> Bounds;
                     parseInteger(boundsValue) &&
                     peek(']', ' '))
                 {
-                    Bounds.Value = boundsValue;
+                    Bounds.Value = *boundsValue;
                     Bounds.Written = std::string_view(exprStart, ptr_ - exprStart);
                     ATI.Bounds = Bounds;
                     if (!parseLiteral("]"))
@@ -2021,7 +2021,7 @@ class RefParser
     }
 
     bool
-    parseInteger(std::optional<std::uint64_t>& dest)
+    parseInteger(Optional<std::uint64_t>& dest)
     {
         if (!hasMore())
         {
diff --git a/src/lib/AST/TerminalTypeVisitor.hpp b/src/lib/AST/TerminalTypeVisitor.hpp
index ee2821f90..838f0c3d7 100644
--- a/src/lib/AST/TerminalTypeVisitor.hpp
+++ b/src/lib/AST/TerminalTypeVisitor.hpp
@@ -255,7 +255,7 @@ class TerminalTypeVisitor
     buildTerminal(
         NestedNameSpecifier,
         IdentifierInfo const*,
-        std::optional<ArrayRef<TemplateArgument>>,
+        Optional<ArrayRef<TemplateArgument>>,
         unsigned,
         bool)
     {
@@ -270,7 +270,7 @@ class TerminalTypeVisitor
     buildTerminal(
         NestedNameSpecifier,
         NamedDecl*,
-        std::optional<ArrayRef<TemplateArgument>>,
+        Optional<ArrayRef<TemplateArgument>>,
         unsigned,
         bool)
     {
@@ -616,7 +616,7 @@ class TerminalTypeVisitor
         RecordDecl* RD = T->getOriginalDecl()->getDefinitionOrSelf();
         // if this is an instantiation of a class template,
         // create a SpecializationTypeInfo & extract the template arguments
-        std::optional<ArrayRef<TemplateArgument>> TArgs = std::nullopt;
+        Optional<ArrayRef<TemplateArgument>> TArgs = std::nullopt;
         if (auto const* CTSD = dyn_cast<ClassTemplateSpecializationDecl>(RD))
         {
             TArgs = CTSD->getTemplateArgs().asArray();
diff --git a/src/lib/AST/TypeInfoBuilder.cpp b/src/lib/AST/TypeInfoBuilder.cpp
index 76bc6512d..39c173518 100644
--- a/src/lib/AST/TypeInfoBuilder.cpp
+++ b/src/lib/AST/TypeInfoBuilder.cpp
@@ -134,7 +134,7 @@ buildAuto(
     I.Keyword = toAutoKind(T->getKeyword());
     if(T->isConstrained())
     {
-        std::optional<ArrayRef<TemplateArgument>> TArgs;
+        Optional<ArrayRef<TemplateArgument>> TArgs;
         if(auto Args = T->getTypeConstraintArguments();
             ! Args.empty())
         {
@@ -180,7 +180,7 @@ TypeInfoBuilder::
 buildTerminal(
     NestedNameSpecifier NNS,
     IdentifierInfo const* II,
-    std::optional<ArrayRef<TemplateArgument>> TArgs,
+    Optional<ArrayRef<TemplateArgument>> TArgs,
     unsigned quals,
     bool pack)
 {
@@ -222,7 +222,7 @@ TypeInfoBuilder::
 buildTerminal(
     NestedNameSpecifier NNS,
     NamedDecl* D,
-    std::optional<ArrayRef<TemplateArgument>> TArgs,
+    Optional<ArrayRef<TemplateArgument>> TArgs,
     unsigned quals,
     bool pack)
 {
diff --git a/src/lib/AST/TypeInfoBuilder.hpp b/src/lib/AST/TypeInfoBuilder.hpp
index d1bb7c5e6..361ce04e9 100644
--- a/src/lib/AST/TypeInfoBuilder.hpp
+++ b/src/lib/AST/TypeInfoBuilder.hpp
@@ -219,7 +219,7 @@ class TypeInfoBuilder
     void buildTerminal(
         NestedNameSpecifier NNS,
         IdentifierInfo const* II,
-        std::optional<ArrayRef<TemplateArgument>> TArgs,
+        Optional<ArrayRef<TemplateArgument>> TArgs,
         unsigned quals,
         bool pack);
 
@@ -241,7 +241,7 @@ class TypeInfoBuilder
     void buildTerminal(
         NestedNameSpecifier NNS,
         NamedDecl* D,
-        std::optional<ArrayRef<TemplateArgument>> TArgs,
+        Optional<ArrayRef<TemplateArgument>> TArgs,
         unsigned quals,
         bool pack);
 };
diff --git a/src/lib/CorpusImpl.cpp b/src/lib/CorpusImpl.cpp
index 1975164dc..a1c5316e2 100644
--- a/src/lib/CorpusImpl.cpp
+++ b/src/lib/CorpusImpl.cpp
@@ -590,7 +590,7 @@ lookupImpl(
             TemplateInfo const* templateInfo = [&]() -> TemplateInfo const* {
                 if constexpr (requires { M.Template; })
                 {
-                    std::optional<TemplateInfo> const& OTI = M.Template;
+                    Optional<TemplateInfo> const& OTI = M.Template;
                     MRDOCS_CHECK_OR(OTI, nullptr);
                     TemplateInfo const& TI = *OTI;
                     return &TI;
diff --git a/src/lib/Gen/adoc/AdocEscape.cpp b/src/lib/Gen/adoc/AdocEscape.cpp
index 0044d71eb..c9461f6ca 100644
--- a/src/lib/Gen/adoc/AdocEscape.cpp
+++ b/src/lib/Gen/adoc/AdocEscape.cpp
@@ -18,7 +18,7 @@ namespace clang::mrdocs::adoc {
 namespace {
 
 constexpr
-std::optional<std::string_view>
+Optional<std::string_view>
 HTMLNamedEntity(char const c)
 {
     // If c has a named entity, we use it
diff --git a/src/lib/Gen/hbs/SinglePageVisitor.hpp b/src/lib/Gen/hbs/SinglePageVisitor.hpp
index 9d938819b..cb69d8883 100644
--- a/src/lib/Gen/hbs/SinglePageVisitor.hpp
+++ b/src/lib/Gen/hbs/SinglePageVisitor.hpp
@@ -31,7 +31,7 @@ class SinglePageVisitor
     std::size_t numSymbols_ = 0;
     std::mutex mutex_;
     std::size_t topSymbol_ = 0;
-    std::vector<std::optional<std::string>> symbols_;
+    std::vector<Optional<std::string>> symbols_;
 
     void writePage(std::string pageText, std::size_t symbolIdx);
 public:
diff --git a/src/lib/Gen/hbs/VisitorHelpers.cpp b/src/lib/Gen/hbs/VisitorHelpers.cpp
index ce3629233..af18610cf 100644
--- a/src/lib/Gen/hbs/VisitorHelpers.cpp
+++ b/src/lib/Gen/hbs/VisitorHelpers.cpp
@@ -101,7 +101,7 @@ findPrimarySiblingWithUrl(Corpus const& c, Info const& I, Info const& parent)
                 {
                     if constexpr (requires { V.Template; })
                     {
-                        std::optional<TemplateInfo> const& Template = V.Template;
+                        Optional<TemplateInfo> const& Template = V.Template;
                         MRDOCS_CHECK_OR(Template, false);
                         return !Template->Params.empty() && Template->Args.empty();
                     }
@@ -160,7 +160,7 @@ findResolvedPrimarySiblingWithUrl(Corpus const& c, Info const& I)
         // The symbol is a specialization
         if constexpr (requires { U.Template; })
         {
-            std::optional<TemplateInfo> const& Template = U.Template;
+            Optional<TemplateInfo> const& Template = U.Template;
             if (Template &&
                 !Template->Args.empty())
             {
diff --git a/src/lib/Gen/xml/XMLWriter.cpp b/src/lib/Gen/xml/XMLWriter.cpp
index 48ac28a9a..e0acb15dc 100644
--- a/src/lib/Gen/xml/XMLWriter.cpp
+++ b/src/lib/Gen/xml/XMLWriter.cpp
@@ -569,7 +569,7 @@ writeLocation(
 void
 XMLWriter::
 openTemplate(
-    const std::optional<TemplateInfo>& I)
+    Optional<TemplateInfo> const& I)
 {
     if(! I)
         return;
@@ -591,7 +591,7 @@ openTemplate(
 void
 XMLWriter::
 closeTemplate(
-    const std::optional<TemplateInfo>& I)
+    const Optional<TemplateInfo>& I)
 {
     if(! I)
         return;
@@ -603,7 +603,7 @@ closeTemplate(
 void
 XMLWriter::
 writeJavadoc(
-    std::optional<Javadoc> const& javadoc)
+    Optional<Javadoc> const& javadoc)
 {
     if (!javadoc)
     {
diff --git a/src/lib/Gen/xml/XMLWriter.hpp b/src/lib/Gen/xml/XMLWriter.hpp
index 75e45752b..b165c7ac3 100644
--- a/src/lib/Gen/xml/XMLWriter.hpp
+++ b/src/lib/Gen/xml/XMLWriter.hpp
@@ -57,10 +57,10 @@ class XMLWriter
 
     void writeSourceInfo(SourceInfo const& I);
     void writeLocation(Location const& loc, bool def = false);
-    void writeJavadoc(std::optional<Javadoc> const& javadoc);
+    void writeJavadoc(Optional<Javadoc> const& javadoc);
     void writeFriend(FriendInfo const& I);
-    void openTemplate(const std::optional<TemplateInfo>& I);
-    void closeTemplate(const std::optional<TemplateInfo>& I);
+    void openTemplate(Optional<TemplateInfo> const& I);
+    void closeTemplate(Optional<TemplateInfo> const& I);
 
     // ---------------
     // Javadoc types
diff --git a/src/lib/Metadata/Finalizers/Javadoc/Function.hpp b/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
index cfff7267c..bd301d7c6 100644
--- a/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
+++ b/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
@@ -103,7 +103,7 @@ isMoveAssignment(FunctionInfo const& I)
     return isCopyOrMoveConstructorOrAssignment<true, true>(I);
 }
 
-std::optional<std::string_view>
+Optional<std::string_view>
 innermostTypenameString(Polymorphic<TypeInfo> const& T)
 {
     auto& R = innermostType(T);
@@ -115,7 +115,7 @@ innermostTypenameString(Polymorphic<TypeInfo> const& T)
     return RStr;
 }
 
-std::optional<std::string_view>
+Optional<std::string_view>
 innermostTypenameString(Optional<Polymorphic<TypeInfo>> const& T)
 {
     MRDOCS_CHECK_OR(T, {});
diff --git a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp b/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
index 887ef651d..733424cb4 100644
--- a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
@@ -1381,7 +1381,7 @@ copyDetails(Javadoc& javadoc)
         }
 
         // Find copydetails command
-        std::optional<doc::CopyDetails> copied;
+        Optional<doc::CopyDetails> copied;
         for (auto textIt = para.children.begin(); textIt != para.children.end();)
         {
             // Find copydoc command
diff --git a/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp b/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp
index f8b36b38e..eaa345770 100644
--- a/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp
@@ -22,13 +22,13 @@ struct SymbolIDCompareFn
 
     template <class InfoTy>
     static
-    std::optional<FunctionClass>
+    Optional<FunctionClass>
     findFunctionClass(InfoTy const& I)
     {
         if constexpr (std::same_as<InfoTy, Info>)
         {
             return visit(I, []<class U>(U const& u)
-                -> std::optional<FunctionClass>
+                -> Optional<FunctionClass>
             {
                 return findFunctionClass<U>(u);
             });
@@ -44,13 +44,13 @@ struct SymbolIDCompareFn
 
     template <class InfoTy>
     static
-    std::optional<OperatorKind>
+    Optional<OperatorKind>
     findOperatorKind(InfoTy const& I)
     {
         if constexpr (std::same_as<InfoTy, Info>)
         {
             return visit(I, []<class U>(U const& u)
-                -> std::optional<OperatorKind>
+                -> Optional<OperatorKind>
             {
                 return findOperatorKind<U>(u);
             });
@@ -76,8 +76,8 @@ struct SymbolIDCompareFn
         Info const& rhs = *rhsPtr;
 
         // Constructors come first
-        std::optional<FunctionClass> const lhsClass = findFunctionClass(lhs);
-        std::optional<FunctionClass> const rhsClass = findFunctionClass(rhs);
+        Optional<FunctionClass> const lhsClass = findFunctionClass(lhs);
+        Optional<FunctionClass> const rhsClass = findFunctionClass(rhs);
         if (corpus_.config->sortMembersCtors1St)
         {
             bool const lhsIsCtor = lhsClass && *lhsClass == FunctionClass::Constructor;
@@ -100,8 +100,8 @@ struct SymbolIDCompareFn
         }
 
         // Assignment operators come next
-        std::optional<OperatorKind> const lhsOp = findOperatorKind(lhs);
-        std::optional<OperatorKind> const rhsOp = findOperatorKind(rhs);
+        Optional<OperatorKind> const lhsOp = findOperatorKind(lhs);
+        Optional<OperatorKind> const rhsOp = findOperatorKind(rhs);
         if (corpus_.config->sortMembersAssignment1St)
         {
             bool const lhsIsAssign = lhsOp && *lhsOp == OperatorKind::Equal;
diff --git a/src/lib/Metadata/Info/Function.cpp b/src/lib/Metadata/Info/Function.cpp
index 3a79a95fe..73fec236f 100644
--- a/src/lib/Metadata/Info/Function.cpp
+++ b/src/lib/Metadata/Info/Function.cpp
@@ -168,7 +168,7 @@ getSafeOperatorName(
     return full.substr(9);
 }
 
-std::optional<std::string_view>
+Optional<std::string_view>
 getOperatorReadableName(
     OperatorKind const kind,
     int const nParams)
diff --git a/src/lib/Metadata/Type.cpp b/src/lib/Metadata/Type.cpp
index ffd067b91..b94fce3c5 100644
--- a/src/lib/Metadata/Type.cpp
+++ b/src/lib/Metadata/Type.cpp
@@ -782,7 +782,7 @@ template <
     class Ptr = std::conditional_t<isMutable, Polymorphic<TypeInfo>*, Polymorphic<TypeInfo> const*>,
     class Ref = std::conditional_t<isMutable, std::reference_wrapper<Polymorphic<TypeInfo>>, std::reference_wrapper<Polymorphic<TypeInfo> const>>>
 requires std::same_as<std::remove_cvref_t<TypeInfoTy>, TypeInfo>
-std::optional<Ref>
+Optional<Ref>
 innerTypeImpl(TypeInfoTy&& TI) noexcept
 {
     // Get a pointer to the inner type
@@ -872,13 +872,13 @@ innermostTypeImpl(PolymorphicTypeInfoTy&& TI) noexcept
 
 }
 
-std::optional<std::reference_wrapper<Polymorphic<TypeInfo> const>>
+Optional<std::reference_wrapper<Polymorphic<TypeInfo> const>>
 innerType(TypeInfo const& TI) noexcept
 {
     return innerTypeImpl(TI);
 }
 
-std::optional<std::reference_wrapper<Polymorphic<TypeInfo>>>
+Optional<std::reference_wrapper<Polymorphic<TypeInfo>>>
 innerType(TypeInfo& TI) noexcept
 {
     return innerTypeImpl(TI);
diff --git a/src/lib/Support/Glob.cpp b/src/lib/Support/Glob.cpp
index 9f840fbe7..fd0028037 100644
--- a/src/lib/Support/Glob.cpp
+++ b/src/lib/Support/Glob.cpp
@@ -86,7 +86,7 @@ parseCharRange(
 Expected<llvm::SmallVector<std::string, 1>>
 parseBraceExpansions(
     std::string_view str,
-    std::optional<std::size_t> const max)
+    Optional<std::size_t> const max)
 {
     // If there are no brace expansions, return the original string
     // as the only subpattern.
@@ -365,7 +365,7 @@ match(std::string_view str, char const delimiter) const
     std::string_view starStr = str;
 
     // The pattern suffix after the "*" run.
-    std::optional<std::string_view> patternStarSuffix;
+    Optional<std::string_view> patternStarSuffix;
 
     // The saved brackets index for backtracking.
     std::size_t bracketsStarMatchIdx = 0;
@@ -564,7 +564,7 @@ Expected<GlobPattern>
 GlobPattern::
 create(
     std::string_view const pattern,
-    std::optional<std::size_t> maxSubGlobs)
+    Optional<std::size_t> maxSubGlobs)
 {
     if (pattern.empty())
     {
diff --git a/src/lib/Support/Handlebars.cpp b/src/lib/Support/Handlebars.cpp
index b5fb3db5b..f9ee2d2b1 100644
--- a/src/lib/Support/Handlebars.cpp
+++ b/src/lib/Support/Handlebars.cpp
@@ -3354,7 +3354,7 @@ renderBlock(
         return {};
     };
 
-    std::optional<HandlebarsError> hbs_error;
+    Optional<HandlebarsError> hbs_error;
     if (!tag.rawBlock) {
         cb.set("write", dom::makeInvocable([&out, &write_nested_block, &hbs_error](
             dom::Value const& newContext,
diff --git a/src/lib/Support/Report.cpp b/src/lib/Support/Report.cpp
index afeefb023..efe1e7f72 100644
--- a/src/lib/Support/Report.cpp
+++ b/src/lib/Support/Report.cpp
@@ -8,22 +8,23 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
+#include <mrdocs/Platform.hpp>
 #include <lib/Support/Report.hpp>
 #include <mrdocs/Support/Path.hpp>
 #include <mrdocs/Version.hpp>
 #include <llvm/Support/Mutex.h>
-#include <llvm/Support/Signals.h>
 #include <llvm/Support/raw_ostream.h>
+#include <llvm/Support/Signals.h>
 #include <cstdlib>
 #include <format>
 #include <mutex>
 
 #ifdef _MSC_VER
 #define WIN32_LEAN_AND_MEAN
-#    include <crtdbg.h>
-#    include <debugapi.h>
-#    include <sstream>
-#    include <windows.h>
+#include <windows.h>
+#include <debugapi.h>
+#include <crtdbg.h>
+#include <sstream>
 #endif
 
 namespace SourceFileNames {
diff --git a/src/test/ADT/Optional.cpp b/src/test/ADT/Optional.cpp
index 08c32b3fc..b7478b3c0 100644
--- a/src/test/ADT/Optional.cpp
+++ b/src/test/ADT/Optional.cpp
@@ -166,7 +166,7 @@ struct OptionalTest {
     {
         static_assert(
             !has_nullable_traits_v<NoTraits>,
-            "NoTraits must fall back to std::optional");
+            "NoTraits must fall back to Optional");
         Optional<NoTraits> o;
         BOOST_TEST(!o.has_value()); // default disengaged
 
diff --git a/src/test/lib/Dom/Dom.cpp b/src/test/lib/Dom/Dom.cpp
index c06e4e990..765b5f52d 100644
--- a/src/test/lib/Dom/Dom.cpp
+++ b/src/test/lib/Dom/Dom.cpp
@@ -1132,16 +1132,16 @@ struct Dom_test
             BOOST_TEST(v == "hello");
         }
 
-        // Value(std::optional<T> const& opt)
+        // Value(Optional<T> const& opt)
         {
             {
-                std::optional<dom::Value> opt;
+                Optional<dom::Value> opt;
                 Value v(opt);
                 BOOST_TEST(v.isUndefined());
             }
 
             {
-                std::optional<dom::Value> opt(123);
+                Optional<dom::Value> opt(123);
                 Value v(opt);
                 BOOST_TEST(v.isInteger());
                 BOOST_TEST(v == 123);
diff --git a/src/test/lib/Support/Handlebars.cpp b/src/test/lib/Support/Handlebars.cpp
index 1547a96d3..e0cef2c68 100644
--- a/src/test/lib/Support/Handlebars.cpp
+++ b/src/test/lib/Support/Handlebars.cpp
@@ -5270,19 +5270,19 @@ to_dom(llvm::json::Value& val)
     }
 
     // val is string
-    std::optional<llvm::StringRef> str_opt = val.getAsString();
+    Optional<llvm::StringRef> str_opt = val.getAsString();
     if (str_opt) {
         return str_opt.value().str();
     }
 
     // val is integer
-    std::optional<std::int64_t> int_opt = val.getAsInteger();
+    Optional<std::int64_t> int_opt = val.getAsInteger();
     if (int_opt) {
         return int_opt.value();
     }
 
     // val is double (convert to string)
-    std::optional<double> num_opt = val.getAsNumber();
+    Optional<double> num_opt = val.getAsNumber();
     if (num_opt) {
         std::string double_str = std::to_string(num_opt.value());
         double_str.erase(double_str.find_last_not_of('0') + 1, std::string::npos);
@@ -5290,7 +5290,7 @@ to_dom(llvm::json::Value& val)
     }
 
     // val is bool
-    std::optional<bool> bool_opt = val.getAsBoolean();
+    Optional<bool> bool_opt = val.getAsBoolean();
     if (bool_opt) {
         return bool_opt.value();
     }
diff --git a/src/tool/CompilerInfo.cpp b/src/tool/CompilerInfo.cpp
index 2cee25fa5..f53d1a8b0 100644
--- a/src/tool/CompilerInfo.cpp
+++ b/src/tool/CompilerInfo.cpp
@@ -17,7 +17,7 @@
 namespace clang {
 namespace mrdocs {
 
-std::optional<std::string> 
+Optional<std::string>
 getCompilerVerboseOutput(llvm::StringRef compilerPath) 
 {
     if ( ! llvm::sys::fs::exists(compilerPath))
diff --git a/src/tool/CompilerInfo.hpp b/src/tool/CompilerInfo.hpp
index fa8138ae7..10cd30c58 100644
--- a/src/tool/CompilerInfo.hpp
+++ b/src/tool/CompilerInfo.hpp
@@ -11,6 +11,7 @@
 #ifndef MRDOCS_TOOL_COMPILERINFO_HPP
 #define MRDOCS_TOOL_COMPILERINFO_HPP
 
+#include <mrdocs/ADT/Optional.hpp>
 #include <clang/Tooling/CompilationDatabase.h>
 #include <llvm/ADT/StringRef.h>
 #include <optional>
@@ -25,9 +26,9 @@ namespace mrdocs {
  * @brief Get the compiler verbose output.
  * 
  * @param compilerPath The compiler path.
- * @return std::optional<std::string> The compiler verbose output.
+ * @return The compiler verbose output.
 */
-std::optional<std::string> 
+Optional<std::string>
 getCompilerVerboseOutput(llvm::StringRef compilerPath);
 
 /**

From 6102c4aeb6c79aab01501b23c3b3175413dc2194 Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Thu, 25 Sep 2025 18:38:40 -0500
Subject: [PATCH 10/23] refactor(lib): Info contains SourceInfo as composition

Info objects contain Source information rather than _being_ source information.
---
 include/mrdocs/Metadata/Info/FileKind.hpp     |  49 +++++++
 include/mrdocs/Metadata/Info/InfoBase.hpp     |  11 +-
 include/mrdocs/Metadata/Info/Location.hpp     | 120 ++++++++++++++++
 include/mrdocs/Metadata/Info/Source.hpp       | 135 +-----------------
 src/lib/AST/ASTVisitor.cpp                    |   6 +-
 src/lib/Gen/xml/XMLWriter.cpp                 |  20 +--
 .../Metadata/Finalizers/JavadocFinalizer.cpp  |   2 +-
 src/lib/Metadata/Info.cpp                     |   2 +-
 src/lib/Metadata/Info/Overloads.cpp           |   2 +-
 src/lib/Metadata/InfoSet.hpp                  |   6 +-
 src/lib/Metadata/Source.cpp                   |   2 +
 src/lib/Support/Report.cpp                    |   2 +
 src/test_suite/test_suite.cpp                 |   2 +
 13 files changed, 204 insertions(+), 155 deletions(-)
 create mode 100644 include/mrdocs/Metadata/Info/FileKind.hpp
 create mode 100644 include/mrdocs/Metadata/Info/Location.hpp

diff --git a/include/mrdocs/Metadata/Info/FileKind.hpp b/include/mrdocs/Metadata/Info/FileKind.hpp
new file mode 100644
index 000000000..03e4a4fca
--- /dev/null
+++ b/include/mrdocs/Metadata/Info/FileKind.hpp
@@ -0,0 +1,49 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_INFO_FILEKIND_HPP
+#define MRDOCS_API_METADATA_INFO_FILEKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Nullable.hpp>
+#include <mrdocs/Dom.hpp>
+#include <string>
+
+namespace clang::mrdocs {
+
+enum class FileKind
+{
+    /// File in the source directory
+    Source,
+    /// File in a system include directory
+    System,
+    /// File outside the source directory
+    Other
+};
+
+MRDOCS_DECL
+std::string_view
+toString(FileKind kind);
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    FileKind kind)
+{
+    v = toString(kind);
+}
+
+} // clang::mrdocs
+
+#endif // MRDOCS_API_METADATA_INFO_FILEKIND_HPP
diff --git a/include/mrdocs/Metadata/Info/InfoBase.hpp b/include/mrdocs/Metadata/Info/InfoBase.hpp
index 7048821b1..6de915403 100644
--- a/include/mrdocs/Metadata/Info/InfoBase.hpp
+++ b/include/mrdocs/Metadata/Info/InfoBase.hpp
@@ -30,8 +30,11 @@ namespace clang::mrdocs {
 /** Base class with common properties of all symbols
 */
 struct MRDOCS_VISIBLE Info
-    : SourceInfo
 {
+    /** The source location information.
+     */
+    SourceInfo Loc;
+
     /** The unique identifier for this symbol.
     */
     SymbolID id;
@@ -82,7 +85,7 @@ struct MRDOCS_VISIBLE Info
 
     //--------------------------------------------
 
-    ~Info() override = default;
+    virtual ~Info() = default;
 
     #define INFO(Type) constexpr bool is##Type() const noexcept { \
         return Kind == InfoKind::Type; \
@@ -246,7 +249,7 @@ tag_invoke(
     {
         io.map("doc", *I.javadoc);
     }
-    io.map("loc", dynamic_cast<SourceInfo const&>(I));
+    io.map("loc", I.Loc);
 }
 
 /** Return the Info as a @ref dom::Value object.
@@ -267,7 +270,7 @@ Optional<Location>
 getPrimaryLocation(Info const& I)
 {
     return getPrimaryLocation(
-        dynamic_cast<SourceInfo const&>(I),
+        I.Loc,
         I.isRecord() || I.isEnum());
 }
 
diff --git a/include/mrdocs/Metadata/Info/Location.hpp b/include/mrdocs/Metadata/Info/Location.hpp
new file mode 100644
index 000000000..f102947a9
--- /dev/null
+++ b/include/mrdocs/Metadata/Info/Location.hpp
@@ -0,0 +1,120 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_INFO_LOCATION_HPP
+#define MRDOCS_API_METADATA_INFO_LOCATION_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Nullable.hpp>
+#include <mrdocs/Dom.hpp>
+#include <string>
+
+namespace clang::mrdocs {
+
+struct MRDOCS_DECL
+    Location
+{
+    /** The full file path
+    */
+    std::string FullPath;
+
+    /** The file path relative to one of the search directories
+    */
+    std::string ShortPath;
+
+    /** The file path relative to the source-root directory
+     */
+    std::string SourcePath;
+
+    /** Line number within the file
+    */
+    unsigned LineNumber = 0;
+
+    /** Whether this location has documentation.
+    */
+    bool Documented = false;
+
+    //--------------------------------------------
+
+    constexpr
+    Location(
+        std::string_view const full_path = {},
+        std::string_view const short_path = {},
+        std::string_view const source_path = {},
+        unsigned const line = 0,
+        bool const documented = false)
+        : FullPath(full_path)
+        , ShortPath(short_path)
+        , SourcePath(source_path)
+        , LineNumber(line)
+        , Documented(documented)
+    {
+    }
+
+    auto operator<=>(Location const&) const = default;
+};
+
+MRDOCS_DECL
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Location const& loc);
+
+/** nullable_traits specialization for Location.
+
+    Semantics
+    - The “null” (sentinel) state is any Location whose ShortPath is empty.
+    - Creating a null value produces a Location with all fields defaulted
+      and ShortPath empty.
+    - Making an existing value null clears ShortPath and resets the other
+      fields to their defaults.
+
+    Rationale
+    - This mirrors the old LocationEmptyPredicate, which treated an empty
+      ShortPath as “empty/null.”
+**/
+template<>
+struct nullable_traits<Location>
+{
+    static constexpr bool
+    is_null(Location const& v) noexcept
+    {
+        return v.ShortPath.empty();
+    }
+
+    static constexpr Location
+    null() noexcept
+    {
+        return Location{
+            /*full_path*/   {},
+            /*short_path*/  {},
+            /*source_path*/ {},
+            /*line*/        0u,
+            /*documented*/  false
+        };
+    }
+
+    static constexpr void
+    make_null(Location& v) noexcept
+    {
+        v.FullPath.clear();
+        v.ShortPath.clear();    // sentinel condition
+        v.SourcePath.clear();
+        v.LineNumber  = 0;
+        v.Documented  = false;
+    }
+};
+
+} // clang::mrdocs
+
+#endif // MRDOCS_API_METADATA_INFO_LOCATION_HPP
diff --git a/include/mrdocs/Metadata/Info/Source.hpp b/include/mrdocs/Metadata/Info/Source.hpp
index 8e4f75d01..bbf39accc 100644
--- a/include/mrdocs/Metadata/Info/Source.hpp
+++ b/include/mrdocs/Metadata/Info/Source.hpp
@@ -14,136 +14,20 @@
 #define MRDOCS_API_METADATA_INFO_SOURCE_HPP
 
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/Info/Location.hpp>
 #include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/Dom.hpp>
 #include <string>
 
 namespace clang::mrdocs {
 
-enum class FileKind
-{
-    /// File in the source directory
-    Source,
-    /// File in a system include directory
-    System,
-    /// File outside the source directory
-    Other
-};
-
-MRDOCS_DECL
-std::string_view
-toString(FileKind kind);
-
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    FileKind kind)
-{
-    v = toString(kind);
-}
-
-struct MRDOCS_DECL
-    Location
-{
-    /** The full file path
-    */
-    std::string FullPath;
-
-    /** The file path relative to one of the search directories
-    */
-    std::string ShortPath;
-
-    /** The file path relative to the source-root directory
-     */
-    std::string SourcePath;
-
-    /** Line number within the file
-    */
-    unsigned LineNumber = 0;
-
-    /** Whether this location has documentation.
-    */
-    bool Documented = false;
-
-    //--------------------------------------------
-
-    constexpr
-    Location(
-        std::string_view const full_path = {},
-        std::string_view const short_path = {},
-        std::string_view const source_path = {},
-        unsigned const line = 0,
-        bool const documented = false)
-        : FullPath(full_path)
-        , ShortPath(short_path)
-        , SourcePath(source_path)
-        , LineNumber(line)
-        , Documented(documented)
-    {
-    }
-
-    auto operator<=>(Location const&) const = default;
-};
-
-MRDOCS_DECL
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Location const& loc);
-
-/** nullable_traits specialization for Location.
-
-    Semantics
-    - The “null” (sentinel) state is any Location whose ShortPath is empty.
-    - Creating a null value produces a Location with all fields defaulted
-      and ShortPath empty.
-    - Making an existing value null clears ShortPath and resets the other
-      fields to their defaults.
-
-    Rationale
-    - This mirrors the old LocationEmptyPredicate, which treated an empty
-      ShortPath as “empty/null.”
-**/
-template<>
-struct nullable_traits<Location>
-{
-    static constexpr bool
-    is_null(Location const& v) noexcept
-    {
-        return v.ShortPath.empty();
-    }
-
-    static constexpr Location
-    null() noexcept
-    {
-        return Location{
-            /*full_path*/   {},
-            /*short_path*/  {},
-            /*source_path*/ {},
-            /*line*/        0u,
-            /*documented*/  false
-        };
-    }
-
-    static constexpr void
-    make_null(Location& v) noexcept
-    {
-        v.FullPath.clear();
-        v.ShortPath.clear();    // sentinel condition
-        v.SourcePath.clear();
-        v.LineNumber  = 0;
-        v.Documented  = false;
-    }
-};
-
 /** Stores source information for a declaration.
 */
 struct MRDOCS_DECL
     SourceInfo
 {
+    constexpr SourceInfo() = default;
+
     /** Location where the entity was defined
 
         KRYSTIAN NOTE: this is used for entities which cannot be
@@ -159,22 +43,9 @@ struct MRDOCS_DECL
     */
     std::vector<Location> Loc;
 
-    constexpr SourceInfo const& asSourceInfo() const noexcept
-    {
-        return *this;
-    }
-
-    constexpr SourceInfo& asSourceInfo() noexcept
-    {
-        return *this;
-    }
-
     constexpr virtual ~SourceInfo() = default;
 
     auto operator<=>(SourceInfo const&) const = default;
-
-protected:
-    constexpr SourceInfo() = default;
 };
 
 MRDOCS_DECL
diff --git a/src/lib/AST/ASTVisitor.cpp b/src/lib/AST/ASTVisitor.cpp
index 550b0720e..53eee91c8 100644
--- a/src/lib/AST/ASTVisitor.cpp
+++ b/src/lib/AST/ASTVisitor.cpp
@@ -525,7 +525,7 @@ ASTVisitor::
 populate(Info& I, bool const isNew, DeclTy const* D)
 {
     populate(I.javadoc, D);
-    populate(I.asSourceInfo(), D);
+    populate(I.Loc, D);
 
     // All other information is redundant if the symbol is not new
     MRDOCS_CHECK_OR(isNew);
@@ -550,7 +550,7 @@ populate(SourceInfo& I, DeclTy const* D)
     if (Loc.isValid())
     {
         populate(
-            I.asSourceInfo(),
+            I,
             Loc,
             isDefinition(D),
             isDocumented(D));
@@ -3532,7 +3532,7 @@ checkUndocumented(
         // Populate the location
         auto handle = undocumented_.extract(undocIt);
         UndocumentedInfo& UI = handle.value();
-        populate(UI.asSourceInfo(), D);
+        populate(UI.Loc, D);
         undocumented_.insert(std::move(handle));
     }
     return Unexpected(Error("Undocumented"));
diff --git a/src/lib/Gen/xml/XMLWriter.cpp b/src/lib/Gen/xml/XMLWriter.cpp
index e0acb15dc..06a92ba35 100644
--- a/src/lib/Gen/xml/XMLWriter.cpp
+++ b/src/lib/Gen/xml/XMLWriter.cpp
@@ -147,7 +147,7 @@ writeEnum(
         tags_.close(baseTagName);
     }
 
-    writeSourceInfo(I);
+    writeSourceInfo(I.Loc);
 
     writeJavadoc(I.javadoc);
 
@@ -173,7 +173,7 @@ writeEnumConstant(
         { I.id }
     });
 
-    writeSourceInfo(I);
+    writeSourceInfo(I.Loc);
 
     writeJavadoc(I.javadoc);
 
@@ -230,7 +230,7 @@ writeFunction(
         { I.id }
         });
 
-    writeSourceInfo(I);
+    writeSourceInfo(I.Loc);
 
     writeAttr(I.IsVariadic,            "is-variadic", tags_);
     writeAttr(I.IsVirtualAsWritten,    "is-virtual-as-written", tags_);
@@ -294,7 +294,7 @@ writeGuide(
         { I.id }
         });
 
-    writeSourceInfo(I);
+    writeSourceInfo(I.Loc);
 
     tags_.open(deducedTagName);
     writeType(I.Deduced, tags_);
@@ -325,7 +325,7 @@ writeConcept(
         { "constraint", I.Constraint.Written },
         });
 
-    writeSourceInfo(I);
+    writeSourceInfo(I.Loc);
 
     writeJavadoc(I.javadoc);
 
@@ -346,7 +346,7 @@ writeNamespaceAlias(
         { I.id }
         });
 
-    writeSourceInfo(I);
+    writeSourceInfo(I.Loc);
 
     writeJavadoc(I.javadoc);
 
@@ -395,7 +395,7 @@ XMLWriter::
         { "qualifier", qualifierStr, !qualifierStr.empty() }
     });
 
-    writeSourceInfo(I);
+    writeSourceInfo(I.Loc);
 
     writeJavadoc(I.javadoc);
 
@@ -420,7 +420,7 @@ writeRecord(
         { I.id }
         });
 
-    writeSourceInfo(I);
+    writeSourceInfo(I.Loc);
 
     writeAttr(I.IsFinal, "is-final", tags_);
     writeAttr(I.IsFinalDestructor, "is-final-dtor", tags_);
@@ -472,7 +472,7 @@ writeTypedef(
         { I.id }
         });
 
-    writeSourceInfo(I);
+    writeSourceInfo(I.Loc);
 
     writeType(I.Type, tags_);
 
@@ -506,7 +506,7 @@ writeVariable(
         { "default", I.Initializer.Written, ! I.Initializer.Written.empty() }
         });
 
-    writeSourceInfo(I);
+    writeSourceInfo(I.Loc);
 
     if(I.IsMutable)
         tags_.write(attributeTagName, {}, {
diff --git a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp b/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
index 733424cb4..87e04a857 100644
--- a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
@@ -1712,7 +1712,7 @@ warnUndocumented()
         bool const prefer_definition = undocI.kind == InfoKind::Record
                                  || undocI.kind == InfoKind::Enum;
         this->warn(
-            *getPrimaryLocation(undocI, prefer_definition),
+            *getPrimaryLocation(undocI.Loc, prefer_definition),
             "{}: Symbol is undocumented", undocI.name);
     }
     corpus_.undocumented_.clear();
diff --git a/src/lib/Metadata/Info.cpp b/src/lib/Metadata/Info.cpp
index 20c52b5c6..eb2ab26e2 100644
--- a/src/lib/Metadata/Info.cpp
+++ b/src/lib/Metadata/Info.cpp
@@ -41,7 +41,7 @@ void
 merge(Info& I, Info&& Other)
 {
     MRDOCS_ASSERT(I.id);
-    merge(I.asSourceInfo(), std::move(Other.asSourceInfo()));
+    merge(I.Loc, std::move(Other.Loc));
     if (I.Name == "")
     {
         I.Name = Other.Name;
diff --git a/src/lib/Metadata/Info/Overloads.cpp b/src/lib/Metadata/Info/Overloads.cpp
index a8f567ddd..4982bd1c6 100644
--- a/src/lib/Metadata/Info/Overloads.cpp
+++ b/src/lib/Metadata/Info/Overloads.cpp
@@ -60,7 +60,7 @@ addMember(OverloadsInfo& I, FunctionInfo const& Member)
             I.ReturnType = std::nullopt;
         }
     }
-    merge(I.asSourceInfo(), Member.asSourceInfo());
+    merge(I.Loc, Member.Loc);
     I.Members.push_back(Member.id);
 }
 
diff --git a/src/lib/Metadata/InfoSet.hpp b/src/lib/Metadata/InfoSet.hpp
index e6919ad30..9094a06fc 100644
--- a/src/lib/Metadata/InfoSet.hpp
+++ b/src/lib/Metadata/InfoSet.hpp
@@ -116,18 +116,18 @@ struct InfoPtrEqual
 using InfoSet = std::unordered_set<
     std::unique_ptr<Info>, InfoPtrHasher, InfoPtrEqual>;
 
-struct UndocumentedInfo final : SourceInfo {
+struct UndocumentedInfo final {
     SymbolID id;
     std::string name;
     InfoKind kind;
+    SourceInfo Loc;
 
     constexpr
     UndocumentedInfo(
         SymbolID id_,
         std::string name_,
         InfoKind kind_) noexcept
-        : SourceInfo()
-        , id(id_)
+        : id(id_)
         , name(std::move(name_))
         , kind(kind_)
     {
diff --git a/src/lib/Metadata/Source.cpp b/src/lib/Metadata/Source.cpp
index ae8e402f7..85c5e5737 100644
--- a/src/lib/Metadata/Source.cpp
+++ b/src/lib/Metadata/Source.cpp
@@ -12,6 +12,8 @@
 #include <mrdocs/Dom/LazyArray.hpp>
 #include <mrdocs/Dom/LazyObject.hpp>
 #include <mrdocs/Metadata/Info/Source.hpp>
+#include <mrdocs/Metadata/Info/Location.hpp>
+#include <mrdocs/Metadata/Info/FileKind.hpp>
 #include <llvm/ADT/STLExtras.h>
 #include <ranges>
 
diff --git a/src/lib/Support/Report.cpp b/src/lib/Support/Report.cpp
index efe1e7f72..54180cbfb 100644
--- a/src/lib/Support/Report.cpp
+++ b/src/lib/Support/Report.cpp
@@ -21,10 +21,12 @@
 
 #ifdef _MSC_VER
 #define WIN32_LEAN_AND_MEAN
+// clang-format off
 #include <windows.h>
 #include <debugapi.h>
 #include <crtdbg.h>
 #include <sstream>
+// clang-format on
 #endif
 
 namespace SourceFileNames {
diff --git a/src/test_suite/test_suite.cpp b/src/test_suite/test_suite.cpp
index 65ed8845a..0621a41eb 100644
--- a/src/test_suite/test_suite.cpp
+++ b/src/test_suite/test_suite.cpp
@@ -19,10 +19,12 @@
 
 #ifdef _MSC_VER
 #define WIN32_LEAN_AND_MEAN
+// clang-format off
 #include <windows.h>
 #include <debugapi.h>
 #include <crtdbg.h>
 #include <sstream>
+// clang-format on
 #endif
 
 namespace test_suite {

From ac3a830f953c6ae40c76e7917db9e7701788031f Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Thu, 25 Sep 2025 22:40:27 -0500
Subject: [PATCH 11/23] feat(lib): optional references

Support Optional for references and replace usages of Optional with reference wrappers in the codebase.
---
 include/mrdocs/ADT/Optional.hpp           | 296 ++++++++++++++++++++++
 include/mrdocs/Metadata/Info/InfoBase.hpp |  20 +-
 include/mrdocs/Metadata/Type.hpp          |   8 +-
 src/lib/AST/ParseRef.cpp                  |   6 +-
 src/lib/CorpusImpl.cpp                    |  15 +-
 src/lib/Metadata/Type.cpp                 |  50 ++--
 src/test/ADT/Optional.cpp                 | 107 ++++++++
 7 files changed, 463 insertions(+), 39 deletions(-)

diff --git a/include/mrdocs/ADT/Optional.hpp b/include/mrdocs/ADT/Optional.hpp
index a743fb9c4..1917a23cd 100644
--- a/include/mrdocs/ADT/Optional.hpp
+++ b/include/mrdocs/ADT/Optional.hpp
@@ -52,6 +52,9 @@ inline constexpr bool isOptionalV = false;
 
 template<typename T>
 inline constexpr bool isOptionalV<Optional<T>> = true;
+
+template<typename T>
+inline constexpr bool isOptionalV<Optional<T&>> = true;
 }
 
 /** A compact optional that automatically uses nullable_traits<T> when
@@ -632,6 +635,298 @@ concept isDerivedFromOptional = requires(T const& t) {
 
 } // namespace detail
 
+
+namespace detail {
+#if defined(__cpp_lib_reference_from_temporary)
+using std::reference_constructs_from_temporary_v;
+using std::reference_converts_from_temporary_v;
+#else
+template<class To, class From>
+concept reference_converts_from_temporary_v =
+    std::is_reference_v<To> &&
+    (
+        (!std::is_reference_v<From> &&
+         std::is_convertible_v<std::remove_cvref_t<From>*,
+                               std::remove_cvref_t<To>*>)
+        ||
+        (std::is_lvalue_reference_v<To> &&
+         std::is_const_v<std::remove_reference_t<To>> &&
+         std::is_convertible_v<From, const std::remove_cvref_t<To>&&> &&
+         !std::is_convertible_v<From, std::remove_cvref_t<To>&>)
+    );
+
+template <class To, class From>
+inline constexpr bool reference_constructs_from_temporary_v
+    = reference_converts_from_temporary_v<To, From>;
+#endif
+} // detail
+
+template <class T>
+class Optional<T&> {
+    T* p_ = nullptr;
+
+    template <class U>
+    static constexpr bool ok_bind_v
+        = std::is_constructible_v<T&, U>
+          && !detail::reference_constructs_from_temporary_v<T&, U>;
+
+public:
+    using value_type = T;
+
+    constexpr
+    Optional() noexcept = default;
+
+    constexpr
+    Optional(Optional const&) noexcept = default;
+
+    constexpr
+    Optional(Optional&&) noexcept = default;
+
+    constexpr
+    Optional(std::nullopt_t) noexcept
+        : Optional() {}
+
+    template <class U>
+    requires(
+        !std::is_same_v<std::remove_cvref_t<U>, Optional> &&
+        !std::is_same_v<std::remove_cvref_t<U>, std::in_place_t> &&
+        ok_bind_v<U>)
+    constexpr
+    explicit(!std::is_convertible_v<U, T&>)
+    Optional(U&& u)
+        noexcept(std::is_nothrow_constructible_v<T&, U>)
+    {
+        T& r(static_cast<U&&>(u));
+        p_ = std::addressof(r);
+    }
+
+    template <class U>
+    requires ok_bind_v<U&>
+    constexpr
+    explicit(!std::is_convertible_v<U&, T&>)
+    Optional(Optional<U>& rhs)
+        noexcept(std::is_nothrow_constructible_v<T&, U&>)
+    {
+        if (rhs)
+        {
+            p_ = std::addressof(*rhs);
+        }
+    }
+
+    template <class U>
+    requires ok_bind_v<U const&>
+    constexpr
+    explicit(!std::is_convertible_v<U const&, T&>)
+    Optional(Optional<U> const& rhs)
+        noexcept(std::is_nothrow_constructible_v<T&, U const&>)
+    {
+        if (rhs)
+        {
+            p_ = std::addressof(*rhs);
+        }
+    }
+
+    template <class U>
+    requires ok_bind_v<U&>
+    constexpr
+    Optional(std::optional<U>& o)
+        noexcept(std::is_nothrow_constructible_v<T&, U&>)
+    {
+        if (o)
+        {
+            p_ = std::addressof(*o);
+        }
+    }
+
+    template <class U>
+    requires ok_bind_v<U const&>
+    constexpr
+    Optional(std::optional<U> const& o)
+        noexcept(std::is_nothrow_constructible_v<T&, U const&>)
+    {
+        if (o)
+        {
+            p_ = std::addressof(*o);
+        }
+    }
+
+    constexpr Optional&
+    operator=(Optional const&) noexcept = default;
+
+    constexpr Optional&
+    operator=(Optional&&) noexcept = default;
+
+    constexpr Optional&
+    operator=(std::nullopt_t) noexcept
+    {
+        p_ = nullptr;
+        return *this;
+    }
+
+    template <class U>
+    requires ok_bind_v<U>
+    constexpr Optional&
+    operator=(U&& u)
+        noexcept(std::is_nothrow_constructible_v<T&, U>)
+    {
+        T& r(static_cast<U&&>(u));
+        p_ = std::addressof(r);
+        return *this;
+    }
+
+    template <class U>
+    requires ok_bind_v<U&>
+    constexpr
+    Optional&
+    operator=(Optional<U>& rhs)
+        noexcept(std::is_nothrow_constructible_v<T&, U&>)
+    {
+        p_ = rhs ? std::addressof(*rhs) : nullptr;
+        return *this;
+    }
+
+    template <class U>
+    requires ok_bind_v<U const&>
+    constexpr
+    Optional&
+    operator=(Optional<U> const& rhs)
+        noexcept(std::is_nothrow_constructible_v<T&, U const&>)
+    {
+        p_ = rhs ? std::addressof(*rhs) : nullptr;
+        return *this;
+    }
+
+    template <class U>
+    requires ok_bind_v<U>
+    constexpr
+    Optional&
+    operator=(Optional<U>&& rhs)
+        noexcept(std::is_nothrow_constructible_v<T&, U>)
+    {
+        p_ = rhs ? std::addressof(*rhs) : nullptr;
+        return *this;
+    }
+
+    template <class U>
+    requires ok_bind_v<U>
+    constexpr
+    value_type&
+    emplace(U&& u)
+        noexcept(std::is_nothrow_constructible_v<T&, U>)
+    {
+        T& r(static_cast<U&&>(u));
+        p_ = std::addressof(r);
+        return *p_;
+    }
+
+    static
+    constexpr
+    bool
+    is_inlined() noexcept
+    {
+        return true;
+    }
+
+    constexpr
+    bool
+    has_value() const noexcept
+    {
+        return p_ != nullptr;
+    }
+
+    constexpr
+    explicit
+    operator bool() const noexcept
+    {
+        return has_value();
+    }
+
+    constexpr
+    void
+    reset() noexcept
+    {
+        p_ = nullptr;
+    }
+
+    constexpr
+    value_type*
+    operator->() noexcept
+    {
+        MRDOCS_ASSERT(has_value());
+        return p_;
+    }
+
+    constexpr
+    value_type const*
+    operator->() const noexcept
+    {
+        MRDOCS_ASSERT(has_value());
+        return p_;
+    }
+
+    constexpr
+    value_type&
+    operator*() noexcept
+    {
+        MRDOCS_ASSERT(has_value());
+        return *p_;
+    }
+
+    constexpr
+    value_type const&
+    operator*() const noexcept
+    {
+        MRDOCS_ASSERT(has_value());
+        return *p_;
+    }
+
+    constexpr
+    value_type&
+    value() & noexcept
+    {
+        MRDOCS_ASSERT(has_value());
+        return *p_;
+    }
+
+    constexpr
+    value_type const&
+    value() const& noexcept
+    {
+        MRDOCS_ASSERT(has_value());
+        return *p_;
+    }
+
+    constexpr
+    value_type&
+    value() && noexcept
+    {
+        MRDOCS_ASSERT(has_value());
+        return *p_;
+    }
+
+    constexpr
+    value_type const&
+    value() const&& noexcept
+    {
+        MRDOCS_ASSERT(has_value());
+        return *p_;
+    }
+
+    constexpr void
+    swap(Optional& other) noexcept
+    {
+        using std::swap;
+        swap(p_, other.p_);
+    }
+};
+
+template <class T>
+constexpr void
+swap(Optional<T&>& a, Optional<T&>& b) noexcept
+{
+    a.swap(b);
+}
+
 /** Compares two Optional values for equality.
     Returns true if both are engaged and their contained values are equal, or both are disengaged.
     @return `true` if both optionals are engaged and equal, or both are disengaged; otherwise, `false`.
@@ -893,6 +1188,7 @@ operator<=>(Optional<T> const& x, U const& v)
 {
     return bool(x) ? *x <=> v : std::strong_ordering::less;
 }
+
 } // namespace clang::mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Info/InfoBase.hpp b/include/mrdocs/Metadata/Info/InfoBase.hpp
index 6de915403..59c1f9456 100644
--- a/include/mrdocs/Metadata/Info/InfoBase.hpp
+++ b/include/mrdocs/Metadata/Info/InfoBase.hpp
@@ -31,22 +31,22 @@ namespace clang::mrdocs {
 */
 struct MRDOCS_VISIBLE Info
 {
+    /** The unqualified name.
+     */
+    std::string Name;
+
     /** The source location information.
      */
     SourceInfo Loc;
 
-    /** The unique identifier for this symbol.
-    */
-    SymbolID id;
-
-    /** The unqualified name.
-    */
-    std::string Name;
-
     /** Kind of declaration.
     */
     InfoKind Kind = InfoKind::None;
 
+    /** The unique identifier for this symbol.
+     */
+    SymbolID id;
+
     /** Declaration access.
 
         Class members use:
@@ -152,8 +152,8 @@ struct MRDOCS_VISIBLE Info
         Info(
             InfoKind const kind,
             SymbolID const& ID) noexcept
-        : id(ID)
-        , Kind(kind)
+        : Kind(kind)
+        , id(ID)
     {
     }
 };
diff --git a/include/mrdocs/Metadata/Type.hpp b/include/mrdocs/Metadata/Type.hpp
index 57a94cfe1..3393f4e31 100644
--- a/include/mrdocs/Metadata/Type.hpp
+++ b/include/mrdocs/Metadata/Type.hpp
@@ -118,16 +118,16 @@ operator==(
 
 /** Return the inner type.
 
-    The inner type is the type which is modified
-    by a specifier (e.g. "int" in "pointer to int".
+    The inner type is the type that is modified
+    by a specifier (e.g. "int" in "pointer to int").
 */
 MRDOCS_DECL
-Optional<std::reference_wrapper<Polymorphic<TypeInfo> const>>
+Optional<Polymorphic<TypeInfo> const&>
 innerType(TypeInfo const& TI) noexcept;
 
 /// @copydoc innerType(TypeInfo const&)
 MRDOCS_DECL
-Optional<std::reference_wrapper<Polymorphic<TypeInfo>>>
+Optional<Polymorphic<TypeInfo>&>
 innerType(TypeInfo& TI) noexcept;
 
 /// @copydoc innerType(TypeInfo const&)
diff --git a/src/lib/AST/ParseRef.cpp b/src/lib/AST/ParseRef.cpp
index 42bfb6cd6..8469da98a 100644
--- a/src/lib/AST/ParseRef.cpp
+++ b/src/lib/AST/ParseRef.cpp
@@ -1550,15 +1550,15 @@ class RefParser
             // For instance, in "int (*)[3][6]", we have a pointer to an
             // array of 3 arrays of 6 ints.
             std::size_t curSuffixLevel = suffixLevel;
-            while (curSuffixLevel > 0 && inner && !inner->get().valueless_after_move())
+            while (curSuffixLevel > 0 && inner && !inner->valueless_after_move())
             {
-                auto& ref = inner->get();
+                auto& ref = *inner;
                 inner = innerType(*ref);
                 --curSuffixLevel;
             }
             char const* parenStart = ptr_;
             if (!parseArrayOrFunctionDeclaratorSuffix<declarator_type>(
-                inner ? inner->get() : dest))
+                inner ? *inner : dest))
             {
                 setError(parenStart, "expected declarator");
                 ptr_ = start;
diff --git a/src/lib/CorpusImpl.cpp b/src/lib/CorpusImpl.cpp
index a1c5316e2..1dad574bd 100644
--- a/src/lib/CorpusImpl.cpp
+++ b/src/lib/CorpusImpl.cpp
@@ -199,6 +199,14 @@ isDecayedEqualImpl(
     Info const& context,
     CorpusImpl const& corpus);
 
+// Check if two types are equal after decay
+//
+// The isInner template parameter indicates if
+// we are comparing inner types (e.g., pointee types)
+// or root types (e.g., function parameter types) because
+// the rules are slightly different depending
+// on the level of the type specifiers.
+//
 template <bool isInner>
 bool
 isDecayedEqualImpl(
@@ -225,7 +233,7 @@ isDecayedEqualImpl(
     MRDOCS_CHECK_OR(lhs->IsPackExpansion == rhs->IsPackExpansion, false);
     if constexpr (isInner)
     {
-        // const and volative are ignored from root types
+        // const and volatile are ignored from root types
         // in function parameters
         MRDOCS_CHECK_OR(lhs->IsConst == rhs->IsConst, false);
         MRDOCS_CHECK_OR(lhs->IsVolatile == rhs->IsVolatile, false);
@@ -301,9 +309,12 @@ isDecayedEqualImpl(
     {
         auto const I1 = innerType(*lhs);
         auto const I2 = innerType(*rhs);
+        // Both inner types must be present or absent, otherwise not equal
         MRDOCS_CHECK_OR(static_cast<bool>(I1) == static_cast<bool>(I2), false);
+        // Both inner types are absent: they are equal
         MRDOCS_CHECK_OR(static_cast<bool>(I1) && static_cast<bool>(I2), true);
-        return isDecayedEqualImpl<true>(I1->get(), I2->get(), context, corpus);
+        // Both inner types are present: compare them internally
+        return isDecayedEqualImpl<true>(*I1, *I2, context, corpus);
     }
     default:
         MRDOCS_UNREACHABLE();
diff --git a/src/lib/Metadata/Type.cpp b/src/lib/Metadata/Type.cpp
index b94fce3c5..16fed0b8f 100644
--- a/src/lib/Metadata/Type.cpp
+++ b/src/lib/Metadata/Type.cpp
@@ -780,7 +780,7 @@ template <
     class TypeInfoTy,
     bool isMutable = !std::is_const_v<std::remove_reference_t<TypeInfoTy>>,
     class Ptr = std::conditional_t<isMutable, Polymorphic<TypeInfo>*, Polymorphic<TypeInfo> const*>,
-    class Ref = std::conditional_t<isMutable, std::reference_wrapper<Polymorphic<TypeInfo>>, std::reference_wrapper<Polymorphic<TypeInfo> const>>>
+    class Ref = std::conditional_t<isMutable, Polymorphic<TypeInfo>&, Polymorphic<TypeInfo> const&>>
 requires std::same_as<std::remove_cvref_t<TypeInfoTy>, TypeInfo>
 Optional<Ref>
 innerTypeImpl(TypeInfoTy&& TI) noexcept
@@ -827,39 +827,48 @@ innerTypeImpl(TypeInfoTy&& TI) noexcept
 }
 
 // Get a pointer to the inner type
-template <class TypeInfoTy>
-auto
+template <
+    class TypeInfoTy,
+    bool isMutable = !std::is_const_v<std::remove_reference_t<TypeInfoTy>>,
+    class Ptr = std::conditional_t<isMutable, Polymorphic<TypeInfo>*, Polymorphic<TypeInfo> const*>,
+    class Ref = std::conditional_t<isMutable, Polymorphic<TypeInfo>&, Polymorphic<TypeInfo> const&>,
+    class InnerPtr = std::conditional_t<isMutable, TypeInfo*, TypeInfo const*>>
+requires std::same_as<std::remove_cvref_t<TypeInfoTy>, TypeInfo>
+InnerPtr
 innerTypePtrImpl(TypeInfoTy&& TI) noexcept
 {
-    auto res = innerTypeImpl(TI);
+    Optional<Ref> res = innerTypeImpl(TI);
     if (res)
     {
-        auto& ref = res->get();
-        return &*ref;
+        MRDOCS_ASSERT(!res->valueless_after_move());
+        return &**res;
     }
-    return decltype(&*res->get())(nullptr);
+    return nullptr;
 }
 
 // Get the innermost type
 // If there's an internal type, return it
 // If there's no internal type, return the current type
-template <class PolymorphicTypeInfoTy>
+template <
+    class PolymorphicTypeInfoTy,
+    bool isMutable = !std::is_const_v<std::remove_reference_t<PolymorphicTypeInfoTy>>,
+    class Ref = std::conditional_t<isMutable, Polymorphic<TypeInfo>&, Polymorphic<TypeInfo> const&>>
 requires std::same_as<std::remove_cvref_t<PolymorphicTypeInfoTy>, Polymorphic<TypeInfo>>
-auto&
+Ref
 innermostTypeImpl(PolymorphicTypeInfoTy&& TI) noexcept
 {
     if (TI.valueless_after_move())
     {
         return TI;
     }
-    /* optional */ auto inner = innerTypeImpl(*TI);
+    Optional<Ref> inner = innerTypeImpl(*TI);
     if (!inner)
     {
         return TI;
     }
     while (inner)
     {
-        /* polymorphic */ auto& ref = inner->get();
+        Ref ref = *inner;
         if (ref.valueless_after_move() ||
             ref->isNamed())
         {
@@ -867,45 +876,46 @@ innermostTypeImpl(PolymorphicTypeInfoTy&& TI) noexcept
         }
         inner = innerTypeImpl(*ref);
     }
-    return inner->get();
+    Ref ref = *inner;
+    return ref;
 }
 
 }
 
-Optional<std::reference_wrapper<Polymorphic<TypeInfo> const>>
+Optional<Polymorphic<TypeInfo> const&>
 innerType(TypeInfo const& TI) noexcept
 {
-    return innerTypeImpl(TI);
+    return innerTypeImpl<TypeInfo const&>(TI);
 }
 
-Optional<std::reference_wrapper<Polymorphic<TypeInfo>>>
+Optional<Polymorphic<TypeInfo>&>
 innerType(TypeInfo& TI) noexcept
 {
-    return innerTypeImpl(TI);
+    return innerTypeImpl<TypeInfo&>(TI);
 }
 
 TypeInfo const*
 innerTypePtr(TypeInfo const& TI) noexcept
 {
-    return innerTypePtrImpl(TI);
+    return innerTypePtrImpl<TypeInfo const&>(TI);
 }
 
 TypeInfo*
 innerTypePtr(TypeInfo& TI) noexcept
 {
-    return innerTypePtrImpl(TI);
+    return innerTypePtrImpl<TypeInfo&>(TI);
 }
 
 Polymorphic<TypeInfo> const&
 innermostType(Polymorphic<TypeInfo> const& TI) noexcept
 {
-    return innermostTypeImpl(TI);
+    return innermostTypeImpl<Polymorphic<TypeInfo> const&>(TI);
 }
 
 Polymorphic<TypeInfo>&
 innermostType(Polymorphic<TypeInfo>& TI) noexcept
 {
-    return innermostTypeImpl(TI);
+    return innermostTypeImpl<Polymorphic<TypeInfo>&>(TI);
 }
 
 } // clang::mrdocs
diff --git a/src/test/ADT/Optional.cpp b/src/test/ADT/Optional.cpp
index b7478b3c0..539233a48 100644
--- a/src/test/ADT/Optional.cpp
+++ b/src/test/ADT/Optional.cpp
@@ -11,6 +11,8 @@
 #include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/Metadata/Info/Source.hpp>
 #include <test_suite/test_suite.hpp>
+#include <optional>
+#include <type_traits>
 
 namespace clang::mrdocs {
 
@@ -216,6 +218,110 @@ struct OptionalTest {
         BOOST_TEST(a < b);
     }
 
+    void
+    test_reference_optional()
+    {
+        static_assert(detail::isOptionalV<Optional<int&>>);
+
+        int a = 1;
+        int b = 2;
+        int c = 3;
+
+        Optional<int&> r = a;
+        BOOST_TEST(r.has_value());
+        BOOST_TEST(&*r == &a);
+        BOOST_TEST(r.value() == 1);
+
+        struct S {
+            int v{ 0 };
+
+            int
+            inc()
+            {
+                return ++v;
+            }
+        };
+        S s{ 7 };
+        Optional<S&> rs = s;
+        BOOST_TEST(rs->inc() == 8);
+        BOOST_TEST((*rs).v == 8);
+
+        r = b;
+        BOOST_TEST(&*r == &b);
+        BOOST_TEST(*r == 2);
+
+        // assign from Optional<int&>
+        Optional<int&> rr = a;
+        rr = r;
+        BOOST_TEST(&*rr == &b);
+
+        // construct from Optional<int&>
+        Optional<int&> rr2{ r };
+        BOOST_TEST(&*rr2 == &b);
+
+        // Rebinding from Optional<int>
+        Optional<int> vo = 42;
+        rr = vo; // rebind to the referent inside vo
+        BOOST_TEST(&*rr == &*vo);
+        BOOST_TEST(*rr == *vo);
+
+        // rebind to different lvalue
+        rr2 = c;
+        BOOST_TEST(&*rr2 == &c);
+        BOOST_TEST(*rr2 == 3);
+
+        rr2.reset();
+        BOOST_TEST(!rr2.has_value());
+        rr2 = a;
+        BOOST_TEST(&*rr2 == &a);
+
+        Optional<int&> copy = rr2;
+        BOOST_TEST(&*copy == &a);
+        Optional<int&> moved = std::move(rr2);
+        BOOST_TEST(&*moved == &a);
+
+        Optional<int&> rx = b;
+        Optional<int&> ry = c;
+        rx.swap(ry);
+        BOOST_TEST(&*rx == &c);
+        BOOST_TEST(&*ry == &b);
+
+        Optional<int&> r1 = a;
+        Optional<int&> r2 = b;
+        BOOST_TEST(r1 != r2);
+        BOOST_TEST((r1 < r2) == (a < b));
+
+        Optional<int&> rn;
+        BOOST_TEST(rn == std::nullopt);
+        BOOST_TEST((r1 <=> std::nullopt) == std::strong_ordering::greater);
+        BOOST_TEST((rn <=> std::nullopt) == std::strong_ordering::equal);
+
+        int z = 9;
+        Optional<int&> rz = z;
+        int& zref = std::move(rz).value();
+        BOOST_TEST(&zref == &z);
+
+        static_assert(!std::is_constructible_v<Optional<int&>, int&&>);
+        static_assert(!std::is_constructible_v<Optional<int&>, int const&&>);
+        static_assert(!std::is_constructible_v<Optional<int&>, Optional<int>&&>);
+        static_assert(!std::is_constructible_v<Optional<int&>, Optional<int> const&&>);
+        static_assert(!std::is_assignable_v<Optional<int&>, int&&>);
+        static_assert(!std::is_assignable_v<Optional<int&>, int const&&>);
+
+        static_assert(std::is_constructible_v<Optional<int&>, int&>);
+        static_assert(std::is_assignable_v<Optional<int&>, int&>);
+        static_assert(std::is_constructible_v<Optional<int&>, Optional<int&>&>);
+        static_assert(std::is_constructible_v<Optional<int&>, Optional<int&> const&>);
+        static_assert(std::is_assignable_v<Optional<int&>, Optional<int&>&>);
+        static_assert(std::is_assignable_v<Optional<int&>, Optional<int&> const&>);
+
+        Optional<int> on = 1;
+        Optional<int&> orf = a;
+        BOOST_TEST(orf == on);
+        a = 5;
+        BOOST_TEST(orf != on);
+    }
+
     void
     run()
     {
@@ -225,6 +331,7 @@ struct OptionalTest {
         test_nullable_enum();
         test_nullable_location();
         test_fallback_notraits();
+        test_reference_optional();
     }
 };
 

From d91f99e176805b2749d928f6b655dffa51f7f29a Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Thu, 25 Sep 2025 23:27:43 -0500
Subject: [PATCH 12/23] feat(lib): expected references

Support Expected for references and replace usages of Expected with reference wrappers in the codebase. As with Optional references, expected references provide a safer interface that always rebinds values. Syntax is also more convenient both to declare variables without std::reference_wrapper and to access values without requiring the get function.
---
 include/mrdocs/ADT/Optional.hpp               |   29 +-
 include/mrdocs/Corpus.hpp                     |    4 +-
 include/mrdocs/Support/Concepts.hpp           |   21 +
 include/mrdocs/Support/Expected.hpp           | 1037 ++++++++++++++++-
 src/lib/CorpusImpl.cpp                        |   10 +-
 src/lib/CorpusImpl.hpp                        |    6 +-
 .../Metadata/Finalizers/JavadocFinalizer.cpp  |    4 +-
 src/test/Support/Expected.cpp                 |  477 ++++++++
 8 files changed, 1500 insertions(+), 88 deletions(-)
 create mode 100644 src/test/Support/Expected.cpp

diff --git a/include/mrdocs/ADT/Optional.hpp b/include/mrdocs/ADT/Optional.hpp
index 1917a23cd..cae1ffb1e 100644
--- a/include/mrdocs/ADT/Optional.hpp
+++ b/include/mrdocs/ADT/Optional.hpp
@@ -15,6 +15,7 @@
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Nullable.hpp>
+#include <mrdocs/Support/Concepts.hpp>
 #include <compare>
 #include <optional>
 #include <type_traits>
@@ -635,32 +636,6 @@ concept isDerivedFromOptional = requires(T const& t) {
 
 } // namespace detail
 
-
-namespace detail {
-#if defined(__cpp_lib_reference_from_temporary)
-using std::reference_constructs_from_temporary_v;
-using std::reference_converts_from_temporary_v;
-#else
-template<class To, class From>
-concept reference_converts_from_temporary_v =
-    std::is_reference_v<To> &&
-    (
-        (!std::is_reference_v<From> &&
-         std::is_convertible_v<std::remove_cvref_t<From>*,
-                               std::remove_cvref_t<To>*>)
-        ||
-        (std::is_lvalue_reference_v<To> &&
-         std::is_const_v<std::remove_reference_t<To>> &&
-         std::is_convertible_v<From, const std::remove_cvref_t<To>&&> &&
-         !std::is_convertible_v<From, std::remove_cvref_t<To>&>)
-    );
-
-template <class To, class From>
-inline constexpr bool reference_constructs_from_temporary_v
-    = reference_converts_from_temporary_v<To, From>;
-#endif
-} // detail
-
 template <class T>
 class Optional<T&> {
     T* p_ = nullptr;
@@ -668,7 +643,7 @@ class Optional<T&> {
     template <class U>
     static constexpr bool ok_bind_v
         = std::is_constructible_v<T&, U>
-          && !detail::reference_constructs_from_temporary_v<T&, U>;
+          && !reference_constructs_from_temporary_v<T&, U>;
 
 public:
     using value_type = T;
diff --git a/include/mrdocs/Corpus.hpp b/include/mrdocs/Corpus.hpp
index 1e9fd5243..e2a41ee52 100644
--- a/include/mrdocs/Corpus.hpp
+++ b/include/mrdocs/Corpus.hpp
@@ -99,7 +99,7 @@ class MRDOCS_VISIBLE
             Use @ref traverse to find all matching symbols.
     */
     virtual
-    Expected<std::reference_wrapper<Info const>>
+    Expected<Info const&>
     lookup(SymbolID const& context, std::string_view name) const = 0;
 
     /** Return the Info for the matching string in the global context.
@@ -108,7 +108,7 @@ class MRDOCS_VISIBLE
         @return The Info for the symbol with the specified name
             in the global context, or an error if not found.
     */
-    Expected<std::reference_wrapper<Info const>>
+    Expected<Info const&>
     lookup(std::string_view name) const
     {
         return lookup(SymbolID::global, name);
diff --git a/include/mrdocs/Support/Concepts.hpp b/include/mrdocs/Support/Concepts.hpp
index 71c377bc0..f9c56536f 100644
--- a/include/mrdocs/Support/Concepts.hpp
+++ b/include/mrdocs/Support/Concepts.hpp
@@ -135,6 +135,27 @@ template <class Range>
 concept range_of_tuple_like =
     std::ranges::range<Range> && tuple_like<std::ranges::range_value_t<Range>>;
 
+#ifdef __cpp_lib_reference_from_temporary
+    using std::reference_constructs_from_temporary_v;
+    using std::reference_converts_from_temporary_v;
+#else
+    template <class To, class From>
+    concept reference_converts_from_temporary_v
+        = std::is_reference_v<To>
+          && ((!std::is_reference_v<From>
+               && std::is_convertible_v<
+                   std::remove_cvref_t<From>*,
+                   std::remove_cvref_t<To>*>)
+              || (std::is_lvalue_reference_v<To>
+                  && std::is_const_v<std::remove_reference_t<To>>
+                  && std::is_convertible_v<From, const std::remove_cvref_t<To>&&>
+                  && !std::is_convertible_v<From, std::remove_cvref_t<To>&>) );
+
+    template <class To, class From>
+    concept reference_constructs_from_temporary_v
+        = reference_converts_from_temporary_v<To, From>;
+#endif
+
 } // namespace clang::mrdocs
 
 
diff --git a/include/mrdocs/Support/Expected.hpp b/include/mrdocs/Support/Expected.hpp
index 28e239977..3bdcfaf2b 100644
--- a/include/mrdocs/Support/Expected.hpp
+++ b/include/mrdocs/Support/Expected.hpp
@@ -14,6 +14,7 @@
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Support/Error.hpp>
+#include <mrdocs/Support/Concepts.hpp>
 #include <mrdocs/Support/source_location.hpp>
 #include <exception>
 #include <functional>
@@ -125,13 +126,13 @@ namespace detail
     constexpr bool isUnexpected<Unexpected<T>> = true;
 
     template <class Fn, class T>
-    using then_result = std::remove_cvref_t<std::invoke_result_t<Fn&&, T&&>>;
+    using ThenResult = std::remove_cvref_t<std::invoke_result_t<Fn&&, T&&>>;
     template <class Fn, class T>
-    using result_transform = std::remove_cv_t<std::invoke_result_t<Fn&&, T&&>>;
+    using ResultTransform = std::remove_cv_t<std::invoke_result_t<Fn&&, T&&>>;
     template <class Fn>
     using result0 = std::remove_cvref_t<std::invoke_result_t<Fn&&>>;
     template <class Fn>
-    using result0_xform = std::remove_cv_t<std::invoke_result_t<Fn&&>>;
+    using result0Transform = std::remove_cv_t<std::invoke_result_t<Fn&&>>;
 
     template <class E>
     concept can_beUnexpected =
@@ -144,6 +145,11 @@ namespace detail
     // Tag types for in-place construction from an invocation result.
     struct in_place_inv { };
     struct unexpect_inv { };
+
+    template <class R, class U>
+    inline constexpr bool ok_bind_ref_v
+        = std::is_constructible_v<R, U>
+          && !reference_constructs_from_temporary_v<R, U>;
 }
 
 template <class E>
@@ -477,7 +483,7 @@ class Expected
 
     template <class U>
     static constexpr bool same_err
-      = std::is_same_v<class U::error_type, E>;
+      = std::is_same_v<typename U::error_type, E>;
 
     template <class, class> friend class Expected;
 
@@ -1091,9 +1097,9 @@ class Expected
     auto
     and_then(Fn&& f) &
     {
-        using U = detail::then_result<Fn, T&>;
+        using U = detail::ThenResult<Fn, T&>;
         static_assert(detail::isExpected<U>);
-        static_assert(std::is_same_v<class U::error_type, E>);
+        static_assert(std::is_same_v<typename U::error_type, E>);
 
         if (has_value())
         {
@@ -1111,9 +1117,9 @@ class Expected
     auto
     and_then(Fn&& f) const &
     {
-        using U = detail::then_result<Fn, T const&>;
+        using U = detail::ThenResult<Fn, T const&>;
         static_assert(detail::isExpected<U>);
-        static_assert(std::is_same_v<class U::error_type, E>);
+        static_assert(std::is_same_v<typename U::error_type, E>);
 
         if (has_value())
         {
@@ -1131,9 +1137,9 @@ class Expected
     auto
     and_then(Fn&& f) &&
     {
-        using U = detail::then_result<Fn, T&&>;
+        using U = detail::ThenResult<Fn, T&&>;
         static_assert(detail::isExpected<U>);
-        static_assert(std::is_same_v<class U::error_type, E>);
+        static_assert(std::is_same_v<typename U::error_type, E>);
 
         if (has_value())
         {
@@ -1152,9 +1158,9 @@ class Expected
     auto
     and_then(Fn&& f) const &&
     {
-        using U = detail::then_result<Fn, T const&&>;
+        using U = detail::ThenResult<Fn, T const&&>;
         static_assert(detail::isExpected<U>);
-        static_assert(std::is_same_v<class U::error_type, E>);
+        static_assert(std::is_same_v<typename U::error_type, E>);
 
         if (has_value())
         {
@@ -1172,9 +1178,9 @@ class Expected
     auto
     or_else(Fn&& f) &
     {
-        using G = detail::then_result<Fn, E&>;
+        using G = detail::ThenResult<Fn, E&>;
         static_assert(detail::isExpected<G>);
-        static_assert(std::is_same_v<class G::value_type, T>);
+        static_assert(std::is_same_v<typename G::value_type, T>);
 
         if (has_value())
         {
@@ -1192,9 +1198,9 @@ class Expected
     auto
     or_else(Fn&& f) const &
     {
-        using G = detail::then_result<Fn, E const&>;
+        using G = detail::ThenResult<Fn, E const&>;
         static_assert(detail::isExpected<G>);
-        static_assert(std::is_same_v<class G::value_type, T>);
+        static_assert(std::is_same_v<typename G::value_type, T>);
 
         if (has_value())
         {
@@ -1212,9 +1218,9 @@ class Expected
     auto
     or_else(Fn&& f) &&
     {
-      using G = detail::then_result<Fn, E&&>;
+      using G = detail::ThenResult<Fn, E&&>;
       static_assert(detail::isExpected<G>);
-      static_assert(std::is_same_v<class G::value_type, T>);
+      static_assert(std::is_same_v<typename G::value_type, T>);
 
       if (has_value())
       {
@@ -1232,9 +1238,9 @@ class Expected
     auto
     or_else(Fn&& f) const &&
     {
-        using G = detail::then_result<Fn, E const&&>;
+        using G = detail::ThenResult<Fn, E const&&>;
         static_assert(detail::isExpected<G>);
-        static_assert(std::is_same_v<class G::value_type, T>);
+        static_assert(std::is_same_v<typename G::value_type, T>);
 
         if (has_value())
         {
@@ -1252,7 +1258,7 @@ class Expected
     auto
     transform(Fn&& f) &
     {
-        using U = detail::result_transform<Fn, T&>;
+        using U = detail::ResultTransform<Fn, T&>;
         using Res = Expected<U, E>;
 
         if (has_value())
@@ -1274,7 +1280,7 @@ class Expected
     auto
     transform(Fn&& f) const &
     {
-        using U = detail::result_transform<Fn, T const&>;
+        using U = detail::ResultTransform<Fn, T const&>;
         using Res = Expected<U, E>;
 
         if (has_value())
@@ -1296,7 +1302,7 @@ class Expected
     auto
     transform(Fn&& f) &&
     {
-        using U = detail::result_transform<Fn, T>;
+        using U = detail::ResultTransform<Fn, T>;
         using Res = Expected<U, E>;
 
         if (has_value())
@@ -1318,7 +1324,7 @@ class Expected
     auto
     transform(Fn&& f) const &&
     {
-        using U = detail::result_transform<Fn, const T>;
+        using U = detail::ResultTransform<Fn, const T>;
         using Res = Expected<U, E>;
 
         if (has_value())
@@ -1340,7 +1346,7 @@ class Expected
     auto
     transform_error(Fn&& f) &
     {
-        using G = detail::result_transform<Fn, E&>;
+        using G = detail::ResultTransform<Fn, E&>;
         using Res = Expected<T, G>;
 
         if (has_value())
@@ -1362,7 +1368,7 @@ class Expected
     auto
     transform_error(Fn&& f) const &
     {
-        using G = detail::result_transform<Fn, E const&>;
+        using G = detail::ResultTransform<Fn, E const&>;
         using Res = Expected<T, G>;
 
         if (has_value())
@@ -1384,7 +1390,7 @@ class Expected
     auto
     transform_error(Fn&& f) &&
     {
-        using G = detail::result_transform<Fn, E&&>;
+        using G = detail::ResultTransform<Fn, E&&>;
         using Res = Expected<T, G>;
 
         if (has_value())
@@ -1406,7 +1412,7 @@ class Expected
     auto
     transform_error(Fn&& f) const &&
     {
-        using G = detail::result_transform<Fn, E const&&>;
+        using G = detail::ResultTransform<Fn, E const&&>;
         using Res = Expected<T, G>;
 
         if (has_value())
@@ -1576,7 +1582,7 @@ class Expected<T, E>
 
     template <class U>
     static constexpr bool same_err
-      = std::is_same_v<class U::error_type, E>;
+      = std::is_same_v<typename U::error_type, E>;
 
     template <class, class> friend class Expected;
 
@@ -1951,7 +1957,7 @@ class Expected<T, E>
     {
         using U = detail::result0<Fn>;
         static_assert(detail::isExpected<U>);
-        static_assert(std::is_same_v<class U::error_type, E>);
+        static_assert(std::is_same_v<typename U::error_type, E>);
 
         if (has_value())
         {
@@ -1971,7 +1977,7 @@ class Expected<T, E>
     {
         using U = detail::result0<Fn>;
         static_assert(detail::isExpected<U>);
-        static_assert(std::is_same_v<class U::error_type, E>);
+        static_assert(std::is_same_v<typename U::error_type, E>);
 
         if (has_value())
         {
@@ -1991,7 +1997,7 @@ class Expected<T, E>
     {
       using U = detail::result0<Fn>;
       static_assert(detail::isExpected<U>);
-      static_assert(std::is_same_v<class U::error_type, E>);
+      static_assert(std::is_same_v<typename U::error_type, E>);
 
       if (has_value())
       {
@@ -2011,7 +2017,7 @@ class Expected<T, E>
     {
         using U = detail::result0<Fn>;
         static_assert(detail::isExpected<U>);
-        static_assert(std::is_same_v<class U::error_type, E>);
+        static_assert(std::is_same_v<typename U::error_type, E>);
 
         if (has_value())
         {
@@ -2028,9 +2034,9 @@ class Expected<T, E>
     auto
     or_else(Fn&& f) &
     {
-        using G = detail::then_result<Fn, E&>;
+        using G = detail::ThenResult<Fn, E&>;
         static_assert(detail::isExpected<G>);
-        static_assert(std::is_same_v<class G::value_type, T>);
+        static_assert(std::is_same_v<typename G::value_type, T>);
 
         if (has_value())
         {
@@ -2047,9 +2053,9 @@ class Expected<T, E>
     auto
     or_else(Fn&& f) const &
     {
-        using G = detail::then_result<Fn, E const&>;
+        using G = detail::ThenResult<Fn, E const&>;
         static_assert(detail::isExpected<G>);
-        static_assert(std::is_same_v<class G::value_type, T>);
+        static_assert(std::is_same_v<typename G::value_type, T>);
 
         if (has_value())
         {
@@ -2066,9 +2072,9 @@ class Expected<T, E>
     auto
     or_else(Fn&& f) &&
     {
-        using G = detail::then_result<Fn, E&&>;
+        using G = detail::ThenResult<Fn, E&&>;
         static_assert(detail::isExpected<G>);
-        static_assert(std::is_same_v<class G::value_type, T>);
+        static_assert(std::is_same_v<typename G::value_type, T>);
 
         if (has_value())
         {
@@ -2085,9 +2091,9 @@ class Expected<T, E>
     auto
     or_else(Fn&& f) const&&
     {
-        using G = detail::then_result<Fn, E const&&>;
+        using G = detail::ThenResult<Fn, E const&&>;
         static_assert(detail::isExpected<G>);
-        static_assert(std::is_same_v<class G::value_type, T>);
+        static_assert(std::is_same_v<typename G::value_type, T>);
 
         if (has_value())
         {
@@ -2105,7 +2111,7 @@ class Expected<T, E>
     auto
     transform(Fn&& f) &
     {
-        using U = detail::result0_xform<Fn>;
+        using U = detail::result0Transform<Fn>;
         using Res = Expected<U, E>;
 
         if (has_value())
@@ -2124,7 +2130,7 @@ class Expected<T, E>
     auto
     transform(Fn&& f) const &
     {
-        using U = detail::result0_xform<Fn>;
+        using U = detail::result0Transform<Fn>;
         using Res = Expected<U, E>;
 
         if (has_value())
@@ -2143,7 +2149,7 @@ class Expected<T, E>
     auto
     transform(Fn&& f) &&
     {
-        using U = detail::result0_xform<Fn>;
+        using U = detail::result0Transform<Fn>;
         using Res = Expected<U, E>;
 
         if (has_value())
@@ -2162,7 +2168,7 @@ class Expected<T, E>
     auto
     transform(Fn&& f) const &&
     {
-        using U = detail::result0_xform<Fn>;
+        using U = detail::result0Transform<Fn>;
         using Res = Expected<U, E>;
 
         if (has_value())
@@ -2180,7 +2186,7 @@ class Expected<T, E>
     auto
     transform_error(Fn&& f) &
     {
-        using G = detail::result_transform<Fn, E&>;
+        using G = detail::ResultTransform<Fn, E&>;
         using Res = Expected<T, G>;
 
         if (has_value())
@@ -2201,7 +2207,7 @@ class Expected<T, E>
     auto
     transform_error(Fn&& f) const &
     {
-        using G = detail::result_transform<Fn, E const&>;
+        using G = detail::ResultTransform<Fn, E const&>;
         using Res = Expected<T, G>;
 
         if (has_value())
@@ -2222,7 +2228,7 @@ class Expected<T, E>
     auto
     transform_error(Fn&& f) &&
     {
-        using G = detail::result_transform<Fn, E&&>;
+        using G = detail::ResultTransform<Fn, E&&>;
         using Res = Expected<T, G>;
 
         if (has_value())
@@ -2243,7 +2249,7 @@ class Expected<T, E>
     auto
     transform_error(Fn&& f) const &&
     {
-        using G = detail::result_transform<Fn, E const&&>;
+        using G = detail::ResultTransform<Fn, E const&&>;
         using Res = Expected<T, G>;
 
         if (has_value())
@@ -2336,6 +2342,939 @@ class Expected<T, E>
     { }
 };
 
+template <class T, class E>
+class Expected<T&, E> {
+    static_assert(detail::can_beUnexpected<E>);
+
+    // Storage: either a bound pointer to T, or an error E.
+    union {
+        T* p_;
+        E unex_;
+    };
+    bool has_value_ = false;
+
+    // Short aliases
+    using R = T&;
+    template <class U>
+    static constexpr bool ok_bind_v = detail::ok_bind_ref_v<R, U>;
+
+public:
+    using value_type = T&;
+    using error_type = E;
+    using unexpected_type = Unexpected<E>;
+
+    template <class U>
+    using rebind = Expected<U, error_type>;
+
+    // ----------------------------------
+    // ctors
+    // ----------------------------------
+
+    // Disengaged by default
+    constexpr
+    Expected() noexcept
+        : p_(nullptr), has_value_(false) {}
+
+    // Success from lvalue: bind
+    template <class U>
+    requires(!std::is_same_v<std::remove_cvref_t<U>, Expected>
+             && !std::is_same_v<std::remove_cvref_t<U>, std::in_place_t>
+             && !detail::isUnexpected<std::remove_cvref_t<U>> && ok_bind_v<U&>)
+    constexpr
+    explicit(!std::is_convertible_v<U&, R>)
+        Expected(U& u) noexcept(std::is_nothrow_constructible_v<R, U&>)
+        : p_(std::addressof(static_cast<R>(u)))
+        , has_value_(true)
+    {}
+
+    // Deleted when binding would be from a temporary / disallowed
+    template <class U>
+    requires(!std::is_same_v<std::remove_cvref_t<U>, Expected>
+             && !std::is_same_v<std::remove_cvref_t<U>, std::in_place_t>
+             && !detail::isUnexpected<std::remove_cvref_t<U>>
+             && !ok_bind_v<U &&>)
+    constexpr
+    Expected(U&&) = delete;
+
+    // In-place: bind to an lvalue argument
+    template <class U>
+    requires ok_bind_v<U&>
+    constexpr
+    explicit
+    Expected(std::in_place_t, U& u) noexcept
+        : p_(std::addressof(static_cast<R>(u)))
+        , has_value_(true)
+    {}
+
+    // In-place via invocation result (mirrors your in_place_inv)
+    template <class Fn>
+    explicit
+    constexpr
+    Expected(detail::in_place_inv, Fn&& fn)
+    {
+        // Expect fn() to yield something bindable to R (i.e. an lvalue of T)
+        auto&& r = std::forward<Fn>(fn)();
+        static_assert(ok_bind_v<decltype(r)>);
+        p_ = std::addressof(static_cast<R>(r));
+        has_value_ = true;
+    }
+
+    // Error ctors (same rules as primary)
+    template <class G = E>
+    requires std::is_constructible_v<E, G const&>
+    constexpr
+    explicit(!std::is_convertible_v<G const&, E>)
+    Expected(Unexpected<G> const& u)
+        noexcept(std::is_nothrow_constructible_v<E, G const&>)
+        : unex_(u.error())
+        , has_value_(false)
+    {}
+
+    template <class G = E>
+    requires std::is_constructible_v<E, G>
+    constexpr
+    explicit(!std::is_convertible_v<G, E>)
+    Expected(Unexpected<G>&& u)
+        noexcept(std::is_nothrow_constructible_v<E, G>)
+        : unex_(std::move(u).error())
+        , has_value_(false)
+    {}
+
+    // Error via invocation-result (mirrors your unexpect_inv)
+    template <class Fn>
+    explicit
+    constexpr
+    Expected(detail::unexpect_inv, Fn&& fn)
+        : unex_(std::forward<Fn>(fn)())
+        , has_value_(false)
+    {}
+
+    // Converting ctors from other Expected -----------------------
+
+    // From Expected<U&, E>: safe to bind for any value category
+    template <class U>
+    requires detail::ok_bind_ref_v<R, U&>
+    constexpr
+    explicit(!std::is_convertible_v<U&, R>)
+    Expected(Expected<U&, E> const& other)
+        noexcept(std::is_nothrow_constructible_v<R, U&>
+            && std::is_nothrow_copy_constructible_v<E>)
+        : has_value_(other.has_value_)
+    {
+        if (has_value_)
+        {
+            p_ = std::addressof(static_cast<U&>(other.value()));
+        } else
+        {
+            std::construct_at(std::addressof(unex_), other.error());
+        }
+    }
+
+    template <class U>
+    requires detail::ok_bind_ref_v<R, U&>
+    constexpr
+    explicit(!std::is_convertible_v<U&, R>)
+    Expected(Expected<U&, E>&& other)
+        noexcept(std::is_nothrow_constructible_v<R, U&>
+            && std::is_nothrow_move_constructible_v<E>)
+        : has_value_(other.has_value_)
+    {
+        if (has_value_)
+        {
+            p_ = std::addressof(static_cast<U&>(other.value()));
+        } else
+        {
+            std::construct_at(std::addressof(unex_), std::move(other).error());
+        }
+    }
+
+    // From Expected<U, E> (non-ref): only from lvalue object; forbid rvalue
+    template <class U>
+    requires detail::ok_bind_ref_v<R, U&>
+    constexpr
+    explicit(!std::is_convertible_v<U&, R>)
+    Expected(Expected<U, E>& other)
+        noexcept(std::is_nothrow_constructible_v<R, U&>
+            && std::is_nothrow_copy_constructible_v<E>)
+        : has_value_(other.has_value())
+    {
+        if (has_value_)
+        {
+            p_ = std::addressof(other.value());
+        } else
+        {
+            std::construct_at(std::addressof(unex_), other.error());
+        }
+    }
+
+    template <class U>
+    constexpr
+    Expected(Expected<U, E>&&) = delete; // would dangle
+
+    // Copy/move/dtor
+    constexpr
+    Expected(Expected const&) = default;
+
+    constexpr
+    Expected(Expected&&) = default;
+
+    template <class... Args>
+    requires std::is_constructible_v<E, Args...>
+    constexpr
+    explicit
+    Expected(unexpect_t, Args&&... args)
+        noexcept(std::is_nothrow_constructible_v<E, Args...>)
+        : unex_(std::forward<Args>(args)...)
+        , has_value_(false)
+    {}
+
+    template <class U, class... Args>
+    requires std::is_constructible_v<E, std::initializer_list<U>&, Args...>
+    constexpr
+    explicit
+    Expected(unexpect_t, std::initializer_list<U> il, Args&&... args)
+        noexcept(std::is_nothrow_constructible_v<E, std::initializer_list<U>&, Args...>)
+        : unex_(il, std::forward<Args>(args)...)
+        , has_value_(false)
+    {}
+
+    constexpr
+    ~Expected()
+    {
+        if (!has_value_)
+        {
+            std::destroy_at(std::addressof(unex_));
+        }
+    }
+
+    // ----------------------------------
+    // assignment (always rebind)
+    // ----------------------------------
+
+    constexpr
+    Expected&
+    operator=(Expected const&) = default;
+
+    constexpr
+    Expected&
+    operator=(Expected&&) = default;
+
+    // Assign from lvalue -> rebind
+    template <class U>
+    requires ok_bind_v<U&>
+    constexpr
+    Expected&
+    operator=(U& u)
+        noexcept(std::is_nothrow_constructible_v<R, U&>)
+    {
+        if (!has_value_)
+        {
+            std::destroy_at(std::addressof(unex_));
+            has_value_ = true;
+        }
+        p_ = std::addressof(static_cast<R>(u));
+        return *this;
+    }
+
+    // Deleted for temporaries
+    template <class U>
+    requires(!ok_bind_v<U &&>)
+    constexpr
+    Expected&
+    operator=(U&&) = delete;
+
+    // Assign from Expected<U&,E> -> rebind or store error
+    template <class U>
+    requires detail::ok_bind_ref_v<R, U&>
+    constexpr
+    Expected&
+    operator=(Expected<U&, E> const& other)
+    {
+        if (other.has_value())
+        {
+            if (!has_value_)
+            {
+                std::destroy_at(std::addressof(unex_));
+                has_value_ = true;
+            }
+            p_ = std::addressof(static_cast<U&>(other.value()));
+        } else
+        {
+            if (has_value_)
+            {
+                std::construct_at(std::addressof(unex_), other.error());
+                has_value_ = false;
+            } else
+            {
+                unex_ = other.error();
+            }
+        }
+        return *this;
+    }
+
+    template <class U>
+    requires detail::ok_bind_ref_v<R, U&>
+    constexpr
+    Expected&
+    operator=(Expected<U&, E>&& other)
+    {
+        if (other.has_value())
+        {
+            if (!has_value_)
+            {
+                std::destroy_at(std::addressof(unex_));
+                has_value_ = true;
+            }
+            p_ = std::addressof(static_cast<U&>(other.value()));
+        } else
+        {
+            if (has_value_)
+            {
+                std::construct_at(
+                    std::addressof(unex_),
+                    std::move(other).error());
+                has_value_ = false;
+            } else
+            {
+                unex_ = std::move(other).error();
+            }
+        }
+        return *this;
+    }
+
+    // Assign from Expected<U,E> lvalue only (non-ref). Rvalue deleted to avoid
+    // dangling.
+    template <class U>
+    requires detail::ok_bind_ref_v<R, U&>
+    constexpr
+    Expected&
+    operator=(Expected<U, E>& other)
+    {
+        if (other.has_value())
+        {
+            if (!has_value_)
+            {
+                std::destroy_at(std::addressof(unex_));
+                has_value_ = true;
+            }
+            p_ = std::addressof(other.value());
+        } else
+        {
+            if (has_value_)
+            {
+                std::construct_at(std::addressof(unex_), other.error());
+                has_value_ = false;
+            } else
+            {
+                unex_ = other.error();
+            }
+        }
+        return *this;
+    }
+
+    template <class U>
+    constexpr
+    Expected&
+    operator=(Expected<U, E>&&) = delete;
+
+    // Assign error
+    template <class G>
+    requires std::is_constructible_v<E, G const&>
+             && std::is_assignable_v<E&, G const&>
+    constexpr
+    Expected&
+    operator=(Unexpected<G> const& e)
+    {
+        if (has_value_)
+        {
+            std::construct_at(std::addressof(unex_), e.error());
+            has_value_ = false;
+        } else
+        {
+            unex_ = e.error();
+        }
+        return *this;
+    }
+
+    template <class G>
+    requires std::is_constructible_v<E, G> && std::is_assignable_v<E&, G>
+    constexpr
+    Expected&
+    operator=(Unexpected<G>&& e)
+    {
+        if (has_value_)
+        {
+            std::construct_at(std::addressof(unex_), std::move(e).error());
+            has_value_ = false;
+        } else
+        {
+            unex_ = std::move(e).error();
+        }
+        return *this;
+    }
+
+    // Emplace: bind to an lvalue
+    template <class U>
+    requires ok_bind_v<U&>
+    constexpr
+    T&
+    emplace(U& u) noexcept
+    {
+        if (!has_value_)
+        {
+            std::destroy_at(std::addressof(unex_));
+            has_value_ = true;
+        }
+        p_ = std::addressof(static_cast<R>(u));
+        return *p_;
+    }
+
+    template <class U>
+    requires(!ok_bind_v<U &&>)
+    constexpr
+    T&
+    emplace(U&&) = delete;
+
+    // swap
+    constexpr
+    void
+    swap(Expected& x)
+        noexcept(
+        std::is_nothrow_move_constructible_v<E>
+        && std::is_nothrow_swappable_v<E&>)
+    requires std::is_swappable_v<E>
+    {
+        if (has_value_)
+        {
+            if (x.has_value_)
+            {
+                using std::swap;
+                swap(p_, x.p_);
+            } else
+            {
+                // this has value, x has error
+                E tmp(std::move(x.unex_));
+                std::destroy_at(std::addressof(x.unex_));
+                x.p_ = p_;
+                x.has_value_ = true;
+
+                std::construct_at(std::addressof(unex_), std::move(tmp));
+                has_value_ = false;
+            }
+        } else
+        {
+            if (x.has_value_)
+            {
+                x.swap(*this);
+            } else
+            {
+                using std::swap;
+                swap(unex_, x.unex_);
+            }
+        }
+    }
+
+    friend constexpr
+    void
+    swap(Expected& a, Expected& b)
+        noexcept(noexcept(a.swap(b)))
+    requires requires { a.swap(b); }
+    {
+        a.swap(b);
+    }
+
+    // ----------------------------------
+    // observers
+    // ----------------------------------
+    [[nodiscard]]
+    constexpr
+    explicit
+    operator bool() const noexcept
+    {
+        return has_value_;
+    }
+
+    [[nodiscard]]
+    constexpr
+    bool
+    has_value() const noexcept
+    {
+        return has_value_;
+    }
+
+    [[nodiscard]]
+    constexpr
+    T*
+    operator->() noexcept
+    {
+        MRDOCS_ASSERT(has_value_);
+        return p_;
+    }
+
+    [[nodiscard]]
+    constexpr
+    T const*
+    operator->() const noexcept
+    {
+        MRDOCS_ASSERT(has_value_);
+        return p_;
+    }
+
+    [[nodiscard]]
+    constexpr
+    T&
+    operator*() & noexcept
+    {
+        MRDOCS_ASSERT(has_value_);
+        return *p_;
+    }
+
+    [[nodiscard]]
+    constexpr
+    T const&
+    operator*() const& noexcept
+    {
+        MRDOCS_ASSERT(has_value_);
+        return *p_;
+    }
+
+    [[nodiscard]]
+    constexpr
+    T&&
+    operator*() && noexcept
+    {
+        MRDOCS_ASSERT(has_value_);
+        return std::move(*p_);
+    }
+
+    [[nodiscard]]
+    constexpr
+    T const&&
+    operator*() const&& noexcept
+    {
+        MRDOCS_ASSERT(has_value_);
+        return std::move(*p_);
+    }
+
+    constexpr
+    T&
+    value() &
+    {
+        if (has_value_)
+        {
+            return *p_;
+        }
+        throw BadExpectedAccess<E>(error());
+    }
+
+    constexpr
+    T const&
+    value() const&
+    {
+        if (has_value_)
+        {
+            return *p_;
+        }
+        throw BadExpectedAccess<E>(error());
+    }
+
+    constexpr
+    T&&
+    value() &&
+    {
+        if (has_value_)
+        {
+            return std::move(*p_);
+        }
+        throw BadExpectedAccess<E>(std::move(error()));
+    }
+
+    constexpr
+    T const&&
+    value() const&&
+    {
+        if (has_value_)
+        {
+            return std::move(*p_);
+        }
+        throw BadExpectedAccess<E>(std::move(error()));
+    }
+
+    [[nodiscard]]
+    constexpr
+    E&
+    error() & noexcept
+    {
+        MRDOCS_ASSERT(!has_value_);
+        return unex_;
+    }
+
+    [[nodiscard]]
+    constexpr
+    E const&
+    error() const& noexcept
+    {
+        MRDOCS_ASSERT(!has_value_);
+        return unex_;
+    }
+
+    [[nodiscard]]
+    constexpr
+    E&&
+    error() && noexcept
+    {
+        MRDOCS_ASSERT(!has_value_);
+        return std::move(unex_);
+    }
+
+    [[nodiscard]]
+    constexpr
+    E const&&
+    error() const&& noexcept
+    {
+        MRDOCS_ASSERT(!has_value_);
+        return std::move(unex_);
+    }
+
+    // value_or: return by value (copy/move), like your non-ref primary
+    template <class U>
+    constexpr
+    std::remove_reference_t<T>
+    value_or(U&& u) const&
+    {
+        using Rval = std::remove_reference_t<T>;
+        static_assert(std::is_copy_constructible_v<Rval>);
+        static_assert(std::is_convertible_v<U, Rval>);
+        return has_value_ ? *p_ : static_cast<Rval>(std::forward<U>(u));
+    }
+
+    template <class U>
+    constexpr
+    std::remove_reference_t<T>
+    value_or(U&& u) &&
+    {
+        using Rval = std::remove_reference_t<T>;
+        static_assert(std::is_move_constructible_v<Rval>);
+        static_assert(std::is_convertible_v<U, Rval>);
+        return has_value_ ? std::move(*p_) :
+                            static_cast<Rval>(std::forward<U>(u));
+    }
+
+    // error_or: identical to primary
+    template <class G = E>
+    constexpr
+    E
+    error_or(G&& g) const&
+    {
+        return has_value_ ? static_cast<E>(std::forward<G>(g)) : unex_;
+    }
+
+    template <class G = E>
+    constexpr
+    E
+    error_or(G&& g) &&
+    {
+        return has_value_ ? static_cast<E>(std::forward<G>(g)) :
+                            std::move(unex_);
+    }
+
+    // ----------------------------------
+    // monadic ops
+    // ----------------------------------
+
+    // and_then: F(T&) -> Expected<*, E>
+    template <class Fn>
+    constexpr
+    auto
+    and_then(Fn&& f) &
+    {
+        using U = std::remove_cvref_t<std::invoke_result_t<Fn, T&>>;
+        static_assert(detail::isExpected<U>);
+        static_assert(std::is_same_v<typename U::error_type, E>);
+        if (has_value_)
+        {
+            return std::invoke(std::forward<Fn>(f), *p_);
+        }
+        return U(unexpect, unex_);
+    }
+
+    template <class Fn>
+    constexpr
+    auto
+    and_then(Fn&& f) const&
+    {
+        using U = std::remove_cvref_t<std::invoke_result_t<Fn, T const&>>;
+        static_assert(detail::isExpected<U>);
+        static_assert(std::is_same_v<typename U::error_type, E>);
+        if (has_value_)
+        {
+            return std::invoke(std::forward<Fn>(f), *p_);
+        }
+        return U(unexpect, unex_);
+    }
+
+    template <class Fn>
+    constexpr
+    auto
+    and_then(Fn&& f) &&
+    {
+        using U = std::remove_cvref_t<std::invoke_result_t<Fn, T&&>>;
+        static_assert(detail::isExpected<U>);
+        static_assert(std::is_same_v<typename U::error_type, E>);
+        if (has_value_)
+        {
+            return std::invoke(std::forward<Fn>(f), std::move(*p_));
+        }
+        return U(unexpect, std::move(unex_));
+    }
+
+    template <class Fn>
+    constexpr
+    auto
+    and_then(Fn&& f) const&&
+    {
+        using U = std::remove_cvref_t<std::invoke_result_t<Fn, T const&&>>;
+        static_assert(detail::isExpected<U>);
+        static_assert(std::is_same_v<typename U::error_type, E>);
+        if (has_value_)
+        {
+            return std::invoke(std::forward<Fn>(f), std::move(*p_));
+        }
+        return U(unexpect, std::move(unex_));
+    }
+
+    // or_else: same signature/behavior as primary; when engaged, return
+    // self-type with same binding
+    template <class Fn>
+    constexpr
+    Expected
+    or_else(Fn&& f) &
+    {
+        if (has_value_)
+        {
+            return *this;
+        }
+        auto g = std::forward<Fn>(f)(unex_);
+        static_assert(
+            std::is_same_v<std::remove_cvref_t<decltype(g)>, Expected>);
+        return g;
+    }
+
+    template <class Fn>
+    constexpr
+    Expected
+    or_else(Fn&& f) const&
+    {
+        if (has_value_)
+        {
+            return *this;
+        }
+        auto g = std::forward<Fn>(f)(unex_);
+        static_assert(
+            std::is_same_v<std::remove_cvref_t<decltype(g)>, Expected>);
+        return g;
+    }
+
+    template <class Fn>
+    constexpr
+    Expected
+    or_else(Fn&& f) &&
+    {
+        if (has_value_)
+        {
+            return *this;
+        }
+        auto g = std::forward<Fn>(f)(std::move(unex_));
+        static_assert(
+            std::is_same_v<std::remove_cvref_t<decltype(g)>, Expected>);
+        return g;
+    }
+
+    template <class Fn>
+    constexpr
+    Expected
+    or_else(Fn&& f) const&&
+    {
+        if (has_value_)
+        {
+            return *this;
+        }
+        auto g = std::forward<Fn>(f)(std::move(unex_));
+        static_assert(
+            std::is_same_v<std::remove_cvref_t<decltype(g)>, Expected>);
+        return g;
+    }
+
+    // transform: F(T&) -> U ; returns Expected<U, E>
+    template <class Fn>
+    constexpr
+    auto
+    transform(Fn&& f) &
+    {
+        using U = std::remove_cv_t<std::invoke_result_t<Fn, T&>>;
+        using Res = Expected<U, E>;
+        if (has_value_)
+        {
+            return Res(detail::in_place_inv{}, [&] {
+                return std::invoke(std::forward<Fn>(f), *p_);
+            });
+        }
+        return Res(unexpect, unex_);
+    }
+
+    template <class Fn>
+    constexpr
+    auto
+    transform(Fn&& f) const&
+    {
+        using U = std::remove_cv_t<std::invoke_result_t<Fn, T const&>>;
+        using Res = Expected<U, E>;
+        if (has_value_)
+        {
+            return Res(detail::in_place_inv{}, [&] {
+                return std::invoke(std::forward<Fn>(f), *p_);
+            });
+        }
+        return Res(unexpect, unex_);
+    }
+
+    template <class Fn>
+    constexpr
+    auto
+    transform(Fn&& f) &&
+    {
+        using U = std::remove_cv_t<std::invoke_result_t<Fn, T&&>>;
+        using Res = Expected<U, E>;
+        if (has_value_)
+        {
+            return Res(detail::in_place_inv{}, [&] {
+                return std::invoke(std::forward<Fn>(f), std::move(*p_));
+            });
+        }
+        return Res(unexpect, std::move(unex_));
+    }
+
+    template <class Fn>
+    constexpr
+    auto
+    transform(Fn&& f) const&&
+    {
+        using U = std::remove_cv_t<std::invoke_result_t<Fn, T const&&>>;
+        using Res = Expected<U, E>;
+        if (has_value_)
+        {
+            return Res(detail::in_place_inv{}, [&] {
+                return std::invoke(std::forward<Fn>(f), std::move(*p_));
+            });
+        }
+        return Res(unexpect, std::move(unex_));
+    }
+
+    // transform_error: identical to primary
+    template <class Fn>
+    constexpr
+    auto
+    transform_error(Fn&& f) &
+    {
+        using G = std::remove_cv_t<std::invoke_result_t<Fn, E&>>;
+        using Res = Expected<T&, G>;
+        if (has_value_)
+        {
+            return Res(std::in_place, *p_);
+        }
+        return Res(detail::unexpect_inv{}, [&] {
+            return std::invoke(std::forward<Fn>(f), unex_);
+        });
+    }
+
+    template <class Fn>
+    constexpr
+    auto
+    transform_error(Fn&& f) const&
+    {
+        using G = std::remove_cv_t<std::invoke_result_t<Fn, E const&>>;
+        using Res = Expected<T&, G>;
+        if (has_value_)
+        {
+            return Res(std::in_place, *p_);
+        }
+        return Res(detail::unexpect_inv{}, [&] {
+            return std::invoke(std::forward<Fn>(f), unex_);
+        });
+    }
+
+    template <class Fn>
+    constexpr
+    auto
+    transform_error(Fn&& f) &&
+    {
+        using G = std::remove_cv_t<std::invoke_result_t<Fn, E&&>>;
+        using Res = Expected<T&, G>;
+        if (has_value_)
+        {
+            return Res(std::in_place, *p_);
+        }
+        return Res(detail::unexpect_inv{}, [&] {
+            return std::invoke(std::forward<Fn>(f), std::move(unex_));
+        });
+    }
+
+    template <class Fn>
+    constexpr
+    auto
+    transform_error(Fn&& f) const&&
+    {
+        using G = std::remove_cv_t<std::invoke_result_t<Fn, E const&&>>;
+        using Res = Expected<T&, G>;
+        if (has_value_)
+        {
+            return Res(std::in_place, *p_);
+        }
+        return Res(detail::unexpect_inv{}, [&] {
+            return std::invoke(std::forward<Fn>(f), std::move(unex_));
+        });
+    }
+
+    template <class U, class E2>
+    friend
+    constexpr
+    bool
+    operator==(Expected const& x, Expected<U, E2> const& y)
+        noexcept(noexcept(bool(*x == *y)) &&
+                 noexcept(bool(x.error() == y.error())))
+    requires (!std::is_void_v<U>)
+    {
+        if (x.has_value())
+        {
+            return y.has_value() && bool(*x == *y);
+        } else
+        {
+            return !y.has_value() && bool(x.error() == y.error());
+        }
+    }
+
+
+    template <class U>
+    friend
+    constexpr
+    bool
+    operator==(Expected const& x, U const& v)
+        noexcept(noexcept(bool(*x == v)))
+    {
+        return x.has_value() && bool(*x == v);
+    }
+
+    template <class E2>
+    friend
+    constexpr
+    bool
+    operator==(Expected const& x, Unexpected<E2> const& e)
+        noexcept(noexcept(bool(x.error() == e.error())))
+    {
+        return !x.has_value() && bool(x.error() == e.error());
+    }
+}; // class Expected<T&, E>
+
 } // clang::mrdocs
 
 #endif
diff --git a/src/lib/CorpusImpl.cpp b/src/lib/CorpusImpl.cpp
index 1dad574bd..6b947fb97 100644
--- a/src/lib/CorpusImpl.cpp
+++ b/src/lib/CorpusImpl.cpp
@@ -374,14 +374,14 @@ isDecayedEqual(
 }
 }
 
-Expected<std::reference_wrapper<Info const>>
+Expected<Info const&>
 CorpusImpl::
 lookup(SymbolID const& context, std::string_view const name) const
 {
     return lookupImpl(*this, context, name);
 }
 
-Expected<std::reference_wrapper<Info const>>
+Expected<Info const&>
 CorpusImpl::
 lookup(SymbolID const& context, std::string_view name)
 {
@@ -389,7 +389,7 @@ lookup(SymbolID const& context, std::string_view name)
 }
 
 template <class Self>
-Expected<std::reference_wrapper<Info const>>
+Expected<Info const&>
 CorpusImpl::
 lookupImpl(Self&& self, SymbolID const& contextId0, std::string_view name)
 {
@@ -412,7 +412,7 @@ lookupImpl(Self&& self, SymbolID const& contextId0, std::string_view name)
                 name,
                 self.Corpus::qualifiedName(*self.find(contextId))));
         }
-        return std::cref(*info);
+        return *info;
     }
     auto const expRef = parse<ParsedRef>(name);
     if (!expRef)
@@ -433,7 +433,7 @@ lookupImpl(Self&& self, SymbolID const& contextId0, std::string_view name)
             name,
             self.Corpus::qualifiedName(*contextPtr)));
     }
-    return std::cref(*res);
+    return *res;
 }
 
 template <class Self>
diff --git a/src/lib/CorpusImpl.hpp b/src/lib/CorpusImpl.hpp
index 0e628264b..2a0c7efd1 100644
--- a/src/lib/CorpusImpl.hpp
+++ b/src/lib/CorpusImpl.hpp
@@ -142,10 +142,10 @@ class CorpusImpl final : public Corpus
             std::views::common;
     }
 
-    Expected<std::reference_wrapper<Info const>>
+    Expected<Info const&>
     lookup(SymbolID const& context, std::string_view name) const override;
 
-    Expected<std::reference_wrapper<Info const>>
+    Expected<Info const&>
     lookup(SymbolID const& context, std::string_view name);
 
     /** Build metadata for a set of translation units.
@@ -198,7 +198,7 @@ class CorpusImpl final : public Corpus
 
     template <class Self>
     static
-    Expected<std::reference_wrapper<Info const>>
+    Expected<Info const&>
     lookupImpl(
         Self&& self,
         SymbolID const& contextId,
diff --git a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp b/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
index 87e04a857..48dca5260 100644
--- a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
@@ -791,9 +791,9 @@ finalize(doc::Reference& ref, bool const emitWarning)
     }
     if (auto resRef = corpus_.lookup(current_context_->id, ref.string))
     {
-        // KRYSTIAN NOTE: we should provide an overload that
+        // KRYSTIAN NOTE: We should provide an overload that
         // returns a non-const reference.
-        auto& res = const_cast<Info&>(resRef->get());
+        auto& res = const_cast<Info&>(*resRef);
         ref.id = res.id;
     }
     else if (
diff --git a/src/test/Support/Expected.cpp b/src/test/Support/Expected.cpp
new file mode 100644
index 000000000..432da2d36
--- /dev/null
+++ b/src/test/Support/Expected.cpp
@@ -0,0 +1,477 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (vinnie.falco@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#include <mrdocs/Support/Expected.hpp>
+#include <test_suite/test_suite.hpp>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+namespace clang {
+namespace mrdocs {
+
+struct ExpectedTest
+{
+    struct S {
+        int v = 0;
+        int
+        get() const noexcept
+        {
+            return v;
+        }
+        auto
+        operator<=>(S const&) const
+            = default;
+    };
+
+    // Helpers returning Expected for monadic tests
+    static
+    Expected<int, Error>
+    plus_one(int x)
+    {
+        return Expected<int, Error>(x + 1);
+    }
+
+    static
+    Expected<int, Error>
+    fail_with(std::string msg)
+    {
+        return Expected<int, Error>(unexpect, Error(std::move(msg)));
+    }
+
+    static
+    Expected<void, Error>
+    ok_void()
+    {
+        return Expected<void, Error>(std::in_place);
+    }
+
+    static
+    Expected<void, Error>
+    fail_void(std::string msg)
+    {
+        return Expected<void, Error>(unexpect, Error(std::move(msg)));
+    }
+
+    void
+    test_value_expected_basic()
+    {
+        using E = Error;
+
+        // default-construct value (if T is default-constructible)
+        {
+            Expected<int, E> e(std::in_place, 0);
+            BOOST_TEST(e.has_value());
+            BOOST_TEST(*e == 0);
+            BOOST_TEST(e.value() == 0);
+        }
+
+        // construct from value
+        {
+            Expected<int, E> e(42);
+            BOOST_TEST(e);
+            BOOST_TEST(*e == 42);
+
+            // copy/move
+            Expected<int, E> c = e;
+            BOOST_TEST(c);
+            BOOST_TEST(*c == 42);
+
+            Expected<int, E> m = std::move(e);
+            BOOST_TEST(m);
+            BOOST_TEST(*m == 42);
+
+            // assign value
+            c = 7;
+            BOOST_TEST(c);
+            BOOST_TEST(*c == 7);
+        }
+
+        // construct unexpected
+        {
+            Expected<int, E> e(unexpect, E("bang"));
+            BOOST_TEST(!e);
+            BOOST_TEST(e.error().failed());
+            BOOST_TEST(!e.has_value());
+            // error_or
+            auto er = e.error_or(E("alt"));
+            BOOST_TEST(er.failed());
+        }
+
+        // assign unexpected
+        {
+            Expected<int, E> e(3);
+            e = Unexpected<E>(E("nope"));
+            BOOST_TEST(!e);
+            BOOST_TEST(e.error().failed());
+        }
+
+        // emplace
+        {
+            Expected<int, E> e(unexpect, E("x"));
+            e.emplace(99);
+            BOOST_TEST(e);
+            BOOST_TEST(*e == 99);
+        }
+
+        // operator-> / operator* with object type
+        {
+            Expected<S, E> es(S{ 5 });
+            BOOST_TEST(es->get() == 5);
+            BOOST_TEST((*es).v == 5);
+        }
+
+        // value_or
+        {
+            Expected<int, E> a(10);
+            Expected<int, E> b(unexpect, E("err"));
+            BOOST_TEST(a.value_or(1) == 10);
+            BOOST_TEST(b.value_or(1) == 1);
+        }
+
+        // and_then (success)
+        {
+            Expected<int, E> e(10);
+            auto r = e.and_then([](int& x) { return plus_one(x); });
+            BOOST_TEST(r);
+            BOOST_TEST(*r == 11);
+        }
+
+        // and_then (error propagates)
+        {
+            Expected<int, E> e(unexpect, E("err"));
+            auto r = e.and_then([](int& x) { return plus_one(x); });
+            BOOST_TEST(!r);
+            BOOST_TEST(r.error().failed());
+        }
+
+        // or_else (success path returns same value)
+        {
+            Expected<int, E> e(3);
+            auto r = e.or_else([](E&) { return fail_with("should-not-run"); });
+            BOOST_TEST(r);
+            BOOST_TEST(*r == 3);
+        }
+
+        // or_else (error path produces alternate)
+        {
+            Expected<int, E> e(unexpect, E("oops"));
+            auto r = e.or_else([](E&) { return Expected<int, E>(7); });
+            BOOST_TEST(r);
+            BOOST_TEST(*r == 7);
+        }
+
+        // transform maps the value
+        {
+            Expected<int, E> e(8);
+            auto r = e.transform([](int& x) { return x * 2; });
+            static_assert(std::is_same_v<decltype(r), Expected<int, E>>);
+            BOOST_TEST(r);
+            BOOST_TEST(*r == 16);
+        }
+
+        // transform_error maps the error
+        {
+            struct MyErr {
+                std::string s;
+            };
+            Expected<int, E> e(unexpect, E("bad"));
+            auto r = e.transform_error([](E& old) {
+                return MyErr{ old.message() };
+            });
+            static_assert(std::is_same_v<decltype(r), Expected<int, MyErr>>);
+            BOOST_TEST(!r);
+            BOOST_TEST(r.error().s.find("bad") != std::string::npos);
+        }
+
+        // swap combinations
+        {
+            Expected<int, E> a(1);
+            Expected<int, E> b(2);
+            swap(a, b);
+            BOOST_TEST(*a == 2);
+            BOOST_TEST(*b == 1);
+
+            Expected<int, E> c(unexpect, E("err"));
+            swap(a, c);
+            BOOST_TEST(!a);
+            BOOST_TEST(c);
+            BOOST_TEST(*c == 2);
+        }
+
+        // equality (value vs value, error vs error)
+        {
+            Expected<int, E> a(5), b(5), c(6);
+            Expected<int, E> xe(unexpect, E("x")), ye(unexpect, E("x"));
+            BOOST_TEST(a == b);
+            BOOST_TEST(!(a == c));
+            BOOST_TEST(xe == ye);
+            BOOST_TEST(!(a == xe));
+        }
+    }
+
+    void
+    test_void_expected_basic()
+    {
+        using Ev = Error;
+
+        // default engaged
+        {
+            Expected<void, Ev> e(std::in_place);
+            BOOST_TEST(e);
+            // operator* is a no-op with an assert, we won't call it here.
+            e.value(); // should not throw
+        }
+
+        // unexpected
+        {
+            Expected<void, Ev> e(unexpect, Ev("boom"));
+            BOOST_TEST(!e);
+            BOOST_TEST(e.error().failed());
+            auto er = e.error_or(Ev("alt"));
+            BOOST_TEST(er.failed());
+        }
+
+        // copy/move assign between states
+        {
+            Expected<void, Ev> ok(std::in_place);
+            Expected<void, Ev> err(unexpect, Ev("x"));
+
+            ok = err; // ok -> err
+            BOOST_TEST(!ok);
+
+            err = Expected<void, Ev>(std::in_place); // err -> ok
+            BOOST_TEST(err);
+        }
+
+        // emplace clears error
+        {
+            Expected<void, Ev> e(unexpect, Ev("no"));
+            e.emplace();
+            BOOST_TEST(e);
+        }
+
+        // and_then
+        {
+            Expected<void, Ev> e(std::in_place);
+            auto r = e.and_then([] { return ok_void(); });
+            BOOST_TEST(r);
+        }
+        {
+            Expected<void, Ev> e(unexpect, Ev("n"));
+            auto r = e.and_then([] { return ok_void(); });
+            BOOST_TEST(!r);
+        }
+
+        // or_else
+        {
+            Expected<void, Ev> e(unexpect, Ev("nope"));
+            auto r = e.or_else([](Ev&) { return ok_void(); });
+            BOOST_TEST(r);
+        }
+
+        // transform to non-void
+        {
+            Expected<void, Ev> e(std::in_place);
+            auto r = e.transform([] { return 17; });
+            static_assert(std::is_same_v<decltype(r), Expected<int, Ev>>);
+            BOOST_TEST(r);
+            BOOST_TEST(*r == 17);
+        }
+
+        // transform_error
+        {
+            struct MyErr {
+                std::string s;
+            };
+            Expected<void, Ev> e(unexpect, Ev("zzz"));
+            auto r = e.transform_error([](Ev& old) {
+                return MyErr{ old.message() };
+            });
+            static_assert(std::is_same_v<decltype(r), Expected<void, MyErr>>);
+            BOOST_TEST(!r);
+            BOOST_TEST(r.error().s.find("zzz") != std::string::npos);
+        }
+
+        // swap
+        {
+            Expected<void, Ev> a(std::in_place);
+            Expected<void, Ev> b(unexpect, Ev("e"));
+            swap(a, b);
+            BOOST_TEST(!a);
+            BOOST_TEST(b);
+        }
+
+        // equality
+        {
+            Expected<void, Ev> ok1(std::in_place), ok2(std::in_place);
+            Expected<void, Ev> er1(unexpect, Ev("e1")), er2(unexpect, Ev("e1"));
+            BOOST_TEST(ok1 == ok2);
+            BOOST_TEST(er1 == er2);
+            BOOST_TEST(!(ok1 == er1));
+        }
+    }
+
+    void
+    test_reference_expected_basic()
+    {
+        using E = Error;
+
+        int x = 10;
+        int y = 20;
+
+        // bind to lvalue, arrow/deref/value
+        {
+            Expected<int&, E> er(std::in_place, x);
+            BOOST_TEST(er);
+            BOOST_TEST(&er.value() == &x);
+            BOOST_TEST(*er == 10);
+
+            er = y; // rebinding
+            BOOST_TEST(&er.value() == &y);
+            BOOST_TEST(*er == 20);
+        }
+
+        // construct from Expected<T,E>& (binds to contained lvalue)
+        {
+            Expected<int, E> ev(std::in_place, 42);
+            Expected<int&, E> er(std::in_place, x);
+            er = ev; // rebind to ev.value()
+            BOOST_TEST(&er.value() == &ev.value());
+            BOOST_TEST(*er == 42);
+        }
+
+        // value_or returns by value (copy)
+        {
+            Expected<int&, E> er(std::in_place, x);
+            Expected<int&, E> bad(unexpect, E("err"));
+            auto v1 = er.value_or(5);
+            auto v2 = bad.value_or(5);
+            static_assert(std::is_same_v<decltype(v1), int>);
+            BOOST_TEST(v1 == 10);
+            BOOST_TEST(v2 == 5);
+        }
+
+        // error transitions
+        {
+            Expected<int&, E> er(unexpect, E("e"));
+            BOOST_TEST(!er);
+            er = x; // rebind from error -> success
+            BOOST_TEST(er);
+            BOOST_TEST(&er.value() == &x);
+        }
+
+        // transform
+        {
+            Expected<int&, E> er(std::in_place, x);
+            auto r = er.transform([](int& r) { return r * 3; });
+            static_assert(std::is_same_v<decltype(r), Expected<int, E>>);
+            BOOST_TEST(r);
+            BOOST_TEST(*r == 30);
+        }
+
+        // and_then (success)
+        {
+            Expected<int&, E> er(std::in_place, x);
+            auto r = er.and_then([](int& r) { return plus_one(r); });
+            BOOST_TEST(r);
+            BOOST_TEST(*r == 11);
+        }
+
+        // and_then (error propagates)
+        {
+            Expected<int&, E> er(unexpect, E("err"));
+            auto r = er.and_then([](int& r) { return plus_one(r); });
+            BOOST_TEST(!r);
+        }
+
+        // transform_error changes error type, preserves binding semantics on
+        // success
+        {
+            struct MyErr {
+                std::string s;
+            };
+
+            Expected<int&, E> ok(std::in_place, x);
+            auto r1 = ok.transform_error([](E& e) {
+                return MyErr{ e.message() };
+            });
+            static_assert(std::is_same_v<decltype(r1), Expected<int&, MyErr>>);
+            BOOST_TEST(r1);
+            BOOST_TEST(&r1.value() == &x);
+
+            Expected<int&, E> bad(unexpect, E("xx"));
+            auto r2 = bad.transform_error([](E& e) {
+                return MyErr{ e.message() };
+            });
+            BOOST_TEST(!r2);
+            BOOST_TEST(r2.error().s.find("xx") != std::string::npos);
+        }
+
+        // swap: value<->value and value<->error
+        {
+            Expected<int&, E> a(std::in_place, x);
+            Expected<int&, E> b(std::in_place, y);
+            swap(a, b);
+            BOOST_TEST(&a.value() == &y);
+            BOOST_TEST(&b.value() == &x);
+
+            Expected<int&, E> c(unexpect, E("err"));
+            swap(a, c);
+            BOOST_TEST(!a);
+            BOOST_TEST(c);
+            BOOST_TEST(&c.value() == &y);
+        }
+
+        // equality (value vs value, error vs error)
+        {
+            Expected<int&, E> a(std::in_place, x);
+            Expected<int&, E> b(std::in_place, x);
+            Expected<int&, E> c(std::in_place, y);
+            Expected<int&, E> xe(unexpect, E("e")), ye(unexpect, E("e"));
+
+            BOOST_TEST(a == b);
+            BOOST_TEST(!(a == c));
+            BOOST_TEST(xe == ye);
+            BOOST_TEST(!(a == xe));
+        }
+
+        // deleted constructs/assignments from temporaries (compile-time checks)
+        {
+            static_assert(!std::is_constructible_v<Expected<int&, E>, int&&>);
+            static_assert(!std::is_assignable_v<Expected<int&, E>, int&&>);
+            static_assert(!std::is_constructible_v<Expected<int&, E>, Expected<int, E>&&>);
+            static_assert(!std::is_assignable_v<Expected<int&, E>, Expected<int, E>&&>);
+        }
+    }
+
+    void
+    run()
+    {
+        test_value_expected_basic();
+        test_void_expected_basic();
+        test_reference_expected_basic();
+    }
+};
+
+TEST_SUITE(
+    ExpectedTest,
+    "clang.mrdocs.Expected");
+
+} // mrdocs
+} // clang

From fe2a192b14728b5514a7e99af0462e170497c9e8 Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Fri, 26 Sep 2025 00:38:33 -0500
Subject: [PATCH 13/23] fix(Report): do not attempt to format logs without
 parameters

This leads to segmentation faults when the string contains reserved sequences.
---
 include/mrdocs/Support/Report.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/mrdocs/Support/Report.hpp b/include/mrdocs/Support/Report.hpp
index c8da3716f..0deffc886 100644
--- a/include/mrdocs/Support/Report.hpp
+++ b/include/mrdocs/Support/Report.hpp
@@ -184,7 +184,7 @@ log_impl(
     Level level,
     Located<std::string_view> fs)
 {
-  std::string str = std::vformat(fs.value, std::make_format_args());
+  std::string str(fs.value);
   return print(level, str, &fs.where);
 }
 }

From ea3d445035f7671f72fc0cd93f57421e1c728904 Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Fri, 26 Sep 2025 00:39:58 -0500
Subject: [PATCH 14/23] feat(Corpus): location objects include column number

---
 include/mrdocs/Metadata/Info/Location.hpp |  6 ++++++
 src/lib/AST/ASTVisitor.cpp                | 15 +++++++++++----
 src/lib/Metadata/Source.cpp               |  1 +
 3 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/include/mrdocs/Metadata/Info/Location.hpp b/include/mrdocs/Metadata/Info/Location.hpp
index f102947a9..260557586 100644
--- a/include/mrdocs/Metadata/Info/Location.hpp
+++ b/include/mrdocs/Metadata/Info/Location.hpp
@@ -39,6 +39,10 @@ struct MRDOCS_DECL
     */
     unsigned LineNumber = 0;
 
+    /** Column number within the line
+    */
+    unsigned ColumnNumber = 0;
+
     /** Whether this location has documentation.
     */
     bool Documented = false;
@@ -51,11 +55,13 @@ struct MRDOCS_DECL
         std::string_view const short_path = {},
         std::string_view const source_path = {},
         unsigned const line = 0,
+        unsigned const col = 0,
         bool const documented = false)
         : FullPath(full_path)
         , ShortPath(short_path)
         , SourcePath(source_path)
         , LineNumber(line)
+        , ColumnNumber(col)
         , Documented(documented)
     {
     }
diff --git a/src/lib/AST/ASTVisitor.cpp b/src/lib/AST/ASTVisitor.cpp
index 53eee91c8..24bdd9639 100644
--- a/src/lib/AST/ASTVisitor.cpp
+++ b/src/lib/AST/ASTVisitor.cpp
@@ -580,21 +580,28 @@ populate(
     bool const definition,
     bool const documented)
 {
-    unsigned line = source_.getPresumedLoc(
-        loc, false).getLine();
+    auto presLoc = source_.getPresumedLoc(loc, false);
+    unsigned line = presLoc.getLine();
+    unsigned col = presLoc.getColumn();
     FileInfo* file = findFileInfo(loc);
 
     // No file is not an error, it just typically means it has been generated
     // in the virtual filesystem.
     MRDOCS_CHECK_OR(file);
 
+    Location Loc(file->full_path,
+        file->short_path,
+        file->source_path,
+        line,
+        col,
+        documented);
     if (definition)
     {
         if (I.DefLoc)
         {
             return;
         }
-        I.DefLoc.emplace(file->full_path, file->short_path, file->source_path, line, documented);
+        I.DefLoc = std::move(Loc);
     }
     else
     {
@@ -609,7 +616,7 @@ populate(
         {
             return;
         }
-        I.Loc.emplace_back(file->full_path, file->short_path, file->source_path, line, documented);
+        I.Loc.push_back(std::move(Loc));
     }
 }
 
diff --git a/src/lib/Metadata/Source.cpp b/src/lib/Metadata/Source.cpp
index 85c5e5737..b0ca0814f 100644
--- a/src/lib/Metadata/Source.cpp
+++ b/src/lib/Metadata/Source.cpp
@@ -111,6 +111,7 @@ tag_invoke(
     io.map("shortPath", loc.ShortPath);
     io.map("sourcePath", loc.SourcePath);
     io.map("line", loc.LineNumber);
+    io.map("column", loc.ColumnNumber);
     io.map("documented", loc.Documented);
 }
 

From bbfcd93d9db648befc9d8b283590c056b5dc4fac Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Fri, 26 Sep 2025 00:40:16 -0500
Subject: [PATCH 15/23] feat(Corpus): render source line and caret in warning
 output

Warnings now include a snippet of the source file similar to GCC and Clang diagnostics. Each warning prints the file path, line, and column, followed by the line of source text
and a caret marker pointing to the column. This makes it easier to identify and fix issues directly in context without having to open the file manually.
---
 .../Metadata/Finalizers/JavadocFinalizer.cpp  | 172 ++++++++++++++++--
 .../Metadata/Finalizers/JavadocFinalizer.hpp  |   6 +-
 2 files changed, 160 insertions(+), 18 deletions(-)

diff --git a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp b/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
index 48dca5260..67dc1bfad 100644
--- a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
@@ -14,6 +14,7 @@
 #include <lib/Metadata/Finalizers/JavadocFinalizer.hpp>
 #include <mrdocs/Support/Algorithm.hpp>
 #include <mrdocs/Support/ScopeExit.hpp>
+#include <mrdocs/Support/Path.hpp>
 #include <algorithm>
 #include <format>
 
@@ -1672,9 +1673,64 @@ checkExists(SymbolID const& id) const
     MRDOCS_ASSERT(corpus_.info_.contains(id));
 }
 
+namespace {
+// Expand tabs to spaces using a tab stop of 8 (common in toolchains)
+inline
+std::string
+expand_tabs(std::string_view s, std::size_t tabw = 8)
+{
+    std::string out;
+    out.reserve(s.size());
+    std::size_t col = 0;
+    for (char ch: s)
+    {
+        if (ch == '\t')
+        {
+            std::size_t spaces = tabw - (col % tabw);
+            out.append(spaces, ' ');
+            col += spaces;
+        } else
+        {
+            out.push_back(ch);
+            // naive column advance;
+            // good enough for ASCII/byte-based columns
+            ++col;
+        }
+    }
+    return out;
+}
+
+// Split into lines; tolerates \n, \r\n, and final line w/o newline
+inline
+std::vector<std::string_view>
+split_lines(std::string const& text)
+{
+    std::vector<std::string_view> lines;
+    std::size_t start = 0;
+    while (start <= text.size())
+    {
+        auto nl = text.find('\n', start);
+        if (nl == std::string::npos)
+        {
+            // last line (may be empty)
+            lines.emplace_back(text.data() + start, text.size() - start);
+            break;
+        }
+        // trim a preceding '\r' if present
+        std::size_t len = nl - start;
+        if (len > 0 && text[nl - 1] == '\r')
+        {
+            --len;
+        }
+        lines.emplace_back(text.data() + start, len);
+        start = nl + 1;
+    }
+    return lines;
+}
+} // namespace
+
 void
-JavadocFinalizer::
-emitWarnings()
+JavadocFinalizer::emitWarnings()
 {
     MRDOCS_CHECK_OR(corpus_.config->warnings);
     warnUndocumented();
@@ -1683,26 +1739,107 @@ emitWarnings()
     warnUndocEnumValues();
     warnUnnamedParams();
 
-    // Print to the console
-    auto const level = !corpus_.config->warnAsError ? report::Level::warn : report::Level::error;
-    for (auto const& [loc, msgs] : warnings_)
+    auto const level = !corpus_.config->warnAsError ?
+                           report::Level::warn :
+                           report::Level::error;
+
+    // Simple cache for the last file we touched
+    std::string_view lastPath;
+    std::string fileContents;
+    std::vector<std::string_view> fileLines;
+
+    for (auto const& [loc, msgs]: warnings_)
     {
-      std::string locWarning =
-          std::format("{}:{}\n", loc.FullPath, loc.LineNumber);
-      int i = 1;
-      for (auto const &msg : msgs) {
-        locWarning += std::format("    {}) {}\n", i++, msg);
-      }
-        report::log(level, locWarning);
+        // Build the location header
+        std::string out;
+        out += std::format("{}:{}:{}:\n", loc.FullPath, loc.LineNumber, loc.ColumnNumber);
+
+        // Append grouped messages for this location
+        {
+            int i = 1;
+            for (auto const& msg: msgs)
+            {
+                out += std::format("    {}) {}\n", i++, msg);
+            }
+        }
+
+        // Render the source snippet if possible
+        // Load file if path changed
+        if (loc.FullPath != lastPath)
+        {
+            lastPath = loc.FullPath;
+            fileContents.clear();
+            fileLines.clear();
+
+            if (auto expFileContents = files::getFileText(loc.FullPath);
+                expFileContents)
+            {
+                fileContents = std::move(*expFileContents);
+                fileLines = split_lines(fileContents);
+            }
+            else
+            {
+                fileLines.clear();
+            }
+        }
+
+        if (loc.LineNumber < fileLines.size() &&
+            loc.LineNumber > 0)
+        {
+            std::string_view rawLine = fileLines[loc.LineNumber - 1];
+            std::size_t caretCol =
+                loc.ColumnNumber < rawLine.size() &&
+                loc.ColumnNumber > 0
+                    ? loc.ColumnNumber - 1
+                    : std::size_t(-1);
+            std::string lineExpanded = expand_tabs(rawLine, 8);
+
+            // Compute width for the line number gutter
+            std::string gutter = std::format("  {} | ", loc.LineNumber);
+            out += gutter;
+
+            // Line text
+            out += lineExpanded;
+            out += "\n";
+
+            // Create gutter for the caret line
+            std::size_t const gutterWidth = gutter.size();
+            gutter = std::string(gutterWidth - 2, ' ') + "| ";
+            out += gutter;
+
+            if (caretCol != std::size_t(-1) && caretCol < rawLine.size())
+            {
+                std::size_t expandedCaretCol = 0;
+                for (std::size_t i = 0; i < caretCol; ++i)
+                {
+                    if (rawLine[i] == '\t')
+                    {
+                        expandedCaretCol += 8;
+                    }
+                    else
+                    {
+                        ++expandedCaretCol;
+                    }
+                }
+                MRDOCS_ASSERT(expandedCaretCol <= lineExpanded.size());
+
+                out += std::string(expandedCaretCol, ' ');
+                out += "^";
+
+                out += std::string(lineExpanded.size() - expandedCaretCol - 1, '~');
+                out += "\n";
+            }
+        }
+
+        report::log(level, out);
     }
 }
 
 void
-JavadocFinalizer::
-warnUndocumented()
+JavadocFinalizer::warnUndocumented()
 {
     MRDOCS_CHECK_OR(corpus_.config->warnIfUndocumented);
-    for (auto& undocI : corpus_.undocumented_)
+    for (auto& undocI: corpus_.undocumented_)
     {
         if (Info const* I = corpus_.find(undocI.id))
         {
@@ -1710,10 +1847,11 @@ warnUndocumented()
                 !I->javadoc || I->Extraction == ExtractionMode::Regular);
         }
         bool const prefer_definition = undocI.kind == InfoKind::Record
-                                 || undocI.kind == InfoKind::Enum;
+                                       || undocI.kind == InfoKind::Enum;
         this->warn(
             *getPrimaryLocation(undocI.Loc, prefer_definition),
-            "{}: Symbol is undocumented", undocI.name);
+            "{}: Symbol is undocumented",
+            undocI.name);
     }
     corpus_.undocumented_.clear();
 }
diff --git a/src/lib/Metadata/Finalizers/JavadocFinalizer.hpp b/src/lib/Metadata/Finalizers/JavadocFinalizer.hpp
index b0814aab8..48fb6bf90 100644
--- a/src/lib/Metadata/Finalizers/JavadocFinalizer.hpp
+++ b/src/lib/Metadata/Finalizers/JavadocFinalizer.hpp
@@ -71,7 +71,11 @@ class JavadocFinalizer
             {
                 return lhs.FullPath < rhs.FullPath;
             }
-            return lhs.LineNumber > rhs.LineNumber;
+            if (lhs.LineNumber != rhs.LineNumber)
+            {
+                return lhs.LineNumber > rhs.LineNumber;
+            }
+            return lhs.ColumnNumber > rhs.ColumnNumber;
         }
     };
 

From 616217a4988c29ac47bd0d35d3ec5f0fd7837d28 Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Fri, 26 Sep 2025 18:11:29 -0500
Subject: [PATCH 16/23] refactor(Corpus): enforce non-optional polymorphic
 types

Ensure optional polymorphic types are only used for members that are really optional in terms of application logic. Otherwise, we only make them polymorphic objects that cannot be empty and give them reasonable defaults among the derived types in that type family.
---
 include/mrdocs/Metadata/Info/Concept.hpp      |   2 +-
 include/mrdocs/Metadata/Info/Enum.hpp         |  25 +-
 include/mrdocs/Metadata/Info/Friend.hpp       |  10 +-
 include/mrdocs/Metadata/Info/Function.hpp     |  11 +-
 include/mrdocs/Metadata/Info/Guide.hpp        |   4 +-
 .../mrdocs/Metadata/Info/NamespaceAlias.hpp   |   2 +-
 include/mrdocs/Metadata/Info/Overloads.hpp    |   9 +-
 include/mrdocs/Metadata/Info/Param.hpp        |   2 +-
 include/mrdocs/Metadata/Info/RecordBase.hpp   |  16 +-
 include/mrdocs/Metadata/Info/Source.hpp       |   2 +-
 include/mrdocs/Metadata/Info/Typedef.hpp      |   4 +-
 include/mrdocs/Metadata/Info/Variable.hpp     |   4 +-
 include/mrdocs/Metadata/TArg.hpp              |   2 +-
 include/mrdocs/Metadata/TArg/NonTypeTArg.hpp  |   2 +-
 include/mrdocs/Metadata/TArg/TArgBase.hpp     |   4 +-
 include/mrdocs/Metadata/TArg/TArgKind.hpp     |   2 +-
 include/mrdocs/Metadata/TArg/TypeTArg.hpp     |   5 +-
 include/mrdocs/Metadata/TParam.hpp            |   6 +-
 .../{NonTypeTParam.hpp => ConstantTParam.hpp} |  20 +-
 include/mrdocs/Metadata/TParam/TParamBase.hpp |  13 +-
 include/mrdocs/Metadata/TParam/TParamKind.hpp |   6 +-
 .../mrdocs/Metadata/Type/ArrayTypeInfo.hpp    |   3 +-
 include/mrdocs/Metadata/Type/AutoTypeInfo.hpp |   3 +
 .../mrdocs/Metadata/Type/FunctionTypeInfo.hpp |   3 +-
 .../Metadata/Type/LValueReferenceTypeInfo.hpp |   2 +-
 .../Metadata/Type/MemberPointerTypeInfo.hpp   |   4 +-
 .../mrdocs/Metadata/Type/PointerTypeInfo.hpp  |   3 +-
 .../Metadata/Type/RValueReferenceTypeInfo.hpp |   3 +-
 include/mrdocs/Support/Expected.hpp           |   2 +-
 mrdocs.rnc                                    |   4 +-
 .../generator/adoc/partials/symbol.adoc.hbs   |   4 +-
 .../common/partials/template/arg.hbs          |   4 +-
 .../common/partials/template/param-text.hbs   |   2 +-
 .../common/partials/template/param.hbs        |   4 +-
 .../generator/html/partials/symbol.html.hbs   |   4 +-
 src/lib/AST/ASTVisitor.cpp                    |  89 ++--
 src/lib/AST/ParseRef.cpp                      |   9 +-
 src/lib/AST/TypeInfoBuilder.cpp               |  73 ++--
 src/lib/AST/TypeInfoBuilder.hpp               |  14 +-
 src/lib/CorpusImpl.cpp                        |  13 +-
 src/lib/Gen/hbs/TagfileWriter.cpp             |  18 +-
 src/lib/Gen/hbs/VisitorHelpers.cpp            |  17 +-
 src/lib/Gen/xml/CXXTags.hpp                   |  79 ++--
 src/lib/Gen/xml/XMLTags.hpp                   |   2 +-
 src/lib/Gen/xml/XMLWriter.cpp                 |  19 +-
 src/lib/Gen/xml/XMLWriter.hpp                 |   2 +-
 .../Finalizers/BaseMembersFinalizer.cpp       |  21 +-
 .../Metadata/Finalizers/DerivedFinalizer.cpp  |   6 +-
 .../Metadata/Finalizers/Javadoc/Function.hpp  | 112 +++--
 .../Metadata/Finalizers/JavadocFinalizer.cpp  |  90 ++--
 .../Finalizers/OverloadsFinalizer.cpp         |   8 +-
 .../Finalizers/SortMembersFinalizer.cpp       |  35 +-
 src/lib/Metadata/Info/Function.cpp            |   7 +-
 src/lib/Metadata/Info/Guide.cpp               |   3 +-
 src/lib/Metadata/Info/NamespaceAlias.cpp      |   8 +-
 src/lib/Metadata/Info/Overloads.cpp           |   3 +-
 src/lib/Metadata/Info/Record.cpp              |   7 +-
 src/lib/Metadata/Info/Typedef.cpp             |   2 +-
 src/lib/Metadata/Info/Variable.cpp            |   2 +-
 src/lib/Metadata/Name.cpp                     |   9 +-
 src/lib/Metadata/Source.cpp                   |   4 +-
 src/lib/Metadata/Template.cpp                 |  25 +-
 src/lib/Metadata/Type.cpp                     |  26 +-
 src/lib/Support/Report.cpp                    |   2 +-
 src/lib/clang.natvis                          |   4 +-
 src/test/ADT/Optional.cpp                     |   2 +-
 src/test/Support/Expected.cpp                 |   2 +-
 src/tool/ToolMain.cpp                         |   2 +-
 .../golden-tests/config/auto-relates/enum.xml |   2 +-
 .../config/auto-relates/return-type.xml       |   2 +-
 .../symbol-type/nested-private-template.xml   |   4 +-
 .../javadoc/copydoc/param-types.xml           |   2 +-
 .../javadoc/copydoc/qualified.xml             |   2 +-
 .../javadoc/copydoc/template-arguments.xml    |  14 +-
 .../function/explicit-conv-operator.xml       |   2 +-
 .../symbols/function/explicit-ctor.xml        |   2 +-
 .../symbols/function/function-template.xml    |  10 +-
 .../symbols/function/function-tparm-decay.xml |   8 +-
 .../symbols/guide/explicit-deduct-guide.xml   |   4 +-
 .../class-template-specializations-1.xml      | 410 +++++++++---------
 .../symbols/record/local-class.cpp            |  12 +-
 .../symbols/record/local-class.xml            |   2 +-
 .../symbols/record/record-data.xml            |   2 +-
 .../template-specialization-inheritance.xml   |  10 +-
 .../symbols/using/using-member-function.xml   |   2 +-
 85 files changed, 717 insertions(+), 684 deletions(-)
 rename include/mrdocs/Metadata/TParam/{NonTypeTParam.hpp => ConstantTParam.hpp} (58%)

diff --git a/include/mrdocs/Metadata/Info/Concept.hpp b/include/mrdocs/Metadata/Info/Concept.hpp
index ba6a15d15..48c97fb0f 100644
--- a/include/mrdocs/Metadata/Info/Concept.hpp
+++ b/include/mrdocs/Metadata/Info/Concept.hpp
@@ -12,8 +12,8 @@
 #define MRDOCS_API_METADATA_INFO_CONCEPT_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/ADT/Optional.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Metadata/Expression.hpp>
 #include <mrdocs/Metadata/Info.hpp>
 #include <mrdocs/Metadata/Info/Source.hpp>
diff --git a/include/mrdocs/Metadata/Info/Enum.hpp b/include/mrdocs/Metadata/Info/Enum.hpp
index fc8550548..9affb60d4 100644
--- a/include/mrdocs/Metadata/Info/Enum.hpp
+++ b/include/mrdocs/Metadata/Info/Enum.hpp
@@ -24,17 +24,32 @@ namespace clang::mrdocs {
 struct EnumInfo final
     : InfoCommonBase<InfoKind::Enum>
 {
-    // Indicates whether this enum is scoped (e.g. enum class).
+    /** Indicates whether this enum is scoped (e.g. enum class).
+
+        If true, the enumerators are accessed with the scope resolution
+        operator (e.g. EnumName::Enumerator).
+
+        If false, the enumerators are accessed directly (e.g. Enumerator)
+        in the parent context.
+    */
     bool Scoped = false;
 
-    // Set too nonempty to the type when this is an explicitly typed enum. For
-    //   enum Foo : short { ... };
-    // this will be "short".
+    /** The underlying type of this enum, if explicitly specified.
+
+        If not specified, the underlying type is an implementation-defined
+        integral type that can represent all the enumerator values defined in
+        the enumeration.
+
+        For `enum Foo : short { ... };` this will be represent `short`.
+    */
     Optional<Polymorphic<TypeInfo>> UnderlyingType = std::nullopt;
 
     /** The members of this scope.
 
-        All members are enum constants;
+        All members are enum constants.
+
+        Enum constants are independent symbol types that
+        can be documented separately.
     */
     std::vector<SymbolID> Constants;
 
diff --git a/include/mrdocs/Metadata/Info/Friend.hpp b/include/mrdocs/Metadata/Info/Friend.hpp
index ef76e3ff6..15ae6cb0d 100644
--- a/include/mrdocs/Metadata/Info/Friend.hpp
+++ b/include/mrdocs/Metadata/Info/Friend.hpp
@@ -21,7 +21,13 @@ namespace clang::mrdocs {
 
     - Friendship is not transitive
     - Friendship is not inherited
-    - Access specifiers have no effect on the meaning of friend declarations
+    - Access specifiers do not affect the meaning of friend declarations
+
+    The friends of a record are stored directly in the record's metadata.
+
+    If the friend declaration is documented, the documentation is
+    stored in the befriended symbol's metadata rather than in the
+    relationship.
 */
 struct FriendInfo final
 {
@@ -30,6 +36,8 @@ struct FriendInfo final
     SymbolID id = SymbolID::invalid;
 
     /** Befriended type.
+
+        This member is nullable and only used when befriending a type.
     */
     Optional<Polymorphic<TypeInfo>> Type = std::nullopt;
 };
diff --git a/include/mrdocs/Metadata/Info/Function.hpp b/include/mrdocs/Metadata/Info/Function.hpp
index de1b9f09d..1d2963e79 100644
--- a/include/mrdocs/Metadata/Info/Function.hpp
+++ b/include/mrdocs/Metadata/Info/Function.hpp
@@ -30,8 +30,15 @@ namespace clang::mrdocs {
 struct FunctionInfo final
     : InfoCommonBase<InfoKind::Function>
 {
-    /// Info about the return type of this function.
-    Optional<Polymorphic<TypeInfo>> ReturnType = std::nullopt;
+    /** Info about the return type of this function.
+
+        If the function has a deduced return type, this contains
+        `auto` to indicate that.
+
+        By default, we also use `auto` in the member to indicate
+        an unknown return type.
+     */
+    Polymorphic<TypeInfo> ReturnType = Polymorphic<TypeInfo>(AutoTypeInfo{});
 
     /// List of parameters.
     std::vector<Param> Params;
diff --git a/include/mrdocs/Metadata/Info/Guide.hpp b/include/mrdocs/Metadata/Info/Guide.hpp
index 67de5f07f..f1272ceab 100644
--- a/include/mrdocs/Metadata/Info/Guide.hpp
+++ b/include/mrdocs/Metadata/Info/Guide.hpp
@@ -12,8 +12,8 @@
 #define MRDOCS_API_METADATA_INFO_GUIDE_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/ADT/Optional.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Metadata/Info.hpp>
 #include <mrdocs/Metadata/Info/Function.hpp>
 #include <mrdocs/Metadata/Info/Source.hpp>
@@ -32,7 +32,7 @@ struct GuideInfo final
 
         This is always a SpecializationTypeInfo.
     */
-    Optional<Polymorphic<TypeInfo>> Deduced = std::nullopt;
+    Polymorphic<TypeInfo> Deduced = Polymorphic<TypeInfo>(AutoTypeInfo{});
 
     /** Template head, if any.
     */
diff --git a/include/mrdocs/Metadata/Info/NamespaceAlias.hpp b/include/mrdocs/Metadata/Info/NamespaceAlias.hpp
index ba0d4a00d..ed17922fc 100644
--- a/include/mrdocs/Metadata/Info/NamespaceAlias.hpp
+++ b/include/mrdocs/Metadata/Info/NamespaceAlias.hpp
@@ -28,7 +28,7 @@ struct NamespaceAliasInfo final
         This is another namespace that might or might
         not be in the same project.
      */
-    Optional<Polymorphic<NameInfo>> AliasedSymbol;
+    IdentifierNameInfo AliasedSymbol;
 
     //--------------------------------------------
 
diff --git a/include/mrdocs/Metadata/Info/Overloads.hpp b/include/mrdocs/Metadata/Info/Overloads.hpp
index d76c541f6..252efe11f 100644
--- a/include/mrdocs/Metadata/Info/Overloads.hpp
+++ b/include/mrdocs/Metadata/Info/Overloads.hpp
@@ -31,8 +31,13 @@ struct OverloadsInfo final
     /// The members of the overload set.
     std::vector<SymbolID> Members;
 
-    /// Info about the return type of this function.
-    Optional<Polymorphic<TypeInfo>> ReturnType = std::nullopt;
+    /** Info about the return type of these function overloads.
+
+        If all overloads have the same return type, this contains
+        that type. Otherwise, it contains `auto` to indicate that
+        the return type varies according to the parameters.
+     */
+    Polymorphic<TypeInfo> ReturnType = Polymorphic<TypeInfo>(AutoTypeInfo{});
 
     //--------------------------------------------
 
diff --git a/include/mrdocs/Metadata/Info/Param.hpp b/include/mrdocs/Metadata/Info/Param.hpp
index 9463a3496..0de17e20d 100644
--- a/include/mrdocs/Metadata/Info/Param.hpp
+++ b/include/mrdocs/Metadata/Info/Param.hpp
@@ -27,7 +27,7 @@ struct Param final
 {
     /** The type of this parameter
      */
-    Optional<Polymorphic<TypeInfo>> Type = std::nullopt;
+    Polymorphic<TypeInfo> Type = Polymorphic<TypeInfo>(AutoTypeInfo{});
 
     /** The parameter name.
      */
diff --git a/include/mrdocs/Metadata/Info/RecordBase.hpp b/include/mrdocs/Metadata/Info/RecordBase.hpp
index 6981db72a..982371c0a 100644
--- a/include/mrdocs/Metadata/Info/RecordBase.hpp
+++ b/include/mrdocs/Metadata/Info/RecordBase.hpp
@@ -22,11 +22,23 @@ namespace clang::mrdocs {
 */
 struct BaseInfo
 {
-    Optional<Polymorphic<TypeInfo>> Type;
+    /** The base type.
+
+        This is typically a `NamedTypeInfo` that refers to a
+        `RecordInfo`, but it could also be a more complex type
+        such as a `decltype`.
+     */
+    Polymorphic<TypeInfo> Type;
+
+    /** The access specifier for the base.
+     */
     AccessKind Access = AccessKind::Public;
+
+    /** Whether the base is virtual.
+     */
     bool IsVirtual = false;
 
-    BaseInfo() = default;
+    BaseInfo() = delete;
 
     BaseInfo(
         Polymorphic<TypeInfo>&& type,
diff --git a/include/mrdocs/Metadata/Info/Source.hpp b/include/mrdocs/Metadata/Info/Source.hpp
index bbf39accc..b38a20c67 100644
--- a/include/mrdocs/Metadata/Info/Source.hpp
+++ b/include/mrdocs/Metadata/Info/Source.hpp
@@ -14,9 +14,9 @@
 #define MRDOCS_API_METADATA_INFO_SOURCE_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Info/Location.hpp>
 #include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/Dom.hpp>
+#include <mrdocs/Metadata/Info/Location.hpp>
 #include <string>
 
 namespace clang::mrdocs {
diff --git a/include/mrdocs/Metadata/Info/Typedef.hpp b/include/mrdocs/Metadata/Info/Typedef.hpp
index a8c66aa6e..06d4c367d 100644
--- a/include/mrdocs/Metadata/Info/Typedef.hpp
+++ b/include/mrdocs/Metadata/Info/Typedef.hpp
@@ -13,8 +13,8 @@
 #ifndef MRDOCS_API_METADATA_INFO_TYPEDEF_HPP
 #define MRDOCS_API_METADATA_INFO_TYPEDEF_HPP
 
-#include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/ADT/Optional.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Metadata/Info.hpp>
 #include <mrdocs/Metadata/Name.hpp>
 #include <mrdocs/Metadata/Template.hpp>
@@ -26,7 +26,7 @@ namespace clang::mrdocs {
 struct TypedefInfo final
     : InfoCommonBase<InfoKind::Typedef>
 {
-    Optional<Polymorphic<TypeInfo>> Type = std::nullopt;
+    Polymorphic<TypeInfo> Type = Polymorphic<TypeInfo>(NamedTypeInfo{});
 
     /** Indicates if this is a new C++ "using"-style typedef
 
diff --git a/include/mrdocs/Metadata/Info/Variable.hpp b/include/mrdocs/Metadata/Info/Variable.hpp
index 5512318b7..cfdfbee2f 100644
--- a/include/mrdocs/Metadata/Info/Variable.hpp
+++ b/include/mrdocs/Metadata/Info/Variable.hpp
@@ -32,8 +32,10 @@ struct VariableInfo final
     : InfoCommonBase<InfoKind::Variable>
 {
     /** The type of the variable */
-    Optional<Polymorphic<TypeInfo>> Type = std::nullopt;
+    Polymorphic<TypeInfo> Type = Polymorphic<TypeInfo>(NamedTypeInfo{});
 
+    /** The template information, if any.
+     */
     Optional<TemplateInfo> Template;
 
     /** The default member initializer, if any.
diff --git a/include/mrdocs/Metadata/TArg.hpp b/include/mrdocs/Metadata/TArg.hpp
index 0094ce2ea..ac1af6837 100644
--- a/include/mrdocs/Metadata/TArg.hpp
+++ b/include/mrdocs/Metadata/TArg.hpp
@@ -39,7 +39,7 @@ visit(
         return f(static_cast<add_cv_from_t<
             TArgTy, TypeTArg>&>(A),
             std::forward<Args>(args)...);
-    case TArgKind::NonType:
+    case TArgKind::Constant:
         return f(static_cast<add_cv_from_t<
             TArgTy, NonTypeTArg>&>(A),
             std::forward<Args>(args)...);
diff --git a/include/mrdocs/Metadata/TArg/NonTypeTArg.hpp b/include/mrdocs/Metadata/TArg/NonTypeTArg.hpp
index f3cad9dcd..39849cd93 100644
--- a/include/mrdocs/Metadata/TArg/NonTypeTArg.hpp
+++ b/include/mrdocs/Metadata/TArg/NonTypeTArg.hpp
@@ -21,7 +21,7 @@
 namespace clang::mrdocs {
 
 struct NonTypeTArg final
-    : TArgCommonBase<TArgKind::NonType>
+    : TArgCommonBase<TArgKind::Constant>
 {
     /** Template argument expression. */
     ExprInfo Value;
diff --git a/include/mrdocs/Metadata/TArg/TArgBase.hpp b/include/mrdocs/Metadata/TArg/TArgBase.hpp
index 0ce2269cf..5e877a92f 100644
--- a/include/mrdocs/Metadata/TArg/TArgBase.hpp
+++ b/include/mrdocs/Metadata/TArg/TArgBase.hpp
@@ -30,7 +30,7 @@ struct TArg
     constexpr virtual ~TArg() = default;
 
     constexpr bool isType()     const noexcept { return Kind == TArgKind::Type; }
-    constexpr bool isNonType()  const noexcept { return Kind == TArgKind::NonType; }
+    constexpr bool isConstant()  const noexcept { return Kind == TArgKind::Constant; }
     constexpr bool isTemplate() const noexcept { return Kind == TArgKind::Template; }
 
     auto operator<=>(TArg const&) const = default;
@@ -52,7 +52,7 @@ struct TArgCommonBase : TArg
     static constexpr TArgKind kind_id = K;
 
     static constexpr bool isType()     noexcept { return K == TArgKind::Type; }
-    static constexpr bool isNonType()  noexcept { return K == TArgKind::NonType; }
+    static constexpr bool isConstant()  noexcept { return K == TArgKind::Constant; }
     static constexpr bool isTemplate() noexcept { return K == TArgKind::Template; }
 
 protected:
diff --git a/include/mrdocs/Metadata/TArg/TArgKind.hpp b/include/mrdocs/Metadata/TArg/TArgKind.hpp
index d14174765..633753140 100644
--- a/include/mrdocs/Metadata/TArg/TArgKind.hpp
+++ b/include/mrdocs/Metadata/TArg/TArgKind.hpp
@@ -27,7 +27,7 @@ enum class TArgKind : int
     /// type arguments
     Type = 1, // for bitstream
     /// non-type arguments, i.e. expressions
-    NonType,
+    Constant,
     /// template template arguments, i.e. template names
     Template
 };
diff --git a/include/mrdocs/Metadata/TArg/TypeTArg.hpp b/include/mrdocs/Metadata/TArg/TypeTArg.hpp
index 642ec2d4a..a061d6124 100644
--- a/include/mrdocs/Metadata/TArg/TypeTArg.hpp
+++ b/include/mrdocs/Metadata/TArg/TypeTArg.hpp
@@ -23,8 +23,9 @@ namespace clang::mrdocs {
 struct TypeTArg final
     : TArgCommonBase<TArgKind::Type>
 {
-    /** Template argument type. */
-    Optional<Polymorphic<TypeInfo>> Type = std::nullopt;
+    /** Template argument type.
+     */
+    Polymorphic<TypeInfo> Type = Polymorphic<TypeInfo>(AutoTypeInfo{});
 
     auto operator<=>(TypeTArg const&) const = default;
 };
diff --git a/include/mrdocs/Metadata/TParam.hpp b/include/mrdocs/Metadata/TParam.hpp
index 9831a87f5..19d211c92 100644
--- a/include/mrdocs/Metadata/TParam.hpp
+++ b/include/mrdocs/Metadata/TParam.hpp
@@ -15,7 +15,7 @@
 #define MRDOCS_API_METADATA_TPARAM_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/TParam/NonTypeTParam.hpp>
+#include <mrdocs/Metadata/TParam/ConstantTParam.hpp>
 #include <mrdocs/Metadata/TParam/TParamBase.hpp>
 #include <mrdocs/Metadata/TParam/TemplateTParam.hpp>
 #include <mrdocs/Metadata/TParam/TypeTParam.hpp>
@@ -40,9 +40,9 @@ visit(
         return f(static_cast<add_cv_from_t<
             TParamTy, TypeTParam>&>(P),
             std::forward<Args>(args)...);
-    case TParamKind::NonType:
+    case TParamKind::Constant:
         return f(static_cast<add_cv_from_t<
-            TParamTy, NonTypeTParam>&>(P),
+            TParamTy, ConstantTParam>&>(P),
             std::forward<Args>(args)...);
     case TParamKind::Template:
         return f(static_cast<add_cv_from_t<
diff --git a/include/mrdocs/Metadata/TParam/NonTypeTParam.hpp b/include/mrdocs/Metadata/TParam/ConstantTParam.hpp
similarity index 58%
rename from include/mrdocs/Metadata/TParam/NonTypeTParam.hpp
rename to include/mrdocs/Metadata/TParam/ConstantTParam.hpp
index 2bd1e70f7..3146f9a7f 100644
--- a/include/mrdocs/Metadata/TParam/NonTypeTParam.hpp
+++ b/include/mrdocs/Metadata/TParam/ConstantTParam.hpp
@@ -11,8 +11,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_TPARAM_NONTYPETPARAM_HPP
-#define MRDOCS_API_METADATA_TPARAM_NONTYPETPARAM_HPP
+#ifndef MRDOCS_API_METADATA_TPARAM_CONSTANTTPARAM_HPP
+#define MRDOCS_API_METADATA_TPARAM_CONSTANTTPARAM_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Optional.hpp>
@@ -22,15 +22,21 @@
 
 namespace clang::mrdocs {
 
-struct NonTypeTParam final
-    : TParamCommonBase<TParamKind::NonType>
+/** A constant template parameter
+
+    Before C++26, constant template parameters were called
+    non-type template parameter in the standard wording.
+    The terminology was changed by P2841R6 / PR#7587.
+ */
+struct ConstantTParam final
+    : TParamCommonBase<TParamKind::Constant>
 {
     /** Type of the non-type template parameter */
-    Optional<Polymorphic<TypeInfo>> Type = std::nullopt;
+    Polymorphic<TypeInfo> Type = Polymorphic<TypeInfo>(AutoTypeInfo{});
 
-    std::strong_ordering operator<=>(NonTypeTParam const&) const;
+    std::strong_ordering operator<=>(ConstantTParam const&) const;
 };
 
 } // clang::mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_TPARAM_CONSTANTTPARAM_HPP
diff --git a/include/mrdocs/Metadata/TParam/TParamBase.hpp b/include/mrdocs/Metadata/TParam/TParamBase.hpp
index 5b201035d..6aa07bb11 100644
--- a/include/mrdocs/Metadata/TParam/TParamBase.hpp
+++ b/include/mrdocs/Metadata/TParam/TParamBase.hpp
@@ -26,22 +26,25 @@ class DomCorpus;
 
 struct TParam
 {
-    /** The kind of template parameter this is */
+    /** The kind of template parameter this is
+     */
     TParamKind Kind = TParamKind::Type;
 
-    /** The template parameters name, if any */
+    /** The template parameters name, if any
+     */
     std::string Name;
 
     /** Whether this template parameter is a parameter pack */
     bool IsParameterPack = false;
 
-    /** The default template argument, if any */
+    /** The default template argument, if any
+     */
     Optional<Polymorphic<TArg>> Default = std::nullopt;
 
     constexpr virtual ~TParam() = default;
 
     constexpr bool isType()     const noexcept { return Kind == TParamKind::Type; }
-    constexpr bool isNonType()  const noexcept { return Kind == TParamKind::NonType; }
+    constexpr bool isConstant()  const noexcept { return Kind == TParamKind::Constant; }
     constexpr bool isTemplate() const noexcept { return Kind == TParamKind::Template; }
 
     std::strong_ordering operator<=>(TParam const&) const;
@@ -71,7 +74,7 @@ struct TParamCommonBase : TParam
     static constexpr TParamKind kind_id = K;
 
     static constexpr bool isType()     noexcept { return K == TParamKind::Type; }
-    static constexpr bool isNonType()  noexcept { return K == TParamKind::NonType; }
+    static constexpr bool isConstant() noexcept { return K == TParamKind::Constant; }
     static constexpr bool isTemplate() noexcept { return K == TParamKind::Template; }
 
     auto operator<=>(TParamCommonBase const&) const = default;
diff --git a/include/mrdocs/Metadata/TParam/TParamKind.hpp b/include/mrdocs/Metadata/TParam/TParamKind.hpp
index 8af7b910b..ae4467da9 100644
--- a/include/mrdocs/Metadata/TParam/TParamKind.hpp
+++ b/include/mrdocs/Metadata/TParam/TParamKind.hpp
@@ -24,12 +24,14 @@ enum class TParamKind : int
     /// Template type parameter, e.g. "typename T" or "class T"
     Type = 1, // for bitstream
     /// Template non-type parameter, e.g. "int N" or "auto N"
-    NonType,
+    Constant,
     /// Template-template parameter, e.g. "template<typename> typename T"
     Template
 };
 
-MRDOCS_DECL std::string_view toString(TParamKind kind) noexcept;
+MRDOCS_DECL
+std::string_view
+toString(TParamKind kind) noexcept;
 
 } // clang::mrdocs
 
diff --git a/include/mrdocs/Metadata/Type/ArrayTypeInfo.hpp b/include/mrdocs/Metadata/Type/ArrayTypeInfo.hpp
index da746e2b2..53495933b 100644
--- a/include/mrdocs/Metadata/Type/ArrayTypeInfo.hpp
+++ b/include/mrdocs/Metadata/Type/ArrayTypeInfo.hpp
@@ -14,6 +14,7 @@
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/Type/AutoTypeInfo.hpp>
 #include <mrdocs/Metadata/Type/TypeBase.hpp>
 
 namespace clang::mrdocs {
@@ -21,7 +22,7 @@ namespace clang::mrdocs {
 struct ArrayTypeInfo final
     : TypeInfoCommonBase<TypeKind::Array>
 {
-    Optional<Polymorphic<TypeInfo>> ElementType = std::nullopt;
+    Polymorphic<TypeInfo> ElementType = Polymorphic<TypeInfo>(AutoTypeInfo{});
     ConstantExprInfo<std::uint64_t> Bounds;
 
     std::strong_ordering
diff --git a/include/mrdocs/Metadata/Type/AutoTypeInfo.hpp b/include/mrdocs/Metadata/Type/AutoTypeInfo.hpp
index 4522e72d8..724881b24 100644
--- a/include/mrdocs/Metadata/Type/AutoTypeInfo.hpp
+++ b/include/mrdocs/Metadata/Type/AutoTypeInfo.hpp
@@ -23,6 +23,9 @@ struct AutoTypeInfo final
     : TypeInfoCommonBase<TypeKind::Auto>
 {
     AutoKind Keyword = AutoKind::Auto;
+
+    /** Constraint on the auto type, if any.
+     */
     Optional<Polymorphic<NameInfo>> Constraint = std::nullopt;
 
     std::strong_ordering
diff --git a/include/mrdocs/Metadata/Type/FunctionTypeInfo.hpp b/include/mrdocs/Metadata/Type/FunctionTypeInfo.hpp
index 2c1658ba8..605b3b837 100644
--- a/include/mrdocs/Metadata/Type/FunctionTypeInfo.hpp
+++ b/include/mrdocs/Metadata/Type/FunctionTypeInfo.hpp
@@ -15,6 +15,7 @@
 #include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Metadata/Specifiers.hpp>
+#include <mrdocs/Metadata/Type/AutoTypeInfo.hpp>
 #include <mrdocs/Metadata/Type/TypeBase.hpp>
 
 namespace clang::mrdocs {
@@ -22,7 +23,7 @@ namespace clang::mrdocs {
 struct FunctionTypeInfo final
     : TypeInfoCommonBase<TypeKind::Function>
 {
-    Optional<Polymorphic<TypeInfo>> ReturnType = std::nullopt;
+    Polymorphic<TypeInfo> ReturnType = Polymorphic<TypeInfo>(AutoTypeInfo{});
     std::vector<Polymorphic<TypeInfo>> ParamTypes;
     ReferenceKind RefQualifier = ReferenceKind::None;
     NoexceptInfo ExceptionSpec;
diff --git a/include/mrdocs/Metadata/Type/LValueReferenceTypeInfo.hpp b/include/mrdocs/Metadata/Type/LValueReferenceTypeInfo.hpp
index d1eea06e2..e54cf6a1a 100644
--- a/include/mrdocs/Metadata/Type/LValueReferenceTypeInfo.hpp
+++ b/include/mrdocs/Metadata/Type/LValueReferenceTypeInfo.hpp
@@ -21,7 +21,7 @@ namespace clang::mrdocs {
 struct LValueReferenceTypeInfo final
     : TypeInfoCommonBase<TypeKind::LValueReference>
 {
-    Optional<Polymorphic<TypeInfo>> PointeeType = std::nullopt;
+    Polymorphic<TypeInfo> PointeeType = Polymorphic<TypeInfo>(AutoTypeInfo{});
 
     std::strong_ordering
     operator<=>(LValueReferenceTypeInfo const&) const;
diff --git a/include/mrdocs/Metadata/Type/MemberPointerTypeInfo.hpp b/include/mrdocs/Metadata/Type/MemberPointerTypeInfo.hpp
index 3fd3ab1fc..46bf05097 100644
--- a/include/mrdocs/Metadata/Type/MemberPointerTypeInfo.hpp
+++ b/include/mrdocs/Metadata/Type/MemberPointerTypeInfo.hpp
@@ -21,8 +21,8 @@ namespace clang::mrdocs {
 struct MemberPointerTypeInfo final
     : TypeInfoCommonBase<TypeKind::MemberPointer>
 {
-    Optional<Polymorphic<TypeInfo>> ParentType = std::nullopt;
-    Optional<Polymorphic<TypeInfo>> PointeeType = std::nullopt;
+    Polymorphic<TypeInfo> ParentType = Polymorphic<TypeInfo>(AutoTypeInfo{});
+    Polymorphic<TypeInfo> PointeeType = Polymorphic<TypeInfo>(AutoTypeInfo{});
 
     std::strong_ordering
     operator<=>(MemberPointerTypeInfo const&) const;
diff --git a/include/mrdocs/Metadata/Type/PointerTypeInfo.hpp b/include/mrdocs/Metadata/Type/PointerTypeInfo.hpp
index ffb070f8e..fdd2c42c3 100644
--- a/include/mrdocs/Metadata/Type/PointerTypeInfo.hpp
+++ b/include/mrdocs/Metadata/Type/PointerTypeInfo.hpp
@@ -21,7 +21,8 @@ namespace clang::mrdocs {
 struct PointerTypeInfo final
     : TypeInfoCommonBase<TypeKind::Pointer>
 {
-    Optional<Polymorphic<TypeInfo>> PointeeType = std::nullopt;
+    Polymorphic<TypeInfo> PointeeType = Polymorphic<TypeInfo>(AutoTypeInfo{});
+
     std::strong_ordering
     operator<=>(PointerTypeInfo const&) const;
 };
diff --git a/include/mrdocs/Metadata/Type/RValueReferenceTypeInfo.hpp b/include/mrdocs/Metadata/Type/RValueReferenceTypeInfo.hpp
index 03d41575a..e435bc7d4 100644
--- a/include/mrdocs/Metadata/Type/RValueReferenceTypeInfo.hpp
+++ b/include/mrdocs/Metadata/Type/RValueReferenceTypeInfo.hpp
@@ -21,7 +21,8 @@ namespace clang::mrdocs {
 struct RValueReferenceTypeInfo final
     : TypeInfoCommonBase<TypeKind::RValueReference>
 {
-    Optional<Polymorphic<TypeInfo>> PointeeType = std::nullopt;
+    Polymorphic<TypeInfo> PointeeType = Polymorphic<TypeInfo>(AutoTypeInfo{});
+
     std::strong_ordering
     operator<=>(RValueReferenceTypeInfo const&) const;
 };
diff --git a/include/mrdocs/Support/Expected.hpp b/include/mrdocs/Support/Expected.hpp
index 3bdcfaf2b..34f430751 100644
--- a/include/mrdocs/Support/Expected.hpp
+++ b/include/mrdocs/Support/Expected.hpp
@@ -13,8 +13,8 @@
 #define MRDOCS_API_SUPPORT_EXPECTED_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Support/Error.hpp>
 #include <mrdocs/Support/Concepts.hpp>
+#include <mrdocs/Support/Error.hpp>
 #include <mrdocs/Support/source_location.hpp>
 #include <exception>
 #include <functional>
diff --git a/mrdocs.rnc b/mrdocs.rnc
index f1ba87798..07042fa9e 100644
--- a/mrdocs.rnc
+++ b/mrdocs.rnc
@@ -288,7 +288,7 @@ grammar
     TemplateArg =
         element targ
         {
-            attribute class { "type"|"non-type"|"template" },
+            attribute class { "type"|"constant"|"template" },
             attribute name { text } ?,
             ID ?,
             attribute type { text } ?,
@@ -299,7 +299,7 @@ grammar
         element tparam
         {
             attribute name { text } ?,
-            attribute class { "type"|"non-type"|"template" },
+            attribute class { "type"|"constant"|"template" },
             attribute type { text } ?,
             attribute default { text } ?,
             TemplateParam *
diff --git a/share/mrdocs/addons/generator/adoc/partials/symbol.adoc.hbs b/share/mrdocs/addons/generator/adoc/partials/symbol.adoc.hbs
index 9dcfabc93..3cf382e49 100644
--- a/share/mrdocs/addons/generator/adoc/partials/symbol.adoc.hbs
+++ b/share/mrdocs/addons/generator/adoc/partials/symbol.adoc.hbs
@@ -37,7 +37,7 @@
 | Description
 {{#each (filter_by symbol.bases "isPublic")}}
 | {{#>markup/code}}{{> type/declarator type }}{{/markup/code}}
-| {{> javadoc/inline-brief symbol.doc.brief }}
+| {{> javadoc/inline-brief type.name.symbol.doc.brief }}
 {{/each}}
 |===
 
@@ -51,7 +51,7 @@
 | Description
 {{#each (filter_by symbol.bases "isProtected")}}
 | {{#>markup/code}}{{> type/declarator type }}{{/markup/code}}
-| {{> javadoc/inline-brief symbol.doc.brief }}
+| {{> javadoc/inline-brief type.name.symbol.doc.brief }}
 {{/each}}
 |===
 
diff --git a/share/mrdocs/addons/generator/common/partials/template/arg.hbs b/share/mrdocs/addons/generator/common/partials/template/arg.hbs
index 601600679..4b6c55f07 100644
--- a/share/mrdocs/addons/generator/common/partials/template/arg.hbs
+++ b/share/mrdocs/addons/generator/common/partials/template/arg.hbs
@@ -13,8 +13,8 @@
 {{#if (eq kind "type")~}}
     {{! TArg is a type: render the declarator ~}}
     {{~>type/declarator type link-components-impl=link-components-impl~}}
-{{else if (eq kind "non-type")~}}
-    {{! TArg is a non-type: render the value string as is ~}}
+{{else if (eq kind "constant")~}}
+    {{! TArg is a constant: render the value string as is ~}}
     {{~value~}}
 {{else if (eq kind "template")~}}
     {{! TArg is another template: render the template head ~}}
diff --git a/share/mrdocs/addons/generator/common/partials/template/param-text.hbs b/share/mrdocs/addons/generator/common/partials/template/param-text.hbs
index 1f11c5272..458628f27 100644
--- a/share/mrdocs/addons/generator/common/partials/template/param-text.hbs
+++ b/share/mrdocs/addons/generator/common/partials/template/param-text.hbs
@@ -2,7 +2,7 @@
     Renders a template parameter as text.
 
     If the template parameter is a type, the templated type name is rendered.
-    If the template parameter is a non-type, the declarator of the type is rendered.
+    If the template parameter is a constant, the declarator of the type is rendered.
     If the template parameter is a template, the template head is rendered.
 
     Expected Context: {TParam}
diff --git a/share/mrdocs/addons/generator/common/partials/template/param.hbs b/share/mrdocs/addons/generator/common/partials/template/param.hbs
index 808e7c533..83178c7a4 100644
--- a/share/mrdocs/addons/generator/common/partials/template/param.hbs
+++ b/share/mrdocs/addons/generator/common/partials/template/param.hbs
@@ -2,7 +2,7 @@
     Renders a template parameter with links to any named components.
 
     If the template parameter is a type, the templated type name is rendered.
-    If the template parameter is a non-type, the declarator of the type is rendered.
+    If the template parameter is a constant, the declarator of the type is rendered.
     If the template parameter is a template, the template head is rendered.
 
     Expected Context: {TParam}
@@ -17,7 +17,7 @@
     {{#if is-pack}}{{ str "..." }}{{/if~}}
     {{#if name}} {{name}}{{/if~}}
     {{#if default}} = {{>template/arg default link-components-impl=link-components-impl ~}}{{/if~}}
-{{else if (eq kind "non-type")~}}
+{{else if (eq kind "constant")~}}
     {{>type/declarator type decl-name=name link-components-impl=link-components-impl }}{{#if is-pack}}{{ str "..." }}{{/if~}}
     {{#if default}} = {{>template/arg default link-components-impl=link-components-impl~}}{{/if~}}
 {{else if (eq kind "template")~}}
diff --git a/share/mrdocs/addons/generator/html/partials/symbol.html.hbs b/share/mrdocs/addons/generator/html/partials/symbol.html.hbs
index 4691fc895..aea81542d 100644
--- a/share/mrdocs/addons/generator/html/partials/symbol.html.hbs
+++ b/share/mrdocs/addons/generator/html/partials/symbol.html.hbs
@@ -53,7 +53,7 @@
 </thead>
 <tbody>
 {{#each (filter_by symbol.bases "isPublic")}}
-<tr><td>{{#>markup/code}}{{> type/declarator type }}{{/markup/code}}</td><td>{{> javadoc/inline-brief symbol.doc.brief }}</td></tr>
+<tr><td>{{#>markup/code}}{{> type/declarator type }}{{/markup/code}}</td><td>{{> javadoc/inline-brief type.name.symbol.doc.brief }}</td></tr>
 {{/each}}
 </tbody>
 </table>
@@ -72,7 +72,7 @@
 </thead>
 <tbody>
 {{#each (filter_by symbol.bases "isProtected")}}
-<tr><td>{{#>markup/code}}{{> type/declarator type }}{{/markup/code}}</td><td>{{> javadoc/inline-brief symbol.doc.brief }}</td></tr>
+<tr><td>{{#>markup/code}}{{> type/declarator type }}{{/markup/code}}</td><td>{{> javadoc/inline-brief type.name.symbol.doc.brief }}</td></tr>
 {{/each}}
 </tbody>
 </table>
diff --git a/src/lib/AST/ASTVisitor.cpp b/src/lib/AST/ASTVisitor.cpp
index 24bdd9639..fa19fcb13 100644
--- a/src/lib/AST/ASTVisitor.cpp
+++ b/src/lib/AST/ASTVisitor.cpp
@@ -881,7 +881,7 @@ populate(
             param.Name = P->getName();
         }
 
-        if (!param.Type)
+        if (param.Type->isAuto())
         {
             param.Type = toTypeInfo(P->getOriginalType());
         }
@@ -907,7 +907,7 @@ populate(
 
     // extract the return type in direct dependency mode
     // if it contains a placeholder type which is
-    // deduceded as a local class type
+    // deduced as a local class type
     QualType const RT = D->getReturnType();
     MRDOCS_SYMBOL_TRACE(RT, context_);
     I.ReturnType = toTypeInfo(RT);
@@ -918,11 +918,11 @@ populate(
     }
     else if (I.Requires.Written.empty())
     {
+        MRDOCS_ASSERT(!I.ReturnType.valueless_after_move());
         // Return type SFINAE constraints
-        if (I.ReturnType &&
-            !(*I.ReturnType)->Constraints.empty())
+        if (!I.ReturnType->Constraints.empty())
         {
-            for (ExprInfo const& constraint: (*I.ReturnType)->Constraints)
+            for (ExprInfo const& constraint: I.ReturnType->Constraints)
             {
                 if (!I.Requires.Written.empty())
                 {
@@ -935,10 +935,10 @@ populate(
         // Iterate I.Params to find trailing requires clauses
         for (auto it = I.Params.begin(); it != I.Params.end(); )
         {
-            if (it->Type &&
-                !(*it->Type)->Constraints.empty())
+            MRDOCS_ASSERT(!it->Type.valueless_after_move());
+            if (!it->Type->Constraints.empty())
             {
-                for (ExprInfo const& constraint: (*it->Type)->Constraints)
+                for (ExprInfo const& constraint: it->Type->Constraints)
                 {
                     if (!I.Requires.Written.empty())
                     {
@@ -1249,7 +1249,9 @@ populate(
 {
     NamedDecl const* Aliased = D->getAliasedNamespace();
     NestedNameSpecifier NNS = D->getQualifier();
-    I.AliasedSymbol = toNameInfo(Aliased, {}, NNS);
+    Polymorphic<NameInfo> NI = toNameInfo(Aliased, {}, NNS);
+    MRDOCS_ASSERT(NI->isIdentifier());
+    I.AliasedSymbol = std::move(dynamic_cast<IdentifierNameInfo&>(*NI));
 }
 
 void
@@ -1344,21 +1346,22 @@ populate(
                 ++it;
                 continue;
             }
-            if (auto* T = dynamic_cast<TypeTArg*>(arg.operator->());
-                T &&
-                T->Type &&
-                !(*T->Type)->Constraints.empty())
+            if (auto* T = dynamic_cast<TypeTArg*>(arg.operator->()))
             {
-                for (ExprInfo const& constraint: (*T->Type)->Constraints)
+                MRDOCS_ASSERT(!T->Type.valueless_after_move());
+                if (!T->Type->Constraints.empty())
                 {
-                    if (!Template.Requires.Written.empty())
+                    for (ExprInfo const& constraint: T->Type->Constraints)
                     {
-                        Template.Requires.Written += " && ";
+                        if (!Template.Requires.Written.empty())
+                        {
+                            Template.Requires.Written += " && ";
+                        }
+                        Template.Requires.Written += constraint.Written;
                     }
-                    Template.Requires.Written += constraint.Written;
+                    it = Template.Args.erase(it);
+                    continue;
                 }
-                it = Template.Args.erase(it);
-                continue;
             }
             ++it;
         }
@@ -1531,9 +1534,9 @@ populate(
         {
             if (I.valueless_after_move())
             {
-                I = Polymorphic<TParam>(std::in_place_type<NonTypeTParam>);
+                I = Polymorphic<TParam>(std::in_place_type<ConstantTParam>);
             }
-            auto* R = dynamic_cast<NonTypeTParam*>(I.operator->());
+            auto* R = dynamic_cast<ConstantTParam*>(I.operator->());
             R->Type = toTypeInfo(P->getType());
             if (P->hasDefaultArgument() && !R->Default)
             {
@@ -1631,42 +1634,46 @@ populate(
         for (auto it = TI.Params.begin(); it != TI.Params.end(); )
         {
             Polymorphic<TParam>& param = *it;
+            MRDOCS_ASSERT(!param.valueless_after_move());
 
-            if (auto const* T = dynamic_cast<NonTypeTParam*>(param.operator->());
-                T &&
-                T->Type &&
-                !(*T->Type)->Constraints.empty())
+            if (param->isConstant())
             {
-                for (ExprInfo const& constraint: (*T->Type)->Constraints)
+                auto& T = dynamic_cast<ConstantTParam&>(*param);
+                MRDOCS_ASSERT(!T.Type.valueless_after_move());
+                if (!T.Type->Constraints.empty())
                 {
-                    if (!TI.Requires.Written.empty())
+                    for (ExprInfo const& constraint: T.Type->Constraints)
                     {
-                        TI.Requires.Written += " && ";
+                        if (!TI.Requires.Written.empty())
+                        {
+                            TI.Requires.Written += " && ";
+                        }
+                        TI.Requires.Written += constraint.Written;
                     }
-                    TI.Requires.Written += constraint.Written;
+                    it = TI.Params.erase(it);
+                    continue;
                 }
-                it = TI.Params.erase(it);
-                continue;
             }
 
             if (param->Default &&
                 (*param->Default)->isType())
             {
-                if (auto const* T = dynamic_cast<TypeTArg*>((*param->Default).operator->());
-                    T &&
-                    T->Type &&
-                    !(*T->Type)->Constraints.empty())
+                if (auto const* T = dynamic_cast<TypeTArg*>((*param->Default).operator->()))
                 {
-                    for (ExprInfo const& constraint: (*T->Type)->Constraints)
+                    MRDOCS_ASSERT(!T->Type.valueless_after_move());
+                    if (!T->Type->Constraints.empty())
                     {
-                        if (!TI.Requires.Written.empty())
+                        for (ExprInfo const& constraint: T->Type->Constraints)
                         {
-                            TI.Requires.Written += " && ";
+                            if (!TI.Requires.Written.empty())
+                            {
+                                TI.Requires.Written += " && ";
+                            }
+                            TI.Requires.Written += constraint.Written;
                         }
-                        TI.Requires.Written += constraint.Written;
+                        it = TI.Params.erase(it);
+                        continue;
                     }
-                    it = TI.Params.erase(it);
-                    continue;
                 }
             }
 
diff --git a/src/lib/AST/ParseRef.cpp b/src/lib/AST/ParseRef.cpp
index 8469da98a..1d161e551 100644
--- a/src/lib/AST/ParseRef.cpp
+++ b/src/lib/AST/ParseRef.cpp
@@ -832,11 +832,12 @@ class RefParser
         // https://en.cppreference.com/w/cpp/language/function#Function_type
         if (curParam->isArray())
         {
-            auto ATI = dynamic_cast<ArrayTypeInfo &>(*curParam);
+            ArrayTypeInfo PrevParamType = dynamic_cast<ArrayTypeInfo &>(*curParam);
             curParam = Polymorphic<TypeInfo>(std::in_place_type<PointerTypeInfo>);
-            *curParam = ATI;
-            static_cast<PointerTypeInfo &>(*curParam).PointeeType =
-                std::move(ATI.ElementType);
+            auto& curAsPointerType = dynamic_cast<PointerTypeInfo &>(*curParam);
+            curAsPointerType.PointeeType = std::move(PrevParamType.ElementType);
+            auto& PrevAsBase = dynamic_cast<TypeInfo&>(PrevParamType);
+            *curParam = std::move(PrevAsBase);
         }
 
         // 3. After producing the list of parameter types, any top-level
diff --git a/src/lib/AST/TypeInfoBuilder.cpp b/src/lib/AST/TypeInfoBuilder.cpp
index 39c173518..cfb636916 100644
--- a/src/lib/AST/TypeInfoBuilder.cpp
+++ b/src/lib/AST/TypeInfoBuilder.cpp
@@ -19,8 +19,9 @@ void
 TypeInfoBuilder::
 buildPointer(PointerType const*, unsigned quals)
 {
+    MRDOCS_ASSERT(Inner);
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<PointerTypeInfo>);
-    auto &I = dynamic_cast<PointerTypeInfo &>(***Inner);
+    auto &I = dynamic_cast<PointerTypeInfo &>(**Inner);
     I.IsConst = quals & Qualifiers::Const;
     I.IsVolatile = quals & Qualifiers::Volatile;
     Inner = &I.PointeeType;
@@ -30,16 +31,18 @@ void
 TypeInfoBuilder::
 buildLValueReference(LValueReferenceType const*)
 {
+    MRDOCS_ASSERT(Inner);
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<LValueReferenceTypeInfo>);
-    Inner = &dynamic_cast<LValueReferenceTypeInfo &>(***Inner).PointeeType;
+    Inner = &dynamic_cast<LValueReferenceTypeInfo &>(**Inner).PointeeType;
 }
 
 void
 TypeInfoBuilder::
 buildRValueReference(RValueReferenceType const*)
 {
+    MRDOCS_ASSERT(Inner);
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<RValueReferenceTypeInfo>);
-    Inner = &dynamic_cast<RValueReferenceTypeInfo &>(***Inner).PointeeType;
+    Inner = &dynamic_cast<RValueReferenceTypeInfo &>(**Inner).PointeeType;
 }
 
 void
@@ -48,8 +51,9 @@ buildMemberPointer(
     MemberPointerType const* T,
     unsigned const quals)
 {
+    MRDOCS_ASSERT(Inner);
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<MemberPointerTypeInfo>);
-    auto &I = dynamic_cast<MemberPointerTypeInfo &>(***Inner);
+    auto &I = dynamic_cast<MemberPointerTypeInfo &>(**Inner);
     I.IsConst = quals & Qualifiers::Const;
     I.IsVolatile = quals & Qualifiers::Volatile;
     // do not set NNS because the parent type is *not*
@@ -63,8 +67,9 @@ void
 TypeInfoBuilder::
 buildArray(ArrayType const* T)
 {
+    MRDOCS_ASSERT(Inner);
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<ArrayTypeInfo>);
-    auto &I = dynamic_cast<ArrayTypeInfo &>(***Inner);
+    auto &I = dynamic_cast<ArrayTypeInfo &>(**Inner);
     if (auto* CAT = dyn_cast<ConstantArrayType>(T))
     {
         getASTVisitor().populate(I.Bounds, CAT->getSizeExpr(), CAT->getSize());
@@ -81,8 +86,9 @@ TypeInfoBuilder::
 populate(FunctionType const* T)
 {
     auto* FPT = cast<FunctionProtoType>(T);
+    MRDOCS_ASSERT(Inner);
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<FunctionTypeInfo>);
-    auto &I = dynamic_cast<FunctionTypeInfo &>(***Inner);
+    auto &I = dynamic_cast<FunctionTypeInfo &>(**Inner);
     for (QualType const PT : FPT->getParamTypes())
     {
         I.ParamTypes.emplace_back(getASTVisitor().toTypeInfo(PT));
@@ -104,17 +110,18 @@ buildDecltype(
     unsigned quals,
     bool pack)
 {
+    MRDOCS_ASSERT(Inner);
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<DecltypeTypeInfo>);
-    (**Inner)->Constraints = this->Constraints;
-    (**Inner)->IsPackExpansion = pack;
+    (*Inner)->Constraints = this->Constraints;
+    (*Inner)->IsPackExpansion = pack;
 
-    auto &I = dynamic_cast<DecltypeTypeInfo &>(***Inner);
+    auto &I = dynamic_cast<DecltypeTypeInfo &>(**Inner);
     getASTVisitor().populate(I.Operand, T->getUnderlyingExpr());
     I.IsConst = quals & Qualifiers::Const;
     I.IsVolatile = quals & Qualifiers::Volatile;
 
-    (*Result)->Constraints = this->Constraints;
-    (*Result)->IsPackExpansion = pack;
+    Result->Constraints = this->Constraints;
+    Result->IsPackExpansion = pack;
 }
 
 void
@@ -124,11 +131,12 @@ buildAuto(
     unsigned const quals,
     bool const pack)
 {
+    MRDOCS_ASSERT(Inner);
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<AutoTypeInfo>);
-    (**Inner)->Constraints = this->Constraints;
-    (**Inner)->IsPackExpansion = pack;
+    (*Inner)->Constraints = this->Constraints;
+    (*Inner)->IsPackExpansion = pack;
 
-    auto &I = dynamic_cast<AutoTypeInfo &>(***Inner);
+    auto &I = dynamic_cast<AutoTypeInfo &>(**Inner);
     I.IsConst = quals & Qualifiers::Const;
     I.IsVolatile = quals & Qualifiers::Volatile;
     I.Keyword = toAutoKind(T->getKeyword());
@@ -145,8 +153,8 @@ buildAuto(
         // Constraint->Prefix = getASTVisitor().buildNameInfo(
         //     cast<Decl>(CD->getDeclContext()));
     }
-    (*Result)->Constraints = this->Constraints;
-    (*Result)->IsPackExpansion = pack;
+    Result->Constraints = this->Constraints;
+    Result->IsPackExpansion = pack;
 }
 
 void
@@ -157,11 +165,12 @@ buildTerminal(
     bool pack)
 {
     MRDOCS_SYMBOL_TRACE(T, getASTVisitor().context_);
+    MRDOCS_ASSERT(Inner);
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-    (**Inner)->IsPackExpansion = pack;
-    (**Inner)->Constraints = this->Constraints;
+    (*Inner)->IsPackExpansion = pack;
+    (*Inner)->Constraints = this->Constraints;
 
-    auto &TI = dynamic_cast<NamedTypeInfo &>(***Inner);
+    auto &TI = dynamic_cast<NamedTypeInfo &>(**Inner);
     TI.IsConst = quals & Qualifiers::Const;
     TI.IsVolatile = quals & Qualifiers::Volatile;
     TI.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
@@ -171,8 +180,8 @@ buildTerminal(
         auto const* FT = cast<BuiltinType>(T);
         TI.FundamentalType = toFundamentalTypeKind(FT->getKind());
     }
-    (*Result)->Constraints = this->Constraints;
-    (*Result)->IsPackExpansion = pack;
+    Result->Constraints = this->Constraints;
+    Result->IsPackExpansion = pack;
 }
 
 void
@@ -184,11 +193,12 @@ buildTerminal(
     unsigned quals,
     bool pack)
 {
+    MRDOCS_ASSERT(Inner);
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-    (**Inner)->IsPackExpansion = pack;
-    (**Inner)->Constraints = this->Constraints;
+    (*Inner)->IsPackExpansion = pack;
+    (*Inner)->Constraints = this->Constraints;
 
-    auto &I = dynamic_cast<NamedTypeInfo &>(***Inner);
+    auto &I = dynamic_cast<NamedTypeInfo &>(**Inner);
     I.IsConst = quals & Qualifiers::Const;
     I.IsVolatile = quals & Qualifiers::Volatile;
 
@@ -213,8 +223,8 @@ buildTerminal(
         }
         Name.Prefix = getASTVisitor().toNameInfo(NNS);
     }
-    (*Result)->Constraints = this->Constraints;
-    (*Result)->IsPackExpansion = pack;
+    Result->Constraints = this->Constraints;
+    Result->IsPackExpansion = pack;
 }
 
 void
@@ -235,11 +245,12 @@ buildTerminal(
     Decl const* ID = decayToPrimaryTemplate(D);
     MRDOCS_SYMBOL_TRACE(ID, getASTVisitor().context_);
 
+    MRDOCS_ASSERT(Inner);
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-    (**Inner)->IsPackExpansion = pack;
-    (**Inner)->Constraints = this->Constraints;
+    (*Inner)->IsPackExpansion = pack;
+    (*Inner)->Constraints = this->Constraints;
 
-    auto &TI = dynamic_cast<NamedTypeInfo &>(***Inner);
+    auto &TI = dynamic_cast<NamedTypeInfo &>(**Inner);
     TI.IsConst = quals & Qualifiers::Const;
     TI.IsVolatile = quals & Qualifiers::Volatile;
 
@@ -272,8 +283,8 @@ buildTerminal(
         populateNameInfo(Name, D);
         getASTVisitor().populate(Name.TemplateArgs, *TArgs);
     }
-    (*Result)->Constraints = this->Constraints;
-    (*Result)->IsPackExpansion = pack;
+    Result->Constraints = this->Constraints;
+    Result->IsPackExpansion = pack;
 }
 
 } // clang::mrdocs
diff --git a/src/lib/AST/TypeInfoBuilder.hpp b/src/lib/AST/TypeInfoBuilder.hpp
index 361ce04e9..92fbdda33 100644
--- a/src/lib/AST/TypeInfoBuilder.hpp
+++ b/src/lib/AST/TypeInfoBuilder.hpp
@@ -40,7 +40,7 @@ class TypeInfoBuilder
        as a polymorphic `TypeInfo` object.
 
      */
-    Optional<Polymorphic<TypeInfo>> Result = std::nullopt;
+    Polymorphic<TypeInfo> Result = Polymorphic<TypeInfo>(AutoTypeInfo{});
 
     /*  A pointer to the inner type of result currently being populated.
 
@@ -61,7 +61,7 @@ class TypeInfoBuilder
         `NamedTypeInfo` object, and the visiting process continues
         populating the `Inner` object.
      */
-    Optional<Polymorphic<TypeInfo>>* Inner = &Result;
+    Polymorphic<TypeInfo>* Inner = &Result;
 
 public:
     using TerminalTypeVisitor::TerminalTypeVisitor;
@@ -76,15 +76,7 @@ class TypeInfoBuilder
     Polymorphic<TypeInfo>
     result()
     {
-        MRDOCS_ASSERT(hasResult());
-        return std::move(*Result);
-    }
-
-    constexpr
-    bool
-    hasResult() const noexcept
-    {
-        return Result.has_value();
+        return std::move(Result);
     }
 
     /** Build type information for a pointer type.
diff --git a/src/lib/CorpusImpl.cpp b/src/lib/CorpusImpl.cpp
index 6b947fb97..f7dd6d079 100644
--- a/src/lib/CorpusImpl.cpp
+++ b/src/lib/CorpusImpl.cpp
@@ -365,7 +365,7 @@ isDecayedEqual(
                                         static_cast<const TypeTArg &>(*rhs).Type,
                                         context, corpus);
     }
-    if (lhs->isNonType())
+    if (lhs->isConstant())
     {
         return trim(static_cast<const NonTypeTArg &>(*lhs).Value.Written) ==
                trim(static_cast<const NonTypeTArg &>(*rhs).Value.Written);
@@ -502,8 +502,8 @@ lookupImpl(
     if (auto* TI = contextPtr->asTypedefPtr())
     {
         MRDOCS_CHECK_OR(TI->Type, nullptr);
-        MRDOCS_ASSERT(!TI->Type->valueless_after_move());
-        SymbolID resolvedSymbolID = (*TI->Type)->namedSymbol();
+        MRDOCS_ASSERT(!TI->Type.valueless_after_move());
+        SymbolID resolvedSymbolID = (*TI->Type).namedSymbol();
         contextPtr = this->find(resolvedSymbolID);
         MRDOCS_CHECK_OR(contextPtr, nullptr);
     }
@@ -652,9 +652,8 @@ lookupImpl(
             MRDOCS_CHECK_OR(F.IsExplicitObjectMemberFunction == ref.IsExplicitObjectMemberFunction, matchRes);
             for (std::size_t i = 0; i < F.Params.size(); ++i)
             {
-                auto& lhsTypeOpt = F.Params[i].Type;
-                MRDOCS_CHECK_OR(lhsTypeOpt, matchRes);
-                auto& lhsType = *lhsTypeOpt;
+                Polymorphic<TypeInfo> const& lhsType = F.Params[i].Type;
+                MRDOCS_ASSERT(!lhsType.valueless_after_move());
                 auto& rhsType  = ref.FunctionParameters[i];
                 MRDOCS_CHECK_OR(isDecayedEqual(lhsType, rhsType, context, *this), matchRes);
             }
@@ -680,7 +679,7 @@ lookupImpl(
         {
             res = &member;
             matchLevel = memberMatchLevel;
-            // Early exit if the matchMatchLevel is the highest possible
+            // Early exit if the match level is the highest possible
             // for the component and the parsed reference
             if (matchLevel >= highestMatchLevel)
             {
diff --git a/src/lib/Gen/hbs/TagfileWriter.cpp b/src/lib/Gen/hbs/TagfileWriter.cpp
index 01c8519b9..060bce1d1 100644
--- a/src/lib/Gen/hbs/TagfileWriter.cpp
+++ b/src/lib/Gen/hbs/TagfileWriter.cpp
@@ -200,11 +200,8 @@ TagfileWriter::
 writeFunctionMember(FunctionInfo const& I)
 {
     tags_.open("member", {{"kind", "function"}});
-    if (I.ReturnType)
-    {
-        MRDOCS_ASSERT(!I.ReturnType->valueless_after_move());
-        tags_.write("type", toString(**I.ReturnType));
-    }
+    MRDOCS_ASSERT(!I.ReturnType.valueless_after_move());
+    tags_.write("type", toString(*I.ReturnType));
     tags_.write("name", I.Name);
     auto [anchorFile, anchor] = generateFileAndAnchor(I);
     tags_.write("anchorfile", anchorFile);
@@ -212,16 +209,11 @@ writeFunctionMember(FunctionInfo const& I)
     std::string arglist = "(";
     for(auto const& J : I.Params)
     {
-        if (J.Type)
-        {
-            arglist += toString(**J.Type);
-            if (J.Name)
-            {
-                arglist += " ";
-            }
-        }
+        MRDOCS_ASSERT(!J.Type.valueless_after_move());
+        arglist += toString(*J.Type);
         if (J.Name)
         {
+            arglist += " ";
             arglist += *J.Name;
         }
         arglist += ", ";
diff --git a/src/lib/Gen/hbs/VisitorHelpers.cpp b/src/lib/Gen/hbs/VisitorHelpers.cpp
index af18610cf..beeda7e9c 100644
--- a/src/lib/Gen/hbs/VisitorHelpers.cpp
+++ b/src/lib/Gen/hbs/VisitorHelpers.cpp
@@ -51,10 +51,10 @@ resolveTypedef(Corpus const& c, Info const& I)
     {
         auto const& TI = I.asTypedef();
         MRDOCS_CHECK_OR(TI.Type, &I);
-        MRDOCS_ASSERT(!TI.Type->valueless_after_move());
-        Polymorphic<TypeInfo> const& T = *TI.Type;
-        MRDOCS_CHECK_OR(!T.valueless_after_move() && T->Kind == TypeKind::Named, &I);
-        auto const& NT = dynamic_cast<NamedTypeInfo const&>(*T);
+        MRDOCS_ASSERT(!TI.Type.valueless_after_move());
+        TypeInfo const& T = *TI.Type;
+        MRDOCS_CHECK_OR(T.Kind == TypeKind::Named, &I);
+        auto const& NT = dynamic_cast<NamedTypeInfo const&>(T);
         MRDOCS_CHECK_OR(NT.Name, &I);
         Info const* resolved = c.find(NT.Name->id);
         MRDOCS_CHECK_OR(resolved, &I);
@@ -171,11 +171,10 @@ findResolvedPrimarySiblingWithUrl(Corpus const& c, Info const& I)
         if constexpr (std::same_as<InfoTy, TypedefInfo>)
         {
             auto const& TOpt = U.Type;
-            MRDOCS_CHECK_OR(TOpt, false);
-            Polymorphic<TypeInfo> const& T = *TOpt;
-            MRDOCS_CHECK_OR(!T.valueless_after_move(), false);
-            MRDOCS_CHECK_OR(T->Kind == TypeKind::Named, false);
-            auto const& NT = dynamic_cast<NamedTypeInfo const&>(*T);
+            MRDOCS_CHECK_OR(!TOpt.valueless_after_move(), false);
+            TypeInfo const& T = *TOpt;
+            MRDOCS_CHECK_OR(T.Kind == TypeKind::Named, false);
+            auto const& NT = dynamic_cast<NamedTypeInfo const&>(T);
             MRDOCS_CHECK_OR(NT.Name, false);
             MRDOCS_CHECK_OR(NT.Name->Kind == NameKind::Specialization, false);
             return true;
diff --git a/src/lib/Gen/xml/CXXTags.hpp b/src/lib/Gen/xml/CXXTags.hpp
index 28eb954e9..4799d9866 100644
--- a/src/lib/Gen/xml/CXXTags.hpp
+++ b/src/lib/Gen/xml/CXXTags.hpp
@@ -126,8 +126,7 @@ writeType(
     XMLTags& tags,
     std::string_view type_tag = "type")
 {
-    visit(I, [&]<typename T>(
-        T const& t)
+    visit(I, [&]<typename T>(T const& t)
         {
             Attributes attrs = {
                 { "class", toString(T::kind_id),
@@ -135,14 +134,11 @@ writeType(
                 { "is-pack", "1", t.IsPackExpansion }
             };
 
-            // KRYSTIAN FIXME: parent should is a type itself
+            // KRYSTIAN FIXME: parent should be a type itself
             if constexpr(requires { t.ParentType; })
             {
-                if (t.ParentType)
-                {
-                    MRDOCS_ASSERT(!t.ParentType->valueless_after_move());
-                    attrs.push({ "parent", toString(**t.ParentType) });
-                }
+                MRDOCS_ASSERT(!t.ParentType.valueless_after_move());
+                attrs.push({ "parent", toString(*t.ParentType) });
             }
 
             if constexpr(T::isNamed())
@@ -223,42 +219,51 @@ writeType(
 
             if constexpr(requires { t.PointeeType; })
             {
-                Optional<Polymorphic<TypeInfo>> pointee = t.PointeeType;
-                if (pointee)
-                {
-                    MRDOCS_ASSERT(!pointee->valueless_after_move());
-                    writeType(**t.PointeeType, tags, "pointee-type");
-                }
+                Polymorphic<TypeInfo> const& pointee = t.PointeeType;
+                MRDOCS_ASSERT(!pointee.valueless_after_move());
+                writeType(*t.PointeeType, tags, "pointee-type");
             }
 
             if constexpr(T::isArray())
             {
                 ArrayTypeInfo const& at = t;
-                if (at.ElementType)
-                {
-                    MRDOCS_ASSERT(!at.ElementType->valueless_after_move());
-                    writeType(**t.ElementType, tags, "element-type");
-                }
+                MRDOCS_ASSERT(!at.ElementType.valueless_after_move());
+                writeType(*t.ElementType, tags, "element-type");
             }
 
             if constexpr(T::isFunction())
             {
                 FunctionTypeInfo const& ft = t;
-                if (ft.ReturnType)
+                MRDOCS_ASSERT(!ft.ReturnType.valueless_after_move());
+                writeType(*t.ReturnType, tags, "return-type");
+                for (auto const& p: t.ParamTypes)
                 {
-                    MRDOCS_ASSERT(!ft.ReturnType->valueless_after_move());
-                    writeType(**t.ReturnType, tags, "return-type");
-                    for (auto const& p: t.ParamTypes)
-                    {
-                        writeType(*p, tags, "param-type");
-                    }
+                    writeType(*p, tags, "param-type");
                 }
             }
-
             tags.close(type_tag);
         });
 }
 
+
+inline
+void
+writeType(
+    NameInfo const& I,
+    XMLTags& tags,
+    std::string_view type_tag = "type")
+{
+    Attributes attrs = {
+        { "class", toString(TypeKind::Named), false },
+        { "is-pack", "1", false }
+    };
+
+    attrs.push({I.id});
+    attrs.push({"name", I.Name});
+
+    tags.write(type_tag, {}, std::move(attrs));
+}
+
 inline
 void
 writeType(
@@ -316,14 +321,11 @@ inline void writeTemplateParam(TParam const& I, XMLTags& tags)
             { "class", toString(T::kind_id) }
         };
 
-        if constexpr (T::isNonType())
+        if constexpr (T::isConstant())
         {
-            NonTypeTParam const& nt = P;
-            if (nt.Type)
-            {
-                MRDOCS_ASSERT(!nt.Type->valueless_after_move());
-                attrs.push({ "type", toString(**nt.Type) });
-            }
+            ConstantTParam const& nt = P;
+            MRDOCS_ASSERT(!nt.Type.valueless_after_move());
+            attrs.push({ "type", toString(*nt.Type) });
         }
 
         if (tp.Default)
@@ -357,13 +359,10 @@ inline void writeTemplateArg(TArg const& I, XMLTags& tags)
         if constexpr (T::isType())
         {
             TypeTArg const& at = A;
-            if (at.Type)
-            {
-                MRDOCS_ASSERT(!at.Type->valueless_after_move());
-                attrs.push({ "type", toString(**A.Type) });
-            }
+            MRDOCS_ASSERT(!at.Type.valueless_after_move());
+            attrs.push({ "type", toString(*A.Type) });
         }
-        if constexpr (T::isNonType())
+        if constexpr (T::isConstant())
         {
             attrs.push({ "value", A.Value.Written });
         }
diff --git a/src/lib/Gen/xml/XMLTags.hpp b/src/lib/Gen/xml/XMLTags.hpp
index 450b726d9..2cd35bf82 100644
--- a/src/lib/Gen/xml/XMLTags.hpp
+++ b/src/lib/Gen/xml/XMLTags.hpp
@@ -113,7 +113,7 @@ struct Attribute
 
 //------------------------------------------------
 
-/** An vector of zero or more XML attributes.
+/** A vector of zero or more XML attributes.
 */
 struct Attributes
 {
diff --git a/src/lib/Gen/xml/XMLWriter.cpp b/src/lib/Gen/xml/XMLWriter.cpp
index 06a92ba35..a4af395e9 100644
--- a/src/lib/Gen/xml/XMLWriter.cpp
+++ b/src/lib/Gen/xml/XMLWriter.cpp
@@ -251,10 +251,8 @@ writeFunction(
     writeAttr(I.IsNodiscard,           "nodiscard", tags_);
     writeAttr(I.IsExplicitObjectMemberFunction, "is-explicit-object-member-function", tags_);
 
-    if (I.ReturnType)
-    {
-        writeReturnType(**I.ReturnType, tags_);
-    }
+    MRDOCS_ASSERT(!I.ReturnType.valueless_after_move());
+    writeReturnType(*I.ReturnType, tags_);
 
     for (auto const& J: I.Params)
     {
@@ -350,13 +348,10 @@ writeNamespaceAlias(
 
     writeJavadoc(I.javadoc);
 
-    if (I.AliasedSymbol)
-    {
-        tags_.write("aliased", {}, {
-            {"name", toString(**I.AliasedSymbol)},
-            { (*I.AliasedSymbol)->id }
-        });
-    }
+    tags_.write("aliased", {}, {
+        {"name", toString(I.AliasedSymbol)},
+        { I.AliasedSymbol.id }
+    });
 
     tags_.close(namespaceAliasTagName);
 }
@@ -431,7 +426,7 @@ writeRecord(
             { B.Access },
             { "class", "virtual", B.IsVirtual },
         });
-        writeType(B.Type, tags_);
+        writeType(*B.Type, tags_);
         tags_.close(baseTagName);
     }
 
diff --git a/src/lib/Gen/xml/XMLWriter.hpp b/src/lib/Gen/xml/XMLWriter.hpp
index b165c7ac3..9af8ed3d0 100644
--- a/src/lib/Gen/xml/XMLWriter.hpp
+++ b/src/lib/Gen/xml/XMLWriter.hpp
@@ -23,7 +23,7 @@ namespace clang::mrdocs::xml {
 
 class jit_indenter;
 
-/** A writer which outputs XML.
+/** A writer that outputs XML.
 */
 class XMLWriter
 {
diff --git a/src/lib/Metadata/Finalizers/BaseMembersFinalizer.cpp b/src/lib/Metadata/Finalizers/BaseMembersFinalizer.cpp
index ad214cf13..d52af11e4 100644
--- a/src/lib/Metadata/Finalizers/BaseMembersFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/BaseMembersFinalizer.cpp
@@ -227,20 +227,17 @@ operator()(RecordInfo& I)
     MRDOCS_CHECK_OR(!finalized_.contains(I.id));
     for (BaseInfo const& baseI: I.Bases)
     {
-        auto const *baseNameType =
-            dynamic_cast<NamedTypeInfo const *>(&**baseI.Type);
-        MRDOCS_CHECK_OR_CONTINUE(baseNameType);
-        auto const *baseName =
-            dynamic_cast<NameInfo const *>(&*baseNameType->Name);
-        MRDOCS_CHECK_OR_CONTINUE(baseName);
-        SymbolID baseID = baseName->id;
+        MRDOCS_ASSERT(!baseI.Type.valueless_after_move());
+        MRDOCS_CHECK_OR_CONTINUE(baseI.Type->isNamed());
+        auto& baseNameType = dynamic_cast<NamedTypeInfo const&>(*baseI.Type);
+        MRDOCS_ASSERT(!baseNameType.Name.valueless_after_move());
+        auto& baseName = dynamic_cast<NameInfo const&>(*baseNameType.Name);
+        SymbolID baseID = baseName.id;
         if (corpus_.config->extractImplicitSpecializations && 
-            baseName->isSpecialization())
+            baseName.isSpecialization())
         {
-            auto const *baseSpec =
-                dynamic_cast<SpecializationNameInfo const *>(baseName);
-            MRDOCS_CHECK_OR_CONTINUE(baseSpec);
-            baseID = baseSpec->specializationID;
+            auto& baseSpec = dynamic_cast<SpecializationNameInfo const&>(baseName);
+            baseID = baseSpec.specializationID;
         }
         MRDOCS_CHECK_OR_CONTINUE(baseID);
         auto basePtr = corpus_.find(baseID);
diff --git a/src/lib/Metadata/Finalizers/DerivedFinalizer.cpp b/src/lib/Metadata/Finalizers/DerivedFinalizer.cpp
index 31daac914..63ab1f9c6 100644
--- a/src/lib/Metadata/Finalizers/DerivedFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/DerivedFinalizer.cpp
@@ -30,9 +30,9 @@ build()
         {
             MRDOCS_CHECK_OR_CONTINUE(base.Access == AccessKind::Public);
             MRDOCS_CHECK_OR_CONTINUE(base.Type);
-            MRDOCS_ASSERT(!base.Type->valueless_after_move());
-            MRDOCS_CHECK_OR_CONTINUE((*base.Type)->isNamed());
-            auto& namedType = dynamic_cast<NamedTypeInfo&>(**base.Type);
+            MRDOCS_ASSERT(!base.Type.valueless_after_move());
+            MRDOCS_CHECK_OR_CONTINUE(base.Type->isNamed());
+            auto& namedType = dynamic_cast<NamedTypeInfo&>(*base.Type);
             MRDOCS_CHECK_OR_CONTINUE(namedType.Name);
             SymbolID const namedSymbolID = namedType.Name->id;
             MRDOCS_CHECK_OR_CONTINUE(namedSymbolID != SymbolID::invalid);
diff --git a/src/lib/Metadata/Finalizers/Javadoc/Function.hpp b/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
index bd301d7c6..0415292b1 100644
--- a/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
+++ b/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
@@ -47,10 +47,8 @@ isCopyOrMoveConstructorOrAssignment(FunctionInfo const& I)
     }
     MRDOCS_CHECK_OR(I.Params.size() == 1, false);
     auto const& param = I.Params[0];
-    auto const& paramTypeOpt = param.Type;
-    MRDOCS_CHECK_OR(paramTypeOpt, false);
-    auto const& paramType = *paramTypeOpt;
-    MRDOCS_CHECK_OR(!paramType.valueless_after_move(), false);
+    Polymorphic<TypeInfo> const& paramType = param.Type;
+    MRDOCS_ASSERT(!paramType.valueless_after_move());
     if constexpr (!move)
     {
         MRDOCS_CHECK_OR(paramType->isLValueReference(), false);
@@ -63,12 +61,9 @@ isCopyOrMoveConstructorOrAssignment(FunctionInfo const& I)
     auto const& paramRefType = static_cast<RefType const &>(*paramType);
     auto const& paramRefPointeeOpt = paramRefType.PointeeType;
     MRDOCS_CHECK_OR(paramRefPointeeOpt, false);
-    auto const& paramRefPointee = *paramRefPointeeOpt;
-    MRDOCS_CHECK_OR(!paramRefPointee.valueless_after_move(), false);
-    auto const *paramRefPointeeNamed =
-        static_cast<NamedTypeInfo const *>(&*paramRefPointee);
-    if (!paramRefPointeeNamed)
-      return false;
+    TypeInfo const& paramRefPointee = *paramRefPointeeOpt;
+    auto const *paramRefPointeeNamed = dynamic_cast<NamedTypeInfo const *>(&paramRefPointee);
+    MRDOCS_CHECK_OR(paramRefPointeeNamed, false);
     MRDOCS_CHECK_OR(paramRefPointeeNamed->Name, false);
     auto const& paramName = paramRefPointeeNamed->Name;
     MRDOCS_CHECK_OR(paramName, false);
@@ -108,19 +103,19 @@ innermostTypenameString(Polymorphic<TypeInfo> const& T)
 {
     auto& R = innermostType(T);
     MRDOCS_CHECK_OR(R->isNamed(), {});
-    MRDOCS_CHECK_OR(static_cast<NamedTypeInfo const &>(*R).Name, {});
-    MRDOCS_CHECK_OR(!static_cast<NamedTypeInfo const &>(*R).Name->Name.empty(),
+    MRDOCS_CHECK_OR(dynamic_cast<NamedTypeInfo const &>(*R).Name, {});
+    MRDOCS_CHECK_OR(!dynamic_cast<NamedTypeInfo const &>(*R).Name->Name.empty(),
                     {});
-    auto& RStr = static_cast<const NamedTypeInfo &>(*R).Name->Name;
+    auto& RStr = dynamic_cast<const NamedTypeInfo &>(*R).Name->Name;
     return RStr;
 }
 
-Optional<std::string_view>
-innermostTypenameString(Optional<Polymorphic<TypeInfo>> const& T)
-{
-    MRDOCS_CHECK_OR(T, {});
-    return innermostTypenameString(*T);
-}
+//Optional<std::string_view>
+//innermostTypenameString(Optional<Polymorphic<TypeInfo>> const& T)
+//{
+//    MRDOCS_CHECK_OR(T, {});
+//    return innermostTypenameString(*T);
+//}
 
 bool
 populateFunctionBriefFromClass(FunctionInfo& I, CorpusImpl const& corpus)
@@ -204,19 +199,18 @@ isStreamInsertion(FunctionInfo const& function)
     MRDOCS_CHECK_OR(!function.IsRecordMethod, false);
     MRDOCS_CHECK_OR(function.Params.size() == 2, false);
     MRDOCS_CHECK_OR(function.OverloadedOperator == OperatorKind::LessLess, false);
-    // Check first param is mutable left reference
+    // Check first param is a mutable left reference
     auto& firstParam = function.Params[0];
     MRDOCS_CHECK_OR(firstParam, false);
-    auto& firstQualTypeOpt = firstParam.Type;
-    MRDOCS_CHECK_OR(firstQualTypeOpt, false);
-    auto& firstQualType = *firstQualTypeOpt;
+    Polymorphic<TypeInfo> const& firstQualType = firstParam.Type;
+    MRDOCS_ASSERT(!firstQualType.valueless_after_move());
     MRDOCS_CHECK_OR(firstQualType->isLValueReference(), false);
     auto& firstNamedTypeOpt =
-        static_cast<LValueReferenceTypeInfo const &>(*firstQualType)
+        dynamic_cast<LValueReferenceTypeInfo const &>(*firstQualType)
             .PointeeType;
     MRDOCS_CHECK_OR(firstNamedTypeOpt, false);
     auto& firstNamedType = *firstNamedTypeOpt;
-    MRDOCS_CHECK_OR(firstNamedType->isNamed(), false);
+    MRDOCS_CHECK_OR(firstNamedType.isNamed(), false);
     // Check return type
     return firstQualType == function.ReturnType;
 }
@@ -356,8 +350,8 @@ populateFunctionReturnsForSpecial(
     }
 
     // Special functions that should return a reference to self
-    if (I.ReturnType &&
-        (*I.ReturnType)->isLValueReference())
+    MRDOCS_ASSERT(!I.ReturnType.valueless_after_move());
+    if (I.ReturnType->isLValueReference())
     {
         Info const* RInfo = getInfo(innerR, corpus);
         MRDOCS_CHECK_OR(RInfo, false);
@@ -365,10 +359,7 @@ populateFunctionReturnsForSpecial(
         I.javadoc->returns.emplace_back("Reference to the current object");
         return true;
     }
-
-    // Special functions that should return a pointer to self
-    if (I.ReturnType &&
-        (*I.ReturnType)->isPointer())
+    else if (I.ReturnType->isPointer())
     {
         Info const* RInfo = getInfo(innerR, corpus);
         MRDOCS_CHECK_OR(RInfo, false);
@@ -389,10 +380,9 @@ populateFunctionReturnsForSpecial(
               OperatorKind::Exclaim }))
     {
         MRDOCS_CHECK_OR(I.ReturnType, false);
-        MRDOCS_CHECK_OR((*I.ReturnType)->isNamed(), false);
-        MRDOCS_ASSERT(!I.ReturnType->valueless_after_move());
+        MRDOCS_CHECK_OR(I.ReturnType->isNamed(), false);
         MRDOCS_CHECK_OR(
-            static_cast<NamedTypeInfo &>(**I.ReturnType).FundamentalType ==
+            dynamic_cast<NamedTypeInfo &>(*I.ReturnType).FundamentalType ==
                 FundamentalTypeKind::Bool,
             false);
         doc::Returns r;
@@ -448,22 +438,22 @@ populateFunctionReturnsForSpecial(
     if (I.IsRecordMethod &&
         !innerR.valueless_after_move() &&
         innerR->isNamed() &&
-        !static_cast<NamedTypeInfo const &>(*innerR).Name.valueless_after_move() &&
-        static_cast<NamedTypeInfo const &>(*innerR).Name->id &&
-        static_cast<NamedTypeInfo const &>(*innerR).Name->id == I.Parent)
+        !dynamic_cast<NamedTypeInfo const &>(*innerR).Name.valueless_after_move() &&
+        dynamic_cast<NamedTypeInfo const &>(*innerR).Name->id &&
+        dynamic_cast<NamedTypeInfo const &>(*innerR).Name->id == I.Parent)
     {
         MRDOCS_CHECK_OR(I.ReturnType, false);
-        MRDOCS_ASSERT(!I.ReturnType->valueless_after_move());
-        if ((*I.ReturnType)->isLValueReference())
+        MRDOCS_ASSERT(!I.ReturnType.valueless_after_move());
+        if (I.ReturnType->isLValueReference())
         {
             I.javadoc->returns.emplace_back("Reference to the current object");
         }
-        else if ((*I.ReturnType)->isRValueReference())
+        else if (I.ReturnType->isRValueReference())
         {
             I.javadoc->returns.emplace_back(
                 "Rvalue reference to the current object");
         }
-        else if ((*I.ReturnType)->isPointer())
+        else if (I.ReturnType->isPointer())
         {
             I.javadoc->returns.emplace_back("Pointer to the current object");
         }
@@ -502,12 +492,12 @@ populateFunctionReturns(FunctionInfo& I, CorpusImpl const& corpus)
 
     // Check if we have a named return type
     MRDOCS_CHECK_OR(I.ReturnType);
-    MRDOCS_CHECK_OR(!I.ReturnType->valueless_after_move());
-    auto& inner = innermostType(*I.ReturnType);
+    MRDOCS_CHECK_OR(!I.ReturnType.valueless_after_move());
+    auto& inner = innermostType(I.ReturnType);
     MRDOCS_CHECK_OR(inner);
     if (inner->isNamed())
     {
-        auto& Ninner = static_cast<NamedTypeInfo const &>(*inner);
+        auto& Ninner = dynamic_cast<NamedTypeInfo const &>(*inner);
         MRDOCS_CHECK_OR(Ninner.Name);
         MRDOCS_CHECK_OR(!Ninner.Name->Name.empty());
         MRDOCS_CHECK_OR(Ninner.FundamentalType != FundamentalTypeKind::Void);
@@ -564,8 +554,8 @@ setCntrOrAssignParamName(
             return *p.Name;
         });
     MRDOCS_CHECK_OR(param.Type, false);
-    MRDOCS_ASSERT(!param.Type->valueless_after_move());
-    auto& innerP = innermostType(*param.Type);
+    MRDOCS_ASSERT(!param.Type.valueless_after_move());
+    Polymorphic<TypeInfo>& innerP = innermostType(param.Type);
     std::string_view paramName = "value";
     if (innerP->namedSymbol() == I.Parent)
     {
@@ -676,30 +666,27 @@ setCntrOrAssignParamDoc(
     // Set the parameter description if we can
     MRDOCS_CHECK_OR(param, false);
     MRDOCS_CHECK_OR(param.Type, false);
-    MRDOCS_ASSERT(!param.Type->valueless_after_move());
-    auto& innerParam = innermostType(*param.Type);
+    MRDOCS_ASSERT(!param.Type.valueless_after_move());
+    auto& innerParam = innermostType(param.Type);
     MRDOCS_CHECK_OR(innerParam, false);
     MRDOCS_CHECK_OR(innerParam->isNamed(), false);
     std::string_view const paramNoun
-        = static_cast<NamedTypeInfo &>(*innerParam).FundamentalType ? "value"
+        = dynamic_cast<NamedTypeInfo &>(*innerParam).FundamentalType ? "value"
                                                                     : "object";
     std::string_view const functionVerb = [&]() {
         bool const isAssign = I.OverloadedOperator == OperatorKind::Equal;
-        if (static_cast<NamedTypeInfo &>(*innerParam).FundamentalType)
+        if (dynamic_cast<NamedTypeInfo &>(*innerParam).FundamentalType)
         {
             return !isAssign ? "construct" : "assign";
         }
-        if (param.Type)
+        MRDOCS_ASSERT(!param.Type.valueless_after_move());
+        if (param.Type->isLValueReference())
         {
-            MRDOCS_ASSERT(!param.Type->valueless_after_move());
-            if ((*param.Type)->isLValueReference())
-            {
-                return !isAssign ? "copy construct" : "copy assign";
-            }
-            if ((*param.Type)->isRValueReference())
-            {
-                return !isAssign ? "move construct" : "move assign";
-            }
+            return !isAssign ? "copy construct" : "copy assign";
+        }
+        if (param.Type->isRValueReference())
+        {
+            return !isAssign ? "move construct" : "move assign";
         }
         return !isAssign ? "construct" : "assign";
     }();
@@ -789,9 +776,8 @@ setFunctionParamDoc(
 
     // param is a named parameter: use the brief of the type
     // as a description for the parameter
-    MRDOCS_CHECK_OR(param.Type);
-    MRDOCS_ASSERT(!param.Type->valueless_after_move());
-    auto const& innerParam = innermostType(*param.Type);
+    MRDOCS_ASSERT(!param.Type.valueless_after_move());
+    auto const& innerParam = innermostType(param.Type);
     doc::Brief const* paramBrief = getInfoBrief(innerParam, corpus);
     MRDOCS_CHECK_OR(paramBrief);
     I.javadoc->params.emplace_back(*param.Name, *paramBrief);
diff --git a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp b/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
index 67dc1bfad..90970d597 100644
--- a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
@@ -12,9 +12,10 @@
 #include <lib/Metadata/Finalizers/Javadoc/Function.hpp>
 #include <lib/Metadata/Finalizers/Javadoc/Overloads.hpp>
 #include <lib/Metadata/Finalizers/JavadocFinalizer.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Support/Algorithm.hpp>
-#include <mrdocs/Support/ScopeExit.hpp>
 #include <mrdocs/Support/Path.hpp>
+#include <mrdocs/Support/ScopeExit.hpp>
 #include <algorithm>
 #include <format>
 
@@ -440,9 +441,8 @@ finalizeMetadataCopies(Info& I)
             // Copy exceptions only if destination exceptions are empty
             // and the destination is not noexcept
             bool const destIsNoExcept =
-                I.isFunction() ?
-                I.asFunction().Noexcept.Kind == NoexceptKind::False :
-                false;
+                I.isFunction() &&
+                I.asFunction().Noexcept.Kind == NoexceptKind::False;
             if (destJavadoc.exceptions.empty() &&
                 !destIsNoExcept)
             {
@@ -720,10 +720,8 @@ finalizeInfoData(InfoTy& I)
     }
     if constexpr (requires { I.ReturnType; })
     {
-        if (I.ReturnType)
-        {
-            finalize(**I.ReturnType);
-        }
+        MRDOCS_ASSERT(!I.ReturnType.valueless_after_move());
+        finalize(*I.ReturnType);
     }
     if constexpr (requires { I.Params; })
     {
@@ -731,9 +729,23 @@ finalizeInfoData(InfoTy& I)
     }
     if constexpr (requires { I.Type; })
     {
-        if (I.Type)
+        if constexpr (detail::isOptionalV<decltype(I.Type)>)
         {
-            finalize(**I.Type);
+            if (I.Type)
+            {
+                finalize(**I.Type);
+            }
+        }
+        else if constexpr (detail::IsPolymorphic<decltype(I.Type)>)
+        {
+            if (!I.Type.valueless_after_move())
+            {
+                finalize(*I.Type);
+            }
+        }
+        else if (I.Type)
+        {
+            finalize(*I.Type);
         }
     }
     if constexpr (requires { I.UnderlyingType; })
@@ -753,10 +765,7 @@ finalizeInfoData(InfoTy& I)
     }
     if constexpr (requires { I.AliasedSymbol; })
     {
-        if (I.AliasedSymbol)
-        {
-            finalize(**I.AliasedSymbol);
-        }
+        finalize(I.AliasedSymbol);
     }
     if constexpr (requires { I.IntroducedName; })
     {
@@ -771,10 +780,7 @@ finalizeInfoData(InfoTy& I)
     }
     if constexpr (requires { I.Deduced; })
     {
-        if (I.Deduced)
-        {
-            finalize(**I.Deduced);
-        }
+        finalize(*I.Deduced);
     }
 }
 
@@ -1265,7 +1271,7 @@ setAutoRelates()
     // 1) Inner type of the first parameter
     [&] {
         MRDOCS_CHECK_OR(!I.Params.empty());
-        auto* firstParamInfo = toRecordOrEnum(*I.Params.front().Type);
+        auto* firstParamInfo = toRecordOrEnum(I.Params.front().Type);
         MRDOCS_CHECK_OR(firstParamInfo);
         if (firstParamInfo->Extraction == ExtractionMode::Regular)
         {
@@ -1276,15 +1282,15 @@ setAutoRelates()
         MRDOCS_CHECK_OR(firstParamInfo->isRecord());
         auto const* firstParamRecord = dynamic_cast<RecordInfo*>(firstParamInfo);
         MRDOCS_CHECK_OR(
-            (*I.Params.front().Type)->isLValueReference() ||
-            (*I.Params.front().Type)->isRValueReference() ||
-            (*I.Params.front().Type)->isPointer());
+            I.Params.front().Type->isLValueReference() ||
+            I.Params.front().Type->isRValueReference() ||
+            I.Params.front().Type->isPointer());
         // Get all transitively derived classes of firstParamRecord
        pushAllDerivedClasses(firstParamRecord, relatedRecordsOrEnums, corpus_);
     }();
 
     // 3) The return type of the function
-    if (auto* returnTypeInfo = toRecordOrEnum(*I.ReturnType))
+    if (auto* returnTypeInfo = toRecordOrEnum(I.ReturnType))
     {
         if (returnTypeInfo->Extraction == ExtractionMode::Regular)
         {
@@ -1295,8 +1301,8 @@ setAutoRelates()
         // each template parameter is also a related record
         [&] {
             MRDOCS_CHECK_OR(I.ReturnType);
-            MRDOCS_CHECK_OR((*I.ReturnType)->isNamed());
-            auto& NTI = dynamic_cast<NamedTypeInfo &>(**I.ReturnType);
+            MRDOCS_CHECK_OR(I.ReturnType->isNamed());
+            auto& NTI = dynamic_cast<NamedTypeInfo &>(*I.ReturnType);
             MRDOCS_CHECK_OR(NTI.Name);
             MRDOCS_CHECK_OR(NTI.Name->isSpecialization());
             auto const& NTIS = dynamic_cast<SpecializationNameInfo &>(*NTI.Name);
@@ -1304,7 +1310,7 @@ setAutoRelates()
             Polymorphic<TArg> const& firstArg = NTIS.TemplateArgs.front();
             MRDOCS_CHECK_OR(firstArg->isType());
             auto const& typeArg = dynamic_cast<TypeTArg const &>(*firstArg);
-            if (auto* argInfo = toRecordOrEnum(*typeArg.Type))
+            if (auto* argInfo = toRecordOrEnum(typeArg.Type))
             {
                 if (argInfo->Extraction == ExtractionMode::Regular)
                 {
@@ -1552,10 +1558,8 @@ finalize(TArg& arg)
     {
         if constexpr (Ty::isType())
         {
-            if (A.Type)
-            {
-                finalize(**A.Type);
-            }
+            MRDOCS_ASSERT(!A.Type.valueless_after_move());
+            finalize(*A.Type);
         }
         if constexpr (Ty::isTemplate())
         {
@@ -1581,13 +1585,10 @@ finalize(TParam& param)
                 finalize(**P.Constraint);
             }
         }
-
-        if constexpr (Ty::isNonType())
+        if constexpr (Ty::isConstant())
         {
-            if (P.Type)
-            {
-                finalize(**P.Type);
-            }
+            MRDOCS_ASSERT(!P.Type.valueless_after_move());
+            finalize(*P.Type);
         }
 
         if constexpr (Ty::isTemplate())
@@ -1601,20 +1602,16 @@ void
 JavadocFinalizer::
 finalize(Param& param)
 {
-    if (param.Type)
-    {
-        finalize(**param.Type);
-    }
+    MRDOCS_ASSERT(!param.Type.valueless_after_move());
+    finalize(*param.Type);
 }
 
 void
 JavadocFinalizer::
 finalize(BaseInfo& info)
 {
-    if (info.Type)
-    {
-        finalize(**info.Type);
-    }
+    MRDOCS_ASSERT(!info.Type.valueless_after_move());
+    finalize(*info.Type);
 }
 
 void
@@ -1950,8 +1947,9 @@ warnNoParamDocs(FunctionInfo const& I)
     }
 
     // Check for undocumented return type
-    if (I.javadoc->returns.empty() && I.ReturnType)
+    if (I.javadoc->returns.empty())
     {
+        MRDOCS_ASSERT(!I.ReturnType.valueless_after_move());
         auto isVoid = [](TypeInfo const& returnType) -> bool
         {
             if (returnType.isNamed())
@@ -1961,7 +1959,7 @@ warnNoParamDocs(FunctionInfo const& I)
             }
             return false;
         };
-        if (!isVoid(**I.ReturnType))
+        if (!isVoid(*I.ReturnType))
         {
             this->warn(
                 *getPrimaryLocation(I),
diff --git a/src/lib/Metadata/Finalizers/OverloadsFinalizer.cpp b/src/lib/Metadata/Finalizers/OverloadsFinalizer.cpp
index 3d377dd2c..57ff43840 100644
--- a/src/lib/Metadata/Finalizers/OverloadsFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/OverloadsFinalizer.cpp
@@ -28,7 +28,7 @@ findBaseClassPermutation(
     {
         // Find the i-th base class
         MRDOCS_CHECK_OR(base.Type, SymbolID::invalid);
-        auto const baseInfo = corpus.find((*base.Type)->namedSymbol());
+        auto const baseInfo = corpus.find(base.Type->namedSymbol());
         MRDOCS_CHECK_OR_CONTINUE(baseInfo);
         auto const baseRecord = baseInfo->asRecordPtr();
         MRDOCS_CHECK_OR_CONTINUE(baseRecord);
@@ -290,9 +290,9 @@ operator()(RecordInfo& I)
     for (auto& b: I.Bases)
     {
         auto& BT = b.Type;
-        MRDOCS_CHECK_OR(BT);
-        MRDOCS_CHECK_OR((*BT)->isNamed());
-        auto& NT = dynamic_cast<NamedTypeInfo&>(**BT);
+        MRDOCS_ASSERT(!BT.valueless_after_move());
+        MRDOCS_CHECK_OR(BT->isNamed());
+        auto& NT = dynamic_cast<NamedTypeInfo&>(*BT);
         MRDOCS_CHECK_OR(NT.Name);
         auto& NI = dynamic_cast<NameInfo&>(*NT.Name);
         MRDOCS_CHECK_OR(NI.id);
diff --git a/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp b/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp
index eaa345770..01fe2f00d 100644
--- a/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp
@@ -163,35 +163,32 @@ struct SymbolIDCompareFn
             (lhsOp && *lhsOp == OperatorKind::Equal &&
              rhsOp && *rhsOp == OperatorKind::Equal))
         {
-            auto& lhsF = lhs.asFunction();
-            auto& rhsF = rhs.asFunction();
+            FunctionInfo const& lhsF = lhs.asFunction();
+            FunctionInfo const& rhsF = rhs.asFunction();
             if (lhsF.Params.size() == 1 && rhsF.Params.size() == 1)
             {
                 auto isCopyOrMoveConstOrAssign = [](FunctionInfo const& I) {
                     if (I.Params.size() == 1)
                     {
                         auto const& param = I.Params[0];
-                        auto const& paramTypeOpt = param.Type;
-                        MRDOCS_CHECK_OR(paramTypeOpt, false);
-                        auto const& paramType = *paramTypeOpt;
-                        if (!paramType->isLValueReference()
-                            && !paramType->isRValueReference())
-                        {
-                            return false;
-                        }
-                        auto const &paramRefPointeeOpt =
+                        Polymorphic<TypeInfo> const& paramType = param.Type;
+                        MRDOCS_ASSERT(!paramType.valueless_after_move());
+                        MRDOCS_CHECK_OR(
+                            paramType->isLValueReference() ||
+                            paramType->isRValueReference(), false);
+                        Polymorphic<TypeInfo> const &paramRefPointeeOpt =
                             paramType->isLValueReference()
-                                ? static_cast<LValueReferenceTypeInfo const &>(*paramType)
+                                ? dynamic_cast<LValueReferenceTypeInfo const &>(*paramType)
                                     .PointeeType
-                                : static_cast<RValueReferenceTypeInfo const &>(*paramType)
+                                : dynamic_cast<RValueReferenceTypeInfo const &>(*paramType)
                                     .PointeeType;
                         MRDOCS_CHECK_OR(paramRefPointeeOpt, false);
                         auto const& paramRefPointee = *paramRefPointeeOpt;
-                        if (!paramRefPointee->isNamed())
+                        if (!paramRefPointee.isNamed())
                         {
                             return false;
                         }
-                        return paramRefPointee->namedSymbol() == I.Parent;
+                        return paramRefPointee.namedSymbol() == I.Parent;
                     }
                     return false;
                 };
@@ -206,10 +203,10 @@ struct SymbolIDCompareFn
                 // Ensure move comes after copy
                 if (lhsIsCopyOrMove && rhsIsCopyOrMove)
                 {
-                    MRDOCS_CHECK_OR(!lhsF.Params[0].Type, false);
-                    MRDOCS_CHECK_OR(!rhsF.Params[0].Type, true);
-                    bool const lhsIsMove = (*lhsF.Params[0].Type)->isRValueReference();
-                    bool const rhsIsMove = (*rhsF.Params[0].Type)->isRValueReference();
+                    MRDOCS_ASSERT(!lhsF.Params[0].Type.valueless_after_move());
+                    MRDOCS_ASSERT(!rhsF.Params[0].Type.valueless_after_move());
+                    bool const lhsIsMove = lhsF.Params[0].Type->isRValueReference();
+                    bool const rhsIsMove = rhsF.Params[0].Type->isRValueReference();
                     if (lhsIsMove != rhsIsMove)
                     {
                         return !lhsIsMove;
diff --git a/src/lib/Metadata/Info/Function.cpp b/src/lib/Metadata/Info/Function.cpp
index 73fec236f..0958ce35b 100644
--- a/src/lib/Metadata/Info/Function.cpp
+++ b/src/lib/Metadata/Info/Function.cpp
@@ -292,7 +292,7 @@ toString(FunctionClass const kind) noexcept
 void
 merge(Param& I, Param&& Other)
 {
-    if (!I.Type)
+    if (I.Type->isAuto())
     {
         I.Type = std::move(Other.Type);
     }
@@ -391,10 +391,7 @@ merge(FunctionInfo& I, FunctionInfo&& Other)
     {
         I.Class = Other.Class;
     }
-    if (!I.ReturnType)
-    {
-        I.ReturnType = std::move(Other.ReturnType);
-    }
+    I.ReturnType = std::move(Other.ReturnType);
     std::size_t const n = std::min(I.Params.size(), Other.Params.size());
     for (std::size_t i = 0; i < n; ++i)
     {
diff --git a/src/lib/Metadata/Info/Guide.cpp b/src/lib/Metadata/Info/Guide.cpp
index ef3b232e5..1fc51fcd2 100644
--- a/src/lib/Metadata/Info/Guide.cpp
+++ b/src/lib/Metadata/Info/Guide.cpp
@@ -83,7 +83,7 @@ void merge(GuideInfo& I, GuideInfo&& Other)
 {
     MRDOCS_ASSERT(canMerge(I, Other));
     merge(I.asInfo(), std::move(Other.asInfo()));
-    if (!I.Deduced)
+    if (I.Deduced->isAuto())
     {
         I.Deduced = std::move(Other.Deduced);
     }
@@ -102,4 +102,3 @@ void merge(GuideInfo& I, GuideInfo&& Other)
 }
 
 } // clang::mrdocs
-
diff --git a/src/lib/Metadata/Info/NamespaceAlias.cpp b/src/lib/Metadata/Info/NamespaceAlias.cpp
index ee20ac9bc..8f79a616f 100644
--- a/src/lib/Metadata/Info/NamespaceAlias.cpp
+++ b/src/lib/Metadata/Info/NamespaceAlias.cpp
@@ -20,9 +20,13 @@ merge(NamespaceAliasInfo& I, NamespaceAliasInfo&& Other)
 {
     MRDOCS_ASSERT(canMerge(I, Other));
     merge(I.asInfo(), std::move(Other.asInfo()));
-    if (!I.AliasedSymbol)
+    if (I.AliasedSymbol.Name.empty())
     {
-        I.AliasedSymbol = std::move(Other.AliasedSymbol);
+        I.AliasedSymbol.Name = std::move(Other.AliasedSymbol.Name);
+    }
+    if (!I.AliasedSymbol.id)
+    {
+        I.AliasedSymbol.id = Other.AliasedSymbol.id;
     }
 }
 
diff --git a/src/lib/Metadata/Info/Overloads.cpp b/src/lib/Metadata/Info/Overloads.cpp
index 4982bd1c6..e7659d37c 100644
--- a/src/lib/Metadata/Info/Overloads.cpp
+++ b/src/lib/Metadata/Info/Overloads.cpp
@@ -57,7 +57,8 @@ addMember(OverloadsInfo& I, FunctionInfo const& Member)
         I.Extraction = leastSpecific(I.Extraction, Member.Extraction);
         if (I.ReturnType != Member.ReturnType)
         {
-            I.ReturnType = std::nullopt;
+            // The return types differ, so we use 'auto' to indicate that.
+            I.ReturnType = Polymorphic<TypeInfo>(AutoTypeInfo{});
         }
     }
     merge(I.Loc, Member.Loc);
diff --git a/src/lib/Metadata/Info/Record.cpp b/src/lib/Metadata/Info/Record.cpp
index 89216ea30..b5cd1f261 100644
--- a/src/lib/Metadata/Info/Record.cpp
+++ b/src/lib/Metadata/Info/Record.cpp
@@ -10,6 +10,7 @@
 
 #include <mrdocs/Dom/LazyObject.hpp>
 #include <mrdocs/Metadata/Info/Record.hpp>
+#include <mrdocs/Metadata/Name.hpp>
 #include <ranges>
 
 namespace clang::mrdocs {
@@ -170,12 +171,6 @@ tag_invoke(
     io.map("isPrivate", I.Access == AccessKind::Private);
     io.map("isVirtual", I.IsVirtual);
     io.map("type", dom::ValueFrom(I.Type, domCorpus));
-    if (I.Type)
-    {
-        MRDOCS_ASSERT(!I.Type->valueless_after_move());
-        io.map("symbol", (*I.Type)->namedSymbol());
-    }
-
 }
 
 void
diff --git a/src/lib/Metadata/Info/Typedef.cpp b/src/lib/Metadata/Info/Typedef.cpp
index 22809f4b9..666a0cea8 100644
--- a/src/lib/Metadata/Info/Typedef.cpp
+++ b/src/lib/Metadata/Info/Typedef.cpp
@@ -67,7 +67,7 @@ void merge(TypedefInfo& I, TypedefInfo&& Other)
     {
         I.IsUsing = Other.IsUsing;
     }
-    if (!I.Type)
+    if (I.Type.valueless_after_move())
     {
         I.Type = std::move(Other.Type);
     }
diff --git a/src/lib/Metadata/Info/Variable.cpp b/src/lib/Metadata/Info/Variable.cpp
index 5a6d6435b..6f8283479 100644
--- a/src/lib/Metadata/Info/Variable.cpp
+++ b/src/lib/Metadata/Info/Variable.cpp
@@ -63,7 +63,7 @@ merge(VariableInfo& I, VariableInfo&& Other)
 {
     MRDOCS_ASSERT(canMerge(I, Other));
     merge(I.asInfo(), std::move(Other.asInfo()));
-    if (!I.Type)
+    if (I.Type.valueless_after_move())
     {
         I.Type = std::move(Other.Type);
     }
diff --git a/src/lib/Metadata/Name.cpp b/src/lib/Metadata/Name.cpp
index 6202f5f30..76554248f 100644
--- a/src/lib/Metadata/Name.cpp
+++ b/src/lib/Metadata/Name.cpp
@@ -119,13 +119,10 @@ toStringImpl(
             {
                 if constexpr(U::isType())
                 {
-                    if (u.Type)
-                    {
-                        MRDOCS_ASSERT(!u.Type->valueless_after_move());
-                        writeTo(result, toString(**u.Type));
-                    }
+                    MRDOCS_ASSERT(!u.Type.valueless_after_move());
+                    writeTo(result, toString(*u.Type));
                 }
-                if constexpr(U::isNonType())
+                if constexpr(U::isConstant())
                 {
                     writeTo(result, u.Value.Written);
                 }
diff --git a/src/lib/Metadata/Source.cpp b/src/lib/Metadata/Source.cpp
index b0ca0814f..1dcaf2af8 100644
--- a/src/lib/Metadata/Source.cpp
+++ b/src/lib/Metadata/Source.cpp
@@ -11,9 +11,9 @@
 
 #include <mrdocs/Dom/LazyArray.hpp>
 #include <mrdocs/Dom/LazyObject.hpp>
-#include <mrdocs/Metadata/Info/Source.hpp>
-#include <mrdocs/Metadata/Info/Location.hpp>
 #include <mrdocs/Metadata/Info/FileKind.hpp>
+#include <mrdocs/Metadata/Info/Location.hpp>
+#include <mrdocs/Metadata/Info/Source.hpp>
 #include <llvm/ADT/STLExtras.h>
 #include <ranges>
 
diff --git a/src/lib/Metadata/Template.cpp b/src/lib/Metadata/Template.cpp
index 5aad05a58..d52c94cf0 100644
--- a/src/lib/Metadata/Template.cpp
+++ b/src/lib/Metadata/Template.cpp
@@ -25,8 +25,8 @@ toString(TArgKind kind) noexcept
     {
     case TArgKind::Type:
         return "type";
-    case TArgKind::NonType:
-        return "non-type";
+    case TArgKind::Constant:
+        return "constant";
     case TArgKind::Template:
         return "template";
     default:
@@ -42,8 +42,8 @@ toString(
     {
     case TParamKind::Type:
         return "type";
-    case TParamKind::NonType:
-        return "non-type";
+    case TParamKind::Constant:
+        return "constant";
     case TParamKind::Template:
         return "template";
     default:
@@ -129,13 +129,10 @@ toString(
         std::string result;
         if constexpr(T::isType())
         {
-            if (t.Type)
-            {
-                MRDOCS_ASSERT(!t.Type->valueless_after_move());
-                result += toString(**t.Type);
-            }
+            MRDOCS_ASSERT(!t.Type.valueless_after_move());
+            result += toString(*t.Type);
         }
-        if constexpr(T::isNonType())
+        if constexpr(T::isConstant())
         {
             result += t.Value.Written;
         }
@@ -165,7 +162,7 @@ tag_invoke(
         {
             io.map("type", t.Type);
         }
-        if constexpr(T::isNonType())
+        if constexpr(T::isConstant())
         {
             io.map("value", t.Value.Written);
         }
@@ -193,8 +190,8 @@ TypeTParam::
 operator<=>(TypeTParam const&) const = default;
 
 std::strong_ordering
-NonTypeTParam::
-operator<=>(NonTypeTParam const&) const = default;
+ConstantTParam::
+operator<=>(ConstantTParam const&) const = default;
 
 std::strong_ordering
 TemplateTParam::
@@ -240,7 +237,7 @@ tag_invoke(
                 io.map("constraint", t.Constraint);
             }
         }
-        if constexpr(T::isNonType())
+        if constexpr(T::isConstant())
         {
             io.map("type", t.Type);
         }
diff --git a/src/lib/Metadata/Type.cpp b/src/lib/Metadata/Type.cpp
index 16fed0b8f..6343caa36 100644
--- a/src/lib/Metadata/Type.cpp
+++ b/src/lib/Metadata/Type.cpp
@@ -172,11 +172,9 @@ operator()(
 
     if constexpr(requires { t.ParentType; })
     {
-        if(t.ParentType)
-        {
-            writeFullType(**t.ParentType, write);
-            write("::");
-        }
+        MRDOCS_ASSERT(!t.ParentType.valueless_after_move());
+        writeFullType(*t.ParentType, write);
+        write("::");
     }
 
     if constexpr(T::isDecltype())
@@ -790,24 +788,18 @@ innerTypeImpl(TypeInfoTy&& TI) noexcept
     {
         if constexpr(requires { t.PointeeType; })
         {
-            if (t.PointeeType)
-            {
-                return &*t.PointeeType;
-            }
+            MRDOCS_ASSERT(!t.PointeeType.valueless_after_move());
+            return &t.PointeeType;
         }
         if constexpr(requires { t.ElementType; })
         {
-            if (t.ElementType)
-            {
-                return &*t.ElementType;
-            }
+            MRDOCS_ASSERT(!t.ElementType.valueless_after_move());
+            return &t.ElementType;
         }
         if constexpr(requires { t.ReturnType; })
         {
-            if (t.ReturnType)
-            {
-                return &*t.ReturnType;
-            }
+            MRDOCS_ASSERT(!t.ReturnType.valueless_after_move());
+            return &t.ReturnType;
         }
         return nullptr;
     });
diff --git a/src/lib/Support/Report.cpp b/src/lib/Support/Report.cpp
index 54180cbfb..24c1d4cde 100644
--- a/src/lib/Support/Report.cpp
+++ b/src/lib/Support/Report.cpp
@@ -13,8 +13,8 @@
 #include <mrdocs/Support/Path.hpp>
 #include <mrdocs/Version.hpp>
 #include <llvm/Support/Mutex.h>
-#include <llvm/Support/raw_ostream.h>
 #include <llvm/Support/Signals.h>
+#include <llvm/Support/raw_ostream.h>
 #include <cstdlib>
 #include <format>
 #include <mutex>
diff --git a/src/lib/clang.natvis b/src/lib/clang.natvis
index 99226d36f..0f3cc7c9c 100644
--- a/src/lib/clang.natvis
+++ b/src/lib/clang.natvis
@@ -109,12 +109,12 @@ For later versions of Visual Studio, no setup is required-->
     <Type Name="clang::ParsedTemplateArgument">
         <DisplayString Condition="Kind==clang::ParsedTemplateArgument::Type" IncludeView="cpp">{(clang::QualType *)Arg,view(cpp)na}</DisplayString>
         <DisplayString Condition="Kind==clang::ParsedTemplateArgument::Type">{*(clang::QualType *)Arg}</DisplayString>
-        <DisplayString Condition="Kind==clang::ParsedTemplateArgument::NonType">{*(clang::Expr *)Arg}</DisplayString>
+        <DisplayString Condition="Kind==clang::ParsedTemplateArgument::Constant">{*(clang::Expr *)Arg}</DisplayString>
         <DisplayString Condition="Kind==clang::ParsedTemplateArgument::Template">{*(clang::TemplateName *)Arg</DisplayString>
         <Expand>
             <Item Name="Kind">Kind,en</Item>
             <Item Name="Arg" Condition="Kind==clang::ParsedTemplateArgument::Type">(clang::QualType *)Arg</Item>
-            <Item Name="Arg" Condition="Kind==clang::ParsedTemplateArgument::NonType">(clang::Expr *)Arg</Item>
+            <Item Name="Arg" Condition="Kind==clang::ParsedTemplateArgument::Constant">(clang::Expr *)Arg</Item>
             <Item Name="Arg" Condition="Kind==clang::ParsedTemplateArgument::Template">(clang::TemplateName *)Arg</Item>
         </Expand>
     </Type>
diff --git a/src/test/ADT/Optional.cpp b/src/test/ADT/Optional.cpp
index 539233a48..00e8496d3 100644
--- a/src/test/ADT/Optional.cpp
+++ b/src/test/ADT/Optional.cpp
@@ -10,9 +10,9 @@
 
 #include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/Metadata/Info/Source.hpp>
-#include <test_suite/test_suite.hpp>
 #include <optional>
 #include <type_traits>
+#include <test_suite/test_suite.hpp>
 
 namespace clang::mrdocs {
 
diff --git a/src/test/Support/Expected.cpp b/src/test/Support/Expected.cpp
index 432da2d36..b633a90b3 100644
--- a/src/test/Support/Expected.cpp
+++ b/src/test/Support/Expected.cpp
@@ -17,10 +17,10 @@
 //
 
 #include <mrdocs/Support/Expected.hpp>
-#include <test_suite/test_suite.hpp>
 #include <string>
 #include <type_traits>
 #include <utility>
+#include <test_suite/test_suite.hpp>
 
 namespace clang {
 namespace mrdocs {
diff --git a/src/tool/ToolMain.cpp b/src/tool/ToolMain.cpp
index 3e4717d89..4b65e3ed9 100644
--- a/src/tool/ToolMain.cpp
+++ b/src/tool/ToolMain.cpp
@@ -16,8 +16,8 @@
 #include <mrdocs/Version.hpp>
 #include <llvm/Support/FileSystem.h>
 #include <llvm/Support/PrettyStackTrace.h>
-#include <llvm/Support/raw_ostream.h>
 #include <llvm/Support/Signals.h>
+#include <llvm/Support/raw_ostream.h>
 #include <llvm/TargetParser/Host.h>
 #include <cstdlib>
 #include <ranges>
diff --git a/test-files/golden-tests/config/auto-relates/enum.xml b/test-files/golden-tests/config/auto-relates/enum.xml
index 5667f16fc..6c4490ced 100644
--- a/test-files/golden-tests/config/auto-relates/enum.xml
+++ b/test-files/golden-tests/config/auto-relates/enum.xml
@@ -18,7 +18,7 @@
   </template>
   <template>
     <tparam name="T" class="type"/>
-    <tparam name="N" class="non-type" type="unsigned long"/>
+    <tparam name="N" class="constant" type="unsigned long"/>
     <class name="SmallVector" id="Xw0FzsI74YygQXKG0MGYooG1ALg=">
       <file short-path="enum.cpp" source-path="enum.cpp" line="12" class="def"/>
       <doc>
diff --git a/test-files/golden-tests/config/auto-relates/return-type.xml b/test-files/golden-tests/config/auto-relates/return-type.xml
index 28170572e..6621622c4 100644
--- a/test-files/golden-tests/config/auto-relates/return-type.xml
+++ b/test-files/golden-tests/config/auto-relates/return-type.xml
@@ -31,7 +31,7 @@
   </template>
   <template>
     <tparam name="T" class="type"/>
-    <tparam name="N" class="non-type" type="unsigned long"/>
+    <tparam name="N" class="constant" type="unsigned long"/>
     <class name="SmallVector" id="Xw0FzsI74YygQXKG0MGYooG1ALg=">
       <file short-path="return-type.cpp" source-path="return-type.cpp" line="12" class="def"/>
       <doc>
diff --git a/test-files/golden-tests/filters/symbol-type/nested-private-template.xml b/test-files/golden-tests/filters/symbol-type/nested-private-template.xml
index ba14e83fc..c2901f3f8 100644
--- a/test-files/golden-tests/filters/symbol-type/nested-private-template.xml
+++ b/test-files/golden-tests/filters/symbol-type/nested-private-template.xml
@@ -8,7 +8,7 @@
       <file short-path="nested-private-template.cpp" source-path="nested-private-template.cpp" line="1" class="def"/>
       <template>
         <tparam name="R" class="type"/>
-        <tparam class="non-type" type="bool"/>
+        <tparam class="constant" type="bool"/>
         <struct name="impl" access="private" id="7XlFKPcXRfyYPWc4WPN3PAH+m58=">
           <file short-path="nested-private-template.cpp" source-path="nested-private-template.cpp" line="4"/>
         </struct>
@@ -16,7 +16,7 @@
       <template class="partial" id="7XlFKPcXRfyYPWc4WPN3PAH+m58=">
         <tparam name="R" class="type"/>
         <targ class="type" type="R"/>
-        <targ class="non-type" value="false"/>
+        <targ class="constant" value="false"/>
         <struct name="impl" access="private" id="BCRU3eMBRSysyvFsjJj+0yg+Vfc=">
           <file short-path="nested-private-template.cpp" source-path="nested-private-template.cpp" line="10" class="def"/>
         </struct>
diff --git a/test-files/golden-tests/javadoc/copydoc/param-types.xml b/test-files/golden-tests/javadoc/copydoc/param-types.xml
index de0134f5a..46a1c89f5 100644
--- a/test-files/golden-tests/javadoc/copydoc/param-types.xml
+++ b/test-files/golden-tests/javadoc/copydoc/param-types.xml
@@ -87,7 +87,7 @@
     </function>
   </struct>
   <template>
-    <tparam name="Idx" class="non-type" type="int"/>
+    <tparam name="Idx" class="constant" type="int"/>
     <struct name="paramType" id="5uZOiQm8Wn76QPmEs/Kkcw4y7Uc=">
       <file short-path="param-types.cpp" source-path="param-types.cpp" line="2" class="def"/>
       <doc>
diff --git a/test-files/golden-tests/javadoc/copydoc/qualified.xml b/test-files/golden-tests/javadoc/copydoc/qualified.xml
index 3ab2d360a..c5ec713e0 100644
--- a/test-files/golden-tests/javadoc/copydoc/qualified.xml
+++ b/test-files/golden-tests/javadoc/copydoc/qualified.xml
@@ -215,7 +215,7 @@
     </struct>
   </namespace>
   <template>
-    <tparam name="N" class="non-type" type="int"/>
+    <tparam name="N" class="constant" type="int"/>
     <class name="param_t" id="X9R785kQEYyJ0tnnSr0SvdLAZQw=">
       <file short-path="qualified.cpp" source-path="qualified.cpp" line="2"/>
       <doc>
diff --git a/test-files/golden-tests/javadoc/copydoc/template-arguments.xml b/test-files/golden-tests/javadoc/copydoc/template-arguments.xml
index 2acc34ca1..22b961105 100644
--- a/test-files/golden-tests/javadoc/copydoc/template-arguments.xml
+++ b/test-files/golden-tests/javadoc/copydoc/template-arguments.xml
@@ -23,7 +23,7 @@
     </namespace-alias>
     <template>
       <tparam name="T" class="type"/>
-      <tparam name="I" class="non-type" type="int"/>
+      <tparam name="I" class="constant" type="int"/>
       <namespace-alias name="B_t" id="40FFJWRtg8LikFmMYkFhi3taM7w=">
         <file short-path="template-arguments.cpp" source-path="template-arguments.cpp" line="11"/>
         <type id="jJtr0x+P2kzEfxAlp7Hjo5akJho=" name="B&lt;T, I&gt;"/>
@@ -57,7 +57,7 @@
     </namespace-alias>
     <template>
       <tparam name="T" class="type"/>
-      <tparam name="B" class="non-type" type="bool"/>
+      <tparam name="B" class="constant" type="bool"/>
       <namespace-alias name="C_t" id="N9KZXiVz/IMBW2CcGYh+8cvUeFQ=">
         <file short-path="template-arguments.cpp" source-path="template-arguments.cpp" line="39"/>
         <type id="WjzMcZfRtncsiJEvL1/LzUes/GM=" name="C&lt;T, B&gt;"/>
@@ -73,7 +73,7 @@
     </template>
     <template>
       <tparam name="T" class="type"/>
-      <tparam class="non-type" type="int" default="0"/>
+      <tparam class="constant" type="int" default="0"/>
       <struct name="B" id="jJtr0x+P2kzEfxAlp7Hjo5akJho=">
         <file short-path="template-arguments.cpp" source-path="template-arguments.cpp" line="7"/>
         <doc>
@@ -102,7 +102,7 @@
     </template>
     <template class="explicit" id="jJtr0x+P2kzEfxAlp7Hjo5akJho=">
       <targ class="type" type="int"/>
-      <targ class="non-type" value="2"/>
+      <targ class="constant" value="2"/>
       <struct name="B" id="zWh7HJU4uEOW6SQu1/X6/fBkFq0=">
         <file short-path="template-arguments.cpp" source-path="template-arguments.cpp" line="25" class="def"/>
         <doc>
@@ -114,7 +114,7 @@
     </template>
     <template>
       <tparam name="T" class="type"/>
-      <tparam class="non-type" type="bool" default="false"/>
+      <tparam class="constant" type="bool" default="false"/>
       <struct name="C" id="WjzMcZfRtncsiJEvL1/LzUes/GM=">
         <file short-path="template-arguments.cpp" source-path="template-arguments.cpp" line="35"/>
         <doc>
@@ -132,7 +132,7 @@
     </template>
     <template class="explicit" id="WjzMcZfRtncsiJEvL1/LzUes/GM=">
       <targ class="type" type="D"/>
-      <targ class="non-type" value="true"/>
+      <targ class="constant" value="true"/>
       <struct name="C" id="+AYNfv3bBiQwa6z9A60U/F7dvXE=">
         <file short-path="template-arguments.cpp" source-path="template-arguments.cpp" line="57" class="def"/>
         <doc>
@@ -144,7 +144,7 @@
     </template>
     <template class="explicit" id="WjzMcZfRtncsiJEvL1/LzUes/GM=">
       <targ class="type" type="int"/>
-      <targ class="non-type" value="true"/>
+      <targ class="constant" value="true"/>
       <struct name="C" id="w5ssdgUOfKNpDbPFUfSYesxFAc8=">
         <file short-path="template-arguments.cpp" source-path="template-arguments.cpp" line="45" class="def"/>
         <doc>
diff --git a/test-files/golden-tests/symbols/function/explicit-conv-operator.xml b/test-files/golden-tests/symbols/function/explicit-conv-operator.xml
index c4b72a0be..1cd913d19 100644
--- a/test-files/golden-tests/symbols/function/explicit-conv-operator.xml
+++ b/test-files/golden-tests/symbols/function/explicit-conv-operator.xml
@@ -22,7 +22,7 @@
     </function>
   </struct>
   <template>
-    <tparam name="B" class="non-type" type="bool"/>
+    <tparam name="B" class="constant" type="bool"/>
     <struct name="ExplicitExpression" id="ztb0u1Q4SVBUQ0roTOM7MFlUt/o=">
       <file short-path="explicit-conv-operator.cpp" source-path="explicit-conv-operator.cpp" line="15" class="def"/>
       <function class="conversion" name="operator bool" explicit-spec="explicit(B)" id="q6N8XkMK9WWWGKNQnlx/o2E1EYc=">
diff --git a/test-files/golden-tests/symbols/function/explicit-ctor.xml b/test-files/golden-tests/symbols/function/explicit-ctor.xml
index 91753effa..4f652b3cf 100644
--- a/test-files/golden-tests/symbols/function/explicit-ctor.xml
+++ b/test-files/golden-tests/symbols/function/explicit-ctor.xml
@@ -60,7 +60,7 @@
     </function>
   </struct>
   <template>
-    <tparam name="B" class="non-type" type="bool"/>
+    <tparam name="B" class="constant" type="bool"/>
     <struct name="ExplicitExpression" id="ztb0u1Q4SVBUQ0roTOM7MFlUt/o=">
       <file short-path="explicit-ctor.cpp" source-path="explicit-ctor.cpp" line="24" class="def"/>
       <function class="constructor" name="ExplicitExpression" explicit-spec="explicit(B)" id="s6L5UKI8FLTRiyny1rXgYxG/f/0=">
diff --git a/test-files/golden-tests/symbols/function/function-template.xml b/test-files/golden-tests/symbols/function/function-template.xml
index dc3e85524..a0ff0fc7c 100644
--- a/test-files/golden-tests/symbols/function/function-template.xml
+++ b/test-files/golden-tests/symbols/function/function-template.xml
@@ -34,7 +34,7 @@
     </function>
   </template>
   <template>
-    <tparam name="I" class="non-type" type="int"/>
+    <tparam name="I" class="constant" type="int"/>
     <function name="g0" id="10VGELAizJ5U/4YaDXaQcV9P5IU=">
       <file short-path="function-template.cpp" source-path="function-template.cpp" line="13" class="def"/>
       <param name="x">
@@ -43,14 +43,14 @@
     </function>
   </template>
   <template>
-    <tparam name="I" class="non-type" type="int" default="1"/>
+    <tparam name="I" class="constant" type="int" default="1"/>
     <function name="g1" id="n4j0p3bBh0UwMIpqw35BJHCUmkA=">
       <file short-path="function-template.cpp" source-path="function-template.cpp" line="16" class="def"/>
     </function>
   </template>
   <template>
-    <tparam name="J" class="non-type" type="int"/>
-    <tparam name="I" class="non-type" type="int" default="1"/>
+    <tparam name="J" class="constant" type="int"/>
+    <tparam name="I" class="constant" type="int" default="1"/>
     <function name="g2" id="CR+oGVkvlYeRXx423BdbUdiyfGI=">
       <file short-path="function-template.cpp" source-path="function-template.cpp" line="19" class="def"/>
     </function>
@@ -72,7 +72,7 @@
   </function>
   <template>
     <tparam name="T" class="type" default="int"/>
-    <tparam name="I" class="non-type" type="int" default="1"/>
+    <tparam name="I" class="constant" type="int" default="1"/>
     <function name="i" id="OAMHb1yDlqAsy2FOrHhyB2Rftts=">
       <file short-path="function-template.cpp" source-path="function-template.cpp" line="26" class="def"/>
     </function>
diff --git a/test-files/golden-tests/symbols/function/function-tparm-decay.xml b/test-files/golden-tests/symbols/function/function-tparm-decay.xml
index 2d5bf6103..39752ba9a 100644
--- a/test-files/golden-tests/symbols/function/function-tparm-decay.xml
+++ b/test-files/golden-tests/symbols/function/function-tparm-decay.xml
@@ -11,7 +11,7 @@
     <type name="int" cv-qualifiers="const"/>
   </namespace-alias>
   <template>
-    <tparam name="x" class="non-type" type="int"/>
+    <tparam name="x" class="constant" type="int"/>
     <function name="f" id="eqMdBnxdb22zO3kokXFKlz9ktqg=">
       <file short-path="function-tparm-decay.cpp" source-path="function-tparm-decay.cpp" line="3"/>
       <file short-path="function-tparm-decay.cpp" source-path="function-tparm-decay.cpp" line="5"/>
@@ -20,7 +20,7 @@
     </function>
   </template>
   <template>
-    <tparam name="x" class="non-type" type="int[4]"/>
+    <tparam name="x" class="constant" type="int[4]"/>
     <function name="g" id="WsEgNgLbqe3a0eM5Bqsuf58XoH0=">
       <file short-path="function-tparm-decay.cpp" source-path="function-tparm-decay.cpp" line="12"/>
       <file short-path="function-tparm-decay.cpp" source-path="function-tparm-decay.cpp" line="14"/>
@@ -29,7 +29,7 @@
     </function>
   </template>
   <template>
-    <tparam name="x" class="non-type" type="int(*)(const bool)"/>
+    <tparam name="x" class="constant" type="int(*)(const bool)"/>
     <function name="h" id="TjNHTu8/auH8QPVcgjW7FUo2dFM=">
       <file short-path="function-tparm-decay.cpp" source-path="function-tparm-decay.cpp" line="21"/>
       <file short-path="function-tparm-decay.cpp" source-path="function-tparm-decay.cpp" line="23"/>
@@ -38,7 +38,7 @@
     </function>
   </template>
   <template>
-    <tparam class="non-type" type="int"/>
+    <tparam class="constant" type="int"/>
     <function name="i" id="2woLp3PdyOT/I0DFMkY8OAli5YM=">
       <file short-path="function-tparm-decay.cpp" source-path="function-tparm-decay.cpp" line="33"/>
       <file short-path="function-tparm-decay.cpp" source-path="function-tparm-decay.cpp" line="35"/>
diff --git a/test-files/golden-tests/symbols/guide/explicit-deduct-guide.xml b/test-files/golden-tests/symbols/guide/explicit-deduct-guide.xml
index f3a3649a3..1318d4aab 100644
--- a/test-files/golden-tests/symbols/guide/explicit-deduct-guide.xml
+++ b/test-files/golden-tests/symbols/guide/explicit-deduct-guide.xml
@@ -3,7 +3,7 @@
        xsi:noNamespaceSchemaLocation="https://github.com/cppalliance/mrdocs/raw/develop/mrdocs.rnc">
 <namespace id="//////////////////////////8=">
   <template>
-    <tparam class="non-type" type="int"/>
+    <tparam class="constant" type="int"/>
     <struct name="X" id="7wllQWhGGsbbeoZVa3gh4d7bcq8=">
       <file short-path="explicit-deduct-guide.cpp" source-path="explicit-deduct-guide.cpp" line="3" class="def"/>
     </struct>
@@ -36,7 +36,7 @@
     </param>
   </guide>
   <template>
-    <tparam name="B" class="non-type" type="bool" default="true"/>
+    <tparam name="B" class="constant" type="bool" default="true"/>
     <guide name="X" explicit-spec="explicit(B)" id="YS/v8XQ/9ShQ2spNAh5EY33PN7s=">
       <file short-path="explicit-deduct-guide.cpp" source-path="explicit-deduct-guide.cpp" line="12"/>
       <deduced>
diff --git a/test-files/golden-tests/symbols/record/class-template-specializations-1.xml b/test-files/golden-tests/symbols/record/class-template-specializations-1.xml
index 19e1aa598..8d3ba58da 100644
--- a/test-files/golden-tests/symbols/record/class-template-specializations-1.xml
+++ b/test-files/golden-tests/symbols/record/class-template-specializations-1.xml
@@ -10,7 +10,7 @@
     <struct name="S1" id="2CQyWIWOAM25oQ1AdJcdT6hFqAE=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S2" id="oNfOAnUjZE7WlBGdMiNtQ9ePi8g=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10" class="def"/>
@@ -21,7 +21,7 @@
             </function>
           </struct>
           <template>
-            <tparam name="K" class="non-type" type="int"/>
+            <tparam name="K" class="constant" type="int"/>
             <tparam name="V" class="type" default="void"/>
             <struct name="S4" id="8UtqZHVItGCqKLwlXny0WJDLkDQ=">
               <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="20" class="def"/>
@@ -40,14 +40,14 @@
       </function>
     </struct>
     <template>
-      <tparam name="J" class="non-type" type="int"/>
+      <tparam name="J" class="constant" type="int"/>
       <tparam name="U" class="type" default="void"/>
       <struct name="S5" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28" class="def"/>
         <struct name="S6" id="icRp7NeoOT+m93ddn+fcm7v0hWU=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
           <template>
-            <tparam name="K" class="non-type" type="int"/>
+            <tparam name="K" class="constant" type="int"/>
             <tparam name="V" class="type" default="void"/>
             <struct name="S7" id="3ZrGNdgVY0Bl8pl2wuSUdgLSht4=">
               <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37" class="def"/>
@@ -58,7 +58,7 @@
                 </function>
               </struct>
               <template>
-                <tparam name="L" class="non-type" type="int"/>
+                <tparam name="L" class="constant" type="int"/>
                 <tparam name="W" class="type" default="void"/>
                 <struct name="S9" id="T91uOH7uarKVQhSHZ7iIV+AOuBQ=">
                   <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="47" class="def"/>
@@ -159,7 +159,7 @@
     <struct name="S1" id="2CQyWIWOAM25oQ1AdJcdT6hFqAE=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S2" id="oNfOAnUjZE7WlBGdMiNtQ9ePi8g=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10" class="def"/>
@@ -170,7 +170,7 @@
             </function>
           </struct>
           <template>
-            <tparam name="K" class="non-type" type="int"/>
+            <tparam name="K" class="constant" type="int"/>
             <tparam name="V" class="type" default="void"/>
             <struct name="S4" id="8UtqZHVItGCqKLwlXny0WJDLkDQ=">
               <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="20" class="def"/>
@@ -189,14 +189,14 @@
       </function>
     </struct>
     <template>
-      <tparam name="J" class="non-type" type="int"/>
+      <tparam name="J" class="constant" type="int"/>
       <tparam name="U" class="type" default="void"/>
       <struct name="S5" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28" class="def"/>
         <struct name="S6" id="icRp7NeoOT+m93ddn+fcm7v0hWU=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
           <template>
-            <tparam name="K" class="non-type" type="int"/>
+            <tparam name="K" class="constant" type="int"/>
             <tparam name="V" class="type" default="void"/>
             <struct name="S7" id="3ZrGNdgVY0Bl8pl2wuSUdgLSht4=">
               <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37" class="def"/>
@@ -207,7 +207,7 @@
                 </function>
               </struct>
               <template>
-                <tparam name="L" class="non-type" type="int"/>
+                <tparam name="L" class="constant" type="int"/>
                 <tparam name="W" class="type" default="void"/>
                 <struct name="S9" id="T91uOH7uarKVQhSHZ7iIV+AOuBQ=">
                   <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="47" class="def"/>
@@ -290,7 +290,7 @@
     <struct name="S1" id="2CQyWIWOAM25oQ1AdJcdT6hFqAE=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S2" id="oNfOAnUjZE7WlBGdMiNtQ9ePi8g=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10" class="def"/>
@@ -301,7 +301,7 @@
             </function>
           </struct>
           <template>
-            <tparam name="K" class="non-type" type="int"/>
+            <tparam name="K" class="constant" type="int"/>
             <tparam name="V" class="type" default="void"/>
             <struct name="S4" id="8UtqZHVItGCqKLwlXny0WJDLkDQ=">
               <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="20" class="def"/>
@@ -320,14 +320,14 @@
       </function>
     </struct>
     <template>
-      <tparam name="J" class="non-type" type="int"/>
+      <tparam name="J" class="constant" type="int"/>
       <tparam name="U" class="type" default="void"/>
       <struct name="S5" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28" class="def"/>
         <struct name="S6" id="icRp7NeoOT+m93ddn+fcm7v0hWU=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
           <template>
-            <tparam name="K" class="non-type" type="int"/>
+            <tparam name="K" class="constant" type="int"/>
             <tparam name="V" class="type" default="void"/>
             <struct name="S7" id="3ZrGNdgVY0Bl8pl2wuSUdgLSht4=">
               <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37" class="def"/>
@@ -338,7 +338,7 @@
                 </function>
               </struct>
               <template>
-                <tparam name="L" class="non-type" type="int"/>
+                <tparam name="L" class="constant" type="int"/>
                 <tparam name="W" class="type" default="void"/>
                 <struct name="S9" id="T91uOH7uarKVQhSHZ7iIV+AOuBQ=">
                   <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="47" class="def"/>
@@ -373,7 +373,7 @@
     <struct name="S1" id="2CQyWIWOAM25oQ1AdJcdT6hFqAE=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S2" id="oNfOAnUjZE7WlBGdMiNtQ9ePi8g=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10" class="def"/>
@@ -384,7 +384,7 @@
             </function>
           </struct>
           <template>
-            <tparam name="K" class="non-type" type="int"/>
+            <tparam name="K" class="constant" type="int"/>
             <tparam name="V" class="type" default="void"/>
             <struct name="S4" id="8UtqZHVItGCqKLwlXny0WJDLkDQ=">
               <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="20" class="def"/>
@@ -403,14 +403,14 @@
       </function>
     </struct>
     <template>
-      <tparam name="J" class="non-type" type="int"/>
+      <tparam name="J" class="constant" type="int"/>
       <tparam name="U" class="type" default="void"/>
       <struct name="S5" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28" class="def"/>
         <struct name="S6" id="icRp7NeoOT+m93ddn+fcm7v0hWU=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
           <template>
-            <tparam name="K" class="non-type" type="int"/>
+            <tparam name="K" class="constant" type="int"/>
             <tparam name="V" class="type" default="void"/>
             <struct name="S7" id="3ZrGNdgVY0Bl8pl2wuSUdgLSht4=">
               <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37" class="def"/>
@@ -421,7 +421,7 @@
                 </function>
               </struct>
               <template>
-                <tparam name="L" class="non-type" type="int"/>
+                <tparam name="L" class="constant" type="int"/>
                 <tparam name="W" class="type" default="void"/>
                 <struct name="S9" id="T91uOH7uarKVQhSHZ7iIV+AOuBQ=">
                   <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="47" class="def"/>
@@ -460,7 +460,7 @@
       <type id="yiTNiZbPnfj9SDdT8k1YKmjW68g=" name="S0&lt;2, bool&gt;::S1"/>
     </base>
     <template>
-      <tparam name="J" class="non-type" type="int"/>
+      <tparam name="J" class="constant" type="int"/>
       <tparam name="U" class="type" default="void"/>
       <struct name="S2" id="boLQk9sIyBQTBaPhSeSLjkGr51k=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10"/>
@@ -471,7 +471,7 @@
     </function>
   </struct>
   <template>
-    <tparam name="I" class="non-type" type="int"/>
+    <tparam name="I" class="constant" type="int"/>
     <tparam name="T" class="type"/>
     <struct name="R31" id="a6PZj6tjiEyiL0giu8norS/dpQ0=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="240" class="def"/>
@@ -502,7 +502,7 @@
     </function>
   </struct>
   <template>
-    <tparam name="I" class="non-type" type="int"/>
+    <tparam name="I" class="constant" type="int"/>
     <tparam name="T" class="type"/>
     <struct name="R35" id="eo8jQEg9QMloSGi6GpyAeQqlpCs=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="249" class="def"/>
@@ -524,7 +524,7 @@
     </base>
   </struct>
   <template>
-    <tparam name="I" class="non-type" type="int"/>
+    <tparam name="I" class="constant" type="int"/>
     <tparam name="T" class="type"/>
     <struct name="R38" id="re0mCvmdqf1rR547opGwiFX8hlA=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="256" class="def"/>
@@ -557,7 +557,7 @@
       <type id="ESA+jWIqD6n9bgbcE+2k+r76ElE=" name="S0&lt;23, bool&gt;::S5&lt;24, bool&gt;::S6"/>
     </base>
     <template>
-      <tparam name="K" class="non-type" type="int"/>
+      <tparam name="K" class="constant" type="int"/>
       <tparam name="V" class="type" default="void"/>
       <struct name="S7" id="Qi1L025HS2xzUSVM/EdHO3S86T8=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37"/>
@@ -568,7 +568,7 @@
     </function>
   </struct>
   <template>
-    <tparam name="I" class="non-type" type="int"/>
+    <tparam name="I" class="constant" type="int"/>
     <tparam name="T" class="type"/>
     <struct name="R42" id="Lw0S5zz85DmfSfnw5wqcfXhtZC4=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="265" class="def"/>
@@ -599,7 +599,7 @@
     </function>
   </struct>
   <template>
-    <tparam name="I" class="non-type" type="int"/>
+    <tparam name="I" class="constant" type="int"/>
     <tparam name="T" class="type"/>
     <struct name="R46" id="zpWPNwEVFZZIH8TbPFJ12fiTZ9Y=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="274" class="def"/>
@@ -651,14 +651,14 @@
     </base>
   </struct>
   <template>
-    <tparam name="I" class="non-type" type="int"/>
+    <tparam name="I" class="constant" type="int"/>
     <tparam name="T" class="type" default="void"/>
     <struct name="S0" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="1" class="def"/>
       <struct name="S1" id="2CQyWIWOAM25oQ1AdJcdT6hFqAE=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
         <template>
-          <tparam name="J" class="non-type" type="int"/>
+          <tparam name="J" class="constant" type="int"/>
           <tparam name="U" class="type" default="void"/>
           <struct name="S2" id="oNfOAnUjZE7WlBGdMiNtQ9ePi8g=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10" class="def"/>
@@ -669,7 +669,7 @@
               </function>
             </struct>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S4" id="8UtqZHVItGCqKLwlXny0WJDLkDQ=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="20" class="def"/>
@@ -688,14 +688,14 @@
         </function>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28" class="def"/>
           <struct name="S6" id="icRp7NeoOT+m93ddn+fcm7v0hWU=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S7" id="3ZrGNdgVY0Bl8pl2wuSUdgLSht4=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37" class="def"/>
@@ -706,7 +706,7 @@
                   </function>
                 </struct>
                 <template>
-                  <tparam name="L" class="non-type" type="int"/>
+                  <tparam name="L" class="constant" type="int"/>
                   <tparam name="W" class="type" default="void"/>
                   <struct name="S9" id="T91uOH7uarKVQhSHZ7iIV+AOuBQ=">
                     <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="47" class="def"/>
@@ -735,33 +735,33 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="0"/>
+    <targ class="constant" value="0"/>
     <struct name="S0" id="vt6SAnqggizkWUqtSC5b9rVm+Qw=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="58" class="def"/>
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="10"/>
+    <targ class="constant" value="10"/>
     <struct name="S0" id="hwWIBHTi29w+6bJar0PyQvwnZWw=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="H+OiQqpA/bs1dZi3ZS1WWNa5qBA=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
         <template>
-          <tparam name="J" class="non-type" type="int"/>
+          <tparam name="J" class="constant" type="int"/>
           <tparam name="U" class="type" default="void"/>
           <struct name="S2" id="s/+gz4h48mKOopEb9TmxFUzl6o8=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10"/>
           </struct>
         </template>
         <template class="explicit" id="oNfOAnUjZE7WlBGdMiNtQ9ePi8g=">
-          <targ class="non-type" value="11"/>
+          <targ class="constant" value="11"/>
           <struct name="S2" id="g2iVCce1Dp6iPMyevfuMN/UU9F0=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="11" class="def"/>
             <struct name="S3" id="NW6Rl/c5GWs2dbFctQ6kW8Kbyh4=">
               <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="15"/>
             </struct>
             <template>
-              <tparam name="I" class="non-type" type="int"/>
+              <tparam name="I" class="constant" type="int"/>
               <tparam name="T" class="type" default="void"/>
               <struct name="S4" id="jsWbJZfAfgKMXbl9GaZXHLmhL2U=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="91" class="def"/>
@@ -778,7 +778,7 @@
         </function>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="Ba443e4B7ySMlh7XYx/5pmJ4VD8=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
@@ -790,34 +790,34 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="12"/>
+    <targ class="constant" value="12"/>
     <struct name="S0" id="7v/tytUkZe7COeYW1bbrzC9LRio=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="Pjf6KqCPylu2b46BR/wONC7VjWU=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
         <template>
-          <tparam name="J" class="non-type" type="int"/>
+          <tparam name="J" class="constant" type="int"/>
           <tparam name="U" class="type" default="void"/>
           <struct name="S2" id="l5pN6etoKup4CUg+bcu1xKLH0TQ=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10"/>
           </struct>
         </template>
         <template class="explicit" id="oNfOAnUjZE7WlBGdMiNtQ9ePi8g=">
-          <targ class="non-type" value="13"/>
+          <targ class="constant" value="13"/>
           <struct name="S2" id="Lu2i8tgrw9I5p6DXmX9LfM8mVSo=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="11" class="def"/>
             <struct name="S3" id="5Sz5l6GKNl23KxxZFfhqy7YgES0=">
               <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="15"/>
             </struct>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S4" id="Aj9j+drHHvowKlbxWQ6lW8Fl0rA=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="20"/>
               </struct>
             </template>
             <template class="explicit" id="8UtqZHVItGCqKLwlXny0WJDLkDQ=">
-              <targ class="non-type" value="14"/>
+              <targ class="constant" value="14"/>
               <struct name="S4" id="yPCRvP9B34hMThomBKlaCzkFM54=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="97" class="def"/>
               </struct>
@@ -832,7 +832,7 @@
         </function>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="OipUIhe/9mIgCedaT6w3xdMAnb0=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
@@ -844,34 +844,34 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="15"/>
+    <targ class="constant" value="15"/>
     <struct name="S0" id="nkoZM9sg9xpibNb1eDSyhqn/Ato=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="6gImp3XchQxxpQbqRhUq0szIb+A=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
         <template>
-          <tparam name="J" class="non-type" type="int"/>
+          <tparam name="J" class="constant" type="int"/>
           <tparam name="U" class="type" default="void"/>
           <struct name="S2" id="f89EHPCeOKy7zB9suvC7AVQwNHk=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10"/>
           </struct>
         </template>
         <template class="explicit" id="oNfOAnUjZE7WlBGdMiNtQ9ePi8g=">
-          <targ class="non-type" value="16"/>
+          <targ class="constant" value="16"/>
           <struct name="S2" id="JnRKKJOV9sM2/Wi7ytI5OenLTcs=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="11" class="def"/>
             <struct name="S3" id="RK410huBsKvtBfnloh7nxNTsrmA=">
               <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="15"/>
             </struct>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S4" id="DWQYigctrt98IiK0iwD/f5A92cI=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="20"/>
               </struct>
             </template>
             <template class="explicit" id="8UtqZHVItGCqKLwlXny0WJDLkDQ=">
-              <targ class="non-type" value="17"/>
+              <targ class="constant" value="17"/>
               <targ class="type" type="int*"/>
               <struct name="S4" id="J3UZDljdSJ1mGU9Js0JpA3TjVtc=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="107" class="def"/>
@@ -879,7 +879,7 @@
             </template>
             <template class="partial" id="8UtqZHVItGCqKLwlXny0WJDLkDQ=">
               <tparam name="T" class="type"/>
-              <targ class="non-type" value="17"/>
+              <targ class="constant" value="17"/>
               <targ class="type" type="T*"/>
               <struct name="S4" id="cV4O7e/J4xug1ZmsOQKwDVjE99M=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="102" class="def"/>
@@ -895,7 +895,7 @@
         </function>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="fUPoYhU5UIcUerJv8OMQMiEWtfU=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
@@ -907,14 +907,14 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="18"/>
+    <targ class="constant" value="18"/>
     <struct name="S0" id="eiJusMAs3cvoF4DWqUBlAfXzYcA=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="o00NNFGC28+7Dvmb3/cTyVzCRvQ=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="I" class="non-type" type="int"/>
+        <tparam name="I" class="constant" type="int"/>
         <tparam name="T" class="type" default="void"/>
         <struct name="S5" id="camC/bDL1+gedizXtv+BQXm3/4s=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="110" class="def"/>
@@ -927,21 +927,21 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="19"/>
+    <targ class="constant" value="19"/>
     <struct name="S0" id="pxo3Lx5X+FdLdaGOmXmAiuNVQME=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="XKSdNXUZ0e+FReoXOI4yAC6LBDQ=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="MoHYU9ImAUNH5QobwugA5LN9DBQ=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
         </struct>
       </template>
       <template class="explicit" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
-        <targ class="non-type" value="20"/>
+        <targ class="constant" value="20"/>
         <struct name="S5" id="dO93MwJZmA5Fpzul37ZMH6F1ong=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="115" class="def"/>
         </struct>
@@ -952,7 +952,7 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="2"/>
+    <targ class="constant" value="2"/>
     <struct name="S0" id="nJGs54s6oYf7fHzIpo0tyaCSH9M=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="yY+X2/Fqu8ENz37/HFEJCBOSfVg=">
@@ -960,7 +960,7 @@
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="5pMsyGC09WFCpWuQKcGtioRlb5Y=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
@@ -972,21 +972,21 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="21"/>
+    <targ class="constant" value="21"/>
     <struct name="S0" id="MUilGFE5YvyMgRjHIcQZ38yyl2c=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="acxje4ZpfatuwoQZl1hZ9D/KHM4=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="fJLNRIc/VqJctXPlhGCD5XwmXKg=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
         </struct>
       </template>
       <template class="explicit" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
-        <targ class="non-type" value="22"/>
+        <targ class="constant" value="22"/>
         <targ class="type" type="int*"/>
         <struct name="S5" id="NnzxSBCBz0/s6OkCTTL/yDO06Go=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="123" class="def"/>
@@ -994,7 +994,7 @@
       </template>
       <template class="partial" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
         <tparam name="T" class="type"/>
-        <targ class="non-type" value="22"/>
+        <targ class="constant" value="22"/>
         <targ class="type" type="T*"/>
         <struct name="S5" id="umZ8gPZZ+qTWuYY3zYO/hx1XCGI=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="119" class="def"/>
@@ -1006,21 +1006,21 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="23"/>
+    <targ class="constant" value="23"/>
     <struct name="S0" id="WK6dfZ+3VdrJbp4Egq7SCGyoAF8=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="yAgJODUxUtNlmUvwjJFy8uTsQME=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="svdEQOjjswR4ileGG8pU+ldVtFk=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
         </struct>
       </template>
       <template class="explicit" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
-        <targ class="non-type" value="24"/>
+        <targ class="constant" value="24"/>
         <struct name="S5" id="lmGGu3RmJh5DZfXs5nd811FPf14=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="29" class="def"/>
           <struct name="S6" id="w4IHOtNv5zozrqG240cCIM/ceiU=">
@@ -1038,27 +1038,27 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="25"/>
+    <targ class="constant" value="25"/>
     <struct name="S0" id="oj8XjM2vuWbeoc2sBpfsIoleCao=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="CToVG+Nxp/obngx4xEPXSkKc6ec=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="ROVvQTAm3IUCI9Z+u5p6znhCXIM=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
         </struct>
       </template>
       <template class="explicit" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
-        <targ class="non-type" value="26"/>
+        <targ class="constant" value="26"/>
         <struct name="S5" id="I29LgIfKHs2KVKydoPZ2XncISyM=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="29" class="def"/>
           <struct name="S6" id="JQyJB8YSN2kw6hjQe1bBwKlHuJ4=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
             <template>
-              <tparam name="I" class="non-type" type="int"/>
+              <tparam name="I" class="constant" type="int"/>
               <tparam name="T" class="type" default="void"/>
               <struct name="S7" id="ExhHzwlrMNSfv2bLNPrl3Ts+Nvk=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="131" class="def"/>
@@ -1080,34 +1080,34 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="27"/>
+    <targ class="constant" value="27"/>
     <struct name="S0" id="niyoFejCRrpY1Aa9GHwGMnaDfsQ=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="m95euF404cXorkuumA4YL7rf/M4=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="t1Qlkn8HaE31JtoPhBd1DqNaK54=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
         </struct>
       </template>
       <template class="explicit" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
-        <targ class="non-type" value="28"/>
+        <targ class="constant" value="28"/>
         <struct name="S5" id="wpJv75dxyLgHOdHJsb50f1IIDVc=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="29" class="def"/>
           <struct name="S6" id="eSNDaVdF6Ls1X50hIBbC2/ZrfXc=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S7" id="vfK1DPDpK0avS7QO2IsoINEq6hw=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37"/>
               </struct>
             </template>
             <template class="explicit" id="3ZrGNdgVY0Bl8pl2wuSUdgLSht4=">
-              <targ class="non-type" value="29"/>
+              <targ class="constant" value="29"/>
               <targ class="type" type="int*"/>
               <struct name="S7" id="3eTbiMMR3GPY7/xRty3EmJ9bdQU=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="142" class="def"/>
@@ -1115,7 +1115,7 @@
             </template>
             <template class="partial" id="3ZrGNdgVY0Bl8pl2wuSUdgLSht4=">
               <tparam name="T" class="type"/>
-              <targ class="non-type" value="29"/>
+              <targ class="constant" value="29"/>
               <targ class="type" type="T*"/>
               <struct name="S7" id="pbmVOgtPeZtTL7BQG/AM7NVsNdo=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="137" class="def"/>
@@ -1136,13 +1136,13 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="3"/>
+    <targ class="constant" value="3"/>
     <struct name="S0" id="c7NNZfjOZ8Ztuw0u26xL/h7UKvA=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="mAjvoVYFGHUEtQCq4FWGGMMxH1s=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
         <template>
-          <tparam name="I" class="non-type" type="int"/>
+          <tparam name="I" class="constant" type="int"/>
           <tparam name="T" class="type" default="void"/>
           <struct name="S2" id="96AKnFS/OwIoVISFMJoJhA0YXIU=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="70" class="def"/>
@@ -1154,7 +1154,7 @@
         </function>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="ySgtQ6cLT4QxgOy9pXpcRhuRj3A=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
@@ -1166,34 +1166,34 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="30"/>
+    <targ class="constant" value="30"/>
     <struct name="S0" id="FREf1tucqdONQ71W3hB/Sf/Fbw4=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="oVLW+4nkn0j9ObUhnIa4DMKY/kE=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="fwkbAJn4bwLVQhZizPOq/sf5LQs=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
         </struct>
       </template>
       <template class="explicit" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
-        <targ class="non-type" value="31"/>
+        <targ class="constant" value="31"/>
         <struct name="S5" id="RFQpd+7V+unGQTgk13maA1YEoyY=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="29" class="def"/>
           <struct name="S6" id="oosblLoO9PeSiNyXVDJFFvMU0K4=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S7" id="w5EzxR7VXcWh8IwwCTwF2DmD6HY=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37"/>
               </struct>
             </template>
             <template class="explicit" id="3ZrGNdgVY0Bl8pl2wuSUdgLSht4=">
-              <targ class="non-type" value="32"/>
+              <targ class="constant" value="32"/>
               <struct name="S7" id="VxqDdgdkcw8E86ZiNolpXLlhyWs=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="147" class="def"/>
               </struct>
@@ -1213,34 +1213,34 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="33"/>
+    <targ class="constant" value="33"/>
     <struct name="S0" id="nuqq8wSa/4T9E2xaPl/SzBPbekM=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="LG1bMk2cI8hV4lWJVykhw6PCrNc=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="tpjDVYdBSPTndP8VDazRf6/8meo=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
         </struct>
       </template>
       <template class="explicit" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
-        <targ class="non-type" value="34"/>
+        <targ class="constant" value="34"/>
         <struct name="S5" id="IhITMrVguwgsTFnxWSalhrn5lnw=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="29" class="def"/>
           <struct name="S6" id="Fw48V8nmSkOhCwPsm1XbxRqPDn0=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S7" id="lQaOnq1H6h180eqz6xbidShIrdA=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37"/>
               </struct>
             </template>
             <template class="explicit" id="3ZrGNdgVY0Bl8pl2wuSUdgLSht4=">
-              <targ class="non-type" value="35"/>
+              <targ class="constant" value="35"/>
               <struct name="S7" id="NkmHmT5oAR5xJObAVl4zdPrTJPk=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="38" class="def"/>
                 <struct name="S8" id="3sBLDynoSyGl1xzXtqGZlO/q6dA=">
@@ -1248,7 +1248,7 @@
                   <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="42"/>
                 </struct>
                 <template>
-                  <tparam name="L" class="non-type" type="int"/>
+                  <tparam name="L" class="constant" type="int"/>
                   <tparam name="W" class="type" default="void"/>
                   <struct name="S9" id="i37LIAL4s3bszXAkCCOEqZEiWm8=">
                     <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="47"/>
@@ -1274,41 +1274,41 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="36"/>
+    <targ class="constant" value="36"/>
     <struct name="S0" id="MyTy/GXkOXKOTiJVqHAVVvaU4es=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="sfl4idQ3XqqjqsGVqx42d8FOaro=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="MTJJE+UTS9FHxIdoox7q++4JZsM=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
         </struct>
       </template>
       <template class="explicit" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
-        <targ class="non-type" value="37"/>
+        <targ class="constant" value="37"/>
         <struct name="S5" id="+J66oroZ92MSPf/1vk3672IXQRM=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="29" class="def"/>
           <struct name="S6" id="CWcmlxIs9QnjmES2Cgjlon6OI7w=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S7" id="WLA6nHwh9KxFHIJwkS99a51Xyko=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37"/>
               </struct>
             </template>
             <template class="explicit" id="3ZrGNdgVY0Bl8pl2wuSUdgLSht4=">
-              <targ class="non-type" value="38"/>
+              <targ class="constant" value="38"/>
               <struct name="S7" id="3jBuzbuFB0fvpQa1ETvIXevGH2w=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="38" class="def"/>
                 <struct name="S8" id="7Jcjk4Lbfc4kwJznX3cZjXNHpWk=">
                   <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="42"/>
                 </struct>
                 <template>
-                  <tparam name="I" class="non-type" type="int"/>
+                  <tparam name="I" class="constant" type="int"/>
                   <tparam name="T" class="type" default="void"/>
                   <struct name="S9" id="KChFuNDElPROHklvCtkJ+O4+io8=">
                     <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="157" class="def"/>
@@ -1335,48 +1335,48 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="39"/>
+    <targ class="constant" value="39"/>
     <struct name="S0" id="a69mw641E3cHVf6ovpLtJxTpmps=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="jhii04LwtzP2xeX9VvJ1vkHi96E=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="MbQ51g7F4DNybKeSijW6A6+Py8E=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
         </struct>
       </template>
       <template class="explicit" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
-        <targ class="non-type" value="40"/>
+        <targ class="constant" value="40"/>
         <struct name="S5" id="fpqbvQR9NuaJY4fq9LHbiAsZKzw=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="29" class="def"/>
           <struct name="S6" id="zcC98n6b6xzVSJI0qlmjgV7wC4o=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S7" id="i5c0yET+iPN3LFNMF/gwxTd2pSk=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37"/>
               </struct>
             </template>
             <template class="explicit" id="3ZrGNdgVY0Bl8pl2wuSUdgLSht4=">
-              <targ class="non-type" value="41"/>
+              <targ class="constant" value="41"/>
               <struct name="S7" id="r7aMtw1PqhcjWuGFP7pwiW2v0ks=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="38" class="def"/>
                 <struct name="S8" id="CS/7AtaJ5KeKtA/s2xnAgctdhCE=">
                   <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="42"/>
                 </struct>
                 <template>
-                  <tparam name="L" class="non-type" type="int"/>
+                  <tparam name="L" class="constant" type="int"/>
                   <tparam name="W" class="type" default="void"/>
                   <struct name="S9" id="XZQjC+vy5ZHIMKQ5ib7EqS1pU24=">
                     <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="47"/>
                   </struct>
                 </template>
                 <template class="explicit" id="T91uOH7uarKVQhSHZ7iIV+AOuBQ=">
-                  <targ class="non-type" value="42"/>
+                  <targ class="constant" value="42"/>
                   <targ class="type" type="int*"/>
                   <struct name="S9" id="hwfbdkFRNunC/3V+s6HA5BwWiSQ=">
                     <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="170" class="def"/>
@@ -1384,7 +1384,7 @@
                 </template>
                 <template class="partial" id="T91uOH7uarKVQhSHZ7iIV+AOuBQ=">
                   <tparam name="T" class="type"/>
-                  <targ class="non-type" value="42"/>
+                  <targ class="constant" value="42"/>
                   <targ class="type" type="T*"/>
                   <struct name="S9" id="CvFJnK9Xu7B2Fbh91NqM0+gKVEU=">
                     <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="164" class="def"/>
@@ -1410,20 +1410,20 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="4"/>
+    <targ class="constant" value="4"/>
     <struct name="S0" id="oXfsqUlMzPbEZZJ7K+iZYQj3wko=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="709lyZwEiIBHmnH6StkYFJ+CdtU=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
         <template>
-          <tparam name="J" class="non-type" type="int"/>
+          <tparam name="J" class="constant" type="int"/>
           <tparam name="U" class="type" default="void"/>
           <struct name="S2" id="Cc0mRYlhWpgycSGkK7WePuPT7hE=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10"/>
           </struct>
         </template>
         <template class="explicit" id="oNfOAnUjZE7WlBGdMiNtQ9ePi8g=">
-          <targ class="non-type" value="5"/>
+          <targ class="constant" value="5"/>
           <struct name="S2" id="8snJ9gp5ca88/AsWGEnFe6Ln6RQ=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="75" class="def"/>
           </struct>
@@ -1433,7 +1433,7 @@
         </function>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="Qiu5RA/uiY+Qq/uITWh8gZDl09s=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
@@ -1445,48 +1445,48 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="43"/>
+    <targ class="constant" value="43"/>
     <struct name="S0" id="uoCdOuqB1v1s6rvl4wDWcLrD4LA=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="lTVuthrZypwbNFQmSwD5A+GPxkk=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="/7HGQwWirqFWT+sfif66EM4XDWY=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
         </struct>
       </template>
       <template class="explicit" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
-        <targ class="non-type" value="44"/>
+        <targ class="constant" value="44"/>
         <struct name="S5" id="j53XjxydcG+wI0iK3mM8/acK5rY=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="29" class="def"/>
           <struct name="S6" id="c68+fcTp+SPAEXyf+mHRUULqSwU=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S7" id="SkuJEV5Urlw9+2JP4u2d89sySxc=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37"/>
               </struct>
             </template>
             <template class="explicit" id="3ZrGNdgVY0Bl8pl2wuSUdgLSht4=">
-              <targ class="non-type" value="45"/>
+              <targ class="constant" value="45"/>
               <struct name="S7" id="J7tgsUhd+qpsq/85qkEgF1l14uk=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="38" class="def"/>
                 <struct name="S8" id="sw7s/ZGAiU2YPilewUBphRtHzJE=">
                   <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="42"/>
                 </struct>
                 <template>
-                  <tparam name="L" class="non-type" type="int"/>
+                  <tparam name="L" class="constant" type="int"/>
                   <tparam name="W" class="type" default="void"/>
                   <struct name="S9" id="vh1pnm0rrDrR7KEDjTsvkyCZpmk=">
                     <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="47"/>
                   </struct>
                 </template>
                 <template class="explicit" id="T91uOH7uarKVQhSHZ7iIV+AOuBQ=">
-                  <targ class="non-type" value="46"/>
+                  <targ class="constant" value="46"/>
                   <struct name="S9" id="8PQtbs9xGpu1L+b0VOqfLlE6TnY=">
                     <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="176" class="def"/>
                   </struct>
@@ -1511,20 +1511,20 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="6"/>
+    <targ class="constant" value="6"/>
     <struct name="S0" id="flxREiXFL5ObY0xUAxojj+jvR54=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="OHtykpXPLoa0xO0Dw3P7uAImGWI=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
         <template>
-          <tparam name="J" class="non-type" type="int"/>
+          <tparam name="J" class="constant" type="int"/>
           <tparam name="U" class="type" default="void"/>
           <struct name="S2" id="TIdvQT1/SnDhh51ggGvABG3pR/A=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10"/>
           </struct>
         </template>
         <template class="explicit" id="oNfOAnUjZE7WlBGdMiNtQ9ePi8g=">
-          <targ class="non-type" value="7"/>
+          <targ class="constant" value="7"/>
           <targ class="type" type="int*"/>
           <struct name="S2" id="eWg27/kfn86dUmPA26mcOo6kkfs=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="83" class="def"/>
@@ -1532,7 +1532,7 @@
         </template>
         <template class="partial" id="oNfOAnUjZE7WlBGdMiNtQ9ePi8g=">
           <tparam name="T" class="type"/>
-          <targ class="non-type" value="7"/>
+          <targ class="constant" value="7"/>
           <targ class="type" type="T*"/>
           <struct name="S2" id="ZyL4aBHmvCmfq+HyxDSySKwRsdA=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="79" class="def"/>
@@ -1543,7 +1543,7 @@
         </function>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="XIHF6Im4J5Yw0dYbehnXXQwDdjk=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
@@ -1555,20 +1555,20 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="8"/>
+    <targ class="constant" value="8"/>
     <struct name="S0" id="o06yQpJHyCkZyFI44/nN8/tpgT8=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="uoWeOq9HHkUSZZj7t+ilmBmv3N8=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
         <template>
-          <tparam name="J" class="non-type" type="int"/>
+          <tparam name="J" class="constant" type="int"/>
           <tparam name="U" class="type" default="void"/>
           <struct name="S2" id="vycCuI8tFTO2XzFK982RELdJtik=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10"/>
           </struct>
         </template>
         <template class="explicit" id="oNfOAnUjZE7WlBGdMiNtQ9ePi8g=">
-          <targ class="non-type" value="9"/>
+          <targ class="constant" value="9"/>
           <struct name="S2" id="zpDyI51RjdguXF8/9KXFrICQwEc=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="11" class="def"/>
             <struct name="S3" id="OuyCzwMT3B0xth9oee9dTlGkXVw=">
@@ -1576,7 +1576,7 @@
               <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="15"/>
             </struct>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S4" id="LWqz4rXaiDuM3Pahx88MykZZO9I=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="20"/>
@@ -1592,7 +1592,7 @@
         </function>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="dFsG0X1P6Tx3hNcuZ3zkjFvRAjg=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
@@ -1604,28 +1604,28 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="1"/>
+    <targ class="constant" value="1"/>
     <targ class="type" type="int*"/>
     <struct name="S0" id="IKgocAXkFMvNmDD+p5dZpSBSRHI=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="64" class="def"/>
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="10"/>
+    <targ class="constant" value="10"/>
     <targ class="type" type="bool"/>
     <struct name="S0" id="Wu710hbNOx84LbfjQUEgqKkZ2dA=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="gCtb2dXrFOJZr+D3olVozhWHsfk=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
         <template>
-          <tparam name="J" class="non-type" type="int"/>
+          <tparam name="J" class="constant" type="int"/>
           <tparam name="U" class="type" default="void"/>
           <struct name="S2" id="cAbW+A71ZucFEdutIxvQsMrRZfo=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10"/>
           </struct>
         </template>
         <template class="explicit" id="oNfOAnUjZE7WlBGdMiNtQ9ePi8g=">
-          <targ class="non-type" value="11"/>
+          <targ class="constant" value="11"/>
           <targ class="type" type="bool"/>
           <struct name="S2" id="tcws+2wcXL0FEmvv7ZVXvxSkAaI=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="11" class="def"/>
@@ -1633,7 +1633,7 @@
               <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="15"/>
             </struct>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S4" id="dgnsEZRrgKjkRc2mMZu4n+Thg5Q=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="20"/>
@@ -1649,7 +1649,7 @@
         </function>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="2Rq4N3puoKp2QK24IubTKoiTfq8=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
@@ -1661,21 +1661,21 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="12"/>
+    <targ class="constant" value="12"/>
     <targ class="type" type="bool"/>
     <struct name="S0" id="zYIKjNzi/kYNKvtrTXu8BhQTFt8=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="cGWeDtBrKQollzB0qm7B9OTac+M=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
         <template>
-          <tparam name="J" class="non-type" type="int"/>
+          <tparam name="J" class="constant" type="int"/>
           <tparam name="U" class="type" default="void"/>
           <struct name="S2" id="7ApgPzN0o+KiX+h1Nt7kpUam/fk=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10"/>
           </struct>
         </template>
         <template class="explicit" id="oNfOAnUjZE7WlBGdMiNtQ9ePi8g=">
-          <targ class="non-type" value="13"/>
+          <targ class="constant" value="13"/>
           <targ class="type" type="bool"/>
           <struct name="S2" id="Xes4IqvFnQoGkxPlP4C4wtbjqxQ=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="11" class="def"/>
@@ -1683,7 +1683,7 @@
               <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="15"/>
             </struct>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S4" id="CHRZtPEkA7kslbQF1GY7Gmxte3Y=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="20"/>
@@ -1699,7 +1699,7 @@
         </function>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="Nojg2jsXai1iAFP9hsJPlC9tFI8=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
@@ -1711,21 +1711,21 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="15"/>
+    <targ class="constant" value="15"/>
     <targ class="type" type="bool"/>
     <struct name="S0" id="ANhUz0/2S6fRsXsZFhXPTPyPfAE=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="GznvBx9oA37GPuoz+kPaL75Zrjc=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
         <template>
-          <tparam name="J" class="non-type" type="int"/>
+          <tparam name="J" class="constant" type="int"/>
           <tparam name="U" class="type" default="void"/>
           <struct name="S2" id="gdFNVKv7I0ihKVjLeuz6GIMd5Q0=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10"/>
           </struct>
         </template>
         <template class="explicit" id="oNfOAnUjZE7WlBGdMiNtQ9ePi8g=">
-          <targ class="non-type" value="16"/>
+          <targ class="constant" value="16"/>
           <targ class="type" type="bool"/>
           <struct name="S2" id="OsUzyKi8NDCZFI1r1y4+Ki/4H0s=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="11" class="def"/>
@@ -1733,7 +1733,7 @@
               <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="15"/>
             </struct>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S4" id="sTA4/H21kP6LPe77SqrI73H6zDA=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="20"/>
@@ -1749,7 +1749,7 @@
         </function>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="GDPrCGIY2hnM7cbCaFUOmm2wshE=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
@@ -1761,7 +1761,7 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="18"/>
+    <targ class="constant" value="18"/>
     <targ class="type" type="bool"/>
     <struct name="S0" id="UUBd87/k0jse5896L03eJ4N0l+c=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
@@ -1769,7 +1769,7 @@
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="+mrn5TAPBw5Ly6qXobQ1L41PIgQ=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
@@ -1781,7 +1781,7 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="19"/>
+    <targ class="constant" value="19"/>
     <targ class="type" type="bool"/>
     <struct name="S0" id="AhWlDEmWhkTeQuWWCaZwMGCG5HQ=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
@@ -1789,7 +1789,7 @@
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="jsvmsDChIjbJL9NiOfViZSJnAjY=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
@@ -1801,14 +1801,14 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="2"/>
+    <targ class="constant" value="2"/>
     <targ class="type" type="bool"/>
     <struct name="S0" id="PA+4gdvi0ChhszyGuOL6zlYXHpk=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="yiTNiZbPnfj9SDdT8k1YKmjW68g=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
         <template>
-          <tparam name="J" class="non-type" type="int"/>
+          <tparam name="J" class="constant" type="int"/>
           <tparam name="U" class="type" default="void"/>
           <struct name="S2" id="boLQk9sIyBQTBaPhSeSLjkGr51k=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10"/>
@@ -1819,7 +1819,7 @@
         </function>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="gL1/NnHh2HYS9OB5keD9fU12dSo=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
@@ -1831,7 +1831,7 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="21"/>
+    <targ class="constant" value="21"/>
     <targ class="type" type="bool"/>
     <struct name="S0" id="A9DWlv0rbuFs3A9eHqZTaJDN7Uk=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
@@ -1839,7 +1839,7 @@
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="yoz58B5jOuyETge5TB/Gq0sww/s=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
@@ -1851,7 +1851,7 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="23"/>
+    <targ class="constant" value="23"/>
     <targ class="type" type="bool"/>
     <struct name="S0" id="x7MfNbWaSdnUCRBlHt+nSvOlEPw=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
@@ -1859,21 +1859,21 @@
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="NCeRVwwum78r2U1ltYyxR8L2w1E=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
         </struct>
       </template>
       <template class="explicit" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
-        <targ class="non-type" value="24"/>
+        <targ class="constant" value="24"/>
         <targ class="type" type="bool"/>
         <struct name="S5" id="+YuAVlOefcnfZIU1wckNM7lfNaA=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="29" class="def"/>
           <struct name="S6" id="ESA+jWIqD6n9bgbcE+2k+r76ElE=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S7" id="Qi1L025HS2xzUSVM/EdHO3S86T8=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37"/>
@@ -1894,7 +1894,7 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="25"/>
+    <targ class="constant" value="25"/>
     <targ class="type" type="bool"/>
     <struct name="S0" id="Up/SfnuYTQw+Y6klSO3f5z86DOY=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
@@ -1902,21 +1902,21 @@
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="UQEIeTWOsCvViISUDQjHQsKXKEE=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
         </struct>
       </template>
       <template class="explicit" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
-        <targ class="non-type" value="26"/>
+        <targ class="constant" value="26"/>
         <targ class="type" type="bool"/>
         <struct name="S5" id="XLAZYk894KbFFFIzJpR6c2Fi870=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="29" class="def"/>
           <struct name="S6" id="ej1LvbYphHq2t9yaXo4D3iiKKN8=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S7" id="x+oMV86+KxeHkrtmDX4jZW+PwTk=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37"/>
@@ -1937,7 +1937,7 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="27"/>
+    <targ class="constant" value="27"/>
     <targ class="type" type="bool"/>
     <struct name="S0" id="ByHV/GlyHOt9h6ZVKpsDi/DkBkM=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
@@ -1945,21 +1945,21 @@
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="93+VLxr4uaKDABFrJr8DqishCnQ=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
         </struct>
       </template>
       <template class="explicit" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
-        <targ class="non-type" value="28"/>
+        <targ class="constant" value="28"/>
         <targ class="type" type="bool"/>
         <struct name="S5" id="1ro4Sv8wGUNxysGIgXgcl9hcP68=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="29" class="def"/>
           <struct name="S6" id="/Iw6bfcamLwq/8bygja2aJQXqVE=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S7" id="0eW+7m0STZ21+XZ3v4lkSVybZJ0=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37"/>
@@ -1980,14 +1980,14 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="3"/>
+    <targ class="constant" value="3"/>
     <targ class="type" type="bool"/>
     <struct name="S0" id="kn1OyT1FzAvXXJMp4nKleaEX+5c=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="jUAs995uvzET3EsGSOVUwR/Ptzc=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
         <template>
-          <tparam name="J" class="non-type" type="int"/>
+          <tparam name="J" class="constant" type="int"/>
           <tparam name="U" class="type" default="void"/>
           <struct name="S2" id="3Hz31SDA9BZgZc5teheYelVphp0=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10"/>
@@ -1998,7 +1998,7 @@
         </function>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="r2RB8PwDCI61PfLPFsx2brM49Ac=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
@@ -2010,7 +2010,7 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="30"/>
+    <targ class="constant" value="30"/>
     <targ class="type" type="bool"/>
     <struct name="S0" id="IbslzK4eUJj1gUsgbS4h/0Axavg=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
@@ -2018,21 +2018,21 @@
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="ZVrd+z+aj7kndV8zl/tQD4n2PpI=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
         </struct>
       </template>
       <template class="explicit" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
-        <targ class="non-type" value="31"/>
+        <targ class="constant" value="31"/>
         <targ class="type" type="bool"/>
         <struct name="S5" id="s40Z8yfzcJnCZSeYYV5sYlFzOxs=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="29" class="def"/>
           <struct name="S6" id="5i4Oz7fFAR9QRQ2ctfC9IaLMH8I=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S7" id="/GAHgBYtFNuyluNz/U8S+0bmRSQ=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37"/>
@@ -2053,7 +2053,7 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="33"/>
+    <targ class="constant" value="33"/>
     <targ class="type" type="bool"/>
     <struct name="S0" id="MYFk6ANWkex8j7vBuMpAqchgYIY=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
@@ -2061,28 +2061,28 @@
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="8vEnMjkS28lfiCf8rbBriqxcO5Y=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
         </struct>
       </template>
       <template class="explicit" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
-        <targ class="non-type" value="34"/>
+        <targ class="constant" value="34"/>
         <targ class="type" type="bool"/>
         <struct name="S5" id="uE1JLlP4kj18/7anYGDOOUyNK5M=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="29" class="def"/>
           <struct name="S6" id="FOmk9y+Cw81IBREmsFKS2/xbZEw=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S7" id="SL5VtD+e99bejq70N9+jOCWJkA0=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37"/>
               </struct>
             </template>
             <template class="explicit" id="3ZrGNdgVY0Bl8pl2wuSUdgLSht4=">
-              <targ class="non-type" value="35"/>
+              <targ class="constant" value="35"/>
               <targ class="type" type="bool"/>
               <struct name="S7" id="V/H0waQNmYhkbcgX6kBFOODNK64=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="38" class="def"/>
@@ -2093,7 +2093,7 @@
                   </function>
                 </struct>
                 <template>
-                  <tparam name="L" class="non-type" type="int"/>
+                  <tparam name="L" class="constant" type="int"/>
                   <tparam name="W" class="type" default="void"/>
                   <struct name="S9" id="C3y4XMVXMiPK3FyTTBIV1tLNz9M=">
                     <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="47"/>
@@ -2119,7 +2119,7 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="36"/>
+    <targ class="constant" value="36"/>
     <targ class="type" type="bool"/>
     <struct name="S0" id="1gjCMmREpyWTXEFMqDWbHTY9s+Q=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
@@ -2127,28 +2127,28 @@
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="l7G+8vz4XtvP9QMA2Pay6EiAAmc=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
         </struct>
       </template>
       <template class="explicit" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
-        <targ class="non-type" value="37"/>
+        <targ class="constant" value="37"/>
         <targ class="type" type="bool"/>
         <struct name="S5" id="tZqwapq24sWOnWsHAcGXH/3yX3Y=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="29" class="def"/>
           <struct name="S6" id="lOYR3RSOn6EXRgMVOdiUYeA1St0=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S7" id="gMX/HXKHuwdr3ZUv3Th0+z3Yn0s=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37"/>
               </struct>
             </template>
             <template class="explicit" id="3ZrGNdgVY0Bl8pl2wuSUdgLSht4=">
-              <targ class="non-type" value="38"/>
+              <targ class="constant" value="38"/>
               <targ class="type" type="bool"/>
               <struct name="S7" id="1YtqF4WYT0uK7amUiCmJVk03Oog=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="38" class="def"/>
@@ -2156,7 +2156,7 @@
                   <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="42"/>
                 </struct>
                 <template>
-                  <tparam name="L" class="non-type" type="int"/>
+                  <tparam name="L" class="constant" type="int"/>
                   <tparam name="W" class="type" default="void"/>
                   <struct name="S9" id="Z3kwHhQ9TeFidONs1zwBzesA5Qk=">
                     <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="47"/>
@@ -2182,7 +2182,7 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="39"/>
+    <targ class="constant" value="39"/>
     <targ class="type" type="bool"/>
     <struct name="S0" id="IG7byGfx+stnhACpeGR2toLyv7U=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
@@ -2190,28 +2190,28 @@
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="ZZH7BKff6J0lIPMbz4l4lG/x9Xw=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
         </struct>
       </template>
       <template class="explicit" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
-        <targ class="non-type" value="40"/>
+        <targ class="constant" value="40"/>
         <targ class="type" type="bool"/>
         <struct name="S5" id="hpAmCOpzad0YvzIs/nrK1blINCo=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="29" class="def"/>
           <struct name="S6" id="psFAepglqmkBtNBdTg6lzRdenHA=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S7" id="ZDCCpKbLnTUygKHcdXArtd9dGLM=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37"/>
               </struct>
             </template>
             <template class="explicit" id="3ZrGNdgVY0Bl8pl2wuSUdgLSht4=">
-              <targ class="non-type" value="41"/>
+              <targ class="constant" value="41"/>
               <targ class="type" type="bool"/>
               <struct name="S7" id="GJK8oH0tb+kOcrLsJD4KLPgW01k=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="38" class="def"/>
@@ -2219,7 +2219,7 @@
                   <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="42"/>
                 </struct>
                 <template>
-                  <tparam name="L" class="non-type" type="int"/>
+                  <tparam name="L" class="constant" type="int"/>
                   <tparam name="W" class="type" default="void"/>
                   <struct name="S9" id="/sbl0h6rv808/hLp3t8ImQj/xWI=">
                     <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="47"/>
@@ -2245,14 +2245,14 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="4"/>
+    <targ class="constant" value="4"/>
     <targ class="type" type="bool"/>
     <struct name="S0" id="tuaR3CreZXFWLNOiRe6vUMcdi/0=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="AedlkzTQ3XMtklY5JQNTU9Q693U=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
         <template>
-          <tparam name="J" class="non-type" type="int"/>
+          <tparam name="J" class="constant" type="int"/>
           <tparam name="U" class="type" default="void"/>
           <struct name="S2" id="ZVPQu+o+bOETjTeYbQPX3DpZHsI=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10"/>
@@ -2263,7 +2263,7 @@
         </function>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="x4evHZHGuxDX33AZdmaDmPqEUBQ=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
@@ -2275,7 +2275,7 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="43"/>
+    <targ class="constant" value="43"/>
     <targ class="type" type="bool"/>
     <struct name="S0" id="UpHebkkBv0Q2s1ECAoKTf79hJ0Q=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
@@ -2283,28 +2283,28 @@
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6"/>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="IXEkzvLrMpSwXl5gP+lIgInnSP8=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
         </struct>
       </template>
       <template class="explicit" id="t/fAg/z+G5QClTBG74e6bR64CDI=">
-        <targ class="non-type" value="44"/>
+        <targ class="constant" value="44"/>
         <targ class="type" type="bool"/>
         <struct name="S5" id="51FuSsXmA0w505ZBRVkx0q/lmUk=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="29" class="def"/>
           <struct name="S6" id="MeilWWlQPSeKS/ejqoeb8fMZVQU=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="33" class="def"/>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S7" id="QT17UXq7NxbmhSdqWIqRBy1Qb/g=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="37"/>
               </struct>
             </template>
             <template class="explicit" id="3ZrGNdgVY0Bl8pl2wuSUdgLSht4=">
-              <targ class="non-type" value="45"/>
+              <targ class="constant" value="45"/>
               <targ class="type" type="bool"/>
               <struct name="S7" id="9PQcUNZCJePNJhT5t0prZNV/lHk=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="38" class="def"/>
@@ -2312,7 +2312,7 @@
                   <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="42"/>
                 </struct>
                 <template>
-                  <tparam name="L" class="non-type" type="int"/>
+                  <tparam name="L" class="constant" type="int"/>
                   <tparam name="W" class="type" default="void"/>
                   <struct name="S9" id="aoYmf5zFdrgPH9Wo0O/CQ5Gm7e8=">
                     <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="47"/>
@@ -2338,14 +2338,14 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="6"/>
+    <targ class="constant" value="6"/>
     <targ class="type" type="bool"/>
     <struct name="S0" id="IxCiCl8tf7r2/CmQWZiWxFHf7+g=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="qbJT920zehI9gqkvbe0x/HrzT00=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
         <template>
-          <tparam name="J" class="non-type" type="int"/>
+          <tparam name="J" class="constant" type="int"/>
           <tparam name="U" class="type" default="void"/>
           <struct name="S2" id="9BOS99lqNCS5fAcBO02qQ0Z2st8=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10"/>
@@ -2356,7 +2356,7 @@
         </function>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="YmolZwhgz1SAGaOGoKIE4JAN0KM=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
@@ -2368,21 +2368,21 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="8"/>
+    <targ class="constant" value="8"/>
     <targ class="type" type="bool"/>
     <struct name="S0" id="Rh5ZoB5qF98iwmDPqUPnsyKkTcs=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="2" class="def"/>
       <struct name="S1" id="ICgSeUPCz86m25XZTXmGxzgkbhY=">
         <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="6" class="def"/>
         <template>
-          <tparam name="J" class="non-type" type="int"/>
+          <tparam name="J" class="constant" type="int"/>
           <tparam name="U" class="type" default="void"/>
           <struct name="S2" id="5nVb5siuVRlsyau36E3FYJlBgdA=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="10"/>
           </struct>
         </template>
         <template class="explicit" id="oNfOAnUjZE7WlBGdMiNtQ9ePi8g=">
-          <targ class="non-type" value="9"/>
+          <targ class="constant" value="9"/>
           <targ class="type" type="bool"/>
           <struct name="S2" id="p3PhPnVydwdupHBMAXlcrNQuiFo=">
             <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="11" class="def"/>
@@ -2393,7 +2393,7 @@
               </function>
             </struct>
             <template>
-              <tparam name="K" class="non-type" type="int"/>
+              <tparam name="K" class="constant" type="int"/>
               <tparam name="V" class="type" default="void"/>
               <struct name="S4" id="Vfp4UI1q/WKw9xkfiS/VJGS128A=">
                 <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="20"/>
@@ -2409,7 +2409,7 @@
         </function>
       </struct>
       <template>
-        <tparam name="J" class="non-type" type="int"/>
+        <tparam name="J" class="constant" type="int"/>
         <tparam name="U" class="type" default="void"/>
         <struct name="S5" id="UArBfH6vZIOYsAbmmAKjRN+1EuM=">
           <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="28"/>
@@ -2422,7 +2422,7 @@
   </template>
   <template class="partial" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
     <tparam name="T" class="type"/>
-    <targ class="non-type" value="1"/>
+    <targ class="constant" value="1"/>
     <targ class="type" type="T*"/>
     <struct name="S0" id="xONzwxGiMBJrTYA5eosi4pOC0n0=">
       <file short-path="class-template-specializations-1.cpp" source-path="class-template-specializations-1.cpp" line="61" class="def"/>
diff --git a/test-files/golden-tests/symbols/record/local-class.cpp b/test-files/golden-tests/symbols/record/local-class.cpp
index 25b5186cc..93947a874 100644
--- a/test-files/golden-tests/symbols/record/local-class.cpp
+++ b/test-files/golden-tests/symbols/record/local-class.cpp
@@ -1 +1,11 @@
-auto f() { struct A { void g(); } a; return a; } struct B : decltype(f()) { };
+auto
+f()
+{
+    struct A {
+        void
+        g();
+    } a;
+    return a;
+}
+
+struct B : decltype(f()) {};
diff --git a/test-files/golden-tests/symbols/record/local-class.xml b/test-files/golden-tests/symbols/record/local-class.xml
index 5c158ea92..7784bdd36 100644
--- a/test-files/golden-tests/symbols/record/local-class.xml
+++ b/test-files/golden-tests/symbols/record/local-class.xml
@@ -3,7 +3,7 @@
        xsi:noNamespaceSchemaLocation="https://github.com/cppalliance/mrdocs/raw/develop/mrdocs.rnc">
 <namespace id="//////////////////////////8=">
   <struct name="B" id="3JsK1DO0O+wZhv+0meptQrbs3fY=">
-    <file short-path="local-class.cpp" source-path="local-class.cpp" line="1" class="def"/>
+    <file short-path="local-class.cpp" source-path="local-class.cpp" line="11" class="def"/>
     <base>
       <type class="decltype" operand="f()">
       </type>
diff --git a/test-files/golden-tests/symbols/record/record-data.xml b/test-files/golden-tests/symbols/record/record-data.xml
index 41c9f6d76..e0d750e54 100644
--- a/test-files/golden-tests/symbols/record/record-data.xml
+++ b/test-files/golden-tests/symbols/record/record-data.xml
@@ -59,7 +59,7 @@
   </struct>
   <template>
     <tparam name="P" class="type"/>
-    <tparam name="I" class="non-type" type="int"/>
+    <tparam name="I" class="constant" type="int"/>
     <struct name="X" id="XSI9u4gB6ZYb6pWxN29K8+iKza4=">
       <file short-path="record-data.cpp" source-path="record-data.cpp" line="33" class="def"/>
       <namespace-alias name="Q" id="nkW23Ykh9wywIjUzLqEQlHf8R5k=">
diff --git a/test-files/golden-tests/symbols/record/template-specialization-inheritance.xml b/test-files/golden-tests/symbols/record/template-specialization-inheritance.xml
index dbf68158f..4e44ee2a3 100644
--- a/test-files/golden-tests/symbols/record/template-specialization-inheritance.xml
+++ b/test-files/golden-tests/symbols/record/template-specialization-inheritance.xml
@@ -36,7 +36,7 @@
     </base>
   </struct>
   <template>
-    <tparam name="I" class="non-type" type="int"/>
+    <tparam name="I" class="constant" type="int"/>
     <tparam name="T" class="type" default="void"/>
     <struct name="S0" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
       <file short-path="template-specialization-inheritance.cpp" source-path="template-specialization-inheritance.cpp" line="1" class="def"/>
@@ -46,7 +46,7 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="2"/>
+    <targ class="constant" value="2"/>
     <struct name="S0" id="nJGs54s6oYf7fHzIpo0tyaCSH9M=">
       <file short-path="template-specialization-inheritance.cpp" source-path="template-specialization-inheritance.cpp" line="2" class="def"/>
       <struct name="S1" id="yY+X2/Fqu8ENz37/HFEJCBOSfVg=">
@@ -55,13 +55,13 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="3"/>
+    <targ class="constant" value="3"/>
     <struct name="S0" id="c7NNZfjOZ8Ztuw0u26xL/h7UKvA=">
       <file short-path="template-specialization-inheritance.cpp" source-path="template-specialization-inheritance.cpp" line="8" class="def"/>
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="5"/>
+    <targ class="constant" value="5"/>
     <struct name="S0" id="6Syw3aWFS3pfPUbWU7C8uCE7Jjc=">
       <file short-path="template-specialization-inheritance.cpp" source-path="template-specialization-inheritance.cpp" line="2" class="def"/>
       <struct name="S1" id="fzQKX2ygXfWjrcDi23o2CnGMkaY=">
@@ -70,7 +70,7 @@
     </struct>
   </template>
   <template class="explicit" id="z/QEAP16LEoD3NlABxA6BOFpYpA=">
-    <targ class="non-type" value="6"/>
+    <targ class="constant" value="6"/>
     <struct name="S0" id="flxREiXFL5ObY0xUAxojj+jvR54=">
       <file short-path="template-specialization-inheritance.cpp" source-path="template-specialization-inheritance.cpp" line="13" class="def"/>
     </struct>
diff --git a/test-files/golden-tests/symbols/using/using-member-function.xml b/test-files/golden-tests/symbols/using/using-member-function.xml
index f4edc7378..f2bcfeb78 100644
--- a/test-files/golden-tests/symbols/using/using-member-function.xml
+++ b/test-files/golden-tests/symbols/using/using-member-function.xml
@@ -120,7 +120,7 @@
     </function>
   </struct>
   <template>
-    <tparam name="idx" class="non-type" type="int"/>
+    <tparam name="idx" class="constant" type="int"/>
     <struct name="Tag" id="VcdHojbpExgHkfZT+vfrZl1ADjM=">
       <file short-path="using-member-function.cpp" source-path="using-member-function.cpp" line="8" class="def"/>
       <doc>

From ede9e23f4db1d56766daa82cbdb3d710e09af5fc Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Fri, 26 Sep 2025 22:17:43 -0500
Subject: [PATCH 17/23] refactor(Corpus): valueless_after_move is asserted

Only use MRDOCS_ASSERT for valueless_after_move(). Since polymorphic objects are no longer nullable, and using moved-from objects is invalid, we should never check valueless_after_move() to determine conditional application logic.
---
 include/mrdocs/ADT/Polymorphic.hpp            |  40 ++---
 include/mrdocs/Metadata/Name.hpp              |   6 +-
 include/mrdocs/Metadata/TArg.hpp              |   6 +-
 include/mrdocs/Metadata/TParam.hpp            |   6 +-
 include/mrdocs/Metadata/Type.hpp              |   6 +-
 src/lib/AST/ASTVisitor.cpp                    |  29 ++--
 src/lib/AST/ParseRef.cpp                      | 164 ++++++++++--------
 src/lib/CorpusImpl.cpp                        |   7 +-
 src/lib/Gen/hbs/VisitorHelpers.cpp            |   2 +-
 src/lib/Gen/xml/CXXTags.hpp                   |  13 +-
 src/lib/Gen/xml/XMLWriter.cpp                 |   6 +-
 .../Metadata/Finalizers/Javadoc/Function.hpp  |   6 +-
 .../Metadata/Finalizers/JavadocFinalizer.hpp  |  12 +-
 src/lib/Metadata/Info/Typedef.cpp             |   4 +-
 src/lib/Metadata/Info/Using.cpp               |   4 +-
 src/lib/Metadata/Info/Variable.cpp            |   4 +-
 src/lib/Metadata/Javadoc.cpp                  |  18 +-
 src/lib/Metadata/Name.cpp                     |  23 +--
 src/lib/Metadata/Template.cpp                 |  36 ++--
 src/lib/Metadata/Type.cpp                     |  33 ++--
 20 files changed, 189 insertions(+), 236 deletions(-)

diff --git a/include/mrdocs/ADT/Polymorphic.hpp b/include/mrdocs/ADT/Polymorphic.hpp
index ee5d33a8c..bd1f3505d 100644
--- a/include/mrdocs/ADT/Polymorphic.hpp
+++ b/include/mrdocs/ADT/Polymorphic.hpp
@@ -193,6 +193,19 @@ template <class T> inline constexpr bool IsPolymorphic<Polymorphic<T>> = true;
 
 } // namespace detail
 
+/// @copydoc CompareDerived(Polymorphic<Base> const&, Polymorphic<Base> const&)
+template <class Base>
+requires(!detail::IsPolymorphic<Base>) && detail::CanVisitCompare<Base>
+auto
+CompareDerived(Base const& lhs, Base const& rhs)
+{
+    if (lhs.Kind == rhs.Kind)
+    {
+        return visit(lhs, detail::VisitCompareFn<Base>(rhs));
+    }
+    return lhs.Kind <=> rhs.Kind;
+}
+
 /** @brief Compares two polymorphic objects that have visit functions
 
     This function compares two Polymorphic objects that
@@ -217,30 +230,9 @@ requires detail::CanVisitCompare<Base>
 auto
 CompareDerived(Polymorphic<Base> const& lhs, Polymorphic<Base> const& rhs)
 {
-    if (!lhs.valueless_after_move() && !rhs.valueless_after_move())
-    {
-        if (lhs->Kind == rhs->Kind)
-        {
-            return visit(*lhs, detail::VisitCompareFn<Base>(*rhs));
-        }
-        return lhs->Kind <=> rhs->Kind;
-    }
-    return lhs.valueless_after_move() ?
-               std::strong_ordering::less :
-               std::strong_ordering::greater;
-}
-
-/// @copydoc CompareDerived(Polymorphic<Base> const&, Polymorphic<Base> const&)
-template <class Base>
-requires(!detail::IsPolymorphic<Base>) && detail::CanVisitCompare<Base>
-auto
-CompareDerived(Base const& lhs, Base const& rhs)
-{
-    if (lhs.Kind == rhs.Kind)
-    {
-        return visit(lhs, detail::VisitCompareFn<Base>(rhs));
-    }
-    return lhs.Kind <=> rhs.Kind;
+    MRDOCS_ASSERT(!lhs.valueless_after_move());
+    MRDOCS_ASSERT(!rhs.valueless_after_move());
+    return CompareDerived(*lhs, *rhs);
 }
 
 template <class Base>
diff --git a/include/mrdocs/Metadata/Name.hpp b/include/mrdocs/Metadata/Name.hpp
index d4505c251..a4b100dc5 100644
--- a/include/mrdocs/Metadata/Name.hpp
+++ b/include/mrdocs/Metadata/Name.hpp
@@ -61,11 +61,7 @@ tag_invoke(
     Polymorphic<NameInfo> const& I,
     DomCorpus const* domCorpus)
 {
-    if(I.valueless_after_move())
-    {
-        v = nullptr;
-        return;
-    }
+    MRDOCS_ASSERT(!I.valueless_after_move());
     tag_invoke(dom::ValueFromTag{}, v, *I, domCorpus);
 }
 
diff --git a/include/mrdocs/Metadata/TArg.hpp b/include/mrdocs/Metadata/TArg.hpp
index ac1af6837..e19daabd4 100644
--- a/include/mrdocs/Metadata/TArg.hpp
+++ b/include/mrdocs/Metadata/TArg.hpp
@@ -64,11 +64,7 @@ tag_invoke(
     Polymorphic<TArg> const& I,
     DomCorpus const* domCorpus)
 {
-    if (I.valueless_after_move())
-    {
-        v = nullptr;
-        return;
-    }
+    MRDOCS_ASSERT(!I.valueless_after_move());
     tag_invoke(dom::ValueFromTag{}, v, *I, domCorpus);
 }
 
diff --git a/include/mrdocs/Metadata/TParam.hpp b/include/mrdocs/Metadata/TParam.hpp
index 19d211c92..b2e2923ff 100644
--- a/include/mrdocs/Metadata/TParam.hpp
+++ b/include/mrdocs/Metadata/TParam.hpp
@@ -71,11 +71,7 @@ tag_invoke(
     Polymorphic<TParam> const& I,
     DomCorpus const* domCorpus)
 {
-    if (I.valueless_after_move())
-    {
-        v = nullptr;
-        return;
-    }
+    MRDOCS_ASSERT(!I.valueless_after_move());
     tag_invoke(dom::ValueFromTag{}, v, *I, domCorpus);
 }
 
diff --git a/include/mrdocs/Metadata/Type.hpp b/include/mrdocs/Metadata/Type.hpp
index 3393f4e31..f66b14f4c 100644
--- a/include/mrdocs/Metadata/Type.hpp
+++ b/include/mrdocs/Metadata/Type.hpp
@@ -175,11 +175,7 @@ tag_invoke(
     Polymorphic<TypeInfo> const& I,
     DomCorpus const* domCorpus)
 {
-    if (I.valueless_after_move())
-    {
-        v = nullptr;
-        return;
-    }
+    MRDOCS_ASSERT(!I.valueless_after_move());
     tag_invoke(dom::ValueFromTag{}, v, *I, domCorpus);
 }
 
diff --git a/src/lib/AST/ASTVisitor.cpp b/src/lib/AST/ASTVisitor.cpp
index fa19fcb13..0b00c92d7 100644
--- a/src/lib/AST/ASTVisitor.cpp
+++ b/src/lib/AST/ASTVisitor.cpp
@@ -714,8 +714,8 @@ populate(
             // CXXBaseSpecifier::getEllipsisLoc indicates whether the
             // base was a pack expansion; a PackExpansionType is not built
             // for base-specifiers
-            if (!BaseType.valueless_after_move() &&
-                B.getEllipsisLoc().isValid())
+            MRDOCS_ASSERT(!BaseType.valueless_after_move());
+            if (B.getEllipsisLoc().isValid())
             {
                 BaseType->IsPackExpansion = true;
             }
@@ -1341,11 +1341,7 @@ populate(
         for (auto it = Template.Args.begin(); it != Template.Args.end();)
         {
             auto& arg = *it;
-            if (arg.valueless_after_move())
-            {
-                ++it;
-                continue;
-            }
+            MRDOCS_ASSERT(!arg.valueless_after_move());
             if (auto* T = dynamic_cast<TypeTArg*>(arg.operator->()))
             {
                 MRDOCS_ASSERT(!T->Type.valueless_after_move());
@@ -1496,6 +1492,7 @@ populate(
     Polymorphic<TParam>& I,
     NamedDecl const* N)
 {
+    MRDOCS_ASSERT(!I.valueless_after_move());
     visit(N, [&]<typename DeclTy>(DeclTy const* P)
     {
         constexpr Decl::Kind kind =
@@ -1503,7 +1500,7 @@ populate(
 
         if constexpr(kind == Decl::TemplateTypeParm)
         {
-            if (I.valueless_after_move())
+            if (I->Kind != TParamKind::Type)
             {
                 I = Polymorphic<TParam>(std::in_place_type<TypeTParam>);
             }
@@ -1532,7 +1529,7 @@ populate(
         }
         else if constexpr(kind == Decl::NonTypeTemplateParm)
         {
-            if (I.valueless_after_move())
+            if (I->Kind != TParamKind::Constant)
             {
                 I = Polymorphic<TParam>(std::in_place_type<ConstantTParam>);
             }
@@ -1547,7 +1544,7 @@ populate(
         }
         else if constexpr(kind == Decl::TemplateTemplateParm)
         {
-            if (I.valueless_after_move())
+            if (I->Kind != TParamKind::Template)
             {
                 I = Polymorphic<TParam>(std::in_place_type<TemplateTParam>);
             }
@@ -1563,8 +1560,7 @@ populate(
                 auto& Param
                     = i < Result->Params.size() ?
                           Result->Params[i] :
-                          Result->Params.emplace_back(
-                              nullable_traits<Polymorphic<TParam>>::null());
+                          Result->Params.emplace_back(std::in_place_type<TypeTParam>);
                 populate(Param, TP);
             }
             if (TTPD->hasDefaultArgument() && !Result->Default)
@@ -1578,6 +1574,7 @@ populate(
         MRDOCS_UNREACHABLE();
     });
 
+    MRDOCS_ASSERT(!I.valueless_after_move());
     if (I->Name.empty())
     {
         I->Name = extractName(N);
@@ -1615,10 +1612,10 @@ populate(
     while (explicitIt != ExplicitTemplateParameters.end())
     {
         NamedDecl const* P = TPL->getParam(i);
-        auto& Param = i < TI.Params.size() ?
-                          TI.Params[i] :
-                          TI.Params.emplace_back(
-                              nullable_traits<Polymorphic<TParam>>::null());
+        Polymorphic<TParam>& Param =
+            i < TI.Params.size() ?
+                TI.Params[i] :
+                TI.Params.emplace_back(std::in_place_type<TypeTParam>);
         populate(Param, P);
         ++explicitIt;
         ++i;
diff --git a/src/lib/AST/ParseRef.cpp b/src/lib/AST/ParseRef.cpp
index 1d161e551..7fd91069e 100644
--- a/src/lib/AST/ParseRef.cpp
+++ b/src/lib/AST/ParseRef.cpp
@@ -473,9 +473,9 @@ class RefParser
             return false;
         }
         skipWhitespace();
-        Polymorphic<TypeInfo> conversionType = nullable_traits<Polymorphic<TypeInfo>>::null();
+        Optional<Polymorphic<TypeInfo>> conversionType = std::nullopt;
         if (!parseDeclarationSpecifier(conversionType) ||
-            conversionType.valueless_after_move())
+            !conversionType)
         {
             ptr_ = start;
             return false;
@@ -650,11 +650,12 @@ class RefParser
         }
         skipWhitespace();
         char const* start = ptr_;
-        Polymorphic<TypeInfo> type = nullable_traits<Polymorphic<TypeInfo>>::null();
+        Optional<Polymorphic<TypeInfo>> type = std::nullopt;
         if (parseTypeId(type))
         {
+            MRDOCS_ASSERT(type);
             dest = Polymorphic<TArg>(std::in_place_type<TypeTArg>);
-            dynamic_cast<TypeTArg &>(*dest).Type = std::move(type);
+            dynamic_cast<TypeTArg &>(*dest).Type = std::move(*type);
             return true;
         }
 
@@ -818,13 +819,15 @@ class RefParser
 
         // https://en.cppreference.com/w/cpp/language/function#Parameter_list
         // decl-specifier-seq
-        auto &curParam = dest.Params.emplace_back(nullable_traits<Polymorphic<TypeInfo>>::null());
-        if (!parseTypeId(curParam))
+        Optional<Polymorphic<TypeInfo>> curParamOpt = std::nullopt;
+        if (!parseTypeId(curParamOpt))
         {
             ptr_ = start;
             setError("expected type-id");
             return false;
         }
+        MRDOCS_ASSERT(curParamOpt);
+        auto &curParam = dest.Params.emplace_back(std::move(*curParamOpt));
 
         // 2. After determining the type of each parameter, any parameter
         // of type “array of T” or of function type T is adjusted to be
@@ -852,7 +855,7 @@ class RefParser
     }
 
     bool
-    parseTypeId(Polymorphic<TypeInfo>& dest)
+    parseTypeId(Optional<Polymorphic<TypeInfo>>& dest)
     {
         char const* start = ptr_;
 
@@ -881,7 +884,7 @@ class RefParser
     }
 
     bool
-    parseDeclarationSpecifiers(Polymorphic<TypeInfo>& dest)
+    parseDeclarationSpecifiers(Optional<Polymorphic<TypeInfo>>& dest)
     {
         //static constexpr std::string_view typeQualifiers[] = {
         //    "const", "volatile"
@@ -914,7 +917,7 @@ class RefParser
                 // If we have one of the "long", "short", "signed", "unsigned"
                 // specifiers, then we don't have an error because
                 // we can later infer the type from these.
-                if (dest.valueless_after_move() &&
+                if (!dest &&
                     !contains_any(specifiers, typeModifiers))
                 {
                     setError(specStart, "expected declaration specifier");
@@ -937,7 +940,7 @@ class RefParser
                 break;
             }
         }
-        if (dest.valueless_after_move() && specifiers.empty())
+        if (!dest && specifiers.empty())
         {
             // We need at least one type declarator or specifier
             ptr_ = start;
@@ -1008,15 +1011,15 @@ class RefParser
             std::string_view signStr = explicitlySigned ? "signed" : "unsigned";
             // Infer basic fundamental type from "signed" or "unsigned",
             // which is "int"
-            if (dest.valueless_after_move())
+            if (!dest)
             {
                 dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-                auto &NTI = dynamic_cast<NamedTypeInfo &>(*dest);
+                auto &NTI = dynamic_cast<NamedTypeInfo &>(**dest);
                 NTI.Name->Name = "int";
                 NTI.FundamentalType = FundamentalTypeKind::Int;
             }
             // Check if the type is named
-            if (!dest->isNamed())
+            if (!(*dest)->isNamed())
             {
               setError(std::format("expected named type for '{}' specifier",
                                    signStr));
@@ -1024,7 +1027,7 @@ class RefParser
               return false;
             }
             // Check if the type is "int" or "char"
-            auto& namedParam = dynamic_cast<NamedTypeInfo&>(*dest);
+            auto& namedParam = dynamic_cast<NamedTypeInfo&>(**dest);
             if (!namedParam.FundamentalType)
             {
               setError(std::format(
@@ -1051,16 +1054,16 @@ class RefParser
         if (contains(specifiers, "short"))
         {
             // Infer basic fundamental type for "short", which is "int"
-            if (dest.valueless_after_move())
+            if (!dest)
             {
                 dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-                auto &NTI = dynamic_cast<NamedTypeInfo &>(*dest);
+                auto &NTI = dynamic_cast<NamedTypeInfo &>(**dest);
                 NTI.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
                 NTI.Name->Name = "int";
                 NTI.FundamentalType = FundamentalTypeKind::Int;
             }
             // Check if the type is named
-            if (!dest->isNamed())
+            if (!(*dest)->isNamed())
             {
                 setError(start, "expected named type for 'short' specifier");
                 ptr_ = start;
@@ -1068,7 +1071,7 @@ class RefParser
             }
 
             // Check if the type is "int"
-            auto& namedParam = dynamic_cast<NamedTypeInfo&>(*dest);
+            auto& namedParam = dynamic_cast<NamedTypeInfo&>(**dest);
             if (!namedParam.FundamentalType)
             {
                 setError(start, "expected fundamental type for 'short' specifier");
@@ -1090,22 +1093,22 @@ class RefParser
         if (contains(specifiers, "long"))
         {
             // Infer basic fundamental type for "long", which is "int"
-            if (dest.valueless_after_move())
+            if (!dest)
             {
                 dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-                auto &NTI = dynamic_cast<NamedTypeInfo &>(*dest);
+                auto &NTI = dynamic_cast<NamedTypeInfo &>(**dest);
                 NTI.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
                 NTI.Name->Name = "int";
                 NTI.FundamentalType = FundamentalTypeKind::Int;
             }
             // Check if the type is named
-            if (!dest->isNamed())
+            if (!(*dest)->isNamed())
             {
                 setError(start, "expected named type for 'long' specifier");
                 ptr_ = start;
                 return false;
             }
-            auto& namedParam = dynamic_cast<NamedTypeInfo&>(*dest);
+            auto& namedParam = dynamic_cast<NamedTypeInfo&>(**dest);
             if (!namedParam.FundamentalType)
             {
                 setError(start, "expected fundamental type for 'long' specifier");
@@ -1134,7 +1137,7 @@ class RefParser
         }
 
         // Final check: if dest is still empty, we have an error
-        if (dest.valueless_after_move())
+        if (!dest)
         {
             ptr_ = start;
             setError("expected parameter type");
@@ -1142,19 +1145,19 @@ class RefParser
         }
 
         // Set cv qualifiers
-        dest->IsConst = contains(specifiers, "const");
-        dest->IsVolatile = contains(specifiers, "volatile");
+        (*dest)->IsConst = contains(specifiers, "const");
+        (*dest)->IsVolatile = contains(specifiers, "volatile");
 
         return true;
     }
 
     bool
-    parseDeclarationSpecifier(Polymorphic<TypeInfo>& dest)
+    parseDeclarationSpecifier(Optional<Polymorphic<TypeInfo>>& dest)
     {
         char const* start = ptr_;
 
         // Some rules are only valid if dest was initially empty
-        auto checkDestWasEmpty = [destWasEmpty=dest.valueless_after_move(), start, this]() {
+        auto checkDestWasEmpty = [destWasEmpty=!dest.has_value(), start, this]() {
             if (!destWasEmpty)
             {
                 setError(start, "multiple type declaration specifiers");
@@ -1206,7 +1209,9 @@ class RefParser
             MRDOCS_CHECK_OR(checkDestWasEmpty(), false);
 
             dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-            auto &NTI = dynamic_cast<NamedTypeInfo &>(*dest);
+            MRDOCS_ASSERT(dest);
+            MRDOCS_ASSERT(!dest->valueless_after_move());
+            auto &NTI = dynamic_cast<NamedTypeInfo &>(**dest);
             MRDOCS_ASSERT(!NTI.Name.valueless_after_move());
             NTI.Name->Name = std::string_view(start, ptr_ - start);
             if (FundamentalTypeKind k;
@@ -1237,12 +1242,14 @@ class RefParser
                     skipWhitespace();
                     if (parseLiteral(")"))
                     {
-                      MRDOCS_CHECK_OR(checkDestWasEmpty(), false);
-                      dest = Polymorphic<TypeInfo>(
-                          std::in_place_type<AutoTypeInfo>);
-                      static_cast<AutoTypeInfo &>(*dest).Keyword =
-                          AutoKind::DecltypeAuto;
-                      return true;
+                        MRDOCS_CHECK_OR(checkDestWasEmpty(), false);
+                        dest = Polymorphic<TypeInfo>(
+                            std::in_place_type<AutoTypeInfo>);
+                        MRDOCS_ASSERT(dest);
+                        MRDOCS_ASSERT(!dest->valueless_after_move());
+                        static_cast<AutoTypeInfo&>(**dest).Keyword = AutoKind::
+                            DecltypeAuto;
+                        return true;
                     }
                 }
                 // - "decltype(expression)"
@@ -1272,8 +1279,10 @@ class RefParser
                     MRDOCS_CHECK_OR(checkDestWasEmpty(), false);
                     dest = Polymorphic<TypeInfo>(
                         std::in_place_type<DecltypeTypeInfo>);
-                    static_cast<DecltypeTypeInfo &>(*dest).Operand.Written =
-                        expr;
+                    MRDOCS_ASSERT(dest);
+                    MRDOCS_ASSERT(!dest->valueless_after_move());
+                    dynamic_cast<DecltypeTypeInfo&>(**dest).Operand.Written
+                        = expr;
                     return true;
                 }
                 setError("expected expression in decltype");
@@ -1377,12 +1386,13 @@ class RefParser
 
     bool
     parseQualifiedIdentifier(
-        Polymorphic<TypeInfo>& dest,
+        Optional<Polymorphic<TypeInfo>>& dest,
         bool const allowTemplateDisambiguation,
         bool const allowTemplateArguments)
     {
-        if (!dest.valueless_after_move())
+        if (dest)
         {
+            MRDOCS_ASSERT(!dest->valueless_after_move());
             setError("type specifier is already set");
             return false;
         }
@@ -1400,12 +1410,12 @@ class RefParser
 
             // Populate dest
             auto const idStr = std::string_view(idStart, ptr_ - idStart);
-            Optional<Polymorphic<NameInfo>>
-                ParentName = !dest.valueless_after_move() ?
-                                 Optional<Polymorphic<NameInfo>>(dynamic_cast<NamedTypeInfo*>(&*dest)->Name) :
-                                 Optional<Polymorphic<NameInfo>>(std::nullopt);
+            Optional<Polymorphic<NameInfo>> ParentName
+                = dest ? Optional<Polymorphic<NameInfo>>(
+                             dynamic_cast<NamedTypeInfo*>(&**dest)->Name) :
+                         Optional<Polymorphic<NameInfo>>(std::nullopt);
             dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-            auto &NTI = dynamic_cast<NamedTypeInfo &>(*dest);
+            auto &NTI = dynamic_cast<NamedTypeInfo &>(**dest);
             NTI.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
             NTI.Name->Name = idStr;
             NTI.Name->Prefix = std::move(ParentName);
@@ -1420,7 +1430,7 @@ class RefParser
             }
             skipWhitespace();
         }
-        if (dest.valueless_after_move())
+        if (!dest)
         {
             ptr_ = start;
             return false;
@@ -1431,14 +1441,15 @@ class RefParser
             skipWhitespace();
             if (peek('<'))
             {
-                if (!dest->isNamed())
+                MRDOCS_ASSERT(dest);
+                if (!(*dest)->isNamed())
                 {
                     setError("expected named type for template arguments");
                     ptr_ = start;
                     return false;
                 }
                 // Replace the nameinfo with a nameinfo with args
-                auto& namedParam = dynamic_cast<NamedTypeInfo&>(*dest);
+                auto& namedParam = dynamic_cast<NamedTypeInfo&>(**dest);
                 SpecializationNameInfo SNI;
                 SNI.Name = std::move(namedParam.Name->Name);
                 SNI.Prefix = std::move(namedParam.Name->Prefix);
@@ -1472,14 +1483,14 @@ class RefParser
     };
 
     bool
-    parseAbstractDeclarator(Polymorphic<TypeInfo>& dest)
+    parseAbstractDeclarator(Optional<Polymorphic<TypeInfo>>& dest)
     {
         return parseDeclarator<abstract>(dest);
     }
 
     template <int declarator_type>
     bool
-    parseDeclarator(Polymorphic<TypeInfo>& dest)
+    parseDeclarator(Optional<Polymorphic<TypeInfo>>& dest)
     {
         char const *start = ptr_;
         if (!parseDeclaratorOrNoPtrDeclarator<declarator_type>(dest))
@@ -1510,7 +1521,7 @@ class RefParser
             ptr_ = start;
             return false;
         }
-        if (dest.valueless_after_move())
+        if (!dest)
         {
             setError("no type defined by specifiers and declarator");
             ptr_ = start;
@@ -1520,7 +1531,9 @@ class RefParser
         auto isNoPtrDeclarator = [&dest, &suffixLevel, this]() {
             if (suffixLevel == 0)
             {
-                if (dest->isLValueReference() || dest->isRValueReference() || dest->isPointer())
+                if ((*dest)->isLValueReference() ||
+                    (*dest)->isRValueReference() ||
+                    (*dest)->isPointer())
                 {
                     return peekBack(')', ' ');
                 }
@@ -1545,21 +1558,24 @@ class RefParser
             // The same logic other elements that have inner types (pointers,
             // arrays, and references).
             // The current inner type of dest is the function return type.
-            auto inner = innerType(*dest);
+            MRDOCS_ASSERT(dest);
+            MRDOCS_ASSERT(!dest->valueless_after_move());
+            Optional<Polymorphic<TypeInfo> &> inner = innerType(**dest);
             // The more suffixes we have, the more levels of inner types
             // the suffix affects.
             // For instance, in "int (*)[3][6]", we have a pointer to an
             // array of 3 arrays of 6 ints.
             std::size_t curSuffixLevel = suffixLevel;
-            while (curSuffixLevel > 0 && inner && !inner->valueless_after_move())
+            while (curSuffixLevel > 0 && inner)
             {
+                MRDOCS_ASSERT(!inner->valueless_after_move());
                 auto& ref = *inner;
                 inner = innerType(*ref);
                 --curSuffixLevel;
             }
             char const* parenStart = ptr_;
             if (!parseArrayOrFunctionDeclaratorSuffix<declarator_type>(
-                inner ? *inner : dest))
+                inner ? *inner : *dest))
             {
                 setError(parenStart, "expected declarator");
                 ptr_ = start;
@@ -1572,7 +1588,7 @@ class RefParser
 
     template <int declarator_type>
     bool
-    parseDeclaratorOrNoPtrDeclarator(Polymorphic<TypeInfo>& dest)
+    parseDeclaratorOrNoPtrDeclarator(Optional<Polymorphic<TypeInfo>>& dest)
     {
         static constexpr bool isAbstractDeclarator = static_cast<bool>(declarator_type & abstract);
         static constexpr bool isInternalDeclarator = static_cast<bool>(declarator_type & internal_declarator);
@@ -1580,7 +1596,7 @@ class RefParser
         // https://en.cppreference.com/w/cpp/language/declarations#Declarators
         char const* start = ptr_;
 
-        if (dest.valueless_after_move())
+        if (!dest)
         {
             setError("expected parameter type for '...'");
             ptr_ = start;
@@ -1682,7 +1698,7 @@ class RefParser
         {
             skipWhitespace();
             parseIdentifier(false);
-            dest->IsPackExpansion = true;
+            (*dest)->IsPackExpansion = true;
             return parseClosingParens();
         }
 
@@ -1692,8 +1708,8 @@ class RefParser
         // https://en.cppreference.com/w/cpp/language/pointer
         if (parseLiteral("*"))
         {
-            if (dest->isLValueReference() ||
-                dest->isRValueReference())
+            if ((*dest)->isLValueReference() ||
+                (*dest)->isRValueReference())
             {
                 setError("pointer to reference not allowed");
                 ptr_ = start;
@@ -1702,14 +1718,14 @@ class RefParser
 
             // Change current type to pointer type
             PointerTypeInfo PTI;
-            PTI.PointeeType = std::move(dest);
+            PTI.PointeeType = std::move(*dest);
             dest = Polymorphic<TypeInfo>(std::move(PTI));
 
             skipWhitespace();
             // cv is a sequence of const and volatile qualifiers,
             // where either qualifier may appear at most once
             // in the sequence.
-            parseCV(dest->IsConst, dest->IsVolatile);
+            parseCV((*dest)->IsConst, (*dest)->IsVolatile);
             // Parse the next declarator, potentially wrapping
             // the destination type in another type
             // If this declarator is abstract, the pointer
@@ -1775,7 +1791,7 @@ class RefParser
 
             // Change current type to member pointer type
             MemberPointerTypeInfo MPTI;
-            MPTI.PointeeType = Polymorphic<TypeInfo>(std::move(dest));
+            MPTI.PointeeType = Polymorphic<TypeInfo>(std::move(*dest));
             MPTI.ParentType = Polymorphic<TypeInfo>(std::move(ParentType));
             dest = Polymorphic<TypeInfo>(std::move(MPTI));
 
@@ -1783,7 +1799,7 @@ class RefParser
             // cv is a sequence of const and volatile qualifiers,
             // where either qualifier may appear at most once
             // in the sequence.
-            parseCV(dest->IsConst, dest->IsVolatile);
+            parseCV((*dest)->IsConst, (*dest)->IsVolatile);
             parseIdentifier(false);
             // We ignore the name and just return true
             return parseClosingParens();
@@ -1815,13 +1831,13 @@ class RefParser
                 !isRValue)
             {
                 LValueReferenceTypeInfo RTI;
-                RTI.PointeeType = std::move(dest);
+                RTI.PointeeType = std::move(*dest);
                 dest = Polymorphic<TypeInfo>(std::move(RTI));
             }
             else
             {
                 RValueReferenceTypeInfo RTI;
-                RTI.PointeeType = std::move(dest);
+                RTI.PointeeType = std::move(*dest);
                 dest = Polymorphic<TypeInfo>(std::move(RTI));
             }
 
@@ -1845,7 +1861,8 @@ class RefParser
         // function
         parenDepth = 0;
         ptr_ = start;
-        if (parseArrayOrFunctionDeclaratorSuffix<declarator_type>(dest))
+        MRDOCS_ASSERT(dest);
+        if (parseArrayOrFunctionDeclaratorSuffix<declarator_type>(*dest))
         {
             return true;
         }
@@ -1871,6 +1888,8 @@ class RefParser
     bool
     parseArrayOrFunctionDeclaratorSuffix(Polymorphic<TypeInfo>& dest)
     {
+        MRDOCS_ASSERT(!dest.valueless_after_move());
+
         char const* start = ptr_;
 
         // (8) Array declarator. noptr-declarator any valid declarator, but
@@ -1878,8 +1897,10 @@ class RefParser
         //     parentheses.
         // noptr-declarator [expr (optional)] attr (optional)
         // https://en.cppreference.com/w/cpp/language/array
-        if (parseArrayDeclaratorSuffix<declarator_type>(dest))
+        Optional<Polymorphic<TypeInfo>> r;
+        if (parseArrayDeclaratorSuffix<declarator_type>(r))
         {
+            dest = *r;
             return true;
         }
         ptr_ = start;
@@ -1890,8 +1911,9 @@ class RefParser
         //     noptr-declarator ( parameter-list ) cv (optional) ref  (optional) except (optional) attr  (optional)
         // https://en.cppreference.com/w/cpp/language/function
         // https://en.cppreference.com/w/cpp/language/function#Function_type
-        if (parseFunctionDeclaratorSuffix<declarator_type>(dest))
+        if (parseFunctionDeclaratorSuffix<declarator_type>(r))
         {
+            dest = *r;
             return true;
         }
 
@@ -1900,7 +1922,7 @@ class RefParser
 
     template <int declarator_type>
     bool
-    parseArrayDeclaratorSuffix(Polymorphic<TypeInfo>& dest)
+    parseArrayDeclaratorSuffix(Optional<Polymorphic<TypeInfo>>& dest)
     {
         char const* start = ptr_;
 
@@ -1920,7 +1942,7 @@ class RefParser
 
             // Change current type to array type
             ArrayTypeInfo ATI;
-            ATI.ElementType = std::move(dest);
+            ATI.ElementType = std::move(*dest);
 
             // expr (optional)
             char const* exprStart = ptr_;
@@ -1973,7 +1995,7 @@ class RefParser
 
     template <int declarator_type>
     bool
-    parseFunctionDeclaratorSuffix(Polymorphic<TypeInfo>& dest)
+    parseFunctionDeclaratorSuffix(Optional<Polymorphic<TypeInfo>>& dest)
     {
         char const* start = ptr_;
 
@@ -2007,7 +2029,7 @@ class RefParser
                 return false;
             }
             FunctionTypeInfo FTI;
-            FTI.ReturnType = std::move(dest);
+            FTI.ReturnType = std::move(*dest);
             FTI.ParamTypes.insert(
                 FTI.ParamTypes.end(),
                 std::make_move_iterator(function.Params.begin()),
diff --git a/src/lib/CorpusImpl.cpp b/src/lib/CorpusImpl.cpp
index f7dd6d079..c0166852b 100644
--- a/src/lib/CorpusImpl.cpp
+++ b/src/lib/CorpusImpl.cpp
@@ -140,7 +140,8 @@ qualifiedNameCompare(
     Info const& context,
     CorpusImpl const& corpus)
 {
-    MRDOCS_CHECK_OR(!lhs0.valueless_after_move() && !rhs0.valueless_after_move(), false);
+    MRDOCS_ASSERT(!lhs0.valueless_after_move());
+    MRDOCS_ASSERT(!rhs0.valueless_after_move());
     // Compare each component of the qualified name
     NameInfo const* lhs = &*lhs0;
     NameInfo const* rhs = &*rhs0;
@@ -216,8 +217,8 @@ isDecayedEqualImpl(
     CorpusImpl const& corpus)
 {
     // Polymorphic
-    MRDOCS_CHECK_OR(lhs.valueless_after_move() == lhs.valueless_after_move(), false);
-    MRDOCS_CHECK_OR(!lhs.valueless_after_move() && !rhs.valueless_after_move(), true);
+    MRDOCS_ASSERT(!lhs.valueless_after_move());
+    MRDOCS_ASSERT(!rhs.valueless_after_move());
     // TypeInfo
     bool const decayToPointer = !isInner && (lhs->isArray() || rhs->isArray());
     if (!decayToPointer)
diff --git a/src/lib/Gen/hbs/VisitorHelpers.cpp b/src/lib/Gen/hbs/VisitorHelpers.cpp
index beeda7e9c..dd0de2287 100644
--- a/src/lib/Gen/hbs/VisitorHelpers.cpp
+++ b/src/lib/Gen/hbs/VisitorHelpers.cpp
@@ -171,7 +171,7 @@ findResolvedPrimarySiblingWithUrl(Corpus const& c, Info const& I)
         if constexpr (std::same_as<InfoTy, TypedefInfo>)
         {
             auto const& TOpt = U.Type;
-            MRDOCS_CHECK_OR(!TOpt.valueless_after_move(), false);
+            MRDOCS_ASSERT(!TOpt.valueless_after_move());
             TypeInfo const& T = *TOpt;
             MRDOCS_CHECK_OR(T.Kind == TypeKind::Named, false);
             auto const& NT = dynamic_cast<NamedTypeInfo const&>(T);
diff --git a/src/lib/Gen/xml/CXXTags.hpp b/src/lib/Gen/xml/CXXTags.hpp
index 4799d9866..21e1b8712 100644
--- a/src/lib/Gen/xml/CXXTags.hpp
+++ b/src/lib/Gen/xml/CXXTags.hpp
@@ -143,11 +143,9 @@ writeType(
 
             if constexpr(T::isNamed())
             {
-                if(!t.Name.valueless_after_move())
-                {
-                    attrs.push({t.Name->id});
-                    attrs.push({"name", toString(*t.Name)});
-                }
+                MRDOCS_ASSERT(!t.Name.valueless_after_move());
+                attrs.push({t.Name->id});
+                attrs.push({"name", toString(*t.Name)});
             }
 
             std::string cvQualifiers;
@@ -270,10 +268,7 @@ writeType(
     Polymorphic<TypeInfo> const& type,
     XMLTags& tags)
 {
-    if (type.valueless_after_move())
-    {
-        return;
-    }
+    MRDOCS_ASSERT(!type.valueless_after_move());
     writeType(*type, tags);
 }
 
diff --git a/src/lib/Gen/xml/XMLWriter.cpp b/src/lib/Gen/xml/XMLWriter.cpp
index a4af395e9..274d115d8 100644
--- a/src/lib/Gen/xml/XMLWriter.cpp
+++ b/src/lib/Gen/xml/XMLWriter.cpp
@@ -377,10 +377,8 @@ XMLWriter::
     }
 
     std::string qualifierStr;
-    if (!I.IntroducedName.valueless_after_move())
-    {
-        qualifierStr = toString(*I.IntroducedName);
-    }
+    MRDOCS_ASSERT(!I.IntroducedName.valueless_after_move());
+    qualifierStr = toString(*I.IntroducedName);
 
     constexpr std::string_view usingTagName = "using";
     tags_.open(usingTagName, {
diff --git a/src/lib/Metadata/Finalizers/Javadoc/Function.hpp b/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
index 0415292b1..609b62d30 100644
--- a/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
+++ b/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
@@ -314,7 +314,6 @@ populateFunctionReturnsFromFunctionBrief(
     return false;
 }
 
-
 bool
 populateFunctionReturnsForSpecial(
     FunctionInfo& I,
@@ -435,10 +434,9 @@ populateFunctionReturnsForSpecial(
     }
 
     // Special function that return the same type as the parent
+    MRDOCS_ASSERT(!innerR.valueless_after_move());
     if (I.IsRecordMethod &&
-        !innerR.valueless_after_move() &&
         innerR->isNamed() &&
-        !dynamic_cast<NamedTypeInfo const &>(*innerR).Name.valueless_after_move() &&
         dynamic_cast<NamedTypeInfo const &>(*innerR).Name->id &&
         dynamic_cast<NamedTypeInfo const &>(*innerR).Name->id == I.Parent)
     {
@@ -492,7 +490,7 @@ populateFunctionReturns(FunctionInfo& I, CorpusImpl const& corpus)
 
     // Check if we have a named return type
     MRDOCS_CHECK_OR(I.ReturnType);
-    MRDOCS_CHECK_OR(!I.ReturnType.valueless_after_move());
+    MRDOCS_ASSERT(!I.ReturnType.valueless_after_move());
     auto& inner = innermostType(I.ReturnType);
     MRDOCS_CHECK_OR(inner);
     if (inner->isNamed())
diff --git a/src/lib/Metadata/Finalizers/JavadocFinalizer.hpp b/src/lib/Metadata/Finalizers/JavadocFinalizer.hpp
index 48fb6bf90..5a0a85b17 100644
--- a/src/lib/Metadata/Finalizers/JavadocFinalizer.hpp
+++ b/src/lib/Metadata/Finalizers/JavadocFinalizer.hpp
@@ -346,20 +346,16 @@ class JavadocFinalizer
     void
     finalize(Polymorphic<T>&& val)
     {
-        if (!val.valueless_after_move())
-        {
-            finalize(*val);
-        }
+        MRDOCS_ASSERT(!val.valueless_after_move());
+        finalize(*val);
     }
 
     template <class T>
     void
     finalize(Polymorphic<T>& val)
     {
-        if (!val.valueless_after_move())
-        {
-            finalize(*val);
-        }
+        MRDOCS_ASSERT(!val.valueless_after_move());
+        finalize(*val);
     }
 
     /// Finalize optional and pointer-like members
diff --git a/src/lib/Metadata/Info/Typedef.cpp b/src/lib/Metadata/Info/Typedef.cpp
index 666a0cea8..199cd5e2a 100644
--- a/src/lib/Metadata/Info/Typedef.cpp
+++ b/src/lib/Metadata/Info/Typedef.cpp
@@ -67,7 +67,9 @@ void merge(TypedefInfo& I, TypedefInfo&& Other)
     {
         I.IsUsing = Other.IsUsing;
     }
-    if (I.Type.valueless_after_move())
+    MRDOCS_ASSERT(!I.Type.valueless_after_move());
+    if (I.Type->isNamed() &&
+        dynamic_cast<NamedTypeInfo&>(*I.Type).Name->Name.empty())
     {
         I.Type = std::move(Other.Type);
     }
diff --git a/src/lib/Metadata/Info/Using.cpp b/src/lib/Metadata/Info/Using.cpp
index 6b24d8f6e..a3412dab4 100644
--- a/src/lib/Metadata/Info/Using.cpp
+++ b/src/lib/Metadata/Info/Using.cpp
@@ -44,8 +44,8 @@ merge(UsingInfo& I, UsingInfo&& Other)
     {
         I.Class = Other.Class;
     }
-    if (I.IntroducedName.valueless_after_move() ||
-        I.IntroducedName->Name.empty())
+    MRDOCS_ASSERT(!I.IntroducedName.valueless_after_move());
+    if (I.IntroducedName->Name.empty())
     {
         I.IntroducedName = std::move(Other.IntroducedName);
     }
diff --git a/src/lib/Metadata/Info/Variable.cpp b/src/lib/Metadata/Info/Variable.cpp
index 6f8283479..ef033ed29 100644
--- a/src/lib/Metadata/Info/Variable.cpp
+++ b/src/lib/Metadata/Info/Variable.cpp
@@ -63,7 +63,9 @@ merge(VariableInfo& I, VariableInfo&& Other)
 {
     MRDOCS_ASSERT(canMerge(I, Other));
     merge(I.asInfo(), std::move(Other.asInfo()));
-    if (I.Type.valueless_after_move())
+    MRDOCS_ASSERT(!I.Type.valueless_after_move());
+    if (I.Type->isNamed() &&
+        dynamic_cast<NamedTypeInfo&>(*I.Type).Name->Name.empty())
     {
         I.Type = std::move(Other.Type);
     }
diff --git a/src/lib/Metadata/Javadoc.cpp b/src/lib/Metadata/Javadoc.cpp
index bf7d94434..a7f82da07 100644
--- a/src/lib/Metadata/Javadoc.cpp
+++ b/src/lib/Metadata/Javadoc.cpp
@@ -183,21 +183,13 @@ append(std::vector<Polymorphic<Text>> const& otherChildren)
 std::strong_ordering
 operator<=>(Polymorphic<Text> const& lhs, Polymorphic<Text> const& rhs)
 {
-    if (!lhs.valueless_after_move() && !rhs.valueless_after_move())
+    MRDOCS_ASSERT(!lhs.valueless_after_move());
+    MRDOCS_ASSERT(!rhs.valueless_after_move());
+    if (lhs->Kind == rhs->Kind)
     {
-        if (lhs->Kind == rhs->Kind)
-        {
-            return visit(*lhs, detail::VisitCompareFn<Node>(*rhs));
-        }
-        return lhs->Kind <=> rhs->Kind;
-    }
-    if (lhs.valueless_after_move() && rhs.valueless_after_move())
-    {
-        return std::strong_ordering::equal;
+        return visit(*lhs, detail::VisitCompareFn<Node>(*rhs));
     }
-    return lhs.valueless_after_move() ?
-               std::strong_ordering::less :
-               std::strong_ordering::greater;
+    return lhs->Kind <=> rhs->Kind;
 }
 
 Paragraph&
diff --git a/src/lib/Metadata/Name.cpp b/src/lib/Metadata/Name.cpp
index 76554248f..92bd96878 100644
--- a/src/lib/Metadata/Name.cpp
+++ b/src/lib/Metadata/Name.cpp
@@ -69,26 +69,17 @@ operator<=>(NameInfo const& other) const
 std::strong_ordering
 operator<=>(Polymorphic<NameInfo> const& lhs, Polymorphic<NameInfo> const& rhs)
 {
-    if (!lhs.valueless_after_move() && !rhs.valueless_after_move())
+    MRDOCS_ASSERT(!lhs.valueless_after_move());
+    MRDOCS_ASSERT(!rhs.valueless_after_move());
+    if (lhs->Kind == rhs->Kind)
     {
-        if (lhs->Kind == rhs->Kind)
+        if (lhs->isIdentifier())
         {
-            if (lhs->isIdentifier())
-            {
-                return *lhs <=> *rhs;
-            }
-            return visit(*lhs, detail::VisitCompareFn<NameInfo>(*rhs));
+            return *lhs <=> *rhs;
         }
-        return lhs->Kind <=> rhs->Kind;
-    }
-    if (lhs.valueless_after_move() &&
-        rhs.valueless_after_move())
-    {
-        return std::strong_ordering::equal;
+        return visit(*lhs, detail::VisitCompareFn<NameInfo>(*rhs));
     }
-    return lhs.valueless_after_move() ?
-               std::strong_ordering::less :
-               std::strong_ordering::greater;
+    return lhs->Kind <=> rhs->Kind;
 }
 
 static
diff --git a/src/lib/Metadata/Template.cpp b/src/lib/Metadata/Template.cpp
index d52c94cf0..b60e1b449 100644
--- a/src/lib/Metadata/Template.cpp
+++ b/src/lib/Metadata/Template.cpp
@@ -73,17 +73,13 @@ toString(
 std::strong_ordering
 operator<=>(Polymorphic<TParam> const& lhs, Polymorphic<TParam> const& rhs)
 {
-    if (!lhs.valueless_after_move() && !rhs.valueless_after_move())
+    MRDOCS_ASSERT(!lhs.valueless_after_move());
+    MRDOCS_ASSERT(!rhs.valueless_after_move());
+    if (lhs->Kind == rhs->Kind)
     {
-        if (lhs->Kind == rhs->Kind)
-        {
-            return visit(*lhs, detail::VisitCompareFn<TParam>(*rhs));
-        }
-        return lhs->Kind <=> rhs->Kind;
+        return visit(*lhs, detail::VisitCompareFn<TParam>(*rhs));
     }
-    return lhs.valueless_after_move() ?
-               std::strong_ordering::less :
-               std::strong_ordering::greater;
+    return lhs->Kind <=> rhs->Kind;
 }
 
 std::string_view
@@ -106,17 +102,13 @@ toString(
 std::strong_ordering
 operator<=>(Polymorphic<TArg> const& lhs, Polymorphic<TArg> const& rhs)
 {
-    if (!lhs.valueless_after_move() && !rhs.valueless_after_move())
+    MRDOCS_ASSERT(!lhs.valueless_after_move());
+    MRDOCS_ASSERT(!rhs.valueless_after_move());
+    if (lhs->Kind == rhs->Kind)
     {
-        if (lhs->Kind == rhs->Kind)
-        {
-            return visit(*lhs, detail::VisitCompareFn<TArg>(*rhs));
-        }
-        return lhs->Kind <=> rhs->Kind;
+        return visit(*lhs, detail::VisitCompareFn<TArg>(*rhs));
     }
-    return lhs.valueless_after_move() ?
-               std::strong_ordering::less :
-               std::strong_ordering::greater;
+    return lhs->Kind <=> rhs->Kind;
 }
 
 std::string
@@ -281,8 +273,8 @@ merge(TemplateInfo& I, TemplateInfo&& Other)
     std::size_t const pn = std::min(I.Params.size(), Other.Params.size());
     for (std::size_t i = 0; i < pn; ++i)
     {
-        if (I.Params[i].valueless_after_move() ||
-            I.Params[i]->Kind != Other.Params[i]->Kind)
+        MRDOCS_ASSERT(!I.Params[i].valueless_after_move());
+        if (I.Params[i]->Kind != Other.Params[i]->Kind)
         {
             I.Params[i] = std::move(Other.Params[i]);
         }
@@ -309,8 +301,8 @@ merge(TemplateInfo& I, TemplateInfo&& Other)
     std::size_t const an = std::min(I.Args.size(), Other.Args.size());
     for (std::size_t i = 0; i < an; ++i)
     {
-        if (I.Args[i].valueless_after_move() ||
-            I.Args[i]->Kind != Other.Args[i]->Kind)
+        MRDOCS_ASSERT(!I.Args[i].valueless_after_move());
+        if (I.Args[i]->Kind != Other.Args[i]->Kind)
         {
             I.Args[i] = std::move(Other.Args[i]);
         }
diff --git a/src/lib/Metadata/Type.cpp b/src/lib/Metadata/Type.cpp
index 6343caa36..8c2b2ae10 100644
--- a/src/lib/Metadata/Type.cpp
+++ b/src/lib/Metadata/Type.cpp
@@ -88,10 +88,8 @@ namedSymbol() const noexcept
         return SymbolID::invalid;
     }
     auto const* NT = dynamic_cast<NamedTypeInfo const*>(this);
-    if (NT->Name.valueless_after_move())
-    {
-        return SymbolID::invalid;
-    }
+    MRDOCS_ASSERT(NT);
+    MRDOCS_ASSERT(!NT->Name.valueless_after_move());
     return NT->Name->id;
 }
 
@@ -757,19 +755,15 @@ makeChar(FundamentalTypeKind& kind) noexcept
 std::strong_ordering
 operator<=>(Polymorphic<TypeInfo> const& lhs, Polymorphic<TypeInfo> const& rhs)
 {
-    if (!lhs.valueless_after_move() && !rhs.valueless_after_move())
+    MRDOCS_ASSERT(!lhs.valueless_after_move());
+    MRDOCS_ASSERT(!rhs.valueless_after_move());
+    auto& lhsRef = *lhs;
+    auto& rhsRef = *rhs;
+    if (lhsRef.Kind == rhsRef.Kind)
     {
-        auto& lhsRef = *lhs;
-        auto& rhsRef = *rhs;
-        if (lhsRef.Kind == rhsRef.Kind)
-        {
-            return visit(lhsRef, detail::VisitCompareFn<TypeInfo>(rhsRef));
-        }
-        return lhsRef.Kind <=> rhsRef.Kind;
+        return visit(lhsRef, detail::VisitCompareFn<TypeInfo>(rhsRef));
     }
-    return lhs.valueless_after_move() ?
-               std::strong_ordering::less :
-               std::strong_ordering::greater;
+    return lhsRef.Kind <=> rhsRef.Kind;
 }
 
 namespace {
@@ -849,10 +843,7 @@ requires std::same_as<std::remove_cvref_t<PolymorphicTypeInfoTy>, Polymorphic<Ty
 Ref
 innermostTypeImpl(PolymorphicTypeInfoTy&& TI) noexcept
 {
-    if (TI.valueless_after_move())
-    {
-        return TI;
-    }
+    MRDOCS_ASSERT(!TI.valueless_after_move());
     Optional<Ref> inner = innerTypeImpl(*TI);
     if (!inner)
     {
@@ -861,8 +852,8 @@ innermostTypeImpl(PolymorphicTypeInfoTy&& TI) noexcept
     while (inner)
     {
         Ref ref = *inner;
-        if (ref.valueless_after_move() ||
-            ref->isNamed())
+        MRDOCS_ASSERT(!ref.valueless_after_move());
+        if (ref->isNamed())
         {
             return ref;
         }

From b0555ce1e7e2909063efe029372c837d2a73b726 Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Fri, 26 Sep 2025 22:45:01 -0500
Subject: [PATCH 18/23] refactor: nullable_traits null() is only used as
 implementation detail

This ensures there are no disengaged versions of value-types
---
 include/mrdocs/Metadata/TArg.hpp              |  4 +-
 .../{NonTypeTArg.hpp => ConstantTArg.hpp}     |  4 +-
 include/mrdocs/Metadata/TArg/TemplateTArg.hpp |  2 +-
 src/lib/AST/ASTVisitor.cpp                    | 71 ++++++++++---------
 src/lib/AST/ASTVisitor.hpp                    |  7 +-
 src/lib/AST/ParseRef.cpp                      | 14 ++--
 src/lib/CorpusImpl.cpp                        |  4 +-
 src/test/ADT/Optional.cpp                     |  2 +-
 8 files changed, 61 insertions(+), 47 deletions(-)
 rename include/mrdocs/Metadata/TArg/{NonTypeTArg.hpp => ConstantTArg.hpp} (91%)

diff --git a/include/mrdocs/Metadata/TArg.hpp b/include/mrdocs/Metadata/TArg.hpp
index e19daabd4..986bb8e96 100644
--- a/include/mrdocs/Metadata/TArg.hpp
+++ b/include/mrdocs/Metadata/TArg.hpp
@@ -15,7 +15,7 @@
 #define MRDOCS_API_METADATA_TARG_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/TArg/NonTypeTArg.hpp>
+#include <mrdocs/Metadata/TArg/ConstantTArg.hpp>
 #include <mrdocs/Metadata/TArg/TArgBase.hpp>
 #include <mrdocs/Metadata/TArg/TemplateTArg.hpp>
 #include <mrdocs/Metadata/TArg/TypeTArg.hpp>
@@ -41,7 +41,7 @@ visit(
             std::forward<Args>(args)...);
     case TArgKind::Constant:
         return f(static_cast<add_cv_from_t<
-            TArgTy, NonTypeTArg>&>(A),
+            TArgTy, ConstantTArg>&>(A),
             std::forward<Args>(args)...);
     case TArgKind::Template:
         return f(static_cast<add_cv_from_t<
diff --git a/include/mrdocs/Metadata/TArg/NonTypeTArg.hpp b/include/mrdocs/Metadata/TArg/ConstantTArg.hpp
similarity index 91%
rename from include/mrdocs/Metadata/TArg/NonTypeTArg.hpp
rename to include/mrdocs/Metadata/TArg/ConstantTArg.hpp
index 39849cd93..3cbe375a7 100644
--- a/include/mrdocs/Metadata/TArg/NonTypeTArg.hpp
+++ b/include/mrdocs/Metadata/TArg/ConstantTArg.hpp
@@ -20,13 +20,13 @@
 
 namespace clang::mrdocs {
 
-struct NonTypeTArg final
+struct ConstantTArg final
     : TArgCommonBase<TArgKind::Constant>
 {
     /** Template argument expression. */
     ExprInfo Value;
 
-    auto operator<=>(NonTypeTArg const&) const = default;
+    auto operator<=>(ConstantTArg const&) const = default;
 };
 
 } // clang::mrdocs
diff --git a/include/mrdocs/Metadata/TArg/TemplateTArg.hpp b/include/mrdocs/Metadata/TArg/TemplateTArg.hpp
index 29db0c23d..494283629 100644
--- a/include/mrdocs/Metadata/TArg/TemplateTArg.hpp
+++ b/include/mrdocs/Metadata/TArg/TemplateTArg.hpp
@@ -15,7 +15,7 @@
 #define MRDOCS_API_METADATA_TARG_TEMPLATETARG_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/TArg/NonTypeTArg.hpp>
+#include <mrdocs/Metadata/TArg/ConstantTArg.hpp>
 #include <mrdocs/Metadata/TArg/TArgBase.hpp>
 #include <mrdocs/Metadata/TArg/TypeTArg.hpp>
 
diff --git a/src/lib/AST/ASTVisitor.cpp b/src/lib/AST/ASTVisitor.cpp
index 0b00c92d7..39a427d6d 100644
--- a/src/lib/AST/ASTVisitor.cpp
+++ b/src/lib/AST/ASTVisitor.cpp
@@ -178,10 +178,11 @@ traverse(UsingDirectiveDecl const* D)
     Info* NDI = findOrTraverse(ND);
     MRDOCS_CHECK_OR(NDI, nullptr);
 
-    auto res = toNameInfo(ND);
-    MRDOCS_ASSERT(!res.valueless_after_move());
-    MRDOCS_ASSERT(res->isIdentifier());
-    if (NameInfo NI = *res;
+    Optional<Polymorphic<NameInfo>> res = toNameInfo(ND);
+    MRDOCS_CHECK_OR(res, nullptr);
+    MRDOCS_ASSERT(!res->valueless_after_move());
+    MRDOCS_ASSERT((*res)->isIdentifier());
+    if (NameInfo NI = **res;
         !contains(PNI.UsingDirectives, NI))
     {
         PNI.UsingDirectives.push_back(std::move(NI));
@@ -1249,9 +1250,10 @@ populate(
 {
     NamedDecl const* Aliased = D->getAliasedNamespace();
     NestedNameSpecifier NNS = D->getQualifier();
-    Polymorphic<NameInfo> NI = toNameInfo(Aliased, {}, NNS);
-    MRDOCS_ASSERT(NI->isIdentifier());
-    I.AliasedSymbol = std::move(dynamic_cast<IdentifierNameInfo&>(*NI));
+    Optional<Polymorphic<NameInfo>> NI = toNameInfo(Aliased, {}, NNS);
+    MRDOCS_CHECK_OR(NI);
+    MRDOCS_ASSERT((*NI)->isIdentifier());
+    I.AliasedSymbol = std::move(dynamic_cast<IdentifierNameInfo&>(**NI));
 }
 
 void
@@ -1263,7 +1265,9 @@ populate(
     I.Class = UsingClass::Normal;
     DeclarationName const& Name = D->getNameInfo().getName();
     NestedNameSpecifier const& NNS = D->getQualifier();
-    I.IntroducedName = toNameInfo(Name, {}, NNS);
+    auto INI = toNameInfo(Name, {}, NNS);
+    MRDOCS_CHECK_OR(INI);
+    I.IntroducedName = *INI;
     for (UsingShadowDecl const* UDS: D->shadows())
     {
         ScopeExitRestore s(mode_, Dependency);
@@ -2054,14 +2058,15 @@ toTypeInfo(QualType const qt, TraversalMode const mode)
     return Builder.result();
 }
 
-Polymorphic<NameInfo>
-ASTVisitor::toNameInfo(NestedNameSpecifier NNS)
+Optional<Polymorphic<NameInfo>>
+ASTVisitor::
+toNameInfo(NestedNameSpecifier NNS)
 {
     MRDOCS_SYMBOL_TRACE(NNS, context_);
     ScopeExitRestore scope(mode_, Dependency);
     switch(NNS.getKind()) {
     case NestedNameSpecifier::Kind::Null:
-        return nullable_traits<Polymorphic<NameInfo>>::null();
+        return std::nullopt;
     case NestedNameSpecifier::Kind::Type: {
         const Type *T = NNS.getAsType();
         NameInfoBuilder Builder(*this);
@@ -2082,40 +2087,42 @@ ASTVisitor::toNameInfo(NestedNameSpecifier NNS)
     }
     case NestedNameSpecifier::Kind::Global:
     case NestedNameSpecifier::Kind::MicrosoftSuper:
-        // FIXME: Unimplemented.
-        return nullable_traits<Polymorphic<NameInfo>>::null();
+    default:
+        // Unimplemented
+        return std::nullopt;
     }
     MRDOCS_UNREACHABLE();
 }
 
 template <class TArgRange>
-Polymorphic<NameInfo>
+Optional<Polymorphic<NameInfo>>
 ASTVisitor::
-toNameInfo(DeclarationName const Name,
+toNameInfo(
+    DeclarationName const Name,
     Optional<TArgRange> TArgs,
     NestedNameSpecifier NNS)
 {
     if (Name.isEmpty())
     {
-        return nullable_traits<Polymorphic<NameInfo>>::null();
+        return std::nullopt;
     }
-    Polymorphic<NameInfo> I = nullable_traits<Polymorphic<NameInfo>>::null();
-    if(TArgs)
+    Optional<Polymorphic<NameInfo>> I = std::nullopt;
+    if (TArgs)
     {
         I = Polymorphic<NameInfo>(std::in_place_type<SpecializationNameInfo>);
-        populate(static_cast<SpecializationNameInfo &>(*I).TemplateArgs, *TArgs);
+        populate(dynamic_cast<SpecializationNameInfo &>(**I).TemplateArgs, *TArgs);
     }
     else
     {
         I = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
     }
-    I->Name = extractName(Name);
-    I->Prefix = toNameInfo(NNS);
+    (*I)->Name = extractName(Name);
+    (*I)->Prefix = toNameInfo(NNS);
     return I;
 }
 
 template <class TArgRange>
-Polymorphic<NameInfo>
+Optional<Polymorphic<NameInfo>>
 ASTVisitor::
 toNameInfo(
     Decl const* D,
@@ -2125,25 +2132,25 @@ toNameInfo(
     auto const* ND = dyn_cast_if_present<NamedDecl>(D);
     if (!ND)
     {
-        return nullable_traits<Polymorphic<NameInfo>>::null();
+        return std::nullopt;
     }
-    auto I = toNameInfo(
-        ND->getDeclName(), std::move(TArgs), NNS);
-    if (I.valueless_after_move())
+    Optional<Polymorphic<NameInfo>> I = toNameInfo(ND->getDeclName(), std::move(TArgs), NNS);
+    if (!I)
     {
-        return nullable_traits<Polymorphic<NameInfo>>::null();
+        return std::nullopt;
     }
+    MRDOCS_ASSERT(!I->valueless_after_move());
     ScopeExitRestore scope(mode_, Dependency);
     auto* ID = getInstantiatedFrom(D);
     if (Info const* info = findOrTraverse(const_cast<Decl*>(ID)))
     {
-        I->id = info->id;
+        (*I)->id = info->id;
     }
     return I;
 }
 
 template
-Polymorphic<NameInfo>
+Optional<Polymorphic<NameInfo>>
 ASTVisitor::
 toNameInfo<llvm::ArrayRef<clang::TemplateArgument>>(
     Decl const* D,
@@ -2233,7 +2240,7 @@ toTArg(TemplateArgument const& A)
     // expression
     case TemplateArgument::Expression:
     {
-        auto R = Polymorphic<TArg>(std::in_place_type<NonTypeTArg>);
+        auto R = Polymorphic<TArg>(std::in_place_type<ConstantTArg>);
         R->IsPackExpansion = A.isPackExpansion();
         // if this is a pack expansion, use the template argument
         // expansion pattern in place of the template argument pack
@@ -2242,7 +2249,7 @@ toTArg(TemplateArgument const& A)
             A.getPackExpansionPattern() : A;
 
         llvm::raw_string_ostream stream(
-            static_cast<NonTypeTArg &>(*R).Value.Written);
+            static_cast<ConstantTArg&>(*R).Value.Written);
         adjusted.print(context_.getPrintingPolicy(), stream, false);
 
         return Polymorphic<TArg>(R);
@@ -2250,7 +2257,7 @@ toTArg(TemplateArgument const& A)
     default:
         MRDOCS_UNREACHABLE();
     }
-    return nullable_traits<Polymorphic<TArg>>::null();
+    return Polymorphic<TArg>(std::in_place_type<ConstantTArg>);
 }
 
 
diff --git a/src/lib/AST/ASTVisitor.hpp b/src/lib/AST/ASTVisitor.hpp
index db292a40c..a7e83ffa7 100644
--- a/src/lib/AST/ASTVisitor.hpp
+++ b/src/lib/AST/ASTVisitor.hpp
@@ -771,17 +771,18 @@ class ASTVisitor
         return toTypeInfo(qt, TraversalMode::Dependency);
     }
 
-    Polymorphic<NameInfo> toNameInfo(NestedNameSpecifier NNS);
+    Optional<Polymorphic<NameInfo>>
+    toNameInfo(NestedNameSpecifier NNS);
 
     template <class TArgRange = ArrayRef<TemplateArgument>>
-    Polymorphic<NameInfo>
+    Optional<Polymorphic<NameInfo>>
     toNameInfo(
         DeclarationName Name,
         Optional<TArgRange> TArgs = std::nullopt,
         NestedNameSpecifier NNS = std::nullopt);
 
     template <class TArgRange = ArrayRef<TemplateArgument>>
-    Polymorphic<NameInfo>
+    Optional<Polymorphic<NameInfo>>
     toNameInfo(
         Decl const* D,
         Optional<TArgRange> TArgs = std::nullopt,
diff --git a/src/lib/AST/ParseRef.cpp b/src/lib/AST/ParseRef.cpp
index 7fd91069e..7208f65dd 100644
--- a/src/lib/AST/ParseRef.cpp
+++ b/src/lib/AST/ParseRef.cpp
@@ -677,8 +677,8 @@ class RefParser
             ptr_ = start;
             return false;
         }
-        dest = Polymorphic<TArg>(std::in_place_type<NonTypeTArg>);
-        static_cast<NonTypeTArg &>(*dest).Value.Written =
+        dest = Polymorphic<TArg>(std::in_place_type<ConstantTArg>);
+        static_cast<ConstantTArg&>(*dest).Value.Written =
             trim(std::string_view(exprStart, ptr_ - exprStart));
         return true;
     }
@@ -1942,7 +1942,10 @@ class RefParser
 
             // Change current type to array type
             ArrayTypeInfo ATI;
-            ATI.ElementType = std::move(*dest);
+            if (dest)
+            {
+                ATI.ElementType = std::move(*dest);
+            }
 
             // expr (optional)
             char const* exprStart = ptr_;
@@ -2029,7 +2032,10 @@ class RefParser
                 return false;
             }
             FunctionTypeInfo FTI;
-            FTI.ReturnType = std::move(*dest);
+            if (dest)
+            {
+                FTI.ReturnType = std::move(*dest);
+            }
             FTI.ParamTypes.insert(
                 FTI.ParamTypes.end(),
                 std::make_move_iterator(function.Params.begin()),
diff --git a/src/lib/CorpusImpl.cpp b/src/lib/CorpusImpl.cpp
index c0166852b..62ed70a44 100644
--- a/src/lib/CorpusImpl.cpp
+++ b/src/lib/CorpusImpl.cpp
@@ -368,8 +368,8 @@ isDecayedEqual(
     }
     if (lhs->isConstant())
     {
-        return trim(static_cast<const NonTypeTArg &>(*lhs).Value.Written) ==
-               trim(static_cast<const NonTypeTArg &>(*rhs).Value.Written);
+        return trim(static_cast<ConstantTArg const&>(*lhs).Value.Written) ==
+               trim(static_cast<ConstantTArg const&>(*rhs).Value.Written);
     }
     return false;
 }
diff --git a/src/test/ADT/Optional.cpp b/src/test/ADT/Optional.cpp
index 00e8496d3..8228f85f6 100644
--- a/src/test/ADT/Optional.cpp
+++ b/src/test/ADT/Optional.cpp
@@ -151,7 +151,7 @@ struct OptionalTest {
         Optional<Location> loc;
         BOOST_TEST(!loc.has_value()); // default has empty ShortPath
 
-        Location L{ "full.cpp", "short.cpp", "src.cpp", 10u, true };
+        Location L{ "full.cpp", "short.cpp", "src.cpp", 10u, 0, true };
         Optional<Location> a{ L };
         BOOST_TEST(a.has_value());
         BOOST_TEST(a->ShortPath == "short.cpp");

From d1c65df030a2167cb633a79968f46529921013a4 Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Fri, 26 Sep 2025 23:34:32 -0500
Subject: [PATCH 19/23] feat(lib): all base classes implement node kind inc
 pattern

This pattern defines a single source of truth for all derived types in a family of classes. Thus, conversions with the `as_` and `is_` functions are limited to valid derived classes.
---
 include/mrdocs/Metadata/Expression.hpp        | 17 ++++--
 include/mrdocs/Metadata/Info/Concept.hpp      |  2 +-
 include/mrdocs/Metadata/Info/Enum.hpp         |  2 +-
 include/mrdocs/Metadata/Info/EnumConstant.hpp |  2 +-
 include/mrdocs/Metadata/Info/Function.hpp     |  2 +-
 include/mrdocs/Metadata/Info/Guide.hpp        |  2 +-
 include/mrdocs/Metadata/Info/Namespace.hpp    |  2 +-
 .../mrdocs/Metadata/Info/NamespaceAlias.hpp   |  2 +-
 include/mrdocs/Metadata/Info/Overloads.hpp    |  2 +-
 include/mrdocs/Metadata/Info/Record.hpp       |  2 +-
 include/mrdocs/Metadata/Info/Typedef.hpp      |  2 +-
 include/mrdocs/Metadata/Info/Using.hpp        |  2 +-
 include/mrdocs/Metadata/Info/Variable.hpp     |  2 +-
 .../Metadata/Name/IdentifierNameInfo.hpp      |  2 +-
 include/mrdocs/Metadata/Name/NameBase.hpp     | 53 +++++++++++++++-
 .../mrdocs/Metadata/Name/NameInfoNodes.inc    | 19 ++++++
 include/mrdocs/Metadata/Name/NameKind.hpp     |  6 +-
 .../Metadata/Name/SpecializationNameInfo.hpp  |  3 +-
 include/mrdocs/Metadata/TArg/TArgBase.hpp     | 56 +++++++++++++++--
 .../mrdocs/Metadata/TArg/TArgInfoNodes.inc    | 20 ++++++
 include/mrdocs/Metadata/TArg/TArgKind.hpp     |  8 +--
 include/mrdocs/Metadata/TParam/TParamBase.hpp | 55 +++++++++++++++--
 .../Metadata/TParam/TParamInfoNodes.inc       | 20 ++++++
 include/mrdocs/Metadata/TParam/TParamKind.hpp |  8 +--
 include/mrdocs/Metadata/Type/TypeBase.hpp     | 61 +++++++++++++++----
 .../mrdocs/Metadata/Type/TypeInfoNodes.inc    | 35 +++++++++++
 include/mrdocs/Metadata/Type/TypeKind.hpp     | 20 +-----
 src/lib/AST/ASTVisitor.cpp                    | 22 +++----
 src/lib/AST/ParseRef.cpp                      | 35 ++++++-----
 src/lib/AST/TypeInfoBuilder.cpp               | 26 ++++----
 src/lib/CorpusImpl.cpp                        | 16 ++---
 src/lib/Gen/hbs/VisitorHelpers.cpp            |  4 +-
 .../Finalizers/BaseMembersFinalizer.cpp       |  9 ++-
 .../Metadata/Finalizers/DerivedFinalizer.cpp  |  2 +-
 .../Metadata/Finalizers/Javadoc/Function.hpp  |  2 +-
 .../Finalizers/OverloadsFinalizer.cpp         |  4 +-
 .../Finalizers/SortMembersFinalizer.cpp       |  6 +-
 src/lib/Metadata/Info/Typedef.cpp             |  2 +-
 src/lib/Metadata/Info/Variable.cpp            |  2 +-
 src/lib/Metadata/Name.cpp                     |  2 +-
 src/lib/Metadata/Type.cpp                     |  7 +--
 41 files changed, 397 insertions(+), 149 deletions(-)
 create mode 100644 include/mrdocs/Metadata/Name/NameInfoNodes.inc
 create mode 100644 include/mrdocs/Metadata/TArg/TArgInfoNodes.inc
 create mode 100644 include/mrdocs/Metadata/TParam/TParamInfoNodes.inc
 create mode 100644 include/mrdocs/Metadata/Type/TypeInfoNodes.inc

diff --git a/include/mrdocs/Metadata/Expression.hpp b/include/mrdocs/Metadata/Expression.hpp
index 76f4cf16a..7cd037229 100644
--- a/include/mrdocs/Metadata/Expression.hpp
+++ b/include/mrdocs/Metadata/Expression.hpp
@@ -25,6 +25,16 @@ struct ExprInfo
     /** The expression, as written */
     std::string Written;
 
+    ExprInfo& asExpr() noexcept
+    {
+        return *this;
+    }
+
+    ExprInfo const& asExpr() const noexcept
+    {
+        return *this;
+    }
+
     auto operator<=>(ExprInfo const&) const = default;
 };
 
@@ -49,8 +59,7 @@ struct ConstantExprInfo
 
     auto operator<=>(ConstantExprInfo const&) const = default;
 
-    static_assert(std::integral<type>,
-        "expression type must be integral");
+    static_assert(std::integral<type>, "expression type must be integral");
 };
 
 template <class T>
@@ -58,9 +67,7 @@ static void merge(
     ConstantExprInfo<T>& I,
     ConstantExprInfo<T>&& Other)
 {
-    merge(
-        dynamic_cast<ExprInfo&>(I),
-        dynamic_cast<ExprInfo&&>(Other));
+    merge(I.asExpr(), std::move(Other.asExpr()));
     if (!I.Value)
     {
         I.Value = std::move(Other.Value);
diff --git a/include/mrdocs/Metadata/Info/Concept.hpp b/include/mrdocs/Metadata/Info/Concept.hpp
index 48c97fb0f..ab4a75795 100644
--- a/include/mrdocs/Metadata/Info/Concept.hpp
+++ b/include/mrdocs/Metadata/Info/Concept.hpp
@@ -64,7 +64,7 @@ tag_invoke(
     ConceptInfo const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Info const&>(I), domCorpus);
+    tag_invoke(t, io, I.asInfo(), domCorpus);
     io.map("template", I.Template);
     if (!I.Constraint.Written.empty())
     {
diff --git a/include/mrdocs/Metadata/Info/Enum.hpp b/include/mrdocs/Metadata/Info/Enum.hpp
index 9affb60d4..486aa6cf7 100644
--- a/include/mrdocs/Metadata/Info/Enum.hpp
+++ b/include/mrdocs/Metadata/Info/Enum.hpp
@@ -87,7 +87,7 @@ tag_invoke(
     EnumInfo const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Info const&>(I), domCorpus);
+    tag_invoke(t, io, I.asInfo(), domCorpus);
     io.map("type", I.UnderlyingType);
     io.map("isScoped", I.Scoped);
     io.map("constants", dom::LazyArray(I.Constants, domCorpus));
diff --git a/include/mrdocs/Metadata/Info/EnumConstant.hpp b/include/mrdocs/Metadata/Info/EnumConstant.hpp
index 32cc6ce22..a9d01c005 100644
--- a/include/mrdocs/Metadata/Info/EnumConstant.hpp
+++ b/include/mrdocs/Metadata/Info/EnumConstant.hpp
@@ -53,7 +53,7 @@ tag_invoke(
     EnumConstantInfo const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Info const&>(I), domCorpus);
+    tag_invoke(t, io, I.asInfo(), domCorpus);
     if (!I.Initializer.Written.empty())
     {
         io.map("initializer", I.Initializer.Written);
diff --git a/include/mrdocs/Metadata/Info/Function.hpp b/include/mrdocs/Metadata/Info/Function.hpp
index 1d2963e79..2b991eadb 100644
--- a/include/mrdocs/Metadata/Info/Function.hpp
+++ b/include/mrdocs/Metadata/Info/Function.hpp
@@ -107,7 +107,7 @@ tag_invoke(
     FunctionInfo const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Info const&>(I), domCorpus);
+    tag_invoke(t, io, I.asInfo(), domCorpus);
     io.map("isVariadic", I.IsVariadic);
     io.map("isVirtual", I.IsVirtual);
     io.map("isVirtualAsWritten", I.IsVirtualAsWritten);
diff --git a/include/mrdocs/Metadata/Info/Guide.hpp b/include/mrdocs/Metadata/Info/Guide.hpp
index f1272ceab..2e3175928 100644
--- a/include/mrdocs/Metadata/Info/Guide.hpp
+++ b/include/mrdocs/Metadata/Info/Guide.hpp
@@ -75,7 +75,7 @@ tag_invoke(
     GuideInfo const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Info const&>(I), domCorpus);
+    tag_invoke(t, io, I.asInfo(), domCorpus);
     io.map("params", dom::LazyArray(I.Params, domCorpus));
     io.map("deduced", I.Deduced);
     io.map("template", I.Template);
diff --git a/include/mrdocs/Metadata/Info/Namespace.hpp b/include/mrdocs/Metadata/Info/Namespace.hpp
index 9e5f66e59..f15778c38 100644
--- a/include/mrdocs/Metadata/Info/Namespace.hpp
+++ b/include/mrdocs/Metadata/Info/Namespace.hpp
@@ -155,7 +155,7 @@ tag_invoke(
     NamespaceInfo const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Info const&>(I), domCorpus);
+    tag_invoke(t, io, I.asInfo(), domCorpus);
     io.map("isInline", I.IsInline);
     io.map("isAnonymous", I.IsAnonymous);
     io.map("members", I.Members);
diff --git a/include/mrdocs/Metadata/Info/NamespaceAlias.hpp b/include/mrdocs/Metadata/Info/NamespaceAlias.hpp
index ed17922fc..f0fd344e6 100644
--- a/include/mrdocs/Metadata/Info/NamespaceAlias.hpp
+++ b/include/mrdocs/Metadata/Info/NamespaceAlias.hpp
@@ -57,7 +57,7 @@ tag_invoke(
     NamespaceAliasInfo const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Info const&>(I), domCorpus);
+    tag_invoke(t, io, I.asInfo(), domCorpus);
     io.map("aliasedSymbol", I.AliasedSymbol);
 }
 
diff --git a/include/mrdocs/Metadata/Info/Overloads.hpp b/include/mrdocs/Metadata/Info/Overloads.hpp
index 252efe11f..a5828c104 100644
--- a/include/mrdocs/Metadata/Info/Overloads.hpp
+++ b/include/mrdocs/Metadata/Info/Overloads.hpp
@@ -79,7 +79,7 @@ tag_invoke(
     OverloadsInfo const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Info const&>(I), domCorpus);
+    tag_invoke(t, io, I.asInfo(), domCorpus);
     io.map("class", I.Class);
     io.map("overloadedOperator", I.OverloadedOperator);
     io.map("members", dom::LazyArray(I.Members, domCorpus));
diff --git a/include/mrdocs/Metadata/Info/Record.hpp b/include/mrdocs/Metadata/Info/Record.hpp
index ab3be600a..da259b506 100644
--- a/include/mrdocs/Metadata/Info/Record.hpp
+++ b/include/mrdocs/Metadata/Info/Record.hpp
@@ -114,7 +114,7 @@ tag_invoke(
     RecordInfo const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Info const&>(I), domCorpus);
+    tag_invoke(t, io, I.asInfo(), domCorpus);
     io.map("tag", I.KeyKind);
     io.map("defaultAccess", getDefaultAccessString(I.KeyKind));
     io.map("isFinal", I.IsFinal);
diff --git a/include/mrdocs/Metadata/Info/Typedef.hpp b/include/mrdocs/Metadata/Info/Typedef.hpp
index 06d4c367d..8b1669564 100644
--- a/include/mrdocs/Metadata/Info/Typedef.hpp
+++ b/include/mrdocs/Metadata/Info/Typedef.hpp
@@ -75,7 +75,7 @@ tag_invoke(
     TypedefInfo const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Info const&>(I), domCorpus);
+    tag_invoke(t, io, I.asInfo(), domCorpus);
     io.map("type", I.Type);
     io.map("template", I.Template);
     io.map("isUsing", I.IsUsing);
diff --git a/include/mrdocs/Metadata/Info/Using.hpp b/include/mrdocs/Metadata/Info/Using.hpp
index d2a2d01b6..77dad5dc0 100644
--- a/include/mrdocs/Metadata/Info/Using.hpp
+++ b/include/mrdocs/Metadata/Info/Using.hpp
@@ -155,7 +155,7 @@ tag_invoke(
     UsingInfo const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Info const&>(I), domCorpus);
+    tag_invoke(t, io, I.asInfo(), domCorpus);
     io.map("usingClass", I.Class);
     io.map("shadows", dom::LazyArray(I.ShadowDeclarations, domCorpus));
     io.map("qualifier", I.IntroducedName);
diff --git a/include/mrdocs/Metadata/Info/Variable.hpp b/include/mrdocs/Metadata/Info/Variable.hpp
index cfdfbee2f..bfcf71b50 100644
--- a/include/mrdocs/Metadata/Info/Variable.hpp
+++ b/include/mrdocs/Metadata/Info/Variable.hpp
@@ -106,7 +106,7 @@ tag_invoke(
     VariableInfo const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Info const&>(I), domCorpus);
+    tag_invoke(t, io, I.asInfo(), domCorpus);
     io.map("type", I.Type);
     io.map("template", I.Template);
     if (I.StorageClass != StorageClassKind::None)
diff --git a/include/mrdocs/Metadata/Name/IdentifierNameInfo.hpp b/include/mrdocs/Metadata/Name/IdentifierNameInfo.hpp
index 093bedd4f..f3b920f0c 100644
--- a/include/mrdocs/Metadata/Name/IdentifierNameInfo.hpp
+++ b/include/mrdocs/Metadata/Name/IdentifierNameInfo.hpp
@@ -39,7 +39,7 @@ struct IdentifierNameInfo final
     auto
     operator<=>(IdentifierNameInfo const& other) const
     {
-        return dynamic_cast<NameInfo const&>(*this) <=> dynamic_cast<NameInfo const&>(other);
+        return asName() <=> other.asName();
     }
 };
 
diff --git a/include/mrdocs/Metadata/Name/NameBase.hpp b/include/mrdocs/Metadata/Name/NameBase.hpp
index b0e43ddf9..48e75a409 100644
--- a/include/mrdocs/Metadata/Name/NameBase.hpp
+++ b/include/mrdocs/Metadata/Name/NameBase.hpp
@@ -18,6 +18,11 @@
 
 namespace clang::mrdocs {
 
+/* Forward declarations
+ */
+#define INFO(Type) struct Type##NameInfo;
+#include <mrdocs/Metadata/Name/NameInfoNodes.inc>
+
 /** Represents a name for a named `TypeInfo`
 
     When the `TypeInfo` is a named type, this class
@@ -62,9 +67,6 @@ struct NameInfo
      */
     Optional<Polymorphic<NameInfo>> Prefix = std::nullopt;
 
-    constexpr bool isIdentifier()     const noexcept { return Kind == NameKind::Identifier; }
-    constexpr bool isSpecialization() const noexcept { return Kind == NameKind::Specialization; }
-
     constexpr virtual ~NameInfo() = default;
 
     std::strong_ordering
@@ -76,6 +78,51 @@ struct NameInfo
         return std::is_eq(*this <=> other);
     }
 
+    constexpr NameInfo const& asName() const noexcept
+    {
+        return *this;
+    }
+
+    constexpr NameInfo& asName() noexcept
+    {
+        return *this;
+    }
+
+    #define INFO(Type) constexpr bool is##Type() const noexcept { \
+        return Kind == NameKind::Type; \
+    }
+#include <mrdocs/Metadata/Name/NameInfoNodes.inc>
+
+    #define INFO(Type) \
+    constexpr Type##NameInfo const& as##Type() const noexcept { \
+        if (Kind == NameKind::Type) \
+            return reinterpret_cast<Type##NameInfo const&>(*this); \
+        MRDOCS_UNREACHABLE(); \
+    }
+#include <mrdocs/Metadata/Name/NameInfoNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##NameInfo & as##Type() noexcept { \
+        if (Kind == NameKind::Type) \
+            return reinterpret_cast<Type##NameInfo&>(*this); \
+        MRDOCS_UNREACHABLE(); \
+    }
+#include <mrdocs/Metadata/Name/NameInfoNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##NameInfo const* as##Type##Ptr() const noexcept { \
+        if (Kind == NameKind::Type) { return reinterpret_cast<Type##NameInfo const*>(this); } \
+        return nullptr; \
+    }
+#include <mrdocs/Metadata/Name/NameInfoNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##NameInfo * as##Type##Ptr() noexcept { \
+        if (Kind == NameKind::Type) { return reinterpret_cast<Type##NameInfo *>(this); } \
+        return nullptr; \
+    }
+#include <mrdocs/Metadata/Name/NameInfoNodes.inc>
+
 protected:
     constexpr
     NameInfo() noexcept
diff --git a/include/mrdocs/Metadata/Name/NameInfoNodes.inc b/include/mrdocs/Metadata/Name/NameInfoNodes.inc
new file mode 100644
index 000000000..c8e6aa8a7
--- /dev/null
+++ b/include/mrdocs/Metadata/Name/NameInfoNodes.inc
@@ -0,0 +1,19 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef INFO
+#define INFO(PascalName)
+#endif
+
+INFO(Identifier)
+INFO(Specialization)
+
+#undef INFO
+
diff --git a/include/mrdocs/Metadata/Name/NameKind.hpp b/include/mrdocs/Metadata/Name/NameKind.hpp
index 716c73a32..5a0ca6f1a 100644
--- a/include/mrdocs/Metadata/Name/NameKind.hpp
+++ b/include/mrdocs/Metadata/Name/NameKind.hpp
@@ -18,10 +18,8 @@ namespace clang::mrdocs {
 
 enum class NameKind
 {
-    /// A simple identifier
-    Identifier = 1, // for bitstream
-    /// A template instantiation
-    Specialization
+#define INFO(Type) Type,
+#include <mrdocs/Metadata/Name/NameInfoNodes.inc>
 };
 
 MRDOCS_DECL
diff --git a/include/mrdocs/Metadata/Name/SpecializationNameInfo.hpp b/include/mrdocs/Metadata/Name/SpecializationNameInfo.hpp
index 9b1199254..5dcc3e78e 100644
--- a/include/mrdocs/Metadata/Name/SpecializationNameInfo.hpp
+++ b/include/mrdocs/Metadata/Name/SpecializationNameInfo.hpp
@@ -38,8 +38,7 @@ struct SpecializationNameInfo final
     auto
     operator<=>(SpecializationNameInfo const& other) const
     {
-        if (auto const r =
-            dynamic_cast<NameInfo const&>(*this) <=> dynamic_cast<NameInfo const&>(other);
+        if (auto const r = asName() <=> other.asName();
             !std::is_eq(r))
         {
             return r;
diff --git a/include/mrdocs/Metadata/TArg/TArgBase.hpp b/include/mrdocs/Metadata/TArg/TArgBase.hpp
index 5e877a92f..1f42fe682 100644
--- a/include/mrdocs/Metadata/TArg/TArgBase.hpp
+++ b/include/mrdocs/Metadata/TArg/TArgBase.hpp
@@ -19,22 +19,68 @@
 
 namespace clang::mrdocs {
 
+/* Forward declarations
+ */
+#define INFO(Type) struct Type##TArg;
+#include <mrdocs/Metadata/TArg/TArgInfoNodes.inc>
+
 struct TArg
 {
     /** The kind of template argument this is. */
-    TArgKind Kind;
+    TArgKind Kind = TArgKind::Type;
 
     /** Whether this template argument is a parameter expansion. */
     bool IsPackExpansion = false;
 
     constexpr virtual ~TArg() = default;
 
-    constexpr bool isType()     const noexcept { return Kind == TArgKind::Type; }
-    constexpr bool isConstant()  const noexcept { return Kind == TArgKind::Constant; }
-    constexpr bool isTemplate() const noexcept { return Kind == TArgKind::Template; }
-
     auto operator<=>(TArg const&) const = default;
 
+    constexpr TArg const& asTArg() const noexcept
+    {
+        return *this;
+    }
+
+    constexpr TArg& asTArg() noexcept
+    {
+        return *this;
+    }
+
+    #define INFO(Type) constexpr bool is##Type() const noexcept { \
+        return Kind == TArgKind::Type; \
+    }
+#include <mrdocs/Metadata/TArg/TArgInfoNodes.inc>
+
+    #define INFO(Type) \
+    constexpr Type##TArg const& as##Type() const noexcept { \
+        if (Kind == TArgKind::Type) \
+            return reinterpret_cast<Type##TArg const&>(*this); \
+        MRDOCS_UNREACHABLE(); \
+    }
+#include <mrdocs/Metadata/TArg/TArgInfoNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##TArg & as##Type() noexcept { \
+        if (Kind == TArgKind::Type) \
+            return reinterpret_cast<Type##TArg&>(*this); \
+        MRDOCS_UNREACHABLE(); \
+    }
+#include <mrdocs/Metadata/TArg/TArgInfoNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##TArg const* as##Type##Ptr() const noexcept { \
+        if (Kind == TArgKind::Type) { return reinterpret_cast<Type##TArg const*>(this); } \
+        return nullptr; \
+    }
+#include <mrdocs/Metadata/TArg/TArgInfoNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##TArg * as##Type##Ptr() noexcept { \
+        if (Kind == TArgKind::Type) { return reinterpret_cast<Type##TArg *>(this); } \
+        return nullptr; \
+    }
+#include <mrdocs/Metadata/TArg/TArgInfoNodes.inc>
+
 protected:
     constexpr TArg() noexcept = default;
 
diff --git a/include/mrdocs/Metadata/TArg/TArgInfoNodes.inc b/include/mrdocs/Metadata/TArg/TArgInfoNodes.inc
new file mode 100644
index 000000000..0cd860d31
--- /dev/null
+++ b/include/mrdocs/Metadata/TArg/TArgInfoNodes.inc
@@ -0,0 +1,20 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef INFO
+#define INFO(PascalName)
+#endif
+
+INFO(Type)
+INFO(Constant)
+INFO(Template)
+
+#undef INFO
+
diff --git a/include/mrdocs/Metadata/TArg/TArgKind.hpp b/include/mrdocs/Metadata/TArg/TArgKind.hpp
index 633753140..f1442fc81 100644
--- a/include/mrdocs/Metadata/TArg/TArgKind.hpp
+++ b/include/mrdocs/Metadata/TArg/TArgKind.hpp
@@ -24,12 +24,8 @@ namespace clang::mrdocs {
 */
 enum class TArgKind : int
 {
-    /// type arguments
-    Type = 1, // for bitstream
-    /// non-type arguments, i.e. expressions
-    Constant,
-    /// template template arguments, i.e. template names
-    Template
+    #define INFO(Type) Type,
+    #include <mrdocs/Metadata/TArg/TArgInfoNodes.inc>
 };
 
 MRDOCS_DECL
diff --git a/include/mrdocs/Metadata/TParam/TParamBase.hpp b/include/mrdocs/Metadata/TParam/TParamBase.hpp
index 6aa07bb11..baa7433b5 100644
--- a/include/mrdocs/Metadata/TParam/TParamBase.hpp
+++ b/include/mrdocs/Metadata/TParam/TParamBase.hpp
@@ -24,6 +24,11 @@ namespace clang::mrdocs {
 
 class DomCorpus;
 
+/* Forward declarations
+ */
+#define INFO(Type) struct Type##TParam;
+#include <mrdocs/Metadata/TParam/TParamInfoNodes.inc>
+
 struct TParam
 {
     /** The kind of template parameter this is
@@ -43,12 +48,54 @@ struct TParam
 
     constexpr virtual ~TParam() = default;
 
-    constexpr bool isType()     const noexcept { return Kind == TParamKind::Type; }
-    constexpr bool isConstant()  const noexcept { return Kind == TParamKind::Constant; }
-    constexpr bool isTemplate() const noexcept { return Kind == TParamKind::Template; }
-
     std::strong_ordering operator<=>(TParam const&) const;
 
+    constexpr TParam const& asTParam() const noexcept
+    {
+        return *this;
+    }
+
+    constexpr TParam& asTParam() noexcept
+    {
+        return *this;
+    }
+
+    #define INFO(Type) constexpr bool is##Type() const noexcept { \
+        return Kind == TParamKind::Type; \
+    }
+#include <mrdocs/Metadata/TParam/TParamInfoNodes.inc>
+
+    #define INFO(Type) \
+    constexpr Type##TParam const& as##Type() const noexcept { \
+        if (Kind == TParamKind::Type) \
+            return reinterpret_cast<Type##TParam const&>(*this); \
+        MRDOCS_UNREACHABLE(); \
+    }
+#include <mrdocs/Metadata/TParam/TParamInfoNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##TParam & as##Type() noexcept { \
+        if (Kind == TParamKind::Type) \
+            return reinterpret_cast<Type##TParam&>(*this); \
+        MRDOCS_UNREACHABLE(); \
+    }
+#include <mrdocs/Metadata/TParam/TParamInfoNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##TParam const* as##Type##Ptr() const noexcept { \
+        if (Kind == TParamKind::Type) { return reinterpret_cast<Type##TParam const*>(this); } \
+        return nullptr; \
+    }
+#include <mrdocs/Metadata/TParam/TParamInfoNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##TParam * as##Type##Ptr() noexcept { \
+        if (Kind == TParamKind::Type) { return reinterpret_cast<Type##TParam *>(this); } \
+        return nullptr; \
+    }
+#include <mrdocs/Metadata/TParam/TParamInfoNodes.inc>
+
+
 protected:
     constexpr
     TParam() noexcept = default;
diff --git a/include/mrdocs/Metadata/TParam/TParamInfoNodes.inc b/include/mrdocs/Metadata/TParam/TParamInfoNodes.inc
new file mode 100644
index 000000000..0cd860d31
--- /dev/null
+++ b/include/mrdocs/Metadata/TParam/TParamInfoNodes.inc
@@ -0,0 +1,20 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef INFO
+#define INFO(PascalName)
+#endif
+
+INFO(Type)
+INFO(Constant)
+INFO(Template)
+
+#undef INFO
+
diff --git a/include/mrdocs/Metadata/TParam/TParamKind.hpp b/include/mrdocs/Metadata/TParam/TParamKind.hpp
index ae4467da9..9e3fe4f98 100644
--- a/include/mrdocs/Metadata/TParam/TParamKind.hpp
+++ b/include/mrdocs/Metadata/TParam/TParamKind.hpp
@@ -21,12 +21,8 @@ namespace clang::mrdocs {
 
 enum class TParamKind : int
 {
-    /// Template type parameter, e.g. "typename T" or "class T"
-    Type = 1, // for bitstream
-    /// Template non-type parameter, e.g. "int N" or "auto N"
-    Constant,
-    /// Template-template parameter, e.g. "template<typename> typename T"
-    Template
+    #define INFO(Type) Type,
+    #include <mrdocs/Metadata/TParam/TParamInfoNodes.inc>
 };
 
 MRDOCS_DECL
diff --git a/include/mrdocs/Metadata/Type/TypeBase.hpp b/include/mrdocs/Metadata/Type/TypeBase.hpp
index 80fff732f..769b80902 100644
--- a/include/mrdocs/Metadata/Type/TypeBase.hpp
+++ b/include/mrdocs/Metadata/Type/TypeBase.hpp
@@ -20,6 +20,11 @@
 
 namespace clang::mrdocs {
 
+/* Forward declarations
+ */
+#define INFO(Type) struct Type##TypeInfo;
+#include <mrdocs/Metadata/Type/TypeInfoNodes.inc>
+
 /** A possibly qualified type.
 
     This class represents a type that may have
@@ -59,17 +64,6 @@ struct TypeInfo
      */
     std::vector<ExprInfo> Constraints;
 
-
-    constexpr bool isNamed()           const noexcept { return Kind == TypeKind::Named; }
-    constexpr bool isDecltype()        const noexcept { return Kind == TypeKind::Decltype; }
-    constexpr bool isAuto()            const noexcept { return Kind == TypeKind::Auto; }
-    constexpr bool isLValueReference() const noexcept { return Kind == TypeKind::LValueReference; }
-    constexpr bool isRValueReference() const noexcept { return Kind == TypeKind::RValueReference; }
-    constexpr bool isPointer()         const noexcept { return Kind == TypeKind::Pointer; }
-    constexpr bool isMemberPointer()   const noexcept { return Kind == TypeKind::MemberPointer; }
-    constexpr bool isArray()           const noexcept { return Kind == TypeKind::Array; }
-    constexpr bool isFunction()        const noexcept { return Kind == TypeKind::Function; }
-
     /** Return the symbol named by this type.
     */
     SymbolID
@@ -77,6 +71,51 @@ struct TypeInfo
 
     auto operator<=>(TypeInfo const&) const = default;
 
+    constexpr TypeInfo const& asType() const noexcept
+    {
+        return *this;
+    }
+
+    constexpr TypeInfo& asType() noexcept
+    {
+        return *this;
+    }
+
+    #define INFO(Type) constexpr bool is##Type() const noexcept { \
+        return Kind == TypeKind::Type; \
+    }
+#include <mrdocs/Metadata/Type/TypeInfoNodes.inc>
+
+    #define INFO(Type) \
+    constexpr Type##TypeInfo const& as##Type() const noexcept { \
+        if (Kind == TypeKind::Type) \
+            return reinterpret_cast<Type##TypeInfo const&>(*this); \
+        MRDOCS_UNREACHABLE(); \
+    }
+#include <mrdocs/Metadata/Type/TypeInfoNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##TypeInfo & as##Type() noexcept { \
+        if (Kind == TypeKind::Type) \
+            return reinterpret_cast<Type##TypeInfo&>(*this); \
+        MRDOCS_UNREACHABLE(); \
+    }
+#include <mrdocs/Metadata/Type/TypeInfoNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##TypeInfo const* as##Type##Ptr() const noexcept { \
+        if (Kind == TypeKind::Type) { return reinterpret_cast<Type##TypeInfo const*>(this); } \
+        return nullptr; \
+    }
+#include <mrdocs/Metadata/Type/TypeInfoNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##TypeInfo * as##Type##Ptr() noexcept { \
+        if (Kind == TypeKind::Type) { return reinterpret_cast<Type##TypeInfo *>(this); } \
+        return nullptr; \
+    }
+#include <mrdocs/Metadata/Type/TypeInfoNodes.inc>
+
 protected:
     constexpr virtual ~TypeInfo() = default;
 
diff --git a/include/mrdocs/Metadata/Type/TypeInfoNodes.inc b/include/mrdocs/Metadata/Type/TypeInfoNodes.inc
new file mode 100644
index 000000000..9b6cfb368
--- /dev/null
+++ b/include/mrdocs/Metadata/Type/TypeInfoNodes.inc
@@ -0,0 +1,35 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef INFO
+#define INFO(PascalName)
+#endif
+
+/// A Named type
+INFO(Named)
+/// A decltype type
+INFO(Decltype)
+/// An auto type
+INFO(Auto)
+/// An LValueReference type
+INFO(LValueReference)
+/// An RValueReference type
+INFO(RValueReference)
+/// A Pointer type
+INFO(Pointer)
+/// A MemberPointer type
+INFO(MemberPointer)
+/// An Array type
+INFO(Array)
+/// A Function type
+INFO(Function)
+
+#undef INFO
+
diff --git a/include/mrdocs/Metadata/Type/TypeKind.hpp b/include/mrdocs/Metadata/Type/TypeKind.hpp
index 4ec6bd8fd..07f92fcfd 100644
--- a/include/mrdocs/Metadata/Type/TypeKind.hpp
+++ b/include/mrdocs/Metadata/Type/TypeKind.hpp
@@ -18,24 +18,8 @@ namespace clang::mrdocs {
 
 enum class TypeKind
 {
-    /// A Named type
-    Named = 1, // for bitstream
-    /// A decltype type
-    Decltype,
-    /// An auto type
-    Auto,
-    /// An LValueReference type
-    LValueReference,
-    /// An RValueReference type
-    RValueReference,
-    /// A Pointer type
-    Pointer,
-    /// A MemberPointer type
-    MemberPointer,
-    /// An Array type
-    Array,
-    /// A Function type
-    Function,
+    #define INFO(Type) Type,
+    #include <mrdocs/Metadata/Type/TypeInfoNodes.inc>
 };
 
 MRDOCS_DECL
diff --git a/src/lib/AST/ASTVisitor.cpp b/src/lib/AST/ASTVisitor.cpp
index 39a427d6d..26c8062e0 100644
--- a/src/lib/AST/ASTVisitor.cpp
+++ b/src/lib/AST/ASTVisitor.cpp
@@ -704,10 +704,10 @@ populate(
                     auto& inner = innermostType(BaseType);
                     MRDOCS_CHECK_OR(inner);
                     MRDOCS_CHECK_OR(inner->isNamed());
-                    auto& NTI = dynamic_cast<NamedTypeInfo&>(*inner);
+                    auto& NTI = inner->asNamed();
                     MRDOCS_CHECK_OR(NTI.Name);
                     MRDOCS_CHECK_OR(NTI.Name->isSpecialization());
-                    auto& SNI = dynamic_cast<SpecializationNameInfo&>(*NTI.Name);
+                    auto& SNI = NTI.Name->asSpecialization();
                     SNI.specializationID = SI->id;
                 }();
             }
@@ -1191,7 +1191,7 @@ populate(
     {
         I.Type = toTypeInfo(TSI->getType());
         MRDOCS_CHECK_OR((*I.Type)->isNamed());
-        auto const& NTI = dynamic_cast<NamedTypeInfo&>(**I.Type);
+        auto const& NTI = (*I.Type)->asNamed();
         MRDOCS_CHECK_OR(NTI.Name);
         I.id = NTI.Name->id;
     }
@@ -1253,7 +1253,7 @@ populate(
     Optional<Polymorphic<NameInfo>> NI = toNameInfo(Aliased, {}, NNS);
     MRDOCS_CHECK_OR(NI);
     MRDOCS_ASSERT((*NI)->isIdentifier());
-    I.AliasedSymbol = std::move(dynamic_cast<IdentifierNameInfo&>(**NI));
+    I.AliasedSymbol = std::move((**NI).asIdentifier());
 }
 
 void
@@ -1346,7 +1346,7 @@ populate(
         {
             auto& arg = *it;
             MRDOCS_ASSERT(!arg.valueless_after_move());
-            if (auto* T = dynamic_cast<TypeTArg*>(arg.operator->()))
+            if (auto* T = (arg.operator->())->asTypePtr())
             {
                 MRDOCS_ASSERT(!T->Type.valueless_after_move());
                 if (!T->Type->Constraints.empty())
@@ -1508,7 +1508,7 @@ populate(
             {
                 I = Polymorphic<TParam>(std::in_place_type<TypeTParam>);
             }
-            auto* R = dynamic_cast<TypeTParam*>(I.operator->());
+            auto* R = (I.operator->())->asTypePtr();
             if (P->wasDeclaredWithTypename())
             {
                 R->KeyKind = TParamKeyKind::Typename;
@@ -1537,7 +1537,7 @@ populate(
             {
                 I = Polymorphic<TParam>(std::in_place_type<ConstantTParam>);
             }
-            auto* R = dynamic_cast<ConstantTParam*>(I.operator->());
+            auto* R = (I.operator->())->asConstantPtr();
             R->Type = toTypeInfo(P->getType());
             if (P->hasDefaultArgument() && !R->Default)
             {
@@ -1556,7 +1556,7 @@ populate(
             MRDOCS_CHECK_OR(TTPD);
             TemplateParameterList const* TPL = TTPD->getTemplateParameters();
             MRDOCS_CHECK_OR(TPL);
-            auto* Result = dynamic_cast<TemplateTParam*>(I.operator->());
+            auto* Result = (I.operator->())->asTemplatePtr();
             Result->Params.reserve(TPL->size());
             for (std::size_t i = 0; i < TPL->size(); ++i)
             {
@@ -1639,7 +1639,7 @@ populate(
 
             if (param->isConstant())
             {
-                auto& T = dynamic_cast<ConstantTParam&>(*param);
+                auto& T = (*param).asConstant();
                 MRDOCS_ASSERT(!T.Type.valueless_after_move());
                 if (!T.Type->Constraints.empty())
                 {
@@ -1659,7 +1659,7 @@ populate(
             if (param->Default &&
                 (*param->Default)->isType())
             {
-                if (auto const* T = dynamic_cast<TypeTArg*>((*param->Default).operator->()))
+                if (auto const* T = ((*param->Default).operator->())->asTypePtr())
                 {
                     MRDOCS_ASSERT(!T->Type.valueless_after_move());
                     if (!T->Type->Constraints.empty())
@@ -2110,7 +2110,7 @@ toNameInfo(
     if (TArgs)
     {
         I = Polymorphic<NameInfo>(std::in_place_type<SpecializationNameInfo>);
-        populate(dynamic_cast<SpecializationNameInfo &>(**I).TemplateArgs, *TArgs);
+        populate((**I).asSpecialization().TemplateArgs, *TArgs);
     }
     else
     {
diff --git a/src/lib/AST/ParseRef.cpp b/src/lib/AST/ParseRef.cpp
index 7208f65dd..5d8a30cf1 100644
--- a/src/lib/AST/ParseRef.cpp
+++ b/src/lib/AST/ParseRef.cpp
@@ -655,7 +655,7 @@ class RefParser
         {
             MRDOCS_ASSERT(type);
             dest = Polymorphic<TArg>(std::in_place_type<TypeTArg>);
-            dynamic_cast<TypeTArg &>(*dest).Type = std::move(*type);
+            dest->asType().Type = std::move(*type);
             return true;
         }
 
@@ -835,11 +835,11 @@ class RefParser
         // https://en.cppreference.com/w/cpp/language/function#Function_type
         if (curParam->isArray())
         {
-            ArrayTypeInfo PrevParamType = dynamic_cast<ArrayTypeInfo &>(*curParam);
+            ArrayTypeInfo PrevParamType = curParam->asArray();
             curParam = Polymorphic<TypeInfo>(std::in_place_type<PointerTypeInfo>);
-            auto& curAsPointerType = dynamic_cast<PointerTypeInfo &>(*curParam);
+            auto& curAsPointerType = curParam->asPointer();
             curAsPointerType.PointeeType = std::move(PrevParamType.ElementType);
-            auto& PrevAsBase = dynamic_cast<TypeInfo&>(PrevParamType);
+            auto& PrevAsBase = PrevParamType.asType();
             *curParam = std::move(PrevAsBase);
         }
 
@@ -1014,7 +1014,7 @@ class RefParser
             if (!dest)
             {
                 dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-                auto &NTI = dynamic_cast<NamedTypeInfo &>(**dest);
+                auto &NTI = (*dest)->asNamed();
                 NTI.Name->Name = "int";
                 NTI.FundamentalType = FundamentalTypeKind::Int;
             }
@@ -1027,7 +1027,7 @@ class RefParser
               return false;
             }
             // Check if the type is "int" or "char"
-            auto& namedParam = dynamic_cast<NamedTypeInfo&>(**dest);
+            auto& namedParam = (*dest)->asNamed();
             if (!namedParam.FundamentalType)
             {
               setError(std::format(
@@ -1057,7 +1057,7 @@ class RefParser
             if (!dest)
             {
                 dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-                auto &NTI = dynamic_cast<NamedTypeInfo &>(**dest);
+                auto &NTI = (*dest)->asNamed();
                 NTI.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
                 NTI.Name->Name = "int";
                 NTI.FundamentalType = FundamentalTypeKind::Int;
@@ -1071,7 +1071,7 @@ class RefParser
             }
 
             // Check if the type is "int"
-            auto& namedParam = dynamic_cast<NamedTypeInfo&>(**dest);
+            auto& namedParam = (*dest)->asNamed();
             if (!namedParam.FundamentalType)
             {
                 setError(start, "expected fundamental type for 'short' specifier");
@@ -1096,7 +1096,7 @@ class RefParser
             if (!dest)
             {
                 dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-                auto &NTI = dynamic_cast<NamedTypeInfo &>(**dest);
+                auto &NTI = (*dest)->asNamed();
                 NTI.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
                 NTI.Name->Name = "int";
                 NTI.FundamentalType = FundamentalTypeKind::Int;
@@ -1108,7 +1108,7 @@ class RefParser
                 ptr_ = start;
                 return false;
             }
-            auto& namedParam = dynamic_cast<NamedTypeInfo&>(**dest);
+            auto& namedParam = (*dest)->asNamed();
             if (!namedParam.FundamentalType)
             {
                 setError(start, "expected fundamental type for 'long' specifier");
@@ -1211,7 +1211,7 @@ class RefParser
             dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
             MRDOCS_ASSERT(dest);
             MRDOCS_ASSERT(!dest->valueless_after_move());
-            auto &NTI = dynamic_cast<NamedTypeInfo &>(**dest);
+            auto &NTI = (*dest)->asNamed();
             MRDOCS_ASSERT(!NTI.Name.valueless_after_move());
             NTI.Name->Name = std::string_view(start, ptr_ - start);
             if (FundamentalTypeKind k;
@@ -1281,8 +1281,7 @@ class RefParser
                         std::in_place_type<DecltypeTypeInfo>);
                     MRDOCS_ASSERT(dest);
                     MRDOCS_ASSERT(!dest->valueless_after_move());
-                    dynamic_cast<DecltypeTypeInfo&>(**dest).Operand.Written
-                        = expr;
+                    (*dest)->asDecltype().Operand.Written = expr;
                     return true;
                 }
                 setError("expected expression in decltype");
@@ -1411,11 +1410,11 @@ class RefParser
             // Populate dest
             auto const idStr = std::string_view(idStart, ptr_ - idStart);
             Optional<Polymorphic<NameInfo>> ParentName
-                = dest ? Optional<Polymorphic<NameInfo>>(
-                             dynamic_cast<NamedTypeInfo*>(&**dest)->Name) :
-                         Optional<Polymorphic<NameInfo>>(std::nullopt);
+                = dest ?
+                     Optional<Polymorphic<NameInfo>>((*dest)->asNamed().Name) :
+                     Optional<Polymorphic<NameInfo>>(std::nullopt);
             dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
-            auto &NTI = dynamic_cast<NamedTypeInfo &>(**dest);
+            auto &NTI = (*dest)->asNamed();
             NTI.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
             NTI.Name->Name = idStr;
             NTI.Name->Prefix = std::move(ParentName);
@@ -1449,7 +1448,7 @@ class RefParser
                     return false;
                 }
                 // Replace the nameinfo with a nameinfo with args
-                auto& namedParam = dynamic_cast<NamedTypeInfo&>(**dest);
+                auto& namedParam = (*dest)->asNamed();
                 SpecializationNameInfo SNI;
                 SNI.Name = std::move(namedParam.Name->Name);
                 SNI.Prefix = std::move(namedParam.Name->Prefix);
diff --git a/src/lib/AST/TypeInfoBuilder.cpp b/src/lib/AST/TypeInfoBuilder.cpp
index cfb636916..50ad67e75 100644
--- a/src/lib/AST/TypeInfoBuilder.cpp
+++ b/src/lib/AST/TypeInfoBuilder.cpp
@@ -21,7 +21,7 @@ buildPointer(PointerType const*, unsigned quals)
 {
     MRDOCS_ASSERT(Inner);
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<PointerTypeInfo>);
-    auto &I = dynamic_cast<PointerTypeInfo &>(**Inner);
+    auto &I = (*Inner)->asPointer();
     I.IsConst = quals & Qualifiers::Const;
     I.IsVolatile = quals & Qualifiers::Volatile;
     Inner = &I.PointeeType;
@@ -33,7 +33,7 @@ buildLValueReference(LValueReferenceType const*)
 {
     MRDOCS_ASSERT(Inner);
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<LValueReferenceTypeInfo>);
-    Inner = &dynamic_cast<LValueReferenceTypeInfo &>(**Inner).PointeeType;
+    Inner = &(*Inner)->asLValueReference().PointeeType;
 }
 
 void
@@ -42,7 +42,7 @@ buildRValueReference(RValueReferenceType const*)
 {
     MRDOCS_ASSERT(Inner);
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<RValueReferenceTypeInfo>);
-    Inner = &dynamic_cast<RValueReferenceTypeInfo &>(**Inner).PointeeType;
+    Inner = &(*Inner)->asRValueReference().PointeeType;
 }
 
 void
@@ -53,7 +53,7 @@ buildMemberPointer(
 {
     MRDOCS_ASSERT(Inner);
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<MemberPointerTypeInfo>);
-    auto &I = dynamic_cast<MemberPointerTypeInfo &>(**Inner);
+    auto &I = (*Inner)->asMemberPointer();
     I.IsConst = quals & Qualifiers::Const;
     I.IsVolatile = quals & Qualifiers::Volatile;
     // do not set NNS because the parent type is *not*
@@ -69,7 +69,7 @@ buildArray(ArrayType const* T)
 {
     MRDOCS_ASSERT(Inner);
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<ArrayTypeInfo>);
-    auto &I = dynamic_cast<ArrayTypeInfo &>(**Inner);
+    auto &I = (*Inner)->asArray();
     if (auto* CAT = dyn_cast<ConstantArrayType>(T))
     {
         getASTVisitor().populate(I.Bounds, CAT->getSizeExpr(), CAT->getSize());
@@ -88,7 +88,7 @@ populate(FunctionType const* T)
     auto* FPT = cast<FunctionProtoType>(T);
     MRDOCS_ASSERT(Inner);
     *Inner = Polymorphic<TypeInfo>(std::in_place_type<FunctionTypeInfo>);
-    auto &I = dynamic_cast<FunctionTypeInfo &>(**Inner);
+    auto &I = (*Inner)->asFunction();
     for (QualType const PT : FPT->getParamTypes())
     {
         I.ParamTypes.emplace_back(getASTVisitor().toTypeInfo(PT));
@@ -115,7 +115,7 @@ buildDecltype(
     (*Inner)->Constraints = this->Constraints;
     (*Inner)->IsPackExpansion = pack;
 
-    auto &I = dynamic_cast<DecltypeTypeInfo &>(**Inner);
+    auto &I = (*Inner)->asDecltype();
     getASTVisitor().populate(I.Operand, T->getUnderlyingExpr());
     I.IsConst = quals & Qualifiers::Const;
     I.IsVolatile = quals & Qualifiers::Volatile;
@@ -136,7 +136,7 @@ buildAuto(
     (*Inner)->Constraints = this->Constraints;
     (*Inner)->IsPackExpansion = pack;
 
-    auto &I = dynamic_cast<AutoTypeInfo &>(**Inner);
+    auto &I = (*Inner)->asAuto();
     I.IsConst = quals & Qualifiers::Const;
     I.IsVolatile = quals & Qualifiers::Volatile;
     I.Keyword = toAutoKind(T->getKeyword());
@@ -170,7 +170,7 @@ buildTerminal(
     (*Inner)->IsPackExpansion = pack;
     (*Inner)->Constraints = this->Constraints;
 
-    auto &TI = dynamic_cast<NamedTypeInfo &>(**Inner);
+    auto &TI = (*Inner)->asNamed();
     TI.IsConst = quals & Qualifiers::Const;
     TI.IsVolatile = quals & Qualifiers::Volatile;
     TI.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
@@ -198,14 +198,14 @@ buildTerminal(
     (*Inner)->IsPackExpansion = pack;
     (*Inner)->Constraints = this->Constraints;
 
-    auto &I = dynamic_cast<NamedTypeInfo &>(**Inner);
+    auto &I = (*Inner)->asNamed();
     I.IsConst = quals & Qualifiers::Const;
     I.IsVolatile = quals & Qualifiers::Volatile;
 
     if (TArgs)
     {
         I.Name = Polymorphic<NameInfo>(std::in_place_type<SpecializationNameInfo>);
-        auto &Name = dynamic_cast<SpecializationNameInfo &>(*I.Name);
+        auto &Name = I.Name->asSpecialization();
         if (II)
         {
             Name.Name = II->getName();
@@ -250,7 +250,7 @@ buildTerminal(
     (*Inner)->IsPackExpansion = pack;
     (*Inner)->Constraints = this->Constraints;
 
-    auto &TI = dynamic_cast<NamedTypeInfo &>(**Inner);
+    auto &TI = (*Inner)->asNamed();
     TI.IsConst = quals & Qualifiers::Const;
     TI.IsVolatile = quals & Qualifiers::Volatile;
 
@@ -279,7 +279,7 @@ buildTerminal(
     {
         TI.Name =
             Polymorphic<NameInfo>(std::in_place_type<SpecializationNameInfo>);
-        auto &Name = dynamic_cast<SpecializationNameInfo &>(*TI.Name);
+        auto &Name = TI.Name->asSpecialization();
         populateNameInfo(Name, D);
         getASTVisitor().populate(Name.TemplateArgs, *TArgs);
     }
diff --git a/src/lib/CorpusImpl.cpp b/src/lib/CorpusImpl.cpp
index 62ed70a44..db42ac187 100644
--- a/src/lib/CorpusImpl.cpp
+++ b/src/lib/CorpusImpl.cpp
@@ -249,19 +249,19 @@ isDecayedEqualImpl(
     {
         return
             qualifiedNameCompare(
-                dynamic_cast<NamedTypeInfo const&>(*lhs).Name,
-                dynamic_cast<NamedTypeInfo const&>(*rhs).Name,
+                lhs->asNamed().Name,
+                rhs->asNamed().Name,
                 context, corpus);
     }
     case TypeKind::Decltype:
     {
-        return dynamic_cast<DecltypeTypeInfo const&>(*lhs).Operand ==
-               dynamic_cast<DecltypeTypeInfo const&>(*rhs).Operand;
+        return lhs->asDecltype().Operand ==
+               rhs->asDecltype().Operand;
     }
     case TypeKind::Auto:
     {
-        auto const& lhsAuto = dynamic_cast<AutoTypeInfo const&>(*lhs);
-        auto const& rhsAuto = dynamic_cast<AutoTypeInfo const&>(*rhs);
+        auto const& lhsAuto = lhs->asAuto();
+        auto const& rhsAuto = rhs->asAuto();
         return lhsAuto.Keyword == rhsAuto.Keyword &&
                lhsAuto.Constraint == rhsAuto.Constraint;
     }
@@ -269,8 +269,8 @@ isDecayedEqualImpl(
     {
         return
             isDecayedEqualImpl<true>(
-                dynamic_cast<LValueReferenceTypeInfo const&>(*lhs).PointeeType,
-                dynamic_cast<LValueReferenceTypeInfo const&>(*rhs).PointeeType,
+                lhs->asLValueReference().PointeeType,
+                rhs->asLValueReference().PointeeType,
                 context, corpus);
     }
     case TypeKind::RValueReference:
diff --git a/src/lib/Gen/hbs/VisitorHelpers.cpp b/src/lib/Gen/hbs/VisitorHelpers.cpp
index dd0de2287..2f64d5e73 100644
--- a/src/lib/Gen/hbs/VisitorHelpers.cpp
+++ b/src/lib/Gen/hbs/VisitorHelpers.cpp
@@ -54,7 +54,7 @@ resolveTypedef(Corpus const& c, Info const& I)
         MRDOCS_ASSERT(!TI.Type.valueless_after_move());
         TypeInfo const& T = *TI.Type;
         MRDOCS_CHECK_OR(T.Kind == TypeKind::Named, &I);
-        auto const& NT = dynamic_cast<NamedTypeInfo const&>(T);
+        auto const& NT = T.asNamed();
         MRDOCS_CHECK_OR(NT.Name, &I);
         Info const* resolved = c.find(NT.Name->id);
         MRDOCS_CHECK_OR(resolved, &I);
@@ -174,7 +174,7 @@ findResolvedPrimarySiblingWithUrl(Corpus const& c, Info const& I)
             MRDOCS_ASSERT(!TOpt.valueless_after_move());
             TypeInfo const& T = *TOpt;
             MRDOCS_CHECK_OR(T.Kind == TypeKind::Named, false);
-            auto const& NT = dynamic_cast<NamedTypeInfo const&>(T);
+            auto const& NT = T.asNamed();
             MRDOCS_CHECK_OR(NT.Name, false);
             MRDOCS_CHECK_OR(NT.Name->Kind == NameKind::Specialization, false);
             return true;
diff --git a/src/lib/Metadata/Finalizers/BaseMembersFinalizer.cpp b/src/lib/Metadata/Finalizers/BaseMembersFinalizer.cpp
index d52af11e4..75d6ea537 100644
--- a/src/lib/Metadata/Finalizers/BaseMembersFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/BaseMembersFinalizer.cpp
@@ -107,8 +107,7 @@ inheritBaseMembers(
         Info& otherInfo = *otherInfoPtr;
 
         // Check if we're not attempt to copy a special member function
-        if (auto const *funcPtr =
-                dynamic_cast<FunctionInfo const *>(otherInfoPtr)) {
+        if (auto const *funcPtr = otherInfoPtr->asFunctionPtr()) {
           MRDOCS_CHECK_OR_CONTINUE(
               !is_one_of(funcPtr->Class, {FunctionClass::Constructor,
                                           FunctionClass::Destructor}));
@@ -229,14 +228,14 @@ operator()(RecordInfo& I)
     {
         MRDOCS_ASSERT(!baseI.Type.valueless_after_move());
         MRDOCS_CHECK_OR_CONTINUE(baseI.Type->isNamed());
-        auto& baseNameType = dynamic_cast<NamedTypeInfo const&>(*baseI.Type);
+        auto& baseNameType = baseI.Type->asNamed();
         MRDOCS_ASSERT(!baseNameType.Name.valueless_after_move());
-        auto& baseName = dynamic_cast<NameInfo const&>(*baseNameType.Name);
+        auto& baseName = baseNameType.Name->asName();
         SymbolID baseID = baseName.id;
         if (corpus_.config->extractImplicitSpecializations && 
             baseName.isSpecialization())
         {
-            auto& baseSpec = dynamic_cast<SpecializationNameInfo const&>(baseName);
+            auto& baseSpec = baseName.asSpecialization();
             baseID = baseSpec.specializationID;
         }
         MRDOCS_CHECK_OR_CONTINUE(baseID);
diff --git a/src/lib/Metadata/Finalizers/DerivedFinalizer.cpp b/src/lib/Metadata/Finalizers/DerivedFinalizer.cpp
index 63ab1f9c6..22373fcba 100644
--- a/src/lib/Metadata/Finalizers/DerivedFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/DerivedFinalizer.cpp
@@ -32,7 +32,7 @@ build()
             MRDOCS_CHECK_OR_CONTINUE(base.Type);
             MRDOCS_ASSERT(!base.Type.valueless_after_move());
             MRDOCS_CHECK_OR_CONTINUE(base.Type->isNamed());
-            auto& namedType = dynamic_cast<NamedTypeInfo&>(*base.Type);
+            auto& namedType = base.Type->asNamed();
             MRDOCS_CHECK_OR_CONTINUE(namedType.Name);
             SymbolID const namedSymbolID = namedType.Name->id;
             MRDOCS_CHECK_OR_CONTINUE(namedSymbolID != SymbolID::invalid);
diff --git a/src/lib/Metadata/Finalizers/Javadoc/Function.hpp b/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
index 609b62d30..90fc29e8c 100644
--- a/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
+++ b/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
@@ -62,7 +62,7 @@ isCopyOrMoveConstructorOrAssignment(FunctionInfo const& I)
     auto const& paramRefPointeeOpt = paramRefType.PointeeType;
     MRDOCS_CHECK_OR(paramRefPointeeOpt, false);
     TypeInfo const& paramRefPointee = *paramRefPointeeOpt;
-    auto const *paramRefPointeeNamed = dynamic_cast<NamedTypeInfo const *>(&paramRefPointee);
+    auto const *paramRefPointeeNamed = paramRefPointee.asNamedPtr();
     MRDOCS_CHECK_OR(paramRefPointeeNamed, false);
     MRDOCS_CHECK_OR(paramRefPointeeNamed->Name, false);
     auto const& paramName = paramRefPointeeNamed->Name;
diff --git a/src/lib/Metadata/Finalizers/OverloadsFinalizer.cpp b/src/lib/Metadata/Finalizers/OverloadsFinalizer.cpp
index 57ff43840..0dc8a0709 100644
--- a/src/lib/Metadata/Finalizers/OverloadsFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/OverloadsFinalizer.cpp
@@ -292,9 +292,9 @@ operator()(RecordInfo& I)
         auto& BT = b.Type;
         MRDOCS_ASSERT(!BT.valueless_after_move());
         MRDOCS_CHECK_OR(BT->isNamed());
-        auto& NT = dynamic_cast<NamedTypeInfo&>(*BT);
+        auto& NT = BT->asNamed();
         MRDOCS_CHECK_OR(NT.Name);
-        auto& NI = dynamic_cast<NameInfo&>(*NT.Name);
+        auto& NI = NT.Name->asName();
         MRDOCS_CHECK_OR(NI.id);
         Info* baseInfo = corpus_.find(NI.id);
         MRDOCS_CHECK_OR(baseInfo);
diff --git a/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp b/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp
index 01fe2f00d..8aae386dd 100644
--- a/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp
@@ -178,10 +178,8 @@ struct SymbolIDCompareFn
                             paramType->isRValueReference(), false);
                         Polymorphic<TypeInfo> const &paramRefPointeeOpt =
                             paramType->isLValueReference()
-                                ? dynamic_cast<LValueReferenceTypeInfo const &>(*paramType)
-                                    .PointeeType
-                                : dynamic_cast<RValueReferenceTypeInfo const &>(*paramType)
-                                    .PointeeType;
+                                ? paramType->asLValueReference().PointeeType
+                                : paramType->asRValueReference().PointeeType;
                         MRDOCS_CHECK_OR(paramRefPointeeOpt, false);
                         auto const& paramRefPointee = *paramRefPointeeOpt;
                         if (!paramRefPointee.isNamed())
diff --git a/src/lib/Metadata/Info/Typedef.cpp b/src/lib/Metadata/Info/Typedef.cpp
index 199cd5e2a..991c99699 100644
--- a/src/lib/Metadata/Info/Typedef.cpp
+++ b/src/lib/Metadata/Info/Typedef.cpp
@@ -69,7 +69,7 @@ void merge(TypedefInfo& I, TypedefInfo&& Other)
     }
     MRDOCS_ASSERT(!I.Type.valueless_after_move());
     if (I.Type->isNamed() &&
-        dynamic_cast<NamedTypeInfo&>(*I.Type).Name->Name.empty())
+        I.Type->asNamed().Name->Name.empty())
     {
         I.Type = std::move(Other.Type);
     }
diff --git a/src/lib/Metadata/Info/Variable.cpp b/src/lib/Metadata/Info/Variable.cpp
index ef033ed29..d99b11810 100644
--- a/src/lib/Metadata/Info/Variable.cpp
+++ b/src/lib/Metadata/Info/Variable.cpp
@@ -65,7 +65,7 @@ merge(VariableInfo& I, VariableInfo&& Other)
     merge(I.asInfo(), std::move(Other.asInfo()));
     MRDOCS_ASSERT(!I.Type.valueless_after_move());
     if (I.Type->isNamed() &&
-        dynamic_cast<NamedTypeInfo&>(*I.Type).Name->Name.empty())
+        I.Type->asNamed().Name->Name.empty())
     {
         I.Type = std::move(Other.Type);
     }
diff --git a/src/lib/Metadata/Name.cpp b/src/lib/Metadata/Name.cpp
index 92bd96878..6e7b2d521 100644
--- a/src/lib/Metadata/Name.cpp
+++ b/src/lib/Metadata/Name.cpp
@@ -100,7 +100,7 @@ toStringImpl(
     {
         return;
     }
-    auto const& NN = dynamic_cast<SpecializationNameInfo const&>(N);
+    auto const& NN = N.asSpecialization();
     std::span const targs = NN.TemplateArgs;
     writeTo(result, '<');
     if(! targs.empty())
diff --git a/src/lib/Metadata/Type.cpp b/src/lib/Metadata/Type.cpp
index 8c2b2ae10..136054188 100644
--- a/src/lib/Metadata/Type.cpp
+++ b/src/lib/Metadata/Type.cpp
@@ -87,7 +87,7 @@ namedSymbol() const noexcept
     {
         return SymbolID::invalid;
     }
-    auto const* NT = dynamic_cast<NamedTypeInfo const*>(this);
+    auto const* NT = this->asNamedPtr();
     MRDOCS_ASSERT(NT);
     MRDOCS_ASSERT(!NT->Name.valueless_after_move());
     return NT->Name->id;
@@ -318,7 +318,7 @@ std::strong_ordering
 NamedTypeInfo::
 operator<=>(NamedTypeInfo const& other) const
 {
-    if (auto const br = dynamic_cast<TypeInfo const&>(*this) <=> dynamic_cast<TypeInfo const&>(other);
+    if (auto const br = this->asType() <=> other.asType();
         !std::is_eq(br))
     {
         return br;
@@ -364,8 +364,7 @@ operator<=>(ArrayTypeInfo const&) const = default;
 std::strong_ordering
 FunctionTypeInfo::
 operator<=>(FunctionTypeInfo const& other) const {
-    if (auto const r = dynamic_cast<TypeInfo const&>(*this) <=>
-             dynamic_cast<TypeInfo const&>(other);
+    if (auto const r = this->asType() <=> other.asType();
         !std::is_eq(r))
     {
         return r;

From 6df912ddfca7e4f9395b2d6b1b420e741eca1a41 Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Sat, 27 Sep 2025 18:11:02 -0500
Subject: [PATCH 20/23] refactor(lib): consistent metadata class family
 hierarchy pattern

Apply a consistent pattern for the class families in the metadata. Class names match their name in all places (such as Symbol instead of Info, and Type instead of TypeInfo), and the clang namespace is described explicitly to avoid name conflicts. The Javadoc hierarchy for blocks and inlines is also well defined.
---
 docs/modules/ROOT/pages/contribute.adoc       |  41 +-
 docs/modules/ROOT/pages/generators.adoc       |  74 +-
 docs/mrdocs.yml                               |   8 +-
 include/mrdocs/ADT/Nullable.hpp               |   4 +-
 include/mrdocs/ADT/Optional.hpp               |   4 +-
 include/mrdocs/ADT/Polymorphic.hpp            |   4 +-
 include/mrdocs/ADT/UnorderedStringMap.hpp     |   4 +-
 include/mrdocs/Config.hpp                     |   4 +-
 .../mrdocs/Config/ReferenceDirectories.hpp    |   4 +-
 include/mrdocs/Corpus.hpp                     | 136 +--
 include/mrdocs/Dom/Array.hpp                  |   2 -
 include/mrdocs/Dom/Array.ipp                  |   4 +-
 include/mrdocs/Dom/Function.hpp               |   4 +-
 include/mrdocs/Dom/Function.ipp               |   4 +-
 include/mrdocs/Dom/Kind.hpp                   |   4 +-
 include/mrdocs/Dom/LazyArray.hpp              |   4 +-
 include/mrdocs/Dom/LazyObject.hpp             |   4 +-
 include/mrdocs/Dom/Object.hpp                 |   4 +-
 include/mrdocs/Dom/Object.ipp                 |   8 +-
 include/mrdocs/Dom/String.hpp                 |   6 +-
 include/mrdocs/Dom/Value.hpp                  |  10 +-
 include/mrdocs/Generator.hpp                  |   4 +-
 include/mrdocs/Generators.hpp                 |   4 +-
 include/mrdocs/Metadata.hpp                   |  32 +-
 include/mrdocs/Metadata/DomCorpus.hpp         |  10 +-
 include/mrdocs/Metadata/Expression.hpp        |   4 +-
 include/mrdocs/Metadata/Javadoc.hpp           |   4 +-
 include/mrdocs/Metadata/Javadoc/Block.hpp     |   4 +-
 .../Metadata/Javadoc/Block/Admonish.hpp       |   4 +-
 .../Metadata/Javadoc/Block/Admonition.hpp     |   4 +-
 .../Metadata/Javadoc/Block/BlockBase.hpp      |   4 +-
 .../mrdocs/Metadata/Javadoc/Block/Brief.hpp   |   4 +-
 .../mrdocs/Metadata/Javadoc/Block/Code.hpp    |   4 +-
 .../mrdocs/Metadata/Javadoc/Block/Heading.hpp |   4 +-
 .../Metadata/Javadoc/Block/ListItem.hpp       |   4 +-
 .../Metadata/Javadoc/Block/Paragraph.hpp      |   4 +-
 .../mrdocs/Metadata/Javadoc/Block/Param.hpp   |   4 +-
 .../Metadata/Javadoc/Block/ParamDirection.hpp |   4 +-
 .../Metadata/Javadoc/Block/Postcondition.hpp  |   4 +-
 .../Metadata/Javadoc/Block/Precondition.hpp   |   4 +-
 .../mrdocs/Metadata/Javadoc/Block/Returns.hpp |   4 +-
 include/mrdocs/Metadata/Javadoc/Block/See.hpp |   4 +-
 .../mrdocs/Metadata/Javadoc/Block/TParam.hpp  |   4 +-
 .../mrdocs/Metadata/Javadoc/Block/Throws.hpp  |   4 +-
 .../Metadata/Javadoc/Block/UnorderedList.hpp  |   4 +-
 include/mrdocs/Metadata/Javadoc/Inline.hpp    |   4 +-
 .../Metadata/Javadoc/Inline/CopyDetails.hpp   |   4 +-
 .../Metadata/Javadoc/Inline/InlineBase.hpp    |   4 +-
 .../mrdocs/Metadata/Javadoc/Inline/Link.hpp   |   4 +-
 .../mrdocs/Metadata/Javadoc/Inline/Parts.hpp  |   4 +-
 .../Metadata/Javadoc/Inline/Reference.hpp     |   6 +-
 .../mrdocs/Metadata/Javadoc/Inline/Style.hpp  |   4 +-
 .../mrdocs/Metadata/Javadoc/Inline/Styled.hpp |   4 +-
 .../mrdocs/Metadata/Javadoc/Inline/Text.hpp   |   4 +-
 include/mrdocs/Metadata/Javadoc/Node.hpp      |   4 +-
 .../mrdocs/Metadata/Javadoc/Node/NodeBase.hpp |   4 +-
 .../mrdocs/Metadata/Javadoc/Node/NodeKind.hpp |   4 +-
 include/mrdocs/Metadata/Name.hpp              |  26 +-
 ...ntifierNameInfo.hpp => IdentifierName.hpp} |  20 +-
 include/mrdocs/Metadata/Name/NameBase.hpp     |  76 +-
 include/mrdocs/Metadata/Name/NameKind.hpp     |  12 +-
 .../Name/{NameInfoNodes.inc => NameNodes.inc} |   0
 ...ionNameInfo.hpp => SpecializationName.hpp} |  20 +-
 .../mrdocs/Metadata/Specifiers/AccessKind.hpp |   4 +-
 .../Metadata/Specifiers/ConstexprKind.hpp     |   4 +-
 .../Metadata/Specifiers/ExplicitInfo.hpp      |   4 +-
 .../Metadata/Specifiers/ExplicitKind.hpp      |   4 +-
 .../Metadata/Specifiers/NoexceptInfo.hpp      |   4 +-
 .../Metadata/Specifiers/NoexceptKind.hpp      |   4 +-
 .../Metadata/Specifiers/OperatorKind.hpp      |   4 +-
 .../Metadata/Specifiers/ReferenceKind.hpp     |   4 +-
 .../Metadata/Specifiers/StorageClassKind.hpp  |   4 +-
 .../mrdocs/Metadata/{Info.hpp => Symbol.hpp}  |  77 +-
 .../Metadata/{Info => Symbol}/Concept.hpp     |  36 +-
 .../mrdocs/Metadata/{Info => Symbol}/Enum.hpp |  40 +-
 .../{Info => Symbol}/EnumConstant.hpp         |  34 +-
 .../{Info => Symbol}/ExtractionMode.hpp       |  14 +-
 .../Metadata/{Info => Symbol}/FileKind.hpp    |  10 +-
 .../Metadata/{Info => Symbol}/Friend.hpp      |  16 +-
 .../Metadata/{Info => Symbol}/Function.hpp    |  44 +-
 .../{Info => Symbol}/FunctionClass.hpp        |  10 +-
 .../Metadata/{Info => Symbol}/Guide.hpp       |  42 +-
 .../Metadata/{Info => Symbol}/Location.hpp    |  10 +-
 .../Metadata/{Info => Symbol}/Namespace.hpp   |  38 +-
 .../{Info => Symbol}/NamespaceAlias.hpp       |  34 +-
 .../Metadata/{Info => Symbol}/Overloads.hpp   |  42 +-
 .../Metadata/{Info => Symbol}/Param.hpp       |  14 +-
 .../Metadata/{Info => Symbol}/Record.hpp      |  42 +-
 .../Metadata/{Info => Symbol}/RecordBase.hpp  |  18 +-
 .../{Info => Symbol}/RecordInterface.hpp      |  12 +-
 .../{Info => Symbol}/RecordKeyKind.hpp        |  10 +-
 .../{Info => Symbol}/RecordTranche.hpp        |  12 +-
 .../Metadata/{Info => Symbol}/Source.hpp      |  12 +-
 .../InfoBase.hpp => Symbol/SymbolBase.hpp}    | 125 ++-
 .../Metadata/{Info => Symbol}/SymbolID.hpp    |  14 +-
 .../InfoKind.hpp => Symbol/SymbolKind.hpp}    |  32 +-
 .../InfoNodes.inc => Symbol/SymbolNodes.inc}  |   0
 .../Metadata/{Info => Symbol}/Typedef.hpp     |  38 +-
 .../Metadata/{Info => Symbol}/Using.hpp       |  38 +-
 .../Metadata/{Info => Symbol}/Variable.hpp    |  38 +-
 include/mrdocs/Metadata/TArg.hpp              |   4 +-
 include/mrdocs/Metadata/TArg/ConstantTArg.hpp |  10 +-
 include/mrdocs/Metadata/TArg/TArgBase.hpp     |   6 +-
 include/mrdocs/Metadata/TArg/TArgKind.hpp     |   6 +-
 include/mrdocs/Metadata/TArg/TemplateTArg.hpp |   4 +-
 include/mrdocs/Metadata/TArg/TypeTArg.hpp     |   6 +-
 include/mrdocs/Metadata/TParam.hpp            |   4 +-
 .../mrdocs/Metadata/TParam/ConstantTParam.hpp |   6 +-
 include/mrdocs/Metadata/TParam/TParamBase.hpp |   6 +-
 .../mrdocs/Metadata/TParam/TParamKeyKind.hpp  |   4 +-
 include/mrdocs/Metadata/TParam/TParamKind.hpp |   6 +-
 .../mrdocs/Metadata/TParam/TemplateTParam.hpp |   4 +-
 include/mrdocs/Metadata/TParam/TypeTParam.hpp |   6 +-
 include/mrdocs/Metadata/Template.hpp          |   6 +-
 include/mrdocs/Metadata/Type.hpp              |  95 +-
 .../Type/{ArrayTypeInfo.hpp => ArrayType.hpp} |  20 +-
 include/mrdocs/Metadata/Type/AutoKind.hpp     |   4 +-
 .../Type/{AutoTypeInfo.hpp => AutoType.hpp}   |  18 +-
 ...{DecltypeTypeInfo.hpp => DecltypeType.hpp} |  16 +-
 ...{FunctionTypeInfo.hpp => FunctionType.hpp} |  22 +-
 .../Metadata/Type/FundamentalTypeKind.hpp     |   4 +-
 ...ceTypeInfo.hpp => LValueReferenceType.hpp} |  18 +-
 .../Metadata/Type/MemberPointerType.hpp       |  33 +
 .../Metadata/Type/MemberPointerTypeInfo.hpp   |  33 -
 .../Type/{NamedTypeInfo.hpp => NamedType.hpp} |  20 +-
 .../{PointerTypeInfo.hpp => PointerType.hpp}  |  18 +-
 .../mrdocs/Metadata/Type/QualifierKind.hpp    |   6 +-
 ...ceTypeInfo.hpp => RValueReferenceType.hpp} |  18 +-
 include/mrdocs/Metadata/Type/TypeBase.hpp     |  76 +-
 include/mrdocs/Metadata/Type/TypeKind.hpp     |   6 +-
 .../Type/{TypeInfoNodes.inc => TypeNodes.inc} |   0
 include/mrdocs/Platform.hpp                   |   4 +-
 include/mrdocs/Support/Algorithm.hpp          |   4 +-
 include/mrdocs/Support/Assert.hpp             |   2 -
 include/mrdocs/Support/Concepts.hpp           |   4 +-
 include/mrdocs/Support/Error.hpp              |  16 +-
 include/mrdocs/Support/ExecutorGroup.hpp      |   4 +-
 include/mrdocs/Support/Expected.hpp           |   4 +-
 include/mrdocs/Support/Glob.hpp               |   4 +-
 include/mrdocs/Support/Handlebars.hpp         |   4 +-
 include/mrdocs/Support/JavaScript.hpp         |   8 +-
 include/mrdocs/Support/Lua.hpp                |   8 +-
 include/mrdocs/Support/Parse.hpp              |   4 +-
 include/mrdocs/Support/Path.hpp               |   4 +-
 include/mrdocs/Support/RangeFor.hpp           |   4 +-
 include/mrdocs/Support/Report.hpp             |   4 +-
 include/mrdocs/Support/ScopeExit.hpp          |   2 +-
 include/mrdocs/Support/String.hpp             |   4 +-
 include/mrdocs/Support/ThreadPool.hpp         |   4 +-
 include/mrdocs/Support/TypeTraits.hpp         |   4 +-
 include/mrdocs/Support/Visitor.hpp            |   4 +-
 include/mrdocs/Support/any_callable.hpp       |   4 +-
 include/mrdocs/Support/source_location.hpp    |  15 +-
 include/mrdocs/Support/unlock_guard.hpp       |   4 +-
 include/mrdocs/Version.hpp.in                 |   4 +-
 include/mrdocs/mrdocs.natvis                  | 138 +--
 share/gdb/mrdocs_printers.py                  |   6 +-
 share/lldb/clang_ast_formatters.py            |   2 +-
 share/lldb/mrdocs_formatters.py               |  44 +-
 .../common/partials/symbol/members-table.hbs  |   2 +-
 src/lib/AST/ASTAction.cpp                     |   6 +-
 src/lib/AST/ASTAction.hpp                     |   4 +-
 src/lib/AST/ASTVisitor.cpp                    | 888 +++++++++---------
 src/lib/AST/ASTVisitor.hpp                    | 362 +++----
 src/lib/AST/ASTVisitorConsumer.cpp            |   6 +-
 src/lib/AST/ASTVisitorConsumer.hpp            |  44 +-
 src/lib/AST/ClangHelpers.cpp                  | 189 ++--
 src/lib/AST/ClangHelpers.hpp                  | 586 ++++++------
 src/lib/AST/FrontendActionFactory.cpp         |   6 +-
 src/lib/AST/FrontendActionFactory.hpp         |   8 +-
 src/lib/AST/InstantiatedFromVisitor.hpp       | 108 +--
 src/lib/AST/MissingSymbolSink.hpp             |   6 +-
 src/lib/AST/MrDocsFileSystem.hpp              |   8 +-
 src/lib/AST/NameBuilder.cpp                   | 122 +++
 .../{NameInfoBuilder.hpp => NameBuilder.hpp}  |  34 +-
 src/lib/AST/NameInfoBuilder.cpp               | 121 ---
 src/lib/AST/ParseJavadoc.cpp                  | 550 ++++++-----
 src/lib/AST/ParseJavadoc.hpp                  |  13 +-
 src/lib/AST/ParseRef.cpp                      | 144 +--
 src/lib/AST/ParseRef.hpp                      |   8 +-
 src/lib/AST/TerminalTypeVisitor.hpp           | 152 +--
 .../{TypeInfoBuilder.cpp => TypeBuilder.cpp}  | 170 ++--
 .../{TypeInfoBuilder.hpp => TypeBuilder.hpp}  | 120 +--
 src/lib/Config.cpp                            |   4 +-
 src/lib/ConfigImpl.cpp                        |  28 +-
 src/lib/ConfigImpl.hpp                        |   4 +-
 src/lib/Corpus.cpp                            |  10 +-
 src/lib/CorpusImpl.cpp                        | 159 ++--
 src/lib/CorpusImpl.hpp                        |  56 +-
 src/lib/Diagnostics.hpp                       |   4 +-
 src/lib/Dom/Array.cpp                         |   4 +-
 src/lib/Dom/Function.cpp                      |   4 +-
 src/lib/Dom/Object.cpp                        |   4 +-
 src/lib/Dom/String.cpp                        |   4 +-
 src/lib/Dom/Value.cpp                         |  10 +-
 src/lib/Gen/adoc/AdocEscape.cpp               |   4 +-
 src/lib/Gen/adoc/AdocEscape.hpp               |   4 +-
 src/lib/Gen/adoc/AdocGenerator.cpp            |   4 +-
 src/lib/Gen/adoc/AdocGenerator.hpp            |   4 +-
 src/lib/Gen/hbs/Builder.cpp                   |  15 +-
 src/lib/Gen/hbs/Builder.hpp                   |   8 +-
 src/lib/Gen/hbs/HandlebarsCorpus.cpp          |  10 +-
 src/lib/Gen/hbs/HandlebarsCorpus.hpp          |   8 +-
 src/lib/Gen/hbs/HandlebarsGenerator.cpp       |   4 +-
 src/lib/Gen/hbs/HandlebarsGenerator.hpp       |   4 +-
 src/lib/Gen/hbs/MultiPageVisitor.cpp          |  12 +-
 src/lib/Gen/hbs/MultiPageVisitor.hpp          |   8 +-
 src/lib/Gen/hbs/SinglePageVisitor.cpp         |  12 +-
 src/lib/Gen/hbs/SinglePageVisitor.hpp         |   6 +-
 src/lib/Gen/hbs/TagfileWriter.cpp             |  18 +-
 src/lib/Gen/hbs/TagfileWriter.hpp             |   8 +-
 src/lib/Gen/hbs/VisitorHelpers.cpp            |  72 +-
 src/lib/Gen/hbs/VisitorHelpers.hpp            |  12 +-
 src/lib/Gen/html/HTMLGenerator.cpp            |   4 +-
 src/lib/Gen/html/HTMLGenerator.hpp            |   4 +-
 src/lib/Gen/xml/CXXTags.cpp                   |  24 +-
 src/lib/Gen/xml/CXXTags.hpp                   |  31 +-
 src/lib/Gen/xml/XMLGenerator.cpp              |   4 +-
 src/lib/Gen/xml/XMLGenerator.hpp              |   4 +-
 src/lib/Gen/xml/XMLTags.cpp                   |   4 +-
 src/lib/Gen/xml/XMLTags.hpp                   |   6 +-
 src/lib/Gen/xml/XMLWriter.cpp                 |  34 +-
 src/lib/Gen/xml/XMLWriter.hpp                 |   8 +-
 src/lib/Metadata/DomCorpus.cpp                |  14 +-
 src/lib/Metadata/Expression.cpp               |   4 +-
 .../Finalizers/BaseMembersFinalizer.cpp       |  34 +-
 .../Finalizers/BaseMembersFinalizer.hpp       |  16 +-
 .../Metadata/Finalizers/DerivedFinalizer.cpp  |   6 +-
 .../Metadata/Finalizers/DerivedFinalizer.hpp  |   6 +-
 .../Metadata/Finalizers/Javadoc/Function.hpp  | 124 ++-
 .../Metadata/Finalizers/Javadoc/Overloads.hpp |  70 +-
 .../Metadata/Finalizers/JavadocFinalizer.cpp  | 150 +--
 .../Metadata/Finalizers/JavadocFinalizer.hpp  |  38 +-
 .../Finalizers/NamespacesFinalizer.cpp        |  12 +-
 .../Finalizers/NamespacesFinalizer.hpp        |  10 +-
 .../Finalizers/OverloadsFinalizer.cpp         |  78 +-
 .../Finalizers/OverloadsFinalizer.hpp         |  14 +-
 .../Finalizers/SortMembersFinalizer.cpp       |  74 +-
 .../Finalizers/SortMembersFinalizer.hpp       |  16 +-
 src/lib/Metadata/Info.cpp                     |  14 +-
 src/lib/Metadata/Info/Concept.cpp             |  12 +-
 src/lib/Metadata/Info/Enum.cpp                |   8 +-
 src/lib/Metadata/Info/EnumConstant.cpp        |   8 +-
 src/lib/Metadata/Info/Friend.cpp              |   6 +-
 src/lib/Metadata/Info/Function.cpp            |  16 +-
 src/lib/Metadata/Info/Guide.cpp               |  14 +-
 src/lib/Metadata/Info/Namespace.cpp           |  16 +-
 src/lib/Metadata/Info/NamespaceAlias.cpp      |  12 +-
 src/lib/Metadata/Info/Overloads.cpp           |  20 +-
 src/lib/Metadata/Info/Record.cpp              |  12 +-
 src/lib/Metadata/Info/Typedef.cpp             |  16 +-
 src/lib/Metadata/Info/Using.cpp               |  10 +-
 src/lib/Metadata/Info/Variable.cpp            |  14 +-
 src/lib/Metadata/Javadoc.cpp                  |   4 +-
 src/lib/Metadata/Name.cpp                     |  28 +-
 src/lib/Metadata/Reduce.hpp                   |  10 +-
 src/lib/Metadata/Source.cpp                   |  10 +-
 src/lib/Metadata/Specifiers.cpp               |   4 +-
 src/lib/Metadata/SymbolID.cpp                 |   6 +-
 .../Metadata/{InfoSet.cpp => SymbolSet.cpp}   |  26 +-
 .../Metadata/{InfoSet.hpp => SymbolSet.hpp}   |  98 +-
 src/lib/Metadata/Template.cpp                 |   4 +-
 src/lib/Metadata/Type.cpp                     | 125 ++-
 src/lib/MrDocsCompilationDatabase.cpp         | 302 +++---
 src/lib/MrDocsCompilationDatabase.hpp         |  16 +-
 src/lib/MrDocsSettingsDB.cpp                  |   9 +-
 src/lib/MrDocsSettingsDB.hpp                  |  12 +-
 src/lib/SingleFileDB.hpp                      |  12 +-
 src/lib/Support/Assert.cpp                    |   4 +-
 src/lib/Support/CMakeExecution.cpp            |   4 +-
 src/lib/Support/CMakeExecution.hpp            |   4 +-
 src/lib/Support/Chrono.hpp                    |   4 +-
 src/lib/Support/Debug.cpp                     |  14 +-
 src/lib/Support/Debug.hpp                     |  28 +-
 src/lib/Support/ExecuteAndWaitWithLogging.cpp |   4 +-
 src/lib/Support/ExecuteAndWaitWithLogging.hpp |   4 +-
 src/lib/Support/ExecutionContext.cpp          |  20 +-
 src/lib/Support/ExecutionContext.hpp          |  36 +-
 src/lib/Support/ExecutorGroup.cpp             |   4 +-
 src/lib/Support/Generator.cpp                 |   4 +-
 src/lib/Support/GeneratorsImpl.cpp            |   4 +-
 src/lib/Support/GeneratorsImpl.hpp            |   4 +-
 src/lib/Support/Glob.cpp                      |   4 +-
 src/lib/Support/Glob.hpp                      |   4 +-
 src/lib/Support/Handlebars.cpp                |   4 +-
 src/lib/Support/JavaScript.cpp                |   6 +-
 src/lib/Support/LegibleNames.cpp              |  39 +-
 src/lib/Support/LegibleNames.hpp              |   6 +-
 src/lib/Support/Path.cpp                      |   3 +-
 src/lib/Support/Path.hpp                      |   8 +-
 src/lib/Support/Radix.cpp                     |   4 +-
 src/lib/Support/Radix.hpp                     |   4 +-
 src/lib/Support/RawOstream.hpp                |   4 +-
 src/lib/Support/Report.cpp                    |   4 +-
 src/lib/Support/Report.hpp                    |   4 +-
 src/lib/Support/String.cpp                    |   4 +-
 src/lib/Support/ThreadPool.cpp                |   4 +-
 src/lib/Support/Validate.cpp                  |   4 +-
 src/lib/Support/Validate.hpp                  |   4 +-
 src/lib/Support/Yaml.cpp                      |   4 +-
 src/lib/Support/Yaml.hpp                      |   4 +-
 src/lib/clang.natvis                          |  94 +-
 src/test/ADT/Nullable.cpp                     |   4 +-
 src/test/ADT/Optional.cpp                     |   6 +-
 src/test/ADT/Polymorphic.cpp                  |   4 +-
 src/test/Support/Expected.cpp                 |   4 +-
 src/test/Support/Glob.cpp                     |   4 +-
 src/test/Support/JavaScript.cpp               |   4 +-
 src/test/TestArgs.cpp                         |   4 +-
 src/test/TestArgs.hpp                         |   4 +-
 src/test/TestMain.cpp                         |  16 +-
 src/test/TestRunner.cpp                       |   4 +-
 src/test/TestRunner.hpp                       |   4 +-
 src/test/lib/AST/ParseRef.cpp                 |   4 +-
 src/test/lib/Dom/Dom.cpp                      |   6 +-
 src/test/lib/Dom/Function.cpp                 |   4 +-
 src/test/lib/Dom/LazyObject.cpp               |   4 +-
 src/test/lib/Support/Handlebars.cpp           |   4 +-
 src/test/lib/Support/Path.cpp                 |   4 +-
 src/tool/CompilerInfo.cpp                     |   4 +-
 src/tool/CompilerInfo.hpp                     |   4 +-
 src/tool/GenerateAction.cpp                   |   6 +-
 src/tool/ToolArgs.cpp                         |   4 +-
 src/tool/ToolArgs.hpp                         |   4 +-
 src/tool/ToolCompilationDatabase.cpp          |  11 +-
 src/tool/ToolCompilationDatabase.hpp          |   7 +-
 src/tool/ToolMain.cpp                         |  14 +-
 util/generate-config-info.py                  |  24 +-
 328 files changed, 4312 insertions(+), 4351 deletions(-)
 rename include/mrdocs/Metadata/Name/{IdentifierNameInfo.hpp => IdentifierName.hpp} (70%)
 rename include/mrdocs/Metadata/Name/{NameInfoNodes.inc => NameNodes.inc} (100%)
 rename include/mrdocs/Metadata/Name/{SpecializationNameInfo.hpp => SpecializationName.hpp} (71%)
 rename include/mrdocs/Metadata/{Info.hpp => Symbol.hpp} (53%)
 rename include/mrdocs/Metadata/{Info => Symbol}/Concept.hpp (66%)
 rename include/mrdocs/Metadata/{Info => Symbol}/Enum.hpp (74%)
 rename include/mrdocs/Metadata/{Info => Symbol}/EnumConstant.hpp (61%)
 rename include/mrdocs/Metadata/{Info => Symbol}/ExtractionMode.hpp (91%)
 rename include/mrdocs/Metadata/{Info => Symbol}/FileKind.hpp (83%)
 rename include/mrdocs/Metadata/{Info => Symbol}/Friend.hpp (86%)
 rename include/mrdocs/Metadata/{Info => Symbol}/Function.hpp (82%)
 rename include/mrdocs/Metadata/{Info => Symbol}/FunctionClass.hpp (85%)
 rename include/mrdocs/Metadata/{Info => Symbol}/Guide.hpp (65%)
 rename include/mrdocs/Metadata/{Info => Symbol}/Location.hpp (94%)
 rename include/mrdocs/Metadata/{Info => Symbol}/Namespace.hpp (83%)
 rename include/mrdocs/Metadata/{Info => Symbol}/NamespaceAlias.hpp (61%)
 rename include/mrdocs/Metadata/{Info => Symbol}/Overloads.hpp (63%)
 rename include/mrdocs/Metadata/{Info => Symbol}/Param.hpp (84%)
 rename include/mrdocs/Metadata/{Info => Symbol}/Record.hpp (76%)
 rename include/mrdocs/Metadata/{Info => Symbol}/RecordBase.hpp (74%)
 rename include/mrdocs/Metadata/{Info => Symbol}/RecordInterface.hpp (91%)
 rename include/mrdocs/Metadata/{Info => Symbol}/RecordKeyKind.hpp (80%)
 rename include/mrdocs/Metadata/{Info => Symbol}/RecordTranche.hpp (93%)
 rename include/mrdocs/Metadata/{Info => Symbol}/Source.hpp (87%)
 rename include/mrdocs/Metadata/{Info/InfoBase.hpp => Symbol/SymbolBase.hpp} (59%)
 rename include/mrdocs/Metadata/{Info => Symbol}/SymbolID.hpp (94%)
 rename include/mrdocs/Metadata/{Info/InfoKind.hpp => Symbol/SymbolKind.hpp} (55%)
 rename include/mrdocs/Metadata/{Info/InfoNodes.inc => Symbol/SymbolNodes.inc} (100%)
 rename include/mrdocs/Metadata/{Info => Symbol}/Typedef.hpp (69%)
 rename include/mrdocs/Metadata/{Info => Symbol}/Using.hpp (82%)
 rename include/mrdocs/Metadata/{Info => Symbol}/Variable.hpp (79%)
 rename include/mrdocs/Metadata/Type/{ArrayTypeInfo.hpp => ArrayType.hpp} (58%)
 rename include/mrdocs/Metadata/Type/{AutoTypeInfo.hpp => AutoType.hpp} (66%)
 rename include/mrdocs/Metadata/Type/{DecltypeTypeInfo.hpp => DecltypeType.hpp} (58%)
 rename include/mrdocs/Metadata/Type/{FunctionTypeInfo.hpp => FunctionType.hpp} (59%)
 rename include/mrdocs/Metadata/Type/{LValueReferenceTypeInfo.hpp => LValueReferenceType.hpp} (55%)
 create mode 100644 include/mrdocs/Metadata/Type/MemberPointerType.hpp
 delete mode 100644 include/mrdocs/Metadata/Type/MemberPointerTypeInfo.hpp
 rename include/mrdocs/Metadata/Type/{NamedTypeInfo.hpp => NamedType.hpp} (61%)
 rename include/mrdocs/Metadata/Type/{PointerTypeInfo.hpp => PointerType.hpp} (58%)
 rename include/mrdocs/Metadata/Type/{RValueReferenceTypeInfo.hpp => RValueReferenceType.hpp} (55%)
 rename include/mrdocs/Metadata/Type/{TypeInfoNodes.inc => TypeNodes.inc} (100%)
 create mode 100644 src/lib/AST/NameBuilder.cpp
 rename src/lib/AST/{NameInfoBuilder.hpp => NameBuilder.hpp} (65%)
 delete mode 100644 src/lib/AST/NameInfoBuilder.cpp
 rename src/lib/AST/{TypeInfoBuilder.cpp => TypeBuilder.cpp} (52%)
 rename src/lib/AST/{TypeInfoBuilder.hpp => TypeBuilder.hpp} (60%)
 rename src/lib/Metadata/{InfoSet.cpp => SymbolSet.cpp} (61%)
 rename src/lib/Metadata/{InfoSet.hpp => SymbolSet.hpp} (51%)

diff --git a/docs/modules/ROOT/pages/contribute.adoc b/docs/modules/ROOT/pages/contribute.adoc
index b9eba5be6..b60d96caf 100644
--- a/docs/modules/ROOT/pages/contribute.adoc
+++ b/docs/modules/ROOT/pages/contribute.adoc
@@ -32,9 +32,9 @@ Common options are defined in `mrdocs/Config.hpp`.
 The `Config` class represents all public options that could be defined in a configuration file.
 It also provides a representation plugins can use to access public options from the command line or configuration file.
 
-The function `clang::mrdocs::loadConfig` is also provided to parse all public options from a YAML configuration file.
+The function `mrdocs::loadConfig` is also provided to parse all public options from a YAML configuration file.
 
-Internally, Mr.Docs uses the derived `clang::mrdocs::ConfigImpl` class (`src/lib/Lib/ConfigImpl.hpp`) to also store the private representation of parsed options, such as filters.
+Internally, Mr.Docs uses the derived `mrdocs::ConfigImpl` class (`src/lib/Lib/ConfigImpl.hpp`) to also store the private representation of parsed options, such as filters.
 
 ==== Finalizing Options
 
@@ -53,6 +53,14 @@ MrDocs has many categories of objects, where we utilize polymorphism with a fixe
 
 Each base class is defined in its own header and, when necessary, implementation file. Each derived class also has its own header and implementation file. Finally, there is a single aggregator header file that includes all the derived headers. This file centralizes logic that requires knowledge of the full set of variants, such as visitors, comparison operators, and other operations that depend on the discriminator.
 
+Suppose we have a polymorphic family of `Symbol` objects, with derived types `Function`, `Class`, and `Enum`. The files would be organized as follows:
+
+* The `Symbol/SymbolNodes.inc` file defines the possible derived types and is used to generate code via macros.
+* The `Symbol/SymbolKind.hpp` file defines the `SymbolKind` enum, which is used as a discriminator for the derived types.
+* The base class `Symbol` is defined in `Symbol/BaseSymbol.hpp` and `Symbol/BaseSymbol.cpp` (if needed).
+* The available kinds of derived symbols are defined in `Symbol/<Derived>.hpp` and `Symbol/<Derived>.cpp` files, e.g., `Symbol/Function.hpp` and `Symbol/Function.cpp`.
+* The `Symbol.hpp` file includes all derived headers and defines operations that require knowledge of all variants, such as visitors and comparison operators.
+
 This pattern keeps the individual derived types self-contained while making cross-variant operations explicit and localized. When adding a new derived type, contributors should create its header and source file alongside the existing ones and update the corresponding aggregator file to register the new variant. This keeps the codebase predictable, avoids scattering logic, and ensures that operations over polymorphic families remain easy to find and maintain.
 
 [#extract_symbols]
@@ -80,19 +88,18 @@ For each compilation command:
 * Paths are normalized
 * Non C++ files are filtered
 
-[#info_nodes]
-==== Info Nodes
+[#symbol_nodes]
+==== Symbol Nodes
 
-MrDocs represents each C++ symbol or construct as an `Info` node (`mrdocs/Metadata/Info.hpp`).
-`Info` can not only represent direct AST symbols but also {cpp} constructs that need to be inferred from these symbols.
+MrDocs represents each C++ symbol or construct as an `Symbol` node (`mrdocs/Metadata/Symbol.hpp`).
+`Symbol` can not only represent direct AST symbols but also {cpp} constructs that need to be inferred from these symbols.
 Nodes in the first category will typically be created in the initial extraction step, and nodes in the second category will be created in the finalization step.
 
-When defining a new `Info` type, it is important to consider how this type will be supported in all other modules of the codebase, including the AST visitor, generators, tests, and the documentation.
-The script `.github/check_info_nodes_support.sh` will attempt to infer whether most of these features have been implemented for each node type.
+When defining a new `Symbol` type, it is important to consider how this type will be supported in all other modules of the codebase, including the AST visitor, generators, tests, and the documentation.
 
 ==== Clang LibTooling
 
-MrDocs uses Clang to extract `Info` objects from the {cpp} AST.
+MrDocs uses Clang to extract `Symbol` objects from the {cpp} AST.
 Clang offers two https://clang.llvm.org/docs/Tooling.html[interfaces] to access the C++ AST: the https://clang.llvm.org/doxygen/group__CINDEX.html[`LibClang`] and https://clang.llvm.org/docs/LibTooling.html[`LibTooling`] libraries.
 MrDocs uses the latter, as it provides full control over the AST traversal process at the cost of an unstable API.
 
@@ -109,7 +116,7 @@ The `clang::tooling::ClangTool::run` method takes a `clang::tooling::ToolAction`
 The action object usually comes from a `clang::tooling::FrontendActionFactory`.
 In the example above, the `SyntaxOnlyAction` is used to parse the source code and generate the AST without any further processing.
 
-In MrDocs, this process happens in `clang::mrdocs::CorpusImpl::build` (`src/lib/Lib/CorpusImpl.cpp`), where we call `Tool.run` for each object in the database with our custom `ASTAction` action and `ASTActionFactory` factory (`src/lib/AST/ASTVisitor.cpp`).
+In MrDocs, this process happens in `mrdocs::CorpusImpl::build` (`src/lib/Lib/CorpusImpl.cpp`), where we call `Tool.run` for each object in the database with our custom `ASTAction` action and `ASTActionFactory` factory (`src/lib/AST/ASTVisitor.cpp`).
 
 ==== AST Traversal
 
@@ -119,7 +126,7 @@ As the AST is generated, it is traversed by the `ASTVisitor` class.
 The entry point of this class is `ASTVisitor::build`, which recursively calls `ASTVisitor::traverseDecl` for the root `clang::TranslationUnitDecl` node of the translation unit.
 During the AST traversal stage, the complete AST generated by the clang frontend is walked beginning with this root `TranslationUnitDecl` node.
 
-Each `clang` node is converted into a `<<info_nodes,mrdocs::Info>>` node, which is then stored with any relevant information in a `mrdocs::Corpus` object.
+Each `clang` node is converted into a `<<symbol_nodes,mrdocs::Symbol>>` node, which is then stored with any relevant information in a `mrdocs::Corpus` object.
 
 ==== USR Generation
 
@@ -132,15 +139,15 @@ This is necessary to generate the full interface for user-defined types.
 After running the AST traversal on all translation units, `CorpusImpl::build` contains finalization steps for the `Corpus` object.
 At this point, we process C++ constructs that are not directly represented in the AST.
 
-The first finalization step happens in `CorpusImpl::build` (`src/lib/Lib/CorpusImpl.cpp`), where the `Info` objects from a single translation unit
+The first finalization step happens in `CorpusImpl::build` (`src/lib/Lib/CorpusImpl.cpp`), where the `Symbol` objects from a single translation unit
 are merged into a map containing the merged results from all other TUs.
 The merging step is necessary as there may be multiple identical definitions of the same entity.
 For instance, this represents the case where a function is declared at different points in the code base and might have different attributes or comments.
 At this step, the doc comments are also finalized.
-Each `Info` object has a pointer to its `Javadoc`  object (`mrdocs/Metadata/Javadoc.hpp`), which is a representation of the documentation comments.
+Each `Symbol` object has a pointer to its `Javadoc`  object (`mrdocs/Metadata/Javadoc.hpp`), which is a representation of the documentation comments.
 
-After AST traversal and `Info` merging, the result is stored as a map of `Info` objects indexed by their respective `SymbolID`.
-A second finalization step is then performed in `clang::mrdocs::finalize`, where any references to `SymbolID` objects that don't exist are removed.
+After AST traversal and `Symbol` merging, the result is stored as a map of `Symbol` objects indexed by their respective `SymbolID`.
+A second finalization step is then performed in `mrdocs::finalize`, where any references to `SymbolID` objects that don't exist are removed.
 This is necessary because the AST traversal will generate references to entities that should be filtered and are not present in the corpus.
 
 At this point, the `Corpus` object contains representations of all entities in the code base and further semantic {cpp} constructs that are not directly represented in the AST can be inferred.
@@ -164,7 +171,7 @@ This directory contains the public headers for the MrDocs library.
 * `include/mrdocs/`—The core library headers
 ** `include/mrdocs/ADT`—Data Structures
 ** `include/mrdocs/Dom`—The Document Object Model for Abstract Trees
-** `include/mrdocs/Metadata`—`Info` nodes and metadata classes
+** `include/mrdocs/Metadata`—`Symbol` nodes and metadata classes
 ** `include/mrdocs/Support`—Various utility classes
 
 ==== `src/`—The main source directory
@@ -176,7 +183,7 @@ This directory contains the source code for the MrDocs library and private heade
 ** `src/lib/Dom/`—The Document Object Model for Abstract Trees
 ** `src/lib/Gen/`—Generators
 ** `src/lib/Lib/`—The core library classes
-** `src/lib/Metadata/`—`Info` nodes and metadata classes
+** `src/lib/Metadata/`—`Symbol` nodes and metadata classes
 ** `src/lib/Support/`—Various utility classes
 * `src/test/`—The test directory
 * `src/test_suite/`—The library used for testing
diff --git a/docs/modules/ROOT/pages/generators.adoc b/docs/modules/ROOT/pages/generators.adoc
index 7b6bccf2b..4e6e5353c 100644
--- a/docs/modules/ROOT/pages/generators.adoc
+++ b/docs/modules/ROOT/pages/generators.adoc
@@ -227,7 +227,7 @@ Symbol objects that contain information about the location include the following
 |Property |Type| Description
 
 | `loc`
-| `<<source-info-fields,Source Info Object>>`
+| `<<source-info-fields,Source Object>>`
 | The location of the symbol in the source code.
 |===
 
@@ -267,7 +267,7 @@ When the symbol kind is `record` (e.g., `class`, `struct`, `union`), the symbol
 | Whether the record is a typedef.
 
 | `bases`
-| `<<base-info-fields,Base Info Object[]>>`
+| `<<base-info-fields,Base Symbol Object[]>>`
 | The base classes of the record.
 
 | `interface`
@@ -275,7 +275,7 @@ When the symbol kind is `record` (e.g., `class`, `struct`, `union`), the symbol
 | The interface of the record.
 
 | `template`
-| `<<template-info-fields,Template Info Object>>`
+| `<<template-info-fields,Template Object>>`
 | The template information of the record.
 |===
 
@@ -285,7 +285,7 @@ When the symbol kind is `enum`, the symbol object has the following additional p
 |Property |Type| Description
 
 | `type`
-| `<<type-info-fields,Type Info Object>>`
+| `<<type-info-fields,Type Object>>`
 | The type information of the enum.
 
 | `isScoped`
@@ -383,11 +383,11 @@ When the symbol kind is `function`, the symbol object has the following addition
 | The parameters of the function.
 
 | `return`
-| `<<type-info-fields,Type Info Object>>`
+| `<<type-info-fields,Type Object>>`
 | The return type of the function.
 
 | `template`
-| `<<template-info-fields,Template Info Object>>`
+| `<<template-info-fields,Template Object>>`
 | The template information of the function.
 
 | `overloadedOperator`
@@ -417,11 +417,11 @@ When the symbol kind is `typedef`, the symbol object has the following additiona
 | Property | Type | Description
 
 | `type`
-| `<<type-info-fields,Type Info Object>>`
+| `<<type-info-fields,Type Object>>`
 | The type information of the typedef.
 
 | `template`
-| `<<template-info-fields,Template Info Object>>`
+| `<<template-info-fields,Template Object>>`
 | The template information of the typedef.
 
 | `isUsing`
@@ -435,11 +435,11 @@ When the symbol kind is `variable`, the symbol object has the following addition
 | Property | Type | Description
 
 | `type`
-| `<<type-info-fields,Type Info Object>>`
+| `<<type-info-fields,Type Object>>`
 | The type information of the variable.
 
 | `template`
-| `<<template-info-fields,Template Info Object>>`
+| `<<template-info-fields,Template Object>>`
 | The template information of the variable.
 
 | `storageClass`
@@ -477,7 +477,7 @@ When the symbol kind is `field` (i.e. non-static data members), the symbol objec
 | Property | Type | Description
 
 | `type`
-| `<<type-info-fields,Type Info Object>>`
+| `<<type-info-fields,Type Object>>`
 | The type information of the field.
 
 | `default`
@@ -531,7 +531,7 @@ When the symbol kind is `friend`, the symbol object has the following additional
 | The friend symbol.
 
 | `type`
-| <<type-info-fields,Type Info Object>>
+| <<type-info-fields,Type Object>>
 | The friend type.
 |===
 
@@ -541,7 +541,7 @@ When the symbol kind is `namespace-alias`, the symbol object has the following a
 | Property | Type | Description
 
 | `aliasedSymbol`
-| <<name-info-fields,Name Info Object>>
+| <<name-info-fields,Name Object>>
 | The aliased symbol.
 |===
 
@@ -559,7 +559,7 @@ When the symbol kind is `using`, the symbol object has the following additional
 | The symbols being used.
 
 | `qualifier`
-| `<<name-info-fields,Name Info Object>>`
+| `<<name-info-fields,Name Object>>`
 | The qualifier of the using declaration.
 |===
 
@@ -583,11 +583,11 @@ When the symbol kind is `guide`, the symbol object has the following additional
 | The parameters of the guide.
 
 | `deduced`
-| `<<type-info-fields,Type Info Object>>`
+| `<<type-info-fields,Type Object>>`
 | The deduced type of the guide.
 
 | `template`
-| `<<template-info-fields,Template Info Object>>`
+| `<<template-info-fields,Template Object>>`
 | The template information of the guide.
 
 | `explicitSpec`
@@ -601,7 +601,7 @@ When the symbol kind is `concept`, the symbol object has the following additiona
 | Property | Type | Description
 
 | `template`
-| `<<template-info-fields,Template Info Object>>`
+| `<<template-info-fields,Template Object>>`
 | The template information of the concept.
 
 | `constraint`
@@ -610,9 +610,9 @@ When the symbol kind is `concept`, the symbol object has the following additiona
 |===
 
 [#source-info-fields]
-=== Source Info Fields
+=== Source Fields
 
-The `Source Info` object represents the location of the symbol in the source code.
+The `Source` object represents the location of the symbol in the source code.
 The source info object has the following properties:
 
 |===
@@ -697,14 +697,14 @@ The base info object has the following properties:
 | Whether the base class is virtual.
 
 | `type`
-| `<<type-info-fields,Type Info Object>>`
+| `<<type-info-fields,Type Object>>`
 | The type information of the base class.
 |===
 
 [#template-info-fields]
-=== Template Info Fields
+=== Template Fields
 
-The `Template Info` object represents the template information of a record, function, or typedef.
+The `Template` object represents the template information of a record, function, or typedef.
 The template info object has the following properties:
 
 |===
@@ -723,7 +723,7 @@ The template info object has the following properties:
 | The template parameters.
 
 | `args`
-| `<<targ-fields,Type Info Object[]>>`
+| `<<targ-fields,Type Object[]>>`
 | The template arguments.
 
 | `requires`
@@ -732,9 +732,9 @@ The template info object has the following properties:
 |===
 
 [#type-info-fields]
-=== Type Info Fields
+=== Type Fields
 
-The `Type Info` object represents the type information of a symbol.
+The `Type` object represents the type information of a symbol.
 The type info object has the following properties:
 
 |===
@@ -769,15 +769,15 @@ The type info object has the following properties:
 | The cv qualifier of the type (e.g., `const`, `volatile`).
 
 | `parent-type`
-| `<<type-info-fields,Type Info Object>>`
+| `<<type-info-fields,Type Object>>`
 | The parent type of the type.
 
 | `pointee-type`
-| `<<type-info-fields,Type Info Object>>`
+| `<<type-info-fields,Type Object>>`
 | The pointee type of the type.
 
 | `element-type`
-| `<<type-info-fields,Type Info Object>>`
+| `<<type-info-fields,Type Object>>`
 | The element type of the type.
 
 | `bounds-value`
@@ -789,11 +789,11 @@ The type info object has the following properties:
 | The bounds expression of the type.
 
 | `return-type`
-| `<<type-info-fields,Type Info Object>>`
+| `<<type-info-fields,Type Object>>`
 | The return type of the type.
 
 | `param-types`
-| `<<type-info-fields,Type Info Object[]>>`
+| `<<type-info-fields,Type Object[]>>`
 | The parameter types of the type.
 
 | `exception-spec`
@@ -823,7 +823,7 @@ The param object has the following properties:
 | The name of the parameter.
 
 | `type`
-| `<<type-info-fields,Type Info Object>>`
+| `<<type-info-fields,Type Object>>`
 | The type information of the parameter.
 
 | `default`
@@ -832,9 +832,9 @@ The param object has the following properties:
 |===
 
 [#name-info-fields]
-=== Name Info Fields
+=== Name Fields
 
-The `Name Info` object represents the name of a symbol.
+The `Name` object represents the name of a symbol.
 The name info object has the following properties:
 
 |===
@@ -849,7 +849,7 @@ The name info object has the following properties:
 | The unique identifier of the symbol.
 
 | `args`
-| `<<targ-fields,Type Info Object[]>>`
+| `<<targ-fields,Type Object[]>>`
 | The template arguments of the symbol.
 
 | `prefix`
@@ -921,7 +921,7 @@ The tparam object has the following properties:
 | The constraint of the template parameter.
 
 | `type`
-| `<<type-info-fields,Type Info Object>>`
+| `<<type-info-fields,Type Object>>`
 | The type information of the template parameter.
 
 | `params`
@@ -947,7 +947,7 @@ The targ object has the following properties:
 | Whether the template argument is a pack expansion.
 
 | `type`
-| `<<type-info-fields,Type Info Object>>`
+| `<<type-info-fields,Type Object>>`
 | The type information of the template argument.
 
 | `value`
@@ -959,7 +959,7 @@ The targ object has the following properties:
 | The name of the template argument.
 
 | `template`
-| `<<template-info-fields,Template Info Object>>`
+| `<<template-info-fields,Template Object>>`
 | The template information of the template argument.
 |===
 
diff --git a/docs/mrdocs.yml b/docs/mrdocs.yml
index f9cdb762b..7692b1090 100644
--- a/docs/mrdocs.yml
+++ b/docs/mrdocs.yml
@@ -8,11 +8,11 @@ input:
 file-patterns:
   - '*.hpp'
 include-symbols:
-  - 'clang::mrdocs::**'
+  - 'mrdocs::**'
 implementation-defined:
-  - 'clang::mrdocs::detail'
-  - 'clang::mrdocs::report::detail'
-  - 'clang::mrdocs::dom::detail'
+  - 'mrdocs::detail'
+  - 'mrdocs::report::detail'
+  - 'mrdocs::dom::detail'
 multipage: true
 generator: adoc
 cmake: '-D MRDOCS_DOCUMENTATION_BUILD=ON'
diff --git a/include/mrdocs/ADT/Nullable.hpp b/include/mrdocs/ADT/Nullable.hpp
index c27fdf95f..8b81c6618 100644
--- a/include/mrdocs/ADT/Nullable.hpp
+++ b/include/mrdocs/ADT/Nullable.hpp
@@ -19,7 +19,7 @@
 #include <type_traits>
 #include <utility>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Defines a customization point for types that have an intrinsic sentinel
     value denoting “null”.
@@ -313,6 +313,6 @@ null_of() noexcept(noexcept(nullable_traits<T>::null()))
     return nullable_traits<T>::null();
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_API_ADT_NULLABLE_HPP
diff --git a/include/mrdocs/ADT/Optional.hpp b/include/mrdocs/ADT/Optional.hpp
index cae1ffb1e..7f0bd4e94 100644
--- a/include/mrdocs/ADT/Optional.hpp
+++ b/include/mrdocs/ADT/Optional.hpp
@@ -21,7 +21,7 @@
 #include <type_traits>
 #include <utility>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 template <class T>
 class Optional;
@@ -1164,6 +1164,6 @@ operator<=>(Optional<T> const& x, U const& v)
     return bool(x) ? *x <=> v : std::strong_ordering::less;
 }
 
-} // namespace clang::mrdocs
+} // namespace mrdocs
 
 #endif
diff --git a/include/mrdocs/ADT/Polymorphic.hpp b/include/mrdocs/ADT/Polymorphic.hpp
index bd1f3505d..2f9f7fb70 100644
--- a/include/mrdocs/ADT/Polymorphic.hpp
+++ b/include/mrdocs/ADT/Polymorphic.hpp
@@ -17,7 +17,7 @@
 #include <concepts>
 #include <utility>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** A polymorphic value-type.
 
@@ -281,6 +281,6 @@ struct nullable_traits<Polymorphic<T>>
     }
 };
 
-} // namespace clang::mrdocs
+} // namespace mrdocs
 
 #endif // MRDOCS_API_ADT_POLYMORPHIC_HPP
diff --git a/include/mrdocs/ADT/UnorderedStringMap.hpp b/include/mrdocs/ADT/UnorderedStringMap.hpp
index 557af2950..e9abc4bfe 100644
--- a/include/mrdocs/ADT/UnorderedStringMap.hpp
+++ b/include/mrdocs/ADT/UnorderedStringMap.hpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <unordered_map>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 struct StringHash
 {
@@ -32,6 +32,6 @@ using UnorderedStringMap = std::unordered_map<std::string, T, StringHash, std::e
 template <class T>
 using UnorderedStringMultiMap = std::unordered_multimap<std::string, T, StringHash, std::equal_to<>>;
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_API_ADT_UNORDEREDSTRINGMAP_HPP
diff --git a/include/mrdocs/Config.hpp b/include/mrdocs/Config.hpp
index 636acb24f..26e00d571 100644
--- a/include/mrdocs/Config.hpp
+++ b/include/mrdocs/Config.hpp
@@ -31,7 +31,7 @@ struct MappingTraits;
 
 } // llvm::yaml
 
-namespace clang {
+
 namespace mrdocs {
 
 class ThreadPool;
@@ -223,6 +223,6 @@ class MRDOCS_DECL
 };
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_API_CONFIG_HPP
diff --git a/include/mrdocs/Config/ReferenceDirectories.hpp b/include/mrdocs/Config/ReferenceDirectories.hpp
index c3bc626e3..b2616cb79 100644
--- a/include/mrdocs/Config/ReferenceDirectories.hpp
+++ b/include/mrdocs/Config/ReferenceDirectories.hpp
@@ -14,7 +14,7 @@
 
 #include <string>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** Reference directories used to resolve paths
@@ -32,6 +32,6 @@ struct ReferenceDirectories
 };
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_API_CONFIG_REFERENCEDIRECTORIES_HPP
diff --git a/include/mrdocs/Corpus.hpp b/include/mrdocs/Corpus.hpp
index e2a41ee52..d323751df 100644
--- a/include/mrdocs/Corpus.hpp
+++ b/include/mrdocs/Corpus.hpp
@@ -23,7 +23,7 @@
 #include <utility>
 #include <vector>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** The collection of declarations in extracted form.
 */
@@ -43,11 +43,11 @@ class MRDOCS_VISIBLE
         The iterator is a forward iterator that
         iterates over all symbols in the index.
         It dereferences to a reference to a
-        const @ref Info.
+        const @ref Symbol.
 
         The logic for incrementing the iterator is
         provided by the Corpus implementation via
-        a function that retuns the next Info in the
+        a function that retuns the next Symbol in the
         index, or nullptr if there are no more.
     */
     class iterator;
@@ -83,41 +83,41 @@ class MRDOCS_VISIBLE
     bool
     empty() const noexcept;
 
-    /** Return the Info with the matching ID, or nullptr.
-    */
-    virtual
-    Info const*
-    find(SymbolID const& id) const noexcept = 0;
-
-    /** Return the Info for the matching string in a given context.
+    /** Return the Symbol for the matching string in a given context.
 
         @param context The context to look up the symbol in.
         @param name The name of the symbol to look up.
-        @return The Info for the symbol with the specified name
+        @return The Symbol for the symbol with the specified name
             in the specified context, or an error if not found.
             If multiple symbols match, one is returned arbitrarily.
             Use @ref traverse to find all matching symbols.
     */
     virtual
-    Expected<Info const&>
+    Expected<Symbol const&>
     lookup(SymbolID const& context, std::string_view name) const = 0;
 
-    /** Return the Info for the matching string in the global context.
+    /** Return the Symbol with the matching ID, or nullptr.
+    */
+    virtual
+    Symbol const*
+    find(SymbolID const& id) const noexcept = 0;
+
+    /** Return the Symbol for the matching string in the global context.
 
         @param name The name of the symbol to look up.
-        @return The Info for the symbol with the specified name
+        @return The Symbol for the symbol with the specified name
             in the global context, or an error if not found.
     */
-    Expected<Info const&>
+    Expected<Symbol const&>
     lookup(std::string_view name) const
     {
         return lookup(SymbolID::global, name);
     }
 
-    /** Return true if an Info with the specified symbol ID exists.
+    /** Return true if an Symbol with the specified symbol ID exists.
 
         This function uses the @ref find function to locate
-        the Info with the specified symbol ID and returns
+        the Symbol with the specified symbol ID and returns
         true if it exists, otherwise false.
     */
     bool
@@ -127,20 +127,20 @@ class MRDOCS_VISIBLE
         return find(id) != nullptr;
     }
 
-    /** Return the Info with the specified symbol ID.
+    /** Return the Symbol with the specified symbol ID.
 
         This function uses the @ref find function to locate
-        the Info with the specified symbol ID. The result
+        the Symbol with the specified symbol ID. The result
         is converted to the specified type T and returned.
 
         The function @ref exists can be used to determine
-        if an Info with the specified symbol ID exists.
+        if an Symbol with the specified symbol ID exists.
         If the id does not exist, the behavior is undefined.
 
-        If the Info is not of type T, the behavior is undefined.
+        If the Symbol is not of type T, the behavior is undefined.
     */
-    template<class T = Info>
-    requires std::derived_from<T, Info>
+    template<class T = Symbol>
+    requires std::derived_from<T, Symbol>
     T const&
     get(SymbolID const& id) const noexcept;
 
@@ -150,7 +150,7 @@ class MRDOCS_VISIBLE
         @ref get with the symbol ID for the
         global namespace.
     */
-    NamespaceInfo const&
+    NamespaceSymbol const&
     globalNamespace() const noexcept;
 
     /** Visit the specified Symbol IDs
@@ -160,11 +160,11 @@ class MRDOCS_VISIBLE
 
         For each member of `I` associated with the ID in `range`,
         the function will invoke the function object `fn` with a
-        type derived from `Info` as the first argument, followed by
+        type derived from `Symbol` as the first argument, followed by
         `args...`.
 
         The type of the first argument is determined
-        by the `InfoKind` of the `Info` object.
+        by the `SymbolKind` of the `Symbol` object.
 
         @param range A range of SymbolID objects.
         @param f The function to invoke.
@@ -182,40 +182,40 @@ class MRDOCS_VISIBLE
         }
     }
 
-    /** Options to traverse the members of an Info.
+    /** Options to traverse the members of an Symbol.
      */
     struct TraverseOptions
     {
         /// Whether to traverse in a stable order
         bool ordered = false;
-        /// Whether to skip inherited members whose parent is not the Info
+        /// Whether to skip inherited members whose parent is not the Symbol
         bool skipInherited = false;
-        /// Whether to skip inherited members whose parent is not the Info
+        /// Whether to skip inherited members whose parent is not the Symbol
         bool recursive = false;
     };
 
-    /** Visit the members of specified Info.
+    /** Visit the members of specified Symbol.
 
         This function invokes the specified function `f`
-        for each member of the specified Info `I`.
+        for each member of the specified Symbol `I`.
 
         For each member of `I`, the function will invoke
         the function object `fn` with a type derived from
-        `Info` as the first argument, followed by `args...`.
+        `Symbol` as the first argument, followed by `args...`.
 
         The type of the first argument is determined
-        by the `InfoKind` of the `Info` object.
+        by the `SymbolKind` of the `Symbol` object.
 
         @param opts The options to traverse.
-        @param I The Info to visit.
+        @param I The Symbol to visit.
         @param f The function to invoke.
         @param args The arguments to pass to the function.
     */
-    template <std::derived_from<Info> T, class F, class... Args>
+    template <std::derived_from<Symbol> T, class F, class... Args>
     void
     traverse(TraverseOptions const& opts, T const& I, F&& f, Args&&... args) const
     {
-        if constexpr (InfoParent<T>)
+        if constexpr (SymbolParent<T>)
         {
             if (!opts.ordered)
             {
@@ -237,7 +237,7 @@ class MRDOCS_VISIBLE
                     auto nonInherited =
                         allMembers(I) |
                         std::views::filter([this, &I](SymbolID const& id) {
-                            Info const* MI = find(id);
+                            Symbol const* MI = find(id);
                             MRDOCS_CHECK_OR(MI, false);
                             return MI->Parent == I.id;
                         });
@@ -265,14 +265,14 @@ class MRDOCS_VISIBLE
                 std::ranges::sort(members,
                     [this](SymbolID const& lhs, SymbolID const& rhs)
                     {
-                        auto const& lhsInfo = get(lhs);
-                        auto const& rhsInfo = get(rhs);
-                        if (auto const cmp = lhsInfo.Name <=> rhsInfo.Name;
+                        auto const& lhsSymbol = get(lhs);
+                        auto const& rhsSymbol = get(rhs);
+                        if (auto const cmp = lhsSymbol.Name <=> rhsSymbol.Name;
                             !std::is_eq(cmp))
                         {
                             return std::is_lt(cmp);
                         }
-                        return std::is_lt(CompareDerived(lhsInfo, rhsInfo));
+                        return std::is_lt(CompareDerived(lhsSymbol, rhsSymbol));
                     });
                 if (!opts.skipInherited)
                 {
@@ -294,7 +294,7 @@ class MRDOCS_VISIBLE
                     auto nonInherited =
                         members |
                         std::views::filter([this, &I](SymbolID const& id) {
-                            Info const* MI = find(id);
+                            Symbol const* MI = find(id);
                             MRDOCS_CHECK_OR(MI, false);
                             return MI->Parent == I.id;
                         });
@@ -315,50 +315,50 @@ class MRDOCS_VISIBLE
         }
     }
 
-    /** Visit the members of specified Info.
+    /** Visit the members of specified Symbol.
 
         This function invokes the specified function `f`
-        for each member of the specified Info `I`.
+        for each member of the specified Symbol `I`.
 
         For each member of `I`, the function will invoke
         the function object `fn` with a type derived from
-        `Info` as the first argument, followed by `args...`.
+        `Symbol` as the first argument, followed by `args...`.
 
         The type of the first argument is determined
-        by the `InfoKind` of the `Info` object.
+        by the `SymbolKind` of the `Symbol` object.
 
-        @param I The Info to visit.
+        @param I The Symbol to visit.
         @param f The function to invoke.
         @param args The arguments to pass to the function.
     */
-    template <std::derived_from<Info> T, class F, class... Args>
+    template <std::derived_from<Symbol> T, class F, class... Args>
     void
     traverse(T const& I, F&& f, Args&&... args) const
     {
         traverse({}, I, std::forward<F>(f), std::forward<Args>(args)...);
     }
 
-    /** Return the fully qualified name of the specified Info.
+    /** Return the fully qualified name of the specified Symbol.
 
         This function returns the fully qualified name
-        of the specified Info `I` as a string.
+        of the specified Symbol `I` as a string.
 
-        The `Info` parents are traversed to construct
+        The `Symbol` parents are traversed to construct
         the fully qualified name which is stored in
         the string `temp`.
 
-        @param I The Info to get the qualified name for.
+        @param I The Symbol to get the qualified name for.
         @param temp The string to store the result in.
         @return A reference to the string `temp`.
      */
     virtual
     void
     qualifiedName(
-        Info const& I,
+        Symbol const& I,
         std::string& temp) const = 0;
 
     std::string
-    qualifiedName(Info const& I) const
+    qualifiedName(Symbol const& I) const
     {
         std::string temp;
         qualifiedName(I, temp);
@@ -368,7 +368,7 @@ class MRDOCS_VISIBLE
     /** Return a qualified name from the specified context.
 
         This function returns the qualified name
-        of the specified Info `I` from the context
+        of the specified Symbol `I` from the context
         specified by the SymbolID `context`.
 
         If the context is a parent of `I`, the
@@ -380,19 +380,19 @@ class MRDOCS_VISIBLE
         qualified name is constructed relative to
         the global namespace with the prefix `::`.
 
-        @param I The Info to get the qualified name for.
+        @param I The Symbol to get the qualified name for.
         @param context The context to get the qualified name from.
         @param result The string to store the result in.
      */
     virtual
     void
     qualifiedName(
-        Info const& I,
+        Symbol const& I,
         SymbolID const& context,
         std::string& result) const = 0;
 
     std::string
-    qualifiedName(Info const& I, SymbolID const& context) const
+    qualifiedName(Symbol const& I, SymbolID const& context) const
     {
         std::string temp;
         qualifiedName(I, context, temp);
@@ -403,7 +403,7 @@ class MRDOCS_VISIBLE
 //------------------------------------------------
 
 template<class T>
-requires std::derived_from<T, Info>
+requires std::derived_from<T, Symbol>
 T const&
 Corpus::
 get(
@@ -411,7 +411,7 @@ get(
 {
     auto I = find(id);
     MRDOCS_ASSERT(I != nullptr);
-    if constexpr(std::is_same_v<T, Info>)
+    if constexpr(std::is_same_v<T, Symbol>)
     {
         return *I;
     }
@@ -426,11 +426,11 @@ get(
 class Corpus::iterator
 {
     Corpus const* corpus_;
-    Info const* val_;
-    Info const*(*next_)(Corpus const*, Info const*);
+    Symbol const* val_;
+    Symbol const*(*next_)(Corpus const*, Symbol const*);
 
 public:
-    using value_type = const Info;
+    using value_type = const Symbol;
     using size_type = std::size_t;
     using difference_type = std::ptrdiff_t;
     using pointer = value_type*;
@@ -444,8 +444,8 @@ class Corpus::iterator
 
     iterator(
         Corpus const* corpus,
-        Info const* val,
-        Info const*(*next)(Corpus const*, Info const*))
+        Symbol const* val,
+        Symbol const*(*next)(Corpus const*, Symbol const*))
         : corpus_(corpus)
         , val_(val)
         , next_(next)
@@ -490,12 +490,12 @@ class Corpus::iterator
     }
 };
 
-/** Return a list of the parent symbols of the specified Info.
+/** Return a list of the parent symbols of the specified Symbol.
  */
 MRDOCS_DECL
 std::vector<SymbolID>
-getParents(Corpus const& C, Info const& I);
+getParents(Corpus const& C, Symbol const& I);
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_API_CORPUS_HPP
diff --git a/include/mrdocs/Dom/Array.hpp b/include/mrdocs/Dom/Array.hpp
index 76f63403e..ef394c488 100644
--- a/include/mrdocs/Dom/Array.hpp
+++ b/include/mrdocs/Dom/Array.hpp
@@ -17,7 +17,6 @@
 #include <string>
 #include <vector>
 
-namespace clang {
 namespace mrdocs {
 namespace dom {
 
@@ -397,7 +396,6 @@ newArray(Args&&... args)
 
 } // dom
 } // mrdocs
-} // clang
 
 // This is here because of circular references
 #include <mrdocs/Dom/Value.hpp>
diff --git a/include/mrdocs/Dom/Array.ipp b/include/mrdocs/Dom/Array.ipp
index d36da06dd..7fb4b219b 100644
--- a/include/mrdocs/Dom/Array.ipp
+++ b/include/mrdocs/Dom/Array.ipp
@@ -11,7 +11,7 @@
 #ifndef MRDOCS_API_DOM_ARRAY_IPP
 #define MRDOCS_API_DOM_ARRAY_IPP
 
-namespace clang {
+
 namespace mrdocs {
 namespace dom {
 
@@ -226,6 +226,6 @@ Array operator+(Array const& lhs, Array const& rhs)
 
 } // dom
 } // mrdocs
-} // clang
+
 
 #endif
diff --git a/include/mrdocs/Dom/Function.hpp b/include/mrdocs/Dom/Function.hpp
index 390e38cdb..49db24d6c 100644
--- a/include/mrdocs/Dom/Function.hpp
+++ b/include/mrdocs/Dom/Function.hpp
@@ -17,7 +17,7 @@
 #include <mrdocs/Support/Expected.hpp>
 #include <memory>
 
-namespace clang {
+
 namespace mrdocs {
 namespace dom {
 
@@ -386,7 +386,7 @@ Function makeVariadicInvocable(F&& f)
 
 } // dom
 } // mrdocs
-} // clang
+
 
 // This is here because of circular references
 #include <mrdocs/Dom/Value.hpp>
diff --git a/include/mrdocs/Dom/Function.ipp b/include/mrdocs/Dom/Function.ipp
index 8947811ee..00663c3ac 100644
--- a/include/mrdocs/Dom/Function.ipp
+++ b/include/mrdocs/Dom/Function.ipp
@@ -11,7 +11,7 @@
 #ifndef MRDOCS_API_DOM_FUNCTION_IPP
 #define MRDOCS_API_DOM_FUNCTION_IPP
 
-namespace clang {
+
 namespace mrdocs {
 namespace dom {
 
@@ -257,6 +257,6 @@ call(Array const& args) const ->
 
 } // dom
 } // mrdocs
-} // clang
+
 
 #endif
diff --git a/include/mrdocs/Dom/Kind.hpp b/include/mrdocs/Dom/Kind.hpp
index bd94c192c..286bc9ac7 100644
--- a/include/mrdocs/Dom/Kind.hpp
+++ b/include/mrdocs/Dom/Kind.hpp
@@ -14,7 +14,7 @@
 #include <mrdocs/Platform.hpp>
 #include <string_view>
 
-namespace clang {
+
 namespace mrdocs {
 namespace dom {
 
@@ -111,6 +111,6 @@ toString(Kind const& value)
 
 } // dom
 } // mrdocs
-} // clang
+
 
 #endif
diff --git a/include/mrdocs/Dom/LazyArray.hpp b/include/mrdocs/Dom/LazyArray.hpp
index a787ed63f..dd7ac690d 100644
--- a/include/mrdocs/Dom/LazyArray.hpp
+++ b/include/mrdocs/Dom/LazyArray.hpp
@@ -17,7 +17,7 @@
 #include <ranges>
 #include <string_view>
 
-namespace clang {
+
 namespace mrdocs {
 namespace dom {
 
@@ -193,6 +193,6 @@ TransformArray(T const& arr, F const& f)
 
 } // dom
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_API_DOM_LAZYARRAY_HPP
diff --git a/include/mrdocs/Dom/LazyObject.hpp b/include/mrdocs/Dom/LazyObject.hpp
index dcef64fa3..65767bb57 100644
--- a/include/mrdocs/Dom/LazyObject.hpp
+++ b/include/mrdocs/Dom/LazyObject.hpp
@@ -16,7 +16,7 @@
 #include <mrdocs/Support/Error.hpp>
 #include <string_view>
 
-namespace clang::mrdocs::dom {
+namespace mrdocs::dom {
 
 namespace detail
 {
@@ -456,6 +456,6 @@ LazyObject(T const& arr, Context const& context)
     return newObject<LazyObjectImpl<T, Context>>(arr, context);
 }
 
-} // clang::mrdocs::dom
+} // mrdocs::dom
 
 #endif // MRDOCS_API_DOM_LAZYOBJECT_HPP
diff --git a/include/mrdocs/Dom/Object.hpp b/include/mrdocs/Dom/Object.hpp
index 1a1553405..a648a601c 100644
--- a/include/mrdocs/Dom/Object.hpp
+++ b/include/mrdocs/Dom/Object.hpp
@@ -18,7 +18,7 @@
 #include <memory>
 #include <vector>
 
-namespace clang {
+
 namespace mrdocs {
 namespace dom {
 
@@ -464,7 +464,7 @@ class MRDOCS_DECL
 
 } // dom
 } // mrdocs
-} // clang
+
 
 // This is here because of circular references
 #include <mrdocs/Dom/Value.hpp>
diff --git a/include/mrdocs/Dom/Object.ipp b/include/mrdocs/Dom/Object.ipp
index 4eef5b1b3..65c473891 100644
--- a/include/mrdocs/Dom/Object.ipp
+++ b/include/mrdocs/Dom/Object.ipp
@@ -11,7 +11,7 @@
 #ifndef MRDOCS_API_DOM_OBJECT_IPP
 #define MRDOCS_API_DOM_OBJECT_IPP
 
-namespace clang {
+
 namespace mrdocs {
 namespace dom {
 
@@ -144,17 +144,17 @@ Object::visit(F&& fn) const
 
 } // dom
 } // mrdocs
-} // clang
+
 
 //------------------------------------------------
 
 template<>
-struct std::formatter<clang::mrdocs::dom::Object>
+struct std::formatter<mrdocs::dom::Object>
     : std::formatter<std::string>
 {
     template <class FmtContext>
     auto format(
-        clang::mrdocs::dom::Object const& value,
+        mrdocs::dom::Object const& value,
         FmtContext& ctx) const
     {
         return std::formatter<std::string>::format(
diff --git a/include/mrdocs/Dom/String.hpp b/include/mrdocs/Dom/String.hpp
index c91ce3dc0..60d8601da 100644
--- a/include/mrdocs/Dom/String.hpp
+++ b/include/mrdocs/Dom/String.hpp
@@ -15,7 +15,6 @@
 #include <mrdocs/Support/String.hpp>
 #include <format>
 
-namespace clang {
 namespace mrdocs {
 namespace dom {
 
@@ -346,15 +345,14 @@ class MRDOCS_DECL
 
 } // dom
 } // mrdocs
-} // clang
 
 //------------------------------------------------
 
 template <>
-struct std::formatter<clang::mrdocs::dom::String>
+struct std::formatter<mrdocs::dom::String>
     : std::formatter<std::string_view> {
   template <class FmtContext>
-  auto format(clang::mrdocs::dom::String const &value, FmtContext &ctx) const {
+  auto format(mrdocs::dom::String const &value, FmtContext &ctx) const {
     return std::formatter<std::string_view>::format(value.get(), ctx);
   }
 };
diff --git a/include/mrdocs/Dom/Value.hpp b/include/mrdocs/Dom/Value.hpp
index 468bc4f39..68f3942ff 100644
--- a/include/mrdocs/Dom/Value.hpp
+++ b/include/mrdocs/Dom/Value.hpp
@@ -25,7 +25,7 @@
 #include <optional> // BAD
 #include <string>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** Create a wrapper for a safe string.
@@ -119,7 +119,7 @@ class MRDOCS_DECL
 
     friend class Array;
     friend class Object;
-    friend Value clang::mrdocs::safeString(std::string_view str);
+    friend Value mrdocs::safeString(std::string_view str);
 
 public:
     ~Value();
@@ -938,7 +938,7 @@ safeString(SV const& str) {
 }
 
 } // mrdocs
-} // clang
+
 
 // These are here because of circular references
 #include <mrdocs/Dom/Array.ipp>
@@ -948,10 +948,10 @@ safeString(SV const& str) {
 //------------------------------------------------
 
 template <>
-struct std::formatter<clang::mrdocs::dom::Value>
+struct std::formatter<mrdocs::dom::Value>
     : public std::formatter<std::string> {
   template <class FmtContext>
-  auto format(clang::mrdocs::dom::Value const &value, FmtContext &ctx) const {
+  auto format(mrdocs::dom::Value const &value, FmtContext &ctx) const {
     return std::formatter<std::string>::format(toString(value), ctx);
   }
 };
diff --git a/include/mrdocs/Generator.hpp b/include/mrdocs/Generator.hpp
index b731c5111..7c7c27f4e 100644
--- a/include/mrdocs/Generator.hpp
+++ b/include/mrdocs/Generator.hpp
@@ -23,7 +23,7 @@
 #include <string>
 #include <string_view>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** Base class for documentation generators.
@@ -207,6 +207,6 @@ getSinglePageFullPath(
     std::string_view extension);
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_API_GENERATOR_HPP
diff --git a/include/mrdocs/Generators.hpp b/include/mrdocs/Generators.hpp
index bedf614fe..79657a5e0 100644
--- a/include/mrdocs/Generators.hpp
+++ b/include/mrdocs/Generators.hpp
@@ -16,7 +16,7 @@
 #include <cstdint>
 #include <string_view>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** A dynamic list of @ref Generator elements.
@@ -77,6 +77,6 @@ Generators const&
 getGenerators() noexcept;
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_API_GENERATORS_HPP
diff --git a/include/mrdocs/Metadata.hpp b/include/mrdocs/Metadata.hpp
index 94bd5719e..7bd250011 100644
--- a/include/mrdocs/Metadata.hpp
+++ b/include/mrdocs/Metadata.hpp
@@ -14,24 +14,24 @@
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Metadata/Expression.hpp>
-#include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/Info/Concept.hpp>
-#include <mrdocs/Metadata/Info/Enum.hpp>
-#include <mrdocs/Metadata/Info/EnumConstant.hpp>
-#include <mrdocs/Metadata/Info/Friend.hpp>
-#include <mrdocs/Metadata/Info/Function.hpp>
-#include <mrdocs/Metadata/Info/Guide.hpp>
-#include <mrdocs/Metadata/Info/Namespace.hpp>
-#include <mrdocs/Metadata/Info/NamespaceAlias.hpp>
-#include <mrdocs/Metadata/Info/Overloads.hpp>
-#include <mrdocs/Metadata/Info/Record.hpp>
-#include <mrdocs/Metadata/Info/Source.hpp>
-#include <mrdocs/Metadata/Info/SymbolID.hpp>
-#include <mrdocs/Metadata/Info/Typedef.hpp>
-#include <mrdocs/Metadata/Info/Using.hpp>
-#include <mrdocs/Metadata/Info/Variable.hpp>
 #include <mrdocs/Metadata/Javadoc.hpp>
 #include <mrdocs/Metadata/Name.hpp>
+#include <mrdocs/Metadata/Symbol.hpp>
+#include <mrdocs/Metadata/Symbol/Concept.hpp>
+#include <mrdocs/Metadata/Symbol/Enum.hpp>
+#include <mrdocs/Metadata/Symbol/EnumConstant.hpp>
+#include <mrdocs/Metadata/Symbol/Friend.hpp>
+#include <mrdocs/Metadata/Symbol/Function.hpp>
+#include <mrdocs/Metadata/Symbol/Guide.hpp>
+#include <mrdocs/Metadata/Symbol/Namespace.hpp>
+#include <mrdocs/Metadata/Symbol/NamespaceAlias.hpp>
+#include <mrdocs/Metadata/Symbol/Overloads.hpp>
+#include <mrdocs/Metadata/Symbol/Record.hpp>
+#include <mrdocs/Metadata/Symbol/Source.hpp>
+#include <mrdocs/Metadata/Symbol/SymbolID.hpp>
+#include <mrdocs/Metadata/Symbol/Typedef.hpp>
+#include <mrdocs/Metadata/Symbol/Using.hpp>
+#include <mrdocs/Metadata/Symbol/Variable.hpp>
 #include <mrdocs/Metadata/Template.hpp>
 #include <mrdocs/Metadata/Type.hpp>
 
diff --git a/include/mrdocs/Metadata/DomCorpus.hpp b/include/mrdocs/Metadata/DomCorpus.hpp
index 7e145e2de..a50f681f0 100644
--- a/include/mrdocs/Metadata/DomCorpus.hpp
+++ b/include/mrdocs/Metadata/DomCorpus.hpp
@@ -17,10 +17,10 @@
 #include <mrdocs/Dom.hpp>
 #include <memory>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 class Corpus;
-struct Info;
+struct Symbol;
 struct Javadoc;
 class SymbolID;
 
@@ -82,7 +82,7 @@ class MRDOCS_DECL
     */
     virtual
     dom::Object
-    construct(Info const& I) const;
+    construct(Symbol const& I) const;
 
     /** Return a Dom object representing the given symbol.
 
@@ -110,8 +110,8 @@ class MRDOCS_DECL
  */
 MRDOCS_DECL
 dom::Array
-getParents(DomCorpus const& C, Info const& I);
+getParents(DomCorpus const& C, Symbol const& I);
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_API_METADATA_DOMCORPUS_HPP
diff --git a/include/mrdocs/Metadata/Expression.hpp b/include/mrdocs/Metadata/Expression.hpp
index 7cd037229..e2bc032b8 100644
--- a/include/mrdocs/Metadata/Expression.hpp
+++ b/include/mrdocs/Metadata/Expression.hpp
@@ -17,7 +17,7 @@
 #include <optional>
 #include <string>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Represents an expression */
 struct ExprInfo
@@ -74,6 +74,6 @@ static void merge(
     }
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Javadoc.hpp b/include/mrdocs/Metadata/Javadoc.hpp
index ac2e4136a..071a13f09 100644
--- a/include/mrdocs/Metadata/Javadoc.hpp
+++ b/include/mrdocs/Metadata/Javadoc.hpp
@@ -17,7 +17,7 @@
 #include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Metadata/Javadoc/Node.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** A processed documentation comment attached to a declaration.
 
@@ -284,6 +284,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Javadoc/Block.hpp b/include/mrdocs/Metadata/Javadoc/Block.hpp
index d874d6b98..5680878b9 100644
--- a/include/mrdocs/Metadata/Javadoc/Block.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Block.hpp
@@ -33,7 +33,7 @@
 #include <mrdocs/Metadata/Javadoc/Block/UnorderedList.hpp>
 #include <mrdocs/Support/Visitor.hpp>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 /** Visit a block.
 
     @param block The block to visit.
@@ -131,6 +131,6 @@ tag_invoke(
             domCorpus);
     });
 }
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Admonish.hpp b/include/mrdocs/Metadata/Javadoc/Block/Admonish.hpp
index 2004a0e1b..d4e5ad3dd 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/Admonish.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Block/Admonish.hpp
@@ -16,7 +16,7 @@
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom.hpp>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** An admonishment style.
  */
@@ -54,6 +54,6 @@ inline
     v = toString(kind);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_ADMONISH_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Admonition.hpp b/include/mrdocs/Metadata/Javadoc/Block/Admonition.hpp
index 62e8142b6..5c2465ed7 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/Admonition.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Block/Admonition.hpp
@@ -19,7 +19,7 @@
 #include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** An admonition.
 
@@ -84,6 +84,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_ADMONITION_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/BlockBase.hpp b/include/mrdocs/Metadata/Javadoc/Block/BlockBase.hpp
index 32cd0abf7..a65e8ff16 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/BlockBase.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Block/BlockBase.hpp
@@ -22,7 +22,7 @@
 #include <algorithm>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** A piece of block content
 
@@ -144,6 +144,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_BLOCKBASE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Brief.hpp b/include/mrdocs/Metadata/Javadoc/Block/Brief.hpp
index 8a1b0b3a5..b3ae24e09 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/Brief.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Block/Brief.hpp
@@ -19,7 +19,7 @@
 #include <mrdocs/Metadata/Javadoc/Node/NodeBase.hpp>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** The brief description
 */
@@ -93,6 +93,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_BRIEF_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Code.hpp b/include/mrdocs/Metadata/Javadoc/Block/Code.hpp
index 6d3655cb2..1e4b1fc3f 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/Code.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Block/Code.hpp
@@ -18,7 +18,7 @@
 #include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** Preformatted source code.
  */
@@ -75,6 +75,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_CODE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Heading.hpp b/include/mrdocs/Metadata/Javadoc/Block/Heading.hpp
index 5a761e3ca..b21a0c5f9 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/Heading.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Block/Heading.hpp
@@ -17,7 +17,7 @@
 #include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** A manually specified section heading.
 */
@@ -75,6 +75,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_HEADING_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/ListItem.hpp b/include/mrdocs/Metadata/Javadoc/Block/ListItem.hpp
index ce51557a8..1a3b4864a 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/ListItem.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Block/ListItem.hpp
@@ -18,7 +18,7 @@
 #include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** An item in a list
 */
@@ -83,6 +83,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_LISTITEM_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Paragraph.hpp b/include/mrdocs/Metadata/Javadoc/Block/Paragraph.hpp
index aa9c2eef5..1de80bbc9 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/Paragraph.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Block/Paragraph.hpp
@@ -17,7 +17,7 @@
 #include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** A sequence of text nodes.
 */
@@ -80,6 +80,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAGRAPH_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Param.hpp b/include/mrdocs/Metadata/Javadoc/Block/Param.hpp
index 8844a3b2a..d76069843 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/Param.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Block/Param.hpp
@@ -19,7 +19,7 @@
 #include <mrdocs/Metadata/Javadoc/Block/ParamDirection.hpp>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** Documentation for a function parameter
 */
@@ -111,6 +111,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAM_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/ParamDirection.hpp b/include/mrdocs/Metadata/Javadoc/Block/ParamDirection.hpp
index 16e3b9b97..bc5ad4281 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/ParamDirection.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Block/ParamDirection.hpp
@@ -16,7 +16,7 @@
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom.hpp>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** Parameter pass direction.
 */
@@ -50,6 +50,6 @@ tag_invoke(
     v = toString(kind);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAMDIRECTION_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Postcondition.hpp b/include/mrdocs/Metadata/Javadoc/Block/Postcondition.hpp
index 251bfa5be..3ca75a27a 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/Postcondition.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Block/Postcondition.hpp
@@ -17,7 +17,7 @@
 #include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 struct Postcondition : Paragraph
 {
@@ -80,6 +80,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_POSTCONDITION_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Precondition.hpp b/include/mrdocs/Metadata/Javadoc/Block/Precondition.hpp
index 39c606155..d2b050ac8 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/Precondition.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Block/Precondition.hpp
@@ -17,7 +17,7 @@
 #include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 struct Precondition final : Paragraph
 {
@@ -80,6 +80,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_PRECONDITION_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Returns.hpp b/include/mrdocs/Metadata/Javadoc/Block/Returns.hpp
index 2108db015..186318235 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/Returns.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Block/Returns.hpp
@@ -18,7 +18,7 @@
 #include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** Documentation for a function return type
 */
@@ -95,6 +95,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_RETURNS_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/See.hpp b/include/mrdocs/Metadata/Javadoc/Block/See.hpp
index 27ba2b974..19d9d7cb1 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/See.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Block/See.hpp
@@ -18,7 +18,7 @@
 #include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** A @see paragraph
 */
@@ -76,6 +76,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_SEE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/TParam.hpp b/include/mrdocs/Metadata/Javadoc/Block/TParam.hpp
index 6a999fa94..0c4657711 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/TParam.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Block/TParam.hpp
@@ -18,7 +18,7 @@
 #include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** Documentation for a template parameter
 */
@@ -76,6 +76,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_TPARAM_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Throws.hpp b/include/mrdocs/Metadata/Javadoc/Block/Throws.hpp
index bc6187bb9..c3e823fe8 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/Throws.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Block/Throws.hpp
@@ -17,7 +17,7 @@
 #include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** Documentation for a function parameter
 */
@@ -83,6 +83,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_THROWS_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/UnorderedList.hpp b/include/mrdocs/Metadata/Javadoc/Block/UnorderedList.hpp
index 1d87c368f..1c1af1872 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/UnorderedList.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Block/UnorderedList.hpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <vector>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** A list of list items
 */
@@ -107,6 +107,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_UNORDEREDLIST_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Inline.hpp b/include/mrdocs/Metadata/Javadoc/Inline.hpp
index ee1a8a0b7..a31983aed 100644
--- a/include/mrdocs/Metadata/Javadoc/Inline.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Inline.hpp
@@ -25,7 +25,7 @@
 #include <mrdocs/Support/Visitor.hpp>
 #include <compare>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** Visit an inline.
 
@@ -117,6 +117,6 @@ operator==(Polymorphic<Inline> const& lhs, Polymorphic<Inline> const& rhs) {
     return std::is_eq(lhs <=> rhs);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_INLINE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Inline/CopyDetails.hpp b/include/mrdocs/Metadata/Javadoc/Inline/CopyDetails.hpp
index 58bc27a34..cda9910c2 100644
--- a/include/mrdocs/Metadata/Javadoc/Inline/CopyDetails.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Inline/CopyDetails.hpp
@@ -18,7 +18,7 @@
 #include <mrdocs/Metadata/Javadoc/Inline/Text.hpp>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** Documentation copied from another symbol.
 */
@@ -75,6 +75,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_INLINE_COPYDETAILS_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Inline/InlineBase.hpp b/include/mrdocs/Metadata/Javadoc/Inline/InlineBase.hpp
index db924c584..6db9fc85b 100644
--- a/include/mrdocs/Metadata/Javadoc/Inline/InlineBase.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Inline/InlineBase.hpp
@@ -17,7 +17,7 @@
 #include <mrdocs/Metadata/Javadoc/Node/NodeBase.hpp>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** A Node containing a string of text.
 
@@ -84,6 +84,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_INLINE_INLINEBASE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Inline/Link.hpp b/include/mrdocs/Metadata/Javadoc/Inline/Link.hpp
index e3500016a..bd7464afe 100644
--- a/include/mrdocs/Metadata/Javadoc/Inline/Link.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Inline/Link.hpp
@@ -17,7 +17,7 @@
 #include <mrdocs/Metadata/Javadoc/Inline/Text.hpp>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** A hyperlink.
 */
@@ -77,6 +77,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_INLINE_LINK_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Inline/Parts.hpp b/include/mrdocs/Metadata/Javadoc/Inline/Parts.hpp
index 63e37f043..268acd258 100644
--- a/include/mrdocs/Metadata/Javadoc/Inline/Parts.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Inline/Parts.hpp
@@ -16,7 +16,7 @@
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom.hpp>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** Which parts of the documentation to copy.
 
@@ -52,6 +52,6 @@ tag_invoke(
     v = toString(kind);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_INLINE_PARTS_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Inline/Reference.hpp b/include/mrdocs/Metadata/Javadoc/Inline/Reference.hpp
index 8a93125f4..76b6146c9 100644
--- a/include/mrdocs/Metadata/Javadoc/Inline/Reference.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Inline/Reference.hpp
@@ -14,11 +14,11 @@
 #define MRDOCS_API_METADATA_JAVADOC_INLINE_REFERENCE_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Info/SymbolID.hpp>
 #include <mrdocs/Metadata/Javadoc/Inline/Text.hpp>
+#include <mrdocs/Metadata/Symbol/SymbolID.hpp>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** A reference to a symbol.
 */
@@ -84,6 +84,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_INLINE_REFERENCE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Inline/Style.hpp b/include/mrdocs/Metadata/Javadoc/Inline/Style.hpp
index 2be1a17c0..76f63974c 100644
--- a/include/mrdocs/Metadata/Javadoc/Inline/Style.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Inline/Style.hpp
@@ -16,7 +16,7 @@
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom.hpp>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** The text style.
 */
@@ -53,6 +53,6 @@ tag_invoke(
     v = toString(kind);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_INLINE_STYLE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Inline/Styled.hpp b/include/mrdocs/Metadata/Javadoc/Inline/Styled.hpp
index 94fcbdf8c..838e94de6 100644
--- a/include/mrdocs/Metadata/Javadoc/Inline/Styled.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Inline/Styled.hpp
@@ -18,7 +18,7 @@
 #include <mrdocs/Metadata/Javadoc/Inline/Text.hpp>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** A piece of styled text.
 */
@@ -77,6 +77,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_INLINE_STYLED_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Inline/Text.hpp b/include/mrdocs/Metadata/Javadoc/Inline/Text.hpp
index 0571e31d2..81db58708 100644
--- a/include/mrdocs/Metadata/Javadoc/Inline/Text.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Inline/Text.hpp
@@ -17,7 +17,7 @@
 #include <mrdocs/Metadata/Javadoc/Inline/InlineBase.hpp>
 #include <string>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** A Node containing a string of text.
 
@@ -91,6 +91,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_INLINE_TEXT_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Node.hpp b/include/mrdocs/Metadata/Javadoc/Node.hpp
index 565c73427..e75b2e885 100644
--- a/include/mrdocs/Metadata/Javadoc/Node.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Node.hpp
@@ -43,7 +43,7 @@
     @see https://www.doxygen.nl
 
  */
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** Visit a node.
 
@@ -155,6 +155,6 @@ tag_invoke(
 }
 
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif
diff --git a/include/mrdocs/Metadata/Javadoc/Node/NodeBase.hpp b/include/mrdocs/Metadata/Javadoc/Node/NodeBase.hpp
index 22400db60..e64dc2828 100644
--- a/include/mrdocs/Metadata/Javadoc/Node/NodeBase.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Node/NodeBase.hpp
@@ -18,7 +18,7 @@
 #include <mrdocs/Metadata/DomCorpus.hpp>
 #include <mrdocs/Metadata/Javadoc/Node/NodeKind.hpp>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 //--------------------------------------------
 
@@ -90,6 +90,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_NODE_NODEBASE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Node/NodeKind.hpp b/include/mrdocs/Metadata/Javadoc/Node/NodeKind.hpp
index 12f6800c0..bfd1a51d2 100644
--- a/include/mrdocs/Metadata/Javadoc/Node/NodeKind.hpp
+++ b/include/mrdocs/Metadata/Javadoc/Node/NodeKind.hpp
@@ -16,7 +16,7 @@
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom.hpp>
 
-namespace clang::mrdocs::doc {
+namespace mrdocs::doc {
 
 /** The kind of node.
 
@@ -127,6 +127,6 @@ tag_invoke(
     v = toString(kind);
 }
 
-} // clang::mrdocs::doc
+} // mrdocs::doc
 
 #endif // MRDOCS_API_METADATA_JAVADOC_NODE_NODEKIND_HPP
diff --git a/include/mrdocs/Metadata/Name.hpp b/include/mrdocs/Metadata/Name.hpp
index a4b100dc5..f7f143923 100644
--- a/include/mrdocs/Metadata/Name.hpp
+++ b/include/mrdocs/Metadata/Name.hpp
@@ -13,31 +13,31 @@
 #define MRDOCS_API_METADATA_NAME_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Name/IdentifierNameInfo.hpp>
+#include <mrdocs/Metadata/Name/IdentifierName.hpp>
 #include <mrdocs/Metadata/Name/NameBase.hpp>
-#include <mrdocs/Metadata/Name/SpecializationNameInfo.hpp>
+#include <mrdocs/Metadata/Name/SpecializationName.hpp>
 #include <mrdocs/Support/Visitor.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 template<
-    std::derived_from<NameInfo> NameInfoTy,
+    std::derived_from<Name> NameTy,
     class Fn,
     class... Args>
 decltype(auto)
 visit(
-    NameInfoTy& info,
+    NameTy& info,
     Fn&& fn,
     Args&&... args)
 {
-    auto visitor = makeVisitor<NameInfo>(
+    auto visitor = makeVisitor<Name>(
         info, std::forward<Fn>(fn), std::forward<Args>(args)...);
     switch(info.Kind)
     {
     case NameKind::Identifier:
-        return visitor.template visit<IdentifierNameInfo>();
+        return visitor.template visit<IdentifierName>();
     case NameKind::Specialization:
-        return visitor.template visit<SpecializationNameInfo>();
+        return visitor.template visit<SpecializationName>();
     default:
         MRDOCS_UNREACHABLE();
     }
@@ -45,10 +45,10 @@ visit(
 
 MRDOCS_DECL
 std::strong_ordering
-operator<=>(Polymorphic<NameInfo> const& lhs, Polymorphic<NameInfo> const& rhs);
+operator<=>(Polymorphic<Name> const& lhs, Polymorphic<Name> const& rhs);
 
 inline bool
-operator==(Polymorphic<NameInfo> const& lhs, Polymorphic<NameInfo> const& rhs)
+operator==(Polymorphic<Name> const& lhs, Polymorphic<Name> const& rhs)
 {
     return lhs <=> rhs == std::strong_ordering::equal;
 }
@@ -58,7 +58,7 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    Polymorphic<NameInfo> const& I,
+    Polymorphic<Name> const& I,
     DomCorpus const* domCorpus)
 {
     MRDOCS_ASSERT(!I.valueless_after_move());
@@ -70,7 +70,7 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    Optional<Polymorphic<NameInfo>> const& I,
+    Optional<Polymorphic<Name>> const& I,
     DomCorpus const* domCorpus)
 {
     if (!I)
@@ -82,6 +82,6 @@ tag_invoke(
     tag_invoke(dom::ValueFromTag{}, v, *I, domCorpus);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Name/IdentifierNameInfo.hpp b/include/mrdocs/Metadata/Name/IdentifierName.hpp
similarity index 70%
rename from include/mrdocs/Metadata/Name/IdentifierNameInfo.hpp
rename to include/mrdocs/Metadata/Name/IdentifierName.hpp
index f3b920f0c..ce4ec36a4 100644
--- a/include/mrdocs/Metadata/Name/IdentifierNameInfo.hpp
+++ b/include/mrdocs/Metadata/Name/IdentifierName.hpp
@@ -8,13 +8,13 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_NAME_IDENTIFIERNAMEINFO_HPP
-#define MRDOCS_API_METADATA_NAME_IDENTIFIERNAMEINFO_HPP
+#ifndef MRDOCS_API_METADATA_NAME_IDENTIFIERNAME_HPP
+#define MRDOCS_API_METADATA_NAME_IDENTIFIERNAME_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Metadata/Name/NameBase.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Represents an identifier
 
@@ -28,21 +28,21 @@ namespace clang::mrdocs {
     When the symbol is not in the corpus,
     the `id` field will be set to `SymbolID::invalid`.
 */
-struct IdentifierNameInfo final
-    : NameInfo
+struct IdentifierName final
+    : Name
 {
     constexpr
-    IdentifierNameInfo() noexcept
-        : NameInfo(NameKind::Identifier)
+    IdentifierName() noexcept
+        : Name(NameKind::Identifier)
     {}
 
     auto
-    operator<=>(IdentifierNameInfo const& other) const
+    operator<=>(IdentifierName const& other) const
     {
         return asName() <=> other.asName();
     }
 };
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_NAME_IDENTIFIERNAME_HPP
diff --git a/include/mrdocs/Metadata/Name/NameBase.hpp b/include/mrdocs/Metadata/Name/NameBase.hpp
index 48e75a409..ea3f0285f 100644
--- a/include/mrdocs/Metadata/Name/NameBase.hpp
+++ b/include/mrdocs/Metadata/Name/NameBase.hpp
@@ -13,31 +13,31 @@
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
-#include <mrdocs/Metadata/Info/SymbolID.hpp>
 #include <mrdocs/Metadata/Name/NameKind.hpp>
+#include <mrdocs/Metadata/Symbol/SymbolID.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /* Forward declarations
  */
-#define INFO(Type) struct Type##NameInfo;
-#include <mrdocs/Metadata/Name/NameInfoNodes.inc>
+#define INFO(Type) struct Type##Name;
+#include <mrdocs/Metadata/Name/NameNodes.inc>
 
-/** Represents a name for a named `TypeInfo`
+/** Represents a name for a named `Type`
 
-    When the `TypeInfo` is a named type, this class
+    When the `Type` is a named type, this class
     represents the name of the type.
 
     It also includes the symbol ID of the named type,
     so that it can be referenced in the documentation.
 
-    This allows the `TypeInfo` to store either a
-    `NameInfo` or a `SpecializationNameInfo`,
+    This allows the `Type` to store either a
+    `Name` or a `SpecializationName`,
     which contains the arguments for a template specialization
     without requiring the application to extract an
     unnecessary symbol.
  */
-struct NameInfo
+struct Name
 {
     /** The kind of name this is.
     */
@@ -48,15 +48,15 @@ struct NameInfo
     SymbolID id = SymbolID::invalid;
 
     /** The unqualified name.
-    */
-    std::string Name;
+     */
+    std::string Identifier;
 
     /** The parent name info, if any.
 
         This recursively includes information about
         the parent, such as the symbol ID and
         potentially template arguments, when
-        the parent is a SpecializationNameInfo.
+        the parent is a SpecializationName.
 
         This is particularly useful because the
         parent of `id` could be a primary template.
@@ -65,25 +65,25 @@ struct NameInfo
         and the template arguments.
 
      */
-    Optional<Polymorphic<NameInfo>> Prefix = std::nullopt;
+    Optional<Polymorphic<struct Name>> Prefix = std::nullopt;
 
-    constexpr virtual ~NameInfo() = default;
+    constexpr virtual ~Name() = default;
 
     std::strong_ordering
-    operator<=>(NameInfo const& other) const;
+    operator<=>(Name const& other) const;
 
     bool
-    operator==(NameInfo const& other) const
+    operator==(Name const& other) const
     {
         return std::is_eq(*this <=> other);
     }
 
-    constexpr NameInfo const& asName() const noexcept
+    constexpr Name const& asName() const noexcept
     {
         return *this;
     }
 
-    constexpr NameInfo& asName() noexcept
+    constexpr Name& asName() noexcept
     {
         return *this;
     }
@@ -91,61 +91,61 @@ struct NameInfo
     #define INFO(Type) constexpr bool is##Type() const noexcept { \
         return Kind == NameKind::Type; \
     }
-#include <mrdocs/Metadata/Name/NameInfoNodes.inc>
+#include <mrdocs/Metadata/Name/NameNodes.inc>
 
-    #define INFO(Type) \
-    constexpr Type##NameInfo const& as##Type() const noexcept { \
+#define INFO(Type) \
+    constexpr Type##Name const& as##Type() const noexcept { \
         if (Kind == NameKind::Type) \
-            return reinterpret_cast<Type##NameInfo const&>(*this); \
+            return reinterpret_cast<Type##Name const&>(*this); \
         MRDOCS_UNREACHABLE(); \
     }
-#include <mrdocs/Metadata/Name/NameInfoNodes.inc>
+#include <mrdocs/Metadata/Name/NameNodes.inc>
 
 #define INFO(Type) \
-    constexpr Type##NameInfo & as##Type() noexcept { \
+    constexpr Type##Name & as##Type() noexcept { \
         if (Kind == NameKind::Type) \
-            return reinterpret_cast<Type##NameInfo&>(*this); \
+            return reinterpret_cast<Type##Name&>(*this); \
         MRDOCS_UNREACHABLE(); \
     }
-#include <mrdocs/Metadata/Name/NameInfoNodes.inc>
+#include <mrdocs/Metadata/Name/NameNodes.inc>
 
 #define INFO(Type) \
-    constexpr Type##NameInfo const* as##Type##Ptr() const noexcept { \
-        if (Kind == NameKind::Type) { return reinterpret_cast<Type##NameInfo const*>(this); } \
+    constexpr Type##Name const* as##Type##Ptr() const noexcept { \
+        if (Kind == NameKind::Type) { return reinterpret_cast<Type##Name const*>(this); } \
         return nullptr; \
     }
-#include <mrdocs/Metadata/Name/NameInfoNodes.inc>
+#include <mrdocs/Metadata/Name/NameNodes.inc>
 
 #define INFO(Type) \
-    constexpr Type##NameInfo * as##Type##Ptr() noexcept { \
-        if (Kind == NameKind::Type) { return reinterpret_cast<Type##NameInfo *>(this); } \
+    constexpr Type##Name * as##Type##Ptr() noexcept { \
+        if (Kind == NameKind::Type) { return reinterpret_cast<Type##Name *>(this); } \
         return nullptr; \
     }
-#include <mrdocs/Metadata/Name/NameInfoNodes.inc>
+#include <mrdocs/Metadata/Name/NameNodes.inc>
 
 protected:
     constexpr
-    NameInfo() noexcept
-        : NameInfo(NameKind::Identifier) {};
+    Name() noexcept
+        : Kind(NameKind::Identifier) {};
 
     explicit
         constexpr
-        NameInfo(NameKind const kind) noexcept
+        Name(NameKind const kind) noexcept
         : Kind(kind) {}
 };
 
 MRDOCS_DECL
 std::string
-toString(NameInfo const& N);
+toString(Name const& N);
 
 MRDOCS_DECL
 void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    NameInfo const& I,
+    Name const& I,
     DomCorpus const* domCorpus);
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Name/NameKind.hpp b/include/mrdocs/Metadata/Name/NameKind.hpp
index 5a0ca6f1a..819c230a3 100644
--- a/include/mrdocs/Metadata/Name/NameKind.hpp
+++ b/include/mrdocs/Metadata/Name/NameKind.hpp
@@ -14,12 +14,11 @@
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
-enum class NameKind
-{
+enum class NameKind {
 #define INFO(Type) Type,
-#include <mrdocs/Metadata/Name/NameInfoNodes.inc>
+#include <mrdocs/Metadata/Name/NameNodes.inc>
 };
 
 MRDOCS_DECL
@@ -30,12 +29,11 @@ inline
 void
 tag_invoke(
     dom::ValueFromTag,
-    dom::Value& v,
-    NameKind const kind)
+    dom::Value& v, NameKind const kind)
 {
     v = toString(kind);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Name/NameInfoNodes.inc b/include/mrdocs/Metadata/Name/NameNodes.inc
similarity index 100%
rename from include/mrdocs/Metadata/Name/NameInfoNodes.inc
rename to include/mrdocs/Metadata/Name/NameNodes.inc
diff --git a/include/mrdocs/Metadata/Name/SpecializationNameInfo.hpp b/include/mrdocs/Metadata/Name/SpecializationName.hpp
similarity index 71%
rename from include/mrdocs/Metadata/Name/SpecializationNameInfo.hpp
rename to include/mrdocs/Metadata/Name/SpecializationName.hpp
index 5dcc3e78e..a7ad1090e 100644
--- a/include/mrdocs/Metadata/Name/SpecializationNameInfo.hpp
+++ b/include/mrdocs/Metadata/Name/SpecializationName.hpp
@@ -8,19 +8,19 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_NAME_SPECIALIZATIONNAMEINFO_HPP
-#define MRDOCS_API_METADATA_NAME_SPECIALIZATIONNAMEINFO_HPP
+#ifndef MRDOCS_API_METADATA_NAME_SPECIALIZATIONNAME_HPP
+#define MRDOCS_API_METADATA_NAME_SPECIALIZATIONNAME_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Metadata/Name/NameBase.hpp>
 #include <mrdocs/Metadata/TArg.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Represents a (possibly qualified) symbol name with template arguments.
 */
-struct SpecializationNameInfo final
-    : NameInfo
+struct SpecializationName final
+    : Name
 {
     /** The template arguments.
     */
@@ -31,12 +31,12 @@ struct SpecializationNameInfo final
     SymbolID specializationID = SymbolID::invalid;
 
     constexpr
-    SpecializationNameInfo() noexcept
-        : NameInfo(NameKind::Specialization)
+    SpecializationName() noexcept
+        : Name(NameKind::Specialization)
     {}
 
     auto
-    operator<=>(SpecializationNameInfo const& other) const
+    operator<=>(SpecializationName const& other) const
     {
         if (auto const r = asName() <=> other.asName();
             !std::is_eq(r))
@@ -47,6 +47,6 @@ struct SpecializationNameInfo final
     }
 };
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_NAME_SPECIALIZATIONNAME_HPP
diff --git a/include/mrdocs/Metadata/Specifiers/AccessKind.hpp b/include/mrdocs/Metadata/Specifiers/AccessKind.hpp
index d75bb5b38..430385ec6 100644
--- a/include/mrdocs/Metadata/Specifiers/AccessKind.hpp
+++ b/include/mrdocs/Metadata/Specifiers/AccessKind.hpp
@@ -16,7 +16,7 @@
 #include <mrdocs/Dom.hpp>
 #include <string>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Access specifier.
 
@@ -57,6 +57,6 @@ tag_invoke(
     v = toString(kind);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Specifiers/ConstexprKind.hpp b/include/mrdocs/Metadata/Specifiers/ConstexprKind.hpp
index 9e1297229..9ec35ee00 100644
--- a/include/mrdocs/Metadata/Specifiers/ConstexprKind.hpp
+++ b/include/mrdocs/Metadata/Specifiers/ConstexprKind.hpp
@@ -15,7 +15,7 @@
 #include <mrdocs/Platform.hpp>
 #include <string>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** `constexpr`/`consteval` specifier kinds
 
@@ -49,6 +49,6 @@ tag_invoke(
     v = toString(kind);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Specifiers/ExplicitInfo.hpp b/include/mrdocs/Metadata/Specifiers/ExplicitInfo.hpp
index 68df0c813..ff95626e4 100644
--- a/include/mrdocs/Metadata/Specifiers/ExplicitInfo.hpp
+++ b/include/mrdocs/Metadata/Specifiers/ExplicitInfo.hpp
@@ -16,7 +16,7 @@
 #include <mrdocs/Metadata/Specifiers/ExplicitKind.hpp>
 #include <string>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /**
     Stores only the operand of the explicit-specifier or noexcept-specifier as a string.
@@ -70,6 +70,6 @@ tag_invoke(
     v = toString(I);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Specifiers/ExplicitKind.hpp b/include/mrdocs/Metadata/Specifiers/ExplicitKind.hpp
index ca3669637..19a93923f 100644
--- a/include/mrdocs/Metadata/Specifiers/ExplicitKind.hpp
+++ b/include/mrdocs/Metadata/Specifiers/ExplicitKind.hpp
@@ -16,7 +16,7 @@
 #include <mrdocs/Dom/String.hpp>
 #include <string>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Explicit specifier kinds
 */
@@ -37,6 +37,6 @@ MRDOCS_DECL
 dom::String
 toString(ExplicitKind kind) noexcept;
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Specifiers/NoexceptInfo.hpp b/include/mrdocs/Metadata/Specifiers/NoexceptInfo.hpp
index dd98b4deb..48a644f90 100644
--- a/include/mrdocs/Metadata/Specifiers/NoexceptInfo.hpp
+++ b/include/mrdocs/Metadata/Specifiers/NoexceptInfo.hpp
@@ -20,7 +20,7 @@
 #include <mrdocs/Metadata/Specifiers/NoexceptKind.hpp>
 #include <string>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 // KRYSTIAN FIXME: this needs to be improved (a lot)
 struct NoexceptInfo
@@ -69,6 +69,6 @@ tag_invoke(
     v = toString(info, false, false);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Specifiers/NoexceptKind.hpp b/include/mrdocs/Metadata/Specifiers/NoexceptKind.hpp
index 08544d496..4ef3f8f13 100644
--- a/include/mrdocs/Metadata/Specifiers/NoexceptKind.hpp
+++ b/include/mrdocs/Metadata/Specifiers/NoexceptKind.hpp
@@ -16,7 +16,7 @@
 #include <mrdocs/Dom/String.hpp>
 #include <string>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Exception specification kinds
 */
@@ -37,6 +37,6 @@ MRDOCS_DECL
 dom::String
 toString(NoexceptKind kind) noexcept;
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Specifiers/OperatorKind.hpp b/include/mrdocs/Metadata/Specifiers/OperatorKind.hpp
index bd2a70c2d..fef84be79 100644
--- a/include/mrdocs/Metadata/Specifiers/OperatorKind.hpp
+++ b/include/mrdocs/Metadata/Specifiers/OperatorKind.hpp
@@ -17,7 +17,7 @@
 #include <mrdocs/Dom/String.hpp>
 #include <string>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Operator kinds
 */
@@ -202,6 +202,6 @@ getOperatorReadableName(
     OperatorKind kind,
     int nParams);
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Specifiers/ReferenceKind.hpp b/include/mrdocs/Metadata/Specifiers/ReferenceKind.hpp
index f5b526e68..608e73665 100644
--- a/include/mrdocs/Metadata/Specifiers/ReferenceKind.hpp
+++ b/include/mrdocs/Metadata/Specifiers/ReferenceKind.hpp
@@ -16,7 +16,7 @@
 #include <mrdocs/Dom.hpp>
 #include <string>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Reference type kinds
 */
@@ -44,6 +44,6 @@ tag_invoke(
     v = toString(kind);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Specifiers/StorageClassKind.hpp b/include/mrdocs/Metadata/Specifiers/StorageClassKind.hpp
index 44a241d7f..6de36a278 100644
--- a/include/mrdocs/Metadata/Specifiers/StorageClassKind.hpp
+++ b/include/mrdocs/Metadata/Specifiers/StorageClassKind.hpp
@@ -16,7 +16,7 @@
 #include <mrdocs/Dom.hpp>
 #include <string>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Storage class kinds
 
@@ -56,6 +56,6 @@ tag_invoke(
     v = toString(kind);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Info.hpp b/include/mrdocs/Metadata/Symbol.hpp
similarity index 53%
rename from include/mrdocs/Metadata/Info.hpp
rename to include/mrdocs/Metadata/Symbol.hpp
index e26641d54..b0b68cf61 100644
--- a/include/mrdocs/Metadata/Info.hpp
+++ b/include/mrdocs/Metadata/Symbol.hpp
@@ -9,94 +9,95 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_HPP
-#define MRDOCS_API_METADATA_INFO_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_HPP
+#define MRDOCS_API_METADATA_SYMBOL_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Info/InfoBase.hpp>
+#include <mrdocs/Metadata/Symbol/SymbolBase.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
-/** Invoke a function object with a type derived from Info
+/** Invoke a function object with a type derived from Symbol
 
     This function will invoke the function object `fn` with
-    a type derived from `Info` as the first argument, followed
+    a type derived from `Symbol` as the first argument, followed
     by `args...`. The type of the first argument is determined
-    by the `InfoKind` of the `Info` object.
+    by the `SymbolKind` of the `Symbol` object.
 
-    @param info The Info object to visit
+    @param info The Symbol object to visit
     @param fn The function object to call
     @param args Additional arguments to pass to the function object
     @return The result of calling the function object with the derived type
  */
 template<
-    std::derived_from<Info> InfoTy,
+    std::derived_from<Symbol> SymbolTy,
     class Fn,
     class... Args>
 decltype(auto)
 visit(
-    InfoTy& info,
+    SymbolTy& info,
     Fn&& fn,
     Args&&... args)
 {
-    auto visitor = makeVisitor<Info>(
+    auto visitor = makeVisitor<
+        Symbol>(
         info, std::forward<Fn>(fn),
         std::forward<Args>(args)...);
     switch(info.Kind)
     {
     #define INFO(Type) \
-    case InfoKind::Type: \
-        return visitor.template visit<Type##Info>();
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
+    case SymbolKind::Type: \
+        return visitor.template visit<Type##Symbol>();
+#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
     default:
         MRDOCS_UNREACHABLE();
     }
 }
 
-/** Merges two Info objects according to the behavior of the derived class.
+/** Merges two Symbol objects according to the behavior of the derived class.
 
-    @param I The Info object to merge into.
-    @param Other The Info object to merge from.
+    @param I The Symbol object to merge into.
+    @param Other The Symbol object to merge from.
  */
-template <polymorphic_storage_for<Info> InfoTy>
+template <polymorphic_storage_for<Symbol> SymbolTy>
 void
-merge(InfoTy& I, InfoTy&& Other)
+merge(SymbolTy& I, SymbolTy&& Other)
 {
     MRDOCS_ASSERT(I.Kind == Other.Kind);
     MRDOCS_ASSERT(I.id == Other.id);
-    Info& base = I;
-    visit(base, [&]<typename DerivedInfoTy>(DerivedInfoTy& derived) mutable
+    Symbol& base = I;
+    visit(base, [&]<typename DerivedSymbolTy>(DerivedSymbolTy& derived) mutable
     {
-        DerivedInfoTy& otherDerived = static_cast<DerivedInfoTy&>(Other);
+        DerivedSymbolTy& otherDerived = static_cast<DerivedSymbolTy&>(Other);
         merge(derived, std::move(otherDerived));
     });
 }
 
-/** A concept for types that have `Info` members.
+/** A concept for types that have `Symbol` members.
 
-    In most cases `T` is another `Info` type that
+    In most cases `T` is another `Symbol` type that
     has a `Members` member which is a range of
     `SymbolID` values.
 */
-template <class InfoTy>
-concept InfoParent = requires(InfoTy const& I)
+template <class SymbolTy>
+concept SymbolParent = requires(SymbolTy const& I)
 {
     { allMembers(I) } -> range_of<SymbolID>;
 };
 
-/** Map the Polymorphic Info to a @ref dom::Object.
+/** Map the Polymorphic Symbol to a @ref dom::Object.
 
     @param io The output parameter to receive the dom::Object.
-    @param I The polymorphic Info to convert.
+    @param I The polymorphic Symbol to convert.
     @param domCorpus The DomCorpus used to resolve references.
  */
-template <class IO, polymorphic_storage_for<Info> PolymorphicInfo>
-requires std::derived_from<PolymorphicInfo, Info>
+template <class IO, polymorphic_storage_for<Symbol> PolymorphicSymbol>
+requires std::derived_from<PolymorphicSymbol, Symbol>
 void
 tag_invoke(
     dom::LazyObjectMapTag,
     IO& io,
-    PolymorphicInfo const& I,
+    PolymorphicSymbol const& I,
     DomCorpus const* domCorpus)
 {
     visit(*I, [&](auto const& U)
@@ -109,19 +110,19 @@ tag_invoke(
     });
 }
 
-/** Map the Polymorphic Info as a @ref dom::Value object.
+/** Map the Polymorphic Symbol as a @ref dom::Value object.
 
     @param io The output parameter to receive the dom::Value.
-    @param I The polymorphic Info to convert.
+    @param I The polymorphic Symbol to convert.
     @param domCorpus The DomCorpus used to resolve references.
  */
-template <class IO, polymorphic_storage_for<Info> InfoTy>
-requires std::derived_from<InfoTy, Info>
+template <class IO, polymorphic_storage_for<Symbol> SymbolTy>
+requires std::derived_from<SymbolTy, Symbol>
 void
 tag_invoke(
     dom::ValueFromTag,
     IO& io,
-    InfoTy const& I,
+    SymbolTy const& I,
     DomCorpus const* domCorpus)
 {
     visit(*I, [&](auto const& U)
@@ -134,6 +135,6 @@ tag_invoke(
     });
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_SYMBOL_HPP
diff --git a/include/mrdocs/Metadata/Info/Concept.hpp b/include/mrdocs/Metadata/Symbol/Concept.hpp
similarity index 66%
rename from include/mrdocs/Metadata/Info/Concept.hpp
rename to include/mrdocs/Metadata/Symbol/Concept.hpp
index ab4a75795..7f3a31f3e 100644
--- a/include/mrdocs/Metadata/Info/Concept.hpp
+++ b/include/mrdocs/Metadata/Symbol/Concept.hpp
@@ -8,23 +8,23 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_CONCEPT_HPP
-#define MRDOCS_API_METADATA_INFO_CONCEPT_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_CONCEPT_HPP
+#define MRDOCS_API_METADATA_SYMBOL_CONCEPT_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Metadata/Expression.hpp>
-#include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/Info/Source.hpp>
+#include <mrdocs/Metadata/Symbol.hpp>
+#include <mrdocs/Metadata/Symbol/Source.hpp>
 #include <mrdocs/Metadata/Template.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Info for concepts.
 */
-struct ConceptInfo final
-    : InfoCommonBase<InfoKind::Concept>
+struct ConceptSymbol final
+    : SymbolCommonBase<SymbolKind::Concept>
 {
     /** The concepts template parameters
     */
@@ -36,24 +36,24 @@ struct ConceptInfo final
 
     //--------------------------------------------
 
-    explicit ConceptInfo(SymbolID const &ID) noexcept
-        : InfoCommonBase(ID)
+    explicit ConceptSymbol(SymbolID const &ID) noexcept
+        : SymbolCommonBase(ID)
     {
     }
 
     std::strong_ordering
-    operator<=>(ConceptInfo const& other) const;
+    operator<=>(ConceptSymbol const& other) const;
 };
 
 MRDOCS_DECL
 void
-merge(ConceptInfo& I, ConceptInfo&& Other);
+merge(ConceptSymbol& I, ConceptSymbol&& Other);
 
-/** Map a ConceptInfo to a dom::Object.
+/** Map a ConceptSymbol to a dom::Object.
 
     @param t The tag type.
     @param io The IO object to use for mapping.
-    @param I The ConceptInfo to map.
+    @param I The ConceptSymbol to map.
     @param domCorpus The DomCorpus used to create
  */
 template <class IO>
@@ -61,7 +61,7 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    ConceptInfo const& I,
+    ConceptSymbol const& I,
     DomCorpus const* domCorpus)
 {
     tag_invoke(t, io, I.asInfo(), domCorpus);
@@ -72,19 +72,19 @@ tag_invoke(
     }
 }
 
-/** Map the ConceptInfo to a @ref dom::Value object.
+/** Map the ConceptSymbol to a @ref dom::Value object.
  */
 inline
 void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    ConceptInfo const& I,
+    ConceptSymbol const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_CONCEPT_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_CONCEPT_HPP
diff --git a/include/mrdocs/Metadata/Info/Enum.hpp b/include/mrdocs/Metadata/Symbol/Enum.hpp
similarity index 74%
rename from include/mrdocs/Metadata/Info/Enum.hpp
rename to include/mrdocs/Metadata/Symbol/Enum.hpp
index 486aa6cf7..935da1553 100644
--- a/include/mrdocs/Metadata/Info/Enum.hpp
+++ b/include/mrdocs/Metadata/Symbol/Enum.hpp
@@ -9,20 +9,20 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_ENUM_HPP
-#define MRDOCS_API_METADATA_INFO_ENUM_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_ENUM_HPP
+#define MRDOCS_API_METADATA_SYMBOL_ENUM_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Dom/LazyArray.hpp>
-#include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/Info/Source.hpp>
+#include <mrdocs/Metadata/Symbol.hpp>
+#include <mrdocs/Metadata/Symbol/Source.hpp>
 #include <mrdocs/Metadata/Type.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
-struct EnumInfo final
-    : InfoCommonBase<InfoKind::Enum>
+struct EnumSymbol final
+    : SymbolCommonBase<SymbolKind::Enum>
 {
     /** Indicates whether this enum is scoped (e.g. enum class).
 
@@ -42,7 +42,7 @@ struct EnumInfo final
 
         For `enum Foo : short { ... };` this will be represent `short`.
     */
-    Optional<Polymorphic<TypeInfo>> UnderlyingType = std::nullopt;
+    Optional<Polymorphic<Type>> UnderlyingType = std::nullopt;
 
     /** The members of this scope.
 
@@ -55,28 +55,28 @@ struct EnumInfo final
 
     //--------------------------------------------
 
-    explicit EnumInfo(SymbolID ID) noexcept
-        : InfoCommonBase(ID)
+    explicit EnumSymbol(SymbolID ID) noexcept
+        : SymbolCommonBase(ID)
     {
     }
 };
 
 inline
 auto&
-allMembers(EnumInfo const& T)
+allMembers(EnumSymbol const& T)
 {
     return T.Constants;
 }
 
 MRDOCS_DECL
 void
-merge(EnumInfo& I, EnumInfo&& Other);
+merge(EnumSymbol& I, EnumSymbol&& Other);
 
-/** Map a EnumInfo to a dom::Object.
+/** Map a EnumSymbol to a dom::Object.
 
     @param t The tag type.
     @param io The IO object to use for mapping.
-    @param I The EnumInfo to map.
+    @param I The EnumSymbol to map.
     @param domCorpus The DomCorpus used to create
  */
 template <class IO>
@@ -84,7 +84,7 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    EnumInfo const& I,
+    EnumSymbol const& I,
     DomCorpus const* domCorpus)
 {
     tag_invoke(t, io, I.asInfo(), domCorpus);
@@ -93,10 +93,10 @@ tag_invoke(
     io.map("constants", dom::LazyArray(I.Constants, domCorpus));
 }
 
-/** Map the EnumInfo to a @ref dom::Value object.
+/** Map the EnumSymbol to a @ref dom::Value object.
 
     @param v The output parameter to receive the dom::Value.
-    @param I The EnumInfo to convert.
+    @param I The EnumSymbol to convert.
     @param domCorpus The DomCorpus used to resolve references.
  */
 inline
@@ -104,12 +104,12 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    EnumInfo const& I,
+    EnumSymbol const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_ENUM_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_ENUM_HPP
diff --git a/include/mrdocs/Metadata/Info/EnumConstant.hpp b/include/mrdocs/Metadata/Symbol/EnumConstant.hpp
similarity index 61%
rename from include/mrdocs/Metadata/Info/EnumConstant.hpp
rename to include/mrdocs/Metadata/Symbol/EnumConstant.hpp
index a9d01c005..5ff744f37 100644
--- a/include/mrdocs/Metadata/Info/EnumConstant.hpp
+++ b/include/mrdocs/Metadata/Symbol/EnumConstant.hpp
@@ -8,19 +8,19 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_ENUMCONSTANT_HPP
-#define MRDOCS_API_METADATA_INFO_ENUMCONSTANT_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_ENUMCONSTANT_HPP
+#define MRDOCS_API_METADATA_SYMBOL_ENUMCONSTANT_HPP
 
 #include <mrdocs/Metadata/Expression.hpp>
-#include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/Info/Source.hpp>
+#include <mrdocs/Metadata/Symbol.hpp>
+#include <mrdocs/Metadata/Symbol/Source.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Info for enum constants.
 */
-struct EnumConstantInfo final
-    : InfoCommonBase<InfoKind::EnumConstant>
+struct EnumConstantSymbol final
+    : SymbolCommonBase<SymbolKind::EnumConstant>
 {
     /** The initializer expression, if any
     */
@@ -28,21 +28,21 @@ struct EnumConstantInfo final
 
     //--------------------------------------------
 
-    explicit EnumConstantInfo(SymbolID ID) noexcept
-        : InfoCommonBase(ID)
+    explicit EnumConstantSymbol(SymbolID ID) noexcept
+        : SymbolCommonBase(ID)
     {
     }
 };
 
 MRDOCS_DECL
 void
-merge(EnumConstantInfo& I, EnumConstantInfo&& Other);
+merge(EnumConstantSymbol& I, EnumConstantSymbol&& Other);
 
-/** Map a EnumConstantInfo to a dom::Object.
+/** Map a EnumConstantSymbol to a dom::Object.
 
     @param t The tag type.
     @param io The IO object to use for mapping.
-    @param I The EnumConstantInfo to map.
+    @param I The EnumConstantSymbol to map.
     @param domCorpus The DomCorpus used to create
  */
 template <class IO>
@@ -50,7 +50,7 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    EnumConstantInfo const& I,
+    EnumConstantSymbol const& I,
     DomCorpus const* domCorpus)
 {
     tag_invoke(t, io, I.asInfo(), domCorpus);
@@ -60,19 +60,19 @@ tag_invoke(
     }
 }
 
-/** Map the EnumConstantInfo to a @ref dom::Value object.
+/** Map the EnumConstantSymbol to a @ref dom::Value object.
  */
 inline
 void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    EnumConstantInfo const& I,
+    EnumConstantSymbol const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_ENUMCONSTANT_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_ENUMCONSTANT_HPP
diff --git a/include/mrdocs/Metadata/Info/ExtractionMode.hpp b/include/mrdocs/Metadata/Symbol/ExtractionMode.hpp
similarity index 91%
rename from include/mrdocs/Metadata/Info/ExtractionMode.hpp
rename to include/mrdocs/Metadata/Symbol/ExtractionMode.hpp
index 862a6ae25..b0db5f48e 100644
--- a/include/mrdocs/Metadata/Info/ExtractionMode.hpp
+++ b/include/mrdocs/Metadata/Symbol/ExtractionMode.hpp
@@ -9,12 +9,12 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_EXTRACTIONMODE_HPP
-#define MRDOCS_API_METADATA_INFO_EXTRACTIONMODE_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_EXTRACTIONMODE_HPP
+#define MRDOCS_API_METADATA_SYMBOL_EXTRACTIONMODE_HPP
 
 #include <mrdocs/Dom.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Determine why a symbol is extracted
 
@@ -54,7 +54,7 @@ enum class ExtractionMode
     Dependency,
 };
 
-/** Return the name of the InfoKind as a string.
+/** Return the name of the SymbolKind as a string.
  */
 constexpr
 std::string_view
@@ -74,7 +74,7 @@ toString(ExtractionMode kind) noexcept
     MRDOCS_UNREACHABLE();
 }
 
-/** Return the InfoKind from a @ref dom::Value string.
+/** Return the SymbolKind from a @ref dom::Value string.
  */
 inline
 void
@@ -119,6 +119,6 @@ mostSpecific(ExtractionMode const a, ExtractionMode const b) noexcept
             std::max(static_cast<IT>(a), static_cast<IT>(b)));
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_EXTRACTIONMODE_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_EXTRACTIONMODE_HPP
diff --git a/include/mrdocs/Metadata/Info/FileKind.hpp b/include/mrdocs/Metadata/Symbol/FileKind.hpp
similarity index 83%
rename from include/mrdocs/Metadata/Info/FileKind.hpp
rename to include/mrdocs/Metadata/Symbol/FileKind.hpp
index 03e4a4fca..87f966956 100644
--- a/include/mrdocs/Metadata/Info/FileKind.hpp
+++ b/include/mrdocs/Metadata/Symbol/FileKind.hpp
@@ -10,15 +10,15 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_FILEKIND_HPP
-#define MRDOCS_API_METADATA_INFO_FILEKIND_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_FILEKIND_HPP
+#define MRDOCS_API_METADATA_SYMBOL_FILEKIND_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Nullable.hpp>
 #include <mrdocs/Dom.hpp>
 #include <string>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 enum class FileKind
 {
@@ -44,6 +44,6 @@ tag_invoke(
     v = toString(kind);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_FILEKIND_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_FILEKIND_HPP
diff --git a/include/mrdocs/Metadata/Info/Friend.hpp b/include/mrdocs/Metadata/Symbol/Friend.hpp
similarity index 86%
rename from include/mrdocs/Metadata/Info/Friend.hpp
rename to include/mrdocs/Metadata/Symbol/Friend.hpp
index 15ae6cb0d..6dabb0c38 100644
--- a/include/mrdocs/Metadata/Info/Friend.hpp
+++ b/include/mrdocs/Metadata/Symbol/Friend.hpp
@@ -8,14 +8,14 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_FRIEND_HPP
-#define MRDOCS_API_METADATA_INFO_FRIEND_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_FRIEND_HPP
+#define MRDOCS_API_METADATA_SYMBOL_FRIEND_HPP
 
-#include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/Info/Source.hpp>
+#include <mrdocs/Metadata/Symbol.hpp>
+#include <mrdocs/Metadata/Symbol/Source.hpp>
 #include <mrdocs/Metadata/Type.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Info for friend declarations.
 
@@ -39,7 +39,7 @@ struct FriendInfo final
 
         This member is nullable and only used when befriending a type.
     */
-    Optional<Polymorphic<TypeInfo>> Type = std::nullopt;
+    Optional<Polymorphic<struct Type>> Type = std::nullopt;
 };
 
 MRDOCS_DECL
@@ -90,6 +90,6 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_FRIEND_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_FRIEND_HPP
diff --git a/include/mrdocs/Metadata/Info/Function.hpp b/include/mrdocs/Metadata/Symbol/Function.hpp
similarity index 82%
rename from include/mrdocs/Metadata/Info/Function.hpp
rename to include/mrdocs/Metadata/Symbol/Function.hpp
index 2b991eadb..17ca2953b 100644
--- a/include/mrdocs/Metadata/Info/Function.hpp
+++ b/include/mrdocs/Metadata/Symbol/Function.hpp
@@ -11,24 +11,24 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_FUNCTION_HPP
-#define MRDOCS_API_METADATA_INFO_FUNCTION_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_FUNCTION_HPP
+#define MRDOCS_API_METADATA_SYMBOL_FUNCTION_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Optional.hpp>
-#include <mrdocs/Metadata/Info/FunctionClass.hpp>
-#include <mrdocs/Metadata/Info/InfoBase.hpp>
-#include <mrdocs/Metadata/Info/Param.hpp>
+#include <mrdocs/Metadata/Symbol/FunctionClass.hpp>
+#include <mrdocs/Metadata/Symbol/Param.hpp>
+#include <mrdocs/Metadata/Symbol/SymbolBase.hpp>
 #include <mrdocs/Metadata/Template.hpp>
 #include <string>
 #include <vector>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 // TODO: Expand to allow for documenting templating and default args.
 // Info for functions.
-struct FunctionInfo final
-    : InfoCommonBase<InfoKind::Function>
+struct FunctionSymbol final
+    : SymbolCommonBase<SymbolKind::Function>
 {
     /** Info about the return type of this function.
 
@@ -38,7 +38,7 @@ struct FunctionInfo final
         By default, we also use `auto` in the member to indicate
         an unknown return type.
      */
-    Polymorphic<TypeInfo> ReturnType = Polymorphic<TypeInfo>(AutoTypeInfo{});
+    Polymorphic<Type> ReturnType = Polymorphic<Type>(AutoType{});
 
     /// List of parameters.
     std::vector<Param> Params;
@@ -79,24 +79,24 @@ struct FunctionInfo final
 
     //--------------------------------------------
 
-    explicit FunctionInfo(SymbolID const& ID) noexcept
-        : InfoCommonBase(ID)
+    explicit FunctionSymbol(SymbolID const& ID) noexcept
+        : SymbolCommonBase(ID)
     {
     }
 
     std::strong_ordering
-    operator<=>(FunctionInfo const& other) const;
+    operator<=>(FunctionSymbol const& other) const;
 };
 
 MRDOCS_DECL
 void
-merge(FunctionInfo& I, FunctionInfo&& Other);
+merge(FunctionSymbol& I, FunctionSymbol&& Other);
 
-/** Map a FunctionInfo to a dom::Object.
+/** Map a FunctionSymbol to a dom::Object.
 
     @param t The tag type.
     @param io The IO object to use for mapping.
-    @param I The FunctionInfo to map.
+    @param I The FunctionSymbol to map.
     @param domCorpus The DomCorpus used to create
  */
 template <class IO>
@@ -104,7 +104,7 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    FunctionInfo const& I,
+    FunctionSymbol const& I,
     DomCorpus const* domCorpus)
 {
     tag_invoke(t, io, I.asInfo(), domCorpus);
@@ -150,10 +150,10 @@ tag_invoke(
     io.map("attributes", dom::LazyArray(I.Attributes));
 }
 
-/** Map the FunctionInfo to a @ref dom::Value object.
+/** Map the FunctionSymbol to a @ref dom::Value object.
 
     @param v The output parameter to receive the dom::Value.
-    @param I The FunctionInfo to convert.
+    @param I The FunctionSymbol to convert.
     @param domCorpus The DomCorpus used to resolve references.
  */
 inline
@@ -161,7 +161,7 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    FunctionInfo const& I,
+    FunctionSymbol const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
@@ -174,8 +174,8 @@ tag_invoke(
  */
 MRDOCS_DECL
 bool
-overrides(FunctionInfo const& base, FunctionInfo const& derived);
+overrides(FunctionSymbol const& base, FunctionSymbol const& derived);
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_FUNCTION_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_FUNCTION_HPP
diff --git a/include/mrdocs/Metadata/Info/FunctionClass.hpp b/include/mrdocs/Metadata/Symbol/FunctionClass.hpp
similarity index 85%
rename from include/mrdocs/Metadata/Info/FunctionClass.hpp
rename to include/mrdocs/Metadata/Symbol/FunctionClass.hpp
index 929efca43..b3f0f1743 100644
--- a/include/mrdocs/Metadata/Info/FunctionClass.hpp
+++ b/include/mrdocs/Metadata/Symbol/FunctionClass.hpp
@@ -11,13 +11,13 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_FUNCTIONCLASS_HPP
-#define MRDOCS_API_METADATA_INFO_FUNCTIONCLASS_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_FUNCTIONCLASS_HPP
+#define MRDOCS_API_METADATA_SYMBOL_FUNCTIONCLASS_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Function classifications */
 enum class FunctionClass
@@ -48,6 +48,6 @@ tag_invoke(
     v = toString(kind);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_SYMBOL_FUNCTIONCLASS_HPP
diff --git a/include/mrdocs/Metadata/Info/Guide.hpp b/include/mrdocs/Metadata/Symbol/Guide.hpp
similarity index 65%
rename from include/mrdocs/Metadata/Info/Guide.hpp
rename to include/mrdocs/Metadata/Symbol/Guide.hpp
index 2e3175928..402ccb469 100644
--- a/include/mrdocs/Metadata/Info/Guide.hpp
+++ b/include/mrdocs/Metadata/Symbol/Guide.hpp
@@ -8,31 +8,31 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_GUIDE_HPP
-#define MRDOCS_API_METADATA_INFO_GUIDE_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_GUIDE_HPP
+#define MRDOCS_API_METADATA_SYMBOL_GUIDE_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
-#include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/Info/Function.hpp>
-#include <mrdocs/Metadata/Info/Source.hpp>
+#include <mrdocs/Metadata/Symbol.hpp>
+#include <mrdocs/Metadata/Symbol/Function.hpp>
+#include <mrdocs/Metadata/Symbol/Source.hpp>
 #include <mrdocs/Metadata/Template.hpp>
 #include <mrdocs/Metadata/Type.hpp>
 #include <vector>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Info for deduction guides.
 */
-struct GuideInfo final
-    : InfoCommonBase<InfoKind::Guide>
+struct GuideSymbol final
+    : SymbolCommonBase<SymbolKind::Guide>
 {
     /** The pattern for the deduced specialization.
 
-        This is always a SpecializationTypeInfo.
+        This is always a SpecializationType.
     */
-    Polymorphic<TypeInfo> Deduced = Polymorphic<TypeInfo>(AutoTypeInfo{});
+    Polymorphic<Type> Deduced = Polymorphic<Type>(AutoType{});
 
     /** Template head, if any.
     */
@@ -48,23 +48,23 @@ struct GuideInfo final
 
     //--------------------------------------------
 
-    explicit GuideInfo(SymbolID ID) noexcept
-        : InfoCommonBase(ID)
+    explicit GuideSymbol(SymbolID ID) noexcept
+        : SymbolCommonBase(ID)
     {}
 
     std::strong_ordering
-    operator<=>(GuideInfo const& other) const;
+    operator<=>(GuideSymbol const& other) const;
 };
 
 MRDOCS_DECL
 void
-merge(GuideInfo& I, GuideInfo&& Other);
+merge(GuideSymbol& I, GuideSymbol&& Other);
 
-/** Map a GuideInfo to a dom::Object.
+/** Map a GuideSymbol to a dom::Object.
 
     @param t The tag type.
     @param io The IO object to use for mapping.
-    @param I The GuideInfo to map.
+    @param I The GuideSymbol to map.
     @param domCorpus The DomCorpus used to create
  */
 template <class IO>
@@ -72,7 +72,7 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    GuideInfo const& I,
+    GuideSymbol const& I,
     DomCorpus const* domCorpus)
 {
     tag_invoke(t, io, I.asInfo(), domCorpus);
@@ -82,19 +82,19 @@ tag_invoke(
     io.map("explicitSpec", I.Explicit);
 }
 
-/** Map the GuideInfo to a @ref dom::Value object.
+/** Map the GuideSymbol to a @ref dom::Value object.
  */
 inline
 void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    GuideInfo const& I,
+    GuideSymbol const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_GUIDE_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_GUIDE_HPP
diff --git a/include/mrdocs/Metadata/Info/Location.hpp b/include/mrdocs/Metadata/Symbol/Location.hpp
similarity index 94%
rename from include/mrdocs/Metadata/Info/Location.hpp
rename to include/mrdocs/Metadata/Symbol/Location.hpp
index 260557586..d9e15c53b 100644
--- a/include/mrdocs/Metadata/Info/Location.hpp
+++ b/include/mrdocs/Metadata/Symbol/Location.hpp
@@ -10,15 +10,15 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_LOCATION_HPP
-#define MRDOCS_API_METADATA_INFO_LOCATION_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_LOCATION_HPP
+#define MRDOCS_API_METADATA_SYMBOL_LOCATION_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Nullable.hpp>
 #include <mrdocs/Dom.hpp>
 #include <string>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 struct MRDOCS_DECL
     Location
@@ -121,6 +121,6 @@ struct nullable_traits<Location>
     }
 };
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_LOCATION_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_LOCATION_HPP
diff --git a/include/mrdocs/Metadata/Info/Namespace.hpp b/include/mrdocs/Metadata/Symbol/Namespace.hpp
similarity index 83%
rename from include/mrdocs/Metadata/Info/Namespace.hpp
rename to include/mrdocs/Metadata/Symbol/Namespace.hpp
index f15778c38..43a2c14ed 100644
--- a/include/mrdocs/Metadata/Info/Namespace.hpp
+++ b/include/mrdocs/Metadata/Symbol/Namespace.hpp
@@ -9,16 +9,16 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_NAMESPACE_HPP
-#define MRDOCS_API_METADATA_INFO_NAMESPACE_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_NAMESPACE_HPP
+#define MRDOCS_API_METADATA_SYMBOL_NAMESPACE_HPP
 
 #include <mrdocs/Dom/LazyArray.hpp>
-#include <mrdocs/Metadata/Info.hpp>
 #include <mrdocs/Metadata/Name.hpp>
+#include <mrdocs/Metadata/Symbol.hpp>
 #include <ranges>
 #include <vector>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** The members of a Namespace
  */
@@ -107,44 +107,44 @@ tag_invoke(
 
 /** Describes a namespace.
 */
-struct NamespaceInfo final
-    : InfoCommonBase<InfoKind::Namespace>
+struct NamespaceSymbol final
+    : SymbolCommonBase<SymbolKind::Namespace>
 {
     bool IsInline = false;
     bool IsAnonymous = false;
 
     /** Namespaces nominated by using-directives.
     */
-    std::vector<NameInfo> UsingDirectives;
+    std::vector<struct Name> UsingDirectives;
 
     /** The members of this namespace.
     */
     NamespaceTranche Members;
 
-    explicit NamespaceInfo(SymbolID const &ID) noexcept
-        : InfoCommonBase(ID)
+    explicit NamespaceSymbol(SymbolID const &ID) noexcept
+        : SymbolCommonBase(ID)
     {
     }
 
     std::strong_ordering
-    operator<=>(NamespaceInfo const&) const;
+    operator<=>(NamespaceSymbol const&) const;
 };
 
 MRDOCS_DECL
-void merge(NamespaceInfo& I, NamespaceInfo&& Other);
+void merge(NamespaceSymbol& I, NamespaceSymbol&& Other);
 
 inline
 auto
-allMembers(NamespaceInfo const& T)
+allMembers(NamespaceSymbol const& T)
 {
     return allMembers(T.Members);
 }
 
-/** Map a NamespaceInfo to a dom::Object.
+/** Map a NamespaceSymbol to a dom::Object.
 
     @param t The tag type.
     @param io The IO object to use for mapping.
-    @param I The NamespaceInfo to map.
+    @param I The NamespaceSymbol to map.
     @param domCorpus The DomCorpus used to create
  */
 template <class IO>
@@ -152,7 +152,7 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    NamespaceInfo const& I,
+    NamespaceSymbol const& I,
     DomCorpus const* domCorpus)
 {
     tag_invoke(t, io, I.asInfo(), domCorpus);
@@ -162,19 +162,19 @@ tag_invoke(
     io.map("usingDirectives", dom::LazyArray(I.UsingDirectives, domCorpus));
 }
 
-/** Map the NamespaceInfo to a @ref dom::Value object.
+/** Map the NamespaceSymbol to a @ref dom::Value object.
  */
 inline
 void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    NamespaceInfo const& I,
+    NamespaceSymbol const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_NAMESPACE_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_NAMESPACE_HPP
diff --git a/include/mrdocs/Metadata/Info/NamespaceAlias.hpp b/include/mrdocs/Metadata/Symbol/NamespaceAlias.hpp
similarity index 61%
rename from include/mrdocs/Metadata/Info/NamespaceAlias.hpp
rename to include/mrdocs/Metadata/Symbol/NamespaceAlias.hpp
index f0fd344e6..8ede49e96 100644
--- a/include/mrdocs/Metadata/Info/NamespaceAlias.hpp
+++ b/include/mrdocs/Metadata/Symbol/NamespaceAlias.hpp
@@ -8,45 +8,45 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_NAMESPACEALIAS_HPP
-#define MRDOCS_API_METADATA_INFO_NAMESPACEALIAS_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_NAMESPACEALIAS_HPP
+#define MRDOCS_API_METADATA_SYMBOL_NAMESPACEALIAS_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
-#include <mrdocs/Metadata/Info.hpp>
 #include <mrdocs/Metadata/Name.hpp>
+#include <mrdocs/Metadata/Symbol.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Info for namespace aliases.
 */
-struct NamespaceAliasInfo final
-    : InfoCommonBase<InfoKind::NamespaceAlias>
+struct NamespaceAliasSymbol final
+    : SymbolCommonBase<SymbolKind::NamespaceAlias>
 {
     /** The aliased symbol.
 
         This is another namespace that might or might
         not be in the same project.
      */
-    IdentifierNameInfo AliasedSymbol;
+    IdentifierName AliasedSymbol;
 
     //--------------------------------------------
 
-    explicit NamespaceAliasInfo(SymbolID const &ID) noexcept
-        : InfoCommonBase(ID)
+    explicit NamespaceAliasSymbol(SymbolID const &ID) noexcept
+        : SymbolCommonBase(ID)
     {
     }
 };
 
 MRDOCS_DECL
 void
-merge(NamespaceAliasInfo& I, NamespaceAliasInfo&& Other);
+merge(NamespaceAliasSymbol& I, NamespaceAliasSymbol&& Other);
 
-/** Map a NamespaceAliasInfo to a dom::Object.
+/** Map a NamespaceAliasSymbol to a dom::Object.
 
     @param t The tag type.
     @param io The IO object to use for mapping.
-    @param I The NamespaceAliasInfo to map.
+    @param I The NamespaceAliasSymbol to map.
     @param domCorpus The DomCorpus used to create
  */
 template <class IO>
@@ -54,26 +54,26 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    NamespaceAliasInfo const& I,
+    NamespaceAliasSymbol const& I,
     DomCorpus const* domCorpus)
 {
     tag_invoke(t, io, I.asInfo(), domCorpus);
     io.map("aliasedSymbol", I.AliasedSymbol);
 }
 
-/** Map the NamespaceAliasInfo to a @ref dom::Value object.
+/** Map the NamespaceAliasSymbol to a @ref dom::Value object.
  */
 inline
 void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    NamespaceAliasInfo const& I,
+    NamespaceAliasSymbol const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_NAMESPACEALIAS_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_NAMESPACEALIAS_HPP
diff --git a/include/mrdocs/Metadata/Info/Overloads.hpp b/include/mrdocs/Metadata/Symbol/Overloads.hpp
similarity index 63%
rename from include/mrdocs/Metadata/Info/Overloads.hpp
rename to include/mrdocs/Metadata/Symbol/Overloads.hpp
index a5828c104..4912a6e34 100644
--- a/include/mrdocs/Metadata/Info/Overloads.hpp
+++ b/include/mrdocs/Metadata/Symbol/Overloads.hpp
@@ -8,19 +8,19 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_OVERLOADS_HPP
-#define MRDOCS_API_METADATA_INFO_OVERLOADS_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_OVERLOADS_HPP
+#define MRDOCS_API_METADATA_SYMBOL_OVERLOADS_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/Info/Function.hpp>
+#include <mrdocs/Metadata/Symbol.hpp>
+#include <mrdocs/Metadata/Symbol/Function.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Represents a set of function overloads.
  */
-struct OverloadsInfo final
-    : InfoCommonBase<InfoKind::Overloads>
+struct OverloadsSymbol final
+    : SymbolCommonBase<SymbolKind::Overloads>
 {
     /// The class of the functions.
     FunctionClass Class = FunctionClass::Normal;
@@ -37,38 +37,38 @@ struct OverloadsInfo final
         that type. Otherwise, it contains `auto` to indicate that
         the return type varies according to the parameters.
      */
-    Polymorphic<TypeInfo> ReturnType = Polymorphic<TypeInfo>(AutoTypeInfo{});
+    Polymorphic<Type> ReturnType = Polymorphic<Type>(AutoType{});
 
     //--------------------------------------------
 
-    explicit OverloadsInfo(SymbolID const& ID) noexcept
-    : InfoCommonBase(ID)
+    explicit OverloadsSymbol(SymbolID const& ID) noexcept
+    : SymbolCommonBase(ID)
     {
     }
 
     explicit
-    OverloadsInfo(SymbolID const& Parent, std::string_view Name, AccessKind Access, bool isStatic) noexcept;
+    OverloadsSymbol(SymbolID const& Parent, std::string_view Name, AccessKind Access, bool isStatic) noexcept;
 };
 
 MRDOCS_DECL
-void merge(OverloadsInfo& I, OverloadsInfo&& Other);
+void merge(OverloadsSymbol& I, OverloadsSymbol&& Other);
 
 inline
 auto&
-allMembers(OverloadsInfo const& T)
+allMembers(OverloadsSymbol const& T)
 {
     return T.Members;
 }
 
 MRDOCS_DECL
 void
-addMember(OverloadsInfo& I, FunctionInfo const& Member);
+addMember(OverloadsSymbol& I, FunctionSymbol const& Member);
 
-/** Map a OverloadsInfo to a dom::Object.
+/** Map a OverloadsSymbol to a dom::Object.
 
     @param t The tag type.
     @param io The IO object to use for mapping.
-    @param I The OverloadsInfo to map.
+    @param I The OverloadsSymbol to map.
     @param domCorpus The DomCorpus used to create
  */
 template <class IO>
@@ -76,7 +76,7 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    OverloadsInfo const& I,
+    OverloadsSymbol const& I,
     DomCorpus const* domCorpus)
 {
     tag_invoke(t, io, I.asInfo(), domCorpus);
@@ -85,19 +85,19 @@ tag_invoke(
     io.map("members", dom::LazyArray(I.Members, domCorpus));
 }
 
-/** Map the OverloadsInfo to a @ref dom::Value object.
+/** Map the OverloadsSymbol to a @ref dom::Value object.
  */
 inline
 void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    OverloadsInfo const& I,
+    OverloadsSymbol const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_OVERLOADS_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_OVERLOADS_HPP
diff --git a/include/mrdocs/Metadata/Info/Param.hpp b/include/mrdocs/Metadata/Symbol/Param.hpp
similarity index 84%
rename from include/mrdocs/Metadata/Info/Param.hpp
rename to include/mrdocs/Metadata/Symbol/Param.hpp
index 0de17e20d..a37e50f78 100644
--- a/include/mrdocs/Metadata/Info/Param.hpp
+++ b/include/mrdocs/Metadata/Symbol/Param.hpp
@@ -11,8 +11,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_PARAM_HPP
-#define MRDOCS_API_METADATA_INFO_PARAM_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_PARAM_HPP
+#define MRDOCS_API_METADATA_SYMBOL_PARAM_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Optional.hpp>
@@ -20,14 +20,14 @@
 #include <mrdocs/Metadata/Type.hpp>
 #include <string>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Represents a single function parameter */
 struct Param final
 {
     /** The type of this parameter
      */
-    Polymorphic<TypeInfo> Type = Polymorphic<TypeInfo>(AutoTypeInfo{});
+    Polymorphic<struct Type> Type = Polymorphic<struct Type>(AutoType{});
 
     /** The parameter name.
      */
@@ -43,7 +43,7 @@ struct Param final
     Param() = default;
 
     Param(
-        Polymorphic<TypeInfo>&& type,
+        Polymorphic<struct Type>&& type,
         std::string&& name,
         std::string&& def_arg)
         : Type(std::move(type))
@@ -69,6 +69,6 @@ tag_invoke(
     Param const& p,
     DomCorpus const* domCorpus);
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_PARAM_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_PARAM_HPP
diff --git a/include/mrdocs/Metadata/Info/Record.hpp b/include/mrdocs/Metadata/Symbol/Record.hpp
similarity index 76%
rename from include/mrdocs/Metadata/Info/Record.hpp
rename to include/mrdocs/Metadata/Symbol/Record.hpp
index da259b506..56cae709c 100644
--- a/include/mrdocs/Metadata/Info/Record.hpp
+++ b/include/mrdocs/Metadata/Symbol/Record.hpp
@@ -9,23 +9,23 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_RECORD_HPP
-#define MRDOCS_API_METADATA_INFO_RECORD_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_RECORD_HPP
+#define MRDOCS_API_METADATA_SYMBOL_RECORD_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Optional.hpp>
-#include <mrdocs/Metadata/Info/Friend.hpp>
-#include <mrdocs/Metadata/Info/RecordBase.hpp>
-#include <mrdocs/Metadata/Info/RecordInterface.hpp>
-#include <mrdocs/Metadata/Info/RecordKeyKind.hpp>
+#include <mrdocs/Metadata/Symbol/Friend.hpp>
+#include <mrdocs/Metadata/Symbol/RecordBase.hpp>
+#include <mrdocs/Metadata/Symbol/RecordInterface.hpp>
+#include <mrdocs/Metadata/Symbol/RecordKeyKind.hpp>
 #include <mrdocs/Metadata/Template.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Metadata for struct, class, or union.
 */
-struct RecordInfo final
-    : InfoCommonBase<InfoKind::Record>
+struct RecordSymbol final
+    : SymbolCommonBase<SymbolKind::Record>
 {
     /** Kind of record this is (class, struct, or union).
     */
@@ -62,13 +62,13 @@ struct RecordInfo final
 
     //--------------------------------------------
 
-    explicit RecordInfo(SymbolID const& ID) noexcept
-        : InfoCommonBase(ID)
+    explicit RecordSymbol(SymbolID const& ID) noexcept
+        : SymbolCommonBase(ID)
     {
     }
 
     std::strong_ordering
-    operator<=>(RecordInfo const& other) const;
+    operator<=>(RecordSymbol const& other) const;
 };
 
 constexpr
@@ -90,20 +90,20 @@ getDefaultAccessString(
 
 inline
 auto
-allMembers(RecordInfo const& T)
+allMembers(RecordSymbol const& T)
 {
     return allMembers(T.Interface);
 }
 
 MRDOCS_DECL
 void
-merge(RecordInfo& I, RecordInfo&& Other);
+merge(RecordSymbol& I, RecordSymbol&& Other);
 
-/** Map a RecordInfo to a dom::Object.
+/** Map a RecordSymbol to a dom::Object.
 
     @param t The tag type.
     @param io The IO object to use for mapping.
-    @param I The RecordInfo to map.
+    @param I The RecordSymbol to map.
     @param domCorpus The DomCorpus used to create
  */
 template <class IO>
@@ -111,7 +111,7 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    RecordInfo const& I,
+    RecordSymbol const& I,
     DomCorpus const* domCorpus)
 {
     tag_invoke(t, io, I.asInfo(), domCorpus);
@@ -126,19 +126,19 @@ tag_invoke(
     io.map("friends", dom::LazyArray(I.Friends, domCorpus));
 }
 
-/** Map the RecordInfo to a @ref dom::Value object.
+/** Map the RecordSymbol to a @ref dom::Value object.
  */
 inline
 void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    RecordInfo const& I,
+    RecordSymbol const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_RECORD_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_RECORD_HPP
diff --git a/include/mrdocs/Metadata/Info/RecordBase.hpp b/include/mrdocs/Metadata/Symbol/RecordBase.hpp
similarity index 74%
rename from include/mrdocs/Metadata/Info/RecordBase.hpp
rename to include/mrdocs/Metadata/Symbol/RecordBase.hpp
index 982371c0a..8045a2753 100644
--- a/include/mrdocs/Metadata/Info/RecordBase.hpp
+++ b/include/mrdocs/Metadata/Symbol/RecordBase.hpp
@@ -9,14 +9,14 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_RECORDBASE_HPP
-#define MRDOCS_API_METADATA_INFO_RECORDBASE_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_RECORDBASE_HPP
+#define MRDOCS_API_METADATA_SYMBOL_RECORDBASE_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Metadata/Specifiers/AccessKind.hpp>
 #include <mrdocs/Metadata/Type.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Metadata for a direct base.
 */
@@ -24,11 +24,11 @@ struct BaseInfo
 {
     /** The base type.
 
-        This is typically a `NamedTypeInfo` that refers to a
-        `RecordInfo`, but it could also be a more complex type
+        This is typically a `NamedType` that refers to a
+        `RecordSymbol`, but it could also be a more complex type
         such as a `decltype`.
      */
-    Polymorphic<TypeInfo> Type;
+    Polymorphic<struct Type> Type;
 
     /** The access specifier for the base.
      */
@@ -41,7 +41,7 @@ struct BaseInfo
     BaseInfo() = delete;
 
     BaseInfo(
-        Polymorphic<TypeInfo>&& type,
+        Polymorphic<struct Type>&& type,
         AccessKind const access,
         bool const is_virtual)
         : Type(std::move(type))
@@ -59,6 +59,6 @@ tag_invoke(
     BaseInfo const& I,
     DomCorpus const* domCorpus);
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_RECORDBASE_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_RECORDBASE_HPP
diff --git a/include/mrdocs/Metadata/Info/RecordInterface.hpp b/include/mrdocs/Metadata/Symbol/RecordInterface.hpp
similarity index 91%
rename from include/mrdocs/Metadata/Info/RecordInterface.hpp
rename to include/mrdocs/Metadata/Symbol/RecordInterface.hpp
index acfdbe32a..022b92ca4 100644
--- a/include/mrdocs/Metadata/Info/RecordInterface.hpp
+++ b/include/mrdocs/Metadata/Symbol/RecordInterface.hpp
@@ -9,13 +9,13 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_RECORDINTERFACE_HPP
-#define MRDOCS_API_METADATA_INFO_RECORDINTERFACE_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_RECORDINTERFACE_HPP
+#define MRDOCS_API_METADATA_SYMBOL_RECORDINTERFACE_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Info/RecordTranche.hpp>
+#include <mrdocs/Metadata/Symbol/RecordTranche.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** The aggregated interface for a given struct, class, or union.
 
@@ -116,6 +116,6 @@ allMembers(RecordInterface const& T)
         std::ranges::views::join;
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_RECORDINTERFACE_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_RECORDINTERFACE_HPP
diff --git a/include/mrdocs/Metadata/Info/RecordKeyKind.hpp b/include/mrdocs/Metadata/Symbol/RecordKeyKind.hpp
similarity index 80%
rename from include/mrdocs/Metadata/Info/RecordKeyKind.hpp
rename to include/mrdocs/Metadata/Symbol/RecordKeyKind.hpp
index c48726341..14a673ec1 100644
--- a/include/mrdocs/Metadata/Info/RecordKeyKind.hpp
+++ b/include/mrdocs/Metadata/Symbol/RecordKeyKind.hpp
@@ -9,14 +9,14 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_RECORDKEYKIND_HPP
-#define MRDOCS_API_METADATA_INFO_RECORDKEYKIND_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_RECORDKEYKIND_HPP
+#define MRDOCS_API_METADATA_SYMBOL_RECORDKEYKIND_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom.hpp>
 #include <string>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** The kind of record: struct, class, or union.
 */
@@ -44,6 +44,6 @@ tag_invoke(
     v = toString(kind);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_RECORDKEYKIND_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_RECORDKEYKIND_HPP
diff --git a/include/mrdocs/Metadata/Info/RecordTranche.hpp b/include/mrdocs/Metadata/Symbol/RecordTranche.hpp
similarity index 93%
rename from include/mrdocs/Metadata/Info/RecordTranche.hpp
rename to include/mrdocs/Metadata/Symbol/RecordTranche.hpp
index c83b87b1f..8a3b88bfc 100644
--- a/include/mrdocs/Metadata/Info/RecordTranche.hpp
+++ b/include/mrdocs/Metadata/Symbol/RecordTranche.hpp
@@ -9,16 +9,16 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_RECORDTRANCHE_HPP
-#define MRDOCS_API_METADATA_INFO_RECORDTRANCHE_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_RECORDTRANCHE_HPP
+#define MRDOCS_API_METADATA_SYMBOL_RECORDTRANCHE_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom/LazyArray.hpp>
 #include <mrdocs/Dom/LazyObject.hpp>
-#include <mrdocs/Metadata/Info/SymbolID.hpp>
+#include <mrdocs/Metadata/Symbol/SymbolID.hpp>
 #include <vector>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** A group of members that have the same access specifier.
 
@@ -116,6 +116,6 @@ tag_invoke(
 }
 
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_RECORDTRANCHE_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_RECORDTRANCHE_HPP
diff --git a/include/mrdocs/Metadata/Info/Source.hpp b/include/mrdocs/Metadata/Symbol/Source.hpp
similarity index 87%
rename from include/mrdocs/Metadata/Info/Source.hpp
rename to include/mrdocs/Metadata/Symbol/Source.hpp
index b38a20c67..910a991f2 100644
--- a/include/mrdocs/Metadata/Info/Source.hpp
+++ b/include/mrdocs/Metadata/Symbol/Source.hpp
@@ -10,16 +10,16 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_SOURCE_HPP
-#define MRDOCS_API_METADATA_INFO_SOURCE_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_SOURCE_HPP
+#define MRDOCS_API_METADATA_SYMBOL_SOURCE_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/Dom.hpp>
-#include <mrdocs/Metadata/Info/Location.hpp>
+#include <mrdocs/Metadata/Symbol/Location.hpp>
 #include <string>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Stores source information for a declaration.
 */
@@ -66,6 +66,6 @@ tag_invoke(
     dom::Value& v,
     SourceInfo const& I);
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_SOURCE_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_SOURCE_HPP
diff --git a/include/mrdocs/Metadata/Info/InfoBase.hpp b/include/mrdocs/Metadata/Symbol/SymbolBase.hpp
similarity index 59%
rename from include/mrdocs/Metadata/Info/InfoBase.hpp
rename to include/mrdocs/Metadata/Symbol/SymbolBase.hpp
index 59c1f9456..906847c19 100644
--- a/include/mrdocs/Metadata/Info/InfoBase.hpp
+++ b/include/mrdocs/Metadata/Symbol/SymbolBase.hpp
@@ -9,28 +9,27 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_INFOBASE_HPP
-#define MRDOCS_API_METADATA_INFO_INFOBASE_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_SYMBOLBASE_HPP
+#define MRDOCS_API_METADATA_SYMBOL_SYMBOLBASE_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Info/ExtractionMode.hpp>
-#include <mrdocs/Metadata/Info/InfoKind.hpp>
-#include <mrdocs/Metadata/Info/Source.hpp>
-#include <mrdocs/Metadata/Info/SymbolID.hpp>
 #include <mrdocs/Metadata/Javadoc.hpp>
 #include <mrdocs/Metadata/Specifiers/AccessKind.hpp>
+#include <mrdocs/Metadata/Symbol/ExtractionMode.hpp>
+#include <mrdocs/Metadata/Symbol/Source.hpp>
+#include <mrdocs/Metadata/Symbol/SymbolID.hpp>
+#include <mrdocs/Metadata/Symbol/SymbolKind.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /* Forward declarations
  */
-#define INFO(Type) struct Type##Info;
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
+#define INFO(Type) struct Type##Symbol;
+#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
 
 /** Base class with common properties of all symbols
 */
-struct MRDOCS_VISIBLE Info
-{
+struct MRDOCS_VISIBLE Symbol {
     /** The unqualified name.
      */
     std::string Name;
@@ -41,7 +40,7 @@ struct MRDOCS_VISIBLE Info
 
     /** Kind of declaration.
     */
-    InfoKind Kind = InfoKind::None;
+    SymbolKind Kind = SymbolKind::None;
 
     /** The unique identifier for this symbol.
      */
@@ -85,72 +84,72 @@ struct MRDOCS_VISIBLE Info
 
     //--------------------------------------------
 
-    virtual ~Info() = default;
+    virtual ~Symbol() = default;
 
     #define INFO(Type) constexpr bool is##Type() const noexcept { \
-        return Kind == InfoKind::Type; \
+        return Kind == SymbolKind::Type; \
     }
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
+#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
 
-    constexpr Info const& asInfo() const noexcept
+    constexpr Symbol const& asInfo() const noexcept
     {
         return *this;
     }
 
-    constexpr Info& asInfo() noexcept
+    constexpr Symbol& asInfo() noexcept
     {
         return *this;
     }
 
     #define INFO(Type) \
-    constexpr Type##Info const& as##Type() const noexcept { \
-        if (Kind == InfoKind::Type) \
-            return reinterpret_cast<Type##Info const&>(*this); \
+    constexpr Type##Symbol const& as##Type() const noexcept { \
+        if (Kind == SymbolKind::Type) \
+            return reinterpret_cast<Type##Symbol const&>(*this); \
         MRDOCS_UNREACHABLE(); \
     }
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
+#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
 
 #define INFO(Type) \
-    constexpr Type##Info & as##Type() noexcept { \
-        if (Kind == InfoKind::Type) \
-            return reinterpret_cast<Type##Info&>(*this); \
+    constexpr Type##Symbol & as##Type() noexcept { \
+        if (Kind == SymbolKind::Type) \
+            return reinterpret_cast<Type##Symbol&>(*this); \
         MRDOCS_UNREACHABLE(); \
     }
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
+#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
 
 #define INFO(Type) \
-    constexpr Type##Info const* as##Type##Ptr() const noexcept { \
-        if (Kind == InfoKind::Type) { return reinterpret_cast<Type##Info const*>(this); } \
+    constexpr Type##Symbol const* as##Type##Ptr() const noexcept { \
+        if (Kind == SymbolKind::Type) { return reinterpret_cast<Type##Symbol const*>(this); } \
         return nullptr; \
     }
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
+#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
 
 #define INFO(Type) \
-    constexpr Type##Info * as##Type##Ptr() noexcept { \
-        if (Kind == InfoKind::Type) { return reinterpret_cast<Type##Info *>(this); } \
+    constexpr Type##Symbol * as##Type##Ptr() noexcept { \
+        if (Kind == SymbolKind::Type) { return reinterpret_cast<Type##Symbol *>(this); } \
         return nullptr; \
     }
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
+#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
 
-    auto operator<=>(Info const&) const = default;
+    auto operator<=>(Symbol const&) const = default;
 
 protected:
-    constexpr Info() = default;
+    constexpr Symbol() = default;
 
-    Info(Info const& Other) = default;
+    Symbol(Symbol const& Other) = default;
 
     /** Move constructor.
      */
-    Info(Info&& Other) = default;
+    Symbol(Symbol&& Other) = default;
 
-    /** Construct an Info.
+    /** Construct an Symbol.
 
         @param kind The kind of symbol
         @param ID The unique identifier for this symbol
     */
     explicit
-        Info(
-            InfoKind const kind,
+        Symbol(
+            SymbolKind const kind,
             SymbolID const& ID) noexcept
         : Kind(kind)
         , id(ID)
@@ -166,57 +165,57 @@ struct MRDOCS_VISIBLE Info
     compile-time, indicating if the most-derived
     class is a certain type.
 */
-template <InfoKind K>
-struct InfoCommonBase : Info
+template <SymbolKind K>
+struct SymbolCommonBase : Symbol
 {
     /** The variant discriminator constant of the most-derived class.
 
-        It only distinguishes from `Info::kind` in that it is a constant.
+        It only distinguishes from `Symbol::kind` in that it is a constant.
 
      */
-    static constexpr InfoKind kind_id = K;
+    static constexpr SymbolKind kind_id = K;
 
     #define INFO(Kind) \
-    static constexpr bool is##Kind() noexcept { return K == InfoKind::Kind; }
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
+    static constexpr bool is##Kind() noexcept { return K == SymbolKind::Kind; }
+#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
 
-    auto operator<=>(InfoCommonBase const&) const = default;
+    auto operator<=>(SymbolCommonBase const&) const = default;
 
 protected:
-    InfoCommonBase() = default;
+    SymbolCommonBase() = default;
 
-    constexpr explicit InfoCommonBase(SymbolID const& ID)
-        : Info(K, ID)
+    constexpr explicit SymbolCommonBase(SymbolID const& ID)
+        : Symbol(K, ID)
     {
     }
 };
 
-/** Merges two Info objects.
+/** Merges two Symbol objects.
 
-    This function is used to merge two Info objects with the same SymbolID.
-    The function assumes that the two Info objects are of the same type.
+    This function is used to merge two Symbol objects with the same SymbolID.
+    The function assumes that the two Symbol objects are of the same type.
     If they are not, the function will fail.
 
-    @param I The Info object to merge into.
-    @param Other The Info object to merge from.
+    @param I The Symbol object to merge into.
+    @param Other The Symbol object to merge from.
 */
 MRDOCS_DECL
 void
-merge(Info& I, Info&& Other);
+merge(Symbol& I, Symbol&& Other);
 
 inline
 bool
-canMerge(Info const& I, Info const& Other)
+canMerge(Symbol const& I, Symbol const& Other)
 {
     return
         I.Kind == Other.Kind &&
         I.id == Other.id;
 }
 
-/** Map the Info to a @ref dom::Object.
+/** Map the Symbol to a @ref dom::Object.
 
     @param io The output parameter to receive the dom::Object.
-    @param I The Info to convert.
+    @param I The Symbol to convert.
     @param domCorpus The DomCorpus used to resolve references.
  */
 template <class IO>
@@ -224,7 +223,7 @@ void
 tag_invoke(
     dom::LazyObjectMapTag,
     IO& io,
-    Info const& I,
+    Symbol const& I,
     DomCorpus const* domCorpus)
 {
     MRDOCS_ASSERT(domCorpus);
@@ -252,14 +251,14 @@ tag_invoke(
     io.map("loc", I.Loc);
 }
 
-/** Return the Info as a @ref dom::Value object.
+/** Return the Symbol as a @ref dom::Value object.
  */
 inline
 void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    Info const& I,
+    Symbol const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
@@ -267,13 +266,13 @@ tag_invoke(
 
 inline
 Optional<Location>
-getPrimaryLocation(Info const& I)
+getPrimaryLocation(Symbol const& I)
 {
     return getPrimaryLocation(
         I.Loc,
         I.isRecord() || I.isEnum());
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_SYMBOL_SYMBOLBASE_HPP
diff --git a/include/mrdocs/Metadata/Info/SymbolID.hpp b/include/mrdocs/Metadata/Symbol/SymbolID.hpp
similarity index 94%
rename from include/mrdocs/Metadata/Info/SymbolID.hpp
rename to include/mrdocs/Metadata/Symbol/SymbolID.hpp
index 6d5380930..dde44b50d 100644
--- a/include/mrdocs/Metadata/Info/SymbolID.hpp
+++ b/include/mrdocs/Metadata/Symbol/SymbolID.hpp
@@ -10,8 +10,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_SYMBOLID_HPP
-#define MRDOCS_API_METADATA_INFO_SYMBOLID_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_SYMBOLID_HPP
+#define MRDOCS_API_METADATA_SYMBOL_SYMBOLID_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Optional.hpp>
@@ -22,7 +22,7 @@
 #include <string>
 #include <string_view>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 class DomCorpus;
 namespace dom {
     struct ValueFromTag;
@@ -214,17 +214,17 @@ tag_invoke(
     std::unique_ptr<SymbolID> const& t,
     DomCorpus const* domCorpus);
 
-} // clang::mrdocs
+} // mrdocs
 
 template<>
-struct std::hash<clang::mrdocs::SymbolID>
+struct std::hash<mrdocs::SymbolID>
 {
     std::size_t
-    operator()(clang::mrdocs::SymbolID const& id) const noexcept
+    operator()(mrdocs::SymbolID const& id) const noexcept
     {
         return std::hash<std::string_view>()(
             std::string_view(id));
     }
 };
 
-#endif // MRDOCS_API_METADATA_INFO_SYMBOLID_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_SYMBOLID_HPP
diff --git a/include/mrdocs/Metadata/Info/InfoKind.hpp b/include/mrdocs/Metadata/Symbol/SymbolKind.hpp
similarity index 55%
rename from include/mrdocs/Metadata/Info/InfoKind.hpp
rename to include/mrdocs/Metadata/Symbol/SymbolKind.hpp
index 6fb3a0f80..5e3f254bd 100644
--- a/include/mrdocs/Metadata/Info/InfoKind.hpp
+++ b/include/mrdocs/Metadata/Symbol/SymbolKind.hpp
@@ -9,52 +9,50 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_INFOKIND_HPP
-#define MRDOCS_API_METADATA_INFO_INFOKIND_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_SYMBOLKIND_HPP
+#define MRDOCS_API_METADATA_SYMBOL_SYMBOLKIND_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Info variant discriminator
 */
-enum class InfoKind
-{
+enum class SymbolKind {
     /// Kind is not specified.
     None = 0,
     #define INFO(Type) Type,
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
+#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
 };
 
-/** Return the name of the InfoKind as a string.
+/** Return the name of the SymbolKind as a string.
  */
 MRDOCS_DECL
 dom::String
-toString(InfoKind kind) noexcept;
+toString(SymbolKind kind) noexcept;
 
-/** Return the InfoKind from a @ref dom::Value string.
+/** Return the SymbolKind from a @ref dom::Value string.
  */
 inline
 void
 tag_invoke(
     dom::ValueFromTag,
-    dom::Value& v,
-    InfoKind const kind)
+    dom::Value& v, SymbolKind const kind)
 {
     v = toString(kind);
 }
 
 consteval
-std::underlying_type_t<InfoKind>
-countInfoKind()
+std::underlying_type_t<SymbolKind>
+countSymbolKind()
 {
-    std::underlying_type_t<InfoKind> count = 0;
+    std::underlying_type_t<SymbolKind> count = 0;
 #define INFO(Type) count++;
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
+#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
     return count;
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_SYMBOL_SYMBOLKIND_HPP
diff --git a/include/mrdocs/Metadata/Info/InfoNodes.inc b/include/mrdocs/Metadata/Symbol/SymbolNodes.inc
similarity index 100%
rename from include/mrdocs/Metadata/Info/InfoNodes.inc
rename to include/mrdocs/Metadata/Symbol/SymbolNodes.inc
diff --git a/include/mrdocs/Metadata/Info/Typedef.hpp b/include/mrdocs/Metadata/Symbol/Typedef.hpp
similarity index 69%
rename from include/mrdocs/Metadata/Info/Typedef.hpp
rename to include/mrdocs/Metadata/Symbol/Typedef.hpp
index 8b1669564..94af07d2c 100644
--- a/include/mrdocs/Metadata/Info/Typedef.hpp
+++ b/include/mrdocs/Metadata/Symbol/Typedef.hpp
@@ -10,23 +10,23 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_TYPEDEF_HPP
-#define MRDOCS_API_METADATA_INFO_TYPEDEF_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_TYPEDEF_HPP
+#define MRDOCS_API_METADATA_SYMBOL_TYPEDEF_HPP
 
 #include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
-#include <mrdocs/Metadata/Info.hpp>
 #include <mrdocs/Metadata/Name.hpp>
+#include <mrdocs/Metadata/Symbol.hpp>
 #include <mrdocs/Metadata/Template.hpp>
 #include <mrdocs/Metadata/Type.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 // Info for typedef and using statements.
-struct TypedefInfo final
-    : InfoCommonBase<InfoKind::Typedef>
+struct TypedefSymbol final
+    : SymbolCommonBase<SymbolKind::Typedef>
 {
-    Polymorphic<TypeInfo> Type = Polymorphic<TypeInfo>(NamedTypeInfo{});
+    Polymorphic<struct Type> Type = Polymorphic<struct Type>(NamedType{});
 
     /** Indicates if this is a new C++ "using"-style typedef
 
@@ -46,25 +46,25 @@ struct TypedefInfo final
 
     //--------------------------------------------
 
-    explicit TypedefInfo(SymbolID ID) noexcept
-        : InfoCommonBase(ID)
+    explicit TypedefSymbol(SymbolID ID) noexcept
+        : SymbolCommonBase(ID)
     {
     }
 
     std::strong_ordering
-    operator<=>(TypedefInfo const& other) const;
+    operator<=>(TypedefSymbol const& other) const;
 
 };
 
 MRDOCS_DECL
 void
-merge(TypedefInfo& I, TypedefInfo&& Other);
+merge(TypedefSymbol& I, TypedefSymbol&& Other);
 
-/** Map a TypedefInfo to a dom::Object.
+/** Map a TypedefSymbol to a dom::Object.
 
     @param t The tag type.
     @param io The IO object to use for mapping.
-    @param I The TypedefInfo to map.
+    @param I The TypedefSymbol to map.
     @param domCorpus The DomCorpus used to create
  */
 template <class IO>
@@ -72,7 +72,7 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    TypedefInfo const& I,
+    TypedefSymbol const& I,
     DomCorpus const* domCorpus)
 {
     tag_invoke(t, io, I.asInfo(), domCorpus);
@@ -81,10 +81,10 @@ tag_invoke(
     io.map("isUsing", I.IsUsing);
 }
 
-/** Map the TypedefInfo to a @ref dom::Value object.
+/** Map the TypedefSymbol to a @ref dom::Value object.
 
     @param v The output parameter to receive the dom::Value.
-    @param I The TypedefInfo to convert.
+    @param I The TypedefSymbol to convert.
     @param domCorpus The DomCorpus used to resolve references.
  */
 inline
@@ -92,12 +92,12 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    TypedefInfo const& I,
+    TypedefSymbol const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_TYPEDEF_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_TYPEDEF_HPP
diff --git a/include/mrdocs/Metadata/Info/Using.hpp b/include/mrdocs/Metadata/Symbol/Using.hpp
similarity index 82%
rename from include/mrdocs/Metadata/Info/Using.hpp
rename to include/mrdocs/Metadata/Symbol/Using.hpp
index 77dad5dc0..59c581bf5 100644
--- a/include/mrdocs/Metadata/Info/Using.hpp
+++ b/include/mrdocs/Metadata/Symbol/Using.hpp
@@ -8,18 +8,18 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_USING_HPP
-#define MRDOCS_API_METADATA_INFO_USING_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_USING_HPP
+#define MRDOCS_API_METADATA_SYMBOL_USING_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom/LazyArray.hpp>
-#include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/Info/Source.hpp>
 #include <mrdocs/Metadata/Name.hpp>
+#include <mrdocs/Metadata/Symbol.hpp>
+#include <mrdocs/Metadata/Symbol/Source.hpp>
 #include <mrdocs/Metadata/Type.hpp>
 #include <vector>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** The class of using declaration.
 
@@ -74,7 +74,7 @@ tag_invoke(
     using A::f; // where f is a function in namespace A
     @endcode
 
-    would be represented by a `UsingInfo` object.
+    would be represented by a `UsingSymbol` object.
 
     Using-declarations can be used to introduce namespace
     members into other namespaces and block scopes, or to
@@ -83,8 +83,8 @@ tag_invoke(
     and class scopes.
 
  */
-struct UsingInfo final
-    : InfoCommonBase<InfoKind::Using>
+struct UsingSymbol final
+    : SymbolCommonBase<SymbolKind::Using>
 {
     /** The using declaration.
     */
@@ -98,7 +98,7 @@ struct UsingInfo final
         Note that this can be a qualified name, such as
         `A::f` in the example above.
      */
-    Polymorphic<NameInfo> IntroducedName = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
+    Polymorphic<struct Name> IntroducedName = Polymorphic<struct Name>(std::in_place_type<IdentifierName>);
 
     /** The shadow declarations.
 
@@ -131,20 +131,20 @@ struct UsingInfo final
 
     //--------------------------------------------
 
-    explicit UsingInfo(SymbolID ID) noexcept
-        : InfoCommonBase(ID)
+    explicit UsingSymbol(SymbolID ID) noexcept
+        : SymbolCommonBase(ID)
     {
     }
 };
 
 MRDOCS_DECL
-void merge(UsingInfo& I, UsingInfo&& Other);
+void merge(UsingSymbol& I, UsingSymbol&& Other);
 
-/** Map a UsingInfo to a dom::Object.
+/** Map a UsingSymbol to a dom::Object.
 
     @param t The tag type.
     @param io The IO object to use for mapping.
-    @param I The UsingInfo to map.
+    @param I The UsingSymbol to map.
     @param domCorpus The DomCorpus used to create
  */
 template <class IO>
@@ -152,7 +152,7 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    UsingInfo const& I,
+    UsingSymbol const& I,
     DomCorpus const* domCorpus)
 {
     tag_invoke(t, io, I.asInfo(), domCorpus);
@@ -161,19 +161,19 @@ tag_invoke(
     io.map("qualifier", I.IntroducedName);
 }
 
-/** Map the UsingInfo to a @ref dom::Value object.
+/** Map the UsingSymbol to a @ref dom::Value object.
  */
 inline
 void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    UsingInfo const& I,
+    UsingSymbol const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_USING_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_USING_HPP
diff --git a/include/mrdocs/Metadata/Info/Variable.hpp b/include/mrdocs/Metadata/Symbol/Variable.hpp
similarity index 79%
rename from include/mrdocs/Metadata/Info/Variable.hpp
rename to include/mrdocs/Metadata/Symbol/Variable.hpp
index bfcf71b50..0772b80b6 100644
--- a/include/mrdocs/Metadata/Info/Variable.hpp
+++ b/include/mrdocs/Metadata/Symbol/Variable.hpp
@@ -9,30 +9,30 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_INFO_VARIABLE_HPP
-#define MRDOCS_API_METADATA_INFO_VARIABLE_HPP
+#ifndef MRDOCS_API_METADATA_SYMBOL_VARIABLE_HPP
+#define MRDOCS_API_METADATA_SYMBOL_VARIABLE_HPP
 
 #include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Dom/LazyArray.hpp>
 #include <mrdocs/Metadata/Expression.hpp>
-#include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/Info/Source.hpp>
+#include <mrdocs/Metadata/Symbol.hpp>
+#include <mrdocs/Metadata/Symbol/Source.hpp>
 #include <mrdocs/Metadata/Template.hpp>
 #include <mrdocs/Metadata/Type.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** A variable.
 
     This includes variables at namespace
     or record scope.
 */
-struct VariableInfo final
-    : InfoCommonBase<InfoKind::Variable>
+struct VariableSymbol final
+    : SymbolCommonBase<SymbolKind::Variable>
 {
     /** The type of the variable */
-    Polymorphic<TypeInfo> Type = Polymorphic<TypeInfo>(NamedTypeInfo{});
+    Polymorphic<struct Type> Type = Polymorphic<struct Type>(NamedType{});
 
     /** The template information, if any.
      */
@@ -78,24 +78,24 @@ struct VariableInfo final
 
     //--------------------------------------------
 
-    explicit VariableInfo(SymbolID const &ID) noexcept
-        : InfoCommonBase(ID)
+    explicit VariableSymbol(SymbolID const &ID) noexcept
+        : SymbolCommonBase(ID)
     {
     }
 
     std::strong_ordering
-    operator<=>(VariableInfo const& other) const;
+    operator<=>(VariableSymbol const& other) const;
 };
 
 MRDOCS_DECL
 void
-merge(VariableInfo& I, VariableInfo&& Other);
+merge(VariableSymbol& I, VariableSymbol&& Other);
 
-/** Map a VariableInfo to a dom::Object.
+/** Map a VariableSymbol to a dom::Object.
 
     @param t The tag type.
     @param io The IO object to use for mapping.
-    @param I The VariableInfo to map.
+    @param I The VariableSymbol to map.
     @param domCorpus The DomCorpus used to create
  */
 template <class IO>
@@ -103,7 +103,7 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    VariableInfo const& I,
+    VariableSymbol const& I,
     DomCorpus const* domCorpus)
 {
     tag_invoke(t, io, I.asInfo(), domCorpus);
@@ -136,19 +136,19 @@ tag_invoke(
     io.map("attributes", dom::LazyArray(I.Attributes));
 }
 
-/** Map the VariableInfo to a @ref dom::Value object.
+/** Map the VariableSymbol to a @ref dom::Value object.
  */
 inline
 void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    VariableInfo const& I,
+    VariableSymbol const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_INFO_VARIABLE_HPP
+#endif // MRDOCS_API_METADATA_SYMBOL_VARIABLE_HPP
diff --git a/include/mrdocs/Metadata/TArg.hpp b/include/mrdocs/Metadata/TArg.hpp
index 986bb8e96..97813035c 100644
--- a/include/mrdocs/Metadata/TArg.hpp
+++ b/include/mrdocs/Metadata/TArg.hpp
@@ -20,7 +20,7 @@
 #include <mrdocs/Metadata/TArg/TemplateTArg.hpp>
 #include <mrdocs/Metadata/TArg/TypeTArg.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 template<
     std::derived_from<TArg> TArgTy,
@@ -68,6 +68,6 @@ tag_invoke(
     tag_invoke(dom::ValueFromTag{}, v, *I, domCorpus);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/TArg/ConstantTArg.hpp b/include/mrdocs/Metadata/TArg/ConstantTArg.hpp
index 3cbe375a7..8bcf0d8a1 100644
--- a/include/mrdocs/Metadata/TArg/ConstantTArg.hpp
+++ b/include/mrdocs/Metadata/TArg/ConstantTArg.hpp
@@ -11,14 +11,14 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_TARG_NONTYPETARG_HPP
-#define MRDOCS_API_METADATA_TARG_NONTYPETARG_HPP
+#ifndef MRDOCS_API_METADATA_TARG_CONSTANTTARG_HPP
+#define MRDOCS_API_METADATA_TARG_CONSTANTTARG_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Metadata/Expression.hpp>
 #include <mrdocs/Metadata/TArg/TArgBase.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 struct ConstantTArg final
     : TArgCommonBase<TArgKind::Constant>
@@ -29,6 +29,6 @@ struct ConstantTArg final
     auto operator<=>(ConstantTArg const&) const = default;
 };
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_API_METADATA_TARG_NONTYPETARG_HPP
+#endif // MRDOCS_API_METADATA_TARG_CONSTANTTARG_HPP
diff --git a/include/mrdocs/Metadata/TArg/TArgBase.hpp b/include/mrdocs/Metadata/TArg/TArgBase.hpp
index 1f42fe682..8f957351f 100644
--- a/include/mrdocs/Metadata/TArg/TArgBase.hpp
+++ b/include/mrdocs/Metadata/TArg/TArgBase.hpp
@@ -17,7 +17,7 @@
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Metadata/TArg/TArgKind.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /* Forward declarations
  */
@@ -51,7 +51,7 @@ struct TArg
     }
 #include <mrdocs/Metadata/TArg/TArgInfoNodes.inc>
 
-    #define INFO(Type) \
+#define INFO(Type) \
     constexpr Type##TArg const& as##Type() const noexcept { \
         if (Kind == TArgKind::Type) \
             return reinterpret_cast<Type##TArg const&>(*this); \
@@ -121,6 +121,6 @@ tag_invoke(
     TArg const& I,
     DomCorpus const* domCorpus);
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_API_METADATA_TARG_TARGBASE_HPP
diff --git a/include/mrdocs/Metadata/TArg/TArgKind.hpp b/include/mrdocs/Metadata/TArg/TArgKind.hpp
index f1442fc81..a7f45272e 100644
--- a/include/mrdocs/Metadata/TArg/TArgKind.hpp
+++ b/include/mrdocs/Metadata/TArg/TArgKind.hpp
@@ -18,14 +18,14 @@
 #include <mrdocs/Dom.hpp>
 #include <string_view>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** The kind of template argument.
 */
 enum class TArgKind : int
 {
     #define INFO(Type) Type,
-    #include <mrdocs/Metadata/TArg/TArgInfoNodes.inc>
+#include <mrdocs/Metadata/TArg/TArgInfoNodes.inc>
 };
 
 MRDOCS_DECL
@@ -42,6 +42,6 @@ tag_invoke(
     v = toString(kind);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_API_METADATA_TARG_TARGKIND_HPP
diff --git a/include/mrdocs/Metadata/TArg/TemplateTArg.hpp b/include/mrdocs/Metadata/TArg/TemplateTArg.hpp
index 494283629..64bd3db20 100644
--- a/include/mrdocs/Metadata/TArg/TemplateTArg.hpp
+++ b/include/mrdocs/Metadata/TArg/TemplateTArg.hpp
@@ -19,7 +19,7 @@
 #include <mrdocs/Metadata/TArg/TArgBase.hpp>
 #include <mrdocs/Metadata/TArg/TypeTArg.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 struct TemplateTArg final
     : TArgCommonBase<TArgKind::Template>
@@ -33,6 +33,6 @@ struct TemplateTArg final
     auto operator<=>(TemplateTArg const&) const = default;
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_API_METADATA_TARG_TEMPLATETARG_HPP
diff --git a/include/mrdocs/Metadata/TArg/TypeTArg.hpp b/include/mrdocs/Metadata/TArg/TypeTArg.hpp
index a061d6124..432641439 100644
--- a/include/mrdocs/Metadata/TArg/TypeTArg.hpp
+++ b/include/mrdocs/Metadata/TArg/TypeTArg.hpp
@@ -18,18 +18,18 @@
 #include <mrdocs/Metadata/TArg/TArgBase.hpp>
 #include <mrdocs/Metadata/Type.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 struct TypeTArg final
     : TArgCommonBase<TArgKind::Type>
 {
     /** Template argument type.
      */
-    Polymorphic<TypeInfo> Type = Polymorphic<TypeInfo>(AutoTypeInfo{});
+    Polymorphic<struct Type> Type = Polymorphic<struct Type>(AutoType{});
 
     auto operator<=>(TypeTArg const&) const = default;
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_API_METADATA_TARG_TYPETARG_HPP
diff --git a/include/mrdocs/Metadata/TParam.hpp b/include/mrdocs/Metadata/TParam.hpp
index b2e2923ff..ee1fe6613 100644
--- a/include/mrdocs/Metadata/TParam.hpp
+++ b/include/mrdocs/Metadata/TParam.hpp
@@ -20,7 +20,7 @@
 #include <mrdocs/Metadata/TParam/TemplateTParam.hpp>
 #include <mrdocs/Metadata/TParam/TypeTParam.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 template<
     typename TParamTy,
@@ -76,6 +76,6 @@ tag_invoke(
 }
 
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/TParam/ConstantTParam.hpp b/include/mrdocs/Metadata/TParam/ConstantTParam.hpp
index 3146f9a7f..51b354736 100644
--- a/include/mrdocs/Metadata/TParam/ConstantTParam.hpp
+++ b/include/mrdocs/Metadata/TParam/ConstantTParam.hpp
@@ -20,7 +20,7 @@
 #include <mrdocs/Metadata/TParam/TParamBase.hpp>
 #include <mrdocs/Metadata/Type/TypeBase.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** A constant template parameter
 
@@ -32,11 +32,11 @@ struct ConstantTParam final
     : TParamCommonBase<TParamKind::Constant>
 {
     /** Type of the non-type template parameter */
-    Polymorphic<TypeInfo> Type = Polymorphic<TypeInfo>(AutoTypeInfo{});
+    Polymorphic<struct Type> Type = Polymorphic<struct Type>(AutoType{});
 
     std::strong_ordering operator<=>(ConstantTParam const&) const;
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_API_METADATA_TPARAM_CONSTANTTPARAM_HPP
diff --git a/include/mrdocs/Metadata/TParam/TParamBase.hpp b/include/mrdocs/Metadata/TParam/TParamBase.hpp
index baa7433b5..c6a269289 100644
--- a/include/mrdocs/Metadata/TParam/TParamBase.hpp
+++ b/include/mrdocs/Metadata/TParam/TParamBase.hpp
@@ -20,7 +20,7 @@
 #include <mrdocs/Metadata/TParam/TParamKind.hpp>
 #include <string>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 class DomCorpus;
 
@@ -65,7 +65,7 @@ struct TParam
     }
 #include <mrdocs/Metadata/TParam/TParamInfoNodes.inc>
 
-    #define INFO(Type) \
+#define INFO(Type) \
     constexpr Type##TParam const& as##Type() const noexcept { \
         if (Kind == TParamKind::Type) \
             return reinterpret_cast<Type##TParam const&>(*this); \
@@ -134,6 +134,6 @@ struct TParamCommonBase : TParam
     }
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/TParam/TParamKeyKind.hpp b/include/mrdocs/Metadata/TParam/TParamKeyKind.hpp
index 53dd13e15..a897eb7c4 100644
--- a/include/mrdocs/Metadata/TParam/TParamKeyKind.hpp
+++ b/include/mrdocs/Metadata/TParam/TParamKeyKind.hpp
@@ -18,7 +18,7 @@
 #include <mrdocs/Dom.hpp>
 #include <string_view>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** The keyword a template parameter was declared with */
 enum class TParamKeyKind : int
@@ -43,6 +43,6 @@ tag_invoke(
     v = toString(kind);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/TParam/TParamKind.hpp b/include/mrdocs/Metadata/TParam/TParamKind.hpp
index 9e3fe4f98..7a6088b2e 100644
--- a/include/mrdocs/Metadata/TParam/TParamKind.hpp
+++ b/include/mrdocs/Metadata/TParam/TParamKind.hpp
@@ -17,18 +17,18 @@
 #include <mrdocs/Platform.hpp>
 #include <string_view>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 enum class TParamKind : int
 {
     #define INFO(Type) Type,
-    #include <mrdocs/Metadata/TParam/TParamInfoNodes.inc>
+#include <mrdocs/Metadata/TParam/TParamInfoNodes.inc>
 };
 
 MRDOCS_DECL
 std::string_view
 toString(TParamKind kind) noexcept;
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/TParam/TemplateTParam.hpp b/include/mrdocs/Metadata/TParam/TemplateTParam.hpp
index 77daee36c..9114ad7db 100644
--- a/include/mrdocs/Metadata/TParam/TemplateTParam.hpp
+++ b/include/mrdocs/Metadata/TParam/TemplateTParam.hpp
@@ -19,7 +19,7 @@
 #include <mrdocs/Metadata/TParam/TParamBase.hpp>
 #include <vector>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 struct TemplateTParam final
     : TParamCommonBase<TParamKind::Template>
@@ -31,6 +31,6 @@ struct TemplateTParam final
     operator<=>(TemplateTParam const& other) const;
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/TParam/TypeTParam.hpp b/include/mrdocs/Metadata/TParam/TypeTParam.hpp
index 796dd682d..73750ec1b 100644
--- a/include/mrdocs/Metadata/TParam/TypeTParam.hpp
+++ b/include/mrdocs/Metadata/TParam/TypeTParam.hpp
@@ -21,7 +21,7 @@
 #include <mrdocs/Metadata/TParam/TParamBase.hpp>
 #include <mrdocs/Metadata/TParam/TParamKeyKind.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 struct TypeTParam final
     : TParamCommonBase<TParamKind::Type>
@@ -30,11 +30,11 @@ struct TypeTParam final
     TParamKeyKind KeyKind = TParamKeyKind::Class;
 
     /** The type-constraint for the parameter, if any. */
-    Optional<Polymorphic<NameInfo>> Constraint = std::nullopt;
+    Optional<Polymorphic<struct Name>> Constraint = std::nullopt;
 
     std::strong_ordering operator<=>(TypeTParam const&) const;
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Template.hpp b/include/mrdocs/Metadata/Template.hpp
index c66712a06..5675d96ad 100644
--- a/include/mrdocs/Metadata/Template.hpp
+++ b/include/mrdocs/Metadata/Template.hpp
@@ -17,12 +17,12 @@
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Metadata/Expression.hpp>
-#include <mrdocs/Metadata/Info/SymbolID.hpp>
+#include <mrdocs/Metadata/Symbol/SymbolID.hpp>
 #include <mrdocs/Metadata/TArg.hpp>
 #include <mrdocs/Metadata/TParam.hpp>
 #include <vector>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** The kind of template or specialization.
 */
@@ -132,6 +132,6 @@ tag_invoke(
 }
 
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Type.hpp b/include/mrdocs/Metadata/Type.hpp
index f66b14f4c..9cc7e084b 100644
--- a/include/mrdocs/Metadata/Type.hpp
+++ b/include/mrdocs/Metadata/Type.hpp
@@ -14,22 +14,22 @@
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
-#include <mrdocs/Metadata/Type/ArrayTypeInfo.hpp>
-#include <mrdocs/Metadata/Type/AutoTypeInfo.hpp>
-#include <mrdocs/Metadata/Type/DecltypeTypeInfo.hpp>
-#include <mrdocs/Metadata/Type/FunctionTypeInfo.hpp>
-#include <mrdocs/Metadata/Type/LValueReferenceTypeInfo.hpp>
-#include <mrdocs/Metadata/Type/MemberPointerTypeInfo.hpp>
-#include <mrdocs/Metadata/Type/NamedTypeInfo.hpp>
-#include <mrdocs/Metadata/Type/PointerTypeInfo.hpp>
-#include <mrdocs/Metadata/Type/RValueReferenceTypeInfo.hpp>
+#include <mrdocs/Metadata/Type/ArrayType.hpp>
+#include <mrdocs/Metadata/Type/AutoType.hpp>
+#include <mrdocs/Metadata/Type/DecltypeType.hpp>
+#include <mrdocs/Metadata/Type/FunctionType.hpp>
+#include <mrdocs/Metadata/Type/LValueReferenceType.hpp>
+#include <mrdocs/Metadata/Type/MemberPointerType.hpp>
+#include <mrdocs/Metadata/Type/NamedType.hpp>
+#include <mrdocs/Metadata/Type/PointerType.hpp>
+#include <mrdocs/Metadata/Type/RValueReferenceType.hpp>
 #include <mrdocs/Metadata/Type/TypeBase.hpp>
 #include <mrdocs/Support/TypeTraits.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 template<
-    std::derived_from<TypeInfo> TypeTy,
+    std::derived_from<Type> TypeTy,
     class F,
     class... Args>
 decltype(auto)
@@ -38,44 +38,44 @@ visit(
     F&& f,
     Args&&... args)
 {
-    add_cv_from_t<TypeTy, TypeInfo>& II = I;
+    add_cv_from_t<TypeTy, Type>& II = I;
     switch(I.Kind)
     {
     case TypeKind::Named:
         return f(static_cast<add_cv_from_t<
-            TypeTy, NamedTypeInfo>&>(II),
+            TypeTy, NamedType>&>(II),
                 std::forward<Args>(args)...);
     case TypeKind::Decltype:
         return f(static_cast<add_cv_from_t<
-            TypeTy, DecltypeTypeInfo>&>(II),
+            TypeTy, DecltypeType>&>(II),
                 std::forward<Args>(args)...);
     case TypeKind::Auto:
         return f(static_cast<add_cv_from_t<
-            TypeTy, AutoTypeInfo>&>(II),
+            TypeTy, AutoType>&>(II),
                 std::forward<Args>(args)...);
     case TypeKind::LValueReference:
         return f(static_cast<add_cv_from_t<
-            TypeTy, LValueReferenceTypeInfo>&>(II),
+            TypeTy, LValueReferenceType>&>(II),
                 std::forward<Args>(args)...);
     case TypeKind::RValueReference:
         return f(static_cast<add_cv_from_t<
-            TypeTy, RValueReferenceTypeInfo>&>(II),
+            TypeTy, RValueReferenceType>&>(II),
                 std::forward<Args>(args)...);
     case TypeKind::Pointer:
         return f(static_cast<add_cv_from_t<
-            TypeTy, PointerTypeInfo>&>(II),
+            TypeTy, PointerType>&>(II),
                 std::forward<Args>(args)...);
     case TypeKind::MemberPointer:
         return f(static_cast<add_cv_from_t<
-            TypeTy, MemberPointerTypeInfo>&>(II),
+            TypeTy, MemberPointerType>&>(II),
                 std::forward<Args>(args)...);
     case TypeKind::Array:
         return f(static_cast<add_cv_from_t<
-            TypeTy, ArrayTypeInfo>&>(II),
+            TypeTy, ArrayType>&>(II),
                 std::forward<Args>(args)...);
     case TypeKind::Function:
         return f(static_cast<add_cv_from_t<
-            TypeTy, FunctionTypeInfo>&>(II),
+            TypeTy, FunctionType>&>(II),
                 std::forward<Args>(args)...);
     default:
         MRDOCS_UNREACHABLE();
@@ -84,18 +84,18 @@ visit(
 
 MRDOCS_DECL
 std::strong_ordering
-operator<=>(Polymorphic<TypeInfo> const& lhs, Polymorphic<TypeInfo> const& rhs);
+operator<=>(Polymorphic<Type> const& lhs, Polymorphic<Type> const& rhs);
 
 inline
 bool
-operator==(Polymorphic<TypeInfo> const& lhs, Polymorphic<TypeInfo> const& rhs) {
+operator==(Polymorphic<Type> const& lhs, Polymorphic<Type> const& rhs) {
     return lhs <=> rhs == std::strong_ordering::equal;
 }
 
 inline std::strong_ordering
 operator<=>(
-    Optional<Polymorphic<TypeInfo>> const& lhs,
-    Optional<Polymorphic<TypeInfo>> const& rhs)
+    Optional<Polymorphic<Type>> const& lhs,
+    Optional<Polymorphic<Type>> const& rhs)
 {
     if (lhs && rhs)
     {
@@ -110,8 +110,8 @@ operator<=>(
 
 inline bool
 operator==(
-    Optional<Polymorphic<TypeInfo>> const& lhs,
-    Optional<Polymorphic<TypeInfo>> const& rhs)
+    Optional<Polymorphic<Type>> const& lhs,
+    Optional<Polymorphic<Type>> const& rhs)
 {
     return lhs <=> rhs == std::strong_ordering::equal;
 }
@@ -122,23 +122,23 @@ operator==(
     by a specifier (e.g. "int" in "pointer to int").
 */
 MRDOCS_DECL
-Optional<Polymorphic<TypeInfo> const&>
-innerType(TypeInfo const& TI) noexcept;
+Optional<Polymorphic<Type> const&>
+innerType(Type const& TI) noexcept;
 
-/// @copydoc innerType(TypeInfo const&)
+/// @copydoc innerType(Type const&)
 MRDOCS_DECL
-Optional<Polymorphic<TypeInfo>&>
-innerType(TypeInfo& TI) noexcept;
+Optional<Polymorphic<Type>&>
+innerType(Type& TI) noexcept;
 
-/// @copydoc innerType(TypeInfo const&)
+/// @copydoc innerType(Type const&)
 MRDOCS_DECL
-TypeInfo const*
-innerTypePtr(TypeInfo const& TI) noexcept;
+Type const*
+innerTypePtr(Type const& TI) noexcept;
 
-/// @copydoc innerTypePtr(TypeInfo const&)
+/// @copydoc innerTypePtr(Type const&)
 MRDOCS_DECL
-TypeInfo*
-innerTypePtr(TypeInfo& TI) noexcept;
+Type*
+innerTypePtr(Type& TI) noexcept;
 
 /** Return the innermost type.
 
@@ -152,19 +152,18 @@ innerTypePtr(TypeInfo& TI) noexcept;
     the current type.
 */
 MRDOCS_DECL
-Polymorphic<TypeInfo> const&
-innermostType(Polymorphic<TypeInfo> const& TI) noexcept;
+Polymorphic<Type> const&
+innermostType(Polymorphic<Type> const& TI) noexcept;
 
-/// @copydoc innermostType(Polymorphic<TypeInfo> const&)
+/// @copydoc innermostType(Polymorphic<Type> const&)
 MRDOCS_DECL
-Polymorphic<TypeInfo>&
-innermostType(Polymorphic<TypeInfo>& TI) noexcept;
+Polymorphic<Type>&
+innermostType(Polymorphic<Type>& TI) noexcept;
 
 // VFALCO maybe we should rename this to `renderType` or something?
 MRDOCS_DECL
 std::string
-toString(
-    TypeInfo const& T,
+toString(Type const& T,
     std::string_view Name = "");
 
 inline
@@ -172,7 +171,7 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    Polymorphic<TypeInfo> const& I,
+    Polymorphic<Type> const& I,
     DomCorpus const* domCorpus)
 {
     MRDOCS_ASSERT(!I.valueless_after_move());
@@ -184,7 +183,7 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    Optional<Polymorphic<TypeInfo>> const& I,
+    Optional<Polymorphic<Type>> const& I,
     DomCorpus const* domCorpus)
 {
     if (!I)
@@ -197,6 +196,6 @@ tag_invoke(
 }
 
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Type/ArrayTypeInfo.hpp b/include/mrdocs/Metadata/Type/ArrayType.hpp
similarity index 58%
rename from include/mrdocs/Metadata/Type/ArrayTypeInfo.hpp
rename to include/mrdocs/Metadata/Type/ArrayType.hpp
index 53495933b..2fcadb608 100644
--- a/include/mrdocs/Metadata/Type/ArrayTypeInfo.hpp
+++ b/include/mrdocs/Metadata/Type/ArrayType.hpp
@@ -8,27 +8,27 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_TYPE_ARRAYTYPEINFO_HPP
-#define MRDOCS_API_METADATA_TYPE_ARRAYTYPEINFO_HPP
+#ifndef MRDOCS_API_METADATA_TYPE_ARRAYTYPE_HPP
+#define MRDOCS_API_METADATA_TYPE_ARRAYTYPE_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
-#include <mrdocs/Metadata/Type/AutoTypeInfo.hpp>
+#include <mrdocs/Metadata/Type/AutoType.hpp>
 #include <mrdocs/Metadata/Type/TypeBase.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
-struct ArrayTypeInfo final
-    : TypeInfoCommonBase<TypeKind::Array>
+struct ArrayType final
+    : TypeCommonBase<TypeKind::Array>
 {
-    Polymorphic<TypeInfo> ElementType = Polymorphic<TypeInfo>(AutoTypeInfo{});
+    Polymorphic<Type> ElementType = Polymorphic<Type>(AutoType{});
     ConstantExprInfo<std::uint64_t> Bounds;
 
     std::strong_ordering
-    operator<=>(ArrayTypeInfo const&) const;
+    operator<=>(ArrayType const&) const;
 };
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_TYPE_ARRAYTYPE_HPP
diff --git a/include/mrdocs/Metadata/Type/AutoKind.hpp b/include/mrdocs/Metadata/Type/AutoKind.hpp
index c59817b98..2193c40df 100644
--- a/include/mrdocs/Metadata/Type/AutoKind.hpp
+++ b/include/mrdocs/Metadata/Type/AutoKind.hpp
@@ -14,7 +14,7 @@
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** The kind of `auto` keyword used in a declaration.
 
@@ -42,6 +42,6 @@ tag_invoke(
     v = toString(kind);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Type/AutoTypeInfo.hpp b/include/mrdocs/Metadata/Type/AutoType.hpp
similarity index 66%
rename from include/mrdocs/Metadata/Type/AutoTypeInfo.hpp
rename to include/mrdocs/Metadata/Type/AutoType.hpp
index 724881b24..11ce16cf0 100644
--- a/include/mrdocs/Metadata/Type/AutoTypeInfo.hpp
+++ b/include/mrdocs/Metadata/Type/AutoType.hpp
@@ -8,8 +8,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_TYPE_AUTOTYPEINFO_HPP
-#define MRDOCS_API_METADATA_TYPE_AUTOTYPEINFO_HPP
+#ifndef MRDOCS_API_METADATA_TYPE_AUTOTYPE_HPP
+#define MRDOCS_API_METADATA_TYPE_AUTOTYPE_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
@@ -17,21 +17,21 @@
 #include <mrdocs/Metadata/Type/AutoKind.hpp>
 #include <mrdocs/Metadata/Type/TypeBase.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
-struct AutoTypeInfo final
-    : TypeInfoCommonBase<TypeKind::Auto>
+struct AutoType final
+    : TypeCommonBase<TypeKind::Auto>
 {
     AutoKind Keyword = AutoKind::Auto;
 
     /** Constraint on the auto type, if any.
      */
-    Optional<Polymorphic<NameInfo>> Constraint = std::nullopt;
+    Optional<Polymorphic<Name>> Constraint = std::nullopt;
 
     std::strong_ordering
-    operator<=>(AutoTypeInfo const&) const;
+    operator<=>(AutoType const&) const;
 };
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_TYPE_AUTOTYPE_HPP
diff --git a/include/mrdocs/Metadata/Type/DecltypeTypeInfo.hpp b/include/mrdocs/Metadata/Type/DecltypeType.hpp
similarity index 58%
rename from include/mrdocs/Metadata/Type/DecltypeTypeInfo.hpp
rename to include/mrdocs/Metadata/Type/DecltypeType.hpp
index 648d40e75..79202c408 100644
--- a/include/mrdocs/Metadata/Type/DecltypeTypeInfo.hpp
+++ b/include/mrdocs/Metadata/Type/DecltypeType.hpp
@@ -8,22 +8,22 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_TYPE_DECLTYPETYPEINFO_HPP
-#define MRDOCS_API_METADATA_TYPE_DECLTYPETYPEINFO_HPP
+#ifndef MRDOCS_API_METADATA_TYPE_DECLTYPETYPE_HPP
+#define MRDOCS_API_METADATA_TYPE_DECLTYPETYPE_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Metadata/Type/TypeBase.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
-struct DecltypeTypeInfo final
-    : TypeInfoCommonBase<TypeKind::Decltype>
+struct DecltypeType final
+    : TypeCommonBase<TypeKind::Decltype>
 {
     ExprInfo Operand;
 
-    auto operator<=>(DecltypeTypeInfo const&) const = default;
+    auto operator<=>(DecltypeType const&) const = default;
 };
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_TYPE_DECLTYPETYPE_HPP
diff --git a/include/mrdocs/Metadata/Type/FunctionTypeInfo.hpp b/include/mrdocs/Metadata/Type/FunctionType.hpp
similarity index 59%
rename from include/mrdocs/Metadata/Type/FunctionTypeInfo.hpp
rename to include/mrdocs/Metadata/Type/FunctionType.hpp
index 605b3b837..e869665a0 100644
--- a/include/mrdocs/Metadata/Type/FunctionTypeInfo.hpp
+++ b/include/mrdocs/Metadata/Type/FunctionType.hpp
@@ -8,31 +8,31 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_TYPE_FUNCTIONTYPEINFO_HPP
-#define MRDOCS_API_METADATA_TYPE_FUNCTIONTYPEINFO_HPP
+#ifndef MRDOCS_API_METADATA_TYPE_FUNCTIONTYPE_HPP
+#define MRDOCS_API_METADATA_TYPE_FUNCTIONTYPE_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Metadata/Specifiers.hpp>
-#include <mrdocs/Metadata/Type/AutoTypeInfo.hpp>
+#include <mrdocs/Metadata/Type/AutoType.hpp>
 #include <mrdocs/Metadata/Type/TypeBase.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
-struct FunctionTypeInfo final
-    : TypeInfoCommonBase<TypeKind::Function>
+struct FunctionType final
+    : TypeCommonBase<TypeKind::Function>
 {
-    Polymorphic<TypeInfo> ReturnType = Polymorphic<TypeInfo>(AutoTypeInfo{});
-    std::vector<Polymorphic<TypeInfo>> ParamTypes;
+    Polymorphic<Type> ReturnType = Polymorphic<Type>(AutoType{});
+    std::vector<Polymorphic<Type>> ParamTypes;
     ReferenceKind RefQualifier = ReferenceKind::None;
     NoexceptInfo ExceptionSpec;
     bool IsVariadic = false;
 
     std::strong_ordering
-    operator<=>(FunctionTypeInfo const&) const;
+    operator<=>(FunctionType const&) const;
 };
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_TYPE_FUNCTIONTYPE_HPP
diff --git a/include/mrdocs/Metadata/Type/FundamentalTypeKind.hpp b/include/mrdocs/Metadata/Type/FundamentalTypeKind.hpp
index fa35717e6..7687a4b06 100644
--- a/include/mrdocs/Metadata/Type/FundamentalTypeKind.hpp
+++ b/include/mrdocs/Metadata/Type/FundamentalTypeKind.hpp
@@ -14,7 +14,7 @@
 #include <mrdocs/Platform.hpp>
 #include <string_view>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Categorically describes a fundamental type.
 
@@ -191,6 +191,6 @@ MRDOCS_DECL
 bool
 makeChar(FundamentalTypeKind& kind) noexcept;
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Type/LValueReferenceTypeInfo.hpp b/include/mrdocs/Metadata/Type/LValueReferenceType.hpp
similarity index 55%
rename from include/mrdocs/Metadata/Type/LValueReferenceTypeInfo.hpp
rename to include/mrdocs/Metadata/Type/LValueReferenceType.hpp
index e54cf6a1a..0899d107d 100644
--- a/include/mrdocs/Metadata/Type/LValueReferenceTypeInfo.hpp
+++ b/include/mrdocs/Metadata/Type/LValueReferenceType.hpp
@@ -8,25 +8,25 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_TYPE_LVALUEREFERENCETYPEINFO_HPP
-#define MRDOCS_API_METADATA_TYPE_LVALUEREFERENCETYPEINFO_HPP
+#ifndef MRDOCS_API_METADATA_TYPE_LVALUEREFERENCETYPE_HPP
+#define MRDOCS_API_METADATA_TYPE_LVALUEREFERENCETYPE_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Metadata/Type/TypeBase.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
-struct LValueReferenceTypeInfo final
-    : TypeInfoCommonBase<TypeKind::LValueReference>
+struct LValueReferenceType final
+    : TypeCommonBase<TypeKind::LValueReference>
 {
-    Polymorphic<TypeInfo> PointeeType = Polymorphic<TypeInfo>(AutoTypeInfo{});
+    Polymorphic<Type> PointeeType = Polymorphic<Type>(AutoType{});
 
     std::strong_ordering
-    operator<=>(LValueReferenceTypeInfo const&) const;
+    operator<=>(LValueReferenceType const&) const;
 };
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_TYPE_LVALUEREFERENCETYPE_HPP
diff --git a/include/mrdocs/Metadata/Type/MemberPointerType.hpp b/include/mrdocs/Metadata/Type/MemberPointerType.hpp
new file mode 100644
index 000000000..ed620cb36
--- /dev/null
+++ b/include/mrdocs/Metadata/Type/MemberPointerType.hpp
@@ -0,0 +1,33 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_TYPE_MEMBERPOINTERTYPE_HPP
+#define MRDOCS_API_METADATA_TYPE_MEMBERPOINTERTYPE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Optional.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/Type/TypeBase.hpp>
+
+namespace mrdocs {
+
+struct MemberPointerType final
+    : TypeCommonBase<TypeKind::MemberPointer>
+{
+    Polymorphic<Type> ParentType = Polymorphic<Type>(AutoType{});
+    Polymorphic<Type> PointeeType = Polymorphic<Type>(AutoType{});
+
+    std::strong_ordering
+    operator<=>(MemberPointerType const&) const;
+};
+
+} // mrdocs
+
+#endif // MRDOCS_API_METADATA_TYPE_MEMBERPOINTERTYPE_HPP
diff --git a/include/mrdocs/Metadata/Type/MemberPointerTypeInfo.hpp b/include/mrdocs/Metadata/Type/MemberPointerTypeInfo.hpp
deleted file mode 100644
index 46bf05097..000000000
--- a/include/mrdocs/Metadata/Type/MemberPointerTypeInfo.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#ifndef MRDOCS_API_METADATA_TYPE_MEMBERPOINTERTYPEINFO_HPP
-#define MRDOCS_API_METADATA_TYPE_MEMBERPOINTERTYPEINFO_HPP
-
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/ADT/Optional.hpp>
-#include <mrdocs/ADT/Polymorphic.hpp>
-#include <mrdocs/Metadata/Type/TypeBase.hpp>
-
-namespace clang::mrdocs {
-
-struct MemberPointerTypeInfo final
-    : TypeInfoCommonBase<TypeKind::MemberPointer>
-{
-    Polymorphic<TypeInfo> ParentType = Polymorphic<TypeInfo>(AutoTypeInfo{});
-    Polymorphic<TypeInfo> PointeeType = Polymorphic<TypeInfo>(AutoTypeInfo{});
-
-    std::strong_ordering
-    operator<=>(MemberPointerTypeInfo const&) const;
-};
-
-} // clang::mrdocs
-
-#endif
diff --git a/include/mrdocs/Metadata/Type/NamedTypeInfo.hpp b/include/mrdocs/Metadata/Type/NamedType.hpp
similarity index 61%
rename from include/mrdocs/Metadata/Type/NamedTypeInfo.hpp
rename to include/mrdocs/Metadata/Type/NamedType.hpp
index a9fd234f6..932856593 100644
--- a/include/mrdocs/Metadata/Type/NamedTypeInfo.hpp
+++ b/include/mrdocs/Metadata/Type/NamedType.hpp
@@ -8,31 +8,31 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_TYPE_NAMEDTYPEINFO_HPP
-#define MRDOCS_API_METADATA_TYPE_NAMEDTYPEINFO_HPP
+#ifndef MRDOCS_API_METADATA_TYPE_NAMEDTYPE_HPP
+#define MRDOCS_API_METADATA_TYPE_NAMEDTYPE_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
-#include <mrdocs/Metadata/Name/IdentifierNameInfo.hpp>
+#include <mrdocs/Metadata/Name/IdentifierName.hpp>
 #include <mrdocs/Metadata/Name/NameBase.hpp>
 #include <mrdocs/Metadata/Type/FundamentalTypeKind.hpp>
 #include <mrdocs/Metadata/Type/TypeBase.hpp>
 #include <mrdocs/Metadata/Type/TypeKind.hpp>
 #include <optional>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
-struct NamedTypeInfo final
-    : TypeInfoCommonBase<TypeKind::Named>
+struct NamedType final
+    : TypeCommonBase<TypeKind::Named>
 {
-    Polymorphic<NameInfo> Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
+    Polymorphic<struct Name> Name = Polymorphic<struct Name>(std::in_place_type<IdentifierName>);
 
     Optional<FundamentalTypeKind> FundamentalType;
 
     std::strong_ordering
-    operator<=>(NamedTypeInfo const& other) const;
+    operator<=>(NamedType const& other) const;
 };
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_TYPE_NAMEDTYPE_HPP
diff --git a/include/mrdocs/Metadata/Type/PointerTypeInfo.hpp b/include/mrdocs/Metadata/Type/PointerType.hpp
similarity index 58%
rename from include/mrdocs/Metadata/Type/PointerTypeInfo.hpp
rename to include/mrdocs/Metadata/Type/PointerType.hpp
index fdd2c42c3..b7a6b3e0d 100644
--- a/include/mrdocs/Metadata/Type/PointerTypeInfo.hpp
+++ b/include/mrdocs/Metadata/Type/PointerType.hpp
@@ -8,25 +8,25 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_TYPE_POINTERTYPEINFO_HPP
-#define MRDOCS_API_METADATA_TYPE_POINTERTYPEINFO_HPP
+#ifndef MRDOCS_API_METADATA_TYPE_POINTERTYPE_HPP
+#define MRDOCS_API_METADATA_TYPE_POINTERTYPE_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Metadata/Type/TypeBase.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
-struct PointerTypeInfo final
-    : TypeInfoCommonBase<TypeKind::Pointer>
+struct PointerType final
+    : TypeCommonBase<TypeKind::Pointer>
 {
-    Polymorphic<TypeInfo> PointeeType = Polymorphic<TypeInfo>(AutoTypeInfo{});
+    Polymorphic<Type> PointeeType = Polymorphic<Type>(AutoType{});
 
     std::strong_ordering
-    operator<=>(PointerTypeInfo const&) const;
+    operator<=>(PointerType const&) const;
 };
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_TYPE_POINTERTYPE_HPP
diff --git a/include/mrdocs/Metadata/Type/QualifierKind.hpp b/include/mrdocs/Metadata/Type/QualifierKind.hpp
index 03a81766d..05ed091a8 100644
--- a/include/mrdocs/Metadata/Type/QualifierKind.hpp
+++ b/include/mrdocs/Metadata/Type/QualifierKind.hpp
@@ -15,14 +15,14 @@
 #include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Dom.hpp>
 #include <mrdocs/Metadata/Expression.hpp>
-#include <mrdocs/Metadata/Info/SymbolID.hpp>
 #include <mrdocs/Metadata/Name/NameBase.hpp>
 #include <mrdocs/Metadata/Specifiers.hpp>
+#include <mrdocs/Metadata/Symbol/SymbolID.hpp>
 #include <mrdocs/Support/TypeTraits.hpp>
 #include <string>
 #include <vector>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Type qualifiers
 */
@@ -50,6 +50,6 @@ tag_invoke(
     v = toString(kind);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Type/RValueReferenceTypeInfo.hpp b/include/mrdocs/Metadata/Type/RValueReferenceType.hpp
similarity index 55%
rename from include/mrdocs/Metadata/Type/RValueReferenceTypeInfo.hpp
rename to include/mrdocs/Metadata/Type/RValueReferenceType.hpp
index e435bc7d4..57703d223 100644
--- a/include/mrdocs/Metadata/Type/RValueReferenceTypeInfo.hpp
+++ b/include/mrdocs/Metadata/Type/RValueReferenceType.hpp
@@ -8,25 +8,25 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_TYPE_RVALUEREFERENCETYPEINFO_HPP
-#define MRDOCS_API_METADATA_TYPE_RVALUEREFERENCETYPEINFO_HPP
+#ifndef MRDOCS_API_METADATA_TYPE_RVALUEREFERENCETYPE_HPP
+#define MRDOCS_API_METADATA_TYPE_RVALUEREFERENCETYPE_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Metadata/Type/TypeBase.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
-struct RValueReferenceTypeInfo final
-    : TypeInfoCommonBase<TypeKind::RValueReference>
+struct RValueReferenceType final
+    : TypeCommonBase<TypeKind::RValueReference>
 {
-    Polymorphic<TypeInfo> PointeeType = Polymorphic<TypeInfo>(AutoTypeInfo{});
+    Polymorphic<Type> PointeeType = Polymorphic<Type>(AutoType{});
 
     std::strong_ordering
-    operator<=>(RValueReferenceTypeInfo const&) const;
+    operator<=>(RValueReferenceType const&) const;
 };
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif
+#endif // MRDOCS_API_METADATA_TYPE_RVALUEREFERENCETYPE_HPP
diff --git a/include/mrdocs/Metadata/Type/TypeBase.hpp b/include/mrdocs/Metadata/Type/TypeBase.hpp
index 769b80902..5f6ae86b2 100644
--- a/include/mrdocs/Metadata/Type/TypeBase.hpp
+++ b/include/mrdocs/Metadata/Type/TypeBase.hpp
@@ -14,16 +14,16 @@
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
 #include <mrdocs/Metadata/Expression.hpp>
-#include <mrdocs/Metadata/Info/SymbolID.hpp>
+#include <mrdocs/Metadata/Symbol/SymbolID.hpp>
 #include <mrdocs/Metadata/Type/TypeKind.hpp>
 #include <vector>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /* Forward declarations
  */
-#define INFO(Type) struct Type##TypeInfo;
-#include <mrdocs/Metadata/Type/TypeInfoNodes.inc>
+#define INFO(TypeKind) struct TypeKind##Type;
+#include <mrdocs/Metadata/Type/TypeNodes.inc>
 
 /** A possibly qualified type.
 
@@ -34,9 +34,8 @@ namespace clang::mrdocs {
     of type. Derived classes are used to store
     the type information according to the kind.
  */
-struct TypeInfo
-{
-    /** The kind of TypeInfo this is
+struct Type {
+    /** The kind of Type this is
     */
     TypeKind Kind;
 
@@ -69,14 +68,14 @@ struct TypeInfo
     SymbolID
     namedSymbol() const noexcept;
 
-    auto operator<=>(TypeInfo const&) const = default;
+    auto operator<=>(Type const&) const = default;
 
-    constexpr TypeInfo const& asType() const noexcept
+    constexpr Type const& asType() const noexcept
     {
         return *this;
     }
 
-    constexpr TypeInfo& asType() noexcept
+    constexpr Type& asType() noexcept
     {
         return *this;
     }
@@ -84,43 +83,42 @@ struct TypeInfo
     #define INFO(Type) constexpr bool is##Type() const noexcept { \
         return Kind == TypeKind::Type; \
     }
-#include <mrdocs/Metadata/Type/TypeInfoNodes.inc>
+#include <mrdocs/Metadata/Type/TypeNodes.inc>
 
-    #define INFO(Type) \
-    constexpr Type##TypeInfo const& as##Type() const noexcept { \
-        if (Kind == TypeKind::Type) \
-            return reinterpret_cast<Type##TypeInfo const&>(*this); \
+#define INFO(TypeKindName) \
+    constexpr TypeKindName##Type const& as##TypeKindName() const noexcept { \
+        if (Kind == TypeKind::TypeKindName) \
+            return reinterpret_cast<TypeKindName##Type const&>(*this); \
         MRDOCS_UNREACHABLE(); \
     }
-#include <mrdocs/Metadata/Type/TypeInfoNodes.inc>
+#include <mrdocs/Metadata/Type/TypeNodes.inc>
 
-#define INFO(Type) \
-    constexpr Type##TypeInfo & as##Type() noexcept { \
-        if (Kind == TypeKind::Type) \
-            return reinterpret_cast<Type##TypeInfo&>(*this); \
+#define INFO(TypeKindName) \
+    constexpr TypeKindName##Type & as##TypeKindName() noexcept { \
+        if (Kind == TypeKind::TypeKindName) \
+            return reinterpret_cast<TypeKindName##Type&>(*this); \
         MRDOCS_UNREACHABLE(); \
     }
-#include <mrdocs/Metadata/Type/TypeInfoNodes.inc>
+#include <mrdocs/Metadata/Type/TypeNodes.inc>
 
-#define INFO(Type) \
-    constexpr Type##TypeInfo const* as##Type##Ptr() const noexcept { \
-        if (Kind == TypeKind::Type) { return reinterpret_cast<Type##TypeInfo const*>(this); } \
+#define INFO(TypeKindName) \
+    constexpr TypeKindName##Type const* as##TypeKindName##Ptr() const noexcept { \
+        if (Kind == TypeKind::TypeKindName) { return reinterpret_cast<TypeKindName##Type const*>(this); } \
         return nullptr; \
     }
-#include <mrdocs/Metadata/Type/TypeInfoNodes.inc>
+#include <mrdocs/Metadata/Type/TypeNodes.inc>
 
-#define INFO(Type) \
-    constexpr Type##TypeInfo * as##Type##Ptr() noexcept { \
-        if (Kind == TypeKind::Type) { return reinterpret_cast<Type##TypeInfo *>(this); } \
+#define INFO(TypeKindName) \
+    constexpr TypeKindName##Type * as##TypeKindName##Ptr() noexcept { \
+        if (Kind == TypeKind::TypeKindName) { return reinterpret_cast<TypeKindName##Type *>(this); } \
         return nullptr; \
     }
-#include <mrdocs/Metadata/Type/TypeInfoNodes.inc>
+#include <mrdocs/Metadata/Type/TypeNodes.inc>
 
 protected:
-    constexpr virtual ~TypeInfo() = default;
+    constexpr virtual ~Type() = default;
 
-    constexpr
-    TypeInfo(
+    constexpr Type(
         TypeKind kind) noexcept
         : Kind(kind)
     {
@@ -132,12 +130,11 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    TypeInfo const& I,
+    Type const& I,
     DomCorpus const* domCorpus);
 
 template<TypeKind K>
-struct TypeInfoCommonBase : TypeInfo
-{
+struct TypeCommonBase : Type {
     static constexpr TypeKind kind_id = K;
 
     static constexpr bool isNamed()           noexcept { return K == TypeKind::Named; }
@@ -150,16 +147,15 @@ struct TypeInfoCommonBase : TypeInfo
     static constexpr bool isArray()           noexcept { return K == TypeKind::Array; }
     static constexpr bool isFunction()        noexcept { return K == TypeKind::Function; }
 
-    auto operator<=>(TypeInfoCommonBase const&) const = default;
+    auto operator<=>(TypeCommonBase const&) const = default;
 
 protected:
-    constexpr
-    TypeInfoCommonBase() noexcept
-        : TypeInfo(K)
+    constexpr TypeCommonBase() noexcept
+        : Type(K)
     {
     }
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Type/TypeKind.hpp b/include/mrdocs/Metadata/Type/TypeKind.hpp
index 07f92fcfd..af01dcb1b 100644
--- a/include/mrdocs/Metadata/Type/TypeKind.hpp
+++ b/include/mrdocs/Metadata/Type/TypeKind.hpp
@@ -14,12 +14,12 @@
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 enum class TypeKind
 {
     #define INFO(Type) Type,
-    #include <mrdocs/Metadata/Type/TypeInfoNodes.inc>
+#include <mrdocs/Metadata/Type/TypeNodes.inc>
 };
 
 MRDOCS_DECL
@@ -36,6 +36,6 @@ tag_invoke(
     v = toString(kind);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Metadata/Type/TypeInfoNodes.inc b/include/mrdocs/Metadata/Type/TypeNodes.inc
similarity index 100%
rename from include/mrdocs/Metadata/Type/TypeInfoNodes.inc
rename to include/mrdocs/Metadata/Type/TypeNodes.inc
diff --git a/include/mrdocs/Platform.hpp b/include/mrdocs/Platform.hpp
index 70e8d5c67..9a99dd94a 100644
--- a/include/mrdocs/Platform.hpp
+++ b/include/mrdocs/Platform.hpp
@@ -23,7 +23,7 @@
     that is dependent on the toolchain.
 */
 
-namespace clang {
+
 namespace mrdocs {
 
 /** The minimum version of LLVM required
@@ -85,6 +85,6 @@ namespace mrdocs {
 #endif
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_API_PLATFORM_HPP
diff --git a/include/mrdocs/Support/Algorithm.hpp b/include/mrdocs/Support/Algorithm.hpp
index ccbf88cb9..d1eeacd78 100644
--- a/include/mrdocs/Support/Algorithm.hpp
+++ b/include/mrdocs/Support/Algorithm.hpp
@@ -15,7 +15,7 @@
 #include <algorithm>
 #include <cstdint>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Determine if a range contains a specific element.
     @param range The range to search.
@@ -188,6 +188,6 @@ find_last_of(Range&& range, Els&& els)
     return std::ranges::end(range);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
\ No newline at end of file
diff --git a/include/mrdocs/Support/Assert.hpp b/include/mrdocs/Support/Assert.hpp
index 5cd895fe7..77a97604d 100644
--- a/include/mrdocs/Support/Assert.hpp
+++ b/include/mrdocs/Support/Assert.hpp
@@ -13,7 +13,6 @@
 
 #include <cstdint>
 
-namespace clang {
 namespace mrdocs {
 
 #ifdef NDEBUG
@@ -42,6 +41,5 @@ namespace mrdocs {
 #endif
 
 } // mrdocs
-} // clang
 
 #endif
\ No newline at end of file
diff --git a/include/mrdocs/Support/Concepts.hpp b/include/mrdocs/Support/Concepts.hpp
index f9c56536f..bc31d07db 100644
--- a/include/mrdocs/Support/Concepts.hpp
+++ b/include/mrdocs/Support/Concepts.hpp
@@ -13,7 +13,7 @@
 
 #include <ranges>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Concept to check if a type is a range of T */
 template <class Range, class T>
@@ -156,7 +156,7 @@ concept range_of_tuple_like =
         = reference_converts_from_temporary_v<To, From>;
 #endif
 
-} // namespace clang::mrdocs
+} // namespace mrdocs
 
 
 #endif // MRDOCS_API_SUPPORT_CONCEPTS_HPP
diff --git a/include/mrdocs/Support/Error.hpp b/include/mrdocs/Support/Error.hpp
index aaae56ef5..8d8cf92ce 100644
--- a/include/mrdocs/Support/Error.hpp
+++ b/include/mrdocs/Support/Error.hpp
@@ -25,7 +25,7 @@
 #include <utility>
 #include <vector>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 //------------------------------------------------
 //
@@ -51,7 +51,7 @@ class MRDOCS_DECL
 public:
     /** Constructor.
 
-        A default constructed error is
+        A default-constructed error is
         equivalent to success.
     */
     Error() noexcept = default;
@@ -251,22 +251,22 @@ class MRDOCS_DECL
     }
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 template<>
-struct std::hash<::clang::mrdocs::Error>
+struct std::hash<::mrdocs::Error>
 {
     std::size_t operator()(
-        ::clang::mrdocs::Error const& err) const noexcept
+        ::mrdocs::Error const& err) const noexcept
     {
         return std::hash<std::string_view>()(err.message());
     }
 };
 
 template <>
-struct std::formatter<clang::mrdocs::Error> : std::formatter<std::string_view> {
+struct std::formatter<mrdocs::Error> : std::formatter<std::string_view> {
   template <class FmtContext>
-  auto format(clang::mrdocs::Error const &err, FmtContext &ctx) const {
+  auto format(mrdocs::Error const &err, FmtContext &ctx) const {
     return std::formatter<std::string_view>::format(err.message(), ctx);
   }
 };
@@ -279,7 +279,7 @@ struct std::formatter<std::error_code> : std::formatter<std::string_view> {
   }
 };
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** A source location with filename prettification.
 */
diff --git a/include/mrdocs/Support/ExecutorGroup.hpp b/include/mrdocs/Support/ExecutorGroup.hpp
index 940fe65e7..0ef56bcf7 100644
--- a/include/mrdocs/Support/ExecutorGroup.hpp
+++ b/include/mrdocs/Support/ExecutorGroup.hpp
@@ -20,7 +20,7 @@
 #include <mutex>
 #include <vector>
 
-namespace clang {
+
 namespace mrdocs {
 
 class MRDOCS_DECL
@@ -143,6 +143,6 @@ class ExecutorGroup : public ExecutorGroupBase
 };
 
 } // mrdocs
-} // clang
+
 
 #endif
diff --git a/include/mrdocs/Support/Expected.hpp b/include/mrdocs/Support/Expected.hpp
index 34f430751..589e1ca78 100644
--- a/include/mrdocs/Support/Expected.hpp
+++ b/include/mrdocs/Support/Expected.hpp
@@ -26,7 +26,7 @@
 #include <utility>
 #include <vector>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 //------------------------------------------------
 //
@@ -3275,6 +3275,6 @@ class Expected<T&, E> {
     }
 }; // class Expected<T&, E>
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Support/Glob.hpp b/include/mrdocs/Support/Glob.hpp
index 4ae383b69..333500c04 100644
--- a/include/mrdocs/Support/Glob.hpp
+++ b/include/mrdocs/Support/Glob.hpp
@@ -17,7 +17,7 @@
 #include <optional>
 #include <string_view>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** A glob pattern matcher
 
@@ -330,6 +330,6 @@ class SymbolGlobPattern {
     }
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_API_SUPPORT_GLOB_HPP
\ No newline at end of file
diff --git a/include/mrdocs/Support/Handlebars.hpp b/include/mrdocs/Support/Handlebars.hpp
index d2705bf1c..b53ce81ac 100644
--- a/include/mrdocs/Support/Handlebars.hpp
+++ b/include/mrdocs/Support/Handlebars.hpp
@@ -21,7 +21,7 @@
 #include <variant>
 #include <vector>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** An error thrown or returned by Handlebars
@@ -1330,6 +1330,6 @@ year_fn();
 
 } // helpers
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_API_SUPPORT_HANDLEBARS_HPP
diff --git a/include/mrdocs/Support/JavaScript.hpp b/include/mrdocs/Support/JavaScript.hpp
index d230cdc16..b3391a650 100644
--- a/include/mrdocs/Support/JavaScript.hpp
+++ b/include/mrdocs/Support/JavaScript.hpp
@@ -18,7 +18,7 @@
 #include <span>
 #include <string_view>
 
-namespace clang {
+
 namespace mrdocs {
 
 class Handlebars;
@@ -716,7 +716,7 @@ class MRDOCS_DECL Value
         `message` is a string.
 
         The mrdocs library function
-        `clang::mrdocs::report::print`
+        `mrdocs::report::print`
         is then called with these
         two arguments to report a
         message to the console.
@@ -1120,13 +1120,13 @@ isFunction() const noexcept
 MRDOCS_DECL
 Expected<void, Error>
 registerHelper(
-    clang::mrdocs::Handlebars& hbs,
+    mrdocs::Handlebars& hbs,
     std::string_view name,
     Context& ctx,
     std::string_view script);
 
 } // js
 } // mrdocs
-} // clang
+
 
 #endif
diff --git a/include/mrdocs/Support/Lua.hpp b/include/mrdocs/Support/Lua.hpp
index 82c9ab4ee..c737dde21 100644
--- a/include/mrdocs/Support/Lua.hpp
+++ b/include/mrdocs/Support/Lua.hpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <string_view>
 
-namespace clang {
+
 namespace mrdocs {
 namespace lua {
 
@@ -495,14 +495,14 @@ class Table : public Value
 
 } // lua
 } // mrdocs
-} // clang
+
 
 //------------------------------------------------
 
 template <>
-struct std::formatter<clang::mrdocs::lua::Value> : std::formatter<std::string> {
+struct std::formatter<mrdocs::lua::Value> : std::formatter<std::string> {
   template <class FmtContext>
-  auto format(clang::mrdocs::lua::Value const &value, FmtContext &ctx) const {
+  auto format(mrdocs::lua::Value const &value, FmtContext &ctx) const {
     return std::formatter<std::string>::format(value.displayString(), ctx);
   }
 };
diff --git a/include/mrdocs/Support/Parse.hpp b/include/mrdocs/Support/Parse.hpp
index c570bc491..a9ad549bd 100644
--- a/include/mrdocs/Support/Parse.hpp
+++ b/include/mrdocs/Support/Parse.hpp
@@ -14,7 +14,7 @@
 #include <mrdocs/Support/Error.hpp>
 #include <mrdocs/Support/Expected.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** The result of a parse operation.
 
@@ -145,6 +145,6 @@ parse(std::string_view sv)
         sv, pos, result.ec.reason()));
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
\ No newline at end of file
diff --git a/include/mrdocs/Support/Path.hpp b/include/mrdocs/Support/Path.hpp
index 1ee42d50c..f60b74f5a 100644
--- a/include/mrdocs/Support/Path.hpp
+++ b/include/mrdocs/Support/Path.hpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <string_view>
 
-namespace clang {
+
 namespace mrdocs {
 
 //------------------------------------------------
@@ -471,6 +471,6 @@ startsWith(
 } // files
 
 } // mrdocs
-} // clang
+
 
 #endif
\ No newline at end of file
diff --git a/include/mrdocs/Support/RangeFor.hpp b/include/mrdocs/Support/RangeFor.hpp
index 016d697fd..0f7af0762 100644
--- a/include/mrdocs/Support/RangeFor.hpp
+++ b/include/mrdocs/Support/RangeFor.hpp
@@ -14,7 +14,7 @@
 
 #include <mrdocs/Platform.hpp>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** Range to help range-for loops identify first and last.
@@ -160,6 +160,6 @@ auto RangeFor<Container>::end() const noexcept ->
 }
 
 } // mrdocs
-} // clang
+
 
 #endif
\ No newline at end of file
diff --git a/include/mrdocs/Support/Report.hpp b/include/mrdocs/Support/Report.hpp
index 0deffc886..8cddc7035 100644
--- a/include/mrdocs/Support/Report.hpp
+++ b/include/mrdocs/Support/Report.hpp
@@ -26,7 +26,7 @@
 #include <utility>
 #include <vector>
 
-namespace clang::mrdocs::report {
+namespace mrdocs::report {
 
 /** Severity levels attached to reported messags.
 */
@@ -303,6 +303,6 @@ fatal(
     return log(Level::fatal, format, std::forward<Args>(args)...);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Support/ScopeExit.hpp b/include/mrdocs/Support/ScopeExit.hpp
index 04501efc0..d0fa74f6f 100644
--- a/include/mrdocs/Support/ScopeExit.hpp
+++ b/include/mrdocs/Support/ScopeExit.hpp
@@ -13,7 +13,7 @@
 
 #include <utility>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 template <class F>
 class ScopeExit {
diff --git a/include/mrdocs/Support/String.hpp b/include/mrdocs/Support/String.hpp
index c43e9b5dd..c679844c9 100644
--- a/include/mrdocs/Support/String.hpp
+++ b/include/mrdocs/Support/String.hpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <string_view>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Return the substring without leading specified characters.
 
@@ -432,6 +432,6 @@ toPascalCase(std::string_view const input)
 }
 
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/include/mrdocs/Support/ThreadPool.hpp b/include/mrdocs/Support/ThreadPool.hpp
index 041607c46..4cd651e33 100644
--- a/include/mrdocs/Support/ThreadPool.hpp
+++ b/include/mrdocs/Support/ThreadPool.hpp
@@ -25,7 +25,7 @@ class StdThreadPool;
 class ThreadPoolTaskGroup;
 } // llvm
 
-namespace clang {
+
 namespace mrdocs {
 
 class TaskGroup;
@@ -186,6 +186,6 @@ forEach(
 }
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_API_SUPPORT_THREADPOOL_HPP
diff --git a/include/mrdocs/Support/TypeTraits.hpp b/include/mrdocs/Support/TypeTraits.hpp
index d7a61170d..ba076db25 100644
--- a/include/mrdocs/Support/TypeTraits.hpp
+++ b/include/mrdocs/Support/TypeTraits.hpp
@@ -14,7 +14,7 @@
 
 #include <type_traits>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** Return the value as its underlying type.
@@ -122,6 +122,6 @@ using add_cvref_from_t =
     add_cvref_from<From, To>::type;
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_API_SUPPORT_TYPETRAITS_HPP
diff --git a/include/mrdocs/Support/Visitor.hpp b/include/mrdocs/Support/Visitor.hpp
index 8a3e36988..7cdc9e5ad 100644
--- a/include/mrdocs/Support/Visitor.hpp
+++ b/include/mrdocs/Support/Visitor.hpp
@@ -15,7 +15,7 @@
 #include <tuple>
 #include <utility>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** A visitor for a type
 
@@ -124,6 +124,6 @@ makeVisitor(
         std::forward<ArgsTy>(args)...);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_API_SUPPORT_VISITOR_HPP
diff --git a/include/mrdocs/Support/any_callable.hpp b/include/mrdocs/Support/any_callable.hpp
index 830656d0f..98698a554 100644
--- a/include/mrdocs/Support/any_callable.hpp
+++ b/include/mrdocs/Support/any_callable.hpp
@@ -16,7 +16,7 @@
 #include <type_traits>
 #include <utility>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** A movable, type-erased function object.
@@ -73,6 +73,6 @@ class any_callable<R(Args...)>
 };
 
 } // mrdocs
-} // clang
+
 
 #endif
diff --git a/include/mrdocs/Support/source_location.hpp b/include/mrdocs/Support/source_location.hpp
index cca423a59..60ee3dc49 100644
--- a/include/mrdocs/Support/source_location.hpp
+++ b/include/mrdocs/Support/source_location.hpp
@@ -16,20 +16,13 @@
 #if __cpp_lib_source_location >= 201907L && \
     __has_include(<source_location>)
 #    include <source_location>
-
-    namespace clang {
-    namespace mrdocs {
-
+namespace mrdocs {
     using std::source_location;
-
-    } // mrdocs
-    } // clang
+} // mrdocs
 #else
 #    include <cstdint>
 
-    namespace clang {
-    namespace mrdocs {
-
+namespace mrdocs {
     struct source_location
     {
         static
@@ -82,8 +75,6 @@
         std::uint_least32_t line_ = 0;
         std::uint_least32_t column_ = 0;
     };
-
 } // mrdocs
-} // clang
 #endif
 #endif
diff --git a/include/mrdocs/Support/unlock_guard.hpp b/include/mrdocs/Support/unlock_guard.hpp
index 1b5164e3f..15f4af23d 100644
--- a/include/mrdocs/Support/unlock_guard.hpp
+++ b/include/mrdocs/Support/unlock_guard.hpp
@@ -14,7 +14,7 @@
 #include <mrdocs/Platform.hpp>
 #include <mutex>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** A scoped guard which unlocks a mutex.
@@ -42,6 +42,6 @@ class unlock_guard
 };
 
 } // mrdocs
-} // clang
+
 
 #endif
diff --git a/include/mrdocs/Version.hpp.in b/include/mrdocs/Version.hpp.in
index ca5d21acc..fa7c95810 100644
--- a/include/mrdocs/Version.hpp.in
+++ b/include/mrdocs/Version.hpp.in
@@ -14,7 +14,7 @@
 #include <string_view>
 #include <cstddef>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** Project version string in MAJOR.MINOR.PATCH format.
@@ -55,6 +55,6 @@ inline constexpr std::string_view project_name                = "@PROJECT_NAME@"
 inline constexpr std::string_view project_description         = "@PROJECT_DESCRIPTION@";
 
 } // mrdocs
-} // clang
+
 
 #endif
diff --git a/include/mrdocs/mrdocs.natvis b/include/mrdocs/mrdocs.natvis
index c9882c627..2a9e9510f 100644
--- a/include/mrdocs/mrdocs.natvis
+++ b/include/mrdocs/mrdocs.natvis
@@ -12,53 +12,53 @@
     </Type>
 
 <!-- Info Types -->
-    <Type Name="clang::mrdocs::Info" Inheritable="false" IncludeView="noinherit">
+    <Type Name="mrdocs::Symbol" Inheritable="false" IncludeView="noinherit">
 	</Type>
 
-	<Type Name="clang::mrdocs::InfoCommonBase&lt;*&gt;" Inheritable="false">
+	<Type Name="mrdocs::SymbolCommonBase&lt;*&gt;" Inheritable="false">
 		<Expand>
-			<ExpandedItem>(Info*)this,view(noinherit)nd</ExpandedItem>
+			<ExpandedItem>(Symbol*)this,view(noinherit)nd</ExpandedItem>
 		</Expand>
 	</Type>
 
-    <Type Name="clang::mrdocs::Info" Inheritable="false" ExcludeView="noinherit">
-		<AlternativeType Name="clang::mrdocs::NamespaceInfo"/>
-		<AlternativeType Name="clang::mrdocs::RecordInfo"/>
-		<AlternativeType Name="clang::mrdocs::FunctionInfo"/>
-		<AlternativeType Name="clang::mrdocs::OverloadsInfo"/>
-		<AlternativeType Name="clang::mrdocs::EnumInfo"/>
-		<AlternativeType Name="clang::mrdocs::TypedefInfo"/>
-		<AlternativeType Name="clang::mrdocs::VariableInfo"/>
-		<AlternativeType Name="clang::mrdocs::FieldInfo"/>
-		<AlternativeType Name="clang::mrdocs::SpecializationInfo"/>
-		<AlternativeType Name="clang::mrdocs::FriendInfo"/>
-		<AlternativeType Name="clang::mrdocs::EnumConstantInfo"/>
-		<AlternativeType Name="clang::mrdocs::GuideInfo"/>
-		<AlternativeType Name="clang::mrdocs::NamespaceAliasInfo"/>
-		<AlternativeType Name="clang::mrdocs::UsingInfo"/>
+    <Type Name="mrdocs::Symbol" Inheritable="false" ExcludeView="noinherit">
+		<AlternativeType Name="mrdocs::NamespaceSymbol"/>
+		<AlternativeType Name="mrdocs::RecordSymbol"/>
+		<AlternativeType Name="mrdocs::FunctionSymbol"/>
+		<AlternativeType Name="mrdocs::OverloadsSymbol"/>
+		<AlternativeType Name="mrdocs::EnumSymbol"/>
+		<AlternativeType Name="mrdocs::TypedefSymbol"/>
+		<AlternativeType Name="mrdocs::VariableSymbol"/>
+		<AlternativeType Name="mrdocs::FieldInfo"/>
+		<AlternativeType Name="mrdocs::SpecializationInfo"/>
+		<AlternativeType Name="mrdocs::FriendInfo"/>
+		<AlternativeType Name="mrdocs::EnumConstantSymbol"/>
+		<AlternativeType Name="mrdocs::GuideSymbol"/>
+		<AlternativeType Name="mrdocs::NamespaceAliasSymbol"/>
+		<AlternativeType Name="mrdocs::UsingSymbol"/>
 
 		<DisplayString>{Kind,en} {Name} (ID = {id})</DisplayString>
 
 		<Expand HideRawView="true">
-			<ExpandedItem ExcludeView="noinherit">(Info*)this,view(noinherit)nd</ExpandedItem>
-			<ExpandedItem Condition="Kind == InfoKind::Namespace">(NamespaceInfo*)this,view(noinherit)</ExpandedItem>
-		    <ExpandedItem Condition="Kind == InfoKind::Record">(RecordInfo*)this,view(noinherit)</ExpandedItem>
-		    <ExpandedItem Condition="Kind == InfoKind::Function">*(FunctionInfo*)this,view(noinherit)</ExpandedItem>
-		    <ExpandedItem Condition="Kind == InfoKind::Overloads">*(OverloadsInfo*)this,view(noinherit)</ExpandedItem>
-		    <ExpandedItem Condition="Kind == InfoKind::Enum">(EnumInfo*)this,view(noinherit)</ExpandedItem>
-		    <ExpandedItem Condition="Kind == InfoKind::Typedef">(TypedefInfo*)this,view(noinherit)</ExpandedItem>
-		    <ExpandedItem Condition="Kind == InfoKind::Variable">(VariableInfo*)this,view(noinherit)</ExpandedItem>
-		    <ExpandedItem Condition="Kind == InfoKind::Field">(FieldInfo*)this,view(noinherit)</ExpandedItem>
-		    <ExpandedItem Condition="Kind == InfoKind::Specialization">(SpecializationInfo*)this,view(noinherit)</ExpandedItem>
-		    <ExpandedItem Condition="Kind == InfoKind::Friend">(FriendInfo*)this,view(noinherit)</ExpandedItem>
-		    <ExpandedItem Condition="Kind == InfoKind::Enumerator">(EnumConstantInfo*)this,view(noinherit)</ExpandedItem>
-		    <ExpandedItem Condition="Kind == InfoKind::Guide">(GuideInfo*)this,view(noinherit)</ExpandedItem>
-		    <ExpandedItem Condition="Kind == InfoKind::NamespaceAlias">(NamespaceAliasInfo*)this,view(noinherit)</ExpandedItem>
-		    <ExpandedItem Condition="Kind == InfoKind::Using">(UsingInfo*)this,view(noinherit)</ExpandedItem>
+			<ExpandedItem ExcludeView="noinherit">(Symbol*)this,view(noinherit)nd</ExpandedItem>
+			<ExpandedItem Condition="Kind == SymbolKind::Namespace">(NamespaceSymbol*)this,view(noinherit)</ExpandedItem>
+		    <ExpandedItem Condition="Kind == SymbolKind::Record">(RecordSymbol*)this,view(noinherit)</ExpandedItem>
+		    <ExpandedItem Condition="Kind == SymbolKind::Function">*(FunctionSymbol*)this,view(noinherit)</ExpandedItem>
+		    <ExpandedItem Condition="Kind == SymbolKind::Overloads">*(OverloadsSymbol*)this,view(noinherit)</ExpandedItem>
+		    <ExpandedItem Condition="Kind == SymbolKind::Enum">(EnumSymbol*)this,view(noinherit)</ExpandedItem>
+		    <ExpandedItem Condition="Kind == SymbolKind::Typedef">(TypedefSymbol*)this,view(noinherit)</ExpandedItem>
+		    <ExpandedItem Condition="Kind == SymbolKind::Variable">(VariableSymbol*)this,view(noinherit)</ExpandedItem>
+		    <ExpandedItem Condition="Kind == SymbolKind::Field">(FieldInfo*)this,view(noinherit)</ExpandedItem>
+		    <ExpandedItem Condition="Kind == SymbolKind::Specialization">(SpecializationInfo*)this,view(noinherit)</ExpandedItem>
+		    <ExpandedItem Condition="Kind == SymbolKind::Friend">(FriendInfo*)this,view(noinherit)</ExpandedItem>
+		    <ExpandedItem Condition="Kind == SymbolKind::Enumerator">(EnumConstantSymbol*)this,view(noinherit)</ExpandedItem>
+		    <ExpandedItem Condition="Kind == SymbolKind::Guide">(GuideSymbol*)this,view(noinherit)</ExpandedItem>
+		    <ExpandedItem Condition="Kind == SymbolKind::NamespaceAlias">(NamespaceAliasSymbol*)this,view(noinherit)</ExpandedItem>
+		    <ExpandedItem Condition="Kind == SymbolKind::Using">(UsingSymbol*)this,view(noinherit)</ExpandedItem>
 		</Expand>
 	</Type>
 
-    <Type Name="clang::mrdocs::SymbolID">
+    <Type Name="mrdocs::SymbolID">
         <DisplayString Condition="strncmp((char*)this, (char*)&amp;SymbolID::invalid, 20) == 0">empty SymbolID</DisplayString>
         <DisplayString Condition="strncmp((char*)this, (char*)&amp;SymbolID::global, 20) == 0">global SymbolID</DisplayString>
         <DisplayString>{data_[0],nvoXb}{data_[1],nvoXb}{data_[2],nvoXb}{data_[3],nvoXb}{data_[4],nvoXb}{data_[5],nvoXb}{data_[6],nvoXb}{data_[7],nvoXb}{data_[8],nvoXb}{data_[9],nvoXb}{data_[10],nvoXb}{data_[11],nvoXb}{data_[12],nvoXb}{data_[13],nvoXb}{data_[14],nvoXb}{data_[15],nvoXb}{data_[16],nvoXb}{data_[17],nvoXb}{data_[18],nvoXb}{data_[19],nvoXb}</DisplayString>
@@ -66,7 +66,7 @@
         </Expand>
     </Type>
 
-    <Type Name="clang::mrdocs::Optional&lt;clang::mrdocs::SymbolID, *&gt;">
+    <Type Name="mrdocs::Optional&lt;mrdocs::SymbolID, *&gt;">
         <DisplayString Condition="strncmp((char*)t_.data_, (char*)&amp;SymbolID::invalid, 20) != 0">{t_}</DisplayString>
         <DisplayString>empty</DisplayString>
         <Expand>
@@ -75,11 +75,11 @@
 
 <!-- Error Types -->
 
-    <Type Name="clang::mrdocs::Error">
+    <Type Name="mrdocs::Error">
         <DisplayString>{reason_}</DisplayString>
     </Type>
 
-    <Type Name="clang::mrdocs::Expected&lt;*, *&gt;">
+    <Type Name="mrdocs::Expected&lt;*, *&gt;">
         <DisplayString Condition="has_value_">{val_}</DisplayString>
         <DisplayString Condition="! has_value_">{unex_}</DisplayString>
 
@@ -91,7 +91,7 @@
 
     <!-- Dom Types -->
 
-    <Type Name="clang::mrdocs::dom::String">
+    <Type Name="mrdocs::dom::String">
         <DisplayString Condition="psz_!=0">{psz_,s}</DisplayString>
         <DisplayString Condition="(((char*)(impl_+1))[0]&amp;0x80)!=0">{((char*)(impl_+1))+1,s}</DisplayString>
         <DisplayString Condition="(((char*)(impl_+1))[1]&amp;0x80)!=0">{((char*)(impl_+1))+2,s}</DisplayString>
@@ -106,11 +106,11 @@
         <DisplayString>[ doc::String ]</DisplayString>
     </Type>
 
-    <Type Name="clang::mrdocs::dom::Array">
+    <Type Name="mrdocs::dom::Array">
         <DisplayString>[ dom::Array ]</DisplayString>
     </Type>
 
-    <Type Name="clang::mrdocs::dom::Object">
+    <Type Name="mrdocs::dom::Object">
         <Intrinsic Name="as_default" Expression="dynamic_cast&lt;DefaultObjectImpl*&gt;(impl_._Ptr)"/>
         <Intrinsic Name="as_overlay" Expression="dynamic_cast&lt;OverlayObjectImpl*&gt;(impl_._Ptr)"/>
         <Intrinsic Name="as_hbs_helper" Expression="dynamic_cast&lt;HbsHelperObjectImpl*&gt;(impl_._Ptr)"/>
@@ -128,31 +128,31 @@
         </Expand>
     </Type>
 
-    <Type Name="clang::mrdocs::dom::Value">
-        <DisplayString Condition="kind_==clang::mrdocs::dom::Kind::Undefined">undefined</DisplayString>
-        <DisplayString Condition="kind_==clang::mrdocs::dom::Kind::Null">null</DisplayString>
-        <DisplayString Condition="kind_==clang::mrdocs::dom::Kind::Boolean">{b_}</DisplayString>
-        <DisplayString Condition="kind_==clang::mrdocs::dom::Kind::Integer">{i_}</DisplayString>
-        <DisplayString Condition="kind_==clang::mrdocs::dom::Kind::String">{str_}</DisplayString>
-        <DisplayString Condition="kind_==clang::mrdocs::dom::Kind::SafeString">{str_}</DisplayString>
-        <DisplayString Condition="kind_==clang::mrdocs::dom::Kind::Array">{arr_}</DisplayString>
-        <DisplayString Condition="kind_==clang::mrdocs::dom::Kind::Object">{obj_}</DisplayString>
-        <DisplayString Condition="kind_==clang::mrdocs::dom::Kind::Function">{fn_}</DisplayString>
+    <Type Name="mrdocs::dom::Value">
+        <DisplayString Condition="kind_==mrdocs::dom::Kind::Undefined">undefined</DisplayString>
+        <DisplayString Condition="kind_==mrdocs::dom::Kind::Null">null</DisplayString>
+        <DisplayString Condition="kind_==mrdocs::dom::Kind::Boolean">{b_}</DisplayString>
+        <DisplayString Condition="kind_==mrdocs::dom::Kind::Integer">{i_}</DisplayString>
+        <DisplayString Condition="kind_==mrdocs::dom::Kind::String">{str_}</DisplayString>
+        <DisplayString Condition="kind_==mrdocs::dom::Kind::SafeString">{str_}</DisplayString>
+        <DisplayString Condition="kind_==mrdocs::dom::Kind::Array">{arr_}</DisplayString>
+        <DisplayString Condition="kind_==mrdocs::dom::Kind::Object">{obj_}</DisplayString>
+        <DisplayString Condition="kind_==mrdocs::dom::Kind::Function">{fn_}</DisplayString>
         <DisplayString>invalid</DisplayString>
 
         <Expand>
-            <Item Condition="kind_==clang::mrdocs::dom::Kind::Boolean" Name="Value">b_</Item>
-            <Item Condition="kind_==clang::mrdocs::dom::Kind::Integer" Name="Value">i_</Item>
-            <ExpandedItem Condition="kind_==clang::mrdocs::dom::Kind::String">str_</ExpandedItem>
-            <ExpandedItem Condition="kind_==clang::mrdocs::dom::Kind::SafeString">str_</ExpandedItem>
-            <ExpandedItem Condition="kind_==clang::mrdocs::dom::Kind::Array">arr_</ExpandedItem>
-            <ExpandedItem Condition="kind_==clang::mrdocs::dom::Kind::Object">obj_</ExpandedItem>
-            <ExpandedItem Condition="kind_==clang::mrdocs::dom::Kind::Function">fn_</ExpandedItem>
+            <Item Condition="kind_==mrdocs::dom::Kind::Boolean" Name="Value">b_</Item>
+            <Item Condition="kind_==mrdocs::dom::Kind::Integer" Name="Value">i_</Item>
+            <ExpandedItem Condition="kind_==mrdocs::dom::Kind::String">str_</ExpandedItem>
+            <ExpandedItem Condition="kind_==mrdocs::dom::Kind::SafeString">str_</ExpandedItem>
+            <ExpandedItem Condition="kind_==mrdocs::dom::Kind::Array">arr_</ExpandedItem>
+            <ExpandedItem Condition="kind_==mrdocs::dom::Kind::Object">obj_</ExpandedItem>
+            <ExpandedItem Condition="kind_==mrdocs::dom::Kind::Function">fn_</ExpandedItem>
         </Expand>
     </Type>
 
 <!-- Javadocs -->
-    <Type Name="std::vector&lt;std::unique_ptr&lt;clang::mrdocs::doc::Block,std::default_delete&lt;clang::mrdocs::doc::Block&gt;&gt;,std::allocator&lt;std::unique_ptr&lt;clang::mrdocs::doc::Block,std::default_delete&lt;clang::mrdocs::doc::Block&gt;&gt;&gt;&gt;">
+    <Type Name="std::vector&lt;std::unique_ptr&lt;mrdocs::doc::Block,std::default_delete&lt;mrdocs::doc::Block&gt;&gt;,std::allocator&lt;std::unique_ptr&lt;mrdocs::doc::Block,std::default_delete&lt;mrdocs::doc::Block&gt;&gt;&gt;&gt;">
         <DisplayString>doc::Block[{_Mypair._Myval2._Myend-_Mypair._Myval2._Myfirst}]</DisplayString>
         <Expand>
             <ArrayItems>
@@ -161,7 +161,7 @@
             </ArrayItems>
         </Expand>
     </Type>
-    <Type Name="std::vector&lt;std::unique_ptr&lt;clang::mrdocs::doc::Text,std::default_delete&lt;clang::mrdocs::doc::Text&gt;&gt;,std::allocator&lt;std::unique_ptr&lt;clang::mrdocs::doc::Text,std::default_delete&lt;clang::mrdocs::doc::Text&gt;&gt;&gt;&gt;">
+    <Type Name="std::vector&lt;std::unique_ptr&lt;mrdocs::doc::Text,std::default_delete&lt;mrdocs::doc::Text&gt;&gt;,std::allocator&lt;std::unique_ptr&lt;mrdocs::doc::Text,std::default_delete&lt;mrdocs::doc::Text&gt;&gt;&gt;&gt;">
         <DisplayString>doc::Block[{_Mypair._Myval2._Myend-_Mypair._Myval2._Myfirst}]</DisplayString>
         <Expand>
             <ArrayItems>
@@ -171,9 +171,9 @@
         </Expand>
     </Type>
 
-    <Type Name="clang::mrdocs::doc::Block" Inheritable="true">
+    <Type Name="mrdocs::doc::Block" Inheritable="true">
         <DisplayString Condition="kind==Kind::admonition">
-            [ Admonition {(*(clang::mrdocs::doc::Admonition*)this).admonish} ]</DisplayString>
+            [ Admonition {(*(mrdocs::doc::Admonition*)this).admonish} ]</DisplayString>
         <DisplayString Condition="kind==Kind::brief">[ Brief ]</DisplayString>
         <DisplayString Condition="kind==Kind::code">[ Code] </DisplayString>
         <DisplayString Condition="kind==Kind::heading">[ doc::Heading ]</DisplayString>
@@ -188,7 +188,7 @@
         </Expand>
     </Type>
 
-    <Type Name="clang::mrdocs::doc::Text" Inheritable="true">
+    <Type Name="mrdocs::doc::Text" Inheritable="true">
         <DisplayString Condition="kind==Kind::styled">[ doc::Styled ]</DisplayString>
         <DisplayString Condition="kind==Kind::link">[ doc::Link ]</DisplayString>
         <DisplayString>{string}</DisplayString>
@@ -198,15 +198,15 @@
 
     <!-- <mrdocs/Support/JavaScript.hpp> -->
 
-    <Type Name="clang::mrdocs::js::Access">
+    <Type Name="mrdocs::js::Access">
         <DisplayString>[ js::Access ]</DisplayString>
     </Type>
 
-    <Type Name="clang::mrdocs::js::Scope">
+    <Type Name="mrdocs::js::Scope">
         <DisplayString>[ js::Scope ]</DisplayString>
     </Type>
 
-    <Type Name="clang::mrdocs::js::Param">
+    <Type Name="mrdocs::js::Param">
         <DisplayString Condition="kind_==Param::Kind::Undefined">undefined</DisplayString>
         <DisplayString Condition="kind_==Param::Kind::Null">null</DisplayString>
         <DisplayString Condition="kind_==Param::Kind::Boolean">{b_}</DisplayString>
@@ -219,16 +219,16 @@
         <DisplayString Condition="kind_==Param::Kind::DomObject">{obj_}</DisplayString>
     </Type>
 
-    <Type Name="clang::mrdocs::js::Value">
+    <Type Name="mrdocs::js::Value">
         <DisplayString>duk_value@{idx_}</DisplayString>
     </Type>
 
     <!-- ASTVisitor -->
 
-    <Type Name="clang::mrdocs::FilterPattern">
+    <Type Name="mrdocs::FilterPattern">
         <DisplayString>{pattern_}</DisplayString>
     </Type>
-    <Type Name="clang::mrdocs::FilterNode">
+    <Type Name="mrdocs::FilterNode">
         <Intrinsic Name="n_children" Expression="(size_t)(Children._Mypair._Myval2._Mylast - Children._Mypair._Myval2._Myfirst)" />
         <!--
         <DisplayString Condition="n_children() == 1">Excluded = {int(Excluded)}, {n_children()} child, Pattern = {Pattern}</DisplayString>
@@ -256,7 +256,7 @@
 
 <!-- ADT  -->
 
-    <Type Name="clang::mrdocs::Polymorphic&lt;*&gt;">
+    <Type Name="mrdocs::Polymorphic&lt;*&gt;">
         <DisplayString Condition="ptr_ != 0">*{ptr_}</DisplayString>
         <DisplayString Condition="ptr_ == 0">(empty)</DisplayString>
         <Expand>
diff --git a/share/gdb/mrdocs_printers.py b/share/gdb/mrdocs_printers.py
index 3b25fe066..5e616bc18 100644
--- a/share/gdb/mrdocs_printers.py
+++ b/share/gdb/mrdocs_printers.py
@@ -114,11 +114,11 @@ def lookup_function(val: gdb.Value):
             return EnumPrinter(val)
 
         typename: str = utils.resolved_typename(val)
-        if typename == 'clang::mrdocs::dom::Kind':
+        if typename == 'mrdocs::dom::Kind':
             return EnumPrinter(val)
-        if typename == 'clang::mrdocs::dom::Value':
+        if typename == 'mrdocs::dom::Value':
             return DomValuePrinter(val)
-        if typename == 'clang::mrdocs::dom::String':
+        if typename == 'mrdocs::dom::String':
             return DomStringPrinter(val)
         return None
 
diff --git a/share/lldb/clang_ast_formatters.py b/share/lldb/clang_ast_formatters.py
index 385bd0c33..e732dd924 100644
--- a/share/lldb/clang_ast_formatters.py
+++ b/share/lldb/clang_ast_formatters.py
@@ -105,7 +105,7 @@ def NamedDecl_summary(valobj, _dict):
     o = _ctx(valobj)
 
     # Qualified name first
-    q = _eval_str(o, "static_cast<const ::clang::NamedDecl*>(this)->getQualifiedNameAsString()")
+    q = _eval_str(o, "static_cast<const ::clang::NamedDecl*>(this)->getNameAsString()")
     if not q:
         q = _eval_str(o, "static_cast<const ::clang::NamedDecl*>(this)->getNameAsString()")
 
diff --git a/share/lldb/mrdocs_formatters.py b/share/lldb/mrdocs_formatters.py
index c9144ff27..b33a976f4 100644
--- a/share/lldb/mrdocs_formatters.py
+++ b/share/lldb/mrdocs_formatters.py
@@ -10,8 +10,8 @@
 # ---------- SIMPLE, WORKING REGEXES ----------
 # Tip: register BOTH const and non-const; avoid fancy groups.
 _INFO_REGEXES = [
-    r"^clang::mrdocs::[^:]*Info$",
-    r"^const clang::mrdocs::[^:]*Info$",
+    r"^mrdocs::[^:]*Info$",
+    r"^const mrdocs::[^:]*Info$",
 ]
 
 
@@ -245,12 +245,12 @@ def _norm_typename(t: lldb.SBType) -> str:
 
 
 def _is_info_type(t: lldb.SBType) -> bool:
-    return _norm_typename(t) == "clang::mrdocs::Info"
+    return _norm_typename(t) == "mrdocs::Info"
 
 
 class InfoLikeSyntheticProvider:
     """
-    Show fields from clang::mrdocs::Info FIRST,
+    Show fields from mrdocs::Info FIRST,
     then all other bases deepest-first, then most-derived.
     Never recurses into fields. Uses order prefixes to beat UI resorting.
     """
@@ -671,12 +671,12 @@ def get_child_index(self, name):
         return -1
 
 
-# -------- NameInfo summary: "Prefix::Name" or "Name" --------
+# -------- Name summary: "Prefix::Name" or "Name" --------
 
-# --- helpers for NameInfo prefix chain (names only, no ids) ---
+# --- helpers for Name prefix chain (names only, no ids) ---
 
 def _nameinfo_path_from(ni: lldb.SBValue) -> str | None:
-    """Return 'A::B::C' built from NameInfo::Name along the Prefix chain. No ids."""
+    """Return 'A::B::C' built from Name::Name along the Prefix chain. No ids."""
     if not ni or not ni.IsValid():
         return None
     # current name
@@ -685,10 +685,10 @@ def _nameinfo_path_from(ni: lldb.SBValue) -> str | None:
     if not nm:
         nm = "<no Name>"
 
-    # recurse into Prefix (Polymorphic<NameInfo>)
+    # recurse into Prefix (Polymorphic<Name>)
     pref_poly = _get_field_value_by_offset(ni, "Prefix") or ni.GetChildMemberWithName("Prefix")
     if pref_poly and pref_poly.IsValid():
-        inner = _poly_inner_value(pref_poly)  # "null" | SBValue(NameInfo) | None
+        inner = _poly_inner_value(pref_poly)  # "null" | SBValue(Name) | None
         if inner and inner != "null":
             parent = _nameinfo_path_from(inner)
             return f"{parent}::{nm}" if parent else nm
@@ -705,9 +705,9 @@ def _hex_from_symbolid(sbv) -> str | None:
     return ''.join(f'{b:02x}' for b in bs)
 
 
-# --- NameInfo summary: "Prefix::Name (idhex)" or "Name" ---
+# --- Name summary: "Prefix::Name (idhex)" or "Name" ---
 
-def NameInfoSummaryProvider(valobj, _dict):
+def NameSummaryProvider(valobj, _dict):
     try:
         v = _deref_if_ptr_or_ref(valobj)
         if not v or not v.IsValid():
@@ -748,22 +748,22 @@ def __lldb_init_module(debugger, _dict):
     for rx in _INFO_REGEXES:
         debugger.HandleCommand(f'type summary add -w {cat} -x -P -F mrdocs_formatters.InfoLikeSummaryProvider "{rx}"')
         debugger.HandleCommand(f'type synthetic add -w {cat} -x -l mrdocs_formatters.InfoLikeSyntheticProvider "{rx}"')
-    for rx in ("^clang::mrdocs::SymbolID$", "^const clang::mrdocs::SymbolID$"):
+    for rx in ("^mrdocs::SymbolID$", "^const mrdocs::SymbolID$"):
         debugger.HandleCommand(
             f'type summary add -w {cat} -x -P -F mrdocs_formatters.SymbolIDSummaryProvider "{rx}"'
         )
-    for rx in ("^clang::mrdocs::Optional<.*>$", "^const clang::mrdocs::Optional<.*>$"):
+    for rx in ("^mrdocs::Optional<.*>$", "^const mrdocs::Optional<.*>$"):
         debugger.HandleCommand(
             f'type summary add -w {cat} -x -P -F mrdocs_formatters.OptionalSummaryProvider "{rx}"'
         )
         debugger.HandleCommand(
             f'type synthetic add -w {cat} -x -l mrdocs_formatters.OptionalTransparentSyntheticProvider "{rx}"'
         )
-    for rx in ("^clang::mrdocs::Location$", "^const clang::mrdocs::Location$"):
+    for rx in ("^mrdocs::Location$", "^const mrdocs::Location$"):
         debugger.HandleCommand(
             f'type summary add -w {cat} -x -P -F mrdocs_formatters.LocationSummaryProvider "{rx}"'
         )
-    for rx in ("^clang::mrdocs::Polymorphic<.*>$", "^const clang::mrdocs::Polymorphic<.*>$"):
+    for rx in ("^mrdocs::Polymorphic<.*>$", "^const mrdocs::Polymorphic<.*>$"):
         debugger.HandleCommand(
             f'type summary add -w {cat} -x -P -F mrdocs_formatters.PolymorphicSummaryProvider "{rx}"'
         )
@@ -771,15 +771,15 @@ def __lldb_init_module(debugger, _dict):
             f'type synthetic add -w {cat} -x -l mrdocs_formatters.PolymorphicTransparentSyntheticProvider "{rx}"'
         )
     for rx in (
-            "^clang::mrdocs::NameInfo$",
-            "^const clang::mrdocs::NameInfo$",
-            "^class clang::mrdocs::NameInfo$",
-            "^const class clang::mrdocs::NameInfo$",
-            "^struct clang::mrdocs::NameInfo$",
-            "^const struct clang::mrdocs::NameInfo$",
+            "^mrdocs::Name$",
+            "^const mrdocs::Name$",
+            "^class mrdocs::Name$",
+            "^const class mrdocs::Name$",
+            "^struct mrdocs::Name$",
+            "^const struct mrdocs::Name$",
     ):
         debugger.HandleCommand(
-            f'type summary add -w {cat} -x -P -F mrdocs_formatters.NameInfoSummaryProvider "{rx}"'
+            f'type summary add -w {cat} -x -P -F mrdocs_formatters.NameSummaryProvider "{rx}"'
         )
 
     debugger.HandleCommand(f"type category enable {cat}")
diff --git a/share/mrdocs/addons/generator/common/partials/symbol/members-table.hbs b/share/mrdocs/addons/generator/common/partials/symbol/members-table.hbs
index fb8f53584..d01982328 100644
--- a/share/mrdocs/addons/generator/common/partials/symbol/members-table.hbs
+++ b/share/mrdocs/addons/generator/common/partials/symbol/members-table.hbs
@@ -4,7 +4,7 @@
     This partials renders each row with the symbol name and brief for
     each member.
 
-    Expected Context: {Symbol|NameInfo}[]
+    Expected Context: {Symbol|Name}[]
 
     Parameters:
         members: An array of symbols or nameinfo to render.
diff --git a/src/lib/AST/ASTAction.cpp b/src/lib/AST/ASTAction.cpp
index 44d6b902c..0dfa6a68a 100644
--- a/src/lib/AST/ASTAction.cpp
+++ b/src/lib/AST/ASTAction.cpp
@@ -18,14 +18,14 @@
 #include <clang/Lex/PreprocessorOptions.h>
 #include <clang/Parse/ParseAST.h>
 
-namespace clang {
+
 namespace mrdocs {
 
 void
 ASTAction::
 ExecuteAction()
 {
-    CompilerInstance& CI = getCompilerInstance();
+    clang::CompilerInstance& CI = getCompilerInstance();
     if (!CI.hasPreprocessor())
     {
         return;
@@ -100,4 +100,4 @@ CreateASTConsumer(
 }
 
 } // mrdocs
-} // clang
+
diff --git a/src/lib/AST/ASTAction.hpp b/src/lib/AST/ASTAction.hpp
index bc61e870b..fd87e63aa 100644
--- a/src/lib/AST/ASTAction.hpp
+++ b/src/lib/AST/ASTAction.hpp
@@ -20,7 +20,7 @@
 #include <lib/Support/ExecutionContext.hpp>
 #include <clang/Tooling/Tooling.h>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** The clang frontend action for visiting the AST
@@ -95,6 +95,6 @@ class ASTAction
 };
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_LIB_AST_ASTACTION_HPP
diff --git a/src/lib/AST/ASTVisitor.cpp b/src/lib/AST/ASTVisitor.cpp
index 26c8062e0..17deb40bc 100644
--- a/src/lib/AST/ASTVisitor.cpp
+++ b/src/lib/AST/ASTVisitor.cpp
@@ -14,9 +14,9 @@
 #include <mrdocs/Platform.hpp>
 #include <lib/AST/ASTVisitor.hpp>
 #include <lib/AST/ClangHelpers.hpp>
-#include <lib/AST/NameInfoBuilder.hpp>
+#include <lib/AST/NameBuilder.hpp>
 #include <lib/AST/ParseJavadoc.hpp>
-#include <lib/AST/TypeInfoBuilder.hpp>
+#include <lib/AST/TypeBuilder.hpp>
 #include <lib/Diagnostics.hpp>
 #include <lib/Support/Path.hpp>
 #include <lib/Support/Radix.hpp>
@@ -42,15 +42,15 @@
 #include <ranges>
 #include <unordered_set>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 ASTVisitor::
 ASTVisitor(
     ConfigImpl const& config,
     Diagnostics const& diags,
-    CompilerInstance& compiler,
-    ASTContext& context,
-    Sema& sema) noexcept
+    clang::CompilerInstance& compiler,
+    clang::ASTContext& context,
+    clang::Sema& sema) noexcept
     : config_(config)
     , diags_(diags)
     , compiler_(compiler)
@@ -62,12 +62,12 @@ ASTVisitor(
     initCustomCommentCommands(context_);
 
     // The traversal scope should *only* consist of the
-    // top-level TranslationUnitDecl.
+    // top-level clang::TranslationUnitDecl.
     // If this `assert` fires, then it means
     // ASTContext::setTraversalScope is being (erroneously)
     // used somewhere
     MRDOCS_ASSERT(context_.getTraversalScope() ==
-                  ArrayRef<Decl *>{context_.getTranslationUnitDecl()});
+                  llvm::ArrayRef<clang::Decl *>{context_.getTranslationUnitDecl()});
 }
 
 void
@@ -77,15 +77,15 @@ build()
     // Traverse the translation unit, only extracting
     // declarations which satisfy all filter conditions.
     // dependencies will be tracked, but not extracted
-    TranslationUnitDecl const* TU = context_.getTranslationUnitDecl();
+    clang::TranslationUnitDecl const* TU = context_.getTranslationUnitDecl();
     traverse(TU);
     MRDOCS_ASSERT(find(SymbolID::global));
 }
 
 template <
     class InfoTy,
-    std::derived_from<Decl> DeclTy>
-Info*
+    std::derived_from<clang::Decl> DeclTy>
+Symbol*
 ASTVisitor::
 traverse(DeclTy const* D)
 {
@@ -93,20 +93,20 @@ traverse(DeclTy const* D)
     MRDOCS_CHECK_OR(!D->isInvalidDecl(), nullptr);
     MRDOCS_SYMBOL_TRACE(D, context_);
 
-    if constexpr (std::same_as<DeclTy, Decl>)
+    if constexpr (std::same_as<DeclTy, clang::Decl>)
     {
         // Convert to the most derived type of the Decl
         // and call the appropriate traverse function
-        return visit(D, [&]<typename DeclTyU>(DeclTyU* U) -> Info*
+        return visit(D, [&]<typename DeclTyU>(DeclTyU* U) -> Symbol*
         {
-            if constexpr (!std::same_as<DeclTyU, Decl>)
+            if constexpr (!std::same_as<DeclTyU, clang::Decl>)
             {
                 return traverse(U);
             }
             return nullptr;
         });
     }
-    else if constexpr (HasInfoTypeFor<DeclTy> || std::derived_from<InfoTy, Info>)
+    else if constexpr (HasInfoTypeFor<DeclTy> || std::derived_from<InfoTy, Symbol>)
     {
         // If the declaration has a corresponding Info type,
         // we build the Info object and populate it with the
@@ -143,46 +143,46 @@ traverse(DeclTy const* D)
     return nullptr;
 }
 
-Info*
+Symbol*
 ASTVisitor::
-traverse(FunctionTemplateDecl const* D)
+traverse(clang::FunctionTemplateDecl const* D)
 {
-    // Route the traversal to GuideInfo or FunctionInfo
-    if (FunctionDecl* FD = D->getTemplatedDecl();
-        FD && isa<CXXDeductionGuideDecl>(FD))
+    // Route the traversal to GuideSymbol or FunctionSymbol
+    if (clang::FunctionDecl* FD = D->getTemplatedDecl();
+        FD && isa<clang::CXXDeductionGuideDecl>(FD))
     {
-        return traverse<GuideInfo>(D);
+        return traverse<GuideSymbol>(D);
     }
-    return traverse<FunctionInfo>(D);
+    return traverse<FunctionSymbol>(D);
 }
 
-Info*
+Symbol*
 ASTVisitor::
-traverse(UsingDirectiveDecl const* D)
+traverse(clang::UsingDirectiveDecl const* D)
 {
     MRDOCS_SYMBOL_TRACE(D, context_);
 
     // Find the parent namespace
     ScopeExitRestore s1(mode_, TraversalMode::Dependency);
-    Decl const* P = getParent(D);
+    clang::Decl const* P = getParent(D);
     MRDOCS_SYMBOL_TRACE(P, context_);
-    Info* PI = findOrTraverse(P);
+    Symbol* PI = findOrTraverse(P);
     MRDOCS_CHECK_OR(PI, nullptr);
     MRDOCS_CHECK_OR(PI->isNamespace(), nullptr);
     auto& PNI = PI->asNamespace();
 
     // Find the nominated namespace
-    Decl const* ND = D->getNominatedNamespace();
+    clang::Decl const* ND = D->getNominatedNamespace();
     MRDOCS_SYMBOL_TRACE(ND, context_);
     ScopeExitRestore s2(mode_, TraversalMode::Dependency);
-    Info* NDI = findOrTraverse(ND);
+    Symbol* NDI = findOrTraverse(ND);
     MRDOCS_CHECK_OR(NDI, nullptr);
 
-    Optional<Polymorphic<NameInfo>> res = toNameInfo(ND);
+    Optional<Polymorphic<Name>> res = toName(ND);
     MRDOCS_CHECK_OR(res, nullptr);
     MRDOCS_ASSERT(!res->valueless_after_move());
     MRDOCS_ASSERT((*res)->isIdentifier());
-    if (NameInfo NI = **res;
+    if (Name NI = **res;
         !contains(PNI.UsingDirectives, NI))
     {
         PNI.UsingDirectives.push_back(std::move(NI));
@@ -190,17 +190,17 @@ traverse(UsingDirectiveDecl const* D)
     return nullptr;
 }
 
-Info*
+Symbol*
 ASTVisitor::
-traverse(IndirectFieldDecl const* D)
+traverse(clang::IndirectFieldDecl const* D)
 {
     return traverse(D->getAnonField());
 }
 
 template <
-    std::derived_from<Info> InfoTy,
-    std::derived_from<Decl> DeclTy>
-requires (!std::derived_from<DeclTy, RedeclarableTemplateDecl>)
+    std::derived_from<Symbol> InfoTy,
+    std::derived_from<clang::Decl> DeclTy>
+requires (!std::derived_from<DeclTy, clang::RedeclarableTemplateDecl>)
 void
 ASTVisitor::
 traverseMembers(InfoTy& I, DeclTy const* DC)
@@ -209,14 +209,14 @@ traverseMembers(InfoTy& I, DeclTy const* DC)
     // not traverse its members as function arguments are
     // not main Info members.
     if constexpr (
-        !std::derived_from<DeclTy, FunctionDecl> &&
-        std::derived_from<DeclTy, DeclContext>)
+        !std::derived_from<DeclTy, clang::FunctionDecl> &&
+        std::derived_from<DeclTy, clang::DeclContext>)
     {
         // We only need members of regular symbols and see-below namespaces
         // - If symbol is SeeBelow we want the members if it's a namespace
         MRDOCS_CHECK_OR(
             I.Extraction != ExtractionMode::SeeBelow ||
-            I.Kind == InfoKind::Namespace);
+            I.Kind == SymbolKind::Namespace);
 
         // - If symbol is a Dependency, we only want the members if
         //   the traversal mode is BaseClass
@@ -232,9 +232,9 @@ traverseMembers(InfoTy& I, DeclTy const* DC)
 
         // There are many implicit declarations, especially in the
         // translation unit declaration, so we preemtively skip them here.
-        auto explicitMembers = std::ranges::views::filter(DC->decls(), [](Decl* D)
+        auto explicitMembers = std::ranges::views::filter(DC->decls(), [](clang::Decl* D)
             {
-                return !D->isImplicit() || isa<IndirectFieldDecl>(D);
+                return !D->isImplicit() || isa<clang::IndirectFieldDecl>(D);
             });
         for (auto* D : explicitMembers)
         {
@@ -248,8 +248,8 @@ traverseMembers(InfoTy& I, DeclTy const* DC)
 }
 
 template <
-    std::derived_from<Info> InfoTy,
-    std::derived_from<RedeclarableTemplateDecl> DeclTy>
+    std::derived_from<Symbol> InfoTy,
+    std::derived_from<clang::RedeclarableTemplateDecl> DeclTy>
 void
 ASTVisitor::
 traverseMembers(InfoTy& I, DeclTy const* D)
@@ -258,15 +258,15 @@ traverseMembers(InfoTy& I, DeclTy const* D)
 }
 
 template <
-    std::derived_from<Info> InfoTy,
-    std::derived_from<Decl> DeclTy>
-requires (!std::derived_from<DeclTy, RedeclarableTemplateDecl>)
+    std::derived_from<Symbol> InfoTy,
+    std::derived_from<clang::Decl> DeclTy>
+requires (!std::derived_from<DeclTy, clang::RedeclarableTemplateDecl>)
 void
 ASTVisitor::
 traverseParent(InfoTy& I, DeclTy const* DC)
 {
     MRDOCS_SYMBOL_TRACE(DC, context_);
-    if (Decl const* PD = getParent(DC))
+    if (clang::Decl const* PD = getParent(DC))
     {
         MRDOCS_SYMBOL_TRACE(PD, context_);
 
@@ -274,7 +274,7 @@ traverseParent(InfoTy& I, DeclTy const* DC)
         // to extract the parent scope:
         // Traverse the parent scope as a dependency if it
         // hasn't been extracted yet
-        Info* PI = nullptr;
+        Symbol* PI = nullptr;
         {
             ScopeExitRestore s(mode_, Dependency);
             if (PI = findOrTraverse(PD); !PI)
@@ -288,7 +288,7 @@ traverseParent(InfoTy& I, DeclTy const* DC)
 
         visit(*PI, [&]<typename ParentInfoTy>(ParentInfoTy& PU) -> void
         {
-            if constexpr (InfoParent<ParentInfoTy>)
+            if constexpr (SymbolParent<ParentInfoTy>)
             {
                 addMember(PU, I);
             }
@@ -297,8 +297,8 @@ traverseParent(InfoTy& I, DeclTy const* DC)
 }
 
 template <
-    std::derived_from<Info> InfoTy,
-    std::derived_from<RedeclarableTemplateDecl> DeclTy>
+    std::derived_from<Symbol> InfoTy,
+    std::derived_from<clang::RedeclarableTemplateDecl> DeclTy>
 void
 ASTVisitor::
 traverseParent(InfoTy& I, DeclTy const* D)
@@ -309,14 +309,14 @@ traverseParent(InfoTy& I, DeclTy const* D)
 
 Expected<llvm::SmallString<128>>
 ASTVisitor::
-generateUSR(Decl const* D) const
+generateUSR(clang::Decl const* D) const
 {
     MRDOCS_ASSERT(D);
     llvm::SmallString<128> res;
 
-    if (auto const* NAD = dyn_cast<NamespaceAliasDecl>(D))
+    if (auto const* NAD = dyn_cast<clang::NamespaceAliasDecl>(D))
     {
-        if (index::generateUSRForDecl(cast<Decl>(NAD->getNamespace()), res))
+        if (clang::index::generateUSRForDecl(cast<clang::Decl>(NAD->getNamespace()), res))
         {
             return Unexpected(Error("Failed to generate USR"));
         }
@@ -326,11 +326,11 @@ generateUSR(Decl const* D) const
     }
 
     // Handling UsingDecl
-    if (auto const* UD = dyn_cast<UsingDecl>(D))
+    if (auto const* UD = dyn_cast<clang::UsingDecl>(D))
     {
         for (auto const* shadow : UD->shadows())
         {
-            if (index::generateUSRForDecl(shadow->getTargetDecl(), res))
+            if (clang::index::generateUSRForDecl(shadow->getTargetDecl(), res))
             {
                 return Unexpected(Error("Failed to generate USR"));
             }
@@ -340,9 +340,9 @@ generateUSR(Decl const* D) const
         return res;
     }
 
-    if (auto const* UD = dyn_cast<UsingDirectiveDecl>(D))
+    if (auto const* UD = dyn_cast<clang::UsingDirectiveDecl>(D))
     {
-        if (index::generateUSRForDecl(UD->getNominatedNamespace(), res))
+        if (clang::index::generateUSRForDecl(UD->getNominatedNamespace(), res))
         {
             return Unexpected(Error("Failed to generate USR"));
         }
@@ -351,10 +351,10 @@ generateUSR(Decl const* D) const
         return res;
     }
 
-    // Handling UnresolvedUsingTypenameDecl
-    if (auto const* UD = dyn_cast<UnresolvedUsingTypenameDecl>(D))
+    // Handling clang::UnresolvedUsingTypenameDecl
+    if (auto const* UD = dyn_cast<clang::UnresolvedUsingTypenameDecl>(D))
     {
-        if (index::generateUSRForDecl(UD, res))
+        if (clang::index::generateUSRForDecl(UD, res))
         {
             return Unexpected(Error("Failed to generate USR"));
         }
@@ -363,10 +363,10 @@ generateUSR(Decl const* D) const
         return res;
     }
 
-    // Handling UnresolvedUsingValueDecl
-    if (auto const* UD = dyn_cast<UnresolvedUsingValueDecl>(D))
+    // Handling clang::UnresolvedUsingValueDecl
+    if (auto const* UD = dyn_cast<clang::UnresolvedUsingValueDecl>(D))
     {
-        if (index::generateUSRForDecl(UD, res))
+        if (clang::index::generateUSRForDecl(UD, res))
         {
             return Unexpected(Error("Failed to generate USR"));
         }
@@ -375,10 +375,10 @@ generateUSR(Decl const* D) const
         return res;
     }
 
-    // Handling UsingPackDecl
-    if (auto const* UD = dyn_cast<UsingPackDecl>(D))
+    // Handling clang::UsingPackDecl
+    if (auto const* UD = dyn_cast<clang::UsingPackDecl>(D))
     {
-        if (index::generateUSRForDecl(UD, res))
+        if (clang::index::generateUSRForDecl(UD, res))
         {
             return Unexpected(Error("Failed to generate USR"));
         }
@@ -387,15 +387,15 @@ generateUSR(Decl const* D) const
         return res;
     }
 
-    // Handling UsingEnumDecl
-    if (auto const* UD = dyn_cast<UsingEnumDecl>(D))
+    // Handling clang::UsingEnumDecl
+    if (auto const* UD = dyn_cast<clang::UsingEnumDecl>(D))
     {
-        if (index::generateUSRForDecl(UD, res))
+        if (clang::index::generateUSRForDecl(UD, res))
         {
             return Unexpected(Error("Failed to generate USR"));
         }
         res.append("@UED");
-        EnumDecl const* ED = UD->getEnumDecl();
+        clang::EnumDecl const* ED = UD->getEnumDecl();
         res.append(ED->getQualifiedNameAsString());
         return res;
     }
@@ -404,10 +404,10 @@ generateUSR(Decl const* D) const
     // generating USRs for friend declarations, so we
     // will improvise until I can merge a patch which
     // adds support for them
-    if(auto const* FD = dyn_cast<FriendDecl>(D))
+    if(auto const* FD = dyn_cast<clang::FriendDecl>(D))
     {
         // first, generate the USR for the containing class
-        if (index::generateUSRForDecl(cast<Decl>(FD->getDeclContext()), res))
+        if (clang::index::generateUSRForDecl(cast<clang::Decl>(FD->getDeclContext()), res))
         {
             return Unexpected(Error("Failed to generate USR"));
         }
@@ -415,9 +415,9 @@ generateUSR(Decl const* D) const
         res.append("@FD");
         // if the friend declaration names a type,
         // use the USR generator for types
-        if (TypeSourceInfo* TSI = FD->getFriendType())
+        if (clang::TypeSourceInfo* TSI = FD->getFriendType())
         {
-            if (index::generateUSRForType(TSI->getType(), context_, res))
+            if (clang::index::generateUSRForType(TSI->getType(), context_, res))
             {
                 return Unexpected(Error("Failed to generate USR"));
             }
@@ -431,12 +431,12 @@ generateUSR(Decl const* D) const
         }
     }
 
-    if (index::generateUSRForDecl(D, res))
+    if (clang::index::generateUSRForDecl(D, res))
     {
         return Unexpected(Error("Failed to generate USR"));
     }
 
-    auto const* Described = dyn_cast_if_present<TemplateDecl>(D);
+    auto const* Described = dyn_cast_if_present<clang::TemplateDecl>(D);
     auto const* Templated = D;
     if (auto const* DT = D->getDescribedTemplate())
     {
@@ -449,33 +449,33 @@ generateUSR(Decl const* D) const
 
     if(Described)
     {
-        TemplateParameterList const* TPL = Described->getTemplateParameters();
+        clang::TemplateParameterList const* TPL = Described->getTemplateParameters();
         if(auto const* RC = TPL->getRequiresClause())
         {
             RC = SubstituteConstraintExpressionWithoutSatisfaction(
-                sema_, cast<NamedDecl>(isa<FunctionTemplateDecl>(Described) ? Described : Templated), RC);
+                sema_, cast<clang::NamedDecl>(isa<clang::FunctionTemplateDecl>(Described) ? Described : Templated), RC);
             if (!RC)
             {
                 return Unexpected(Error("Failed to generate USR"));
             }
-            ODRHash odr_hash;
+            clang::ODRHash odr_hash;
             odr_hash.AddStmt(RC);
             res.append("@TPL#");
             res.append(llvm::itostr(odr_hash.CalculateHash()));
         }
     }
 
-    if(auto* FD = dyn_cast<FunctionDecl>(Templated);
+    if(auto* FD = dyn_cast<clang::FunctionDecl>(Templated);
         FD && FD->getTrailingRequiresClause())
     {
-        Expr const* RC = FD->getTrailingRequiresClause().ConstraintExpr;
+        clang::Expr const* RC = FD->getTrailingRequiresClause().ConstraintExpr;
         RC = SubstituteConstraintExpressionWithoutSatisfaction(
-            sema_, cast<NamedDecl>(Described ? Described : Templated), RC);
+            sema_, cast<clang::NamedDecl>(Described ? Described : Templated), RC);
         if (!RC)
         {
             return Unexpected(Error("Failed to generate USR"));
         }
-        ODRHash odr_hash;
+        clang::ODRHash odr_hash;
         odr_hash.AddStmt(RC);
         res.append("@TRC#");
         res.append(llvm::itostr(odr_hash.CalculateHash()));
@@ -487,7 +487,7 @@ generateUSR(Decl const* D) const
 bool
 ASTVisitor::
 generateID(
-    Decl const* D,
+    clang::Decl const* D,
     SymbolID& id) const
 {
     if (!D)
@@ -495,7 +495,7 @@ generateID(
         return false;
     }
 
-    if (isa<TranslationUnitDecl>(D))
+    if (isa<clang::TranslationUnitDecl>(D))
     {
         id = SymbolID::global;
         return true;
@@ -513,17 +513,17 @@ generateID(
 
 SymbolID
 ASTVisitor::
-generateID(Decl const* D) const
+generateID(clang::Decl const* D) const
 {
     SymbolID id = SymbolID::invalid;
     generateID(D, id);
     return id;
 }
 
-template <std::derived_from<Decl> DeclTy>
+template <std::derived_from<clang::Decl> DeclTy>
 void
 ASTVisitor::
-populate(Info& I, bool const isNew, DeclTy const* D)
+populate(Symbol& I, bool const isNew, DeclTy const* D)
 {
     populate(I.javadoc, D);
     populate(I.Loc, D);
@@ -533,12 +533,12 @@ populate(Info& I, bool const isNew, DeclTy const* D)
 
     // These should already have been populated by traverseImpl
     MRDOCS_ASSERT(I.id);
-    MRDOCS_ASSERT(I.Kind != InfoKind::None);
+    MRDOCS_ASSERT(I.Kind != SymbolKind::None);
 
     I.Name = extractName(D);
 }
 
-template <std::derived_from<Decl> DeclTy>
+template <std::derived_from<clang::Decl> DeclTy>
 void
 ASTVisitor::
 populate(SourceInfo& I, DeclTy const* D)
@@ -562,11 +562,11 @@ bool
 ASTVisitor::
 populate(
     Optional<Javadoc>& javadoc,
-    Decl const* D)
+    clang::Decl const* D)
 {
-    RawComment const* RC = getDocumentation(D);
+    clang::RawComment const* RC = getDocumentation(D);
     MRDOCS_CHECK_OR(RC, false);
-    comments::FullComment* FC =
+    clang::comments::FullComment* FC =
         RC->parse(D->getASTContext(), &sema_.getPreprocessor(), D);
     MRDOCS_CHECK_OR(FC, false);
     parseJavadoc(javadoc, FC, D, config_, diags_);
@@ -624,8 +624,8 @@ populate(
 void
 ASTVisitor::
 populate(
-    NamespaceInfo& I,
-    NamespaceDecl const* D)
+    NamespaceSymbol& I,
+    clang::NamespaceDecl const* D)
 {
     I.IsAnonymous = D->isAnonymousNamespace();
     if (!I.IsAnonymous)
@@ -638,8 +638,8 @@ populate(
 void
 ASTVisitor::
 populate(
-    NamespaceInfo& I,
-    TranslationUnitDecl const*)
+    NamespaceSymbol& I,
+    clang::TranslationUnitDecl const*)
 {
     I.id = SymbolID::global;
     I.IsAnonymous = false;
@@ -649,37 +649,37 @@ populate(
 void
 ASTVisitor::
 populate(
-    RecordInfo& I,
-    CXXRecordDecl const* D)
+    RecordSymbol& I,
+    clang::CXXRecordDecl const* D)
 {
     if (D->getTypedefNameForAnonDecl())
     {
         I.IsTypeDef = true;
     }
     I.KeyKind = toRecordKeyKind(D->getTagKind());
-    // These are from CXXRecordDecl::isEffectivelyFinal()
-    I.IsFinal = D->hasAttr<FinalAttr>();
+    // These are from clang::CXXRecordDecl::isEffectivelyFinal()
+    I.IsFinal = D->hasAttr<clang::FinalAttr>();
     if (auto const* DT = D->getDestructor())
     {
-        I.IsFinalDestructor = DT->hasAttr<FinalAttr>();
+        I.IsFinalDestructor = DT->hasAttr<clang::FinalAttr>();
     }
 
     // Extract direct bases. D->bases() will get the bases
     // from whichever declaration is the definition (if any)
     if(D->hasDefinition() && I.Bases.empty())
     {
-        for (CXXBaseSpecifier const& B : D->bases())
+        for (clang::CXXBaseSpecifier const& B : D->bases())
         {
-            AccessSpecifier const access = B.getAccessSpecifier();
+            clang::AccessSpecifier const access = B.getAccessSpecifier();
 
             if (!config_->extractPrivateBases &&
-                access == AS_private)
+                access == clang::AS_private)
             {
                 continue;
             }
 
-            QualType const BT = B.getType();
-            auto BaseType = toTypeInfo(BT, BaseClass);
+            clang::QualType const BT = B.getType();
+            auto BaseType = toType(BT, BaseClass);
 
             // If we're going to copy the members from the specialization,
             // we need to instantiate and traverse the specialization
@@ -687,19 +687,19 @@ populate(
             if (config_->extractImplicitSpecializations)
             {
                 [&] {
-                    auto* TST = BT->getAs<TemplateSpecializationType>();
+                    auto* TST = BT->getAs<clang::TemplateSpecializationType>();
                     MRDOCS_CHECK_OR(TST);
                     MRDOCS_SYMBOL_TRACE(TST, context_);
 
                     auto const* CTSD = dyn_cast_or_null<
-                            ClassTemplateSpecializationDecl>(
+                            clang::ClassTemplateSpecializationDecl>(
                             TST->getAsCXXRecordDecl());
                     MRDOCS_CHECK_OR(CTSD);
                     MRDOCS_SYMBOL_TRACE(CTSD, context_);
 
                     // Traverse the Decl as a dependency
                     ScopeExitRestore s(mode_, TraversalMode::BaseClass);
-                    Info const* SI = findOrTraverse(CTSD);
+                    Symbol const* SI = findOrTraverse(CTSD);
                     MRDOCS_CHECK_OR(SI);
                     auto& inner = innermostType(BaseType);
                     MRDOCS_CHECK_OR(inner);
@@ -712,7 +712,7 @@ populate(
                 }();
             }
 
-            // CXXBaseSpecifier::getEllipsisLoc indicates whether the
+            // clang::CXXBaseSpecifier::getEllipsisLoc indicates whether the
             // base was a pack expansion; a PackExpansionType is not built
             // for base-specifiers
             MRDOCS_ASSERT(!BaseType.valueless_after_move());
@@ -732,22 +732,22 @@ populate(
         D->hasDefinition() &&
         D->hasFriends())
     {
-        for (FriendDecl const* FD : D->friends())
+        for (clang::FriendDecl const* FD : D->friends())
         {
             // Check if the friend is a fundamental type
             // Declaring a fundamental type like `int` as a friend of a
             // class or struct does not have any practical effect. Thus,
             // it's not considered part of the public API.
-            if (TypeSourceInfo const* TSI = FD->getFriendType())
+            if (clang::TypeSourceInfo const* TSI = FD->getFriendType())
             {
-                Type const* T = TSI->getType().getTypePtrOrNull();
+                clang::Type const* T = TSI->getType().getTypePtrOrNull();
                 MRDOCS_CHECK_OR_CONTINUE(!T || !T->isBuiltinType());
             }
             FriendInfo F;
             populate(F, FD);
             if (F.id != SymbolID::invalid)
             {
-                Info* FI = this->find(F.id);
+                Symbol* FI = this->find(F.id);
                 MRDOCS_CHECK_OR_CONTINUE(FI);
                 MRDOCS_CHECK_OR_CONTINUE(FI->Extraction != ExtractionMode::ImplementationDefined);
             }
@@ -769,7 +769,7 @@ populate(
 
 void
 ASTVisitor::
-populate(RecordInfo& I, ClassTemplateDecl const* D)
+populate(RecordSymbol& I, clang::ClassTemplateDecl const* D)
 {
     populate(I.Template, D->getTemplatedDecl(), D);
     populate(I, D->getTemplatedDecl());
@@ -777,24 +777,24 @@ populate(RecordInfo& I, ClassTemplateDecl const* D)
 
 void
 ASTVisitor::
-populate(RecordInfo& I, ClassTemplateSpecializationDecl const* D)
+populate(RecordSymbol& I, clang::ClassTemplateSpecializationDecl const* D)
 {
     populate(I.Template, D, D->getSpecializedTemplate());
-    populate(I, cast<CXXRecordDecl>(D));
+    populate(I, cast<clang::CXXRecordDecl>(D));
 }
 
 void
 ASTVisitor::
-populate(RecordInfo& I, ClassTemplatePartialSpecializationDecl const* D)
+populate(RecordSymbol& I, clang::ClassTemplatePartialSpecializationDecl const* D)
 {
-    populate(I, dynamic_cast<ClassTemplateSpecializationDecl const*>(D));
+    populate(I, dynamic_cast<clang::ClassTemplateSpecializationDecl const*>(D));
 }
 
 void
 ASTVisitor::
 populate(
-    FunctionInfo& I,
-    FunctionDecl const* D)
+    FunctionSymbol& I,
+    clang::FunctionDecl const* D)
 {
     MRDOCS_SYMBOL_TRACE(D, context_);
 
@@ -840,7 +840,7 @@ populate(
     if (auto FT = getDeclaratorType(D); !FT.isNull())
     {
         MRDOCS_SYMBOL_TRACE(FT, context_);
-        auto const* FPT = FT->template getAs<FunctionProtoType>();
+        auto const* FPT = FT->template getAs<clang::FunctionProtoType>();
         MRDOCS_SYMBOL_TRACE(FPT, context_);
         populate(I.Noexcept, FPT);
         I.HasTrailingReturn |= FPT->hasTrailingReturn();
@@ -853,27 +853,27 @@ populate(
     I.IsDeleted |= D->isDeleted();
     I.IsDeletedAsWritten |= D->isDeletedAsWritten();
     I.IsNoReturn |= D->isNoReturn();
-    I.HasOverrideAttr |= D->hasAttr<OverrideAttr>();
+    I.HasOverrideAttr |= D->hasAttr<clang::OverrideAttr>();
 
-    if (ConstexprSpecKind const CSK = D->getConstexprKind();
-        CSK != ConstexprSpecKind::Unspecified)
+    if (clang::ConstexprSpecKind const CSK = D->getConstexprKind();
+        CSK != clang::ConstexprSpecKind::Unspecified)
     {
         I.Constexpr = toConstexprKind(CSK);
     }
 
-    if (StorageClass const SC = D->getStorageClass())
+    if (clang::StorageClass const SC = D->getStorageClass())
     {
         I.StorageClass = toStorageClassKind(SC);
     }
 
-    I.IsNodiscard |= D->hasAttr<WarnUnusedResultAttr>();
+    I.IsNodiscard |= D->hasAttr<clang::WarnUnusedResultAttr>();
     I.IsExplicitObjectMemberFunction |= D->hasCXXExplicitFunctionObjectParameter();
 
-    ArrayRef<ParmVarDecl*> const params = D->parameters();
+    llvm::ArrayRef<clang::ParmVarDecl*> const params = D->parameters();
     I.Params.resize(params.size());
     for (std::size_t i = 0; i < params.size(); ++i)
     {
-        ParmVarDecl const* P = params[i];
+        clang::ParmVarDecl const* P = params[i];
         MRDOCS_SYMBOL_TRACE(P, context_);
         Param& param = I.Params[i];
 
@@ -884,10 +884,10 @@ populate(
 
         if (param.Type->isAuto())
         {
-            param.Type = toTypeInfo(P->getOriginalType());
+            param.Type = toType(P->getOriginalType());
         }
 
-        Expr const* default_arg = P->hasUninstantiatedDefaultArg() ?
+        clang::Expr const* default_arg = P->hasUninstantiatedDefaultArg() ?
             P->getUninstantiatedDefaultArg() : P->getInit();
         if (!param.Default && default_arg)
         {
@@ -909,9 +909,9 @@ populate(
     // extract the return type in direct dependency mode
     // if it contains a placeholder type which is
     // deduced as a local class type
-    QualType const RT = D->getReturnType();
+    clang::QualType const RT = D->getReturnType();
     MRDOCS_SYMBOL_TRACE(RT, context_);
-    I.ReturnType = toTypeInfo(RT);
+    I.ReturnType = toType(RT);
 
     if (auto* TRC = D->getTrailingRequiresClause().ConstraintExpr)
     {
@@ -961,23 +961,23 @@ populate(
 
 void
 ASTVisitor::
-populate(FunctionInfo& I, FunctionTemplateDecl const* D)
+populate(FunctionSymbol& I, clang::FunctionTemplateDecl const* D)
 {
-    FunctionDecl const* TD = D->getTemplatedDecl();
+    clang::FunctionDecl const* TD = D->getTemplatedDecl();
     populate(I.Template, TD, D);
-    if (auto* C = dyn_cast<CXXConstructorDecl>(TD))
+    if (auto* C = dyn_cast<clang::CXXConstructorDecl>(TD))
     {
         populate(I, C);
     }
-    else if (auto* Dtor = dyn_cast<CXXDestructorDecl>(TD))
+    else if (auto* Dtor = dyn_cast<clang::CXXDestructorDecl>(TD))
     {
         populate(I, Dtor);
     }
-    else if (auto* Conv = dyn_cast<CXXConversionDecl>(TD))
+    else if (auto* Conv = dyn_cast<clang::CXXConversionDecl>(TD))
     {
         populate(I, Conv);
     }
-    else if (auto* M = dyn_cast<CXXMethodDecl>(TD))
+    else if (auto* M = dyn_cast<clang::CXXMethodDecl>(TD))
     {
         populate(I, M);
     }
@@ -989,9 +989,9 @@ populate(FunctionInfo& I, FunctionTemplateDecl const* D)
 
 void
 ASTVisitor::
-populate(FunctionInfo& I, CXXMethodDecl const* D)
+populate(FunctionSymbol& I, clang::CXXMethodDecl const* D)
 {
-    FunctionDecl const* FD = D;
+    clang::FunctionDecl const* FD = D;
     populate(I, FD);
     I.IsRecordMethod = true;
     I.IsVirtual |= D->isVirtual();
@@ -1000,31 +1000,31 @@ populate(FunctionInfo& I, CXXMethodDecl const* D)
     I.IsConst |= D->isConst();
     I.IsVolatile |= D->isVolatile();
     I.RefQualifier = toReferenceKind(D->getRefQualifier());
-    I.IsFinal |= D->hasAttr<FinalAttr>();
+    I.IsFinal |= D->hasAttr<clang::FinalAttr>();
 }
 
 void
 ASTVisitor::
-populate(FunctionInfo& I, CXXConstructorDecl const* D)
+populate(FunctionSymbol& I, clang::CXXConstructorDecl const* D)
 {
-    CXXMethodDecl const* FD = D;
+    clang::CXXMethodDecl const* FD = D;
     populate(I, FD);
     populate(I.Explicit, D->getExplicitSpecifier());
 }
 
 void
 ASTVisitor::
-populate(FunctionInfo& I, CXXDestructorDecl const* D)
+populate(FunctionSymbol& I, clang::CXXDestructorDecl const* D)
 {
-    CXXMethodDecl const* FD = D;
+    clang::CXXMethodDecl const* FD = D;
     populate(I, FD);
 }
 
 void
 ASTVisitor::
-populate(FunctionInfo& I, CXXConversionDecl const* D)
+populate(FunctionSymbol& I, clang::CXXConversionDecl const* D)
 {
-    CXXMethodDecl const* FD = D;
+    clang::CXXMethodDecl const* FD = D;
     populate(I, FD);
     populate(I.Explicit, D->getExplicitSpecifier());
 }
@@ -1033,21 +1033,21 @@ populate(FunctionInfo& I, CXXConversionDecl const* D)
 void
 ASTVisitor::
 populate(
-    EnumInfo& I,
-    EnumDecl const* D)
+    EnumSymbol& I,
+    clang::EnumDecl const* D)
 {
     I.Scoped = D->isScoped();
     if (D->isFixed())
     {
-        I.UnderlyingType = toTypeInfo(D->getIntegerType());
+        I.UnderlyingType = toType(D->getIntegerType());
     }
 }
 
 void
 ASTVisitor::
 populate(
-    EnumConstantInfo& I,
-    EnumConstantDecl const* D)
+    EnumConstantSymbol& I,
+    clang::EnumConstantDecl const* D)
 {
     I.Name = extractName(D);
     populate(
@@ -1058,36 +1058,36 @@ populate(
 
 void
 ASTVisitor::
-populate(TypedefInfo& I, TypedefNameDecl const* D)
+populate(TypedefSymbol& I, clang::TypedefNameDecl const* D)
 {
-    QualType const QT = D->getUnderlyingType();
-    I.Type = toTypeInfo(QT);
+    clang::QualType const QT = D->getUnderlyingType();
+    I.Type = toType(QT);
 }
 
 void
 ASTVisitor::
-populate(TypedefInfo& I, TypedefDecl const* D)
+populate(TypedefSymbol& I, clang::TypedefDecl const* D)
 {
-    populate(I, cast<TypedefNameDecl>(D));
+    populate(I, cast<clang::TypedefNameDecl>(D));
 }
 
 void
 ASTVisitor::
-populate(TypedefInfo& I, TypeAliasDecl const* D)
+populate(TypedefSymbol& I, clang::TypeAliasDecl const* D)
 {
-    I.IsUsing = isa<TypeAliasDecl>(D);
-    populate(I, cast<TypedefNameDecl>(D));
+    I.IsUsing = isa<clang::TypeAliasDecl>(D);
+    populate(I, cast<clang::TypedefNameDecl>(D));
 }
 
 void
 ASTVisitor::
-populate(TypedefInfo& I, TypeAliasTemplateDecl const* D)
+populate(TypedefSymbol& I, clang::TypeAliasTemplateDecl const* D)
 {
     populate(I.Template, D->getTemplatedDecl(), D);
     if (auto* TD = D->getTemplatedDecl();
-        isa<TypeAliasDecl>(TD))
+        isa<clang::TypeAliasDecl>(TD))
     {
-        populate(I, cast<TypeAliasDecl>(TD));
+        populate(I, cast<clang::TypeAliasDecl>(TD));
     }
     else
     {
@@ -1098,28 +1098,28 @@ populate(TypedefInfo& I, TypeAliasTemplateDecl const* D)
 void
 ASTVisitor::
 populate(
-    VariableInfo& I,
-    VarDecl const* D)
+    VariableSymbol& I,
+    clang::VarDecl const* D)
 {
     // KRYSTIAN FIXME: we need to properly merge storage class
-    if (StorageClass const SC = D->getStorageClass())
+    if (clang::StorageClass const SC = D->getStorageClass())
     {
         I.StorageClass = toStorageClassKind(SC);
     }
     // this handles thread_local, as well as the C
     // __thread and __Thread_local specifiers
     I.IsThreadLocal |= D->getTSCSpec() !=
-        ThreadStorageClassSpecifier::TSCS_unspecified;
+        clang::ThreadStorageClassSpecifier::TSCS_unspecified;
     // KRYSTIAN NOTE: VarDecl does not provide getConstexprKind,
     // nor does it use getConstexprKind to store whether
     // a variable is constexpr/constinit. Although
     // only one is permitted in a variable declaration,
     // it is possible to declare a static data member
     // as both constexpr and constinit in separate declarations..
-    I.IsConstinit |= D->hasAttr<ConstInitAttr>();
+    I.IsConstinit |= D->hasAttr<clang::ConstInitAttr>();
     I.IsConstexpr |= D->isConstexpr();
     I.IsInline |= D->isInline();
-    if (Expr const* E = D->getInit())
+    if (clang::Expr const* E = D->getInit())
     {
         populate(I.Initializer, E);
     }
@@ -1129,13 +1129,13 @@ populate(
         // `const` qualifier which we need to remove
         QT.removeLocalConst();
     }
-    I.Type = toTypeInfo(QT);
+    I.Type = toType(QT);
     populateAttributes(I, D);
 }
 
 void
 ASTVisitor::
-populate(VariableInfo& I, VarTemplateDecl const* D)
+populate(VariableSymbol& I, clang::VarTemplateDecl const* D)
 {
     populate(I.Template, D->getTemplatedDecl(), D);
     populate(I, D->getTemplatedDecl());
@@ -1143,28 +1143,28 @@ populate(VariableInfo& I, VarTemplateDecl const* D)
 
 void
 ASTVisitor::
-populate(VariableInfo& I, VarTemplateSpecializationDecl const* D)
+populate(VariableSymbol& I, clang::VarTemplateSpecializationDecl const* D)
 {
     populate(I.Template, D, D->getSpecializedTemplate());
-    populate(I, cast<VarDecl>(D));
+    populate(I, cast<clang::VarDecl>(D));
 }
 
 void
 ASTVisitor::
-populate(VariableInfo& I, VarTemplatePartialSpecializationDecl const* D)
+populate(VariableSymbol& I, clang::VarTemplatePartialSpecializationDecl const* D)
 {
-    populate(I, dynamic_cast<VarTemplateSpecializationDecl const*>(D));
+    populate(I, dynamic_cast<clang::VarTemplateSpecializationDecl const*>(D));
 }
 
 void
 ASTVisitor::
 populate(
-    VariableInfo& I,
-    FieldDecl const* D)
+    VariableSymbol& I,
+    clang::FieldDecl const* D)
 {
     I.IsRecordField = true;
-    I.Type = toTypeInfo(D->getType());
-    if (Expr const* E = D->getInClassInitializer())
+    I.Type = toType(D->getType());
+    if (clang::Expr const* E = D->getInClassInitializer())
     {
         populate(I.Initializer, E);
     }
@@ -1175,9 +1175,9 @@ populate(
         I.IsBitfield = true;
         populate(I.BitfieldWidth, D->getBitWidth());
     }
-    I.HasNoUniqueAddress = D->hasAttr<NoUniqueAddressAttr>();
-    I.IsDeprecated = D->hasAttr<DeprecatedAttr>();
-    I.IsMaybeUnused = D->hasAttr<UnusedAttr>();
+    I.HasNoUniqueAddress = D->hasAttr<clang::NoUniqueAddressAttr>();
+    I.IsDeprecated = D->hasAttr<clang::DeprecatedAttr>();
+    I.IsMaybeUnused = D->hasAttr<clang::UnusedAttr>();
     populateAttributes(I, D);
 }
 
@@ -1185,21 +1185,21 @@ void
 ASTVisitor::
 populate(
     FriendInfo& I,
-    FriendDecl const* D)
+    clang::FriendDecl const* D)
 {
-    if (TypeSourceInfo const* TSI = D->getFriendType())
+    if (clang::TypeSourceInfo const* TSI = D->getFriendType())
     {
-        I.Type = toTypeInfo(TSI->getType());
+        I.Type = toType(TSI->getType());
         MRDOCS_CHECK_OR((*I.Type)->isNamed());
         auto const& NTI = (*I.Type)->asNamed();
         MRDOCS_CHECK_OR(NTI.Name);
         I.id = NTI.Name->id;
     }
-    else if (NamedDecl const* ND = D->getFriendDecl())
+    else if (clang::NamedDecl const* ND = D->getFriendDecl())
     {
         // ND can be a function or a class
         ScopeExitRestore s(mode_, Dependency);
-        if (Info const* SI = traverse(dyn_cast<Decl>(ND)))
+        if (Symbol const* SI = traverse(dyn_cast<clang::Decl>(ND)))
         {
             I.id = SI->id;
         }
@@ -1208,7 +1208,7 @@ populate(
     // documentation from the FriendDecl when the friend
     // is the only declaration.
     MRDOCS_CHECK_OR(isDocumented(D));
-    Info* TI = find(I.id);
+    Symbol* TI = find(I.id);
     MRDOCS_CHECK_OR(TI);
     MRDOCS_CHECK_OR(!TI->javadoc);
     populate(TI->javadoc, D);
@@ -1217,14 +1217,14 @@ populate(
 void
 ASTVisitor::
 populate(
-    GuideInfo& I,
-    CXXDeductionGuideDecl const* D)
+    GuideSymbol& I,
+    clang::CXXDeductionGuideDecl const* D)
 {
-    I.Deduced = toTypeInfo(D->getReturnType());
-    for (ParmVarDecl const* P : D->parameters())
+    I.Deduced = toType(D->getReturnType());
+    for (clang::ParmVarDecl const* P : D->parameters())
     {
         I.Params.emplace_back(
-            toTypeInfo(P->getOriginalType()),
+            toType(P->getOriginalType()),
             P->getNameAsString(),
             // deduction guides cannot have default arguments
             std::string());
@@ -1235,22 +1235,22 @@ populate(
 void
 ASTVisitor::
 populate(
-    GuideInfo& I,
-    FunctionTemplateDecl const* D)
+    GuideSymbol& I,
+    clang::FunctionTemplateDecl const* D)
 {
     populate(I.Template, D->getTemplatedDecl(), D);
-    populate(I, cast<CXXDeductionGuideDecl>(D->getTemplatedDecl()));
+    populate(I, cast<clang::CXXDeductionGuideDecl>(D->getTemplatedDecl()));
 }
 
 void
 ASTVisitor::
 populate(
-    NamespaceAliasInfo& I,
-    NamespaceAliasDecl const* D)
+    NamespaceAliasSymbol& I,
+    clang::NamespaceAliasDecl const* D)
 {
-    NamedDecl const* Aliased = D->getAliasedNamespace();
-    NestedNameSpecifier NNS = D->getQualifier();
-    Optional<Polymorphic<NameInfo>> NI = toNameInfo(Aliased, {}, NNS);
+    clang::NamedDecl const* Aliased = D->getAliasedNamespace();
+    clang::NestedNameSpecifier NNS = D->getQualifier();
+    Optional<Polymorphic<Name>> NI = toName(Aliased, {}, NNS);
     MRDOCS_CHECK_OR(NI);
     MRDOCS_ASSERT((*NI)->isIdentifier());
     I.AliasedSymbol = std::move((**NI).asIdentifier());
@@ -1259,21 +1259,21 @@ populate(
 void
 ASTVisitor::
 populate(
-    UsingInfo& I,
-    UsingDecl const* D)
+    UsingSymbol& I,
+    clang::UsingDecl const* D)
 {
     I.Class = UsingClass::Normal;
-    DeclarationName const& Name = D->getNameInfo().getName();
-    NestedNameSpecifier const& NNS = D->getQualifier();
-    auto INI = toNameInfo(Name, {}, NNS);
+    clang::DeclarationName const& Name = D->getNameInfo().getName();
+    clang::NestedNameSpecifier const& NNS = D->getQualifier();
+    auto INI = toName(Name, {}, NNS);
     MRDOCS_CHECK_OR(INI);
     I.IntroducedName = *INI;
-    for (UsingShadowDecl const* UDS: D->shadows())
+    for (clang::UsingShadowDecl const* UDS: D->shadows())
     {
         ScopeExitRestore s(mode_, Dependency);
-        Decl* S = UDS->getTargetDecl();
+        clang::Decl* S = UDS->getTargetDecl();
         using enum ExtractionMode;
-        if (Info* SI = findOrTraverse(S);
+        if (Symbol* SI = findOrTraverse(S);
             SI &&
             !is_one_of(SI->Extraction,{Dependency, ImplementationDefined}))
         {
@@ -1285,8 +1285,8 @@ populate(
 void
 ASTVisitor::
 populate(
-    ConceptInfo& I,
-    ConceptDecl const* D)
+    ConceptSymbol& I,
+    clang::ConceptDecl const* D)
 {
     populate(I.Template, D, D);
     populate(I.Constraint, D->getConstraintExpr());
@@ -1296,23 +1296,23 @@ populate(
 /*  Default function to populate template parameters
  */
 template <
-    std::derived_from<Decl> DeclTy,
-    std::derived_from<TemplateDecl> TemplateDeclTy>
+    std::derived_from<clang::Decl> DeclTy,
+    std::derived_from<clang::TemplateDecl> TemplateDeclTy>
 void
 ASTVisitor::
 populate(TemplateInfo& Template, DeclTy const*, TemplateDeclTy const* TD)
 {
     MRDOCS_ASSERT(TD);
     MRDOCS_CHECK_OR(!TD->isImplicit());
-    if (TemplateParameterList const* TPL = TD->getTemplateParameters();
+    if (clang::TemplateParameterList const* TPL = TD->getTemplateParameters();
         !TPL->empty() &&
-        std::ranges::none_of(TPL->asArray(), [](NamedDecl const* ND) {
+        std::ranges::none_of(TPL->asArray(), [](clang::NamedDecl const* ND) {
             return !ND->isImplicit();
         }))
     {
         return;
     }
-    TemplateParameterList const* TPL = TD->getTemplateParameters();
+    clang::TemplateParameterList const* TPL = TD->getTemplateParameters();
     populate(Template, TPL);
 }
 
@@ -1320,8 +1320,8 @@ void
 ASTVisitor::
 populate(
     TemplateInfo& Template,
-    ClassTemplateSpecializationDecl const* CTSD,
-    ClassTemplateDecl const* CTD)
+    clang::ClassTemplateSpecializationDecl const* CTSD,
+    clang::ClassTemplateDecl const* CTD)
 {
     MRDOCS_ASSERT(CTD);
 
@@ -1369,31 +1369,31 @@ populate(
 
 
     // Extract the template parameters if this is a partial specialization
-    if (auto* CTPSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(CTSD))
+    if (auto* CTPSD = dyn_cast<clang::ClassTemplatePartialSpecializationDecl>(CTSD))
     {
-        TemplateParameterList* params = CTPSD->getTemplateParameters();
+        clang::TemplateParameterList* params = CTPSD->getTemplateParameters();
         populate(Template, params);
     }
 }
 
-template<std::derived_from<VarDecl> VarDeclTy>
+template<std::derived_from<clang::VarDecl> VarDeclTy>
 void
 ASTVisitor::
 populate(
     TemplateInfo& Template,
     VarDeclTy const* D,
-    VarTemplateDecl const* VTD)
+    clang::VarTemplateDecl const* VTD)
 {
     MRDOCS_ASSERT(VTD);
 
     // If D is a partial/explicit specialization, extract the template arguments
-    if(auto* VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
+    if(auto* VTSD = dyn_cast<clang::VarTemplateSpecializationDecl>(D))
     {
         generateID(getInstantiatedFrom(VTD), Template.Primary);
         // extract the template arguments of the specialization
         populate(Template.Args, VTSD->getTemplateArgsAsWritten());
         // extract the template parameters if this is a partial specialization
-        if (auto* VTPSD = dyn_cast<VarTemplatePartialSpecializationDecl>(D))
+        if (auto* VTPSD = dyn_cast<clang::VarTemplatePartialSpecializationDecl>(D))
         {
             populate(Template, VTPSD->getTemplateParameters());
         }
@@ -1409,14 +1409,14 @@ void
 ASTVisitor::
 populate(
     NoexceptInfo& I,
-    FunctionProtoType const* FPT)
+    clang::FunctionProtoType const* FPT)
 {
     MRDOCS_ASSERT(FPT);
     I.Implicit = ! FPT->hasNoexceptExceptionSpec();
     I.Kind = toNoexceptKind(
         FPT->getExceptionSpecType());
     // store the operand, if any
-    if (Expr const* NoexceptExpr = FPT->getNoexceptExpr())
+    if (clang::Expr const* NoexceptExpr = FPT->getNoexceptExpr())
     {
         I.Operand = toString(NoexceptExpr);
     }
@@ -1426,13 +1426,13 @@ void
 ASTVisitor::
 populate(
     ExplicitInfo& I,
-    ExplicitSpecifier const& ES)
+    clang::ExplicitSpecifier const& ES)
 {
     I.Implicit = ! ES.isSpecified();
     I.Kind = toExplicitKind(ES);
 
     // store the operand, if any
-    if (Expr const* ExplicitExpr = ES.getExpr())
+    if (clang::Expr const* ExplicitExpr = ES.getExpr())
     {
         I.Operand = toString(ExplicitExpr);
     }
@@ -1442,7 +1442,7 @@ void
 ASTVisitor::
 populate(
     ExprInfo& I,
-    Expr const* E)
+    clang::Expr const* E)
 {
     if (!E)
     {
@@ -1457,7 +1457,7 @@ void
 ASTVisitor::
 populate(
     ConstantExprInfo<T>& I,
-    Expr const* E)
+    clang::Expr const* E)
 {
     populate(static_cast<ExprInfo&>(I), E);
     // if the expression is dependent,
@@ -1474,7 +1474,7 @@ void
 ASTVisitor::
 populate(
     ConstantExprInfo<T>& I,
-    Expr const* E,
+    clang::Expr const* E,
     llvm::APInt const& V)
 {
     populate(I, E);
@@ -1486,7 +1486,7 @@ void
 ASTVisitor::
 populate<std::uint64_t>(
     ConstantExprInfo<std::uint64_t>& I,
-    Expr const* E,
+    clang::Expr const* E,
     llvm::APInt const& V);
 
 
@@ -1494,15 +1494,15 @@ void
 ASTVisitor::
 populate(
     Polymorphic<TParam>& I,
-    NamedDecl const* N)
+    clang::NamedDecl const* N)
 {
     MRDOCS_ASSERT(!I.valueless_after_move());
     visit(N, [&]<typename DeclTy>(DeclTy const* P)
     {
-        constexpr Decl::Kind kind =
+        constexpr clang::Decl::Kind kind =
             DeclToKind<DeclTy>();
 
-        if constexpr(kind == Decl::TemplateTypeParm)
+        if constexpr(kind == clang::Decl::TemplateTypeParm)
         {
             if (I->Kind != TParamKind::Type)
             {
@@ -1518,27 +1518,27 @@ populate(
                 R->Default = toTArg(
                     P->getDefaultArgument().getArgument());
             }
-            if(TypeConstraint const* TC = P->getTypeConstraint())
+            if (clang::TypeConstraint const* TC = P->getTypeConstraint())
             {
-                NestedNameSpecifier NNS =
+                clang::NestedNameSpecifier NNS =
                     TC->getNestedNameSpecifierLoc().getNestedNameSpecifier();
-                Optional<ASTTemplateArgumentListInfo const*> TArgs;
+                Optional<clang::ASTTemplateArgumentListInfo const*> TArgs;
                 if (TC->hasExplicitTemplateArgs())
                 {
                     TArgs.emplace(TC->getTemplateArgsAsWritten());
                 }
-                R->Constraint = toNameInfo(TC->getNamedConcept(), TArgs, NNS);
+                R->Constraint = toName(TC->getNamedConcept(), TArgs, NNS);
             }
             return;
         }
-        else if constexpr(kind == Decl::NonTypeTemplateParm)
+        else if constexpr(kind == clang::Decl::NonTypeTemplateParm)
         {
             if (I->Kind != TParamKind::Constant)
             {
                 I = Polymorphic<TParam>(std::in_place_type<ConstantTParam>);
             }
             auto* R = (I.operator->())->asConstantPtr();
-            R->Type = toTypeInfo(P->getType());
+            R->Type = toType(P->getType());
             if (P->hasDefaultArgument() && !R->Default)
             {
                 R->Default = toTArg(
@@ -1546,21 +1546,21 @@ populate(
             }
             return;
         }
-        else if constexpr(kind == Decl::TemplateTemplateParm)
+        else if constexpr(kind == clang::Decl::TemplateTemplateParm)
         {
             if (I->Kind != TParamKind::Template)
             {
                 I = Polymorphic<TParam>(std::in_place_type<TemplateTParam>);
             }
-            auto const* TTPD = cast<TemplateTemplateParmDecl>(P);
+            auto const* TTPD = cast<clang::TemplateTemplateParmDecl>(P);
             MRDOCS_CHECK_OR(TTPD);
-            TemplateParameterList const* TPL = TTPD->getTemplateParameters();
+            clang::TemplateParameterList const* TPL = TTPD->getTemplateParameters();
             MRDOCS_CHECK_OR(TPL);
             auto* Result = (I.operator->())->asTemplatePtr();
             Result->Params.reserve(TPL->size());
             for (std::size_t i = 0; i < TPL->size(); ++i)
             {
-                NamedDecl const* TP = TPL->getParam(i);
+                clang::NamedDecl const* TP = TPL->getParam(i);
                 auto& Param
                     = i < Result->Params.size() ?
                           Result->Params[i] :
@@ -1569,8 +1569,8 @@ populate(
             }
             if (TTPD->hasDefaultArgument() && !Result->Default)
             {
-                TemplateArgumentLoc const& TAL = TTPD->getDefaultArgument();
-                TemplateArgument const& TA = TAL.getArgument();
+                clang::TemplateArgumentLoc const& TAL = TTPD->getDefaultArgument();
+                clang::TemplateArgument const& TA = TAL.getArgument();
                 Result->Default = toTArg(TA);
             }
             return;
@@ -1593,7 +1593,7 @@ void
 ASTVisitor::
 populate(
     TemplateInfo& TI,
-    TemplateParameterList const* TPL)
+    clang::TemplateParameterList const* TPL)
 {
     if (!TPL)
     {
@@ -1603,7 +1603,7 @@ populate(
     auto ExplicitTemplateParameters =
         std::views::filter(
             TemplateParameters,
-            [](NamedDecl const* P)
+            [](clang::NamedDecl const* P)
             {
                 return !P->isImplicit();
             });
@@ -1615,7 +1615,7 @@ populate(
     std::size_t i = 0;
     while (explicitIt != ExplicitTemplateParameters.end())
     {
-        NamedDecl const* P = TPL->getParam(i);
+        clang::NamedDecl const* P = TPL->getParam(i);
         Polymorphic<TParam>& Param =
             i < TI.Params.size() ?
                 TI.Params[i] :
@@ -1687,7 +1687,7 @@ void
 ASTVisitor::
 populate(
     std::vector<Polymorphic<TArg>>& result,
-    ASTTemplateArgumentListInfo const* args)
+    clang::ASTTemplateArgumentListInfo const* args)
 {
     if (!args)
     {
@@ -1701,17 +1701,17 @@ populate(
         }));
 }
 
-template <std::derived_from<Info> InfoTy>
+template <std::derived_from<Symbol> InfoTy>
 void
 ASTVisitor::
-populateAttributes(InfoTy& I, Decl const* D)
+populateAttributes(InfoTy& I, clang::Decl const* D)
 {
     if constexpr (requires { I.Attributes; })
     {
         MRDOCS_CHECK_OR(D->hasAttrs());
-        for (Attr const* attr: D->getAttrs())
+        for (clang::Attr const* attr: D->getAttrs())
         {
-            IdentifierInfo const* II = attr->getAttrName();
+            clang::IdentifierInfo const* II = attr->getAttrName();
             if (!II)
             {
                 continue;
@@ -1727,8 +1727,7 @@ populateAttributes(InfoTy& I, Decl const* D)
 void
 ASTVisitor::
 addMember(
-    NamespaceInfo& I,
-    Info const& Member)
+    NamespaceSymbol& I, Symbol const& Member)
 {
     if (auto const* U = Member.asNamespacePtr())
     {
@@ -1789,8 +1788,7 @@ addMember(
 void
 ASTVisitor::
 addMember(
-    RecordInfo& I,
-    Info const& Member)
+    RecordSymbol& I, Symbol const& Member)
 {
     switch (Member.Access)
     {
@@ -1810,7 +1808,7 @@ addMember(
 
 void
 ASTVisitor::
-addMember(RecordTranche& T, Info const& Member)
+addMember(RecordTranche& T, Symbol const& Member)
 {
     if (auto const* U = Member.asNamespaceAliasPtr())
     {
@@ -1878,7 +1876,7 @@ addMember(RecordTranche& T, Info const& Member)
 
 void
 ASTVisitor::
-addMember(EnumInfo& I, Info const& Member) const
+addMember(EnumSymbol& I, Symbol const& Member) const
 {
     if (auto const* U = Member.asEnumConstantPtr())
     {
@@ -1893,7 +1891,7 @@ addMember(EnumInfo& I, Info const& Member) const
 
 void
 ASTVisitor::
-addMember(OverloadsInfo& I, Info const& Member) const
+addMember(OverloadsSymbol& I, Symbol const& Member) const
 {
     if (Member.isFunction())
     {
@@ -1908,7 +1906,7 @@ addMember(OverloadsInfo& I, Info const& Member) const
 
 void
 ASTVisitor::
-addMember(std::vector<SymbolID>& container, Info const& Member) const
+addMember(std::vector<SymbolID>& container, Symbol const& Member) const
 {
     if (!contains(container, Member.id))
     {
@@ -1916,22 +1914,22 @@ addMember(std::vector<SymbolID>& container, Info const& Member) const
     }
 }
 
-template <std::derived_from<Decl> DeclTy>
+template <std::derived_from<clang::Decl> DeclTy>
 std::string
 ASTVisitor::
 extractName(DeclTy const* D)
 {
-    if constexpr (std::same_as<DeclTy, CXXDeductionGuideDecl>)
+    if constexpr (std::same_as<DeclTy, clang::CXXDeductionGuideDecl>)
     {
         return extractName(D->getDeducedTemplate());
     }
-    else if constexpr (std::derived_from<DeclTy, FriendDecl>)
+    else if constexpr (std::derived_from<DeclTy, clang::FriendDecl>)
     {
         if (auto* FD = D->getFriendDecl())
         {
             return extractName(D->getFriendDecl());
         }
-        if (TypeSourceInfo const* FT = D->getFriendType())
+        if (clang::TypeSourceInfo const* FT = D->getFriendType())
         {
             std::string Name;
             llvm::raw_string_ostream os(Name);
@@ -1939,27 +1937,27 @@ extractName(DeclTy const* D)
             return Name;
         }
     }
-    else if constexpr (std::derived_from<DeclTy, UsingDirectiveDecl>)
+    else if constexpr (std::derived_from<DeclTy, clang::UsingDirectiveDecl>)
     {
         return extractName(D->getNominatedNamespace());
     }
-    else if constexpr (std::derived_from<DeclTy, NamedDecl>)
+    else if constexpr (std::derived_from<DeclTy, clang::NamedDecl>)
     {
-        return extractName(cast<NamedDecl>(D));
+        return extractName(cast<clang::NamedDecl>(D));
     }
     return {};
 }
 
 std::string
 ASTVisitor::
-extractName(NamedDecl const* D)
+extractName(clang::NamedDecl const* D)
 {
     return extractName(D->getDeclName());
 }
 
 std::string
 ASTVisitor::
-extractName(DeclarationName const N)
+extractName(clang::DeclarationName const N)
 {
     std::string result;
     if (N.isEmpty())
@@ -1968,36 +1966,36 @@ extractName(DeclarationName const N)
     }
     switch(N.getNameKind())
     {
-    case DeclarationName::Identifier:
+    case clang::DeclarationName::Identifier:
         if (auto const* I = N.getAsIdentifierInfo())
         {
             result.append(I->getName());
         }
         break;
-    case DeclarationName::CXXDestructorName:
+    case clang::DeclarationName::CXXDestructorName:
         result.push_back('~');
         [[fallthrough]];
-    case DeclarationName::CXXConstructorName:
+    case clang::DeclarationName::CXXConstructorName:
         if (auto const* R = N.getCXXNameType()->getAsCXXRecordDecl())
         {
             result.append(R->getIdentifier()->getName());
         }
         break;
-    case DeclarationName::CXXDeductionGuideName:
+    case clang::DeclarationName::CXXDeductionGuideName:
         if (auto const* T = N.getCXXDeductionGuideTemplate())
         {
             result.append(T->getIdentifier()->getName());
         }
         break;
-    case DeclarationName::CXXConversionFunctionName:
+    case clang::DeclarationName::CXXConversionFunctionName:
     {
         result.append("operator ");
         // KRYSTIAN FIXME: we *really* should not be
         // converting types to strings like this
-        result.append(mrdocs::toString(*toTypeInfo(N.getCXXNameType())));
+        result.append(mrdocs::toString(*toType(N.getCXXNameType())));
         break;
     }
-    case DeclarationName::CXXOperatorName:
+    case clang::DeclarationName::CXXOperatorName:
     {
         OperatorKind const K = toOperatorKind(
             N.getCXXOverloadedOperator());
@@ -2010,8 +2008,8 @@ extractName(DeclarationName const N)
         result.append(name);
         break;
     }
-    case DeclarationName::CXXLiteralOperatorName:
-    case DeclarationName::CXXUsingDirective:
+    case clang::DeclarationName::CXXLiteralOperatorName:
+        case clang::DeclarationName::CXXUsingDirective:
         break;
     default:
         MRDOCS_UNREACHABLE();
@@ -2019,30 +2017,30 @@ extractName(DeclarationName const N)
     return result;
 }
 
-SmallString<256>
+llvm::SmallString<256>
 ASTVisitor::
-qualifiedName(Decl const* D) const
+qualifiedName(clang::Decl const* D) const
 {
-    if (auto* ND = dyn_cast<NamedDecl>(D))
+    if (auto* ND = dyn_cast<clang::NamedDecl>(D))
     {
         return qualifiedName(ND);
     }
     return {};
 }
 
-SmallString<256>
+llvm::SmallString<256>
 ASTVisitor::
-qualifiedName(NamedDecl const* ND) const
+qualifiedName(clang::NamedDecl const* ND) const
 {
-    SmallString<256> name;
+    llvm::SmallString<256> name;
     llvm::raw_svector_ostream stream(name);
     getQualifiedName(ND, stream, context_.getPrintingPolicy());
     return name;
 }
 
-Polymorphic<TypeInfo>
+Polymorphic<Type>
 ASTVisitor::
-toTypeInfo(QualType const qt, TraversalMode const mode)
+toType(clang::QualType const qt, TraversalMode const mode)
 {
     MRDOCS_SYMBOL_TRACE(qt, context_);
 
@@ -2052,41 +2050,41 @@ toTypeInfo(QualType const qt, TraversalMode const mode)
     // extraction criteria
     ScopeExitRestore s(mode_, mode);
 
-    // Build the TypeInfo representation for the type
-    TypeInfoBuilder Builder(*this);
+    // Build the Type representation for the type
+    TypeBuilder Builder(*this);
     Builder.Visit(qt);
     return Builder.result();
 }
 
-Optional<Polymorphic<NameInfo>>
+Optional<Polymorphic<Name>>
 ASTVisitor::
-toNameInfo(NestedNameSpecifier NNS)
+toName(clang::NestedNameSpecifier NNS)
 {
     MRDOCS_SYMBOL_TRACE(NNS, context_);
     ScopeExitRestore scope(mode_, Dependency);
     switch(NNS.getKind()) {
-    case NestedNameSpecifier::Kind::Null:
+    case clang::NestedNameSpecifier::Kind::Null:
         return std::nullopt;
-    case NestedNameSpecifier::Kind::Type: {
-        const Type *T = NNS.getAsType();
-        NameInfoBuilder Builder(*this);
+    case clang::NestedNameSpecifier::Kind::Type: {
+        const clang::Type *T = NNS.getAsType();
+        NameBuilder Builder(*this);
         Builder.Visit(T);
         return Builder.result();
     }
-    case NestedNameSpecifier::Kind::Namespace: {
-        auto I = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
+    case clang::NestedNameSpecifier::Kind::Namespace: {
+        auto I = Polymorphic<Name>(std::in_place_type<IdentifierName>);
         auto [ND, Prefix] = NNS.getAsNamespaceAndPrefix();
-        I->Name = ND->getIdentifier()->getName();
-        I->Prefix = toNameInfo(Prefix);
-        Decl const* ID = getInstantiatedFrom(ND);
-        if (Info* info = findOrTraverse(const_cast<Decl*>(ID)))
+        I->Identifier = ND->getIdentifier()->getName();
+        I->Prefix = toName(Prefix);
+        clang::Decl const* ID = getInstantiatedFrom(ND);
+        if (Symbol* info = findOrTraverse(const_cast<clang::Decl*>(ID)))
         {
             I->id = info->id;
         }
         return I;
     }
-    case NestedNameSpecifier::Kind::Global:
-    case NestedNameSpecifier::Kind::MicrosoftSuper:
+    case clang::NestedNameSpecifier::Kind::Global:
+    case clang::NestedNameSpecifier::Kind::MicrosoftSuper:
     default:
         // Unimplemented
         return std::nullopt;
@@ -2095,46 +2093,46 @@ toNameInfo(NestedNameSpecifier NNS)
 }
 
 template <class TArgRange>
-Optional<Polymorphic<NameInfo>>
+Optional<Polymorphic<Name>>
 ASTVisitor::
-toNameInfo(
-    DeclarationName const Name,
+toName(
+    clang::DeclarationName const Name,
     Optional<TArgRange> TArgs,
-    NestedNameSpecifier NNS)
+    clang::NestedNameSpecifier NNS)
 {
     if (Name.isEmpty())
     {
         return std::nullopt;
     }
-    Optional<Polymorphic<NameInfo>> I = std::nullopt;
+    Optional<Polymorphic<struct Name>> I = std::nullopt;
     if (TArgs)
     {
-        I = Polymorphic<NameInfo>(std::in_place_type<SpecializationNameInfo>);
+        I = Polymorphic<struct Name>(std::in_place_type<SpecializationName>);
         populate((**I).asSpecialization().TemplateArgs, *TArgs);
     }
     else
     {
-        I = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
+        I = Polymorphic<struct Name>(std::in_place_type<IdentifierName>);
     }
-    (*I)->Name = extractName(Name);
-    (*I)->Prefix = toNameInfo(NNS);
+    (*I)->Identifier = extractName(Name);
+    (*I)->Prefix = toName(NNS);
     return I;
 }
 
 template <class TArgRange>
-Optional<Polymorphic<NameInfo>>
+Optional<Polymorphic<Name>>
 ASTVisitor::
-toNameInfo(
-    Decl const* D,
+toName(
+    clang::Decl const* D,
     Optional<TArgRange> TArgs,
-    NestedNameSpecifier NNS)
+    clang::NestedNameSpecifier NNS)
 {
-    auto const* ND = dyn_cast_if_present<NamedDecl>(D);
+    auto const* ND = dyn_cast_if_present<clang::NamedDecl>(D);
     if (!ND)
     {
         return std::nullopt;
     }
-    Optional<Polymorphic<NameInfo>> I = toNameInfo(ND->getDeclName(), std::move(TArgs), NNS);
+    Optional<Polymorphic<Name>> I = toName(ND->getDeclName(), std::move(TArgs), NNS);
     if (!I)
     {
         return std::nullopt;
@@ -2142,7 +2140,7 @@ toNameInfo(
     MRDOCS_ASSERT(!I->valueless_after_move());
     ScopeExitRestore scope(mode_, Dependency);
     auto* ID = getInstantiatedFrom(D);
-    if (Info const* info = findOrTraverse(const_cast<Decl*>(ID)))
+    if (Symbol const* info = findOrTraverse(const_cast<clang::Decl*>(ID)))
     {
         (*I)->id = info->id;
     }
@@ -2150,16 +2148,16 @@ toNameInfo(
 }
 
 template
-Optional<Polymorphic<NameInfo>>
+Optional<Polymorphic<Name>>
 ASTVisitor::
-toNameInfo<llvm::ArrayRef<clang::TemplateArgument>>(
-    Decl const* D,
+toName<llvm::ArrayRef<clang::TemplateArgument>>(
+    clang::Decl const* D,
     Optional<llvm::ArrayRef<clang::TemplateArgument>> TArgs,
-    NestedNameSpecifier NNS);
+    clang::NestedNameSpecifier NNS);
 
 Polymorphic<TArg>
 ASTVisitor::
-toTArg(TemplateArgument const& A)
+toTArg(clang::TemplateArgument const& A)
 {
     // TypePrinter generates an internal placeholder name (e.g. type-parameter-0-0)
     // for template type parameters used as arguments. it also cannonicalizes
@@ -2173,38 +2171,38 @@ toTArg(TemplateArgument const& A)
     switch(A.getKind())
     {
     // empty template argument (e.g. not yet deduced)
-    case TemplateArgument::Null:
+    case clang::TemplateArgument::Null:
         break;
 
     // a template argument pack (any kind)
-    case TemplateArgument::Pack:
+    case clang::TemplateArgument::Pack:
     {
-        // we should never a TemplateArgument::Pack here
+        // we should never a clang::TemplateArgument::Pack here
         MRDOCS_UNREACHABLE();
         break;
     }
     // type
-    case TemplateArgument::Type:
+    case clang::TemplateArgument::Type:
     {
         auto R = Polymorphic<TArg>(std::in_place_type<TypeTArg>);
-        QualType QT = A.getAsType();
+        clang::QualType QT = A.getAsType();
         MRDOCS_ASSERT(! QT.isNull());
         // if the template argument is a pack expansion,
         // use the expansion pattern as the type & mark
         // the template argument as a pack expansion
-        if(Type const* T = QT.getTypePtr();
-            auto* PT = dyn_cast<PackExpansionType>(T))
+        if(clang::Type const* T = QT.getTypePtr();
+            auto* PT = dyn_cast<clang::PackExpansionType>(T))
         {
             R->IsPackExpansion = true;
             QT = PT->getPattern();
         }
-        static_cast<TypeTArg &>(*R).Type = toTypeInfo(QT);
+        static_cast<TypeTArg &>(*R).Type = toType(QT);
         return R;
     }
     // pack expansion of a template name
-    case TemplateArgument::TemplateExpansion:
+    case clang::TemplateArgument::TemplateExpansion:
     // template name
-    case TemplateArgument::Template:
+    case clang::TemplateArgument::Template:
     {
         auto R = Polymorphic<TArg>(std::in_place_type<TemplateTArg>);
         R->IsPackExpansion = A.isPackExpansion();
@@ -2215,7 +2213,7 @@ toTArg(TemplateArgument const& A)
         // for the time being, we will use the name & SymbolID of
         // the referenced declaration (if it isn't dependent),
         // and fallback to printing the template name otherwise
-        TemplateName const TN = A.getAsTemplateOrTemplatePattern();
+        clang::TemplateName const TN = A.getAsTemplateOrTemplatePattern();
         if(auto* TD = TN.getAsTemplateDecl())
         {
             if (auto* II = TD->getIdentifier())
@@ -2227,24 +2225,24 @@ toTArg(TemplateArgument const& A)
         {
             llvm::raw_string_ostream stream(Name);
             TN.print(stream, context_.getPrintingPolicy(),
-                TemplateName::Qualified::AsWritten);
+                clang::TemplateName::Qualified::AsWritten);
         }
         return R;
     }
     // nullptr value
-    case TemplateArgument::NullPtr:
+    case clang::TemplateArgument::NullPtr:
     // expression referencing a declaration
-    case TemplateArgument::Declaration:
+    case clang::TemplateArgument::Declaration:
     // integral expression
-    case TemplateArgument::Integral:
+    case clang::TemplateArgument::Integral:
     // expression
-    case TemplateArgument::Expression:
+    case clang::TemplateArgument::Expression:
     {
         auto R = Polymorphic<TArg>(std::in_place_type<ConstantTArg>);
         R->IsPackExpansion = A.isPackExpansion();
         // if this is a pack expansion, use the template argument
         // expansion pattern in place of the template argument pack
-        TemplateArgument const& adjusted =
+        clang::TemplateArgument const& adjusted =
             R->IsPackExpansion ?
             A.getPackExpansionPattern() : A;
 
@@ -2263,7 +2261,7 @@ toTArg(TemplateArgument const& A)
 
 std::string
 ASTVisitor::
-toString(Expr const* E)
+toString(clang::Expr const* E)
 {
     std::string result;
     llvm::raw_string_ostream stream(result);
@@ -2273,30 +2271,30 @@ toString(Expr const* E)
 
 std::string
 ASTVisitor::
-toString(Type const* T)
+toString(clang::Type const* T)
 {
-    if(auto* AT = dyn_cast_if_present<AutoType>(T))
+    if(auto* AT = dyn_cast_if_present<clang::AutoType>(T))
     {
         switch(AT->getKeyword())
         {
-        case AutoTypeKeyword::Auto:
-        case AutoTypeKeyword::GNUAutoType:
+        case clang::AutoTypeKeyword::Auto:
+        case clang::AutoTypeKeyword::GNUAutoType:
             return "auto";
-        case AutoTypeKeyword::DecltypeAuto:
+        case clang::AutoTypeKeyword::DecltypeAuto:
             return "decltype(auto)";
         default:
             MRDOCS_UNREACHABLE();
         }
     }
-    if(auto* TTPT = dyn_cast_if_present<TemplateTypeParmType>(T))
+    if(auto* TTPT = dyn_cast_if_present<clang::TemplateTypeParmType>(T))
     {
-        if (TemplateTypeParmDecl* TTPD = TTPT->getDecl();
+        if (clang::TemplateTypeParmDecl* TTPD = TTPT->getDecl();
             TTPD && TTPD->isImplicit())
         {
             return "auto";
         }
     }
-    return QualType(T, 0).getAsString(
+    return clang::QualType(T, 0).getAsString(
         context_.getPrintingPolicy());
 }
 
@@ -2317,17 +2315,17 @@ toInteger(llvm::APInt const& V)
 
 std::string
 ASTVisitor::
-getSourceCode(SourceRange const& R) const
+getSourceCode(clang::SourceRange const& R) const
 {
-    return Lexer::getSourceText(
-        CharSourceRange::getTokenRange(R),
+    return clang::Lexer::getSourceText(
+        clang::CharSourceRange::getTokenRange(R),
         source_,
         context_.getLangOpts()).str();
 }
 
 Optional<ASTVisitor::SFINAEInfo>
 ASTVisitor::
-extractSFINAEInfo(QualType const T)
+extractSFINAEInfo(clang::QualType const T)
 {
     MRDOCS_SYMBOL_TRACE(T, context_);
     MRDOCS_CHECK_OR(config_->sfinae, std::nullopt);
@@ -2357,9 +2355,9 @@ extractSFINAEInfo(QualType const T)
         if (SFINAEControl->ControllingParams[I])
         {
             MRDOCS_SYMBOL_TRACE(Args[I], context_);
-            TemplateArgument ArgsI = Args[I];
-            MRDOCS_CHECK_OR_CONTINUE(ArgsI.getKind() == TemplateArgument::ArgKind::Expression);
-            Expr* E = Args[I].getAsExpr();
+            clang::TemplateArgument ArgsI = Args[I];
+            MRDOCS_CHECK_OR_CONTINUE(ArgsI.getKind() == clang::TemplateArgument::ArgKind::Expression);
+            clang::Expr* E = Args[I].getAsExpr();
             MRDOCS_CHECK_OR_CONTINUE(E);
             Result.Constraints.emplace_back();
             populate(Result.Constraints.back(), E);
@@ -2373,8 +2371,8 @@ extractSFINAEInfo(QualType const T)
 Optional<ASTVisitor::SFINAEControlParams>
 ASTVisitor::
 getSFINAEControlParams(
-    TemplateDecl* TD,
-    IdentifierInfo const* Member)
+    clang::TemplateDecl* TD,
+    clang::IdentifierInfo const* Member)
 {
     MRDOCS_SYMBOL_TRACE(TD, context_);
     MRDOCS_SYMBOL_TRACE(Member, context_);
@@ -2385,18 +2383,18 @@ getSFINAEControlParams(
     // to find the index of the controlling parameter in the list of
     // template arguments of the template declaration.
     auto FindParam = [this](
-        ArrayRef<TemplateArgument> Arguments,
-        TemplateArgument const& Arg) -> std::size_t
+        llvm::ArrayRef<clang::TemplateArgument> Arguments,
+        clang::TemplateArgument const& Arg) -> std::size_t
     {
-        if (Arg.getKind() != TemplateArgument::Type)
+        if (Arg.getKind() != clang::TemplateArgument::Type)
         {
             return -1;
         }
         auto const It = std::ranges::find_if(
             Arguments,
-            [&](TemplateArgument const& Other)
+            [&](clang::TemplateArgument const& Other)
             {
-                if (Other.getKind() != TemplateArgument::Type)
+                if (Other.getKind() != clang::TemplateArgument::Type)
                 {
                     return false;
                 }
@@ -2406,7 +2404,7 @@ getSFINAEControlParams(
         return found ? It - Arguments.data() : static_cast<std::size_t>(-1);
     };
 
-    if(auto* ATD = dyn_cast<TypeAliasTemplateDecl>(TD))
+    if(auto* ATD = dyn_cast<clang::TypeAliasTemplateDecl>(TD))
     {
         // If the alias template is an alias template specialization,
         // we need to do the process for the underlying type
@@ -2441,7 +2439,7 @@ getSFINAEControlParams(
 
         // Return the controlling parameters with values corresponding to
         // the primary template arguments
-        TemplateParameterList* primaryTemplParams = ATD->getTemplateParameters();
+        clang::TemplateParameterList* primaryTemplParams = ATD->getTemplateParameters();
         MRDOCS_SYMBOL_TRACE(primaryTemplParams, context_);
         return SFINAEControlParams(
             primaryTemplParams,
@@ -2449,8 +2447,8 @@ getSFINAEControlParams(
             ParamIdx);
     }
 
-    // Ensure this is a ClassTemplateDecl
-    auto* CTD = dyn_cast<ClassTemplateDecl>(TD);
+    // Ensure this is a clang::ClassTemplateDecl
+    auto* CTD = dyn_cast<clang::ClassTemplateDecl>(TD);
     MRDOCS_SYMBOL_TRACE(CTD, context_);
     MRDOCS_CHECK_OR(CTD, std::nullopt);
 
@@ -2459,7 +2457,7 @@ getSFINAEControlParams(
     MRDOCS_SYMBOL_TRACE(PrimaryArgs, context_);
 
     // Type of the member that represents the SFINAE result.
-    QualType MemberType;
+    clang::QualType MemberType;
 
     // Index of the parameter that represents the the SFINAE result.
     // For instance, in the specialization `std::enable_if<true,T>::type`,
@@ -2468,14 +2466,14 @@ getSFINAEControlParams(
     unsigned ParamIdx = -1;
 
     // The `IsMismatch` function checks if there's a mismatch between the
-    // CXXRecordDecl of the ClassTemplateDecl and the specified template
+    // clang::CXXRecordDecl of the clang::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)
+    auto IsMismatch = [&](clang::CXXRecordDecl* RD, llvm::ArrayRef<clang::TemplateArgument> Args)
     {
         MRDOCS_SYMBOL_TRACE(RD, context_);
         MRDOCS_SYMBOL_TRACE(Args, context_);
@@ -2487,7 +2485,7 @@ getSFINAEControlParams(
         // as the member `::type` in `std::enable_if<B,T>`
         auto MemberLookup = RD->lookup(Member);
         MRDOCS_SYMBOL_TRACE(MemberLookup, context_);
-        QualType CurrentType;
+        clang::QualType CurrentType;
         if(MemberLookup.empty())
         {
             if (!RD->getNumBases())
@@ -2557,7 +2555,7 @@ getSFINAEControlParams(
                 // SFINAE template.
                 return true;
             }
-            if (auto* TND = dyn_cast<TypedefNameDecl>(MemberLookup.front()))
+            if (auto* TND = dyn_cast<clang::TypedefNameDecl>(MemberLookup.front()))
             {
                 // Update the current type to the underlying type of the
                 // typedef declaration.
@@ -2582,7 +2580,7 @@ getSFINAEControlParams(
         // `true` to indicate a mismatch.
         if(CurrentType->isDependentType())
         {
-            TemplateArgument asTemplateArg(CurrentType);
+            clang::TemplateArgument asTemplateArg(CurrentType);
             auto FoundIdx = FindParam(Args, asTemplateArg);
             if (FoundIdx == static_cast<std::size_t>(-1) ||
                 FoundIdx >= PrimaryArgs.size())
@@ -2598,10 +2596,10 @@ getSFINAEControlParams(
             ParamIdx = FoundIdx;
             // Get this primary template argument as a template
             // argument of the current type.
-            TemplateArgument MappedPrimary = PrimaryArgs[FoundIdx];
+            clang::TemplateArgument MappedPrimary = PrimaryArgs[FoundIdx];
             MRDOCS_SYMBOL_TRACE(MappedPrimary, context_);
             // The primary argument in SFINAE should be a type
-            MRDOCS_ASSERT(MappedPrimary.getKind() == TemplateArgument::Type);
+            MRDOCS_ASSERT(MappedPrimary.getKind() == clang::TemplateArgument::Type);
             // Update the current type to the type of the primary argument
             CurrentType = MappedPrimary.getAsType();
             MRDOCS_SYMBOL_TRACE(CurrentType, context_);
@@ -2621,7 +2619,7 @@ getSFINAEControlParams(
     };
 
     // Check if there's a mismatch between the primary record and the arguments
-    CXXRecordDecl* PrimaryRD = CTD->getTemplatedDecl();
+    clang::CXXRecordDecl* PrimaryRD = CTD->getTemplatedDecl();
     MRDOCS_SYMBOL_TRACE(PrimaryRD, context_);
     MRDOCS_CHECK_OR(!IsMismatch(PrimaryRD, PrimaryArgs), std::nullopt);
 
@@ -2633,12 +2631,12 @@ getSFINAEControlParams(
         {
             continue;
         }
-        ArrayRef<TemplateArgument> SpecArgs = CTSD->getTemplateArgs().asArray();
+        llvm::ArrayRef<clang::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;
+    llvm::SmallVector<clang::ClassTemplatePartialSpecializationDecl*> PartialSpecs;
     CTD->getPartialSpecializations(PartialSpecs);
     for(auto* CTPSD : PartialSpecs)
     {
@@ -2659,16 +2657,16 @@ getSFINAEControlParams(
         MRDOCS_SYMBOL_TRACE(PartialArgs, context_);
         for(std::size_t i = 0; i < PartialArgs.size(); ++i)
         {
-            TemplateArgument Arg = PartialArgs[i];
+            clang::TemplateArgument Arg = PartialArgs[i];
             MRDOCS_SYMBOL_TRACE(Arg, context_);
             switch (Arg.getKind())
             {
-            case TemplateArgument::Integral:
-            case TemplateArgument::Declaration:
-            case TemplateArgument::StructuralValue:
-            case TemplateArgument::NullPtr:
+            case clang::TemplateArgument::Integral:
+            case clang::TemplateArgument::Declaration:
+            case clang::TemplateArgument::StructuralValue:
+            case clang::TemplateArgument::NullPtr:
                 break;
-            case TemplateArgument::Expression:
+            case clang::TemplateArgument::Expression:
                 if(getNTTPFromExpr(
                     Arg.getAsExpr(),
                     CTPSD->getTemplateDepth() - 1))
@@ -2685,7 +2683,7 @@ getSFINAEControlParams(
 }
 
 Optional<ASTVisitor::SFINAETemplateInfo>
-ASTVisitor::getSFINAETemplateInfo(QualType T, bool const AllowDependentNames) const
+ASTVisitor::getSFINAETemplateInfo(clang::QualType T, bool const AllowDependentNames) const
 {
     MRDOCS_SYMBOL_TRACE(T, context_);
     MRDOCS_ASSERT(!T.isNull());
@@ -2693,12 +2691,12 @@ ASTVisitor::getSFINAETemplateInfo(QualType T, bool const AllowDependentNames) co
     // 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>();
+    if (auto* DNT = T->getAsAdjusted<clang::DependentNameType>();
         DNT && AllowDependentNames)
     {
         SFINAE.Member = DNT->getIdentifier();
         MRDOCS_SYMBOL_TRACE(SFINAE.Member, context_);
-        T = QualType(DNT->getQualifier().getAsType(), 0);
+        T = clang::QualType(DNT->getQualifier().getAsType(), 0);
         MRDOCS_SYMBOL_TRACE(T, context_);
     }
     if (!T.getTypePtrOrNull())
@@ -2708,7 +2706,7 @@ ASTVisitor::getSFINAETemplateInfo(QualType T, bool const AllowDependentNames) co
 
     // If the type is a template specialization type, extract the template name
     // and the template arguments
-    if (auto* TST = T->getAsAdjusted<TemplateSpecializationType>())
+    if (auto* TST = T->getAsAdjusted<clang::TemplateSpecializationType>())
     {
         MRDOCS_SYMBOL_TRACE(TST, context_);
         SFINAE.Template = TST->getTemplateName().getAsTemplateDecl();
@@ -2722,11 +2720,11 @@ ASTVisitor::getSFINAETemplateInfo(QualType T, bool const AllowDependentNames) co
     return std::nullopt;
 }
 
-Optional<TemplateArgument>
+Optional<clang::TemplateArgument>
 ASTVisitor::
 tryGetTemplateArgument(
-    TemplateParameterList* Parameters,
-    ArrayRef<TemplateArgument> const Arguments,
+    clang::TemplateParameterList* Parameters,
+    llvm::ArrayRef<clang::TemplateArgument> const Arguments,
     std::size_t const Index)
 {
     MRDOCS_SYMBOL_TRACE(Parameters, context_);
@@ -2743,15 +2741,15 @@ tryGetTemplateArgument(
     MRDOCS_CHECK_OR(Index < Parameters->size(), std::nullopt);
 
     // Attempt to get the default argument of the template parameter
-    NamedDecl* ND = Parameters->getParam(Index);
+    clang::NamedDecl* ND = Parameters->getParam(Index);
     MRDOCS_SYMBOL_TRACE(ND, context_);
-    if(auto* TTPD = dyn_cast<TemplateTypeParmDecl>(ND);
+    if(auto* TTPD = dyn_cast<clang::TemplateTypeParmDecl>(ND);
         TTPD && TTPD->hasDefaultArgument())
     {
         MRDOCS_SYMBOL_TRACE(TTPD, context_);
         return TTPD->getDefaultArgument().getArgument();
     }
-    if(auto* NTTPD = dyn_cast<NonTypeTemplateParmDecl>(ND);
+    if(auto* NTTPD = dyn_cast<clang::NonTypeTemplateParmDecl>(ND);
         NTTPD && NTTPD->hasDefaultArgument())
     {
         MRDOCS_SYMBOL_TRACE(NTTPD, context_);
@@ -2763,8 +2761,8 @@ tryGetTemplateArgument(
 ExtractionMode
 ASTVisitor::
 checkFilters(
-    Decl const* D,
-    AccessSpecifier const access)
+    clang::Decl const* D,
+    clang::AccessSpecifier const access)
 {
     if (mode_ == BaseClass &&
         isAnyImplicitSpecialization(D))
@@ -2776,7 +2774,7 @@ checkFilters(
     // global namespace. It can't fail any of the filters
     // because its qualified name is represented by the
     // empty string, and it has no file associated with it.
-    MRDOCS_CHECK_OR(!isa<TranslationUnitDecl>(D), ExtractionMode::Regular);
+    MRDOCS_CHECK_OR(!isa<clang::TranslationUnitDecl>(D), ExtractionMode::Regular);
 
     // Check if this kind of symbol should be extracted.
     // This filters symbols supported by MrDocs and
@@ -2804,9 +2802,9 @@ checkFilters(
 
 bool
 ASTVisitor::
-checkTypeFilters(Decl const* D, AccessSpecifier const access)
+checkTypeFilters(clang::Decl const* D, clang::AccessSpecifier const access)
 {
-    if (access == AS_private)
+    if (access == clang::AS_private)
     {
         // Don't extract private members
         if (isVirtualMember(D))
@@ -2825,7 +2823,7 @@ checkTypeFilters(Decl const* D, AccessSpecifier const access)
     {
         MRDOCS_CHECK_OR(!isStaticFileLevelMember(D), false);
     }
-    if (!config_->extractLocalClasses && isa<RecordDecl>(D))
+    if (!config_->extractLocalClasses && isa<clang::RecordDecl>(D))
     {
         if (auto const* FI = findFileInfo(D);
             FI->full_path.ends_with(".cpp") ||
@@ -2838,18 +2836,18 @@ checkTypeFilters(Decl const* D, AccessSpecifier const access)
     }
 
     // Don't extract anonymous unions
-    auto const* RD = dyn_cast<RecordDecl>(D);
+    auto const* RD = dyn_cast<clang::RecordDecl>(D);
     MRDOCS_CHECK_OR(!RD || !RD->isAnonymousStructOrUnion(), false);
 
     // Don't extract declarations implicitly generated by the compiler
-    MRDOCS_CHECK_OR(!D->isImplicit() || isa<IndirectFieldDecl>(D), false);
+    MRDOCS_CHECK_OR(!D->isImplicit() || isa<clang::IndirectFieldDecl>(D), false);
 
     return true;
 }
 
 bool
 ASTVisitor::
-checkFileFilters(Decl const* D)
+checkFileFilters(clang::Decl const* D)
 {
     MRDOCS_SYMBOL_TRACE(D, context_);
 
@@ -2928,7 +2926,7 @@ checkFileFilters(std::string_view const symbolPath) const
 
 ASTVisitor::ExtractionInfo
 ASTVisitor::
-checkSymbolFilters(Decl const* D, bool const AllowParent)
+checkSymbolFilters(clang::Decl const* D, bool const AllowParent)
 {
     // Use the cache
     if (auto const it = extraction_.find(D); it != extraction_.end())
@@ -2942,8 +2940,8 @@ checkSymbolFilters(Decl const* D, bool const AllowParent)
         return result;
     };
 
-    // If not a NamedDecl, then symbol filters don't apply
-    auto const* ND = dyn_cast<NamedDecl>(D);
+    // If not a clang::NamedDecl, then symbol filters don't apply
+    auto const* ND = dyn_cast<clang::NamedDecl>(D);
     if (!ND)
     {
         constexpr ExtractionInfo res{ExtractionMode::Regular, ExtractionMatchType::Strict};
@@ -2951,14 +2949,14 @@ checkSymbolFilters(Decl const* D, bool const AllowParent)
     }
 
     // Get the symbol name
-    SmallString<256> const name = qualifiedName(ND);
+    llvm::SmallString<256> const name = qualifiedName(ND);
     auto const symbolName = name.str();
 
     // Function to check if parent is of a certain extraction mode
-    auto ParentIs = [&](Decl const* D, ExtractionMode expected) {
-        if (Decl const* P = getParent(D);
+    auto ParentIs = [&](clang::Decl const* D, ExtractionMode expected) {
+        if (clang::Decl const* P = getParent(D);
             P &&
-            !isa<TranslationUnitDecl>(P))
+            !isa<clang::TranslationUnitDecl>(P))
         {
             auto const [parentMode, kind] = checkSymbolFilters(P);
             return parentMode == expected;
@@ -3022,9 +3020,9 @@ checkSymbolFilters(Decl const* D, bool const AllowParent)
         {
             // A child of see-below is also see-below (if namespace)
             // or dependency (if record)
-            if (Decl const* P = getParent(D);
+            if (clang::Decl const* P = getParent(D);
                 P &&
-                isa<NamespaceDecl>(P))
+                isa<clang::NamespaceDecl>(P))
             {
                 return updateCache(
                 { ExtractionMode::SeeBelow,
@@ -3059,13 +3057,13 @@ checkSymbolFilters(Decl const* D, bool const AllowParent)
     if (containsLiteralPatterns)
     {
         // 2b) For each parent namespace
-        Decl const* Cur = getParent(D);
+        clang::Decl const* Cur = getParent(D);
         while (Cur)
         {
-            if (isa<NamespaceDecl>(Cur))
+            if (isa<clang::NamespaceDecl>(Cur))
             {
                 // 2c) Check if it matches any literal pattern
-                SmallString<256> const namespaceName = qualifiedName(Cur);
+                llvm::SmallString<256> const namespaceName = qualifiedName(Cur);
                 for (auto const& [patterns, mode] : patternsAndModes)
                 {
                     if (!patterns->empty() &&
@@ -3093,9 +3091,9 @@ checkSymbolFilters(Decl const* D, bool const AllowParent)
     // and `implementation-defined`, we should extract it as `include-symbol`,
     // since symbols that only pass `include-symbol` will also be included in this namespace
     // later on.
-    if (isa<NamespaceDecl>(D) || isa<TranslationUnitDecl>(D))
+    if (isa<clang::NamespaceDecl>(D) || isa<clang::TranslationUnitDecl>(D))
     {
-        SmallString<256> symbolAsPrefix{ symbolName };
+        llvm::SmallString<256> symbolAsPrefix{ symbolName };
         symbolAsPrefix += "::";
         for (auto const& [patterns, mode] : std::ranges::views::reverse(patternsAndModes))
         {
@@ -3107,12 +3105,12 @@ checkSymbolFilters(Decl const* D, bool const AllowParent)
             // prefixes that can potentially include children, but
             // we have to check if any children actually matches
             // the pattern strictly.
-            auto const* DC = cast<DeclContext>(D);
+            auto const* DC = cast<clang::DeclContext>(D);
             auto childrenMode = ExtractionMode::Dependency;
             for (auto* M : DC->decls())
             {
                 MRDOCS_SYMBOL_TRACE(M, context_);
-                if (M->isImplicit() && !isa<IndirectFieldDecl>(M))
+                if (M->isImplicit() && !isa<clang::IndirectFieldDecl>(M))
                 {
                     // Ignore implicit members
                     continue;
@@ -3154,7 +3152,7 @@ checkSymbolFilters(Decl const* D, bool const AllowParent)
     }
     else if (AllowParent)
     {
-        Decl const* P = getParent(D);
+        clang::Decl const* P = getParent(D);
         if (P)
         {
             // 4) Parent symbols imply this symbol should be included
@@ -3238,7 +3236,7 @@ checkSymbolFiltersImpl(
 }
 
 
-Info*
+Symbol*
 ASTVisitor::
 find(SymbolID const& id) const
 {
@@ -3249,9 +3247,9 @@ find(SymbolID const& id) const
     return nullptr;
 }
 
-Info*
+Symbol*
 ASTVisitor::
-find(Decl const* D) const
+find(clang::Decl const* D) const
 {
     auto ID = generateID(D);
     MRDOCS_CHECK_OR(ID, nullptr);
@@ -3264,8 +3262,8 @@ findFileInfo(clang::SourceLocation const loc)
 {
     MRDOCS_CHECK_OR(!loc.isInvalid(), nullptr);
     // Find the presumed location, ignoring #line directives
-    PresumedLoc presumed = source_.getPresumedLoc(loc, false);
-    FileID id = presumed.getFileID();
+    clang::PresumedLoc presumed = source_.getPresumedLoc(loc, false);
+    clang::FileID id = presumed.getFileID();
     if(id.isInvalid())
         return nullptr;
 
@@ -3280,7 +3278,7 @@ findFileInfo(clang::SourceLocation const loc)
 
 ASTVisitor::FileInfo*
 ASTVisitor::
-findFileInfo(Decl const* D)
+findFileInfo(clang::Decl const* D)
 {
     clang::SourceLocation Loc = D->getBeginLoc();
     if (Loc.isInvalid())
@@ -3369,16 +3367,16 @@ buildFileInfo(std::string_view path)
     }
 
     // Find the best match for the file path in the search directories
-    for (HeaderSearch& HS = sema_.getPreprocessor().getHeaderSearchInfo();
-         DirectoryLookup const& DL : HS.search_dir_range())
+    for (clang::HeaderSearch& HS = sema_.getPreprocessor().getHeaderSearchInfo();
+         clang::DirectoryLookup const& DL : HS.search_dir_range())
     {
-        OptionalDirectoryEntryRef DR = DL.getDirRef();
+        clang::OptionalDirectoryEntryRef DR = DL.getDirRef();
         if (!DL.isNormalDir() || !DR)
         {
             // Only consider normal directories
             continue;
         }
-        StringRef searchDir = DR->getName();
+        clang::StringRef searchDir = DR->getName();
         if (auto shortPath = tryGetRelativePath(searchDir))
         {
             file_info.short_path = std::string(*shortPath);
@@ -3416,14 +3414,14 @@ buildFileInfo(std::string_view path)
     return file_info;
 }
 
-template <std::derived_from<Info> InfoTy>
+template <std::derived_from<Symbol> InfoTy>
 ASTVisitor::upsertResult<InfoTy>
 ASTVisitor::
 upsert(SymbolID const& id)
 {
     // Creating symbol with invalid SymbolID
     MRDOCS_ASSERT(id != SymbolID::invalid);
-    Info* info = find(id);
+    Symbol* info = find(id);
     bool const isNew = !info;
     if (!info)
     {
@@ -3491,15 +3489,15 @@ upsert(DeclType const* D)
     }
 
     // Already populate the access specifier
-    AccessSpecifier const access = getAccess(D);
+    clang::AccessSpecifier const access = getAccess(D);
     I.Access = toAccessKind(access);
 
     return upsertResult<R>{std::ref(I), isNew};
 }
 
 template <
-    std::derived_from<Info> InfoTy,
-    std::derived_from<Decl> DeclTy>
+    std::derived_from<Symbol> InfoTy,
+    std::derived_from<clang::Decl> DeclTy>
 Expected<void>
 ASTVisitor::
 checkUndocumented(
@@ -3511,7 +3509,7 @@ checkUndocumented(
     MRDOCS_CHECK_OR(!config_->extractAll, {});
     // If the symbol is a namespace, the `extract-all`
     // doesn't apply to it
-    MRDOCS_CHECK_OR((!std::same_as<InfoTy,NamespaceInfo>), {});
+    MRDOCS_CHECK_OR((!std::same_as<InfoTy,NamespaceSymbol>), {});
     // If the symbol is not being extracted as a Regular
     // symbol, we don't need to check for undocumented symbols
     // These are expected to be potentially undocumented
@@ -3544,16 +3542,16 @@ checkUndocumented(
         auto const undocIt = undocumented_.find(id);
         if (undocIt == undocumented_.end())
         {
-            InfoKind const kind = InfoTy::kind_id;
-            undocumented_.insert(UndocumentedInfo{id, extractName(D), kind});
+            SymbolKind const kind = InfoTy::kind_id;
+            undocumented_.insert(UndocumentedSymbol{id, extractName(D), kind});
         }
         // Populate the location
         auto handle = undocumented_.extract(undocIt);
-        UndocumentedInfo& UI = handle.value();
+        UndocumentedSymbol& UI = handle.value();
         populate(UI.Loc, D);
         undocumented_.insert(std::move(handle));
     }
     return Unexpected(Error("Undocumented"));
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/AST/ASTVisitor.hpp b/src/lib/AST/ASTVisitor.hpp
index a7e83ffa7..b5379c31d 100644
--- a/src/lib/AST/ASTVisitor.hpp
+++ b/src/lib/AST/ASTVisitor.hpp
@@ -17,18 +17,18 @@
 #include <lib/AST/ClangHelpers.hpp>
 #include <lib/ConfigImpl.hpp>
 #include <lib/Support/ExecutionContext.hpp>
-#include <mrdocs/Metadata/Info/ExtractionMode.hpp>
-#include <mrdocs/Metadata/Info/Source.hpp>
 #include <mrdocs/Metadata/Name.hpp>
+#include <mrdocs/Metadata/Symbol/ExtractionMode.hpp>
+#include <mrdocs/Metadata/Symbol/Source.hpp>
 #include <mrdocs/Support/Concepts.hpp>
 #include <clang/AST/ODRHash.h>
 #include <clang/Tooling/Tooling.h>
 #include <llvm/ADT/SmallBitVector.h>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
-class TypeInfoBuilder;
-class NameInfoBuilder;
+class TypeBuilder;
+class NameBuilder;
 template <class Derived>
 class TerminalTypeVisitor;
 
@@ -43,17 +43,17 @@ class TerminalTypeVisitor;
     only handles translation units represented by a
     `clang::ASTContext` by creating an instance of this
     class and calling the `build` method, which recursively
-    traverses the `clang::Decl` representing the
+    traverses the `clang::clang::Decl` representing the
     translation unit.
 
-    As it traverse nodes, the `ASTVisitor` class will
+    As it traverses nodes, the `ASTVisitor` class will
     create MrDocs `Info` objects for each declaration that
     passes the filter configurations.
 */
 class ASTVisitor
 {
-    friend TypeInfoBuilder;
-    friend NameInfoBuilder;
+    friend TypeBuilder;
+    friend NameBuilder;
     template <typename Derived>
     friend class TerminalTypeVisitor;
 
@@ -64,19 +64,19 @@ class ASTVisitor
     Diagnostics diags_;
 
     // The compiler instance
-    CompilerInstance& compiler_;
+    clang::CompilerInstance& compiler_;
 
     // The AST context
-    ASTContext& context_;
+    clang::ASTContext& context_;
 
     // The source files in memory
-    SourceManager& source_;
+    clang::SourceManager& source_;
 
     // Semantic analysis
-    Sema& sema_;
+    clang::Sema& sema_;
 
     // An unordered set of all extracted Info declarations
-    InfoSet info_;
+    SymbolSet info_;
 
     /*  The symbols we would extract if they were documented
 
@@ -99,7 +99,7 @@ class ASTVisitor
         units are merged, we will iterate these symbols
         and warn if they are not documented.
      */
-    UndocumentedInfoSet undocumented_;
+    UndocumentedSymbolSet undocumented_;
 
     /* Struct to hold pre-processed file information.
 
@@ -138,9 +138,9 @@ class ASTVisitor
         if a file should be extracted or to add the
         SourceInfo to an Info object.
     */
-    llvm::DenseMap<FileID, FileInfo> files_;
+    llvm::DenseMap<clang::FileID, FileInfo> files_;
 
-    /*  Determine how a Decl matched the filters
+    /*  Determine how a clang::Decl matched the filters
      */
     enum class ExtractionMatchType {
         // It matches one of the patterns as is
@@ -159,7 +159,7 @@ class ASTVisitor
     /*  Extraction Info
 
         This struct is used to store information about
-        the filters a Decl pass.
+        the filters a clang::Decl pass.
      */
     struct ExtractionInfo
     {
@@ -171,7 +171,7 @@ class ASTVisitor
         ExtractionMatchType kind;
     };
 
-    /*  A map of Clang Decl objects to ExtractionMode values
+    /*  A map of Clang clang::Decl objects to ExtractionMode values
 
         This map is used to store the extraction mode for
         declarations that have been identified through the
@@ -181,7 +181,7 @@ class ASTVisitor
         function to determine if a declaration should be
         extracted based on the extraction mode.
     */
-    std::unordered_map<Decl const*, ExtractionInfo> extraction_;
+    std::unordered_map<clang::Decl const*, ExtractionInfo> extraction_;
 
     /* How we should traverse the current node
      */
@@ -254,13 +254,13 @@ class ASTVisitor
 
     /* A map which stores the Info types created by each decl.
      */
-    std::unordered_map<FriendDecl const*, Info const*> friendDecls_;
+    std::unordered_map<clang::FriendDecl const*, Symbol const*> friendDecls_;
 
 public:
     /** Constructor for ASTVisitor.
 
         This constructor initializes the ASTVisitor with the given configuration,
-        diagnostics, compiler instance, AST context, and Sema object.
+        diagnostics, compiler instance, AST context, and clang::Sema object.
 
         It also initializes clang custom documentation commands and
         populates `files_` with the FileInfo for files in the
@@ -270,14 +270,14 @@ class ASTVisitor
         @param diags The diagnostics object.
         @param compiler The compiler instance.
         @param context The AST context.
-        @param sema The Sema object.
+        @param sema The clang::Sema object.
      */
     ASTVisitor(
         ConfigImpl const& config,
         Diagnostics const& diags,
-        CompilerInstance& compiler,
-        ASTContext& context,
-        Sema& sema) noexcept;
+        clang::CompilerInstance& compiler,
+        clang::ASTContext& context,
+        clang::Sema& sema) noexcept;
 
     /** Build the metadata representation from the AST.
 
@@ -307,9 +307,9 @@ class ASTVisitor
         This function returns a reference to the set of Info
         declarations that have been extracted by the ASTVisitor.
 
-        @return A reference to the InfoSet containing the extracted Info declarations.
+        @return A reference to the SymbolSet containing the extracted Info declarations.
      */
-    InfoSet&
+    SymbolSet&
     results()
     {
         return info_;
@@ -320,9 +320,9 @@ class ASTVisitor
         This function returns a reference to the set of Info
         declarations that have been extracted by the ASTVisitor.
 
-        @return A reference to the InfoSet containing the extracted Info declarations.
+        @return A reference to the SymbolSet containing the extracted Info declarations.
      */
-    UndocumentedInfoSet&
+    UndocumentedSymbolSet&
     undocumented()
     {
         return undocumented_;
@@ -351,8 +351,8 @@ class ASTVisitor
      */
     template <
         class InfoTy = void,
-        std::derived_from<Decl> DeclTy>
-    Info*
+        std::derived_from<clang::Decl> DeclTy>
+    Symbol*
     traverse(DeclTy const* D);
 
     /*  Traverse a function template
@@ -362,8 +362,8 @@ class ASTVisitor
         concept or function template.
 
      */
-    Info*
-    traverse(FunctionTemplateDecl const* D);
+    Symbol*
+    traverse(clang::FunctionTemplateDecl const* D);
 
     /*  Traverse a using directive
 
@@ -373,16 +373,16 @@ class ASTVisitor
         If the parent declaration is a Namespace, we
         update its `UsingDirectives` const field.
     */
-    Info*
-    traverse(UsingDirectiveDecl const* D);
+    Symbol*
+    traverse(clang::UsingDirectiveDecl const* D);
 
     /*  Traverse a member of an anonymous union.
 
         We get the anonymous union field and traverse it
         as a regular `FieldDecl`.
      */
-    Info*
-    traverse(IndirectFieldDecl const* D);
+    Symbol*
+    traverse(clang::IndirectFieldDecl const* D);
 
     // =================================================
     // AST Traversal Helpers
@@ -391,28 +391,28 @@ class ASTVisitor
     /*  Traverse the members of a declaration
 
         This function is called to traverse the members of
-        a Decl that is a DeclContext with other members.
+        a clang::Decl that is a DeclContext with other members.
 
         The function will call traverseAny for all members of the
         declaration context.
     */
     template <
-        std::derived_from<Info> InfoTy,
-        std::derived_from<Decl> DeclTy>
-    requires (!std::derived_from<DeclTy, RedeclarableTemplateDecl>)
+        std::derived_from<Symbol> InfoTy,
+        std::derived_from<clang::Decl> DeclTy>
+    requires (!std::derived_from<DeclTy, clang::RedeclarableTemplateDecl>)
     void
     traverseMembers(InfoTy& I, DeclTy const* DC);
 
     template <
-        std::derived_from<Info> InfoTy,
-        std::derived_from<RedeclarableTemplateDecl> DeclTy>
+        std::derived_from<Symbol> InfoTy,
+        std::derived_from<clang::RedeclarableTemplateDecl> DeclTy>
     void
     traverseMembers(InfoTy& I, DeclTy const* DC);
 
     /*  Traverse the parents of a declaration
 
         This function is called to traverse the parents of
-        a Decl until we find the translation unit declaration
+        a clang::Decl until we find the translation unit declaration
         or a parent that has already been extracted.
 
         This function is called when the declaration is
@@ -424,15 +424,15 @@ class ASTVisitor
         context.
     */
     template <
-        std::derived_from<Info> InfoTy,
-        std::derived_from<Decl> DeclTy>
-    requires (!std::derived_from<DeclTy, RedeclarableTemplateDecl>)
+        std::derived_from<Symbol> InfoTy,
+        std::derived_from<clang::Decl> DeclTy>
+    requires (!std::derived_from<DeclTy, clang::RedeclarableTemplateDecl>)
     void
     traverseParent(InfoTy& I, DeclTy const* DC);
 
     template <
-        std::derived_from<Info> InfoTy,
-        std::derived_from<RedeclarableTemplateDecl> DeclTy>
+        std::derived_from<Symbol> InfoTy,
+        std::derived_from<clang::RedeclarableTemplateDecl> DeclTy>
     void
     traverseParent(InfoTy& I, DeclTy const* DC);
 
@@ -440,13 +440,13 @@ class ASTVisitor
 
         USRs are strings that provide an unambiguous reference to a symbol.
 
-        This function determines the underlying Decl type and
+        This function determines the underlying clang::Decl type and
         generates a USR for it.
 
         @returns true if USR generation succeeded.
     */
-    Expected<SmallString<128>>
-    generateUSR(Decl const* D) const;
+    Expected<llvm::SmallString<128>>
+    generateUSR(clang::Decl const* D) const;
 
     /*  Generate the symbol ID for a declaration.
 
@@ -460,13 +460,13 @@ class ASTVisitor
 
         To guarantee the uniqueness of symbols while using
         a relatively small amount of memory (vs storing
-        USRs directly), this function hashes the Decl
+        USRs directly), this function hashes the clang::Decl
         USR value with SHA1.
 
         @return true if the symbol ID could be extracted.
      */
     bool
-    generateID(Decl const* D, SymbolID& id) const;
+    generateID(clang::Decl const* D, SymbolID& id) const;
 
     /*  Extracts the symbol ID for a declaration.
 
@@ -479,16 +479,16 @@ class ASTVisitor
         @return the symbol ID for the declaration.
      */
     SymbolID
-    generateID(Decl const* D) const;
+    generateID(clang::Decl const* D) const;
 
     // =================================================
     // Populate functions
     // =================================================
-    template <std::derived_from<Decl> DeclTy>
+    template <std::derived_from<clang::Decl> DeclTy>
     void
-    populate(Info& I, bool isNew, DeclTy const* D);
+    populate(Symbol& I, bool isNew, DeclTy const* D);
 
-    template <std::derived_from<Decl> DeclTy>
+    template <std::derived_from<clang::Decl> DeclTy>
     void
     populate(SourceInfo& I, DeclTy const* D);
 
@@ -504,98 +504,98 @@ class ASTVisitor
     bool
     populate(
         Optional<Javadoc>& javadoc,
-        Decl const* D);
+        clang::Decl const* D);
 
     void
     populate(SourceInfo& I, clang::SourceLocation loc, bool definition, bool documented);
 
     void
-    populate(NamespaceInfo& I, NamespaceDecl const* D);
+    populate(NamespaceSymbol& I, clang::NamespaceDecl const* D);
 
     static
     void
-    populate(NamespaceInfo& I, TranslationUnitDecl const* D);
+    populate(NamespaceSymbol& I, clang::TranslationUnitDecl const* D);
 
     void
-    populate(RecordInfo& I, CXXRecordDecl const* D);
+    populate(RecordSymbol& I, clang::CXXRecordDecl const* D);
 
     void
-    populate(RecordInfo& I, ClassTemplateDecl const* D);
+    populate(RecordSymbol& I, clang::ClassTemplateDecl const* D);
 
     void
-    populate(RecordInfo& I, ClassTemplateSpecializationDecl const* D);
+    populate(RecordSymbol& I, clang::ClassTemplateSpecializationDecl const* D);
 
     void
-    populate(RecordInfo& I, ClassTemplatePartialSpecializationDecl const* D);
+    populate(RecordSymbol& I, clang::ClassTemplatePartialSpecializationDecl const* D);
 
     void
-    populate(FunctionInfo& I, FunctionDecl const* D);
+    populate(FunctionSymbol& I, clang::FunctionDecl const* D);
 
     void
-    populate(FunctionInfo& I, FunctionTemplateDecl const* D);
+    populate(FunctionSymbol& I, clang::FunctionTemplateDecl const* D);
 
     void
-    populate(FunctionInfo& I, CXXMethodDecl const* D);
+    populate(FunctionSymbol& I, clang::CXXMethodDecl const* D);
 
     void
-    populate(FunctionInfo& I, CXXConstructorDecl const* D);
+    populate(FunctionSymbol& I, clang::CXXConstructorDecl const* D);
 
     void
-    populate(FunctionInfo& I, CXXDestructorDecl const* D);
+    populate(FunctionSymbol& I, clang::CXXDestructorDecl const* D);
 
     void
-    populate(FunctionInfo& I, CXXConversionDecl const* D);
+    populate(FunctionSymbol& I, clang::CXXConversionDecl const* D);
 
     void
-    populate(EnumInfo& I, EnumDecl const* D);
+    populate(EnumSymbol& I, clang::EnumDecl const* D);
 
     void
-    populate(EnumConstantInfo& I, EnumConstantDecl const* D);
+    populate(EnumConstantSymbol& I, clang::EnumConstantDecl const* D);
 
     void
-    populate(TypedefInfo& I, TypedefNameDecl const* D);
+    populate(TypedefSymbol& I, clang::TypedefNameDecl const* D);
 
     void
-    populate(TypedefInfo& I, TypedefDecl const* D);
+    populate(TypedefSymbol& I, clang::TypedefDecl const* D);
 
     void
-    populate(TypedefInfo& I, TypeAliasDecl const* D);
+    populate(TypedefSymbol& I, clang::TypeAliasDecl const* D);
 
     void
-    populate(TypedefInfo& I, TypeAliasTemplateDecl const* D);
+    populate(TypedefSymbol& I, clang::TypeAliasTemplateDecl const* D);
 
     void
-    populate(VariableInfo& I, VarDecl const* D);
+    populate(VariableSymbol& I, clang::VarDecl const* D);
 
     void
-    populate(VariableInfo& I, VarTemplateDecl const* D);
+    populate(VariableSymbol& I, clang::VarTemplateDecl const* D);
 
     void
-    populate(VariableInfo& I, VarTemplateSpecializationDecl const* D);
+    populate(VariableSymbol& I, clang::VarTemplateSpecializationDecl const* D);
 
     void
-    populate(VariableInfo& I, VarTemplatePartialSpecializationDecl const* D);
+    populate(VariableSymbol& I, clang::VarTemplatePartialSpecializationDecl const* D);
 
     void
-    populate(VariableInfo& I, FieldDecl const* D);
+    populate(VariableSymbol& I, clang::FieldDecl const* D);
 
     void
-    populate(FriendInfo& I, FriendDecl const* D);
+    populate(FriendInfo& I, clang::FriendDecl const* D);
 
     void
-    populate(GuideInfo& I, CXXDeductionGuideDecl const* D);
+    populate(GuideSymbol& I, clang::CXXDeductionGuideDecl const* D);
 
     void
-    populate(GuideInfo& I, FunctionTemplateDecl const* D);
+    populate(GuideSymbol& I, clang::FunctionTemplateDecl const* D);
 
     void
-    populate(NamespaceAliasInfo& I, NamespaceAliasDecl const* D);
+    populate(NamespaceAliasSymbol& I, clang::NamespaceAliasDecl const* D);
 
     void
-    populate(UsingInfo& I, UsingDecl const* D);
+    populate(UsingSymbol& I, clang::UsingDecl const* D);
 
     void
-    populate(ConceptInfo& I, ConceptDecl const* D);
+    populate(ConceptSymbol& I, clang::ConceptDecl const* D);
 
     /*  Default function to populate the template information
 
@@ -604,34 +604,34 @@ class ASTVisitor
         of the template declaration.
      */
     template <
-        std::derived_from<Decl> DeclTy,
-        std::derived_from<TemplateDecl> TemplateDeclTy>
+        std::derived_from<clang::Decl> DeclTy,
+        std::derived_from<clang::TemplateDecl> TemplateDeclTy>
     void
     populate(TemplateInfo& Template, DeclTy const* D, TemplateDeclTy const* TD);
 
     void
-    populate(TemplateInfo& Template, ClassTemplateSpecializationDecl const* D, ClassTemplateDecl const* CTD);
+    populate(TemplateInfo& Template, clang::ClassTemplateSpecializationDecl const* D, clang::ClassTemplateDecl const* CTD);
 
     /*  Populate the template information for a variable template
 
         The function will populate the template parameters
         depending on whether the variable is a specialization.
     */
-    template<std::derived_from<VarDecl> VarDeclTy>
+    template<std::derived_from<clang::VarDecl> VarDeclTy>
     void
-    populate(TemplateInfo& Template, VarDeclTy const* D, VarTemplateDecl const* VTD);
+    populate(TemplateInfo& Template, VarDeclTy const* D, clang::VarTemplateDecl const* VTD);
 
     template<
-        std::derived_from<Decl> DeclTy,
-        std::derived_from<TemplateDecl> TemplateDeclTy>
+        std::derived_from<clang::Decl> DeclTy,
+        std::derived_from<clang::TemplateDecl> TemplateDeclTy>
     void
     populate(Optional<TemplateInfo>& Template, DeclTy const* D, TemplateDeclTy const* VTD)
     {
         MRDOCS_CHECK_OR(VTD);
         MRDOCS_CHECK_OR(!VTD->isImplicit());
-        if (TemplateParameterList const* TPL = VTD->getTemplateParameters();
+        if (clang::TemplateParameterList const* TPL = VTD->getTemplateParameters();
             !TPL->empty() &&
-            std::ranges::none_of(TPL->asArray(), [](NamedDecl const* ND) {
+            std::ranges::none_of(TPL->asArray(), [](clang::NamedDecl const* ND) {
                 return !ND->isImplicit();
             }))
         {
@@ -646,27 +646,27 @@ class ASTVisitor
     }
 
     void
-    populate(NoexceptInfo& I, FunctionProtoType const* FPT);
+    populate(NoexceptInfo& I, clang::FunctionProtoType const* FPT);
 
     void
-    populate(ExplicitInfo& I, ExplicitSpecifier const& ES);
+    populate(ExplicitInfo& I, clang::ExplicitSpecifier const& ES);
 
     void
-    populate(ExprInfo& I, Expr const* E);
+    populate(ExprInfo& I, clang::Expr const* E);
 
     template <class T>
     void
-    populate(ConstantExprInfo<T>& I, Expr const* E);
+    populate(ConstantExprInfo<T>& I, clang::Expr const* E);
 
     template <class T>
     void
-    populate(ConstantExprInfo<T>& I, Expr const* E, llvm::APInt const& V);
+    populate(ConstantExprInfo<T>& I, clang::Expr const* E, llvm::APInt const& V);
 
     void
-    populate(Polymorphic<TParam>& I, NamedDecl const* N);
+    populate(Polymorphic<TParam>& I, clang::NamedDecl const* N);
 
     void
-    populate(Optional<TemplateInfo>& TI, TemplateParameterList const* TPL)
+    populate(Optional<TemplateInfo>& TI, clang::TemplateParameterList const* TPL)
     {
         if (!TI)
         {
@@ -676,16 +676,16 @@ class ASTVisitor
     }
 
     void
-    populate(TemplateInfo& TI, TemplateParameterList const* TPL);
+    populate(TemplateInfo& TI, clang::TemplateParameterList const* TPL);
 
-    template <range_of<TemplateArgument> Range>
+    template <range_of<clang::TemplateArgument> Range>
     void
     populate(
         std::vector<Polymorphic<TArg>>& result,
         Range&& args)
     {
         std::size_t i = 0;
-        for (TemplateArgument const& arg : args)
+        for (clang::TemplateArgument const& arg : args)
         {
             if (arg.getIsDefaulted())
             {
@@ -694,7 +694,7 @@ class ASTVisitor
             // KRYSTIAN NOTE: is this correct? should we have a
             // separate TArgKind for packs instead of "unlaminating"
             // them as we are doing here?
-            if (arg.getKind() == TemplateArgument::Pack)
+            if (arg.getKind() == clang::TemplateArgument::Pack)
             {
                 populate(result, arg.pack_elements());
             }
@@ -716,88 +716,88 @@ class ASTVisitor
     void
     populate(
         std::vector<Polymorphic<TArg>>& result,
-        ASTTemplateArgumentListInfo const* args);
+        clang::ASTTemplateArgumentListInfo const* args);
 
-    template <std::derived_from<Info> InfoTy>
+    template <std::derived_from<Symbol> InfoTy>
     static
     void
-    populateAttributes(InfoTy& I, Decl const* D);
+    populateAttributes(InfoTy& I, clang::Decl const* D);
 
     // =================================================
     // Populate function helpers
     // =================================================
-    template <std::derived_from<Decl> DeclTy>
+    template <std::derived_from<clang::Decl> DeclTy>
     std::string
     extractName(DeclTy const* D);
 
     // Extract the name of a declaration
     std::string
-    extractName(NamedDecl const* D);
+    extractName(clang::NamedDecl const* D);
 
     // Extract the name of a declaration
     std::string
-    extractName(DeclarationName N);
+    extractName(clang::DeclarationName N);
 
-    SmallString<256>
-    qualifiedName(Decl const* D) const;
+    llvm::SmallString<256>
+    qualifiedName(clang::Decl const* D) const;
 
-    SmallString<256>
-    qualifiedName(NamedDecl const* ND) const;
+    llvm::SmallString<256>
+    qualifiedName(clang::NamedDecl const* ND) const;
 
     void
-    addMember(NamespaceInfo& I, Info const& Member);
+    addMember(NamespaceSymbol& I, Symbol const& Member);
 
     void
-    addMember(RecordInfo& I, Info const& Member);
+    addMember(RecordSymbol& I, Symbol const& Member);
 
     void
-    addMember(RecordTranche& I, Info const& Member);
+    addMember(RecordTranche& I, Symbol const& Member);
 
     void
-    addMember(EnumInfo& I, Info const& Member) const;
+    addMember(EnumSymbol& I, Symbol const& Member) const;
 
     void
-    addMember(OverloadsInfo& I, Info const& Member) const;
+    addMember(OverloadsSymbol& I, Symbol const& Member) const;
 
     void
-    addMember(std::vector<SymbolID>& container, Info const& Member) const;
+    addMember(std::vector<SymbolID>& container, Symbol const& Member) const;
 
-    Polymorphic<TypeInfo>
-    toTypeInfo(QualType qt, TraversalMode mode);
+    Polymorphic<Type>
+    toType(clang::QualType qt, TraversalMode mode);
 
-    Polymorphic<TypeInfo>
-    toTypeInfo(QualType const qt)
+    Polymorphic<Type>
+    toType(clang::QualType const qt)
     {
-        return toTypeInfo(qt, TraversalMode::Dependency);
+        return toType(qt, TraversalMode::Dependency);
     }
 
-    Optional<Polymorphic<NameInfo>>
-    toNameInfo(NestedNameSpecifier NNS);
+    Optional<Polymorphic<Name>>
+    toName(clang::NestedNameSpecifier NNS);
 
-    template <class TArgRange = ArrayRef<TemplateArgument>>
-    Optional<Polymorphic<NameInfo>>
-    toNameInfo(
-        DeclarationName Name,
+    template <class TArgRange = llvm::ArrayRef<clang::TemplateArgument>>
+    Optional<Polymorphic<Name>>
+    toName(
+        clang::DeclarationName Name,
         Optional<TArgRange> TArgs = std::nullopt,
-        NestedNameSpecifier NNS = std::nullopt);
+        clang::NestedNameSpecifier NNS = std::nullopt);
 
-    template <class TArgRange = ArrayRef<TemplateArgument>>
-    Optional<Polymorphic<NameInfo>>
-    toNameInfo(
-        Decl const* D,
+    template <class TArgRange = llvm::ArrayRef<clang::TemplateArgument>>
+    Optional<Polymorphic<Name>>
+    toName(
+        clang::Decl const* D,
         Optional<TArgRange> TArgs = std::nullopt,
-        NestedNameSpecifier NNS = std::nullopt);
+        clang::NestedNameSpecifier NNS = std::nullopt);
 
     Polymorphic<TArg>
-    toTArg(TemplateArgument const& A);
+    toTArg(clang::TemplateArgument const& A);
 
     // Pretty-print an expression
     std::string
-    toString(Expr const* E);
+    toString(clang::Expr const* E);
 
     // Pretty-print a type
     std::string
-    toString(Type const* T);
+    toString(clang::Type const* T);
 
     template <class Integer>
     Integer
@@ -811,7 +811,7 @@ class ASTVisitor
         arguments.
      */
     std::string
-    getSourceCode(SourceRange const& R) const;
+    getSourceCode(clang::SourceRange const& R) const;
 
     /*  Struct to hold the underlying type result of a SFINAE type.
 
@@ -825,7 +825,7 @@ class ASTVisitor
     struct SFINAEInfo
     {
         // The underlying type of the SFINAE type.
-        QualType Type;
+        clang::QualType Type;
 
         // The template arguments used in the SFINAE context.
         std::vector<ExprInfo> Constraints;
@@ -846,13 +846,13 @@ class ASTVisitor
         otherwise.
      */
     Optional<SFINAEInfo>
-    extractSFINAEInfo(QualType T);
+    extractSFINAEInfo(clang::QualType T);
 
-    // @copydoc extractSFINAEInfo(QualType)
+    // @copydoc extractSFINAEInfo(clang::QualType)
     Optional<SFINAEInfo>
-    extractSFINAEInfo(Type const* T)
+    extractSFINAEInfo(clang::Type const* T)
     {
-        return extractSFINAEInfo(QualType(T, 0));
+        return extractSFINAEInfo(clang::QualType(T, 0));
     }
 
     /* Struct to hold SFINAE information.
@@ -868,13 +868,13 @@ class ASTVisitor
     struct SFINAETemplateInfo
     {
         /// The template declaration involved in SFINAE
-        TemplateDecl* Template = nullptr;
+        clang::TemplateDecl* Template = nullptr;
 
         /// The identifier of the member being checked.
-        IdentifierInfo const* Member = nullptr;
+        clang::IdentifierInfo const* Member = nullptr;
 
         /// The template arguments used in the SFINAE context.
-        ArrayRef<TemplateArgument> Arguments;
+        llvm::ArrayRef<clang::TemplateArgument> Arguments;
     };
 
     /* Get the template declaration and member identifier
@@ -896,7 +896,7 @@ class ASTVisitor
         and `Arguments` would be `{B,T}`.
      */
     Optional<SFINAETemplateInfo>
-    getSFINAETemplateInfo(QualType T, bool AllowDependentNames) const;
+    getSFINAETemplateInfo(clang::QualType T, bool AllowDependentNames) const;
 
     /* The controlling parameters of a SFINAE template
 
@@ -914,7 +914,7 @@ class ASTVisitor
     struct SFINAEControlParams
     {
         // The template parameters of the template declaration
-        TemplateParameterList* Parameters = nullptr;
+        clang::TemplateParameterList* Parameters = nullptr;
 
         // The controlling parameters of the template declaration
         llvm::SmallBitVector ControllingParams;
@@ -937,7 +937,7 @@ class ASTVisitor
        (such as `typename enable_if<B,T>::type`) will be extract instead.
      */
     Optional<SFINAEControlParams>
-    getSFINAEControlParams(TemplateDecl* TD, IdentifierInfo const* Member);
+    getSFINAEControlParams(clang::TemplateDecl* TD, clang::IdentifierInfo const* Member);
 
     Optional<SFINAEControlParams>
     getSFINAEControlParams(SFINAETemplateInfo const& SFINAE) {
@@ -954,10 +954,10 @@ class ASTVisitor
         arguments, the function will attempt to get the
         argument from the default template arguments.
      */
-    Optional<TemplateArgument>
+    Optional<clang::TemplateArgument>
     tryGetTemplateArgument(
-        TemplateParameterList* Parameters,
-        ArrayRef<TemplateArgument> Arguments,
+        clang::TemplateParameterList* Parameters,
+        llvm::ArrayRef<clang::TemplateArgument> Arguments,
         std::size_t Index);
 
     // =================================================
@@ -989,28 +989,28 @@ class ASTVisitor
         possible for the declaration.
      */
     ExtractionMode
-    checkFilters(Decl const* D, AccessSpecifier access);
+    checkFilters(clang::Decl const* D, clang::AccessSpecifier access);
 
     static
     ExtractionMode
-    checkFilters(TranslationUnitDecl const*, AccessSpecifier)
+    checkFilters(clang::TranslationUnitDecl const*, clang::AccessSpecifier)
     {
         return ExtractionMode::Regular;
     }
 
-    template <std::derived_from<Decl> DeclTy>
+    template <std::derived_from<clang::Decl> DeclTy>
     ExtractionMode
     checkFilters(DeclTy const* D)
     {
-        AccessSpecifier A = getAccess(D);
+        clang::AccessSpecifier A = getAccess(D);
         return checkFilters(D, A);
     }
 
     bool
-    checkTypeFilters(Decl const* D, AccessSpecifier access);
+    checkTypeFilters(clang::Decl const* D, clang::AccessSpecifier access);
 
     bool
-    checkFileFilters(Decl const* D);
+    checkFileFilters(clang::Decl const* D);
 
     bool
     checkFileFilters(std::string_view symbolPath) const;
@@ -1022,10 +1022,10 @@ class ASTVisitor
        be allowed to inherit the value from the parent.
      */
     ExtractionInfo
-    checkSymbolFilters(Decl const* D, bool AllowParent);
+    checkSymbolFilters(clang::Decl const* D, bool AllowParent);
 
     ExtractionInfo
-    checkSymbolFilters(Decl const* D)
+    checkSymbolFilters(clang::Decl const* D)
     {
         return checkSymbolFilters(D, true);
     }
@@ -1059,24 +1059,24 @@ class ASTVisitor
     // Element access
     // =================================================
 
-    /*  Get Info from ASTVisitor InfoSet
+    /*  Get Info from ASTVisitor SymbolSet
      */
-    Info*
+    Symbol*
     find(SymbolID const& id) const;
 
-     /*  Get Info from ASTVisitor InfoSet
+     /*  Get Info from ASTVisitor SymbolSet
 
         This function will generate a symbol ID for the
         declaration and call the other `find` function
         to get the Info object for the declaration.
      */
-    Info*
-    find(Decl const* D) const;
+    Symbol*
+    find(clang::Decl const* D) const;
 
     /*  Find or traverse a declaration
 
         This function will first attempt to find the Info
-        object for a declaration in the InfoSet.
+        object for a declaration in the SymbolSet.
 
         If the Info object does not exist, the function
         will traverse the declaration and create a new
@@ -1101,8 +1101,8 @@ class ASTVisitor
 
         @return a pointer to the Info object.
      */
-    Info*
-    findOrTraverse(Decl const* D)
+    Symbol*
+    findOrTraverse(clang::Decl const* D)
     {
         MRDOCS_CHECK_OR(D, nullptr);
         if (auto* I = find(D))
@@ -1129,7 +1129,7 @@ class ASTVisitor
     findFileInfo(clang::SourceLocation loc);
 
     FileInfo*
-    findFileInfo(Decl const* D);
+    findFileInfo(clang::Decl const* D);
 
     /* Build a FileInfo for a string path
 
@@ -1178,7 +1178,7 @@ class ASTVisitor
         `InfoTy` with the given `id`, and return a reference
         to the new Info object.
     */
-    template <std::derived_from<Info> InfoTy>
+    template <std::derived_from<Symbol> InfoTy>
     upsertResult<InfoTy>
     upsert(SymbolID const& id);
 
@@ -1206,14 +1206,14 @@ class ASTVisitor
     upsert(DeclType const* D);
 
     template <
-        std::derived_from<Info> InfoTy,
-        std::derived_from<Decl> DeclTy>
+        std::derived_from<Symbol> InfoTy,
+        std::derived_from<clang::Decl> DeclTy>
     Expected<void>
     checkUndocumented(
         SymbolID const& id,
         DeclTy const* D);
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_LIB_AST_ASTVISITOR_HPP
diff --git a/src/lib/AST/ASTVisitorConsumer.cpp b/src/lib/AST/ASTVisitorConsumer.cpp
index c4e328113..dd96ce1ee 100644
--- a/src/lib/AST/ASTVisitorConsumer.cpp
+++ b/src/lib/AST/ASTVisitorConsumer.cpp
@@ -15,11 +15,11 @@
 #include <lib/AST/ASTVisitorConsumer.hpp>
 #include <lib/Support/Path.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 void
 ASTVisitorConsumer::
-HandleTranslationUnit(ASTContext& Context)
+HandleTranslationUnit(clang::ASTContext& Context)
 {
     MRDOCS_ASSERT(sema_);
     Diagnostics diags;
@@ -33,4 +33,4 @@ HandleTranslationUnit(ASTContext& Context)
     ex_.report(std::move(visitor.results()), std::move(diags), std::move(visitor.undocumented()));
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/AST/ASTVisitorConsumer.hpp b/src/lib/AST/ASTVisitorConsumer.hpp
index 191cd14de..8a15796e1 100644
--- a/src/lib/AST/ASTVisitorConsumer.hpp
+++ b/src/lib/AST/ASTVisitorConsumer.hpp
@@ -20,7 +20,7 @@
 #include <clang/Sema/SemaConsumer.h>
 #include <clang/Tooling/Tooling.h>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** A consumer for visiting AST nodes and performing semantic analysis.
@@ -37,18 +37,18 @@ namespace mrdocs {
     when the translation unit is complete.
  */
 class ASTVisitorConsumer
-    : public SemaConsumer
+    : public clang::SemaConsumer
 {
     ConfigImpl const& config_;
     ExecutionContext& ex_;
-    CompilerInstance& compiler_;
-    Sema* sema_ = nullptr;
+    clang::CompilerInstance& compiler_;
+    clang::Sema* sema_ = nullptr;
 
 public:
     ASTVisitorConsumer(
         ConfigImpl const& config,
         ExecutionContext& ex,
-        CompilerInstance& compiler) noexcept
+        clang::CompilerInstance& compiler) noexcept
         : config_(config)
         , ex_(ex)
         , compiler_(compiler)
@@ -62,7 +62,7 @@ class ASTVisitorConsumer
         tree.
       */
     void
-    InitializeSema(Sema& S) override
+    InitializeSema(clang::Sema& S) override
     {
         // Sema should not have been initialized yet
         MRDOCS_ASSERT(!sema_);
@@ -93,7 +93,7 @@ class ASTVisitorConsumer
         of declaration or definition is found is left as an empty stub.
       */
     void
-    HandleTranslationUnit(ASTContext& Context) override;
+    HandleTranslationUnit(clang::ASTContext& Context) override;
 
     /** Handle the specified top-level declaration.
 
@@ -103,7 +103,7 @@ class ASTVisitorConsumer
         @returns `true` to always continue parsing
      */
     bool
-    HandleTopLevelDecl(DeclGroupRef) override
+    HandleTopLevelDecl(clang::DeclGroupRef) override
     {
         return true;
     }
@@ -123,7 +123,7 @@ class ASTVisitorConsumer
         @param D The declaration of the static member variable
      */
     void
-    HandleCXXStaticMemberVarInstantiation(VarDecl* D) override
+    HandleCXXStaticMemberVarInstantiation(clang::VarDecl* D) override
     {
         D->setImplicit();
     }
@@ -142,12 +142,12 @@ class ASTVisitorConsumer
         because implicitly instantiated definitions of member
         functions of class templates are added to the end of the
         TU DeclContext. As a result, Decl::isImplicit returns
-        false for these FunctionDecls, so we manually set it here.
+        false for these clang::FunctionDecls, so we manually set it here.
 
         @param D The declaration of the function
      */
     void
-    HandleCXXImplicitFunctionInstantiation(FunctionDecl* D) override
+    HandleCXXImplicitFunctionInstantiation(clang::FunctionDecl* D) override
     {
         D->setImplicit();
     }
@@ -161,7 +161,7 @@ class ASTVisitorConsumer
 
         @param D The declaration of the function
      */
-    void HandleInlineFunctionDefinition(FunctionDecl*) override { }
+    void HandleInlineFunctionDefinition(clang::FunctionDecl*) override { }
 
     /** Handle a tag declaration definition.
 
@@ -172,7 +172,7 @@ class ASTVisitorConsumer
 
         @param D The declaration of the tag
      */
-    void HandleTagDeclDefinition(TagDecl*) override { }
+    void HandleTagDeclDefinition(clang::TagDecl*) override { }
 
     /** Handle a tag declaration required definition.
 
@@ -183,7 +183,7 @@ class ASTVisitorConsumer
 
         @param D The declaration of the tag
      */
-    void HandleTagDeclRequiredDefinition(TagDecl const*) override { }
+    void HandleTagDeclRequiredDefinition(clang::TagDecl const*) override { }
 
     /** Handle an interesting declaration.
 
@@ -196,7 +196,7 @@ class ASTVisitorConsumer
 
         @param D The declaration
      */
-    void HandleInterestingDecl(DeclGroupRef) override { }
+    void HandleInterestingDecl(clang::DeclGroupRef) override { }
 
     /** Handle a tentative definition.
 
@@ -206,7 +206,7 @@ class ASTVisitorConsumer
 
         @param D The declaration
      */
-    void CompleteTentativeDefinition(VarDecl*) override { }
+    void CompleteTentativeDefinition(clang::VarDecl*) override { }
 
     /** Handle a tentative definition.
 
@@ -216,7 +216,7 @@ class ASTVisitorConsumer
 
         @param D The declaration
      */
-    void CompleteExternalDeclaration(DeclaratorDecl*) override { }
+    void CompleteExternalDeclaration(clang::DeclaratorDecl*) override { }
 
     /** Handle a vtable.
 
@@ -226,7 +226,7 @@ class ASTVisitorConsumer
 
         @param D The declaration
      */
-    void AssignInheritanceModel(CXXRecordDecl*) override { }
+    void AssignInheritanceModel(clang::CXXRecordDecl*) override { }
 
     /** Handle an implicit import declaration.
 
@@ -236,7 +236,7 @@ class ASTVisitorConsumer
 
         @param D The declaration
      */
-    void HandleVTable(CXXRecordDecl*) override { }
+    void HandleVTable(clang::CXXRecordDecl*) override { }
 
     /** Handle an implicit import declaration.
 
@@ -246,7 +246,7 @@ class ASTVisitorConsumer
 
         @param D The declaration
      */
-    void HandleImplicitImportDecl(ImportDecl*) override { }
+    void HandleImplicitImportDecl(clang::ImportDecl*) override { }
 
     /** Handle a top-level declaration in an Objective-C container.
 
@@ -257,10 +257,10 @@ class ASTVisitorConsumer
 
         @param D The declaration
      */
-    void HandleTopLevelDeclInObjCContainer(DeclGroupRef) override { }
+    void HandleTopLevelDeclInObjCContainer(clang::DeclGroupRef) override { }
 };
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_LIB_AST_ASTVISITORCONSUMER_HPP
diff --git a/src/lib/AST/ClangHelpers.cpp b/src/lib/AST/ClangHelpers.cpp
index 150e05afe..430d1c1f8 100644
--- a/src/lib/AST/ClangHelpers.cpp
+++ b/src/lib/AST/ClangHelpers.cpp
@@ -17,14 +17,14 @@
 #include <clang/Sema/Template.h>
 #include <ranges>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
-Expr const*
+clang::Expr const*
 SubstituteConstraintExpressionWithoutSatisfaction(
-    Sema &S, const Sema::TemplateCompareNewDeclInfo &DeclInfo,
-    const Expr *ConstrExpr)
+    clang::Sema &S, const clang::Sema::TemplateCompareNewDeclInfo &DeclInfo,
+    clang::Expr const* ConstrExpr)
 {
-    MultiLevelTemplateArgumentList MLTAL = S.getTemplateInstantiationArgs(
+    clang::MultiLevelTemplateArgumentList MLTAL = S.getTemplateInstantiationArgs(
         DeclInfo.getDecl(), DeclInfo.getLexicalDeclContext(), /*Final=*/false,
         /*Innermost=*/std::nullopt,
         /*RelativeToPrimary=*/true,
@@ -36,12 +36,12 @@ SubstituteConstraintExpressionWithoutSatisfaction(
         return ConstrExpr;
     }
 
-    Sema::SFINAETrap const SFINAE(S, /*AccessCheckingSFINAE=*/false);
+    clang::Sema::SFINAETrap const SFINAE(S, /*AccessCheckingSFINAE=*/false);
 
-    Sema::InstantiatingTemplate Inst(
+    clang::Sema::InstantiatingTemplate Inst(
         S, DeclInfo.getLocation(),
-        Sema::InstantiatingTemplate::ConstraintNormalization{},
-        const_cast<NamedDecl *>(DeclInfo.getDecl()), SourceRange{});
+        clang::Sema::InstantiatingTemplate::ConstraintNormalization{},
+        const_cast<clang::NamedDecl *>(DeclInfo.getDecl()), clang::SourceRange{});
     if (Inst.isInvalid())
     {
         return nullptr;
@@ -51,7 +51,7 @@ SubstituteConstraintExpressionWithoutSatisfaction(
     // parameters that the surrounding function hasn't been instantiated yet. Note
     // this may happen while we're comparing two templates' constraint
     // equivalence.
-    LocalInstantiationScope ScopeForParameters(S);
+    clang::LocalInstantiationScope ScopeForParameters(S);
     if (auto *FD = DeclInfo.getDecl()->getAsFunction())
     {
         for (auto *PVD : FD->parameters())
@@ -60,7 +60,7 @@ SubstituteConstraintExpressionWithoutSatisfaction(
         }
     }
 
-    Optional<Sema::CXXThisScopeRAII> ThisScope;
+    Optional<clang::Sema::CXXThisScopeRAII> ThisScope;
 
     // See TreeTransform::RebuildTemplateSpecializationType. A context scope is
     // essential for having an injected class as the canonical type for a template
@@ -69,14 +69,14 @@ SubstituteConstraintExpressionWithoutSatisfaction(
     // template specializations can be profiled to the same value, which makes it
     // possible that e.g. constraints involving C<Class<T>> and C<Class> are
     // perceived identical.
-    Optional<Sema::ContextRAII> ContextScope;
-    if (auto *RD = dyn_cast<CXXRecordDecl>(DeclInfo.getDeclContext()))
+    Optional<clang::Sema::ContextRAII> ContextScope;
+    if (auto *RD = dyn_cast<clang::CXXRecordDecl>(DeclInfo.getDeclContext()))
     {
-        ThisScope.emplace(S, const_cast<CXXRecordDecl *>(RD), Qualifiers());
-        ContextScope.emplace(S, const_cast<DeclContext *>(cast<DeclContext>(RD)),
+        ThisScope.emplace(S, const_cast<clang::CXXRecordDecl *>(RD), clang::Qualifiers());
+        ContextScope.emplace(S, const_cast<clang::DeclContext *>(cast<clang::DeclContext>(RD)),
                              /*NewThisContext=*/false);
     }
-    ExprResult SubstConstr = S.SubstConstraintExprWithoutSatisfaction(
+    clang::ExprResult SubstConstr = S.SubstConstraintExprWithoutSatisfaction(
         const_cast<clang::Expr *>(ConstrExpr), MLTAL);
     if (SFINAE.hasErrorOccurred() || !SubstConstr.isUsable())
     {
@@ -85,34 +85,34 @@ SubstituteConstraintExpressionWithoutSatisfaction(
     return SubstConstr.get();
 }
 
-AccessSpecifier
-getAccess(Decl const* D)
+clang::AccessSpecifier
+getAccess(clang::Decl const* D)
 {
     // First, get the declaration this was instantiated from
     D = getInstantiatedFrom(D);
 
     // If this is the template declaration of a template,
     // use the access of the template
-    if (TemplateDecl const* TD = D->getDescribedTemplate())
+    if (clang::TemplateDecl const* TD = D->getDescribedTemplate())
     {
         return TD->getAccessUnsafe();
     }
 
     // For class/variable template partial/explicit specializations,
     // we want to use the access of the primary template
-    if (auto const* CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
+    if (auto const* CTSD = dyn_cast<clang::ClassTemplateSpecializationDecl>(D))
     {
         return CTSD->getSpecializedTemplate()->getAccessUnsafe();
     }
 
-    if (auto const* VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
+    if (auto const* VTSD = dyn_cast<clang::VarTemplateSpecializationDecl>(D))
     {
         return VTSD->getSpecializedTemplate()->getAccessUnsafe();
     }
 
     // For function template specializations, use the access of the
     // primary template if it has been resolved
-    if(auto const* FD = dyn_cast<FunctionDecl>(D))
+    if(auto const* FD = dyn_cast<clang::FunctionDecl>(D))
     {
         if (auto const* FTD = FD->getPrimaryTemplate())
         {
@@ -124,23 +124,23 @@ getAccess(Decl const* D)
     // their access based on the default access for the tag they
     // appear in, and any AccessSpecDecls which appears lexically
     // before them
-    if(auto const* FD = dyn_cast<FriendDecl>(D))
+    if(auto const* FD = dyn_cast<clang::FriendDecl>(D))
     {
-        auto const* RD = dyn_cast<CXXRecordDecl>(
+        auto const* RD = dyn_cast<clang::CXXRecordDecl>(
             FD->getLexicalDeclContext());
         // RD should never be null in well-formed code,
         // but clang error recovery may build an AST
         // where the assumption will not hold
         if (!RD)
         {
-            return AccessSpecifier::AS_public;
+            return clang::AccessSpecifier::AS_public;
         }
         auto access = RD->isClass() ?
-            AccessSpecifier::AS_private :
-            AccessSpecifier::AS_public;
+            clang::AccessSpecifier::AS_private :
+            clang::AccessSpecifier::AS_public;
         for(auto* M : RD->decls())
         {
-            if (auto* AD = dyn_cast<AccessSpecDecl>(M))
+            if (auto* AD = dyn_cast<clang::AccessSpecDecl>(M))
             {
                 access = AD->getAccessUnsafe();
             } else if (M == FD)
@@ -158,8 +158,8 @@ getAccess(Decl const* D)
     return D->getAccessUnsafe();
 }
 
-QualType
-getDeclaratorType(DeclaratorDecl const* DD)
+clang::QualType
+getDeclaratorType(clang::DeclaratorDecl const* DD)
 {
     if (auto* TSI = DD->getTypeSourceInfo();
         TSI && !TSI->getType().isNull())
@@ -169,27 +169,27 @@ getDeclaratorType(DeclaratorDecl const* DD)
     return DD->getType();
 }
 
-NonTypeTemplateParmDecl const*
-getNTTPFromExpr(Expr const* E, unsigned const Depth)
+clang::NonTypeTemplateParmDecl const*
+getNTTPFromExpr(clang::Expr const* E, unsigned const Depth)
 {
     while(true)
     {
-        if(auto const* ICE = dyn_cast<ImplicitCastExpr>(E))
+        if(auto const* ICE = dyn_cast<clang::ImplicitCastExpr>(E))
         {
             E = ICE->getSubExpr();
             continue;
         }
-        if(auto const* CE = dyn_cast<ConstantExpr>(E))
+        if(auto const* CE = dyn_cast<clang::ConstantExpr>(E))
         {
             E = CE->getSubExpr();
             continue;
         }
-        if(auto const* SNTTPE = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
+        if(auto const* SNTTPE = dyn_cast<clang::SubstNonTypeTemplateParmExpr>(E))
         {
             E = SNTTPE->getReplacement();
             continue;
         }
-        if(auto const* CCE = dyn_cast<CXXConstructExpr>(E);
+        if(auto const* CCE = dyn_cast<clang::CXXConstructExpr>(E);
             CCE && CCE->getParenOrBraceRange().isInvalid())
         {
             // look through implicit copy construction from an lvalue of the same type
@@ -199,13 +199,13 @@ getNTTPFromExpr(Expr const* E, unsigned const Depth)
         break;
     }
 
-    auto const* DRE = dyn_cast<DeclRefExpr>(E);
+    auto const* DRE = dyn_cast<clang::DeclRefExpr>(E);
     if (!DRE)
     {
         return nullptr;
     }
 
-    auto const* NTTPD = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
+    auto const* NTTPD = dyn_cast<clang::NonTypeTemplateParmDecl>(DRE->getDecl());
     if (!NTTPD || NTTPD->getDepth() != Depth)
     {
         return nullptr;
@@ -214,30 +214,29 @@ getNTTPFromExpr(Expr const* E, unsigned const Depth)
     return NTTPD;
 }
 
-Decl const*
-getParent(Decl const* D)
+clang::Decl const*
+getParent(clang::Decl const* D)
 {
-    while((D = cast_if_present<
-        Decl>(D->getDeclContext())))
+    while((D = cast_if_present<clang::Decl>(D->getDeclContext())))
     {
         switch(D->getKind())
         {
-        case Decl::CXXRecord:
+        case clang::Decl::CXXRecord:
             // we treat anonymous unions as "transparent"
-            if (auto const* RD = cast<CXXRecordDecl>(D);
+            if (auto const* RD = cast<clang::CXXRecordDecl>(D);
                 RD &&
                 RD->isAnonymousStructOrUnion())
             {
                 break;
             }
             [[fallthrough]];
-        case Decl::TranslationUnit:
-        case Decl::Namespace:
-        case Decl::Enum:
-        case Decl::ClassTemplateSpecialization:
-        case Decl::ClassTemplatePartialSpecialization:
+        case clang::Decl::TranslationUnit:
+        case clang::Decl::Namespace:
+        case clang::Decl::Enum:
+        case clang::Decl::ClassTemplateSpecialization:
+        case clang::Decl::ClassTemplatePartialSpecialization:
             // we treat anonymous namespaces as "transparent"
-            if (auto const* ND = dyn_cast<NamespaceDecl>(D);
+            if (auto const* ND = dyn_cast<clang::NamespaceDecl>(D);
                 ND &&
                 (ND->isInlineNamespace() ||
                  ND->isAnonymousNamespace()))
@@ -255,14 +254,14 @@ getParent(Decl const* D)
 
 void
 getQualifiedName(
-    NamedDecl const* ND,
-    raw_ostream& stream,
-    const PrintingPolicy &policy)
+    clang::NamedDecl const* ND,
+    clang::raw_ostream& stream,
+    clang::PrintingPolicy const& policy)
 {
-    if (auto const* CTS = dyn_cast<ClassTemplateSpecializationDecl>(ND))
+    if (auto const* CTS = dyn_cast<clang::ClassTemplateSpecializationDecl>(ND))
     {
         CTS->getSpecializedTemplate()->printQualifiedName(stream, policy);
-        TemplateArgumentList const& args = CTS->getTemplateArgs();
+        clang::TemplateArgumentList const& args = CTS->getTemplateArgs();
         stream << '<';
         for (unsigned i = 0, e = args.size(); i != e; ++i) {
             if (args[i].getIsDefaulted())
@@ -283,18 +282,18 @@ getQualifiedName(
     }
 }
 
-Decl const*
-decayToPrimaryTemplate(Decl const* D)
+clang::Decl const*
+decayToPrimaryTemplate(clang::Decl const* D)
 {
 #ifndef NDEBUG
     // Print only the class header (name and template args if specialization)
-    SmallString<128> symbolName;
-    if (const auto* ND = dyn_cast<NamedDecl>(D))
+    llvm::SmallString<128> symbolName;
+    if (const auto* ND = dyn_cast<clang::NamedDecl>(D))
     {
-        if (const auto* CTS = dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
+        if (const auto* CTS = dyn_cast<clang::ClassTemplateSpecializationDecl>(ND)) {
             llvm::raw_svector_ostream os(symbolName);
             CTS->getSpecializedTemplate()->printQualifiedName(os, CTS->getASTContext().getPrintingPolicy());
-            const TemplateArgumentList& args = CTS->getTemplateArgs();
+            const clang::TemplateArgumentList& args = CTS->getTemplateArgs();
             os << '<';
             for (unsigned i = 0, e = args.size(); i != e; ++i)
             {
@@ -310,28 +309,28 @@ decayToPrimaryTemplate(Decl const* D)
     else
     {
         llvm::raw_svector_ostream os(symbolName);
-        os << "<unnamed " << D->Decl::getDeclKindName() << ">";
+        os << "<unnamed " << D->clang::Decl::getDeclKindName() << ">";
     }
     llvm::raw_svector_ostream os(symbolName);
     report::trace("symbolName: ", std::string_view(os.str()));
 #endif
 
-    Decl const* ID = D;
+    clang::Decl const* ID = D;
 
     // Check parent
-    if (CXXRecordDecl const* ClassParent = dyn_cast<CXXRecordDecl>(getParent(ID)))
+    if (clang::CXXRecordDecl const* ClassParent = dyn_cast<clang::CXXRecordDecl>(getParent(ID)))
     {
-        if (Decl const* DecayedClassParent = decayToPrimaryTemplate(ClassParent);
+        if (clang::Decl const* DecayedClassParent = decayToPrimaryTemplate(ClassParent);
             DecayedClassParent != ClassParent &&
-            isa<ClassTemplateSpecializationDecl>(DecayedClassParent))
+            isa<clang::ClassTemplateSpecializationDecl>(DecayedClassParent))
         {
-            auto const* RD = dyn_cast<ClassTemplateDecl>(DecayedClassParent);
-            CXXRecordDecl* RDParent = RD->getTemplatedDecl();
-            auto* NamedID = dyn_cast<NamedDecl>(ID);
+            auto const* RD = dyn_cast<clang::ClassTemplateDecl>(DecayedClassParent);
+            clang::CXXRecordDecl* RDParent = RD->getTemplatedDecl();
+            auto* NamedID = dyn_cast<clang::NamedDecl>(ID);
             auto NamedDecls = RDParent->decls()
-                | std::ranges::views::transform([](Decl* C) { return dyn_cast<NamedDecl>(C); })
-                | std::ranges::views::filter([](NamedDecl* C) { return C; });
-            for (NamedDecl const* Child : NamedDecls)
+                | std::ranges::views::transform([](clang::Decl* C) { return dyn_cast<clang::NamedDecl>(C); })
+                | std::ranges::views::filter([](clang::NamedDecl* C) { return C; });
+            for (clang::NamedDecl const* Child : NamedDecls)
             {
                 if (Child->getDeclName() == NamedID->getDeclName() &&
                     Child->getKind() == ID->getKind())
@@ -344,7 +343,7 @@ decayToPrimaryTemplate(Decl const* D)
     }
 
     // Check template specialization
-    if (auto const* TSD = dynamic_cast<ClassTemplateSpecializationDecl const*>(ID);
+    if (auto const* TSD = dynamic_cast<clang::ClassTemplateSpecializationDecl const*>(ID);
         TSD &&
         !TSD->isExplicitSpecialization())
     {
@@ -355,19 +354,19 @@ decayToPrimaryTemplate(Decl const* D)
 }
 
 bool
-isAllImplicitSpecialization(Decl const* D)
+isAllImplicitSpecialization(clang::Decl const* D)
 {
     if (!D)
     {
         return true;
     }
-    if (auto const* TSD = dynamic_cast<ClassTemplateSpecializationDecl const*>(D);
+    if (auto const* TSD = dynamic_cast<clang::ClassTemplateSpecializationDecl const*>(D);
         TSD &&
         TSD->isExplicitSpecialization())
     {
         return false;
     }
-    if (auto const* TSD = dynamic_cast<VarTemplateSpecializationDecl const*>(D);
+    if (auto const* TSD = dynamic_cast<clang::VarTemplateSpecializationDecl const*>(D);
         TSD &&
         TSD->isExplicitSpecialization())
     {
@@ -378,19 +377,19 @@ isAllImplicitSpecialization(Decl const* D)
 }
 
 bool
-isAnyImplicitSpecialization(Decl const* D)
+isAnyImplicitSpecialization(clang::Decl const* D)
 {
     if (!D)
     {
         return false;
     }
-    if (auto const* TSD = dynamic_cast<ClassTemplateSpecializationDecl const*>(D);
+    if (auto const* TSD = dynamic_cast<clang::ClassTemplateSpecializationDecl const*>(D);
         TSD &&
         !TSD->isExplicitSpecialization())
     {
         return true;
     }
-    if (auto const* TSD = dynamic_cast<VarTemplateSpecializationDecl const*>(D);
+    if (auto const* TSD = dynamic_cast<clang::VarTemplateSpecializationDecl const*>(D);
         TSD &&
         !TSD->isExplicitSpecialization())
     {
@@ -401,9 +400,9 @@ isAnyImplicitSpecialization(Decl const* D)
 }
 
 bool
-isVirtualMember(Decl const* D)
+isVirtualMember(clang::Decl const* D)
 {
-    if (auto const* MD = dyn_cast<CXXMethodDecl>(D))
+    if (auto const* MD = dyn_cast<clang::CXXMethodDecl>(D))
     {
         return MD->isVirtual();
     }
@@ -411,9 +410,9 @@ isVirtualMember(Decl const* D)
 }
 
 bool
-isAnonymousNamespace(Decl const* D)
+isAnonymousNamespace(clang::Decl const* D)
 {
-    if (auto const* ND = dyn_cast<NamespaceDecl>(D))
+    if (auto const* ND = dyn_cast<clang::NamespaceDecl>(D))
     {
         return ND->isAnonymousNamespace();
     }
@@ -421,27 +420,27 @@ isAnonymousNamespace(Decl const* D)
 }
 
 bool
-isStaticFileLevelMember(Decl const* D)
+isStaticFileLevelMember(clang::Decl const* D)
 {
-    if (const auto *VD = dyn_cast<VarDecl>(D)) {
-        return VD->getStorageClass() == SC_Static && VD->getDeclContext()->isFileContext();
+    if (const auto *VD = dyn_cast<clang::VarDecl>(D)) {
+        return VD->getStorageClass() == clang::SC_Static && VD->getDeclContext()->isFileContext();
     }
-    if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
-        return FD->getStorageClass() == SC_Static && FD->getDeclContext()->isFileContext();
+    if (const auto *FD = dyn_cast<clang::FunctionDecl>(D)) {
+        return FD->getStorageClass() == clang::SC_Static && FD->getDeclContext()->isFileContext();
     }
     return false;
 }
 
-RawComment const*
-getDocumentation(Decl const* D)
+clang::RawComment const*
+getDocumentation(clang::Decl const* D)
 {
-    RawComment const* RC =
+    clang::RawComment const* RC =
         D->getASTContext().getRawCommentForDeclNoCache(D);
     if (!RC)
     {
-        auto const* TD = dyn_cast<TemplateDecl>(D);
+        auto const* TD = dyn_cast<clang::TemplateDecl>(D);
         MRDOCS_CHECK_OR(TD, nullptr);
-        NamedDecl const* ND = TD->getTemplatedDecl();
+        clang::NamedDecl const* ND = TD->getTemplatedDecl();
         MRDOCS_CHECK_OR(ND, nullptr);
         RC = ND->getASTContext().getRawCommentForDeclNoCache(ND);
     }
@@ -449,9 +448,9 @@ getDocumentation(Decl const* D)
 }
 
 bool
-isDocumented(Decl const* D)
+isDocumented(clang::Decl const* D)
 {
     return getDocumentation(D) != nullptr;
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/AST/ClangHelpers.hpp b/src/lib/AST/ClangHelpers.hpp
index 0e8cc31e5..f2305f6fa 100644
--- a/src/lib/AST/ClangHelpers.hpp
+++ b/src/lib/AST/ClangHelpers.hpp
@@ -17,7 +17,7 @@
 #include <mrdocs/Platform.hpp>
 #include <lib/AST/InstantiatedFromVisitor.hpp>
 #include <mrdocs/Metadata.hpp>
-#include <mrdocs/Metadata/Info/SymbolID.hpp>
+#include <mrdocs/Metadata/Symbol/SymbolID.hpp>
 #include <mrdocs/Metadata/Type/QualifierKind.hpp>
 #include <mrdocs/Support/Error.hpp>
 #include <mrdocs/Support/TypeTraits.hpp>
@@ -28,7 +28,7 @@
 #include <clang/Sema/Sema.h>
 #include <type_traits>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Substitute the constraint expression without satisfaction.
 
@@ -43,11 +43,11 @@ namespace clang::mrdocs {
     @param ConstrExpr The constraint expression to be substituted.
     @return The substituted constraint expression, or nullptr if an error occurs.
  */
-Expr const*
+clang::Expr const*
 SubstituteConstraintExpressionWithoutSatisfaction(
-    Sema &S,
-    const Sema::TemplateCompareNewDeclInfo &DeclInfo,
-    const Expr *ConstrExpr);
+    clang::Sema &S,
+    const clang::Sema::TemplateCompareNewDeclInfo &DeclInfo,
+    const clang::Expr *ConstrExpr);
 
 /** Determine the MrDocs Info type for a Clang DeclType
 
@@ -68,131 +68,131 @@ SubstituteConstraintExpressionWithoutSatisfaction(
 template <class>
 struct InfoTypeFor {};
 
-// Extract NamespaceInfo from NamespaceDecl or TranslationUnitDecl
+// Extract NamespaceSymbol from NamespaceDecl or TranslationUnitDecl
 template <>
-struct InfoTypeFor<NamespaceDecl>
-    : std::type_identity<NamespaceInfo> {};
+struct InfoTypeFor<clang::NamespaceDecl>
+    : std::type_identity<NamespaceSymbol> {};
 
 template <>
-struct InfoTypeFor<TranslationUnitDecl>
-    : std::type_identity<NamespaceInfo> {};
+struct InfoTypeFor<clang::TranslationUnitDecl>
+    : std::type_identity<NamespaceSymbol> {};
 
-// Extract RecordInfo from anything derived from CXXRecordDecl
-// and ClassTemplateDecl. Decls derived from CXXRecordDecl
+// Extract RecordSymbol from anything derived from clang::CXXRecordDecl
+// and clang::ClassTemplateDecl. Decls derived from clang::CXXRecordDecl
 // include class specializations.
 template <>
-struct InfoTypeFor<CXXRecordDecl>
-    : std::type_identity<RecordInfo> {};
+struct InfoTypeFor<clang::CXXRecordDecl>
+    : std::type_identity<RecordSymbol> {};
 
 template <>
-struct InfoTypeFor<ClassTemplateSpecializationDecl>
-    : std::type_identity<RecordInfo> {};
+struct InfoTypeFor<clang::ClassTemplateSpecializationDecl>
+    : std::type_identity<RecordSymbol> {};
 
 template <>
-struct InfoTypeFor<ClassTemplatePartialSpecializationDecl>
-    : std::type_identity<RecordInfo> {};
+struct InfoTypeFor<clang::ClassTemplatePartialSpecializationDecl>
+    : std::type_identity<RecordSymbol> {};
 
 template <>
-struct InfoTypeFor<ClassTemplateDecl>
-    : std::type_identity<RecordInfo> {};
+struct InfoTypeFor<clang::ClassTemplateDecl>
+    : std::type_identity<RecordSymbol> {};
 
-// Extract FunctionInfo from anything derived from FunctionDecl
+// Extract FunctionSymbol from anything derived from clang::FunctionDecl
 template <>
-struct InfoTypeFor<FunctionDecl>
-    : std::type_identity<FunctionInfo> {};
+struct InfoTypeFor<clang::FunctionDecl>
+    : std::type_identity<FunctionSymbol> {};
 
 template <>
-struct InfoTypeFor<CXXMethodDecl>
-    : std::type_identity<FunctionInfo> {};
+struct InfoTypeFor<clang::CXXMethodDecl>
+    : std::type_identity<FunctionSymbol> {};
 
 template <>
-struct InfoTypeFor<CXXConstructorDecl>
-    : std::type_identity<FunctionInfo> {};
+struct InfoTypeFor<clang::CXXConstructorDecl>
+    : std::type_identity<FunctionSymbol> {};
 
 template <>
-struct InfoTypeFor<CXXDestructorDecl>
-    : std::type_identity<FunctionInfo> {};
+struct InfoTypeFor<clang::CXXDestructorDecl>
+    : std::type_identity<FunctionSymbol> {};
 
 template <>
-struct InfoTypeFor<CXXConversionDecl>
-    : std::type_identity<FunctionInfo> {};
+struct InfoTypeFor<clang::CXXConversionDecl>
+    : std::type_identity<FunctionSymbol> {};
 
 template <>
-struct InfoTypeFor<FunctionTemplateDecl>
-    : std::type_identity<FunctionInfo> {};
+struct InfoTypeFor<clang::FunctionTemplateDecl>
+    : std::type_identity<FunctionSymbol> {};
 
-// Extract EnumInfo from EnumDecl
+// Extract EnumSymbol from EnumDecl
 template <>
-struct InfoTypeFor<EnumDecl>
-    : std::type_identity<EnumInfo> {};
+struct InfoTypeFor<clang::EnumDecl>
+    : std::type_identity<EnumSymbol> {};
 
-// Extract EnumConstantInfo from EnumConstantDecl
+// Extract EnumConstantSymbol from EnumConstantDecl
 template <>
-struct InfoTypeFor<EnumConstantDecl>
-    : std::type_identity<EnumConstantInfo> {};
+struct InfoTypeFor<clang::EnumConstantDecl>
+    : std::type_identity<EnumConstantSymbol> {};
 
-// Extract TypedefInfo from anything derived from TypedefNameDecl
+// Extract TypedefSymbol from anything derived from TypedefNameDecl
 template <>
-struct InfoTypeFor<TypedefDecl>
-    : std::type_identity<TypedefInfo> {};
+struct InfoTypeFor<clang::TypedefDecl>
+    : std::type_identity<TypedefSymbol> {};
 
 template <>
-struct InfoTypeFor<TypeAliasDecl>
-    : std::type_identity<TypedefInfo> {};
+struct InfoTypeFor<clang::TypeAliasDecl>
+    : std::type_identity<TypedefSymbol> {};
 
 template <>
-struct InfoTypeFor<TypedefNameDecl>
-    : std::type_identity<TypedefInfo> {};
+struct InfoTypeFor<clang::TypedefNameDecl>
+    : std::type_identity<TypedefSymbol> {};
 
 template <>
-struct InfoTypeFor<TypeAliasTemplateDecl>
-    : std::type_identity<TypedefInfo> {};
+struct InfoTypeFor<clang::TypeAliasTemplateDecl>
+    : std::type_identity<TypedefSymbol> {};
 
-// Extract VariableInfo from anything derived from VarDecl
+// Extract VariableSymbol from anything derived from VarDecl
 // and VarTemplateDecl.
 template <>
-struct InfoTypeFor<VarDecl>
-    : std::type_identity<VariableInfo> {};
+struct InfoTypeFor<clang::VarDecl>
+    : std::type_identity<VariableSymbol> {};
 
 template <>
-struct InfoTypeFor<VarTemplateSpecializationDecl>
-    : std::type_identity<VariableInfo> {};
+struct InfoTypeFor<clang::VarTemplateSpecializationDecl>
+    : std::type_identity<VariableSymbol> {};
 
 template <>
-struct InfoTypeFor<VarTemplatePartialSpecializationDecl>
-    : std::type_identity<VariableInfo> {};
+struct InfoTypeFor<clang::VarTemplatePartialSpecializationDecl>
+    : std::type_identity<VariableSymbol> {};
 
 template <>
-struct InfoTypeFor<VarTemplateDecl>
-    : std::type_identity<VariableInfo> {};
+struct InfoTypeFor<clang::VarTemplateDecl>
+    : std::type_identity<VariableSymbol> {};
 
 template <>
-struct InfoTypeFor<FieldDecl>
-    : std::type_identity<VariableInfo> {};
+struct InfoTypeFor<clang::FieldDecl>
+    : std::type_identity<VariableSymbol> {};
 
-// Extract GuideInfo from CXXDeductionGuideDecl
+// Extract GuideSymbol from CXXDeductionGuideDecl
 template <>
-struct InfoTypeFor<CXXDeductionGuideDecl>
-    : std::type_identity<GuideInfo> {};
+struct InfoTypeFor<clang::CXXDeductionGuideDecl>
+    : std::type_identity<GuideSymbol> {};
 
-// Extract NamespaceAliasInfo from NamespaceAliasDecl
+// Extract NamespaceAliasSymbol from NamespaceAliasDecl
 template <>
-struct InfoTypeFor<NamespaceAliasDecl>
-    : std::type_identity<NamespaceAliasInfo> {};
+struct InfoTypeFor<clang::NamespaceAliasDecl>
+    : std::type_identity<NamespaceAliasSymbol> {};
 
-// Extract UsingInfo from UsingDecl
+// Extract UsingSymbol from UsingDecl
 template <>
-struct InfoTypeFor<UsingDecl>
-    : std::type_identity<UsingInfo> {};
+struct InfoTypeFor<clang::UsingDecl>
+    : std::type_identity<UsingSymbol> {};
 
-// Extract ConceptInfo from ConceptDecl
+// Extract ConceptSymbol from ConceptDecl
 template <>
-struct InfoTypeFor<ConceptDecl>
-    : std::type_identity<ConceptInfo> {};
+struct InfoTypeFor<clang::ConceptDecl>
+    : std::type_identity<ConceptSymbol> {};
 
 /// Determine if there's a MrDocs Info type for a Clang DeclType
 template <class T>
-concept HasInfoTypeFor = std::derived_from<T, Decl> && requires
+concept HasInfoTypeFor = std::derived_from<T, clang::Decl> && requires
 {
     typename InfoTypeFor<T>::type;
 };
@@ -205,14 +205,14 @@ using InfoTypeFor_t = typename InfoTypeFor<DeclType>::type;
  */
 inline
 AccessKind
-toAccessKind(AccessSpecifier const spec)
+toAccessKind(clang::AccessSpecifier const spec)
 {
     switch(spec)
     {
-    case AccessSpecifier::AS_public:    return AccessKind::Public;
-    case AccessSpecifier::AS_protected: return AccessKind::Protected;
-    case AccessSpecifier::AS_private:   return AccessKind::Private;
-    case AccessSpecifier::AS_none:      return AccessKind::None;
+    case clang::AccessSpecifier::AS_public:    return AccessKind::Public;
+    case clang::AccessSpecifier::AS_protected: return AccessKind::Protected;
+    case clang::AccessSpecifier::AS_private:   return AccessKind::Private;
+    case clang::AccessSpecifier::AS_none:      return AccessKind::None;
     default:
         MRDOCS_UNREACHABLE();
     }
@@ -222,15 +222,15 @@ toAccessKind(AccessSpecifier const spec)
  */
 inline
 StorageClassKind
-toStorageClassKind(StorageClass const spec)
+toStorageClassKind(clang::StorageClass const spec)
 {
     switch(spec)
     {
-    case StorageClass::SC_None:     return StorageClassKind::None;
-    case StorageClass::SC_Extern:   return StorageClassKind::Extern;
-    case StorageClass::SC_Static:   return StorageClassKind::Static;
-    case StorageClass::SC_Auto:     return StorageClassKind::Auto;
-    case StorageClass::SC_Register: return StorageClassKind::Register;
+    case clang::StorageClass::SC_None:     return StorageClassKind::None;
+    case clang::StorageClass::SC_Extern:   return StorageClassKind::Extern;
+    case clang::StorageClass::SC_Static:   return StorageClassKind::Static;
+    case clang::StorageClass::SC_Auto:     return StorageClassKind::Auto;
+    case clang::StorageClass::SC_Register: return StorageClassKind::Register;
     default:
         // SC_PrivateExtern (__private_extern__)
         // is a C only Apple extension
@@ -242,18 +242,18 @@ toStorageClassKind(StorageClass const spec)
  */
 inline
 ConstexprKind
-toConstexprKind(ConstexprSpecKind const spec)
+toConstexprKind(clang::ConstexprSpecKind const spec)
 {
     switch(spec)
     {
-    case ConstexprSpecKind::Unspecified: return ConstexprKind::None;
-    case ConstexprSpecKind::Constexpr:   return ConstexprKind::Constexpr;
-    case ConstexprSpecKind::Consteval:   return ConstexprKind::Consteval;
-    // KRYSTIAN NOTE: ConstexprSpecKind::Constinit exists,
+    case clang::ConstexprSpecKind::Unspecified: return ConstexprKind::None;
+    case clang::ConstexprSpecKind::Constexpr:   return ConstexprKind::Constexpr;
+    case clang::ConstexprSpecKind::Consteval:   return ConstexprKind::Consteval;
+    // KRYSTIAN NOTE: clang::ConstexprSpecKind::Constinit exists,
     // but I don't think it's ever used because a variable
     // can be declared both constexpr and constinit
     // (but not both in the same declaration)
-    case ConstexprSpecKind::Constinit:
+    case clang::ConstexprSpecKind::Constinit:
     default:
         MRDOCS_UNREACHABLE();
     }
@@ -263,7 +263,7 @@ toConstexprKind(ConstexprSpecKind const spec)
  */
 inline
 ExplicitKind
-toExplicitKind(ExplicitSpecifier const& spec)
+toExplicitKind(clang::ExplicitSpecifier const& spec)
 {
     // no explicit-specifier
     if (!spec.isSpecified())
@@ -273,9 +273,9 @@ toExplicitKind(ExplicitSpecifier const& spec)
 
     switch(spec.getKind())
     {
-    case ExplicitSpecKind::ResolvedFalse:  return ExplicitKind::False;
-    case ExplicitSpecKind::ResolvedTrue:   return ExplicitKind::True;
-    case ExplicitSpecKind::Unresolved:     return ExplicitKind::Dependent;
+    case clang::ExplicitSpecKind::ResolvedFalse:  return ExplicitKind::False;
+    case clang::ExplicitSpecKind::ResolvedTrue:   return ExplicitKind::True;
+    case clang::ExplicitSpecKind::Unresolved:     return ExplicitKind::Dependent;
     default:
         MRDOCS_UNREACHABLE();
     }
@@ -285,133 +285,133 @@ toExplicitKind(ExplicitSpecifier const& spec)
  */
 inline
 NoexceptKind
-toNoexceptKind(ExceptionSpecificationType const spec)
+toNoexceptKind(clang::ExceptionSpecificationType const spec)
 {
     // KRYSTIAN TODO: right now we convert pre-C++17 dynamic exception
     // specifications to an (roughly) equivalent noexcept-specifier
     switch(spec)
     {
-    case ExceptionSpecificationType::EST_None:
-    case ExceptionSpecificationType::EST_MSAny:
-    case ExceptionSpecificationType::EST_Unevaluated:
-    case ExceptionSpecificationType::EST_Uninstantiated:
+    case clang::ExceptionSpecificationType::EST_None:
+    case clang::ExceptionSpecificationType::EST_MSAny:
+    case clang::ExceptionSpecificationType::EST_Unevaluated:
+    case clang::ExceptionSpecificationType::EST_Uninstantiated:
     // we *shouldn't* ever encounter an unparsed exception specification,
     // assuming that clang is working correctly...
-    case ExceptionSpecificationType::EST_Unparsed:
-    case ExceptionSpecificationType::EST_Dynamic:
-    case ExceptionSpecificationType::EST_NoexceptFalse:
+    case clang::ExceptionSpecificationType::EST_Unparsed:
+    case clang::ExceptionSpecificationType::EST_Dynamic:
+    case clang::ExceptionSpecificationType::EST_NoexceptFalse:
         return NoexceptKind::False;
-    case ExceptionSpecificationType::EST_NoThrow:
-    case ExceptionSpecificationType::EST_BasicNoexcept:
-    case ExceptionSpecificationType::EST_NoexceptTrue:
-    case ExceptionSpecificationType::EST_DynamicNone:
+    case clang::ExceptionSpecificationType::EST_NoThrow:
+    case clang::ExceptionSpecificationType::EST_BasicNoexcept:
+    case clang::ExceptionSpecificationType::EST_NoexceptTrue:
+    case clang::ExceptionSpecificationType::EST_DynamicNone:
         return NoexceptKind::True;
-    case ExceptionSpecificationType::EST_DependentNoexcept:
+    case clang::ExceptionSpecificationType::EST_DependentNoexcept:
         return NoexceptKind::Dependent;
     default:
         MRDOCS_UNREACHABLE();
     }
 }
 
-/** Convert a Clang OverloadedOperatorKind into a MrDocs OperatorKind
+/** Convert a Clang clang::OverloadedOperatorKind into a MrDocs OperatorKind
  */
 inline
 OperatorKind
-toOperatorKind(OverloadedOperatorKind const kind)
+toOperatorKind(clang::OverloadedOperatorKind const kind)
 {
     switch(kind)
     {
-    case OverloadedOperatorKind::OO_None:
+    case clang::OverloadedOperatorKind::OO_None:
         return OperatorKind::None;
-    case OverloadedOperatorKind::OO_New:
+    case clang::OverloadedOperatorKind::OO_New:
         return OperatorKind::New;
-    case OverloadedOperatorKind::OO_Delete:
+    case clang::OverloadedOperatorKind::OO_Delete:
         return OperatorKind::Delete;
-    case OverloadedOperatorKind::OO_Array_New:
+    case clang::OverloadedOperatorKind::OO_Array_New:
         return OperatorKind::ArrayNew;
-    case OverloadedOperatorKind::OO_Array_Delete:
+    case clang::OverloadedOperatorKind::OO_Array_Delete:
         return OperatorKind::ArrayDelete;
-    case OverloadedOperatorKind::OO_Plus:
+    case clang::OverloadedOperatorKind::OO_Plus:
         return OperatorKind::Plus;
-    case OverloadedOperatorKind::OO_Minus:
+    case clang::OverloadedOperatorKind::OO_Minus:
         return OperatorKind::Minus;
-    case OverloadedOperatorKind::OO_Star:
+    case clang::OverloadedOperatorKind::OO_Star:
         return OperatorKind::Star;
-    case OverloadedOperatorKind::OO_Slash:
+    case clang::OverloadedOperatorKind::OO_Slash:
         return OperatorKind::Slash;
-    case OverloadedOperatorKind::OO_Percent:
+    case clang::OverloadedOperatorKind::OO_Percent:
         return OperatorKind::Percent;
-    case OverloadedOperatorKind::OO_Caret:
+    case clang::OverloadedOperatorKind::OO_Caret:
         return OperatorKind::Caret;
-    case OverloadedOperatorKind::OO_Amp:
+    case clang::OverloadedOperatorKind::OO_Amp:
         return OperatorKind::Amp;
-    case OverloadedOperatorKind::OO_Pipe:
+    case clang::OverloadedOperatorKind::OO_Pipe:
         return OperatorKind::Pipe;
-    case OverloadedOperatorKind::OO_Tilde:
+    case clang::OverloadedOperatorKind::OO_Tilde:
         return OperatorKind::Tilde;
-    case OverloadedOperatorKind::OO_Exclaim:
+    case clang::OverloadedOperatorKind::OO_Exclaim:
         return OperatorKind::Exclaim;
-    case OverloadedOperatorKind::OO_Equal:
+    case clang::OverloadedOperatorKind::OO_Equal:
         return OperatorKind::Equal;
-    case OverloadedOperatorKind::OO_Less:
+    case clang::OverloadedOperatorKind::OO_Less:
         return OperatorKind::Less;
-    case OverloadedOperatorKind::OO_Greater:
+    case clang::OverloadedOperatorKind::OO_Greater:
         return OperatorKind::Greater;
-    case OverloadedOperatorKind::OO_PlusEqual:
+    case clang::OverloadedOperatorKind::OO_PlusEqual:
         return OperatorKind::PlusEqual;
-    case OverloadedOperatorKind::OO_MinusEqual:
+    case clang::OverloadedOperatorKind::OO_MinusEqual:
         return OperatorKind::MinusEqual;
-    case OverloadedOperatorKind::OO_StarEqual:
+    case clang::OverloadedOperatorKind::OO_StarEqual:
         return OperatorKind::StarEqual;
-    case OverloadedOperatorKind::OO_SlashEqual:
+    case clang::OverloadedOperatorKind::OO_SlashEqual:
         return OperatorKind::SlashEqual;
-    case OverloadedOperatorKind::OO_PercentEqual:
+    case clang::OverloadedOperatorKind::OO_PercentEqual:
         return OperatorKind::PercentEqual;
-    case OverloadedOperatorKind::OO_CaretEqual:
+    case clang::OverloadedOperatorKind::OO_CaretEqual:
         return OperatorKind::CaretEqual;
-    case OverloadedOperatorKind::OO_AmpEqual:
+    case clang::OverloadedOperatorKind::OO_AmpEqual:
         return OperatorKind::AmpEqual;
-    case OverloadedOperatorKind::OO_PipeEqual:
+    case clang::OverloadedOperatorKind::OO_PipeEqual:
         return OperatorKind::PipeEqual;
-    case OverloadedOperatorKind::OO_LessLess:
+    case clang::OverloadedOperatorKind::OO_LessLess:
         return OperatorKind::LessLess;
-    case OverloadedOperatorKind::OO_GreaterGreater:
+    case clang::OverloadedOperatorKind::OO_GreaterGreater:
         return OperatorKind::GreaterGreater;
-    case OverloadedOperatorKind::OO_LessLessEqual:
+    case clang::OverloadedOperatorKind::OO_LessLessEqual:
         return OperatorKind::LessLessEqual;
-    case OverloadedOperatorKind::OO_GreaterGreaterEqual:
+    case clang::OverloadedOperatorKind::OO_GreaterGreaterEqual:
         return OperatorKind::GreaterGreaterEqual;
-    case OverloadedOperatorKind::OO_EqualEqual:
+    case clang::OverloadedOperatorKind::OO_EqualEqual:
         return OperatorKind::EqualEqual;
-    case OverloadedOperatorKind::OO_ExclaimEqual:
+    case clang::OverloadedOperatorKind::OO_ExclaimEqual:
         return OperatorKind::ExclaimEqual;
-    case OverloadedOperatorKind::OO_LessEqual:
+    case clang::OverloadedOperatorKind::OO_LessEqual:
         return OperatorKind::LessEqual;
-    case OverloadedOperatorKind::OO_GreaterEqual:
+    case clang::OverloadedOperatorKind::OO_GreaterEqual:
         return OperatorKind::GreaterEqual;
-    case OverloadedOperatorKind::OO_Spaceship:
+    case clang::OverloadedOperatorKind::OO_Spaceship:
         return OperatorKind::Spaceship;
-    case OverloadedOperatorKind::OO_AmpAmp:
+    case clang::OverloadedOperatorKind::OO_AmpAmp:
         return OperatorKind::AmpAmp;
-    case OverloadedOperatorKind::OO_PipePipe:
+    case clang::OverloadedOperatorKind::OO_PipePipe:
         return OperatorKind::PipePipe;
-    case OverloadedOperatorKind::OO_PlusPlus:
+    case clang::OverloadedOperatorKind::OO_PlusPlus:
         return OperatorKind::PlusPlus;
-    case OverloadedOperatorKind::OO_MinusMinus:
+    case clang::OverloadedOperatorKind::OO_MinusMinus:
         return OperatorKind::MinusMinus;
-    case OverloadedOperatorKind::OO_Comma:
+    case clang::OverloadedOperatorKind::OO_Comma:
         return OperatorKind::Comma;
-    case OverloadedOperatorKind::OO_ArrowStar:
+    case clang::OverloadedOperatorKind::OO_ArrowStar:
         return OperatorKind::ArrowStar;
-    case OverloadedOperatorKind::OO_Arrow:
+    case clang::OverloadedOperatorKind::OO_Arrow:
         return OperatorKind::Arrow;
-    case OverloadedOperatorKind::OO_Call:
+    case clang::OverloadedOperatorKind::OO_Call:
         return OperatorKind::Call;
-    case OverloadedOperatorKind::OO_Subscript:
+    case clang::OverloadedOperatorKind::OO_Subscript:
         return OperatorKind::Subscript;
-    case OverloadedOperatorKind::OO_Conditional:
+    case clang::OverloadedOperatorKind::OO_Conditional:
         return OperatorKind::Conditional;
-    case OverloadedOperatorKind::OO_Coawait:
+    case clang::OverloadedOperatorKind::OO_Coawait:
         return OperatorKind::Coawait;
     default:
         MRDOCS_UNREACHABLE();
@@ -422,34 +422,34 @@ toOperatorKind(OverloadedOperatorKind const kind)
  */
 inline
 ReferenceKind
-toReferenceKind(RefQualifierKind const kind)
+toReferenceKind(clang::RefQualifierKind const kind)
 {
     switch(kind)
     {
-    case RefQualifierKind::RQ_None:
+    case clang::RefQualifierKind::RQ_None:
         return ReferenceKind::None;
-    case RefQualifierKind::RQ_LValue:
+    case clang::RefQualifierKind::RQ_LValue:
         return ReferenceKind::LValue;
-    case RefQualifierKind::RQ_RValue:
+    case clang::RefQualifierKind::RQ_RValue:
         return ReferenceKind::RValue;
     default:
         MRDOCS_UNREACHABLE();
     }
 }
 
-/** Convert a Clang TagTypeKind into a MrDocs RecordKeyKind
+/** Convert a Clang clang::TagTypeKind into a MrDocs RecordKeyKind
  */
 inline
 RecordKeyKind
-toRecordKeyKind(TagTypeKind const kind)
+toRecordKeyKind(clang::TagTypeKind const kind)
 {
     switch(kind)
     {
-    case TagTypeKind::Struct: return RecordKeyKind::Struct;
-    case TagTypeKind::Class:  return RecordKeyKind::Class;
-    case TagTypeKind::Union:  return RecordKeyKind::Union;
+    case clang::TagTypeKind::Struct: return RecordKeyKind::Struct;
+    case clang::TagTypeKind::Class:  return RecordKeyKind::Class;
+    case clang::TagTypeKind::Union:  return RecordKeyKind::Union;
     default:
-        // unsupported TagTypeKind (Interface, or Enum)
+        // unsupported clang::TagTypeKind (Interface, or Enum)
         MRDOCS_UNREACHABLE();
     }
 }
@@ -461,11 +461,11 @@ QualifierKind
 toQualifierKind(unsigned const quals)
 {
     std::underlying_type_t<QualifierKind> result = QualifierKind::None;
-    if (quals & Qualifiers::Const)
+    if (quals & clang::Qualifiers::Const)
     {
         result |= QualifierKind::Const;
     }
-    if (quals & Qualifiers::Volatile)
+    if (quals & clang::Qualifiers::Volatile)
     {
         result |= QualifierKind::Volatile;
     }
@@ -477,89 +477,89 @@ toQualifierKind(unsigned const quals)
  */
 inline
 FunctionClass
-toFunctionClass(Decl::Kind const kind)
+toFunctionClass(clang::Decl::Kind const kind)
 {
     switch(kind)
     {
-    case Decl::Kind::Function:
-    case Decl::Kind::CXXMethod:         return FunctionClass::Normal;
-    case Decl::Kind::CXXConstructor:    return FunctionClass::Constructor;
-    case Decl::Kind::CXXConversion:     return FunctionClass::Conversion;
-    case Decl::Kind::CXXDestructor:     return FunctionClass::Destructor;
+    case clang::Decl::Kind::Function:
+    case clang::Decl::Kind::CXXMethod:         return FunctionClass::Normal;
+    case clang::Decl::Kind::CXXConstructor:    return FunctionClass::Constructor;
+    case clang::Decl::Kind::CXXConversion:     return FunctionClass::Conversion;
+    case clang::Decl::Kind::CXXDestructor:     return FunctionClass::Destructor;
     default:
         MRDOCS_UNREACHABLE();
     }
 }
 
-/** Convert a Clang AutoTypeKeyword into a MrDocs AutoKind
+/** Convert a Clang clang::AutoTypeKeyword into a MrDocs AutoKind
  */
 inline
 AutoKind
-toAutoKind(AutoTypeKeyword const kind)
+toAutoKind(clang::AutoTypeKeyword const kind)
 {
     switch(kind)
     {
-    case AutoTypeKeyword::Auto:
-    case AutoTypeKeyword::GNUAutoType:
+    case clang::AutoTypeKeyword::Auto:
+    case clang::AutoTypeKeyword::GNUAutoType:
       return AutoKind::Auto;
-    case AutoTypeKeyword::DecltypeAuto:
+    case clang::AutoTypeKeyword::DecltypeAuto:
       return AutoKind::DecltypeAuto;
     default:
         MRDOCS_UNREACHABLE();
     }
 }
 
-/** Convert a Clang AutoTypeKeyword into a MrDocs AutoKind
+/** Convert a Clang clang::clang::BuiltinType into a MrDocs AutoKind
  */
 inline
 Optional<FundamentalTypeKind>
-toFundamentalTypeKind(BuiltinType::Kind const kind)
+toFundamentalTypeKind(clang::BuiltinType::Kind const kind)
 {
     switch(kind)
     {
-    case BuiltinType::Kind::Void:
+    case clang::BuiltinType::Kind::Void:
         return FundamentalTypeKind::Void;
-    case BuiltinType::Kind::NullPtr:
+    case clang::BuiltinType::Kind::NullPtr:
         return FundamentalTypeKind::Nullptr;
-    case BuiltinType::Kind::Bool:
+    case clang::BuiltinType::Kind::Bool:
         return FundamentalTypeKind::Bool;
-    case BuiltinType::Kind::Char_U:
-    case BuiltinType::Kind::Char_S:
+    case clang::BuiltinType::Kind::Char_U:
+    case clang::BuiltinType::Kind::Char_S:
         return FundamentalTypeKind::Char;
-    case BuiltinType::Kind::SChar:
+    case clang::BuiltinType::Kind::SChar:
         return FundamentalTypeKind::SignedChar;
-    case BuiltinType::Kind::UChar:
+    case clang::BuiltinType::Kind::UChar:
         return FundamentalTypeKind::UnsignedChar;
-    case BuiltinType::Kind::Char8:
+    case clang::BuiltinType::Kind::Char8:
         return FundamentalTypeKind::Char8;
-    case BuiltinType::Kind::Char16:
+    case clang::BuiltinType::Kind::Char16:
         return FundamentalTypeKind::Char16;
-    case BuiltinType::Kind::Char32:
+    case clang::BuiltinType::Kind::Char32:
         return FundamentalTypeKind::Char32;
-    case BuiltinType::Kind::WChar_S:
-    case BuiltinType::Kind::WChar_U:
+    case clang::BuiltinType::Kind::WChar_S:
+    case clang::BuiltinType::Kind::WChar_U:
         return FundamentalTypeKind::WChar;
-    case BuiltinType::Kind::Short:
+    case clang::BuiltinType::Kind::Short:
         return FundamentalTypeKind::Short;
-    case BuiltinType::Kind::UShort:
+    case clang::BuiltinType::Kind::UShort:
         return FundamentalTypeKind::UnsignedShort;
-    case BuiltinType::Kind::Int:
+    case clang::BuiltinType::Kind::Int:
         return FundamentalTypeKind::Int;
-    case BuiltinType::Kind::UInt:
+    case clang::BuiltinType::Kind::UInt:
         return FundamentalTypeKind::UnsignedInt;
-    case BuiltinType::Kind::Long:
+    case clang::BuiltinType::Kind::Long:
         return FundamentalTypeKind::Long;
-    case BuiltinType::Kind::ULong:
+    case clang::BuiltinType::Kind::ULong:
         return FundamentalTypeKind::UnsignedLong;
-    case BuiltinType::Kind::LongLong:
+    case clang::BuiltinType::Kind::LongLong:
         return FundamentalTypeKind::LongLong;
-    case BuiltinType::Kind::ULongLong:
+    case clang::BuiltinType::Kind::ULongLong:
         return FundamentalTypeKind::UnsignedLongLong;
-    case BuiltinType::Kind::Float:
+    case clang::BuiltinType::Kind::Float:
         return FundamentalTypeKind::Float;
-    case BuiltinType::Kind::Double:
+    case clang::BuiltinType::Kind::Double:
         return FundamentalTypeKind::Double;
-    case BuiltinType::Kind::LongDouble:
+    case clang::BuiltinType::Kind::LongDouble:
         return FundamentalTypeKind::LongDouble;
     default:
         return std::nullopt;
@@ -574,7 +574,7 @@ template<
     typename DeclTy,
     typename Visitor,
     typename... Args>
-    requires std::derived_from<DeclTy, Decl>
+    requires std::derived_from<DeclTy, clang::Decl>
 decltype(auto)
 visit(
     DeclTy* D,
@@ -586,11 +586,11 @@ visit(
     {
     #define ABSTRACT_DECL(TYPE)
     #define DECL(DERIVED, BASE) \
-        case Decl::DERIVED: \
-        if constexpr(std::derived_from<DERIVED##Decl, DeclTy>) \
+        case clang::Decl::DERIVED: \
+        if constexpr(std::derived_from<clang::DERIVED##Decl, DeclTy>) \
             return std::forward<Visitor>(visitor)( \
                 static_cast<add_cv_from_t<DeclTy, \
-                    DERIVED##Decl>*>(D), \
+                    clang::DERIVED##Decl>*>(D), \
                 std::forward<Args>(args)...); \
         else \
             MRDOCS_UNREACHABLE();
@@ -604,23 +604,23 @@ visit(
 
 template<typename DeclTy>
 consteval
-Decl::Kind
+clang::Decl::Kind
 DeclToKindImpl() = delete;
 
 #define ABSTRACT_DECL(TYPE)
 #define DECL(DERIVED, BASE) \
     template<> \
     consteval \
-    Decl::Kind \
-    DeclToKindImpl<DERIVED##Decl>() { return Decl::DERIVED; }
+    clang::Decl::Kind \
+    DeclToKindImpl<clang::DERIVED##Decl>() { return clang::Decl::DERIVED; }
 
 #include <clang/AST/DeclNodes.inc>
 
-/** Get the Decl::Kind for a type DeclTy derived from Decl.
+/** Get the clang::Decl::Kind for a type DeclTy derived from Decl.
  */
 template<typename DeclTy>
 consteval
-Decl::Kind
+clang::Decl::Kind
 DeclToKind()
 {
     return DeclToKindImpl<
@@ -635,7 +635,7 @@ template<
     typename TypeTy,
     typename Visitor,
     typename... Args>
-    requires std::derived_from<TypeTy, Type>
+    requires std::derived_from<TypeTy, clang::Type>
 decltype(auto)
 visit(
     TypeTy* T,
@@ -646,11 +646,11 @@ visit(
     switch(T->getTypeClass())
     {
     #define TYPE(DERIVED, BASE) \
-        case Type::DERIVED: \
-        if constexpr(std::derived_from<DERIVED##Type, TypeTy>) \
+        case clang::Type::DERIVED: \
+        if constexpr(std::derived_from<clang::DERIVED##Type, TypeTy>) \
             return std::forward<Visitor>(visitor)( \
                 static_cast<add_cv_from_t<TypeTy, \
-                    DERIVED##Type>*>(T), \
+                    clang::DERIVED##Type>*>(T), \
                 std::forward<Args>(args)...); \
         else \
             MRDOCS_UNREACHABLE();
@@ -664,21 +664,21 @@ visit(
 
 template<typename TypeTy>
 consteval
-Type::TypeClass
+clang::Type::TypeClass
 TypeToKindImpl() = delete;
 
 #define ABSTRACT_TYPE(DERIVED, BASE)
 #define TYPE(DERIVED, BASE) \
     template<> \
     consteval \
-    Type::TypeClass \
-    TypeToKindImpl<DERIVED##Type>() { return Type::DERIVED; }
+    clang::Type::TypeClass \
+    TypeToKindImpl<clang::DERIVED##Type>() { return clang::Type::DERIVED; }
 
 #include <clang/AST/TypeNodes.inc>
 
 template<typename TypeTy>
 consteval
-Type::TypeClass
+clang::Type::TypeClass
 TypeToKind()
 {
     return TypeToKindImpl<
@@ -693,7 +693,7 @@ template<
     typename TypeLocTy,
     typename Visitor,
     typename... Args>
-    requires std::derived_from<TypeLocTy, TypeLoc>
+    requires std::derived_from<TypeLocTy, clang::TypeLoc>
 decltype(auto)
 visit(
     TypeLocTy* T,
@@ -704,11 +704,11 @@ visit(
     {
     #define ABSTRACT_TYPELOC(DERIVED, BASE)
     #define TYPELOC(DERIVED, BASE) \
-        case TypeLoc::DERIVED: \
-        if constexpr(std::derived_from<DERIVED##TypeLoc, TypeLocTy>) \
+        case clang::TypeLoc::DERIVED: \
+        if constexpr(std::derived_from<clang::DERIVED##TypeLoc, TypeLocTy>) \
             return std::forward<Visitor>(visitor)( \
                 static_cast<add_cv_from_t<TypeLocTy, \
-                    DERIVED##TypeLoc>*>(T), \
+                    clang::DERIVED##TypeLoc>*>(T), \
                 std::forward<Args>(args)...); \
         else \
             MRDOCS_UNREACHABLE();
@@ -722,23 +722,23 @@ visit(
 
 template<typename TypeLocTy>
 consteval
-TypeLoc::TypeLocClass
+clang::TypeLoc::TypeLocClass
 TypeLocToKindImpl() = delete;
 
 #define ABSTRACT_TYPELOC(DERIVED, BASE)
 #define TYPELOC(DERIVED, BASE) \
     template<> \
     consteval \
-    TypeLoc::TypeLocClass \
-    TypeLocToKindImpl<DERIVED##TypeLoc>() { return TypeLoc::DERIVED; }
+    clang::TypeLoc::TypeLocClass \
+    TypeLocToKindImpl<clang::DERIVED##TypeLoc>() { return clang::TypeLoc::DERIVED; }
 
 #include <clang/AST/TypeLocNodes.def>
 
-/** Get the TypeLoc::TypeLocClass for a type TypeLocTy derived from TypeLoc.
+/** Get the clang::TypeLoc::TypeLocClass for a type TypeLocTy derived from TypeLoc.
  */
 template<typename TypeLocTy>
 consteval
-TypeLoc::TypeLocClass
+clang::TypeLoc::TypeLocClass
 TypeLocToKind()
 {
     return TypeLocToKindImpl<
@@ -765,52 +765,52 @@ getInstantiatedFrom(DeclTy const* D)
     {
         return nullptr;
     }
-    Decl const* resultDecl = InstantiatedFromVisitor().Visit(D);
+    clang::Decl const* resultDecl = InstantiatedFromVisitor().Visit(D);
     return cast<DeclTy>(resultDecl);
 }
 
 template <class DeclTy>
 requires
-    std::derived_from<DeclTy, FunctionDecl> ||
-    std::same_as<FunctionTemplateDecl, std::remove_cv_t<DeclTy>>
-FunctionDecl const*
+    std::derived_from<DeclTy, clang::FunctionDecl> ||
+    std::same_as<clang::FunctionTemplateDecl, std::remove_cv_t<DeclTy>>
+clang::FunctionDecl const*
 getInstantiatedFrom(DeclTy const* D)
 {
-    return dyn_cast_if_present<FunctionDecl>(
-        getInstantiatedFrom<Decl>(D));
+    return dyn_cast_if_present<clang::FunctionDecl>(
+        getInstantiatedFrom<clang::Decl>(D));
 }
 
 template <class DeclTy>
 requires
-    std::derived_from<DeclTy, CXXRecordDecl> ||
-    std::same_as<ClassTemplateDecl, std::remove_cv_t<DeclTy>>
-CXXRecordDecl const*
+    std::derived_from<DeclTy, clang::CXXRecordDecl> ||
+    std::same_as<clang::ClassTemplateDecl, std::remove_cv_t<DeclTy>>
+clang::CXXRecordDecl const*
 getInstantiatedFrom(DeclTy const* D)
 {
-    return dyn_cast_if_present<CXXRecordDecl>(
-        getInstantiatedFrom<Decl>(D));
+    return dyn_cast_if_present<clang::CXXRecordDecl>(
+        getInstantiatedFrom<clang::Decl>(D));
 }
 
 template <class DeclTy>
 requires
-    std::derived_from<DeclTy, VarDecl> ||
-    std::same_as<VarTemplateDecl, std::remove_cv_t<DeclTy>>
-VarDecl const*
+    std::derived_from<DeclTy, clang::VarDecl> ||
+    std::same_as<clang::VarTemplateDecl, std::remove_cv_t<DeclTy>>
+clang::VarDecl const*
 getInstantiatedFrom(DeclTy const* D)
 {
-    return dyn_cast_if_present<VarDecl>(
-        getInstantiatedFrom<Decl>(D));
+    return dyn_cast_if_present<clang::VarDecl>(
+        getInstantiatedFrom<clang::Decl>(D));
 }
 
 template <class DeclTy>
 requires
-    std::derived_from<DeclTy, TypedefNameDecl> ||
-    std::same_as<TypeAliasTemplateDecl, std::remove_cv_t<DeclTy>>
-TypedefNameDecl const*
+    std::derived_from<DeclTy, clang::TypedefNameDecl> ||
+    std::same_as<clang::TypeAliasTemplateDecl, std::remove_cv_t<DeclTy>>
+clang::TypedefNameDecl const*
 getInstantiatedFrom(DeclTy const* D)
 {
-    return dyn_cast_if_present<TypedefNameDecl>(
-        getInstantiatedFrom<Decl>(D));
+    return dyn_cast_if_present<clang::TypedefNameDecl>(
+        getInstantiatedFrom<clang::Decl>(D));
 }
 
 /** Get the access specifier for a `Decl`
@@ -819,19 +819,19 @@ getInstantiatedFrom(DeclTy const* D)
     context and return the access specifier for the declaration.
  */
 MRDOCS_DECL
-AccessSpecifier
-getAccess(Decl const* D);
+clang::AccessSpecifier
+getAccess(clang::Decl const* D);
 
 MRDOCS_DECL
-QualType
-getDeclaratorType(DeclaratorDecl const* DD);
+clang::QualType
+getDeclaratorType(clang::DeclaratorDecl const* DD);
 
 /** Get the NonTypeTemplateParm of an expression
 
-    This function will return the NonTypeTemplateParmDecl
+    This function will return the clang::NonTypeTemplateParmDecl
     corresponding to the expression `E` if it is a
-    NonTypeTemplateParmDecl. If the expression is not
-    a NonTypeTemplateParmDecl, the function will return
+    clang::NonTypeTemplateParmDecl. If the expression is not
+    a clang::NonTypeTemplateParmDecl, the function will return
     nullptr.
 
     For instance, given the expression `x` in the following
@@ -842,38 +842,38 @@ getDeclaratorType(DeclaratorDecl const* DD);
     void f() {}
     @endcode
 
-    the function will return the NonTypeTemplateParmDecl
+    the function will return the clang::NonTypeTemplateParmDecl
     corresponding to `x`, which is the template parameter
     of the function `f`.
  */
 MRDOCS_DECL
-NonTypeTemplateParmDecl const*
-getNTTPFromExpr(Expr const* E, unsigned Depth);
+clang::NonTypeTemplateParmDecl const*
+getNTTPFromExpr(clang::Expr const* E, unsigned Depth);
 
 // Get the parent declaration of a declaration
 MRDOCS_DECL
-Decl const*
-getParent(Decl const* D);
+clang::Decl const*
+getParent(clang::Decl const* D);
 
 MRDOCS_DECL
 void
 getQualifiedName(
-    NamedDecl const* ND,
-    raw_ostream &Out,
-    const PrintingPolicy &Policy);
+    clang::NamedDecl const* ND,
+    clang::raw_ostream &Out,
+    clang::PrintingPolicy const& Policy);
 
 // If D refers to an implicit instantiation of a template specialization,
-// decay it to the Decl of the primary template. The template arguments
-// will be extracted separately as part of the TypeInfo.
-// For instance, a Decl to `S<0>` becomes a Decl to `S`, unless `S<0>` is
+// decay it to the clang::Decl of the primary template. The template arguments
+// will be extracted separately as part of the Type.
+// For instance, a clang::Decl to `S<0>` becomes a clang::Decl to `S`, unless `S<0>` is
 // an explicit specialization of the primary template.
 // This function also applies recursively to the parent of D so that
 // the primary template is resolved for nested classes.
-// For instance, a Decl to `A<0>::S` becomes a Decl to `A::S`, unless
+// For instance, a clang::Decl to `A<0>::S` becomes a clang::Decl to `A::S`, unless
 // `A<0>` is an explicit specialization of the primary template.
 MRDOCS_DECL
-Decl const*
-decayToPrimaryTemplate(Decl const* D);
+clang::Decl const*
+decayToPrimaryTemplate(clang::Decl const* D);
 
 // Iterate the Decl and check if this is a template specialization
 // also considering the parent declarations. For instance,
@@ -882,17 +882,17 @@ decayToPrimaryTemplate(Decl const* D);
 // template specializations.
 MRDOCS_DECL
 bool
-isAllImplicitSpecialization(Decl const* D);
+isAllImplicitSpecialization(clang::Decl const* D);
 
 // Check if any component of D is an implicit specialization
 MRDOCS_DECL
 bool
-isAnyImplicitSpecialization(Decl const* D);
+isAnyImplicitSpecialization(clang::Decl const* D);
 
 // Check if at least one component of D is explicit
 inline
 bool
-isAnyExplicitSpecialization(Decl const* D)
+isAnyExplicitSpecialization(clang::Decl const* D)
 {
     return !isAllImplicitSpecialization(D);
 }
@@ -900,30 +900,30 @@ isAnyExplicitSpecialization(Decl const* D)
 // Check if all components are explicit
 inline
 bool
-isAllExplicitSpecialization(Decl const* D)
+isAllExplicitSpecialization(clang::Decl const* D)
 {
     return !isAnyImplicitSpecialization(D);
 }
 
 MRDOCS_DECL
 bool
-isVirtualMember(Decl const* D);
+isVirtualMember(clang::Decl const* D);
 
 MRDOCS_DECL
 bool
-isAnonymousNamespace(Decl const* D);
+isAnonymousNamespace(clang::Decl const* D);
 
 MRDOCS_DECL
 bool
-isStaticFileLevelMember(Decl const *D);
+isStaticFileLevelMember(clang::Decl const *D);
 
 MRDOCS_DECL
 bool
-isDocumented(Decl const *D);
+isDocumented(clang::Decl const *D);
 
 MRDOCS_DECL
-RawComment const*
-getDocumentation(Decl const *D);
+clang::RawComment const*
+getDocumentation(clang::Decl const *D);
 
 template <class DeclTy>
 bool
@@ -948,25 +948,25 @@ namespace detail {
     // getASTVisitor().context_.getPrintingPolicy());
     // is a valid expression
     template <class T>
-    concept HasPrintQualifiedName = requires(T const& D, llvm::raw_svector_ostream& OS, PrintingPolicy PP)
+    concept HasPrintQualifiedName = requires(T const& D, llvm::raw_svector_ostream& OS, clang::PrintingPolicy PP)
     {
         D.printQualifiedName(OS, PP);
     };
 
     template <class T>
-    concept HasPrint = requires(T const& D, llvm::raw_svector_ostream& OS, PrintingPolicy PP)
+    concept HasPrint = requires(T const& D, llvm::raw_svector_ostream& OS, clang::PrintingPolicy PP)
     {
         D.print(OS, PP);
     };
 
     template <class T>
-    concept HasPrintWithPolicyFirst = requires(T const& D, llvm::raw_svector_ostream& OS, PrintingPolicy PP)
+    concept HasPrintWithPolicyFirst = requires(T const& D, llvm::raw_svector_ostream& OS, clang::PrintingPolicy PP)
     {
         D.print(PP, OS, true);
     };
 
     template <class T>
-    concept HasDump = requires(T const& D, llvm::raw_svector_ostream& OS, ASTContext const& C)
+    concept HasDump = requires(T const& D, llvm::raw_svector_ostream& OS, clang::ASTContext const& C)
     {
         D.dump(OS, C);
     };
@@ -986,20 +986,20 @@ namespace detail {
     template <class T>
     requires (!std::is_pointer_v<T>)
     void
-    printTraceName(T const& D, ASTContext const& C, std::string& symbol_name);
+    printTraceName(T const& D, clang::ASTContext const& C, std::string& symbol_name);
 
     template <class T>
     void
-    printTraceName(T const* D, ASTContext const& C, std::string& symbol_name)
+    printTraceName(T const* D, clang::ASTContext const& C, std::string& symbol_name)
     {
         if (!D)
         {
             return;
         }
         llvm::raw_string_ostream os(symbol_name);
-        if constexpr (std::derived_from<T, Decl>)
+        if constexpr (std::derived_from<T, clang::Decl>)
         {
-            if (NamedDecl const* ND = dyn_cast<NamedDecl>(D))
+            if (clang::NamedDecl const* ND = dyn_cast<clang::NamedDecl>(D))
             {
                 getQualifiedName(ND, os, C.getPrintingPolicy());
             }
@@ -1022,7 +1022,7 @@ namespace detail {
         }
         else if constexpr (ConvertibleToUnqualifiedQualType<T>)
         {
-            QualType const QT(D, 0);
+            clang::QualType const QT(D, 0);
             QT.print(os, C.getPrintingPolicy());
         }
         else if constexpr (HasDump<T>)
@@ -1053,14 +1053,14 @@ namespace detail {
     template <class T>
     requires (!std::is_pointer_v<T>)
     void
-    printTraceName(T const& D, ASTContext const& C, std::string& symbol_name)
+    printTraceName(T const& D, clang::ASTContext const& C, std::string& symbol_name)
     {
         printTraceName(&D, C, symbol_name);
     }
 
     template <class T>
     void
-    printTraceName(Optional<T> const& D, ASTContext const& C, std::string& symbol_name)
+    printTraceName(Optional<T> const& D, clang::ASTContext const& C, std::string& symbol_name)
     {
         if (D)
         {
@@ -1082,6 +1082,6 @@ namespace detail {
     report::trace("{}", MRDOCS_SYMBOL_TRACE_UNIQUE_NAME)
 #endif
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/src/lib/AST/FrontendActionFactory.cpp b/src/lib/AST/FrontendActionFactory.cpp
index 3d7a3f16c..80943fd0d 100644
--- a/src/lib/AST/FrontendActionFactory.cpp
+++ b/src/lib/AST/FrontendActionFactory.cpp
@@ -14,11 +14,11 @@
 #include "FrontendActionFactory.hpp"
 #include <lib/AST/ASTAction.hpp>
 
-namespace clang {
+
 namespace mrdocs {
 
 
-std::unique_ptr<FrontendAction>
+std::unique_ptr<clang::FrontendAction>
 ASTActionFactory::
 create()
 {
@@ -28,4 +28,4 @@ create()
 }
 
 } // mrdocs
-} // clang
+
diff --git a/src/lib/AST/FrontendActionFactory.hpp b/src/lib/AST/FrontendActionFactory.hpp
index 3c4ec99a1..05e983e96 100644
--- a/src/lib/AST/FrontendActionFactory.hpp
+++ b/src/lib/AST/FrontendActionFactory.hpp
@@ -19,11 +19,11 @@
 #include <lib/Support/ExecutionContext.hpp>
 #include <clang/Tooling/Tooling.h>
 
-namespace clang {
+
 namespace mrdocs {
 
 class ASTActionFactory :
-    public tooling::FrontendActionFactory
+    public clang::tooling::FrontendActionFactory
 {
     ExecutionContext& ex_;
     ConfigImpl const& config_;
@@ -39,11 +39,11 @@ class ASTActionFactory :
     {
     }
 
-    std::unique_ptr<FrontendAction>
+    std::unique_ptr<clang::FrontendAction>
     create() override;
 };
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_LIB_AST_FRONTENDACTIONFACTORY_HPP
diff --git a/src/lib/AST/InstantiatedFromVisitor.hpp b/src/lib/AST/InstantiatedFromVisitor.hpp
index f284ba637..2a7d9651a 100644
--- a/src/lib/AST/InstantiatedFromVisitor.hpp
+++ b/src/lib/AST/InstantiatedFromVisitor.hpp
@@ -16,7 +16,7 @@
 
 #include <clang/AST/DeclVisitor.h>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** A visitor class for handling instantiations from templates.
 
@@ -24,17 +24,17 @@ namespace clang::mrdocs {
     and retrieve the original declarations from which they were instantiated.
  */
 class InstantiatedFromVisitor
-    : public ConstDeclVisitor<InstantiatedFromVisitor, Decl const*>
+    : public clang::ConstDeclVisitor<InstantiatedFromVisitor, clang::Decl const*>
 {
 public:
-    Decl const*
-    VisitDecl(Decl const* D)
+    clang::Decl const*
+    VisitDecl(clang::Decl const* D)
     {
         return D;
     }
 
-    FunctionDecl const*
-    VisitFunctionTemplateDecl(FunctionTemplateDecl const* D)
+    clang::FunctionDecl const*
+    VisitFunctionTemplateDecl(clang::FunctionTemplateDecl const* D)
     {
         while(auto* MT = D->getInstantiatedFromMemberTemplate())
         {
@@ -47,8 +47,8 @@ class InstantiatedFromVisitor
         return D->getTemplatedDecl();
     }
 
-    CXXRecordDecl const*
-    VisitClassTemplateDecl(ClassTemplateDecl const* D)
+    clang::CXXRecordDecl const*
+    VisitClassTemplateDecl(clang::ClassTemplateDecl const* D)
     {
         while (auto* MT = D->getInstantiatedFromMemberTemplate())
         {
@@ -61,8 +61,8 @@ class InstantiatedFromVisitor
         return D->getTemplatedDecl();
     }
 
-    VarDecl const*
-    VisitVarTemplateDecl(VarTemplateDecl const* D)
+    clang::VarDecl const*
+    VisitVarTemplateDecl(clang::VarTemplateDecl const* D)
     {
         while(auto* MT = D->getInstantiatedFromMemberTemplate())
         {
@@ -75,8 +75,8 @@ class InstantiatedFromVisitor
         return D->getTemplatedDecl();
     }
 
-    TypedefNameDecl const*
-    VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl const* D)
+    clang::TypedefNameDecl const*
+    VisitTypeAliasTemplateDecl(clang::TypeAliasTemplateDecl const* D)
     {
         if(auto* MT = D->getInstantiatedFromMemberTemplate())
         {
@@ -89,24 +89,24 @@ class InstantiatedFromVisitor
         return VisitTypedefNameDecl(D->getTemplatedDecl());
     }
 
-    FunctionDecl const*
-    VisitFunctionDecl(FunctionDecl const* D)
+    clang::FunctionDecl const*
+    VisitFunctionDecl(clang::FunctionDecl const* D)
     {
-        if (FunctionDecl const* DD = nullptr;
+        if (clang::FunctionDecl const* DD = nullptr;
             D->isDefined(DD, false))
         {
-            D = const_cast<FunctionDecl*>(DD);
+            D = const_cast<clang::FunctionDecl*>(DD);
         }
 
-        if (MemberSpecializationInfo const* MSI = D->getMemberSpecializationInfo())
+        if (clang::MemberSpecializationInfo const* MSI = D->getMemberSpecializationInfo())
         {
             if (!MSI->isExplicitSpecialization())
             {
-                D = cast<FunctionDecl>(MSI->getInstantiatedFrom());
+                D = cast<clang::FunctionDecl>(MSI->getInstantiatedFrom());
             }
         }
         else if(D->getTemplateSpecializationKind() !=
-            TSK_ExplicitSpecialization)
+            clang::TSK_ExplicitSpecialization)
         {
             D = D->getFirstDecl();
             if (auto* FTD = D->getPrimaryTemplate())
@@ -117,8 +117,8 @@ class InstantiatedFromVisitor
         return D;
     }
 
-    CXXRecordDecl const*
-    VisitClassTemplatePartialSpecializationDecl(ClassTemplatePartialSpecializationDecl const* D)
+    clang::CXXRecordDecl const*
+    VisitClassTemplatePartialSpecializationDecl(clang::ClassTemplatePartialSpecializationDecl const* D)
     {
         while (auto* MT = D->getInstantiatedFromMember())
         {
@@ -131,20 +131,20 @@ class InstantiatedFromVisitor
         return VisitClassTemplateSpecializationDecl(D);
     }
 
-    CXXRecordDecl const*
-    VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl const* D)
+    clang::CXXRecordDecl const*
+    VisitClassTemplateSpecializationDecl(clang::ClassTemplateSpecializationDecl const* D)
     {
         if (!D->isExplicitSpecialization())
         {
             auto const inst_from = D->getSpecializedTemplateOrPartial();
             if(auto* CTPSD = inst_from.dyn_cast<
-                ClassTemplatePartialSpecializationDecl*>())
+                clang::ClassTemplatePartialSpecializationDecl*>())
             {
                 MRDOCS_ASSERT(D != CTPSD);
                 return VisitClassTemplatePartialSpecializationDecl(CTPSD);
             }
             // Explicit instantiation declaration/definition
-            else if(auto* CTD = inst_from.dyn_cast<ClassTemplateDecl*>())
+            else if(auto* CTD = inst_from.dyn_cast<clang::ClassTemplateDecl*>())
             {
                 return VisitClassTemplateDecl(CTD);
             }
@@ -152,10 +152,10 @@ class InstantiatedFromVisitor
         return VisitCXXRecordDecl(D);
     }
 
-    CXXRecordDecl const*
-    VisitCXXRecordDecl(CXXRecordDecl const* D)
+    clang::CXXRecordDecl const*
+    VisitCXXRecordDecl(clang::CXXRecordDecl const* D)
     {
-        while (MemberSpecializationInfo const* MSI =
+        while (clang::MemberSpecializationInfo const* MSI =
             D->getMemberSpecializationInfo())
         {
             // if this is a member of an explicit specialization,
@@ -164,13 +164,13 @@ class InstantiatedFromVisitor
             {
                 break;
             }
-            D = cast<CXXRecordDecl>(MSI->getInstantiatedFrom());
+            D = cast<clang::CXXRecordDecl>(MSI->getInstantiatedFrom());
         }
         return D;
     }
 
-    VarDecl const*
-    VisitVarTemplatePartialSpecializationDecl(VarTemplatePartialSpecializationDecl const* D)
+    clang::VarDecl const*
+    VisitVarTemplatePartialSpecializationDecl(clang::VarTemplatePartialSpecializationDecl const* D)
     {
         while(auto* MT = D->getInstantiatedFromMember())
         {
@@ -183,21 +183,21 @@ class InstantiatedFromVisitor
         return VisitVarTemplateSpecializationDecl(D);
     }
 
-    VarDecl const*
-    VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl const* D)
+    clang::VarDecl const*
+    VisitVarTemplateSpecializationDecl(clang::VarTemplateSpecializationDecl const* D)
     {
         if(! D->isExplicitSpecialization())
         {
             auto const inst_from = D->getSpecializedTemplateOrPartial();
             if(auto* VTPSD = inst_from.dyn_cast<
-                VarTemplatePartialSpecializationDecl*>())
+                clang::VarTemplatePartialSpecializationDecl*>())
             {
                 MRDOCS_ASSERT(D != VTPSD);
                 return VisitVarTemplatePartialSpecializationDecl(VTPSD);
             }
             // explicit instantiation declaration/definition
             else if(auto* VTD = inst_from.dyn_cast<
-                VarTemplateDecl*>())
+                clang::VarTemplateDecl*>())
             {
                 return VisitVarTemplateDecl(VTD);
             }
@@ -205,60 +205,60 @@ class InstantiatedFromVisitor
         return VisitVarDecl(D);
     }
 
-    VarDecl const*
-    VisitVarDecl(VarDecl const* D)
+    clang::VarDecl const*
+    VisitVarDecl(clang::VarDecl const* D)
     {
-        while(MemberSpecializationInfo* MSI =
+        while(clang::MemberSpecializationInfo* MSI =
             D->getMemberSpecializationInfo())
         {
             if (MSI->isExplicitSpecialization())
             {
                 break;
             }
-            D = cast<VarDecl>(MSI->getInstantiatedFrom());
+            D = cast<clang::VarDecl>(MSI->getInstantiatedFrom());
         }
         return D;
     }
 
-    EnumDecl const*
-    VisitEnumDecl(EnumDecl const* D)
+    clang::EnumDecl const*
+    VisitEnumDecl(clang::EnumDecl const* D)
     {
-        while(MemberSpecializationInfo* MSI =
+        while(clang::MemberSpecializationInfo* MSI =
             D->getMemberSpecializationInfo())
         {
             if (MSI->isExplicitSpecialization())
             {
                 break;
             }
-            D = cast<EnumDecl>(MSI->getInstantiatedFrom());
+            D = cast<clang::EnumDecl>(MSI->getInstantiatedFrom());
         }
         return D;
     }
 
-    TypedefNameDecl const*
-    VisitTypedefNameDecl(TypedefNameDecl const* D)
+    clang::TypedefNameDecl const*
+    VisitTypedefNameDecl(clang::TypedefNameDecl const* D)
     {
-        DeclContext const* Context = D->getNonTransparentDeclContext();
+        clang::DeclContext const* Context = D->getNonTransparentDeclContext();
         if (Context->isFileContext())
         {
             return D;
         }
-        Decl const* ContextDecl = Decl::castFromDeclContext(Context);
-        Decl const* ContextInstatiationContextDecl = Visit(ContextDecl);
-        DeclContext const* ContextPattern =
-            Decl::castToDeclContext(ContextInstatiationContextDecl);
+        clang::Decl const* ContextDecl = clang::Decl::castFromDeclContext(Context);
+        clang::Decl const* ContextInstatiationContextDecl = Visit(ContextDecl);
+        clang::DeclContext const* ContextPattern =
+            clang::Decl::castToDeclContext(ContextInstatiationContextDecl);
         if (Context == ContextPattern)
         {
             return D;
         }
         for (auto lookup = ContextPattern->lookup(D->getDeclName());
-             NamedDecl * ND : lookup)
+             clang::NamedDecl * ND : lookup)
         {
-            if (auto const* TND = dyn_cast<TypedefNameDecl>(ND))
+            if (auto const* TND = dyn_cast<clang::TypedefNameDecl>(ND))
             {
                 return TND;
             }
-            if (auto const* TATD = dyn_cast<TypeAliasTemplateDecl>(ND))
+            if (auto const* TATD = dyn_cast<clang::TypeAliasTemplateDecl>(ND))
             {
                 return TATD->getTemplatedDecl();
             }
@@ -267,6 +267,6 @@ class InstantiatedFromVisitor
     }
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/src/lib/AST/MissingSymbolSink.hpp b/src/lib/AST/MissingSymbolSink.hpp
index fa634a3e2..87bbf04e5 100644
--- a/src/lib/AST/MissingSymbolSink.hpp
+++ b/src/lib/AST/MissingSymbolSink.hpp
@@ -25,7 +25,7 @@
 #include <set>
 #include <string>
 
-namespace clang {
+
 namespace mrdocs {
 
 struct FrozenDiag {
@@ -125,7 +125,7 @@ class MissingSymbolSink {
                 col = P.getColumn();
             }
         }
-        StringRef flag = Info.getFlagValue();
+        llvm::StringRef flag = Info.getFlagValue();
 
         FrozenDiag d;
         d.level = L;
@@ -436,6 +436,6 @@ class CollectingDiagConsumer : public clang::DiagnosticConsumer {
 };
 
 } // namespace mrdocs
-} // namespace clang
+
 
 #endif // MRDOCS_LIB_AST_MISSINGSYMBOLSINK_HPP
diff --git a/src/lib/AST/MrDocsFileSystem.hpp b/src/lib/AST/MrDocsFileSystem.hpp
index a622a2a0a..5aa2a5535 100644
--- a/src/lib/AST/MrDocsFileSystem.hpp
+++ b/src/lib/AST/MrDocsFileSystem.hpp
@@ -22,7 +22,7 @@
 #include <string>
 #include <vector>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 // A proxy and overlay FS that, when a file is missing, might serve an
 // adjusted or empty file from an in-memory FS and remembers it, so repeated
@@ -36,7 +36,7 @@ namespace clang::mrdocs {
 // the "**" pattern to forgive all missing includes or specific
 // patterns like "llvm/**" to forgive all includes from LLVM.
 class MrDocsFileSystem : public llvm::vfs::FileSystem {
-    IntrusiveRefCntPtr<llvm::vfs::FileSystem> Real;
+    llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> Real;
     std::shared_ptr<llvm::vfs::InMemoryFileSystem> Mem;
     ConfigImpl const &config_;
     clang::HeaderSearch* HeaderSearch = nullptr;
@@ -186,7 +186,7 @@ class MrDocsFileSystem : public llvm::vfs::FileSystem {
 
 public:
     MrDocsFileSystem(
-        IntrusiveRefCntPtr<llvm::vfs::FileSystem> RealFS,
+        llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> RealFS,
         ConfigImpl const &Cfg)
         : Real(std::move(RealFS))
         , Mem(std::make_shared<llvm::vfs::InMemoryFileSystem>())
@@ -337,6 +337,6 @@ createMrDocsFileSystem(ConfigImpl const &Cfg)
     return { new MrDocsFileSystem(Real, Cfg) };
 }
 
-} // namespace clang::mrdocs
+} // namespace mrdocs
 
 #endif // MRDOCS_LIB_AST_MRDOCSFILESYSTEM_HPP
diff --git a/src/lib/AST/NameBuilder.cpp b/src/lib/AST/NameBuilder.cpp
new file mode 100644
index 000000000..d1846cc08
--- /dev/null
+++ b/src/lib/AST/NameBuilder.cpp
@@ -0,0 +1,122 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2024 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#include <lib/AST/NameBuilder.hpp>
+
+namespace mrdocs {
+
+void
+NameBuilder::
+buildDecltype(
+    clang::DecltypeType const*,
+    unsigned,
+    bool)
+{
+    // KRYSTIAN TODO: support decltype in names
+    // (e.g. within nested-name-specifiers).
+}
+
+void
+NameBuilder::
+buildTerminal(
+    clang::Type const* T,
+    unsigned,
+    bool)
+{
+    Result = Polymorphic<Name>(std::in_place_type<IdentifierName>);
+    (*Result)->Identifier = getASTVisitor().toString(T);
+}
+
+void
+NameBuilder::
+buildTerminal(
+    clang::NestedNameSpecifier NNS,
+    clang::IdentifierInfo const* II,
+    Optional<llvm::ArrayRef<clang::TemplateArgument>> TArgs,
+    unsigned,
+    bool)
+{
+    if (TArgs)
+    {
+        Result =
+            Polymorphic<Name>(std::in_place_type<SpecializationName>);
+        if (II)
+        {
+            (*Result)->Identifier = II->getName();
+        }
+        getASTVisitor().populate(
+            static_cast<SpecializationName&>(**Result).TemplateArgs,
+            *TArgs);
+    }
+    else
+    {
+        Result = Polymorphic<Name>(std::in_place_type<IdentifierName>);
+        if (II)
+        {
+            (*Result)->Identifier = II->getName();
+        }
+    }
+    if (NNS)
+    {
+        (*Result)->Prefix = getASTVisitor().toName(NNS);
+    }
+}
+
+void
+NameBuilder::
+buildTerminal(
+    clang::NestedNameSpecifier NNS,
+    clang::NamedDecl const* D,
+    Optional<llvm::ArrayRef<clang::TemplateArgument>> const& TArgs,
+    unsigned,
+    bool)
+{
+    // Look for the Info type. If this is a template specialization,
+    // we look for the Info of the specialized record.
+    clang::Decl const* ID = decayToPrimaryTemplate(D);
+
+
+    auto populateName = [&](Name& Name, clang::NamedDecl const* DU)
+    {
+        if(clang::IdentifierInfo const* II = DU->getIdentifier())
+        {
+            Name.Identifier = II->getName();
+        }
+        if (Symbol const* I = getASTVisitor().findOrTraverse(const_cast<clang::Decl*>(ID)))
+        {
+            Name.id = I->id;
+        }
+        if (NNS)
+        {
+            Name.Prefix = getASTVisitor().toName(NNS);
+        }
+    };
+
+    if (!TArgs)
+    {
+        Result = Polymorphic<Name>(std::in_place_type<IdentifierName>);
+        populateName(**Result, D);
+    }
+    else
+    {
+        Result = Polymorphic<Name>(
+            std::in_place_type<SpecializationName>);
+        populateName(**Result, D);
+        MRDOCS_ASSERT(Result);
+        getASTVisitor().populate(
+            (*Result)->asSpecialization().TemplateArgs,
+            *TArgs);
+    }
+}
+
+} // mrdocs
diff --git a/src/lib/AST/NameInfoBuilder.hpp b/src/lib/AST/NameBuilder.hpp
similarity index 65%
rename from src/lib/AST/NameInfoBuilder.hpp
rename to src/lib/AST/NameBuilder.hpp
index c57ab455d..bc3f6ae0f 100644
--- a/src/lib/AST/NameInfoBuilder.hpp
+++ b/src/lib/AST/NameBuilder.hpp
@@ -11,24 +11,24 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_AST_NAMEINFOBUILDER_HPP
-#define MRDOCS_LIB_AST_NAMEINFOBUILDER_HPP
+#ifndef MRDOCS_LIB_AST_NAMEBUILDER_HPP
+#define MRDOCS_LIB_AST_NAMEBUILDER_HPP
 
 #include <lib/AST/TerminalTypeVisitor.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
 #include <clang/AST/TypeVisitor.h>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
-class NameInfoBuilder
-    : public TerminalTypeVisitor<NameInfoBuilder>
+class NameBuilder
+    : public TerminalTypeVisitor<NameBuilder>
 {
-    Optional<Polymorphic<NameInfo>> Result;
+    Optional<Polymorphic<Name>> Result;
 
 public:
     using TerminalTypeVisitor::TerminalTypeVisitor;
 
-    Polymorphic<NameInfo>
+    Polymorphic<Name>
     result()
     {
         MRDOCS_ASSERT(Result.has_value());
@@ -43,33 +43,33 @@ class NameInfoBuilder
 
     void
     buildDecltype(
-        DecltypeType const* T,
+        clang::DecltypeType const* T,
         unsigned quals,
         bool pack);
 
     void
     buildTerminal(
-        Type const* T,
+        clang::Type const* T,
         unsigned quals,
         bool pack);
 
     void
     buildTerminal(
-        NestedNameSpecifier NNS,
-        IdentifierInfo const* II,
-        Optional<ArrayRef<TemplateArgument>> TArgs,
+        clang::NestedNameSpecifier NNS,
+        clang::IdentifierInfo const* II,
+        Optional<llvm::ArrayRef<clang::TemplateArgument>> TArgs,
         unsigned quals,
         bool pack);
 
     void
     buildTerminal(
-        NestedNameSpecifier NNS,
-        NamedDecl const* D,
-        Optional<ArrayRef<TemplateArgument>> const& TArgs,
+        clang::NestedNameSpecifier NNS,
+        clang::NamedDecl const* D,
+        Optional<llvm::ArrayRef<clang::TemplateArgument>> const& TArgs,
         unsigned quals,
         bool pack);
 };
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif
+#endif // MRDOCS_LIB_AST_NAMEBUILDER_HPP
diff --git a/src/lib/AST/NameInfoBuilder.cpp b/src/lib/AST/NameInfoBuilder.cpp
deleted file mode 100644
index 2d6347692..000000000
--- a/src/lib/AST/NameInfoBuilder.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-//
-// This is a derivative work. originally part of the LLVM Project.
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-// Copyright (c) 2024 Alan de Freitas (alandefreitas@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#include <lib/AST/NameInfoBuilder.hpp>
-
-namespace clang::mrdocs {
-
-void
-NameInfoBuilder::
-buildDecltype(
-    DecltypeType const*,
-    unsigned,
-    bool)
-{
-    // KRYSTIAN TODO: support decltype in names
-    // (e.g. within nested-name-specifiers).
-}
-
-void
-NameInfoBuilder::
-buildTerminal(
-    Type const* T,
-    unsigned,
-    bool)
-{
-    Result = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
-    (*Result)->Name = getASTVisitor().toString(T);
-}
-
-void
-NameInfoBuilder::
-buildTerminal(
-    NestedNameSpecifier NNS,
-    IdentifierInfo const* II,
-    Optional<ArrayRef<TemplateArgument>> TArgs,
-    unsigned,
-    bool)
-{
-    if (TArgs)
-    {
-        Result =
-            Polymorphic<NameInfo>(std::in_place_type<SpecializationNameInfo>);
-        if (II)
-        {
-            (*Result)->Name = II->getName();
-        }
-        getASTVisitor().populate(
-            static_cast<SpecializationNameInfo&>(**Result).TemplateArgs,
-            *TArgs);
-    }
-    else
-    {
-        Result = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
-        if (II)
-        {
-            (*Result)->Name = II->getName();
-        }
-    }
-    if (NNS)
-    {
-        (*Result)->Prefix = getASTVisitor().toNameInfo(NNS);
-    }
-}
-
-void
-NameInfoBuilder::
-buildTerminal(
-    NestedNameSpecifier NNS,
-    NamedDecl const* D,
-    Optional<ArrayRef<TemplateArgument>> const& TArgs,
-    unsigned,
-    bool)
-{
-    // Look for the Info type. If this is a template specialization,
-    // we look for the Info of the specialized record.
-    Decl const* ID = decayToPrimaryTemplate(D);
-
-
-    auto populateNameInfo = [&](NameInfo& Name, NamedDecl const* DU)
-    {
-        if(IdentifierInfo const* II = DU->getIdentifier())
-        {
-            Name.Name = II->getName();
-        }
-        if (Info const* I = getASTVisitor().findOrTraverse(const_cast<Decl*>(ID)))
-        {
-            Name.id = I->id;
-        }
-        if (NNS)
-        {
-            Name.Prefix = getASTVisitor().toNameInfo(NNS);
-        }
-    };
-
-    if (!TArgs)
-    {
-        Result = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
-        populateNameInfo(**Result, D);
-    }
-    else
-    {
-        Result = Polymorphic<NameInfo>(
-            std::in_place_type<SpecializationNameInfo>);
-        populateNameInfo(**Result, D);
-        getASTVisitor().populate(
-            static_cast<SpecializationNameInfo&>(**Result).TemplateArgs,
-            *TArgs);
-    }
-}
-
-} // clang::mrdocs
diff --git a/src/lib/AST/ParseJavadoc.cpp b/src/lib/AST/ParseJavadoc.cpp
index 9990dee6e..31aaa6c15 100644
--- a/src/lib/AST/ParseJavadoc.cpp
+++ b/src/lib/AST/ParseJavadoc.cpp
@@ -83,7 +83,7 @@ namespace detail {
 } // namespace detail
 
 #define MRDOCS_COMMENT_TRACE(D, C) \
-    SmallString<1024> MRDOCS_COMMENT_TRACE_UNIQUE_NAME;                 \
+    llvm::SmallString<1024> MRDOCS_COMMENT_TRACE_UNIQUE_NAME;                 \
     ::detail::dumpCommentContent(D, C, MRDOCS_COMMENT_TRACE_UNIQUE_NAME);        \
     report::trace("{}", std::string_view(MRDOCS_COMMENT_TRACE_UNIQUE_NAME.str()))
 #endif
@@ -148,12 +148,10 @@ namespace detail {
 
 */
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 namespace {
 
-using namespace comments;
-
 //------------------------------------------------
 
 /** A visitor for extracting javadoc from comments.
@@ -163,12 +161,12 @@ using namespace comments;
 
   */
 class JavadocVisitor
-    : public ConstCommentVisitor<JavadocVisitor>
+    : public clang::comments::ConstCommentVisitor<JavadocVisitor>
 {
     Config const& config_;
-    ASTContext const& ctx_;
-    SourceManager const& sm_;
-    FullComment const* FC_;
+    clang::ASTContext const& ctx_;
+    clang::SourceManager const& sm_;
+    clang::comments::FullComment const* FC_;
     Javadoc jd_;
     Diagnostics& diags_;
     doc::Block* block_ = nullptr;
@@ -176,9 +174,9 @@ class JavadocVisitor
     std::size_t htmlTagNesting_ = 0;
 
     // Used to visit children of a comment
-    Comment const* parent_ = nullptr;
-    Comment::child_iterator it_{};
-    Comment::child_iterator end_{};
+    clang::comments::Comment const* parent_ = nullptr;
+    clang::comments::Comment::child_iterator it_{};
+    clang::comments::Comment::child_iterator end_{};
 
     /** Ensure that a string is valid UTF-8.
 
@@ -199,7 +197,7 @@ class JavadocVisitor
         and appended to the current block.
 
      */
-    void visitChildren(Comment const* C);
+    void visitChildren(clang::comments::Comment const* C);
 
 
     /** Temporarily set a block as the current block.
@@ -274,7 +272,7 @@ class JavadocVisitor
 
      */
     JavadocVisitor(
-        FullComment const*, Decl const*,
+        clang::comments::FullComment const*, clang::Decl const*,
         Config const&, Diagnostics&);
 
     /** Extract the javadoc from the comment.
@@ -294,22 +292,22 @@ class JavadocVisitor
 
      */
     void
-    visitComment(Comment const* C);
+    visitComment(clang::comments::Comment const* C);
 
     /** Visit a plain text comment.
      */
     void
-    visitTextComment(TextComment const* C);
+    visitTextComment(clang::comments::TextComment const* C);
 
     /** Visit an opening HTML tag with attributes.
      */
     void
-    visitHTMLStartTagComment(HTMLStartTagComment const* C);
+    visitHTMLStartTagComment(clang::comments::HTMLStartTagComment const* C);
 
     /** Visit a closing HTML tag.
      */
     void
-    visitHTMLEndTagComment(HTMLEndTagComment const* C);
+    visitHTMLEndTagComment(clang::comments::HTMLEndTagComment const* C);
 
     /** Visit a command with word-like arguments that is considered inline content.
 
@@ -322,7 +320,7 @@ class JavadocVisitor
 
      */
     void
-    visitInlineCommandComment(InlineCommandComment const* C);
+    visitInlineCommandComment(clang::comments::InlineCommandComment const* C);
 
     /** Fix a reference string
 
@@ -349,7 +347,7 @@ class JavadocVisitor
     /** Visit a single paragraph that contains inline content.
      */
     void
-    visitParagraphComment(ParagraphComment const* C);
+    visitParagraphComment(clang::comments::ParagraphComment const* C);
 
     /** Visit a command that has zero or more word-like arguments
 
@@ -358,12 +356,12 @@ class JavadocVisitor
 
      */
     void
-    visitBlockCommandComment(BlockCommandComment const* C);
+    visitBlockCommandComment(clang::comments::BlockCommandComment const* C);
 
     /** Visit the doxygen @param command.
      */
     void
-    visitParamCommandComment(ParamCommandComment const* C);
+    visitParamCommandComment(clang::comments::ParamCommandComment const* C);
 
 
     /** Visit the doxygen @tparam command
@@ -371,7 +369,7 @@ class JavadocVisitor
         The @tparam describes a template parameter.
     */
     void
-    visitTParamCommandComment(TParamCommandComment const* C);
+    visitTParamCommandComment(clang::comments::TParamCommandComment const* C);
 
     /** Visit a verbatim block command (e. g., preformatted code).
 
@@ -379,7 +377,7 @@ class JavadocVisitor
         multiple lines of text (VerbatimBlockLineComment nodes).
      */
     void
-    visitVerbatimBlockComment(VerbatimBlockComment const* C);
+    visitVerbatimBlockComment(clang::comments::VerbatimBlockComment const* C);
 
     /** Visit a verbatim line command.
 
@@ -388,12 +386,12 @@ class JavadocVisitor
         closing command.
      */
     void
-    visitVerbatimLineComment(VerbatimLineComment const* C);
+    visitVerbatimLineComment(clang::comments::VerbatimLineComment const* C);
 
     /** Visit a line of text contained in a verbatim block.
      */
     void
-    visitVerbatimBlockLineComment(VerbatimBlockLineComment const* C);
+    visitVerbatimBlockLineComment(clang::comments::VerbatimBlockLineComment const* C);
 
     /** @name Helpers
      * @{
@@ -408,11 +406,11 @@ class JavadocVisitor
         @returns `true` if the number of arguments is correct
      */
     bool
-    goodArgCount(std::size_t n, InlineCommandComment const& C);
+    goodArgCount(std::size_t n, clang::comments::InlineCommandComment const& C);
 
 
     Expected<TagComponents>
-    parseHTMLTag(HTMLStartTagComment const* C);
+    parseHTMLTag(clang::comments::HTMLStartTagComment const* C);
 
     /** Append a text node to the current block.
 
@@ -493,7 +491,7 @@ std::string &JavadocVisitor::ensureUTF8(std::string &&s) {
 
  */
 std::vector<Polymorphic<doc::Text>>
-parseStyled(StringRef s)
+parseStyled(llvm::StringRef s)
 {
     std::vector<Polymorphic<doc::Text>> result;
     std::string currentText;
@@ -584,7 +582,7 @@ parseStyled(StringRef s)
 void
 JavadocVisitor::
 visitChildren(
-    Comment const* C)
+    clang::comments::Comment const* C)
 {
     MRDOCS_COMMENT_TRACE(C, ctx_);
     ScopeExitRestore s1(it_, C->child_begin());
@@ -661,8 +659,8 @@ visitChildren(
 
 JavadocVisitor::
 JavadocVisitor(
-    FullComment const* FC,
-    Decl const* D,
+    clang::comments::FullComment const* FC,
+    clang::Decl const* D,
     Config const& config,
     Diagnostics& diags)
     : config_(config)
@@ -714,7 +712,7 @@ build()
 void
 JavadocVisitor::
 visitComment(
-    Comment const* C)
+    clang::comments::Comment const* C)
 {
     MRDOCS_COMMENT_TRACE(C, ctx_);
     visitChildren(C);
@@ -729,7 +727,7 @@ visitComment(
 void
 JavadocVisitor::
 visitTextComment(
-    TextComment const* C)
+    clang::comments::TextComment const* C)
 {
     MRDOCS_COMMENT_TRACE(C, ctx_);
     llvm::StringRef s = C->getText();
@@ -752,7 +750,7 @@ visitTextComment(
 
 Expected<JavadocVisitor::TagComponents>
 JavadocVisitor::
-parseHTMLTag(HTMLStartTagComment const* C)
+parseHTMLTag(clang::comments::HTMLStartTagComment const* C)
 {
     MRDOCS_COMMENT_TRACE(C, ctx_);
     TagComponents res;
@@ -769,9 +767,9 @@ parseHTMLTag(HTMLStartTagComment const* C)
 
     // Find Comment::HTMLEndTagCommentKind
     auto const tagEndIt =
-        requiresEndTag ? std::ranges::find_if(it_ + 1, end_, [](Comment const* c)
+        requiresEndTag ? std::ranges::find_if(it_ + 1, end_, [](clang::comments::Comment const* c)
         {
-            return c->getCommentKind() == CommentKind::HTMLEndTagComment;
+            return c->getCommentKind() == clang::comments::CommentKind::HTMLEndTagComment;
         }) : it_;
     if (tagEndIt == end_)
     {
@@ -780,7 +778,7 @@ parseHTMLTag(HTMLStartTagComment const* C)
 
     // Check if end tag matches start tag
     auto const& cEndTag =
-        *static_cast<HTMLEndTagComment const*>(*tagEndIt);
+        *static_cast<clang::comments::HTMLEndTagComment const*>(*tagEndIt);
     if(cEndTag.getTagName() != res.tag)
     {
       return Unexpected(Error(std::format(
@@ -789,9 +787,9 @@ parseHTMLTag(HTMLStartTagComment const* C)
     }
 
     // Check if all the siblings are text nodes
-    bool const areAllText = std::all_of(it_ + 1, tagEndIt, [](Comment const* c)
+    bool const areAllText = std::all_of(it_ + 1, tagEndIt, [](clang::comments::Comment const* c)
     {
-        return c->getCommentKind() == CommentKind::TextComment;
+        return c->getCommentKind() == clang::comments::CommentKind::TextComment;
     });
     if (!areAllText)
     {
@@ -804,7 +802,7 @@ parseHTMLTag(HTMLStartTagComment const* C)
     for (auto it = std::next(it_); it != tagEndIt; ++it)
     {
         auto const& cText =
-            *static_cast<TextComment const*>(*it);
+            *static_cast<clang::comments::TextComment const*>(*it);
         res.text += cText.getText();
     }
 
@@ -814,14 +812,14 @@ parseHTMLTag(HTMLStartTagComment const* C)
 void
 JavadocVisitor::
 visitHTMLStartTagComment(
-    HTMLStartTagComment const* C)
+    clang::comments::HTMLStartTagComment const* C)
 {
     MRDOCS_COMMENT_TRACE(C, ctx_);
     MRDOCS_ASSERT(C->child_begin() == C->child_end());
-    PresumedLoc const loc = sm_.getPresumedLoc(C->getBeginLoc());
+    clang::PresumedLoc const loc = sm_.getPresumedLoc(C->getBeginLoc());
     auto filename = files::makePosixStyle(loc.getFilename());
 
-    auto getAttribute = [&C](StringRef name) -> Expected<std::string>
+    auto getAttribute = [&C](llvm::StringRef name) -> Expected<std::string>
     {
         auto idxs = std::views::iota(unsigned(0), C->getNumAttrs());
         auto attr_it = std::ranges::find_if(idxs, [&C, name](std::size_t i)
@@ -885,7 +883,7 @@ visitHTMLStartTagComment(
 void
 JavadocVisitor::
 visitHTMLEndTagComment(
-    HTMLEndTagComment const* C)
+    clang::comments::HTMLEndTagComment const* C)
 {
     MRDOCS_COMMENT_TRACE(C, ctx_);
     MRDOCS_ASSERT(C->child_begin() == C->child_end());
@@ -898,11 +896,11 @@ convertCopydoc(unsigned id)
 {
     switch(id)
     {
-    case CommandTraits::KCI_copydoc:
+    case clang::comments::CommandTraits::KCI_copydoc:
         return doc::Parts::all;
-    case CommandTraits::KCI_copybrief:
+    case clang::comments::CommandTraits::KCI_copybrief:
         return doc::Parts::brief;
-    case CommandTraits::KCI_copydetails:
+    case clang::comments::CommandTraits::KCI_copydetails:
         return doc::Parts::description;
     default:
     {
@@ -914,40 +912,40 @@ convertCopydoc(unsigned id)
 
 static
 doc::Style
-convertStyle(InlineCommandRenderKind kind)
+convertStyle(clang::comments::InlineCommandRenderKind kind)
 {
     switch(kind)
     {
-    case InlineCommandRenderKind::Monospaced:
+    case clang::comments::InlineCommandRenderKind::Monospaced:
         return doc::Style::mono;
-    case InlineCommandRenderKind::Bold:
+    case clang::comments::InlineCommandRenderKind::Bold:
         return doc::Style::bold;
-    case InlineCommandRenderKind::Emphasized:
+    case clang::comments::InlineCommandRenderKind::Emphasized:
         return doc::Style::italic;
-    case InlineCommandRenderKind::Normal:
-    case InlineCommandRenderKind::Anchor:
+    case clang::comments::InlineCommandRenderKind::Normal:
+    case clang::comments::InlineCommandRenderKind::Anchor:
         return doc::Style::none;
     default:
         // unknown RenderKind
-        report::error("error: unsupported InlineCommandRenderKind <{}>", static_cast<int>(kind));
+        report::error("error: unsupported clang::comments::InlineCommandRenderKind <{}>", static_cast<int>(kind));
         MRDOCS_UNREACHABLE();
     }
 }
 
 static
 doc::ParamDirection
-convertDirection(ParamCommandPassDirection kind)
+convertDirection(clang::comments::ParamCommandPassDirection kind)
 {
     switch(kind)
     {
-    case ParamCommandPassDirection::In:
+    case clang::comments::ParamCommandPassDirection::In:
         return doc::ParamDirection::in;
-    case ParamCommandPassDirection::Out:
+    case clang::comments::ParamCommandPassDirection::Out:
         return doc::ParamDirection::out;
-    case ParamCommandPassDirection::InOut:
+    case clang::comments::ParamCommandPassDirection::InOut:
         return doc::ParamDirection::inout;
     default:
-        report::error("error: unsupported ParamCommandPassDirection <{}>", static_cast<int>(kind));
+        report::error("error: unsupported clang::comments::ParamCommandPassDirection <{}>", static_cast<int>(kind));
         MRDOCS_UNREACHABLE();
     }
 }
@@ -955,7 +953,7 @@ convertDirection(ParamCommandPassDirection kind)
 void
 JavadocVisitor::
 visitInlineCommandComment(
-    InlineCommandComment const* C)
+    clang::comments::InlineCommandComment const* C)
 {
     MRDOCS_COMMENT_TRACE(C, ctx_);
     auto const* cmd = ctx_
@@ -968,7 +966,7 @@ visitInlineCommandComment(
     switch(unsigned ID = cmd->getID())
     {
     // Newline
-    case CommandTraits::KCI_n:
+    case clang::comments::CommandTraits::KCI_n:
     {
         if(! goodArgCount(0, *C))
             return;
@@ -977,9 +975,9 @@ visitInlineCommandComment(
         return;
     }
     // Emphasis
-    case CommandTraits::KCI_a:
-    case CommandTraits::KCI_e:
-    case CommandTraits::KCI_em:
+    case clang::comments::CommandTraits::KCI_a:
+    case clang::comments::CommandTraits::KCI_e:
+    case clang::comments::CommandTraits::KCI_em:
     {
         MRDOCS_CHECK_OR(goodArgCount(1, *C));
         auto style = doc::Style::italic;
@@ -991,9 +989,9 @@ visitInlineCommandComment(
     }
 
     // copy
-    case CommandTraits::KCI_copybrief:
-    case CommandTraits::KCI_copydetails:
-    case CommandTraits::KCI_copydoc:
+    case clang::comments::CommandTraits::KCI_copybrief:
+    case clang::comments::CommandTraits::KCI_copydetails:
+    case clang::comments::CommandTraits::KCI_copydoc:
     {
         MRDOCS_CHECK_OR(goodArgCount(1, *C));
         std::string ref = C->getArgText(0).str();
@@ -1031,7 +1029,7 @@ visitInlineCommandComment(
         }
         return;
     }
-    case CommandTraits::KCI_ref:
+    case clang::comments::CommandTraits::KCI_ref:
     {
         MRDOCS_CHECK_OR(goodArgCount(1, *C));
         std::string ref = C->getArgText(0).str();
@@ -1049,15 +1047,15 @@ visitInlineCommandComment(
         return;
     }
     // KRYSTIAN FIXME: these need to be made inline commands in clang
-    case CommandTraits::KCI_related:
-    case CommandTraits::KCI_relates:
+    case clang::comments::CommandTraits::KCI_related:
+    case clang::comments::CommandTraits::KCI_relates:
     // MrDocs doesn't document members inline, so there's no
     // distinction between "related" and "relatedalso"
-    case CommandTraits::KCI_relatedalso:
-    case CommandTraits::KCI_relatesalso:
+    case clang::comments::CommandTraits::KCI_relatedalso:
+    case clang::comments::CommandTraits::KCI_relatesalso:
     // Member of is a concept used only in C. MrDocs handles
     // it as a non-member function is all cases.
-    case CommandTraits::KCI_memberof:
+    case clang::comments::CommandTraits::KCI_memberof:
     {
         MRDOCS_CHECK_OR(goodArgCount(1, *C));
         std::string ref = C->getArgText(0).str();
@@ -1110,13 +1108,13 @@ fixReference(std::string& ref)
     {
         ++it_;
         if (it_ == end_ ||
-            (*it_)->getCommentKind() != CommentKind::TextComment)
+            (*it_)->getCommentKind() != clang::comments::CommentKind::TextComment)
         {
             --it_;
             return std::nullopt;
         }
-        Comment const* c = *it_;
-        std::string_view text = static_cast<TextComment const*>(c)->getText();
+        clang::comments::Comment const* c = *it_;
+        std::string_view text = static_cast<clang::comments::TextComment const*>(c)->getText();
         --it_;
         return text;
     };
@@ -1252,7 +1250,7 @@ fixReference(std::string& ref)
 void
 JavadocVisitor::
 visitParagraphComment(
-    ParagraphComment const* C)
+    clang::comments::ParagraphComment const* C)
 {
     MRDOCS_COMMENT_TRACE(C, ctx_);
     if(block_)
@@ -1268,7 +1266,7 @@ visitParagraphComment(
 void
 JavadocVisitor::
 visitBlockCommandComment(
-    BlockCommandComment const* C)
+    clang::comments::BlockCommandComment const* C)
 {
     MRDOCS_COMMENT_TRACE(C, ctx_);
     auto const* cmd = ctx_
@@ -1283,8 +1281,8 @@ visitBlockCommandComment(
 
     switch(cmd->getID())
     {
-    case CommandTraits::KCI_brief:
-    case CommandTraits::KCI_short:
+    case clang::comments::CommandTraits::KCI_brief:
+    case clang::comments::CommandTraits::KCI_short:
     {
         doc::Brief brief;
         auto scope = enterScope(brief);
@@ -1299,9 +1297,9 @@ visitBlockCommandComment(
         return;
     }
 
-    case CommandTraits::KCI_return:
-    case CommandTraits::KCI_returns:
-    case CommandTraits::KCI_result:
+    case clang::comments::CommandTraits::KCI_return:
+    case clang::comments::CommandTraits::KCI_returns:
+    case clang::comments::CommandTraits::KCI_result:
     {
         doc::Returns returns;
         auto scope = enterScope(returns);
@@ -1314,9 +1312,9 @@ visitBlockCommandComment(
         }
         return;
     }
-    case CommandTraits::KCI_throw:
-    case CommandTraits::KCI_throws:
-    case CommandTraits::KCI_exception:
+    case clang::comments::CommandTraits::KCI_throw:
+    case clang::comments::CommandTraits::KCI_throws:
+    case clang::comments::CommandTraits::KCI_exception:
     {
         doc::Throws throws;
         auto scope = enterScope(throws);
@@ -1332,10 +1330,10 @@ visitBlockCommandComment(
         jd_.exceptions.push_back(std::move(throws));
         return;
     }
-    case CommandTraits::KCI_note:
-    case CommandTraits::KCI_warning:
+    case clang::comments::CommandTraits::KCI_note:
+    case clang::comments::CommandTraits::KCI_warning:
     {
-        doc::Admonish admonish = cmd->getID() == CommandTraits::KCI_note
+        doc::Admonish admonish = cmd->getID() == clang::comments::CommandTraits::KCI_note
             ? doc::Admonish::note
             : doc::Admonish::warning;
         doc::Admonition paragraph(admonish);
@@ -1344,7 +1342,7 @@ visitBlockCommandComment(
         jd_.emplace_back(std::move(paragraph));
         return;
     }
-    case CommandTraits::KCI_par:
+    case clang::comments::CommandTraits::KCI_par:
     {
         // VFALCO This is legacy compatibility
         // for Boost libraries using @par as a
@@ -1387,7 +1385,7 @@ visitBlockCommandComment(
         }
         return;
     }
-    case CommandTraits::KCI_li:
+    case clang::comments::CommandTraits::KCI_li:
     {
         doc::ListItem paragraph;
         auto scope = enterScope(paragraph);
@@ -1395,7 +1393,7 @@ visitBlockCommandComment(
         jd_.emplace_back(std::move(paragraph));
         return;
     }
-    case CommandTraits::KCI_details:
+    case clang::comments::CommandTraits::KCI_details:
     {
         doc::Paragraph paragraph;
         auto scope = enterScope(paragraph);
@@ -1403,7 +1401,7 @@ visitBlockCommandComment(
         jd_.emplace_back(std::move(paragraph));
         return;
     }
-    case CommandTraits::KCI_see:
+    case clang::comments::CommandTraits::KCI_see:
     {
         doc::See see;
         auto scope = enterScope(see);
@@ -1411,7 +1409,7 @@ visitBlockCommandComment(
         jd_.sees.push_back(std::move(see));
         return;
     }
-    case CommandTraits::KCI_pre:
+    case clang::comments::CommandTraits::KCI_pre:
     {
         doc::Precondition pre;
         auto scope = enterScope(pre);
@@ -1419,7 +1417,7 @@ visitBlockCommandComment(
         jd_.preconditions.push_back(std::move(pre));
         return;
     }
-    case CommandTraits::KCI_post:
+    case clang::comments::CommandTraits::KCI_post:
     {
         doc::Postcondition post;
         auto scope = enterScope(post);
@@ -1428,170 +1426,170 @@ visitBlockCommandComment(
         return;
     }
 
-    case CommandTraits::KCI_addindex:
-    case CommandTraits::KCI_addtogroup:
-    case CommandTraits::KCI_anchor:
-    case CommandTraits::KCI_arg:
-    case CommandTraits::KCI_attention:
-    case CommandTraits::KCI_author:
-    case CommandTraits::KCI_authors:
-    case CommandTraits::KCI_b:
-    case CommandTraits::KCI_bug:
-    case CommandTraits::KCI_c:
-    case CommandTraits::KCI_callergraph:
-    case CommandTraits::KCI_callgraph:
-    case CommandTraits::KCI_category:
-    case CommandTraits::KCI_cite:
-    case CommandTraits::KCI_class:
-    case CommandTraits::KCI_code:
-    case CommandTraits::KCI_concept:
-    case CommandTraits::KCI_cond:
-    case CommandTraits::KCI_copyright:
-    case CommandTraits::KCI_date:
-    case CommandTraits::KCI_def:
-    case CommandTraits::KCI_defgroup:
-    case CommandTraits::KCI_deprecated:
-    case CommandTraits::KCI_diafile:
-    case CommandTraits::KCI_dir:
-    case CommandTraits::KCI_docbookinclude:
-    case CommandTraits::KCI_docbookonly:
-    case CommandTraits::KCI_dontinclude:
-    case CommandTraits::KCI_dot:
-    case CommandTraits::KCI_dotfile:
-    //case CommandTraits::KCI_doxyconfig:
-    case CommandTraits::KCI_else:
-    case CommandTraits::KCI_elseif:
-    case CommandTraits::KCI_emoji:
-    case CommandTraits::KCI_endcode:
-    case CommandTraits::KCI_endcond:
-    case CommandTraits::KCI_enddocbookonly:
-    case CommandTraits::KCI_enddot:
-    case CommandTraits::KCI_endhtmlonly:
-    case CommandTraits::KCI_endif:
-    case CommandTraits::KCI_endinternal:
-    case CommandTraits::KCI_endlatexonly:
-    //case CommandTraits::KCI_endlink:
-    case CommandTraits::KCI_endmanonly:
-    case CommandTraits::KCI_endmsc:
-    case CommandTraits::KCI_endparblock:
-    case CommandTraits::KCI_endrtfonly:
-    case CommandTraits::KCI_endsecreflist:
-    case CommandTraits::KCI_endverbatim:
-    case CommandTraits::KCI_enduml:
-    case CommandTraits::KCI_endxmlonly:
-    case CommandTraits::KCI_enum:
-    case CommandTraits::KCI_example:
-    case CommandTraits::KCI_extends:
-    case CommandTraits::KCI_flparen:  // @f(
-    case CommandTraits::KCI_frparen:  // @f)
-    case CommandTraits::KCI_fdollar:  // @f$
-    case CommandTraits::KCI_flsquare: // @f[
-    case CommandTraits::KCI_frsquare: // @f]
-    case CommandTraits::KCI_flbrace:  // @f{
-    case CommandTraits::KCI_frbrace:  // @f}
-    case CommandTraits::KCI_file:
-    //case CommandTraits::KCI_fileinfo:
-    case CommandTraits::KCI_fn:
-    case CommandTraits::KCI_headerfile:
-    case CommandTraits::KCI_hidecallergraph:
-    case CommandTraits::KCI_hidecallgraph:
-    case CommandTraits::KCI_hiderefby:
-    case CommandTraits::KCI_hiderefs:
-    case CommandTraits::KCI_hideinitializer:
-    case CommandTraits::KCI_htmlinclude:
-    case CommandTraits::KCI_htmlonly:
-    case CommandTraits::KCI_idlexcept:
-    case CommandTraits::KCI_if:
-    case CommandTraits::KCI_ifnot:
-    case CommandTraits::KCI_image:
-    case CommandTraits::KCI_implements:
-    case CommandTraits::KCI_include:
-    //case CommandTraits::KCI_includedoc:
-    //case CommandTraits::KCI_includelineno:
-    case CommandTraits::KCI_ingroup:
-    case CommandTraits::KCI_internal:
-    case CommandTraits::KCI_invariant:
-    case CommandTraits::KCI_interface:
-    case CommandTraits::KCI_latexinclude:
-    case CommandTraits::KCI_latexonly:
-    case CommandTraits::KCI_line:
-    //case CommandTraits::KCI_lineinfo:
-    case CommandTraits::KCI_link:
-    case CommandTraits::KCI_mainpage:
-    case CommandTraits::KCI_maninclude:
-    case CommandTraits::KCI_manonly:
-    case CommandTraits::KCI_memberof:
-    case CommandTraits::KCI_msc:
-    case CommandTraits::KCI_mscfile:
-    case CommandTraits::KCI_name:
-    case CommandTraits::KCI_namespace:
-    case CommandTraits::KCI_noop:
-    case CommandTraits::KCI_nosubgrouping:
-    case CommandTraits::KCI_overload:
-    case CommandTraits::KCI_p:
-    //case CommandTraits::KCI_package:
-    case CommandTraits::KCI_page:
-    case CommandTraits::KCI_paragraph:
-    case CommandTraits::KCI_param:
-    case CommandTraits::KCI_parblock:
-    case CommandTraits::KCI_private:
-    case CommandTraits::KCI_privatesection:
-    case CommandTraits::KCI_property:
-    case CommandTraits::KCI_protected:
-    case CommandTraits::KCI_protectedsection:
-    case CommandTraits::KCI_protocol:
-    case CommandTraits::KCI_public:
-    case CommandTraits::KCI_publicsection:
-    case CommandTraits::KCI_pure:
-    //case CommandTraits::KCI_qualifier:
-    //case CommandTraits::KCI_raisewarning:
-    case CommandTraits::KCI_ref:
-    case CommandTraits::KCI_refitem:
-    case CommandTraits::KCI_related:
-    case CommandTraits::KCI_relates:
-    case CommandTraits::KCI_relatedalso:
-    case CommandTraits::KCI_relatesalso:
-    case CommandTraits::KCI_remark:
-    case CommandTraits::KCI_remarks:
-
-    case CommandTraits::KCI_retval:
-    case CommandTraits::KCI_rtfinclude:
-    case CommandTraits::KCI_rtfonly:
-    case CommandTraits::KCI_sa:
-    case CommandTraits::KCI_secreflist:
-    case CommandTraits::KCI_section:
-    //case CommandTraits::KCI_showdate:
-    case CommandTraits::KCI_showinitializer:
-    case CommandTraits::KCI_showrefby:
-    case CommandTraits::KCI_showrefs:
-    case CommandTraits::KCI_since:
-    case CommandTraits::KCI_skip:
-    case CommandTraits::KCI_skipline:
-    case CommandTraits::KCI_snippet:
-    //case CommandTraits::KCI_snippetdoc:
-    //case CommandTraits::KCI_snippetlineno:
-    case CommandTraits::KCI_static:
-    case CommandTraits::KCI_startuml:
-    case CommandTraits::KCI_struct:
-    case CommandTraits::KCI_subpage:
-    case CommandTraits::KCI_subsection:
-    case CommandTraits::KCI_subsubsection:
-    case CommandTraits::KCI_tableofcontents:
-    case CommandTraits::KCI_test:
-    case CommandTraits::KCI_todo:
-    case CommandTraits::KCI_tparam:
-    case CommandTraits::KCI_typedef:
-    case CommandTraits::KCI_union:
-    case CommandTraits::KCI_until:
-    case CommandTraits::KCI_var:
-    case CommandTraits::KCI_verbatim:
-    case CommandTraits::KCI_verbinclude:
-    case CommandTraits::KCI_version:
-    //case CommandTraits::KCI_vhdlflow:
-    case CommandTraits::KCI_weakgroup:
-    case CommandTraits::KCI_xmlinclude:
-    case CommandTraits::KCI_xmlonly:
-    case CommandTraits::KCI_xrefitem:
+    case clang::comments::CommandTraits::KCI_addindex:
+    case clang::comments::CommandTraits::KCI_addtogroup:
+    case clang::comments::CommandTraits::KCI_anchor:
+    case clang::comments::CommandTraits::KCI_arg:
+    case clang::comments::CommandTraits::KCI_attention:
+    case clang::comments::CommandTraits::KCI_author:
+    case clang::comments::CommandTraits::KCI_authors:
+    case clang::comments::CommandTraits::KCI_b:
+    case clang::comments::CommandTraits::KCI_bug:
+    case clang::comments::CommandTraits::KCI_c:
+    case clang::comments::CommandTraits::KCI_callergraph:
+    case clang::comments::CommandTraits::KCI_callgraph:
+    case clang::comments::CommandTraits::KCI_category:
+    case clang::comments::CommandTraits::KCI_cite:
+    case clang::comments::CommandTraits::KCI_class:
+    case clang::comments::CommandTraits::KCI_code:
+    case clang::comments::CommandTraits::KCI_concept:
+    case clang::comments::CommandTraits::KCI_cond:
+    case clang::comments::CommandTraits::KCI_copyright:
+    case clang::comments::CommandTraits::KCI_date:
+    case clang::comments::CommandTraits::KCI_def:
+    case clang::comments::CommandTraits::KCI_defgroup:
+    case clang::comments::CommandTraits::KCI_deprecated:
+    case clang::comments::CommandTraits::KCI_diafile:
+    case clang::comments::CommandTraits::KCI_dir:
+    case clang::comments::CommandTraits::KCI_docbookinclude:
+    case clang::comments::CommandTraits::KCI_docbookonly:
+    case clang::comments::CommandTraits::KCI_dontinclude:
+    case clang::comments::CommandTraits::KCI_dot:
+    case clang::comments::CommandTraits::KCI_dotfile:
+    //case clang::comments::CommandTraits::KCI_doxyconfig:
+    case clang::comments::CommandTraits::KCI_else:
+    case clang::comments::CommandTraits::KCI_elseif:
+    case clang::comments::CommandTraits::KCI_emoji:
+    case clang::comments::CommandTraits::KCI_endcode:
+    case clang::comments::CommandTraits::KCI_endcond:
+    case clang::comments::CommandTraits::KCI_enddocbookonly:
+    case clang::comments::CommandTraits::KCI_enddot:
+    case clang::comments::CommandTraits::KCI_endhtmlonly:
+    case clang::comments::CommandTraits::KCI_endif:
+    case clang::comments::CommandTraits::KCI_endinternal:
+    case clang::comments::CommandTraits::KCI_endlatexonly:
+    //case clang::comments::CommandTraits::KCI_endlink:
+    case clang::comments::CommandTraits::KCI_endmanonly:
+    case clang::comments::CommandTraits::KCI_endmsc:
+    case clang::comments::CommandTraits::KCI_endparblock:
+    case clang::comments::CommandTraits::KCI_endrtfonly:
+    case clang::comments::CommandTraits::KCI_endsecreflist:
+    case clang::comments::CommandTraits::KCI_endverbatim:
+    case clang::comments::CommandTraits::KCI_enduml:
+    case clang::comments::CommandTraits::KCI_endxmlonly:
+    case clang::comments::CommandTraits::KCI_enum:
+    case clang::comments::CommandTraits::KCI_example:
+    case clang::comments::CommandTraits::KCI_extends:
+    case clang::comments::CommandTraits::KCI_flparen:  // @f(
+    case clang::comments::CommandTraits::KCI_frparen:  // @f)
+    case clang::comments::CommandTraits::KCI_fdollar:  // @f$
+    case clang::comments::CommandTraits::KCI_flsquare: // @f[
+    case clang::comments::CommandTraits::KCI_frsquare: // @f]
+    case clang::comments::CommandTraits::KCI_flbrace:  // @f{
+    case clang::comments::CommandTraits::KCI_frbrace:  // @f}
+    case clang::comments::CommandTraits::KCI_file:
+    //case clang::comments::CommandTraits::KCI_fileinfo:
+    case clang::comments::CommandTraits::KCI_fn:
+    case clang::comments::CommandTraits::KCI_headerfile:
+    case clang::comments::CommandTraits::KCI_hidecallergraph:
+    case clang::comments::CommandTraits::KCI_hidecallgraph:
+    case clang::comments::CommandTraits::KCI_hiderefby:
+    case clang::comments::CommandTraits::KCI_hiderefs:
+    case clang::comments::CommandTraits::KCI_hideinitializer:
+    case clang::comments::CommandTraits::KCI_htmlinclude:
+    case clang::comments::CommandTraits::KCI_htmlonly:
+    case clang::comments::CommandTraits::KCI_idlexcept:
+    case clang::comments::CommandTraits::KCI_if:
+    case clang::comments::CommandTraits::KCI_ifnot:
+    case clang::comments::CommandTraits::KCI_image:
+    case clang::comments::CommandTraits::KCI_implements:
+    case clang::comments::CommandTraits::KCI_include:
+    //case clang::comments::CommandTraits::KCI_includedoc:
+    //case clang::comments::CommandTraits::KCI_includelineno:
+    case clang::comments::CommandTraits::KCI_ingroup:
+    case clang::comments::CommandTraits::KCI_internal:
+    case clang::comments::CommandTraits::KCI_invariant:
+    case clang::comments::CommandTraits::KCI_interface:
+    case clang::comments::CommandTraits::KCI_latexinclude:
+    case clang::comments::CommandTraits::KCI_latexonly:
+    case clang::comments::CommandTraits::KCI_line:
+    //case clang::comments::CommandTraits::KCI_lineinfo:
+    case clang::comments::CommandTraits::KCI_link:
+    case clang::comments::CommandTraits::KCI_mainpage:
+    case clang::comments::CommandTraits::KCI_maninclude:
+    case clang::comments::CommandTraits::KCI_manonly:
+    case clang::comments::CommandTraits::KCI_memberof:
+    case clang::comments::CommandTraits::KCI_msc:
+    case clang::comments::CommandTraits::KCI_mscfile:
+    case clang::comments::CommandTraits::KCI_name:
+    case clang::comments::CommandTraits::KCI_namespace:
+    case clang::comments::CommandTraits::KCI_noop:
+    case clang::comments::CommandTraits::KCI_nosubgrouping:
+    case clang::comments::CommandTraits::KCI_overload:
+    case clang::comments::CommandTraits::KCI_p:
+    //case clang::comments::CommandTraits::KCI_package:
+    case clang::comments::CommandTraits::KCI_page:
+    case clang::comments::CommandTraits::KCI_paragraph:
+    case clang::comments::CommandTraits::KCI_param:
+    case clang::comments::CommandTraits::KCI_parblock:
+    case clang::comments::CommandTraits::KCI_private:
+    case clang::comments::CommandTraits::KCI_privatesection:
+    case clang::comments::CommandTraits::KCI_property:
+    case clang::comments::CommandTraits::KCI_protected:
+    case clang::comments::CommandTraits::KCI_protectedsection:
+    case clang::comments::CommandTraits::KCI_protocol:
+    case clang::comments::CommandTraits::KCI_public:
+    case clang::comments::CommandTraits::KCI_publicsection:
+    case clang::comments::CommandTraits::KCI_pure:
+    //case clang::comments::CommandTraits::KCI_qualifier:
+    //case clang::comments::CommandTraits::KCI_raisewarning:
+    case clang::comments::CommandTraits::KCI_ref:
+    case clang::comments::CommandTraits::KCI_refitem:
+    case clang::comments::CommandTraits::KCI_related:
+    case clang::comments::CommandTraits::KCI_relates:
+    case clang::comments::CommandTraits::KCI_relatedalso:
+    case clang::comments::CommandTraits::KCI_relatesalso:
+    case clang::comments::CommandTraits::KCI_remark:
+    case clang::comments::CommandTraits::KCI_remarks:
+
+    case clang::comments::CommandTraits::KCI_retval:
+    case clang::comments::CommandTraits::KCI_rtfinclude:
+    case clang::comments::CommandTraits::KCI_rtfonly:
+    case clang::comments::CommandTraits::KCI_sa:
+    case clang::comments::CommandTraits::KCI_secreflist:
+    case clang::comments::CommandTraits::KCI_section:
+    //case clang::comments::CommandTraits::KCI_showdate:
+    case clang::comments::CommandTraits::KCI_showinitializer:
+    case clang::comments::CommandTraits::KCI_showrefby:
+    case clang::comments::CommandTraits::KCI_showrefs:
+    case clang::comments::CommandTraits::KCI_since:
+    case clang::comments::CommandTraits::KCI_skip:
+    case clang::comments::CommandTraits::KCI_skipline:
+    case clang::comments::CommandTraits::KCI_snippet:
+    //case clang::comments::CommandTraits::KCI_snippetdoc:
+    //case clang::comments::CommandTraits::KCI_snippetlineno:
+    case clang::comments::CommandTraits::KCI_static:
+    case clang::comments::CommandTraits::KCI_startuml:
+    case clang::comments::CommandTraits::KCI_struct:
+    case clang::comments::CommandTraits::KCI_subpage:
+    case clang::comments::CommandTraits::KCI_subsection:
+    case clang::comments::CommandTraits::KCI_subsubsection:
+    case clang::comments::CommandTraits::KCI_tableofcontents:
+    case clang::comments::CommandTraits::KCI_test:
+    case clang::comments::CommandTraits::KCI_todo:
+    case clang::comments::CommandTraits::KCI_tparam:
+    case clang::comments::CommandTraits::KCI_typedef:
+    case clang::comments::CommandTraits::KCI_union:
+    case clang::comments::CommandTraits::KCI_until:
+    case clang::comments::CommandTraits::KCI_var:
+    case clang::comments::CommandTraits::KCI_verbatim:
+    case clang::comments::CommandTraits::KCI_verbinclude:
+    case clang::comments::CommandTraits::KCI_version:
+    //case clang::comments::CommandTraits::KCI_vhdlflow:
+    case clang::comments::CommandTraits::KCI_weakgroup:
+    case clang::comments::CommandTraits::KCI_xmlinclude:
+    case clang::comments::CommandTraits::KCI_xmlonly:
+    case clang::comments::CommandTraits::KCI_xrefitem:
     /*
         @$
         @@
@@ -1613,13 +1611,13 @@ visitBlockCommandComment(
         break;
 
     // inline commands handled elsewhere
-    case CommandTraits::KCI_a:
-    case CommandTraits::KCI_e:
-    case CommandTraits::KCI_em:
-    case CommandTraits::KCI_n:
-    case CommandTraits::KCI_copybrief:
-    case CommandTraits::KCI_copydetails:
-    case CommandTraits::KCI_copydoc:
+    case clang::comments::CommandTraits::KCI_a:
+    case clang::comments::CommandTraits::KCI_e:
+    case clang::comments::CommandTraits::KCI_em:
+    case clang::comments::CommandTraits::KCI_n:
+    case clang::comments::CommandTraits::KCI_copybrief:
+    case clang::comments::CommandTraits::KCI_copydetails:
+        case clang::comments::CommandTraits::KCI_copydoc:
         report::error("error: inline command {} should be handled elsewhere", cmd->Name);
         MRDOCS_UNREACHABLE();
     default:
@@ -1631,7 +1629,7 @@ visitBlockCommandComment(
 void
 JavadocVisitor::
 visitParamCommandComment(
-    ParamCommandComment const* C)
+    clang::comments::ParamCommandComment const* C)
 {
     MRDOCS_COMMENT_TRACE(C, ctx_);
     doc::Param param;
@@ -1677,7 +1675,7 @@ visitParamCommandComment(
 void
 JavadocVisitor::
 visitTParamCommandComment(
-    TParamCommandComment const* C)
+    clang::comments::TParamCommandComment const* C)
 {
     MRDOCS_COMMENT_TRACE(C, ctx_);
     doc::TParam tparam;
@@ -1720,7 +1718,7 @@ visitTParamCommandComment(
 void
 JavadocVisitor::
 visitVerbatimBlockComment(
-    VerbatimBlockComment const* C)
+    clang::comments::VerbatimBlockComment const* C)
 {
     MRDOCS_COMMENT_TRACE(C, ctx_);
     doc::Code code;
@@ -1733,7 +1731,7 @@ visitVerbatimBlockComment(
 void
 JavadocVisitor::
 visitVerbatimLineComment(
-    VerbatimLineComment const* C)
+    clang::comments::VerbatimLineComment const* C)
 {
     MRDOCS_COMMENT_TRACE(C, ctx_);
     // VFALCO This doesn't seem to be used
@@ -1743,7 +1741,7 @@ visitVerbatimLineComment(
 void
 JavadocVisitor::
 visitVerbatimBlockLineComment(
-    VerbatimBlockLineComment const* C)
+    clang::comments::VerbatimBlockLineComment const* C)
 {
     MRDOCS_COMMENT_TRACE(C, ctx_);
     emplaceText<doc::Text>(true, C->getText().str());
@@ -1754,7 +1752,7 @@ visitVerbatimBlockLineComment(
 bool
 JavadocVisitor::
 goodArgCount(std::size_t n,
-    InlineCommandComment const& C)
+    clang::comments::InlineCommandComment const& C)
 {
     MRDOCS_COMMENT_TRACE(C, ctx_);
     if(C.getNumArgs() != n)
@@ -1776,7 +1774,7 @@ goodArgCount(std::size_t n,
 } // (anon)
 
 void
-initCustomCommentCommands(ASTContext& context)
+initCustomCommentCommands(clang::ASTContext& context)
 {
     auto& traits = context.getCommentCommandTraits();
 
@@ -1795,8 +1793,8 @@ initCustomCommentCommands(ASTContext& context)
 void
 parseJavadoc(
     Optional<Javadoc>& jd,
-    FullComment const* FC,
-    Decl const* D,
+    clang::comments::FullComment const* FC,
+    clang::Decl const* D,
     Config const& config,
     Diagnostics& diags)
 {
@@ -1818,4 +1816,4 @@ parseJavadoc(
 
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/AST/ParseJavadoc.hpp b/src/lib/AST/ParseJavadoc.hpp
index ff18d72b3..e6d744ee3 100644
--- a/src/lib/AST/ParseJavadoc.hpp
+++ b/src/lib/AST/ParseJavadoc.hpp
@@ -18,14 +18,13 @@
 #include <mrdocs/Metadata/Javadoc.hpp>
 
 namespace clang {
-
 class Decl;
 class ASTContext;
 class RawComment;
-
 namespace comments {
-  class FullComment;
+class FullComment;
 } // comments
+} // clang
 
 namespace mrdocs {
 
@@ -36,7 +35,7 @@ namespace mrdocs {
 */
 void
 initCustomCommentCommands(
-    ASTContext& ctx);
+    clang::ASTContext& ctx);
 
 /** Parse doc comments from a declaration
 
@@ -52,12 +51,12 @@ initCustomCommentCommands(
 void
 parseJavadoc(
     Optional<Javadoc>& jd,
-    comments::FullComment const* FC,
-    Decl const* D,
+    clang::comments::FullComment const* FC,
+    clang::Decl const* D,
     Config const& config,
     Diagnostics& diags);
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_LIB_AST_PARSEJAVADOC_HPP
diff --git a/src/lib/AST/ParseRef.cpp b/src/lib/AST/ParseRef.cpp
index 5d8a30cf1..726be5344 100644
--- a/src/lib/AST/ParseRef.cpp
+++ b/src/lib/AST/ParseRef.cpp
@@ -9,8 +9,8 @@
 //
 
 #include <lib/AST/ParseRef.hpp>
-#include <mrdocs/Metadata/Info/Function.hpp>
 #include <mrdocs/Metadata/Name.hpp>
+#include <mrdocs/Metadata/Symbol/Function.hpp>
 #include <mrdocs/Metadata/Type.hpp>
 #include <mrdocs/Support/Algorithm.hpp>
 #include <mrdocs/Support/Expected.hpp>
@@ -18,7 +18,7 @@
 #include <llvm/ADT/StringExtras.h>
 #include <format>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 namespace {
 constexpr
@@ -56,7 +56,7 @@ struct ParsedFunctionSuffix
     /* List of parsed function parameter types.
        Example: For 'void foo(int, double)', Params contains 'int' and 'double'.
     */
-    llvm::SmallVector<Polymorphic<TypeInfo>, 8> Params;
+    llvm::SmallVector<Polymorphic<Type>, 8> Params;
 
     /* True if the parameter list contains only 'void'.
        Example: For 'void foo(void)', HasVoid is true.
@@ -473,7 +473,7 @@ class RefParser
             return false;
         }
         skipWhitespace();
-        Optional<Polymorphic<TypeInfo>> conversionType = std::nullopt;
+        Optional<Polymorphic<Type>> conversionType = std::nullopt;
         if (!parseDeclarationSpecifier(conversionType) ||
             !conversionType)
         {
@@ -650,7 +650,7 @@ class RefParser
         }
         skipWhitespace();
         char const* start = ptr_;
-        Optional<Polymorphic<TypeInfo>> type = std::nullopt;
+        Optional<Polymorphic<Type>> type = std::nullopt;
         if (parseTypeId(type))
         {
             MRDOCS_ASSERT(type);
@@ -819,7 +819,7 @@ class RefParser
 
         // https://en.cppreference.com/w/cpp/language/function#Parameter_list
         // decl-specifier-seq
-        Optional<Polymorphic<TypeInfo>> curParamOpt = std::nullopt;
+        Optional<Polymorphic<Type>> curParamOpt = std::nullopt;
         if (!parseTypeId(curParamOpt))
         {
             ptr_ = start;
@@ -835,8 +835,8 @@ class RefParser
         // https://en.cppreference.com/w/cpp/language/function#Function_type
         if (curParam->isArray())
         {
-            ArrayTypeInfo PrevParamType = curParam->asArray();
-            curParam = Polymorphic<TypeInfo>(std::in_place_type<PointerTypeInfo>);
+            ArrayType PrevParamType = curParam->asArray();
+            curParam = Polymorphic<Type>(std::in_place_type<PointerType>);
             auto& curAsPointerType = curParam->asPointer();
             curAsPointerType.PointeeType = std::move(PrevParamType.ElementType);
             auto& PrevAsBase = PrevParamType.asType();
@@ -855,7 +855,7 @@ class RefParser
     }
 
     bool
-    parseTypeId(Optional<Polymorphic<TypeInfo>>& dest)
+    parseTypeId(Optional<Polymorphic<Type>>& dest)
     {
         char const* start = ptr_;
 
@@ -884,7 +884,7 @@ class RefParser
     }
 
     bool
-    parseDeclarationSpecifiers(Optional<Polymorphic<TypeInfo>>& dest)
+    parseDeclarationSpecifiers(Optional<Polymorphic<Type>>& dest)
     {
         //static constexpr std::string_view typeQualifiers[] = {
         //    "const", "volatile"
@@ -1013,9 +1013,9 @@ class RefParser
             // which is "int"
             if (!dest)
             {
-                dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
+                dest = Polymorphic<Type>(std::in_place_type<NamedType>);
                 auto &NTI = (*dest)->asNamed();
-                NTI.Name->Name = "int";
+                NTI.Name->Identifier = "int";
                 NTI.FundamentalType = FundamentalTypeKind::Int;
             }
             // Check if the type is named
@@ -1047,7 +1047,7 @@ class RefParser
               return false;
             }
             // Add the specifier to the type name
-            namedParam.Name->Name = toString(*namedParam.FundamentalType);
+            namedParam.Name->Identifier = toString(*namedParam.FundamentalType);
         }
 
         // - "short" can be combined with int.
@@ -1056,10 +1056,10 @@ class RefParser
             // Infer basic fundamental type for "short", which is "int"
             if (!dest)
             {
-                dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
+                dest = Polymorphic<Type>(std::in_place_type<NamedType>);
                 auto &NTI = (*dest)->asNamed();
-                NTI.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
-                NTI.Name->Name = "int";
+                NTI.Name = Polymorphic<Name>(std::in_place_type<IdentifierName>);
+                NTI.Name->Identifier = "int";
                 NTI.FundamentalType = FundamentalTypeKind::Int;
             }
             // Check if the type is named
@@ -1086,7 +1086,7 @@ class RefParser
                 return false;
             }
             // Add the specifier to the type name
-            namedParam.Name->Name = toString(*namedParam.FundamentalType);
+            namedParam.Name->Identifier = toString(*namedParam.FundamentalType);
         }
 
         // - "long" can be combined with "int", "double" and "long"
@@ -1095,10 +1095,10 @@ class RefParser
             // Infer basic fundamental type for "long", which is "int"
             if (!dest)
             {
-                dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
+                dest = Polymorphic<Type>(std::in_place_type<NamedType>);
                 auto &NTI = (*dest)->asNamed();
-                NTI.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
-                NTI.Name->Name = "int";
+                NTI.Name = Polymorphic<Name>(std::in_place_type<IdentifierName>);
+                NTI.Name->Identifier = "int";
                 NTI.FundamentalType = FundamentalTypeKind::Int;
             }
             // Check if the type is named
@@ -1133,7 +1133,7 @@ class RefParser
                 }
             }
             // Add the specifier to the type name
-            namedParam.Name->Name = toString(*namedParam.FundamentalType);
+            namedParam.Name->Identifier = toString(*namedParam.FundamentalType);
         }
 
         // Final check: if dest is still empty, we have an error
@@ -1152,7 +1152,7 @@ class RefParser
     }
 
     bool
-    parseDeclarationSpecifier(Optional<Polymorphic<TypeInfo>>& dest)
+    parseDeclarationSpecifier(Optional<Polymorphic<Type>>& dest)
     {
         char const* start = ptr_;
 
@@ -1208,14 +1208,14 @@ class RefParser
         {
             MRDOCS_CHECK_OR(checkDestWasEmpty(), false);
 
-            dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
+            dest = Polymorphic<Type>(std::in_place_type<NamedType>);
             MRDOCS_ASSERT(dest);
             MRDOCS_ASSERT(!dest->valueless_after_move());
             auto &NTI = (*dest)->asNamed();
             MRDOCS_ASSERT(!NTI.Name.valueless_after_move());
-            NTI.Name->Name = std::string_view(start, ptr_ - start);
+            NTI.Name->Identifier = std::string_view(start, ptr_ - start);
             if (FundamentalTypeKind k;
-                fromString(NTI.Name->Name, k))
+                fromString(NTI.Name->Identifier, k))
             {
                 NTI.FundamentalType = k;
             }
@@ -1226,7 +1226,7 @@ class RefParser
         if (parseKeyword("auto"))
         {
             MRDOCS_CHECK_OR(checkDestWasEmpty(), false);
-            dest = Polymorphic<TypeInfo>(std::in_place_type<AutoTypeInfo>);
+            dest = Polymorphic<Type>(std::in_place_type<AutoType>);
             return true;
         }
 
@@ -1243,11 +1243,11 @@ class RefParser
                     if (parseLiteral(")"))
                     {
                         MRDOCS_CHECK_OR(checkDestWasEmpty(), false);
-                        dest = Polymorphic<TypeInfo>(
-                            std::in_place_type<AutoTypeInfo>);
+                        dest = Polymorphic<Type>(
+                            std::in_place_type<AutoType>);
                         MRDOCS_ASSERT(dest);
                         MRDOCS_ASSERT(!dest->valueless_after_move());
-                        static_cast<AutoTypeInfo&>(**dest).Keyword = AutoKind::
+                        static_cast<AutoType&>(**dest).Keyword = AutoKind::
                             DecltypeAuto;
                         return true;
                     }
@@ -1277,8 +1277,8 @@ class RefParser
                         return false;
                     }
                     MRDOCS_CHECK_OR(checkDestWasEmpty(), false);
-                    dest = Polymorphic<TypeInfo>(
-                        std::in_place_type<DecltypeTypeInfo>);
+                    dest = Polymorphic<Type>(
+                        std::in_place_type<DecltypeType>);
                     MRDOCS_ASSERT(dest);
                     MRDOCS_ASSERT(!dest->valueless_after_move());
                     (*dest)->asDecltype().Operand.Written = expr;
@@ -1385,7 +1385,7 @@ class RefParser
 
     bool
     parseQualifiedIdentifier(
-        Optional<Polymorphic<TypeInfo>>& dest,
+        Optional<Polymorphic<Type>>& dest,
         bool const allowTemplateDisambiguation,
         bool const allowTemplateArguments)
     {
@@ -1409,14 +1409,14 @@ class RefParser
 
             // Populate dest
             auto const idStr = std::string_view(idStart, ptr_ - idStart);
-            Optional<Polymorphic<NameInfo>> ParentName
+            Optional<Polymorphic<Name>> ParentName
                 = dest ?
-                     Optional<Polymorphic<NameInfo>>((*dest)->asNamed().Name) :
-                     Optional<Polymorphic<NameInfo>>(std::nullopt);
-            dest = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
+                     Optional<Polymorphic<Name>>((*dest)->asNamed().Name) :
+                     Optional<Polymorphic<Name>>(std::nullopt);
+            dest = Polymorphic<Type>(std::in_place_type<NamedType>);
             auto &NTI = (*dest)->asNamed();
-            NTI.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
-            NTI.Name->Name = idStr;
+            NTI.Name = Polymorphic<Name>(std::in_place_type<IdentifierName>);
+            NTI.Name->Identifier = idStr;
             NTI.Name->Prefix = std::move(ParentName);
 
             // Look for the next "::"
@@ -1449,8 +1449,8 @@ class RefParser
                 }
                 // Replace the nameinfo with a nameinfo with args
                 auto& namedParam = (*dest)->asNamed();
-                SpecializationNameInfo SNI;
-                SNI.Name = std::move(namedParam.Name->Name);
+                SpecializationName SNI;
+                SNI.Identifier = std::move(namedParam.Name->Identifier);
                 SNI.Prefix = std::move(namedParam.Name->Prefix);
                 SNI.id = namedParam.Name->id;
                 if (!parseTemplateArguments(SNI.TemplateArgs))
@@ -1458,8 +1458,8 @@ class RefParser
                     ptr_ = start;
                     return false;
                 }
-                namedParam.Name = Polymorphic<NameInfo>(
-                    std::in_place_type<SpecializationNameInfo>, std::move(SNI));
+                namedParam.Name = Polymorphic<Name>(
+                    std::in_place_type<SpecializationName>, std::move(SNI));
             }
             else
             {
@@ -1482,14 +1482,14 @@ class RefParser
     };
 
     bool
-    parseAbstractDeclarator(Optional<Polymorphic<TypeInfo>>& dest)
+    parseAbstractDeclarator(Optional<Polymorphic<Type>>& dest)
     {
         return parseDeclarator<abstract>(dest);
     }
 
     template <int declarator_type>
     bool
-    parseDeclarator(Optional<Polymorphic<TypeInfo>>& dest)
+    parseDeclarator(Optional<Polymorphic<Type>>& dest)
     {
         char const *start = ptr_;
         if (!parseDeclaratorOrNoPtrDeclarator<declarator_type>(dest))
@@ -1559,7 +1559,7 @@ class RefParser
             // The current inner type of dest is the function return type.
             MRDOCS_ASSERT(dest);
             MRDOCS_ASSERT(!dest->valueless_after_move());
-            Optional<Polymorphic<TypeInfo> &> inner = innerType(**dest);
+            Optional<Polymorphic<Type> &> inner = innerType(**dest);
             // The more suffixes we have, the more levels of inner types
             // the suffix affects.
             // For instance, in "int (*)[3][6]", we have a pointer to an
@@ -1587,7 +1587,7 @@ class RefParser
 
     template <int declarator_type>
     bool
-    parseDeclaratorOrNoPtrDeclarator(Optional<Polymorphic<TypeInfo>>& dest)
+    parseDeclaratorOrNoPtrDeclarator(Optional<Polymorphic<Type>>& dest)
     {
         static constexpr bool isAbstractDeclarator = static_cast<bool>(declarator_type & abstract);
         static constexpr bool isInternalDeclarator = static_cast<bool>(declarator_type & internal_declarator);
@@ -1716,9 +1716,9 @@ class RefParser
             }
 
             // Change current type to pointer type
-            PointerTypeInfo PTI;
+            PointerType PTI;
             PTI.PointeeType = std::move(*dest);
-            dest = Polymorphic<TypeInfo>(std::move(PTI));
+            dest = Polymorphic<Type>(std::move(PTI));
 
             skipWhitespace();
             // cv is a sequence of const and volatile qualifiers,
@@ -1764,14 +1764,14 @@ class RefParser
             }
 
             // Assemble the parent type for the NNS
-            NamedTypeInfo ParentType;
+            NamedType ParentType;
             auto NNSString = std::string_view(start, NNSEnd - start);
-            IdentifierNameInfo NNS;
+            IdentifierName NNS;
             auto const NNSRange = llvm::split(NNSString, "::");
             MRDOCS_ASSERT(!NNSRange.empty());
             auto NNSIt = NNSRange.begin();
             std::string_view unqualID = *NNSIt;
-            NNS.Name = std::string(unqualID);
+            NNS.Identifier = std::string(unqualID);
             ++NNSIt;
             while (NNSIt != NNSRange.end())
             {
@@ -1780,19 +1780,19 @@ class RefParser
                 {
                     break;
                 }
-                IdentifierNameInfo NewNNS;
-                NewNNS.Name = std::string(unqualID);
-                NewNNS.Prefix = Polymorphic<NameInfo>(std::move(NNS));
+                IdentifierName NewNNS;
+                NewNNS.Identifier = std::string(unqualID);
+                NewNNS.Prefix = Polymorphic<Name>(std::move(NNS));
                 NNS = NewNNS;
                 ++NNSIt;
             }
-            ParentType.Name = Polymorphic<NameInfo>(std::move(NNS));
+            ParentType.Name = Polymorphic<Name>(std::move(NNS));
 
             // Change current type to member pointer type
-            MemberPointerTypeInfo MPTI;
-            MPTI.PointeeType = Polymorphic<TypeInfo>(std::move(*dest));
-            MPTI.ParentType = Polymorphic<TypeInfo>(std::move(ParentType));
-            dest = Polymorphic<TypeInfo>(std::move(MPTI));
+            MemberPointerType MPTI;
+            MPTI.PointeeType = Polymorphic<Type>(std::move(*dest));
+            MPTI.ParentType = Polymorphic<Type>(std::move(ParentType));
+            dest = Polymorphic<Type>(std::move(MPTI));
 
             skipWhitespace();
             // cv is a sequence of const and volatile qualifiers,
@@ -1829,15 +1829,15 @@ class RefParser
             if (bool const isRValue = parseLiteral("&");
                 !isRValue)
             {
-                LValueReferenceTypeInfo RTI;
+                LValueReferenceType RTI;
                 RTI.PointeeType = std::move(*dest);
-                dest = Polymorphic<TypeInfo>(std::move(RTI));
+                dest = Polymorphic<Type>(std::move(RTI));
             }
             else
             {
-                RValueReferenceTypeInfo RTI;
+                RValueReferenceType RTI;
                 RTI.PointeeType = std::move(*dest);
-                dest = Polymorphic<TypeInfo>(std::move(RTI));
+                dest = Polymorphic<Type>(std::move(RTI));
             }
 
             skipWhitespace();
@@ -1885,7 +1885,7 @@ class RefParser
     // is empty.
     template <int declarator_type>
     bool
-    parseArrayOrFunctionDeclaratorSuffix(Polymorphic<TypeInfo>& dest)
+    parseArrayOrFunctionDeclaratorSuffix(Polymorphic<Type>& dest)
     {
         MRDOCS_ASSERT(!dest.valueless_after_move());
 
@@ -1896,7 +1896,7 @@ class RefParser
         //     parentheses.
         // noptr-declarator [expr (optional)] attr (optional)
         // https://en.cppreference.com/w/cpp/language/array
-        Optional<Polymorphic<TypeInfo>> r;
+        Optional<Polymorphic<Type>> r;
         if (parseArrayDeclaratorSuffix<declarator_type>(r))
         {
             dest = *r;
@@ -1921,7 +1921,7 @@ class RefParser
 
     template <int declarator_type>
     bool
-    parseArrayDeclaratorSuffix(Optional<Polymorphic<TypeInfo>>& dest)
+    parseArrayDeclaratorSuffix(Optional<Polymorphic<Type>>& dest)
     {
         char const* start = ptr_;
 
@@ -1940,7 +1940,7 @@ class RefParser
             }
 
             // Change current type to array type
-            ArrayTypeInfo ATI;
+            ArrayType ATI;
             if (dest)
             {
                 ATI.ElementType = std::move(*dest);
@@ -1986,7 +1986,7 @@ class RefParser
                     ATI.Bounds = Bounds;
                 }
             }
-            dest = Polymorphic<TypeInfo>(std::move(ATI));
+            dest = Polymorphic<Type>(std::move(ATI));
             skipWhitespace();
 
             // We ignore the name and just return true
@@ -1997,7 +1997,7 @@ class RefParser
 
     template <int declarator_type>
     bool
-    parseFunctionDeclaratorSuffix(Optional<Polymorphic<TypeInfo>>& dest)
+    parseFunctionDeclaratorSuffix(Optional<Polymorphic<Type>>& dest)
     {
         char const* start = ptr_;
 
@@ -2030,7 +2030,7 @@ class RefParser
                 ptr_ = start;
                 return false;
             }
-            FunctionTypeInfo FTI;
+            FunctionType FTI;
             if (dest)
             {
                 FTI.ReturnType = std::move(*dest);
@@ -2041,7 +2041,7 @@ class RefParser
                 std::make_move_iterator(function.Params.end()));
             FTI.ExceptionSpec = std::move(function.ExceptionSpec);
             FTI.IsVariadic = function.IsVariadic;
-            dest = Polymorphic<TypeInfo>(std::move(FTI));
+            dest = Polymorphic<Type>(std::move(FTI));
             return true;
         }
 
@@ -2271,4 +2271,4 @@ parse(
     return res;
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/AST/ParseRef.hpp b/src/lib/AST/ParseRef.hpp
index 34fc7218f..064ef3723 100644
--- a/src/lib/AST/ParseRef.hpp
+++ b/src/lib/AST/ParseRef.hpp
@@ -18,7 +18,7 @@
 #include <llvm/ADT/SmallVector.h>
 #include <string_view>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 struct TArg;
 
@@ -36,7 +36,7 @@ struct ParsedRefComponent {
 
     // If not empty, this is a conversion operator
     // Only the last component can be a conversion operator
-    Optional<Polymorphic<TypeInfo>> ConversionType = std::nullopt;
+    Optional<Polymorphic<Type>> ConversionType = std::nullopt;
 
     constexpr
     bool
@@ -65,7 +65,7 @@ struct ParsedRef {
 
     // The following are populated when the last element is a function
     bool HasFunctionParameters = false;
-    llvm::SmallVector<Polymorphic<TypeInfo>, 8> FunctionParameters;
+    llvm::SmallVector<Polymorphic<Type>, 8> FunctionParameters;
     bool IsVariadic = false;
     bool IsExplicitObjectMemberFunction = false;
     ReferenceKind Kind = ReferenceKind::None;
@@ -80,6 +80,6 @@ parse(
     char const* last,
     ParsedRef& value);
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_LIB_AST_PARSEREF_HPP
diff --git a/src/lib/AST/TerminalTypeVisitor.hpp b/src/lib/AST/TerminalTypeVisitor.hpp
index 838f0c3d7..88bfd9947 100644
--- a/src/lib/AST/TerminalTypeVisitor.hpp
+++ b/src/lib/AST/TerminalTypeVisitor.hpp
@@ -17,12 +17,12 @@
 #include <lib/AST/ASTVisitor.hpp>
 #include <clang/AST/TypeVisitor.h>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** A visitor to build objects from `Type`s.
 
     MrDocs might need to convert class instances derived from `Type`
-    into other struct instances like `TypeInfo` or `NameInfo`.
+    into other struct instances like `Type` or `Name`.
 
     This class can be used to define a visitor to build objects
     from `Type`s. The visitor can be defined as a class that
@@ -55,7 +55,7 @@ namespace clang::mrdocs {
     from `TerminalTypeVisitor<Derived>`, which converts the
     `Type` into the concrete type and calls the corresponding
     `VisitXXXType` function. It also provides
-    `bool Visit(QualType QT)` as an extension to visit the
+    `bool Visit(clang::QualType QT)` as an extension to visit the
     `Type` associated with the qualified type.
 
     Each `VisitXXXType` function will store any relative information
@@ -71,7 +71,7 @@ namespace clang::mrdocs {
  */
 template <class Derived>
 class TerminalTypeVisitor
-    : public TypeVisitor<TerminalTypeVisitor<Derived>, bool>
+    : public clang::TypeVisitor<TerminalTypeVisitor<Derived>, bool>
 {
     friend class TerminalTypeVisitor::TypeVisitor;
 
@@ -122,11 +122,11 @@ class TerminalTypeVisitor
         - Unwrapped type: `int`
      */
     bool
-    Visit(QualType const QT)
+    Visit(clang::QualType const QT)
     {
         MRDOCS_SYMBOL_TRACE(QT, Visitor_.context_);
         Quals_ |= QT.getLocalFastQualifiers();
-        Type const* T = QT.getTypePtrOrNull();
+        clang::Type const* T = QT.getTypePtrOrNull();
         MRDOCS_SYMBOL_TRACE(T, Visitor_.context_);
         return Visit(T);
     }
@@ -151,7 +151,7 @@ class TerminalTypeVisitor
     static
     void
     buildPointer
-        (PointerType const*,
+        (clang::PointerType const*,
         unsigned)
     {
     }
@@ -163,7 +163,7 @@ class TerminalTypeVisitor
      */
     void
     buildLValueReference(
-        LValueReferenceType const*)
+        clang::LValueReferenceType const*)
     {
     }
 
@@ -174,7 +174,7 @@ class TerminalTypeVisitor
      */
     void
     buildRValueReference(
-        RValueReferenceType const*)
+        clang::RValueReferenceType const*)
     {
     }
 
@@ -185,7 +185,7 @@ class TerminalTypeVisitor
      */
     void
     buildMemberPointer(
-        MemberPointerType const*, unsigned)
+        clang::MemberPointerType const*, unsigned)
     {
     }
 
@@ -196,13 +196,13 @@ class TerminalTypeVisitor
      */
     void
     buildArray(
-        ArrayType const*)
+        clang::ArrayType const*)
     {
     }
 
     void
     populate(
-        FunctionType const*)
+        clang::FunctionType const*)
     {
     }
 
@@ -213,7 +213,7 @@ class TerminalTypeVisitor
      */
     void
     buildDecltype(
-        DecltypeType const*,
+        clang::DecltypeType const*,
         unsigned,
         bool)
     {
@@ -226,7 +226,7 @@ class TerminalTypeVisitor
      */
     void
     buildAuto(
-        AutoType const*,
+        clang::AutoType const*,
         unsigned,
         bool)
     {
@@ -239,8 +239,8 @@ class TerminalTypeVisitor
      */
     void
     buildTerminal(
-        NestedNameSpecifier,
-        Type const*,
+        clang::NestedNameSpecifier,
+        clang::Type const*,
         unsigned,
         bool)
     {
@@ -253,9 +253,9 @@ class TerminalTypeVisitor
      */
     void
     buildTerminal(
-        NestedNameSpecifier,
-        IdentifierInfo const*,
-        Optional<ArrayRef<TemplateArgument>>,
+        clang::NestedNameSpecifier,
+        clang::IdentifierInfo const*,
+        Optional<llvm::ArrayRef<clang::TemplateArgument>>,
         unsigned,
         bool)
     {
@@ -268,9 +268,9 @@ class TerminalTypeVisitor
      */
     void
     buildTerminal(
-        NestedNameSpecifier,
-        NamedDecl*,
-        Optional<ArrayRef<TemplateArgument>>,
+        clang::NestedNameSpecifier,
+        clang::NamedDecl*,
+        Optional<llvm::ArrayRef<clang::TemplateArgument>>,
         unsigned,
         bool)
     {
@@ -299,9 +299,9 @@ class TerminalTypeVisitor
         - Unwrapped type: `int`
      */
     bool
-    VisitParenType(ParenType const* T)
+    VisitParenType(clang::ParenType const* T)
     {
-        QualType I = T->getInnerType();
+        clang::QualType I = T->getInnerType();
         return Visit(I);
     }
 
@@ -315,9 +315,9 @@ class TerminalTypeVisitor
      */
     bool
     VisitMacroQualified(
-        MacroQualifiedType const* T)
+        clang::MacroQualifiedType const* T)
     {
-        QualType UT = T->getUnderlyingType();
+        clang::QualType UT = T->getUnderlyingType();
         return Visit(UT);
     }
 
@@ -331,9 +331,9 @@ class TerminalTypeVisitor
      */
     bool
     VisitAttributedType(
-        AttributedType const* T)
+        clang::AttributedType const* T)
     {
-        QualType MT = T->getModifiedType();
+        clang::QualType MT = T->getModifiedType();
         return Visit(MT);
     }
 
@@ -346,9 +346,9 @@ class TerminalTypeVisitor
         - Unwrapped type: original `int[4]`
      */
     bool
-    VisitAdjustedType(AdjustedType const* T)
+    VisitAdjustedType(clang::AdjustedType const* T)
     {
-        QualType OT = T->getOriginalType();
+        clang::QualType OT = T->getOriginalType();
         return Visit(OT);
     }
 
@@ -361,9 +361,9 @@ class TerminalTypeVisitor
         - Unwrapped type: `int`
      */
     bool
-    VisitUsingType(UsingType const* T)
+    VisitUsingType(clang::UsingType const* T)
     {
-        QualType UT = T->desugar();
+        clang::QualType UT = T->desugar();
         return Visit(UT);
     }
 
@@ -377,9 +377,9 @@ class TerminalTypeVisitor
      */
     bool
     VisitSubstTemplateTypeParmType(
-        SubstTemplateTypeParmType const* T)
+        clang::SubstTemplateTypeParmType const* T)
     {
-        QualType RT = T->getReplacementType();
+        clang::QualType RT = T->getReplacementType();
         return Visit(RT);
     }
 
@@ -395,10 +395,10 @@ class TerminalTypeVisitor
      */
     bool
     VisitPackExpansionType(
-        PackExpansionType const* T)
+        clang::PackExpansionType const* T)
     {
         IsPack_ = true;
-        QualType PT = T->getPattern();
+        clang::QualType PT = T->getPattern();
         return Visit(PT);
     }
 
@@ -414,10 +414,10 @@ class TerminalTypeVisitor
      */
     bool
     VisitPointerType(
-        PointerType const* T)
+        clang::PointerType const* T)
     {
         getDerived().buildPointer(T, std::exchange(Quals_, 0));
-        QualType PT = T->getPointeeType();
+        clang::QualType PT = T->getPointeeType();
         return Visit(PT);
     }
 
@@ -431,11 +431,11 @@ class TerminalTypeVisitor
      */
     bool
     VisitLValueReferenceType(
-        LValueReferenceType const* T)
+        clang::LValueReferenceType const* T)
     {
         getDerived().buildLValueReference(T);
         Quals_ = 0;
-        QualType PT = T->getPointeeType();
+        clang::QualType PT = T->getPointeeType();
         return Visit(PT);
     }
 
@@ -449,11 +449,11 @@ class TerminalTypeVisitor
      */
     bool
     VisitRValueReferenceType(
-        RValueReferenceType const* T)
+        clang::RValueReferenceType const* T)
     {
         getDerived().buildRValueReference(T);
         Quals_ = 0;
-        QualType PT = T->getPointeeType();
+        clang::QualType PT = T->getPointeeType();
         return Visit(PT);
     }
 
@@ -467,19 +467,19 @@ class TerminalTypeVisitor
      */
     bool
     VisitMemberPointerType(
-        MemberPointerType const* T)
+        clang::MemberPointerType const* T)
     {
         getDerived().buildMemberPointer(T, std::exchange(Quals_, 0));
-        QualType PT = T->getPointeeType();
+        clang::QualType PT = T->getPointeeType();
         return Visit(PT);
     }
 
     bool
     VisitFunctionType(
-        FunctionType const* T)
+        clang::FunctionType const* T)
     {
         getDerived().populate(T);
-        QualType RT = T->getReturnType();
+        clang::QualType RT = T->getReturnType();
         return Visit(RT);
     }
 
@@ -493,10 +493,10 @@ class TerminalTypeVisitor
      */
     bool
     VisitArrayType(
-        ArrayType const* T)
+        clang::ArrayType const* T)
     {
         getDerived().buildArray(T);
-        QualType ET = T->getElementType();
+        clang::QualType ET = T->getElementType();
         return Visit(ET);
     }
 
@@ -504,7 +504,7 @@ class TerminalTypeVisitor
 
     bool
     VisitDecltypeType(
-        DecltypeType const* T)
+        clang::DecltypeType const* T)
     {
         getDerived().buildDecltype(T, Quals_, IsPack_);
         return true;
@@ -512,7 +512,7 @@ class TerminalTypeVisitor
 
     bool
     VisitAutoType(
-        AutoType const* T)
+        clang::AutoType const* T)
     {
         // KRYSTIAN NOTE: we don't use isDeduced because it will
         // return true if the type is dependent
@@ -523,18 +523,18 @@ class TerminalTypeVisitor
 
     bool
     VisitDeducedTemplateSpecializationType(
-        DeducedTemplateSpecializationType const* T)
+        clang::DeducedTemplateSpecializationType const* T)
     {
-        // KRYSTIAN TODO: we should probably add a TypeInfo
+        // KRYSTIAN TODO: we should probably add a Type
         // to represent deduced types also stores what it
         // was deduced as.
-        if (QualType DT = T->getDeducedType(); !DT.isNull())
+        if (clang::QualType DT = T->getDeducedType(); !DT.isNull())
         {
             return Visit(DT);
         }
-        TemplateName const TN = T->getTemplateName();
+        clang::TemplateName const TN = T->getTemplateName();
         MRDOCS_ASSERT(! TN.isNull());
-        NamedDecl* ND = TN.getAsTemplateDecl();
+        clang::NamedDecl* ND = TN.getAsTemplateDecl();
         getDerived().buildTerminal(TN.getQualifier(), ND,
             std::nullopt, Quals_, IsPack_);
         return true;
@@ -542,7 +542,7 @@ class TerminalTypeVisitor
 
     bool
     VisitDependentNameType(
-        DependentNameType const* T)
+        clang::DependentNameType const* T)
     {
         if (auto SFINAE = getASTVisitor().extractSFINAEInfo(T))
         {
@@ -557,10 +557,10 @@ class TerminalTypeVisitor
 
     bool
     VisitDependentTemplateSpecializationType(
-        DependentTemplateSpecializationType const* T)
+        clang::DependentTemplateSpecializationType const* T)
     {
         MRDOCS_SYMBOL_TRACE(T, Visitor_.context_);
-        const DependentTemplateStorage &S = T->getDependentTemplateName();
+        const clang::DependentTemplateStorage &S = T->getDependentTemplateName();
         getDerived().buildTerminal(S.getQualifier(), S.getName().getIdentifier(),
                                    T->template_arguments(), Quals_, IsPack_);
         return true;
@@ -569,7 +569,7 @@ class TerminalTypeVisitor
     // Visit a template specialization such as `A<T>`
     bool
     VisitTemplateSpecializationType(
-        TemplateSpecializationType const* T)
+        clang::TemplateSpecializationType const* T)
     {
         MRDOCS_SYMBOL_TRACE(T, Visitor_.context_);
         if (auto SFINAE = getASTVisitor().extractSFINAEInfo(T))
@@ -583,18 +583,18 @@ class TerminalTypeVisitor
         // is `template<typename T> class X { };`.
         // Template names can also refer to function templates,
         // C++0x template aliases, etc...
-        TemplateName const TN = T->getTemplateName();
+        clang::TemplateName const TN = T->getTemplateName();
         MRDOCS_SYMBOL_TRACE(TN, Visitor_.context_);
         MRDOCS_ASSERT(! TN.isNull());
 
         // The list of template parameters and a reference to
         // the templated scoped declaration
-        NamedDecl* D = TN.getAsTemplateDecl();
+        clang::NamedDecl* D = TN.getAsTemplateDecl();
         MRDOCS_SYMBOL_TRACE(TN, Visitor_.context_);
 
         if (!T->isTypeAlias())
         {
-            if (auto* CT = dyn_cast<TagType>(T->getCanonicalTypeInternal()))
+            if (auto* CT = dyn_cast<clang::TagType>(T->getCanonicalTypeInternal()))
             {
                 MRDOCS_SYMBOL_TRACE(CT, Visitor_.context_);
                 D = CT->getOriginalDecl()->getDefinitionOrSelf();
@@ -611,13 +611,13 @@ class TerminalTypeVisitor
 
     bool
     VisitRecordType(
-        RecordType const* T)
+        clang::RecordType const* T)
     {
-        RecordDecl* RD = T->getOriginalDecl()->getDefinitionOrSelf();
+        clang::RecordDecl* RD = T->getOriginalDecl()->getDefinitionOrSelf();
         // if this is an instantiation of a class template,
-        // create a SpecializationTypeInfo & extract the template arguments
-        Optional<ArrayRef<TemplateArgument>> TArgs = std::nullopt;
-        if (auto const* CTSD = dyn_cast<ClassTemplateSpecializationDecl>(RD))
+        // create a SpecializationType & extract the template arguments
+        Optional<llvm::ArrayRef<clang::TemplateArgument>> TArgs = std::nullopt;
+        if (auto const* CTSD = dyn_cast<clang::ClassTemplateSpecializationDecl>(RD))
         {
             TArgs = CTSD->getTemplateArgs().asArray();
         }
@@ -628,7 +628,7 @@ class TerminalTypeVisitor
 
     bool
     VisitInjectedClassNameType(
-        InjectedClassNameType const* T)
+        clang::InjectedClassNameType const* T)
     {
         getDerived().buildTerminal(T->getQualifier(), T->getOriginalDecl()->getDefinitionOrSelf(),
             std::nullopt, Quals_, IsPack_);
@@ -637,7 +637,7 @@ class TerminalTypeVisitor
 
     bool
     VisitEnumType(
-        EnumType const* T)
+        clang::EnumType const* T)
     {
         getDerived().buildTerminal(T->getQualifier(), T->getOriginalDecl()->getDefinitionOrSelf(),
             std::nullopt, Quals_, IsPack_);
@@ -646,7 +646,7 @@ class TerminalTypeVisitor
 
     bool
     VisitTypedefType(
-        TypedefType const* T)
+        clang::TypedefType const* T)
     {
         getDerived().buildTerminal(T->getQualifier(), T->getDecl(),
             std::nullopt, Quals_, IsPack_);
@@ -655,11 +655,11 @@ class TerminalTypeVisitor
 
     bool
     VisitTemplateTypeParmType(
-        TemplateTypeParmType const* T)
+        clang::TemplateTypeParmType const* T)
     {
         MRDOCS_SYMBOL_TRACE(T, Visitor_.context_);
-        IdentifierInfo const* II = nullptr;
-        if (TemplateTypeParmDecl const* D = T->getDecl())
+        clang::IdentifierInfo const* II = nullptr;
+        if (clang::TemplateTypeParmDecl const* D = T->getDecl())
         {
             MRDOCS_SYMBOL_TRACE(D, Visitor_.context_);
             if(D->isImplicit())
@@ -679,7 +679,7 @@ class TerminalTypeVisitor
 
     bool
     VisitSubstTemplateTypeParmPackType(
-        SubstTemplateTypeParmPackType const* T)
+        clang::SubstTemplateTypeParmPackType const* T)
     {
         getDerived().buildTerminal(std::nullopt, T->getIdentifier(),
             std::nullopt, Quals_, IsPack_);
@@ -687,7 +687,7 @@ class TerminalTypeVisitor
     }
 
     bool
-    VisitType(Type const* T)
+    VisitType(clang::Type const* T)
     {
         getDerived().buildTerminal(
             T, Quals_, IsPack_);
@@ -695,6 +695,6 @@ class TerminalTypeVisitor
     }
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/src/lib/AST/TypeInfoBuilder.cpp b/src/lib/AST/TypeBuilder.cpp
similarity index 52%
rename from src/lib/AST/TypeInfoBuilder.cpp
rename to src/lib/AST/TypeBuilder.cpp
index 50ad67e75..f2bea70d5 100644
--- a/src/lib/AST/TypeInfoBuilder.cpp
+++ b/src/lib/AST/TypeBuilder.cpp
@@ -11,70 +11,70 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <lib/AST/TypeInfoBuilder.hpp>
+#include <lib/AST/TypeBuilder.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 void
-TypeInfoBuilder::
-buildPointer(PointerType const*, unsigned quals)
+TypeBuilder::
+buildPointer(clang::PointerType const*, unsigned quals)
 {
     MRDOCS_ASSERT(Inner);
-    *Inner = Polymorphic<TypeInfo>(std::in_place_type<PointerTypeInfo>);
+    *Inner = Polymorphic<Type>(std::in_place_type<PointerType>);
     auto &I = (*Inner)->asPointer();
-    I.IsConst = quals & Qualifiers::Const;
-    I.IsVolatile = quals & Qualifiers::Volatile;
+    I.IsConst = quals & clang::Qualifiers::Const;
+    I.IsVolatile = quals & clang::Qualifiers::Volatile;
     Inner = &I.PointeeType;
 }
 
 void
-TypeInfoBuilder::
-buildLValueReference(LValueReferenceType const*)
+TypeBuilder::
+buildLValueReference(clang::LValueReferenceType const*)
 {
     MRDOCS_ASSERT(Inner);
-    *Inner = Polymorphic<TypeInfo>(std::in_place_type<LValueReferenceTypeInfo>);
+    *Inner = Polymorphic<Type>(std::in_place_type<LValueReferenceType>);
     Inner = &(*Inner)->asLValueReference().PointeeType;
 }
 
 void
-TypeInfoBuilder::
-buildRValueReference(RValueReferenceType const*)
+TypeBuilder::
+buildRValueReference(clang::RValueReferenceType const*)
 {
     MRDOCS_ASSERT(Inner);
-    *Inner = Polymorphic<TypeInfo>(std::in_place_type<RValueReferenceTypeInfo>);
+    *Inner = Polymorphic<Type>(std::in_place_type<RValueReferenceType>);
     Inner = &(*Inner)->asRValueReference().PointeeType;
 }
 
 void
-TypeInfoBuilder::
+TypeBuilder::
 buildMemberPointer(
-    MemberPointerType const* T,
+    clang::MemberPointerType const* T,
     unsigned const quals)
 {
     MRDOCS_ASSERT(Inner);
-    *Inner = Polymorphic<TypeInfo>(std::in_place_type<MemberPointerTypeInfo>);
+    *Inner = Polymorphic<Type>(std::in_place_type<MemberPointerType>);
     auto &I = (*Inner)->asMemberPointer();
-    I.IsConst = quals & Qualifiers::Const;
-    I.IsVolatile = quals & Qualifiers::Volatile;
+    I.IsConst = quals & clang::Qualifiers::Const;
+    I.IsVolatile = quals & clang::Qualifiers::Volatile;
     // do not set NNS because the parent type is *not*
     // a nested-name-specifier which qualifies the pointee type
     I.ParentType =
-        getASTVisitor().toTypeInfo(QualType(T->getQualifier().getAsType(), 0));
+        getASTVisitor().toType(clang::QualType(T->getQualifier().getAsType(), 0));
     Inner = &I.PointeeType;
 }
 
 void
-TypeInfoBuilder::
-buildArray(ArrayType const* T)
+TypeBuilder::
+buildArray(clang::ArrayType const* T)
 {
     MRDOCS_ASSERT(Inner);
-    *Inner = Polymorphic<TypeInfo>(std::in_place_type<ArrayTypeInfo>);
+    *Inner = Polymorphic<Type>(std::in_place_type<ArrayType>);
     auto &I = (*Inner)->asArray();
-    if (auto* CAT = dyn_cast<ConstantArrayType>(T))
+    if (auto* CAT = dyn_cast<clang::ConstantArrayType>(T))
     {
         getASTVisitor().populate(I.Bounds, CAT->getSizeExpr(), CAT->getSize());
     }
-    else if (auto* DAT = dyn_cast<DependentSizedArrayType>(T))
+    else if (auto* DAT = dyn_cast<clang::DependentSizedArrayType>(T))
     {
         getASTVisitor().populate(I.Bounds, DAT->getSizeExpr());
     }
@@ -82,75 +82,75 @@ buildArray(ArrayType const* T)
 }
 
 void
-TypeInfoBuilder::
-populate(FunctionType const* T)
+TypeBuilder::
+populate(clang::FunctionType const* T)
 {
-    auto* FPT = cast<FunctionProtoType>(T);
+    auto* FPT = cast<clang::FunctionProtoType>(T);
     MRDOCS_ASSERT(Inner);
-    *Inner = Polymorphic<TypeInfo>(std::in_place_type<FunctionTypeInfo>);
+    *Inner = Polymorphic<Type>(std::in_place_type<FunctionType>);
     auto &I = (*Inner)->asFunction();
-    for (QualType const PT : FPT->getParamTypes())
+    for (clang::QualType const PT : FPT->getParamTypes())
     {
-        I.ParamTypes.emplace_back(getASTVisitor().toTypeInfo(PT));
+        I.ParamTypes.emplace_back(getASTVisitor().toType(PT));
     }
     I.RefQualifier = toReferenceKind(
         FPT->getRefQualifier());
     unsigned const quals = FPT->getMethodQuals().getFastQualifiers();
-    I.IsConst = quals & Qualifiers::Const;
-    I.IsVolatile = quals & Qualifiers::Volatile;
+    I.IsConst = quals & clang::Qualifiers::Const;
+    I.IsVolatile = quals & clang::Qualifiers::Volatile;
     I.IsVariadic = FPT->isVariadic();
     getASTVisitor().populate(I.ExceptionSpec, FPT);
     Inner = &I.ReturnType;
 }
 
 void
-TypeInfoBuilder::
+TypeBuilder::
 buildDecltype(
-    DecltypeType const* T,
+    clang::DecltypeType const* T,
     unsigned quals,
     bool pack)
 {
     MRDOCS_ASSERT(Inner);
-    *Inner = Polymorphic<TypeInfo>(std::in_place_type<DecltypeTypeInfo>);
+    *Inner = Polymorphic<Type>(std::in_place_type<DecltypeType>);
     (*Inner)->Constraints = this->Constraints;
     (*Inner)->IsPackExpansion = pack;
 
     auto &I = (*Inner)->asDecltype();
     getASTVisitor().populate(I.Operand, T->getUnderlyingExpr());
-    I.IsConst = quals & Qualifiers::Const;
-    I.IsVolatile = quals & Qualifiers::Volatile;
+    I.IsConst = quals & clang::Qualifiers::Const;
+    I.IsVolatile = quals & clang::Qualifiers::Volatile;
 
     Result->Constraints = this->Constraints;
     Result->IsPackExpansion = pack;
 }
 
 void
-TypeInfoBuilder::
+TypeBuilder::
 buildAuto(
-    AutoType const* T,
+    clang::AutoType const* T,
     unsigned const quals,
     bool const pack)
 {
     MRDOCS_ASSERT(Inner);
-    *Inner = Polymorphic<TypeInfo>(std::in_place_type<AutoTypeInfo>);
+    *Inner = Polymorphic<Type>(std::in_place_type<AutoType>);
     (*Inner)->Constraints = this->Constraints;
     (*Inner)->IsPackExpansion = pack;
 
     auto &I = (*Inner)->asAuto();
-    I.IsConst = quals & Qualifiers::Const;
-    I.IsVolatile = quals & Qualifiers::Volatile;
+    I.IsConst = quals & clang::Qualifiers::Const;
+    I.IsVolatile = quals & clang::Qualifiers::Volatile;
     I.Keyword = toAutoKind(T->getKeyword());
     if(T->isConstrained())
     {
-        Optional<ArrayRef<TemplateArgument>> TArgs;
+        Optional<llvm::ArrayRef<clang::TemplateArgument>> TArgs;
         if(auto Args = T->getTypeConstraintArguments();
             ! Args.empty())
         {
             TArgs.emplace(Args);
         }
         I.Constraint =
-            getASTVisitor().toNameInfo(T->getTypeConstraintConcept(), TArgs);
-        // Constraint->Prefix = getASTVisitor().buildNameInfo(
+            getASTVisitor().toName(T->getTypeConstraintConcept(), TArgs);
+        // Constraint->Prefix = getASTVisitor().buildName(
         //     cast<Decl>(CD->getDeclContext()));
     }
     Result->Constraints = this->Constraints;
@@ -158,26 +158,26 @@ buildAuto(
 }
 
 void
-TypeInfoBuilder::
+TypeBuilder::
 buildTerminal(
-    Type const* T,
+    clang::Type const* T,
     unsigned quals,
     bool pack)
 {
     MRDOCS_SYMBOL_TRACE(T, getASTVisitor().context_);
     MRDOCS_ASSERT(Inner);
-    *Inner = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
+    *Inner = Polymorphic<Type>(std::in_place_type<NamedType>);
     (*Inner)->IsPackExpansion = pack;
     (*Inner)->Constraints = this->Constraints;
 
     auto &TI = (*Inner)->asNamed();
-    TI.IsConst = quals & Qualifiers::Const;
-    TI.IsVolatile = quals & Qualifiers::Volatile;
-    TI.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
-    TI.Name->Name = getASTVisitor().toString(T);
-    if (isa<BuiltinType>(T))
+    TI.IsConst = quals & clang::Qualifiers::Const;
+    TI.IsVolatile = quals & clang::Qualifiers::Volatile;
+    TI.Name = Polymorphic<Name>(std::in_place_type<IdentifierName>);
+    TI.Name->Identifier = getASTVisitor().toString(T);
+    if (isa<clang::BuiltinType>(T))
     {
-        auto const* FT = cast<BuiltinType>(T);
+        auto const* FT = cast<clang::BuiltinType>(T);
         TI.FundamentalType = toFundamentalTypeKind(FT->getKind());
     }
     Result->Constraints = this->Constraints;
@@ -185,54 +185,54 @@ buildTerminal(
 }
 
 void
-TypeInfoBuilder::
+TypeBuilder::
 buildTerminal(
-    NestedNameSpecifier NNS,
-    IdentifierInfo const* II,
-    Optional<ArrayRef<TemplateArgument>> TArgs,
+    clang::NestedNameSpecifier NNS,
+    clang::IdentifierInfo const* II,
+    Optional<llvm::ArrayRef<clang::TemplateArgument>> TArgs,
     unsigned quals,
     bool pack)
 {
     MRDOCS_ASSERT(Inner);
-    *Inner = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
+    *Inner = Polymorphic<Type>(std::in_place_type<NamedType>);
     (*Inner)->IsPackExpansion = pack;
     (*Inner)->Constraints = this->Constraints;
 
     auto &I = (*Inner)->asNamed();
-    I.IsConst = quals & Qualifiers::Const;
-    I.IsVolatile = quals & Qualifiers::Volatile;
+    I.IsConst = quals & clang::Qualifiers::Const;
+    I.IsVolatile = quals & clang::Qualifiers::Volatile;
 
     if (TArgs)
     {
-        I.Name = Polymorphic<NameInfo>(std::in_place_type<SpecializationNameInfo>);
+        I.Name = Polymorphic<Name>(std::in_place_type<SpecializationName>);
         auto &Name = I.Name->asSpecialization();
         if (II)
         {
-            Name.Name = II->getName();
+            Name.Identifier = II->getName();
         }
-        Name.Prefix = getASTVisitor().toNameInfo(NNS);
+        Name.Prefix = getASTVisitor().toName(NNS);
         getASTVisitor().populate(Name.TemplateArgs, *TArgs);
     }
     else
     {
-        I.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
+        I.Name = Polymorphic<Name>(std::in_place_type<IdentifierName>);
         auto &Name = *I.Name;
         if (II)
         {
-            Name.Name = II->getName();
+            Name.Identifier = II->getName();
         }
-        Name.Prefix = getASTVisitor().toNameInfo(NNS);
+        Name.Prefix = getASTVisitor().toName(NNS);
     }
     Result->Constraints = this->Constraints;
     Result->IsPackExpansion = pack;
 }
 
 void
-TypeInfoBuilder::
+TypeBuilder::
 buildTerminal(
-    NestedNameSpecifier NNS,
-    NamedDecl* D,
-    Optional<ArrayRef<TemplateArgument>> TArgs,
+    clang::NestedNameSpecifier NNS,
+    clang::NamedDecl* D,
+    Optional<llvm::ArrayRef<clang::TemplateArgument>> TArgs,
     unsigned quals,
     bool pack)
 {
@@ -242,49 +242,49 @@ buildTerminal(
 
     // Look for the Info type. If this is a template specialization,
     // we look for the Info of the specialized record.
-    Decl const* ID = decayToPrimaryTemplate(D);
+    clang::Decl const* ID = decayToPrimaryTemplate(D);
     MRDOCS_SYMBOL_TRACE(ID, getASTVisitor().context_);
 
     MRDOCS_ASSERT(Inner);
-    *Inner = Polymorphic<TypeInfo>(std::in_place_type<NamedTypeInfo>);
+    *Inner = Polymorphic<Type>(std::in_place_type<NamedType>);
     (*Inner)->IsPackExpansion = pack;
     (*Inner)->Constraints = this->Constraints;
 
     auto &TI = (*Inner)->asNamed();
-    TI.IsConst = quals & Qualifiers::Const;
-    TI.IsVolatile = quals & Qualifiers::Volatile;
+    TI.IsConst = quals & clang::Qualifiers::Const;
+    TI.IsVolatile = quals & clang::Qualifiers::Volatile;
 
-    auto populateNameInfo = [&](NameInfo& Name, NamedDecl* D)
+    auto populateName = [&](Name& Name, clang::NamedDecl* D)
     {
-        if(IdentifierInfo const* II = D->getIdentifier())
+        if(clang::IdentifierInfo const* II = D->getIdentifier())
         {
-            Name.Name = II->getName();
+            Name.Identifier = II->getName();
         }
-        if (Info const* I = getASTVisitor().findOrTraverse(const_cast<Decl*>(ID)))
+        if (Symbol const* I = getASTVisitor().findOrTraverse(const_cast<clang::Decl*>(ID)))
         {
             Name.id = I->id;
         }
         if(NNS)
         {
-            Name.Prefix = getASTVisitor().toNameInfo(NNS);
+            Name.Prefix = getASTVisitor().toName(NNS);
         }
     };
 
     if (!TArgs)
     {
-        TI.Name = Polymorphic<NameInfo>(std::in_place_type<IdentifierNameInfo>);
-        populateNameInfo(*TI.Name, D);
+        TI.Name = Polymorphic<Name>(std::in_place_type<IdentifierName>);
+        populateName(*TI.Name, D);
     }
     else
     {
         TI.Name =
-            Polymorphic<NameInfo>(std::in_place_type<SpecializationNameInfo>);
+            Polymorphic<Name>(std::in_place_type<SpecializationName>);
         auto &Name = TI.Name->asSpecialization();
-        populateNameInfo(Name, D);
+        populateName(Name, D);
         getASTVisitor().populate(Name.TemplateArgs, *TArgs);
     }
     Result->Constraints = this->Constraints;
     Result->IsPackExpansion = pack;
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/AST/TypeInfoBuilder.hpp b/src/lib/AST/TypeBuilder.hpp
similarity index 60%
rename from src/lib/AST/TypeInfoBuilder.hpp
rename to src/lib/AST/TypeBuilder.hpp
index 92fbdda33..e868e0987 100644
--- a/src/lib/AST/TypeInfoBuilder.hpp
+++ b/src/lib/AST/TypeBuilder.hpp
@@ -11,57 +11,57 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_AST_TYPEINFOBUILDER_HPP
-#define MRDOCS_LIB_AST_TYPEINFOBUILDER_HPP
+#ifndef MRDOCS_LIB_AST_TYPEBUILDER_HPP
+#define MRDOCS_LIB_AST_TYPEBUILDER_HPP
 
 #include <lib/AST/TerminalTypeVisitor.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
-/** A visitor to build a `mrdocs::TypeInfo` from a `clang::Type`.
+/** A visitor to build a `mrdocs::Type` from a `clang::Type`.
 
     This class is used to build type information by visiting
     various terminal types. The method `Visit` from the
     base class can be used to iterate over the type information
-    and build the corresponding `TypeInfo` object:
+    and build the corresponding `Type` object:
 
     @code
-    TypeInfoBuilder Builder(astVisitor);
+    TypeBuilder Builder(astVisitor);
     Builder.Visit(qt);
-    std::unique_ptr<TypeInfo> typeInfo = Builder.result();
+    std::unique_ptr<Type> typeInfo = Builder.result();
     @endcode
  */
-class TypeInfoBuilder
-    : public TerminalTypeVisitor<TypeInfoBuilder>
+class TypeBuilder
+    : public TerminalTypeVisitor<TypeBuilder>
 {
-    /* The resulting of converting a QualType to a TypeInfo
+    /* The resulting of converting a QualType to a Type
 
        This variable holds the result of the type information
-       as a polymorphic `TypeInfo` object.
+       as a polymorphic `Type` object.
 
      */
-    Polymorphic<TypeInfo> Result = Polymorphic<TypeInfo>(AutoTypeInfo{});
+    Polymorphic<Type> Result = Polymorphic<Type>(AutoType{});
 
     /*  A pointer to the inner type of result currently being populated.
 
-        The Result variable is a polymorphic `TypeInfo` object that
+        The Result variable is a polymorphic `Type` object that
         might contain nested type information, also represented
-        as a `TypeInfo` object.
+        as a `Type` object.
 
-        For instance `int&` is represented as a `ReferenceTypeInfo`
-        object that contains a `NamedTypeInfo` object representing
+        For instance `int&` is represented as a `ReferenceType`
+        object that contains a `NamedType` object representing
         the `int` type.
 
         The builder will always populate the inner type of the
         result being constructed. For instance, when building
-        a `ReferenceTypeInfo` object for `int&`, the inner type
+        a `ReferenceType` object for `int&`, the inner type
         (initially the same as the result) will be set to a
-        `LValueReferenceTypeInfo`, that contains the `NamedTypeInfo`
+        `LValueReferenceType`, that contains the `NamedType`
         as a member. So `Inner` becomes a pointer to this
-        `NamedTypeInfo` object, and the visiting process continues
+        `NamedType` object, and the visiting process continues
         populating the `Inner` object.
      */
-    Polymorphic<TypeInfo>* Inner = &Result;
+    Polymorphic<Type>* Inner = &Result;
 
 public:
     using TerminalTypeVisitor::TerminalTypeVisitor;
@@ -69,11 +69,11 @@ class TypeInfoBuilder
     /** Get the result of the type information.
 
         This function returns the result of the type information
-        as a unique pointer to the `TypeInfo` object.
+        as a unique pointer to the `Type` object.
 
-        @return A unique pointer to the `TypeInfo` object.
+        @return A unique pointer to the `Type` object.
      */
-    Polymorphic<TypeInfo>
+    Polymorphic<Type>
     result()
     {
         return std::move(Result);
@@ -81,90 +81,90 @@ class TypeInfoBuilder
 
     /** Build type information for a pointer type.
 
-        Create a `PointerTypeInfo` object and populate it with
+        Create a `PointerType` object and populate it with
         the qualifiers and the pointee type.
 
         @param T The pointer type to build.
         @param quals The qualifiers for the pointer type.
      */
-    void buildPointer(PointerType const* T, unsigned quals);
+    void buildPointer(clang::PointerType const* T, unsigned quals);
 
     /** Build type information for a lvalue reference type.
 
-        Create a `LValueReferenceTypeInfo` object and populate it with
+        Create a `LValueReferenceType` object and populate it with
         the pointee type.
 
         @param T The lvalue reference type to build.
      */
-    void buildLValueReference(LValueReferenceType const* T);
+    void buildLValueReference(clang::LValueReferenceType const* T);
 
     /** Build type information for an rvalue reference type.
 
-        Create a `RValueReferenceTypeInfo` object and populate it with
+        Create a `RValueReferenceType` object and populate it with
         the pointee type.
 
         @param T The rvalue reference type to build.
      */
-    void buildRValueReference(RValueReferenceType const* T);
+    void buildRValueReference(clang::RValueReferenceType const* T);
 
     /** Build type information for a member pointer type.
 
-        Create a `MemberPointerTypeInfo` object and populate it with
+        Create a `MemberPointerType` object and populate it with
         the qualifiers and the parent type.
 
-        A `MemberPointerTypeInfo` object is used to represent a pointer
+        A `MemberPointerType` object is used to represent a pointer
         to a member of a class.
 
         @param T The member pointer type to build.
         @param quals The qualifiers for the member pointer type.
      */
-    void buildMemberPointer(MemberPointerType const* T, unsigned quals);
+    void buildMemberPointer(clang::MemberPointerType const* T, unsigned quals);
 
     /** Build type information for an array type.
 
-        Create an `ArrayTypeInfo` object and populate it with the
+        Create an `ArrayType` object and populate it with the
         element type and the array bounds.
 
-        An `ArrayTypeInfo` object is used to represent an array type.
-        It includes the internal `TypeInfo` object for the element type
+        An `ArrayType` object is used to represent an array type.
+        It includes the internal `Type` object for the element type
         and the expression defining the array bounds.
 
         @param T The array type to build.
      */
-    void buildArray(ArrayType const* T);
+    void buildArray(clang::ArrayType const* T);
 
     /** Populate type information for a function type.
 
-        Create a `FunctionTypeInfo` object and populate it with
+        Create a `FunctionType` object and populate it with
         the function type information.
 
-        A `FunctionTypeInfo` object is used to represent a function type.
+        A `FunctionType` object is used to represent a function type.
         It includes the return type and the parameter types.
 
         @param T The function type to populate.
      */
-    void populate(FunctionType const* T);
+    void populate(clang::FunctionType const* T);
 
     /** Build type information for a decltype type.
 
-        Create a `DecltypeTypeInfo` object and populate it with
+        Create a `DecltypeType` object and populate it with
         the underlying expression.
 
-        A `DecltypeTypeInfo` object is used to represent a decltype type.
+        A `DecltypeType` object is used to represent a decltype type.
         It includes the underlying expression.
 
         @param T The decltype type to build.
         @param quals The qualifiers for the decltype type.
         @param pack Whether the decltype type is a pack.
      */
-    void buildDecltype(DecltypeType const* T, unsigned quals, bool pack);
+    void buildDecltype(clang::DecltypeType const* T, unsigned quals, bool pack);
 
     /** Build type information for an auto type.
 
-        Create an `AutoTypeInfo` object and populate it with
+        Create an `AutoType` object and populate it with
         the qualifiers.
 
-        An `AutoTypeInfo` object is used to represent an auto type.
+        An `AutoType` object is used to represent an auto type.
         It includes the qualifiers for the auto type, the keyword
         used to declare the auto type, and constraints.
 
@@ -172,14 +172,14 @@ class TypeInfoBuilder
         @param quals The qualifiers for the auto type.
         @param pack Whether the auto type is a pack.
      */
-    void buildAuto(AutoType const* T, unsigned quals, bool pack);
+    void buildAuto(clang::AutoType const* T, unsigned quals, bool pack);
 
     /** Build type information for a terminal type.
 
-        Create a `NamedTypeInfo` object and populate it with
+        Create a `NamedType` object and populate it with
         the name information.
 
-        A `NamedTypeInfo` object is used to represent a terminal type.
+        A `NamedType` object is used to represent a terminal type.
         It includes the name information, the nested name specifier,
         and the qualifiers for the terminal type.
 
@@ -189,16 +189,16 @@ class TypeInfoBuilder
         @param pack Whether the terminal type is a pack.
      */
     void buildTerminal(
-        Type const* T,
+        clang::Type const* T,
         unsigned quals,
         bool pack);
 
     /** Build type information for a terminal type with an identifier.
 
-        Create a `NamedTypeInfo` object and populate it with
+        Create a `NamedType` object and populate it with
         the name information.
 
-        A `NamedTypeInfo` object is used to represent a terminal type.
+        A `NamedType` object is used to represent a terminal type.
         It includes the name information, the nested name specifier,
         and the qualifiers for the terminal type.
 
@@ -209,18 +209,18 @@ class TypeInfoBuilder
         @param pack Whether the terminal type is a pack.
      */
     void buildTerminal(
-        NestedNameSpecifier NNS,
-        IdentifierInfo const* II,
-        Optional<ArrayRef<TemplateArgument>> TArgs,
+        clang::NestedNameSpecifier NNS,
+        clang::IdentifierInfo const* II,
+        Optional<llvm::ArrayRef<clang::TemplateArgument>> TArgs,
         unsigned quals,
         bool pack);
 
     /** Build type information for a terminal type with a named declaration.
 
-        Create a `NamedTypeInfo` object and populate it with
+        Create a `NamedType` object and populate it with
         the name information.
 
-        A `NamedTypeInfo` object is used to represent a terminal type.
+        A `NamedType` object is used to represent a terminal type.
         It includes the name information, the nested name specifier,
         and the qualifiers for the terminal type.
 
@@ -231,13 +231,13 @@ class TypeInfoBuilder
         @param pack Whether the terminal type is a pack.
      */
     void buildTerminal(
-        NestedNameSpecifier NNS,
-        NamedDecl* D,
-        Optional<ArrayRef<TemplateArgument>> TArgs,
+        clang::NestedNameSpecifier NNS,
+        clang::NamedDecl* D,
+        Optional<llvm::ArrayRef<clang::TemplateArgument>> TArgs,
         unsigned quals,
         bool pack);
 };
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif
+#endif // MRDOCS_LIB_AST_TYPEBUILDER_HPP
diff --git a/src/lib/Config.cpp b/src/lib/Config.cpp
index 943c9302d..c6ad84735 100644
--- a/src/lib/Config.cpp
+++ b/src/lib/Config.cpp
@@ -14,7 +14,7 @@
 #include <mrdocs/Support/Report.hpp>
 #include <thread>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 Config::
 Config() noexcept
@@ -562,4 +562,4 @@ outputDir() const
     return files::getParentDir(output);
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/ConfigImpl.cpp b/src/lib/ConfigImpl.cpp
index 73bcd9c55..977a70b0e 100644
--- a/src/lib/ConfigImpl.cpp
+++ b/src/lib/ConfigImpl.cpp
@@ -23,7 +23,7 @@
 #include <llvm/Support/YAMLTraits.h>
 #include <utility>
 
-namespace clang {
+
 namespace mrdocs {
 
 namespace {
@@ -42,7 +42,7 @@ ConfigImpl(access_token, ThreadPool& threadPool)
 
 bool
 ConfigImpl::
-shouldVisitSymbol(StringRef filePath) const noexcept
+shouldVisitSymbol(llvm::StringRef filePath) const noexcept
 {
     if (settings_.input.empty())
     {
@@ -75,7 +75,7 @@ shouldVisitSymbol(StringRef filePath) const noexcept
 bool
 ConfigImpl::
 shouldExtractFromFile(
-    StringRef filePath,
+    llvm::StringRef filePath,
     std::string& prefixPath) const noexcept
 {
     namespace path = llvm::sys::path;
@@ -133,10 +133,10 @@ toDomObject(llvm::yaml::MappingNode* Object)
     dom::Object obj;
     for (auto &Pair : *Object)
     {
-        auto *KeyString = dyn_cast<llvm::yaml::ScalarNode>(Pair.getKey());
+        auto *KeyString = clang::dyn_cast<llvm::yaml::ScalarNode>(Pair.getKey());
         if (!KeyString) { continue; }
-        SmallString<10> KeyStorage;
-        StringRef KeyValue = KeyString->getValue(KeyStorage);
+        llvm::SmallString<10> KeyStorage;
+        llvm::StringRef KeyValue = KeyString->getValue(KeyStorage);
         llvm::yaml::Node *Value = Pair.getValue();
         if (!Value) {
             obj.set(KeyValue, dom::Kind::Undefined);
@@ -163,9 +163,9 @@ toDomArray(llvm::yaml::SequenceNode* Array)
 dom::Value
 toDomScalar(llvm::yaml::ScalarNode* Scalar)
 {
-    SmallString<10> ScalarStorage;
-    StringRef ScalarValue = Scalar->getValue(ScalarStorage);
-    StringRef RawValue = Scalar->getRawValue();
+    llvm::SmallString<10> ScalarStorage;
+    llvm::StringRef ScalarValue = Scalar->getValue(ScalarStorage);
+    llvm::StringRef RawValue = Scalar->getRawValue();
     bool const isEscaped = RawValue.size() != ScalarValue.size();
     if (isEscaped)
     {
@@ -196,17 +196,17 @@ toDomScalar(llvm::yaml::ScalarNode* Scalar)
 dom::Value
 toDom(llvm::yaml::Node* Value)
 {
-    auto *ValueObject = dyn_cast<llvm::yaml::MappingNode>(Value);
+    auto *ValueObject = clang::dyn_cast<llvm::yaml::MappingNode>(Value);
     if (ValueObject)
     {
         return toDomObject(ValueObject);
     }
-    auto *ValueArray = dyn_cast<llvm::yaml::SequenceNode>(Value);
+    auto *ValueArray = clang::dyn_cast<llvm::yaml::SequenceNode>(Value);
     if (ValueArray)
     {
         return toDomArray(ValueArray);
     }
-    auto *ValueString = dyn_cast<llvm::yaml::ScalarNode>(Value);
+    auto *ValueString = clang::dyn_cast<llvm::yaml::ScalarNode>(Value);
     if (ValueString)
     {
         return toDomScalar(ValueString);
@@ -246,7 +246,7 @@ toDomObject(std::string_view yaml)
         return {};
     }
     llvm::yaml::Node *Root = I->getRoot();
-    auto *Object = dyn_cast<llvm::yaml::MappingNode>(Root);
+    auto *Object = clang::dyn_cast<llvm::yaml::MappingNode>(Root);
     if (!Object)
     {
         return {};
@@ -320,4 +320,4 @@ updateConfigDom()
 
 
 } // mrdocs
-} // clang
+
diff --git a/src/lib/ConfigImpl.hpp b/src/lib/ConfigImpl.hpp
index 495653210..05d8d0b6e 100644
--- a/src/lib/ConfigImpl.hpp
+++ b/src/lib/ConfigImpl.hpp
@@ -19,7 +19,7 @@
 #include <llvm/Support/ThreadPool.h>
 #include <memory>
 
-namespace clang {
+
 namespace mrdocs {
 
 /* Private configuration implementation.
@@ -159,6 +159,6 @@ class ConfigImpl
 
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_LIB_CONFIGIMPL_HPP
diff --git a/src/lib/Corpus.cpp b/src/lib/Corpus.cpp
index 2d2bd391f..cf8ed6ab3 100644
--- a/src/lib/Corpus.cpp
+++ b/src/lib/Corpus.cpp
@@ -15,7 +15,7 @@
 #include <mrdocs/Support/Error.hpp>
 #include <ranges>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 //------------------------------------------------
 
@@ -36,11 +36,11 @@ empty() const noexcept
 
 /** Return the metadata for the global namespace.
 */
-NamespaceInfo const&
+NamespaceSymbol const&
 Corpus::
 globalNamespace() const noexcept
 {
-    return get<NamespaceInfo>(SymbolID::global);
+    return get<NamespaceSymbol>(SymbolID::global);
 }
 
 //------------------------------------------------
@@ -50,7 +50,7 @@ globalNamespace() const noexcept
 //------------------------------------------------
 
 std::vector<SymbolID>
-getParents(Corpus const& C, Info const& I)
+getParents(Corpus const& C, Symbol const& I)
 {
     std::vector<SymbolID> parents;
     std::size_t n = 0;
@@ -73,4 +73,4 @@ getParents(Corpus const& C, Info const& I)
     return parents;
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/CorpusImpl.cpp b/src/lib/CorpusImpl.cpp
index db42ac187..c8f68a0ed 100644
--- a/src/lib/CorpusImpl.cpp
+++ b/src/lib/CorpusImpl.cpp
@@ -29,7 +29,7 @@
 #include <mrdocs/Support/ThreadPool.hpp>
 #include <chrono>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 auto
 CorpusImpl::
@@ -41,8 +41,7 @@ begin() const noexcept ->
     // KRYSTIAN NOTE: this is far from ideal, but i'm not sure
     // to what extent implementation detail should be hidden.
     return iterator(this, info_.begin()->get(),
-        [](Corpus const* corpus, Info const* val) ->
-            Info const*
+        [](Corpus const* corpus, Symbol const* val) -> Symbol const*
         {
             MRDOCS_ASSERT(val);
             CorpusImpl const* impl =
@@ -62,7 +61,7 @@ end() const noexcept ->
     return iterator();
 }
 
-Info*
+Symbol*
 CorpusImpl::
 find(
     SymbolID const& id) noexcept
@@ -75,7 +74,7 @@ find(
     return nullptr;
 }
 
-Info const*
+Symbol const*
 CorpusImpl::
 find(SymbolID const& id) const noexcept
 {
@@ -89,7 +88,7 @@ find(SymbolID const& id) const noexcept
 
 namespace {
 bool
-isTransparent(Info const& info)
+isTransparent(Symbol const& info)
 {
     return visit(info, []<typename InfoTy>(
         InfoTy const& I) -> bool
@@ -108,7 +107,7 @@ isTransparent(Info const& info)
 
 SymbolID
 findFirstParentInfo(
-    InfoSet const& info,
+    SymbolSet const& info,
     SymbolID const& contextID)
 {
     SymbolID currentID = contextID;
@@ -123,7 +122,7 @@ findFirstParentInfo(
         bool const isParent = visit(context, []<typename InfoTy>(
             InfoTy const& I) -> bool
         {
-            return InfoParent<InfoTy>;
+            return SymbolParent<InfoTy>;
         });
         if (isParent)
         {
@@ -135,19 +134,19 @@ findFirstParentInfo(
 
 bool
 qualifiedNameCompare(
-    Polymorphic<NameInfo> const& lhs0,
-    Polymorphic<NameInfo> const& rhs0,
-    Info const& context,
+    Polymorphic<Name> const& lhs0,
+    Polymorphic<Name> const& rhs0,
+    Symbol const& context,
     CorpusImpl const& corpus)
 {
     MRDOCS_ASSERT(!lhs0.valueless_after_move());
     MRDOCS_ASSERT(!rhs0.valueless_after_move());
     // Compare each component of the qualified name
-    NameInfo const* lhs = &*lhs0;
-    NameInfo const* rhs = &*rhs0;
+    Name const* lhs = &*lhs0;
+    Name const* rhs = &*rhs0;
     while (lhs && rhs)
     {
-        if (lhs->Name != rhs->Name)
+        if (lhs->Identifier != rhs->Identifier)
         {
             return false;
         }
@@ -163,13 +162,13 @@ qualifiedNameCompare(
     // these component should match the names from
     // the context. When we doesn't match the context
     // we try again with the parent context.
-    NameInfo const* curName0 = lhs ? lhs : rhs;
-    Info const* curContext0 = &context;
-    NameInfo const* curName = curName0;
-    Info const* curContext = curContext0;
+    Name const* curName0 = lhs ? lhs : rhs;
+    Symbol const* curContext0 = &context;
+    Name const* curName = curName0;
+    Symbol const* curContext = curContext0;
     while (curName && curContext)
     {
-        if (curName->Name != curContext->Name)
+        if (curName->Identifier != curContext->Name)
         {
             // The name doesn't match the context name
             // Try again, starting from the parent
@@ -195,9 +194,9 @@ qualifiedNameCompare(
 template <bool isInner>
 bool
 isDecayedEqualImpl(
-    Optional<Polymorphic<TypeInfo>> const& lhs,
-    Optional<Polymorphic<TypeInfo>> const& rhs,
-    Info const& context,
+    Optional<Polymorphic<Type>> const& lhs,
+    Optional<Polymorphic<Type>> const& rhs,
+    Symbol const& context,
     CorpusImpl const& corpus);
 
 // Check if two types are equal after decay
@@ -211,15 +210,15 @@ isDecayedEqualImpl(
 template <bool isInner>
 bool
 isDecayedEqualImpl(
-    Polymorphic<TypeInfo> const& lhs,
-    Polymorphic<TypeInfo> const& rhs,
-    Info const& context,
+    Polymorphic<Type> const& lhs,
+    Polymorphic<Type> const& rhs,
+    Symbol const& context,
     CorpusImpl const& corpus)
 {
     // Polymorphic
     MRDOCS_ASSERT(!lhs.valueless_after_move());
     MRDOCS_ASSERT(!rhs.valueless_after_move());
-    // TypeInfo
+    // Type
     bool const decayToPointer = !isInner && (lhs->isArray() || rhs->isArray());
     if (!decayToPointer)
     {
@@ -244,7 +243,7 @@ isDecayedEqualImpl(
     {
     // Types that never decay are compared directly, but we
     // only compare the fields of the type, without reevaluating
-    // the fields of TypeInfo.
+    // the fields of Type.
     case TypeKind::Named:
     {
         return
@@ -277,22 +276,22 @@ isDecayedEqualImpl(
     {
         return
             isDecayedEqualImpl<true>(
-                dynamic_cast<RValueReferenceTypeInfo const&>(*lhs).PointeeType,
-                dynamic_cast<RValueReferenceTypeInfo const&>(*rhs).PointeeType,
+                dynamic_cast<RValueReferenceType const&>(*lhs).PointeeType,
+                dynamic_cast<RValueReferenceType const&>(*rhs).PointeeType,
                 context, corpus);
     }
     case TypeKind::MemberPointer:
     {
-        auto const& lhsMP = dynamic_cast<MemberPointerTypeInfo const&>(*lhs);
-        auto const& rhsMP = dynamic_cast<MemberPointerTypeInfo const&>(*rhs);
+        auto const& lhsMP = dynamic_cast<MemberPointerType const&>(*lhs);
+        auto const& rhsMP = dynamic_cast<MemberPointerType const&>(*rhs);
         return
             isDecayedEqualImpl<true>(lhsMP.PointeeType, rhsMP.PointeeType, context, corpus) &&
             isDecayedEqualImpl<true>(lhsMP.ParentType, rhsMP.ParentType, context, corpus);
     }
     case TypeKind::Function:
     {
-        auto const& lhsF = dynamic_cast<FunctionTypeInfo const&>(*lhs);
-        auto const& rhsF = dynamic_cast<FunctionTypeInfo const&>(*rhs);
+        auto const& lhsF = dynamic_cast<FunctionType const&>(*lhs);
+        auto const& rhsF = dynamic_cast<FunctionType const&>(*rhs);
         MRDOCS_CHECK_OR(lhsF.RefQualifier == rhsF.RefQualifier, false);
         MRDOCS_CHECK_OR(lhsF.ExceptionSpec == rhsF.ExceptionSpec, false);
         MRDOCS_CHECK_OR(lhsF.IsVariadic == rhsF.IsVariadic, false);
@@ -326,9 +325,9 @@ isDecayedEqualImpl(
 template <bool isInner>
 bool
 isDecayedEqualImpl(
-    Optional<Polymorphic<TypeInfo>> const& lhs,
-    Optional<Polymorphic<TypeInfo>> const& rhs,
-    Info const& context,
+    Optional<Polymorphic<Type>> const& lhs,
+    Optional<Polymorphic<Type>> const& rhs,
+    Symbol const& context,
     CorpusImpl const& corpus)
 {
     MRDOCS_CHECK_OR(static_cast<bool>(lhs) == static_cast<bool>(rhs), false);
@@ -341,9 +340,9 @@ isDecayedEqualImpl(
  */
 bool
 isDecayedEqual(
-    Polymorphic<TypeInfo> const& lhs,
-    Polymorphic<TypeInfo> const& rhs,
-    Info const& context,
+    Polymorphic<Type> const& lhs,
+    Polymorphic<Type> const& rhs,
+    Symbol const& context,
     CorpusImpl const& corpus)
 {
     return isDecayedEqualImpl<false>(lhs, rhs, context, corpus);
@@ -353,7 +352,7 @@ bool
 isDecayedEqual(
     Polymorphic<TArg> const& lhs,
     Polymorphic<TArg> const& rhs,
-    Info const& context,
+    Symbol const& context,
     CorpusImpl const& corpus)
 {
     if (lhs->Kind != rhs->Kind)
@@ -375,14 +374,14 @@ isDecayedEqual(
 }
 }
 
-Expected<Info const&>
+Expected<Symbol const&>
 CorpusImpl::
 lookup(SymbolID const& context, std::string_view const name) const
 {
     return lookupImpl(*this, context, name);
 }
 
-Expected<Info const&>
+Expected<Symbol const&>
 CorpusImpl::
 lookup(SymbolID const& context, std::string_view name)
 {
@@ -390,7 +389,7 @@ lookup(SymbolID const& context, std::string_view name)
 }
 
 template <class Self>
-Expected<Info const&>
+Expected<Symbol const&>
 CorpusImpl::
 lookupImpl(Self&& self, SymbolID const& contextId0, std::string_view name)
 {
@@ -421,7 +420,7 @@ lookupImpl(Self&& self, SymbolID const& contextId0, std::string_view name)
         return Unexpected(formatError("Failed to parse '{}'\n     {}", name, expRef.error().reason()));
     }
     ParsedRef const& ref = *std::move(expRef);
-    Info const* res = lookupImpl(self, contextId, ref, name, false);
+    Symbol const* res = lookupImpl(self, contextId, ref, name, false);
     if (!res)
     {
         auto const contextPtr = self.find(contextId);
@@ -438,7 +437,7 @@ lookupImpl(Self&& self, SymbolID const& contextId0, std::string_view name)
 }
 
 template <class Self>
-Info const*
+Symbol const*
 CorpusImpl::
 lookupImpl(
     Self&& self,
@@ -456,12 +455,12 @@ lookupImpl(
         }
     }
 
-    Info const* contextPtr = self.find(contextId);
+    Symbol const* contextPtr = self.find(contextId);
     MRDOCS_CHECK_OR(contextPtr, nullptr);
     report::trace("    Context: '{}'", contextPtr->Name);
 
     // Check the current contextId
-    Info const* curContext = contextPtr;
+    Symbol const* curContext = contextPtr;
     for (std::size_t i = 0; i < ref.Components.size(); ++i)
     {
         ParsedRefComponent const& component = ref.Components[i];
@@ -479,13 +478,13 @@ lookupImpl(
     }
 
     // Fallback to parent contextId
-    Info const& contextInfo = *contextPtr;
-    Info const* res = lookupImpl(self, contextInfo.Parent, ref, name, true);
+    Symbol const& contextInfo = *contextPtr;
+    Symbol const* res = lookupImpl(self, contextInfo.Parent, ref, name, true);
     self.lookupCacheSet(contextId, name, res);
     return res;
 }
 
-Info const*
+Symbol const*
 CorpusImpl::
 lookupImpl(
     SymbolID const& contextId,
@@ -495,7 +494,7 @@ lookupImpl(
 {
     report::trace("Looking up component '{}'", component.Name);
     // 1. Find context
-    Info const* contextPtr = this->find(contextId);
+    Symbol const* contextPtr = this->find(contextId);
     MRDOCS_CHECK_OR(contextPtr, nullptr);
     report::trace("    Context: '{}'", contextPtr->Name);
 
@@ -508,16 +507,16 @@ lookupImpl(
         contextPtr = this->find(resolvedSymbolID);
         MRDOCS_CHECK_OR(contextPtr, nullptr);
     }
-    Info const& context = *contextPtr;
+    Symbol const& context = *contextPtr;
 
     // 2. Get a list of members
     report::trace("    Finding members of context '{}'", contextPtr->Name);
-    SmallVector<SymbolID, 128> memberIDs;
-    auto pushAllMembersOf = [&](Info const& I)
+    llvm::SmallVector<SymbolID, 128> memberIDs;
+    auto pushAllMembersOf = [&](Symbol const& I)
     {
-        visit(I, [&]<typename CInfoTy>(CInfoTy const& C) -> Info const*
+        visit(I, [&]<typename CInfoTy>(CInfoTy const& C) -> Symbol const*
         {
-            if constexpr (InfoParent<CInfoTy>)
+            if constexpr (SymbolParent<CInfoTy>)
             {
                 for (SymbolID const& MId : allMembers(C))
                 {
@@ -535,7 +534,7 @@ lookupImpl(
     for (std::size_t i = 0; i < rootMembersSize; ++i)
     {
         SymbolID const& id = memberIDs[i];
-        Info const* I = find(id);
+        Symbol const* I = find(id);
         MRDOCS_CHECK_OR_CONTINUE(I);
         MRDOCS_CHECK_OR_CONTINUE(I->isOverloads());
         pushAllMembersOf(*I);
@@ -560,12 +559,12 @@ lookupImpl(
             MatchLevel::TemplateArgs :
             MatchLevel::Qualifiers;
     auto matchLevel = MatchLevel::None;
-    Info const* res = nullptr;
+    Symbol const* res = nullptr;
     for (SymbolID const& memberID : memberIDs)
     {
-        Info const* memberPtr = find(memberID);
+        Symbol const* memberPtr = find(memberID);
         MRDOCS_CHECK_OR_CONTINUE(memberPtr);
-        Info const& member = *memberPtr;
+        Symbol const& member = *memberPtr;
         report::trace("    Attempting to match {} '{}'", toString(member.Kind), member.Name);
         MatchLevel const memberMatchLevel =
             visit(member, [&]<typename MInfoTy>(MInfoTy const& M)
@@ -575,8 +574,8 @@ lookupImpl(
 
             // Name match
             if constexpr (
-                std::same_as<MInfoTy, FunctionInfo> ||
-                std::same_as<MInfoTy, OverloadsInfo>)
+                std::same_as<MInfoTy, FunctionSymbol> ||
+                std::same_as<MInfoTy, OverloadsSymbol>)
             {
                 if (component.isOperator())
                 {
@@ -653,7 +652,7 @@ lookupImpl(
             MRDOCS_CHECK_OR(F.IsExplicitObjectMemberFunction == ref.IsExplicitObjectMemberFunction, matchRes);
             for (std::size_t i = 0; i < F.Params.size(); ++i)
             {
-                Polymorphic<TypeInfo> const& lhsType = F.Params[i].Type;
+                Polymorphic<Type> const& lhsType = F.Params[i].Type;
                 MRDOCS_ASSERT(!lhsType.valueless_after_move());
                 auto& rhsType  = ref.FunctionParameters[i];
                 MRDOCS_CHECK_OR(isDecayedEqual(lhsType, rhsType, context, *this), matchRes);
@@ -699,11 +698,11 @@ lookupImpl(
     report::trace("    Looking up in transparent contexts");
     for (SymbolID const& memberID : memberIDs)
     {
-        Info const* memberPtr = find(memberID);
+        Symbol const* memberPtr = find(memberID);
         MRDOCS_CHECK_OR_CONTINUE(memberPtr);
-        Info const& member = *memberPtr;
+        Symbol const& member = *memberPtr;
         MRDOCS_CHECK_OR_CONTINUE(isTransparent(member));
-        if (Info const* r = lookupImpl(member.id, component, ref, checkParameters))
+        if (Symbol const* r = lookupImpl(member.id, component, ref, checkParameters))
         {
             return r;
         }
@@ -713,7 +712,7 @@ lookupImpl(
     return nullptr;
 }
 
-std::pair<Info const*, bool>
+std::pair<Symbol const*, bool>
 CorpusImpl::
 lookupCacheGet(
     SymbolID const& context,
@@ -738,7 +737,7 @@ CorpusImpl::
 lookupCacheSet(
     SymbolID const& contextId,
     std::string_view name,
-    Info const* info)
+    Symbol const* info)
 {
     lookupCache_[contextId][std::string(name)] = info;
 }
@@ -750,7 +749,7 @@ mrdocs::Expected<std::unique_ptr<Corpus>>
 CorpusImpl::
 build(
     std::shared_ptr<ConfigImpl const> const& config,
-    tooling::CompilationDatabase const& compilations)
+    clang::tooling::CompilationDatabase const& compilations)
 {
     using clock_type = std::chrono::steady_clock;
     auto start_time = clock_type::now();
@@ -767,7 +766,7 @@ build(
     // Create an execution context to store the
     // results of the AST traversal.
     // Any new Info objects will be added to the
-    // InfoSet in the execution context.
+    // SymbolSet in the execution context.
     InfoExecutionContext context(*config);
 
     // ------------------------------------------
@@ -796,8 +795,8 @@ build(
                 && "createMrDocsFileSystem must return MrDocsFileSystem");
 
             // Create a Clang Tool to run the action
-            auto PHCCOntainerOps = std::make_shared<PCHContainerOperations>();
-            tooling::ClangTool
+            auto PHCCOntainerOps = std::make_shared<clang::PCHContainerOperations>();
+            clang::tooling::ClangTool
                 Tool(compilations, { path }, std::move(PHCCOntainerOps), FS);
             Tool.setPrintErrorMessage(false);
 
@@ -829,9 +828,9 @@ build(
                 std::string shimPath = makeShimPathPlatformAbsolute();
                 FSConcrete->addVirtualFile(shimPath, shimContent);
                 Tool.appendArgumentsAdjuster(
-                    tooling::combineAdjusters(
-                        tooling::getInsertArgumentAdjuster("-include"),
-                        tooling::getInsertArgumentAdjuster(shimPath.data())));
+                    clang::tooling::combineAdjusters(
+                        clang::tooling::getInsertArgumentAdjuster("-include"),
+                        clang::tooling::getInsertArgumentAdjuster(shimPath.data())));
             }
 
             // Run the action
@@ -955,7 +954,7 @@ build(
 
 void
 CorpusImpl::
-qualifiedName(Info const& I, std::string& result) const
+qualifiedName(Symbol const& I, std::string& result) const
 {
     result.clear();
     if (!I.id || I.id == SymbolID::global)
@@ -966,7 +965,7 @@ qualifiedName(Info const& I, std::string& result) const
     if (I.Parent &&
         I.Parent != SymbolID::global)
     {
-        if (Info const* PI = find(I.Parent))
+        if (Symbol const* PI = find(I.Parent))
         {
             qualifiedName(*PI, result);
             result += "::";
@@ -987,7 +986,7 @@ qualifiedName(Info const& I, std::string& result) const
 void
 CorpusImpl::
 qualifiedName(
-    Info const& I,
+    Symbol const& I,
     SymbolID const& context,
     std::string& result) const
 {
@@ -1007,7 +1006,7 @@ qualifiedName(
         !is_one_of(I.Parent, {SymbolID::global, context}) &&
         I.id != context)
     {
-        if (Info const* PI = find(I.Parent))
+        if (Symbol const* PI = find(I.Parent))
         {
             qualifiedName(*PI, context, result);
             result += "::";
@@ -1083,4 +1082,4 @@ CorpusImpl::finalize()
     }
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/CorpusImpl.hpp b/src/lib/CorpusImpl.hpp
index 2a0c7efd1..c0e0f5b12 100644
--- a/src/lib/CorpusImpl.hpp
+++ b/src/lib/CorpusImpl.hpp
@@ -15,7 +15,7 @@
 #include <mrdocs/Platform.hpp>
 #include <lib/AST/ParseRef.hpp>
 #include <lib/ConfigImpl.hpp>
-#include <lib/Metadata/InfoSet.hpp>
+#include <lib/Metadata/SymbolSet.hpp>
 #include <lib/Support/Debug.hpp>
 #include <mrdocs/ADT/UnorderedStringMap.hpp>
 #include <mrdocs/Corpus.hpp>
@@ -28,7 +28,7 @@
 #include <set>
 #include <string>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Implements the Corpus.
 
@@ -45,15 +45,15 @@ class CorpusImpl final : public Corpus
     std::shared_ptr<ConfigImpl const> config_;
 
     // Info keyed on Symbol ID.
-    InfoSet info_;
+    SymbolSet info_;
 
     // Undocumented symbols
-    UndocumentedInfoSet undocumented_;
+    UndocumentedSymbolSet undocumented_;
 
     // Lookup cache
     // The key represents the context symbol ID.
     // The value is another map from the name to the Info.
-    std::map<SymbolID, UnorderedStringMap<Info const*>> lookupCache_;
+    std::map<SymbolID, UnorderedStringMap<Symbol const*>> lookupCache_;
 
     friend class Corpus;
     friend class BaseMembersFinalizer;
@@ -88,10 +88,10 @@ class CorpusImpl final : public Corpus
 
         If the id does not exist, the behavior is undefined.
     */
-    Info*
+    Symbol*
     find(SymbolID const& id) noexcept;
 
-    Info const*
+    Symbol const*
     find(SymbolID const& id) const noexcept override;
 
     /** Return a range of Info objects for the specified Symbol IDs.
@@ -103,15 +103,15 @@ class CorpusImpl final : public Corpus
         return
             std::views::transform(
                 range,
-                [this](SymbolID const& id) -> Info*
+                [this](SymbolID const& id) -> Symbol*
                 {
                     return this->find(id);
                 }) |
-            std::views::filter([](Info const* info)
+            std::views::filter([](Symbol const* info)
                 {
                     return info != nullptr;
                 }) |
-            std::views::transform([](Info* info) -> Info&
+            std::views::transform([](Symbol* info) -> Symbol&
                 {
                     return *info;
                 }) |
@@ -127,25 +127,25 @@ class CorpusImpl final : public Corpus
         return
             std::views::transform(
                 range,
-                [this](SymbolID const& id) -> Info const*
+                [this](SymbolID const& id) -> Symbol const*
                 {
                     return this->find(id);
                 }) |
-            std::views::filter([](Info const* info)
+            std::views::filter([](Symbol const* info)
                 {
                     return info != nullptr;
                 }) |
-            std::views::transform([](Info const* info) -> Info const&
+            std::views::transform([](Symbol const* info) -> Symbol const&
                 {
                     return *info;
                 }) |
             std::views::common;
     }
 
-    Expected<Info const&>
+    Expected<Symbol const&>
     lookup(SymbolID const& context, std::string_view name) const override;
 
-    Expected<Info const&>
+    Expected<Symbol const&>
     lookup(SymbolID const& context, std::string_view name);
 
     /** Build metadata for a set of translation units.
@@ -169,16 +169,14 @@ class CorpusImpl final : public Corpus
     mrdocs::Expected<std::unique_ptr<Corpus>>
     build(
         std::shared_ptr<ConfigImpl const> const& config,
-        tooling::CompilationDatabase const& compilations);
+        clang::tooling::CompilationDatabase const& compilations);
 
     void
-    qualifiedName(
-        Info const& I,
+    qualifiedName(Symbol const& I,
         std::string& result) const override;
 
     void
-    qualifiedName(
-        Info const& I,
+    qualifiedName(Symbol const& I,
         SymbolID const& context,
         std::string& result) const override;
 
@@ -198,15 +196,14 @@ class CorpusImpl final : public Corpus
 
     template <class Self>
     static
-    Expected<Info const&>
+    Expected<Symbol const&>
     lookupImpl(
         Self&& self,
         SymbolID const& contextId,
         std::string_view name);
 
     template <class Self>
-    static
-    Info const*
+    static Symbol const*
     lookupImpl(
         Self&& self,
         SymbolID const& context,
@@ -214,14 +211,14 @@ class CorpusImpl final : public Corpus
         std::string_view name,
         bool cache);
 
-    Info const*
+    Symbol const*
     lookupImpl(
         SymbolID const& contextId,
         ParsedRefComponent const& component,
         ParsedRef const& ref,
         bool checkParameters) const;
 
-    std::pair<Info const*, bool>
+    std::pair<Symbol const*, bool>
     lookupCacheGet(
         SymbolID const& context,
         std::string_view name) const;
@@ -230,13 +227,12 @@ class CorpusImpl final : public Corpus
     lookupCacheSet(
         SymbolID const& context,
         std::string_view name,
-        Info const* info);
+        Symbol const* info);
 
     void
     lookupCacheSet(
         SymbolID const&,
-        std::string_view,
-        Info const*) const
+        std::string_view, Symbol const*) const
     {
         // no-op when const
     }
@@ -251,11 +247,11 @@ get(
     auto I = find(id);
     MRDOCS_ASSERT(I != nullptr);
     auto const t = static_cast<T*>(I);
-    if constexpr(! std::is_same_v<T, Info>)
+    if constexpr(! std::is_same_v<T, Symbol>)
         MRDOCS_ASSERT(t->Kind == T::kind_id);
     return *t;
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_LIB_CORPUSIMPL_HPP
diff --git a/src/lib/Diagnostics.hpp b/src/lib/Diagnostics.hpp
index 010b35bda..5f9499c95 100644
--- a/src/lib/Diagnostics.hpp
+++ b/src/lib/Diagnostics.hpp
@@ -17,7 +17,7 @@
 #include <string>
 #include <unordered_map>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** Diagnostic information accumulated during visitation.
@@ -139,6 +139,6 @@ class Diagnostics
 };
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_LIB_DIAGNOSTICS_HPP
diff --git a/src/lib/Dom/Array.cpp b/src/lib/Dom/Array.cpp
index c2df24665..3e395599e 100644
--- a/src/lib/Dom/Array.cpp
+++ b/src/lib/Dom/Array.cpp
@@ -10,7 +10,7 @@
 
 #include <mrdocs/Dom/Array.hpp>
 
-namespace clang {
+
 namespace mrdocs {
 namespace dom {
 
@@ -220,4 +220,4 @@ type_key() const noexcept
 
 } // dom
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Dom/Function.cpp b/src/lib/Dom/Function.cpp
index 34baf5530..0ec509967 100644
--- a/src/lib/Dom/Function.cpp
+++ b/src/lib/Dom/Function.cpp
@@ -10,7 +10,7 @@
 
 #include <mrdocs/Dom/Function.hpp>
 
-namespace clang {
+
 namespace mrdocs {
 namespace dom {
 
@@ -89,4 +89,4 @@ type_key() const noexcept
 
 } // dom
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Dom/Object.cpp b/src/lib/Dom/Object.cpp
index 379ad5e99..bec43d3e7 100644
--- a/src/lib/Dom/Object.cpp
+++ b/src/lib/Dom/Object.cpp
@@ -14,7 +14,7 @@
 #include <format>
 #include <ranges>
 
-namespace clang {
+
 namespace mrdocs {
 namespace dom {
 
@@ -208,4 +208,4 @@ DefaultObjectImpl::exists(std::string_view key) const {
 
 } // dom
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Dom/String.cpp b/src/lib/Dom/String.cpp
index 538f457e0..f14a7e1be 100644
--- a/src/lib/Dom/String.cpp
+++ b/src/lib/Dom/String.cpp
@@ -12,7 +12,7 @@
 #include <atomic>
 #include <cstring>
 
-namespace clang {
+
 namespace mrdocs {
 namespace dom {
 
@@ -139,4 +139,4 @@ data() const noexcept
 
 } // dom
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Dom/Value.cpp b/src/lib/Dom/Value.cpp
index 83eb6ce1e..49457c72e 100644
--- a/src/lib/Dom/Value.cpp
+++ b/src/lib/Dom/Value.cpp
@@ -12,7 +12,7 @@
 #include <algorithm>
 #include <unordered_set>
 
-namespace clang {
+
 namespace mrdocs {
 namespace dom {
 
@@ -91,7 +91,7 @@ Value(
     Value&& other) noexcept
     : kind_(other.kind_)
 {
-    using enum clang::mrdocs::dom::Kind;
+    using enum mrdocs::dom::Kind;
     switch(kind_)
     {
     case Undefined:
@@ -481,7 +481,7 @@ empty() const
 {
     switch(kind_)
     {
-    using enum clang::mrdocs::dom::Kind;
+    using enum mrdocs::dom::Kind;
     case Undefined:
     case Null:
         return true;
@@ -508,7 +508,7 @@ size() const
 {
     switch(kind_)
     {
-    using enum clang::mrdocs::dom::Kind;
+    using enum mrdocs::dom::Kind;
     case Undefined:
     case Null:
         return 0;
@@ -899,4 +899,4 @@ toString(
 
 } // dom
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Gen/adoc/AdocEscape.cpp b/src/lib/Gen/adoc/AdocEscape.cpp
index c9461f6ca..29244a179 100644
--- a/src/lib/Gen/adoc/AdocEscape.cpp
+++ b/src/lib/Gen/adoc/AdocEscape.cpp
@@ -13,7 +13,7 @@
 #include <mrdocs/Support/Handlebars.hpp>
 #include <ranges>
 
-namespace clang::mrdocs::adoc {
+namespace mrdocs::adoc {
 
 namespace {
 
@@ -97,4 +97,4 @@ AdocEscape(std::string_view str) {
 }
 
 
-} // clang::mrdocs::adoc
+} // mrdocs::adoc
diff --git a/src/lib/Gen/adoc/AdocEscape.hpp b/src/lib/Gen/adoc/AdocEscape.hpp
index 514b94109..f01cfbdd8 100644
--- a/src/lib/Gen/adoc/AdocEscape.hpp
+++ b/src/lib/Gen/adoc/AdocEscape.hpp
@@ -17,7 +17,7 @@
 #include <string>
 #include <string_view>
 
-namespace clang::mrdocs::adoc {
+namespace mrdocs::adoc {
 
 /** Escape a string for use in AsciiDoc
   */
@@ -29,6 +29,6 @@ MRDOCS_DECL
 std::string
 AdocEscape(std::string_view str);
 
-} // clang::mrdocs::adoc
+} // mrdocs::adoc
 
 #endif
diff --git a/src/lib/Gen/adoc/AdocGenerator.cpp b/src/lib/Gen/adoc/AdocGenerator.cpp
index cdd7717a9..3a74512a4 100644
--- a/src/lib/Gen/adoc/AdocGenerator.cpp
+++ b/src/lib/Gen/adoc/AdocGenerator.cpp
@@ -13,7 +13,7 @@
 #include "AdocEscape.hpp"
 #include <mrdocs/Support/Handlebars.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 namespace adoc {
 
 void
@@ -31,4 +31,4 @@ makeAdocGenerator()
     return std::make_unique<adoc::AdocGenerator>();
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Gen/adoc/AdocGenerator.hpp b/src/lib/Gen/adoc/AdocGenerator.hpp
index e35f2b28b..382e231c5 100644
--- a/src/lib/Gen/adoc/AdocGenerator.hpp
+++ b/src/lib/Gen/adoc/AdocGenerator.hpp
@@ -17,7 +17,7 @@
 #include <lib/Gen/hbs/HandlebarsGenerator.hpp>
 #include <mrdocs/Generator.hpp>
 
-namespace clang::mrdocs::adoc {
+namespace mrdocs::adoc {
 
 class AdocGenerator final
     : public hbs::HandlebarsGenerator
@@ -46,6 +46,6 @@ class AdocGenerator final
     escape(OutputRef& os, std::string_view str) const override;
 };
 
-} // clang::mrdocs::adoc
+} // mrdocs::adoc
 
 #endif
diff --git a/src/lib/Gen/hbs/Builder.cpp b/src/lib/Gen/hbs/Builder.cpp
index a41ff4831..8cb40bf46 100644
--- a/src/lib/Gen/hbs/Builder.cpp
+++ b/src/lib/Gen/hbs/Builder.cpp
@@ -17,7 +17,7 @@
 #include <filesystem>
 #include <format>
 
-namespace clang {
+
 namespace mrdocs {
 
 namespace lua {
@@ -306,8 +306,7 @@ getRelPrefix(std::size_t depth)
 
 dom::Object
 Builder::
-createContext(
-    Info const& I)
+createContext(Symbol const& I)
 {
     dom::Object ctx;
     ctx.set("symbol", domCorpus.get(I.id));
@@ -315,7 +314,7 @@ createContext(
     return ctx;
 }
 
-template <std::derived_from<Info> T>
+template <std::derived_from<Symbol> T>
 Expected<void>
 Builder::
 operator()(std::ostream& os, T const& I)
@@ -347,9 +346,9 @@ operator()(std::ostream& os, T const& I)
     return callTemplate(os, wrapperFile, wrapperCtx);
 }
 
-// Compile the Builder::operator() for each Info type
-#define INFO(T) template Expected<void> Builder::operator()<T##Info>(std::ostream&, T##Info const&);
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
+// Compile the Builder::operator() for each Symbol type
+#define INFO(T) template Expected<void> Builder::operator()<T##Symbol>(std::ostream&, T##Symbol const&);
+#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
 
 Expected<void>
 Builder::
@@ -436,4 +435,4 @@ commonTemplatesDir(std::string_view const subdir) const
 
 } // hbs
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Gen/hbs/Builder.hpp b/src/lib/Gen/hbs/Builder.hpp
index 8b0ab4bfd..3f64e6f8a 100644
--- a/src/lib/Gen/hbs/Builder.hpp
+++ b/src/lib/Gen/hbs/Builder.hpp
@@ -20,7 +20,7 @@
 #include <mrdocs/Support/JavaScript.hpp>
 #include <ostream>
 
-namespace clang {
+
 namespace mrdocs {
 namespace hbs {
 
@@ -57,7 +57,7 @@ class Builder
         this function renders the wrapper template
         with the index template as the contents.
      */
-    template<std::derived_from<Info> T>
+    template<std::derived_from<Symbol> T>
     Expected<void>
     operator()(std::ostream& os, T const&);
 
@@ -112,7 +112,7 @@ class Builder
         the section where the symbol is located.
      */
     dom::Object
-    createContext(Info const& I);
+    createContext(Symbol const& I);
 
     /** Render a Handlebars template from the templates directory.
      */
@@ -126,6 +126,6 @@ class Builder
 
 } // hbs
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_LIB_GEN_HBS_BUILDER_HPP
diff --git a/src/lib/Gen/hbs/HandlebarsCorpus.cpp b/src/lib/Gen/hbs/HandlebarsCorpus.cpp
index 3535dd01b..5b2970c5f 100644
--- a/src/lib/Gen/hbs/HandlebarsCorpus.cpp
+++ b/src/lib/Gen/hbs/HandlebarsCorpus.cpp
@@ -16,11 +16,11 @@
 #include <mrdocs/Support/String.hpp>
 #include <iterator>
 
-namespace clang::mrdocs::hbs {
+namespace mrdocs::hbs {
 
 dom::Object
 HandlebarsCorpus::
-construct(Info const& I) const
+construct(Symbol const& I) const
 {
     dom::Object obj = this->DomCorpus::construct(I);
     if (shouldGenerate(I, getCorpus().config))
@@ -33,7 +33,7 @@ construct(Info const& I) const
     // If the URL is not available because it's a specialization
     // or dependency, we still want to generate the URL and anchor
     // for the primary template if it's part of the corpus.
-    if (Info const* primaryInfo = findAlternativeURLInfo(getCorpus(), I))
+    if (Symbol const* primaryInfo = findAlternativeURLInfo(getCorpus(), I))
     {
         MRDOCS_ASSERT(shouldGenerate(*primaryInfo, getCorpus().config));
         obj.set("url", getURL(*primaryInfo));
@@ -44,7 +44,7 @@ construct(Info const& I) const
 
 std::string
 HandlebarsCorpus::
-getURL(Info const& I) const
+getURL(Symbol const& I) const
 {
     bool const multipage = getCorpus().config->multipage;
     char const prefix = multipage ? '/' : '#';
@@ -59,4 +59,4 @@ getURL(Info const& I) const
     return href;
 }
 
-} // clang::mrdocs::hbs
+} // mrdocs::hbs
diff --git a/src/lib/Gen/hbs/HandlebarsCorpus.hpp b/src/lib/Gen/hbs/HandlebarsCorpus.hpp
index 0515901f6..73c85ba6f 100644
--- a/src/lib/Gen/hbs/HandlebarsCorpus.hpp
+++ b/src/lib/Gen/hbs/HandlebarsCorpus.hpp
@@ -18,7 +18,7 @@
 #include <mrdocs/Metadata/DomCorpus.hpp>
 #include <mrdocs/Metadata/Javadoc.hpp>
 
-namespace clang::mrdocs::hbs {
+namespace mrdocs::hbs {
 
 /** A specialized DomCorpus for generating Handlebars values.
 
@@ -59,7 +59,7 @@ class HandlebarsCorpus final : public DomCorpus
         @return A dom::Object representing the Info.
     */
     dom::Object
-    construct(Info const& I) const override;
+    construct(Symbol const& I) const override;
 
     /** Get the cross-reference for the given Info.
 
@@ -67,9 +67,9 @@ class HandlebarsCorpus final : public DomCorpus
         @return A string representing the cross-reference.
     */
     std::string
-    getURL(Info const& I) const;
+    getURL(Symbol const& I) const;
 };
 
-} // clang::mrdocs::hbs
+} // mrdocs::hbs
 
 #endif // MRDOCS_LIB_GEN_HBS_HANDLEBARSCORPUS_HPP
diff --git a/src/lib/Gen/hbs/HandlebarsGenerator.cpp b/src/lib/Gen/hbs/HandlebarsGenerator.cpp
index 64b018606..7ba936a9a 100644
--- a/src/lib/Gen/hbs/HandlebarsGenerator.cpp
+++ b/src/lib/Gen/hbs/HandlebarsGenerator.cpp
@@ -25,7 +25,7 @@
 #include <fstream>
 #include <sstream>
 
-namespace clang::mrdocs::hbs {
+namespace mrdocs::hbs {
 
 namespace {
 std::function<void(OutputRef&, std::string_view)>
@@ -213,4 +213,4 @@ escape(OutputRef& out, std::string_view str) const
     out << str;
 }
 
-} // clang::mrdocs::hbs
\ No newline at end of file
+} // mrdocs::hbs
\ No newline at end of file
diff --git a/src/lib/Gen/hbs/HandlebarsGenerator.hpp b/src/lib/Gen/hbs/HandlebarsGenerator.hpp
index 5aa4ffc21..f077f400a 100644
--- a/src/lib/Gen/hbs/HandlebarsGenerator.hpp
+++ b/src/lib/Gen/hbs/HandlebarsGenerator.hpp
@@ -18,7 +18,7 @@
 #include <mrdocs/Metadata/DomCorpus.hpp>
 #include <utility>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 class OutputRef;
 
@@ -61,6 +61,6 @@ class HandlebarsGenerator
 
 } // hbs
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/src/lib/Gen/hbs/MultiPageVisitor.cpp b/src/lib/Gen/hbs/MultiPageVisitor.cpp
index b77a578dd..5096b3f44 100644
--- a/src/lib/Gen/hbs/MultiPageVisitor.cpp
+++ b/src/lib/Gen/hbs/MultiPageVisitor.cpp
@@ -15,9 +15,9 @@
 #include <mrdocs/Support/Report.hpp>
 #include <fstream>
 
-namespace clang::mrdocs::hbs {
+namespace mrdocs::hbs {
 
-template <std::derived_from<Info> T>
+template <std::derived_from<Symbol> T>
 void
 MultiPageVisitor::
 operator()(T const& I)
@@ -68,12 +68,12 @@ operator()(T const& I)
         // ===================================
         // Traverse the symbol members
         // ===================================
-        Corpus::TraverseOptions opts = {.skipInherited = std::same_as<T, RecordInfo>};
+        Corpus::TraverseOptions opts = {.skipInherited = std::same_as<T, RecordSymbol>};
         corpus_.traverse(opts, I, *this);
     });
 }
 
-#define INFO(T) template void MultiPageVisitor::operator()<T##Info>(T##Info const&);
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
+#define INFO(T) template void MultiPageVisitor::operator()<T##Symbol>(T##Symbol const&);
+#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
 
-} // clang::mrdocs::hbs
+} // mrdocs::hbs
diff --git a/src/lib/Gen/hbs/MultiPageVisitor.hpp b/src/lib/Gen/hbs/MultiPageVisitor.hpp
index 13b306edf..61eab75de 100644
--- a/src/lib/Gen/hbs/MultiPageVisitor.hpp
+++ b/src/lib/Gen/hbs/MultiPageVisitor.hpp
@@ -13,7 +13,7 @@
 #define MRDOCS_LIB_GEN_HBS_MULTIPAGEVISITOR_HPP
 
 #include <lib/Gen/hbs/Builder.hpp>
-#include <mrdocs/Metadata/Info.hpp>
+#include <mrdocs/Metadata/Symbol.hpp>
 #include <mrdocs/Support/ExecutorGroup.hpp>
 #include <atomic>
 #include <mutex>
@@ -21,7 +21,7 @@
 #include <string>
 #include <vector>
 
-namespace clang::mrdocs::hbs {
+namespace mrdocs::hbs {
 
 /** Visitor which emites a multi-page reference.
 */
@@ -49,7 +49,7 @@ class MultiPageVisitor
         respective tasks are also pushed to the executor group.
 
     */
-    template <std::derived_from<Info> T>
+    template <std::derived_from<Symbol> T>
     void
     operator()(T const& I);
 
@@ -62,6 +62,6 @@ class MultiPageVisitor
     }
 };
 
-} // clang::mrdocs::hbs
+} // mrdocs::hbs
 
 #endif
diff --git a/src/lib/Gen/hbs/SinglePageVisitor.cpp b/src/lib/Gen/hbs/SinglePageVisitor.cpp
index 9c9fc9e8a..28cd26a3c 100644
--- a/src/lib/Gen/hbs/SinglePageVisitor.cpp
+++ b/src/lib/Gen/hbs/SinglePageVisitor.cpp
@@ -14,9 +14,9 @@
 #include <mrdocs/Support/unlock_guard.hpp>
 #include <sstream>
 
-namespace clang::mrdocs::hbs {
+namespace mrdocs::hbs {
 
-template <std::derived_from<Info> T>
+template <std::derived_from<Symbol> T>
 void
 SinglePageVisitor::
 operator()(T const& I)
@@ -38,12 +38,12 @@ operator()(T const& I)
             }
         });
     }
-    Corpus::TraverseOptions opts = {.skipInherited = std::same_as<T, RecordInfo>};
+    Corpus::TraverseOptions opts = {.skipInherited = std::same_as<T, RecordSymbol>};
     corpus_.traverse(opts, I, *this);
 }
 
-#define INFO(T) template void SinglePageVisitor::operator()<T##Info>(T##Info const&);
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
+#define INFO(T) template void SinglePageVisitor::operator()<T##Symbol>(T##Symbol const&);
+#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
 
 // pageNumber is zero-based
 void
@@ -97,4 +97,4 @@ writePage(
     }
 }
 
-} // clang::mrdocs::hbs
+} // mrdocs::hbs
diff --git a/src/lib/Gen/hbs/SinglePageVisitor.hpp b/src/lib/Gen/hbs/SinglePageVisitor.hpp
index cb69d8883..ac52b7ea3 100644
--- a/src/lib/Gen/hbs/SinglePageVisitor.hpp
+++ b/src/lib/Gen/hbs/SinglePageVisitor.hpp
@@ -19,7 +19,7 @@
 #include <string>
 #include <vector>
 
-namespace clang::mrdocs::hbs {
+namespace mrdocs::hbs {
 
 /** Visitor which writes everything to a single page.
 */
@@ -51,10 +51,10 @@ class SinglePageVisitor
         respective tasks are also pushed to the executor group.
 
     */
-    template <std::derived_from<Info> T>
+    template <std::derived_from<Symbol> T>
     void operator()(T const& I);
 };
 
-} // clang::mrdocs::hbs
+} // mrdocs::hbs
 
 #endif
diff --git a/src/lib/Gen/hbs/TagfileWriter.cpp b/src/lib/Gen/hbs/TagfileWriter.cpp
index 060bce1d1..57e3c25c9 100644
--- a/src/lib/Gen/hbs/TagfileWriter.cpp
+++ b/src/lib/Gen/hbs/TagfileWriter.cpp
@@ -17,7 +17,7 @@
 #include <mrdocs/Support/Path.hpp>
 #include <llvm/Support/FileSystem.h>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 //------------------------------------------------
 //
@@ -77,7 +77,7 @@ void
 TagfileWriter::
 operator()(T const& I)
 {
-    if constexpr (std::derived_from<T, Info>)
+    if constexpr (std::derived_from<T, Symbol>)
     {
         if (!hbs::shouldGenerate(I, corpus_.getCorpus().config))
         {
@@ -100,24 +100,24 @@ operator()(T const& I)
     }
 }
 
-#define INFO(Type) template void TagfileWriter::operator()<Type##Info>(Type##Info const&);
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
+#define INFO(Type) template void TagfileWriter::operator()<Type##Symbol>(Type##Symbol const&);
+#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
 
 void
 TagfileWriter::
 writeNamespace(
-    NamespaceInfo const& I)
+    NamespaceSymbol const& I)
 {
     // Check if this namespace contains only other namespaces
     bool onlyNamespaces = true;
-    corpus_->traverse(I, [&](Info const& U)
+    corpus_->traverse(I, [&](Symbol const& U)
     {
         if (!hbs::shouldGenerate(U, corpus_.getCorpus().config))
         {
             return;
         }
 
-        if (U.Kind != InfoKind::Namespace)
+        if (U.Kind != SymbolKind::Namespace)
         {
             onlyNamespaces = false;
         }
@@ -197,7 +197,7 @@ writeClassLike(
 
 void
 TagfileWriter::
-writeFunctionMember(FunctionInfo const& I)
+writeFunctionMember(FunctionSymbol const& I)
 {
     tags_.open("member", {{"kind", "function"}});
     MRDOCS_ASSERT(!I.ReturnType.valueless_after_move());
@@ -283,4 +283,4 @@ generateFileAndAnchor(T const& I)
     return {url.substr(0, pos), url.substr(pos + 1)};
 }
 
-} // clang::mrdocs
\ No newline at end of file
+} // mrdocs
\ No newline at end of file
diff --git a/src/lib/Gen/hbs/TagfileWriter.hpp b/src/lib/Gen/hbs/TagfileWriter.hpp
index 83f424976..43b82ddc1 100644
--- a/src/lib/Gen/hbs/TagfileWriter.hpp
+++ b/src/lib/Gen/hbs/TagfileWriter.hpp
@@ -19,7 +19,7 @@
 #include <fstream>
 #include <string>
 
-namespace clang {
+
 namespace mrdocs {
 
 struct SimpleWriterTag {}; //Tag dispatch for simple writers
@@ -116,14 +116,14 @@ class TagfileWriter
     // Write
     // ==================================================
     void
-    writeNamespace(NamespaceInfo const&);
+    writeNamespace(NamespaceSymbol const&);
 
     template<class T>
     void
     writeClassLike(T const& I);
 
     void
-    writeFunctionMember(FunctionInfo const& I);
+    writeFunctionMember(FunctionSymbol const& I);
 
     // ==================================================
     // URLs
@@ -139,6 +139,6 @@ class TagfileWriter
 };
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_LIB_GEN_HBS_TAGFILEWRITER_HPP
\ No newline at end of file
diff --git a/src/lib/Gen/hbs/VisitorHelpers.cpp b/src/lib/Gen/hbs/VisitorHelpers.cpp
index 2f64d5e73..965ca8c57 100644
--- a/src/lib/Gen/hbs/VisitorHelpers.cpp
+++ b/src/lib/Gen/hbs/VisitorHelpers.cpp
@@ -10,14 +10,14 @@
 
 #include "VisitorHelpers.hpp"
 #include <mrdocs/Corpus.hpp>
-#include <mrdocs/Metadata/Info.hpp>
 #include <mrdocs/Metadata/Name.hpp>
+#include <mrdocs/Metadata/Symbol.hpp>
 #include <mrdocs/Metadata/Type.hpp>
 
-namespace clang::mrdocs::hbs {
+namespace mrdocs::hbs {
 
 bool
-shouldGenerate(Info const& I, Config const& config)
+shouldGenerate(Symbol const& I, Config const& config)
 {
     if (I.isEnumConstant() && !config->showEnumConstants)
     {
@@ -44,21 +44,21 @@ shouldGenerate(Info const& I, Config const& config)
 namespace {
 
 // Resolve a typedef to its underlying Info type
-Info const*
-resolveTypedef(Corpus const& c, Info const& I)
+Symbol const*
+resolveTypedef(Corpus const& c, Symbol const& I)
 {
     if (I.isTypedef())
     {
         auto const& TI = I.asTypedef();
         MRDOCS_CHECK_OR(TI.Type, &I);
         MRDOCS_ASSERT(!TI.Type.valueless_after_move());
-        TypeInfo const& T = *TI.Type;
+        Type const& T = *TI.Type;
         MRDOCS_CHECK_OR(T.Kind == TypeKind::Named, &I);
         auto const& NT = T.asNamed();
         MRDOCS_CHECK_OR(NT.Name, &I);
-        Info const* resolved = c.find(NT.Name->id);
+        Symbol const* resolved = c.find(NT.Name->id);
         MRDOCS_CHECK_OR(resolved, &I);
-        if (resolved->Kind == InfoKind::Typedef)
+        if (resolved->Kind == SymbolKind::Typedef)
         {
             return resolveTypedef(c, *resolved);
         }
@@ -69,15 +69,15 @@ resolveTypedef(Corpus const& c, Info const& I)
 
 /* Look for an equivalent symbol in the parent Info
  */
-Info const*
-findPrimarySiblingWithUrl(Corpus const& c, Info const& I, Info const& parent)
+Symbol const*
+findPrimarySiblingWithUrl(Corpus const& c, Symbol const& I, Symbol const& parent)
 {
     // Look for the primary sibling in the parent scope
     MRDOCS_CHECK_OR(parent, nullptr);
     return visit(parent, [&]<typename InfoTy>(InfoTy const& U)
-        -> Info const*
+        -> Symbol const*
     {
-        if constexpr (InfoParent<InfoTy>)
+        if constexpr (SymbolParent<InfoTy>)
         {
             namespace stdv = std::ranges::views;
             auto sameNameSiblings =
@@ -86,11 +86,11 @@ findPrimarySiblingWithUrl(Corpus const& c, Info const& I, Info const& parent)
                 {
                     return c.find(siblingID);
                 }) |
-                stdv::filter([&](Info const* sibling)
+                stdv::filter([&](Symbol const* sibling)
                 {
                     return sibling && sibling->Name == I.Name;
                 });
-            for (Info const* sibling: sameNameSiblings)
+            for (Symbol const* sibling: sameNameSiblings)
             {
                 if (!sibling ||
                     !shouldGenerate(*sibling, c.config))
@@ -117,8 +117,8 @@ findPrimarySiblingWithUrl(Corpus const& c, Info const& I, Info const& parent)
     });
 }
 
-Info const*
-findPrimarySiblingWithUrl(Corpus const& c, Info const& I);
+Symbol const*
+findPrimarySiblingWithUrl(Corpus const& c, Symbol const& I);
 
 /* Find the parent and look for equivalent symbol in the parent
 
@@ -130,12 +130,12 @@ findPrimarySiblingWithUrl(Corpus const& c, Info const& I);
    we look for a symbol equivalent to the parent, and then look
    for an equivalent symbol in the parent.
  */
-Info const*
-findDirectPrimarySiblingWithUrl(Corpus const& c, Info const& I)
+Symbol const*
+findDirectPrimarySiblingWithUrl(Corpus const& c, Symbol const& I)
 {
     // If the parent is a scope, look for a primary sibling
     // in the parent scope for which we want to generate the URL
-    Info const* parent = c.find(I.Parent);
+    Symbol const* parent = c.find(I.Parent);
     MRDOCS_CHECK_OR(parent, nullptr);
     if (!shouldGenerate(*parent, c.config))
     {
@@ -150,8 +150,8 @@ findDirectPrimarySiblingWithUrl(Corpus const& c, Info const& I)
     This function will resolve typedefs and look for an equivalent
     symbol in the parent scope for which we want to generate the URL.
  */
-Info const*
-findResolvedPrimarySiblingWithUrl(Corpus const& c, Info const& I)
+Symbol const*
+findResolvedPrimarySiblingWithUrl(Corpus const& c, Symbol const& I)
 {
     // Check if this info is a specialization or a typedef to
     // a specialization, otherwise there's nothing to resolve
@@ -168,15 +168,15 @@ findResolvedPrimarySiblingWithUrl(Corpus const& c, Info const& I)
             }
         }
         // The symbol is a typedef to a specialization
-        if constexpr (std::same_as<InfoTy, TypedefInfo>)
+        if constexpr (std::same_as<InfoTy, TypedefSymbol>)
         {
             auto const& TOpt = U.Type;
             MRDOCS_ASSERT(!TOpt.valueless_after_move());
-            TypeInfo const& T = *TOpt;
+            Type const& T = *TOpt;
             MRDOCS_CHECK_OR(T.Kind == TypeKind::Named, false);
             auto const& NT = T.asNamed();
             MRDOCS_CHECK_OR(NT.Name, false);
-            MRDOCS_CHECK_OR(NT.Name->Kind == NameKind::Specialization, false);
+            MRDOCS_CHECK_OR(NT.Name->isSpecialization(), false);
             return true;
         }
         return false;
@@ -185,14 +185,14 @@ findResolvedPrimarySiblingWithUrl(Corpus const& c, Info const& I)
 
     // Find the parent scope containing the primary sibling
     // for which we want to generate the URL
-    Info const* parent = c.find(I.Parent);
+    Symbol const* parent = c.find(I.Parent);
     MRDOCS_CHECK_OR(parent, nullptr);
 
     // If the parent is a typedef, resolve it
     // so we can iterate the members of this scope.
     // We can't find siblings in a typedef because
     // it's not a scope.
-    if (parent->Kind == InfoKind::Typedef)
+    if (parent->Kind == SymbolKind::Typedef)
     {
         parent = resolveTypedef(c, *parent);
         MRDOCS_CHECK_OR(parent, nullptr);
@@ -211,10 +211,10 @@ findResolvedPrimarySiblingWithUrl(Corpus const& c, Info const& I)
     return findPrimarySiblingWithUrl(c, I, *parent);
 }
 
-Info const*
-findPrimarySiblingWithUrl(Corpus const& c, Info const& I)
+Symbol const*
+findPrimarySiblingWithUrl(Corpus const& c, Symbol const& I)
 {
-    if (Info const* primary = findDirectPrimarySiblingWithUrl(c, I))
+    if (Symbol const* primary = findDirectPrimarySiblingWithUrl(c, I))
     {
         return primary;
     }
@@ -234,10 +234,10 @@ findPrimarySiblingWithUrl(Corpus const& c, Info const& I)
     is looking for a URL for a symbol.
 
  */
-Info const*
-findParentWithUrl(Corpus const& c, Info const& I)
+Symbol const*
+findParentWithUrl(Corpus const& c, Symbol const& I)
 {
-    Info const* parent = c.find(I.Parent);
+    Symbol const* parent = c.find(I.Parent);
     MRDOCS_CHECK_OR(parent, nullptr);
     MRDOCS_CHECK_OR(!parent->isNamespace(), nullptr);
     if (shouldGenerate(*parent, c.config))
@@ -251,14 +251,14 @@ findParentWithUrl(Corpus const& c, Info const& I)
 }
 }
 
-Info const*
-findAlternativeURLInfo(Corpus const& c, Info const& I)
+Symbol const*
+findAlternativeURLInfo(Corpus const& c, Symbol const& I)
 {
-    if (Info const* primary = findPrimarySiblingWithUrl(c, I))
+    if (Symbol const* primary = findPrimarySiblingWithUrl(c, I))
     {
         return primary;
     }
     return findParentWithUrl(c, I);
 }
 
-} // clang::mrdocs::hbs
+} // mrdocs::hbs
diff --git a/src/lib/Gen/hbs/VisitorHelpers.hpp b/src/lib/Gen/hbs/VisitorHelpers.hpp
index 67d007ba1..48ba983b0 100644
--- a/src/lib/Gen/hbs/VisitorHelpers.hpp
+++ b/src/lib/Gen/hbs/VisitorHelpers.hpp
@@ -13,9 +13,9 @@
 
 #include <mrdocs/Config.hpp>
 #include <mrdocs/Corpus.hpp>
-#include <mrdocs/Metadata/Info.hpp>
+#include <mrdocs/Metadata/Symbol.hpp>
 
-namespace clang::mrdocs::hbs {
+namespace mrdocs::hbs {
 
 /** @brief Determine if the generator should generate a page for this Info.
 
@@ -24,7 +24,7 @@ namespace clang::mrdocs::hbs {
  */
 MRDOCS_DECL
 bool
-shouldGenerate(Info const& I, Config const& config);
+shouldGenerate(Symbol const& I, Config const& config);
 
 /** Find an Info type whose URL we can use for the specified Info
 
@@ -41,9 +41,9 @@ shouldGenerate(Info const& I, Config const& config);
     return nullptr.
  */
 MRDOCS_DECL
-Info const*
-findAlternativeURLInfo(Corpus const& c, Info const& I);
+Symbol const*
+findAlternativeURLInfo(Corpus const& c, Symbol const& I);
 
-} // clang::mrdocs::hbs
+} // mrdocs::hbs
 
 #endif
diff --git a/src/lib/Gen/html/HTMLGenerator.cpp b/src/lib/Gen/html/HTMLGenerator.cpp
index 1368cf3c5..f2cfe4ebc 100644
--- a/src/lib/Gen/html/HTMLGenerator.cpp
+++ b/src/lib/Gen/html/HTMLGenerator.cpp
@@ -12,7 +12,7 @@
 #include "HTMLGenerator.hpp"
 #include <mrdocs/Support/Handlebars.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 namespace html {
 
 void
@@ -32,4 +32,4 @@ makeHTMLGenerator()
     return std::make_unique<html::HTMLGenerator>();
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Gen/html/HTMLGenerator.hpp b/src/lib/Gen/html/HTMLGenerator.hpp
index 921decdd6..5d9594419 100644
--- a/src/lib/Gen/html/HTMLGenerator.hpp
+++ b/src/lib/Gen/html/HTMLGenerator.hpp
@@ -17,7 +17,7 @@
 #include <lib/Gen/hbs/HandlebarsGenerator.hpp>
 #include <mrdocs/Generator.hpp>
 
-namespace clang::mrdocs::html {
+namespace mrdocs::html {
 
 class HTMLGenerator final
     : public hbs::HandlebarsGenerator
@@ -45,6 +45,6 @@ class HTMLGenerator final
     escape(OutputRef& os, std::string_view str) const override;
 };
 
-} // clang::mrdocs::html
+} // mrdocs::html
 
 #endif
diff --git a/src/lib/Gen/xml/CXXTags.cpp b/src/lib/Gen/xml/CXXTags.cpp
index e80682f30..c7c55f3ff 100644
--- a/src/lib/Gen/xml/CXXTags.cpp
+++ b/src/lib/Gen/xml/CXXTags.cpp
@@ -10,21 +10,21 @@
 //
 
 #include "CXXTags.hpp"
-#include <mrdocs/Metadata/Info/Record.hpp>
-#include <mrdocs/Metadata/Info/Typedef.hpp>
+#include <mrdocs/Metadata/Symbol/Record.hpp>
+#include <mrdocs/Metadata/Symbol/Typedef.hpp>
 #include <mrdocs/Support/String.hpp>
 
-namespace clang::mrdocs::xml {
+namespace mrdocs::xml {
 
 std::string
-getDefaultTagName(Info const& I) noexcept
+getDefaultTagName(Symbol const& I) noexcept
 {
     switch(I.Kind)
     {
 #define INFO(Type) \
-    case InfoKind::Type: \
+    case SymbolKind::Type: \
         return toKebabCase(#Type) + "TagName";
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
+#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
     default:
         break;
     }
@@ -33,12 +33,12 @@ getDefaultTagName(Info const& I) noexcept
 
 
 std::string
-getTagName(Info const& I) noexcept
+getTagName(Symbol const& I) noexcept
 {
     switch(I.Kind)
     {
-    case InfoKind::Record:
-        switch(static_cast<RecordInfo const&>(I).KeyKind)
+    case SymbolKind::Record:
+        switch(static_cast<RecordSymbol const&>(I).KeyKind)
         {
         case RecordKeyKind::Class:     return classTagName;
         case RecordKeyKind::Struct:    return structTagName;
@@ -47,8 +47,8 @@ getTagName(Info const& I) noexcept
             break;
         }
         break;
-    case InfoKind::Typedef:
-        if (static_cast<TypedefInfo const&>(I).IsUsing)
+    case SymbolKind::Typedef:
+        if (static_cast<TypedefSymbol const&>(I).IsUsing)
         {
             return "namespace";
         }
@@ -62,4 +62,4 @@ getTagName(Info const& I) noexcept
     MRDOCS_UNREACHABLE();
 }
 
-} // clang::mrdocs::xml
+} // mrdocs::xml
diff --git a/src/lib/Gen/xml/CXXTags.hpp b/src/lib/Gen/xml/CXXTags.hpp
index 21e1b8712..dd8cf2ffa 100644
--- a/src/lib/Gen/xml/CXXTags.hpp
+++ b/src/lib/Gen/xml/CXXTags.hpp
@@ -14,8 +14,8 @@
 #define MRDOCS_LIB_GEN_XML_CXXTAGS_HPP
 
 #include <lib/Gen/xml/XMLTags.hpp>
-#include <mrdocs/Metadata/Info/Function.hpp>
 #include <mrdocs/Metadata/Name.hpp>
+#include <mrdocs/Metadata/Symbol/Function.hpp>
 #include <mrdocs/Metadata/TParam.hpp>
 #include <mrdocs/Metadata/Type.hpp>
 
@@ -25,7 +25,7 @@
     in the MRDOCS DTD XML schema.
 */
 
-namespace clang::mrdocs::xml {
+namespace mrdocs::xml {
 
 constexpr auto accessTagName         = "access";
 constexpr auto attributeTagName      = "attr";
@@ -121,8 +121,7 @@ writeTemplateArg(TArg const& I, XMLTags& tags);
 
 inline
 void
-writeType(
-    TypeInfo const& I,
+writeType(Type const& I,
     XMLTags& tags,
     std::string_view type_tag = "type")
 {
@@ -182,7 +181,7 @@ writeType(
 
             if constexpr(T::isAuto())
             {
-                AutoTypeInfo const& at = t;
+                AutoType const& at = t;
                 attrs.push({"keyword", toString(at.Keyword)});
                 if(at.Constraint)
                 {
@@ -199,7 +198,7 @@ writeType(
                 if(t.RefQualifier != ReferenceKind::None)
                     attrs.push({"ref-qualifier", toString(t.RefQualifier)});
 
-                // KRYSTIAN TODO: TypeInfo should use ExceptionInfo!
+                // KRYSTIAN TODO: Type should use ExceptionInfo!
                 if(auto spec = toString(t.ExceptionSpec); ! spec.empty())
                     attrs.push({"exception-spec", spec});
             }
@@ -217,21 +216,21 @@ writeType(
 
             if constexpr(requires { t.PointeeType; })
             {
-                Polymorphic<TypeInfo> const& pointee = t.PointeeType;
+                Polymorphic<Type> const& pointee = t.PointeeType;
                 MRDOCS_ASSERT(!pointee.valueless_after_move());
                 writeType(*t.PointeeType, tags, "pointee-type");
             }
 
             if constexpr(T::isArray())
             {
-                ArrayTypeInfo const& at = t;
+                ArrayType const& at = t;
                 MRDOCS_ASSERT(!at.ElementType.valueless_after_move());
                 writeType(*t.ElementType, tags, "element-type");
             }
 
             if constexpr(T::isFunction())
             {
-                FunctionTypeInfo const& ft = t;
+                FunctionType const& ft = t;
                 MRDOCS_ASSERT(!ft.ReturnType.valueless_after_move());
                 writeType(*t.ReturnType, tags, "return-type");
                 for (auto const& p: t.ParamTypes)
@@ -247,7 +246,7 @@ writeType(
 inline
 void
 writeType(
-    NameInfo const& I,
+    Name const& I,
     XMLTags& tags,
     std::string_view type_tag = "type")
 {
@@ -257,7 +256,7 @@ writeType(
     };
 
     attrs.push({I.id});
-    attrs.push({"name", I.Name});
+    attrs.push({"name", I.Identifier});
 
     tags.write(type_tag, {}, std::move(attrs));
 }
@@ -265,7 +264,7 @@ writeType(
 inline
 void
 writeType(
-    Polymorphic<TypeInfo> const& type,
+    Polymorphic<Type> const& type,
     XMLTags& tags)
 {
     MRDOCS_ASSERT(!type.valueless_after_move());
@@ -275,7 +274,7 @@ writeType(
 inline
 void
 writeType(
-    Optional<Polymorphic<TypeInfo>> const& type,
+    Optional<Polymorphic<Type>> const& type,
     XMLTags& tags)
 {
     if (type)
@@ -285,7 +284,7 @@ writeType(
 }
 
 
-inline void writeReturnType(TypeInfo const& I, XMLTags& tags)
+inline void writeReturnType(Type const& I, XMLTags& tags)
 {
     // KRYSTIAN NOTE: we don't *have* to do this...
     if (toString(I) == "void")
@@ -374,8 +373,8 @@ inline void writeTemplateArg(TArg const& I, XMLTags& tags)
 /** Return the xml tag name for the Info.
 */
 std::string
-getTagName(Info const& I) noexcept;
+getTagName(Symbol const& I) noexcept;
 
-} // clang::mrdocs::xml
+} // mrdocs::xml
 
 #endif
diff --git a/src/lib/Gen/xml/XMLGenerator.cpp b/src/lib/Gen/xml/XMLGenerator.cpp
index 42e4ab749..2d42cd8d3 100644
--- a/src/lib/Gen/xml/XMLGenerator.cpp
+++ b/src/lib/Gen/xml/XMLGenerator.cpp
@@ -16,7 +16,7 @@
 #include <mrdocs/Metadata.hpp>
 #include <mrdocs/Support/Error.hpp>
 
-namespace clang {
+
 namespace mrdocs {
 namespace xml {
 
@@ -42,4 +42,4 @@ makeXMLGenerator()
 }
 
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Gen/xml/XMLGenerator.hpp b/src/lib/Gen/xml/XMLGenerator.hpp
index 57a45b58d..18bbcbba6 100644
--- a/src/lib/Gen/xml/XMLGenerator.hpp
+++ b/src/lib/Gen/xml/XMLGenerator.hpp
@@ -17,7 +17,7 @@
 #include <mrdocs/Metadata/Javadoc.hpp>
 #include <optional>
 
-namespace clang::mrdocs::xml {
+namespace mrdocs::xml {
 
 //------------------------------------------------
 
@@ -47,6 +47,6 @@ struct XMLGenerator : Generator
         Corpus const& corpus) const override;
 };
 
-} // clang::mrdocs::xml
+} // mrdocs::xml
 
 #endif
diff --git a/src/lib/Gen/xml/XMLTags.cpp b/src/lib/Gen/xml/XMLTags.cpp
index d93448d1d..6dedad694 100644
--- a/src/lib/Gen/xml/XMLTags.cpp
+++ b/src/lib/Gen/xml/XMLTags.cpp
@@ -13,7 +13,7 @@
 #include <mrdocs/Platform.hpp>
 #include <lib/Support/Radix.hpp>
 
-namespace clang {
+
 namespace mrdocs {
 namespace xml {
 
@@ -210,4 +210,4 @@ nest(int levels)
 
 } // xml
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Gen/xml/XMLTags.hpp b/src/lib/Gen/xml/XMLTags.hpp
index 2cd35bf82..728492b00 100644
--- a/src/lib/Gen/xml/XMLTags.hpp
+++ b/src/lib/Gen/xml/XMLTags.hpp
@@ -13,8 +13,8 @@
 #define MRDOCS_LIB_GEN_XML_XMLTAGS_HPP
 
 #include <mrdocs/Dom.hpp>
-#include <mrdocs/Metadata/Info/SymbolID.hpp>
 #include <mrdocs/Metadata/Javadoc.hpp>
+#include <mrdocs/Metadata/Symbol/SymbolID.hpp>
 #include <mrdocs/Metadata/Type.hpp>
 #include <clang/Basic/Specifiers.h>
 #include <llvm/ADT/StringRef.h>
@@ -27,7 +27,7 @@
     XML tags and correctly escaped strings
 */
 
-namespace clang::mrdocs::xml {
+namespace mrdocs::xml {
 
 class jit_indenter;
 
@@ -203,6 +203,6 @@ class XMLTags
     void nest(int levels);
 };
 
-} // clang::mrdocs::xml
+} // mrdocs::xml
 
 #endif
diff --git a/src/lib/Gen/xml/XMLWriter.cpp b/src/lib/Gen/xml/XMLWriter.cpp
index 274d115d8..6c06ea8f8 100644
--- a/src/lib/Gen/xml/XMLWriter.cpp
+++ b/src/lib/Gen/xml/XMLWriter.cpp
@@ -26,7 +26,7 @@
 //
 //------------------------------------------------
 
-namespace clang::mrdocs::xml {
+namespace mrdocs::xml {
 
 //------------------------------------------------
 //
@@ -93,13 +93,13 @@ XMLWriter::
 operator()(
     T const& I)
 {
-    if (Info const& base = I;
+    if (Symbol const& base = I;
         base.Extraction == ExtractionMode::Dependency)
     {
         return;
     }
     #define INFO(Type) if constexpr(T::is##Type()) write##Type(I);
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
+#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
 }
 
 //------------------------------------------------
@@ -107,7 +107,7 @@ operator()(
 void
 XMLWriter::
 writeNamespace(
-    NamespaceInfo const& I)
+    NamespaceSymbol const& I)
 {
     constexpr std::string_view namespaceTagName = "namespace";
     tags_.open(namespaceTagName, {
@@ -117,7 +117,7 @@ writeNamespace(
         { "is-inline", "1", I.IsInline}
     });
     writeJavadoc(I.javadoc);
-    for (NameInfo const& NI: I.UsingDirectives)
+    for (Name const& NI: I.UsingDirectives)
     {
         if (auto const& id = NI.id; id != SymbolID::invalid)
         {
@@ -131,7 +131,7 @@ writeNamespace(
 void
 XMLWriter::
 writeEnum(
-    EnumInfo const& I)
+    EnumSymbol const& I)
 {
     constexpr std::string_view enumTagName = "enum";
     tags_.open(enumTagName, {
@@ -159,7 +159,7 @@ writeEnum(
 void
 XMLWriter::
 writeEnumConstant(
-    EnumConstantInfo const& I)
+    EnumConstantSymbol const& I)
 {
     std::string val = I.Initializer.Value ?
         std::to_string(*I.Initializer.Value) :
@@ -208,7 +208,7 @@ writeFriend(
 void
 XMLWriter::
 writeFunction(
-    FunctionInfo const& I)
+    FunctionSymbol const& I)
 {
     openTemplate(I.Template);
 
@@ -269,7 +269,7 @@ writeFunction(
 void
 XMLWriter::
 writeOverloads(
-    OverloadsInfo const& I)
+    OverloadsSymbol const& I)
 {
     corpus_.traverse(I, *this);
 }
@@ -277,7 +277,7 @@ writeOverloads(
 void
 XMLWriter::
 writeGuide(
-    GuideInfo const& I)
+    GuideSymbol const& I)
 {
     openTemplate(I.Template);
 
@@ -311,7 +311,7 @@ writeGuide(
 void
 XMLWriter::
 writeConcept(
-    ConceptInfo const& I)
+    ConceptSymbol const& I)
 {
     openTemplate(I.Template);
 
@@ -335,7 +335,7 @@ writeConcept(
 void
 XMLWriter::
 writeNamespaceAlias(
-    NamespaceAliasInfo const& I)
+    NamespaceAliasSymbol const& I)
 {
     constexpr std::string_view namespaceAliasTagName = "namespace-alias";
     tags_.open(namespaceAliasTagName, {
@@ -358,7 +358,7 @@ writeNamespaceAlias(
 
 void
 XMLWriter::
-    writeUsing(UsingInfo const& I)
+    writeUsing(UsingSymbol const& I)
 {
     dom::String classStr;
     switch (I.Class)
@@ -401,7 +401,7 @@ XMLWriter::
 void
 XMLWriter::
 writeRecord(
-    RecordInfo const& I)
+    RecordSymbol const& I)
 {
     openTemplate(I.Template);
 
@@ -445,7 +445,7 @@ writeRecord(
 void
 XMLWriter::
 writeTypedef(
-    TypedefInfo const& I)
+    TypedefSymbol const& I)
 {
     openTemplate(I.Template);
 
@@ -479,7 +479,7 @@ writeTypedef(
 void
 XMLWriter::
 writeVariable(
-    VariableInfo const& I)
+    VariableSymbol const& I)
 {
     openTemplate(I.Template);
 
@@ -943,4 +943,4 @@ writeTParam(
     tags_.close("tparam");
 }
 
-} // clang::mrdocs::xml
+} // mrdocs::xml
diff --git a/src/lib/Gen/xml/XMLWriter.hpp b/src/lib/Gen/xml/XMLWriter.hpp
index 9af8ed3d0..831dbe26e 100644
--- a/src/lib/Gen/xml/XMLWriter.hpp
+++ b/src/lib/Gen/xml/XMLWriter.hpp
@@ -19,7 +19,7 @@
 #include <mrdocs/Support/Error.hpp>
 #include <string>
 
-namespace clang::mrdocs::xml {
+namespace mrdocs::xml {
 
 class jit_indenter;
 
@@ -52,8 +52,8 @@ class XMLWriter
     // ---------------
     // Info types
 
-#define INFO(Type) void write##Type(Type##Info const&);
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
+#define INFO(Type) void write##Type(Type##Symbol const&);
+#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
 
     void writeSourceInfo(SourceInfo const& I);
     void writeLocation(Location const& loc, bool def = false);
@@ -107,6 +107,6 @@ class XMLWriter
     }
 };
 
-} // clang::mrdocs::xml
+} // mrdocs::xml
 
 #endif // MRDOCS_LIB_GEN_XML_XMLWRITER_HPP
diff --git a/src/lib/Metadata/DomCorpus.cpp b/src/lib/Metadata/DomCorpus.cpp
index 45e523b0e..f6cf32dc6 100644
--- a/src/lib/Metadata/DomCorpus.cpp
+++ b/src/lib/Metadata/DomCorpus.cpp
@@ -21,7 +21,7 @@
 #include <mutex>
 #include <variant>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 class DomCorpus::Impl
 {
@@ -46,7 +46,7 @@ class DomCorpus::Impl
     }
 
     dom::Object
-    create(Info const& I) const
+    create(Symbol const& I) const
     {
         return domCorpus_.construct(I);
     }
@@ -56,7 +56,7 @@ class DomCorpus::Impl
     {
         // VFALCO Hack to deal with symbol IDs
         // being emitted without the corresponding data.
-        Info const* I = corpus_.find(id);
+        Symbol const* I = corpus_.find(id);
         MRDOCS_CHECK_OR(I, {});
         return create(*I);
     }
@@ -82,7 +82,7 @@ getCorpus() const
 
 dom::Object
 DomCorpus::
-construct(Info const& I) const
+construct(Symbol const& I) const
 {
     return visit(I, [this]<class T>(T const& U) -> dom::Object
     {
@@ -110,7 +110,7 @@ getJavadoc(Javadoc const&) const
 }
 
 dom::Array
-getParents(DomCorpus const& C, Info const& I)
+getParents(DomCorpus const& C, Symbol const& I)
 {
     // A convenient list to iterate over the parents
     // with resorting to partial template recursion
@@ -119,10 +119,10 @@ getParents(DomCorpus const& C, Info const& I)
     dom::Array res;
     for (SymbolID const& id : pIds)
     {
-        Info const& PI = corpus.get(id);
+        Symbol const& PI = corpus.get(id);
         res.push_back(C.construct(PI));
     }
     return res;
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Metadata/Expression.cpp b/src/lib/Metadata/Expression.cpp
index 223c3c78c..9b5c8261b 100644
--- a/src/lib/Metadata/Expression.cpp
+++ b/src/lib/Metadata/Expression.cpp
@@ -11,7 +11,7 @@
 
 #include <mrdocs/Metadata/Expression.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 void
 merge(ExprInfo& I, ExprInfo&& Other)
@@ -22,4 +22,4 @@ merge(ExprInfo& I, ExprInfo&& Other)
     }
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Metadata/Finalizers/BaseMembersFinalizer.cpp b/src/lib/Metadata/Finalizers/BaseMembersFinalizer.cpp
index 75d6ea537..dc56b86e3 100644
--- a/src/lib/Metadata/Finalizers/BaseMembersFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/BaseMembersFinalizer.cpp
@@ -13,11 +13,11 @@
 #include <mrdocs/Support/Report.hpp>
 #include <format>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 void
 BaseMembersFinalizer::
-inheritBaseMembers(RecordInfo& I, RecordInfo const& B, AccessKind const A)
+inheritBaseMembers(RecordSymbol& I, RecordSymbol const& B, AccessKind const A)
 {
     inheritBaseMembers(I.id, I.Interface, B.Interface, A);
 }
@@ -81,7 +81,7 @@ inheritBaseMembers(
 
 namespace {
 bool
-shouldCopy(Config const& config, Info const& M)
+shouldCopy(Config const& config, Symbol const& M)
 {
     if (config->inheritBaseMembers == PublicSettings::BaseMemberInheritance::CopyDependencies)
     {
@@ -102,9 +102,9 @@ inheritBaseMembers(
     {
         // Find the info from the base class
         MRDOCS_CHECK_OR_CONTINUE(!contains(derived, otherID));
-        Info* otherInfoPtr = corpus_.find(otherID);
+        Symbol* otherInfoPtr = corpus_.find(otherID);
         MRDOCS_CHECK_OR_CONTINUE(otherInfoPtr);
-        Info& otherInfo = *otherInfoPtr;
+        Symbol& otherInfo = *otherInfoPtr;
 
         // Check if we're not attempt to copy a special member function
         if (auto const *funcPtr = otherInfoPtr->asFunctionPtr()) {
@@ -118,7 +118,7 @@ inheritBaseMembers(
             derived,
             [&](SymbolID const& id)
             {
-                Info* infoPtr = corpus_.find(id);
+            Symbol* infoPtr = corpus_.find(id);
                 MRDOCS_CHECK_OR(infoPtr, false);
                 auto& info = *infoPtr;
                 MRDOCS_CHECK_OR(info.Kind == otherInfo.Kind, false);
@@ -126,8 +126,8 @@ inheritBaseMembers(
                 {
                     // If it's a function, it's only a shadow if the signatures
                     // are the same
-                    auto const& otherFunc = static_cast<FunctionInfo const&>(otherInfo);
-                    auto const& func = static_cast<FunctionInfo const&>(info);
+                    auto const& otherFunc = static_cast<FunctionSymbol const&>(otherInfo);
+                    auto const& func = static_cast<FunctionSymbol const&>(info);
                     return overrides(func, otherFunc);
                 }
                 // For other kinds of members, it's a shadow if the names
@@ -152,9 +152,9 @@ inheritBaseMembers(
         }
         else
         {
-            std::unique_ptr<Info> otherCopy =
+            std::unique_ptr<Symbol> otherCopy =
                 visit(otherInfo, [&]<class T>(T const& other)
-                    -> std::unique_ptr<Info>
+                    -> std::unique_ptr<Symbol>
                 {
                     return std::make_unique<T>(other);
                 });
@@ -166,9 +166,9 @@ inheritBaseMembers(
             // Get the extraction mode from the derived class
             if (otherCopy->Extraction == ExtractionMode::Dependency)
             {
-                Info* derivedInfoPtr = corpus_.find(derivedId);
+                Symbol* derivedInfoPtr = corpus_.find(derivedId);
                 MRDOCS_CHECK_OR_CONTINUE(derivedInfoPtr);
-                Info const& derivedInfo = *derivedInfoPtr;
+                Symbol const& derivedInfo = *derivedInfoPtr;
                 otherCopy->Extraction = derivedInfo.Extraction;
             }
             corpus_.info_.insert(std::move(otherCopy));
@@ -182,7 +182,7 @@ finalizeRecords(std::vector<SymbolID> const& ids)
 {
     for (SymbolID const& id: ids)
     {
-        Info* infoPtr = corpus_.find(id);
+        Symbol* infoPtr = corpus_.find(id);
         MRDOCS_CHECK_OR_CONTINUE(infoPtr);
         auto* record = infoPtr->asRecordPtr();
         MRDOCS_CHECK_OR_CONTINUE(record);
@@ -196,7 +196,7 @@ finalizeNamespaces(std::vector<SymbolID> const& ids)
 {
     for (SymbolID const& id: ids)
     {
-        Info* infoPtr = corpus_.find(id);
+        Symbol* infoPtr = corpus_.find(id);
         MRDOCS_CHECK_OR_CONTINUE(infoPtr);
         auto* ns = infoPtr->asNamespacePtr();
         MRDOCS_CHECK_OR_CONTINUE(ns);
@@ -206,7 +206,7 @@ finalizeNamespaces(std::vector<SymbolID> const& ids)
 
 void
 BaseMembersFinalizer::
-operator()(NamespaceInfo& I)
+operator()(NamespaceSymbol& I)
 {
     report::trace(
         "Extracting base members for namespace '{}'",
@@ -217,7 +217,7 @@ operator()(NamespaceInfo& I)
 
 void
 BaseMembersFinalizer::
-operator()(RecordInfo& I)
+operator()(RecordSymbol& I)
 {
     MRDOCS_CHECK_OR(I.Extraction == ExtractionMode::Regular);
     report::trace(
@@ -252,4 +252,4 @@ operator()(RecordInfo& I)
     finalized_.emplace(I.id);
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Metadata/Finalizers/BaseMembersFinalizer.hpp b/src/lib/Metadata/Finalizers/BaseMembersFinalizer.hpp
index a6607fb49..e74bf1e79 100644
--- a/src/lib/Metadata/Finalizers/BaseMembersFinalizer.hpp
+++ b/src/lib/Metadata/Finalizers/BaseMembersFinalizer.hpp
@@ -12,9 +12,9 @@
 #define MRDOCS_LIB_METADATA_FINALIZERS_BASEMEMBERSFINALIZER_HPP
 
 #include <lib/CorpusImpl.hpp>
-#include <lib/Metadata/InfoSet.hpp>
+#include <lib/Metadata/SymbolSet.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Finalizes a set of Info.
 
@@ -30,7 +30,7 @@ class BaseMembersFinalizer
     std::unordered_set<SymbolID> finalized_;
 
     void
-    inheritBaseMembers(RecordInfo& I, RecordInfo const& B, AccessKind A);
+    inheritBaseMembers(RecordSymbol& I, RecordSymbol const& B, AccessKind A);
 
     void
     inheritBaseMembers(
@@ -66,21 +66,21 @@ class BaseMembersFinalizer
     void
     build()
     {
-        Info* info = corpus_.find(SymbolID::global);
+        Symbol* info = corpus_.find(SymbolID::global);
         MRDOCS_CHECK_OR(info);
         operator()(info->asNamespace());
     }
 
     void
-    operator()(NamespaceInfo& I);
+    operator()(NamespaceSymbol& I);
 
     void
-    operator()(RecordInfo& I);
+    operator()(RecordSymbol& I);
 
     void
-    operator()(Info&) {}
+    operator()(Symbol&) {}
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_LIB_METADATA_FINALIZERS_BASEMEMBERSFINALIZER_HPP
diff --git a/src/lib/Metadata/Finalizers/DerivedFinalizer.cpp b/src/lib/Metadata/Finalizers/DerivedFinalizer.cpp
index 22373fcba..d492682ee 100644
--- a/src/lib/Metadata/Finalizers/DerivedFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/DerivedFinalizer.cpp
@@ -13,7 +13,7 @@
 #include <mrdocs/Support/Report.hpp>
 #include <algorithm>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 void
 DerivedFinalizer::
@@ -36,7 +36,7 @@ build()
             MRDOCS_CHECK_OR_CONTINUE(namedType.Name);
             SymbolID const namedSymbolID = namedType.Name->id;
             MRDOCS_CHECK_OR_CONTINUE(namedSymbolID != SymbolID::invalid);
-            Info* baseInfoPtr = corpus_.find(namedSymbolID);
+            Symbol* baseInfoPtr = corpus_.find(namedSymbolID);
             MRDOCS_CHECK_OR_CONTINUE(baseInfoPtr);
             MRDOCS_CHECK_OR_CONTINUE(baseInfoPtr->isRecord());
             MRDOCS_CHECK_OR_CONTINUE(baseInfoPtr->Extraction == ExtractionMode::Regular);
@@ -64,4 +64,4 @@ build()
     }
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Metadata/Finalizers/DerivedFinalizer.hpp b/src/lib/Metadata/Finalizers/DerivedFinalizer.hpp
index 11c802e87..ca0ddb7e2 100644
--- a/src/lib/Metadata/Finalizers/DerivedFinalizer.hpp
+++ b/src/lib/Metadata/Finalizers/DerivedFinalizer.hpp
@@ -13,10 +13,10 @@
 #define MRDOCS_LIB_METADATA_FINALIZERS_DERIVEDFINALIZER_HPP
 
 #include <lib/CorpusImpl.hpp>
-#include <lib/Metadata/InfoSet.hpp>
+#include <lib/Metadata/SymbolSet.hpp>
 #include <utility>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Finalizes a set of Info.
 
@@ -37,6 +37,6 @@ class DerivedFinalizer
     build();
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_LIB_METADATA_FINALIZERS_DERIVEDFINALIZER_HPP
diff --git a/src/lib/Metadata/Finalizers/Javadoc/Function.hpp b/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
index 90fc29e8c..fea0a5a9b 100644
--- a/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
+++ b/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
@@ -12,15 +12,15 @@
 #define MRDOCS_LIB_METADATA_FINALIZERS_JAVADOC_FUNCTION_HPP
 
 #include <lib/CorpusImpl.hpp>
-#include <lib/Metadata/InfoSet.hpp>
+#include <lib/Metadata/SymbolSet.hpp>
 #include <mrdocs/Support/Algorithm.hpp>
 #include <format>
 #include <utility>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 namespace {
 bool
-isSpecialFunction(FunctionInfo const& I)
+isSpecialFunction(FunctionSymbol const& I)
 {
     return
         I.Class != FunctionClass::Normal ||
@@ -28,14 +28,14 @@ isSpecialFunction(FunctionInfo const& I)
 }
 
 bool
-isDefaultConstructor(FunctionInfo const& I)
+isDefaultConstructor(FunctionSymbol const& I)
 {
     return I.Class == FunctionClass::Constructor && I.Params.empty();
 }
 
 template <bool move, bool assignment>
 bool
-isCopyOrMoveConstructorOrAssignment(FunctionInfo const& I)
+isCopyOrMoveConstructorOrAssignment(FunctionSymbol const& I)
 {
     if constexpr (!assignment)
     {
@@ -47,7 +47,7 @@ isCopyOrMoveConstructorOrAssignment(FunctionInfo const& I)
     }
     MRDOCS_CHECK_OR(I.Params.size() == 1, false);
     auto const& param = I.Params[0];
-    Polymorphic<TypeInfo> const& paramType = param.Type;
+    Polymorphic<Type> const& paramType = param.Type;
     MRDOCS_ASSERT(!paramType.valueless_after_move());
     if constexpr (!move)
     {
@@ -57,17 +57,17 @@ isCopyOrMoveConstructorOrAssignment(FunctionInfo const& I)
     {
         MRDOCS_CHECK_OR(paramType->isRValueReference(), false);
     }
-    using RefType = std::conditional_t<move, RValueReferenceTypeInfo, LValueReferenceTypeInfo>;
+    using RefType = std::conditional_t<move, RValueReferenceType, LValueReferenceType>;
     auto const& paramRefType = static_cast<RefType const &>(*paramType);
     auto const& paramRefPointeeOpt = paramRefType.PointeeType;
     MRDOCS_CHECK_OR(paramRefPointeeOpt, false);
-    TypeInfo const& paramRefPointee = *paramRefPointeeOpt;
+    Type const& paramRefPointee = *paramRefPointeeOpt;
     auto const *paramRefPointeeNamed = paramRefPointee.asNamedPtr();
     MRDOCS_CHECK_OR(paramRefPointeeNamed, false);
     MRDOCS_CHECK_OR(paramRefPointeeNamed->Name, false);
     auto const& paramName = paramRefPointeeNamed->Name;
     MRDOCS_CHECK_OR(paramName, false);
-    auto const& paramRefPointeeNamedName = paramName->Name;
+    auto const& paramRefPointeeNamedName = paramName->Identifier;
     MRDOCS_CHECK_OR(!paramRefPointeeNamedName.empty(), false);
     SymbolID const& id = paramName->id;
     MRDOCS_CHECK_OR(id, false);
@@ -75,50 +75,50 @@ isCopyOrMoveConstructorOrAssignment(FunctionInfo const& I)
 }
 
 bool
-isCopyConstructor(FunctionInfo const& I)
+isCopyConstructor(FunctionSymbol const& I)
 {
     return isCopyOrMoveConstructorOrAssignment<false, false>(I);
 }
 
 bool
-isMoveConstructor(FunctionInfo const& I)
+isMoveConstructor(FunctionSymbol const& I)
 {
     return isCopyOrMoveConstructorOrAssignment<true, false>(I);
 }
 
 bool
-isCopyAssignment(FunctionInfo const& I)
+isCopyAssignment(FunctionSymbol const& I)
 {
     return isCopyOrMoveConstructorOrAssignment<false, true>(I);
 }
 
 bool
-isMoveAssignment(FunctionInfo const& I)
+isMoveAssignment(FunctionSymbol const& I)
 {
     return isCopyOrMoveConstructorOrAssignment<true, true>(I);
 }
 
 Optional<std::string_view>
-innermostTypenameString(Polymorphic<TypeInfo> const& T)
+innermostTypenameString(Polymorphic<Type> const& T)
 {
     auto& R = innermostType(T);
     MRDOCS_CHECK_OR(R->isNamed(), {});
-    MRDOCS_CHECK_OR(dynamic_cast<NamedTypeInfo const &>(*R).Name, {});
-    MRDOCS_CHECK_OR(!dynamic_cast<NamedTypeInfo const &>(*R).Name->Name.empty(),
+    MRDOCS_CHECK_OR(dynamic_cast<NamedType const &>(*R).Name, {});
+    MRDOCS_CHECK_OR(!dynamic_cast<NamedType const &>(*R).Name->Identifier.empty(),
                     {});
-    auto& RStr = dynamic_cast<const NamedTypeInfo &>(*R).Name->Name;
+    auto& RStr = dynamic_cast<const NamedType &>(*R).Name->Identifier;
     return RStr;
 }
 
 //Optional<std::string_view>
-//innermostTypenameString(Optional<Polymorphic<TypeInfo>> const& T)
+//innermostTypenameString(Optional<Polymorphic<Type>> const& T)
 //{
 //    MRDOCS_CHECK_OR(T, {});
 //    return innermostTypenameString(*T);
 //}
 
 bool
-populateFunctionBriefFromClass(FunctionInfo& I, CorpusImpl const& corpus)
+populateFunctionBriefFromClass(FunctionSymbol& I, CorpusImpl const& corpus)
 {
     switch (I.Class)
     {
@@ -194,7 +194,7 @@ populateFunctionBriefFromClass(FunctionInfo& I, CorpusImpl const& corpus)
 }
 
 bool
-isStreamInsertion(FunctionInfo const& function)
+isStreamInsertion(FunctionSymbol const& function)
 {
     MRDOCS_CHECK_OR(!function.IsRecordMethod, false);
     MRDOCS_CHECK_OR(function.Params.size() == 2, false);
@@ -202,11 +202,11 @@ isStreamInsertion(FunctionInfo const& function)
     // Check first param is a mutable left reference
     auto& firstParam = function.Params[0];
     MRDOCS_CHECK_OR(firstParam, false);
-    Polymorphic<TypeInfo> const& firstQualType = firstParam.Type;
+    Polymorphic<Type> const& firstQualType = firstParam.Type;
     MRDOCS_ASSERT(!firstQualType.valueless_after_move());
     MRDOCS_CHECK_OR(firstQualType->isLValueReference(), false);
     auto& firstNamedTypeOpt =
-        dynamic_cast<LValueReferenceTypeInfo const &>(*firstQualType)
+        dynamic_cast<LValueReferenceType const &>(*firstQualType)
             .PointeeType;
     MRDOCS_CHECK_OR(firstNamedTypeOpt, false);
     auto& firstNamedType = *firstNamedTypeOpt;
@@ -216,7 +216,7 @@ isStreamInsertion(FunctionInfo const& function)
 }
 
 bool
-populateFunctionBriefFromOperator(FunctionInfo& I)
+populateFunctionBriefFromOperator(FunctionSymbol& I)
 {
     MRDOCS_CHECK_OR(I.OverloadedOperator != OperatorKind::None, false);
 
@@ -252,7 +252,7 @@ populateFunctionBriefFromOperator(FunctionInfo& I)
 }
 
 void
-populateFunctionBrief(FunctionInfo& I, CorpusImpl const& corpus)
+populateFunctionBrief(FunctionSymbol& I, CorpusImpl const& corpus)
 {
     MRDOCS_CHECK_OR(!I.javadoc->brief);
     MRDOCS_CHECK_OR(!populateFunctionBriefFromClass(I, corpus));
@@ -260,25 +260,23 @@ populateFunctionBrief(FunctionInfo& I, CorpusImpl const& corpus)
 }
 
 
-
-
-Info const*
+Symbol const*
 getInfo(
-    Polymorphic<TypeInfo> const& R,
+    Polymorphic<Type> const& R,
     CorpusImpl const& corpus)
 {
     SymbolID const id = R->namedSymbol();
     MRDOCS_CHECK_OR(id, nullptr);
-    Info const* Rinfo = corpus.find(id);
+    Symbol const* Rinfo = corpus.find(id);
     return Rinfo;
 }
 
 doc::Brief const*
 getInfoBrief(
-    Polymorphic<TypeInfo> const& R,
+    Polymorphic<Type> const& R,
     CorpusImpl const& corpus)
 {
-    Info const* Rinfo = getInfo(R, corpus);
+    Symbol const* Rinfo = getInfo(R, corpus);
     MRDOCS_CHECK_OR(Rinfo, nullptr);
     MRDOCS_CHECK_OR(Rinfo->javadoc, nullptr);
     MRDOCS_CHECK_OR(Rinfo->javadoc->brief, nullptr);
@@ -287,7 +285,7 @@ getInfoBrief(
 
 bool
 populateFunctionReturnsFromFunctionBrief(
-    FunctionInfo& I)
+    FunctionSymbol& I)
 {
     MRDOCS_CHECK_OR(I.javadoc->brief, false);
     MRDOCS_CHECK_OR(I.javadoc->brief->children.size() == 1, false);
@@ -316,8 +314,8 @@ populateFunctionReturnsFromFunctionBrief(
 
 bool
 populateFunctionReturnsForSpecial(
-    FunctionInfo& I,
-    Polymorphic<TypeInfo> const& innerR,
+    FunctionSymbol& I,
+    Polymorphic<Type> const& innerR,
     CorpusImpl const& corpus)
 {
     if (I.Class == FunctionClass::Conversion)
@@ -352,7 +350,7 @@ populateFunctionReturnsForSpecial(
     MRDOCS_ASSERT(!I.ReturnType.valueless_after_move());
     if (I.ReturnType->isLValueReference())
     {
-        Info const* RInfo = getInfo(innerR, corpus);
+        Symbol const* RInfo = getInfo(innerR, corpus);
         MRDOCS_CHECK_OR(RInfo, false);
         MRDOCS_CHECK_OR(RInfo->id == I.Parent, false);
         I.javadoc->returns.emplace_back("Reference to the current object");
@@ -360,7 +358,7 @@ populateFunctionReturnsForSpecial(
     }
     else if (I.ReturnType->isPointer())
     {
-        Info const* RInfo = getInfo(innerR, corpus);
+        Symbol const* RInfo = getInfo(innerR, corpus);
         MRDOCS_CHECK_OR(RInfo, false);
         MRDOCS_CHECK_OR(RInfo->id == I.Parent, false);
         I.javadoc->returns.emplace_back("Pointer to the current object");
@@ -381,7 +379,7 @@ populateFunctionReturnsForSpecial(
         MRDOCS_CHECK_OR(I.ReturnType, false);
         MRDOCS_CHECK_OR(I.ReturnType->isNamed(), false);
         MRDOCS_CHECK_OR(
-            dynamic_cast<NamedTypeInfo &>(*I.ReturnType).FundamentalType ==
+            dynamic_cast<NamedType &>(*I.ReturnType).FundamentalType ==
                 FundamentalTypeKind::Bool,
             false);
         doc::Returns r;
@@ -437,8 +435,8 @@ populateFunctionReturnsForSpecial(
     MRDOCS_ASSERT(!innerR.valueless_after_move());
     if (I.IsRecordMethod &&
         innerR->isNamed() &&
-        dynamic_cast<NamedTypeInfo const &>(*innerR).Name->id &&
-        dynamic_cast<NamedTypeInfo const &>(*innerR).Name->id == I.Parent)
+        dynamic_cast<NamedType const &>(*innerR).Name->id &&
+        dynamic_cast<NamedType const &>(*innerR).Name->id == I.Parent)
     {
         MRDOCS_CHECK_OR(I.ReturnType, false);
         MRDOCS_ASSERT(!I.ReturnType.valueless_after_move());
@@ -467,8 +465,8 @@ populateFunctionReturnsForSpecial(
 
 bool
 populateFunctionReturnsFromReturnTypeBrief(
-    FunctionInfo& I,
-    Polymorphic<TypeInfo> const& innerR,
+    FunctionSymbol& I,
+    Polymorphic<Type> const& innerR,
     CorpusImpl const& corpus)
 {
     if (auto* brief = getInfoBrief(innerR, corpus))
@@ -480,7 +478,7 @@ populateFunctionReturnsFromReturnTypeBrief(
 }
 
 void
-populateFunctionReturns(FunctionInfo& I, CorpusImpl const& corpus)
+populateFunctionReturns(FunctionSymbol& I, CorpusImpl const& corpus)
 {
     MRDOCS_CHECK_OR(I.javadoc->returns.empty());
 
@@ -495,9 +493,9 @@ populateFunctionReturns(FunctionInfo& I, CorpusImpl const& corpus)
     MRDOCS_CHECK_OR(inner);
     if (inner->isNamed())
     {
-        auto& Ninner = dynamic_cast<NamedTypeInfo const &>(*inner);
+        auto& Ninner = dynamic_cast<NamedType const &>(*inner);
         MRDOCS_CHECK_OR(Ninner.Name);
-        MRDOCS_CHECK_OR(!Ninner.Name->Name.empty());
+        MRDOCS_CHECK_OR(!Ninner.Name->Identifier.empty());
         MRDOCS_CHECK_OR(Ninner.FundamentalType != FundamentalTypeKind::Void);
     }
 
@@ -515,10 +513,10 @@ populateFunctionReturns(FunctionInfo& I, CorpusImpl const& corpus)
     a list of parameters separated by commas. This function
     returns a list of all parameter names in the javadoc.
  */
-SmallVector<std::string_view, 32>
+llvm::SmallVector<std::string_view, 32>
 getJavadocParamNames(Javadoc const& javadoc)
 {
-    SmallVector<std::string_view, 32> result;
+    llvm::SmallVector<std::string_view, 32> result;
     for (auto const& javadocParam: javadoc.params)
     {
         auto const& paramNamesStr = javadocParam.name;
@@ -533,7 +531,7 @@ getJavadocParamNames(Javadoc const& javadoc)
 
 bool
 setCntrOrAssignParamName(
-    FunctionInfo& I,
+    FunctionSymbol& I,
     Param& param,
     std::size_t const index)
 {
@@ -553,7 +551,7 @@ setCntrOrAssignParamName(
         });
     MRDOCS_CHECK_OR(param.Type, false);
     MRDOCS_ASSERT(!param.Type.valueless_after_move());
-    Polymorphic<TypeInfo>& innerP = innermostType(param.Type);
+    Polymorphic<Type>& innerP = innermostType(param.Type);
     std::string_view paramName = "value";
     if (innerP->namedSymbol() == I.Parent)
     {
@@ -566,7 +564,7 @@ setCntrOrAssignParamName(
 
 bool
 setStreamOperatorParamName(
-    FunctionInfo& I,
+    FunctionSymbol& I,
     Param& param,
     std::size_t const index)
 {
@@ -588,7 +586,7 @@ setStreamOperatorParamName(
 
 bool
 setBinaryOpParamName(
-    FunctionInfo& I,
+    FunctionSymbol& I,
     Param& param,
     std::size_t const index)
 {
@@ -613,7 +611,7 @@ setBinaryOpParamName(
 
 bool
 setUnaryOpParamName(
-    FunctionInfo& I,
+    FunctionSymbol& I,
     Param& param,
     std::size_t const index)
 {
@@ -637,7 +635,7 @@ setUnaryOpParamName(
 
 bool
 setSpecialFunctionParamName(
-    FunctionInfo& I,
+    FunctionSymbol& I,
     Param& param,
     std::size_t index)
 {
@@ -650,7 +648,7 @@ setSpecialFunctionParamName(
 
 bool
 setCntrOrAssignParamDoc(
-    FunctionInfo& I,
+    FunctionSymbol& I,
     Param& param,
     std::size_t const index)
 {
@@ -669,11 +667,11 @@ setCntrOrAssignParamDoc(
     MRDOCS_CHECK_OR(innerParam, false);
     MRDOCS_CHECK_OR(innerParam->isNamed(), false);
     std::string_view const paramNoun
-        = dynamic_cast<NamedTypeInfo &>(*innerParam).FundamentalType ? "value"
+        = dynamic_cast<NamedType &>(*innerParam).FundamentalType ? "value"
                                                                     : "object";
     std::string_view const functionVerb = [&]() {
         bool const isAssign = I.OverloadedOperator == OperatorKind::Equal;
-        if (dynamic_cast<NamedTypeInfo &>(*innerParam).FundamentalType)
+        if (dynamic_cast<NamedType &>(*innerParam).FundamentalType)
         {
             return !isAssign ? "construct" : "assign";
         }
@@ -695,7 +693,7 @@ setCntrOrAssignParamDoc(
 
 bool
 setBinaryOpParamDoc(
-    FunctionInfo& I,
+    FunctionSymbol& I,
     Param& param,
     std::size_t const index)
 {
@@ -714,7 +712,7 @@ setBinaryOpParamDoc(
 
 bool
 setUnaryOpParamDoc(
-    FunctionInfo& I,
+    FunctionSymbol& I,
     Param& param,
     std::size_t const index)
 {
@@ -730,7 +728,7 @@ setUnaryOpParamDoc(
 
 bool
 setStreamOperatorParamDoc(
-    FunctionInfo& I,
+    FunctionSymbol& I,
     Param& param,
     std::size_t const index)
 {
@@ -749,7 +747,7 @@ setStreamOperatorParamDoc(
 
 void
 setFunctionParamDoc(
-    FunctionInfo& I,
+    FunctionSymbol& I,
     Param& param,
     std::size_t const index,
     CorpusImpl const& corpus)
@@ -783,10 +781,10 @@ setFunctionParamDoc(
 
 void
 populateFunctionParam(
-    FunctionInfo& I,
+    FunctionSymbol& I,
     Param& param,
     std::size_t const index,
-    SmallVector<std::string_view, 32>& documentedParams,
+    llvm::SmallVector<std::string_view, 32>& documentedParams,
     CorpusImpl const& corpus)
 {
     if (!param.Name)
@@ -802,7 +800,7 @@ populateFunctionParam(
 }
 
 void
-populateFunctionParams(FunctionInfo& I, CorpusImpl const& corpus)
+populateFunctionParams(FunctionSymbol& I, CorpusImpl const& corpus)
 {
     auto documentedParams = getJavadocParamNames(*I.javadoc);
     for (std::size_t i = 0; i < I.Params.size(); ++i)
@@ -812,6 +810,6 @@ populateFunctionParams(FunctionInfo& I, CorpusImpl const& corpus)
 }
 
 }
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_LIB_METADATA_FINALIZERS_JAVADOC_FUNCTION_HPP
diff --git a/src/lib/Metadata/Finalizers/Javadoc/Overloads.hpp b/src/lib/Metadata/Finalizers/Javadoc/Overloads.hpp
index 9b8ef1ff1..b13bdf50f 100644
--- a/src/lib/Metadata/Finalizers/Javadoc/Overloads.hpp
+++ b/src/lib/Metadata/Finalizers/Javadoc/Overloads.hpp
@@ -13,13 +13,13 @@
 
 #include <lib/CorpusImpl.hpp>
 #include <lib/Metadata/Finalizers/Javadoc/Function.hpp>
-#include <lib/Metadata/InfoSet.hpp>
+#include <lib/Metadata/SymbolSet.hpp>
 #include <utility>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 namespace {
 auto
-overloadFunctionsRange(OverloadsInfo const& O, CorpusImpl& corpus_)
+overloadFunctionsRange(OverloadsSymbol const& O, CorpusImpl& corpus_)
 {
     // Create a view all Info members of O
     auto functions =
@@ -28,11 +28,11 @@ overloadFunctionsRange(OverloadsInfo const& O, CorpusImpl& corpus_)
             {
                 return corpus_.find(id);
             }) |
-        std::views::filter([](Info const* infoPtr)
+        std::views::filter([](Symbol const* infoPtr)
             {
                 return infoPtr != nullptr && infoPtr->isFunction();
             }) |
-        std::views::transform([](Info const* infoPtr) -> FunctionInfo const&
+        std::views::transform([](Symbol const* infoPtr) -> FunctionSymbol const&
             {
                 return infoPtr->asFunction();
             });
@@ -41,12 +41,12 @@ overloadFunctionsRange(OverloadsInfo const& O, CorpusImpl& corpus_)
 
 template <class Range>
 bool
-populateOverloadsBriefIfAllSameBrief(OverloadsInfo& I, Range&& functionsWithBrief)
+populateOverloadsBriefIfAllSameBrief(OverloadsSymbol& I, Range&& functionsWithBrief)
 {
     auto first = *functionsWithBrief.begin();
     doc::Brief const& firstBrief = *first.javadoc->brief;
     if (auto otherFunctions = std::views::drop(functionsWithBrief, 1);
-        std::ranges::all_of(otherFunctions, [&](FunctionInfo const& otherFunction)
+        std::ranges::all_of(otherFunctions, [&](FunctionSymbol const& otherFunction)
         {
             doc::Brief const& otherBrief = *otherFunction.javadoc->brief;
             return otherBrief.children == firstBrief.children;
@@ -59,7 +59,7 @@ populateOverloadsBriefIfAllSameBrief(OverloadsInfo& I, Range&& functionsWithBrie
 }
 
 bool
-populateOverloadsFromClass(OverloadsInfo& I)
+populateOverloadsFromClass(OverloadsSymbol& I)
 {
     switch (I.Class)
     {
@@ -87,7 +87,7 @@ populateOverloadsFromClass(OverloadsInfo& I)
 
 template <class Range>
 bool
-populateOverloadsFromOperator(OverloadsInfo& I, Range&& functions)
+populateOverloadsFromOperator(OverloadsSymbol& I, Range&& functions)
 {
     MRDOCS_CHECK_OR(I.OverloadedOperator != OperatorKind::None, false);
 
@@ -100,7 +100,7 @@ populateOverloadsFromOperator(OverloadsInfo& I, Range&& functions)
     }
 
     // Find the operator name
-    auto isBinary = [&](FunctionInfo const& function) {
+    auto isBinary = [&](FunctionSymbol const& function) {
         return (function.Params.size() + function.IsRecordMethod) == 2;
     };
     auto isAllBinary = std::ranges::all_of(functions, isBinary);
@@ -114,7 +114,7 @@ populateOverloadsFromOperator(OverloadsInfo& I, Range&& functions)
 }
 
 bool
-populateOverloadsFromFunctionName(OverloadsInfo& I)
+populateOverloadsFromFunctionName(OverloadsSymbol& I)
 {
     std::string name = I.Name;
     if (name.empty() &&
@@ -136,10 +136,10 @@ populateOverloadsFromFunctionName(OverloadsInfo& I)
 
 template <class Range>
 void
-populateOverloadsBrief(OverloadsInfo& I, Range&& functions, CorpusImpl& corpus)
+populateOverloadsBrief(OverloadsSymbol& I, Range&& functions, CorpusImpl& corpus)
 {
     auto functionsWithBrief = std::views::
-        filter(functions, [](FunctionInfo const& function) {
+        filter(functions, [](FunctionSymbol const& function) {
         return function.javadoc && function.javadoc->brief
                && !function.javadoc->brief->empty();
     });
@@ -170,13 +170,13 @@ populateOverloadsBrief(OverloadsInfo& I, Range&& functions, CorpusImpl& corpus)
 // Populate with all the unique "returns" from the functions
 template <class Range>
 void
-populateOverloadsReturns(OverloadsInfo& I, Range&& functions) {
+populateOverloadsReturns(OverloadsSymbol& I, Range&& functions) {
     auto functionReturns = functions |
-        std::views::filter([](FunctionInfo const& function)
+        std::views::filter([](FunctionSymbol const& function)
             {
                 return function.javadoc && !function.javadoc->returns.empty();
             }) |
-        std::views::transform([](FunctionInfo const& function)
+        std::views::transform([](FunctionSymbol const& function)
             {
                 return function.javadoc->returns;
             }) |
@@ -198,13 +198,13 @@ populateOverloadsReturns(OverloadsInfo& I, Range&& functions) {
 
 template <class Range>
 void
-populateOverloadsParams(OverloadsInfo& I, Range& functions) {
+populateOverloadsParams(OverloadsSymbol& I, Range& functions) {
     auto functionParams = functions |
-        std::views::filter([](FunctionInfo const& function)
+        std::views::filter([](FunctionSymbol const& function)
             {
                 return function.javadoc && !function.javadoc->params.empty();
             }) |
-        std::views::transform([](FunctionInfo const& function)
+        std::views::transform([](FunctionSymbol const& function)
             {
                 return function.javadoc->params;
             }) |
@@ -226,13 +226,13 @@ populateOverloadsParams(OverloadsInfo& I, Range& functions) {
 
 template <class Range>
 void
-populateOverloadsTParams(OverloadsInfo& I, Range& functions) {
+populateOverloadsTParams(OverloadsSymbol& I, Range& functions) {
     auto functionTParams = functions |
-        std::views::filter([](FunctionInfo const& function)
+        std::views::filter([](FunctionSymbol const& function)
             {
                 return function.javadoc && !function.javadoc->tparams.empty();
             }) |
-        std::views::transform([](FunctionInfo const& function)
+        std::views::transform([](FunctionSymbol const& function)
             {
                 return function.javadoc->tparams;
             }) |
@@ -254,13 +254,13 @@ populateOverloadsTParams(OverloadsInfo& I, Range& functions) {
 
 template <class Range>
 void
-populateOverloadsExceptions(OverloadsInfo& I, Range& functions) {
+populateOverloadsExceptions(OverloadsSymbol& I, Range& functions) {
     auto functionExceptions = functions |
-        std::views::filter([](FunctionInfo const& function)
+        std::views::filter([](FunctionSymbol const& function)
             {
                 return function.javadoc && !function.javadoc->exceptions.empty();
             }) |
-        std::views::transform([](FunctionInfo const& function)
+        std::views::transform([](FunctionSymbol const& function)
             {
                 return function.javadoc->exceptions;
             }) |
@@ -282,13 +282,13 @@ populateOverloadsExceptions(OverloadsInfo& I, Range& functions) {
 
 template <class Range>
 void
-populateOverloadsSees(OverloadsInfo& I, Range& functions) {
+populateOverloadsSees(OverloadsSymbol& I, Range& functions) {
     auto functionSees = functions |
-        std::views::filter([](FunctionInfo const& function)
+        std::views::filter([](FunctionSymbol const& function)
             {
                 return function.javadoc && !function.javadoc->sees.empty();
             }) |
-        std::views::transform([](FunctionInfo const& function)
+        std::views::transform([](FunctionSymbol const& function)
             {
                 return function.javadoc->sees;
             }) |
@@ -310,13 +310,13 @@ populateOverloadsSees(OverloadsInfo& I, Range& functions) {
 
 template <class Range>
 void
-populateOverloadsPreconditions(OverloadsInfo& I, Range& functions) {
+populateOverloadsPreconditions(OverloadsSymbol& I, Range& functions) {
     auto functionsPres = functions |
-        std::views::filter([](FunctionInfo const& function)
+        std::views::filter([](FunctionSymbol const& function)
             {
                 return function.javadoc && !function.javadoc->preconditions.empty();
             }) |
-        std::views::transform([](FunctionInfo const& function)
+        std::views::transform([](FunctionSymbol const& function)
             {
                 return function.javadoc->preconditions;
             }) |
@@ -338,13 +338,13 @@ populateOverloadsPreconditions(OverloadsInfo& I, Range& functions) {
 
 template <class Range>
 void
-populateOverloadsPostconditions(OverloadsInfo& I, Range& functions) {
+populateOverloadsPostconditions(OverloadsSymbol& I, Range& functions) {
     auto functionsPosts = functions |
-        std::views::filter([](FunctionInfo const& function)
+        std::views::filter([](FunctionSymbol const& function)
             {
                 return function.javadoc && !function.javadoc->postconditions.empty();
             }) |
-        std::views::transform([](FunctionInfo const& function)
+        std::views::transform([](FunctionSymbol const& function)
             {
                 return function.javadoc->postconditions;
             }) |
@@ -365,6 +365,6 @@ populateOverloadsPostconditions(OverloadsInfo& I, Range& functions) {
 }
 
 }
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_LIB_METADATA_FINALIZERS_JAVADOC_OVERLOADS_HPP
diff --git a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp b/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
index 90970d597..874d77ea1 100644
--- a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
@@ -19,7 +19,7 @@
 #include <algorithm>
 #include <format>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 void
 JavadocFinalizer::
@@ -38,7 +38,7 @@ build()
     for (auto& infoPtr : corpus_.info_)
     {
         MRDOCS_ASSERT(infoPtr);
-        Info& I = *infoPtr;
+        Symbol& I = *infoPtr;
         MRDOCS_CHECK_OR_CONTINUE(I.Extraction != ExtractionMode::Dependency);
         finalizeBrief(I);
     }
@@ -53,7 +53,7 @@ build()
     for (auto& infoPtr : corpus_.info_)
     {
         MRDOCS_ASSERT(infoPtr);
-        Info& I = *infoPtr;
+        Symbol& I = *infoPtr;
         MRDOCS_CHECK_OR_CONTINUE(I.Extraction != ExtractionMode::Dependency);
         finalizeMetadataCopies(I);
     }
@@ -68,7 +68,7 @@ build()
         for (auto& infoPtr : corpus_.info_)
         {
             MRDOCS_ASSERT(infoPtr);
-            Info& I = *infoPtr;
+            Symbol& I = *infoPtr;
             MRDOCS_CHECK_OR_CONTINUE(I.isOverloads());
             MRDOCS_CHECK_OR_CONTINUE(I.Extraction != ExtractionMode::Dependency);
             if (!I.javadoc)
@@ -83,7 +83,7 @@ build()
     for (auto& infoPtr : corpus_.info_)
     {
         MRDOCS_ASSERT(infoPtr);
-        Info& I = *infoPtr;
+        Symbol& I = *infoPtr;
         MRDOCS_CHECK_OR_CONTINUE(I.Extraction != ExtractionMode::Dependency);
         finalizeJavadoc(I);
     }
@@ -98,7 +98,7 @@ build()
         for (auto& infoPtr : corpus_.info_)
         {
             MRDOCS_ASSERT(infoPtr);
-            Info& I = *infoPtr;
+            Symbol& I = *infoPtr;
             MRDOCS_CHECK_OR_CONTINUE(I.isFunction());
             MRDOCS_CHECK_OR_CONTINUE(I.Extraction != ExtractionMode::Dependency);
             populateFunctionJavadoc(I.asFunction());
@@ -109,7 +109,7 @@ build()
     for (auto& infoPtr : corpus_.info_)
     {
         MRDOCS_ASSERT(infoPtr);
-        Info& I = *infoPtr;
+        Symbol& I = *infoPtr;
         visit(I, [&](auto& U) {
             finalizeInfoData(U);
         });
@@ -122,7 +122,7 @@ build()
 
 void
 JavadocFinalizer::
-finalizeBrief(Info& I)
+finalizeBrief(Symbol& I)
 {
     MRDOCS_CHECK_OR(!finalized_brief_.contains(&I));
     finalized_brief_.emplace(&I);
@@ -145,7 +145,7 @@ finalizeBrief(Info& I)
         for (auto const& MemberIDs = OI.Members;
              auto& memberID : MemberIDs)
         {
-            Info* member = corpus_.find(memberID);
+            Symbol* member = corpus_.find(memberID);
             MRDOCS_CHECK_OR_CONTINUE(member);
             finalizeBrief(*member);
         }
@@ -193,8 +193,8 @@ copyBrief(Javadoc& javadoc)
         }
 
         // Ensure the brief source is finalized
-        Info const& res = *resRef;
-        finalizeBrief(const_cast<Info&>(res));
+        Symbol const& res = *resRef;
+        finalizeBrief(const_cast<Symbol&>(res));
 
         // Check if the source has a brief
         if (!res.javadoc ||
@@ -264,7 +264,7 @@ setAutoBrief(Javadoc& javadoc) const
 
 namespace {
 TemplateInfo const*
-getTemplateInfo(Info& I)
+getTemplateInfo(Symbol& I)
 {
     return visit(I, [](auto& I) -> TemplateInfo const* {
         if constexpr (requires { I.Template; })
@@ -281,7 +281,7 @@ getTemplateInfo(Info& I)
 
 void
 JavadocFinalizer::
-finalizeMetadataCopies(Info& I)
+finalizeMetadataCopies(Symbol& I)
 {
     MRDOCS_CHECK_OR(!finalized_metadata_.contains(&I));
     finalized_metadata_.emplace(&I);
@@ -295,7 +295,7 @@ finalizeMetadataCopies(Info& I)
     MRDOCS_CHECK_OR(!I.javadoc->blocks.empty());
     Javadoc& destJavadoc = *I.javadoc;
 
-    SmallVector<doc::CopyDetails, 16> copiedRefs;
+    llvm::SmallVector<doc::CopyDetails, 16> copiedRefs;
     for (auto& block: destJavadoc.blocks)
     {
         MRDOCS_CHECK_OR_CONTINUE(
@@ -339,18 +339,18 @@ finalizeMetadataCopies(Info& I)
         // We can't copy directly from the overload set
         // because its metadata is not created at this
         // step yet.
-        auto copyInfoRangeMetadata = [&](ArrayRef<Info const*> srcInfoPtrs)
+        auto copyInfoRangeMetadata = [&](llvm::ArrayRef<Symbol const*> srcInfoPtrs)
         {
             auto srcInfos = srcInfoPtrs
                             | std::views::transform(
-                                [](Info const* ptr) -> Info const& {
+                                [](Symbol const* ptr) -> Symbol const& {
                 return *ptr;
             });
 
             // Ensure the source metadata is finalized
             for (auto& srcInfo: srcInfos)
             {
-                auto& mutSrcInfo = const_cast<Info&>(srcInfo);
+                auto& mutSrcInfo = const_cast<Symbol&>(srcInfo);
                 finalizeMetadataCopies(mutSrcInfo);
             }
 
@@ -374,7 +374,7 @@ finalizeMetadataCopies(Info& I)
             if (I.isFunction())
             {
                 auto& destF = I.asFunction();
-                for (Info const& srcInfo: srcInfos)
+                for (Symbol const& srcInfo: srcInfos)
                 {
                     MRDOCS_CHECK_OR_CONTINUE(srcInfo.isFunction());
                     auto const& srcFunction = srcInfo.asFunction();
@@ -409,7 +409,7 @@ finalizeMetadataCopies(Info& I)
             // template parameters.
             if (auto const destTemplateInfo = getTemplateInfo(I))
             {
-                for (Info const& srcInfo: srcInfos)
+                for (Symbol const& srcInfo: srcInfos)
                 {
                     MRDOCS_CHECK_OR_CONTINUE(srcInfo.javadoc);
                     for (Javadoc const& srcJavadoc = *srcInfo.javadoc;
@@ -446,7 +446,7 @@ finalizeMetadataCopies(Info& I)
             if (destJavadoc.exceptions.empty() &&
                 !destIsNoExcept)
             {
-                for (Info const& srcInfo: srcInfos)
+                for (Symbol const& srcInfo: srcInfos)
                 {
                     MRDOCS_CHECK_OR_CONTINUE(srcInfo.javadoc);
                     for (doc::Throws const& exceptionsEl: srcInfo.javadoc->exceptions)
@@ -460,7 +460,7 @@ finalizeMetadataCopies(Info& I)
             // Copy sees only if destination sees are empty
             if (destJavadoc.sees.empty())
             {
-                for (Info const& srcInfo: srcInfos)
+                for (Symbol const& srcInfo: srcInfos)
                 {
                     MRDOCS_CHECK_OR_CONTINUE(srcInfo.javadoc);
                     for (doc::See const& seesEl: srcInfo.javadoc->sees)
@@ -474,7 +474,7 @@ finalizeMetadataCopies(Info& I)
             // Copy preconditions only if destination preconditions is empty
             if (destJavadoc.preconditions.empty())
             {
-                for (Info const& srcInfo: srcInfos)
+                for (Symbol const& srcInfo: srcInfos)
                 {
                     MRDOCS_CHECK_OR_CONTINUE(srcInfo.javadoc);
                     for (doc::Precondition const& preconditionsEl: srcInfo.javadoc->preconditions)
@@ -488,7 +488,7 @@ finalizeMetadataCopies(Info& I)
             // Copy postconditions only if destination postconditions is empty
             if (destJavadoc.postconditions.empty())
             {
-                for (Info const& srcInfo: srcInfos)
+                for (Symbol const& srcInfo: srcInfos)
                 {
                     MRDOCS_CHECK_OR_CONTINUE(srcInfo.javadoc);
                     for (doc::Postcondition const& postconditionsEl:
@@ -504,7 +504,7 @@ finalizeMetadataCopies(Info& I)
         };
 
         // Ensure the source metadata is finalized
-        Info const& res = *resRef;
+        Symbol const& res = *resRef;
         if (!res.isOverloads())
         {
             // If it's a single element, we check the element javadoc
@@ -529,17 +529,17 @@ finalizeMetadataCopies(Info& I)
                 }
                 continue;
             }
-            SmallVector<Info const*, 1> srcInfos = { &res };
+            llvm::SmallVector<Symbol const*, 1> srcInfos = { &res };
             copyInfoRangeMetadata(srcInfos);
         }
         else
         {
             auto& OI = res.asOverloads();
-            SmallVector<Info const*, 16> srcInfos;
+            llvm::SmallVector<Symbol const*, 16> srcInfos;
             srcInfos.reserve(OI.Members.size());
             for (auto& memberID: OI.Members)
             {
-                Info* member = corpus_.find(memberID);
+                Symbol* member = corpus_.find(memberID);
                 MRDOCS_CHECK_OR_CONTINUE(member);
                 srcInfos.push_back(member);
             }
@@ -550,7 +550,7 @@ finalizeMetadataCopies(Info& I)
 
 void
 JavadocFinalizer::
-populateFunctionJavadoc(FunctionInfo& I) const
+populateFunctionJavadoc(FunctionSymbol& I) const
 {
     // For special functions (constructors, destructors, ...),
     // we create the javadoc if it does not exist because
@@ -625,7 +625,7 @@ populateFunctionJavadoc(FunctionInfo& I) const
 
 void
 JavadocFinalizer::
-populateOverloadJavadoc(OverloadsInfo& I)
+populateOverloadJavadoc(OverloadsSymbol& I)
 {
     // Create a view all Info members of I.
     // The javadoc for these function should already be as
@@ -636,11 +636,11 @@ populateOverloadJavadoc(OverloadsInfo& I)
             {
                 return corpus_.find(id);
             }) |
-        std::views::filter([](Info const* infoPtr)
+        std::views::filter([](Symbol const* infoPtr)
             {
                 return infoPtr != nullptr && infoPtr->isFunction();
             }) |
-        std::views::transform([](Info const* infoPtr) -> FunctionInfo const&
+        std::views::transform([](Symbol const* infoPtr) -> FunctionSymbol const&
             {
                 return infoPtr->asFunction();
             });
@@ -665,7 +665,7 @@ populateOverloadJavadoc(OverloadsInfo& I)
 
 void
 JavadocFinalizer::
-finalizeJavadoc(Info& I)
+finalizeJavadoc(Symbol& I)
 {
     MRDOCS_CHECK_OR(!finalized_.contains(&I));
     finalized_.emplace(&I);
@@ -692,7 +692,7 @@ finalizeInfoData(InfoTy& I)
     {
         checkExists(I.Parent);
     }
-    if constexpr (InfoParent<InfoTy>)
+    if constexpr (SymbolParent<InfoTy>)
     {
         checkExists(allMembers(I));
     }
@@ -784,8 +784,8 @@ finalizeInfoData(InfoTy& I)
     }
 }
 
-#define INFO(T) template void JavadocFinalizer::finalizeInfoData<T## Info>(T## Info&);
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
+#define INFO(T) template void JavadocFinalizer::finalizeInfoData<T##Symbol>(T## Symbol&);
+#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
 
 void
 JavadocFinalizer::
@@ -800,7 +800,7 @@ finalize(doc::Reference& ref, bool const emitWarning)
     {
         // KRYSTIAN NOTE: We should provide an overload that
         // returns a non-const reference.
-        auto& res = const_cast<Info&>(*resRef);
+        auto& res = const_cast<Symbol&>(*resRef);
         ref.id = res.id;
     }
     else if (
@@ -903,9 +903,9 @@ processRelates(Javadoc& javadoc)
 
     MRDOCS_CHECK_OR(!javadoc.relates.empty());
 
-    Info const* currentPtr = corpus_.find(current_context_->id);
+    Symbol const* currentPtr = corpus_.find(current_context_->id);
     MRDOCS_ASSERT(currentPtr);
-    Info const& current = *currentPtr;
+    Symbol const& current = *currentPtr;
 
     if (!current.isFunction())
     {
@@ -919,9 +919,9 @@ processRelates(Javadoc& javadoc)
     for (doc::Reference& ref: javadoc.relates)
     {
         finalize(ref, true);
-        Info* relatedPtr = corpus_.find(ref.id);
+        Symbol* relatedPtr = corpus_.find(ref.id);
         MRDOCS_CHECK_OR_CONTINUE(relatedPtr);
-        Info& related = *relatedPtr;
+        Symbol& related = *relatedPtr;
         if (!related.javadoc)
         {
             related.javadoc.emplace();
@@ -1217,16 +1217,16 @@ unindentCodeBlocks(doc::Block& block)
 namespace {
 void
 pushAllDerivedClasses(
-    RecordInfo const* record,
-    SmallVector<Info*, 16>& relatedRecordsOrEnums,
+    RecordSymbol const* record,
+    llvm::SmallVector<Symbol*, 16>& relatedRecordsOrEnums,
     CorpusImpl& corpus)
 {
     for (auto& derivedId : record->Derived)
     {
-        Info* derivedPtr = corpus.find(derivedId);
+        Symbol* derivedPtr = corpus.find(derivedId);
         MRDOCS_CHECK_OR_CONTINUE(derivedPtr);
         MRDOCS_CHECK_OR_CONTINUE(derivedPtr->Extraction == ExtractionMode::Regular);
-        auto derived = dynamic_cast<RecordInfo*>(derivedPtr);
+        auto derived = dynamic_cast<RecordSymbol*>(derivedPtr);
         MRDOCS_CHECK_OR_CONTINUE(derived);
         relatedRecordsOrEnums.push_back(derived);
         // Recursively get derived classes of the derived class
@@ -1243,22 +1243,22 @@ setAutoRelates()
     MRDOCS_CHECK_OR(current_context_->Extraction == ExtractionMode::Regular);
     MRDOCS_CHECK_OR(current_context_->isFunction());
     MRDOCS_CHECK_OR(current_context_->javadoc);
-    auto& I = dynamic_cast<FunctionInfo&>(*current_context_);
+    auto& I = dynamic_cast<FunctionSymbol&>(*current_context_);
     MRDOCS_CHECK_OR(!I.IsRecordMethod);
     auto* parentPtr = corpus_.find(I.Parent);
     MRDOCS_CHECK_OR(parentPtr);
     MRDOCS_CHECK_OR(parentPtr->isNamespace());
 
-    auto toRecordOrEnum = [&](Polymorphic<TypeInfo> const& type) -> Info* {
+    auto toRecordOrEnum = [&](Polymorphic<Type> const& type) -> Symbol* {
         MRDOCS_CHECK_OR(type, nullptr);
         auto& innermost = innermostType(type);
         MRDOCS_CHECK_OR(innermost, nullptr);
         MRDOCS_CHECK_OR(innermost->isNamed(), nullptr);
-        auto const& namedType = dynamic_cast<NamedTypeInfo const&>(*innermost);
+        auto const& namedType = dynamic_cast<NamedType const&>(*innermost);
         MRDOCS_CHECK_OR(namedType.Name, nullptr);
         SymbolID const namedSymbolID = namedType.Name->id;
         MRDOCS_CHECK_OR(namedSymbolID != SymbolID::invalid, nullptr);
-        Info* infoPtr = corpus_.find(namedSymbolID);
+        Symbol* infoPtr = corpus_.find(namedSymbolID);
         MRDOCS_CHECK_OR(infoPtr, nullptr);
         MRDOCS_CHECK_OR(
             infoPtr->isRecord() ||
@@ -1266,7 +1266,7 @@ setAutoRelates()
         return infoPtr;
     };
 
-    SmallVector<Info*, 16> relatedRecordsOrEnums;
+    llvm::SmallVector<Symbol*, 16> relatedRecordsOrEnums;
 
     // 1) Inner type of the first parameter
     [&] {
@@ -1280,7 +1280,7 @@ setAutoRelates()
         // 2) If the type is a reference or a pointer, derived classes
         // of this inner type are also valid related records
         MRDOCS_CHECK_OR(firstParamInfo->isRecord());
-        auto const* firstParamRecord = dynamic_cast<RecordInfo*>(firstParamInfo);
+        auto const* firstParamRecord = dynamic_cast<RecordSymbol*>(firstParamInfo);
         MRDOCS_CHECK_OR(
             I.Params.front().Type->isLValueReference() ||
             I.Params.front().Type->isRValueReference() ||
@@ -1290,11 +1290,11 @@ setAutoRelates()
     }();
 
     // 3) The return type of the function
-    if (auto* returnTypeInfo = toRecordOrEnum(I.ReturnType))
+    if (auto* returnType = toRecordOrEnum(I.ReturnType))
     {
-        if (returnTypeInfo->Extraction == ExtractionMode::Regular)
+        if (returnType->Extraction == ExtractionMode::Regular)
         {
-            relatedRecordsOrEnums.push_back(returnTypeInfo);
+            relatedRecordsOrEnums.push_back(returnType);
         }
         // 4) If the return type is a template specialization,
         // and the template parameters are records, then
@@ -1302,10 +1302,10 @@ setAutoRelates()
         [&] {
             MRDOCS_CHECK_OR(I.ReturnType);
             MRDOCS_CHECK_OR(I.ReturnType->isNamed());
-            auto& NTI = dynamic_cast<NamedTypeInfo &>(*I.ReturnType);
+            auto& NTI = dynamic_cast<NamedType &>(*I.ReturnType);
             MRDOCS_CHECK_OR(NTI.Name);
             MRDOCS_CHECK_OR(NTI.Name->isSpecialization());
-            auto const& NTIS = dynamic_cast<SpecializationNameInfo &>(*NTI.Name);
+            auto const& NTIS = dynamic_cast<SpecializationName &>(*NTI.Name);
             MRDOCS_CHECK_OR(!NTIS.TemplateArgs.empty());
             Polymorphic<TArg> const& firstArg = NTIS.TemplateArgs.front();
             MRDOCS_CHECK_OR(firstArg->isType());
@@ -1328,17 +1328,17 @@ setAutoRelates()
 
     // Insert the records with valid ids into the javadoc relates section
     std::size_t const prevRelatesSize = I.javadoc->relates.size();
-    for (Info const* relatedRecordOrEnumPtr : relatedRecordsOrEnums)
+    for (Symbol const* relatedRecordOrEnumPtr : relatedRecordsOrEnums)
     {
         MRDOCS_CHECK_OR_CONTINUE(relatedRecordOrEnumPtr);
         MRDOCS_ASSERT(I.javadoc);
-        Info const& recordOrEnum = *relatedRecordOrEnumPtr;
+        Symbol const& recordOrEnum = *relatedRecordOrEnumPtr;
         MRDOCS_CHECK_OR_CONTINUE(recordOrEnum.Extraction == ExtractionMode::Regular);
         doc::Reference ref(recordOrEnum.Name);
         ref.id = recordOrEnum.id;
 
         // Check if already listed as friend
-        if (auto* record = dynamic_cast<RecordInfo const*>(relatedRecordOrEnumPtr))
+        if (auto* record = dynamic_cast<RecordSymbol const*>(relatedRecordOrEnumPtr))
         {
             using std::views::transform;
             if (contains(transform(record->Friends, &FriendInfo::id), I.id))
@@ -1493,8 +1493,8 @@ copyDetails(Javadoc& javadoc)
         }
 
         // Ensure the source node is finalized
-        Info const& res = *resRef;
-        finalizeJavadoc(const_cast<Info&>(res));
+        Symbol const& res = *resRef;
+        finalizeJavadoc(const_cast<Symbol&>(res));
 
         // Check if there's any documentation details to copy
         if (!res.javadoc)
@@ -1625,7 +1625,7 @@ finalize(TemplateInfo& info)
 
 void
 JavadocFinalizer::
-finalize(TypeInfo& type)
+finalize(Type& type)
 {
     finalize(innerTypePtr(type));
 
@@ -1650,7 +1650,7 @@ finalize(TypeInfo& type)
 
 void
 JavadocFinalizer::
-finalize(NameInfo& name)
+finalize(Name& name)
 {
     visit(name, [this]<typename Ty>(Ty& T)
     {
@@ -1838,13 +1838,13 @@ JavadocFinalizer::warnUndocumented()
     MRDOCS_CHECK_OR(corpus_.config->warnIfUndocumented);
     for (auto& undocI: corpus_.undocumented_)
     {
-        if (Info const* I = corpus_.find(undocI.id))
+        if (Symbol const* I = corpus_.find(undocI.id))
         {
             MRDOCS_CHECK_OR(
                 !I->javadoc || I->Extraction == ExtractionMode::Regular);
         }
-        bool const prefer_definition = undocI.kind == InfoKind::Record
-                                       || undocI.kind == InfoKind::Enum;
+        bool const prefer_definition = undocI.kind == SymbolKind::Record
+                                       || undocI.kind == SymbolKind::Enum;
         this->warn(
             *getPrimaryLocation(undocI.Loc, prefer_definition),
             "{}: Symbol is undocumented",
@@ -1862,13 +1862,13 @@ warnDocErrors()
     {
         MRDOCS_CHECK_OR_CONTINUE(I->Extraction == ExtractionMode::Regular);
         MRDOCS_CHECK_OR_CONTINUE(I->isFunction());
-        warnParamErrors(dynamic_cast<FunctionInfo const&>(*I));
+        warnParamErrors(dynamic_cast<FunctionSymbol const&>(*I));
     }
 }
 
 void
 JavadocFinalizer::
-warnParamErrors(FunctionInfo const& I)
+warnParamErrors(FunctionSymbol const& I)
 {
     MRDOCS_CHECK_OR(I.javadoc);
 
@@ -1918,13 +1918,13 @@ warnNoParamDocs()
         MRDOCS_CHECK_OR_CONTINUE(I->Extraction == ExtractionMode::Regular);
         MRDOCS_CHECK_OR_CONTINUE(I->isFunction());
         MRDOCS_CHECK_OR_CONTINUE(I->javadoc);
-        warnNoParamDocs(dynamic_cast<FunctionInfo const&>(*I));
+        warnNoParamDocs(dynamic_cast<FunctionSymbol const&>(*I));
     }
 }
 
 void
 JavadocFinalizer::
-warnNoParamDocs(FunctionInfo const& I)
+warnNoParamDocs(FunctionSymbol const& I)
 {
     MRDOCS_CHECK_OR(!I.IsDeleted);
     // Check for function parameters that are not documented in javadoc
@@ -1950,12 +1950,12 @@ warnNoParamDocs(FunctionInfo const& I)
     if (I.javadoc->returns.empty())
     {
         MRDOCS_ASSERT(!I.ReturnType.valueless_after_move());
-        auto isVoid = [](TypeInfo const& returnType) -> bool
+        auto isVoid = [](Type const& returnType) -> bool
         {
             if (returnType.isNamed())
             {
-                auto const& namedReturnType = dynamic_cast<NamedTypeInfo const&>(returnType);
-                return namedReturnType.Name->Name == "void";
+                auto const& namedReturnType = dynamic_cast<NamedType const&>(returnType);
+                return namedReturnType.Name->Identifier == "void";
             }
             return false;
         };
@@ -1996,13 +1996,13 @@ warnUnnamedParams()
         MRDOCS_CHECK_OR_CONTINUE(I->isFunction());
         MRDOCS_CHECK_OR_CONTINUE(I->Extraction == ExtractionMode::Regular);
         MRDOCS_CHECK_OR_CONTINUE(I->javadoc);
-        warnUnnamedParams(dynamic_cast<FunctionInfo const&>(*I));
+        warnUnnamedParams(dynamic_cast<FunctionSymbol const&>(*I));
     }
 }
 
 void
 JavadocFinalizer::
-warnUnnamedParams(FunctionInfo const& I)
+warnUnnamedParams(FunctionSymbol const& I)
 {
     auto orderSuffix = [](std::size_t const i) -> std::string
     {
@@ -2035,4 +2035,4 @@ warnUnnamedParams(FunctionInfo const& I)
     }
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Metadata/Finalizers/JavadocFinalizer.hpp b/src/lib/Metadata/Finalizers/JavadocFinalizer.hpp
index 5a0a85b17..790f7b686 100644
--- a/src/lib/Metadata/Finalizers/JavadocFinalizer.hpp
+++ b/src/lib/Metadata/Finalizers/JavadocFinalizer.hpp
@@ -13,14 +13,14 @@
 #define MRDOCS_LIB_METADATA_FINALIZERS_JAVADOCFINALIZER_HPP
 
 #include <lib/CorpusImpl.hpp>
-#include <lib/Metadata/InfoSet.hpp>
+#include <lib/Metadata/SymbolSet.hpp>
 #include <mrdocs/Support/Report.hpp>
 #include <mrdocs/Support/ScopeExit.hpp>
 #include <format>
 #include <set>
 #include <utility>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Finalizes a set of Info.
 
@@ -33,7 +33,7 @@ namespace clang::mrdocs {
 class JavadocFinalizer
 {
     CorpusImpl& corpus_;
-    Info* current_context_ = nullptr;
+    Symbol* current_context_ = nullptr;
 
     /* Broken references for which we have already emitted
        a warning.
@@ -45,15 +45,15 @@ class JavadocFinalizer
        This is used to avoid allow recursion when
        finalizing references.
      */
-    std::set<Info const*> finalized_;
+    std::set<Symbol const*> finalized_;
 
     /* Info objects whose brief have been finalized
      */
-    std::set<Info const*> finalized_brief_;
+    std::set<Symbol const*> finalized_brief_;
 
     /* Info objects whose metadata have been finalized
      */
-    std::set<Info const*> finalized_metadata_;
+    std::set<Symbol const*> finalized_metadata_;
 
     // A comparison function that sorts locations by:
     // 1) ascending full path
@@ -119,7 +119,7 @@ class JavadocFinalizer
         summary.
      */
     void
-    finalizeBrief(Info& I);
+    finalizeBrief(Symbol& I);
 
     /** Copy the brief from another symbol
 
@@ -147,7 +147,7 @@ class JavadocFinalizer
         reference to another symbol created with \@copydoc.
      */
     void
-    finalizeMetadataCopies(Info& I);
+    finalizeMetadataCopies(Symbol& I);
 
     /** Populate function javadoc from with missing fields
 
@@ -155,7 +155,7 @@ class JavadocFinalizer
         missing fields of special functions.
      */
     void
-    populateFunctionJavadoc(FunctionInfo&) const;
+    populateFunctionJavadoc(FunctionSymbol&) const;
 
     /** Populate the metadata of overloads
 
@@ -163,7 +163,7 @@ class JavadocFinalizer
         with the metadata of the functions it overloads.
      */
     void
-    populateOverloadJavadoc(OverloadsInfo&);
+    populateOverloadJavadoc(OverloadsSymbol&);
 
     /** Resolve references in the javadoc
 
@@ -173,7 +173,7 @@ class JavadocFinalizer
         the reference.
      */
     void
-    finalizeJavadoc(Info& I);
+    finalizeJavadoc(Symbol& I);
 
     /** Recursively finalize javadoc members
 
@@ -333,13 +333,13 @@ class JavadocFinalizer
     void
     finalize(TemplateInfo& info);
 
-    /// Remove invalid ids from TypeInfo members
+    /// Remove invalid ids from Type members
     void
-    finalize(TypeInfo& type);
+    finalize(Type& type);
 
-    /// Remove invalid ids from NameInfo members
+    /// Remove invalid ids from Name members
     void
-    finalize(NameInfo& name);
+    finalize(Name& name);
 
     /// Finalize polymorphic
     template <class T>
@@ -432,13 +432,13 @@ class JavadocFinalizer
     warnDocErrors();
 
     void
-    warnParamErrors(FunctionInfo const& I);
+    warnParamErrors(FunctionSymbol const& I);
 
     void
     warnNoParamDocs();
 
     void
-    warnNoParamDocs(FunctionInfo const& I);
+    warnNoParamDocs(FunctionSymbol const& I);
 
     void
     warnUndocEnumValues();
@@ -447,9 +447,9 @@ class JavadocFinalizer
     warnUnnamedParams();
 
     void
-    warnUnnamedParams(FunctionInfo const& I);
+    warnUnnamedParams(FunctionSymbol const& I);
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_LIB_METADATA_FINALIZERS_JAVADOCFINALIZER_HPP
diff --git a/src/lib/Metadata/Finalizers/NamespacesFinalizer.cpp b/src/lib/Metadata/Finalizers/NamespacesFinalizer.cpp
index 424f4cebf..b8c6d4be1 100644
--- a/src/lib/Metadata/Finalizers/NamespacesFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/NamespacesFinalizer.cpp
@@ -11,20 +11,20 @@
 #include "NamespacesFinalizer.hpp"
 #include <mrdocs/Support/Report.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 NamespacesFinalizer::FinalizerResult
 NamespacesFinalizer::
-operator()(NamespaceInfo& I)
+operator()(NamespaceSymbol& I)
 {
     report::trace(
         "Finalizing namespace '{}'",
         corpus_.Corpus::qualifiedName(I));
 
     // 1) Finalize sub-namespaces
-    SmallVector<SymbolID, 64> removedNamespaces;
+    llvm::SmallVector<SymbolID, 64> removedNamespaces;
     for (auto subNamespaces = corpus_.find(I.Members.Namespaces);
-         Info& info: subNamespaces)
+         Symbol& info: subNamespaces)
     {
         MRDOCS_ASSERT(info.isNamespace());
         SymbolID memberID = info.id;
@@ -70,7 +70,7 @@ operator()(NamespaceInfo& I)
     bool allDependencies = true;
     bool allImplementationDefined = true;
     bool anySeeBelow = false;
-    for (Info const& member : members)
+    for (Symbol const& member : members)
     {
         if (member.Extraction == ExtractionMode::Regular)
         {
@@ -107,4 +107,4 @@ operator()(NamespaceInfo& I)
     return FinalizerResult::Changed;
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Metadata/Finalizers/NamespacesFinalizer.hpp b/src/lib/Metadata/Finalizers/NamespacesFinalizer.hpp
index 30e040384..c37053a56 100644
--- a/src/lib/Metadata/Finalizers/NamespacesFinalizer.hpp
+++ b/src/lib/Metadata/Finalizers/NamespacesFinalizer.hpp
@@ -12,9 +12,9 @@
 #define MRDOCS_LIB_METADATA_FINALIZERS_NAMESPACESFINALIZER_HPP
 
 #include <lib/CorpusImpl.hpp>
-#include <lib/Metadata/InfoSet.hpp>
+#include <lib/Metadata/SymbolSet.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Finalizes the namespaces in corpus.
 
@@ -36,7 +36,7 @@ class NamespacesFinalizer
     void
     build()
     {
-        Info* info = corpus_.find(SymbolID::global);
+        Symbol* info = corpus_.find(SymbolID::global);
         MRDOCS_CHECK_OR(info);
         MRDOCS_ASSERT(info->isNamespace());
         operator()(info->asNamespace());
@@ -49,9 +49,9 @@ class NamespacesFinalizer
     };
 
     FinalizerResult
-    operator()(NamespaceInfo& I);
+    operator()(NamespaceSymbol& I);
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_LIB_METADATA_FINALIZERS_NAMESPACESFINALIZER_HPP
diff --git a/src/lib/Metadata/Finalizers/OverloadsFinalizer.cpp b/src/lib/Metadata/Finalizers/OverloadsFinalizer.cpp
index 0dc8a0709..5ee684be3 100644
--- a/src/lib/Metadata/Finalizers/OverloadsFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/OverloadsFinalizer.cpp
@@ -11,17 +11,17 @@
 #include "OverloadsFinalizer.hpp"
 #include <mrdocs/Support/Assert.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 namespace {
 SymbolID
 findBaseClassPermutation(
     SymbolID const& contextId,
     CorpusImpl& corpus,
-    ArrayRef<SymbolID> sameNameFunctionIds)
+    llvm::ArrayRef<SymbolID> sameNameFunctionIds)
 {
-    // Find the RecordInfo
-    Info* info = corpus.find(contextId);
+    // Find the RecordSymbol
+    Symbol* info = corpus.find(contextId);
     MRDOCS_CHECK_OR(info, SymbolID::invalid);
     MRDOCS_CHECK_OR(info->isRecord(), SymbolID::invalid);
     for (auto const& base: info->asRecordPtr()->Bases)
@@ -52,7 +52,7 @@ findBaseClassPermutation(
                 // name functions
                 for (SymbolID const& baseID: *trancheFunctionsPtr)
                 {
-                    Info* baseFuncMember = corpus.find(baseID);
+                    Symbol* baseFuncMember = corpus.find(baseID);
                     MRDOCS_CHECK_OR_CONTINUE(baseFuncMember);
                     MRDOCS_CHECK_OR_CONTINUE(baseFuncMember->isOverloads());
                     auto* overloads = baseFuncMember->asOverloadsPtr();
@@ -74,23 +74,23 @@ SymbolID
 findIntroducedNamespacePermutation(
     SymbolID const& contextId,
     CorpusImpl& corpus,
-    ArrayRef<SymbolID> sameNameFunctionIds)
+    llvm::ArrayRef<SymbolID> sameNameFunctionIds)
 {
-    // Find the UsingInfo
-    Info* info = corpus.find(contextId);
+    // Find the UsingSymbol
+    Symbol* info = corpus.find(contextId);
     MRDOCS_CHECK_OR(info, SymbolID::invalid);
     MRDOCS_CHECK_OR(info->isUsing(), SymbolID::invalid);
 
-    // Find the FunctionInfo for the first shadow declaration
+    // Find the FunctionSymbol for the first shadow declaration
     MRDOCS_CHECK_OR(!sameNameFunctionIds.empty(), SymbolID::invalid);
-    Info* firstShadowInfo = corpus.find(sameNameFunctionIds.front());
+    Symbol* firstShadowInfo = corpus.find(sameNameFunctionIds.front());
     MRDOCS_CHECK_OR(firstShadowInfo, SymbolID::invalid);
     MRDOCS_CHECK_OR(firstShadowInfo->isFunction(), SymbolID::invalid);
     auto* firstShadowFunction = firstShadowInfo->asFunctionPtr();
 
     // Find the introduced namespace of the first shadow declaration
     MRDOCS_CHECK_OR(firstShadowFunction->Parent, SymbolID::invalid);
-    Info* parentInfo = corpus.find(firstShadowFunction->Parent);
+    Symbol* parentInfo = corpus.find(firstShadowFunction->Parent);
     MRDOCS_CHECK_OR(parentInfo, SymbolID::invalid);
     MRDOCS_CHECK_OR(parentInfo->isNamespace(), SymbolID::invalid);
     auto* parentNamespace = parentInfo->asNamespacePtr();
@@ -98,7 +98,7 @@ findIntroducedNamespacePermutation(
     // Find an overload set that's a permutation of the same name functions
     for (SymbolID const& baseID: parentNamespace->Members.Functions)
     {
-        Info* baseFuncMember = corpus.find(baseID);
+        Symbol* baseFuncMember = corpus.find(baseID);
         MRDOCS_CHECK_OR_CONTINUE(baseFuncMember);
         MRDOCS_CHECK_OR_CONTINUE(baseFuncMember->isOverloads());
         auto* overloads = baseFuncMember->asOverloadsPtr();
@@ -118,27 +118,27 @@ void
 OverloadsFinalizer::
 foldOverloads(SymbolID const& contextId, std::vector<SymbolID>& functionIds, bool isStatic)
 {
-    Info* contextInfo = corpus_.find(contextId);
+    Symbol* contextInfo = corpus_.find(contextId);
     MRDOCS_CHECK_OR(contextInfo);
 
     for (auto functionIdIt = functionIds.begin();
          functionIdIt != functionIds.end();
          ++functionIdIt)
     {
-        // Get the FunctionInfo for the current id
+        // Get the FunctionSymbol for the current id
         auto infoPtr = corpus_.find(*functionIdIt);
         MRDOCS_CHECK_OR_CONTINUE(infoPtr);
         auto* function = infoPtr->asFunctionPtr();
         MRDOCS_CHECK_OR_CONTINUE(function);
 
-        // Check if the FunctionInfo is unique
+        // Check if the FunctionSymbol is unique
         std::ranges::subrange otherFunctionIds(
             std::next(functionIdIt),
             functionIds.end());
         auto isSameNameFunction = [&](SymbolID const& otherID) {
             auto const otherFunctionPtr = corpus_.find(otherID);
             MRDOCS_CHECK_OR(otherFunctionPtr, false);
-            Info const& otherInfo = *otherFunctionPtr;
+            Symbol const& otherInfo = *otherFunctionPtr;
             return function->Name == otherInfo.Name;
         };
         auto sameNameIt = std::ranges::
@@ -146,11 +146,11 @@ foldOverloads(SymbolID const& contextId, std::vector<SymbolID>& functionIds, boo
         bool const isUniqueFunction = sameNameIt == otherFunctionIds.end();
         MRDOCS_CHECK_OR_CONTINUE(!isUniqueFunction);
 
-        // Create a list of FunctionInfo overloads
+        // Create a list of FunctionSymbol overloads
         auto sameNameFunctionIdsView =
             std::ranges::subrange(functionIdIt, functionIds.end()) |
             std::views::filter(isSameNameFunction);
-        SmallVector<SymbolID, 16> sameNameFunctionIds(
+        llvm::SmallVector<SymbolID, 16> sameNameFunctionIds(
             sameNameFunctionIdsView.begin(),
             sameNameFunctionIdsView.end());
 
@@ -209,16 +209,16 @@ foldOverloads(SymbolID const& contextId, std::vector<SymbolID>& functionIds, boo
             }
         }
 
-        // FunctionInfo is not unique and there's no equivalent
+        // FunctionSymbol is not unique and there's no equivalent
         // overload set in base classes, so we merge it with the
-        // other FunctionInfos into a new OverloadsInfo
-        OverloadsInfo O(contextId, function->Name, function->Access, isStatic);
+        // other FunctionSymbols into a new OverloadsSymbol
+        OverloadsSymbol O(contextId, function->Name, function->Access, isStatic);
         addMember(O, *function);
         *functionIdIt = O.id;
         auto const itOffset = functionIdIt - functionIds.begin();
         for (auto otherIt = functionIdIt + 1; otherIt != functionIds.end(); ++otherIt)
         {
-            Info* otherInfoPtr = corpus_.find(*otherIt);
+            Symbol* otherInfoPtr = corpus_.find(*otherIt);
             MRDOCS_CHECK_OR_CONTINUE(otherInfoPtr);
             auto* otherFunction = otherInfoPtr->asFunctionPtr();
             MRDOCS_CHECK_OR_CONTINUE(otherFunction);
@@ -229,7 +229,7 @@ foldOverloads(SymbolID const& contextId, std::vector<SymbolID>& functionIds, boo
             }
         }
         functionIdIt = functionIds.begin() + itOffset;
-        MRDOCS_ASSERT(corpus_.info_.emplace(std::make_unique<OverloadsInfo>(std::move(O))).second);
+        MRDOCS_ASSERT(corpus_.info_.emplace(std::make_unique<OverloadsSymbol>(std::move(O))).second);
     }
 }
 
@@ -243,10 +243,10 @@ toDerivedView(std::vector<SymbolID> const& ids, CorpusImpl& c)
        std::views::transform([&c](SymbolID const& id) {
             return c.find(id);
         }) |
-       std::views::filter([](Info* infoPtr) {
+       std::views::filter([](Symbol* infoPtr) {
             return infoPtr != nullptr;
        }) |
-      std::views::transform([](Info* infoPtr) -> T* {
+      std::views::transform([](Symbol* infoPtr) -> T* {
          return dynamic_cast<T*>(infoPtr);
       }) |
       std::views::filter([](T* ptr) {
@@ -260,21 +260,21 @@ toDerivedView(std::vector<SymbolID> const& ids, CorpusImpl& c)
 
 void
 OverloadsFinalizer::
-operator()(NamespaceInfo& I)
+operator()(NamespaceSymbol& I)
 {
     MRDOCS_CHECK_OR(!finalized_.contains(I.id));
     finalized_.emplace(I.id);
 
     foldOverloads(I.id, I.Members.Functions, true);
-    for (RecordInfo& RI: toDerivedView<RecordInfo>(I.Members.Records, corpus_))
+    for (RecordSymbol& RI: toDerivedView<RecordSymbol>(I.Members.Records, corpus_))
     {
         operator()(RI);
     }
-    for (NamespaceInfo& NI: toDerivedView<NamespaceInfo>(I.Members.Namespaces, corpus_))
+    for (NamespaceSymbol& NI: toDerivedView<NamespaceSymbol>(I.Members.Namespaces, corpus_))
     {
         operator()(NI);
     }
-    for (UsingInfo& UI: toDerivedView<UsingInfo>(I.Members.Usings, corpus_))
+    for (UsingSymbol& UI: toDerivedView<UsingSymbol>(I.Members.Usings, corpus_))
     {
         operator()(UI);
     }
@@ -282,7 +282,7 @@ operator()(NamespaceInfo& I)
 
 void
 OverloadsFinalizer::
-operator()(RecordInfo& I)
+operator()(RecordSymbol& I)
 {
     MRDOCS_CHECK_OR(!finalized_.contains(I.id));
     finalized_.emplace(I.id);
@@ -296,7 +296,7 @@ operator()(RecordInfo& I)
         MRDOCS_CHECK_OR(NT.Name);
         auto& NI = NT.Name->asName();
         MRDOCS_CHECK_OR(NI.id);
-        Info* baseInfo = corpus_.find(NI.id);
+        Symbol* baseInfo = corpus_.find(NI.id);
         MRDOCS_CHECK_OR(baseInfo);
         auto* baseRecord = baseInfo->asRecordPtr();
         MRDOCS_CHECK_OR(baseRecord);
@@ -308,28 +308,28 @@ operator()(RecordInfo& I)
     foldOverloads(I.id, I.Interface.Public.StaticFunctions, true);
     foldOverloads(I.id, I.Interface.Protected.StaticFunctions, true);
     foldOverloads(I.id, I.Interface.Private.StaticFunctions, true);
-    for (RecordInfo& RI: toDerivedView<RecordInfo>(I.Interface.Public.Records, corpus_)) {
+    for (RecordSymbol& RI: toDerivedView<RecordSymbol>(I.Interface.Public.Records, corpus_)) {
         operator()(RI);
     }
-    for (RecordInfo& RI: toDerivedView<RecordInfo>(I.Interface.Protected.Records, corpus_)) {
+    for (RecordSymbol& RI: toDerivedView<RecordSymbol>(I.Interface.Protected.Records, corpus_)) {
         operator()(RI);
     }
-    for (RecordInfo& RI: toDerivedView<RecordInfo>(I.Interface.Private.Records, corpus_)) {
+    for (RecordSymbol& RI: toDerivedView<RecordSymbol>(I.Interface.Private.Records, corpus_)) {
         operator()(RI);
     }
 }
 
 void
 OverloadsFinalizer::
-operator()(UsingInfo& I)
+operator()(UsingSymbol& I)
 {
     MRDOCS_CHECK_OR(!finalized_.contains(I.id));
     finalized_.emplace(I.id);
 
-    auto shadowFunctions = toDerivedView<FunctionInfo>(I.ShadowDeclarations, corpus_);
-    for (FunctionInfo& FI: shadowFunctions)
+    auto shadowFunctions = toDerivedView<FunctionSymbol>(I.ShadowDeclarations, corpus_);
+    for (FunctionSymbol& FI: shadowFunctions)
     {
-        Info* PI = corpus_.find(FI.Parent);
+        Symbol* PI = corpus_.find(FI.Parent);
         MRDOCS_CHECK_OR_CONTINUE(PI);
         if (auto* NI = PI->asNamespacePtr())
         {
@@ -344,4 +344,4 @@ operator()(UsingInfo& I)
     foldOverloads(I.id, I.ShadowDeclarations, true);
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Metadata/Finalizers/OverloadsFinalizer.hpp b/src/lib/Metadata/Finalizers/OverloadsFinalizer.hpp
index 10b3c2e53..cb065ba2d 100644
--- a/src/lib/Metadata/Finalizers/OverloadsFinalizer.hpp
+++ b/src/lib/Metadata/Finalizers/OverloadsFinalizer.hpp
@@ -12,9 +12,9 @@
 #define MRDOCS_LIB_METADATA_FINALIZERS_OVERLOADSFINALIZER_HPP
 
 #include <lib/CorpusImpl.hpp>
-#include <lib/Metadata/InfoSet.hpp>
+#include <lib/Metadata/SymbolSet.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Finalizes a set of Info.
 
@@ -52,24 +52,24 @@ class OverloadsFinalizer
     /* Visit the namespace members identifying overload sets
      */
     void
-    operator()(NamespaceInfo& I);
+    operator()(NamespaceSymbol& I);
 
     /* Visit the record members identifying overload sets
      */
     void
-    operator()(RecordInfo& I);
+    operator()(RecordSymbol& I);
 
     /* Visit the using directive shadows for overloads
      */
     void
-    operator()(UsingInfo& I);
+    operator()(UsingSymbol& I);
 
     /* No-op for other Info types
      */
     void
-    operator()(Info&) {}
+    operator()(Symbol&) {}
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_LIB_METADATA_FINALIZERS_OVERLOADSFINALIZER_HPP
diff --git a/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp b/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp
index 8aae386dd..f36233856 100644
--- a/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp
@@ -12,7 +12,7 @@
 #include <algorithm>
 #include <ranges>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 namespace {
 // Comparison function by symbol IDs
@@ -25,7 +25,7 @@ struct SymbolIDCompareFn
     Optional<FunctionClass>
     findFunctionClass(InfoTy const& I)
     {
-        if constexpr (std::same_as<InfoTy, Info>)
+        if constexpr (std::same_as<InfoTy, Symbol>)
         {
             return visit(I, []<class U>(U const& u)
                 -> Optional<FunctionClass>
@@ -34,8 +34,8 @@ struct SymbolIDCompareFn
             });
         }
         else if constexpr (
-            std::same_as<FunctionInfo, InfoTy> ||
-            std::same_as<OverloadsInfo, InfoTy>)
+            std::same_as<FunctionSymbol, InfoTy> ||
+            std::same_as<OverloadsSymbol, InfoTy>)
         {
             return I.Class;
         }
@@ -47,7 +47,7 @@ struct SymbolIDCompareFn
     Optional<OperatorKind>
     findOperatorKind(InfoTy const& I)
     {
-        if constexpr (std::same_as<InfoTy, Info>)
+        if constexpr (std::same_as<InfoTy, Symbol>)
         {
             return visit(I, []<class U>(U const& u)
                 -> Optional<OperatorKind>
@@ -56,8 +56,8 @@ struct SymbolIDCompareFn
             });
         }
         else if constexpr (
-            std::same_as<FunctionInfo, InfoTy> ||
-            std::same_as<OverloadsInfo, InfoTy>)
+            std::same_as<FunctionSymbol, InfoTy> ||
+            std::same_as<OverloadsSymbol, InfoTy>)
         {
             return I.OverloadedOperator;
         }
@@ -68,12 +68,12 @@ struct SymbolIDCompareFn
     operator()(SymbolID const& lhsId, SymbolID const& rhsId) const
     {
         // Get Info from SymbolID
-        Info const* lhsPtr = corpus_.find(lhsId);
+        Symbol const* lhsPtr = corpus_.find(lhsId);
         MRDOCS_CHECK_OR(lhsPtr, false);
-        Info const* rhsPtr = corpus_.find(rhsId);
+        Symbol const* rhsPtr = corpus_.find(rhsId);
         MRDOCS_CHECK_OR(rhsPtr, true);
-        Info const& lhs = *lhsPtr;
-        Info const& rhs = *rhsPtr;
+        Symbol const& lhs = *lhsPtr;
+        Symbol const& rhs = *rhsPtr;
 
         // Constructors come first
         Optional<FunctionClass> const lhsClass = findFunctionClass(lhs);
@@ -163,20 +163,20 @@ struct SymbolIDCompareFn
             (lhsOp && *lhsOp == OperatorKind::Equal &&
              rhsOp && *rhsOp == OperatorKind::Equal))
         {
-            FunctionInfo const& lhsF = lhs.asFunction();
-            FunctionInfo const& rhsF = rhs.asFunction();
+            FunctionSymbol const& lhsF = lhs.asFunction();
+            FunctionSymbol const& rhsF = rhs.asFunction();
             if (lhsF.Params.size() == 1 && rhsF.Params.size() == 1)
             {
-                auto isCopyOrMoveConstOrAssign = [](FunctionInfo const& I) {
+                auto isCopyOrMoveConstOrAssign = [](FunctionSymbol const& I) {
                     if (I.Params.size() == 1)
                     {
                         auto const& param = I.Params[0];
-                        Polymorphic<TypeInfo> const& paramType = param.Type;
+                        Polymorphic<Type> const& paramType = param.Type;
                         MRDOCS_ASSERT(!paramType.valueless_after_move());
                         MRDOCS_CHECK_OR(
                             paramType->isLValueReference() ||
                             paramType->isRValueReference(), false);
-                        Polymorphic<TypeInfo> const &paramRefPointeeOpt =
+                        Polymorphic<Type> const &paramRefPointeeOpt =
                             paramType->isLValueReference()
                                 ? paramType->asLValueReference().PointeeType
                                 : paramType->asRValueReference().PointeeType;
@@ -214,7 +214,7 @@ struct SymbolIDCompareFn
         }
 
         // Special cases are handled, so use the configuration criteria
-        Info const* P = corpus_.find(lhs.Parent);
+        Symbol const* P = corpus_.find(lhs.Parent);
         bool const isClassMember = P && P->isRecord();
         auto const generalSortCriteria =
             isClassMember
@@ -222,13 +222,13 @@ struct SymbolIDCompareFn
                 : corpus_.config->sortNamespaceMembersBy;
         switch (generalSortCriteria)
         {
-        case clang::mrdocs::PublicSettings::SortSymbolBy::Name:
+        case mrdocs::PublicSettings::SortSymbolBy::Name:
             if (auto const cmp = lhs.Name <=> rhs.Name; cmp != 0)
             {
                 return std::is_lt(cmp);
             }
             break;
-        case clang::mrdocs::PublicSettings::SortSymbolBy::Location:
+        case mrdocs::PublicSettings::SortSymbolBy::Location:
         {
             // By location: short path, line, column
             auto const& lhsLoc = getPrimaryLocation(lhs);
@@ -318,10 +318,10 @@ toDerivedView(std::vector<SymbolID> const& ids, CorpusImpl& c)
        std::views::transform([&c](SymbolID const& id) {
             return c.find(id);
         }) |
-       std::views::filter([](Info* infoPtr) {
+       std::views::filter([](Symbol* infoPtr) {
             return infoPtr != nullptr;
        }) |
-      std::views::transform([](Info* infoPtr) -> T* {
+      std::views::transform([](Symbol* infoPtr) -> T* {
          return dynamic_cast<T*>(infoPtr);
       }) |
       std::views::filter([](T* ptr) {
@@ -335,21 +335,21 @@ toDerivedView(std::vector<SymbolID> const& ids, CorpusImpl& c)
 
 void
 SortMembersFinalizer::
-operator()(NamespaceInfo& I)
+operator()(NamespaceSymbol& I)
 {
     // Sort members of all tranches
     sortMembers(I.Members);
 
     // Recursively sort members of child namespaces, records, and overloads
-    for (RecordInfo& RI: toDerivedView<RecordInfo>(I.Members.Records, corpus_))
+    for (RecordSymbol& RI: toDerivedView<RecordSymbol>(I.Members.Records, corpus_))
     {
         operator()(RI);
     }
-    for (NamespaceInfo& RI: toDerivedView<NamespaceInfo>(I.Members.Namespaces, corpus_))
+    for (NamespaceSymbol& RI: toDerivedView<NamespaceSymbol>(I.Members.Namespaces, corpus_))
     {
         operator()(RI);
     }
-    for (OverloadsInfo& RI: toDerivedView<OverloadsInfo>(I.Members.Functions, corpus_))
+    for (OverloadsSymbol& RI: toDerivedView<OverloadsSymbol>(I.Members.Functions, corpus_))
     {
         operator()(RI);
     }
@@ -357,7 +357,7 @@ operator()(NamespaceInfo& I)
 
 void
 SortMembersFinalizer::
-operator()(RecordInfo& I)
+operator()(RecordSymbol& I)
 {
     // Sort members of all tranches if sorting is enabled for records
     if (corpus_.config->sortMembers)
@@ -366,39 +366,39 @@ operator()(RecordInfo& I)
     }
 
     // Recursively sort members of child records and overloads
-    for (RecordInfo& RI: toDerivedView<RecordInfo>(I.Interface.Public.Records, corpus_))
+    for (RecordSymbol& RI: toDerivedView<RecordSymbol>(I.Interface.Public.Records, corpus_))
     {
         operator()(RI);
     }
-    for (RecordInfo& RI: toDerivedView<RecordInfo>(I.Interface.Protected.Records, corpus_))
+    for (RecordSymbol& RI: toDerivedView<RecordSymbol>(I.Interface.Protected.Records, corpus_))
     {
         operator()(RI);
     }
-    for (RecordInfo& RI: toDerivedView<RecordInfo>(I.Interface.Private.Records, corpus_))
+    for (RecordSymbol& RI: toDerivedView<RecordSymbol>(I.Interface.Private.Records, corpus_))
     {
         operator()(RI);
     }
-    for (OverloadsInfo& RI: toDerivedView<OverloadsInfo>(I.Interface.Public.Functions, corpus_))
+    for (OverloadsSymbol& RI: toDerivedView<OverloadsSymbol>(I.Interface.Public.Functions, corpus_))
     {
         operator()(RI);
     }
-    for (OverloadsInfo& RI: toDerivedView<OverloadsInfo>(I.Interface.Protected.Functions, corpus_))
+    for (OverloadsSymbol& RI: toDerivedView<OverloadsSymbol>(I.Interface.Protected.Functions, corpus_))
     {
         operator()(RI);
     }
-    for (OverloadsInfo& RI: toDerivedView<OverloadsInfo>(I.Interface.Private.Functions, corpus_))
+    for (OverloadsSymbol& RI: toDerivedView<OverloadsSymbol>(I.Interface.Private.Functions, corpus_))
     {
         operator()(RI);
     }
-    for (OverloadsInfo& RI: toDerivedView<OverloadsInfo>(I.Interface.Public.StaticFunctions, corpus_))
+    for (OverloadsSymbol& RI: toDerivedView<OverloadsSymbol>(I.Interface.Public.StaticFunctions, corpus_))
     {
         operator()(RI);
     }
-    for (OverloadsInfo& RI: toDerivedView<OverloadsInfo>(I.Interface.Protected.StaticFunctions, corpus_))
+    for (OverloadsSymbol& RI: toDerivedView<OverloadsSymbol>(I.Interface.Protected.StaticFunctions, corpus_))
     {
         operator()(RI);
     }
-    for (OverloadsInfo& RI: toDerivedView<OverloadsInfo>(I.Interface.Private.StaticFunctions, corpus_))
+    for (OverloadsSymbol& RI: toDerivedView<OverloadsSymbol>(I.Interface.Private.StaticFunctions, corpus_))
     {
         operator()(RI);
     }
@@ -406,10 +406,10 @@ operator()(RecordInfo& I)
 
 void
 SortMembersFinalizer::
-operator()(OverloadsInfo& I)
+operator()(OverloadsSymbol& I)
 {
     // Sort the member functions
     sortMembers(I.Members);
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Metadata/Finalizers/SortMembersFinalizer.hpp b/src/lib/Metadata/Finalizers/SortMembersFinalizer.hpp
index 283dc0187..efeaeb980 100644
--- a/src/lib/Metadata/Finalizers/SortMembersFinalizer.hpp
+++ b/src/lib/Metadata/Finalizers/SortMembersFinalizer.hpp
@@ -12,9 +12,9 @@
 #define MRDOCS_LIB_METADATA_FINALIZERS_SORTMEMBERSFINALIZER_HPP
 
 #include <lib/CorpusImpl.hpp>
-#include <lib/Metadata/InfoSet.hpp>
+#include <lib/Metadata/SymbolSet.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Finalizes a set of Info.
 
@@ -57,25 +57,25 @@ class SortMembersFinalizer
     void
     build()
     {
-        Info* globalPtr = corpus_.find(SymbolID::global);
+        Symbol* globalPtr = corpus_.find(SymbolID::global);
         MRDOCS_CHECK_OR(globalPtr);
         MRDOCS_ASSERT(globalPtr->isNamespace());
         operator()(globalPtr->asNamespace());
     }
 
     void
-    operator()(NamespaceInfo& I);
+    operator()(NamespaceSymbol& I);
 
     void
-    operator()(RecordInfo& I);
+    operator()(RecordSymbol& I);
 
     void
-    operator()(OverloadsInfo& I);
+    operator()(OverloadsSymbol& I);
 
     void
-    operator()(Info&) {}
+    operator()(Symbol&) {}
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_LIB_METADATA_FINALIZERS_SORTMEMBERSFINALIZER_HPP
diff --git a/src/lib/Metadata/Info.cpp b/src/lib/Metadata/Info.cpp
index eb2ab26e2..721b7d55a 100644
--- a/src/lib/Metadata/Info.cpp
+++ b/src/lib/Metadata/Info.cpp
@@ -15,30 +15,30 @@
 #include <mrdocs/Dom/LazyObject.hpp>
 #include <mrdocs/Metadata.hpp>
 #include <mrdocs/Metadata/DomCorpus.hpp>
-#include <mrdocs/Metadata/Info/Record.hpp>
+#include <mrdocs/Metadata/Symbol/Record.hpp>
 #include <mrdocs/Support/String.hpp>
 #include <clang/AST/Type.h>
 #include <llvm/ADT/STLExtras.h>
 #include <llvm/Support/FileSystem.h>
 #include <llvm/Support/Path.h>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 dom::String
-toString(InfoKind const kind) noexcept
+toString(SymbolKind const kind) noexcept
 {
     switch(kind)
     {
 #define INFO(Type) \
-    case InfoKind::Type: return toKebabCase(#Type);
-#include <mrdocs/Metadata/Info/InfoNodes.inc>
+    case SymbolKind::Type: return toKebabCase(#Type);
+#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
     default:
         MRDOCS_UNREACHABLE();
     }
 }
 
 void
-merge(Info& I, Info&& Other)
+merge(Symbol& I, Symbol&& Other)
 {
     MRDOCS_ASSERT(I.id);
     merge(I.Loc, std::move(Other.Loc));
@@ -67,4 +67,4 @@ merge(Info& I, Info&& Other)
     }
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Metadata/Info/Concept.cpp b/src/lib/Metadata/Info/Concept.cpp
index e3762af31..28aea5bf5 100644
--- a/src/lib/Metadata/Info/Concept.cpp
+++ b/src/lib/Metadata/Info/Concept.cpp
@@ -10,14 +10,14 @@
 //
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Info/Concept.hpp>
+#include <mrdocs/Metadata/Symbol/Concept.hpp>
 #include <llvm/ADT/STLExtras.h>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 std::strong_ordering
-ConceptInfo::
-operator<=>(ConceptInfo const& other) const
+ConceptSymbol::
+operator<=>(ConceptSymbol const& other) const
 {
     if (auto const cmp = Name <=> other.Name;
         !std::is_eq(cmp))
@@ -59,7 +59,7 @@ operator<=>(ConceptInfo const& other) const
 }
 
 void
-merge(ConceptInfo& I, ConceptInfo&& Other)
+merge(ConceptSymbol& I, ConceptSymbol&& Other)
 {
     MRDOCS_ASSERT(canMerge(I, Other));
     merge(I.asInfo(), std::move(Other.asInfo()));
@@ -73,5 +73,5 @@ merge(ConceptInfo& I, ConceptInfo&& Other)
     }
 }
 
-} // clang::mrdocs
+} // mrdocs
 
diff --git a/src/lib/Metadata/Info/Enum.cpp b/src/lib/Metadata/Info/Enum.cpp
index e94e789dc..d076cf8c7 100644
--- a/src/lib/Metadata/Info/Enum.cpp
+++ b/src/lib/Metadata/Info/Enum.cpp
@@ -10,10 +10,10 @@
 //
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Info/Enum.hpp>
+#include <mrdocs/Metadata/Symbol/Enum.hpp>
 #include <llvm/ADT/STLExtras.h>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 namespace {
 
@@ -35,7 +35,7 @@ reduceSymbolIDs(
 } // (anon)
 
 void
-merge(EnumInfo& I, EnumInfo&& Other)
+merge(EnumSymbol& I, EnumSymbol&& Other)
 {
     MRDOCS_ASSERT(canMerge(I, Other));
     merge(I.asInfo(), std::move(Other.asInfo()));
@@ -50,5 +50,5 @@ merge(EnumInfo& I, EnumInfo&& Other)
     reduceSymbolIDs(I.Constants, std::move(Other.Constants));
 }
 
-} // clang::mrdocs
+} // mrdocs
 
diff --git a/src/lib/Metadata/Info/EnumConstant.cpp b/src/lib/Metadata/Info/EnumConstant.cpp
index 08979b448..a8ae6aeaa 100644
--- a/src/lib/Metadata/Info/EnumConstant.cpp
+++ b/src/lib/Metadata/Info/EnumConstant.cpp
@@ -10,13 +10,13 @@
 //
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Info/EnumConstant.hpp>
+#include <mrdocs/Metadata/Symbol/EnumConstant.hpp>
 #include <llvm/ADT/STLExtras.h>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 void
-merge(EnumConstantInfo& I, EnumConstantInfo&& Other)
+merge(EnumConstantSymbol& I, EnumConstantSymbol&& Other)
 {
     MRDOCS_ASSERT(canMerge(I, Other));
     merge(I.asInfo(), std::move(Other.asInfo()));
@@ -26,5 +26,5 @@ merge(EnumConstantInfo& I, EnumConstantInfo&& Other)
     }
 }
 
-} // clang::mrdocs
+} // mrdocs
 
diff --git a/src/lib/Metadata/Info/Friend.cpp b/src/lib/Metadata/Info/Friend.cpp
index 4dbe59d49..d4d7f4826 100644
--- a/src/lib/Metadata/Info/Friend.cpp
+++ b/src/lib/Metadata/Info/Friend.cpp
@@ -10,10 +10,10 @@
 //
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Info/Friend.hpp>
+#include <mrdocs/Metadata/Symbol/Friend.hpp>
 #include <llvm/ADT/STLExtras.h>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 void
 merge(FriendInfo& I, FriendInfo&& Other)
@@ -28,5 +28,5 @@ merge(FriendInfo& I, FriendInfo&& Other)
     }
 }
 
-} // clang::mrdocs
+} // mrdocs
 
diff --git a/src/lib/Metadata/Info/Function.cpp b/src/lib/Metadata/Info/Function.cpp
index 0958ce35b..8a2c20ad2 100644
--- a/src/lib/Metadata/Info/Function.cpp
+++ b/src/lib/Metadata/Info/Function.cpp
@@ -11,11 +11,11 @@
 //
 
 #include <mrdocs/Dom/LazyObject.hpp>
-#include <mrdocs/Metadata/Info/Function.hpp>
+#include <mrdocs/Metadata/Symbol/Function.hpp>
 #include <mrdocs/Support/TypeTraits.hpp>
 #include <utility>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 namespace {
 
@@ -330,8 +330,8 @@ tag_invoke(
 }
 
 std::strong_ordering
-FunctionInfo::
-operator<=>(FunctionInfo const& other) const
+FunctionSymbol::
+operator<=>(FunctionSymbol const& other) const
 {
     if (auto const cmp = Name <=> other.Name;
         !std::is_eq(cmp))
@@ -383,7 +383,7 @@ operator<=>(FunctionInfo const& other) const
 }
 
 void
-merge(FunctionInfo& I, FunctionInfo&& Other)
+merge(FunctionSymbol& I, FunctionSymbol&& Other)
 {
     MRDOCS_ASSERT(canMerge(I, Other));
     merge(I.asInfo(), std::move(Other.asInfo()));
@@ -457,9 +457,9 @@ merge(FunctionInfo& I, FunctionInfo&& Other)
 
 MRDOCS_DECL
 bool
-overrides(FunctionInfo const& base, FunctionInfo const& derived)
+overrides(FunctionSymbol const& base, FunctionSymbol const& derived)
 {
-    auto toOverrideTuple = [](FunctionInfo const& f) {
+    auto toOverrideTuple = [](FunctionSymbol const& f) {
         return std::forward_as_tuple(
             f.Name,
             f.Params,
@@ -472,5 +472,5 @@ overrides(FunctionInfo const& base, FunctionInfo const& derived)
     return toOverrideTuple(base) == toOverrideTuple(derived);
 }
 
-} // clang::mrdocs
+} // mrdocs
 
diff --git a/src/lib/Metadata/Info/Guide.cpp b/src/lib/Metadata/Info/Guide.cpp
index 1fc51fcd2..a9a1e4122 100644
--- a/src/lib/Metadata/Info/Guide.cpp
+++ b/src/lib/Metadata/Info/Guide.cpp
@@ -10,16 +10,16 @@
 //
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Info/Guide.hpp>
-#include <mrdocs/Metadata/Info/Param.hpp>
+#include <mrdocs/Metadata/Symbol/Guide.hpp>
+#include <mrdocs/Metadata/Symbol/Param.hpp>
 #include <llvm/ADT/STLExtras.h>
 #include <vector>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 std::strong_ordering
-GuideInfo::
-operator<=>(GuideInfo const& other) const
+GuideSymbol::
+operator<=>(GuideSymbol const& other) const
 {
     if (auto const cmp = Name <=> other.Name;
         !std::is_eq(cmp))
@@ -79,7 +79,7 @@ operator<=>(GuideInfo const& other) const
 }
 
 
-void merge(GuideInfo& I, GuideInfo&& Other)
+void merge(GuideSymbol& I, GuideSymbol&& Other)
 {
     MRDOCS_ASSERT(canMerge(I, Other));
     merge(I.asInfo(), std::move(Other.asInfo()));
@@ -101,4 +101,4 @@ void merge(GuideInfo& I, GuideInfo&& Other)
     }
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Metadata/Info/Namespace.cpp b/src/lib/Metadata/Info/Namespace.cpp
index 3fcebcee2..b38fc9073 100644
--- a/src/lib/Metadata/Info/Namespace.cpp
+++ b/src/lib/Metadata/Info/Namespace.cpp
@@ -10,14 +10,14 @@
 //
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Info/Namespace.hpp>
+#include <mrdocs/Metadata/Symbol/Namespace.hpp>
 #include <llvm/ADT/STLExtras.h>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 std::strong_ordering
-NamespaceInfo::
-operator<=>(NamespaceInfo const& other) const
+NamespaceSymbol::
+operator<=>(NamespaceSymbol const& other) const
 {
     if (auto const res = this->asInfo() <=> other.asInfo();
         std::is_neq(res))
@@ -73,8 +73,8 @@ reduceSymbolIDs(
 
 void
 reduceNames(
-    std::vector<NameInfo>& list,
-    std::vector<NameInfo>&& otherList)
+    std::vector<Name>& list,
+    std::vector<Name>&& otherList)
 {
     for(auto const& id : otherList)
     {
@@ -103,7 +103,7 @@ merge(NamespaceTranche& I, NamespaceTranche&& Other)
 }
 
 void
-merge(NamespaceInfo& I, NamespaceInfo&& Other)
+merge(NamespaceSymbol& I, NamespaceSymbol&& Other)
 {
     MRDOCS_ASSERT(canMerge(I, Other));
     merge(I.asInfo(), std::move(Other.asInfo()));
@@ -112,5 +112,5 @@ merge(NamespaceInfo& I, NamespaceInfo&& Other)
     I.IsInline |= Other.IsInline;
     I.IsAnonymous |= Other.IsAnonymous;
 }
-} // clang::mrdocs
+} // mrdocs
 
diff --git a/src/lib/Metadata/Info/NamespaceAlias.cpp b/src/lib/Metadata/Info/NamespaceAlias.cpp
index 8f79a616f..379c6cf94 100644
--- a/src/lib/Metadata/Info/NamespaceAlias.cpp
+++ b/src/lib/Metadata/Info/NamespaceAlias.cpp
@@ -10,19 +10,19 @@
 //
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Info/NamespaceAlias.hpp>
+#include <mrdocs/Metadata/Symbol/NamespaceAlias.hpp>
 #include <llvm/ADT/STLExtras.h>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 void
-merge(NamespaceAliasInfo& I, NamespaceAliasInfo&& Other)
+merge(NamespaceAliasSymbol& I, NamespaceAliasSymbol&& Other)
 {
     MRDOCS_ASSERT(canMerge(I, Other));
     merge(I.asInfo(), std::move(Other.asInfo()));
-    if (I.AliasedSymbol.Name.empty())
+    if (I.AliasedSymbol.Identifier.empty())
     {
-        I.AliasedSymbol.Name = std::move(Other.AliasedSymbol.Name);
+        I.AliasedSymbol.Identifier = std::move(Other.AliasedSymbol.Identifier);
     }
     if (!I.AliasedSymbol.id)
     {
@@ -30,5 +30,5 @@ merge(NamespaceAliasInfo& I, NamespaceAliasInfo&& Other)
     }
 }
 
-} // clang::mrdocs
+} // mrdocs
 
diff --git a/src/lib/Metadata/Info/Overloads.cpp b/src/lib/Metadata/Info/Overloads.cpp
index e7659d37c..a6b1b4996 100644
--- a/src/lib/Metadata/Info/Overloads.cpp
+++ b/src/lib/Metadata/Info/Overloads.cpp
@@ -12,24 +12,24 @@
 #include <mrdocs/Corpus.hpp>
 #include <mrdocs/Dom/LazyArray.hpp>
 #include <mrdocs/Metadata/DomCorpus.hpp>
-#include <mrdocs/Metadata/Info/Function.hpp>
-#include <mrdocs/Metadata/Info/Namespace.hpp>
-#include <mrdocs/Metadata/Info/Overloads.hpp>
+#include <mrdocs/Metadata/Symbol/Function.hpp>
+#include <mrdocs/Metadata/Symbol/Namespace.hpp>
+#include <mrdocs/Metadata/Symbol/Overloads.hpp>
 #include <llvm/ADT/STLExtras.h>
 #include <llvm/ADT/StringRef.h>
 #include <format>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
-OverloadsInfo::OverloadsInfo(SymbolID const &Parent, std::string_view Name,
+OverloadsSymbol::OverloadsSymbol(SymbolID const &Parent, std::string_view Name,
                              AccessKind access, bool isStatic) noexcept
-    : InfoCommonBase(SymbolID::createFromString(std::format(
+    : SymbolCommonBase(SymbolID::createFromString(std::format(
           "{}-{}-{}-{}", toBase16(Parent), Name, toString(access), isStatic))) {
   this->Parent = Parent;
 }
 
 void
-merge(OverloadsInfo& I, OverloadsInfo&& Other)
+merge(OverloadsSymbol& I, OverloadsSymbol&& Other)
 {
     merge(I.asInfo(), std::move(Other.asInfo()));
     namespace stdr = std::ranges;
@@ -41,7 +41,7 @@ merge(OverloadsInfo& I, OverloadsInfo&& Other)
 }
 
 void
-addMember(OverloadsInfo& I, FunctionInfo const& Member)
+addMember(OverloadsSymbol& I, FunctionSymbol const& Member)
 {
     if (I.Members.empty())
     {
@@ -58,11 +58,11 @@ addMember(OverloadsInfo& I, FunctionInfo const& Member)
         if (I.ReturnType != Member.ReturnType)
         {
             // The return types differ, so we use 'auto' to indicate that.
-            I.ReturnType = Polymorphic<TypeInfo>(AutoTypeInfo{});
+            I.ReturnType = Polymorphic<Type>(AutoType{});
         }
     }
     merge(I.Loc, Member.Loc);
     I.Members.push_back(Member.id);
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Metadata/Info/Record.cpp b/src/lib/Metadata/Info/Record.cpp
index b5cd1f261..75b464128 100644
--- a/src/lib/Metadata/Info/Record.cpp
+++ b/src/lib/Metadata/Info/Record.cpp
@@ -9,11 +9,11 @@
 //
 
 #include <mrdocs/Dom/LazyObject.hpp>
-#include <mrdocs/Metadata/Info/Record.hpp>
 #include <mrdocs/Metadata/Name.hpp>
+#include <mrdocs/Metadata/Symbol/Record.hpp>
 #include <ranges>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 dom::String
 toString(
@@ -68,8 +68,8 @@ reduceSymbolIDs(
 } // (anon)
 
 std::strong_ordering
-RecordInfo::
-operator<=>(RecordInfo const& other) const
+RecordSymbol::
+operator<=>(RecordSymbol const& other) const
 {
     if (auto const cmp = Name <=> other.Name;
         !std::is_eq(cmp))
@@ -134,7 +134,7 @@ merge(RecordInterface& I, RecordInterface&& Other)
 }
 
 void
-merge(RecordInfo& I, RecordInfo&& Other)
+merge(RecordSymbol& I, RecordSymbol&& Other)
 {
     merge(I.asInfo(), std::move(Other.asInfo()));
     if (Other.KeyKind != RecordKeyKind::Struct &&
@@ -183,4 +183,4 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Metadata/Info/Typedef.cpp b/src/lib/Metadata/Info/Typedef.cpp
index 991c99699..e6d798e8f 100644
--- a/src/lib/Metadata/Info/Typedef.cpp
+++ b/src/lib/Metadata/Info/Typedef.cpp
@@ -10,15 +10,15 @@
 //
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/Info/Typedef.hpp>
+#include <mrdocs/Metadata/Symbol.hpp>
+#include <mrdocs/Metadata/Symbol/Typedef.hpp>
 #include <llvm/ADT/STLExtras.h>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 std::strong_ordering
-TypedefInfo::
-operator<=>(TypedefInfo const& other) const
+TypedefSymbol::
+operator<=>(TypedefSymbol const& other) const
 {
     if (auto const cmp = Name <=> other.Name;
         !std::is_eq(cmp))
@@ -59,7 +59,7 @@ operator<=>(TypedefInfo const& other) const
     return this->asInfo() <=> other.asInfo();
 }
 
-void merge(TypedefInfo& I, TypedefInfo&& Other)
+void merge(TypedefSymbol& I, TypedefSymbol&& Other)
 {
     MRDOCS_ASSERT(canMerge(I, Other));
     merge(I.asInfo(), std::move(Other.asInfo()));
@@ -69,7 +69,7 @@ void merge(TypedefInfo& I, TypedefInfo&& Other)
     }
     MRDOCS_ASSERT(!I.Type.valueless_after_move());
     if (I.Type->isNamed() &&
-        I.Type->asNamed().Name->Name.empty())
+        I.Type->asNamed().Name->Identifier.empty())
     {
         I.Type = std::move(Other.Type);
     }
@@ -79,5 +79,5 @@ void merge(TypedefInfo& I, TypedefInfo&& Other)
     }
 }
 
-} // clang::mrdocs
+} // mrdocs
 
diff --git a/src/lib/Metadata/Info/Using.cpp b/src/lib/Metadata/Info/Using.cpp
index a3412dab4..f4ad51aa4 100644
--- a/src/lib/Metadata/Info/Using.cpp
+++ b/src/lib/Metadata/Info/Using.cpp
@@ -10,10 +10,10 @@
 //
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Info/Using.hpp>
+#include <mrdocs/Metadata/Symbol/Using.hpp>
 #include <llvm/ADT/STLExtras.h>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 namespace {
 
@@ -35,7 +35,7 @@ reduceSymbolIDs(
 } // (anon)
 
 void
-merge(UsingInfo& I, UsingInfo&& Other)
+merge(UsingSymbol& I, UsingSymbol&& Other)
 {
     MRDOCS_ASSERT(canMerge(I, Other));
     merge(I.asInfo(), std::move(Other.asInfo()));
@@ -45,11 +45,11 @@ merge(UsingInfo& I, UsingInfo&& Other)
         I.Class = Other.Class;
     }
     MRDOCS_ASSERT(!I.IntroducedName.valueless_after_move());
-    if (I.IntroducedName->Name.empty())
+    if (I.IntroducedName->Identifier.empty())
     {
         I.IntroducedName = std::move(Other.IntroducedName);
     }
 }
 
-} // clang::mrdocs
+} // mrdocs
 
diff --git a/src/lib/Metadata/Info/Variable.cpp b/src/lib/Metadata/Info/Variable.cpp
index d99b11810..8251ff1e9 100644
--- a/src/lib/Metadata/Info/Variable.cpp
+++ b/src/lib/Metadata/Info/Variable.cpp
@@ -10,14 +10,14 @@
 //
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Info/Variable.hpp>
+#include <mrdocs/Metadata/Symbol/Variable.hpp>
 #include <llvm/ADT/STLExtras.h>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 std::strong_ordering
-VariableInfo::
-operator<=>(VariableInfo const& other) const
+VariableSymbol::
+operator<=>(VariableSymbol const& other) const
 {
     if (auto const cmp = Name <=> other.Name;
         !std::is_eq(cmp))
@@ -59,13 +59,13 @@ operator<=>(VariableInfo const& other) const
 }
 
 void
-merge(VariableInfo& I, VariableInfo&& Other)
+merge(VariableSymbol& I, VariableSymbol&& Other)
 {
     MRDOCS_ASSERT(canMerge(I, Other));
     merge(I.asInfo(), std::move(Other.asInfo()));
     MRDOCS_ASSERT(!I.Type.valueless_after_move());
     if (I.Type->isNamed() &&
-        I.Type->asNamed().Name->Name.empty())
+        I.Type->asNamed().Name->Identifier.empty())
     {
         I.Type = std::move(Other.Type);
     }
@@ -101,5 +101,5 @@ merge(VariableInfo& I, VariableInfo&& Other)
     I.HasNoUniqueAddress |= Other.HasNoUniqueAddress;
 }
 
-} // clang::mrdocs
+} // mrdocs
 
diff --git a/src/lib/Metadata/Javadoc.cpp b/src/lib/Metadata/Javadoc.cpp
index a7f82da07..3afddee5f 100644
--- a/src/lib/Metadata/Javadoc.cpp
+++ b/src/lib/Metadata/Javadoc.cpp
@@ -19,7 +19,7 @@
 #include <llvm/Support/Path.h>
 #include <format>
 
-namespace clang {
+
 namespace mrdocs {
 namespace doc {
 
@@ -384,4 +384,4 @@ append(std::vector<Polymorphic<doc::Node>>&& blocks)
 }
 
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Metadata/Name.cpp b/src/lib/Metadata/Name.cpp
index 6e7b2d521..4f9d0656f 100644
--- a/src/lib/Metadata/Name.cpp
+++ b/src/lib/Metadata/Name.cpp
@@ -15,7 +15,7 @@
 #include <mrdocs/Metadata/Name.hpp>
 #include <span>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 dom::String toString(NameKind kind) noexcept
 {
@@ -40,8 +40,8 @@ writeTo(
 }
 
 std::strong_ordering
-NameInfo::
-operator<=>(NameInfo const& other) const
+Name::
+operator<=>(Name const& other) const
 {
     if (this == &other)
     {
@@ -51,9 +51,9 @@ operator<=>(NameInfo const& other) const
     {
         return Kind <=> other.Kind;
     }
-    if (Name != other.Name)
+    if (Identifier != other.Identifier)
     {
-        return Name <=> other.Name;
+        return Identifier <=> other.Identifier;
     }
     if (bool(Prefix) != bool(other.Prefix))
     {
@@ -67,7 +67,7 @@ operator<=>(NameInfo const& other) const
 }
 
 std::strong_ordering
-operator<=>(Polymorphic<NameInfo> const& lhs, Polymorphic<NameInfo> const& rhs)
+operator<=>(Polymorphic<Name> const& lhs, Polymorphic<Name> const& rhs)
 {
     MRDOCS_ASSERT(!lhs.valueless_after_move());
     MRDOCS_ASSERT(!rhs.valueless_after_move());
@@ -77,7 +77,7 @@ operator<=>(Polymorphic<NameInfo> const& lhs, Polymorphic<NameInfo> const& rhs)
         {
             return *lhs <=> *rhs;
         }
-        return visit(*lhs, detail::VisitCompareFn<NameInfo>(*rhs));
+        return visit(*lhs, detail::VisitCompareFn<Name>(*rhs));
     }
     return lhs->Kind <=> rhs->Kind;
 }
@@ -86,7 +86,7 @@ static
 void
 toStringImpl(
     std::string& result,
-    NameInfo const& N)
+    Name const& N)
 {
     if (N.Prefix)
     {
@@ -94,7 +94,7 @@ toStringImpl(
         writeTo(result, "::");
     }
 
-    writeTo(result, N.Name);
+    writeTo(result, N.Identifier);
 
     if (!N.isSpecialization())
     {
@@ -135,7 +135,7 @@ toStringImpl(
 }
 
 std::string
-toString(NameInfo const& N)
+toString(Name const& N)
 {
     std::string result;
     toStringImpl(result, N);
@@ -147,14 +147,14 @@ void
 tag_invoke(
     dom::LazyObjectMapTag,
     IO& io,
-    NameInfo const& I,
+    Name const& I,
     DomCorpus const* domCorpus)
 {
     io.map("class", std::string("name"));
     io.map("kind", I.Kind);
     visit(I, [domCorpus, &io]<typename T>(T const& t)
     {
-        io.map("name", t.Name);
+        io.map("name", t.Identifier);
         io.map("symbol", t.id);
         if constexpr(requires { t.TemplateArgs; })
         {
@@ -168,10 +168,10 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    NameInfo const& I,
+    Name const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Metadata/Reduce.hpp b/src/lib/Metadata/Reduce.hpp
index ec011697c..d26a666f3 100644
--- a/src/lib/Metadata/Reduce.hpp
+++ b/src/lib/Metadata/Reduce.hpp
@@ -16,7 +16,7 @@
 #include <memory>
 #include <vector>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 //
 // This file defines the merging of different types of infos. The data in the
@@ -33,11 +33,11 @@ namespace clang::mrdocs {
 //
 
 template<typename T>
-std::unique_ptr<Info>
-reduce(std::vector<std::unique_ptr<Info>>& Values)
+std::unique_ptr<Symbol>
+reduce(std::vector<std::unique_ptr<Symbol>>& Values)
 {
     MRDOCS_ASSERT(! Values.empty() && Values[0]);
-    std::unique_ptr<Info> Merged = std::make_unique<T>(Values[0]->id);
+    std::unique_ptr<Symbol> Merged = std::make_unique<T>(Values[0]->id);
     T* Tmp = static_cast<T*>(Merged.get());
     for (auto& I: Values)
     {
@@ -79,7 +79,7 @@ reduceChildren(
     }
 }
 
-} // clang::mrdocs
+} // mrdocs
 
 
 #endif
\ No newline at end of file
diff --git a/src/lib/Metadata/Source.cpp b/src/lib/Metadata/Source.cpp
index 1dcaf2af8..817a5dd66 100644
--- a/src/lib/Metadata/Source.cpp
+++ b/src/lib/Metadata/Source.cpp
@@ -11,13 +11,13 @@
 
 #include <mrdocs/Dom/LazyArray.hpp>
 #include <mrdocs/Dom/LazyObject.hpp>
-#include <mrdocs/Metadata/Info/FileKind.hpp>
-#include <mrdocs/Metadata/Info/Location.hpp>
-#include <mrdocs/Metadata/Info/Source.hpp>
+#include <mrdocs/Metadata/Symbol/FileKind.hpp>
+#include <mrdocs/Metadata/Symbol/Location.hpp>
+#include <mrdocs/Metadata/Symbol/Source.hpp>
 #include <llvm/ADT/STLExtras.h>
 #include <ranges>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 std::string_view
 toString(FileKind kind)
@@ -150,4 +150,4 @@ tag_invoke(
     v = dom::LazyObject(I);
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Metadata/Specifiers.cpp b/src/lib/Metadata/Specifiers.cpp
index dce87235e..9f8b45848 100644
--- a/src/lib/Metadata/Specifiers.cpp
+++ b/src/lib/Metadata/Specifiers.cpp
@@ -12,7 +12,7 @@
 #include <mrdocs/Support/Algorithm.hpp>
 #include <format>
 
-namespace clang {
+
 namespace mrdocs {
 
 dom::String toString(AccessKind kind) noexcept
@@ -201,5 +201,5 @@ isBinaryOperator(OperatorKind kind) noexcept
 }
 
 
-} // clang
+
 } // mrdocs
diff --git a/src/lib/Metadata/SymbolID.cpp b/src/lib/Metadata/SymbolID.cpp
index 442978797..5eb5a3349 100644
--- a/src/lib/Metadata/SymbolID.cpp
+++ b/src/lib/Metadata/SymbolID.cpp
@@ -12,12 +12,12 @@
 #include <lib/Support/Radix.hpp>
 #include <mrdocs/Dom.hpp>
 #include <mrdocs/Metadata/DomCorpus.hpp>
-#include <mrdocs/Metadata/Info/SymbolID.hpp>
+#include <mrdocs/Metadata/Symbol/SymbolID.hpp>
 #include <llvm/Support/SHA1.h>
 #include <climits>
 #include <ranges>
 
-namespace clang {
+
 namespace mrdocs {
 
 // Better have 8 bits per byte, otherwise
@@ -156,4 +156,4 @@ tag_invoke(
 
 
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Metadata/InfoSet.cpp b/src/lib/Metadata/SymbolSet.cpp
similarity index 61%
rename from src/lib/Metadata/InfoSet.cpp
rename to src/lib/Metadata/SymbolSet.cpp
index 23b1a2f35..05acc9110 100644
--- a/src/lib/Metadata/InfoSet.cpp
+++ b/src/lib/Metadata/SymbolSet.cpp
@@ -1,12 +1,12 @@
 
-#include "InfoSet.hpp"
+#include "SymbolSet.hpp"
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 std::size_t
-InfoPtrHasher::
+SymbolPtrHasher::
 operator()(
-    const std::unique_ptr<Info>& I) const
+    const std::unique_ptr<Symbol>& I) const
 {
     // The info set should never contain nullptrs
     MRDOCS_ASSERT(I);
@@ -14,7 +14,7 @@ operator()(
 }
 
 std::size_t
-InfoPtrHasher::
+SymbolPtrHasher::
 operator()(
     SymbolID const& id) const
 {
@@ -22,10 +22,10 @@ operator()(
 }
 
 bool
-InfoPtrEqual::
+SymbolPtrEqual::
 operator()(
-    const std::unique_ptr<Info>& a,
-    const std::unique_ptr<Info>& b) const
+    const std::unique_ptr<Symbol>& a,
+    const std::unique_ptr<Symbol>& b) const
 {
     MRDOCS_ASSERT(a && b);
     if(a == b)
@@ -36,9 +36,9 @@ operator()(
 }
 
 bool
-InfoPtrEqual::
+SymbolPtrEqual::
 operator()(
-    const std::unique_ptr<Info>& a,
+    const std::unique_ptr<Symbol>& a,
     SymbolID const& b) const
 {
     MRDOCS_ASSERT(a);
@@ -46,13 +46,13 @@ operator()(
 }
 
 bool
-InfoPtrEqual::
+SymbolPtrEqual::
 operator()(
     SymbolID const& a,
-    const std::unique_ptr<Info>& b) const
+    const std::unique_ptr<Symbol>& b) const
 {
     MRDOCS_ASSERT(b);
     return b->id == a;
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Metadata/InfoSet.hpp b/src/lib/Metadata/SymbolSet.hpp
similarity index 51%
rename from src/lib/Metadata/InfoSet.hpp
rename to src/lib/Metadata/SymbolSet.hpp
index 9094a06fc..3e0b7e4fb 100644
--- a/src/lib/Metadata/InfoSet.hpp
+++ b/src/lib/Metadata/SymbolSet.hpp
@@ -10,36 +10,36 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_METADATA_INFOSET_HPP
-#define MRDOCS_LIB_METADATA_INFOSET_HPP
+#ifndef MRDOCS_LIB_METADATA_SYMBOLSET_HPP
+#define MRDOCS_LIB_METADATA_SYMBOLSET_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Info.hpp>
+#include <mrdocs/Metadata/Symbol.hpp>
 #include <memory>
 #include <unordered_set>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
-/** A hash function for Info pointers.
+/** A hash function for Symbol pointers.
 
     The generated hash is based on the SymbolID
-    of the Info object.
+    of the Symbol object.
 
-    This hasher is used to implement the InfoSet.
+    This hasher is used to implement the SymbolSet.
 */
-struct InfoPtrHasher
+struct SymbolPtrHasher
 {
     using is_transparent = void;
 
-    /** Returns the hash of the Info object.
+    /** Returns the hash of the Symbol object.
 
-        The hash is based on the SymbolID of the Info object.
+        The hash is based on the SymbolID of the Symbol object.
 
-        @param I The Info object to hash.
+        @param I The Symbol object to hash.
     */
     std::size_t
     operator()(
-        const std::unique_ptr<Info>& I) const;
+        const std::unique_ptr<Symbol>& I) const;
 
     /** Returns the hash of the SymbolID.
 
@@ -53,80 +53,80 @@ struct InfoPtrHasher
         SymbolID const& id) const;
 };
 
-/** Equality comparison for Info pointers.
+/** Equality comparison for Symbol pointers.
 
-    The comparison is based on the SymbolID of the Info object.
+    The comparison is based on the SymbolID of the Symbol object.
 
-    This equality comparison is used to implement the InfoSet.
+    This equality comparison is used to implement the SymbolSet.
 */
-struct InfoPtrEqual
+struct SymbolPtrEqual
 {
     using is_transparent = void;
 
-    /** Returns `true` if the Info objects are equal.
+    /** Returns `true` if the Symbol objects are equal.
 
-        The comparison is based on the SymbolID of the Info object.
+        The comparison is based on the SymbolID of the Symbol object.
 
-        @param a The first Info object to compare.
-        @param b The second Info object to compare.
+        @param a The first Symbol object to compare.
+        @param b The second Symbol object to compare.
     */
     bool
     operator()(
-        const std::unique_ptr<Info>& a,
-        const std::unique_ptr<Info>& b) const;
+        const std::unique_ptr<Symbol>& a,
+        const std::unique_ptr<Symbol>& b) const;
 
-    /** Returns `true` if the id of the Info object is equal to the SymbolID.
+    /** Returns `true` if the id of the Symbol object is equal to the SymbolID.
 
-        The comparison is based on the SymbolID of the Info object.
+        The comparison is based on the SymbolID of the Symbol object.
 
         The function allows the SymbolID to be used as a key
         in an unordered container.
 
-        @param a The Info object to compare.
+        @param a The Symbol object to compare.
         @param b The SymbolID to compare.
     */
     bool
     operator()(
-        const std::unique_ptr<Info>& a,
+        const std::unique_ptr<Symbol>& a,
         SymbolID const& b) const;
 
-    /** Returns `true` if the SymbolID is equal to the id of the Info object.
+    /** Returns `true` if the SymbolID is equal to the id of the Symbol object.
 
-        The comparison is based on the SymbolID of the Info object.
+        The comparison is based on the SymbolID of the Symbol object.
 
         The function allows the SymbolID to be used as a key
         in an unordered container.
 
         @param a The SymbolID to compare.
-        @param b The Info object to compare.
+        @param b The Symbol object to compare.
     */
     bool
     operator()(
         SymbolID const& a,
-        const std::unique_ptr<Info>& b) const;
+        const std::unique_ptr<Symbol>& b) const;
 };
 
-/** A set of Info objects.
+/** A set of Symbol objects.
 
     This set is used to store the results of the execution
     of a tool at the end of the processing.
 
-    This is a set of unique pointers to Info objects.
+    This is a set of unique pointers to Symbol objects.
 */
-using InfoSet = std::unordered_set<
-    std::unique_ptr<Info>, InfoPtrHasher, InfoPtrEqual>;
+using SymbolSet = std::unordered_set<
+    std::unique_ptr<Symbol>, SymbolPtrHasher, SymbolPtrEqual>;
 
-struct UndocumentedInfo final {
+struct UndocumentedSymbol final {
     SymbolID id;
     std::string name;
-    InfoKind kind;
+    SymbolKind kind;
     SourceInfo Loc;
 
     constexpr
-    UndocumentedInfo(
+    UndocumentedSymbol(
         SymbolID id_,
         std::string name_,
-        InfoKind kind_) noexcept
+        SymbolKind kind_) noexcept
         : id(id_)
         , name(std::move(name_))
         , kind(kind_)
@@ -134,7 +134,7 @@ struct UndocumentedInfo final {
     }
 };
 
-struct UndocumentedInfoHasher {
+struct UndocumentedSymbolHasher {
     using is_transparent = void;
 
     std::size_t
@@ -143,25 +143,25 @@ struct UndocumentedInfoHasher {
     }
 
     std::size_t
-    operator()(UndocumentedInfo const& I) const {
+    operator()(UndocumentedSymbol const& I) const {
         return std::hash<SymbolID>()(I.id);
     }
 };
 
-struct UndocumentedInfoEqual {
+struct UndocumentedSymbolEqual {
     using is_transparent = void;
 
     bool
     operator()(
-        UndocumentedInfo const& a,
-        UndocumentedInfo const& b) const
+        UndocumentedSymbol const& a,
+        UndocumentedSymbol const& b) const
     {
         return a.id == b.id;
     }
 
     bool
     operator()(
-        UndocumentedInfo const& a,
+        UndocumentedSymbol const& a,
         SymbolID const& b) const
     {
         return a.id == b;
@@ -170,15 +170,15 @@ struct UndocumentedInfoEqual {
     bool
     operator()(
         SymbolID const& a,
-        UndocumentedInfo const& b) const
+        UndocumentedSymbol const& b) const
     {
         return a == b.id;
     }
 };
 
-using UndocumentedInfoSet = std::unordered_set<
-    UndocumentedInfo, UndocumentedInfoHasher, UndocumentedInfoEqual>;
+using UndocumentedSymbolSet = std::unordered_set<
+    UndocumentedSymbol, UndocumentedSymbolHasher, UndocumentedSymbolEqual>;
 
-} // clang::mrdocs
+} // mrdocs
 
-#endif // MRDOCS_LIB_METADATA_INFOSET_HPP
+#endif // MRDOCS_LIB_METADATA_SYMBOLSET_HPP
diff --git a/src/lib/Metadata/Template.cpp b/src/lib/Metadata/Template.cpp
index b60e1b449..b989632e7 100644
--- a/src/lib/Metadata/Template.cpp
+++ b/src/lib/Metadata/Template.cpp
@@ -16,7 +16,7 @@
 #include <mrdocs/Metadata/Name.hpp>
 #include <mrdocs/Metadata/Template.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 std::string_view
 toString(TArgKind kind) noexcept
@@ -356,4 +356,4 @@ tag_invoke(
     v = dom::LazyObject(I, domCorpus);
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Metadata/Type.cpp b/src/lib/Metadata/Type.cpp
index 136054188..6e8e48f0b 100644
--- a/src/lib/Metadata/Type.cpp
+++ b/src/lib/Metadata/Type.cpp
@@ -14,7 +14,7 @@
 #include <mrdocs/Metadata/Type.hpp>
 #include <mrdocs/Metadata/Type/QualifierKind.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 dom::String
 toString(
@@ -80,7 +80,7 @@ toString(
 }
 
 SymbolID
-TypeInfo::
+Type::
 namedSymbol() const noexcept
 {
     if (!isNamed())
@@ -146,7 +146,7 @@ operator()(
     auto& write,
     std::bool_constant<NeedParens>) const
 {
-    if (TypeInfo const* inner = innerTypePtr(t))
+    if (Type const* inner = innerTypePtr(t))
     {
         visit(*inner, *this, write, std::bool_constant<requires {
             t.PointeeType;
@@ -296,7 +296,7 @@ operator()(
         }
     }
 
-    if (TypeInfo const* inner = innerTypePtr(t))
+    if (Type const* inner = innerTypePtr(t))
     {
         visit(*inner, *this, write, std::bool_constant<requires {
             t.PointeeType;
@@ -315,8 +315,8 @@ writeTypeTo(
 } // (anon)
 
 std::strong_ordering
-NamedTypeInfo::
-operator<=>(NamedTypeInfo const& other) const
+NamedType::
+operator<=>(NamedType const& other) const
 {
     if (auto const br = this->asType() <=> other.asType();
         !std::is_eq(br))
@@ -338,32 +338,32 @@ operator<=>(NamedTypeInfo const& other) const
 }
 
 std::strong_ordering
-AutoTypeInfo::
-operator<=>(AutoTypeInfo const&) const = default;
+AutoType::
+operator<=>(AutoType const&) const = default;
 
 std::strong_ordering
-LValueReferenceTypeInfo::
-operator<=>(LValueReferenceTypeInfo const&) const = default;
+LValueReferenceType::
+operator<=>(LValueReferenceType const&) const = default;
 
 std::strong_ordering
-RValueReferenceTypeInfo::
-operator<=>(RValueReferenceTypeInfo const&) const = default;
+RValueReferenceType::
+operator<=>(RValueReferenceType const&) const = default;
 
 std::strong_ordering
-PointerTypeInfo::
-operator<=>(PointerTypeInfo const&) const = default;
+PointerType::
+operator<=>(PointerType const&) const = default;
 
 std::strong_ordering
-MemberPointerTypeInfo::
-operator<=>(MemberPointerTypeInfo const&) const = default;
+MemberPointerType::
+operator<=>(MemberPointerType const&) const = default;
 
 std::strong_ordering
-ArrayTypeInfo::
-operator<=>(ArrayTypeInfo const&) const = default;
+ArrayType::
+operator<=>(ArrayType const&) const = default;
 
 std::strong_ordering
-FunctionTypeInfo::
-operator<=>(FunctionTypeInfo const& other) const {
+FunctionType::
+operator<=>(FunctionType const& other) const {
     if (auto const r = this->asType() <=> other.asType();
         !std::is_eq(r))
     {
@@ -393,8 +393,7 @@ operator<=>(FunctionTypeInfo const& other) const {
 
 
 std::string
-toString(
-    TypeInfo const& T,
+toString(Type const& T,
     std::string_view Name)
 {
     auto write = [result = std::string()](
@@ -417,7 +416,7 @@ void
 tag_invoke(
     dom::LazyObjectMapTag,
     IO& io,
-    TypeInfo const& I,
+    Type const& I,
     DomCorpus const* domCorpus)
 {
     io.map("class", std::string("type"));
@@ -475,7 +474,7 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    TypeInfo const& I,
+    Type const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
@@ -752,7 +751,7 @@ makeChar(FundamentalTypeKind& kind) noexcept
 }
 
 std::strong_ordering
-operator<=>(Polymorphic<TypeInfo> const& lhs, Polymorphic<TypeInfo> const& rhs)
+operator<=>(Polymorphic<Type> const& lhs, Polymorphic<Type> const& rhs)
 {
     MRDOCS_ASSERT(!lhs.valueless_after_move());
     MRDOCS_ASSERT(!rhs.valueless_after_move());
@@ -760,7 +759,7 @@ operator<=>(Polymorphic<TypeInfo> const& lhs, Polymorphic<TypeInfo> const& rhs)
     auto& rhsRef = *rhs;
     if (lhsRef.Kind == rhsRef.Kind)
     {
-        return visit(lhsRef, detail::VisitCompareFn<TypeInfo>(rhsRef));
+        return visit(lhsRef, detail::VisitCompareFn<Type>(rhsRef));
     }
     return lhsRef.Kind <=> rhsRef.Kind;
 }
@@ -768,13 +767,13 @@ operator<=>(Polymorphic<TypeInfo> const& lhs, Polymorphic<TypeInfo> const& rhs)
 namespace {
 // Get an optional reference to the inner type
 template <
-    class TypeInfoTy,
-    bool isMutable = !std::is_const_v<std::remove_reference_t<TypeInfoTy>>,
-    class Ptr = std::conditional_t<isMutable, Polymorphic<TypeInfo>*, Polymorphic<TypeInfo> const*>,
-    class Ref = std::conditional_t<isMutable, Polymorphic<TypeInfo>&, Polymorphic<TypeInfo> const&>>
-requires std::same_as<std::remove_cvref_t<TypeInfoTy>, TypeInfo>
+    class TypeTy,
+    bool isMutable = !std::is_const_v<std::remove_reference_t<TypeTy>>,
+    class Ptr = std::conditional_t<isMutable, Polymorphic<Type>*, Polymorphic<Type> const*>,
+    class Ref = std::conditional_t<isMutable, Polymorphic<Type>&, Polymorphic<Type> const&>>
+requires std::same_as<std::remove_cvref_t<TypeTy>, Type>
 Optional<Ref>
-innerTypeImpl(TypeInfoTy&& TI) noexcept
+innerTypeImpl(TypeTy&& TI) noexcept
 {
     // Get a pointer to the inner type
     Ptr innerPtr = visit(TI, []<typename T>(T& t) -> Ptr
@@ -813,14 +812,14 @@ innerTypeImpl(TypeInfoTy&& TI) noexcept
 
 // Get a pointer to the inner type
 template <
-    class TypeInfoTy,
-    bool isMutable = !std::is_const_v<std::remove_reference_t<TypeInfoTy>>,
-    class Ptr = std::conditional_t<isMutable, Polymorphic<TypeInfo>*, Polymorphic<TypeInfo> const*>,
-    class Ref = std::conditional_t<isMutable, Polymorphic<TypeInfo>&, Polymorphic<TypeInfo> const&>,
-    class InnerPtr = std::conditional_t<isMutable, TypeInfo*, TypeInfo const*>>
-requires std::same_as<std::remove_cvref_t<TypeInfoTy>, TypeInfo>
+    class TypeTy,
+    bool isMutable = !std::is_const_v<std::remove_reference_t<TypeTy>>,
+    class Ptr = std::conditional_t<isMutable, Polymorphic<Type>*, Polymorphic<Type> const*>,
+    class Ref = std::conditional_t<isMutable, Polymorphic<Type>&, Polymorphic<Type> const&>,
+    class InnerPtr = std::conditional_t<isMutable, Type*, Type const*>>
+requires std::same_as<std::remove_cvref_t<TypeTy>, Type>
 InnerPtr
-innerTypePtrImpl(TypeInfoTy&& TI) noexcept
+innerTypePtrImpl(TypeTy&& TI) noexcept
 {
     Optional<Ref> res = innerTypeImpl(TI);
     if (res)
@@ -835,12 +834,12 @@ innerTypePtrImpl(TypeInfoTy&& TI) noexcept
 // If there's an internal type, return it
 // If there's no internal type, return the current type
 template <
-    class PolymorphicTypeInfoTy,
-    bool isMutable = !std::is_const_v<std::remove_reference_t<PolymorphicTypeInfoTy>>,
-    class Ref = std::conditional_t<isMutable, Polymorphic<TypeInfo>&, Polymorphic<TypeInfo> const&>>
-requires std::same_as<std::remove_cvref_t<PolymorphicTypeInfoTy>, Polymorphic<TypeInfo>>
+    class PolymorphicTypeTy,
+    bool isMutable = !std::is_const_v<std::remove_reference_t<PolymorphicTypeTy>>,
+    class Ref = std::conditional_t<isMutable, Polymorphic<Type>&, Polymorphic<Type> const&>>
+requires std::same_as<std::remove_cvref_t<PolymorphicTypeTy>, Polymorphic<Type>>
 Ref
-innermostTypeImpl(PolymorphicTypeInfoTy&& TI) noexcept
+innermostTypeImpl(PolymorphicTypeTy&& TI) noexcept
 {
     MRDOCS_ASSERT(!TI.valueless_after_move());
     Optional<Ref> inner = innerTypeImpl(*TI);
@@ -864,40 +863,40 @@ innermostTypeImpl(PolymorphicTypeInfoTy&& TI) noexcept
 
 }
 
-Optional<Polymorphic<TypeInfo> const&>
-innerType(TypeInfo const& TI) noexcept
+Optional<Polymorphic<Type> const&>
+innerType(Type const& TI) noexcept
 {
-    return innerTypeImpl<TypeInfo const&>(TI);
+    return innerTypeImpl<Type const&>(TI);
 }
 
-Optional<Polymorphic<TypeInfo>&>
-innerType(TypeInfo& TI) noexcept
+Optional<Polymorphic<Type>&>
+innerType(Type& TI) noexcept
 {
-    return innerTypeImpl<TypeInfo&>(TI);
+    return innerTypeImpl<Type&>(TI);
 }
 
-TypeInfo const*
-innerTypePtr(TypeInfo const& TI) noexcept
+Type const*
+innerTypePtr(Type const& TI) noexcept
 {
-    return innerTypePtrImpl<TypeInfo const&>(TI);
+    return innerTypePtrImpl<Type const&>(TI);
 }
 
-TypeInfo*
-innerTypePtr(TypeInfo& TI) noexcept
+Type*
+innerTypePtr(Type& TI) noexcept
 {
-    return innerTypePtrImpl<TypeInfo&>(TI);
+    return innerTypePtrImpl<Type&>(TI);
 }
 
-Polymorphic<TypeInfo> const&
-innermostType(Polymorphic<TypeInfo> const& TI) noexcept
+Polymorphic<Type> const&
+innermostType(Polymorphic<Type> const& TI) noexcept
 {
-    return innermostTypeImpl<Polymorphic<TypeInfo> const&>(TI);
+    return innermostTypeImpl<Polymorphic<Type> const&>(TI);
 }
 
-Polymorphic<TypeInfo>&
-innermostType(Polymorphic<TypeInfo>& TI) noexcept
+Polymorphic<Type>&
+innermostType(Polymorphic<Type>& TI) noexcept
 {
-    return innermostTypeImpl<Polymorphic<TypeInfo>&>(TI);
+    return innermostTypeImpl<Polymorphic<Type>&>(TI);
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/MrDocsCompilationDatabase.cpp b/src/lib/MrDocsCompilationDatabase.cpp
index ef5e0f315..7e6972746 100644
--- a/src/lib/MrDocsCompilationDatabase.cpp
+++ b/src/lib/MrDocsCompilationDatabase.cpp
@@ -27,7 +27,7 @@
 #include <format>
 #include <ranges>
 
-namespace clang {
+
 namespace mrdocs {
 
 static
@@ -35,9 +35,9 @@ bool
 isCXXSrcFile(
     std::string_view filename)
 {
-    StringRef ext = llvm::sys::path::extension(filename).drop_front();
-    driver::types::ID extensionId = driver::types::lookupTypeForExtension(ext);
-    return driver::types::isCXX(extensionId);
+    llvm::StringRef ext = llvm::sys::path::extension(filename).drop_front();
+    clang::driver::types::ID extensionId = clang::driver::types::lookupTypeForExtension(ext);
+    return clang::driver::types::isCXX(extensionId);
 }
 
 static
@@ -45,7 +45,7 @@ bool
 isCXXHeaderFile(
     std::string_view filename)
 {
-    StringRef ext = llvm::sys::path::extension(filename).drop_front();
+    llvm::StringRef ext = llvm::sys::path::extension(filename).drop_front();
     return ext == "hpp" || ext == "hh" || ext == "hxx" || ext == "h++";
 }
 
@@ -54,7 +54,7 @@ bool
 isCSrcFile(
     std::string_view filename)
 {
-    StringRef ext = llvm::sys::path::extension(filename).drop_front();
+    llvm::StringRef ext = llvm::sys::path::extension(filename).drop_front();
     return ext == "c";
 }
 
@@ -63,7 +63,7 @@ bool
 isCHeaderFile(
     std::string_view filename)
 {
-    StringRef ext = llvm::sys::path::extension(filename).drop_front();
+    llvm::StringRef ext = llvm::sys::path::extension(filename).drop_front();
     return ext == "h";
 }
 
@@ -95,153 +95,153 @@ isValidMrDocsOption(
 
     if (optionMatchesAny(opt,
              // unknown options
-             driver::options::OPT_UNKNOWN,
+             clang::driver::options::OPT_UNKNOWN,
 
              // sanitizers
-             driver::options::OPT_fsanitize_EQ,
-             driver::options::OPT_fno_sanitize_EQ,
-             driver::options::OPT_fsanitize_recover_EQ,
-             driver::options::OPT_fno_sanitize_recover_EQ,
-             driver::options::OPT_fsanitize_trap_EQ,
-             driver::options::OPT_fno_sanitize_trap_EQ,
-             driver::options::OPT_fsanitize_address_use_after_scope,
-             driver::options::OPT_fexperimental_sanitize_metadata_ignorelist_EQ,
-             driver::options::OPT_fexperimental_sanitize_metadata_EQ_atomics,
-             driver::options::OPT_fexperimental_sanitize_metadata_EQ_covered,
-             driver::options::OPT_fexperimental_sanitize_metadata_EQ,
-             driver::options::OPT_fgpu_sanitize,
-             driver::options::OPT_fno_experimental_sanitize_metadata_EQ,
-             driver::options::OPT_fno_gpu_sanitize,
-             driver::options::OPT_fno_sanitize_address_globals_dead_stripping,
-             driver::options::OPT_fno_sanitize_address_outline_instrumentation,
-             driver::options::OPT_fno_sanitize_address_poison_custom_array_cookie,
-             driver::options::OPT_fno_sanitize_address_use_after_scope,
-             driver::options::OPT_fno_sanitize_address_use_odr_indicator,
-             driver::options::OPT__SLASH_fno_sanitize_address_vcasan_lib,
-             driver::options::OPT_fno_sanitize_cfi_canonical_jump_tables,
-             driver::options::OPT_fno_sanitize_cfi_cross_dso,
-             driver::options::OPT_fno_sanitize_coverage,
-             driver::options::OPT_fno_sanitize_hwaddress_experimental_aliasing,
-             driver::options::OPT_fno_sanitize_ignorelist,
-             driver::options::OPT_fno_sanitize_link_cxx_runtime,
-             driver::options::OPT_fno_sanitize_link_runtime,
-             driver::options::OPT_fno_sanitize_memory_param_retval,
-             driver::options::OPT_fno_sanitize_memory_track_origins,
-             driver::options::OPT_fno_sanitize_memory_use_after_dtor,
-             driver::options::OPT_fno_sanitize_minimal_runtime,
-             driver::options::OPT_fno_sanitize_recover_EQ,
-             driver::options::OPT_fno_sanitize_recover,
-             driver::options::OPT_fno_sanitize_stable_abi,
-             driver::options::OPT_fno_sanitize_stats,
-             driver::options::OPT_fno_sanitize_thread_atomics,
-             driver::options::OPT_fno_sanitize_thread_func_entry_exit,
-             driver::options::OPT_fno_sanitize_thread_memory_access,
-             driver::options::OPT_fno_sanitize_trap_EQ,
-             driver::options::OPT_fno_sanitize_trap,
-             driver::options::OPT_fno_sanitize_undefined_trap_on_error,
-             driver::options::OPT_fno_sanitize_EQ,
-             driver::options::OPT_sanitize_address_destructor_EQ,
-             driver::options::OPT_fsanitize_address_field_padding,
-             driver::options::OPT_fsanitize_address_globals_dead_stripping,
-             driver::options::OPT_fsanitize_address_outline_instrumentation,
-             driver::options::OPT_fsanitize_address_poison_custom_array_cookie,
-             driver::options::OPT_sanitize_address_use_after_return_EQ,
-             driver::options::OPT__SLASH_fsanitize_address_use_after_return,
-             driver::options::OPT_fsanitize_address_use_after_scope,
-             driver::options::OPT_fsanitize_address_use_odr_indicator,
-             driver::options::OPT_fsanitize_cfi_canonical_jump_tables,
-             driver::options::OPT_fsanitize_cfi_cross_dso,
-             driver::options::OPT_fsanitize_cfi_icall_normalize_integers,
-             driver::options::OPT_fsanitize_cfi_icall_generalize_pointers,
-             driver::options::OPT_fsanitize_coverage_8bit_counters,
-             driver::options::OPT_fsanitize_coverage_allowlist,
-             driver::options::OPT_fsanitize_coverage_control_flow,
-             driver::options::OPT_fsanitize_coverage_ignorelist,
-             driver::options::OPT_fsanitize_coverage_indirect_calls,
-             driver::options::OPT_fsanitize_coverage_inline_8bit_counters,
-             driver::options::OPT_fsanitize_coverage_inline_bool_flag,
-             driver::options::OPT_fsanitize_coverage_no_prune,
-             driver::options::OPT_fsanitize_coverage_pc_table,
-             driver::options::OPT_fsanitize_coverage_stack_depth,
-             driver::options::OPT_fsanitize_coverage_trace_bb,
-             driver::options::OPT_fsanitize_coverage_trace_cmp,
-             driver::options::OPT_fsanitize_coverage_trace_div,
-             driver::options::OPT_fsanitize_coverage_trace_gep,
-             driver::options::OPT_fsanitize_coverage_trace_loads,
-             driver::options::OPT_fsanitize_coverage_trace_pc_guard,
-             driver::options::OPT_fsanitize_coverage_trace_pc,
-             driver::options::OPT_fsanitize_coverage_trace_stores,
-             driver::options::OPT_fsanitize_coverage_type,
-             driver::options::OPT_fsanitize_coverage,
-             driver::options::OPT_fsanitize_hwaddress_abi_EQ,
-             driver::options::OPT_fsanitize_hwaddress_experimental_aliasing,
-             driver::options::OPT_fsanitize_ignorelist_EQ,
-             driver::options::OPT_fsanitize_link_cxx_runtime,
-             driver::options::OPT_fsanitize_link_runtime,
-             driver::options::OPT_fsanitize_memory_param_retval,
-             driver::options::OPT_fsanitize_memory_track_origins_EQ,
-             driver::options::OPT_fsanitize_memory_track_origins,
-             driver::options::OPT_fsanitize_memory_use_after_dtor,
-             driver::options::OPT_fsanitize_memtag_mode_EQ,
-             driver::options::OPT_fsanitize_minimal_runtime,
-             driver::options::OPT_fsanitize_recover_EQ,
-             driver::options::OPT_fsanitize_recover,
-             driver::options::OPT_fsanitize_stable_abi,
-             driver::options::OPT_fsanitize_stats,
-             driver::options::OPT_fsanitize_system_ignorelist_EQ,
-             driver::options::OPT_fsanitize_thread_atomics,
-             driver::options::OPT_fsanitize_thread_func_entry_exit,
-             driver::options::OPT_fsanitize_thread_memory_access,
-             driver::options::OPT_fsanitize_trap_EQ,
-             driver::options::OPT_fsanitize_trap,
-             driver::options::OPT_fsanitize_undefined_strip_path_components_EQ,
-             driver::options::OPT_fsanitize_undefined_trap_on_error,
-             driver::options::OPT__SLASH_fsanitize_EQ_address,
-             driver::options::OPT_fsanitize_EQ,
-             driver::options::OPT_shared_libsan,
-             driver::options::OPT_static_libsan,
-             driver::options::OPT_static_libsan,
+             clang::driver::options::OPT_fsanitize_EQ,
+             clang::driver::options::OPT_fno_sanitize_EQ,
+             clang::driver::options::OPT_fsanitize_recover_EQ,
+             clang::driver::options::OPT_fno_sanitize_recover_EQ,
+             clang::driver::options::OPT_fsanitize_trap_EQ,
+             clang::driver::options::OPT_fno_sanitize_trap_EQ,
+             clang::driver::options::OPT_fsanitize_address_use_after_scope,
+             clang::driver::options::OPT_fexperimental_sanitize_metadata_ignorelist_EQ,
+             clang::driver::options::OPT_fexperimental_sanitize_metadata_EQ_atomics,
+             clang::driver::options::OPT_fexperimental_sanitize_metadata_EQ_covered,
+             clang::driver::options::OPT_fexperimental_sanitize_metadata_EQ,
+             clang::driver::options::OPT_fgpu_sanitize,
+             clang::driver::options::OPT_fno_experimental_sanitize_metadata_EQ,
+             clang::driver::options::OPT_fno_gpu_sanitize,
+             clang::driver::options::OPT_fno_sanitize_address_globals_dead_stripping,
+             clang::driver::options::OPT_fno_sanitize_address_outline_instrumentation,
+             clang::driver::options::OPT_fno_sanitize_address_poison_custom_array_cookie,
+             clang::driver::options::OPT_fno_sanitize_address_use_after_scope,
+             clang::driver::options::OPT_fno_sanitize_address_use_odr_indicator,
+             clang::driver::options::OPT__SLASH_fno_sanitize_address_vcasan_lib,
+             clang::driver::options::OPT_fno_sanitize_cfi_canonical_jump_tables,
+             clang::driver::options::OPT_fno_sanitize_cfi_cross_dso,
+             clang::driver::options::OPT_fno_sanitize_coverage,
+             clang::driver::options::OPT_fno_sanitize_hwaddress_experimental_aliasing,
+             clang::driver::options::OPT_fno_sanitize_ignorelist,
+             clang::driver::options::OPT_fno_sanitize_link_cxx_runtime,
+             clang::driver::options::OPT_fno_sanitize_link_runtime,
+             clang::driver::options::OPT_fno_sanitize_memory_param_retval,
+             clang::driver::options::OPT_fno_sanitize_memory_track_origins,
+             clang::driver::options::OPT_fno_sanitize_memory_use_after_dtor,
+             clang::driver::options::OPT_fno_sanitize_minimal_runtime,
+             clang::driver::options::OPT_fno_sanitize_recover_EQ,
+             clang::driver::options::OPT_fno_sanitize_recover,
+             clang::driver::options::OPT_fno_sanitize_stable_abi,
+             clang::driver::options::OPT_fno_sanitize_stats,
+             clang::driver::options::OPT_fno_sanitize_thread_atomics,
+             clang::driver::options::OPT_fno_sanitize_thread_func_entry_exit,
+             clang::driver::options::OPT_fno_sanitize_thread_memory_access,
+             clang::driver::options::OPT_fno_sanitize_trap_EQ,
+             clang::driver::options::OPT_fno_sanitize_trap,
+             clang::driver::options::OPT_fno_sanitize_undefined_trap_on_error,
+             clang::driver::options::OPT_fno_sanitize_EQ,
+             clang::driver::options::OPT_sanitize_address_destructor_EQ,
+             clang::driver::options::OPT_fsanitize_address_field_padding,
+             clang::driver::options::OPT_fsanitize_address_globals_dead_stripping,
+             clang::driver::options::OPT_fsanitize_address_outline_instrumentation,
+             clang::driver::options::OPT_fsanitize_address_poison_custom_array_cookie,
+             clang::driver::options::OPT_sanitize_address_use_after_return_EQ,
+             clang::driver::options::OPT__SLASH_fsanitize_address_use_after_return,
+             clang::driver::options::OPT_fsanitize_address_use_after_scope,
+             clang::driver::options::OPT_fsanitize_address_use_odr_indicator,
+             clang::driver::options::OPT_fsanitize_cfi_canonical_jump_tables,
+             clang::driver::options::OPT_fsanitize_cfi_cross_dso,
+             clang::driver::options::OPT_fsanitize_cfi_icall_normalize_integers,
+             clang::driver::options::OPT_fsanitize_cfi_icall_generalize_pointers,
+             clang::driver::options::OPT_fsanitize_coverage_8bit_counters,
+             clang::driver::options::OPT_fsanitize_coverage_allowlist,
+             clang::driver::options::OPT_fsanitize_coverage_control_flow,
+             clang::driver::options::OPT_fsanitize_coverage_ignorelist,
+             clang::driver::options::OPT_fsanitize_coverage_indirect_calls,
+             clang::driver::options::OPT_fsanitize_coverage_inline_8bit_counters,
+             clang::driver::options::OPT_fsanitize_coverage_inline_bool_flag,
+             clang::driver::options::OPT_fsanitize_coverage_no_prune,
+             clang::driver::options::OPT_fsanitize_coverage_pc_table,
+             clang::driver::options::OPT_fsanitize_coverage_stack_depth,
+             clang::driver::options::OPT_fsanitize_coverage_trace_bb,
+             clang::driver::options::OPT_fsanitize_coverage_trace_cmp,
+             clang::driver::options::OPT_fsanitize_coverage_trace_div,
+             clang::driver::options::OPT_fsanitize_coverage_trace_gep,
+             clang::driver::options::OPT_fsanitize_coverage_trace_loads,
+             clang::driver::options::OPT_fsanitize_coverage_trace_pc_guard,
+             clang::driver::options::OPT_fsanitize_coverage_trace_pc,
+             clang::driver::options::OPT_fsanitize_coverage_trace_stores,
+             clang::driver::options::OPT_fsanitize_coverage_type,
+             clang::driver::options::OPT_fsanitize_coverage,
+             clang::driver::options::OPT_fsanitize_hwaddress_abi_EQ,
+             clang::driver::options::OPT_fsanitize_hwaddress_experimental_aliasing,
+             clang::driver::options::OPT_fsanitize_ignorelist_EQ,
+             clang::driver::options::OPT_fsanitize_link_cxx_runtime,
+             clang::driver::options::OPT_fsanitize_link_runtime,
+             clang::driver::options::OPT_fsanitize_memory_param_retval,
+             clang::driver::options::OPT_fsanitize_memory_track_origins_EQ,
+             clang::driver::options::OPT_fsanitize_memory_track_origins,
+             clang::driver::options::OPT_fsanitize_memory_use_after_dtor,
+             clang::driver::options::OPT_fsanitize_memtag_mode_EQ,
+             clang::driver::options::OPT_fsanitize_minimal_runtime,
+             clang::driver::options::OPT_fsanitize_recover_EQ,
+             clang::driver::options::OPT_fsanitize_recover,
+             clang::driver::options::OPT_fsanitize_stable_abi,
+             clang::driver::options::OPT_fsanitize_stats,
+             clang::driver::options::OPT_fsanitize_system_ignorelist_EQ,
+             clang::driver::options::OPT_fsanitize_thread_atomics,
+             clang::driver::options::OPT_fsanitize_thread_func_entry_exit,
+             clang::driver::options::OPT_fsanitize_thread_memory_access,
+             clang::driver::options::OPT_fsanitize_trap_EQ,
+             clang::driver::options::OPT_fsanitize_trap,
+             clang::driver::options::OPT_fsanitize_undefined_strip_path_components_EQ,
+             clang::driver::options::OPT_fsanitize_undefined_trap_on_error,
+             clang::driver::options::OPT__SLASH_fsanitize_EQ_address,
+             clang::driver::options::OPT_fsanitize_EQ,
+             clang::driver::options::OPT_shared_libsan,
+             clang::driver::options::OPT_static_libsan,
+             clang::driver::options::OPT_static_libsan,
 
              // diagnostic options
-             driver::options::OPT_Diag_Group,
-             driver::options::OPT_W_value_Group,
-             driver::options::OPT__SLASH_wd,
+             clang::driver::options::OPT_Diag_Group,
+             clang::driver::options::OPT_W_value_Group,
+             clang::driver::options::OPT__SLASH_wd,
 
              // language conformance options
-             driver::options::OPT_pedantic_Group,
-             driver::options::OPT__SLASH_permissive,
-             driver::options::OPT__SLASH_permissive_,
+             clang::driver::options::OPT_pedantic_Group,
+             clang::driver::options::OPT__SLASH_permissive,
+             clang::driver::options::OPT__SLASH_permissive_,
 
              // ignored options
-             driver::options::OPT_cl_ignored_Group,
-             driver::options::OPT_cl_ignored_Group,
-             driver::options::OPT_clang_ignored_f_Group,
-             driver::options::OPT_clang_ignored_gcc_optimization_f_Group,
-             driver::options::OPT_clang_ignored_legacy_options_Group,
-             driver::options::OPT_clang_ignored_m_Group,
-             driver::options::OPT_flang_ignored_w_Group
+             clang::driver::options::OPT_cl_ignored_Group,
+             clang::driver::options::OPT_cl_ignored_Group,
+             clang::driver::options::OPT_clang_ignored_f_Group,
+             clang::driver::options::OPT_clang_ignored_gcc_optimization_f_Group,
+             clang::driver::options::OPT_clang_ignored_legacy_options_Group,
+             clang::driver::options::OPT_clang_ignored_m_Group,
+             clang::driver::options::OPT_flang_ignored_w_Group
 #if 0
             // input file options
-            driver::options::OPT_INPUT,
+            clang::driver::options::OPT_INPUT,
 
             // output file options
-            driver::options::OPT_o,
-            driver::options::OPT__SLASH_o,
-            driver::options::OPT__SLASH_Fo,
-            driver::options::OPT__SLASH_Fe,
-            driver::options::OPT__SLASH_Fd,
-            driver::options::OPT__SLASH_FA,
-            driver::options::OPT__SLASH_Fa,
-            driver::options::OPT__SLASH_Fi,
-            driver::options::OPT__SLASH_FR,
-            driver::options::OPT__SLASH_Fr,
-            driver::options::OPT__SLASH_Fm,
-            driver::options::OPT__SLASH_Fx,
+            clang::driver::options::OPT_o,
+            clang::driver::options::OPT__SLASH_o,
+            clang::driver::options::OPT__SLASH_Fo,
+            clang::driver::options::OPT__SLASH_Fe,
+            clang::driver::options::OPT__SLASH_Fd,
+            clang::driver::options::OPT__SLASH_FA,
+            clang::driver::options::OPT__SLASH_Fa,
+            clang::driver::options::OPT__SLASH_Fi,
+            clang::driver::options::OPT__SLASH_FR,
+            clang::driver::options::OPT__SLASH_Fr,
+            clang::driver::options::OPT__SLASH_Fm,
+            clang::driver::options::OPT__SLASH_Fx,
 #endif
-            // driver::options::OPT__SLASH_TP
-            // driver::options::OPT__SLASH_Tp
-            // driver::options::OPT__SLASH_TC
-            // driver::options::OPT__SLASH_Tc
+            // clang::driver::options::OPT__SLASH_TP
+            // clang::driver::options::OPT__SLASH_Tp
+            // clang::driver::options::OPT__SLASH_TC
+            // clang::driver::options::OPT__SLASH_Tc
     ))
     {
         return false;
@@ -273,7 +273,7 @@ isValidMrDocsOption(
 static
 std::vector<std::string>
 adjustCommandLine(
-    StringRef const workingDir,
+    llvm::StringRef const workingDir,
     std::vector<std::string> const& cmdline,
     std::shared_ptr<Config const> const& config,
     std::unordered_map<std::string, std::vector<std::string>> const& implicitIncludeDirectories,
@@ -307,10 +307,10 @@ adjustCommandLine(
     // command line option formats. The value is deduced from
     // the `-drive-mode` option or from `progName`.
     // Common values are "gcc", "g++", "cpp", "cl" and "flang".
-    StringRef const driver_mode = driver::getDriverMode(progName, cmdLineCStrs);
+    llvm::StringRef const driver_mode = clang::driver::getDriverMode(progName, cmdLineCStrs);
     // Identify if we should use "msvc/clang-cl" or "clang/gcc" format
     // for options.
-    bool const is_clang_cl = driver::IsClangCL(driver_mode);
+    bool const is_clang_cl = clang::driver::IsClangCL(driver_mode);
 
     // ------------------------------------------------------
     // Supress all warnings
@@ -502,7 +502,7 @@ adjustCommandLine(
     // errors.
     llvm::opt::OptTable const& opts_table = clang::driver::getDriverOptTable();
     llvm::opt::Visibility visibility(is_clang_cl ?
-        driver::options::CLOption : driver::options::ClangOption);
+        clang::driver::options::CLOption : clang::driver::options::ClangOption);
     unsigned idx = 1;
     while (idx < cmdline.size())
     {
@@ -546,14 +546,14 @@ makeAbsoluteAndNative(
 
 MrDocsCompilationDatabase::
 MrDocsCompilationDatabase(
-    StringRef const workingDir,
+    llvm::StringRef const workingDir,
     CompilationDatabase const& inner,
     std::shared_ptr<Config const> const& config,
     std::unordered_map<std::string, std::vector<std::string>> const& implicitIncludeDirectories)
 {
     namespace fs = llvm::sys::fs;
     namespace path = llvm::sys::path;
-    using tooling::CompileCommand;
+    using clang::tooling::CompileCommand;
 
     std::vector<CompileCommand> allCommands = inner.getAllCompileCommands();
     AllCommands_.reserve(allCommands.size());
@@ -591,7 +591,7 @@ MrDocsCompilationDatabase(
     }
 }
 
-std::vector<tooling::CompileCommand>
+std::vector<clang::tooling::CompileCommand>
 MrDocsCompilationDatabase::
 getCompileCommands(
     llvm::StringRef FilePath) const
@@ -602,7 +602,7 @@ getCompileCommands(
     auto const it = IndexByFile_.find(nativeFilePath);
     if (it == IndexByFile_.end())
         return {};
-    std::vector<tooling::CompileCommand> Commands;
+    std::vector<clang::tooling::CompileCommand> Commands;
     Commands.push_back(AllCommands_[it->getValue()]);
     return Commands;
 }
@@ -618,7 +618,7 @@ getAllFiles() const
     return allFiles;
 }
 
-std::vector<tooling::CompileCommand>
+std::vector<clang::tooling::CompileCommand>
 MrDocsCompilationDatabase::
 getAllCompileCommands() const
 {
@@ -626,4 +626,4 @@ getAllCompileCommands() const
 }
 
 } // mrdocs
-} // clang
+
diff --git a/src/lib/MrDocsCompilationDatabase.hpp b/src/lib/MrDocsCompilationDatabase.hpp
index 097ae5c0a..cb45862ea 100644
--- a/src/lib/MrDocsCompilationDatabase.hpp
+++ b/src/lib/MrDocsCompilationDatabase.hpp
@@ -16,7 +16,7 @@
 #include <llvm/ADT/StringMap.h>
 #include <vector>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** A compilation database for MrDocs.
@@ -34,9 +34,9 @@ namespace mrdocs {
 
 */
 class MrDocsCompilationDatabase
-    : public tooling::CompilationDatabase
+    : public clang::tooling::CompilationDatabase
 {
-    std::vector<tooling::CompileCommand> AllCommands_;
+    std::vector<clang::tooling::CompileCommand> AllCommands_;
     llvm::StringMap<std::size_t> IndexByFile_;
 
 public:
@@ -54,7 +54,7 @@ class MrDocsCompilationDatabase
      *        implicit include directories, as determined by the system's compiler.
      */
     MrDocsCompilationDatabase(
-        StringRef workingDir,
+        llvm::StringRef workingDir,
         CompilationDatabase const& inner,
         std::shared_ptr<Config const> const& config,
         std::unordered_map<std::string, std::vector<std::string>> const& implicitIncludeDirectories);
@@ -63,9 +63,9 @@ class MrDocsCompilationDatabase
 
         @return A vector of compile commands.
     */
-    std::vector<tooling::CompileCommand>
+    std::vector<clang::tooling::CompileCommand>
     getCompileCommands(
-        StringRef FilePath) const override;
+        llvm::StringRef FilePath) const override;
 
     /** Get all files in the database.
 
@@ -78,12 +78,12 @@ class MrDocsCompilationDatabase
 
         @return A vector of compile commands.
     */
-    std::vector<tooling::CompileCommand>
+    std::vector<clang::tooling::CompileCommand>
     getAllCompileCommands() const override;
 };
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_LIB_MRDOCSCOMPILATIONDATABASE_HPP
 
diff --git a/src/lib/MrDocsSettingsDB.cpp b/src/lib/MrDocsSettingsDB.cpp
index 5740475ab..d32b0cc6b 100644
--- a/src/lib/MrDocsSettingsDB.cpp
+++ b/src/lib/MrDocsSettingsDB.cpp
@@ -12,7 +12,7 @@
 #include "MrDocsSettingsDB.hpp"
 #include <mrdocs/Support/Path.hpp>
 
-namespace clang {
+
 namespace mrdocs {
 
 MrDocsSettingsDB::MrDocsSettingsDB(ConfigImpl const& config)
@@ -79,10 +79,10 @@ MrDocsSettingsDB::MrDocsSettingsDB(ConfigImpl const& config)
     }
 }
 
-std::vector<tooling::CompileCommand>
+std::vector<clang::tooling::CompileCommand>
 MrDocsSettingsDB::getCompileCommands(llvm::StringRef FilePath) const
 {
-    std::vector<tooling::CompileCommand> result;
+    std::vector<clang::tooling::CompileCommand> result;
     for (auto const& cmd: cc_)
     {
         if (cmd.Filename == FilePath)
@@ -105,11 +105,10 @@ MrDocsSettingsDB::getAllFiles() const
     return result;
 }
 
-std::vector<tooling::CompileCommand>
+std::vector<clang::tooling::CompileCommand>
 MrDocsSettingsDB::getAllCompileCommands() const
 {
     return cc_;
 }
 
 } // namespace mrdocs
-} // namespace clang
diff --git a/src/lib/MrDocsSettingsDB.hpp b/src/lib/MrDocsSettingsDB.hpp
index 1e8477842..24da5c554 100644
--- a/src/lib/MrDocsSettingsDB.hpp
+++ b/src/lib/MrDocsSettingsDB.hpp
@@ -18,33 +18,33 @@
 #include <utility>
 #include <vector>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** A compilation database generated from the mrdocs.yml options
 */
 class MrDocsSettingsDB
-    : public tooling::CompilationDatabase
+    : public clang::tooling::CompilationDatabase
 {
-    std::vector<tooling::CompileCommand> cc_;
+    std::vector<clang::tooling::CompileCommand> cc_;
 
 public:
     explicit
     MrDocsSettingsDB(
         ConfigImpl const& config);
 
-    std::vector<tooling::CompileCommand>
+    std::vector<clang::tooling::CompileCommand>
     getCompileCommands(
         llvm::StringRef FilePath) const override;
 
     std::vector<std::string>
     getAllFiles() const override;
 
-    std::vector<tooling::CompileCommand>
+    std::vector<clang::tooling::CompileCommand>
     getAllCompileCommands() const override;
 };
 
 } // mrdocs
-} // clang
+
 
 #endif
diff --git a/src/lib/SingleFileDB.hpp b/src/lib/SingleFileDB.hpp
index 16af01ed5..5139aba97 100644
--- a/src/lib/SingleFileDB.hpp
+++ b/src/lib/SingleFileDB.hpp
@@ -17,15 +17,15 @@
 #include <utility>
 #include <vector>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** Compilation database for a single .cpp file.
 */
 class SingleFileDB
-    : public tooling::CompilationDatabase
+    : public clang::tooling::CompilationDatabase
 {
-    std::vector<tooling::CompileCommand> cc_;
+    std::vector<clang::tooling::CompileCommand> cc_;
 
 public:
     explicit
@@ -50,7 +50,7 @@ class SingleFileDB
         cc_.back().Heuristic = "unit test";
     }
 
-    std::vector<tooling::CompileCommand>
+    std::vector<clang::tooling::CompileCommand>
     getCompileCommands(
         llvm::StringRef FilePath) const override
     {
@@ -65,7 +65,7 @@ class SingleFileDB
         return { cc_.front().Filename };
     }
 
-    std::vector<tooling::CompileCommand>
+    std::vector<clang::tooling::CompileCommand>
     getAllCompileCommands() const override
     {
         return { cc_.front() };
@@ -73,6 +73,6 @@ class SingleFileDB
 };
 
 } // mrdocs
-} // clang
+
 
 #endif
diff --git a/src/lib/Support/Assert.cpp b/src/lib/Support/Assert.cpp
index 8347a34fe..82666a9c3 100644
--- a/src/lib/Support/Assert.cpp
+++ b/src/lib/Support/Assert.cpp
@@ -17,7 +17,7 @@ namespace SourceFileNames {
 extern char const* getFileName(char const*) noexcept;
 } // SourceFileNames
 
-namespace clang {
+
 namespace mrdocs {
 
 void
@@ -31,4 +31,4 @@ assert_failed(
 }
 
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Support/CMakeExecution.cpp b/src/lib/Support/CMakeExecution.cpp
index db0cc4c79..00636d909 100644
--- a/src/lib/Support/CMakeExecution.cpp
+++ b/src/lib/Support/CMakeExecution.cpp
@@ -16,7 +16,7 @@
 #include <llvm/Support/Path.h>
 #include <llvm/Support/Program.h>
 
-namespace clang {
+
 namespace mrdocs {
 
 namespace {
@@ -535,4 +535,4 @@ executeCmakeExportCompileCommands(llvm::StringRef projectPath, llvm::StringRef c
 
 
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Support/CMakeExecution.hpp b/src/lib/Support/CMakeExecution.hpp
index c22c554f3..9d4439432 100644
--- a/src/lib/Support/CMakeExecution.hpp
+++ b/src/lib/Support/CMakeExecution.hpp
@@ -15,7 +15,7 @@
 #include <llvm/ADT/StringRef.h>
 #include <string>
 
-namespace clang {
+
 namespace mrdocs {
 
 /**
@@ -34,7 +34,7 @@ Expected<std::string>
 executeCmakeExportCompileCommands(llvm::StringRef projectPath, llvm::StringRef cmakeArgs, llvm::StringRef tempDir);
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_LIB_SUPPORT_CMAKEEXECUTION_HPP
 
diff --git a/src/lib/Support/Chrono.hpp b/src/lib/Support/Chrono.hpp
index f98ccad67..1ec6a9a1c 100644
--- a/src/lib/Support/Chrono.hpp
+++ b/src/lib/Support/Chrono.hpp
@@ -17,7 +17,7 @@
 #include <format>
 #include <string>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** Formats a duration into a human-readable string.
@@ -65,6 +65,6 @@ format_duration(
 }
 
 } // mrdocs
-} // clang
+
 
 #endif
diff --git a/src/lib/Support/Debug.cpp b/src/lib/Support/Debug.cpp
index 2beec1b05..d3d1738b7 100644
--- a/src/lib/Support/Debug.cpp
+++ b/src/lib/Support/Debug.cpp
@@ -11,13 +11,13 @@
 
 #include <lib/Support/Debug.hpp>
 #include <lib/Support/Radix.hpp>
-#include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/Info/Record.hpp>
-#include <mrdocs/Metadata/Info/SymbolID.hpp>
+#include <mrdocs/Metadata/Symbol.hpp>
+#include <mrdocs/Metadata/Symbol/Record.hpp>
+#include <mrdocs/Metadata/Symbol/SymbolID.hpp>
 #include <format>
 #include <memory>
 
-namespace clang {
+
 namespace mrdocs {
 
 void
@@ -32,16 +32,16 @@ debugEnableHeapChecking()
 }
 
 } // mrdocs
-} // clang
+
 
 std::string
-std::formatter<clang::mrdocs::Info>::toString(clang::mrdocs::Info const &i) {
+std::formatter<mrdocs::Symbol>::toString(mrdocs::Symbol const &i) {
   std::string str = std::format("Info: kind = {}", i.Kind);
   if (!i.Name.empty()) {
     str += std::format(", name = '{}'", i.Name);
   }
   str += std::format(", ID = {}", i.id);
-  clang::mrdocs::SymbolID curParent = i.Parent;
+  mrdocs::SymbolID curParent = i.Parent;
   std::string namespaces;
   while (curParent) {
     namespaces += std::format("{}", curParent);
diff --git a/src/lib/Support/Debug.hpp b/src/lib/Support/Debug.hpp
index bc964526b..8292a55cb 100644
--- a/src/lib/Support/Debug.hpp
+++ b/src/lib/Support/Debug.hpp
@@ -17,56 +17,56 @@
 #    include <llvm/Support/ErrorHandling.h>
 #endif
 #include <lib/Support/Radix.hpp>
-#include <mrdocs/Metadata/Info.hpp>
-#include <mrdocs/Metadata/Info/SymbolID.hpp>
+#include <mrdocs/Metadata/Symbol.hpp>
+#include <mrdocs/Metadata/Symbol/SymbolID.hpp>
 #include <llvm/Support/raw_ostream.h>
 #include <format>
 #include <string>
 
 template <>
-struct std::formatter<clang::mrdocs::SymbolID> : std::formatter<std::string> {
+struct std::formatter<mrdocs::SymbolID> : std::formatter<std::string> {
   template <class FmtContext>
-  std::format_context::iterator format(clang::mrdocs::SymbolID const &s,
+  std::format_context::iterator format(mrdocs::SymbolID const &s,
                                        FmtContext &ctx) const {
-    std::string str = s ? clang::mrdocs::toBase64(s) : "<invalid SymbolID>";
+    std::string str = s ? mrdocs::toBase64(s) : "<invalid SymbolID>";
     return std::formatter<std::string>::format(std::move(str), ctx);
   }
 };
 
 template <>
-struct std::formatter<clang::mrdocs::InfoKind> : std::formatter<std::string> {
+struct std::formatter<mrdocs::SymbolKind> : std::formatter<std::string> {
   template <class FmtContext>
-  std::format_context::iterator format(clang::mrdocs::InfoKind t,
+  std::format_context::iterator format(mrdocs::SymbolKind t,
                                        FmtContext &ctx) const {
     return std::formatter<std::string>::format(toString(t).str(), ctx);
   }
 };
 
 template <>
-struct std::formatter<clang::mrdocs::AccessKind> : std::formatter<std::string> {
+struct std::formatter<mrdocs::AccessKind> : std::formatter<std::string> {
   template <class FmtContext>
-  std::format_context::iterator format(clang::mrdocs::AccessKind a,
+  std::format_context::iterator format(mrdocs::AccessKind a,
                                        FmtContext &ctx) const {
     return std::formatter<std::string>::format(toString(a).str(), ctx);
   }
 };
 
 template <>
-struct std::formatter<clang::mrdocs::Info> : std::formatter<std::string> {
+struct std::formatter<mrdocs::Symbol> : std::formatter<std::string> {
   template <class FmtContext>
-  std::format_context::iterator format(clang::mrdocs::Info const &i,
+  std::format_context::iterator format(mrdocs::Symbol const &i,
                                        FmtContext &ctx) const {
     return std::formatter<std::string>::format(toString(i), ctx);
   }
 
 private:
-  static std::string toString(clang::mrdocs::Info const &i);
+  static std::string toString(mrdocs::Symbol const &i);
 };
 
 // Some nice odds and ends such as leak checking
 // and redirection to the Visual Studio output window.
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** Enable debug heap checking.
 */
@@ -75,6 +75,6 @@ MRDOCS_DECL void debugEnableHeapChecking();
 #define static_error(msg, value) \
     static_assert(!std::is_same_v<decltype(value),decltype(value)>,msg)
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_LIB_SUPPORT_DEBUG_HPP
diff --git a/src/lib/Support/ExecuteAndWaitWithLogging.cpp b/src/lib/Support/ExecuteAndWaitWithLogging.cpp
index 392c9aa06..8ad2ef7ae 100644
--- a/src/lib/Support/ExecuteAndWaitWithLogging.cpp
+++ b/src/lib/Support/ExecuteAndWaitWithLogging.cpp
@@ -12,7 +12,7 @@
 #include <lib/Support/Report.hpp>
 #include <mrdocs/Support/Assert.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 int ExecuteAndWaitWithLogging(
     llvm::StringRef program,
@@ -36,4 +36,4 @@ int ExecuteAndWaitWithLogging(
     return llvm::sys::ExecuteAndWait(program, args, env, redirects, secondsToWait, memoryLimit, errMsg, executionFailed, procStat, affinityMask);
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Support/ExecuteAndWaitWithLogging.hpp b/src/lib/Support/ExecuteAndWaitWithLogging.hpp
index 4bbfde16b..1e9ddd68d 100644
--- a/src/lib/Support/ExecuteAndWaitWithLogging.hpp
+++ b/src/lib/Support/ExecuteAndWaitWithLogging.hpp
@@ -13,7 +13,7 @@
 
 #include <llvm/Support/Program.h>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /**
  * A wrapper around llvm::sys::ExecuteAndWait() that prints the command
@@ -37,6 +37,6 @@ int ExecuteAndWaitWithLogging(
     std::optional<llvm::sys::ProcessStatistics>* procStat = nullptr,
     llvm::BitVector* affinityMask = nullptr);
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_LIB_SUPPORT_EXECUTEANDWAITWITHLOGGING_HPP
diff --git a/src/lib/Support/ExecutionContext.cpp b/src/lib/Support/ExecutionContext.cpp
index 309acd448..b7173e343 100644
--- a/src/lib/Support/ExecutionContext.cpp
+++ b/src/lib/Support/ExecutionContext.cpp
@@ -14,11 +14,11 @@
 #include "ExecutionContext.hpp"
 #include <lib/Metadata/Reduce.hpp>
 #include <mrdocs/Metadata.hpp>
-#include <mrdocs/Metadata/Info/Namespace.hpp>
+#include <mrdocs/Metadata/Symbol/Namespace.hpp>
 #include <mrdocs/Support/Assert.hpp>
 #include <ranges>
 
-namespace clang {
+
 namespace mrdocs {
 
 namespace {
@@ -32,8 +32,8 @@ namespace {
 
     @param Values The vector of Info objects to merge.
 */
-mrdocs::Expected<std::unique_ptr<Info>>
-mergeInfos(std::vector<std::unique_ptr<Info>>& Values)
+mrdocs::Expected<std::unique_ptr<Symbol>>
+mergeInfos(std::vector<std::unique_ptr<Symbol>>& Values)
 {
     if(Values.empty() || ! Values[0])
     {
@@ -56,11 +56,11 @@ mergeInfos(std::vector<std::unique_ptr<Info>>& Values)
 void
 InfoExecutionContext::
 report(
-    InfoSet&& results,
+    SymbolSet&& results,
     Diagnostics&& diags,
-    UndocumentedInfoSet&& undocumented)
+    UndocumentedSymbolSet&& undocumented)
 {
-    InfoSet info = std::move(results);
+    SymbolSet info = std::move(results);
     std::unique_lock<std::shared_mutex> write_lock(mutex_);
 
     // Add all new Info to the existing set.
@@ -107,14 +107,14 @@ reportEnd(report::Level level)
     diags_.reportTotals(level);
 }
 
-Expected<InfoSet>
+Expected<SymbolSet>
 InfoExecutionContext::
 results()
 {
     return std::move(info_);
 }
 
-UndocumentedInfoSet
+UndocumentedSymbolSet
 InfoExecutionContext::
 undocumented()
 {
@@ -122,4 +122,4 @@ undocumented()
 }
 
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Support/ExecutionContext.hpp b/src/lib/Support/ExecutionContext.hpp
index b34f9d48d..11ef036a6 100644
--- a/src/lib/Support/ExecutionContext.hpp
+++ b/src/lib/Support/ExecutionContext.hpp
@@ -15,7 +15,7 @@
 
 #include <lib/ConfigImpl.hpp>
 #include <lib/Diagnostics.hpp>
-#include <lib/Metadata/InfoSet.hpp>
+#include <lib/Metadata/SymbolSet.hpp>
 #include <mrdocs/Support/Error.hpp>
 #include <llvm/ADT/SmallString.h>
 #include <mutex>
@@ -23,7 +23,7 @@
 #include <unordered_map>
 #include <vector>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** A custom execution context for visitation.
 
@@ -38,7 +38,7 @@ namespace clang::mrdocs {
     MrDocs by referring to the `ConfigImpl`,
     reporting based on the `Info` and `Diagnostics`
     classes, and including a `results` method
-    which returns the `InfoSet`.
+    which returns the `SymbolSet`.
 */
 class ExecutionContext
 {
@@ -66,7 +66,7 @@ class ExecutionContext
         This function is called to report the results
         of an execution.
 
-        The `InfoSet` is merged into the existing
+        The `SymbolSet` is merged into the existing
         set of results. Duplicate IDs are merged.
 
         Any new diagnostics are appended to the
@@ -79,9 +79,9 @@ class ExecutionContext
     virtual
     void
     report(
-        InfoSet&& info,
+        SymbolSet&& info,
         Diagnostics&& diags,
-        UndocumentedInfoSet&& undocumented) = 0;
+        UndocumentedSymbolSet&& undocumented) = 0;
 
     /** Called when the execution is complete.
 
@@ -102,19 +102,19 @@ class ExecutionContext
         @return The results of the execution.
     */
     virtual
-    mrdocs::Expected<InfoSet>
+    mrdocs::Expected<SymbolSet>
     results() = 0;
 
     virtual
-    UndocumentedInfoSet
+    UndocumentedSymbolSet
     undocumented() = 0;
 };
 
 // ----------------------------------------------------------------
 
-/** An execution context which stores the InfoSet and Diagnostics.
+/** An execution context which stores the SymbolSet and Diagnostics.
 
-    It stores the `InfoSet` and `Diagnostics`
+    It stores the `SymbolSet` and `Diagnostics`
     objects, and returns them when `results`
     is called.
  */
@@ -123,8 +123,8 @@ class InfoExecutionContext
 {
     std::shared_mutex mutex_;
     Diagnostics diags_;
-    InfoSet info_;
-    UndocumentedInfoSet undocumented_;
+    SymbolSet info_;
+    UndocumentedSymbolSet undocumented_;
 
 public:
     using ExecutionContext::ExecutionContext;
@@ -132,9 +132,9 @@ class InfoExecutionContext
     /// @copydoc ExecutionContext::report
     void
     report(
-        InfoSet&& info,
+        SymbolSet&& info,
         Diagnostics&& diags,
-        UndocumentedInfoSet&& undocumented) override;
+        UndocumentedSymbolSet&& undocumented) override;
 
     /// @copydoc ExecutionContext::reportEnd
     void
@@ -145,18 +145,18 @@ class InfoExecutionContext
         The results are returned as a set of
         `Info` objects.
 
-        The `InfoSet` object is moved out of
+        The `SymbolSet` object is moved out of
         the execution context.
 
         @return The results of the execution.
     */
-    Expected<InfoSet>
+    Expected<SymbolSet>
     results() override;
 
-    UndocumentedInfoSet
+    UndocumentedSymbolSet
     undocumented() override;
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif // MRDOCS_LIB_SUPPORT_EXECUTIONCONTEXT_HPP
diff --git a/src/lib/Support/ExecutorGroup.cpp b/src/lib/Support/ExecutorGroup.cpp
index ac97398a2..bd21cd92a 100644
--- a/src/lib/Support/ExecutorGroup.cpp
+++ b/src/lib/Support/ExecutorGroup.cpp
@@ -14,7 +14,7 @@
 #include <condition_variable>
 #include <unordered_set>
 
-namespace clang {
+
 namespace mrdocs {
 
 struct ExecutorGroupBase::
@@ -152,4 +152,4 @@ wait() noexcept
 }
 
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Support/Generator.cpp b/src/lib/Support/Generator.cpp
index d2b1e89a4..4f4e6ccd0 100644
--- a/src/lib/Support/Generator.cpp
+++ b/src/lib/Support/Generator.cpp
@@ -20,7 +20,7 @@
 #include <fstream>
 #include <sstream>
 
-namespace clang {
+
 namespace mrdocs {
 
 Generator::
@@ -157,4 +157,4 @@ getSinglePageFullPath(
 }
 
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Support/GeneratorsImpl.cpp b/src/lib/Support/GeneratorsImpl.cpp
index b0cfdbbfb..8238339ba 100644
--- a/src/lib/Support/GeneratorsImpl.cpp
+++ b/src/lib/Support/GeneratorsImpl.cpp
@@ -12,7 +12,7 @@
 #include <mrdocs/Support/Report.hpp>
 #include <llvm/ADT/STLExtras.h>
 
-namespace clang {
+
 namespace mrdocs {
 
 extern
@@ -90,4 +90,4 @@ getGenerators() noexcept
 }
 
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Support/GeneratorsImpl.hpp b/src/lib/Support/GeneratorsImpl.hpp
index 73de003f4..d9ba47eea 100644
--- a/src/lib/Support/GeneratorsImpl.hpp
+++ b/src/lib/Support/GeneratorsImpl.hpp
@@ -18,7 +18,7 @@
 #include <memory>
 #include <vector>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** Implementaiton of Generators.
@@ -63,6 +63,6 @@ GeneratorsImpl&
 getGeneratorsImpl() noexcept;
 
 } // mrdocs
-} // clang
+
 
 #endif
diff --git a/src/lib/Support/Glob.cpp b/src/lib/Support/Glob.cpp
index fd0028037..117a282f4 100644
--- a/src/lib/Support/Glob.cpp
+++ b/src/lib/Support/Glob.cpp
@@ -16,7 +16,7 @@
 #include <llvm/Support/YAMLTraits.h>
 #include <ranges>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 namespace {
 
@@ -719,5 +719,5 @@ pattern() const
     return impl_->pattern;
 }
 
-} // clang::mrdocs
+} // mrdocs
 
diff --git a/src/lib/Support/Glob.hpp b/src/lib/Support/Glob.hpp
index aa4306003..8e1e50345 100644
--- a/src/lib/Support/Glob.hpp
+++ b/src/lib/Support/Glob.hpp
@@ -13,7 +13,7 @@
 
 #include <string>
 
-namespace clang {
+
 namespace mrdocs {
 
 /// Check if the string matches the glob pattern
@@ -23,7 +23,7 @@ globMatch(
     std::string_view str) noexcept;
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_LIB_SUPPORT_GLOB_HPP
 
diff --git a/src/lib/Support/Handlebars.cpp b/src/lib/Support/Handlebars.cpp
index f9ee2d2b1..cdab1c0b2 100644
--- a/src/lib/Support/Handlebars.cpp
+++ b/src/lib/Support/Handlebars.cpp
@@ -21,7 +21,7 @@
 #include <unordered_set>
 #include <utility>
 
-namespace clang {
+
 namespace mrdocs {
 
 // ==============================================================
@@ -6987,5 +6987,5 @@ unregisterHelper(std::string_view name) {
 }
 
 } // mrdocs
-} // clang
+
 
diff --git a/src/lib/Support/JavaScript.cpp b/src/lib/Support/JavaScript.cpp
index 47ecc1dbf..28bbd357c 100644
--- a/src/lib/Support/JavaScript.cpp
+++ b/src/lib/Support/JavaScript.cpp
@@ -19,7 +19,7 @@
 #include <utility>
 #include <variant>
 
-namespace clang {
+
 namespace mrdocs {
 namespace js {
 
@@ -1883,7 +1883,7 @@ operator&&(Value const& lhs, Value const& rhs)
 
 Expected<void, Error>
 registerHelper(
-    clang::mrdocs::Handlebars& hbs,
+    mrdocs::Handlebars& hbs,
     std::string_view name,
     Context& ctx,
     std::string_view script)
@@ -1987,4 +1987,4 @@ registerHelper(
 
 } // js
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Support/LegibleNames.cpp b/src/lib/Support/LegibleNames.cpp
index d3f9052c6..c9c91daf1 100644
--- a/src/lib/Support/LegibleNames.cpp
+++ b/src/lib/Support/LegibleNames.cpp
@@ -25,11 +25,11 @@
 #include <string_view>
 #include <unordered_map>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 namespace {
 
 std::string
-getUnnamedInfoName(Info const& I)
+getUnnamedInfoName(Symbol const& I)
 {
     // All valid c++ identifiers begin with
     // an underscore or alphabetic character,
@@ -99,7 +99,7 @@ class LegibleNames::Impl
 
     /* The info related to the legible name for a symbol
      */
-    struct LegibleNameInfo
+    struct LegibleName
     {
         /*  Raw unqualified name for the symbol
          */
@@ -117,11 +117,11 @@ class LegibleNames::Impl
 
     /* A map from SymbolID to legible name information
      */
-    std::unordered_map<SymbolID, LegibleNameInfo> map_;
+    std::unordered_map<SymbolID, LegibleName> map_;
 
     /* Maps unqualified names to all symbols with that name within the current scope
      */
-    UnorderedStringMultiMap<LegibleNameInfo*> disambiguation_map_;
+    UnorderedStringMultiMap<LegibleName*> disambiguation_map_;
 
 public:
     /*  Build the map of legible names for all symbols in the corpus
@@ -130,7 +130,7 @@ class LegibleNames::Impl
         : corpus_(corpus)
         , global_ns_(global_ns)
     {
-        NamespaceInfo const& global = corpus_.globalNamespace();
+        NamespaceSymbol const& global = corpus_.globalNamespace();
 
         // Treat the global namespace as-if its "name"
         // is in the same scope as its members
@@ -149,11 +149,11 @@ class LegibleNames::Impl
     void
     operator()(InfoTy const& I)
     {
-        if constexpr (InfoParent<InfoTy> && !std::same_as<InfoTy, OverloadsInfo>)
+        if constexpr (SymbolParent<InfoTy> && !std::same_as<InfoTy, OverloadsSymbol>)
         {
             // Visit the members of the symbol and build legible names
             constexpr Corpus::TraverseOptions opts = {.skipInherited = true};
-            corpus_.traverse(opts, I, [this, &I](Info const& M)
+            corpus_.traverse(opts, I, [this, &I](Symbol const& M)
                 {
                     auto const raw = getRawUnqualified(M);
                     buildLegibleMember(M, raw);
@@ -161,7 +161,7 @@ class LegibleNames::Impl
                     // Traverse non inherited function overloads inline
                     if (auto* MO = M.asOverloadsPtr())
                     {
-                        corpus_.traverse(*MO, [this, &I](Info const& M2)
+                        corpus_.traverse(*MO, [this, &I](Symbol const& M2)
                             {
                                 // Not inherited in regard to I
                                 MRDOCS_CHECK_OR(M2.Parent == I.id);
@@ -176,7 +176,7 @@ class LegibleNames::Impl
 
             // Visit the members of the symbol to build legible names
             // for their members
-            corpus_.traverse(opts, I, [this](Info const& M)
+            corpus_.traverse(opts, I, [this](Symbol const& M)
                 {
                     visit(M, *this);
                 });
@@ -194,7 +194,7 @@ class LegibleNames::Impl
     std::string
     getRawUnqualified(SymbolID const& id)
     {
-        Info const* I = corpus_.find(id);
+        Symbol const* I = corpus_.find(id);
         MRDOCS_ASSERT(I);
         return getRawUnqualified(*I);
     }
@@ -202,7 +202,7 @@ class LegibleNames::Impl
     /* @copydoc getRawUnqualified(SymbolID const&)
      */
     std::string
-    getRawUnqualified(Info const& I)
+    getRawUnqualified(Symbol const& I)
     {
         MRDOCS_ASSERT(I.id && I.id != SymbolID::global);
         if (I.Name.empty())
@@ -239,19 +239,18 @@ class LegibleNames::Impl
     /* Take the raw unqualified name for a symbol and build a legible name
      */
     void
-    buildLegibleMember(
-        Info const& I,
+    buildLegibleMember(Symbol const& I,
         std::string_view rawName)
     {
         // Generate the legible name information for this symbol
         auto const idAsString = toBase16(I.id, true);
-        LegibleNameInfo LI(std::string(rawName), 0, idAsString);
-        LegibleNameInfo& info = map_.emplace(I.id, std::move(LI)).first->second;
+        LegibleName LI(std::string(rawName), 0, idAsString);
+        LegibleName& info = map_.emplace(I.id, std::move(LI)).first->second;
 
         // Look for symbols with the same unqualified name
         auto [first, last] = disambiguation_map_.equal_range(rawName);
-        auto sameNameInfos = std::ranges::subrange(first, last) | std::views::values;
-        if (std::ranges::empty(sameNameInfos))
+        auto sameNames = std::ranges::subrange(first, last) | std::views::values;
+        if (std::ranges::empty(sameNames))
         {
             // Add this symbol to the disambiguation map
             disambiguation_map_.emplace(rawName, &info);
@@ -263,7 +262,7 @@ class LegibleNames::Impl
         // Iterate over the other symbols with the same raw unqualified name
         // and update their legible name information
         std::uint8_t suffix_size_required = 0;
-        for (LegibleNameInfo* other : sameNameInfos)
+        for (LegibleName* other : sameNames)
         {
             // Find the first character that differs between the two symbol IDs
             auto const mismatch_it = std::ranges::mismatch(
@@ -380,4 +379,4 @@ getQualified(
     return result;
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Support/LegibleNames.hpp b/src/lib/Support/LegibleNames.hpp
index 1dd9c043c..1bd7babac 100644
--- a/src/lib/Support/LegibleNames.hpp
+++ b/src/lib/Support/LegibleNames.hpp
@@ -13,11 +13,11 @@
 #define MRDOCS_LIB_SUPPORT_LEGIBLENAMES_HPP
 
 #include <mrdocs/Corpus.hpp>
-#include <mrdocs/Metadata/Info/SymbolID.hpp>
+#include <mrdocs/Metadata/Symbol/SymbolID.hpp>
 #include <memory>
 #include <string>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 /** A table mapping Info objects to legible names.
 
@@ -61,6 +61,6 @@ class LegibleNames
         char delim = '-') const;
 };
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/src/lib/Support/Path.cpp b/src/lib/Support/Path.cpp
index f0c7d5f90..38fc0adbf 100644
--- a/src/lib/Support/Path.cpp
+++ b/src/lib/Support/Path.cpp
@@ -17,7 +17,7 @@
 #include <llvm/Support/Path.h>
 #include <fstream>
 
-namespace clang {
+
 namespace mrdocs {
 
 AnyFileVisitor::
@@ -561,4 +561,3 @@ error() const
 }
 
 } // mrdocs
-} // clang
\ No newline at end of file
diff --git a/src/lib/Support/Path.hpp b/src/lib/Support/Path.hpp
index 9e17725eb..9781402c3 100644
--- a/src/lib/Support/Path.hpp
+++ b/src/lib/Support/Path.hpp
@@ -18,7 +18,7 @@
 #include <llvm/ADT/StringRef.h>
 #include <llvm/Support/Path.h>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** A reasonably sized small string for paths.
@@ -45,7 +45,7 @@ convert_to_slash(
 */
 class ScopedTempFile
 {
-    clang::mrdocs::SmallPathString path_;
+    mrdocs::SmallPathString path_;
     bool ok_ = false;
 public:
     /** Destructor
@@ -93,7 +93,7 @@ class ScopedTempDirectory
         CannotCreateDirectories
     };
 
-    clang::mrdocs::SmallPathString path_;
+    mrdocs::SmallPathString path_;
     ErrorStatus status_ = ErrorStatus::None;
 public:
     /** Destructor
@@ -164,6 +164,6 @@ class ScopedTempDirectory
 };
 
 } // mrdocs
-} // clang
+
 
 #endif
diff --git a/src/lib/Support/Radix.cpp b/src/lib/Support/Radix.cpp
index 7f656ef0d..26ddf1915 100644
--- a/src/lib/Support/Radix.cpp
+++ b/src/lib/Support/Radix.cpp
@@ -16,7 +16,7 @@
 #include <algorithm>
 #include <vector>
 
-namespace clang {
+
 namespace mrdocs {
 
 namespace {
@@ -329,4 +329,4 @@ toBase16(
 }
 
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Support/Radix.hpp b/src/lib/Support/Radix.hpp
index a8347e3fc..36406d7b7 100644
--- a/src/lib/Support/Radix.hpp
+++ b/src/lib/Support/Radix.hpp
@@ -20,7 +20,7 @@
 #include <string>
 #include <string_view>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 std::string
 toBase64(std::string_view str);
@@ -42,6 +42,6 @@ toBase16(
     std::string_view str,
     bool lowercase = false);
 
-} // clang::mrdocs
+} // mrdocs
 
 #endif
diff --git a/src/lib/Support/RawOstream.hpp b/src/lib/Support/RawOstream.hpp
index 2001193e1..230af79a3 100644
--- a/src/lib/Support/RawOstream.hpp
+++ b/src/lib/Support/RawOstream.hpp
@@ -14,7 +14,7 @@
 #include <llvm/Support/raw_ostream.h>
 #include <ostream>
 
-namespace clang {
+
 namespace mrdocs {
 
 class RawOstream : public llvm::raw_ostream
@@ -51,6 +51,6 @@ class RawOstream : public llvm::raw_ostream
 };
 
 } // mrdocs
-} // clang
+
 
 #endif
diff --git a/src/lib/Support/Report.cpp b/src/lib/Support/Report.cpp
index 24c1d4cde..4c31ad886 100644
--- a/src/lib/Support/Report.cpp
+++ b/src/lib/Support/Report.cpp
@@ -33,7 +33,7 @@ namespace SourceFileNames {
 extern char const* getFileName(char const*) noexcept;
 } // SourceFileNames
 
-namespace clang {
+
 namespace mrdocs {
 
 //------------------------------------------------
@@ -337,4 +337,4 @@ call_impl(
 } // report
 
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Support/Report.hpp b/src/lib/Support/Report.hpp
index ab49e4dc0..39afcbddf 100644
--- a/src/lib/Support/Report.hpp
+++ b/src/lib/Support/Report.hpp
@@ -20,7 +20,7 @@
 #include <ostream>
 #include <utility>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 namespace report {
 
@@ -128,7 +128,7 @@ call(
 
 } // report
 
-} // clang::mrdocs
+} // mrdocs
 
 template <>
 struct std::formatter<llvm::StringRef> : std::formatter<std::string_view> {
diff --git a/src/lib/Support/String.cpp b/src/lib/Support/String.cpp
index 8959faced..479146049 100644
--- a/src/lib/Support/String.cpp
+++ b/src/lib/Support/String.cpp
@@ -10,7 +10,7 @@
 
 #include <mrdocs/Support/String.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 void
 replace(std::string& s, std::string_view from, std::string_view to)
@@ -25,4 +25,4 @@ replace(std::string& s, std::string_view from, std::string_view to)
     }
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/lib/Support/ThreadPool.cpp b/src/lib/Support/ThreadPool.cpp
index 07a962e55..191397624 100644
--- a/src/lib/Support/ThreadPool.cpp
+++ b/src/lib/Support/ThreadPool.cpp
@@ -16,7 +16,7 @@
 #include <unordered_set>
 #include <utility>
 
-namespace clang {
+
 namespace mrdocs {
 
 //------------------------------------------------
@@ -185,4 +185,4 @@ post(
 }
 
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Support/Validate.cpp b/src/lib/Support/Validate.cpp
index c910e97e4..c623226e6 100644
--- a/src/lib/Support/Validate.cpp
+++ b/src/lib/Support/Validate.cpp
@@ -12,7 +12,7 @@
 #include "Validate.hpp"
 #include <cctype>
 
-namespace clang {
+
 namespace mrdocs {
 
 bool
@@ -34,4 +34,4 @@ validAdocSectionID(
 }
 
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Support/Validate.hpp b/src/lib/Support/Validate.hpp
index 4b7c9cb74..0c124f873 100644
--- a/src/lib/Support/Validate.hpp
+++ b/src/lib/Support/Validate.hpp
@@ -20,7 +20,7 @@
     as Asciidoc section identifiers or XML attributes.
 */
 
-namespace clang {
+
 namespace mrdocs {
 
 /** Return true if s is a valid Asciidoc section ID.
@@ -30,6 +30,6 @@ validAdocSectionID(
     llvm::StringRef s) noexcept;
 
 } // mrdocs
-} // clang
+
 
 #endif
diff --git a/src/lib/Support/Yaml.cpp b/src/lib/Support/Yaml.cpp
index 958a28068..4c8a2ef95 100644
--- a/src/lib/Support/Yaml.cpp
+++ b/src/lib/Support/Yaml.cpp
@@ -12,7 +12,7 @@
 #include <lib/Support/Report.hpp>
 #include <lib/Support/Yaml.hpp>
 
-namespace clang {
+
 namespace mrdocs {
 
 void YamlReporter::diag(llvm::SMDiagnostic const &D, void *) {
@@ -45,4 +45,4 @@ void YamlReporter::diag(llvm::SMDiagnostic const &D, void *) {
 }
 
 } // mrdocs
-} // clang
+
diff --git a/src/lib/Support/Yaml.hpp b/src/lib/Support/Yaml.hpp
index c00b93223..3431a79b2 100644
--- a/src/lib/Support/Yaml.hpp
+++ b/src/lib/Support/Yaml.hpp
@@ -15,7 +15,7 @@
 #include <mrdocs/Platform.hpp>
 #include <llvm/Support/YAMLTraits.h>
 
-namespace clang {
+
 namespace mrdocs {
 
 class MRDOCS_DECL
@@ -30,6 +30,6 @@ class MRDOCS_DECL
 };
 
 } // mrdocs
-} // clang
+
 
 #endif
diff --git a/src/lib/clang.natvis b/src/lib/clang.natvis
index 0f3cc7c9c..85022670b 100644
--- a/src/lib/clang.natvis
+++ b/src/lib/clang.natvis
@@ -316,8 +316,8 @@ For later versions of Visual Studio, no setup is required-->
     <Type Name="clang::DeclarationName">
         <Intrinsic Category="Data" Name="get_ptr" Expression="(void*)(Ptr &amp; ~PtrMask)"/>
         <Intrinsic Category="Data" Name="get_stored_kind" Expression="Ptr &amp; PtrMask"/>
-        <Intrinsic Category="Data" Name="get_name_kind" Expression="(NameKind)(get_stored_kind() != StoredDeclarationNameExtra ?
-            get_stored_kind() : UncommonNameKindOffset + ((detail::DeclarationNameExtra*)get_ptr())-&gt;get_kind())"/>
+        <Intrinsic Category="Data" Name="get_name_kind" Expression="(Name)(get_stored_kind() != StoredDeclarationNameExtra ?
+            get_stored_kind() : UncommonNameOffset + ((detail::DeclarationNameExtra*)get_ptr())-&gt;get_kind())"/>
 
         <DisplayString Condition="! Ptr"></DisplayString>
         <DisplayString Condition="get_stored_kind() == StoredIdentifier">{*(IdentifierInfo*)get_ptr(),na}</DisplayString>
@@ -335,7 +335,7 @@ For later versions of Visual Studio, no setup is required-->
 
         <Expand>
             <Item Name="Kind">get_name_kind(),en</Item>
-            <Item Name="StoredKind">StoredNameKind(get_stored_kind()),en</Item>
+            <Item Name="StoredKind">StoredName(get_stored_kind()),en</Item>
 
             <Item Name="[identifier]" Condition="get_stored_kind() == StoredIdentifier">*(IdentifierInfo*)get_ptr(),na</Item>
             <Item Name="[selector]" Condition="get_stored_kind() == StoredObjCZeroArgSelector">*(IdentifierInfo*)get_ptr(),na</Item>
@@ -402,7 +402,7 @@ For later versions of Visual Studio, no setup is required-->
         </Expand>
     </Type>
 
-    <Type Name="clang::DeclarationNameInfo">
+    <Type Name="clang::DeclarationName">
         <DisplayString>{Name}</DisplayString>
     </Type>
 
@@ -1141,16 +1141,16 @@ For later versions of Visual Studio, no setup is required-->
         <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::ObjCProperty">(ObjCPropertyDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::BuiltinTemplate">(BuiltinTemplateDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::Concept">(ConceptDecl*)this</MostDerivedType>
-        <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::ClassTemplate">(ClassTemplateDecl*)this</MostDerivedType>
+        <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::ClassTemplate">(clang::ClassTemplateDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::FunctionTemplate">(FunctionTemplateDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::TypeAliasTemplate">(TypeAliasTemplateDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::VarTemplate">(VarTemplateDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::TemplateTemplateParm">(TemplateTemplateParmDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::Enum">(EnumDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::Record">(RecordDecl*)this</MostDerivedType>
-        <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::CXXRecord">(CXXRecordDecl*)this</MostDerivedType>
+        <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::CXXRecord">(clang::CXXRecordDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::ClassTemplateSpecialization">(ClassTemplateSpecializationDecl*)this</MostDerivedType>
-        <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::ClassTemplatePartialSpecialization">(ClassTemplatePartialSpecializationDecl*)this</MostDerivedType>
+        <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::ClassTemplatePartialSpecialization">(clang::ClassTemplatePartialSpecializationDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::TemplateTypeParm">(TemplateTypeParmDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::ObjCTypeParam">(ObjCTypeParamDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::TypeAlias">(TypeAliasDecl*)this</MostDerivedType>
@@ -1165,7 +1165,7 @@ For later versions of Visual Studio, no setup is required-->
         <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::Field">(FieldDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::ObjCAtDefsField">(ObjCAtDefsFieldDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::ObjCIvar">(ObjCIvarDecl*)this</MostDerivedType>
-        <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::Function">(FunctionDecl*)this</MostDerivedType>
+        <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::Function">(clang::FunctionDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::CXXDeductionGuide">(CXXDeductionGuideDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::CXXMethod">(CXXMethodDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclKind == Decl::CXXConstructor">(CXXConstructorDecl*)this</MostDerivedType>
@@ -1226,7 +1226,7 @@ For later versions of Visual Studio, no setup is required-->
     </Type>
 
     <Type Name="clang::DeclContext">
-        <MostDerivedType Condition="(Decl::Kind)DeclContextBits.DeclKind == Decl::Function">(FunctionDecl*)this</MostDerivedType>
+        <MostDerivedType Condition="(Decl::Kind)DeclContextBits.DeclKind == Decl::Function">(clang::FunctionDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclContextBits.DeclKind == Decl::CXXDeductionGuide">(CXXDeductionGuideDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclContextBits.DeclKind == Decl::CXXMethod">(CXXMethodDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclContextBits.DeclKind == Decl::CXXConstructor">(CXXConstructorDecl*)this</MostDerivedType>
@@ -1234,9 +1234,9 @@ For later versions of Visual Studio, no setup is required-->
         <MostDerivedType Condition="(Decl::Kind)DeclContextBits.DeclKind == Decl::CXXDestructor">(CXXDestructorDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclContextBits.DeclKind == Decl::Enum">(EnumDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclContextBits.DeclKind == Decl::Record">(RecordDecl*)this</MostDerivedType>
-        <MostDerivedType Condition="(Decl::Kind)DeclContextBits.DeclKind == Decl::CXXRecord">(CXXRecordDecl*)this</MostDerivedType>
+        <MostDerivedType Condition="(Decl::Kind)DeclContextBits.DeclKind == Decl::CXXRecord">(clang::CXXRecordDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclContextBits.DeclKind == Decl::ClassTemplateSpecialization">(ClassTemplateSpecializationDecl*)this</MostDerivedType>
-        <MostDerivedType Condition="(Decl::Kind)DeclContextBits.DeclKind == Decl::ClassTemplatePartialSpecialization">(ClassTemplatePartialSpecializationDecl*)this</MostDerivedType>
+        <MostDerivedType Condition="(Decl::Kind)DeclContextBits.DeclKind == Decl::ClassTemplatePartialSpecialization">(clang::ClassTemplatePartialSpecializationDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclContextBits.DeclKind == Decl::Block">(BlockDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclContextBits.DeclKind == Decl::Captured">(CapturedDecl*)this</MostDerivedType>
         <MostDerivedType Condition="(Decl::Kind)DeclContextBits.DeclKind == Decl::TranslationUnit">(TranslationUnitDecl*)this</MostDerivedType>
@@ -1418,7 +1418,7 @@ For later versions of Visual Studio, no setup is required-->
         </Expand>
     </Type>
 
-    <Type Name="clang::FunctionDecl" Inheritable="false">
+    <Type Name="clang::clang::FunctionDecl" Inheritable="false">
         <AlternativeType Name="clang::CXXMethodDecl" Inheritable="false" />
         <AlternativeType Name="clang::CXXConstructorDecl" Inheritable="false" />
         <AlternativeType Name="clang::CXXConversionDecl" Inheritable="false" />
@@ -1432,19 +1432,19 @@ For later versions of Visual Studio, no setup is required-->
             <Item Name="Qualifier" Condition="get_qualifier()">get_qualifier(),na</Item>
 
             <Item Name="IsDefinition">
-                (FunctionDeclBits.IsDeleted &amp;&amp; ! FunctionDeclBits.IsDefaulted) ||
-                ((! FunctionDeclBits.HasDefaultedFunctionInfo &amp;&amp; Body.Ptr) || FunctionDeclBits.IsLateTemplateParsed) ||
-                FunctionDeclBits.HasSkippedBody ||
-                FunctionDeclBits.WillHaveBody
+                (clang::FunctionDeclBits.IsDeleted &amp;&amp; ! clang::FunctionDeclBits.IsDefaulted) ||
+                ((! clang::FunctionDeclBits.HasDefaultedFunctionSymbol &amp;&amp; Body.Ptr) || clang::FunctionDeclBits.IsLateTemplateParsed) ||
+                clang::FunctionDeclBits.HasSkippedBody ||
+                clang::FunctionDeclBits.WillHaveBody
             </Item>
             <!--
             <Synthetic Name="[definition]">
                 <Expand>
                     <Item Name="IsDefinition">
-                        (FunctionDeclBits.IsDeleted &amp;&amp; ! FunctionDeclBits.IsDefaulted) ||
-                        ((! FunctionDeclBits.HasDefaultedFunctionInfo &amp;&amp; Body.Ptr) || FunctionDeclBits.IsLateTemplateParsed) ||
-                        FunctionDeclBits.HasSkippedBody ||
-                        FunctionDeclBits.WillHaveBody
+                        (clang::FunctionDeclBits.IsDeleted &amp;&amp; ! clang::FunctionDeclBits.IsDefaulted) ||
+                        ((! clang::FunctionDeclBits.HasDefaultedFunctionSymbol &amp;&amp; Body.Ptr) || clang::FunctionDeclBits.IsLateTemplateParsed) ||
+                        clang::FunctionDeclBits.HasSkippedBody ||
+                        clang::FunctionDeclBits.WillHaveBody
                     </Item>
                 </Expand>
             </Synthetic>
@@ -1458,11 +1458,11 @@ For later versions of Visual Studio, no setup is required-->
             <Item Name="InstantiatedFrom" Condition="! TemplateOrSpecialization.is_null() &amp;&amp;
                 TemplateOrSpecialization.get_int() == 0 &amp;&amp;
                     ((NamedDecl*)TemplateOrSpecialization.get_ptr())-&gt;get_kind() == Decl::Function">
-                        (FunctionDecl*)TemplateOrSpecialization.get_ptr()
+                        (clang::FunctionDecl*)TemplateOrSpecialization.get_ptr()
             </Item>
 
             <Item Name="MemberSpecialization" Condition="! TemplateOrSpecialization.is_null() &amp;&amp; TemplateOrSpecialization.get_int() == 1">
-                (MemberSpecializationInfo*)TemplateOrSpecialization.get_ptr(),na
+                (clang::MemberSpecializationInfo*)TemplateOrSpecialization.get_ptr(),na
             </Item>
 
             <Item Name="TemplateSpecialization" Condition="! TemplateOrSpecialization.is_null() &amp;&amp; TemplateOrSpecialization.get_int() == 2">
@@ -1491,7 +1491,7 @@ For later versions of Visual Studio, no setup is required-->
 
     <!-- ================================================================================================ -->
 
-    <Type Name="clang::ClassTemplateDecl::Common">
+    <Type Name="clang::clang::ClassTemplateDecl::Common">
         <Expand>
             <ExpandedItem>*(RedeclarableTemplateDecl::CommonBase*)this,nd</ExpandedItem>
             <Item Name="InjectedClassNameType">InjectedClassNameType</Item>
@@ -1511,7 +1511,7 @@ For later versions of Visual Studio, no setup is required-->
                 <Expand>
                     <ArrayItems>
                         <Size>(size_t)PartialSpecializations.Vector.Size</Size>
-                        <ValuePointer>(ClassTemplatePartialSpecializationDecl**)PartialSpecializations.Vector.BeginX</ValuePointer>
+                        <ValuePointer>(clang::ClassTemplatePartialSpecializationDecl**)PartialSpecializations.Vector.BeginX</ValuePointer>
                     </ArrayItems>
                 </Expand>
             </Synthetic>
@@ -1640,7 +1640,7 @@ For later versions of Visual Studio, no setup is required-->
                     <Exec>common = decl ? decl-&gt;Common : nullptr</Exec>
                 </Loop>
                 <If Condition="common">
-                    <Item Condition="get_kind() == Decl::ClassTemplate" Name="[common base]">(ClassTemplateDecl::Common*)common</Item>
+                    <Item Condition="get_kind() == Decl::ClassTemplate" Name="[common base]">(clang::ClassTemplateDecl::Common*)common</Item>
                     <Item Condition="get_kind() == Decl::VarTemplate" Name="[common base]">(VarTemplateDecl::Common*)common</Item>
                     <Item Condition="get_kind() == Decl::FunctionTemplate" Name="[common base]">(FunctionTemplateDecl::Common*)common</Item>
                     <Item Condition="get_kind() == Decl::TypeAliasTemplate" Name="[common base]">(TypeAliasTemplateDecl::Common*)common</Item>
@@ -1648,7 +1648,7 @@ For later versions of Visual Studio, no setup is required-->
             </CustomListItems>
             -->
             <ExpandedItem Condition="get_common_ptr() != nullptr &amp;&amp; get_kind() == Decl::ClassTemplate">
-                *(ClassTemplateDecl::Common*)get_common_ptr()
+                *(clang::ClassTemplateDecl::Common*)get_common_ptr()
             </ExpandedItem>
             <ExpandedItem Condition="get_common_ptr() != nullptr &amp;&amp; get_kind() == Decl::VarTemplate">
                 *(VarTemplateDecl::Common*)get_common_ptr()
@@ -1687,7 +1687,7 @@ For later versions of Visual Studio, no setup is required-->
             <Item Name="SpecializationKind">clang::TemplateSpecializationKind(Template.get_int() + 1),en</Item>
             <Item Name="IsMemberSpecialization">Function.get_int()</Item>
             <Item Name="InstantiatedFromMember" Condition="Function.get_int()">
-                *reinterpret_cast&lt;MemberSpecializationInfo**&gt;(this + 1)
+                *reinterpret_cast&lt;clang::MemberSpecializationInfo**&gt;(this + 1)
             </Item>
             <Item Name="Function" Condition="! Function.is_null()">Function.get_ptr()</Item>
             <Item Name="Template" Condition="! Template.is_null()">Template.get_ptr()</Item>
@@ -1707,7 +1707,7 @@ For later versions of Visual Studio, no setup is required-->
 
     <!-- ================================================================================================ -->
 
-    <Type Name="clang::MemberSpecializationInfo">
+    <Type Name="clang::clang::MemberSpecializationInfo">
         <Expand>
             <Item Name="SpecializationKind">clang::TemplateSpecializationKind(MemberAndTSK.get_int() + 1),en</Item>
             <Item Name="InstantiatedFrom" Condition="! MemberAndTSK.is_null()">
@@ -1743,7 +1743,7 @@ For later versions of Visual Studio, no setup is required-->
             <!-- KRYSTIAN TODO: this is stored in a DenseMap in ASTContext...
             <Item Name="SpecializationKind" Condition="! is_vtsd() &amp;&amp; ! TemplateOrInstantiation.is_null() &amp;&amp; TemplateOrInstantiation.get_int() == 1">
                 clang::TemplateSpecializationKind(
-                    ((MemberSpecializationInfo*)TemplateOrInstantiation.get_ptr())-&gt;MemberAndTSK.get_int() + 1),en
+                    ((clang::MemberSpecializationInfo*)TemplateOrInstantiation.get_ptr())-&gt;MemberAndTSK.get_int() + 1),en
             </Item>
             -->
 
@@ -1752,7 +1752,7 @@ For later versions of Visual Studio, no setup is required-->
                 (VarTemplateDecl*)TemplateOrInstantiation.get_ptr()
             </Item>
             <Item Name="MemberSpecialization" Condition="! TemplateOrInstantiation.is_null() &amp;&amp; TemplateOrInstantiation.get_int() == 1">
-                (MemberSpecializationInfo*)TemplateOrInstantiation.get_ptr()
+                (clang::MemberSpecializationInfo*)TemplateOrInstantiation.get_ptr()
             </Item>
             -->
 
@@ -1785,11 +1785,11 @@ For later versions of Visual Studio, no setup is required-->
 
     <!-- ================================================================================================ -->
 
-    <Type Name="clang::CXXRecordDecl" Inheritable="false" >
-        <AlternativeType Name="clang::ClassTemplatePartialSpecializationDecl" Inheritable="false" />
+    <Type Name="clang::clang::CXXRecordDecl" Inheritable="false" >
+        <AlternativeType Name="clang::clang::ClassTemplatePartialSpecializationDecl" Inheritable="false" />
         <AlternativeType Name="clang::ClassTemplateSpecializationDecl" Inheritable="false" />
         <Intrinsic Category="Data" Name="is_ctpsd" Expression="get_kind() == Decl::ClassTemplatePartialSpecialization" />
-        <Intrinsic Category="Data" Name="as_ctpsd" Expression="(ClassTemplatePartialSpecializationDecl*)this" />
+        <Intrinsic Category="Data" Name="as_ctpsd" Expression="(clang::ClassTemplatePartialSpecializationDecl*)this" />
         <Intrinsic Category="Data" Name="is_ctsd" Expression="get_kind() == Decl::ClassTemplateSpecialization || is_ctpsd()" />
         <Intrinsic Category="Data" Name="as_ctsd" Expression="(ClassTemplateSpecializationDecl*)this" />
 
@@ -1807,14 +1807,14 @@ For later versions of Visual Studio, no setup is required-->
             </Item>
             <Item Name="SpecializationKind" Condition="! is_ctsd() &amp;&amp; ! TemplateOrInstantiation.is_null() &amp;&amp; TemplateOrInstantiation.get_int() == 1">
                 clang::TemplateSpecializationKind(
-                    ((MemberSpecializationInfo*)TemplateOrInstantiation.get_ptr())-&gt;MemberAndTSK.get_int() + 1),en
+                    ((clang::MemberSpecializationInfo*)TemplateOrInstantiation.get_ptr())-&gt;MemberAndTSK.get_int() + 1),en
             </Item>
 
             <Item Name="DescribedTemplate" Condition="! TemplateOrInstantiation.is_null() &amp;&amp; TemplateOrInstantiation.get_int() == 0">
-                (ClassTemplateDecl*)TemplateOrInstantiation.get_ptr()
+                (clang::ClassTemplateDecl*)TemplateOrInstantiation.get_ptr()
             </Item>
             <Item Name="MemberSpecialization" Condition="! TemplateOrInstantiation.is_null() &amp;&amp; TemplateOrInstantiation.get_int() == 1">
-                (MemberSpecializationInfo*)TemplateOrInstantiation.get_ptr(),na
+                (clang::MemberSpecializationInfo*)TemplateOrInstantiation.get_ptr(),na
             </Item>
 
             <Item Name="IsMemberSpecialization" Optional="true">InstantiatedFromMember.get_int()</Item>
@@ -1823,7 +1823,7 @@ For later versions of Visual Studio, no setup is required-->
             </Item>
 
             <Item Name="SpecializedTemplate" Optional="true" Condition="SpecializedTemplate.get_int() == 0">
-                (ClassTemplateDecl*)SpecializedTemplate.get_ptr()
+                (clang::ClassTemplateDecl*)SpecializedTemplate.get_ptr()
             </Item>
             <Item Name="SpecializedPartial" Optional="true" Condition="SpecializedTemplate.get_int() == 1">
                 ((ClassTemplateSpecializationDecl::SpecializedPartialSpecialization*)(SpecializedTemplate.get_ptr()))-&gt;PartialSpecialization
@@ -1856,22 +1856,22 @@ For later versions of Visual Studio, no setup is required-->
     <!--
 
   <Type Name="clang::CXXMethodDecl">
-    <DisplayString IncludeView="cpp">{*(clang::FunctionDecl *)this,nd}</DisplayString>
+    <DisplayString IncludeView="cpp">{*(clang::clang::FunctionDecl *)this,nd}</DisplayString>
     <DisplayString>Method {{{*this,view(cpp)}}}</DisplayString>
     <Expand>
-      <ExpandedItem>*(FunctionDecl*)this,nd</ExpandedItem>
+      <ExpandedItem>*(clang::FunctionDecl*)this,nd</ExpandedItem>
     </Expand>
   </Type>
   <Type Name="clang::CXXConstructorDecl">
-    <DisplayString>Constructor {{{Name,view(cpp)}({*(clang::FunctionDecl *)this,view(parm0)nd})}}</DisplayString>
+    <DisplayString>Constructor {{{Name,view(cpp)}({*(clang::clang::FunctionDecl *)this,view(parm0)nd})}}</DisplayString>
     <Expand>
-      <ExpandedItem>*(FunctionDecl*)this,nd</ExpandedItem>
+      <ExpandedItem>*(clang::FunctionDecl*)this,nd</ExpandedItem>
     </Expand>
   </Type>
   <Type Name="clang::CXXDestructorDecl">
     <DisplayString>Destructor {{~{Name,view(cpp)}()}}</DisplayString>
     <Expand>
-      <ExpandedItem>*(FunctionDecl*)this,nd</ExpandedItem>
+      <ExpandedItem>*(clang::FunctionDecl*)this,nd</ExpandedItem>
     </Expand>
   </Type>
   <Type Name="clang::TemplateTypeParmDecl">
@@ -1965,11 +1965,11 @@ For later versions of Visual Studio, no setup is required-->
     <DisplayString>{ExplicitSpec,view(int)en} : {ExplicitSpec,view(ptr)na}</DisplayString>
   </Type>
   <Type Name="clang::CXXDeductionGuideDecl">
-    <DisplayString>{ExplicitSpec,view(cpp)}{Name,view(cpp)nd}({(FunctionDecl*)this,view(parm0)nand}) -&gt; {((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)->ResultType,view(cpp)}</DisplayString>
+    <DisplayString>{ExplicitSpec,view(cpp)}{Name,view(cpp)nd}({(clang::FunctionDecl*)this,view(parm0)nand}) -&gt; {((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)->ResultType,view(cpp)}</DisplayString>
     <Expand>
       <Item Name="ExplicitSpec">ExplicitSpec</Item>
-      <Item Name="IsCopyDeductionCandidate">(bool)FunctionDeclBits.IsCopyDeductionCandidate</Item>
-      <ExpandedItem>(FunctionDecl*)this,nd</ExpandedItem>
+      <Item Name="IsCopyDeductionCandidate">(bool)clang::FunctionDeclBits.IsCopyDeductionCandidate</Item>
+      <ExpandedItem>(clang::FunctionDecl*)this,nd</ExpandedItem>
     </Expand>
   </Type>
 
@@ -1990,7 +1990,7 @@ For later versions of Visual Studio, no setup is required-->
     </Expand>
   </Type>
 
-  <Type Name="clang::FunctionDecl">
+  <Type Name="clang::clang::FunctionDecl">
     <DisplayString IncludeView="retType">{((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)((*(uintptr_t *)DeclType.Value.Value.Data) &amp; ~15))-&gt;BaseType)->ResultType,view(cpp)}</DisplayString>
     <DisplayString IncludeView="parm0" Condition="0 == ((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)((*(uintptr_t *)DeclType.Value.Value.Data) &amp; ~15))-&gt;BaseType)-&gt;FunctionTypeBits.NumParams"></DisplayString>
     <DisplayString IncludeView="parm0">{ParamInfo[0],na}{*this,view(parm1)nd}</DisplayString>
@@ -2010,7 +2010,7 @@ For later versions of Visual Studio, no setup is required-->
     <DisplayString>{this,view(retType)nand} {Name,view(cpp)nd}({*this,view(parm0)nd})</DisplayString>
     <Expand>
       <ExpandedItem>(clang::DeclaratorDecl *)this,nd</ExpandedItem>
-      <ExpandedItem>(clang::Redeclarable&lt;clang::FunctionDecl&gt; *)this,nd</ExpandedItem>
+      <ExpandedItem>(clang::Redeclarable&lt;clang::clang::FunctionDecl&gt; *)this,nd</ExpandedItem>
       <Item Name="ReturnType">((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)((*(uintptr_t *)DeclType.Value.Value.Data) &amp; ~15))-&gt;BaseType)->ResultType</Item>
       <Synthetic Name="Parameter Types">
         <DisplayString>{*this,view(parm0)nd}</DisplayString>
diff --git a/src/test/ADT/Nullable.cpp b/src/test/ADT/Nullable.cpp
index fe4ed346d..54976aa1e 100644
--- a/src/test/ADT/Nullable.cpp
+++ b/src/test/ADT/Nullable.cpp
@@ -15,7 +15,7 @@
 #include <vector>
 #include <test_suite/test_suite.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 struct NullableTest {
     // Types for testing
@@ -236,4 +236,4 @@ struct NullableTest {
 
 TEST_SUITE(NullableTest, "clang.mrdocs.ADT.Nullable");
 
-} // namespace clang::mrdocs
+} // namespace mrdocs
diff --git a/src/test/ADT/Optional.cpp b/src/test/ADT/Optional.cpp
index 8228f85f6..59c7e8c1c 100644
--- a/src/test/ADT/Optional.cpp
+++ b/src/test/ADT/Optional.cpp
@@ -9,12 +9,12 @@
 //
 
 #include <mrdocs/ADT/Optional.hpp>
-#include <mrdocs/Metadata/Info/Source.hpp>
+#include <mrdocs/Metadata/Symbol/Source.hpp>
 #include <optional>
 #include <type_traits>
 #include <test_suite/test_suite.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 struct OptionalTest {
     // A fallback-only payload type (no sentinel, no empty()/clear()).
@@ -337,4 +337,4 @@ struct OptionalTest {
 
 TEST_SUITE(OptionalTest, "clang.mrdocs.ADT.Optional");
 
-} // namespace clang::mrdocs
+} // namespace mrdocs
diff --git a/src/test/ADT/Polymorphic.cpp b/src/test/ADT/Polymorphic.cpp
index 21fd36e7d..50d6b5451 100644
--- a/src/test/ADT/Polymorphic.cpp
+++ b/src/test/ADT/Polymorphic.cpp
@@ -11,7 +11,7 @@
 #include <mrdocs/ADT/Polymorphic.hpp>
 #include <test_suite/test_suite.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 struct X {
     virtual ~X() = default;
@@ -332,5 +332,5 @@ TEST_SUITE(
     Polymorphic_test,
     "clang.mrdocs.ADT.Polymorphic");
 
-} // clang::mrdocs
+} // mrdocs
 
diff --git a/src/test/Support/Expected.cpp b/src/test/Support/Expected.cpp
index b633a90b3..1bd5ba439 100644
--- a/src/test/Support/Expected.cpp
+++ b/src/test/Support/Expected.cpp
@@ -22,7 +22,7 @@
 #include <utility>
 #include <test_suite/test_suite.hpp>
 
-namespace clang {
+
 namespace mrdocs {
 
 struct ExpectedTest
@@ -474,4 +474,4 @@ TEST_SUITE(
     "clang.mrdocs.Expected");
 
 } // mrdocs
-} // clang
+
diff --git a/src/test/Support/Glob.cpp b/src/test/Support/Glob.cpp
index be83be4fd..51979f302 100644
--- a/src/test/Support/Glob.cpp
+++ b/src/test/Support/Glob.cpp
@@ -11,7 +11,7 @@
 #include <mrdocs/Support/Glob.hpp>
 #include <test_suite/test_suite.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 struct Glob_test
 {
@@ -609,5 +609,5 @@ TEST_SUITE(
     Glob_test,
     "clang.mrdocs.Glob");
 
-} // clang::mrdocs
+} // mrdocs
 
diff --git a/src/test/Support/JavaScript.cpp b/src/test/Support/JavaScript.cpp
index 369b0609a..ab2edbf15 100644
--- a/src/test/Support/JavaScript.cpp
+++ b/src/test/Support/JavaScript.cpp
@@ -13,7 +13,7 @@
 #include <array>
 #include <test_suite/test_suite.hpp>
 
-namespace clang {
+
 namespace mrdocs {
 namespace js {
 
@@ -1306,5 +1306,5 @@ TEST_SUITE(
 
 } // js
 } // mrdocs
-} // clang
+
 
diff --git a/src/test/TestArgs.cpp b/src/test/TestArgs.cpp
index 067616748..44e33bf59 100644
--- a/src/test/TestArgs.cpp
+++ b/src/test/TestArgs.cpp
@@ -11,7 +11,7 @@
 #include "TestArgs.hpp"
 #include <vector>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 TestArgs TestArgs::instance_;
 
@@ -83,4 +83,4 @@ hideForeignOptions() const
     }
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/test/TestArgs.hpp b/src/test/TestArgs.hpp
index 9deb8cf39..d1480d4d8 100644
--- a/src/test/TestArgs.hpp
+++ b/src/test/TestArgs.hpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <tool/PublicToolArgs.hpp>
 
-namespace clang {
+
 namespace mrdocs {
 
 enum Action : int
@@ -54,6 +54,6 @@ class TestArgs : public PublicToolArgs
 constexpr static TestArgs& testArgs = TestArgs::instance_;
 
 } // mrdocs
-} // clang
+
 
 #endif
diff --git a/src/test/TestMain.cpp b/src/test/TestMain.cpp
index 4a144a6db..d74ef9b91 100644
--- a/src/test/TestMain.cpp
+++ b/src/test/TestMain.cpp
@@ -25,12 +25,12 @@
 
 int main(int argc, char const** argv);
 
-namespace clang {
+
 namespace mrdocs {
 
 void DoTestAction(char const** argv)
 {
-    using namespace clang::mrdocs;
+    using namespace mrdocs;
 
     std::vector<std::string> testPaths(
         testArgs.cmdLineInputs.begin(),
@@ -134,25 +134,25 @@ static void reportUnhandledException(
 #endif
 
 } // mrdocs
-} // clang
+
 
 int main(int argc, char const** argv)
 {
 #ifndef _NDEBUG
-    return clang::mrdocs::test_main(argc, argv);
+    return mrdocs::test_main(argc, argv);
 #else
     try
     {
-        return clang::mrdocs::test_main(argc, argv);
+        return mrdocs::test_main(argc, argv);
     }
-    catch(clang::mrdocs::Exception const& ex)
+    catch(mrdocs::Exception const& ex)
     {
         // thrown Exception should never get here.
-        clang::mrdocs::reportUnhandledException(ex);
+        mrdocs::reportUnhandledException(ex);
     }
     catch(std::exception const& ex)
     {
-        clang::mrdocs::reportUnhandledException(ex);
+        mrdocs::reportUnhandledException(ex);
     }
     return EXIT_FAILURE;
 #endif
diff --git a/src/test/TestRunner.cpp b/src/test/TestRunner.cpp
index 9c2785f97..150e93cae 100644
--- a/src/test/TestRunner.cpp
+++ b/src/test/TestRunner.cpp
@@ -30,7 +30,7 @@
 #include <iostream>
 #include <test_suite/diff.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 TestRunner::
 TestRunner(std::string_view generator)
@@ -394,4 +394,4 @@ checkPath(
     }
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/test/TestRunner.hpp b/src/test/TestRunner.hpp
index 1a437cb3e..6e8974f17 100644
--- a/src/test/TestRunner.hpp
+++ b/src/test/TestRunner.hpp
@@ -21,7 +21,7 @@
 #include <cstdint>
 #include <memory>
 
-namespace clang {
+
 namespace mrdocs {
 
 struct TestResults
@@ -84,6 +84,6 @@ class TestRunner
 };
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_TEST_TESTRUNNER_HPP
diff --git a/src/test/lib/AST/ParseRef.cpp b/src/test/lib/AST/ParseRef.cpp
index 25f8140cb..532f975e1 100644
--- a/src/test/lib/AST/ParseRef.cpp
+++ b/src/test/lib/AST/ParseRef.cpp
@@ -10,7 +10,7 @@
 #include <test_suite/diff.hpp>
 #include <test_suite/test_suite.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 struct ParseRef_test
 {
@@ -321,4 +321,4 @@ TEST_SUITE(
     ParseRef_test,
     "clang.mrdocs.ParseRef");
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/test/lib/Dom/Dom.cpp b/src/test/lib/Dom/Dom.cpp
index 765b5f52d..12686c67e 100644
--- a/src/test/lib/Dom/Dom.cpp
+++ b/src/test/lib/Dom/Dom.cpp
@@ -12,7 +12,7 @@
 #include <format>
 #include <test_suite/test_suite.hpp>
 
-namespace clang {
+
 namespace mrdocs {
 namespace dom {
 
@@ -227,7 +227,7 @@ struct Dom_test
             BOOST_TEST(s3 == "helloworld");
         }
 
-        // std::formatter<clang::mrdocs::dom::String>
+        // std::formatter<mrdocs::dom::String>
         {
             String s("hello");
             BOOST_TEST(std::format("{}", s) == "hello");
@@ -2154,5 +2154,5 @@ TEST_SUITE(
 
 } // dom
 } // mrdocs
-} // clang
+
 
diff --git a/src/test/lib/Dom/Function.cpp b/src/test/lib/Dom/Function.cpp
index 581802b3f..10bdf0b4a 100644
--- a/src/test/lib/Dom/Function.cpp
+++ b/src/test/lib/Dom/Function.cpp
@@ -11,7 +11,7 @@
 #include <mrdocs/Dom/Function.hpp>
 #include <test_suite/test_suite.hpp>
 
-namespace clang {
+
 namespace mrdocs {
 namespace dom {
 
@@ -43,5 +43,5 @@ TEST_SUITE(
 
 } // dom
 } // mrdocs
-} // clang
+
 
diff --git a/src/test/lib/Dom/LazyObject.cpp b/src/test/lib/Dom/LazyObject.cpp
index f280be3fa..4139d3325 100644
--- a/src/test/lib/Dom/LazyObject.cpp
+++ b/src/test/lib/Dom/LazyObject.cpp
@@ -11,7 +11,7 @@
 #include <mrdocs/Dom/LazyObject.hpp>
 #include <test_suite/test_suite.hpp>
 
-namespace clang {
+
 namespace mrdocs {
 namespace dom {
 
@@ -251,5 +251,5 @@ TEST_SUITE(
 
 } // dom
 } // mrdocs
-} // clang
+
 
diff --git a/src/test/lib/Support/Handlebars.cpp b/src/test/lib/Support/Handlebars.cpp
index e0cef2c68..bf7db7957 100644
--- a/src/test/lib/Support/Handlebars.cpp
+++ b/src/test/lib/Support/Handlebars.cpp
@@ -18,7 +18,7 @@
 #include <test_suite/diff.hpp>
 #include <test_suite/test_suite.hpp>
 
-namespace clang {
+
 namespace mrdocs {
 
 template <std::convertible_to<dom::Value> DomValue>
@@ -5445,4 +5445,4 @@ TEST_SUITE(
     "clang.mrdocs.Handlebars");
 
 } // mrdocs
-} // clang
+
diff --git a/src/test/lib/Support/Path.cpp b/src/test/lib/Support/Path.cpp
index 56da2d001..17c3b11de 100644
--- a/src/test/lib/Support/Path.cpp
+++ b/src/test/lib/Support/Path.cpp
@@ -11,7 +11,7 @@
 #include <lib/Support/Path.hpp>
 #include <test_suite/test_suite.hpp>
 
-namespace clang {
+
 namespace mrdocs {
 
 struct Path_test
@@ -76,5 +76,5 @@ TEST_SUITE(
     "clang.mrdocs.Path");
 
 } // mrdocs
-} // clang
+
 
diff --git a/src/tool/CompilerInfo.cpp b/src/tool/CompilerInfo.cpp
index f53d1a8b0..595cbe865 100644
--- a/src/tool/CompilerInfo.cpp
+++ b/src/tool/CompilerInfo.cpp
@@ -14,7 +14,7 @@
 #include <mrdocs/Support/Error.hpp>
 #include <llvm/Support/Program.h>
 
-namespace clang {
+
 namespace mrdocs {
 
 Optional<std::string>
@@ -116,4 +116,4 @@ getCompilersDefaultIncludeDir(clang::tooling::CompilationDatabase const& compDb,
 }
 
 } // mrdocs
-} // clang
+
diff --git a/src/tool/CompilerInfo.hpp b/src/tool/CompilerInfo.hpp
index 10cd30c58..de6b3cbbe 100644
--- a/src/tool/CompilerInfo.hpp
+++ b/src/tool/CompilerInfo.hpp
@@ -19,7 +19,7 @@
 #include <unordered_map>
 #include <vector>
 
-namespace clang {
+
 namespace mrdocs {
 
 /**
@@ -51,6 +51,6 @@ std::unordered_map<std::string, std::vector<std::string>>
 getCompilersDefaultIncludeDir(clang::tooling::CompilationDatabase const& compDb, bool useSystemStdlib);
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_TOOL_COMPILERINFO_HPP
diff --git a/src/tool/GenerateAction.cpp b/src/tool/GenerateAction.cpp
index 670047a94..a05fd38b6 100644
--- a/src/tool/GenerateAction.cpp
+++ b/src/tool/GenerateAction.cpp
@@ -21,7 +21,7 @@
 #include <mrdocs/Support/Report.hpp>
 #include <mrdocs/Support/ThreadPool.hpp>
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 
 Expected<void>
@@ -73,7 +73,7 @@ DoGenerateAction(
     }
     MRDOCS_TRY(
         MrDocsCompilationDatabase compilationDatabase,
-        generateCompilationDatabase(tempDir.path(), config, threadPool));
+        generateCompilationDatabase(tempDir.path(), config));
 
     // --------------------------------------------------------------
     //
@@ -108,4 +108,4 @@ DoGenerateAction(
     return {};
 }
 
-} // clang::mrdocs
+} // mrdocs
diff --git a/src/tool/ToolArgs.cpp b/src/tool/ToolArgs.cpp
index f556d87af..229ea87f0 100644
--- a/src/tool/ToolArgs.cpp
+++ b/src/tool/ToolArgs.cpp
@@ -15,7 +15,7 @@
 #include <string>
 #include <vector>
 
-namespace clang {
+
 namespace mrdocs {
 
 ToolArgs ToolArgs::instance_;
@@ -56,4 +56,4 @@ hideForeignOptions()
 }
 
 } // mrdocs
-} // clang
+
diff --git a/src/tool/ToolArgs.hpp b/src/tool/ToolArgs.hpp
index 2510703f9..89656140b 100644
--- a/src/tool/ToolArgs.hpp
+++ b/src/tool/ToolArgs.hpp
@@ -16,7 +16,7 @@
 #include <string>
 #include <tool/PublicToolArgs.hpp>
 
-namespace clang {
+
 namespace mrdocs {
 
 /** Command line options and tool settings.
@@ -44,6 +44,6 @@ class ToolArgs : public PublicToolArgs
 constexpr static ToolArgs& toolArgs = ToolArgs::instance_;
 
 } // mrdocs
-} // clang
+
 
 #endif
diff --git a/src/tool/ToolCompilationDatabase.cpp b/src/tool/ToolCompilationDatabase.cpp
index 9e3d25fef..6872f602b 100644
--- a/src/tool/ToolCompilationDatabase.cpp
+++ b/src/tool/ToolCompilationDatabase.cpp
@@ -15,7 +15,7 @@
 #include <lib/Support/Path.hpp>
 #include <mrdocs/Support/Report.hpp>
 
-namespace clang {
+
 namespace mrdocs {
 
 namespace {
@@ -78,8 +78,7 @@ generateCompileCommandsFile(llvm::StringRef inputPath, llvm::StringRef cmakeArgs
 Expected<MrDocsCompilationDatabase>
 generateCompilationDatabase(
     std::string_view tempDir,
-    std::shared_ptr<ConfigImpl const> const& config,
-    ThreadPool& threadPool)
+    std::shared_ptr<ConfigImpl const> const& config)
 {
     auto& settings = config->settings();
     std::string compilationDatabasePath = settings.compilationDatabase;
@@ -136,10 +135,10 @@ generateCompilationDatabase(
     std::string errorMessage;
     std::unique_ptr<clang::tooling::JSONCompilationDatabase>
         jsonDatabasePtr =
-            tooling::JSONCompilationDatabase::loadFromFile(
+            clang::tooling::JSONCompilationDatabase::loadFromFile(
                 compileCommandsPath,
                 errorMessage,
-                tooling::JSONCommandLineSyntax::AutoDetect);
+                clang::tooling::JSONCommandLineSyntax::AutoDetect);
     if (!jsonDatabasePtr)
     {
         return Unexpected(formatError(
@@ -160,4 +159,4 @@ generateCompilationDatabase(
 }
 
 } // mrdocs
-} // clang
+
diff --git a/src/tool/ToolCompilationDatabase.hpp b/src/tool/ToolCompilationDatabase.hpp
index 3abadc91d..f4d888173 100644
--- a/src/tool/ToolCompilationDatabase.hpp
+++ b/src/tool/ToolCompilationDatabase.hpp
@@ -14,16 +14,15 @@
 #include <lib/ConfigImpl.hpp>
 #include <lib/MrDocsCompilationDatabase.hpp>
 
-namespace clang {
+
 namespace mrdocs {
 
 Expected<MrDocsCompilationDatabase>
 generateCompilationDatabase(
     std::string_view tempDir,
-    std::shared_ptr<ConfigImpl const> const& config,
-    ThreadPool& threadPool);
+    std::shared_ptr<ConfigImpl const> const& config);
 
 } // mrdocs
-} // clang
+
 
 #endif // MRDOCS_TOOL_TOOLCOMPILATIONDATABASE_HPP
diff --git a/src/tool/ToolMain.cpp b/src/tool/ToolMain.cpp
index 4b65e3ed9..fa8c60601 100644
--- a/src/tool/ToolMain.cpp
+++ b/src/tool/ToolMain.cpp
@@ -24,7 +24,7 @@
 
 extern int main(int argc, char const** argv);
 
-namespace clang::mrdocs {
+namespace mrdocs {
 
 extern
 int
@@ -166,26 +166,26 @@ reportUnhandledException(
 }
 #endif
 
-} // clang::mrdocs
+} // mrdocs
 
 int
 main(int argc, char const** argv)
 {
 #ifndef _NDEBUG
-    return clang::mrdocs::mrdocs_main(argc, argv);
+    return mrdocs::mrdocs_main(argc, argv);
 #else
     try
     {
-        return clang::mrdocs::mrdocs_main(argc, argv);
+        return mrdocs::mrdocs_main(argc, argv);
     }
-    catch(clang::mrdocs::Exception const& ex)
+    catch(mrdocs::Exception const& ex)
     {
         // Thrown Exception should never get here.
-        clang::mrdocs::reportUnhandledException(ex);
+        mrdocs::reportUnhandledException(ex);
     }
     catch(std::exception const& ex)
     {
-        clang::mrdocs::reportUnhandledException(ex);
+        mrdocs::reportUnhandledException(ex);
     }
     return EXIT_FAILURE;
 #endif
diff --git a/util/generate-config-info.py b/util/generate-config-info.py
index ba68423e9..529b4b564 100644
--- a/util/generate-config-info.py
+++ b/util/generate-config-info.py
@@ -309,7 +309,7 @@ def generate_public_settings_hpp(config):
         contents += f'#include {header}\n'
     contents += '\n'
 
-    contents += 'namespace clang::mrdocs {\n\n'
+    contents += 'namespace mrdocs {\n\n'
     contents += 'struct PublicSettings {\n'
 
     contents += '    //--------------------------------------------\n'
@@ -524,7 +524,7 @@ def generate_public_settings_hpp(config):
         contents += '    return {};\n'
         contents += '}\n\n'
 
-    contents += '} // namespace clang::mrdocs\n\n'
+    contents += '} // namespace mrdocs\n\n'
     contents += f'#endif // {header_guard}\n'
     return contents
 
@@ -548,7 +548,7 @@ def generate_public_toolargs_hpp(config):
         contents += f'#include {header}\n'
     contents += '\n'
 
-    contents += 'namespace clang {\n'
+    contents += '\n'
     contents += 'namespace mrdocs {\n\n'
     contents += 'struct PublicToolArgs {\n\n'
 
@@ -604,14 +604,13 @@ def generate_public_toolargs_hpp(config):
 
     contents += '}; // struct PublicToolArgs\n\n'
     contents += '} // namespace mrdocs\n'
-    contents += '} // namespace clang\n\n'
     contents += f'#endif // {header_guard}\n'
     return contents
 
 
 def generate_yaml_mapping_traits(option, namespace=None):
     if namespace is None:
-        namespace = 'clang::mrdocs::PublicSettings'
+        namespace = 'mrdocs::PublicSettings'
 
     contents = ''
     if 'options' in option:
@@ -704,7 +703,7 @@ def generate_public_settings_cpp(config):
 
     # Generate the LLVM YAML traits for each enum, such as:
     for [enum_name, enum_values] in get_valid_enum_categories().items():
-        cpp_enum_type = f'clang::mrdocs::PublicSettings::{to_pascal_case(enum_name)}'
+        cpp_enum_type = f'mrdocs::PublicSettings::{to_pascal_case(enum_name)}'
         contents += f'template<>\n'
         contents += f'struct llvm::yaml::ScalarEnumerationTraits<\n'
         contents += f'    {cpp_enum_type}>\n'
@@ -725,7 +724,7 @@ def generate_public_settings_cpp(config):
 
     # Generate the LLVM YAML traits for glob patterns, such as:
     for name in ['PathGlobPattern', 'SymbolGlobPattern']:
-        qualified_name = f'clang::mrdocs::{name}'
+        qualified_name = f'mrdocs::{name}'
         contents += f'template<>\n'
         contents += f'struct llvm::yaml::ScalarTraits<\n'
         contents += f'    {qualified_name}>\n'
@@ -790,11 +789,11 @@ def generate_public_settings_cpp(config):
     # Generate the LLVM YAML traits for all PublicSettings
     contents += f'template<>\n'
     contents += f'struct llvm::yaml::MappingTraits<\n'
-    contents += f'    clang::mrdocs::PublicSettings>\n'
+    contents += f'    mrdocs::PublicSettings>\n'
     contents += '{\n'
     contents += f'    static void mapping(\n'
     contents += f'        llvm::yaml::IO& io,\n'
-    contents += f'        clang::mrdocs::PublicSettings& s)\n'
+    contents += f'        mrdocs::PublicSettings& s)\n'
     contents += '    {\n'
     for category in config:
         for option in category['options']:
@@ -804,7 +803,7 @@ def generate_public_settings_cpp(config):
     contents += '    }\n'
     contents += '};\n\n'
 
-    contents += 'namespace clang {\n'
+    contents += '\n'
     contents += 'namespace mrdocs {\n\n'
 
     # Main function to load the configuration from a YAML file
@@ -830,7 +829,6 @@ def generate_public_settings_cpp(config):
     contents += '}\n\n'
 
     contents += '} // namespace mrdocs\n'
-    contents += '} // namespace clang\n\n'
     return contents
 
 
@@ -960,7 +958,7 @@ def generate_public_toolargs_cpp(config):
 };
     '''
 
-    contents += 'namespace clang::mrdocs {\n\n'
+    contents += 'namespace mrdocs {\n\n'
 
     # Main constructor that initializes all options
     contents += 'PublicToolArgs::\n'
@@ -1096,7 +1094,7 @@ def generate_public_toolargs_cpp(config):
     contents += '    return {};\n'
     contents += '}\n'
 
-    contents += '} // namespace clang::mrdocs\n'
+    contents += '} // namespace mrdocs\n'
     return contents
 
 

From 49b8900c607c76347a2fe144948286f6ac3897bd Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Sun, 28 Sep 2025 17:02:59 -0500
Subject: [PATCH 21/23] test(javadoc): refs to parent contexts

---
 .../javadoc/ref/parent_context.adoc           | 149 +++++++++++++
 .../javadoc/ref/parent_context.cpp            |  16 ++
 .../javadoc/ref/parent_context.html           | 211 ++++++++++++++++++
 .../javadoc/ref/parent_context.xml            |  57 +++++
 4 files changed, 433 insertions(+)
 create mode 100644 test-files/golden-tests/javadoc/ref/parent_context.adoc
 create mode 100644 test-files/golden-tests/javadoc/ref/parent_context.cpp
 create mode 100644 test-files/golden-tests/javadoc/ref/parent_context.html
 create mode 100644 test-files/golden-tests/javadoc/ref/parent_context.xml

diff --git a/test-files/golden-tests/javadoc/ref/parent_context.adoc b/test-files/golden-tests/javadoc/ref/parent_context.adoc
new file mode 100644
index 000000000..a1ef66643
--- /dev/null
+++ b/test-files/golden-tests/javadoc/ref/parent_context.adoc
@@ -0,0 +1,149 @@
+= Reference
+:mrdocs:
+
+[#index]
+== Global namespace
+
+=== Namespaces
+
+[cols=1]
+|===
+| Name
+| link:#boost[`boost`] 
+|===
+
+[#boost]
+== boost
+
+=== Namespaces
+
+[cols=1]
+|===
+| Name
+| link:#boost-openmethod[`openmethod`] 
+|===
+
+[#boost-openmethod]
+== link:#boost[boost]::openmethod
+
+=== Namespaces
+
+[cols=1]
+|===
+| Name
+| link:#boost-openmethod-policies[`policies`] 
+|===
+
+=== Functions
+
+[cols=2]
+|===
+| Name
+| Description
+| link:#boost-openmethod-final_virtual_ptr-04[`final&lowbar;virtual&lowbar;ptr`] 
+| 
+|===
+
+[#boost-openmethod-policies]
+== link:#boost[boost]::link:#boost-openmethod[openmethod]::policies
+
+=== Namespaces
+
+[cols=1]
+|===
+| Name
+| link:#boost-openmethod-policies-runtime_checks[`runtime&lowbar;checks`] 
+|===
+
+[#boost-openmethod-policies-runtime_checks]
+== link:#boost[boost]::link:#boost-openmethod[openmethod]::link:#boost-openmethod-policies[policies]::runtime&lowbar;checks
+
+=== Types
+
+[cols=2]
+|===
+| Name
+| Description
+| link:#boost-openmethod-policies-runtime_checks-runtime_checks[`runtime&lowbar;checks`] 
+| Documentation with ref to final&lowbar;virtual&lowbar;ptr
+|===
+
+[#boost-openmethod-policies-runtime_checks-runtime_checks]
+== link:#boost[boost]::link:#boost-openmethod[openmethod]::link:#boost-openmethod-policies[policies]::link:#boost-openmethod-policies-runtime_checks[runtime&lowbar;checks]::runtime&lowbar;checks
+
+Documentation with ref to final&lowbar;virtual&lowbar;ptr
+
+=== Synopsis
+
+Declared in `&lt;parent&lowbar;context&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+struct runtime&lowbar;checks;
+----
+
+=== Description
+
+See link:#boost-openmethod-final_virtual_ptr-04[`final&lowbar;virtual&lowbar;ptr`]
+
+[#boost-openmethod-final_virtual_ptr-04]
+== link:#boost[boost]::link:#boost-openmethod[openmethod]::final&lowbar;virtual&lowbar;ptr
+
+=== Synopses
+
+Declared in `&lt;parent&lowbar;context&period;cpp&gt;`
+
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+template&lt;class Arg&gt;
+auto
+link:#boost-openmethod-final_virtual_ptr-08[final&lowbar;virtual&lowbar;ptr](Arg&& obj);
+----
+
+[.small]#link:#boost-openmethod-final_virtual_ptr-08[_» more&period;&period;&period;_]#
+
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+template&lt;
+    class Registry,
+    typename Arg&gt;
+auto
+link:#boost-openmethod-final_virtual_ptr-03[final&lowbar;virtual&lowbar;ptr](Arg&& obj);
+----
+
+[.small]#link:#boost-openmethod-final_virtual_ptr-03[_» more&period;&period;&period;_]#
+
+[#boost-openmethod-final_virtual_ptr-08]
+== link:#boost[boost]::link:#boost-openmethod[openmethod]::final&lowbar;virtual&lowbar;ptr
+
+=== Synopsis
+
+Declared in `&lt;parent&lowbar;context&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+template&lt;class Arg&gt;
+auto
+final&lowbar;virtual&lowbar;ptr(Arg&& obj);
+----
+
+[#boost-openmethod-final_virtual_ptr-03]
+== link:#boost[boost]::link:#boost-openmethod[openmethod]::final&lowbar;virtual&lowbar;ptr
+
+=== Synopsis
+
+Declared in `&lt;parent&lowbar;context&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+template&lt;
+    class Registry,
+    typename Arg&gt;
+auto
+final&lowbar;virtual&lowbar;ptr(Arg&& obj);
+----
+
+
+[.small]#Created with https://www.mrdocs.com[MrDocs]#
diff --git a/test-files/golden-tests/javadoc/ref/parent_context.cpp b/test-files/golden-tests/javadoc/ref/parent_context.cpp
new file mode 100644
index 000000000..66e0bf11d
--- /dev/null
+++ b/test-files/golden-tests/javadoc/ref/parent_context.cpp
@@ -0,0 +1,16 @@
+namespace boost::openmethod {
+    template<class Arg>
+    auto final_virtual_ptr(Arg&& obj);
+
+    template<class Registry, typename Arg>
+    auto final_virtual_ptr(Arg&& obj);
+
+    namespace policies::runtime_checks
+    {
+        /** Documentation with ref to final_virtual_ptr
+
+            See @ref final_virtual_ptr
+         */
+        struct runtime_checks;
+    }
+}
diff --git a/test-files/golden-tests/javadoc/ref/parent_context.html b/test-files/golden-tests/javadoc/ref/parent_context.html
new file mode 100644
index 000000000..a1b5e20a9
--- /dev/null
+++ b/test-files/golden-tests/javadoc/ref/parent_context.html
@@ -0,0 +1,211 @@
+<html lang="en">
+<head>
+<title>Reference</title>
+</head>
+<body>
+<div>
+<h1>Reference</h1>
+<div>
+<div>
+<h2 id="index"></h2>
+</div>
+<h2>Namespaces</h2>
+<table style="table-layout: fixed; width: 100%;">
+<thead>
+<tr>
+<th>Name</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><a href="#boost"><code>boost</code></a> </td></tr>
+</tbody>
+</table>
+
+</div>
+<div>
+<div>
+<h2 id="boost">boost</h2>
+</div>
+<h2>Namespaces</h2>
+<table style="table-layout: fixed; width: 100%;">
+<thead>
+<tr>
+<th>Name</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><a href="#boost-openmethod"><code>openmethod</code></a> </td></tr>
+</tbody>
+</table>
+
+</div>
+<div>
+<div>
+<h2 id="boost-openmethod">boost::openmethod</h2>
+</div>
+<h2>Namespaces</h2>
+<table style="table-layout: fixed; width: 100%;">
+<thead>
+<tr>
+<th>Name</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><a href="#boost-openmethod-policies"><code>policies</code></a> </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="#boost-openmethod-final_virtual_ptr-04"><code>final_virtual_ptr</code></a> </td><td><span></span></td></tr>
+</tbody>
+</table>
+
+</div>
+<div>
+<div>
+<h2 id="boost-openmethod-policies">boost::openmethod::policies</h2>
+</div>
+<h2>Namespaces</h2>
+<table style="table-layout: fixed; width: 100%;">
+<thead>
+<tr>
+<th>Name</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><a href="#boost-openmethod-policies-runtime_checks"><code>runtime_checks</code></a> </td></tr>
+</tbody>
+</table>
+
+</div>
+<div>
+<div>
+<h2 id="boost-openmethod-policies-runtime_checks">boost::openmethod::policies::runtime_checks</h2>
+</div>
+<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="#boost-openmethod-policies-runtime_checks-runtime_checks"><code>runtime_checks</code></a> </td><td><span>Documentation with ref to final_virtual_ptr</span></td></tr>
+</tbody>
+</table>
+
+</div>
+<div>
+<div>
+<h2 id="boost-openmethod-policies-runtime_checks-runtime_checks">boost::openmethod::policies::runtime_checks::runtime_checks</h2>
+<div>
+<span>Documentation with ref to final_virtual_ptr</span>
+
+</div>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;parent_context.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">struct runtime_checks;
+
+</code>
+</pre>
+</div>
+
+
+<div>
+<h3>Description</h3>
+<p>See <a href="#boost-openmethod-final_virtual_ptr-04"><code>final_virtual_ptr</code></a></p>
+</div>
+</div>
+<div>
+<div>
+<h2 id="boost-openmethod-final_virtual_ptr-04">boost::openmethod::final_virtual_ptr</h2>
+</div>
+<div>
+<h3>Synopses</h3>
+<div>
+Declared in <code>&lt;parent_context.cpp&gt;</code></div>
+
+<pre>
+<code class="source-code cpp">template&lt;class Arg&gt;
+auto
+<a href="#boost-openmethod-final_virtual_ptr-08">final_virtual_ptr</a>(Arg&& obj);
+
+</code>
+</pre><span class="small"><a href="#boost-openmethod-final_virtual_ptr-08"><em>» more...</em></a></span>
+
+
+<pre>
+<code class="source-code cpp">template&lt;
+    class Registry,
+    typename Arg&gt;
+auto
+<a href="#boost-openmethod-final_virtual_ptr-03">final_virtual_ptr</a>(Arg&& obj);
+
+</code>
+</pre><span class="small"><a href="#boost-openmethod-final_virtual_ptr-03"><em>» more...</em></a></span>
+
+
+</div>
+</div>
+<div>
+<div>
+<h2 id="boost-openmethod-final_virtual_ptr-08">boost::openmethod::final_virtual_ptr</h2>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;parent_context.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">template&lt;class Arg&gt;
+auto
+final_virtual_ptr(Arg&& obj);
+
+</code>
+</pre>
+</div>
+</div>
+<div>
+<div>
+<h2 id="boost-openmethod-final_virtual_ptr-03">boost::openmethod::final_virtual_ptr</h2>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;parent_context.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">template&lt;
+    class Registry,
+    typename Arg&gt;
+auto
+final_virtual_ptr(Arg&& obj);
+
+</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/javadoc/ref/parent_context.xml b/test-files/golden-tests/javadoc/ref/parent_context.xml
new file mode 100644
index 000000000..26c885851
--- /dev/null
+++ b/test-files/golden-tests/javadoc/ref/parent_context.xml
@@ -0,0 +1,57 @@
+<?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=">
+  <namespace name="boost" id="+jO0pmMB/RXahxtatVUYoEwUKWs=">
+    <namespace name="openmethod" id="8vOLQN1FS3phbXzrBx8KohfFQCw=">
+      <namespace name="policies" id="iyqzr2bAIIz4tcVOh2wjYTkCOC0=">
+        <namespace name="runtime_checks" id="TVhmFYxnwUAmcG327zb+ghem758=">
+          <struct name="runtime_checks" id="1Jkj+l8tdM+DGWC1GVMWML70iGA=">
+            <file short-path="parent_context.cpp" source-path="parent_context.cpp" line="14" class="def"/>
+            <doc>
+              <brief>
+                <text>Documentation with ref to final_virtual_ptr</text>
+              </brief>
+              <para>
+                <text>See </text>
+                <reference id="RgmcrbKVGmXz6c3Lxk0nacbfXkg=">final_virtual_ptr</reference>
+              </para>
+            </doc>
+          </struct>
+        </namespace>
+      </namespace>
+      <template>
+        <tparam name="Arg" class="type"/>
+        <function name="final_virtual_ptr" id="jq5N3pt8pWn/EcTzXTPM1Gj1O9s=">
+          <file short-path="parent_context.cpp" source-path="parent_context.cpp" line="2"/>
+          <return>
+            <type class="auto" keyword="auto">
+            </type>
+          </return>
+          <param name="obj">
+            <type class="rvalue-reference">
+              <pointee-type name="Arg"/>
+            </type>
+          </param>
+        </function>
+      </template>
+      <template>
+        <tparam name="Registry" class="type"/>
+        <tparam name="Arg" class="type"/>
+        <function name="final_virtual_ptr" id="N+/tS2Uxf62zshI73QwQ0n3wcJg=">
+          <file short-path="parent_context.cpp" source-path="parent_context.cpp" line="5"/>
+          <return>
+            <type class="auto" keyword="auto">
+            </type>
+          </return>
+          <param name="obj">
+            <type class="rvalue-reference">
+              <pointee-type name="Arg"/>
+            </type>
+          </param>
+        </function>
+      </template>
+    </namespace>
+  </namespace>
+</namespace>
+</mrdocs>

From e1f6f7d97b9e4fdc71fe226528e5a4b7ae67f936 Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Mon, 29 Sep 2025 14:56:49 -0500
Subject: [PATCH 22/23] feat(metadata): support recursive inline elements in
 documentation

---
 .github/workflows/ci.yml                      |   65 +
 docs/modules/ROOT/pages/commands.adoc         |   60 +-
 docs/modules/ROOT/pages/contribute.adoc       |    4 +-
 docs/modules/ROOT/pages/index.adoc            |    2 +-
 docs/website/snippets/is_prime.cpp            |    3 +-
 include/mrdocs/ADT/ArrayView.hpp              |  167 ++
 include/mrdocs/ADT/Nullable.hpp               |   50 +-
 include/mrdocs/ADT/Optional.hpp               |    8 +-
 include/mrdocs/ADT/Overload.hpp               |  246 +++
 include/mrdocs/ADT/Polymorphic.hpp            |  122 ++
 include/mrdocs/Dom/Value.hpp                  |    5 +-
 include/mrdocs/Metadata.hpp                   |    2 +-
 include/mrdocs/Metadata/DocComment.hpp        |  382 ++++
 include/mrdocs/Metadata/DocComment/Block.hpp  |  193 ++
 .../DocComment/Block/AdmonitionBlock.hpp      |   89 +
 .../Block/AdmonitionKind.hpp}                 |   21 +-
 .../Metadata/DocComment/Block/BlockBase.hpp   |  295 +++
 .../DocComment/Block/BlockCommandNodes.inc    |   24 +
 .../Metadata/DocComment/Block/BlockKind.hpp   |   63 +
 .../Metadata/DocComment/Block/BlockNodes.inc  |   32 +
 .../Metadata/DocComment/Block/BriefBlock.hpp  |  106 +
 .../Metadata/DocComment/Block/CodeBlock.hpp   |   75 +
 .../DocComment/Block/DefinitionListBlock.hpp  |   78 +
 .../DocComment/Block/DefinitionListItem.hpp   |   67 +
 .../Block/FootnoteDefinitionBlock.hpp         |   70 +
 .../Block/HeadingBlock.hpp}                   |   43 +-
 .../Block/ListBlock.hpp}                      |   55 +-
 .../Block/ListItem.hpp                        |   44 +-
 .../Metadata/DocComment/Block/ListKind.hpp    |   49 +
 .../Metadata/DocComment/Block/MathBlock.hpp   |   71 +
 .../Block/ParagraphBlock.hpp}                 |   45 +-
 .../Metadata/DocComment/Block/ParamBlock.hpp  |   94 +
 .../Block/ParamDirection.hpp                  |    7 +-
 .../Block/PostconditionBlock.hpp}             |   45 +-
 .../Block/PreconditionBlock.hpp}              |   45 +-
 .../Metadata/DocComment/Block/QuoteBlock.hpp  |   68 +
 .../DocComment/Block/ReturnsBlock.hpp         |   76 +
 .../See.hpp => DocComment/Block/SeeBlock.hpp} |   44 +-
 .../Block/TParamBlock.hpp}                    |   41 +-
 .../DocComment/Block/TableAlignmentKind.hpp   |   55 +
 .../Metadata/DocComment/Block/TableBlock.hpp  |   92 +
 .../Metadata/DocComment/Block/TableCell.hpp   |   64 +
 .../Metadata/DocComment/Block/TableRow.hpp    |   72 +
 .../DocComment/Block/ThematicBreakBlock.hpp   |   65 +
 .../Block/ThrowsBlock.hpp}                    |   51 +-
 .../{Javadoc => DocComment}/Inline.hpp        |   83 +-
 .../Metadata/DocComment/Inline/CodeInline.hpp |   67 +
 .../Inline/CopyDetailsInline.hpp}             |   40 +-
 .../Metadata/DocComment/Inline/EmphInline.hpp |   67 +
 .../Inline/FootnoteReferenceInline.hpp        |   68 +
 .../DocComment/Inline/HighlightInline.hpp     |   66 +
 .../DocComment/Inline/ImageInline.hpp         |   71 +
 .../Metadata/DocComment/Inline/InlineBase.hpp |  491 +++++
 .../Metadata/DocComment/Inline/InlineKind.hpp |   47 +
 .../DocComment/Inline/InlineNodes.inc         |   32 +
 .../DocComment/Inline/LineBreakInline.hpp     |   65 +
 .../Inline/LinkInline.hpp}                    |   45 +-
 .../Metadata/DocComment/Inline/MathInline.hpp |   75 +
 .../{Javadoc => DocComment}/Inline/Parts.hpp  |    7 +-
 .../Inline/ReferenceInline.hpp}               |   48 +-
 .../DocComment/Inline/SoftBreakInline.hpp     |   65 +
 .../DocComment/Inline/StrikethroughInline.hpp |   66 +
 .../DocComment/Inline/StrongInline.hpp        |   67 +
 .../DocComment/Inline/SubscriptInline.hpp     |   66 +
 .../DocComment/Inline/SuperscriptInline.hpp   |   66 +
 .../Metadata/DocComment/Inline/TextInline.hpp |   90 +
 include/mrdocs/Metadata/DomCorpus.hpp         |    6 +-
 include/mrdocs/Metadata/Javadoc.hpp           |  289 ---
 include/mrdocs/Metadata/Javadoc/Block.hpp     |  136 --
 .../Metadata/Javadoc/Block/Admonition.hpp     |   89 -
 .../Metadata/Javadoc/Block/BlockBase.hpp      |  149 --
 .../mrdocs/Metadata/Javadoc/Block/Brief.hpp   |   98 -
 .../mrdocs/Metadata/Javadoc/Block/Code.hpp    |   80 -
 .../mrdocs/Metadata/Javadoc/Block/Param.hpp   |  116 --
 .../mrdocs/Metadata/Javadoc/Block/Returns.hpp |  100 -
 .../Metadata/Javadoc/Inline/InlineBase.hpp    |   89 -
 .../mrdocs/Metadata/Javadoc/Inline/Style.hpp  |   58 -
 .../mrdocs/Metadata/Javadoc/Inline/Styled.hpp |   82 -
 .../mrdocs/Metadata/Javadoc/Inline/Text.hpp   |   96 -
 include/mrdocs/Metadata/Javadoc/Node.hpp      |  160 --
 .../mrdocs/Metadata/Javadoc/Node/NodeBase.hpp |   95 -
 .../mrdocs/Metadata/Javadoc/Node/NodeKind.hpp |  132 --
 include/mrdocs/Metadata/Name.hpp              |    7 +-
 include/mrdocs/Metadata/Symbol.hpp            |   36 +-
 include/mrdocs/Metadata/Symbol/Namespace.hpp  |    3 +-
 include/mrdocs/Metadata/Symbol/SymbolBase.hpp |   10 +-
 include/mrdocs/Support/ScopeExit.hpp          |   12 +
 include/mrdocs/Support/SplitLines.hpp         |  208 ++
 include/mrdocs/Support/String.hpp             |   20 +-
 include/mrdocs/mrdocs.natvis                  |    2 +-
 mrdocs.rnc                                    |   24 +-
 share/lldb/clang_ast_formatters.py            |  142 +-
 share/lldb/mrdocs_formatters.py               | 1035 ++++++---
 .../partials/doc/block/admonition.adoc.hbs    |    5 +
 .../adoc/partials/doc/block/brief.adoc.hbs    |    3 +
 .../adoc/partials/doc/block/code.adoc.hbs     |    4 +
 .../adoc/partials/doc/block/list.adoc.hbs     |    9 +
 .../partials/doc/block/paragraph.adoc.hbs     |    3 +
 .../adoc/partials/javadoc/admonition.adoc.hbs |    3 -
 .../adoc/partials/javadoc/brief.adoc.hbs      |    3 -
 .../adoc/partials/javadoc/code.adoc.hbs       |    5 -
 .../partials/javadoc/description.adoc.hbs     |    1 -
 .../adoc/partials/javadoc/heading.adoc.hbs    |    1 -
 .../adoc/partials/javadoc/paragraph.adoc.hbs  |    2 -
 .../partials/javadoc/unordered_list.adoc.hbs  |    3 -
 .../generator/adoc/partials/markup/h.adoc.hbs |    1 +
 .../generator/adoc/partials/symbol.adoc.hbs   |   74 +-
 .../common/partials/doc/block-container.hbs   |    1 +
 .../generator/common/partials/doc/block.hbs   |    1 +
 .../common/partials/doc/block/admonition.hbs  |    1 +
 .../common/partials/doc/block/brief.hbs       |    1 +
 .../common/partials/doc/block/code.hbs        |    1 +
 .../partials/doc/block/definition-list.hbs    |    1 +
 .../common/partials/doc/block/document.hbs    |    1 +
 .../doc/block/footnote-definition.hbs         |    1 +
 .../common/partials/doc/block/heading.hbs     |    1 +
 .../partials/doc/block/inline-brief.hbs       |    4 +
 .../common/partials/doc/block/list.hbs        |    2 +
 .../common/partials/doc/block/math.hbs        |    1 +
 .../common/partials/doc/block/paragraph.hbs   |    1 +
 .../common/partials/doc/block/param.hbs       |    1 +
 .../partials/doc/block/postcondition.hbs      |    1 +
 .../partials/doc/block/precondition.hbs       |    1 +
 .../common/partials/doc/block/quote.hbs       |    1 +
 .../common/partials/doc/block/returns.hbs     |    1 +
 .../common/partials/doc/block/see.hbs         |    1 +
 .../common/partials/doc/block/t-param.hbs     |    1 +
 .../common/partials/doc/block/table.hbs       |    1 +
 .../partials/doc/block/thematic-break.hbs     |    1 +
 .../common/partials/doc/block/throws.hbs      |    1 +
 .../common/partials/doc/inline-container.hbs  |    1 +
 .../generator/common/partials/doc/inline.hbs  |    1 +
 .../common/partials/doc/inline/code.hbs       |    1 +
 .../common/partials/doc/inline/emph.hbs       |    1 +
 .../doc/inline/footnote-reference.hbs         |    1 +
 .../common/partials/doc/inline/highlight.hbs  |    1 +
 .../common/partials/doc/inline/image.hbs      |    1 +
 .../common/partials/doc/inline/line-break.hbs |    0
 .../common/partials/doc/inline/link.hbs       |    1 +
 .../common/partials/doc/inline/math.hbs       |    1 +
 .../common/partials/doc/inline/reference.hbs  |    5 +
 .../common/partials/doc/inline/soft-break.hbs |    0
 .../partials/doc/inline/strikethrough.hbs     |    1 +
 .../common/partials/doc/inline/strong.hbs     |    1 +
 .../common/partials/doc/inline/subscript.hbs  |    1 +
 .../partials/doc/inline/superscript.hbs       |    1 +
 .../common/partials/doc/inline/text.hbs       |    1 +
 .../common/partials/javadoc/any-block.hbs     |    1 -
 .../common/partials/javadoc/any-text.hbs      |    1 -
 .../common/partials/javadoc/block.hbs         |    1 -
 .../common/partials/javadoc/brief.hbs         |    1 -
 .../common/partials/javadoc/inline-brief.hbs  |    1 -
 .../common/partials/javadoc/link.hbs          |    1 -
 .../common/partials/javadoc/reference.hbs     |    5 -
 .../common/partials/javadoc/returns.hbs       |    1 -
 .../generator/common/partials/javadoc/see.hbs |    1 -
 .../common/partials/javadoc/styled.hbs        |    1 -
 .../common/partials/javadoc/styled/bold.hbs   |    1 -
 .../common/partials/javadoc/styled/italic.hbs |    1 -
 .../common/partials/javadoc/styled/mono.hbs   |    1 -
 .../common/partials/javadoc/text.hbs          |    1 -
 .../partials/markup/dynamic-level-h.hbs       |    2 +-
 .../symbol/detail/members-table-row.hbs       |    2 +-
 .../common/partials/symbol/members-table.hbs  |    2 +-
 .../common/partials/symbol/signatures.hbs     |    2 +-
 .../block}/admonition.html.hbs                |    3 +-
 .../html/partials/doc/block/code.html.hbs     |    3 +
 .../html/partials/doc/block/list.html.hbs     |    4 +
 .../partials/doc/block/paragraph.html.hbs     |    1 +
 .../html/partials/javadoc/code.html.hbs       |    4 -
 .../partials/javadoc/description.html.hbs     |    2 -
 .../html/partials/javadoc/heading.html.hbs    |    1 -
 .../html/partials/javadoc/paragraph.html.hbs  |    1 -
 .../partials/javadoc/unordered_list.html.hbs  |    4 -
 .../html/partials/markup/code-block.html.hbs  |    4 +-
 .../generator/html/partials/markup/h.html.hbs |    2 +-
 .../generator/html/partials/symbol.html.hbs   |   71 +-
 src/lib/AST/ASTVisitor.cpp                    |   14 +-
 src/lib/AST/ASTVisitor.hpp                    |    8 +-
 src/lib/AST/ExtractDocComment.cpp             | 1188 +++++++++++
 ...ParseJavadoc.hpp => ExtractDocComment.hpp} |   20 +-
 src/lib/AST/NameBuilder.hpp                   |    7 +-
 src/lib/AST/ParseJavadoc.cpp                  | 1819 ----------------
 src/lib/AST/ParseRef.cpp                      |    1 -
 src/lib/CorpusImpl.cpp                        |   10 +-
 src/lib/CorpusImpl.hpp                        |    2 +-
 src/lib/Gen/hbs/HandlebarsCorpus.hpp          |    4 +-
 src/lib/Gen/xml/CXXTags.hpp                   |    2 +-
 src/lib/Gen/xml/XMLGenerator.hpp              |    2 +-
 src/lib/Gen/xml/XMLTags.hpp                   |    2 +-
 src/lib/Gen/xml/XMLWriter.cpp                 |  584 ++++--
 src/lib/Gen/xml/XMLWriter.hpp                 |  106 +-
 src/lib/Metadata/DocComment.cpp               |  182 ++
 src/lib/Metadata/DocComment/Block.cpp         |   26 +
 .../Metadata/DocComment/Block/BlockBase.cpp   |  199 ++
 src/lib/Metadata/DocComment/Inline.cpp        |   87 +
 .../Metadata/DocComment/Inline/InlineBase.cpp |  148 ++
 src/lib/Metadata/DomCorpus.cpp                |    8 +-
 .../Metadata/Finalizers/DerivedFinalizer.hpp  |    2 +-
 .../{Javadoc => DocComment}/Function.hpp      |  164 +-
 .../{Javadoc => DocComment}/Overloads.hpp     |  148 +-
 .../Finalizers/DocComment/parseInlines.hpp    | 1062 ++++++++++
 ...cFinalizer.cpp => DocCommentFinalizer.cpp} | 1767 ++++++++--------
 .../Finalizers/DocCommentFinalizer.hpp        |  333 +++
 .../Metadata/Finalizers/JavadocFinalizer.hpp  |  455 ----
 .../Finalizers/NamespacesFinalizer.cpp        |    2 +-
 .../Finalizers/SortMembersFinalizer.cpp       |    5 +
 src/lib/Metadata/Info.cpp                     |   10 +-
 src/lib/Metadata/Javadoc.cpp                  |  387 ----
 src/lib/Metadata/{Info => Symbol}/Concept.cpp |    0
 src/lib/Metadata/{Info => Symbol}/Enum.cpp    |    0
 .../{Info => Symbol}/EnumConstant.cpp         |    0
 src/lib/Metadata/{Info => Symbol}/Friend.cpp  |    0
 .../Metadata/{Info => Symbol}/Function.cpp    |    0
 src/lib/Metadata/{Info => Symbol}/Guide.cpp   |    0
 .../Metadata/{Info => Symbol}/Namespace.cpp   |    0
 .../{Info => Symbol}/NamespaceAlias.cpp       |    0
 .../Metadata/{Info => Symbol}/Overloads.cpp   |    0
 src/lib/Metadata/{Info => Symbol}/Record.cpp  |    0
 src/lib/Metadata/{Info => Symbol}/Typedef.cpp |    0
 src/lib/Metadata/{Info => Symbol}/Using.cpp   |    0
 .../Metadata/{Info => Symbol}/Variable.cpp    |    0
 src/lib/Support/ExecutionContext.cpp          |    2 +-
 src/lib/Support/Generator.cpp                 |    2 +-
 src/lib/Support/Handlebars.cpp                |    4 +-
 src/lib/Support/String.cpp                    |   85 +
 src/test/ADT/ArrayView.cpp                    |  171 ++
 src/test/ADT/Nullable.cpp                     |   10 +-
 src/test/ADT/Optional.cpp                     |    2 +-
 src/test/Support/Expected.cpp                 |    2 +-
 src/test/Support/JavaScript.cpp               |    2 +-
 src/test/TestMain.cpp                         |    2 +-
 src/test/TestRunner.cpp                       |    2 +-
 src/test/lib/Dom/Dom.cpp                      |    2 +-
 .../Finalizers/Javadoc/parseInlines.cpp       |  322 +++
 src/test/lib/Support/Handlebars.cpp           |   14 +-
 src/test_suite/test_suite.hpp                 |   12 +-
 .../config/auto-brief/auto-brief.html         |  243 +--
 .../config/auto-brief/auto-brief.xml          |   34 -
 .../config/auto-brief/no-auto-brief.html      |  225 +-
 .../config/auto-brief/no-auto-brief.xml       |   46 -
 .../brief-from-function-class.html            |  142 +-
 .../brief-from-operator.adoc                  |   10 +
 .../brief-from-operator.html                  |  125 +-
 .../brief-from-operator.xml                   |    6 +
 .../param-from-function-class.html            |  188 +-
 .../param-from-operator.adoc                  |   22 +
 .../param-from-operator.html                  |  112 +-
 .../param-from-operator.xml                   |   16 +
 .../returns-from-brief.html                   |   42 +-
 .../returns-from-return-brief.html            |   22 +-
 .../returns-from-special.adoc                 |   34 +
 .../returns-from-special.html                 |  388 ++--
 .../returns-from-special.xml                  |   40 +
 .../config/auto-relates/auto-relates.html     |   75 +-
 .../config/auto-relates/derived.html          |  144 +-
 .../config/auto-relates/enum.html             |   70 +-
 .../config/auto-relates/no-auto-relates.html  |   63 +-
 .../config/auto-relates/qualified.html        |   84 +-
 .../config/auto-relates/remove-friend.html    |   41 +-
 .../config/auto-relates/return-type.html      |   70 +-
 .../config/extract-all/no-extract-all.html    |   18 +-
 .../no-extract-empty-namespaces.adoc          |    1 -
 .../no-extract-empty-namespaces.html          |   70 +-
 .../extract-friends/extract-friends.html      |   18 +-
 .../extract-friends/no-extract-friends.html   |   16 +-
 .../base.html                                 |   16 +-
 .../extract-implicit-specializations.html     |   20 +-
 .../no-extract-implicit-specializations.html  |   16 +-
 .../extract-local-classes.html                |   12 +-
 .../no-extract-local-classes.html             |    4 +-
 .../extract-private-virtual.html              |   12 +-
 .../no-extract-private-virtual.html           |    8 +-
 .../base-overload-set.adoc                    |    8 +-
 .../base-overload-set.html                    |   46 +-
 .../copy-dependencies.html                    |  301 +--
 .../config/inherit-base-members/copy.html     |  454 ++--
 .../config/inherit-base-members/never.html    |  213 +-
 .../inherit-base-members/reference.html       |  247 +--
 .../inherit-base-members/skip-special.html    |  355 ++--
 .../config/legible-names/constructor.html     |   82 +-
 .../config/missing-include-prefixes/main.html |    8 +-
 .../config/missing-include-shims/main.html    |   11 +-
 .../config/overloads/const-mutable.adoc       |    4 +-
 .../config/overloads/const-mutable.html       |   23 +-
 .../config/overloads/visibility.adoc          |   16 +-
 .../config/overloads/visibility.html          |   80 +-
 .../golden-tests/config/sfinae/redeclare.html |    4 +-
 .../config/sfinae/return-based.html           |    4 +-
 .../show-enum-constants-false.html            |   15 +-
 .../show-enum-constants-true.html             |   36 +-
 .../show-namespaces/show-namespaces.html      |   12 +-
 .../sort-members-by-location.html             |  119 +-
 .../sort-members-by/sort-members-by-name.html |  119 +-
 .../sort-namespace-members-by-location.adoc   |   14 +
 .../sort-namespace-members-by-location.html   |  274 +--
 .../sort-namespace-members-by-location.xml    |   16 +
 .../sort-namespace-members-by-name.adoc       |   14 +
 .../sort-namespace-members-by-name.html       |  274 +--
 .../sort-namespace-members-by-name.xml        |   16 +
 .../config/sort/sort-members.adoc             |   14 +
 .../config/sort/sort-members.html             |  274 +--
 .../golden-tests/config/sort/sort-members.xml |   16 +
 .../golden-tests/config/sort/unordered.adoc   |   14 +
 .../golden-tests/config/sort/unordered.html   |  274 +--
 .../golden-tests/config/sort/unordered.xml    |   16 +
 test-files/golden-tests/core/libcxx.html      |   17 +-
 test-files/golden-tests/core/utf-8.html       |    4 +-
 .../filters/file/include-self.html            |    4 +-
 .../filters/file/include-symlink.html         |    9 +-
 .../filters/file/subdirectories.html          |    9 +-
 .../filters/file/subdirectories2.html         |    9 +-
 .../filters/symbol-name/blacklist_0.html      |   16 +-
 .../symbol-name/excluded-base-class.html      |   44 +-
 .../symbol-name/excluded-namespace-alias.html |    4 +-
 .../filters/symbol-name/extraction-mode.html  |  235 +--
 .../symbol-name/impl-defined-member.html      |   12 +-
 .../filters/symbol-name/whitelist_0.html      |  121 +-
 .../filters/symbol-name/whitelist_0.xml       |    9 +-
 .../symbol-type/nested-private-template.html  |   12 +-
 .../golden-tests/javadoc/brief/brief-1.html   |   18 +-
 .../golden-tests/javadoc/brief/brief-2.html   |   54 +-
 .../golden-tests/javadoc/brief/brief-3.html   |   57 +-
 .../golden-tests/javadoc/brief/brief-4.html   |   16 +-
 .../golden-tests/javadoc/brief/brief-5.html   |   48 +-
 .../golden-tests/javadoc/brief/brief-6.html   |    9 +-
 .../golden-tests/javadoc/code/code.html       |   18 +-
 test-files/golden-tests/javadoc/code/code.xml |   18 +-
 .../javadoc/copybrief/copybrief.html          |   27 +-
 .../javadoc/copydetails/copydetails.html      |   86 +-
 .../javadoc/copydoc/conversion.html           |   77 +-
 .../javadoc/copydoc/decay-params.html         |   67 +-
 .../javadoc/copydoc/fundamental.html          |   59 +-
 .../javadoc/copydoc/no-param.html             |   63 +-
 .../javadoc/copydoc/operator-param.html       |   47 +-
 .../javadoc/copydoc/param-types.adoc          |    4 +-
 .../javadoc/copydoc/param-types.html          |  363 ++--
 .../javadoc/copydoc/qualified.html            |  218 +-
 .../javadoc/copydoc/qualifiers.html           |  151 +-
 .../javadoc/copydoc/template-arguments.html   |  129 +-
 .../golden-tests/javadoc/inline/styled.cpp    |    2 +-
 .../golden-tests/javadoc/inline/styled.html   |   22 +-
 .../golden-tests/javadoc/link/link.adoc       |    2 +-
 .../golden-tests/javadoc/link/link.html       |   11 +-
 test-files/golden-tests/javadoc/lists/li.html |   18 +-
 .../golden-tests/javadoc/lists/listitem.html  |   66 +-
 .../golden-tests/javadoc/paragraph/par-1.adoc |   12 +-
 .../golden-tests/javadoc/paragraph/par-1.html |   68 +-
 .../javadoc/paragraph/para-1.html             |   27 +-
 .../javadoc/paragraph/para-2.html             |    9 +-
 .../javadoc/paragraph/para-3.adoc             |    6 +-
 .../javadoc/paragraph/para-3.html             |   15 +-
 .../golden-tests/javadoc/paragraph/para-3.xml |    5 +-
 .../golden-tests/javadoc/param/param-1.adoc   |    8 +-
 .../golden-tests/javadoc/param/param-1.html   |   41 +-
 .../javadoc/param/param-direction.adoc        |   53 +-
 .../javadoc/param/param-direction.cpp         |   42 +-
 .../javadoc/param/param-direction.html        |  101 +-
 .../javadoc/param/param-direction.xml         |   40 +
 .../javadoc/param/param-duplicate.html        |   78 +-
 .../golden-tests/javadoc/param/param.adoc     |   27 +-
 .../golden-tests/javadoc/param/param.cpp      |   20 +-
 .../golden-tests/javadoc/param/param.html     |   45 +-
 .../golden-tests/javadoc/param/param.xml      |   20 +
 .../golden-tests/javadoc/pre/pre-post.adoc    |    4 +-
 .../golden-tests/javadoc/pre/pre-post.html    |   13 +-
 .../golden-tests/javadoc/ref/broken-ref.html  |   15 +-
 .../javadoc/ref/parent_context.adoc           |    4 +-
 .../javadoc/ref/parent_context.html           |   28 +-
 .../javadoc/ref/parent_context.xml            |    2 +-
 .../golden-tests/javadoc/ref/punctuation.html |   21 +-
 test-files/golden-tests/javadoc/ref/ref.html  |  243 +--
 .../golden-tests/javadoc/relates/relates.html |   29 +-
 .../golden-tests/javadoc/returns/returns.adoc |    4 +-
 .../golden-tests/javadoc/returns/returns.html |   41 +-
 .../golden-tests/javadoc/throw/throw.html     |   11 +-
 .../golden-tests/javadoc/tparam/tparam-1.adoc |    2 +-
 .../golden-tests/javadoc/tparam/tparam-1.cpp  |    2 +-
 .../golden-tests/javadoc/tparam/tparam-1.html |   19 +-
 .../golden-tests/javadoc/tparam/tparam-1.xml  |    2 +
 .../golden-tests/output/canonical_1.html      |   32 +-
 .../golden-tests/snippets/distance.html       |   17 +-
 .../golden-tests/snippets/is_prime.adoc       |    5 +-
 test-files/golden-tests/snippets/is_prime.cpp |    3 +-
 .../golden-tests/snippets/is_prime.html       |   14 +-
 test-files/golden-tests/snippets/is_prime.xml |    6 +-
 test-files/golden-tests/snippets/sqrt.html    |   15 +-
 .../golden-tests/snippets/terminate.adoc      |    3 +
 .../golden-tests/snippets/terminate.html      |   10 +-
 .../golden-tests/symbols/concept/concept.html |   12 +-
 .../symbols/concept/requires-clause.adoc      |    5 +-
 .../symbols/concept/requires-clause.html      |   41 +-
 .../golden-tests/symbols/enum/enum.html       |   38 +-
 .../symbols/function/attributes-2.html        |    4 +-
 .../symbols/function/attributes_1.html        |    4 +-
 .../golden-tests/symbols/function/auto.html   |   13 +-
 .../function/explicit-conv-operator.html      |   60 +-
 .../symbols/function/explicit-ctor.html       |  260 +--
 .../function/explicit-object-parameter.adoc   |    4 +-
 .../function/explicit-object-parameter.html   |   23 +-
 .../symbols/function/function-parm-decay.html |   24 +-
 .../function/function-template-template.html  |    4 +-
 .../symbols/function/function-template.html   |   48 +-
 .../function/function-tparm-decay.html        |   24 +-
 .../golden-tests/symbols/function/mem-fn.html |  160 +-
 .../symbols/function/merge-params.html        |   13 +-
 .../symbols/function/merge-tparams.html       |   13 +-
 .../symbols/function/noreturn.html            |   18 +-
 .../symbols/function/overloaded-op-1.html     |   15 +-
 .../symbols/function/overloaded-op-2.html     |   17 +-
 .../symbols/function/qualified-params.html    |   12 +-
 .../golden-tests/symbols/function/sfinae.adoc |    4 +-
 .../golden-tests/symbols/function/sfinae.html |  143 +-
 .../spec-mem-implicit-instantiation.html      |  120 +-
 .../symbols/function/type-resolution.html     |  200 +-
 .../symbols/function/variadic-function.html   |   20 +-
 .../symbols/guide/explicit-deduct-guide.html  |   20 +-
 .../namespace-alias/namespace-alias-1.html    |    8 +-
 .../namespace-alias/namespace-alias-2.html    |   12 +-
 .../namespace-alias/namespace-alias-3.html    |   12 +-
 .../symbols/namespace/namespace.html          |   48 +-
 .../symbols/overloads/overloads-brief.html    |  299 +--
 .../symbols/overloads/overloads-metadata.html |  114 +-
 .../symbols/overloads/overloads-ostream.adoc  |   12 +
 .../symbols/overloads/overloads-ostream.html  |  119 +-
 .../symbols/overloads/overloads-ostream.xml   |   12 +
 .../symbols/overloads/overloads.adoc          |   20 +-
 .../symbols/overloads/overloads.html          |  164 +-
 .../symbols/overloads/overloads.xml           |   12 +
 .../symbols/record/class-private-alias.html   |    8 +-
 .../record/class-template-partial-spec.html   |   16 +-
 .../symbols/record/class-template-spec.html   |   72 +-
 .../class-template-specializations-1.html     | 1848 +++++------------
 .../class-template-specializations-2.html     |   92 +-
 .../class-template-specializations-3.html     |  256 +--
 .../symbols/record/class-template.html        |   88 +-
 .../symbols/record/conditional-explicit.html  |  113 +-
 .../symbols/record/dtor-overloads.html        |   35 +-
 .../symbols/record/final-class.html           |   28 +-
 .../symbols/record/friend-duplicate.html      |   16 +-
 .../symbols/record/friend-excluded.html       |   16 +-
 .../symbols/record/friend-fn-has-docs.html    |   15 +-
 .../symbols/record/friend-fn-member.adoc      |    2 +-
 .../symbols/record/friend-fn-member.cpp       |    2 +-
 .../symbols/record/friend-fn-member.html      |   45 +-
 .../symbols/record/friend-fn-member.xml       |    1 +
 .../symbols/record/friend-fn-multi-2nd.html   |   21 +-
 .../symbols/record/friend-fn-multi-free.html  |   21 +-
 .../symbols/record/friend-fn-multi.html       |   21 +-
 .../symbols/record/friend-fn.html             |   15 +-
 .../symbols/record/friend-type.html           |   42 +-
 .../symbols/record/local-class.html           |   10 +-
 .../record/out-of-line-record-def.html        |    4 +-
 .../golden-tests/symbols/record/record-1.html |   57 +-
 .../symbols/record/record-access.html         |   48 +-
 .../symbols/record/record-data.html           |   84 +-
 .../symbols/record/record-inheritance.html    |   98 +-
 .../template-specialization-inheritance.html  |   68 +-
 .../golden-tests/symbols/record/union.html    |   28 +-
 .../golden-tests/symbols/record/unnamed.html  |   64 +-
 .../symbols/typedef/alias-template.html       |   20 +-
 .../symbols/typedef/decay-to-primary.html     |   44 +-
 .../typedef/dependency-propagation.html       |   22 +-
 .../implicit-instantiation-member-ref.html    |   44 +-
 .../symbols/using-directive/using-1.html      |    4 +-
 .../symbols/using-enum/using-enum-in-ns.html  |   10 +-
 .../using-enum/using-enum-in-record.html      |   14 +-
 .../symbols/using/using-function-after.html   |   42 +-
 .../using/using-function-and-type.html        |   31 +-
 .../using/using-function-excluded.html        |    9 +-
 .../using/using-function-local-overloads.html |   59 +-
 .../using/using-function-overloads.html       |   55 +-
 .../symbols/using/using-function.html         |   20 +-
 .../using/using-member-conversion.html        |   55 +-
 .../symbols/using/using-member-function.html  |  304 +--
 .../symbols/using/using-multi.html            |   16 +-
 .../symbols/using/using-struct-template.html  |   16 +-
 .../symbols/using/using-struct.html           |   16 +-
 .../using/using-template-function.html        |    8 +-
 .../symbols/using/using-typename.html         |   12 +-
 .../symbols/variable/no_unique_address.html   |   16 +-
 .../symbols/variable/ns-variables.html        |   40 +-
 .../variable/static-data-def-constexpr.html   |   16 +-
 .../symbols/variable/static-data-def.html     |   52 +-
 .../variable/static-data-template.html        |   16 +-
 .../variable/var-inline-constexpr.html        |   40 +-
 .../symbols/variable/var-template.html        |   28 +-
 .../templates/c_mct_expl_inline.html          |   20 +-
 .../templates/c_mct_expl_outside.html         |   20 +-
 .../templates/c_mft_expl_inline.adoc          |    4 +-
 .../templates/c_mft_expl_inline.html          |   23 +-
 .../templates/c_mft_expl_outside.adoc         |    4 +-
 .../templates/c_mft_expl_outside.html         |   23 +-
 .../golden-tests/templates/ct_expl.html       |   16 +-
 .../templates/ct_expl_dependency.html         |    8 +-
 test-files/golden-tests/templates/ct_mc.html  |   12 +-
 .../templates/ct_mc_expl_outside.html         |   24 +-
 test-files/golden-tests/templates/ct_mct.html |   12 +-
 .../templates/ct_mct_expl_inline.html         |   20 +-
 .../templates/ct_mct_expl_outside.html        |   28 +-
 test-files/golden-tests/templates/ct_mf.html  |    8 +-
 .../templates/ct_mf_expl_outside.html         |   16 +-
 test-files/golden-tests/templates/ct_mft.html |    8 +-
 .../templates/ct_mft_expl_inline.adoc         |    4 +-
 .../templates/ct_mft_expl_inline.html         |   23 +-
 .../templates/ct_mft_expl_outside.adoc        |    4 +-
 .../templates/ct_mft_expl_outside.html        |   31 +-
 .../golden-tests/templates/ft_expl.adoc       |    4 +-
 .../golden-tests/templates/ft_expl.html       |   19 +-
 test-files/handlebars/features_test.adoc      |    2 +-
 510 files changed, 16751 insertions(+), 17117 deletions(-)
 create mode 100644 include/mrdocs/ADT/ArrayView.hpp
 create mode 100644 include/mrdocs/ADT/Overload.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Block.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/AdmonitionBlock.hpp
 rename include/mrdocs/Metadata/{Javadoc/Block/Admonish.hpp => DocComment/Block/AdmonitionKind.hpp} (71%)
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/BlockBase.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/BlockCommandNodes.inc
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/BlockKind.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/BlockNodes.inc
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/BriefBlock.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/CodeBlock.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/DefinitionListBlock.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/DefinitionListItem.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/FootnoteDefinitionBlock.hpp
 rename include/mrdocs/Metadata/{Javadoc/Block/Heading.hpp => DocComment/Block/HeadingBlock.hpp} (55%)
 rename include/mrdocs/Metadata/{Javadoc/Block/UnorderedList.hpp => DocComment/Block/ListBlock.hpp} (56%)
 rename include/mrdocs/Metadata/{Javadoc => DocComment}/Block/ListItem.hpp (51%)
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/ListKind.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/MathBlock.hpp
 rename include/mrdocs/Metadata/{Javadoc/Block/Paragraph.hpp => DocComment/Block/ParagraphBlock.hpp} (56%)
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/ParamBlock.hpp
 rename include/mrdocs/Metadata/{Javadoc => DocComment}/Block/ParamDirection.hpp (81%)
 rename include/mrdocs/Metadata/{Javadoc/Block/Postcondition.hpp => DocComment/Block/PostconditionBlock.hpp} (55%)
 rename include/mrdocs/Metadata/{Javadoc/Block/Precondition.hpp => DocComment/Block/PreconditionBlock.hpp} (55%)
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/QuoteBlock.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/ReturnsBlock.hpp
 rename include/mrdocs/Metadata/{Javadoc/Block/See.hpp => DocComment/Block/SeeBlock.hpp} (57%)
 rename include/mrdocs/Metadata/{Javadoc/Block/TParam.hpp => DocComment/Block/TParamBlock.hpp} (58%)
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/TableAlignmentKind.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/TableBlock.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/TableCell.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/TableRow.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Block/ThematicBreakBlock.hpp
 rename include/mrdocs/Metadata/{Javadoc/Block/Throws.hpp => DocComment/Block/ThrowsBlock.hpp} (53%)
 rename include/mrdocs/Metadata/{Javadoc => DocComment}/Inline.hpp (54%)
 create mode 100644 include/mrdocs/Metadata/DocComment/Inline/CodeInline.hpp
 rename include/mrdocs/Metadata/{Javadoc/Inline/CopyDetails.hpp => DocComment/Inline/CopyDetailsInline.hpp} (52%)
 create mode 100644 include/mrdocs/Metadata/DocComment/Inline/EmphInline.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Inline/FootnoteReferenceInline.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Inline/HighlightInline.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Inline/ImageInline.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Inline/InlineBase.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Inline/InlineKind.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Inline/InlineNodes.inc
 create mode 100644 include/mrdocs/Metadata/DocComment/Inline/LineBreakInline.hpp
 rename include/mrdocs/Metadata/{Javadoc/Inline/Link.hpp => DocComment/Inline/LinkInline.hpp} (50%)
 create mode 100644 include/mrdocs/Metadata/DocComment/Inline/MathInline.hpp
 rename include/mrdocs/Metadata/{Javadoc => DocComment}/Inline/Parts.hpp (83%)
 rename include/mrdocs/Metadata/{Javadoc/Inline/Reference.hpp => DocComment/Inline/ReferenceInline.hpp} (54%)
 create mode 100644 include/mrdocs/Metadata/DocComment/Inline/SoftBreakInline.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Inline/StrikethroughInline.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Inline/StrongInline.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Inline/SubscriptInline.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Inline/SuperscriptInline.hpp
 create mode 100644 include/mrdocs/Metadata/DocComment/Inline/TextInline.hpp
 delete mode 100644 include/mrdocs/Metadata/Javadoc.hpp
 delete mode 100644 include/mrdocs/Metadata/Javadoc/Block.hpp
 delete mode 100644 include/mrdocs/Metadata/Javadoc/Block/Admonition.hpp
 delete mode 100644 include/mrdocs/Metadata/Javadoc/Block/BlockBase.hpp
 delete mode 100644 include/mrdocs/Metadata/Javadoc/Block/Brief.hpp
 delete mode 100644 include/mrdocs/Metadata/Javadoc/Block/Code.hpp
 delete mode 100644 include/mrdocs/Metadata/Javadoc/Block/Param.hpp
 delete mode 100644 include/mrdocs/Metadata/Javadoc/Block/Returns.hpp
 delete mode 100644 include/mrdocs/Metadata/Javadoc/Inline/InlineBase.hpp
 delete mode 100644 include/mrdocs/Metadata/Javadoc/Inline/Style.hpp
 delete mode 100644 include/mrdocs/Metadata/Javadoc/Inline/Styled.hpp
 delete mode 100644 include/mrdocs/Metadata/Javadoc/Inline/Text.hpp
 delete mode 100644 include/mrdocs/Metadata/Javadoc/Node.hpp
 delete mode 100644 include/mrdocs/Metadata/Javadoc/Node/NodeBase.hpp
 delete mode 100644 include/mrdocs/Metadata/Javadoc/Node/NodeKind.hpp
 create mode 100644 include/mrdocs/Support/SplitLines.hpp
 create mode 100644 share/mrdocs/addons/generator/adoc/partials/doc/block/admonition.adoc.hbs
 create mode 100644 share/mrdocs/addons/generator/adoc/partials/doc/block/brief.adoc.hbs
 create mode 100644 share/mrdocs/addons/generator/adoc/partials/doc/block/code.adoc.hbs
 create mode 100644 share/mrdocs/addons/generator/adoc/partials/doc/block/list.adoc.hbs
 create mode 100644 share/mrdocs/addons/generator/adoc/partials/doc/block/paragraph.adoc.hbs
 delete mode 100644 share/mrdocs/addons/generator/adoc/partials/javadoc/admonition.adoc.hbs
 delete mode 100644 share/mrdocs/addons/generator/adoc/partials/javadoc/brief.adoc.hbs
 delete mode 100644 share/mrdocs/addons/generator/adoc/partials/javadoc/code.adoc.hbs
 delete mode 100644 share/mrdocs/addons/generator/adoc/partials/javadoc/description.adoc.hbs
 delete mode 100644 share/mrdocs/addons/generator/adoc/partials/javadoc/heading.adoc.hbs
 delete mode 100644 share/mrdocs/addons/generator/adoc/partials/javadoc/paragraph.adoc.hbs
 delete mode 100644 share/mrdocs/addons/generator/adoc/partials/javadoc/unordered_list.adoc.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block-container.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/admonition.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/brief.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/code.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/definition-list.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/document.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/footnote-definition.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/heading.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/inline-brief.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/list.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/math.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/paragraph.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/param.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/postcondition.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/precondition.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/quote.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/returns.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/see.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/t-param.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/table.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/thematic-break.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/block/throws.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/inline-container.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/inline.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/inline/code.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/inline/emph.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/inline/footnote-reference.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/inline/highlight.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/inline/image.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/inline/line-break.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/inline/link.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/inline/math.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/inline/reference.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/inline/soft-break.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/inline/strikethrough.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/inline/strong.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/inline/subscript.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/inline/superscript.hbs
 create mode 100644 share/mrdocs/addons/generator/common/partials/doc/inline/text.hbs
 delete mode 100644 share/mrdocs/addons/generator/common/partials/javadoc/any-block.hbs
 delete mode 100644 share/mrdocs/addons/generator/common/partials/javadoc/any-text.hbs
 delete mode 100644 share/mrdocs/addons/generator/common/partials/javadoc/block.hbs
 delete mode 100644 share/mrdocs/addons/generator/common/partials/javadoc/brief.hbs
 delete mode 100644 share/mrdocs/addons/generator/common/partials/javadoc/inline-brief.hbs
 delete mode 100644 share/mrdocs/addons/generator/common/partials/javadoc/link.hbs
 delete mode 100644 share/mrdocs/addons/generator/common/partials/javadoc/reference.hbs
 delete mode 100644 share/mrdocs/addons/generator/common/partials/javadoc/returns.hbs
 delete mode 100644 share/mrdocs/addons/generator/common/partials/javadoc/see.hbs
 delete mode 100644 share/mrdocs/addons/generator/common/partials/javadoc/styled.hbs
 delete mode 100644 share/mrdocs/addons/generator/common/partials/javadoc/styled/bold.hbs
 delete mode 100644 share/mrdocs/addons/generator/common/partials/javadoc/styled/italic.hbs
 delete mode 100644 share/mrdocs/addons/generator/common/partials/javadoc/styled/mono.hbs
 delete mode 100644 share/mrdocs/addons/generator/common/partials/javadoc/text.hbs
 rename share/mrdocs/addons/generator/html/partials/{javadoc => doc/block}/admonition.html.hbs (50%)
 create mode 100644 share/mrdocs/addons/generator/html/partials/doc/block/code.html.hbs
 create mode 100644 share/mrdocs/addons/generator/html/partials/doc/block/list.html.hbs
 create mode 100644 share/mrdocs/addons/generator/html/partials/doc/block/paragraph.html.hbs
 delete mode 100644 share/mrdocs/addons/generator/html/partials/javadoc/code.html.hbs
 delete mode 100644 share/mrdocs/addons/generator/html/partials/javadoc/description.html.hbs
 delete mode 100644 share/mrdocs/addons/generator/html/partials/javadoc/heading.html.hbs
 delete mode 100644 share/mrdocs/addons/generator/html/partials/javadoc/paragraph.html.hbs
 delete mode 100644 share/mrdocs/addons/generator/html/partials/javadoc/unordered_list.html.hbs
 create mode 100644 src/lib/AST/ExtractDocComment.cpp
 rename src/lib/AST/{ParseJavadoc.hpp => ExtractDocComment.hpp} (72%)
 delete mode 100644 src/lib/AST/ParseJavadoc.cpp
 create mode 100644 src/lib/Metadata/DocComment.cpp
 create mode 100644 src/lib/Metadata/DocComment/Block.cpp
 create mode 100644 src/lib/Metadata/DocComment/Block/BlockBase.cpp
 create mode 100644 src/lib/Metadata/DocComment/Inline.cpp
 create mode 100644 src/lib/Metadata/DocComment/Inline/InlineBase.cpp
 rename src/lib/Metadata/Finalizers/{Javadoc => DocComment}/Function.hpp (80%)
 rename src/lib/Metadata/Finalizers/{Javadoc => DocComment}/Overloads.hpp (64%)
 create mode 100644 src/lib/Metadata/Finalizers/DocComment/parseInlines.hpp
 rename src/lib/Metadata/Finalizers/{JavadocFinalizer.cpp => DocCommentFinalizer.cpp} (54%)
 create mode 100644 src/lib/Metadata/Finalizers/DocCommentFinalizer.hpp
 delete mode 100644 src/lib/Metadata/Finalizers/JavadocFinalizer.hpp
 delete mode 100644 src/lib/Metadata/Javadoc.cpp
 rename src/lib/Metadata/{Info => Symbol}/Concept.cpp (100%)
 rename src/lib/Metadata/{Info => Symbol}/Enum.cpp (100%)
 rename src/lib/Metadata/{Info => Symbol}/EnumConstant.cpp (100%)
 rename src/lib/Metadata/{Info => Symbol}/Friend.cpp (100%)
 rename src/lib/Metadata/{Info => Symbol}/Function.cpp (100%)
 rename src/lib/Metadata/{Info => Symbol}/Guide.cpp (100%)
 rename src/lib/Metadata/{Info => Symbol}/Namespace.cpp (100%)
 rename src/lib/Metadata/{Info => Symbol}/NamespaceAlias.cpp (100%)
 rename src/lib/Metadata/{Info => Symbol}/Overloads.cpp (100%)
 rename src/lib/Metadata/{Info => Symbol}/Record.cpp (100%)
 rename src/lib/Metadata/{Info => Symbol}/Typedef.cpp (100%)
 rename src/lib/Metadata/{Info => Symbol}/Using.cpp (100%)
 rename src/lib/Metadata/{Info => Symbol}/Variable.cpp (100%)
 create mode 100644 src/test/ADT/ArrayView.cpp
 create mode 100644 src/test/lib/Metadata/Finalizers/Javadoc/parseInlines.cpp

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 3c24266be..67a8598a1 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -497,6 +497,71 @@ jobs:
           # The schema in the docs folder is valid
           npx -y -p ajv-cli -- ajv compile -s docs/mrdocs.schema.json
 
+      - name: Verify snippet .cpp files match golden tests (bash)
+        shell: bash
+        run: |
+          set -euo pipefail
+          shopt -s nullglob
+          
+          SRC="docs/website/snippets"
+          DST="test-files/golden-tests/snippets"
+          
+          [[ -d "$SRC" ]] || { echo "Source directory not found: $SRC"; exit 2; }
+          [[ -d "$DST" ]] || { echo "Destination directory not found: $DST"; exit 2; }
+          
+          missing=()
+          mismatched=()
+          
+          # Walk all .cpp files under SRC
+          while IFS= read -r -d '' src; do
+            rel="${src#$SRC/}"
+            dst="$DST/$rel"
+          
+            if [[ ! -f "$dst" ]]; then
+              missing+=("$rel")
+              continue
+            fi
+          
+            if [[ "${STRICT_EOL:-0}" == "1" ]]; then
+              # strict byte-for-byte comparison
+              if ! cmp -s -- "$src" "$dst"; then
+                mismatched+=("$rel")
+              fi
+            else
+              # ignore CRLF/LF differences using git diff (available on all runners)
+              if ! git diff --no-index --ignore-cr-at-eol --quiet -- "$src" "$dst"; then
+                mismatched+=("$rel")
+              fi
+            fi
+          done < <(find "$SRC" -type f -name '*.cpp' -print0)
+          
+          if (( ${#missing[@]} || ${#mismatched[@]} )); then
+            if (( ${#missing[@]} )); then
+              echo "Missing corresponding golden files:"
+              printf '  %s\n' "${missing[@]}"
+            fi
+            if (( ${#mismatched[@]} )); then
+              echo "Content mismatches:"
+              printf '  %s\n' "${mismatched[@]}"
+            fi
+            exit 1
+          fi
+          
+          echo "All snippet .cpp files are present and match."
+        env:
+          # Set to "1" to enforce byte-for-byte equality (do not ignore CRLF/LF)
+          STRICT_EOL: "0"
+
+
+      - name: Check landing page snippets
+        run: |
+          # Find python
+          python=$(command -v python3 || command -v python)
+          # The schema in this branch is up to date 
+          "$python" ./util/generate-yaml-schema.py --check
+          # The schema in the docs folder is valid
+          npx -y -p ajv-cli -- ajv compile -s docs/mrdocs.schema.json
+
       - name: Upload GitHub Release Artifacts
         if: ${{ matrix.is-main && matrix.compiler != 'clang' }}
         uses: actions/upload-artifact@v4
diff --git a/docs/modules/ROOT/pages/commands.adoc b/docs/modules/ROOT/pages/commands.adoc
index 76f8d0cd9..15d99ef8c 100644
--- a/docs/modules/ROOT/pages/commands.adoc
+++ b/docs/modules/ROOT/pages/commands.adoc
@@ -1,6 +1,6 @@
 = Commands
 
-The code should be documented with the https://docs.oracle.com/en/java/javase/13/docs/specs/javadoc/doc-comment-spec.html[Doc Comment,window=_blank] format, also informally known as "javadoc" format or Doxygen-style comments.
+The code should be documented with the https://docs.oracle.com/en/java/javase/13/docs/specs/javadoc/doc-comment-spec.html[Doc Comment,window=_blank] format, also informally known as Javadoc-style or Doxygen-style comments.
 
 In its most basic form, these are usually comment blocks between `pass:[/**]` and `pass:[*/]` placed above a class, function, or field declaration:
 
@@ -43,6 +43,64 @@ Most doc comments will contain these two sections, which could also be explicitl
 Doc comments can also contain many special commands, such as `@param`, that are used to document the parameters of a function.
 Mr. Docs supports most commands commonly used in Javadoc and Doxygen comments.
 
+== Documentation Comment Formats
+
+The documentation format used by MrDocs has its roots in earlier tools and languages. It is based on writing structured comments directly in the source code, which are then parsed to generate API reference documentation.
+
+* **Origins: Javadoc**: The format originated with Java and the `doc` tool.
+The https://docs.oracle.com/en/java/javase/17/docs/specs/doc/doc-comment-spec.html[official specification] consistently calls these comments *Documentation Comments*, often abbreviated as "doc comments". In practice, many developers also refer to them as *Javadoc-style comments* due to their close association with the `doc` tool.
+* **Doxygen**: When Doxygen was created to support C, C++, and other languages, it adopted a similar comment style. In its https://www.doxygen.nl/manual/docblocks.html[documentation section about this comment style], Doxygen calls these comments *comment blocks*, but also explains them as *Javadoc style comments* for users familiar with the Java ecosystem. This established the convention of using the same recognizable syntax (`/** ... */`) across different ecosystems.
+* **JSDoc**: For JavaScript, the https://jsdoc.app/[JSDoc] tool introduced the same concept. Developers usually refer to them as *JSDoc comments*, again following the tradition of naming the comments after the tool.
+
+Other ecosystems have adopted similar approaches and comment styles, sometimes with different syntax:
+
+- C#: XML documentation comments (`/// ...`)
+- Rust: doc comments (`/// ...` and `//! ...`)
+- Swift: markup-based documentation comments (`/// ...`)
+
+[cols="1,1,2,2",options="header"]
+|===
+| Language | Tool | Official Term | Common Term
+
+| Java
+| Javadoc
+| https://docs.oracle.com/en/java/javase/17/docs/specs/doc/doc-comment-spec.html[Documentation comments]
+| Javadoc-style comments
+
+| C, C++, etc.
+| Doxygen
+| https://www.doxygen.nl/manual/docblocks.html[Comment blocks]
+| Doxygen-style comments
+
+| JavaScript
+| JSDoc
+| https://jsdoc.app/[JSDoc comments]
+| -
+
+| C#
+| XML Documentation Comments
+| https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/xmldoc/[XML documentation comments]
+| -
+
+| Rust
+| Rustdoc
+| https://doc.rust-lang.org/rustdoc/the-doc-attribute.html[Doc comments]
+| -
+
+| Swift
+| Swift Markup
+| https://developer.apple.com/library/archive/documentation/Xcode/Reference/xcode_markup_formatting_ref/[Markup documentation comments]
+| -
+|===
+
+Briefly summarizing the table above:
+
+- The original term, from Java, is *doc comments*. Other tools follow a similar convention.
+- Many tools and communities prefer to call them after the tool name, e.g. *Javadoc-style comments*, *Doxygen-style comments*, or *JSDoc-style comments*.
+- MrDocs follows this tradition by supporting a familiar syntax that developers across ecosystems already recognize.
+
+
+
 // == Style
 //
 // The following commands can be used to format the text in the doc comments:
diff --git a/docs/modules/ROOT/pages/contribute.adoc b/docs/modules/ROOT/pages/contribute.adoc
index b60d96caf..1d9e2b0d6 100644
--- a/docs/modules/ROOT/pages/contribute.adoc
+++ b/docs/modules/ROOT/pages/contribute.adoc
@@ -49,7 +49,7 @@ As a last step, `DoGenerateAction` converts the public `Config` settings into a
 [#representing_symbols]
 == Representing Symbols
 
-MrDocs has many categories of objects, where we utilize polymorphism with a fixed set of valid derived types, including Symbols (functions, classes, and enums), Javadoc blocks, template parameters, template arguments, and data types. For each such family, we follow a consistent file layout. Most of these families are defined in the `mrdocs/Metadata` directory.
+MrDocs has many categories of objects, where we utilize polymorphism with a fixed set of valid derived types, including Symbols (functions, classes, and enums), DocComment blocks, template parameters, template arguments, and data types. For each such family, we follow a consistent file layout. Most of these families are defined in the `mrdocs/Metadata` directory.
 
 Each base class is defined in its own header and, when necessary, implementation file. Each derived class also has its own header and implementation file. Finally, there is a single aggregator header file that includes all the derived headers. This file centralizes logic that requires knowledge of the full set of variants, such as visitors, comparison operators, and other operations that depend on the discriminator.
 
@@ -144,7 +144,7 @@ are merged into a map containing the merged results from all other TUs.
 The merging step is necessary as there may be multiple identical definitions of the same entity.
 For instance, this represents the case where a function is declared at different points in the code base and might have different attributes or comments.
 At this step, the doc comments are also finalized.
-Each `Symbol` object has a pointer to its `Javadoc`  object (`mrdocs/Metadata/Javadoc.hpp`), which is a representation of the documentation comments.
+Each `Symbol` object has a pointer to its `DocComment`  object (`mrdocs/Metadata/DocComment.hpp`), which is a representation of the documentation comments.
 
 After AST traversal and `Symbol` merging, the result is stored as a map of `Symbol` objects indexed by their respective `SymbolID`.
 A second finalization step is then performed in `mrdocs::finalize`, where any references to `SymbolID` objects that don't exist are removed.
diff --git a/docs/modules/ROOT/pages/index.adoc b/docs/modules/ROOT/pages/index.adoc
index 174b1b38a..8a4033b47 100644
--- a/docs/modules/ROOT/pages/index.adoc
+++ b/docs/modules/ROOT/pages/index.adoc
@@ -1,6 +1,6 @@
 = Mr.Docs
 Alan Freitas <alandefreitas@gmail.com>
-:description: Mr.Docs: A Clang/LLVM tool for building reference documentation from C++ code and javadoc comments.
+:description: Mr.Docs: A Clang/LLVM tool for building reference documentation from C++ code and documentation comments.
 :sectanchors:
 :url-repo: https://github.com/cppalliance/mrdocs
 :page-tags: mrdocs
diff --git a/docs/website/snippets/is_prime.cpp b/docs/website/snippets/is_prime.cpp
index b13810c01..9330eaf30 100644
--- a/docs/website/snippets/is_prime.cpp
+++ b/docs/website/snippets/is_prime.cpp
@@ -4,9 +4,8 @@
 
     Linear in n.
 
-    @return Whether or not n is prime.
+    @return Whether `n` is prime.
     @param n The number to test
-
 */
 bool
 is_prime(unsigned long long n) noexcept;
\ No newline at end of file
diff --git a/include/mrdocs/ADT/ArrayView.hpp b/include/mrdocs/ADT/ArrayView.hpp
new file mode 100644
index 000000000..1341c032a
--- /dev/null
+++ b/include/mrdocs/ADT/ArrayView.hpp
@@ -0,0 +1,167 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_ADT_ARRAYVIEW_HPP
+#define MRDOCS_API_ADT_ARRAYVIEW_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <algorithm>
+#include <cassert>
+#include <compare>
+#include <cstddef>
+#include <iterator>
+#include <memory>
+#include <type_traits>
+
+namespace mrdocs {
+
+/** A non-owning, read-only view over a contiguous array of T.
+
+    Similar to std::string_view but for arbitrary element type T.
+*/
+template <class T>
+class ArrayView {
+    static_assert(!std::is_void_v<T>, "ArrayView<void> is ill-formed");
+
+public:
+    // types
+    using value_type             = T;
+    using size_type              = std::size_t;
+    using difference_type        = std::ptrdiff_t;
+    using pointer                = const T*;
+    using const_pointer          = const T*;
+    using reference              = const T&;
+    using const_reference        = const T&;
+    using iterator               = const T*;
+    using const_iterator         = const T*;
+    using reverse_iterator       = std::reverse_iterator<const_iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+    static constexpr size_type npos = static_cast<size_type>(-1);
+
+    // ctors
+    constexpr ArrayView() noexcept = default;
+
+    constexpr ArrayView(const T* data, size_type count) noexcept
+        : data_(data), size_(count) {}
+
+    template <size_type N>
+    constexpr ArrayView(const T (&arr)[N]) noexcept
+        : data_(arr), size_(N) {}
+
+    template <class It>
+    requires (std::contiguous_iterator<It> &&
+             std::same_as<std::remove_cv_t<std::remove_reference_t<std::iter_value_t<It>>>, T>)
+    constexpr ArrayView(It first, size_type count) noexcept
+        : data_(std::to_address(first)), size_(count) {}
+
+    // iterators
+    constexpr const_iterator begin()  const noexcept { return data_; }
+    constexpr const_iterator end()    const noexcept { return data_ + size_; }
+    constexpr const_iterator cbegin() const noexcept { return begin(); }
+    constexpr const_iterator cend()   const noexcept { return end(); }
+    constexpr const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
+    constexpr const_reverse_iterator rend()   const noexcept { return const_reverse_iterator(begin()); }
+
+    // capacity
+    constexpr size_type size()   const noexcept { return size_; }
+    constexpr size_type length() const noexcept { return size_; }
+    [[nodiscard]] constexpr bool empty() const noexcept { return size_ == 0; }
+
+    // element access
+    constexpr const_reference operator[](size_type i) const noexcept {
+        return data_[i];
+    }
+    constexpr const_reference at(size_type i) const {
+        assert(i < size_);
+        return data_[i];
+    }
+    constexpr const_reference front() const {
+        assert(!empty());
+        return data_[0];
+    }
+    constexpr const_reference back() const {
+        assert(!empty());
+        return data_[size_ - 1];
+    }
+    constexpr const_pointer data() const noexcept { return data_; }
+
+    // modifiers (adjust the view; do not touch underlying data)
+    constexpr void remove_prefix(size_type n) noexcept {
+        assert(n <= size_);
+        data_ += n;
+        size_ -= n;
+    }
+    constexpr void remove_suffix(size_type n) noexcept {
+        assert(n <= size_);
+        size_ -= n;
+    }
+
+    // slicing
+    constexpr ArrayView slice(size_type pos, size_type count = npos) const noexcept {
+        assert(pos <= size_);
+        const size_type rcount = (count == npos || pos + count > size_) ? (size_ - pos) : count;
+        return ArrayView(data_ + pos, rcount);
+    }
+    constexpr ArrayView take_front(size_type n) const noexcept {
+        return slice(0, n <= size_ ? n : size_);
+    }
+    constexpr ArrayView take_back(size_type n) const noexcept {
+        n = (n <= size_) ? n : size_;
+        return slice(size_ - n, n);
+    }
+    constexpr ArrayView drop_front(size_type n) const noexcept {
+        return (n >= size_) ? ArrayView() : ArrayView(data_ + n, size_ - n);
+    }
+    constexpr ArrayView drop_back(size_type n) const noexcept {
+        return (n >= size_) ? ArrayView() : ArrayView(data_, size_ - n);
+    }
+
+    // comparisons
+    friend constexpr bool operator==(ArrayView a, ArrayView b) noexcept
+    requires requires (const T& x, const T& y) { { x == y } -> std::convertible_to<bool>; }
+    {
+        return a.size_ == b.size_ && std::equal(a.begin(), a.end(), b.begin());
+    }
+
+    friend constexpr auto operator<=>(ArrayView a, ArrayView b) noexcept
+    requires requires (const T& x, const T& y) { x <=> y; }
+    {
+        return std::lexicographical_compare_three_way(
+            a.begin(), a.end(), b.begin(), b.end(), std::compare_three_way{});
+    }
+
+private:
+    const T* data_ = nullptr;
+    size_type size_ = 0;
+};
+
+// deduction guides
+template <class T>
+ArrayView(const T*, std::size_t) -> ArrayView<T>;
+
+template <class T, std::size_t N>
+ArrayView(const T (&)[N]) -> ArrayView<T>;
+
+// helpers
+template <class T>
+constexpr ArrayView<T> make_array_view(const T* data, std::size_t count) noexcept {
+    return ArrayView<T>(data, count);
+}
+
+template <class T, std::size_t N>
+constexpr ArrayView<T> make_array_view(const T (&arr)[N]) noexcept {
+    return ArrayView<T>(arr);
+}
+
+} // mrdocs
+
+#endif // MRDOCS_API_ADT_ARRAYVIEW_HPP
diff --git a/include/mrdocs/ADT/Nullable.hpp b/include/mrdocs/ADT/Nullable.hpp
index 8b81c6618..ba659db60 100644
--- a/include/mrdocs/ADT/Nullable.hpp
+++ b/include/mrdocs/ADT/Nullable.hpp
@@ -137,8 +137,10 @@ struct sentinel_traits<T>
 **/
 template <typename T>
 requires std::is_enum_v<T> &&
-         (requires { T::Unknown; } ||
+         (requires { T::unknown; } ||
+          requires { T::Unknown; } ||
           requires { T::UNKNOWN; } ||
+          requires { T::none; } ||
           requires { T::None; } ||
           requires { T::NONE; })
 struct sentinel_traits<T>
@@ -183,13 +185,45 @@ concept HasSentinel =
     std::optional, std::unique_ptr, std::shared_ptr, and many more.
 **/
 template<class T>
-concept ClearableEmpty =
-    std::default_initializable<T> &&
-    requires(T& t, const T& ct)
-    {
+concept ClearableContainerLike =
+    // ---- nested container typedefs present ----
+    requires {
+        typename T::value_type;
+        typename T::size_type;
+        typename T::difference_type;
+        typename T::reference;
+        typename T::const_reference;
+        typename T::iterator;
+        typename T::const_iterator;
+    } &&
+    // size_type should be integral for normal containers
+    std::is_integral_v<typename T::size_type> &&
+
+    // ---- member begin/end with expected iterator types ----
+    requires(T& t, const T& ct) {
+        { t.begin() }  -> std::convertible_to<typename T::iterator>;
+        { t.end() }    -> std::convertible_to<typename T::iterator>;
+        { ct.begin() } -> std::convertible_to<typename T::const_iterator>;
+        { ct.end() }   -> std::convertible_to<typename T::const_iterator>;
+    } &&
+
+    // ---- iterator “shape”: deref and increment ----
+    requires(T& t, const T& ct) {
+        { *t.begin() }  -> std::convertible_to<typename T::reference>;
+        { *ct.begin() } -> std::convertible_to<typename T::const_reference>;
+        { ++std::declval<typename T::iterator&>() } -> std::same_as<typename T::iterator&>;
+    } &&
+
+    // ---- size/empty/clear trio ----
+    requires(T& t, const T& ct) {
+        { ct.size() }  -> std::same_as<typename T::size_type>;
         { ct.empty() } -> std::convertible_to<bool>;
-        { t.clear() } -> std::same_as<void>;
-    };
+        { t.clear() }  -> std::same_as<void>;
+    } &&
+
+    // ---- default constructible (most std containers satisfy this) ----
+    std::default_initializable<T>;
+
 
 /** nullable_traits<T> defines how to treat a T as “nullable” without an
    external engaged bit.
@@ -245,7 +279,7 @@ struct nullable_traits<T>
     and erases via clear().
 **/
 template<class T>
-requires (!HasSentinel<T> && ClearableEmpty<T>)
+requires (!HasSentinel<T> && ClearableContainerLike<T>)
 struct nullable_traits<T>
 {
     static constexpr bool
diff --git a/include/mrdocs/ADT/Optional.hpp b/include/mrdocs/ADT/Optional.hpp
index 7f0bd4e94..5014344d5 100644
--- a/include/mrdocs/ADT/Optional.hpp
+++ b/include/mrdocs/ADT/Optional.hpp
@@ -540,13 +540,13 @@ class Optional {
     constexpr value_type*
     operator->() noexcept
     {
-        MRDOCS_ASSERT(has_value());
         if constexpr (uses_nullable_traits)
         {
             return std::addressof(s_);
         }
         else
         {
+            MRDOCS_ASSERT(has_value());
             return std::addressof(*s_);
         }
     }
@@ -555,13 +555,13 @@ class Optional {
     constexpr value_type const*
     operator->() const noexcept
     {
-        MRDOCS_ASSERT(has_value());
         if constexpr (uses_nullable_traits)
         {
             return std::addressof(s_);
         }
         else
         {
+            MRDOCS_ASSERT(has_value());
             return std::addressof(*s_);
         }
     }
@@ -573,13 +573,13 @@ class Optional {
     constexpr value_type&
     operator*() noexcept
     {
-        MRDOCS_ASSERT(has_value());
         if constexpr (uses_nullable_traits)
         {
             return s_;
         }
         else
         {
+            MRDOCS_ASSERT(has_value());
             return *s_;
         }
     }
@@ -588,13 +588,13 @@ class Optional {
     constexpr value_type const&
     operator*() const noexcept
     {
-        MRDOCS_ASSERT(has_value());
         if constexpr (uses_nullable_traits)
         {
             return s_;
         }
         else
         {
+            MRDOCS_ASSERT(has_value());
             return *s_;
         }
     }
diff --git a/include/mrdocs/ADT/Overload.hpp b/include/mrdocs/ADT/Overload.hpp
new file mode 100644
index 000000000..a94c6a1ea
--- /dev/null
+++ b/include/mrdocs/ADT/Overload.hpp
@@ -0,0 +1,246 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_ADT_OVERLOAD_HPP
+#define MRDOCS_API_ADT_OVERLOAD_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+#include <variant>
+
+namespace mrdocs {
+
+/** Combines multiple callable types into a single overloaded function object.
+
+    This is the canonical "overloaded pattern" implemented as a class template.
+    It inherits from all provided callables and brings in their operator()s,
+    so the resulting object can be called with whichever overload matches.
+
+    Typical use-cases include visiting std::variant and building small ad-hoc
+    pattern-matching style dispatchers.
+
+    @tparam Ts The callable types to combine (lambdas, function objects, etc.)
+
+    @example
+    @code
+    auto f = fn::makeOverload(
+     [](int i) { return i * 2; },
+     [](const std::string& s) { return s.size(); }
+    );
+    auto a = f(21);        // calls int overload
+    auto b = f(std::string("hello")); // calls string overload
+    @endcode
+ */
+template<class... Ts>
+struct Overload : Ts... {
+    using Ts::operator()...;
+
+    /** Constructs an Overload from the given callables.
+
+        @param xs The callables to store.
+     */
+    constexpr explicit Overload(Ts... xs)
+        noexcept((std::is_nothrow_move_constructible_v<Ts> && ...))
+        : Ts(std::move(xs))... {}
+};
+
+/** Class template argument deduction guide for Overload.
+
+    Allows writing Overload{lambda1, lambda2, ...} without
+    specifying template parameters.
+ */
+template<class... Ts>
+Overload(Ts...) -> Overload<Ts...>;
+
+/** Factory function that creates an Overload from the given callables.
+
+    Prefer this over constructing Overload directly when you need perfect
+    forwarding and decayed storage.
+
+    @param xs The callables to combine.
+    @return An Overload whose base classes are the decayed types of the provided callables.
+
+    @example
+    @code
+    auto visitor = fn::makeOverload(
+         [](int) { return 1; },
+         [](double) { return 2; }
+    );
+    @endcode
+
+ */
+template<class... Ts>
+[[nodiscard]] constexpr auto makeOverload(Ts&&... xs)
+    noexcept((std::is_nothrow_constructible_v<std::decay_t<Ts>, Ts&&> && ...))
+        -> Overload<std::decay_t<Ts>...>
+{
+    return Overload<std::decay_t<Ts>...>(std::forward<Ts>(xs)...);
+}
+
+/** Applies a set of callables to a std::variant using std::visit and Overload.
+
+    This is a convenience wrapper around std::visit(makeOverload(...), variant).
+    It forwards the variant and the callables and returns whatever std::visit
+    returns.
+
+    @param v The variant to visit (can be lvalue or rvalue; const-qualification is preserved).
+    @param xs The callables to be combined with makeOverload and passed to std::visit.
+    @return The result of std::visit.
+
+    @example
+    @code
+    std::variant<int, std::string> v = 42;
+    auto r = fn::match(v,
+        [](int i) { return i + 1; },
+        [](const std::string& s) { return s.size(); }
+    );
+    @endcode
+ */
+template<class Variant, class... Ts>
+constexpr decltype(auto) match(Variant&& v, Ts&&... xs)
+{
+    return std::visit(
+        makeOverload(std::forward<Ts>(xs)...),
+        std::forward<Variant>(v));
+}
+
+/** Visits a std::variant and calls the combined callable with the active
+    index and the value.
+
+    Unlike match, visitIndexed passes an additional first parameter to your
+    callable set: the runtime index of the active alternative (as a std::size_t).
+
+    This is useful when you need both the value and which alternative was
+    selected, without relying on type-unique alternatives.
+
+    The supplied callables are combined via makeOverload and are expected to
+    accept a signature like (std::size_t index, T value) for the relevant T.
+
+    @param v The variant to visit.
+    @param xs The callables to be combined with makeOverload and invoked with (index, value).
+    @return The result of invoking the selected callable.
+
+    @example
+    @code
+    std::variant<int, double, std::string> v = 3.14;
+    fn::visitIndexed(v,
+        [](std::size_t i, int x) { return i + x; },
+        [](std::size_t i, double d) { return d + i; },
+        [](std::size_t i, const std::string& s) { return s.size() + i; });
+    @endcode
+ */
+template<class Variant, class... Ts>
+constexpr decltype(auto) visitIndexed(Variant&& v, Ts&&... xs)
+{
+    auto f = makeOverload(std::forward<Ts>(xs)...);
+    const std::size_t idx = std::as_const(v).index();
+    return std::visit(
+        [&](auto&& val) -> decltype(auto) {
+        return f(idx, std::forward<decltype(val)>(val));
+    },
+        std::forward<Variant>(v)
+    );
+}
+
+/** Enables recursive lambdas by passing a self-reference as the first argument.
+
+    YCombinator stores a callable F and exposes operator() that forwards
+    arguments to F, prepending a reference to *this so that F can recurse.
+
+    Overloads are provided for &, const&, &&, const&& to preserve value
+    category.
+
+    @tparam F The callable to wrap.
+
+    @example
+    auto fact = fn::yCombinator(
+        [](auto self, int n) -> long long {
+            return n <= 1 ? 1 : n * self(n - 1);
+        });
+    auto r = fact(10);
+    @endcode
+ */
+template<class F>
+class YCombinator {
+public:
+    /** Constructs a YCombinator from the given callable.
+
+        @param f The callable to store.
+     */
+    constexpr explicit YCombinator(F f)
+        noexcept(std::is_nothrow_move_constructible_v<F>)
+        : f_(std::move(f)) {}
+
+    /** Invokes the stored callable, passing *this as the first parameter.
+
+         @param args The arguments to forward to the callable after the self reference.
+         @return Whatever the callable returns.
+     */
+    template<class... Args>
+    constexpr decltype(auto) operator()(Args&&... args) &
+    {
+        return f_(*this, std::forward<Args>(args)...);
+    }
+
+    /** Const lvalue overload of operator().
+     */
+    template<class... Args>
+    constexpr decltype(auto) operator()(Args&&... args) const &
+    {
+        return f_(*this, std::forward<Args>(args)...);
+    }
+
+    /** Rvalue overload of operator().
+     */
+    template<class... Args>
+    constexpr decltype(auto) operator()(Args&&... args) &&
+    {
+        return std::move(f_)(*this, std::forward<Args>(args)...);
+    }
+
+    /** Const rvalue overload of operator().
+     */
+    template<class... Args>
+    constexpr decltype(auto) operator()(Args&&... args) const &&
+    {
+        return std::move(f_)(*this, std::forward<Args>(args)...);
+    }
+
+private:
+    F f_;
+};
+
+/** Factory that creates a YCombinator from a callable.
+
+    Prefer this helper to avoid spelling template arguments explicitly.
+
+    @param f The callable to wrap.
+    @return A YCombinator storing a decayed copy of the callable.
+
+    @example
+    auto fib = fn::yCombinator(
+        [](auto self, int n) -> int {
+            return n <= 1 ? n : self(n - 1) + self(n - 2);
+        });
+ */
+template<class F>
+[[nodiscard]] constexpr auto yCombinator(F&& f)
+    noexcept(std::is_nothrow_constructible_v<std::decay_t<F>, F&&>)
+        -> YCombinator<std::decay_t<F>>
+{
+    return YCombinator<std::decay_t<F>>(std::forward<F>(f));
+}
+
+} // mrdocs
+
+#endif // MRDOCS_API_ADT_OVERLOAD_HPP
diff --git a/include/mrdocs/ADT/Polymorphic.hpp b/include/mrdocs/ADT/Polymorphic.hpp
index 2f9f7fb70..e9be2396b 100644
--- a/include/mrdocs/ADT/Polymorphic.hpp
+++ b/include/mrdocs/ADT/Polymorphic.hpp
@@ -281,6 +281,128 @@ struct nullable_traits<Polymorphic<T>>
     }
 };
 
+//------------------------------------------------------------------------------
+// isa<T>(p)
+//------------------------------------------------------------------------------
+
+template <class To, class From>
+requires ( std::derived_from<std::remove_cvref_t<To>, std::remove_cvref_t<From>> )
+[[nodiscard]] inline bool
+isa(const Polymorphic<From>& p) noexcept
+{
+    if (p.valueless_after_move()) return false;
+    using ToU = std::remove_reference_t<To>;
+    return dynamic_cast<const ToU*>(std::addressof(*p)) != nullptr;
+}
+
+template <class To, class From>
+requires ( std::derived_from<std::remove_cvref_t<To>, std::remove_cvref_t<From>> )
+[[nodiscard]] inline bool
+isa_or_null(const Polymorphic<From>* pp) noexcept
+{
+    return pp && isa<To>(*pp);
+}
+
+//------------------------------------------------------------------------------
+// dyn_cast<T>(p)  → pointer (nullptr if not)
+//------------------------------------------------------------------------------
+
+template <class To, class From>
+requires ( std::derived_from<std::remove_cvref_t<To>, std::remove_cvref_t<From>> )
+[[nodiscard]] inline auto
+dyn_cast(Polymorphic<From>& p) noexcept
+    -> std::add_pointer_t<std::remove_reference_t<To>>
+{
+    if (p.valueless_after_move()) return nullptr;
+    using ToU = std::remove_reference_t<To>;
+    return dynamic_cast<ToU*>(std::addressof(*p));
+}
+
+template <class To, class From>
+requires ( std::derived_from<std::remove_cvref_t<To>, std::remove_cvref_t<From>> )
+[[nodiscard]] inline auto
+dyn_cast(const Polymorphic<From>& p) noexcept
+    -> std::add_pointer_t<const std::remove_reference_t<To>>
+{
+    if (p.valueless_after_move()) return nullptr;
+    using ToU = std::remove_reference_t<To>;
+    return dynamic_cast<const ToU*>(std::addressof(*p));
+}
+
+template <class To, class From>
+requires ( std::derived_from<std::remove_cvref_t<To>, std::remove_cvref_t<From>> )
+[[nodiscard]] inline auto
+dyn_cast_or_null(Polymorphic<From>* pp) noexcept
+    -> std::add_pointer_t<std::remove_reference_t<To>>
+{
+    return (pp && !pp->valueless_after_move()) ? dyn_cast<To>(*pp) : nullptr;
+}
+
+template <class To, class From>
+requires ( std::derived_from<std::remove_cvref_t<To>, std::remove_cvref_t<From>> )
+[[nodiscard]] inline auto
+dyn_cast_or_null(const Polymorphic<From>* pp) noexcept
+    -> std::add_pointer_t<const std::remove_reference_t<To>>
+{
+    return (pp && !pp->valueless_after_move()) ? dyn_cast<To>(*pp) : nullptr;
+}
+
+//------------------------------------------------------------------------------
+// cast<T>(p)  → reference (asserts on failure)
+//------------------------------------------------------------------------------
+
+template <class To, class From>
+requires ( std::derived_from<std::remove_cvref_t<To>, std::remove_cvref_t<From>> )
+[[nodiscard]] inline auto
+cast(Polymorphic<From>& p)
+    -> std::remove_reference_t<To>&
+{
+    assert(!p.valueless_after_move() && "cast: moved-from Polymorphic");
+    auto* r = dyn_cast<To>(p);
+    assert(r && "cast<T>: invalid cast");
+    return *r;
+}
+
+template <class To, class From>
+requires ( std::derived_from<std::remove_cvref_t<To>, std::remove_cvref_t<From>> )
+[[nodiscard]] inline auto
+cast(const Polymorphic<From>& p)
+    -> const std::remove_reference_t<To>&
+{
+    assert(!p.valueless_after_move() && "cast: moved-from Polymorphic");
+    auto* r = dyn_cast<To>(p);
+    assert(r && "cast<T>: invalid cast");
+    return *r;
+}
+
+//------------------------------------------------------------------------------
+// cast_or_null<T>(pp)  → pointer (asserts on bad non-null)
+//------------------------------------------------------------------------------
+
+template <class To, class From>
+requires ( std::derived_from<std::remove_cvref_t<To>, std::remove_cvref_t<From>> )
+[[nodiscard]] inline auto
+cast_or_null(Polymorphic<From>* pp)
+    -> std::add_pointer_t<std::remove_reference_t<To>>
+{
+    if (!pp) return nullptr;
+    auto* r = dyn_cast<To>(*pp);
+    assert(r && "cast_or_null<T>: invalid cast on non-null argument");
+    return r;
+}
+
+template <class To, class From>
+requires ( std::derived_from<std::remove_cvref_t<To>, std::remove_cvref_t<From>> )
+[[nodiscard]] inline auto
+cast_or_null(const Polymorphic<From>* pp)
+    -> std::add_pointer_t<const std::remove_reference_t<To>>
+{
+    if (!pp) return nullptr;
+    auto* r = dyn_cast<To>(*pp);
+    assert(r && "cast_or_null<T>: invalid cast on non-null argument");
+    return r;
+}
+
 } // namespace mrdocs
 
 #endif // MRDOCS_API_ADT_POLYMORPHIC_HPP
diff --git a/include/mrdocs/Dom/Value.hpp b/include/mrdocs/Dom/Value.hpp
index 68f3942ff..06d22cc67 100644
--- a/include/mrdocs/Dom/Value.hpp
+++ b/include/mrdocs/Dom/Value.hpp
@@ -797,7 +797,8 @@ ValueFrom(
     {
         tag_invoke(ValueFromTag{}, v, static_cast<T&&>(t), ctx);
     }
-    else {
+    else
+    {
         ValueFrom(static_cast<T&&>(t), v);
     }
 }
@@ -925,7 +926,7 @@ Value
 ValueFrom(T&& t, Context const& ctx)
 {
     dom::Value v;
-    ValueFrom(static_cast<T&&>(t), ctx, v);
+    ValueFrom(std::forward<T>(t), ctx, v);
     return v;
 }
 
diff --git a/include/mrdocs/Metadata.hpp b/include/mrdocs/Metadata.hpp
index 7bd250011..96f133c7b 100644
--- a/include/mrdocs/Metadata.hpp
+++ b/include/mrdocs/Metadata.hpp
@@ -13,8 +13,8 @@
 #define MRDOCS_API_METADATA_HPP
 
 #include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/DocComment.hpp>
 #include <mrdocs/Metadata/Expression.hpp>
-#include <mrdocs/Metadata/Javadoc.hpp>
 #include <mrdocs/Metadata/Name.hpp>
 #include <mrdocs/Metadata/Symbol.hpp>
 #include <mrdocs/Metadata/Symbol/Concept.hpp>
diff --git a/include/mrdocs/Metadata/DocComment.hpp b/include/mrdocs/Metadata/DocComment.hpp
new file mode 100644
index 000000000..636d7c548
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment.hpp
@@ -0,0 +1,382 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/DocComment/Block.hpp>
+
+namespace mrdocs {
+
+/** A processed documentation comment attached to a declaration.
+
+    A complete documentation comment document consists of a
+    sequence of text blocks. Blocks are the top-level
+    structural units that might contain other blocks
+    or inline elements. These are analogous to markdown
+    blocks.
+
+    Inline elements (text, emphasis, links, code spans, etc.)
+    live inside certain block types, like paragraphs or
+    headings. Inlines can contain other inlines
+    (e.g., emphasis contains text, link contains text), but
+    they cannot directly contain blocks.
+
+    Some blocks contain metadata about the symbol being
+    documented, such as parameters and return values. These
+    blocks are parsed as usual, but are stored separately in the
+    DocComment structure.
+
+    Each block in the document might contain:
+
+    - No other blocks (leaf blocks)
+    - Other blocks (container blocks: e.g. lists)
+
+    When they contain no other blocks, they might be:
+
+    - Inlines only (e.g. paragraphs)
+    - No inlines (e.g. horizontal rule)
+
+    Inline content elements contain other inlines
+    but cannot contain blocks.
+ */
+struct MRDOCS_DECL DocComment {
+    /// The list of text blocks.
+    std::vector<Polymorphic<doc::Block>> Document;
+
+    // ----------------------
+    // Symbol Metadata
+
+    /// A brief description of the symbol.
+    Optional<doc::BriefBlock> brief;
+
+    /** The list of return type descriptions.
+
+        Multiple return descriptions are allowed.
+
+        The results are concatenated in the order
+        they appear in the source code.
+     */
+    std::vector<doc::ReturnsBlock> returns;
+
+    /// The list of parameters.
+    std::vector<doc::ParamBlock> params;
+
+    /// The list of template parameters.
+    std::vector<doc::TParamBlock> tparams;
+
+    /// The list of exceptions.
+    std::vector<doc::ThrowsBlock> exceptions;
+
+    /// The list of "see also" references.
+    std::vector<doc::SeeBlock> sees;
+
+    /// The list of preconditions.
+    std::vector<doc::PreconditionBlock> preconditions;
+
+    /// The list of postconditions.
+    std::vector<doc::PostconditionBlock> postconditions;
+
+    /** The list of "relates" references.
+
+        These references are created with the
+        \\relates command.
+     */
+    std::vector<doc::ReferenceInline> relates;
+
+    /** The list of "related" references.
+
+        These references are the inverse of
+        the \\relates command.
+
+        They are calculated automatically by
+        MrDocs and are rendered as
+        Non-Member Functions.
+     */
+    std::vector<doc::ReferenceInline> related;
+
+    /** Constructor.
+    */
+    MRDOCS_DECL
+    DocComment() noexcept;
+
+    /** Constructor
+    */
+    explicit DocComment(
+        std::vector<Polymorphic<doc::Block>> blocks);
+
+    /** Return true if this is empty
+    */
+    bool
+    empty() const noexcept
+    {
+        return Document.empty() &&
+            !brief &&
+            returns.empty() &&
+            params.empty() &&
+            tparams.empty() &&
+            exceptions.empty() &&
+            sees.empty() &&
+            related.empty() &&
+            preconditions.empty() &&
+            postconditions.empty();
+    }
+
+    auto operator<=>(DocComment const& other) const noexcept {
+        if (auto const cmp = Document.size() <=> other.Document.size();
+            !std::is_eq(cmp))
+        {
+            return cmp;
+        }
+        for (std::size_t i = 0; i < Document.size(); ++i)
+        {
+            if (auto cmp = CompareDerived(Document[i], other.Document[i]);
+                !std::is_eq(cmp))
+            {
+                return cmp;
+            }
+        }
+        return std::strong_ordering::equal;
+    }
+    bool operator==(DocComment const&) const noexcept = default;
+    bool operator!=(DocComment const&) const noexcept;
+
+    /** Append blocks from another DocComment to this.
+    */
+    void
+    append(DocComment&& other);
+};
+
+inline
+void merge(DocComment& I, DocComment&& other)
+{
+    // FIXME: this doesn't merge parameter information;
+    // parameters with the same name but different directions
+    // or descriptions end up being duplicated
+    if(other != I)
+    {
+        // Unconditionally extend the blocks
+        // since each decl may have a comment.
+        I.append(std::move(other));
+    }
+}
+
+/** Map the @ref DocComment to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The DocComment to map.
+    @param domCorpus The DOM corpus, or nullptr.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag,
+    IO& io,
+    DocComment const& I,
+    DomCorpus const* domCorpus)
+{
+    io.defer("description", [&I, domCorpus] {
+        return dom::LazyArray(I.Document, domCorpus);
+    });
+    if (I.brief && !I.brief->children.empty())
+    {
+        io.map("brief", I.brief);
+    }
+    io.defer("returns", [&I, domCorpus] {
+        return dom::LazyArray(I.returns, domCorpus);
+    });
+    io.defer("params", [&I, domCorpus] {
+        return dom::LazyArray(I.params, domCorpus);
+    });
+    io.defer("tparams", [&I, domCorpus] {
+        return dom::LazyArray(I.tparams, domCorpus);
+    });
+    io.defer("exceptions", [&I, domCorpus] {
+        return dom::LazyArray(I.exceptions, domCorpus);
+    });
+    io.defer("sees", [&I, domCorpus] {
+        return dom::LazyArray(I.sees, domCorpus);
+    });
+    io.defer("relates", [&I, domCorpus] {
+        return dom::LazyArray(I.relates, domCorpus);
+    });
+    io.defer("related", [&I, domCorpus] {
+        return dom::LazyArray(I.related, domCorpus);
+    });
+    io.defer("preconditions", [&I, domCorpus] {
+        return dom::LazyArray(I.preconditions, domCorpus);
+    });
+    io.defer("postconditions", [&I, domCorpus] {
+        return dom::LazyArray(I.postconditions, domCorpus);
+    });
+}
+
+/** Return the @ref DocComment as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    DocComment const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+/** Concept to check if a type represents a DocComment node.
+ */
+template <class T>
+concept DocCommentNode =
+    std::derived_from<T, doc::Block> || std::derived_from<T, doc::Inline>;
+
+namespace detail {
+// forward declaration to handle derived nodes
+template <bool bottomUp, DocCommentNode T, class F>
+void
+traverseImpl(Polymorphic<T>& node, F&& func);
+
+// forward declaration to handle base class nodes
+template <bool bottomUp, class T, class F>
+requires std::same_as<T, doc::Block> || std::same_as<T, doc::Inline>
+void
+traverseImpl(T& baseNode, F&& func);
+
+// Traverse a derived node
+template <bool bottomUp, DocCommentNode NodeTy, class F>
+requires(!std::same_as<NodeTy, doc::Block> && !std::same_as<NodeTy, doc::Inline>)
+void
+traverseImpl(NodeTy& N, F&& func)
+{
+    if constexpr (!bottomUp && std::invocable<F, NodeTy&>)
+    {
+        func(N);
+    }
+    if constexpr (requires { N.children; })
+    {
+        for (auto& child: N.children)
+        {
+            traverseImpl<bottomUp>(child, func);
+        }
+    }
+    if constexpr (requires { N.blocks; })
+    {
+        for (auto& block: N.blocks)
+        {
+            traverseImpl<bottomUp>(block, func);
+        }
+    }
+    if constexpr (std::same_as<NodeTy, doc::ThrowsBlock>)
+    {
+        traverseImpl<bottomUp>(N.exception, func);
+    }
+    if constexpr (bottomUp && std::invocable<F, NodeTy&>)
+    {
+        func(N);
+    }
+}
+
+template <bool bottomUp, class F>
+void
+traverseImpl(DocComment& doc, F&& func)
+{
+    if constexpr (!bottomUp && std::invocable<F, DocComment&>)
+    {
+        func(doc);
+    }
+    for (auto& block: doc.Document)
+    {
+        traverseImpl<bottomUp>(block, std::forward<F>(func));
+    }
+    if (doc.brief)
+    {
+        traverseImpl<bottomUp>(*doc.brief, std::forward<F>(func));
+    }
+    for (auto& returnsEl: doc.returns)
+    {
+        traverseImpl<bottomUp>(returnsEl, std::forward<F>(func));
+    }
+    for (auto& paramsEl: doc.params)
+    {
+        traverseImpl<bottomUp>(paramsEl, std::forward<F>(func));
+    }
+    for (auto& tparamsEl: doc.tparams)
+    {
+        traverseImpl<bottomUp>(tparamsEl, std::forward<F>(func));
+    }
+    for (auto& exceptionsEl: doc.exceptions)
+    {
+        traverseImpl<bottomUp>(exceptionsEl, std::forward<F>(func));
+    }
+    for (auto& seesEl: doc.sees)
+    {
+        traverseImpl<bottomUp>(seesEl, std::forward<F>(func));
+    }
+    for (auto& preconditionsEl: doc.preconditions)
+    {
+        traverseImpl<bottomUp>(preconditionsEl, std::forward<F>(func));
+    }
+    for (auto& postconditionsEl: doc.postconditions)
+    {
+        traverseImpl<bottomUp>(postconditionsEl, std::forward<F>(func));
+    }
+    if constexpr (bottomUp && std::invocable<F, DocComment&>)
+    {
+        func(doc);
+    }
+}
+
+// Traverse a reference to a base class node
+template <bool bottomUp, class T, class F>
+requires std::same_as<T, doc::Block> || std::same_as<T, doc::Inline>
+void
+traverseImpl(T& baseNode, F&& func)
+{
+    visit(baseNode, [&]<typename NodeTy>(NodeTy& N) {
+        traverseImpl<bottomUp>(N, std::forward<F>(func));
+    });
+}
+
+// Traverse a polymorphic node
+template <bool bottomUp, DocCommentNode T, class F>
+void
+traverseImpl(Polymorphic<T>& node, F&& func)
+{
+    traverseImpl<bottomUp>(*node, std::forward<F>(func));
+}
+}
+
+template <class T>
+concept DocCommentNodeTraversable =
+    DocCommentNode<T> ||
+    std::same_as<DocComment, T> ||
+    (detail::IsPolymorphic<T> && DocCommentNode<typename T::value_type>);
+
+template <DocCommentNodeTraversable T, class F>
+void
+bottomUpTraverse(T& node, F&& func)
+{
+    detail::traverseImpl<true>(node, std::forward<F>(func));
+}
+
+template <DocCommentNodeTraversable T, class F>
+void
+topDownTraverse(T& node, F&& func)
+{
+    detail::traverseImpl<false>(node, std::forward<F>(func));
+}
+} // mrdocs
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Block.hpp b/include/mrdocs/Metadata/DocComment/Block.hpp
new file mode 100644
index 000000000..464da939f
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block.hpp
@@ -0,0 +1,193 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/DocComment/Block/AdmonitionBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BriefBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/CodeBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/DefinitionListBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/FootnoteDefinitionBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/HeadingBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ListBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/MathBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParamBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/PostconditionBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/PreconditionBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/QuoteBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ReturnsBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/SeeBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/TParamBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/TableBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ThematicBreakBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ThrowsBlock.hpp>
+#include <mrdocs/Support/Visitor.hpp>
+
+namespace mrdocs::doc {
+/** Visit a block.
+
+    @param block The block to visit.
+    @param fn The function to call for each block.
+    @param args Additional arguments to pass to the function.
+    @return The result of calling the function.
+ */
+template<
+    std::derived_from<Block> BlockTy,
+    class Fn,
+    class... Args>
+decltype(auto)
+visit(
+    BlockTy& info,
+    Fn&& fn,
+    Args&&... args)
+{
+    auto visitor = makeVisitor<Block>(
+        info, std::forward<Fn>(fn), std::forward<Args>(args)...);
+    switch(info.Kind)
+    {
+    #define INFO(Type) case BlockKind::Type: \
+        return visitor.template visit<Type##Block>();
+#include <mrdocs/Metadata/DocComment/Block/BlockNodes.inc>
+    default:
+        MRDOCS_UNREACHABLE();
+    }
+}
+
+MRDOCS_DECL
+std::strong_ordering
+operator<=>(Polymorphic<Block> const& lhs, Polymorphic<Block> const& rhs);
+
+inline bool
+operator==(Polymorphic<Block> const& lhs, Polymorphic<Block> const& rhs)
+{
+    return lhs <=> rhs == std::strong_ordering::equal;
+}
+
+/** Map the Polymorphic Block to a @ref dom::Object.
+
+    @param io The output parameter to receive the dom::Object.
+    @param I The polymorphic Block to convert.
+    @param domCorpus The DomCorpus used to resolve references.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag,
+    IO& io,
+    Polymorphic<Block> const& I,
+    DomCorpus const* domCorpus)
+{
+    visit(*I, [&](auto const& U)
+    {
+        tag_invoke(
+            dom::LazyObjectMapTag{},
+            io,
+            U,
+            domCorpus);
+    });
+}
+
+/** Map the Polymorphic Block as a @ref dom::Value object.
+
+    @param io The output parameter to receive the dom::Value.
+    @param I The polymorphic Block to convert.
+    @param domCorpus The DomCorpus used to resolve references.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Polymorphic<Block> const& I,
+    DomCorpus const* domCorpus)
+{
+    visit(*I, [&](auto const& U)
+    {
+        tag_invoke(
+            dom::ValueFromTag{},
+            v,
+            U,
+            domCorpus);
+    });
+}
+
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Optional<Polymorphic<Block>> const& I,
+    DomCorpus const* domCorpus)
+{
+    if (!I)
+    {
+        v = nullptr;
+        return;
+    }
+    MRDOCS_ASSERT(!I->valueless_after_move());
+    tag_invoke(dom::ValueFromTag{}, v, *I, domCorpus);
+}
+
+/** Removes leading whitespace from the block.
+
+    @param el The Polymorphic<Block> to trim.
+    @return void
+ */
+inline
+void
+ltrim(Polymorphic<Block>& el)
+{
+    ltrim(*el);
+}
+
+/** Removes trailing whitespace from the block.
+
+    @param el The Polymorphic<Block> to trim.
+    @return void
+ */
+inline
+void
+rtrim(Polymorphic<Block>& el)
+{
+    rtrim(*el);
+}
+
+/** Removes leading and trailing whitespace from the block.
+
+    @param el The Polymorphic<Block> to trim.
+    @return void
+ */
+inline
+void
+trim(Polymorphic<Block>& el)
+{
+    ltrim(el);
+    rtrim(el);
+}
+
+/** Determine if the inline is empty
+ */
+inline
+bool
+isEmpty(Polymorphic<Block> const& el)
+{
+    MRDOCS_ASSERT(!el.valueless_after_move());
+    return isEmpty(*el);
+}
+
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Block/AdmonitionBlock.hpp b/include/mrdocs/Metadata/DocComment/Block/AdmonitionBlock.hpp
new file mode 100644
index 000000000..a8584f6b2
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/AdmonitionBlock.hpp
@@ -0,0 +1,89 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_ADMONITIONBLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_ADMONITIONBLOCK_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/DocComment/Block/AdmonitionKind.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** A block for side-notes like tips, warnings, notes
+
+    This paragraph represents an admonition, such as
+    a note, tip, important, caution, or warning.
+
+*/
+struct AdmonitionBlock final
+    : BlockCommonBase<BlockKind::Admonition>
+    , BlockContainer
+{
+    /** The kind of admonition
+
+        This is typically a string in other implementations.
+     */
+    AdmonitionKind admonish;
+
+    /// Optional title for the admonition
+    Optional<Polymorphic<Inline>> Title;
+
+    explicit
+    AdmonitionBlock(
+        AdmonitionKind const admonish_ = AdmonitionKind::none) noexcept
+        : admonish(admonish_)
+    {}
+
+    auto operator<=>(AdmonitionBlock const&) const = default;
+    bool operator==(AdmonitionBlock const&) const noexcept = default;
+};
+
+/** Map the @ref Admonition to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    AdmonitionBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<BlockContainer const&>(I), domCorpus);
+    io.map("admonish", I.admonish);
+}
+
+/** Return the @ref Admonition as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    AdmonitionBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_ADMONITIONBLOCK_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Admonish.hpp b/include/mrdocs/Metadata/DocComment/Block/AdmonitionKind.hpp
similarity index 71%
rename from include/mrdocs/Metadata/Javadoc/Block/Admonish.hpp
rename to include/mrdocs/Metadata/DocComment/Block/AdmonitionKind.hpp
index d4e5ad3dd..8957f04a5 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/Admonish.hpp
+++ b/include/mrdocs/Metadata/DocComment/Block/AdmonitionKind.hpp
@@ -6,12 +6,13 @@
 //
 // Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
 // Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
 //
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_ADMONISH_HPP
-#define MRDOCS_API_METADATA_JAVADOC_BLOCK_ADMONISH_HPP
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_ADMONITIONKIND_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_ADMONITIONKIND_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom.hpp>
@@ -20,7 +21,7 @@ namespace mrdocs::doc {
 
 /** An admonishment style.
  */
-enum class Admonish
+enum class AdmonitionKind
 {
     /// No admonishment
     none = 1, // needed by bitstream
@@ -40,20 +41,20 @@ enum class Admonish
  */
 MRDOCS_DECL
 dom::String
-toString(Admonish kind) noexcept;
+toString(AdmonitionKind kind) noexcept;
 
 /** Return the Admonish from a @ref dom::Value string.
  */
 inline
-    void
-    tag_invoke(
-        dom::ValueFromTag,
-        dom::Value& v,
-        Admonish const kind)
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    AdmonitionKind const kind)
 {
     v = toString(kind);
 }
 
 } // mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_ADMONISH_HPP
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_ADMONITIONKIND_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Block/BlockBase.hpp b/include/mrdocs/Metadata/DocComment/Block/BlockBase.hpp
new file mode 100644
index 000000000..9b6c19947
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/BlockBase.hpp
@@ -0,0 +1,295 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_BLOCKBASE_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_BLOCKBASE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/ArrayView.hpp>
+#include <mrdocs/Dom.hpp>
+#include <mrdocs/Dom/LazyArray.hpp>
+#include <mrdocs/Dom/LazyObject.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockKind.hpp>
+#include <mrdocs/Metadata/DocComment/Inline.hpp>
+#include <algorithm>
+#include <string>
+
+namespace mrdocs::doc {
+
+/* Forward declarations
+ */
+#define INFO(Type) struct Type##Block;
+#include <mrdocs/Metadata/DocComment/Block/BlockNodes.inc>
+
+/** A piece of block content
+
+    The top level is a list of blocks.
+
+    There are two types of blocks: headings and paragraphs.
+*/
+struct MRDOCS_DECL Block
+{
+    BlockKind Kind = BlockKind::Paragraph;
+
+    virtual ~Block() = default;
+
+    auto
+    operator<=>(Block const& other) const = default;
+
+    bool
+    operator==(Block const& other) const noexcept = default;
+
+    constexpr Block const& asBlock() const noexcept
+    {
+        return *this;
+    }
+
+    constexpr Block& asBlock() noexcept
+    {
+        return *this;
+    }
+
+    #define INFO(Type) constexpr bool is##Type() const noexcept { \
+        return Kind == BlockKind::Type; \
+    }
+#include <mrdocs/Metadata/DocComment/Block/BlockNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##Block const& as##Type() const noexcept { \
+        if (Kind == BlockKind::Type) \
+            return reinterpret_cast<Type##Block const&>(*this); \
+        MRDOCS_UNREACHABLE(); \
+    }
+#include <mrdocs/Metadata/DocComment/Block/BlockNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##Block & as##Type() noexcept { \
+        if (Kind == BlockKind::Type) \
+            return reinterpret_cast<Type##Block&>(*this); \
+        MRDOCS_UNREACHABLE(); \
+    }
+#include <mrdocs/Metadata/DocComment/Block/BlockNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##Block const* as##Type##Ptr() const noexcept { \
+        if (Kind == BlockKind::Type) { return reinterpret_cast<Type##Block const*>(this); } \
+        return nullptr; \
+    }
+#include <mrdocs/Metadata/DocComment/Block/BlockNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##Block * as##Type##Ptr() noexcept { \
+        if (Kind == BlockKind::Type) { return reinterpret_cast<Type##Block *>(this); } \
+        return nullptr; \
+    }
+#include <mrdocs/Metadata/DocComment/Block/BlockNodes.inc>
+
+protected:
+    constexpr
+    Block() = default;
+
+    explicit
+    Block(BlockKind const kind_) noexcept
+        : Kind(kind_)
+    {}
+};
+
+/** Base class for providing variant discriminator functions.
+
+    This offers functions that return a boolean at
+    compile-time, indicating if the most-derived
+    class is a certain type.
+*/
+template <BlockKind K>
+struct BlockCommonBase : Block
+{
+    /** The variant discriminator constant of the most-derived class.
+
+        It only distinguishes from `Block::kind` in that it is a constant.
+
+     */
+    static constexpr BlockKind kind_id = K;
+
+    ~BlockCommonBase() override = default;
+
+    #define INFO(Kind) \
+    static constexpr bool is##Kind() noexcept { return K == BlockKind::Kind; }
+#include <mrdocs/Metadata/DocComment/Block/BlockNodes.inc>
+
+    auto operator<=>(BlockCommonBase const&) const = default;
+
+protected:
+    constexpr explicit BlockCommonBase()
+        : Block(K)
+    {}
+};
+
+/** Map the @ref Block to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    Block const& I,
+    DomCorpus const*)
+{
+    io.map("kind", doc::toString(I.Kind));
+}
+
+/** Return the @ref Block as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Block const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+/** Removes leading whitespace from the block.
+
+    @param el The Block to trim.
+    @return void
+ */
+MRDOCS_DECL
+void
+ltrim(Block& el);
+
+/** Removes trailing whitespace from the block.
+
+    @param el The Block to trim.
+    @return void
+ */
+MRDOCS_DECL
+void
+rtrim(Block& el);
+
+/** Removes leading and trailing whitespace from the block.
+
+    @param el The Block to trim.
+    @return void
+ */
+inline
+void
+trim(Block& el)
+{
+    ltrim(el);
+    rtrim(el);
+}
+
+/** Determine if the inline is empty
+ */
+MRDOCS_DECL
+bool
+isEmpty(Block const& el);
+
+
+struct MRDOCS_DECL BlockContainer
+{
+    std::vector<Polymorphic<Block>> blocks;
+
+    BlockContainer&
+    asBlockContainer()
+    {
+        return *this;
+    }
+
+    BlockContainer const&
+    asBlockContainer() const
+    {
+        return *this;
+    }
+
+    std::strong_ordering
+    operator<=>(BlockContainer const&) const;
+
+    bool
+    operator==(BlockContainer const&) const = default;
+};
+
+template <class IO, polymorphic_storage_for<Block> BlockTy>
+void
+tag_invoke(
+    dom::ValueFromTag,
+    IO& io,
+    BlockTy const& I,
+    DomCorpus const* domCorpus);
+
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    BlockContainer const& I,
+    DomCorpus const* domCorpus)
+{
+    io.defer("blocks", [&I, domCorpus] {
+        return dom::LazyArray(I.blocks, domCorpus);
+    });
+}
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    BlockContainer const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+/** Removes leading whitespace from the first text elements
+
+    @param blocks The BlockContainer to trim.
+    @return void
+ */
+MRDOCS_DECL
+void
+ltrim(BlockContainer& blocks);
+
+/** Removes trailing whitespace from the last text elements
+
+    @param blocks The BlockContainer to trim.
+    @return void
+ */
+MRDOCS_DECL
+void
+rtrim(BlockContainer& blocks);
+
+/** Removes leading and trailing whitespace from the text elements
+
+    @param blocks The BlockContainer to trim.
+    @return void
+ */
+inline
+void
+trim(BlockContainer& blocks)
+{
+    ltrim(blocks);
+    rtrim(blocks);
+}
+
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_BLOCKBASE_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Block/BlockCommandNodes.inc b/include/mrdocs/Metadata/DocComment/Block/BlockCommandNodes.inc
new file mode 100644
index 000000000..bd085dbcc
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/BlockCommandNodes.inc
@@ -0,0 +1,24 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef INFO
+#define INFO(PascalName)
+#endif
+
+// Metadata Blocks
+INFO(Param)
+INFO(Postcondition)
+INFO(Precondition)
+INFO(Returns)
+INFO(See)
+INFO(Throws)
+INFO(TParam)
+
+#undef INFO
diff --git a/include/mrdocs/Metadata/DocComment/Block/BlockKind.hpp b/include/mrdocs/Metadata/DocComment/Block/BlockKind.hpp
new file mode 100644
index 000000000..b5df094f9
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/BlockKind.hpp
@@ -0,0 +1,63 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_BLOCKKIND_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_BLOCKKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+
+namespace mrdocs::doc {
+
+enum class BlockKind {
+    #define INFO(Type) Type,
+#include <mrdocs/Metadata/DocComment/Block/BlockNodes.inc>
+};
+
+inline
+dom::String
+toString(BlockKind kind) noexcept
+{
+    switch (kind)
+    {
+        #define INFO(Type) case BlockKind::Type: return toKebabCase(#Type);
+#include <mrdocs/Metadata/DocComment/Block/BlockNodes.inc>
+    }
+    return "Unknown";
+}
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v, BlockKind const kind)
+{
+    v = toString(kind);
+}
+
+constexpr
+bool
+isBlockCommand(BlockKind k) noexcept
+{
+    switch (k)
+    {
+        #define INFO(Type) \
+        case BlockKind::Type: \
+            return true;
+#include <mrdocs/Metadata/DocComment/Block/BlockCommandNodes.inc>
+#undef INFO
+    default:
+        return false;
+    }
+}
+
+} // namespace mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_BLOCKKIND_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Block/BlockNodes.inc b/include/mrdocs/Metadata/DocComment/Block/BlockNodes.inc
new file mode 100644
index 000000000..458eb8839
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/BlockNodes.inc
@@ -0,0 +1,32 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef INFO
+#define INFO(PascalName)
+#endif
+
+// Markup Blocks
+INFO(Admonition)
+INFO(Brief)
+INFO(Code)
+INFO(Heading)
+INFO(Paragraph)
+INFO(List)
+INFO(DefinitionList)
+INFO(Quote)
+INFO(ThematicBreak)
+INFO(FootnoteDefinition)
+INFO(Table)
+INFO(Math)
+
+// Metadata Blocks
+#include <mrdocs/Metadata/DocComment/Block/BlockCommandNodes.inc>
+
+#undef INFO
diff --git a/include/mrdocs/Metadata/DocComment/Block/BriefBlock.hpp b/include/mrdocs/Metadata/DocComment/Block/BriefBlock.hpp
new file mode 100644
index 000000000..1a9e719a2
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/BriefBlock.hpp
@@ -0,0 +1,106 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_BRIEFBLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_BRIEFBLOCK_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** The brief description
+*/
+struct BriefBlock final
+    : BlockCommonBase<BlockKind::Brief>
+    , InlineContainer
+{
+    std::vector<std::string> copiedFrom;
+
+    BriefBlock() = default;
+
+    BriefBlock(BriefBlock const& other) = default;
+
+    using InlineContainer::InlineContainer;
+
+    BriefBlock&
+    operator=(BriefBlock const& other) = default;
+
+    using InlineContainer::operator=;
+
+    auto operator<=>(BriefBlock const&) const = default;
+};
+
+/** Map the @ref Brief to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    BriefBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<InlineContainer const&>(I), domCorpus);
+    io.defer("copiedFrom", [&I] {
+        return dom::LazyArray(I.copiedFrom);
+    });
+}
+
+/** Return the @ref Brief as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    BriefBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+
+    Optional<BriefBlock> o;
+}
+
+inline
+void
+tag_invoke(
+    mrdocs::dom::ValueFromTag,
+    mrdocs::dom::Value& v,
+    Optional<BriefBlock> const& I,
+    DomCorpus const* domCorpus)
+{
+    if (!I)
+    {
+        v = nullptr;
+        return;
+    }
+    tag_invoke(mrdocs::dom::ValueFromTag{}, v, *I, domCorpus);
+}
+
+static_assert(dom::HasValueFrom<BriefBlock, DomCorpus const*>);
+static_assert(dom::HasValueFromWithContext<BriefBlock, DomCorpus const*>);
+
+static_assert(dom::HasValueFrom<Optional<BriefBlock>, DomCorpus const*>);
+static_assert(dom::HasValueFromWithContext<Optional<BriefBlock>, DomCorpus const*>);
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_BRIEFBLOCK_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Block/CodeBlock.hpp b/include/mrdocs/Metadata/DocComment/Block/CodeBlock.hpp
new file mode 100644
index 000000000..c32576514
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/CodeBlock.hpp
@@ -0,0 +1,75 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_CODEBLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_CODEBLOCK_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** Preformatted source code.
+ */
+struct CodeBlock final
+    : BlockCommonBase<BlockKind::Code>
+{
+    std::string literal;
+
+    /// Fence info string, e.g. "cpp"
+    std::string info;
+
+    CodeBlock() noexcept = default;
+    auto operator<=>(CodeBlock const&) const = default;
+    bool operator==(CodeBlock const&) const noexcept = default;
+};
+
+/** Map the @ref Code to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    CodeBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
+    io.map("literal", I.literal);
+    if (!I.info.empty())
+    {
+        io.map("info", I.info);
+    }
+}
+
+/** Return the @ref Code as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    CodeBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_CODEBLOCK_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Block/DefinitionListBlock.hpp b/include/mrdocs/Metadata/DocComment/Block/DefinitionListBlock.hpp
new file mode 100644
index 000000000..6a9ae28f1
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/DefinitionListBlock.hpp
@@ -0,0 +1,78 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_DEFINITIONLISTBLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_DEFINITIONLISTBLOCK_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DocComment/Block/DefinitionListItem.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ListKind.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp>
+#include <string>
+#include <vector>
+
+namespace mrdocs::doc {
+
+struct DefinitionListBlock final
+    : BlockCommonBase<BlockKind::List>
+{
+    std::vector<DefinitionListItem> items;
+
+    auto operator<=>(DefinitionListBlock const& other) const {
+        if (auto const cmp = items.size() <=> other.items.size();
+            !std::is_eq(cmp))
+        {
+            return cmp;
+        }
+        for (std::size_t i = 0; i < items.size(); ++i)
+        {
+            if (auto const cmp = items[i] <=> other.items[i];
+                !std::is_eq(cmp))
+            {
+                return cmp;
+            }
+        }
+        return std::strong_ordering::equal;
+    }
+
+    bool
+    operator==(DefinitionListBlock const&) const noexcept = default;
+};
+
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    DefinitionListBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
+    io.defer("items", [&I, domCorpus] {
+        return dom::LazyArray(I.items, domCorpus);
+    });
+}
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    DefinitionListBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_DEFINITIONLISTBLOCK_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Block/DefinitionListItem.hpp b/include/mrdocs/Metadata/DocComment/Block/DefinitionListItem.hpp
new file mode 100644
index 000000000..ce0dc897d
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/DefinitionListItem.hpp
@@ -0,0 +1,67 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_DEFINITIONLISTITEM_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_DEFINITIONLISTITEM_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** An item in a definition list
+*/
+struct DefinitionListItem final
+    : BlockContainer
+{
+    InlineContainer term;
+
+    auto operator<=>(DefinitionListItem const&) const = default;
+    bool operator==(DefinitionListItem const&) const noexcept = default;
+};
+
+/** Map the @ref DefinitionListItem to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    DefinitionListItem const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, static_cast<BlockContainer const&>(I), domCorpus);
+    io.map("term", I.term);
+}
+
+/** Return the @ref DefinitionListItem as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    DefinitionListItem const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_DEFINITIONLISTITEM_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Block/FootnoteDefinitionBlock.hpp b/include/mrdocs/Metadata/DocComment/Block/FootnoteDefinitionBlock.hpp
new file mode 100644
index 000000000..feaa46dd5
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/FootnoteDefinitionBlock.hpp
@@ -0,0 +1,70 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_FOOTNOTEDEFINITIONBLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_FOOTNOTEDEFINITIONBLOCK_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** Preformatted source code.
+ */
+struct FootnoteDefinitionBlock final
+    : BlockCommonBase<BlockKind::FootnoteDefinition>
+    , BlockContainer
+{
+    std::string label;
+
+    FootnoteDefinitionBlock() noexcept = default;
+    auto operator<=>(FootnoteDefinitionBlock const&) const = default;
+    bool operator==(FootnoteDefinitionBlock const&) const noexcept = default;
+};
+
+/** Map the @ref FootnoteDefinition to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    FootnoteDefinitionBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<BlockContainer const&>(I), domCorpus);
+    io.map("label", I.label);
+}
+
+/** Return the @ref FootnoteDefinition as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    FootnoteDefinitionBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_FOOTNOTEDEFINITIONBLOCK_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Heading.hpp b/include/mrdocs/Metadata/DocComment/Block/HeadingBlock.hpp
similarity index 55%
rename from include/mrdocs/Metadata/Javadoc/Block/Heading.hpp
rename to include/mrdocs/Metadata/DocComment/Block/HeadingBlock.hpp
index b21a0c5f9..15ab196d5 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/Heading.hpp
+++ b/include/mrdocs/Metadata/DocComment/Block/HeadingBlock.hpp
@@ -4,43 +4,31 @@
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
 //
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_HEADING_HPP
-#define MRDOCS_API_METADATA_JAVADOC_BLOCK_HEADING_HPP
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_HEADINGBLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_HEADINGBLOCK_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
 #include <string>
 
 namespace mrdocs::doc {
 
 /** A manually specified section heading.
 */
-struct Heading final : Block
+struct HeadingBlock final
+    : BlockCommonBase<BlockKind::Heading>
+    , InlineContainer
 {
-    static constexpr auto static_kind = NodeKind::heading;
+    unsigned level = 1; // 1 to 6
 
-    std::string string;
-
-    Heading(
-        std::string string_ = std::string()) noexcept
-        : Block(NodeKind::heading)
-        , string(std::move(string_))
-    {
-    }
-
-    auto operator<=>(Heading const&) const = default;
-    bool operator==(Heading const&) const noexcept = default;
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Heading const&>(other);
-    }
+    using InlineContainer::InlineContainer;
+    auto operator<=>(HeadingBlock const&) const = default;
+    bool operator==(HeadingBlock const&) const noexcept = default;
 };
 
 /** Map the @ref Heading to a @ref dom::Object.
@@ -55,11 +43,12 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    Heading const& I,
+    HeadingBlock const& I,
     DomCorpus const* domCorpus)
 {
     tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
-    io.map("string", I.string);
+    tag_invoke(t, io, dynamic_cast<InlineContainer const&>(I), domCorpus);
+    io.map("level", I.level);
 }
 
 /** Return the @ref Heading as a @ref dom::Value object.
@@ -69,7 +58,7 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    Heading const& I,
+    HeadingBlock const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
@@ -77,4 +66,4 @@ tag_invoke(
 
 } // mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_HEADING_HPP
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_HEADINGBLOCK_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/UnorderedList.hpp b/include/mrdocs/Metadata/DocComment/Block/ListBlock.hpp
similarity index 56%
rename from include/mrdocs/Metadata/Javadoc/Block/UnorderedList.hpp
rename to include/mrdocs/Metadata/DocComment/Block/ListBlock.hpp
index 1c1af1872..193bdbc41 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/UnorderedList.hpp
+++ b/include/mrdocs/Metadata/DocComment/Block/ListBlock.hpp
@@ -4,19 +4,19 @@
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
 //
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_UNORDEREDLIST_HPP
-#define MRDOCS_API_METADATA_JAVADOC_BLOCK_UNORDEREDLIST_HPP
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_LISTBLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_LISTBLOCK_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/ListItem.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ListItem.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ListKind.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp>
 #include <string>
 #include <vector>
 
@@ -24,20 +24,13 @@ namespace mrdocs::doc {
 
 /** A list of list items
 */
-struct UnorderedList final : Paragraph
+struct ListBlock final
+    : BlockCommonBase<BlockKind::List>
 {
-    static constexpr auto static_kind = NodeKind::unordered_list;
-
     std::vector<ListItem> items;
+    ListKind listKind = ListKind::Unordered;
 
-    UnorderedList()
-        : Paragraph(static_kind)
-    {
-    }
-
-    using Paragraph::operator=;
-
-    auto operator<=>(UnorderedList const& other) const {
+    auto operator<=>(ListBlock const& other) const {
         if (auto const cmp = items.size() <=> other.items.size();
             !std::is_eq(cmp))
         {
@@ -55,22 +48,7 @@ struct UnorderedList final : Paragraph
     }
 
     bool
-    operator==(UnorderedList const&) const noexcept = default;
-
-    bool
-    equals(Node const& other) const noexcept override
-    {
-        auto* p = dynamic_cast<UnorderedList const*>(&other);
-        if (!p)
-        {
-            return false;
-        }
-        if (this == &other)
-        {
-            return true;
-        }
-        return *this == *p;
-    }
+    operator==(ListBlock const&) const noexcept = default;
 };
 
 /** Map the @ref UnorderedList to a @ref dom::Object.
@@ -85,13 +63,14 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    UnorderedList const& I,
+    ListBlock const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
     io.defer("items", [&I, domCorpus] {
         return dom::LazyArray(I.items, domCorpus);
     });
+    io.map("listKind", toString(I.listKind));
 }
 
 /** Return the @ref UnorderedList as a @ref dom::Value object.
@@ -101,7 +80,7 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    UnorderedList const& I,
+    ListBlock const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
@@ -109,4 +88,4 @@ tag_invoke(
 
 } // mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_UNORDEREDLIST_HPP
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_LISTBLOCK_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/ListItem.hpp b/include/mrdocs/Metadata/DocComment/Block/ListItem.hpp
similarity index 51%
rename from include/mrdocs/Metadata/Javadoc/Block/ListItem.hpp
rename to include/mrdocs/Metadata/DocComment/Block/ListItem.hpp
index 1a3b4864a..14693d3a3 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/ListItem.hpp
+++ b/include/mrdocs/Metadata/DocComment/Block/ListItem.hpp
@@ -4,52 +4,28 @@
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
 //
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_LISTITEM_HPP
-#define MRDOCS_API_METADATA_JAVADOC_BLOCK_LISTITEM_HPP
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_LISTITEM_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_LISTITEM_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp>
 #include <string>
 
 namespace mrdocs::doc {
 
 /** An item in a list
 */
-struct ListItem final : Paragraph
+struct ListItem final
+    : BlockContainer
 {
-    static constexpr auto static_kind = NodeKind::list_item;
-
-    ListItem()
-        : Paragraph(static_kind)
-    {}
-
-    using Paragraph::operator=;
-
     auto operator<=>(ListItem const&) const = default;
-    bool
-    operator==(ListItem const&) const noexcept = default;
-
-    bool
-    equals(Node const& other) const noexcept override
-    {
-        auto* p = dynamic_cast<ListItem const*>(&other);
-        if (!p)
-        {
-            return false;
-        }
-        if (this == &other)
-        {
-            return true;
-        }
-        return *this == *p;
-    }
+    bool operator==(ListItem const&) const noexcept = default;
 };
 
 /** Map the @ref ListItem to a @ref dom::Object.
@@ -67,7 +43,7 @@ tag_invoke(
     ListItem const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
+    tag_invoke(t, io, static_cast<BlockContainer const&>(I), domCorpus);
 }
 
 /** Return the @ref ListItem as a @ref dom::Value object.
@@ -85,4 +61,4 @@ tag_invoke(
 
 } // mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_LISTITEM_HPP
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_LISTITEM_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Block/ListKind.hpp b/include/mrdocs/Metadata/DocComment/Block/ListKind.hpp
new file mode 100644
index 000000000..6b56c766e
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/ListKind.hpp
@@ -0,0 +1,49 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_LISTKIND_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_LISTKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+
+namespace mrdocs {
+
+enum class ListKind {
+    Unordered,
+    Ordered
+};
+
+inline
+dom::String
+toString(ListKind kind) noexcept
+{
+    switch (kind)
+    {
+        case ListKind::Unordered:
+            return "unordered";
+        case ListKind::Ordered:
+            return "ordered";
+    }
+    return "Unknown";
+}
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v, ListKind const kind)
+{
+    v = toString(kind);
+}
+
+} // mrdocs
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_LISTKIND_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Block/MathBlock.hpp b/include/mrdocs/Metadata/DocComment/Block/MathBlock.hpp
new file mode 100644
index 000000000..63cc52c51
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/MathBlock.hpp
@@ -0,0 +1,71 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_MATHBLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_MATHBLOCK_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** A block of LaTeX math
+
+    A block of LaTeX math, typically between
+    $$ … $$ or fenced with "math".
+ */
+struct MathBlock final
+    : BlockCommonBase<BlockKind::Math>
+{
+    /// Raw TeX math source
+    std::string literal;
+
+    MathBlock(MathBlock const& other) = default;
+    MathBlock& operator=(MathBlock const& other) = default;
+    auto operator<=>(MathBlock const&) const = default;
+};
+
+/** Map the @ref Brief to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    MathBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
+    io.map("literal", I.literal);
+}
+
+/** Return the @ref Brief as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    MathBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_MATHBLOCK_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Paragraph.hpp b/include/mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp
similarity index 56%
rename from include/mrdocs/Metadata/Javadoc/Block/Paragraph.hpp
rename to include/mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp
index 1de80bbc9..48bc0daa4 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/Paragraph.hpp
+++ b/include/mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp
@@ -6,47 +6,31 @@
 //
 // Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
 // Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
 //
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAGRAPH_HPP
-#define MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAGRAPH_HPP
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_PARAGRAPHBLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_PARAGRAPHBLOCK_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DocComment/Inline.hpp>
 #include <string>
 
 namespace mrdocs::doc {
 
 /** A sequence of text nodes.
 */
-struct Paragraph : Block
+struct ParagraphBlock
+    : BlockCommonBase<BlockKind::Paragraph>
+    , InlineContainer
 {
-    static constexpr auto static_kind = NodeKind::paragraph;
+    ~ParagraphBlock() override = default;
+    ParagraphBlock() noexcept = default;
 
-    Paragraph() noexcept : Block(NodeKind::paragraph) {}
-
-    virtual
-    Paragraph&
-    operator=(std::string_view str);
-
-    auto operator<=>(Paragraph const&) const = default;
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Paragraph const&>(other);
-    }
-
-protected:
-    explicit
-    Paragraph(
-        NodeKind const kind,
-        std::vector<Polymorphic<Text>> children_ = {}) noexcept
-        : Block(kind, std::move(children_))
-    {
-    }
+    auto operator<=>(ParagraphBlock const&) const = default;
 };
 
 /** Map the @ref Paragraph to a @ref dom::Object.
@@ -61,10 +45,11 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    Paragraph const& I,
+    ParagraphBlock const& I,
     DomCorpus const* domCorpus)
 {
     tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
+    tag_invoke(t, io, static_cast<InlineContainer const&>(I), domCorpus);
 }
 
 /** Return the @ref Paragraph as a @ref dom::Value object.
@@ -74,7 +59,7 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    Paragraph const& I,
+    ParagraphBlock const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
@@ -82,4 +67,4 @@ tag_invoke(
 
 } // mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAGRAPH_HPP
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_PARAGRAPHBLOCK_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Block/ParamBlock.hpp b/include/mrdocs/Metadata/DocComment/Block/ParamBlock.hpp
new file mode 100644
index 000000000..26e7d2261
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/ParamBlock.hpp
@@ -0,0 +1,94 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_PARAMBLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_PARAMBLOCK_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParamDirection.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** Documentation for a function parameter
+*/
+struct ParamBlock final
+    : BlockCommonBase<BlockKind::Param>
+    , InlineContainer
+{
+    std::string name;
+    ParamDirection direction = ParamDirection::none;
+
+    using InlineContainer::InlineContainer;
+
+    ParamBlock(InlineContainer const& other)
+        : InlineContainer(other)
+    {}
+
+    ParamBlock(InlineContainer&& other) noexcept
+        : InlineContainer(std::move(other))
+    {}
+
+    ParamBlock(
+        std::string_view name,
+        std::string_view text,
+        ParamDirection direction = ParamDirection::none)
+        : InlineContainer(text)
+        , name(name)
+        , direction(direction)
+    {}
+
+    auto operator<=>(ParamBlock const&) const = default;
+    bool operator==(ParamBlock const&)
+        const noexcept = default;
+};
+
+/** Map the @ref Param to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    ParamBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<InlineContainer const&>(I), domCorpus);
+    io.map("name", I.name);
+    io.map("direction", I.direction);
+}
+
+/** Return the @ref Param as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    ParamBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_PARAMBLOCK_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/ParamDirection.hpp b/include/mrdocs/Metadata/DocComment/Block/ParamDirection.hpp
similarity index 81%
rename from include/mrdocs/Metadata/Javadoc/Block/ParamDirection.hpp
rename to include/mrdocs/Metadata/DocComment/Block/ParamDirection.hpp
index bc5ad4281..89f66f995 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/ParamDirection.hpp
+++ b/include/mrdocs/Metadata/DocComment/Block/ParamDirection.hpp
@@ -6,12 +6,13 @@
 //
 // Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
 // Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
 //
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAMDIRECTION_HPP
-#define MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAMDIRECTION_HPP
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_PARAMDIRECTION_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_PARAMDIRECTION_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom.hpp>
@@ -52,4 +53,4 @@ tag_invoke(
 
 } // mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAMDIRECTION_HPP
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_PARAMDIRECTION_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Postcondition.hpp b/include/mrdocs/Metadata/DocComment/Block/PostconditionBlock.hpp
similarity index 55%
rename from include/mrdocs/Metadata/Javadoc/Block/Postcondition.hpp
rename to include/mrdocs/Metadata/DocComment/Block/PostconditionBlock.hpp
index 3ca75a27a..f882c4686 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/Postcondition.hpp
+++ b/include/mrdocs/Metadata/DocComment/Block/PostconditionBlock.hpp
@@ -6,43 +6,27 @@
 //
 // Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
 // Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
 //
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_POSTCONDITION_HPP
-#define MRDOCS_API_METADATA_JAVADOC_BLOCK_POSTCONDITION_HPP
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_POSTCONDITIONBLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_POSTCONDITIONBLOCK_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp>
 #include <string>
 
 namespace mrdocs::doc {
 
-struct Postcondition : Paragraph
+struct PostconditionBlock
+    : BlockCommonBase<BlockKind::Postcondition>
+    , InlineContainer
 {
-    static constexpr auto static_kind = NodeKind::postcondition;
-
-    Postcondition(
-        Paragraph details_ = Paragraph())
-        : Paragraph(
-            NodeKind::postcondition,
-            std::move(details_.children))
-    {
-    }
-
-    using Paragraph::operator=;
-
-    auto operator<=>(Postcondition const&) const = default;
-
-    bool operator==(Postcondition const&)
-        const noexcept = default;
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Postcondition const&>(other);
-    }
+    using InlineContainer::InlineContainer;
+    auto operator<=>(PostconditionBlock const&) const = default;
+    bool operator==(PostconditionBlock const&) const noexcept = default;
 };
 
 /** Map the @ref Postcondition to a @ref dom::Object.
@@ -57,10 +41,11 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    Postcondition const& I,
+    PostconditionBlock const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<InlineContainer const&>(I), domCorpus);
 }
 
 /** Return the @ref Postcondition as a @ref dom::Value object.
@@ -74,7 +59,7 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    Postcondition const& I,
+    PostconditionBlock const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
@@ -82,4 +67,4 @@ tag_invoke(
 
 } // mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_POSTCONDITION_HPP
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_POSTCONDITIONBLOCK_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Precondition.hpp b/include/mrdocs/Metadata/DocComment/Block/PreconditionBlock.hpp
similarity index 55%
rename from include/mrdocs/Metadata/Javadoc/Block/Precondition.hpp
rename to include/mrdocs/Metadata/DocComment/Block/PreconditionBlock.hpp
index d2b050ac8..fbd9a914e 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/Precondition.hpp
+++ b/include/mrdocs/Metadata/DocComment/Block/PreconditionBlock.hpp
@@ -6,43 +6,27 @@
 //
 // Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
 // Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
 //
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_PRECONDITION_HPP
-#define MRDOCS_API_METADATA_JAVADOC_BLOCK_PRECONDITION_HPP
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_PRECONDITIONBLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_PRECONDITIONBLOCK_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp>
 #include <string>
 
 namespace mrdocs::doc {
 
-struct Precondition final : Paragraph
+struct PreconditionBlock final
+    : BlockCommonBase<BlockKind::Precondition>
+    , InlineContainer
 {
-    static constexpr NodeKind static_kind = NodeKind::precondition;
-
-    Precondition(
-        Paragraph details_ = Paragraph())
-        : Paragraph(
-            NodeKind::precondition,
-            std::move(details_.children))
-    {
-    }
-
-    using Paragraph::operator=;
-
-    auto operator<=>(Precondition const&) const = default;
-
-    bool operator==(Precondition const&)
-        const noexcept = default;
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Precondition const&>(other);
-    }
+    using InlineContainer::InlineContainer;
+    auto operator<=>(PreconditionBlock const&) const = default;
+    bool operator==(PreconditionBlock const&) const noexcept = default;
 };
 
 /** Map the @ref Precondition to a @ref dom::Object.
@@ -57,10 +41,11 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    Precondition const& I,
+    PreconditionBlock const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<InlineContainer const&>(I), domCorpus);
 }
 
 /** Return the @ref Precondition as a @ref dom::Value object.
@@ -74,7 +59,7 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    Precondition const& I,
+    PreconditionBlock const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
@@ -82,4 +67,4 @@ tag_invoke(
 
 } // mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_PRECONDITION_HPP
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_PRECONDITIONBLOCK_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Block/QuoteBlock.hpp b/include/mrdocs/Metadata/DocComment/Block/QuoteBlock.hpp
new file mode 100644
index 000000000..53a7c6bd3
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/QuoteBlock.hpp
@@ -0,0 +1,68 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_QUOTEBLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_QUOTEBLOCK_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ListItem.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp>
+#include <string>
+#include <vector>
+
+namespace mrdocs::doc {
+
+/** A list of list items
+*/
+struct QuoteBlock final
+    : BlockCommonBase<BlockKind::Quote>
+    , BlockContainer
+{
+    auto operator<=>(QuoteBlock const&) const = default;
+    bool operator==(QuoteBlock const&) const noexcept = default;
+};
+
+/** Map the @ref QuoteBlock to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    QuoteBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<BlockContainer const&>(I), domCorpus);
+}
+
+/** Return the @ref QuoteBlock as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    QuoteBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_QUOTEBLOCK_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Block/ReturnsBlock.hpp b/include/mrdocs/Metadata/DocComment/Block/ReturnsBlock.hpp
new file mode 100644
index 000000000..5704e1688
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/ReturnsBlock.hpp
@@ -0,0 +1,76 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_RETURNSBLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_RETURNSBLOCK_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** Documentation for a function return type
+*/
+struct ReturnsBlock final
+    : BlockCommonBase<BlockKind::Returns>
+    , InlineContainer
+{
+    using InlineContainer::InlineContainer;
+    ReturnsBlock(ReturnsBlock const&) = default;
+    ReturnsBlock(ReturnsBlock&&) noexcept = default;
+    ReturnsBlock(InlineContainer const& other) : InlineContainer(other) {}
+    ReturnsBlock(InlineContainer&& other) noexcept : InlineContainer(other) {}
+    ~ReturnsBlock() override = default;
+    ReturnsBlock& operator=(ReturnsBlock const&) = default;
+    ReturnsBlock& operator=(ReturnsBlock&&) noexcept = default;
+    auto operator<=>(ReturnsBlock const&) const = default;
+    bool operator==(ReturnsBlock const&) const noexcept = default;
+};
+
+/** Map the @ref Returns to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    ReturnsBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<InlineContainer const&>(I), domCorpus);
+}
+
+/** Return the @ref Returns as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    ReturnsBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_RETURNSBLOCK_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/See.hpp b/include/mrdocs/Metadata/DocComment/Block/SeeBlock.hpp
similarity index 57%
rename from include/mrdocs/Metadata/Javadoc/Block/See.hpp
rename to include/mrdocs/Metadata/DocComment/Block/SeeBlock.hpp
index 19d9d7cb1..09f73bb29 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/See.hpp
+++ b/include/mrdocs/Metadata/DocComment/Block/SeeBlock.hpp
@@ -6,43 +6,30 @@
 //
 // Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
 // Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
 //
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_SEE_HPP
-#define MRDOCS_API_METADATA_JAVADOC_BLOCK_SEE_HPP
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_SEEBLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_SEEBLOCK_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp>
 #include <string>
 
 namespace mrdocs::doc {
 
 /** A @see paragraph
 */
-struct See final : Paragraph
+struct SeeBlock final
+    : BlockCommonBase<BlockKind::See>
+    , InlineContainer
 {
-    static constexpr auto static_kind = NodeKind::see;
-
-    See()
-        : Paragraph(static_kind)
-    {
-    }
-
-    using Paragraph::operator=;
-
-    auto operator<=>(See const&) const = default;
-
-    bool operator==(See const&)
-        const noexcept = default;
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<See const&>(other);
-    }
+    using InlineContainer::InlineContainer;
+    auto operator<=>(SeeBlock const&) const = default;
+    bool operator==(SeeBlock const&) const noexcept = default;
 };
 
 /** Map the @ref See to a @ref dom::Object.
@@ -57,10 +44,11 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    See const& I,
+    SeeBlock const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<InlineContainer const&>(I), domCorpus);
 }
 
 /** Return the @ref See as a @ref dom::Value object.
@@ -70,7 +58,7 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    See const& I,
+    SeeBlock const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
@@ -78,4 +66,4 @@ tag_invoke(
 
 } // mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_SEE_HPP
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_SEEBLOCK_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/TParam.hpp b/include/mrdocs/Metadata/DocComment/Block/TParamBlock.hpp
similarity index 58%
rename from include/mrdocs/Metadata/Javadoc/Block/TParam.hpp
rename to include/mrdocs/Metadata/DocComment/Block/TParamBlock.hpp
index 0c4657711..124d1007b 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/TParam.hpp
+++ b/include/mrdocs/Metadata/DocComment/Block/TParamBlock.hpp
@@ -6,42 +6,32 @@
 //
 // Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
 // Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
 //
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_TPARAM_HPP
-#define MRDOCS_API_METADATA_JAVADOC_BLOCK_TPARAM_HPP
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_TPARAMBLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_TPARAMBLOCK_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp>
 #include <string>
 
 namespace mrdocs::doc {
 
 /** Documentation for a template parameter
 */
-struct TParam final : Paragraph
+struct TParamBlock final
+    : BlockCommonBase<BlockKind::TParam>
+    , InlineContainer
 {
     std::string name;
 
-    static constexpr NodeKind static_kind = NodeKind::tparam;
-
-    TParam()
-        : Paragraph(NodeKind::tparam)
-    {
-    }
-
-    using Paragraph::operator=;
-
-    auto operator<=>(TParam const&) const = default;
-    bool operator==(TParam const&) const noexcept = default;
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<TParam const&>(other);
-    }
+    using InlineContainer::InlineContainer;
+    auto operator<=>(TParamBlock const&) const = default;
+    bool operator==(TParamBlock const&) const noexcept = default;
 };
 
 /** Map the @ref TParam to a @ref dom::Object.
@@ -56,10 +46,11 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    TParam const& I,
+    TParamBlock const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<InlineContainer const&>(I), domCorpus);
     io.map("name", I.name);
 }
 
@@ -70,7 +61,7 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    TParam const& I,
+    TParamBlock const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
@@ -78,4 +69,4 @@ tag_invoke(
 
 } // mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_TPARAM_HPP
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_TPARAMBLOCK_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Block/TableAlignmentKind.hpp b/include/mrdocs/Metadata/DocComment/Block/TableAlignmentKind.hpp
new file mode 100644
index 000000000..8dd01f686
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/TableAlignmentKind.hpp
@@ -0,0 +1,55 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_TABLEALIGNMENTKIND_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_TABLEALIGNMENTKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+
+namespace mrdocs {
+
+enum class TableAlignmentKind {
+    None,
+    Left,
+    Center,
+    Right,
+};
+
+inline
+dom::String
+toString(TableAlignmentKind kind) noexcept
+{
+    switch (kind)
+    {
+        case TableAlignmentKind::None:
+            return "none";
+        case TableAlignmentKind::Left:
+            return "left";
+        case TableAlignmentKind::Center:
+            return "center";
+        case TableAlignmentKind::Right:
+            return "right";
+    }
+    return "unknown";
+}
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v, TableAlignmentKind const kind)
+{
+    v = toString(kind);
+}
+
+} // mrdocs
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_TABLEALIGNMENTKIND_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Block/TableBlock.hpp b/include/mrdocs/Metadata/DocComment/Block/TableBlock.hpp
new file mode 100644
index 000000000..3ccb261fd
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/TableBlock.hpp
@@ -0,0 +1,92 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_TABLEBLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_TABLEBLOCK_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Block/TableAlignmentKind.hpp>
+#include <mrdocs/Metadata/DocComment/Block/TableRow.hpp>
+#include <string>
+#include <vector>
+
+namespace mrdocs::doc {
+
+/** A table block
+*/
+struct TableBlock final: BlockCommonBase<BlockKind::Table>
+{
+    std::vector<TableAlignmentKind> Alignments;
+    std::vector<TableRow> items;
+
+    auto operator<=>(TableBlock const& other) const {
+        if (auto const cmp = items.size() <=> other.items.size();
+            !std::is_eq(cmp))
+        {
+            return cmp;
+        }
+        for (std::size_t i = 0; i < items.size(); ++i)
+        {
+            if (auto const cmp = items[i] <=> other.items[i];
+                !std::is_eq(cmp))
+            {
+                return cmp;
+            }
+        }
+        return std::strong_ordering::equal;
+    }
+
+    bool
+    operator==(TableBlock const&) const noexcept = default;
+};
+
+/** Map the @ref UnorderedTable to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    TableBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
+    io.defer("alignments", [&I, domCorpus] {
+        return dom::LazyArray(I.Alignments, domCorpus);
+    });
+    io.defer("items", [&I, domCorpus] {
+        return dom::LazyArray(I.items, domCorpus);
+    });
+}
+
+/** Return the @ref UnorderedTable as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    TableBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_TABLEBLOCK_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Block/TableCell.hpp b/include/mrdocs/Metadata/DocComment/Block/TableCell.hpp
new file mode 100644
index 000000000..529329f72
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/TableCell.hpp
@@ -0,0 +1,64 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_TABLECELL_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_TABLECELL_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DocComment/Inline.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** A cell in a table
+*/
+struct TableCell final
+    : InlineContainer
+{
+    auto operator<=>(TableCell const&) const = default;
+    bool
+    operator==(TableCell const&) const noexcept = default;
+};
+
+/** Map the @ref TableCell to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    TableCell const& I,
+    DomCorpus const* domCorpus)
+{
+}
+
+/** Return the @ref TableCell as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    TableCell const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_TABLECELL_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Block/TableRow.hpp b/include/mrdocs/Metadata/DocComment/Block/TableRow.hpp
new file mode 100644
index 000000000..76f11d3f8
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/TableRow.hpp
@@ -0,0 +1,72 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_TABLEROW_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_TABLEROW_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+#include <mrdocs/Dom/LazyArray.hpp>
+#include <mrdocs/Dom/LazyObject.hpp>
+#include <mrdocs/Metadata/DocComment/Block/TableCell.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** An item in a list
+*/
+struct TableRow final
+{
+    bool is_header = false;
+    std::vector<TableCell> Cells;
+
+    auto operator<=>(TableRow const&) const = default;
+    bool
+    operator==(TableRow const&) const noexcept = default;
+};
+
+/** Map the @ref TableRow to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    TableRow const& I,
+    DomCorpus const* domCorpus)
+{
+    io.map("is_header", I.is_header);
+    io.defer("cells", [&] {
+        return dom::LazyArray(I.Cells, domCorpus);
+    });
+}
+
+/** Return the @ref TableRow as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    TableRow const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_TABLEROW_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Block/ThematicBreakBlock.hpp b/include/mrdocs/Metadata/DocComment/Block/ThematicBreakBlock.hpp
new file mode 100644
index 000000000..a5a9baf36
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Block/ThematicBreakBlock.hpp
@@ -0,0 +1,65 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_THEMATICBREAKBLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_THEMATICBREAKBLOCK_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** The brief description
+*/
+struct ThematicBreakBlock final
+    : BlockCommonBase<BlockKind::ThematicBreak>
+{
+    ThematicBreakBlock(ThematicBreakBlock const& other) = default;
+    ThematicBreakBlock& operator=(ThematicBreakBlock const& other) = default;
+    auto operator<=>(ThematicBreakBlock const&) const = default;
+};
+
+/** Map the @ref Brief to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    ThematicBreakBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
+}
+
+/** Return the @ref Brief as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    ThematicBreakBlock const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_THEMATICBREAKBLOCK_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Throws.hpp b/include/mrdocs/Metadata/DocComment/Block/ThrowsBlock.hpp
similarity index 53%
rename from include/mrdocs/Metadata/Javadoc/Block/Throws.hpp
rename to include/mrdocs/Metadata/DocComment/Block/ThrowsBlock.hpp
index c3e823fe8..7b7482306 100644
--- a/include/mrdocs/Metadata/Javadoc/Block/Throws.hpp
+++ b/include/mrdocs/Metadata/DocComment/Block/ThrowsBlock.hpp
@@ -6,49 +6,31 @@
 //
 // Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
 // Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
 //
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_THROWS_HPP
-#define MRDOCS_API_METADATA_JAVADOC_BLOCK_THROWS_HPP
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_THROWSBLOCK_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_THROWSBLOCK_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
+#include <mrdocs/Metadata/DocComment/Block/ParagraphBlock.hpp>
+#include <mrdocs/Metadata/DocComment/Inline.hpp>
 #include <string>
 
 namespace mrdocs::doc {
 
 /** Documentation for a function parameter
 */
-struct Throws final : Paragraph
+struct ThrowsBlock final
+    : BlockCommonBase<BlockKind::Throws>
+    , InlineContainer
 {
-    Reference exception;
-
-    static constexpr NodeKind static_kind = NodeKind::throws;
-
-    Throws(
-        std::string exception_ = std::string(),
-        Paragraph details_ = Paragraph())
-        : Paragraph(
-            NodeKind::throws,
-            std::move(details_.children))
-        , exception(std::move(exception_))
-    {
-    }
-
-    using Paragraph::operator=;
-
-    auto operator<=>(Throws const&) const = default;
-
-    bool operator==(Throws const&)
-        const noexcept = default;
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Throws const&>(other);
-    }
+    ReferenceInline exception;
+    using InlineContainer::InlineContainer;
+    auto operator<=>(ThrowsBlock const&) const = default;
+    bool operator==(ThrowsBlock const&) const noexcept = default;
 };
 
 /** Map the @ref Throws to a @ref dom::Object.
@@ -63,10 +45,11 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    Throws const& I,
+    ThrowsBlock const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<Block const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<InlineContainer const&>(I), domCorpus);
     io.map("exception", I.exception);
 }
 
@@ -77,7 +60,7 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    Throws const& I,
+    ThrowsBlock const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
@@ -85,4 +68,4 @@ tag_invoke(
 
 } // mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_THROWS_HPP
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_BLOCK_THROWSBLOCK_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Inline.hpp b/include/mrdocs/Metadata/DocComment/Inline.hpp
similarity index 54%
rename from include/mrdocs/Metadata/Javadoc/Inline.hpp
rename to include/mrdocs/Metadata/DocComment/Inline.hpp
index a31983aed..fe0b503c0 100644
--- a/include/mrdocs/Metadata/Javadoc/Inline.hpp
+++ b/include/mrdocs/Metadata/DocComment/Inline.hpp
@@ -10,21 +10,32 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_INLINE_HPP
-#define MRDOCS_API_METADATA_JAVADOC_INLINE_HPP
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
-#include <mrdocs/Metadata/Javadoc/Inline/CopyDetails.hpp>
-#include <mrdocs/Metadata/Javadoc/Inline/Link.hpp>
-#include <mrdocs/Metadata/Javadoc/Inline/Reference.hpp>
-#include <mrdocs/Metadata/Javadoc/Inline/Style.hpp>
-#include <mrdocs/Metadata/Javadoc/Inline/Styled.hpp>
-#include <mrdocs/Metadata/Javadoc/Inline/Text.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/CodeInline.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/CopyDetailsInline.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/EmphInline.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/FootnoteReferenceInline.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/HighlightInline.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/ImageInline.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/LineBreakInline.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/LinkInline.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/MathInline.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/ReferenceInline.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/SoftBreakInline.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/StrikethroughInline.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/StrongInline.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/SubscriptInline.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/SuperscriptInline.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/TextInline.hpp>
 #include <mrdocs/Support/Concepts.hpp>
 #include <mrdocs/Support/Visitor.hpp>
 #include <compare>
 
+
 namespace mrdocs::doc {
 
 /** Visit an inline.
@@ -50,16 +61,9 @@ visit(
         std::forward<Args>(args)...);
     switch(el.Kind)
     {
-    case NodeKind::link:
-        return visitor.template visit<Link>();
-    case NodeKind::reference:
-        return visitor.template visit<Reference>();
-    case NodeKind::copy_details:
-        return visitor.template visit<CopyDetails>();
-    case NodeKind::styled:
-        return visitor.template visit<Styled>();
-    case NodeKind::text:
-        return visitor.template visit<Text>();
+        #define INFO(Type) case InlineKind::Type: \
+            return visitor.template visit<Type##Inline>();
+#include <mrdocs/Metadata/DocComment/Inline/InlineNodes.inc>
     default:
         MRDOCS_UNREACHABLE();
     }
@@ -117,6 +121,47 @@ operator==(Polymorphic<Inline> const& lhs, Polymorphic<Inline> const& rhs) {
     return std::is_eq(lhs <=> rhs);
 }
 
+/** Removes leading whitespace from the inline element.
+
+    @param el The Polymorphic<Inline> to trim.
+    @return void
+ */
+MRDOCS_DECL
+void
+ltrim(Polymorphic<Inline>& el);
+
+/** Removes trailing whitespace from the inline element.
+
+    @param el The Polymorphic<Inline> to trim.
+    @return void
+ */
+MRDOCS_DECL
+void
+rtrim(Polymorphic<Inline>& el);
+
+/** Removes leading and trailing whitespace from the inline element.
+
+    @param el The Polymorphic<Inline> to trim.
+    @return void
+ */
+inline
+void
+trim(Polymorphic<Inline>& el)
+{
+    ltrim(el);
+    rtrim(el);
+}
+
+/** Determine if the inline is empty
+
+    This determines if the inline is considered to
+    have no content for the purposes of trimming.
+
+ */
+MRDOCS_DECL
+bool
+isEmpty(Polymorphic<Inline> const& el);
+
 } // mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_INLINE_HPP
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Inline/CodeInline.hpp b/include/mrdocs/Metadata/DocComment/Inline/CodeInline.hpp
new file mode 100644
index 000000000..25ae621d6
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Inline/CodeInline.hpp
@@ -0,0 +1,67 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_CODEINLINE_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_CODEINLINE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/InlineBase.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** A piece of styled text.
+*/
+struct CodeInline final
+    : InlineCommonBase<InlineKind::Code>
+    , InlineContainer
+{
+    using InlineContainer::InlineContainer;
+    auto operator<=>(CodeInline const&) const = default;
+    bool operator==(CodeInline const&) const noexcept = default;
+};
+
+/** Map the @ref Code to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    CodeInline const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Inline const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<InlineContainer const&>(I), domCorpus);
+}
+
+/** Return the @ref Code as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    CodeInline const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_CODEINLINE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Inline/CopyDetails.hpp b/include/mrdocs/Metadata/DocComment/Inline/CopyDetailsInline.hpp
similarity index 52%
rename from include/mrdocs/Metadata/Javadoc/Inline/CopyDetails.hpp
rename to include/mrdocs/Metadata/DocComment/Inline/CopyDetailsInline.hpp
index cda9910c2..36c4ffa96 100644
--- a/include/mrdocs/Metadata/Javadoc/Inline/CopyDetails.hpp
+++ b/include/mrdocs/Metadata/DocComment/Inline/CopyDetailsInline.hpp
@@ -4,40 +4,36 @@
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
 //
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_INLINE_COPYDETAILS_HPP
-#define MRDOCS_API_METADATA_JAVADOC_INLINE_COPYDETAILS_HPP
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_COPYDETAILSINLINE_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_COPYDETAILSINLINE_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Inline/Reference.hpp>
-#include <mrdocs/Metadata/Javadoc/Inline/Text.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/ReferenceInline.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/TextInline.hpp>
 #include <string>
 
 namespace mrdocs::doc {
 
 /** Documentation copied from another symbol.
 */
-struct CopyDetails final : Reference
+struct CopyDetailsInline final
+    : InlineCommonBase<InlineKind::CopyDetails>
 {
-    static constexpr auto static_kind = NodeKind::copy_details;
+    std::string string;
+    SymbolID id = SymbolID::invalid;
 
-    CopyDetails(std::string string_ = std::string()) noexcept
-        : Reference(std::move(string_), NodeKind::copy_details)
+    CopyDetailsInline(std::string string_ = std::string()) noexcept
+        : string(std::move(string_))
     {
     }
 
-    auto operator<=>(CopyDetails const&) const = default;
-    bool operator==(CopyDetails const&) const noexcept = default;
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<CopyDetails const&>(other);
-    }
+    auto operator<=>(CopyDetailsInline const&) const = default;
+    bool operator==(CopyDetailsInline const&) const noexcept = default;
 };
 
 /** Map the @ref CopyDetails to a @ref dom::Object.
@@ -52,10 +48,12 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    CopyDetails const& I,
+    CopyDetailsInline const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Reference const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<Inline const&>(I), domCorpus);
+    io.map("string", I.string);
+    io.map("symbol", I.id);
 }
 
 /** Return the @ref CopyDetails as a @ref dom::Value object.
@@ -69,7 +67,7 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    CopyDetails const& I,
+    CopyDetailsInline const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
@@ -77,4 +75,4 @@ tag_invoke(
 
 } // mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_INLINE_COPYDETAILS_HPP
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_COPYDETAILSINLINE_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Inline/EmphInline.hpp b/include/mrdocs/Metadata/DocComment/Inline/EmphInline.hpp
new file mode 100644
index 000000000..1d78383cc
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Inline/EmphInline.hpp
@@ -0,0 +1,67 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_EMPHINLINE_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_EMPHINLINE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/InlineBase.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** A piece of styled text.
+*/
+struct EmphInline final
+    : InlineCommonBase<InlineKind::Emph>
+    , InlineContainer
+{
+    using InlineContainer::InlineContainer;
+    auto operator<=>(EmphInline const&) const = default;
+    bool operator==(EmphInline const&) const noexcept = default;
+};
+
+/** Map the @ref Emph to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    EmphInline const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Inline const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<InlineContainer const&>(I), domCorpus);
+}
+
+/** Return the @ref Emph as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    EmphInline const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_EMPHINLINE_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Inline/FootnoteReferenceInline.hpp b/include/mrdocs/Metadata/DocComment/Inline/FootnoteReferenceInline.hpp
new file mode 100644
index 000000000..c8fe61f5b
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Inline/FootnoteReferenceInline.hpp
@@ -0,0 +1,68 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_FOOTNOTEREFERENCEINLINE_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_FOOTNOTEREFERENCEINLINE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/TextInline.hpp>
+#include <mrdocs/Metadata/Symbol/SymbolID.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** A reference to a symbol.
+
+    In markdown, this is represented as "[^label]".
+*/
+struct FootnoteReferenceInline
+    : InlineCommonBase<InlineKind::FootnoteReference>
+{
+    std::string label;
+    auto operator<=>(FootnoteReferenceInline const&) const = default;
+    bool operator==(FootnoteReferenceInline const&) const noexcept = default;
+};
+
+/** Map the @ref FootnoteReference to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    FootnoteReferenceInline const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Inline const&>(I), domCorpus);
+    io.map("label", I.label);
+}
+
+/** Return the @ref FootnoteReference as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    FootnoteReferenceInline const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_FOOTNOTEREFERENCEINLINE_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Inline/HighlightInline.hpp b/include/mrdocs/Metadata/DocComment/Inline/HighlightInline.hpp
new file mode 100644
index 000000000..ca1ab3ab2
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Inline/HighlightInline.hpp
@@ -0,0 +1,66 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_HIGHLIGHTINLINE_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_HIGHLIGHTINLINE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/InlineBase.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** A piece of highlighted text.
+*/
+struct HighlightInline final
+    : InlineCommonBase<InlineKind::Highlight>
+    , InlineContainer
+{
+    auto operator<=>(HighlightInline const&) const = default;
+    bool operator==(HighlightInline const&) const noexcept = default;
+};
+
+/** Map the @ref Highlight to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    HighlightInline const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Inline const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<InlineContainer const&>(I), domCorpus);
+}
+
+/** Return the @ref Highlight as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    HighlightInline const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_HIGHLIGHTINLINE_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Inline/ImageInline.hpp b/include/mrdocs/Metadata/DocComment/Inline/ImageInline.hpp
new file mode 100644
index 000000000..5d4695e65
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Inline/ImageInline.hpp
@@ -0,0 +1,71 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_IMAGEINLINE_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_IMAGEINLINE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/TextInline.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** An image.
+*/
+struct ImageInline final
+    : InlineCommonBase<InlineKind::Image>
+    , InlineContainer
+{
+    std::string src;
+    std::string alt;
+
+    auto operator<=>(ImageInline const&) const = default;
+    bool operator==(ImageInline const&) const noexcept = default;
+};
+
+/** Map the @ref Image to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    ImageInline const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Inline const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<InlineContainer const&>(I), domCorpus);
+    io.map("src", I.src);
+    io.map("alt", I.alt);
+}
+
+/** Return the @ref Image as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    ImageInline const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_IMAGEINLINE_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Inline/InlineBase.hpp b/include/mrdocs/Metadata/DocComment/Inline/InlineBase.hpp
new file mode 100644
index 000000000..09b36ea1f
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Inline/InlineBase.hpp
@@ -0,0 +1,491 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_INLINEBASE_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_INLINEBASE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom/LazyArray.hpp>
+#include <mrdocs/Dom/LazyObject.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/InlineKind.hpp>
+#include <mrdocs/Metadata/DomCorpus.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/* Forward declarations
+ */
+#define INFO(Type) struct Type##Inline;
+#include <mrdocs/Metadata/DocComment/Inline/InlineNodes.inc>
+
+/** A Node containing a string of text.
+
+    There will be no newlines in the text. Otherwise,
+    this would be represented as multiple text nodes
+    within a Paragraph node.
+*/
+struct MRDOCS_DECL Inline
+{
+    InlineKind Kind = InlineKind::Text;
+
+    virtual ~Inline() = default;
+
+    auto operator<=>(Inline const&) const = default;
+    bool operator==(Inline const&) const noexcept = default;
+
+    constexpr Inline const& asInline() const noexcept
+    {
+        return *this;
+    }
+
+    constexpr Inline& asInline() noexcept
+    {
+        return *this;
+    }
+
+    #define INFO(Type) constexpr bool is##Type() const noexcept { \
+        return Kind == InlineKind::Type; \
+    }
+#include <mrdocs/Metadata/DocComment/Inline/InlineNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##Inline const& as##Type() const noexcept { \
+        if (Kind == InlineKind::Type) \
+            return reinterpret_cast<Type##Inline const&>(*this); \
+        MRDOCS_UNREACHABLE(); \
+    }
+#include <mrdocs/Metadata/DocComment/Inline/InlineNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##Inline & as##Type() noexcept { \
+        if (Kind == InlineKind::Type) \
+            return reinterpret_cast<Type##Inline&>(*this); \
+        MRDOCS_UNREACHABLE(); \
+    }
+#include <mrdocs/Metadata/DocComment/Inline/InlineNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##Inline const* as##Type##Ptr() const noexcept { \
+        if (Kind == InlineKind::Type) { return reinterpret_cast<Type##Inline const*>(this); } \
+        return nullptr; \
+    }
+#include <mrdocs/Metadata/DocComment/Inline/InlineNodes.inc>
+
+#define INFO(Type) \
+    constexpr Type##Inline * as##Type##Ptr() noexcept { \
+        if (Kind == InlineKind::Type) { return reinterpret_cast<Type##Inline *>(this); } \
+        return nullptr; \
+    }
+#include <mrdocs/Metadata/DocComment/Inline/InlineNodes.inc>
+
+protected:
+    constexpr Inline() noexcept = default;
+
+    Inline(
+        InlineKind kind_)
+        : Kind(kind_)
+    {
+    }
+};
+
+/** Base class for providing variant discriminator functions.
+
+    This offers functions that return a boolean at
+    compile-time, indicating if the most-derived
+    class is a certain type.
+*/
+template <InlineKind K>
+struct InlineCommonBase : Inline
+{
+    /** The variant discriminator constant of the most-derived class.
+
+        It only distinguishes from `Inline::kind` in that it is a constant.
+
+     */
+    static constexpr InlineKind kind_id = K;
+
+    virtual ~InlineCommonBase() override = default;
+
+    #define INFO(Kind) \
+    static constexpr bool is##Kind() noexcept { return K == InlineKind::Kind; }
+#include <mrdocs/Metadata/DocComment/Inline/InlineNodes.inc>
+
+    auto operator<=>(InlineCommonBase const&) const = default;
+
+protected:
+    constexpr explicit InlineCommonBase()
+        : Inline(K)
+    {}
+};
+
+
+/** Map the @ref Inline to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    Inline const& I,
+    DomCorpus const* domCorpus)
+{
+    io.map("kind", toString(I.Kind));
+}
+
+/** Return the @ref Inline as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    Inline const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+/** Get the plain text representation of an inline element tree.
+
+    This strips all formatting and returns just the text content.
+
+    @param in The input inline element.
+    @param dst The output string to append to.
+ */
+MRDOCS_DECL
+void
+getAsPlainText(doc::Inline const& in, std::string& dst);
+
+/** Get the plain text representation of an inline element tree.
+
+    This strips all formatting and returns just the text content.
+
+    @param in The input inline element.
+    @return The flattened plain text.
+ */
+inline
+std::string
+getAsPlainText(doc::Inline const& in)
+{
+    std::string dst;
+    getAsPlainText(in, dst);
+    return dst;
+}
+
+/// An internal node in the inline element tree
+struct MRDOCS_DECL InlineContainer
+{
+    std::vector<Polymorphic<Inline>> children;
+
+    virtual ~InlineContainer() = default;
+
+    InlineContainer() = default;
+
+    InlineContainer(InlineContainer const&) = default;
+
+    InlineContainer(InlineContainer&&) noexcept = default;
+
+    /// Construct an InlineContainer with a single TextInline child.
+    explicit
+    InlineContainer(std::string_view text);
+
+    /// Construct an InlineContainer with a single TextInline child.
+    explicit
+    InlineContainer(char const* text)
+        : InlineContainer(std::string_view(text))
+    {}
+
+    /// Construct an InlineContainer with a single TextInline child.
+    explicit
+    InlineContainer(std::string const& text);
+
+    /// Construct an InlineContainer with a single TextInline child.
+    explicit
+    InlineContainer(std::string&& text);
+
+    InlineContainer&
+    operator=(InlineContainer const&) = default;
+
+    InlineContainer&
+    operator=(InlineContainer&&) noexcept = default;
+
+    /// Assign an InlineContainer with a single TextInline child.
+    InlineContainer&
+    operator=(std::string_view text);
+
+    /// Helper function so that derived classes can get a reference to
+    /// the base class.
+    InlineContainer&
+    asInlineContainer()
+    {
+        return *this;
+    }
+
+    /// @copydoc asInlineContainer
+    InlineContainer const&
+    asInlineContainer() const
+    {
+        return *this;
+    }
+
+    /// Get the first inline child.
+    Polymorphic<Inline> const&
+    front() const
+    {
+        MRDOCS_ASSERT(!children.empty());
+        return children.front();
+    }
+
+    /// Get the first inline child.
+    Polymorphic<Inline>&
+    front()
+    {
+        MRDOCS_ASSERT(!children.empty());
+        return children.front();
+    }
+
+    /// Get the last inline child.
+    Polymorphic<Inline> const&
+    back() const
+    {
+        MRDOCS_ASSERT(!children.empty());
+        return children.back();
+    }
+
+    /// Get the last inline child.
+    Polymorphic<Inline>&
+    back()
+    {
+        MRDOCS_ASSERT(!children.empty());
+        return children.back();
+    }
+
+    /// Determine if there are no inline children.
+    bool
+    empty() const noexcept
+    {
+        return children.empty();
+    }
+
+    /// Get the number of inline children.
+    std::size_t
+    size() const noexcept
+    {
+        return children.size();
+    }
+
+    /// Begin iterator forwarding to children
+    decltype(auto)
+    begin(this auto&& self) noexcept
+    {
+        return self.children.begin();
+    }
+
+    /// End iterator forwarding to children
+    decltype(auto)
+    end(this auto&& self) noexcept
+    {
+        return self.children.end();
+    }
+
+    /// Erase from children
+    decltype(auto)
+    erase(this auto&& self, auto&&... args)
+    {
+        return self.children.erase(std::forward<decltype(args)>(args)...);
+    }
+
+    /// Erase from children
+    decltype(auto)
+    insert(this auto&& self, auto&&... args)
+    {
+        return self.children.insert(std::forward<decltype(args)>(args)...);
+    }
+
+    /// Clear all inline children.
+    void
+    clear()
+    {
+        children.clear();
+    }
+
+    /// Append a TextInline child.
+    InlineContainer&
+    append(std::string_view text);
+
+    /// Append a child of the specified type.
+    template <std::derived_from<Inline> InlineTy, class... Args>
+    InlineContainer&
+    append(Args&&... args)
+    {
+        children.push_back(Polymorphic<Inline>(std::in_place_type<InlineTy>, std::forward<Args>(args)...));
+        return *this;
+    }
+
+    /// Append a TextInline child.
+    InlineContainer&
+    operator+=(std::string_view text)
+    {
+        return append(text);
+    }
+
+    /// Append an inline child.
+    template <std::derived_from<Inline> InlineTy>
+    InlineContainer&
+    operator+=(InlineTy&& inlineChild)
+    {
+        children.push_back(Polymorphic<Inline>(std::in_place_type<InlineTy>, std::forward<InlineTy>(inlineChild)));
+        return *this;
+    }
+
+    /// Append a child of the specified type.
+    template <std::derived_from<Inline> InlineTy, class... Args>
+    InlineContainer&
+    emplace_back(Args&&... args)
+    {
+        children.push_back(Polymorphic<Inline>(std::in_place_type<InlineTy>, std::forward<Args>(args)...));
+        return *this;
+    }
+
+    /// Compare two InlineContainers.
+    std::strong_ordering
+    operator<=>(InlineContainer const&) const;
+
+    /// Compare two InlineContainers.
+    bool
+    operator==(InlineContainer const&) const = default;
+};
+
+template <class IO, polymorphic_storage_for<Inline> InlineTy>
+void
+tag_invoke(
+    dom::ValueFromTag,
+    IO& io,
+    InlineTy const& I,
+    DomCorpus const* domCorpus);
+
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    InlineContainer const& I,
+    DomCorpus const* domCorpus)
+{
+    io.defer("children", [&I, domCorpus] {
+        return dom::LazyArray(I.children, domCorpus);
+    });
+}
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    InlineContainer const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+/** Removes leading whitespace from the first text element in the given InlineContainer.
+
+    @param inlines The InlineContainer to trim.
+    @return void
+ */
+MRDOCS_DECL
+void
+ltrim(InlineContainer& inlines);
+
+/** Removes trailing whitespace from the last text element in the given InlineContainer.
+
+    @param inlines The InlineContainer to trim.
+    @return void
+ */
+MRDOCS_DECL
+void
+rtrim(InlineContainer& inlines);
+
+/** Removes leading and trailing whitespace from the text elements in the given InlineContainer.
+
+    @param inlines The InlineContainer to trim.
+    @return void
+ */
+inline
+void
+trim(InlineContainer& inlines)
+{
+    ltrim(inlines);
+    rtrim(inlines);
+}
+
+/** Flatten an InlineContainer to plain text.
+
+    This concatenates all text nodes, ignoring formatting.
+
+    @param in The InlineContainer to flatten.
+    @param dst The output string to append to.
+ */
+MRDOCS_DECL
+void
+getAsPlainText(doc::InlineContainer const& in, std::string& dst);
+
+/** Flatten an InlineContainer to plain text.
+
+    This concatenates all text nodes, ignoring formatting.
+
+    @param in The InlineContainer to flatten.
+    @return The flattened plain text.
+ */
+inline
+std::string
+getAsPlainText(doc::InlineContainer const& in)
+{
+    std::string dst;
+    getAsPlainText(in, dst);
+    return dst;
+}
+
+/// A leaf node that stores a string of text.
+struct MRDOCS_DECL InlineTextLeaf
+{
+    std::string literal;
+
+    explicit
+    InlineTextLeaf(std::string_view literal_)
+        : literal(literal_)
+    {}
+
+    explicit
+    InlineTextLeaf(std::string const& literal_)
+        : literal(literal_)
+    {}
+
+    explicit
+    InlineTextLeaf(std::string&& literal_) noexcept
+        : literal(std::move(literal_))
+    {}
+
+    auto operator<=>(InlineTextLeaf const&) const = default;
+    bool operator==(InlineTextLeaf const&) const noexcept = default;
+};
+
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_INLINEBASE_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Inline/InlineKind.hpp b/include/mrdocs/Metadata/DocComment/Inline/InlineKind.hpp
new file mode 100644
index 000000000..38570e822
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Inline/InlineKind.hpp
@@ -0,0 +1,47 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_INLINEKIND_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_INLINEKIND_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Dom.hpp>
+
+namespace mrdocs::doc {
+
+enum class InlineKind {
+    #define INFO(Type) Type,
+#include <mrdocs/Metadata/DocComment/Inline/InlineNodes.inc>
+};
+
+inline
+dom::String
+toString(InlineKind kind) noexcept
+{
+    switch (kind)
+    {
+        #define INFO(Type) case InlineKind::Type: return toKebabCase(#Type);
+#include <mrdocs/Metadata/DocComment/Inline/InlineNodes.inc>
+    }
+    return "Unknown";
+}
+
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v, InlineKind const kind)
+{
+    v = toString(kind);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_INLINEKIND_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Inline/InlineNodes.inc b/include/mrdocs/Metadata/DocComment/Inline/InlineNodes.inc
new file mode 100644
index 000000000..9afbafecc
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Inline/InlineNodes.inc
@@ -0,0 +1,32 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef INFO
+#define INFO(PascalName)
+#endif
+
+INFO(Reference)
+INFO(CopyDetails)
+INFO(Link)
+INFO(Text)
+INFO(SoftBreak)
+INFO(LineBreak)
+INFO(Code)
+INFO(Emph)
+INFO(Strong)
+INFO(Image)
+INFO(FootnoteReference)
+INFO(Strikethrough)
+INFO(Math)
+INFO(Superscript)
+INFO(Subscript)
+INFO(Highlight)
+
+#undef INFO
diff --git a/include/mrdocs/Metadata/DocComment/Inline/LineBreakInline.hpp b/include/mrdocs/Metadata/DocComment/Inline/LineBreakInline.hpp
new file mode 100644
index 000000000..45e535690
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Inline/LineBreakInline.hpp
@@ -0,0 +1,65 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_LINEBREAKINLINE_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_LINEBREAKINLINE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/InlineBase.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** A hard line break that renders as "<br>"
+*/
+struct LineBreakInline
+    : InlineCommonBase<InlineKind::LineBreak>
+{
+    constexpr ~LineBreakInline() override = default;
+    constexpr LineBreakInline() noexcept = default;
+    auto operator<=>(LineBreakInline const&) const = default;
+    bool operator==(LineBreakInline const&) const noexcept = default;
+};
+
+/** Map the @ref LineBreak to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    LineBreakInline const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Inline const&>(I), domCorpus);
+}
+
+/** Return the @ref LineBreak as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    LineBreakInline const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_LINEBREAKINLINE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Inline/Link.hpp b/include/mrdocs/Metadata/DocComment/Inline/LinkInline.hpp
similarity index 50%
rename from include/mrdocs/Metadata/Javadoc/Inline/Link.hpp
rename to include/mrdocs/Metadata/DocComment/Inline/LinkInline.hpp
index bd7464afe..947a51047 100644
--- a/include/mrdocs/Metadata/Javadoc/Inline/Link.hpp
+++ b/include/mrdocs/Metadata/DocComment/Inline/LinkInline.hpp
@@ -4,45 +4,37 @@
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
 //
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_INLINE_LINK_HPP
-#define MRDOCS_API_METADATA_JAVADOC_INLINE_LINK_HPP
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_LINKINLINE_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_LINKINLINE_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Inline/Text.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/TextInline.hpp>
 #include <string>
 
 namespace mrdocs::doc {
 
 /** A hyperlink.
 */
-struct Link final : Text
+struct LinkInline final
+    : InlineCommonBase<InlineKind::Link>
+    , InlineContainer
 {
     std::string href;
 
-    static constexpr auto static_kind = NodeKind::link;
+    LinkInline() = default;
 
-    explicit
-    Link(
-        std::string string_ = std::string(),
-        std::string href_ = std::string()) noexcept
-        : Text(std::move(string_), NodeKind::link)
-        , href(std::move(href_))
-    {
-    }
+    LinkInline(std::string_view text, std::string_view href)
+        : InlineContainer(text)
+        , href(href)
+    {}
 
-    auto operator<=>(Link const&) const = default;
-    bool operator==(Link const&) const noexcept = default;
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Link const&>(other);
-    }
+    auto operator<=>(LinkInline const&) const = default;
+    bool operator==(LinkInline const&) const noexcept = default;
 };
 
 /** Map the @ref Link to a @ref dom::Object.
@@ -57,10 +49,11 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    Link const& I,
+    LinkInline const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Text const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<Inline const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<InlineContainer const&>(I), domCorpus);
     io.map("href", I.href);
 }
 
@@ -71,7 +64,7 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    Link const& I,
+    LinkInline const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
@@ -79,4 +72,4 @@ tag_invoke(
 
 } // mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_INLINE_LINK_HPP
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_LINKINLINE_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Inline/MathInline.hpp b/include/mrdocs/Metadata/DocComment/Inline/MathInline.hpp
new file mode 100644
index 000000000..9ba7aceb1
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Inline/MathInline.hpp
@@ -0,0 +1,75 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_MATHINLINE_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_MATHINLINE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/InlineBase.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** An inline LaTeX math expression
+
+    Inline LaTeX math, typically between $…$.
+ */
+struct MathInline
+    : InlineCommonBase<InlineKind::Math>
+{
+    std::string literal;
+
+    constexpr ~MathInline() override = default;
+    constexpr MathInline() noexcept = default;
+
+    explicit MathInline(std::string string_) noexcept
+        : literal(std::move(string_))
+    {}
+
+    auto operator<=>(MathInline const&) const = default;
+    bool operator==(MathInline const&) const noexcept = default;
+};
+
+/** Map the @ref Math to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    MathInline const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Inline const&>(I), domCorpus);
+    io.map("literal", I.literal);
+}
+
+/** Return the @ref Math as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    MathInline const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_MATHINLINE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Inline/Parts.hpp b/include/mrdocs/Metadata/DocComment/Inline/Parts.hpp
similarity index 83%
rename from include/mrdocs/Metadata/Javadoc/Inline/Parts.hpp
rename to include/mrdocs/Metadata/DocComment/Inline/Parts.hpp
index 268acd258..9a417e124 100644
--- a/include/mrdocs/Metadata/Javadoc/Inline/Parts.hpp
+++ b/include/mrdocs/Metadata/DocComment/Inline/Parts.hpp
@@ -6,12 +6,13 @@
 //
 // Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
 // Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
 //
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_INLINE_PARTS_HPP
-#define MRDOCS_API_METADATA_JAVADOC_INLINE_PARTS_HPP
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_PARTS_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_PARTS_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Dom.hpp>
@@ -54,4 +55,4 @@ tag_invoke(
 
 } // mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_INLINE_PARTS_HPP
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_PARTS_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Inline/Reference.hpp b/include/mrdocs/Metadata/DocComment/Inline/ReferenceInline.hpp
similarity index 54%
rename from include/mrdocs/Metadata/Javadoc/Inline/Reference.hpp
rename to include/mrdocs/Metadata/DocComment/Inline/ReferenceInline.hpp
index 76b6146c9..8cd7db65d 100644
--- a/include/mrdocs/Metadata/Javadoc/Inline/Reference.hpp
+++ b/include/mrdocs/Metadata/DocComment/Inline/ReferenceInline.hpp
@@ -6,15 +6,16 @@
 //
 // Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
 // Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
 //
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_API_METADATA_JAVADOC_INLINE_REFERENCE_HPP
-#define MRDOCS_API_METADATA_JAVADOC_INLINE_REFERENCE_HPP
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_REFERENCEINLINE_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_REFERENCEINLINE_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Inline/Text.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/TextInline.hpp>
 #include <mrdocs/Metadata/Symbol/SymbolID.hpp>
 #include <string>
 
@@ -22,34 +23,18 @@ namespace mrdocs::doc {
 
 /** A reference to a symbol.
 */
-struct Reference : Text
+struct ReferenceInline
+    : InlineCommonBase<InlineKind::Reference>
 {
+    std::string literal;
     SymbolID id = SymbolID::invalid;
 
-    static constexpr auto static_kind = NodeKind::reference;
+    explicit ReferenceInline(std::string str = {}) noexcept
+        : literal(std::move(str))
+    {}
 
-    explicit
-    Reference(
-        std::string string_ = std::string()) noexcept
-        : Text(std::move(string_), NodeKind::reference)
-    {
-    }
-
-    auto operator<=>(Reference const&) const = default;
-    bool operator==(Reference const&) const noexcept = default;
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Reference const&>(other);
-    }
-
-protected:
-    Reference(
-        std::string string_,
-        NodeKind const kind_) noexcept
-        : Text(std::move(string_), kind_)
-    {
-    }
+    auto operator<=>(ReferenceInline const&) const = default;
+    bool operator==(ReferenceInline const&) const noexcept = default;
 };
 
 /** Map the @ref Reference to a @ref dom::Object.
@@ -64,10 +49,11 @@ void
 tag_invoke(
     dom::LazyObjectMapTag t,
     IO& io,
-    Reference const& I,
+    ReferenceInline const& I,
     DomCorpus const* domCorpus)
 {
-    tag_invoke(t, io, dynamic_cast<Text const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<Inline const&>(I), domCorpus);
+    io.map("literal", I.literal);
     io.map("symbol", I.id);
 }
 
@@ -78,7 +64,7 @@ void
 tag_invoke(
     dom::ValueFromTag,
     dom::Value& v,
-    Reference const& I,
+    ReferenceInline const& I,
     DomCorpus const* domCorpus)
 {
     v = dom::LazyObject(I, domCorpus);
@@ -86,4 +72,4 @@ tag_invoke(
 
 } // mrdocs::doc
 
-#endif // MRDOCS_API_METADATA_JAVADOC_INLINE_REFERENCE_HPP
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_REFERENCEINLINE_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Inline/SoftBreakInline.hpp b/include/mrdocs/Metadata/DocComment/Inline/SoftBreakInline.hpp
new file mode 100644
index 000000000..35a77e166
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Inline/SoftBreakInline.hpp
@@ -0,0 +1,65 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_SOFTBREAKINLINE_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_SOFTBREAKINLINE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/InlineBase.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** A line break that may render as space
+*/
+struct SoftBreakInline
+    : InlineCommonBase<InlineKind::SoftBreak>
+{
+    constexpr ~SoftBreakInline() override = default;
+    constexpr SoftBreakInline() noexcept = default;
+    auto operator<=>(SoftBreakInline const&) const = default;
+    bool operator==(SoftBreakInline const&) const noexcept = default;
+};
+
+/** Map the @ref SoftBreak to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    SoftBreakInline const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Inline const&>(I), domCorpus);
+}
+
+/** Return the @ref SoftBreak as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    SoftBreakInline const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_SOFTBREAKINLINE_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Inline/StrikethroughInline.hpp b/include/mrdocs/Metadata/DocComment/Inline/StrikethroughInline.hpp
new file mode 100644
index 000000000..f0f38470d
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Inline/StrikethroughInline.hpp
@@ -0,0 +1,66 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_STRIKETHROUGHINLINE_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_STRIKETHROUGHINLINE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/TextInline.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** A piece of styled text.
+*/
+struct StrikethroughInline final
+    : InlineCommonBase<InlineKind::Strikethrough>
+    , InlineContainer
+{
+    auto operator<=>(StrikethroughInline const&) const = default;
+    bool operator==(StrikethroughInline const&) const noexcept = default;
+};
+
+/** Map the @ref Strikethrough to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    StrikethroughInline const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Inline const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<InlineContainer const&>(I), domCorpus);
+}
+
+/** Return the @ref Strikethrough as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    StrikethroughInline const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_STRIKETHROUGHINLINE_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Inline/StrongInline.hpp b/include/mrdocs/Metadata/DocComment/Inline/StrongInline.hpp
new file mode 100644
index 000000000..1eb209280
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Inline/StrongInline.hpp
@@ -0,0 +1,67 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_STRONGINLINE_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_STRONGINLINE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/TextInline.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** A piece of styled text.
+*/
+struct StrongInline final
+    : InlineCommonBase<InlineKind::Strong>
+    , InlineContainer
+{
+    using InlineContainer::InlineContainer;
+    auto operator<=>(StrongInline const&) const = default;
+    bool operator==(StrongInline const&) const noexcept = default;
+};
+
+/** Map the @ref Strong to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    StrongInline const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Inline const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<InlineContainer const&>(I), domCorpus);
+}
+
+/** Return the @ref Strong as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    StrongInline const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_STRONGINLINE_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Inline/SubscriptInline.hpp b/include/mrdocs/Metadata/DocComment/Inline/SubscriptInline.hpp
new file mode 100644
index 000000000..84461d57b
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Inline/SubscriptInline.hpp
@@ -0,0 +1,66 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_SUBSCRIPTINLINE_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_SUBSCRIPTINLINE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/TextInline.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** A piece of styled text.
+*/
+struct SubscriptInline final
+    : InlineCommonBase<InlineKind::Subscript>
+    , InlineContainer
+{
+    auto operator<=>(SubscriptInline const&) const = default;
+    bool operator==(SubscriptInline const&) const noexcept = default;
+};
+
+/** Map the @ref Subscript to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    SubscriptInline const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Inline const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<InlineContainer const&>(I), domCorpus);
+}
+
+/** Return the @ref Subscript as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    SubscriptInline const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_SUBSCRIPTINLINE_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Inline/SuperscriptInline.hpp b/include/mrdocs/Metadata/DocComment/Inline/SuperscriptInline.hpp
new file mode 100644
index 000000000..772c6b4ad
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Inline/SuperscriptInline.hpp
@@ -0,0 +1,66 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_SUPERSCRIPTINLINE_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_SUPERSCRIPTINLINE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/TextInline.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** A piece of styled text.
+*/
+struct SuperscriptInline final
+    : InlineCommonBase<InlineKind::Superscript>
+    , InlineContainer
+{
+    auto operator<=>(SuperscriptInline const&) const = default;
+    bool operator==(SuperscriptInline const&) const noexcept = default;
+};
+
+/** Map the @ref Superscript to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    SuperscriptInline const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Inline const&>(I), domCorpus);
+    tag_invoke(t, io, dynamic_cast<InlineContainer const&>(I), domCorpus);
+}
+
+/** Return the @ref Superscript as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    SuperscriptInline const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_SUPERSCRIPTINLINE_HPP
diff --git a/include/mrdocs/Metadata/DocComment/Inline/TextInline.hpp b/include/mrdocs/Metadata/DocComment/Inline/TextInline.hpp
new file mode 100644
index 000000000..0df55cae7
--- /dev/null
+++ b/include/mrdocs/Metadata/DocComment/Inline/TextInline.hpp
@@ -0,0 +1,90 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_METADATA_DOCCOMMENT_INLINE_TEXTINLINE_HPP
+#define MRDOCS_API_METADATA_DOCCOMMENT_INLINE_TEXTINLINE_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/InlineBase.hpp>
+#include <string>
+
+namespace mrdocs::doc {
+
+/** A Node containing a string of text.
+
+    There will be no newlines in the text. Otherwise,
+    this would be represented as multiple text nodes
+    within a Paragraph node.
+*/
+struct TextInline
+    : InlineCommonBase<InlineKind::Text>
+{
+    std::string literal;
+
+    constexpr ~TextInline() override = default;
+
+    constexpr TextInline() noexcept = default;
+
+    explicit TextInline(std::string_view str) noexcept
+        : literal(str)
+    {}
+
+    explicit TextInline(char const* str) noexcept
+        : literal(str)
+    {}
+
+    explicit TextInline(std::string const& str) noexcept
+        : literal(str)
+    {}
+
+    explicit TextInline(std::string&& str) noexcept
+        : literal(std::move(str))
+    {}
+
+    auto operator<=>(TextInline const&) const = default;
+    bool operator==(TextInline const&) const noexcept = default;
+};
+
+/** Map the @ref Text to a @ref dom::Object.
+
+    @param t The tag.
+    @param io The output object.
+    @param I The input object.
+    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
+ */
+template <class IO>
+void
+tag_invoke(
+    dom::LazyObjectMapTag t,
+    IO& io,
+    TextInline const& I,
+    DomCorpus const* domCorpus)
+{
+    tag_invoke(t, io, dynamic_cast<Inline const&>(I), domCorpus);
+    io.map("literal", I.literal);
+}
+
+/** Return the @ref Text as a @ref dom::Value object.
+ */
+inline
+void
+tag_invoke(
+    dom::ValueFromTag,
+    dom::Value& v,
+    TextInline const& I,
+    DomCorpus const* domCorpus)
+{
+    v = dom::LazyObject(I, domCorpus);
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_API_METADATA_DOCCOMMENT_INLINE_TEXTINLINE_HPP
diff --git a/include/mrdocs/Metadata/DomCorpus.hpp b/include/mrdocs/Metadata/DomCorpus.hpp
index a50f681f0..3eab8ade3 100644
--- a/include/mrdocs/Metadata/DomCorpus.hpp
+++ b/include/mrdocs/Metadata/DomCorpus.hpp
@@ -21,7 +21,7 @@ namespace mrdocs {
 
 class Corpus;
 struct Symbol;
-struct Javadoc;
+struct DocComment;
 class SymbolID;
 
 /** Front-end factory for producing Dom nodes.
@@ -94,7 +94,7 @@ class MRDOCS_DECL
     dom::Value
     get(SymbolID const& id) const;
 
-    /** Return a Dom value representing the Javadoc.
+    /** Return a Dom value representing the DocComment.
 
         The default implementation returns null. A
         @ref Generator should override this member
@@ -103,7 +103,7 @@ class MRDOCS_DECL
     */
     virtual
     dom::Value
-    getJavadoc(Javadoc const& jd) const;
+    getDocComment(DocComment const& jd) const;
 };
 
 /** Return a list of the parent symbols of the specified Info.
diff --git a/include/mrdocs/Metadata/Javadoc.hpp b/include/mrdocs/Metadata/Javadoc.hpp
deleted file mode 100644
index 071a13f09..000000000
--- a/include/mrdocs/Metadata/Javadoc.hpp
+++ /dev/null
@@ -1,289 +0,0 @@
-//
-// This is a derivative work. originally part of the LLVM Project.
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#ifndef MRDOCS_API_METADATA_JAVADOC_HPP
-#define MRDOCS_API_METADATA_JAVADOC_HPP
-
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/ADT/Polymorphic.hpp>
-#include <mrdocs/Metadata/Javadoc/Node.hpp>
-
-namespace mrdocs {
-
-/** A processed documentation comment attached to a declaration.
-
-    A complete documentation comment consists of a
-    sequence of text blocks.
-
-    Some blocks are used to contain regular text,
-    such as paragraphs and lists. These are
-    analogous to markdown blocks.
-
-    Other blocks contain metadata about the declaration,
-    such as parameters and return values. These
-    blocks are stored separately in the
-    @ref Javadoc structure.
-
-    Each block in the document might contain:
-
-    - No other blocks (leaf blocks)
-    - Other blocks (container blocks: e.g. lists)
-
-    When they contain no other blocks, they might be:
-
-    - Inlines only (e.g. paragraphs)
-    - No inlines (e.g. horizontal rule)
-
-    Inline content elements contain other inlines
-    but cannot contain blocks.
- */
-struct MRDOCS_DECL
-    Javadoc
-{
-    /// The list of text blocks.
-    std::vector<Polymorphic<doc::Block>> blocks;
-
-    // ----------------------
-    // Symbol Metadata
-
-    /// A brief description of the symbol.
-    Optional<doc::Brief> brief;
-
-    /** The list of return type descriptions.
-
-        Multiple return descriptions are allowed.
-
-        The results are concatenated in the order
-        they appear in the source code.
-     */
-    std::vector<doc::Returns> returns;
-
-    /// The list of parameters.
-    std::vector<doc::Param> params;
-
-    /// The list of template parameters.
-    std::vector<doc::TParam> tparams;
-
-    /// The list of exceptions.
-    std::vector<doc::Throws> exceptions;
-
-    /// The list of "see also" references.
-    std::vector<doc::See> sees;
-
-    /// The list of preconditions.
-    std::vector<doc::Precondition> preconditions;
-
-    /// The list of postconditions.
-    std::vector<doc::Postcondition> postconditions;
-
-    /** The list of "relates" references.
-
-        These references are creates with the
-        \\relates command.
-     */
-    std::vector<doc::Reference> relates;
-
-    /** The list of "related" references.
-
-        These references are the inverse of
-        the \\relates command.
-     */
-    std::vector<doc::Reference> related;
-
-    /** Constructor.
-    */
-    MRDOCS_DECL
-    Javadoc() noexcept;
-
-    /** Constructor
-    */
-    explicit
-    Javadoc(
-        std::vector<Polymorphic<doc::Block>> blocks);
-
-    /** Return true if this is empty
-    */
-    bool
-    empty() const noexcept
-    {
-        return
-            blocks.empty() &&
-            !brief &&
-            returns.empty() &&
-            params.empty() &&
-            tparams.empty() &&
-            exceptions.empty() &&
-            sees.empty() &&
-            related.empty() &&
-            preconditions.empty() &&
-            postconditions.empty();
-    }
-
-    /** Return the list of top level blocks.
-    */
-    std::vector<Polymorphic<doc::Block>> const&
-    getBlocks() const noexcept
-    {
-        return blocks;
-    }
-
-    // VFALCO This is unfortunately necessary for
-    //        the deserialization from bitcode...
-    std::vector<Polymorphic<doc::Block>>&
-    getBlocks() noexcept
-    {
-        return blocks;
-    }
-
-    //--------------------------------------------
-
-    /** Comparison
-
-        These are used internally to impose a
-        total ordering, and not visible in the
-        output format.
-    */
-    /** @{ */
-    auto operator<=>(Javadoc const& other) const noexcept {
-        if (auto const cmp = blocks.size() <=> other.blocks.size();
-            !std::is_eq(cmp))
-        {
-            return cmp;
-        }
-        for (std::size_t i = 0; i < blocks.size(); ++i)
-        {
-            if (auto cmp = CompareDerived(blocks[i], other.blocks[i]);
-                !std::is_eq(cmp))
-            {
-                return cmp;
-            }
-        }
-        return std::strong_ordering::equal;
-    }
-    bool operator==(Javadoc const&) const noexcept;
-    bool operator!=(Javadoc const&) const noexcept;
-    /* @} */
-
-    //--------------------------------------------
-
-    /** Attempt to append a block.
-
-        @return An empty string on success, otherwise
-        a string indicating the reason for the failure.
-
-        @param block The block to append.
-    */
-    template<std::derived_from<doc::Block> T>
-    std::string
-    emplace_back(T&& block)
-    {
-        return emplace_back(Polymorphic<doc::Block>(std::in_place_type<T>,
-                                                    std::forward<T>(block)));
-    }
-
-    /** Append blocks from another javadoc to this.
-    */
-    void append(Javadoc&& other);
-
-    /** Append blocks from a list to this.
-
-        @param blocks The blocks to append.
-     */
-    void
-    append(std::vector<Polymorphic<doc::Node>>&& blocks);
-
-private:
-    std::string
-    emplace_back(Polymorphic<doc::Block>);
-};
-
-inline
-void merge(Javadoc& I, Javadoc&& other)
-{
-    // FIXME: this doesn't merge parameter information;
-    // parameters with the same name but different directions
-    // or descriptions end up being duplicated
-    if(other != I)
-    {
-        // Unconditionally extend the blocks
-        // since each decl may have a comment.
-        I.append(std::move(other));
-    }
-}
-
-/** Map the @ref Javadoc to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The javadoc to map.
-    @param domCorpus The DOM corpus, or nullptr.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Javadoc const& I,
-    DomCorpus const* domCorpus)
-{
-    io.defer("description", [&I, domCorpus] {
-        return dom::LazyArray(I.blocks, domCorpus);
-    });
-    if (I.brief && !I.brief->children.empty())
-    {
-        io.map("brief", I.brief);
-    }
-    io.defer("returns", [&I, domCorpus] {
-        return dom::LazyArray(I.returns, domCorpus);
-    });
-    io.defer("params", [&I, domCorpus] {
-        return dom::LazyArray(I.params, domCorpus);
-    });
-    io.defer("tparams", [&I, domCorpus] {
-        return dom::LazyArray(I.tparams, domCorpus);
-    });
-    io.defer("exceptions", [&I, domCorpus] {
-        return dom::LazyArray(I.exceptions, domCorpus);
-    });
-    io.defer("sees", [&I, domCorpus] {
-        return dom::LazyArray(I.sees, domCorpus);
-    });
-    io.defer("relates", [&I, domCorpus] {
-        return dom::LazyArray(I.relates, domCorpus);
-    });
-    io.defer("related", [&I, domCorpus] {
-        return dom::LazyArray(I.related, domCorpus);
-    });
-    io.defer("preconditions", [&I, domCorpus] {
-        return dom::LazyArray(I.preconditions, domCorpus);
-    });
-    io.defer("postconditions", [&I, domCorpus] {
-        return dom::LazyArray(I.postconditions, domCorpus);
-    });
-}
-
-/** Return the @ref Javadoc as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Javadoc const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-} // mrdocs
-
-#endif
diff --git a/include/mrdocs/Metadata/Javadoc/Block.hpp b/include/mrdocs/Metadata/Javadoc/Block.hpp
deleted file mode 100644
index 5680878b9..000000000
--- a/include/mrdocs/Metadata/Javadoc/Block.hpp
+++ /dev/null
@@ -1,136 +0,0 @@
-//
-// This is a derivative work. originally part of the LLVM Project.
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_HPP
-#define MRDOCS_API_METADATA_JAVADOC_BLOCK_HPP
-
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Admonish.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Admonition.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Brief.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Code.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Heading.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/ListItem.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Param.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/ParamDirection.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Postcondition.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Precondition.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Returns.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/See.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/TParam.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Throws.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/UnorderedList.hpp>
-#include <mrdocs/Support/Visitor.hpp>
-
-namespace mrdocs::doc {
-/** Visit a block.
-
-    @param block The block to visit.
-    @param fn The function to call for each block.
-    @param args Additional arguments to pass to the function.
-    @return The result of calling the function.
- */
-template<
-    class BlockTy,
-    class Fn,
-    class... Args>
-    requires std::derived_from<BlockTy, Block>
-decltype(auto)
-visit(
-    BlockTy& block,
-    Fn&& fn,
-    Args&&... args)
-{
-    auto visitor = makeVisitor<Block>(
-        block, std::forward<Fn>(fn),
-        std::forward<Args>(args)...);
-    switch(block.Kind)
-    {
-    case NodeKind::admonition:
-        return visitor.template visit<Admonition>();
-    case NodeKind::brief:
-        return visitor.template visit<Brief>();
-    case NodeKind::code:
-        return visitor.template visit<Code>();
-    case NodeKind::heading:
-        return visitor.template visit<Heading>();
-    case NodeKind::paragraph:
-        return visitor.template visit<Paragraph>();
-    case NodeKind::list_item:
-        return visitor.template visit<ListItem>();
-    case NodeKind::unordered_list:
-        return visitor.template visit<UnorderedList>();
-    case NodeKind::param:
-        return visitor.template visit<Param>();
-    case NodeKind::returns:
-        return visitor.template visit<Returns>();
-    case NodeKind::tparam:
-        return visitor.template visit<TParam>();
-    case NodeKind::throws:
-        return visitor.template visit<Throws>();
-    case NodeKind::see:
-        return visitor.template visit<See>();
-    case NodeKind::precondition:
-        return visitor.template visit<Precondition>();
-    case NodeKind::postcondition:
-        return visitor.template visit<Postcondition>();
-    default:
-        MRDOCS_UNREACHABLE();
-    }
-}
-
-/** Traverse a list of blocks.
-
-    @param list The list of blocks to traverse.
-    @param f The function to call for each block.
-    @param args Additional arguments to pass to the function.
- */
-template<class F, class T, class... Args>
-requires std::derived_from<T, Block>
-void traverse(
-    std::vector<std::unique_ptr<T>> const& list,
-    F&& f, Args&&... args)
-{
-    for(auto const& block : list)
-        visit(*block,
-            std::forward<F>(f),
-            std::forward<Args>(args)...);
-}
-
-/** Map the Polymorphic Block as a @ref dom::Value object.
-
-    @param io The output parameter to receive the dom::Object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO, polymorphic_storage_for<Block> BlockTy>
-void
-tag_invoke(
-    dom::ValueFromTag,
-    IO& io,
-    BlockTy const& I,
-    DomCorpus const* domCorpus)
-{
-    visit(*I, [&](auto const& U)
-    {
-        tag_invoke(
-            dom::ValueFromTag{},
-            io,
-            U,
-            domCorpus);
-    });
-}
-} // mrdocs::doc
-
-#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Admonition.hpp b/include/mrdocs/Metadata/Javadoc/Block/Admonition.hpp
deleted file mode 100644
index 5c2465ed7..000000000
--- a/include/mrdocs/Metadata/Javadoc/Block/Admonition.hpp
+++ /dev/null
@@ -1,89 +0,0 @@
-//
-// This is a derivative work. originally part of the LLVM Project.
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_ADMONITION_HPP
-#define MRDOCS_API_METADATA_JAVADOC_BLOCK_ADMONITION_HPP
-
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Admonish.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
-#include <string>
-
-namespace mrdocs::doc {
-
-/** An admonition.
-
-    This paragraph represents an admonition, such as
-    a note, tip, important, caution, or warning.
-
-*/
-struct Admonition final : Paragraph
-{
-    Admonish admonish;
-
-    explicit
-    Admonition(
-        Admonish const admonish_ = Admonish::none) noexcept
-        : Paragraph(NodeKind::admonition)
-        , admonish(admonish_)
-    {
-    }
-
-    using Paragraph::operator=;
-
-    auto operator<=>(Admonition const&) const = default;
-
-    bool operator==(Admonition const&) const noexcept = default;
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Admonition const&>(other);
-    }
-};
-
-/** Map the @ref Admonition to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Admonition const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
-    io.map("admonish", I.admonish);
-}
-
-/** Return the @ref Admonition as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Admonition const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-} // mrdocs::doc
-
-#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_ADMONITION_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/BlockBase.hpp b/include/mrdocs/Metadata/Javadoc/Block/BlockBase.hpp
deleted file mode 100644
index a65e8ff16..000000000
--- a/include/mrdocs/Metadata/Javadoc/Block/BlockBase.hpp
+++ /dev/null
@@ -1,149 +0,0 @@
-//
-// This is a derivative work. originally part of the LLVM Project.
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_BLOCKBASE_HPP
-#define MRDOCS_API_METADATA_JAVADOC_BLOCK_BLOCKBASE_HPP
-
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/Dom.hpp>
-#include <mrdocs/Dom/LazyArray.hpp>
-#include <mrdocs/Dom/LazyObject.hpp>
-#include <mrdocs/Metadata/Javadoc/Inline.hpp>
-#include <mrdocs/Metadata/Javadoc/Node/NodeBase.hpp>
-#include <algorithm>
-#include <string>
-
-namespace mrdocs::doc {
-
-/** A piece of block content
-
-    The top level is a list of blocks.
-
-    There are two types of blocks: headings and paragraphs
-*/
-struct MRDOCS_DECL
-    Block : Node
-{
-    std::vector<Polymorphic<Text>> children;
-
-    bool isBlock() const noexcept final
-    {
-        return true;
-    }
-
-    bool empty() const noexcept
-    {
-        return children.empty();
-    }
-
-    auto operator<=>(Block const& other) const {
-        if (auto const cmp = children.size() <=> other.children.size();
-            !std::is_eq(cmp))
-        {
-            return cmp;
-        }
-        for (std::size_t i = 0; i < children.size(); ++i)
-        {
-            if (auto const cmp = *children[i] <=> *other.children[i];
-                !std::is_eq(cmp))
-            {
-                return cmp;
-            }
-        }
-        return std::strong_ordering::equal;
-    }
-
-    bool operator==(Block const& other) const noexcept
-    {
-        if (Kind != other.Kind)
-        {
-            return false;
-        }
-        return std::ranges::
-            equal(children, other.children,
-            [](auto const& a, auto const& b)
-            {
-                return a->equals(*b);
-            });
-    }
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Block const&>(other);
-    }
-
-    template<std::derived_from<Text> T>
-    T& emplace_back(T&& text)
-    {
-        return static_cast<T&>(emplace_back(
-            std::make_unique<T>(std::forward<T>(text))));
-    }
-
-    void append(std::vector<Polymorphic<Node>>&& blocks);
-
-    void append(std::vector<Polymorphic<Text>> const& otherChildren);
-
-protected:
-    constexpr
-    Block() = default;
-
-    explicit
-    Block(
-        NodeKind const kind_,
-        std::vector<Polymorphic<Text>> children_ = {}) noexcept
-        : Node(kind_)
-        , children(std::move(children_))
-    {
-    }
-
-private:
-    Text& emplace_back(Polymorphic<Text> text);
-};
-
-/** Map the @ref Block to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Block const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Node const&>(I), domCorpus);
-    io.defer("children", [&I, domCorpus] {
-        return dom::LazyArray(I.children, domCorpus);
-    });
-}
-
-/** Return the @ref Block as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Block const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-} // mrdocs::doc
-
-#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_BLOCKBASE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Brief.hpp b/include/mrdocs/Metadata/Javadoc/Block/Brief.hpp
deleted file mode 100644
index b3ae24e09..000000000
--- a/include/mrdocs/Metadata/Javadoc/Block/Brief.hpp
+++ /dev/null
@@ -1,98 +0,0 @@
-//
-// This is a derivative work. originally part of the LLVM Project.
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_BRIEF_HPP
-#define MRDOCS_API_METADATA_JAVADOC_BLOCK_BRIEF_HPP
-
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
-#include <mrdocs/Metadata/Javadoc/Node/NodeBase.hpp>
-#include <string>
-
-namespace mrdocs::doc {
-
-/** The brief description
-*/
-struct Brief final : Paragraph
-{
-    static constexpr NodeKind static_kind = NodeKind::brief;
-
-    std::vector<std::string> copiedFrom;
-
-    Brief() noexcept
-        : Paragraph(NodeKind::brief)
-    {
-    }
-
-    explicit
-    Brief(std::string_view const text)
-        : Brief()
-    {
-        operator=(text);
-    }
-
-    Brief(Brief const& other) = default;
-
-    Brief&
-    operator=(Brief const& other) = default;
-
-    Brief&
-    operator=(std::string_view const text) override
-    {
-        Paragraph::operator=(text);
-        return *this;
-    }
-
-    auto operator<=>(Brief const&) const = default;
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Brief const&>(other);
-    }
-};
-
-/** Map the @ref Brief to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Brief const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
-}
-
-/** Return the @ref Brief as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Brief const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-} // mrdocs::doc
-
-#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_BRIEF_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Code.hpp b/include/mrdocs/Metadata/Javadoc/Block/Code.hpp
deleted file mode 100644
index 1e4b1fc3f..000000000
--- a/include/mrdocs/Metadata/Javadoc/Block/Code.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-//
-// This is a derivative work. originally part of the LLVM Project.
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_CODE_HPP
-#define MRDOCS_API_METADATA_JAVADOC_BLOCK_CODE_HPP
-
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
-#include <string>
-
-namespace mrdocs::doc {
-
-/** Preformatted source code.
- */
-struct Code final : Paragraph
-{
-    // VFALCO we can add a language (e.g., C++),
-    //        then emit attributes in the generator.
-
-    static constexpr auto static_kind = NodeKind::code;
-
-    Code() noexcept
-        : Paragraph(NodeKind::code)
-    {
-    }
-
-    using Paragraph::operator=;
-    auto operator<=>(Code const&) const = default;
-    bool operator==(Code const&) const noexcept = default;
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-               *this == dynamic_cast<Code const&>(other);
-    }
-};
-
-/** Map the @ref Code to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Code const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
-}
-
-/** Return the @ref Code as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Code const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-} // mrdocs::doc
-
-#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_CODE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Param.hpp b/include/mrdocs/Metadata/Javadoc/Block/Param.hpp
deleted file mode 100644
index d76069843..000000000
--- a/include/mrdocs/Metadata/Javadoc/Block/Param.hpp
+++ /dev/null
@@ -1,116 +0,0 @@
-//
-// This is a derivative work. originally part of the LLVM Project.
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAM_HPP
-#define MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAM_HPP
-
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/ParamDirection.hpp>
-#include <string>
-
-namespace mrdocs::doc {
-
-/** Documentation for a function parameter
-*/
-struct Param final : Paragraph
-{
-    std::string name;
-    ParamDirection direction;
-
-    static constexpr auto static_kind = NodeKind::param;
-
-    Param(
-        std::string name_ = std::string(),
-        Paragraph details_ = Paragraph(),
-        ParamDirection const direction_ = ParamDirection::none)
-        : Paragraph(
-            NodeKind::param,
-            std::move(details_.children))
-        , name(std::move(name_))
-        , direction(direction_)
-    {
-    }
-
-    explicit
-    Param(
-        std::string_view const name,
-        std::string_view const text)
-    : Param()
-    {
-        this->name = name;
-        this->operator=(text);
-    }
-
-    explicit
-    Param(Paragraph const& other)
-        : Param()
-    {
-        children = other.children;
-    }
-
-    Param&
-    operator=(std::string_view const text) override
-    {
-        Paragraph::operator=(text);
-        return *this;
-    }
-
-    auto operator<=>(Param const&) const = default;
-
-    bool operator==(Param const&)
-        const noexcept = default;
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Param const&>(other);
-    }
-};
-
-/** Map the @ref Param to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Param const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
-    io.map("name", I.name);
-    io.map("direction", I.direction);
-}
-
-/** Return the @ref Param as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Param const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-} // mrdocs::doc
-
-#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_PARAM_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Block/Returns.hpp b/include/mrdocs/Metadata/Javadoc/Block/Returns.hpp
deleted file mode 100644
index 186318235..000000000
--- a/include/mrdocs/Metadata/Javadoc/Block/Returns.hpp
+++ /dev/null
@@ -1,100 +0,0 @@
-//
-// This is a derivative work. originally part of the LLVM Project.
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#ifndef MRDOCS_API_METADATA_JAVADOC_BLOCK_RETURNS_HPP
-#define MRDOCS_API_METADATA_JAVADOC_BLOCK_RETURNS_HPP
-
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/BlockBase.hpp>
-#include <mrdocs/Metadata/Javadoc/Block/Paragraph.hpp>
-#include <string>
-
-namespace mrdocs::doc {
-
-/** Documentation for a function return type
-*/
-struct Returns final : Paragraph
-{
-    static constexpr NodeKind static_kind = NodeKind::returns;
-
-    Returns()
-        : Paragraph(NodeKind::returns)
-    {
-    }
-
-    explicit
-    Returns(std::string_view const text)
-        : Returns()
-    {
-        operator=(text);
-    }
-
-    explicit
-    Returns(Paragraph const& other)
-        : Returns()
-    {
-        children = other.children;
-    }
-
-    Returns&
-    operator=(std::string_view const text) override
-    {
-        Paragraph::operator=(text);
-        return *this;
-    }
-
-    auto operator<=>(Returns const&) const = default;
-
-    bool operator==(Returns const&)
-        const noexcept = default;
-
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Returns const&>(other);
-    }
-};
-
-/** Map the @ref Returns to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Returns const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Paragraph const&>(I), domCorpus);
-}
-
-/** Return the @ref Returns as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Returns const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-} // mrdocs::doc
-
-#endif // MRDOCS_API_METADATA_JAVADOC_BLOCK_RETURNS_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Inline/InlineBase.hpp b/include/mrdocs/Metadata/Javadoc/Inline/InlineBase.hpp
deleted file mode 100644
index 6db9fc85b..000000000
--- a/include/mrdocs/Metadata/Javadoc/Inline/InlineBase.hpp
+++ /dev/null
@@ -1,89 +0,0 @@
-//
-// This is a derivative work. originally part of the LLVM Project.
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#ifndef MRDOCS_API_METADATA_JAVADOC_INLINE_INLINEBASE_HPP
-#define MRDOCS_API_METADATA_JAVADOC_INLINE_INLINEBASE_HPP
-
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Node/NodeBase.hpp>
-#include <string>
-
-namespace mrdocs::doc {
-
-/** A Node containing a string of text.
-
-    There will be no newlines in the text. Otherwise,
-    this would be represented as multiple text nodes
-    within a Paragraph node.
-*/
-struct Inline : Node
-{
-    constexpr ~Inline() override = default;
-
-    bool
-    isBlock() const noexcept final
-    {
-        return false;
-    }
-
-    auto operator<=>(Inline const&) const = default;
-    bool operator==(Inline const&) const noexcept = default;
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Inline const&>(other);
-    }
-
-protected:
-    constexpr Inline() noexcept = default;
-
-    Inline(
-        NodeKind kind_)
-        : Node(kind_)
-    {
-    }
-};
-
-/** Map the @ref Inline to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Inline const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Node const&>(I), domCorpus);
-}
-
-/** Return the @ref Inline as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Inline const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-} // mrdocs::doc
-
-#endif // MRDOCS_API_METADATA_JAVADOC_INLINE_INLINEBASE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Inline/Style.hpp b/include/mrdocs/Metadata/Javadoc/Inline/Style.hpp
deleted file mode 100644
index 76f63974c..000000000
--- a/include/mrdocs/Metadata/Javadoc/Inline/Style.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//
-// This is a derivative work. originally part of the LLVM Project.
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#ifndef MRDOCS_API_METADATA_JAVADOC_INLINE_STYLE_HPP
-#define MRDOCS_API_METADATA_JAVADOC_INLINE_STYLE_HPP
-
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/Dom.hpp>
-
-namespace mrdocs::doc {
-
-/** The text style.
-*/
-enum class Style
-{
-    /// No style
-    none = 1, // needed by bitstream
-    /// Monospaced text
-    mono,
-    /// Bold text
-    bold,
-    /// Italic text
-    italic
-};
-
-/** Return the name of the @ref Style as a string.
-
-    @param kind The style kind.
-    @return The string representation of the style.
- */
-MRDOCS_DECL
-dom::String
-toString(Style kind) noexcept;
-
-/** Return the @ref Style from a @ref dom::Value string.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Style const kind)
-{
-    v = toString(kind);
-}
-
-} // mrdocs::doc
-
-#endif // MRDOCS_API_METADATA_JAVADOC_INLINE_STYLE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Inline/Styled.hpp b/include/mrdocs/Metadata/Javadoc/Inline/Styled.hpp
deleted file mode 100644
index 838e94de6..000000000
--- a/include/mrdocs/Metadata/Javadoc/Inline/Styled.hpp
+++ /dev/null
@@ -1,82 +0,0 @@
-//
-// This is a derivative work. originally part of the LLVM Project.
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#ifndef MRDOCS_API_METADATA_JAVADOC_INLINE_STYLED_HPP
-#define MRDOCS_API_METADATA_JAVADOC_INLINE_STYLED_HPP
-
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Inline/Style.hpp>
-#include <mrdocs/Metadata/Javadoc/Inline/Text.hpp>
-#include <string>
-
-namespace mrdocs::doc {
-
-/** A piece of styled text.
-*/
-struct Styled final : Text
-{
-    Style style;
-
-    static constexpr auto static_kind = NodeKind::styled;
-
-    Styled(
-        std::string string_ = std::string(),
-        Style style_ = Style::none) noexcept
-        : Text(std::move(string_), NodeKind::styled)
-        , style(style_)
-    {
-    }
-
-    auto operator<=>(Styled const&) const = default;
-    bool operator==(Styled const&) const noexcept = default;
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Styled const&>(other);
-    }
-};
-
-/** Map the @ref Styled to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Styled const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Text const&>(I), domCorpus);
-    io.map("style", I.style);
-}
-
-/** Return the @ref Styled as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Styled const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-} // mrdocs::doc
-
-#endif // MRDOCS_API_METADATA_JAVADOC_INLINE_STYLED_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Inline/Text.hpp b/include/mrdocs/Metadata/Javadoc/Inline/Text.hpp
deleted file mode 100644
index 81db58708..000000000
--- a/include/mrdocs/Metadata/Javadoc/Inline/Text.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-//
-// This is a derivative work. originally part of the LLVM Project.
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#ifndef MRDOCS_API_METADATA_JAVADOC_INLINE_TEXT_HPP
-#define MRDOCS_API_METADATA_JAVADOC_INLINE_TEXT_HPP
-
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Inline/InlineBase.hpp>
-#include <string>
-
-namespace mrdocs::doc {
-
-/** A Node containing a string of text.
-
-    There will be no newlines in the text. Otherwise,
-    this would be represented as multiple text nodes
-    within a Paragraph node.
-*/
-struct Text : Inline
-{
-    std::string string;
-
-    static constexpr auto static_kind = NodeKind::text;
-
-    constexpr ~Text() override = default;
-
-    constexpr Text() noexcept = default;
-
-    explicit Text(std::string string_ = std::string()) noexcept
-        : Inline(NodeKind::text)
-        , string(std::move(string_))
-    {}
-
-
-    auto operator<=>(Text const&) const = default;
-    bool operator==(Text const&) const noexcept = default;
-    bool equals(Node const& other) const noexcept override
-    {
-        return Kind == other.Kind &&
-            *this == dynamic_cast<Text const&>(other);
-    }
-
-protected:
-    Text(
-        std::string string_,
-        NodeKind kind_)
-        : Inline(kind_)
-        , string(std::move(string_))
-    {
-    }
-};
-
-/** Map the @ref Text to a @ref dom::Object.
-
-    @param t The tag.
-    @param io The output object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag t,
-    IO& io,
-    Text const& I,
-    DomCorpus const* domCorpus)
-{
-    tag_invoke(t, io, dynamic_cast<Node const&>(I), domCorpus);
-    io.map("string", I.string);
-}
-
-/** Return the @ref Text as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Text const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-} // mrdocs::doc
-
-#endif // MRDOCS_API_METADATA_JAVADOC_INLINE_TEXT_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Node.hpp b/include/mrdocs/Metadata/Javadoc/Node.hpp
deleted file mode 100644
index e75b2e885..000000000
--- a/include/mrdocs/Metadata/Javadoc/Node.hpp
+++ /dev/null
@@ -1,160 +0,0 @@
-//
-// This is a derivative work. originally part of the LLVM Project.
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#ifndef MRDOCS_API_METADATA_JAVADOC_NODE_HPP
-#define MRDOCS_API_METADATA_JAVADOC_NODE_HPP
-
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc/Block.hpp>
-#include <mrdocs/Metadata/Javadoc/Inline.hpp>
-#include <mrdocs/Metadata/Javadoc/Node/NodeBase.hpp>
-#include <mrdocs/Support/Concepts.hpp>
-#include <mrdocs/Support/Visitor.hpp>
-
-/** Javadoc related types and functions.
-
-    Javadoc is a documentation generator originally
-    created for the Java language from source code.
-
-    The Javadoc documentation generator tool can interpret
-    text in the "doc comments" format included
-    directly in the source code.
-
-    The same "doc comments" format has been replicated
-    and extended by documentation systems for other
-    languages, including the cross-language Doxygen
-    and the JSDoc system for JavaScript.
-
-    Because Clang can already parse and extract
-    blocks of Javadoc-style comments from source
-    code, these classes are used to represent the
-    parsed documentation in a structured form.
-
-    @see https://en.wikipedia.org/wiki/Javadoc
-    @see https://www.doxygen.nl
-
- */
-namespace mrdocs::doc {
-
-/** Visit a node.
-
-    @param node The node to visit.
-    @param fn The function to call for each node.
-    @param args Additional arguments to pass to the function.
-    @return The result of calling the function.
- */
-template<
-    class NodeTy,
-    class Fn,
-    class... Args>
-requires
-    std::same_as<std::remove_cvref_t<NodeTy>, Node>
-decltype(auto)
-visit(
-    NodeTy& node,
-    Fn&& fn,
-    Args&&... args)
-{
-    auto visitor = makeVisitor<Node>(
-        node, std::forward<Fn>(fn),
-        std::forward<Args>(args)...);
-    switch(node.Kind)
-    {
-    case NodeKind::admonition:
-        return visitor.template visit<Admonition>();
-    case NodeKind::brief:
-        return visitor.template visit<Brief>();
-    case NodeKind::code:
-        return visitor.template visit<Code>();
-    case NodeKind::heading:
-        return visitor.template visit<Heading>();
-    case NodeKind::paragraph:
-        return visitor.template visit<Paragraph>();
-    case NodeKind::link:
-        return visitor.template visit<Link>();
-    case NodeKind::reference:
-        return visitor.template visit<Reference>();
-    case NodeKind::copy_details:
-        return visitor.template visit<CopyDetails>();
-    case NodeKind::list_item:
-        return visitor.template visit<ListItem>();
-    case NodeKind::unordered_list:
-        return visitor.template visit<UnorderedList>();
-    case NodeKind::param:
-        return visitor.template visit<Param>();
-    case NodeKind::returns:
-        return visitor.template visit<Returns>();
-    case NodeKind::styled:
-        return visitor.template visit<Styled>();
-    case NodeKind::text:
-        return visitor.template visit<Text>();
-    case NodeKind::tparam:
-        return visitor.template visit<TParam>();
-    case NodeKind::throws:
-        return visitor.template visit<Throws>();
-    case NodeKind::see:
-        return visitor.template visit<See>();
-    case NodeKind::precondition:
-        return visitor.template visit<Precondition>();
-    case NodeKind::postcondition:
-        return visitor.template visit<Postcondition>();
-    default:
-        MRDOCS_UNREACHABLE();
-    }
-}
-
-/** Traverse a list of nodes.
-
-    @param list The list of nodes to traverse.
-    @param f The function to call for each node.
-    @param args Additional arguments to pass to the function.
- */
-template<class F, class T, class... Args>
-requires std::derived_from<T, Node>
-void traverse(
-    std::vector<std::unique_ptr<T>> const& list,
-    F&& f, Args&&... args)
-{
-    for(auto const& node : list)
-        visit(*node,
-            std::forward<F>(f),
-            std::forward<Args>(args)...);
-}
-
-/** Map the Polymorphic Node as a @ref dom::Value object.
-
-    @param io The output parameter to receive the dom::Object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::ValueFromTag,
-    IO& io,
-    Polymorphic<Node> const& I,
-    DomCorpus const* domCorpus)
-{
-    visit(*I, [&](auto const& U)
-    {
-        tag_invoke(
-            dom::ValueFromTag{},
-            io,
-            U,
-            domCorpus);
-    });
-}
-
-
-} // mrdocs::doc
-
-#endif
diff --git a/include/mrdocs/Metadata/Javadoc/Node/NodeBase.hpp b/include/mrdocs/Metadata/Javadoc/Node/NodeBase.hpp
deleted file mode 100644
index e64dc2828..000000000
--- a/include/mrdocs/Metadata/Javadoc/Node/NodeBase.hpp
+++ /dev/null
@@ -1,95 +0,0 @@
-//
-// This is a derivative work. originally part of the LLVM Project.
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#ifndef MRDOCS_API_METADATA_JAVADOC_NODE_NODEBASE_HPP
-#define MRDOCS_API_METADATA_JAVADOC_NODE_NODEBASE_HPP
-
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/Dom/LazyObject.hpp>
-#include <mrdocs/Metadata/DomCorpus.hpp>
-#include <mrdocs/Metadata/Javadoc/Node/NodeKind.hpp>
-
-namespace mrdocs::doc {
-
-//--------------------------------------------
-
-/** This is a variant-like list element.
-
-    There are two types of nodes: text and block.
-
-    - The javadoc is a list of blocks.
-    - A block contains a list of text elements.
-    - A text element contains a string.
-*/
-struct MRDOCS_DECL
-    Node
-{
-    NodeKind Kind;
-
-    virtual ~Node() = default;
-
-    virtual bool isBlock() const noexcept = 0;
-
-    bool isText() const noexcept
-    {
-        return ! isBlock();
-    }
-
-    auto operator<=>(Node const&) const = default;
-    bool operator==(Node const&)const noexcept = default;
-    virtual bool equals(Node const& other) const noexcept
-    {
-        return Kind == other.Kind;
-    }
-protected:
-    constexpr Node() noexcept = default;
-
-    explicit Node(NodeKind const kind_) noexcept
-        : Kind(kind_)
-    {
-    }
-};
-
-/** Map the @ref Node to a @ref dom::Object.
-
-    @param io The output parameter to receive the dom::Object.
-    @param I The input object.
-    @param domCorpus The DOM corpus, or nullptr if not part of a corpus.
- */
-template <class IO>
-void
-tag_invoke(
-    dom::LazyObjectMapTag,
-    IO& io,
-    Node const& I,
-    DomCorpus const* domCorpus)
-{
-    MRDOCS_ASSERT(domCorpus);
-    io.map("kind", I.Kind);
-}
-
-/** Return the @ref Node as a @ref dom::Value object.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    Node const& I,
-    DomCorpus const* domCorpus)
-{
-    v = dom::LazyObject(I, domCorpus);
-}
-
-} // mrdocs::doc
-
-#endif // MRDOCS_API_METADATA_JAVADOC_NODE_NODEBASE_HPP
diff --git a/include/mrdocs/Metadata/Javadoc/Node/NodeKind.hpp b/include/mrdocs/Metadata/Javadoc/Node/NodeKind.hpp
deleted file mode 100644
index bfd1a51d2..000000000
--- a/include/mrdocs/Metadata/Javadoc/Node/NodeKind.hpp
+++ /dev/null
@@ -1,132 +0,0 @@
-//
-// This is a derivative work. originally part of the LLVM Project.
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#ifndef MRDOCS_API_METADATA_JAVADOC_NODE_NODEKIND_HPP
-#define MRDOCS_API_METADATA_JAVADOC_NODE_NODEKIND_HPP
-
-#include <mrdocs/Platform.hpp>
-#include <mrdocs/Dom.hpp>
-
-namespace mrdocs::doc {
-
-/** The kind of node.
-
-    This includes tags and block types.
-
-    Some of the available tags are:
-
-    @li `@author Author Name`
-    @li `{@docRoot}`
-    @li `@version version`
-    @li `@since since-text `
-    @li `@see reference`
-    @li `@param name description`
-    @li `@return description`
-    @li `@exception classname description`
-    @li `@throws classname description`
-    @li `@deprecated description`
-    @li `{@inheritDoc}`
-    @li `{@link reference}`
-    @li `{@linkplain reference}`
-    @li `{@value #STATIC_FIELD}`
-    @li `{@code literal}`
-    @li `{@literal literal}`
-    @li `{@serial literal}`
-    @li `{@serialData literal}`
-    @li `{@serialField literal}`
-
-    Doxygen also introduces a number of additional tags on top
-    of the the doc comment specification.
-
-    @note When a new tag is added, the `visit` function overloads
-    must be updated to handle the new tag.
-
-    @see https://en.wikipedia.org/wiki/Javadoc[Javadoc - Wikipedia]
-    @see https://docs.oracle.com/javase/1.5.0/docs/tooldocs/solaris/javadoc.html[Javadoc Documentation]
-    @see https://docs.oracle.com/en/java/javase/13/docs/specs/javadoc/doc-comment-spec.html[Doc Comment Specification]
-    @see https://www.oracle.com/java/technologies/javase/javadoc-tool.html[Javadoc Tool]
-    @see https://www.oracle.com/technical-resources/articles/java/javadoc-tool.html[How to Write Doc Comments]
-    @see https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html[Javadoc Package]
-    @see https://web.archive.org/web/20170714215721/http://agile.csc.ncsu.edu:80/SEMaterials/tutorials/javadoc[Javadoc Tutorial]
-    @see https://en.wikipedia.org/wiki/Doxygen[Doxygen - Wikipedia]
-    @see https://www.doxygen.nl/manual/commands.html[Doxygen Special Tags]
-
- */
-enum class NodeKind
-{
-    // VFALCO Don't forget to update
-    // Node::isText() and Node::isBlock()
-    // when changing this enum!
-
-    /// A text tag
-    text = 1, // needed by bitstream
-    /// An admonition tag
-    admonition,
-    /// A brief tag
-    brief,
-    /// A code tag
-    code,
-    /// A heading tag
-    heading,
-    /// A link tag
-    link,
-    /// A list_item tag
-    list_item,
-    /// An unordered_list tag
-    unordered_list,
-    /// A paragraph tag
-    paragraph,
-    /// A param tag
-    param,
-    /// A returns tag
-    returns,
-    /// A styled tag
-    styled,
-    /// A tparam tag
-    tparam,
-    /// A reference tag
-    reference,
-    /// A copy_details tag
-    copy_details,
-    /// A throws tag
-    throws,
-    /// A details tag
-    details,
-    /// A see tag
-    see,
-    /// A general tag.
-    precondition,
-    /// A postcondition tag.
-    postcondition
-};
-
-/** Return the name of the NodeKind as a string.
- */
-MRDOCS_DECL
-dom::String
-toString(NodeKind kind) noexcept;
-
-/** Return the NodeKind from a @ref dom::Value string.
- */
-inline
-void
-tag_invoke(
-    dom::ValueFromTag,
-    dom::Value& v,
-    NodeKind const kind)
-{
-    v = toString(kind);
-}
-
-} // mrdocs::doc
-
-#endif // MRDOCS_API_METADATA_JAVADOC_NODE_NODEKIND_HPP
diff --git a/include/mrdocs/Metadata/Name.hpp b/include/mrdocs/Metadata/Name.hpp
index f7f143923..c97340fe8 100644
--- a/include/mrdocs/Metadata/Name.hpp
+++ b/include/mrdocs/Metadata/Name.hpp
@@ -34,10 +34,9 @@ visit(
         info, std::forward<Fn>(fn), std::forward<Args>(args)...);
     switch(info.Kind)
     {
-    case NameKind::Identifier:
-        return visitor.template visit<IdentifierName>();
-    case NameKind::Specialization:
-        return visitor.template visit<SpecializationName>();
+    #define INFO(Type) case NameKind::Type: \
+        return visitor.template visit<Type##Name>();
+#include <mrdocs/Metadata/Name/NameNodes.inc>
     default:
         MRDOCS_UNREACHABLE();
     }
diff --git a/include/mrdocs/Metadata/Symbol.hpp b/include/mrdocs/Metadata/Symbol.hpp
index b0b68cf61..d9e9608ed 100644
--- a/include/mrdocs/Metadata/Symbol.hpp
+++ b/include/mrdocs/Metadata/Symbol.hpp
@@ -116,24 +116,24 @@ tag_invoke(
     @param I The polymorphic Symbol to convert.
     @param domCorpus The DomCorpus used to resolve references.
  */
-template <class IO, polymorphic_storage_for<Symbol> SymbolTy>
-requires std::derived_from<SymbolTy, Symbol>
-void
-tag_invoke(
-    dom::ValueFromTag,
-    IO& io,
-    SymbolTy const& I,
-    DomCorpus const* domCorpus)
-{
-    visit(*I, [&](auto const& U)
-    {
-        tag_invoke(
-            dom::ValueFromTag{},
-            io,
-            U,
-            domCorpus);
-    });
-}
+//template <class IO, polymorphic_storage_for<Symbol> SymbolTy>
+//requires std::derived_from<SymbolTy, Symbol>
+//void
+//tag_invoke(
+//    dom::ValueFromTag,
+//    IO& io,
+//    SymbolTy const& I,
+//    DomCorpus const* domCorpus)
+//{
+//    visit(*I, [&](auto const& U)
+//    {
+//        tag_invoke(
+//            dom::ValueFromTag{},
+//            io,
+//            U,
+//            domCorpus);
+//    });
+//}
 
 } // mrdocs
 
diff --git a/include/mrdocs/Metadata/Symbol/Namespace.hpp b/include/mrdocs/Metadata/Symbol/Namespace.hpp
index 43a2c14ed..06a5e5683 100644
--- a/include/mrdocs/Metadata/Symbol/Namespace.hpp
+++ b/include/mrdocs/Metadata/Symbol/Namespace.hpp
@@ -121,7 +121,8 @@ struct NamespaceSymbol final
     */
     NamespaceTranche Members;
 
-    explicit NamespaceSymbol(SymbolID const &ID) noexcept
+    explicit
+    NamespaceSymbol(SymbolID const &ID) noexcept
         : SymbolCommonBase(ID)
     {
     }
diff --git a/include/mrdocs/Metadata/Symbol/SymbolBase.hpp b/include/mrdocs/Metadata/Symbol/SymbolBase.hpp
index 906847c19..9769f645f 100644
--- a/include/mrdocs/Metadata/Symbol/SymbolBase.hpp
+++ b/include/mrdocs/Metadata/Symbol/SymbolBase.hpp
@@ -13,7 +13,7 @@
 #define MRDOCS_API_METADATA_SYMBOL_SYMBOLBASE_HPP
 
 #include <mrdocs/Platform.hpp>
-#include <mrdocs/Metadata/Javadoc.hpp>
+#include <mrdocs/Metadata/DocComment.hpp>
 #include <mrdocs/Metadata/Specifiers/AccessKind.hpp>
 #include <mrdocs/Metadata/Symbol/ExtractionMode.hpp>
 #include <mrdocs/Metadata/Symbol/Source.hpp>
@@ -78,9 +78,9 @@ struct MRDOCS_VISIBLE Symbol {
      */
     SymbolID Parent;
 
-    /** The extracted javadoc for this declaration.
+    /** The extracted documentation for this declaration.
      */
-    Optional<Javadoc> javadoc;
+    Optional<DocComment> doc;
 
     //--------------------------------------------
 
@@ -244,9 +244,9 @@ tag_invoke(
     {
         io.map("parent", I.Parent);
     }
-    if (I.javadoc)
+    if (I.doc)
     {
-        io.map("doc", *I.javadoc);
+        io.map("doc", *I.doc);
     }
     io.map("loc", I.Loc);
 }
diff --git a/include/mrdocs/Support/ScopeExit.hpp b/include/mrdocs/Support/ScopeExit.hpp
index d0fa74f6f..3574414e4 100644
--- a/include/mrdocs/Support/ScopeExit.hpp
+++ b/include/mrdocs/Support/ScopeExit.hpp
@@ -44,11 +44,23 @@ class ScopeExitRestore {
     T& ref_;
     bool dismissed_{false};
 public:
+    /** Restore `ref` to its previous value when the scope ends
+
+        Store the current value of `ref` and restore it
+        when this object goes out of scope, unless `dismiss()`
+        is called.
+     */
     explicit
     ScopeExitRestore(T& ref)
         : prev_(ref), ref_(ref)
     {}
 
+    /** Temporarily set `ref` to `next` and restore it when the scope ends
+
+        Store the current value of `ref`, set it to `next`,
+        and restore the previous value when this object goes
+        out of scope, unless `dismiss()` is called.
+     */
     template <std::convertible_to<T> T2>
     explicit
     ScopeExitRestore(T& ref, T2 next)
diff --git a/include/mrdocs/Support/SplitLines.hpp b/include/mrdocs/Support/SplitLines.hpp
new file mode 100644
index 000000000..2c6339923
--- /dev/null
+++ b/include/mrdocs/Support/SplitLines.hpp
@@ -0,0 +1,208 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_API_SUPPORT_SPLITLINES_HPP
+#define MRDOCS_API_SUPPORT_SPLITLINES_HPP
+
+#include <mrdocs/Platform.hpp>
+#include <cstddef>
+#include <ranges>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+namespace mrdocs {
+
+namespace detail {
+// Return length (in bytes) of the line-break sequence starting at i, or 0 if
+// none
+constexpr std::size_t
+lbLen(std::string_view s, std::size_t i) noexcept
+{
+    auto b = [&](std::size_t k) -> unsigned char {
+        return static_cast<unsigned char>(s[k]);
+    };
+    if (i >= s.size())
+    {
+        return 0;
+    }
+
+    // CRLF
+    if (s[i] == '\r')
+    {
+        if (i + 1 < s.size() && s[i + 1] == '\n')
+        {
+            return 2;
+        }
+        return 1; // lone CR
+    }
+    // LF, VT, FF
+    if (s[i] == '\n' || s[i] == '\v' || s[i] == '\f')
+    {
+        return 1;
+    }
+
+    // NEL: U+0085 — single byte (0x85) or UTF-8 C2 85
+    if (b(i) == 0x85)
+    {
+        return 1;
+    }
+    if (i + 1 < s.size() && b(i) == 0xC2 && b(i + 1) == 0x85)
+    {
+        return 2;
+    }
+
+    // LS (U+2028) and PS (U+2029): UTF-8 E2 80 A8 / E2 80 A9
+    if (i + 2 < s.size() && b(i) == 0xE2 && b(i + 1) == 0x80
+        && (b(i + 2) == 0xA8 || b(i + 2) == 0xA9))
+    {
+        return 3;
+    }
+
+    return 0;
+}
+}
+
+// A lazy input range of std::string_view lines split on all known line breaks.
+struct SplitLinesView : std::ranges::view_interface<SplitLinesView> {
+    std::string_view sv_;
+
+    constexpr SplitLinesView() = default;
+    explicit constexpr SplitLinesView(std::string_view sv) : sv_(sv) {}
+
+    struct Iterator {
+        std::string_view sv{};
+        std::size_t cur = 0;       // start of current line
+        std::size_t nextBreak = 0; // index of current break (or npos)
+        bool atEnd = false;
+
+        constexpr Iterator() = default;
+        explicit constexpr Iterator(std::string_view s, bool begin) : sv(s)
+        {
+            if (!begin)
+            {
+                atEnd = true;
+                return;
+            }
+            nextBreak = findBreak(cur);
+        }
+
+        constexpr std::size_t
+        findBreak(std::size_t from) const noexcept
+        {
+            for (std::size_t i = from; i < sv.size(); ++i)
+            {
+                if (detail::lbLen(sv, i))
+                {
+                    return i;
+                }
+            }
+            return std::string_view::npos;
+        }
+
+        using value_type = std::string_view;
+        using difference_type = std::ptrdiff_t;
+
+        constexpr value_type
+        operator*() const noexcept
+        {
+            auto end = (nextBreak == std::string_view::npos) ?
+                           sv.size() :
+                           nextBreak;
+            return sv.substr(cur, end - cur);
+        }
+
+        constexpr Iterator&
+        operator++() noexcept
+        {
+            if (nextBreak == std::string_view::npos)
+            {
+                atEnd = true;
+                return *this;
+            }
+            std::size_t const jump = detail::lbLen(sv, nextBreak);
+            cur = nextBreak + jump;
+            nextBreak = findBreak(cur);
+            if (cur > sv.size())
+            {
+                atEnd = true;
+            }
+            return *this;
+        }
+
+        constexpr void
+        operator++(int)
+        {
+            ++*this;
+        }
+
+        friend constexpr bool
+        operator==(Iterator const& it, std::default_sentinel_t) noexcept
+        {
+            return it.atEnd;
+        }
+    };
+
+    constexpr Iterator
+    begin() const noexcept
+    {
+        return Iterator{ sv_, true };
+    }
+    constexpr std::default_sentinel_t
+    end() const noexcept
+    {
+        return {};
+    }
+};
+
+// Pipeable range adaptor object:
+//   - s | text::views::splitLines
+//   - text::views::splitLines(s)
+struct SplitLinesAdaptor {
+    // Call-style
+    constexpr auto
+    operator()(std::string_view sv) const
+    {
+        return SplitLinesView{ sv };
+    }
+
+    // Accept any contiguous range of (const) char and wrap it as string_view.
+    template <std::ranges::contiguous_range R>
+    requires
+        std::same_as<std::remove_cv_t<std::ranges::range_value_t<R>>, char>
+    constexpr auto
+    operator()(R&& r) const
+    {
+        return SplitLinesView{
+            std::string_view(std::ranges::data(r), std::ranges::size(r))
+        };
+    }
+
+    // Pipe-style
+    template <std::ranges::viewable_range R>
+    requires
+        std::ranges::contiguous_range<R> &&
+        std::same_as<std::remove_cv_t<std::ranges::range_value_t<R>>, char>
+    friend constexpr auto
+    operator|(R&& r, SplitLinesAdaptor const& a)
+    {
+        return a(std::forward<R>(r));
+    }
+};
+
+/** Split a string view into lines, recognizing all common line breaks
+
+    This is a convenience function for creating a SplitLinesView.
+ */
+inline constexpr SplitLinesAdaptor splitLines{};
+
+} // mrdocs
+
+#endif
diff --git a/include/mrdocs/Support/String.hpp b/include/mrdocs/Support/String.hpp
index c679844c9..826257798 100644
--- a/include/mrdocs/Support/String.hpp
+++ b/include/mrdocs/Support/String.hpp
@@ -131,6 +131,14 @@ isWhitespace(std::string_view s) noexcept
     return s.find_first_not_of(" \t\n\v\f\r") == std::string::npos;
 }
 
+constexpr
+bool
+isWhitespace(char c) noexcept
+{
+    return c == ' ' || c == '\t' || c == '\n' ||
+           c == '\v' || c == '\f' || c == '\r';
+}
+
 /** Determine if a string starts with one of the specified characters
 
     @param s The string to check.
@@ -201,7 +209,7 @@ constexpr
 char
 toLowerCase(char const c) noexcept
 {
-    return isUpperCase(c) ? c + ('a' - 'A') : c;
+    return isUpperCase(c) ? static_cast<char>(c - 'A' + 'a') : c;
 }
 
 constexpr
@@ -221,7 +229,7 @@ constexpr
 char
 toUpperCase(char const c) noexcept
 {
-    return isLowerCase(c) ? c - ('a' - 'A') : c;
+    return isLowerCase(c) ? static_cast<char>(c - 'a' + 'A') : c;
 }
 
 constexpr
@@ -431,6 +439,14 @@ toPascalCase(std::string_view const input)
     return result;
 }
 
+/** Reindent code by removing the common leading spaces and adding the specified indent.
+
+    @param code The code block to unindent.
+    @return The modified code block.
+*/
+MRDOCS_DECL
+std::string
+reindentCode(std::string_view code, std::size_t indent = 0);
 
 } // mrdocs
 
diff --git a/include/mrdocs/mrdocs.natvis b/include/mrdocs/mrdocs.natvis
index 2a9e9510f..9a17e3f8c 100644
--- a/include/mrdocs/mrdocs.natvis
+++ b/include/mrdocs/mrdocs.natvis
@@ -151,7 +151,7 @@
         </Expand>
     </Type>
 
-<!-- Javadocs -->
+<!-- DocComment -->
     <Type Name="std::vector&lt;std::unique_ptr&lt;mrdocs::doc::Block,std::default_delete&lt;mrdocs::doc::Block&gt;&gt;,std::allocator&lt;std::unique_ptr&lt;mrdocs::doc::Block,std::default_delete&lt;mrdocs::doc::Block&gt;&gt;&gt;&gt;">
         <DisplayString>doc::Block[{_Mypair._Myval2._Myend-_Mypair._Myval2._Myfirst}]</DisplayString>
         <Expand>
diff --git a/mrdocs.rnc b/mrdocs.rnc
index 07042fa9e..03f131ff9 100644
--- a/mrdocs.rnc
+++ b/mrdocs.rnc
@@ -35,7 +35,7 @@ grammar
             ID?,
             attribute is-inline { "1" }?,
             attribute is-anonymous { "1" }?,
-            Javadoc?,
+            DocComment?,
             element using-directive { ID } *,
             Scope*
         }
@@ -56,7 +56,7 @@ grammar
         (
             BaseInfo |
             Attr |
-            Javadoc? |
+            DocComment? |
             RecordScope
         ) *
     )
@@ -92,7 +92,7 @@ grammar
                     ID ?,
                     TypeInfo
                 } * |
-                Javadoc ?
+                DocComment ?
             ) *
         }
 
@@ -115,7 +115,7 @@ grammar
                     ID ?,
                     TypeInfo
                 } * |
-                Javadoc ?
+                DocComment ?
             ) *
         }
 
@@ -129,7 +129,7 @@ grammar
             ID,
             BaseInfo ?,
             Location *,
-            Javadoc ?,
+            DocComment ?,
             EnumScope
         }
 
@@ -142,7 +142,7 @@ grammar
             ID,
             attribute initializer { text } ?,
             Location *,
-            Javadoc ?
+            DocComment ?
         }
 
     #---------------------------------------------
@@ -154,7 +154,7 @@ grammar
             ID,
             Location *,
             TypeInfo,
-            Javadoc ?
+            DocComment ?
         } |
         element typedef
         {
@@ -178,7 +178,7 @@ grammar
             (
                 Attr * &
                 TypeInfo &
-                Javadoc ?
+                DocComment ?
             )
         }
 
@@ -206,7 +206,7 @@ grammar
             Access ?,
             ID,
             Location *,
-            Javadoc ?,
+            DocComment ?,
             element aliased
             {
                 attribute name { text },
@@ -222,7 +222,7 @@ grammar
             Access ?,
             ID,
             Location *,
-            Javadoc ?,
+            DocComment ?,
             attribute class { "using" | "using typename" | "using enum" },
             attribute qualifier { text } ?,
             element named { ID } *
@@ -237,7 +237,7 @@ grammar
             Access ?,
             ID,
             Location *,
-            Javadoc ?,
+            DocComment ?,
             attribute constraint { text }
         }
 
@@ -365,7 +365,7 @@ grammar
     #
     #---------------------------------------------
 
-    Javadoc = element doc { BlockNode * }
+    DocComment = element doc { BlockNode * }
 
     BlockNode = (
         Admonition | Brief | Code | Heading | ListItem |
diff --git a/share/lldb/clang_ast_formatters.py b/share/lldb/clang_ast_formatters.py
index e732dd924..ce9a455ab 100644
--- a/share/lldb/clang_ast_formatters.py
+++ b/share/lldb/clang_ast_formatters.py
@@ -9,7 +9,9 @@
 import re
 
 
-# ---------- tiny helpers ----------
+# ================================================================
+# Small utilities
+# ================================================================
 def _ctx(v):
     try:
         return v.Dereference() if v.TypeIsPointerType() else v
@@ -26,25 +28,20 @@ def _eval_str(scope, code):
         return s.strip('"') if s else None
     return None
 
-def _strip_ptr_ref(t):  # SBType -> SBType (no pointers/refs)
+def _strip_ptr_ref(t):
+    # SBType -> SBType (no pointers/refs)
     try:
-        # Drop references if possible
+        # Drop references first
         dt = t.GetDereferencedType()
-        if dt and dt.IsValid():  # only valid for refs
+        if dt and dt.IsValid():
             t = dt
-        # Drop pointers
+        # Drop pointers next
         while t.IsPointerType():
             t = t.GetPointeeType()
     except Exception:
         pass
     return t
 
-def _kind_from_type(valobj):
-    t = _strip_ptr_ref(valobj.GetType())
-    name = t.GetName() or ""
-    m = re.search(r'clang::([A-Za-z_0-9]+)Decl', name)
-    return m.group(1) if m else "Decl"
-
 def _humanize_kind(kind: str) -> str:
     # Insert spaces at transitions: a|A, A|A a, digit|A; then lowercase.
     if not kind:
@@ -82,7 +79,9 @@ def _is_derived_from(sbtype: lldb.SBType, qualified_basename: str) -> bool:
     return False
 
 
-# ---------- recognizers ----------
+# ================================================================
+# Decl recognizers & summaries
+# ================================================================
 def is_clang_nameddecl(sbtype, _dict):
     t = _strip_ptr_ref(sbtype)
     n = t.GetName() or ""
@@ -98,8 +97,16 @@ def is_clang_decl_not_named(sbtype, _dict):
     # Must be a Decl, but NOT a NamedDecl
     return _is_derived_from(t, "clang::Decl") and not _is_derived_from(t, "clang::NamedDecl")
 
+def _kind_from_type(valobj):
+    t = _strip_ptr_ref(valobj.GetType())
+    name = t.GetName() or ""
+    m = re.search(r'clang::([A-Za-z_0-9]+)Decl', name)
+    return m.group(1) if m else "Decl"
+
+# ================================================================
+# Decl Summaries
+# ================================================================
 
-# ---------- summaries ----------
 # NamedDecl (qualified name + humanized kind)
 def NamedDecl_summary(valobj, _dict):
     o = _ctx(valobj)
@@ -125,7 +132,6 @@ def NamedDecl_summary(valobj, _dict):
 
     return f"{q} ({hkind})" if q else f"<unnamed> ({hkind})"
 
-
 # Non-NamedDecl (unnamed) → "<unnamed> (humanized kind)"
 def UnnamedDecl_summary(valobj, _dict):
     o = _ctx(valobj)
@@ -133,18 +139,120 @@ def UnnamedDecl_summary(valobj, _dict):
     hkind = _humanize_kind(kind)
     return f"<unnamed> ({hkind})"
 
+# ================================================================
+# Comment recognizer & frame-aware summary (actual source text)
+# ================================================================
+def is_clang_comment(sbtype, _dict):
+    try:
+        n = _strip_ptr_ref(sbtype).GetName() or ""
+        return n.startswith("clang::comments::")
+    except Exception:
+        return False
 
+def _frame():
+    try:
+        tgt = lldb.debugger.GetSelectedTarget()
+        if not tgt: return None
+        proc = tgt.GetProcess()
+        if not proc: return None
+        thr = proc.GetSelectedThread()
+        if not thr: return None
+        return thr.GetSelectedFrame()
+    except Exception:
+        return None
+
+def _frame_eval_str(code: str):
+    f = _frame()
+    if not f:
+        return None
+    opts = lldb.SBExpressionOptions()
+    opts.SetLanguage(lldb.eLanguageTypeC_plus_plus)
+    opts.SetCoerceResultToId(False)
+    r = f.EvaluateExpression(code, opts)
+    if r and r.GetError() and r.GetError().Success():
+        s = r.GetSummary() or r.GetValue()
+        return s.strip('"') if s else None
+    return None
+
+def _comments_ptr_expr(valobj):
+    try:
+        addr = valobj.GetValueAsUnsigned(0)
+        if addr:
+            return f"(const ::clang::comments::Comment*)0x{addr:x}"
+    except Exception:
+        pass
+    return None
+
+def _astctx_candidates_from_frame():
+    # Order these to match your codebase first
+    return [
+        "(&this->ctx_)",   # common in visitors
+        "(&ctx_)",
+        "(&Ctx)",
+        "(&context)",
+        "(&Context)",
+        "(&ASTCtx)",
+    ]
+
+def _shorten_one_line(s: str, maxlen=160) -> str:
+    if not s:
+        return None
+    s = " ".join(s.replace("\r", "\n").split())
+    return (s[: maxlen - 3] + "...") if len(s) > maxlen else s
+
+def Comment_summary(valobj, _dict):
+    """
+    Show the exact source slice of the comment (single line), if we can obtain
+    an ASTContext from the current frame. Otherwise, fall back to a type label.
+    """
+    cptr = _comments_ptr_expr(valobj)
+    if cptr:
+        text_tmpl = (
+            "{ "
+            f"  auto C = {cptr};"
+            "  ::clang::SourceRange R = C->getSourceRange();"
+            "  const ::clang::ASTContext* ACTX = ASTCTX_EXPR;"
+            "  if (!ACTX) return std::string();"
+            "  const auto& SM = ACTX->getSourceManager();"
+            "  return std::string(::clang::Lexer::getSourceText("
+            "    ::clang::CharSourceRange::getTokenRange(R), SM, ACTX->getLangOpts()));"
+            "}"
+        )
+        for cand in _astctx_candidates_from_frame():
+            code = text_tmpl.replace("ASTCTX_EXPR", cand)
+            s = _frame_eval_str(code)
+            if s:
+                one = _shorten_one_line(s)
+                if one:
+                    return one  # just the text; no extra suffix
+
+    # Fallback: readable type label (keeps something useful when ACTX is unreachable)
+    tname = (_strip_ptr_ref(valobj.GetType()).GetName() or "").rsplit("::", 1)[-1]
+    base = _humanize_kind(tname.replace("Comment", "")) or "comment"
+    return f"{base} (comment)"
+
+
+# ================================================================
+# Registration
+# ================================================================
 def __lldb_init_module(debugger, _dict):
-    # One rule for ALL NamedDecl-derived types
+    # Decl summaries
     debugger.HandleCommand(
         'type summary add '
         '--python-function clang_ast_formatters.NamedDecl_summary '
         '--recognizer-function clang_ast_formatters.is_clang_nameddecl'
     )
-    # And a second rule for other Decl types (non-NamedDecl)
     debugger.HandleCommand(
         'type summary add '
         '--python-function clang_ast_formatters.UnnamedDecl_summary '
         '--recognizer-function clang_ast_formatters.is_clang_decl_not_named'
     )
-    print("[clang-ast] NamedDecl and Unnamed Decl summaries registered via recognizers.")
+
+    # Comments summary (no synthetic; members remain visible)
+    debugger.HandleCommand(
+        'type summary add '
+        '--python-function clang_ast_formatters.Comment_summary '
+        '--recognizer-function clang_ast_formatters.is_clang_comment'
+    )
+
+    print("[clang-ast] Decl summaries + comments source-text summaries registered.")
diff --git a/share/lldb/mrdocs_formatters.py b/share/lldb/mrdocs_formatters.py
index b33a976f4..ae68441af 100644
--- a/share/lldb/mrdocs_formatters.py
+++ b/share/lldb/mrdocs_formatters.py
@@ -5,18 +5,16 @@
 # https://www.boost.org/LICENSE_1_0.txt
 #
 
+from __future__ import annotations
 import lldb
+import re
 
-# ---------- SIMPLE, WORKING REGEXES ----------
-# Tip: register BOTH const and non-const; avoid fancy groups.
-_INFO_REGEXES = [
-    r"^mrdocs::[^:]*Info$",
-    r"^const mrdocs::[^:]*Info$",
-]
+# =============================================================================
+# Core utilities (shared by all providers)
+# =============================================================================
 
-
-# ---------- POINTER/REF SAFE ----------
 def _deref_if_ptr_or_ref(v: lldb.SBValue) -> lldb.SBValue:
+    """Return v dereferenced if it is a pointer/reference and deref succeeds; else v unchanged."""
     t = v.GetType()
     if not t or not t.IsValid():
         return v
@@ -26,37 +24,36 @@ def _deref_if_ptr_or_ref(v: lldb.SBValue) -> lldb.SBValue:
     return v
 
 
-# ---------- TYPE INTROSPECTION HELPERS ----------
 def _type_name(t: lldb.SBType) -> str:
+    """Best-effort type name ('' if unavailable)."""
     return (t.GetName() or "") if (t and t.IsValid()) else ""
 
 
 def _get_type_fields(t: lldb.SBType):
+    """Iterate SBTypeMember for non-virtual data members/bases (robust to exceptions)."""
     try:
         n = t.GetNumberOfFields()
     except Exception:
         n = 0
     for i in range(n):
-        yield t.GetFieldAtIndex(i)  # SBTypeMember
+        yield t.GetFieldAtIndex(i)
 
 
 def _get_direct_bases(t: lldb.SBType):
+    """Iterate SBTypeMember for direct base classes (robust to exceptions)."""
     try:
         n = t.GetNumberOfDirectBaseClasses()
     except Exception:
         n = 0
     for i in range(n):
-        yield t.GetDirectBaseClassAtIndex(i)  # SBTypeMember
+        yield t.GetDirectBaseClassAtIndex(i)
 
 
 def _base_value_from_typemember(parent_v: lldb.SBValue, base_tm: lldb.SBTypeMember) -> lldb.SBValue | None:
-    """
-    Robustly get the base subobject SBValue from the parent, using the base type and byte offset.
-    """
+    """Materialize a direct base subobject by offset. Returns None on failure."""
     bt = base_tm.GetType()
     if not bt or not bt.IsValid():
         return None
-    # Offset is in bits in some LLDBs; prefer GetOffsetInBytes() if available.
     try:
         off = base_tm.GetOffsetInBytes()
     except Exception:
@@ -66,11 +63,149 @@ def _base_value_from_typemember(parent_v: lldb.SBValue, base_tm: lldb.SBTypeMemb
     return child if child and child.IsValid() else None
 
 
-# ---------- STRING EXTRACTION (std::string only, per your note) ----------
-def _string_from_std_string(sbv: lldb.SBValue) -> str | None:
+def _get_field_value_by_offset(parent_v: lldb.SBValue, field_name: str) -> lldb.SBValue | None:
+    """Materialize a named field via type layout offsets (preferred), else try direct lookup."""
+    t = parent_v.GetType()
+    if t and t.IsValid():
+        try:
+            n = t.GetNumberOfFields()
+        except Exception:
+            n = 0
+        for i in range(n):
+            tm = t.GetFieldAtIndex(i)
+            try:
+                if tm.IsBaseClass():
+                    continue
+            except Exception:
+                pass
+            if (tm.GetName() or "") == field_name:
+                ftype = tm.GetType()
+                if not (ftype and ftype.IsValid()):
+                    break
+                try:
+                    off = tm.GetOffsetInBytes()
+                except Exception:
+                    off_bits = tm.GetOffsetInBits() if hasattr(tm, "GetOffsetInBits") else 0
+                    off = off_bits // 8
+                v = parent_v.CreateChildAtOffset(field_name, off, ftype)
+                return v if v and v.IsValid() else None
+    v = parent_v.GetChildMemberWithName(field_name)
+    return v if v and v.IsValid() else None
+
+
+def _clean(s: str | None) -> str | None:
+    """Strip/normalize a string value; filter out LLDB 'error:' summaries."""
+    if not s:
+        return None
+    s = s.strip()
+    if s.startswith("error:"):
+        return None
+    return s
+
+
+def _fmt_ptr_addr(p: lldb.SBValue) -> str:
+    """Return pointer as 0x<hex> with no leading zeros (LLDB style)."""
+    try:
+        v = p.GetValueAsUnsigned(0)
+        return f"0x{v:x}"
+    except Exception:
+        s = (p.GetValue() or "").strip()
+        if s.startswith(("0x", "0X")):
+            h = s[2:].lstrip("0")
+            return "0x" + (h if h else "0")
+        return s or "0x0"
+
+
+# =============================================================================
+# Child lookup helpers (work across synthetic/non-synthetic)
+# =============================================================================
+
+def _strip_prefixes_for_match(nm: str) -> str:
+    """Strip ordering prefixes ('NN '), optional decl prefixes ('T::'), and de-dupe suffixes (' #k')."""
+    if not nm:
+        return nm
+    nm = re.sub(r"^\d{2}\s+", "", nm)
+    if "::" in nm:
+        nm = nm.split("::", 1)[1]
+    nm = re.sub(r"\s+#\d+$", "", nm)
+    return nm
+
+
+def _child_by_name_any(v: lldb.SBValue, names: tuple[str, ...]) -> lldb.SBValue | None:
+    """Return first child whose name matches any in `names`, searching both synthetic and raw views."""
+    if not v or not v.IsValid():
+        return None
+    views = [v]
+    try:
+        ns = v.GetNonSyntheticValue()
+        if ns and ns.IsValid() and ns.GetID() != v.GetID():
+            views.append(ns)
+    except Exception:
+        pass
+    # direct lookup
+    for view in views:
+        for nm in names:
+            ch = view.GetChildMemberWithName(nm)
+            if ch and ch.IsValid():
+                return ch
+    # enumerated children (names may be prefixed by a synthetic)
+    for view in views:
+        n = view.GetNumChildren()
+        for i in range(n):
+            ch = view.GetChildAtIndex(i)
+            if not (ch and ch.IsValid()):
+                continue
+            nm = _strip_prefixes_for_match(ch.GetName() or "")
+            if nm in names:
+                return ch
+    return None
+
+
+def _find_field_recursive_any(v: lldb.SBValue, names: tuple[str, ...]) -> lldb.SBValue | None:
+    """Like _child_by_name_any, but recurses into direct bases using type offsets."""
+    if not v or not v.IsValid():
+        return None
+    got = _child_by_name_any(v, names)
+    if got and got.IsValid():
+        return got
+    t = v.GetType()
+    if t and t.IsValid():
+        # search own fields by offset
+        for tm in _get_type_fields(t):
+            try:
+                if tm.IsBaseClass():
+                    continue
+            except Exception:
+                pass
+            if (tm.GetName() or "") in names:
+                ft = tm.GetType()
+                if ft and ft.IsValid():
+                    try:
+                        off = tm.GetOffsetInBytes()
+                    except Exception:
+                        off_bits = tm.GetOffsetInBits() if hasattr(tm, "GetOffsetInBits") else 0
+                        off = off_bits // 8
+                    ch = v.CreateChildAtOffset(tm.GetName() or "", off, ft)
+                    if ch and ch.IsValid():
+                        return ch
+        # recurse bases
+        for btm in _get_direct_bases(t):
+            base_v = _base_value_from_typemember(v, btm)
+            if base_v and base_v.IsValid():
+                got = _find_field_recursive_any(base_v, names)
+                if got and got.IsValid():
+                    return got
+    return None
+
+
+# =============================================================================
+# std::string helpers (simple/robust)
+# =============================================================================
+
+def _str_from_std_string(sbv: lldb.SBValue) -> str | None:
+    """Extract std::string contents leveraging LLDB’s own summary when available."""
     if not sbv or not sbv.IsValid():
         return None
-    # LLDB usually gives a quoted summary for std::string
     s = sbv.GetSummary() or sbv.GetObjectDescription() or sbv.GetValue()
     if not s:
         return None
@@ -80,11 +215,13 @@ def _string_from_std_string(sbv: lldb.SBValue) -> str | None:
     return s
 
 
-# ---------- FIND Name IN SELF OR BASES (std::string only) ----------
-_CANDIDATES = ("Name", "name", "Name_", "name_")  # add others if your field is different
-
+# =============================================================================
+# Symbol-like: summary + synthetic
+# =============================================================================
 
 def _find_std_string_name(v: lldb.SBValue) -> lldb.SBValue | None:
+    """Find a std::string-ish member named 'Name' (or common variants) on this object or its bases."""
+    candidates = ("Name", "name", "Name_", "name_")
     v = _deref_if_ptr_or_ref(v)
     if not v or not v.IsValid():
         return None
@@ -92,7 +229,7 @@ def _find_std_string_name(v: lldb.SBValue) -> lldb.SBValue | None:
     if not t or not t.IsValid():
         return None
 
-    # 1) own data members
+    # direct members first
     for tm in _get_type_fields(t):
         try:
             if tm.IsBaseClass():
@@ -100,76 +237,40 @@ def _find_std_string_name(v: lldb.SBValue) -> lldb.SBValue | None:
         except Exception:
             pass
         fname = tm.GetName() or ""
-        if fname not in _CANDIDATES:
+        if fname not in candidates:
             continue
         child = v.GetChildMemberWithName(fname)
-        if child and child.IsValid():
-            # rely on LLDB’s std::string summary (no need to check its exact SBType)
-            if _string_from_std_string(child) is not None:
-                return child
+        if child and child.IsValid() and _str_from_std_string(child) is not None:
+            return child
 
-    # 2) direct bases (RELIABLE path using offset)
+    # then bases
     for btm in _get_direct_bases(t):
         base_v = _base_value_from_typemember(v, btm)
         if base_v:
-            got = _find_std_string_name(base_v)  # recurse
+            got = _find_std_string_name(base_v)
             if got:
                 return got
     return None
 
 
-# ---------- SUMMARY ----------
-def InfoLikeSummaryProvider(valobj, _dict):
+def SymbolLikeSummaryProvider(valobj, _dict):
+    """Summary for Symbol-like types: show name or '<unnamed>'."""
     try:
         name_val = _find_std_string_name(valobj)
         if not name_val:
             return "<unnamed>"
-        s = _string_from_std_string(name_val)
+        s = _str_from_std_string(name_val)
         return s if s else "<unnamed>"
     except Exception as e:
         return f"<summary error: {e}>"
 
 
-# -------- SymbolID summary --------
-
-# Optional: set to True if you prefer uppercase hex
-_SYMBOLID_HEX_UPPER = False
-
-
-def _get_field_value_by_offset(parent_v: lldb.SBValue, field_name: str) -> lldb.SBValue | None:
-    """Create the SBValue for a named field using its exact offset+type (robust across toolchains)."""
-    t = parent_v.GetType()
-    if not t or not t.IsValid():
-        return None
-    # First try: exact match via SBTypeMember
-    try:
-        n = t.GetNumberOfFields()
-    except Exception:
-        n = 0
-    for i in range(n):
-        tm = t.GetFieldAtIndex(i)
-        try:
-            if tm.IsBaseClass():
-                continue
-        except Exception:
-            pass
-        if (tm.GetName() or "") == field_name:
-            ftype = tm.GetType()
-            if not ftype or not ftype.IsValid():
-                break
-            try:
-                off = tm.GetOffsetInBytes()
-            except Exception:
-                off_bits = tm.GetOffsetInBits() if hasattr(tm, "GetOffsetInBits") else 0
-                off = off_bits // 8
-            v = parent_v.CreateChildAtOffset(field_name, off, ftype)
-            return v if v and v.IsValid() else None
-    # Fallback: if toolchain exposes it directly
-    v = parent_v.GetChildMemberWithName(field_name)
-    return v if v and v.IsValid() else None
+# ---- SymbolID (fixed size blob → hex) ---------------------------------------
 
+_SYMBOLID_HEX_UPPER = False  # set True for uppercase hex
 
 def _read_process_bytes(valobj: lldb.SBValue, addr: int, n: int) -> bytes | None:
+    """Read n bytes from process memory at addr; None on failure."""
     if addr == 0 or n <= 0:
         return None
     proc = valobj.GetProcess()
@@ -181,6 +282,7 @@ def _read_process_bytes(valobj: lldb.SBValue, addr: int, n: int) -> bytes | None
 
 
 def _extract_symbolid_bytes(sym: lldb.SBValue, expected_len: int = 20) -> list[int] | None:
+    """Extract byte array from SymbolID::data_ either via children or raw memory."""
     sym = _deref_if_ptr_or_ref(sym)
     if not sym or not sym.IsValid():
         return None
@@ -188,7 +290,7 @@ def _extract_symbolid_bytes(sym: lldb.SBValue, expected_len: int = 20) -> list[i
     if not data_field or not data_field.IsValid():
         return None
 
-    # Route A: child iteration (if LLDB exposes array elements)
+    # A: array children
     n = data_field.GetNumChildren()
     if n >= expected_len:
         out = []
@@ -201,18 +303,18 @@ def _extract_symbolid_bytes(sym: lldb.SBValue, expected_len: int = 20) -> list[i
         if len(out) == expected_len:
             return out
 
-    # Route B: direct memory read from the array address
+    # B: direct memory
     addr_v = data_field.AddressOf()
     if addr_v and addr_v.IsValid():
         addr = addr_v.GetValueAsUnsigned()
         raw = _read_process_bytes(sym, addr, expected_len)
         if raw is not None:
             return [b for b in raw]
-
     return None
 
 
 def SymbolIDSummaryProvider(valobj, _dict):
+    """Render SymbolID as hex; special cases: all-FF → <global>, all-00 → std::nullopt."""
     try:
         bs = _extract_symbolid_bytes(valobj, 20)
         if not bs:
@@ -221,23 +323,20 @@ def SymbolIDSummaryProvider(valobj, _dict):
             return "<global>"
         if all(b == 0x00 for b in bs):
             return "std::nullopt"
-        if _SYMBOLID_HEX_UPPER:
-            return "".join(f"{b:02X}" for b in bs)
-        else:
-            return "".join(f"{b:02x}" for b in bs)
+        fmt = (lambda b: f"{b:02X}") if _SYMBOLID_HEX_UPPER else (lambda b: f"{b:02x}")
+        return "".join(fmt(b) for b in bs)
     except Exception as e:
         return f"<summary error: {e}>"
 
 
-# ---------- SYNTHETIC: FLATTEN BASES ONLY ----------
-# --- knobs (same as before) ---
-_PREFIX_ORDER = True  # add "NN " so alphabetical sort preserves order
-_INCLUDE_DECL_TYPE = True  # include "DeclType::" before the field name
+# ---- Symbol-like synthetic: flatten bases (stable order) ---------------------
 
+_PREFIX_ORDER = True       # prefix children with "NN" to stabilize sort order
+_INCLUDE_DECL_TYPE = True  # include "DeclType::" before member name
 
 def _norm_typename(t: lldb.SBType) -> str:
+    """Strip common C++ qualifiers and keywords from type name."""
     n = _type_name(t)
-    # strip common prefixes/qualifiers
     for p in ("class ", "struct ", "const ", "volatile "):
         if n.startswith(p):
             n = n[len(p):]
@@ -245,14 +344,14 @@ def _norm_typename(t: lldb.SBType) -> str:
 
 
 def _is_info_type(t: lldb.SBType) -> bool:
-    return _norm_typename(t) == "mrdocs::Info"
+    """Identify the 'mrdocs::Symbol' base to show it first."""
+    return _norm_typename(t) == "mrdocs::Symbol"
 
 
-class InfoLikeSyntheticProvider:
+class SymbolLikeSyntheticProvider:
     """
-    Show fields from mrdocs::Info FIRST,
-    then all other bases deepest-first, then most-derived.
-    Never recurses into fields. Uses order prefixes to beat UI resorting.
+    Show fields from mrdocs::Symbol FIRST, then other bases (deepest→most-derived), then own fields.
+    Does not recurse into sub-fields.
     """
 
     def __init__(self, valobj, _dict):
@@ -261,6 +360,7 @@ def __init__(self, valobj, _dict):
         self.update()
 
     def _append_own_fields(self, v: lldb.SBValue, seen: set[str], rank: int, decl: str):
+        """Append this node's data members with stable, prefixed display names."""
         t = v.GetType()
         if not t or not t.IsValid():
             return
@@ -277,17 +377,12 @@ def _append_own_fields(self, v: lldb.SBValue, seen: set[str], rank: int, decl: s
             if not child or not child.IsValid():
                 continue
 
-            # Build display name with stable, sortable prefix
             parts = []
             if _PREFIX_ORDER:
                 parts.append(f"{rank:02d}")
-            if _INCLUDE_DECL_TYPE and decl:
-                parts.append(f"{decl}::{fname}")
-            else:
-                parts.append(fname)
+            parts.append(f"{decl}::{fname}" if (_INCLUDE_DECL_TYPE and decl) else fname)
             name = " ".join(parts)
 
-            # Dedup if collisions happen
             base = name
             k = 2
             while name in seen:
@@ -302,9 +397,7 @@ def _append_own_fields(self, v: lldb.SBValue, seen: set[str], rank: int, decl: s
             self.children.append(child)
 
     def _linearize_bases_postorder(self, v: lldb.SBValue):
-        """
-        Returns nodes in post-order: [deepest bases ..., most-derived (v)].
-        """
+        """Return nodes in post-order: [deepest bases …, most-derived (v)]."""
         order = []
 
         def dfs(node: lldb.SBValue):
@@ -321,27 +414,22 @@ def dfs(node: lldb.SBValue):
         return order
 
     def update(self):
+        """Rebuild flat child list: Symbol base(s) first, then others, then self."""
         self.children = []
         v = self.root
         if not v or not v.IsValid():
             return
 
         seen = set()
-        order = self._linearize_bases_postorder(v)  # deepest … -> most-derived
+        order = self._linearize_bases_postorder(v)
         if order:
-            # Partition: Info nodes first, others after (preserving their relative order)
             info_nodes = [n for n in order if _is_info_type(n.GetType())]
             other_nodes = [n for n in order if not _is_info_type(n.GetType())]
-
             rank = 0
-            for node in info_nodes:
-                self._append_own_fields(node, seen, rank, _norm_typename(node.GetType()))
-                rank += 1
-            for node in other_nodes:
+            for node in info_nodes + other_nodes:
                 self._append_own_fields(node, seen, rank, _norm_typename(node.GetType()))
                 rank += 1
 
-        # Fallback: nothing discovered → show immediate children (no field recursion)
         if not self.children:
             n = v.GetNumChildren()
             for i in range(n):
@@ -350,15 +438,9 @@ def update(self):
                     self.children.append(c)
 
     # required API
-    def has_children(self):
-        return len(self.children) > 0
-
-    def num_children(self):
-        return len(self.children)
-
-    def get_child_at_index(self, idx):
-        return self.children[idx] if 0 <= idx < len(self.children) else None
-
+    def has_children(self): return len(self.children) > 0
+    def num_children(self): return len(self.children)
+    def get_child_at_index(self, idx): return self.children[idx] if 0 <= idx < len(self.children) else None
     def get_child_index(self, name):
         for i, c in enumerate(self.children):
             if c.GetName() == name:
@@ -366,98 +448,247 @@ def get_child_index(self, name):
         return -1
 
 
-# -------- Optional<T>: transparent summary + children (fixed) --------
+# =============================================================================
+# Optional<T>: summary + synthetic (handles libc++/libstdc++)
+# =============================================================================
 
-def _optional_inner(valobj):
-    v = _deref_if_ptr_or_ref(valobj)
-    if not v or not v.IsValid():
+def _is_std_optional_typename(tyname: str | None) -> bool:
+    """Heuristic: does the name look like a std::optional specialization (any vendor)."""
+    if not tyname:
+        return False
+    tn = tyname.replace("class ", "").replace("struct ", "").replace("const ", "").replace("volatile ", "")
+    return ("optional<" in tn and "std::" in tn) or "__optional" in tn or "::optional<" in tn
+
+
+# Known payload/flag spellings across libstdc++/libc++
+_OPT_PAYLOAD_NAMES = ("__val__", "__val_", "_M_value", "_M_payload", "__value_")
+_OPT_ENGAGED_NAMES = ("__engaged_", "_M_engaged", "_M_has_value", "__has_value_")
+
+def _nonsynth(vo):
+    """Prefer non-synthetic view (raw layout) when available."""
+    try:
+        ns = vo.GetNonSyntheticValue()
+        return ns if (ns and ns.IsValid()) else vo
+    except Exception:
+        return vo
+
+def _value_from_typemember(parent_v, tm):
+    """Materialize a field from its SBTypeMember (offset-aware)."""
+    ft = tm.GetType()
+    if not (ft and ft.IsValid()):
         return None
-    inner = _get_field_value_by_offset(v, "t_") or v.GetChildMemberWithName("t_")
-    return inner if inner and inner.IsValid() else None
+    try:
+        off = tm.GetOffsetInBytes()
+    except Exception:
+        off_bits = tm.GetOffsetInBits() if hasattr(tm, "GetOffsetInBits") else 0
+        off = off_bits // 8
+    ch = parent_v.CreateChildAtOffset(tm.GetName() or "", off, ft)
+    return ch if (ch and ch.IsValid()) else None
 
+def _find_optional_payload(s):
+    """
+    From std::optional storage 's' (non-synthetic), return (payload_vo, engaged_bool_or_None).
+    Works across libc++/libstdc++ raw layouts by scanning fields/bases.
+    """
+    s = _nonsynth(s)
+    if not (s and s.IsValid()):
+        return (None, None)
 
-def _clean(s: str | None) -> str | None:
-    if not s:
+    t = s.GetType()
+    if t and t.IsValid():
+        engaged = None
+        # own fields
+        for tm in _get_type_fields(t):
+            nm = tm.GetName() or ""
+            if nm in _OPT_ENGAGED_NAMES:
+                flag = _value_from_typemember(s, tm)
+                if flag and flag.IsValid():
+                    try:
+                        engaged = flag.GetValueAsUnsigned(0) != 0
+                    except Exception:
+                        engaged = None
+            if nm in _OPT_PAYLOAD_NAMES:
+                val = _value_from_typemember(s, tm)
+                if val and val.IsValid():
+                    return (val, engaged)
+        # bases
+        for btm in _get_direct_bases(t):
+            base_v = _base_value_from_typemember(s, btm)
+            if base_v and base_v.IsValid():
+                val, eng = _find_optional_payload(base_v)
+                if val:
+                    return (val, engaged if engaged is not None else eng)
+
+    # last resort: direct child lookup by name
+    for nm in _OPT_PAYLOAD_NAMES:
+        ch = s.GetChildMemberWithName(nm)
+        if ch and ch.IsValid():
+            return (ch, None)
+
+    return (None, None)
+
+def _resolve_inner(valobj):
+    """
+    Resolve the contained value of mrdocs::Optional<T>.
+    Returns:
+      - SBValue of T (or T* for Optional<T*>), or
+      - None if disengaged/unavailable.
+    """
+    vo = _deref_if_ptr_or_ref(valobj)
+    if not (vo and vo.IsValid()):
         return None
-    s = s.strip()
-    if s.startswith("error:"):
+
+    # Optional<T&> path: p_ is a T*
+    p = _get_field_value_by_offset(vo, "p_") or vo.GetChildMemberWithName("p_")
+    if p is not None and p.IsValid():
+        try:
+            if p.GetValueAsUnsigned(0) == 0:
+                return None
+        except Exception:
+            pv = p.GetValue()
+            if not pv or pv in ("0", "(nullptr)", "NULL"):
+                return None
+        deref = p.Dereference()
+        return deref if (deref and deref.IsValid()) else None
+
+    # Optional<T> path: s_ is inline T or std::optional<T>
+    s = _get_field_value_by_offset(vo, "s_") or vo.GetChildMemberWithName("s_")
+    if not (s and s.IsValid()):
+        return None
+
+    # A) Friendly synthetic with a 'Value' child
+    try:
+        n = s.GetNumChildren()
+    except Exception:
+        n = 0
+    if n > 0:
+        for i in range(n):
+            ch = s.GetChildAtIndex(i)
+            if ch and ch.IsValid() and (ch.GetName() or "") == "Value":
+                return ch
+        # don't return s here: synthetic may be libc++ internals; fall through
+
+    # B) Raw layout: find payload (__val_ / _M_value) and engaged flag
+    payload, engaged = _find_optional_payload(s)
+    if engaged is False:
         return None
+    if payload and payload.IsValid():
+        return payload
+
+    # C) Nullable-traits inline T: s_ is the value
     return s
 
 
 def OptionalSummaryProvider(valobj, _dict):
+    """
+    Summary for mrdocs::Optional<T>.
+    - Disengaged: 'nullopt'
+    - T*       : '0xaddr[ → <short pointee>]'
+    - Scalars  : value
+    - Strings  : string (no quotes)
+    - Structs  : '' (empty summary; children show content)
+    """
     try:
-        inner = _optional_inner(valobj)
-        if not inner:
-            return "<unavailable>"
+        inner = _resolve_inner(valobj)
+        if inner is None:
+            return "nullopt"
+
+        # T* : compact address; optional hint with short pointee summary/value
+        t = inner.GetType()
+        if t and t.IsValid() and t.IsPointerType():
+            addr = _fmt_ptr_addr(inner)
+            hint = ""
+            try:
+                dv = inner.Dereference()
+                if dv and dv.IsValid():
+                    hs = _clean(dv.GetSummary()) or _clean(dv.GetValue())
+                    if hs:
+                        hint = f" → {hs}"
+            except Exception:
+                pass
+            return f"{addr}{hint}"
 
-        # 1) Prefer T's own summary (works with your other formatters)
+        # Scalars/strings
         s = _clean(inner.GetSummary())
-        if s is not None:
+        if s not in (None, ""):
             return s
-
-        # 2) Safe fallbacks without type introspection
         v = _clean(inner.GetValue())
-        if v is not None:
+        if v not in (None, ""):
             return v
 
+        # Structured types: quiet summary; show children
+        try:
+            if inner.GetNumChildren() > 0 or inner.MightHaveChildren():
+                return ""
+        except Exception:
+            pass
+
         d = _clean(inner.GetObjectDescription())
-        if d is not None:
+        if d not in (None, ""):
             return d
-
-        return "<unavailable summary>"
+        return ""
     except Exception as e:
         return f"<summary error: {e}>"
 
 
 class OptionalTransparentSyntheticProvider:
     """
-    Present Optional<T> as if it were T: forward children to t_.
+    Synthetic for mrdocs::Optional<T> that forwards to the contained value.
+    - For T* the children are those of *T (summary still shows the pointer).
     """
 
     def __init__(self, valobj, _dict):
         self.valobj = valobj
-        self.inner = None
+        self.inner = None          # SBValue of T or T*
+        self.children_root = None  # SBValue used to enumerate children (T or *T)
         self.update()
 
     def update(self):
-        self.inner = _optional_inner(self.valobj)
+        """Recompute forward target and children root (dereference T* if needed)."""
+        self.inner = _resolve_inner(self.valobj)
+        self.children_root = self.inner
+        if self.inner and self.inner.IsValid():
+            t = self.inner.GetType()
+            if t and t.IsValid() and t.IsPointerType():
+                try:
+                    deref = self.inner.Dereference()
+                    if deref and deref.IsValid():
+                        self.children_root = deref
+                except Exception:
+                    pass
 
     def has_children(self):
-        return bool(self.inner) and (self.inner.GetNumChildren() > 0 or self.inner.MightHaveChildren())
+        r = self.children_root
+        return bool(r) and (r.GetNumChildren() > 0 or r.MightHaveChildren())
 
     def num_children(self):
-        return self.inner.GetNumChildren() if self.inner else 0
+        r = self.children_root
+        return r.GetNumChildren() if r else 0
 
     def get_child_at_index(self, i):
-        if not self.inner: return None
-        return self.inner.GetChildAtIndex(i)
+        r = self.children_root
+        if not r:
+            return None
+        return r.GetChildAtIndex(i)
 
     def get_child_index(self, name):
-        if not self.inner: return -1
-        n = self.inner.GetNumChildren()
+        r = self.children_root
+        if not r:
+            return -1
+        n = r.GetNumChildren()
         for idx in range(n):
-            c = self.inner.GetChildAtIndex(idx)
+            c = r.GetChildAtIndex(idx)
             if c and c.IsValid() and c.GetName() == name:
                 return idx
         return -1
 
 
-# -------- Location summary: "ShortPath:LineNumber" --------
-
-def _str_from_std_string(v: lldb.SBValue) -> str | None:
-    if not v or not v.IsValid():
-        return None
-    s = v.GetSummary() or v.GetObjectDescription() or v.GetValue()
-    if not s:
-        return None
-    s = s.strip()
-    if len(s) >= 2 and s[0] == '"' and s[-1] == '"':
-        s = s[1:-1]
-    return s
-
+# =============================================================================
+# Location: summary only ("ShortPath:LineNumber [doc]")
+# =============================================================================
 
 def LocationSummaryProvider(valobj, _dict):
+    """Summary for mrdocs::Location → 'ShortPath:LineNumber[ [doc]]'."""
     try:
         v = _deref_if_ptr_or_ref(valobj)
         if not v or not v.IsValid():
@@ -471,133 +702,34 @@ def LocationSummaryProvider(valobj, _dict):
         if not path:
             return "<unknown-path>"
 
-        line = 0
-        if ln and ln.IsValid():
-            line = ln.GetValueAsUnsigned(0)
-
-        documented = False
-        if dn and dn.IsValid():
-            documented = dn.GetValueAsUnsigned(0) != 0
-
+        line = ln.GetValueAsUnsigned(0) if (ln and ln.IsValid()) else 0
+        documented = (dn.GetValueAsUnsigned(0) != 0) if (dn and dn.IsValid()) else False
         return f"{path}:{line}{' [doc]' if documented else ''}"
     except Exception as e:
         return f"<summary error: {e}>"
 
 
-# ---------- helpers for name-based child lookup ----------
-def _strip_prefixes_for_match(nm: str) -> str:
-    """Strip our NN prefixes and optional 'Decl::' we add in other providers."""
-    if not nm:
-        return nm
-    # Remove leading "NN " prefix (e.g., "03 Info::Name")
-    nm = re.sub(r"^\d{2}\s+", "", nm)
-    # If a DeclType prefix exists, keep only the field after '::'
-    if "::" in nm:
-        nm = nm.split("::", 1)[1]
-    # Also strip any trailing " #k" suffix used for de-duping
-    nm = re.sub(r"\s+#\d+$", "", nm)
-    return nm
-
-
-def _child_by_name_any(v: lldb.SBValue, names: tuple[str, ...]) -> lldb.SBValue | None:
-    """Try to get a child by name from both synthetic and non-synthetic views."""
-    if not v or not v.IsValid():
-        return None
-    views = [v]
-    try:
-        ns = v.GetNonSyntheticValue()
-        if ns and ns.IsValid() and ns.GetID() != v.GetID():
-            views.append(ns)
-    except Exception:
-        pass
-
-    # 1) Direct member lookup
-    for view in views:
-        for nm in names:
-            ch = view.GetChildMemberWithName(nm)
-            if ch and ch.IsValid():
-                return ch
-
-    # 2) Enumerate children and match by (possibly prefixed) name
-    for view in views:
-        n = view.GetNumChildren()
-        for i in range(n):
-            ch = view.GetChildAtIndex(i)
-            if not ch or not ch.IsValid():
-                continue
-            nm = _strip_prefixes_for_match(ch.GetName() or "")
-            if nm in names:
-                return ch
-    return None
-
-
-def _find_field_recursive_any(v: lldb.SBValue, names: tuple[str, ...]) -> lldb.SBValue | None:
-    """Search own fields for any name in `names`; recurse into direct bases (type+offset)."""
-    if not v or not v.IsValid():
-        return None
-    # Try fast path on this node
-    got = _child_by_name_any(v, names)
-    if got and got.IsValid():
-        return got
+# =============================================================================
+# Polymorphic<T>: summary + synthetic
+# =============================================================================
 
-    # Try via SBType fields (offset-based)
-    t = v.GetType()
-    if t and t.IsValid():
-        try:
-            n = t.GetNumberOfFields()
-        except Exception:
-            n = 0
-        for i in range(n):
-            tm = t.GetFieldAtIndex(i)
-            # skip bases
-            try:
-                if tm.IsBaseClass():
-                    continue
-            except Exception:
-                pass
-            fname = tm.GetName() or ""
-            if fname in names:
-                try:
-                    off = tm.GetOffsetInBytes()
-                except Exception:
-                    off_bits = tm.GetOffsetInBits() if hasattr(tm, "GetOffsetInBits") else 0
-                    off = off_bits // 8
-                ft = tm.GetType()
-                ch = v.CreateChildAtOffset(fname, off, ft) if ft and ft.IsValid() else None
-                if ch and ch.IsValid():
-                    return ch
-
-        # Recurse into direct bases
-        for btm in _get_direct_bases(t):
-            base_v = _base_value_from_typemember(v, btm)
-            if base_v and base_v.IsValid():
-                got = _find_field_recursive_any(base_v, names)
-                if got and got.IsValid():
-                    return got
-    return None
-
-
-# ---------- Polymorphic<T>: forward to WB->Value ----------
 def _poly_inner_value(valobj):
     """
-    Resolve Polymorphic<T>::WB (WrapperBase*). If null -> "null".
-    Else, deref to dynamic Wrapper<T> and return its 'Value' field.
+    Resolve Polymorphic<T>::WB (WrapperBase*).
+    - nullptr → "null"
+    - else deref, take dynamic type, return its 'Value' field (own or in bases).
     """
     v = _deref_if_ptr_or_ref(valobj)
     if not v or not v.IsValid():
         return None
 
-    # Find WB robustly
     wb = (_child_by_name_any(v, ("WB", "wb", "WB_", "wb_"))
           or _get_field_value_by_offset(v, "WB"))
     if not wb or not wb.IsValid():
         return None
-
-    # nullptr?
     if wb.GetValueAsUnsigned(0) == 0:
         return "null"
 
-    # Deref WB and prefer dynamic type; also try non-synthetic view
     pointee = wb.Dereference()
     if not pointee or not pointee.IsValid():
         return None
@@ -608,13 +740,13 @@ def _poly_inner_value(valobj):
     except Exception:
         pass
 
-    # Find Value on the wrapper (own or in bases)
     value = (_child_by_name_any(wrapper, ("Value", "value", "Value_", "value_"))
              or _find_field_recursive_any(wrapper, ("Value", "value", "Value_", "value_")))
     return value if value and value.IsValid() else None
 
 
 def PolymorphicSummaryProvider(valobj, _dict):
+    """Summary for mrdocs::Polymorphic<T>: forward T’s summary/value; null → std::nullopt."""
     try:
         inner = _poly_inner_value(valobj)
         if inner == "null":
@@ -622,7 +754,6 @@ def PolymorphicSummaryProvider(valobj, _dict):
         if not inner:
             return "<unavailable>"
 
-        # Forward T's own summary if present; else clean fallbacks
         s = _clean(inner.GetSummary())
         if s is not None:
             return s
@@ -638,8 +769,7 @@ def PolymorphicSummaryProvider(valobj, _dict):
 
 
 class PolymorphicTransparentSyntheticProvider:
-    """Present Polymorphic<T> as if it were the inner Value."""
-
+    """Synthetic for mrdocs::Polymorphic<T>: expose inner 'Value' as children."""
     def __init__(self, valobj, _dict):
         self.valobj = valobj
         self.inner = None
@@ -648,6 +778,26 @@ def __init__(self, valobj, _dict):
     def update(self):
         iv = _poly_inner_value(self.valobj)
         self.inner = None if (iv is None or iv == "null") else iv
+        self.children_root = self.inner
+
+        if self.inner and self.inner.IsValid():
+            try:
+                self.inner.SetPreferDynamicValue(lldb.eDynamicCanRunTarget)
+                self.inner.SetPreferSyntheticValue(True)
+            except Exception:
+                pass
+
+            t = self.inner.GetType()
+            if t and t.IsValid() and t.IsPointerType():
+                try:
+                    deref = self.inner.Dereference()
+                    if deref and deref.IsValid():
+                        self.children_root = deref
+                        # also ensure prefs on the deref we’ll enumerate
+                        self.children_root.SetPreferDynamicValue(lldb.eDynamicCanRunTarget)
+                        self.children_root.SetPreferSyntheticValue(True)
+                except Exception:
+                    pass
 
     def has_children(self):
         return bool(self.inner) and (self.inner.GetNumChildren() > 0 or self.inner.MightHaveChildren())
@@ -671,6 +821,39 @@ def get_child_index(self, name):
         return -1
 
 
+# =============================================================================
+# Registration helpers & setup (uniform, zero hard-coded variant lists)
+# =============================================================================
+
+def _rx_variants(core: str) -> list[str]:
+    """
+    Build regex variants for a given C++ type name/pattern.
+
+    Args:
+      core:   Base name or pattern (without ^$). Examples:
+              - 'mrdocs::Name'
+              - 'mrdocs::Optional<.*>'
+              - 'mrdocs::[^:]*Symbol'  (already a regex)
+      allow_kind_prefixes:
+              If True, generate 'class ' and 'struct ' prefixed variants.
+              If False, don't (useful for templated regexes).
+      allow_const:
+              If True, generate 'const ' prefixed variants.
+
+    Returns:
+      List of '^...$' anchored regex strings.
+    """
+    kinds = ["", "class ", "struct "]
+    consts = ["", "const "]
+    out = []
+    for c in consts:
+        for k in kinds:
+            # Note: const must go before class/struct, e.g. 'const class T'
+            prefix = f"{c}{k}".strip()
+            space = (prefix + " ") if prefix else ""
+            out.append(f"^{space}{core}$")
+    return out
+
 # -------- Name summary: "Prefix::Name" or "Name" --------
 
 # --- helpers for Name prefix chain (names only, no ids) ---
@@ -741,45 +924,289 @@ def NameSummaryProvider(valobj, _dict):
     except Exception as e:
         return f"<summary error: {e}>"
 
+class FlattenAllBasesSyntheticProvider:
+    """
+    Flatten data members from all base classes (deepest → most-derived), then own members.
+    Does not recurse into sub-fields. Skips base-class nodes as direct children.
+    Drop-in generic provider for “show me everything flat”.
+    """
+
+    # knobs (override per-class by assigning on the instance in __init__ if you want)
+    EMIT_SELF_LAST = True         # after all bases, append the most-derived's own fields
+    INCLUDE_DECL_TYPE = _INCLUDE_DECL_TYPE
+    PREFIX_ORDER = _PREFIX_ORDER
+
+    def __init__(self, valobj, _dict):
+        self.root = _deref_if_ptr_or_ref(valobj)
+        self.children = []
+        self._err = None
+        self.update()
+
+    # ----- helpers -----
+
+    def _norm_typename(self, t: lldb.SBType) -> str:
+        n = _type_name(t)
+        for p in ("class ", "struct ", "const ", "volatile "):
+            if n.startswith(p):
+                n = n[len(p):]
+        return n
+
+    def _append_own_fields(self, v: lldb.SBValue, seen: set[str], rank: int, decl: str):
+        t = v.GetType()
+        if not t or not t.IsValid():
+            return
+        for tm in _get_type_fields(t):
+            # only data members, never a base node
+            try:
+                if tm.IsBaseClass():
+                    continue
+            except Exception:
+                # older LLDBs may not have IsBaseClass; rely on data-path fallback
+                pass
+
+            fname = tm.GetName()
+            if not fname:
+                continue
+
+            child = v.GetChildMemberWithName(fname)
+            if not child or not child.IsValid():
+                continue
+
+            # build display name
+            parts = []
+            if self.PREFIX_ORDER:
+                parts.append(f"{rank:02d}")
+            parts.append(f"{decl}::{fname}" if (self.INCLUDE_DECL_TYPE and decl) else fname)
+            name = " ".join(parts)
+
+            # de-dup same display labels
+            base = name
+            k = 2
+            while name in seen:
+                name = f"{base} #{k}"
+                k += 1
+            seen.add(name)
+
+            try:
+                child.SetName(name)
+            except Exception:
+                pass
+
+            self.children.append(child)
+
+    def _linearize_bases_postorder(self, v: lldb.SBValue):
+        """Nodes in post-order: [deepest bases …, most-derived (v)]."""
+        order = []
+        visited_types = set()  # avoid re-visiting virtual bases / diamonds
+
+        def dfs(node: lldb.SBValue):
+            t = node.GetType()
+            if not t or not t.IsValid():
+                return
+            # Use type name as a proxy key; SBType equality can be flaky across modules
+            key = self._norm_typename(t)
+            if key in visited_types:
+                return
+            visited_types.add(key)
+
+            for btm in _get_direct_bases(t):
+                base_v = _base_value_from_typemember(node, btm)
+                if base_v and base_v.IsValid():
+                    dfs(base_v)
+
+            order.append(node)
+
+        dfs(v)
+        return order
+
+    # ----- required API -----
+
+    def update(self):
+        self.children = []
+        v = self.root
+        if not v or not v.IsValid():
+            return
+
+        try:
+            order = self._linearize_bases_postorder(v)
+            if not order:
+                # nothing to flatten → fall back
+                n = v.GetNumChildren()
+                for i in range(n):
+                    c = v.GetChildAtIndex(i)
+                    if c and c.IsValid():
+                        self.children.append(c)
+                return
+
+            # Optionally place self (most-derived) last
+            if self.EMIT_SELF_LAST and order[-1] is v:
+                bases = order[:-1]
+                tail = [order[-1]]
+            else:
+                bases = order
+                tail = []
+
+            seen = set()
+            rank = 0
+            for node in bases:
+                self._append_own_fields(node, seen, rank, self._norm_typename(node.GetType()))
+                rank += 1
+            for node in tail:
+                self._append_own_fields(node, seen, rank, self._norm_typename(node.GetType()))
+                rank += 1
+
+            # final fallback if nothing was emitted
+            if not self.children:
+                n = v.GetNumChildren()
+                for i in range(n):
+                    c = v.GetChildAtIndex(i)
+                    if c and c.IsValid():
+                        self.children.append(c)
+
+        except Exception as e:
+            # defensive: on any unexpected LLDB quirk, degrade gracefully
+            self._err = str(e)
+            n = v.GetNumChildren()
+            for i in range(n):
+                c = v.GetChildAtIndex(i)
+                if c and c.IsValid():
+                    self.children.append(c)
+
+    def has_children(self): return len(self.children) > 0
+    def num_children(self): return len(self.children)
+    def get_child_at_index(self, idx): return self.children[idx] if 0 <= idx < len(self.children) else None
+    def get_child_index(self, name):
+        for i, c in enumerate(self.children):
+            try:
+                if c.GetName() == name:
+                    return i
+            except Exception:
+                pass
+        return -1
+
+def _escape_for_summary(s: str) -> str:
+    # C-ish minimal escaping for debugger summaries
+    s = s.replace("\\", "\\\\").replace("\"", "\\\"")
+    s = s.replace("\n", "\\n").replace("\r", "\\r").replace("\t", "\\t")
+    return s
+
+def _kind_string(v: lldb.SBValue) -> str:
+    k = _get_field_value_by_offset(v, "Kind") or v.GetChildMemberWithName("Kind")
+    if not (k and k.IsValid()):
+        return "Inline"
+    return (_clean(k.GetSummary()) or _clean(k.GetValue()) or "Inline")
+
+def _inline_text(vo: lldb.SBValue, depth: int = 0, max_depth: int = 16, max_children: int = 512) -> str:
+    """
+    Extract *textual* content of an Inline:
+      - literal → its contents
+      - children → concatenation of children's textual contents (recursively)
+      - otherwise → ""
+    (Does NOT prepend Kind; meant for building the quoted part.)
+    """
+    if not (vo and vo.IsValid()):
+        return ""
+
+    v = _deref_if_ptr_or_ref(vo)
+
+    # literal
+    lit = _get_field_value_by_offset(v, "literal") or v.GetChildMemberWithName("literal")
+    if lit and lit.IsValid():
+        s = _str_from_std_string(lit)
+        return s or ""
+
+    # children
+    ch = _get_field_value_by_offset(v, "children") or v.GetChildMemberWithName("children")
+    if ch and ch.IsValid():
+        try:
+            ch.SetPreferSyntheticValue(True)
+        except Exception:
+            pass
+        n = ch.GetNumChildren()
+        if n <= 0 or depth >= max_depth:
+            return ""
+        pieces = []
+        limit = min(n, max_children)
+        for i in range(limit):
+            el = ch.GetChildAtIndex(i)
+            if not (el and el.IsValid()):
+                continue
+            inner = _poly_inner_value(el)
+            if inner == "null":
+                continue
+            inner = inner or el
+            try:
+                inner.SetPreferSyntheticValue(True)
+                inner.SetPreferDynamicValue(lldb.eDynamicCanRunTarget)
+            except Exception:
+                pass
+            pieces.append(_inline_text(inner, depth + 1, max_depth, max_children))
+        return "".join(pieces)
+
+    # nothing textual here
+    return ""
+
+def InlineSummaryProvider(valobj, _dict):
+    """
+    Summary for mrdocs::doc::<...>Inline:
+      1) Kind: "escaped text"    (literal or children concatenation)
+      2) Kind                     (no literal/children)
+    """
+    try:
+        v = _deref_if_ptr_or_ref(valobj)
+        if not (v and v.IsValid()):
+            return ""
+
+        kind = _kind_string(v)
+
+        # textual content (literal or concatenated children)
+        text = _inline_text(v)
+        if text:
+            return f'{kind}: "{_escape_for_summary(text)}"'
+
+        # no textual content → just Kind
+        return kind
+    except Exception as e:
+        return f"<summary error: {e}>"
 
 def __lldb_init_module(debugger, _dict):
+    """
+    Register all summaries/synthetics in category 'MrDocs' using uniform variant generation.
+    """
     cat = "MrDocs"
-    # Register for both regexes; keep it boring and compatible.
-    for rx in _INFO_REGEXES:
-        debugger.HandleCommand(f'type summary add -w {cat} -x -P -F mrdocs_formatters.InfoLikeSummaryProvider "{rx}"')
-        debugger.HandleCommand(f'type synthetic add -w {cat} -x -l mrdocs_formatters.InfoLikeSyntheticProvider "{rx}"')
-    for rx in ("^mrdocs::SymbolID$", "^const mrdocs::SymbolID$"):
-        debugger.HandleCommand(
-            f'type summary add -w {cat} -x -P -F mrdocs_formatters.SymbolIDSummaryProvider "{rx}"'
-        )
-    for rx in ("^mrdocs::Optional<.*>$", "^const mrdocs::Optional<.*>$"):
-        debugger.HandleCommand(
-            f'type summary add -w {cat} -x -P -F mrdocs_formatters.OptionalSummaryProvider "{rx}"'
-        )
-        debugger.HandleCommand(
-            f'type synthetic add -w {cat} -x -l mrdocs_formatters.OptionalTransparentSyntheticProvider "{rx}"'
-        )
-    for rx in ("^mrdocs::Location$", "^const mrdocs::Location$"):
-        debugger.HandleCommand(
-            f'type summary add -w {cat} -x -P -F mrdocs_formatters.LocationSummaryProvider "{rx}"'
-        )
-    for rx in ("^mrdocs::Polymorphic<.*>$", "^const mrdocs::Polymorphic<.*>$"):
-        debugger.HandleCommand(
-            f'type summary add -w {cat} -x -P -F mrdocs_formatters.PolymorphicSummaryProvider "{rx}"'
-        )
-        debugger.HandleCommand(
-            f'type synthetic add -w {cat} -x -l mrdocs_formatters.PolymorphicTransparentSyntheticProvider "{rx}"'
-        )
-    for rx in (
-            "^mrdocs::Name$",
-            "^const mrdocs::Name$",
-            "^class mrdocs::Name$",
-            "^const class mrdocs::Name$",
-            "^struct mrdocs::Name$",
-            "^const struct mrdocs::Name$",
-    ):
-        debugger.HandleCommand(
-            f'type summary add -w {cat} -x -P -F mrdocs_formatters.NameSummaryProvider "{rx}"'
-        )
+
+    # Symbol-like (regex pattern + const variant; no class/struct added)
+    for rx in _rx_variants("mrdocs::[^:]*Symbol"):
+        debugger.HandleCommand(f'type summary   add -w {cat} -x -P -F mrdocs_formatters.SymbolLikeSummaryProvider "{rx}"')
+        debugger.HandleCommand(f'type synthetic add -w {cat} -x -l mrdocs_formatters.SymbolLikeSyntheticProvider "{rx}"')
+
+    # SymbolID (concrete type; include class/struct & const variants)
+    for rx in _rx_variants("mrdocs::SymbolID"):
+        debugger.HandleCommand(f'type summary add -w {cat} -x -P -F mrdocs_formatters.SymbolIDSummaryProvider "{rx}"')
+
+    # Location (concrete type with variants)
+    for rx in _rx_variants("mrdocs::Location"):
+        debugger.HandleCommand(f'type summary add -w {cat} -x -P -F mrdocs_formatters.LocationSummaryProvider "{rx}"')
+
+    # Name (concrete type; include class/struct & const variants)
+    for rx in _rx_variants("mrdocs::Name"):
+        debugger.HandleCommand(f'type summary add -w {cat} -x -P -F mrdocs_formatters.NameSummaryProvider "{rx}"')
+
+    # Documentation: use the flattener
+    for rx in _rx_variants("mrdocs::doc::[^:]*Block") + _rx_variants("mrdocs::doc::[^:]*Inline"):
+        debugger.HandleCommand(f'type synthetic add -w {cat} -x -l mrdocs_formatters.FlattenAllBasesSyntheticProvider "{rx}"')
+
+    # Optional<T> (templated regex; don't add class/struct; do add const)
+    for rx in _rx_variants("mrdocs::Optional<.*>"):
+        debugger.HandleCommand(f'type summary   add -w {cat} -x -P -F mrdocs_formatters.OptionalSummaryProvider "{rx}"')
+        debugger.HandleCommand(f'type synthetic add -w {cat} -x -l mrdocs_formatters.OptionalTransparentSyntheticProvider "{rx}"')
+
+    # Polymorphic<T> (templated regex; no class/struct; add const)
+    for rx in _rx_variants("mrdocs::Polymorphic<.*>"):
+        debugger.HandleCommand(f'type summary   add -w {cat} -x -P -F mrdocs_formatters.PolymorphicSummaryProvider "{rx}"')
+        debugger.HandleCommand(f'type synthetic add -w {cat} -x -l mrdocs_formatters.PolymorphicTransparentSyntheticProvider "{rx}"')
+
+    for rx in _rx_variants("mrdocs::doc::[^:]*Inline"):
+        debugger.HandleCommand(f'type summary add -w {cat} -x -P -F mrdocs_formatters.InlineSummaryProvider "{rx}"')
 
     debugger.HandleCommand(f"type category enable {cat}")
diff --git a/share/mrdocs/addons/generator/adoc/partials/doc/block/admonition.adoc.hbs b/share/mrdocs/addons/generator/adoc/partials/doc/block/admonition.adoc.hbs
new file mode 100644
index 000000000..1e38a0e9d
--- /dev/null
+++ b/share/mrdocs/addons/generator/adoc/partials/doc/block/admonition.adoc.hbs
@@ -0,0 +1,5 @@
+[{{upper admonish}}]
+====
+{{> doc/block-container ~}}
+====
+
diff --git a/share/mrdocs/addons/generator/adoc/partials/doc/block/brief.adoc.hbs b/share/mrdocs/addons/generator/adoc/partials/doc/block/brief.adoc.hbs
new file mode 100644
index 000000000..5f8b2b0e6
--- /dev/null
+++ b/share/mrdocs/addons/generator/adoc/partials/doc/block/brief.adoc.hbs
@@ -0,0 +1,3 @@
+{{>doc/block/inline-brief}}
+
+
diff --git a/share/mrdocs/addons/generator/adoc/partials/doc/block/code.adoc.hbs b/share/mrdocs/addons/generator/adoc/partials/doc/block/code.adoc.hbs
new file mode 100644
index 000000000..2deaa1510
--- /dev/null
+++ b/share/mrdocs/addons/generator/adoc/partials/doc/block/code.adoc.hbs
@@ -0,0 +1,4 @@
+[,{{ or info "cpp" }}]
+----
+{{{ literal }}}
+----
diff --git a/share/mrdocs/addons/generator/adoc/partials/doc/block/list.adoc.hbs b/share/mrdocs/addons/generator/adoc/partials/doc/block/list.adoc.hbs
new file mode 100644
index 000000000..9f5d2c86e
--- /dev/null
+++ b/share/mrdocs/addons/generator/adoc/partials/doc/block/list.adoc.hbs
@@ -0,0 +1,9 @@
+{{#each items}}
+* {{#each blocks}}{{#unless @first}}
+
++
+{{/unless}}
+{{#if (eq kind "paragraph")}}{{> doc/inline-container }}{{else}}{{> doc/block }}{{/if}}
+{{/each}}
+{{/each}}
+
diff --git a/share/mrdocs/addons/generator/adoc/partials/doc/block/paragraph.adoc.hbs b/share/mrdocs/addons/generator/adoc/partials/doc/block/paragraph.adoc.hbs
new file mode 100644
index 000000000..01389db3b
--- /dev/null
+++ b/share/mrdocs/addons/generator/adoc/partials/doc/block/paragraph.adoc.hbs
@@ -0,0 +1,3 @@
+{{> doc/inline-container }}
+
+
diff --git a/share/mrdocs/addons/generator/adoc/partials/javadoc/admonition.adoc.hbs b/share/mrdocs/addons/generator/adoc/partials/javadoc/admonition.adoc.hbs
deleted file mode 100644
index 9e105d399..000000000
--- a/share/mrdocs/addons/generator/adoc/partials/javadoc/admonition.adoc.hbs
+++ /dev/null
@@ -1,3 +0,0 @@
-[{{upper admonish}}]
-{{#each children}}{{> javadoc/any-text }}{{/each}}
-
diff --git a/share/mrdocs/addons/generator/adoc/partials/javadoc/brief.adoc.hbs b/share/mrdocs/addons/generator/adoc/partials/javadoc/brief.adoc.hbs
deleted file mode 100644
index b43fc7676..000000000
--- a/share/mrdocs/addons/generator/adoc/partials/javadoc/brief.adoc.hbs
+++ /dev/null
@@ -1,3 +0,0 @@
-{{>javadoc/inline-brief}}
-
-
diff --git a/share/mrdocs/addons/generator/adoc/partials/javadoc/code.adoc.hbs b/share/mrdocs/addons/generator/adoc/partials/javadoc/code.adoc.hbs
deleted file mode 100644
index 6cfe4e5e8..000000000
--- a/share/mrdocs/addons/generator/adoc/partials/javadoc/code.adoc.hbs
+++ /dev/null
@@ -1,5 +0,0 @@
-[,cpp]
-----
-{{#each children}}{{> javadoc/any-text verbatim=true }}
-{{/each}}
-----
diff --git a/share/mrdocs/addons/generator/adoc/partials/javadoc/description.adoc.hbs b/share/mrdocs/addons/generator/adoc/partials/javadoc/description.adoc.hbs
deleted file mode 100644
index 63e7695e6..000000000
--- a/share/mrdocs/addons/generator/adoc/partials/javadoc/description.adoc.hbs
+++ /dev/null
@@ -1 +0,0 @@
-{{#each .}}{{>javadoc/any-block .}}{{/each}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/adoc/partials/javadoc/heading.adoc.hbs b/share/mrdocs/addons/generator/adoc/partials/javadoc/heading.adoc.hbs
deleted file mode 100644
index 4c699e751..000000000
--- a/share/mrdocs/addons/generator/adoc/partials/javadoc/heading.adoc.hbs
+++ /dev/null
@@ -1 +0,0 @@
-{{#> markup/dynamic-level-h level=1 }}{{string}}{{/markup/dynamic-level-h}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/adoc/partials/javadoc/paragraph.adoc.hbs b/share/mrdocs/addons/generator/adoc/partials/javadoc/paragraph.adoc.hbs
deleted file mode 100644
index 9b14154cc..000000000
--- a/share/mrdocs/addons/generator/adoc/partials/javadoc/paragraph.adoc.hbs
+++ /dev/null
@@ -1,2 +0,0 @@
-{{#each children}}{{> javadoc/any-text }}{{/each}}
-
diff --git a/share/mrdocs/addons/generator/adoc/partials/javadoc/unordered_list.adoc.hbs b/share/mrdocs/addons/generator/adoc/partials/javadoc/unordered_list.adoc.hbs
deleted file mode 100644
index f83265378..000000000
--- a/share/mrdocs/addons/generator/adoc/partials/javadoc/unordered_list.adoc.hbs
+++ /dev/null
@@ -1,3 +0,0 @@
-{{#each items}}* {{> javadoc/block }}
-{{/each}}
-
diff --git a/share/mrdocs/addons/generator/adoc/partials/markup/h.adoc.hbs b/share/mrdocs/addons/generator/adoc/partials/markup/h.adoc.hbs
index d8959caaf..d8deae259 100644
--- a/share/mrdocs/addons/generator/adoc/partials/markup/h.adoc.hbs
+++ b/share/mrdocs/addons/generator/adoc/partials/markup/h.adoc.hbs
@@ -17,3 +17,4 @@
 {{#if id}}[#{{{id}}}]
 {{/if}}
 ={{{select level (repeat "=" level) (select @root.config.multipage "==" "=")}}} {{> @partial-block }}
+
diff --git a/share/mrdocs/addons/generator/adoc/partials/symbol.adoc.hbs b/share/mrdocs/addons/generator/adoc/partials/symbol.adoc.hbs
index 3cf382e49..bc35cf07a 100644
--- a/share/mrdocs/addons/generator/adoc/partials/symbol.adoc.hbs
+++ b/share/mrdocs/addons/generator/adoc/partials/symbol.adoc.hbs
@@ -15,14 +15,14 @@
 {{! Single page documentation: symbol is not available to the wrapper but it's available here }}
 {{! Include the symbol title at a higher level }}
 {{#> markup/h level=1 id=symbol.anchor }}{{> symbol/qualified-name-title symbol }}{{/markup/h}}
-{{/unless}}
+{{~/unless}}
 {{! Brief }}
 {{#if symbol.doc.brief}}
-{{> javadoc/brief symbol.doc.brief }}
+{{> doc/block/brief symbol.doc.brief }}
 {{/if}}
 {{! Synopsis }}
 {{#unless (eq symbol.kind "namespace")}}
-{{#> markup/dynamic-level-h }}{{#if (ne symbol.kind "overloads")}}Synopsis{{else}}Synopses{{/if}}{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h }}{{#if (ne symbol.kind "overloads")}}Synopsis{{else}}Synopses{{/if}}{{/markup/dynamic-level-h~}}
 {{>location/source dcl=(primary_location symbol)}}
 
 
@@ -30,28 +30,28 @@
 {{/unless}}
 {{! Base classes }}
 {{#if (any_of_by symbol.bases "isPublic")}}
-{{#> markup/dynamic-level-h }}Base Classes{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h }}Base Classes{{/markup/dynamic-level-h~}}
 [cols=2]
 |===
 | Name
 | Description
 {{#each (filter_by symbol.bases "isPublic")}}
 | {{#>markup/code}}{{> type/declarator type }}{{/markup/code}}
-| {{> javadoc/inline-brief type.name.symbol.doc.brief }}
+| {{> doc/block/inline-brief type.name.symbol.doc.brief }}
 {{/each}}
 |===
 
 {{/if}}
 {{! Protected Base classes }}
 {{#if (any_of_by symbol.bases "isProtected")}}
-{{#> markup/dynamic-level-h }}Protected Base Classes{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h }}Protected Base Classes{{/markup/dynamic-level-h~}}
 [cols=2]
 |===
 | Name
 | Description
 {{#each (filter_by symbol.bases "isProtected")}}
 | {{#>markup/code}}{{> type/declarator type }}{{/markup/code}}
-| {{> javadoc/inline-brief type.name.symbol.doc.brief }}
+| {{> doc/block/inline-brief type.name.symbol.doc.brief }}
 {{/each}}
 |===
 
@@ -73,7 +73,7 @@
 {{/if}}
 {{! Friends }}
 {{#if symbol.friends}}
-{{#> markup/dynamic-level-h }}Friends{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h }}Friends{{/markup/dynamic-level-h~}}
 [cols=2]
 |===
 | Name
@@ -81,7 +81,7 @@
 {{#each symbol.friends }}
 {{#if symbol}}
 | {{#>markup/code}}{{> symbol/qualified-name symbol }}{{/markup/code}}
-| {{> javadoc/inline-brief symbol.doc.brief }}
+| {{> doc/block/inline-brief symbol.doc.brief }}
 {{else}}
 | {{#>markup/code}}{{> type/declarator type }}{{/markup/code}}
 |
@@ -97,21 +97,21 @@
 {{/if}}
 {{! Related symbols }}
 {{#if symbol.doc.related}}
-{{#> markup/dynamic-level-h }}Non-Member Functions{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h }}Non-Member Functions{{/markup/dynamic-level-h~}}
 [cols=2]
 |===
 | Name
 | Description
 {{#each symbol.doc.related}}
-| {{> javadoc/reference }}
-| {{> javadoc/inline-brief symbol.doc.brief }}
+| {{> doc/inline/reference }}
+| {{> doc/block/inline-brief symbol.doc.brief }}
 {{/each}}
 |===
 
 {{/if}}
 {{! Derived classes }}
 {{#if symbol.derived}}
-{{#> markup/dynamic-level-h }}Derived Classes{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h }}Derived Classes{{/markup/dynamic-level-h~}}
 [cols=2]
 |===
 | Name
@@ -122,7 +122,7 @@
 {{else~}}
 {{> type/name-info-text . }}
 {{/if}}
-| {{> javadoc/inline-brief doc.brief }}
+| {{> doc/block/inline-brief doc.brief }}
 {{/each}}
 |===
 
@@ -130,13 +130,15 @@
 {{! Description }}
 {{#if symbol.doc.description}}
 {{#unless traversing-global-namespace}}
-{{#> markup/dynamic-level-h }}Description{{/markup/dynamic-level-h}}
-{{> javadoc/description symbol.doc.description }}
+{{#unless (eq (lookup (first symbol.doc.description) "kind") "heading") }}
+{{#> markup/dynamic-level-h }}Description{{/markup/dynamic-level-h~}}
+{{~/unless}}
+{{> doc/block/document symbol.doc.description }}
 {{/unless}}
 {{/if}}
 {{! Using symbols }}
 {{#if symbol.shadows}}
-{{#> markup/dynamic-level-h }}Introduced Symbols{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h }}Introduced Symbols{{/markup/dynamic-level-h~}}
 {{#if (any_of_by symbol.shadows "doc")}}
 [cols=2]
 |===
@@ -144,7 +146,7 @@
 | Description
 {{#each symbol.shadows}}
 | {{> symbol/qualified-name . }}
-| {{> javadoc/inline-brief doc.brief }}
+| {{> doc/block/inline-brief doc.brief }}
 {{/each}}
 |===
 {{else}}
@@ -159,86 +161,86 @@
 {{/if}}
 {{! Exceptions }}
 {{#if symbol.doc.exceptions}}
-{{#> markup/dynamic-level-h }}Exceptions{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h }}Exceptions{{/markup/dynamic-level-h~}}
 [cols=2]
 |===
 | Name
 | Thrown on
 {{#each symbol.doc.exceptions}}
-| {{> javadoc/reference exception}}
-| {{>javadoc/block .}}
+| {{> doc/inline/reference exception}}
+| {{>doc/block .}}
 {{/each}}
 |===
 
 {{/if}}
 {{! Return value }}
 {{#if symbol.doc.returns}}
-{{#> markup/dynamic-level-h }}Return Value{{/markup/dynamic-level-h}}
-{{#if (eq (size symbol.doc.returns) 1)}}
-{{> javadoc/returns symbol.doc.returns.[0]}}
+{{#> markup/dynamic-level-h }}Return Value{{/markup/dynamic-level-h~}}
+{{~#if (eq (size symbol.doc.returns) 1)}}
+{{> doc/block/returns symbol.doc.returns.[0]}}
 
 
 {{else}}
 {{#each symbol.doc.returns}}
-* {{> javadoc/returns .}}
+* {{> doc/block/returns .}}
 {{/each}}
 
 {{/if}}
 {{/if}}
 {{! Template Parameters }}
 {{#if symbol.doc.tparams}}
-{{#> markup/dynamic-level-h }}Template Parameters{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h }}Template Parameters{{/markup/dynamic-level-h~}}
 [cols=2]
 |===
 | Name
 | Description
 {{#each symbol.doc.tparams}}
 | *{{name}}*
-| {{>javadoc/block .}}
+| {{>doc/block .}}
 {{/each}}
 |===
 
 {{/if}}
 {{! Parameters }}
 {{#if symbol.doc.params}}
-{{#> markup/dynamic-level-h }}Parameters{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h }}Parameters{{/markup/dynamic-level-h~}}
 [cols=2]
 |===
 | Name
 | Description
 {{#each symbol.doc.params}}
 | *{{name}}*{{#if direction}} [{{direction}}]{{/if}}
-| {{>javadoc/block .}}
+| {{>doc/block .}}
 {{/each}}
 |===
 
 {{/if}}
 {{! Preconditions }}
 {{#if symbol.doc.preconditions}}
-{{#> markup/dynamic-level-h }}Preconditions{{/markup/dynamic-level-h}}
-{{#each symbol.doc.preconditions}}* {{>javadoc/block .}}
+{{#> markup/dynamic-level-h }}Preconditions{{/markup/dynamic-level-h~}}
+{{#each symbol.doc.preconditions}}* {{>doc/block .}}
 {{/each}}
 
 {{/if}}
 {{! Postconditions }}
 {{#if symbol.doc.postconditions}}
-{{#> markup/dynamic-level-h }}Postconditions{{/markup/dynamic-level-h}}
-{{#each symbol.doc.postconditions}}* {{>javadoc/block .}}
+{{#> markup/dynamic-level-h }}Postconditions{{/markup/dynamic-level-h~}}
+{{#each symbol.doc.postconditions}}* {{>doc/block .}}
 {{/each}}
 
 {{/if}}
 {{! See Also }}
 {{#if symbol.doc.sees}}
-{{#> markup/dynamic-level-h }}See Also{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h }}See Also{{/markup/dynamic-level-h~}}
 {{#each symbol.doc.sees}}
-{{>javadoc/see .}}
+{{>doc/block/see .}}
 {{/each}}
 {{/if}}
 {{! Recursive index for multipage global namespace }}
 {{#if (and (eq symbol.kind "namespace") @root.config.multipage @root.config.global-namespace-index (eq @root.symbol.kind "namespace") (not @root.symbol.name) (not @root.symbol.parent)) }}
 {{#each symbol.members.namespaces}}
 {{#if isRegular}}
-{{#> markup/dynamic-level-h id=null }}{{> symbol/qualified-name . }} namespace{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h id=null }}{{> symbol/qualified-name . }} namespace{{/markup/dynamic-level-h~}}
 {{> symbol symbol=. id=null traversing-global-namespace=true }}
 {{/if}}
 {{/each}}
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block-container.hbs b/share/mrdocs/addons/generator/common/partials/doc/block-container.hbs
new file mode 100644
index 000000000..701bb129f
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block-container.hbs
@@ -0,0 +1 @@
+{{#each blocks}}{{>doc/block }}{{/each}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block.hbs b/share/mrdocs/addons/generator/common/partials/doc/block.hbs
new file mode 100644
index 000000000..3212a9bfc
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block.hbs
@@ -0,0 +1 @@
+{{> (concat 'doc/block/' kind) }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/admonition.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/admonition.hbs
new file mode 100644
index 000000000..766efa7e4
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/admonition.hbs
@@ -0,0 +1 @@
+{{> doc/block-container }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/brief.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/brief.hbs
new file mode 100644
index 000000000..6391a4959
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/brief.hbs
@@ -0,0 +1 @@
+{{#> markup/p }}{{> doc/inline-container }}{{/ markup/p }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/code.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/code.hbs
new file mode 100644
index 000000000..138367f69
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/code.hbs
@@ -0,0 +1 @@
+{{ literal }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/definition-list.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/definition-list.hbs
new file mode 100644
index 000000000..b1d95fd42
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/definition-list.hbs
@@ -0,0 +1 @@
+{{> doc/inline-container }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/document.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/document.hbs
new file mode 100644
index 000000000..cfb8830df
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/document.hbs
@@ -0,0 +1 @@
+{{#each .}}{{>doc/block .}}{{/each}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/footnote-definition.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/footnote-definition.hbs
new file mode 100644
index 000000000..b1d95fd42
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/footnote-definition.hbs
@@ -0,0 +1 @@
+{{> doc/inline-container }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/heading.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/heading.hbs
new file mode 100644
index 000000000..122093cb7
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/heading.hbs
@@ -0,0 +1 @@
+{{#> markup/dynamic-level-h level=(or level 1) }}{{> doc/inline-container }}{{/markup/dynamic-level-h}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/inline-brief.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/inline-brief.hbs
new file mode 100644
index 000000000..844b1debf
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/inline-brief.hbs
@@ -0,0 +1,4 @@
+{{! This partial is used to render the brief description of a Java element in an inline context,
+    such as within a sentence, a short paragraph or a table of member symbols.
+    It includes the inline-container partial to handle the actual rendering of the brief description. }}
+{{> doc/inline-container }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/list.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/list.hbs
new file mode 100644
index 000000000..8829fa1f4
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/list.hbs
@@ -0,0 +1,2 @@
+{{#each items}}* {{> doc/block }}
+{{/each}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/math.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/math.hbs
new file mode 100644
index 000000000..b1d95fd42
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/math.hbs
@@ -0,0 +1 @@
+{{> doc/inline-container }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/paragraph.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/paragraph.hbs
new file mode 100644
index 000000000..b1d95fd42
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/paragraph.hbs
@@ -0,0 +1 @@
+{{> doc/inline-container }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/param.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/param.hbs
new file mode 100644
index 000000000..b1d95fd42
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/param.hbs
@@ -0,0 +1 @@
+{{> doc/inline-container }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/postcondition.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/postcondition.hbs
new file mode 100644
index 000000000..b1d95fd42
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/postcondition.hbs
@@ -0,0 +1 @@
+{{> doc/inline-container }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/precondition.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/precondition.hbs
new file mode 100644
index 000000000..b1d95fd42
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/precondition.hbs
@@ -0,0 +1 @@
+{{> doc/inline-container }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/quote.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/quote.hbs
new file mode 100644
index 000000000..b1d95fd42
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/quote.hbs
@@ -0,0 +1 @@
+{{> doc/inline-container }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/returns.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/returns.hbs
new file mode 100644
index 000000000..b1d95fd42
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/returns.hbs
@@ -0,0 +1 @@
+{{> doc/inline-container }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/see.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/see.hbs
new file mode 100644
index 000000000..4f1052434
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/see.hbs
@@ -0,0 +1 @@
+{{> doc/block/paragraph }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/t-param.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/t-param.hbs
new file mode 100644
index 000000000..b1d95fd42
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/t-param.hbs
@@ -0,0 +1 @@
+{{> doc/inline-container }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/table.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/table.hbs
new file mode 100644
index 000000000..b1d95fd42
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/table.hbs
@@ -0,0 +1 @@
+{{> doc/inline-container }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/thematic-break.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/thematic-break.hbs
new file mode 100644
index 000000000..b1d95fd42
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/thematic-break.hbs
@@ -0,0 +1 @@
+{{> doc/inline-container }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/block/throws.hbs b/share/mrdocs/addons/generator/common/partials/doc/block/throws.hbs
new file mode 100644
index 000000000..b1d95fd42
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/block/throws.hbs
@@ -0,0 +1 @@
+{{> doc/inline-container }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/inline-container.hbs b/share/mrdocs/addons/generator/common/partials/doc/inline-container.hbs
new file mode 100644
index 000000000..63ebbed3f
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/inline-container.hbs
@@ -0,0 +1 @@
+{{#each children}}{{> doc/inline }}{{/each}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/inline.hbs b/share/mrdocs/addons/generator/common/partials/doc/inline.hbs
new file mode 100644
index 000000000..2850b0bf9
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/inline.hbs
@@ -0,0 +1 @@
+{{> (concat 'doc/inline/' kind) }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/inline/code.hbs b/share/mrdocs/addons/generator/common/partials/doc/inline/code.hbs
new file mode 100644
index 000000000..fd8549c7c
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/inline/code.hbs
@@ -0,0 +1 @@
+{{#> markup/code }}{{> doc/inline-container }}{{/ markup/code }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/inline/emph.hbs b/share/mrdocs/addons/generator/common/partials/doc/inline/emph.hbs
new file mode 100644
index 000000000..2bd7f82f1
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/inline/emph.hbs
@@ -0,0 +1 @@
+{{#> markup/i }}{{> doc/inline-container }}{{/ markup/i }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/inline/footnote-reference.hbs b/share/mrdocs/addons/generator/common/partials/doc/inline/footnote-reference.hbs
new file mode 100644
index 000000000..31a6db315
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/inline/footnote-reference.hbs
@@ -0,0 +1 @@
+{{#> markup/i }}{{literal}}{{/ markup/i }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/inline/highlight.hbs b/share/mrdocs/addons/generator/common/partials/doc/inline/highlight.hbs
new file mode 100644
index 000000000..2bd7f82f1
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/inline/highlight.hbs
@@ -0,0 +1 @@
+{{#> markup/i }}{{> doc/inline-container }}{{/ markup/i }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/inline/image.hbs b/share/mrdocs/addons/generator/common/partials/doc/inline/image.hbs
new file mode 100644
index 000000000..2bd7f82f1
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/inline/image.hbs
@@ -0,0 +1 @@
+{{#> markup/i }}{{> doc/inline-container }}{{/ markup/i }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/inline/line-break.hbs b/share/mrdocs/addons/generator/common/partials/doc/inline/line-break.hbs
new file mode 100644
index 000000000..e69de29bb
diff --git a/share/mrdocs/addons/generator/common/partials/doc/inline/link.hbs b/share/mrdocs/addons/generator/common/partials/doc/inline/link.hbs
new file mode 100644
index 000000000..ab8706785
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/inline/link.hbs
@@ -0,0 +1 @@
+{{#>markup/a href=href}}{{> doc/inline-container }}{{/markup/a}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/inline/math.hbs b/share/mrdocs/addons/generator/common/partials/doc/inline/math.hbs
new file mode 100644
index 000000000..31a6db315
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/inline/math.hbs
@@ -0,0 +1 @@
+{{#> markup/i }}{{literal}}{{/ markup/i }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/inline/reference.hbs b/share/mrdocs/addons/generator/common/partials/doc/inline/reference.hbs
new file mode 100644
index 000000000..942630119
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/inline/reference.hbs
@@ -0,0 +1,5 @@
+{{#if symbol.url~}}
+{{#>markup/a href=symbol.url}}{{#>markup/code}}{{ literal }}{{/markup/code}}{{/markup/a}}
+{{~else~}}
+{{#>markup/code}}{{ literal }}{{/markup/code}}
+{{~/if}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/inline/soft-break.hbs b/share/mrdocs/addons/generator/common/partials/doc/inline/soft-break.hbs
new file mode 100644
index 000000000..e69de29bb
diff --git a/share/mrdocs/addons/generator/common/partials/doc/inline/strikethrough.hbs b/share/mrdocs/addons/generator/common/partials/doc/inline/strikethrough.hbs
new file mode 100644
index 000000000..2bd7f82f1
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/inline/strikethrough.hbs
@@ -0,0 +1 @@
+{{#> markup/i }}{{> doc/inline-container }}{{/ markup/i }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/inline/strong.hbs b/share/mrdocs/addons/generator/common/partials/doc/inline/strong.hbs
new file mode 100644
index 000000000..ef363be65
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/inline/strong.hbs
@@ -0,0 +1 @@
+{{#> markup/b }}{{> doc/inline-container }}{{/ markup/b }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/inline/subscript.hbs b/share/mrdocs/addons/generator/common/partials/doc/inline/subscript.hbs
new file mode 100644
index 000000000..2bd7f82f1
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/inline/subscript.hbs
@@ -0,0 +1 @@
+{{#> markup/i }}{{> doc/inline-container }}{{/ markup/i }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/inline/superscript.hbs b/share/mrdocs/addons/generator/common/partials/doc/inline/superscript.hbs
new file mode 100644
index 000000000..2bd7f82f1
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/inline/superscript.hbs
@@ -0,0 +1 @@
+{{#> markup/i }}{{> doc/inline-container }}{{/ markup/i }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/doc/inline/text.hbs b/share/mrdocs/addons/generator/common/partials/doc/inline/text.hbs
new file mode 100644
index 000000000..4ee9c5180
--- /dev/null
+++ b/share/mrdocs/addons/generator/common/partials/doc/inline/text.hbs
@@ -0,0 +1 @@
+{{literal}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/javadoc/any-block.hbs b/share/mrdocs/addons/generator/common/partials/javadoc/any-block.hbs
deleted file mode 100644
index e232ea71d..000000000
--- a/share/mrdocs/addons/generator/common/partials/javadoc/any-block.hbs
+++ /dev/null
@@ -1 +0,0 @@
-{{> (concat 'javadoc/' kind) }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/javadoc/any-text.hbs b/share/mrdocs/addons/generator/common/partials/javadoc/any-text.hbs
deleted file mode 100644
index e232ea71d..000000000
--- a/share/mrdocs/addons/generator/common/partials/javadoc/any-text.hbs
+++ /dev/null
@@ -1 +0,0 @@
-{{> (concat 'javadoc/' kind) }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/javadoc/block.hbs b/share/mrdocs/addons/generator/common/partials/javadoc/block.hbs
deleted file mode 100644
index 0475cb215..000000000
--- a/share/mrdocs/addons/generator/common/partials/javadoc/block.hbs
+++ /dev/null
@@ -1 +0,0 @@
-{{#>markup/span class=undefined}}{{#each children}}{{>javadoc/any-text }}{{/each}}{{/markup/span}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/javadoc/brief.hbs b/share/mrdocs/addons/generator/common/partials/javadoc/brief.hbs
deleted file mode 100644
index d19c8494c..000000000
--- a/share/mrdocs/addons/generator/common/partials/javadoc/brief.hbs
+++ /dev/null
@@ -1 +0,0 @@
-{{>javadoc/block}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/javadoc/inline-brief.hbs b/share/mrdocs/addons/generator/common/partials/javadoc/inline-brief.hbs
deleted file mode 100644
index d19c8494c..000000000
--- a/share/mrdocs/addons/generator/common/partials/javadoc/inline-brief.hbs
+++ /dev/null
@@ -1 +0,0 @@
-{{>javadoc/block}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/javadoc/link.hbs b/share/mrdocs/addons/generator/common/partials/javadoc/link.hbs
deleted file mode 100644
index f4fb3636c..000000000
--- a/share/mrdocs/addons/generator/common/partials/javadoc/link.hbs
+++ /dev/null
@@ -1 +0,0 @@
-{{#>markup/a href=href}}{{> javadoc/block }}{{/markup/a}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/javadoc/reference.hbs b/share/mrdocs/addons/generator/common/partials/javadoc/reference.hbs
deleted file mode 100644
index e1d877236..000000000
--- a/share/mrdocs/addons/generator/common/partials/javadoc/reference.hbs
+++ /dev/null
@@ -1,5 +0,0 @@
-{{#if symbol.url~}}
-{{#>markup/a href=symbol.url}}{{#>markup/code}}{{string}}{{/markup/code}}{{/markup/a}}
-{{~else~}}
-{{#>markup/code}}{{string}}{{/markup/code}}
-{{~/if}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/javadoc/returns.hbs b/share/mrdocs/addons/generator/common/partials/javadoc/returns.hbs
deleted file mode 100644
index d19c8494c..000000000
--- a/share/mrdocs/addons/generator/common/partials/javadoc/returns.hbs
+++ /dev/null
@@ -1 +0,0 @@
-{{>javadoc/block}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/javadoc/see.hbs b/share/mrdocs/addons/generator/common/partials/javadoc/see.hbs
deleted file mode 100644
index c15e96828..000000000
--- a/share/mrdocs/addons/generator/common/partials/javadoc/see.hbs
+++ /dev/null
@@ -1 +0,0 @@
-{{>javadoc/paragraph}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/javadoc/styled.hbs b/share/mrdocs/addons/generator/common/partials/javadoc/styled.hbs
deleted file mode 100644
index 1a11bfe15..000000000
--- a/share/mrdocs/addons/generator/common/partials/javadoc/styled.hbs
+++ /dev/null
@@ -1 +0,0 @@
-{{> (concat 'javadoc/styled/' style) }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/javadoc/styled/bold.hbs b/share/mrdocs/addons/generator/common/partials/javadoc/styled/bold.hbs
deleted file mode 100644
index 2e32e2505..000000000
--- a/share/mrdocs/addons/generator/common/partials/javadoc/styled/bold.hbs
+++ /dev/null
@@ -1 +0,0 @@
-{{#> markup/b }}{{string}}{{/ markup/b }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/javadoc/styled/italic.hbs b/share/mrdocs/addons/generator/common/partials/javadoc/styled/italic.hbs
deleted file mode 100644
index 63f67e78e..000000000
--- a/share/mrdocs/addons/generator/common/partials/javadoc/styled/italic.hbs
+++ /dev/null
@@ -1 +0,0 @@
-{{#> markup/i }}{{string}}{{/ markup/i }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/javadoc/styled/mono.hbs b/share/mrdocs/addons/generator/common/partials/javadoc/styled/mono.hbs
deleted file mode 100644
index 291958e65..000000000
--- a/share/mrdocs/addons/generator/common/partials/javadoc/styled/mono.hbs
+++ /dev/null
@@ -1 +0,0 @@
-{{#> markup/code }}{{string}}{{/ markup/code }}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/javadoc/text.hbs b/share/mrdocs/addons/generator/common/partials/javadoc/text.hbs
deleted file mode 100644
index c6019f9fa..000000000
--- a/share/mrdocs/addons/generator/common/partials/javadoc/text.hbs
+++ /dev/null
@@ -1 +0,0 @@
-{{#unless verbatim}}{{string}}{{else}}{{{string}}}{{/unless}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/markup/dynamic-level-h.hbs b/share/mrdocs/addons/generator/common/partials/markup/dynamic-level-h.hbs
index fce6d34e3..ce78690c4 100644
--- a/share/mrdocs/addons/generator/common/partials/markup/dynamic-level-h.hbs
+++ b/share/mrdocs/addons/generator/common/partials/markup/dynamic-level-h.hbs
@@ -19,7 +19,7 @@
     See: https://mrdocs.com/docs/mrdocs/develop/generators.html#dom_reference
 --}}
 {{#> markup/h
-    level=(select @root.config.multipage (or level 1) (add (or level 1) 1))
+    level=(add (or level 1) (select @root.config.multipage 0 1))
     id=id
 }}
 {{> @partial-block }}
diff --git a/share/mrdocs/addons/generator/common/partials/symbol/detail/members-table-row.hbs b/share/mrdocs/addons/generator/common/partials/symbol/detail/members-table-row.hbs
index 52fb4bd6e..568f395a3 100644
--- a/share/mrdocs/addons/generator/common/partials/symbol/detail/members-table-row.hbs
+++ b/share/mrdocs/addons/generator/common/partials/symbol/detail/members-table-row.hbs
@@ -15,7 +15,7 @@
 {{~/markup/td}}
 {{#if includeBrief~}}
 {{~#>markup/td~}}
-{{~> javadoc/inline-brief doc.brief~}}
+{{~> doc/block/inline-brief doc.brief~}}
 {{~/markup/td}}
 {{/if}}
 {{/markup/tr}}
diff --git a/share/mrdocs/addons/generator/common/partials/symbol/members-table.hbs b/share/mrdocs/addons/generator/common/partials/symbol/members-table.hbs
index d01982328..daa5418c0 100644
--- a/share/mrdocs/addons/generator/common/partials/symbol/members-table.hbs
+++ b/share/mrdocs/addons/generator/common/partials/symbol/members-table.hbs
@@ -17,7 +17,7 @@
 {{#if members}}
 {{#if (or (eq members[0].class "name") (any_of_by members "isRegular" "isSeeBelow"))}}
 {{#>markup/h level=(select @root.config.multipage (select traversing-global-namespace 2 1) 2)}}{{title}}{{/markup/h}}
-{{>symbol/detail/members-table-impl members=members isName=(eq members[0].class "name") includeBrief=(select (any_of_by members "doc") true false) title=title}}
+{{~>symbol/detail/members-table-impl members=members isName=(eq members[0].class "name") includeBrief=(select (any_of_by members "doc.brief") true false) title=title}}
 
 {{/if}}
 {{/if}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/common/partials/symbol/signatures.hbs b/share/mrdocs/addons/generator/common/partials/symbol/signatures.hbs
index a75a16990..2f5a2cec5 100644
--- a/share/mrdocs/addons/generator/common/partials/symbol/signatures.hbs
+++ b/share/mrdocs/addons/generator/common/partials/symbol/signatures.hbs
@@ -18,7 +18,7 @@
 {{/markup/code-block}}
 {{else}}
 {{#each members as | member |}}
-{{#if member.doc.brief}}{{> javadoc/brief member.doc.brief }}{{/if}}
+{{#if member.doc.brief}}{{> doc/block/brief member.doc.brief }}{{/if}}
 {{#> markup/code-block }}
 {{> symbol/signature/function member force-link=true }}
 {{/markup/code-block}}
diff --git a/share/mrdocs/addons/generator/html/partials/javadoc/admonition.html.hbs b/share/mrdocs/addons/generator/html/partials/doc/block/admonition.html.hbs
similarity index 50%
rename from share/mrdocs/addons/generator/html/partials/javadoc/admonition.html.hbs
rename to share/mrdocs/addons/generator/html/partials/doc/block/admonition.html.hbs
index 92e022b0c..4f6bef73d 100644
--- a/share/mrdocs/addons/generator/html/partials/javadoc/admonition.html.hbs
+++ b/share/mrdocs/addons/generator/html/partials/doc/block/admonition.html.hbs
@@ -1,4 +1,5 @@
 <div class="admonition">
 <h4>{{upper admonish}}</h4>
-<p>{{#each children}}{{> javadoc/any-text }}{{/each}}</p>
+<div>
+{{> doc/block-container ~}}</div>
 </div>
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/html/partials/doc/block/code.html.hbs b/share/mrdocs/addons/generator/html/partials/doc/block/code.html.hbs
new file mode 100644
index 000000000..daabda628
--- /dev/null
+++ b/share/mrdocs/addons/generator/html/partials/doc/block/code.html.hbs
@@ -0,0 +1,3 @@
+<code class="language-{{ or info "cpp" }}">
+{{{ replace (replace (replace literal "&" "&amp;") ">" "&gt;") "<" "&lt;" }}}
+</code>
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/html/partials/doc/block/list.html.hbs b/share/mrdocs/addons/generator/html/partials/doc/block/list.html.hbs
new file mode 100644
index 000000000..6711340cb
--- /dev/null
+++ b/share/mrdocs/addons/generator/html/partials/doc/block/list.html.hbs
@@ -0,0 +1,4 @@
+<ul>
+{{#each items}}<li>{{#each blocks}}{{> doc/block }}{{/each}}</li>
+{{/each}}
+</ul>
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/html/partials/doc/block/paragraph.html.hbs b/share/mrdocs/addons/generator/html/partials/doc/block/paragraph.html.hbs
new file mode 100644
index 000000000..63e7cbbf7
--- /dev/null
+++ b/share/mrdocs/addons/generator/html/partials/doc/block/paragraph.html.hbs
@@ -0,0 +1 @@
+{{#>markup/p}}{{#each children}}{{> doc/inline }}{{/each}}{{/markup/p}}
diff --git a/share/mrdocs/addons/generator/html/partials/javadoc/code.html.hbs b/share/mrdocs/addons/generator/html/partials/javadoc/code.html.hbs
deleted file mode 100644
index 586376c5f..000000000
--- a/share/mrdocs/addons/generator/html/partials/javadoc/code.html.hbs
+++ /dev/null
@@ -1,4 +0,0 @@
-<code>
-{{#each children}}{{> javadoc/any-text verbatim=true }}
-{{/each}}
-</code>
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/html/partials/javadoc/description.html.hbs b/share/mrdocs/addons/generator/html/partials/javadoc/description.html.hbs
deleted file mode 100644
index 2ecb541c2..000000000
--- a/share/mrdocs/addons/generator/html/partials/javadoc/description.html.hbs
+++ /dev/null
@@ -1,2 +0,0 @@
-{{#each .}}{{>javadoc/any-block .}}
-{{/each}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/html/partials/javadoc/heading.html.hbs b/share/mrdocs/addons/generator/html/partials/javadoc/heading.html.hbs
deleted file mode 100644
index 075f69652..000000000
--- a/share/mrdocs/addons/generator/html/partials/javadoc/heading.html.hbs
+++ /dev/null
@@ -1 +0,0 @@
-<h3>{{string}}</h3>
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/html/partials/javadoc/paragraph.html.hbs b/share/mrdocs/addons/generator/html/partials/javadoc/paragraph.html.hbs
deleted file mode 100644
index 52e81cd45..000000000
--- a/share/mrdocs/addons/generator/html/partials/javadoc/paragraph.html.hbs
+++ /dev/null
@@ -1 +0,0 @@
-{{#>markup/p}}{{#each children}}{{> javadoc/any-text }}{{/each}}{{/markup/p}}
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/html/partials/javadoc/unordered_list.html.hbs b/share/mrdocs/addons/generator/html/partials/javadoc/unordered_list.html.hbs
deleted file mode 100644
index 20244bbe0..000000000
--- a/share/mrdocs/addons/generator/html/partials/javadoc/unordered_list.html.hbs
+++ /dev/null
@@ -1,4 +0,0 @@
-<ul>
-{{#each items}}<li>{{> javadoc/block }}</li>
-{{/each}}
-</ul>
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/html/partials/markup/code-block.html.hbs b/share/mrdocs/addons/generator/html/partials/markup/code-block.html.hbs
index d1dbe4e22..e1992ae29 100644
--- a/share/mrdocs/addons/generator/html/partials/markup/code-block.html.hbs
+++ b/share/mrdocs/addons/generator/html/partials/markup/code-block.html.hbs
@@ -1,5 +1,3 @@
 <pre>
-<code class="source-code cpp">{{> @partial-block }}
-
-</code>
+<code class="source-code cpp">{{> @partial-block }}</code>
 </pre>
\ No newline at end of file
diff --git a/share/mrdocs/addons/generator/html/partials/markup/h.html.hbs b/share/mrdocs/addons/generator/html/partials/markup/h.html.hbs
index 41f84c971..996a129cc 100644
--- a/share/mrdocs/addons/generator/html/partials/markup/h.html.hbs
+++ b/share/mrdocs/addons/generator/html/partials/markup/h.html.hbs
@@ -1 +1 @@
-<h{{or level 3}}{{#if class}} class="{{{class}}}"{{/if}}{{#if id}} id="{{{id}}}"{{/if}}>{{> @partial-block }}</h{{or level 3}}>
\ No newline at end of file
+<h{{or level 3}}{{#if class}} class="{{{class}}}"{{/if}}{{#if id}} id="{{{id}}}"{{/if}}>{{> @partial-block }}</h{{or level 3}}>
diff --git a/share/mrdocs/addons/generator/html/partials/symbol.html.hbs b/share/mrdocs/addons/generator/html/partials/symbol.html.hbs
index aea81542d..3f51a4f99 100644
--- a/share/mrdocs/addons/generator/html/partials/symbol.html.hbs
+++ b/share/mrdocs/addons/generator/html/partials/symbol.html.hbs
@@ -17,12 +17,11 @@
 <div>
 <div>
 {{#> markup/h level=2 id=symbol.anchor }}{{> symbol/qualified-name symbol }}{{/markup/h}}
-{{/unless}}
+{{~/unless}}
 {{! Brief }}
 {{#if symbol.doc.brief}}
 <div>
-{{> javadoc/brief symbol.doc.brief }}
-
+{{> doc/block/brief symbol.doc.brief }}
 
 </div>
 {{/if}}
@@ -32,7 +31,7 @@
 {{! Synopsis }}
 {{#unless (eq symbol.kind "namespace")}}
 <div>
-{{#> markup/dynamic-level-h level=2 }}{{#if (ne symbol.kind "overloads")}}Synopsis{{else}}Synopses{{/if}}{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h level=2 }}{{#if (ne symbol.kind "overloads")}}Synopsis{{else}}Synopses{{/if}}{{/markup/dynamic-level-h~}}
 <div>
 {{>location/source dcl=(primary_location symbol)}}
 </div>
@@ -43,7 +42,7 @@
 {{! Base classes }}
 {{#if (any_of_by symbol.bases "isPublic")}}
 <div>
-{{#> markup/dynamic-level-h }}Base Classes{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h }}Base Classes{{/markup/dynamic-level-h~}}
 <table>
 <thead>
 <tr>
@@ -53,7 +52,7 @@
 </thead>
 <tbody>
 {{#each (filter_by symbol.bases "isPublic")}}
-<tr><td>{{#>markup/code}}{{> type/declarator type }}{{/markup/code}}</td><td>{{> javadoc/inline-brief type.name.symbol.doc.brief }}</td></tr>
+<tr><td>{{#>markup/code}}{{> type/declarator type }}{{/markup/code}}</td><td>{{> doc/block/inline-brief type.name.symbol.doc.brief }}</td></tr>
 {{/each}}
 </tbody>
 </table>
@@ -62,7 +61,7 @@
 {{! Protected Base classes }}
 {{#if (any_of_by symbol.bases "isProtected")}}
 <div>
-{{#> markup/dynamic-level-h }}Protected Base Classes{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h }}Protected Base Classes{{/markup/dynamic-level-h~}}
 <table>
 <thead>
 <tr>
@@ -72,7 +71,7 @@
 </thead>
 <tbody>
 {{#each (filter_by symbol.bases "isProtected")}}
-<tr><td>{{#>markup/code}}{{> type/declarator type }}{{/markup/code}}</td><td>{{> javadoc/inline-brief type.name.symbol.doc.brief }}</td></tr>
+<tr><td>{{#>markup/code}}{{> type/declarator type }}{{/markup/code}}</td><td>{{> doc/block/inline-brief type.name.symbol.doc.brief }}</td></tr>
 {{/each}}
 </tbody>
 </table>
@@ -98,7 +97,7 @@
 {{! Friends }}
 {{#if symbol.friends}}
 <div>
-{{#> markup/dynamic-level-h }}Friends{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h }}Friends{{/markup/dynamic-level-h~}}
 <table>
 <thead>
 <tr>
@@ -111,7 +110,7 @@
 <tr>
 {{#if symbol}}
 <td>{{#>markup/code}}{{> symbol/name symbol }}{{/markup/code}}</td>
-<td>{{> javadoc/inline-brief symbol.doc.brief }}</td>
+<td>{{> doc/block/inline-brief symbol.doc.brief }}</td>
 {{else}}
 <td>{{#>markup/code}}{{> type/declarator type }}{{/markup/code}}</td>
 <td></td>
@@ -134,7 +133,7 @@
 {{! Related symbols }}
 {{#if symbol.doc.related}}
 <div>
-{{#> markup/dynamic-level-h }}Non-Member Functions{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h }}Non-Member Functions{{/markup/dynamic-level-h~}}
 <table>
 <thead>
 <tr>
@@ -144,7 +143,7 @@
 </thead>
 <tbody>
 {{#each symbol.doc.related}}
-<tr><td>{{> javadoc/reference }}</td><td>{{> javadoc/inline-brief symbol.doc.brief }}</td></tr>
+<tr><td>{{> doc/inline/reference }}</td><td>{{> doc/block/inline-brief symbol.doc.brief }}</td></tr>
 {{/each}}
 </tbody>
 </table>
@@ -153,7 +152,7 @@
 {{! Derived classes }}
 {{#if symbol.derived}}
 <div>
-{{#> markup/dynamic-level-h }}Derived Classes{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h }}Derived Classes{{/markup/dynamic-level-h~}}
 <table>
 <thead>
 <tr>
@@ -167,7 +166,7 @@
     {{#>markup/a href=url}}{{#>markup/code}}{{> type/name-info-text . }}{{/markup/code}}{{/markup/a}}
     {{else~}}
     {{> type/name-info-text . }}
-{{/if}}</td><td>{{> javadoc/inline-brief doc.brief }}</td></tr>
+{{/if}}</td><td>{{> doc/block/inline-brief doc.brief }}</td></tr>
 {{/each}}
 </tbody>
 </table>
@@ -177,15 +176,17 @@
 {{#if symbol.doc.description}}
 {{#unless traversing-global-namespace}}
 <div>
-{{#> markup/dynamic-level-h level=2 }}Description{{/markup/dynamic-level-h}}
-{{> javadoc/description symbol.doc.description }}
+{{#unless (eq (lookup (first symbol.doc.description) "kind") "heading") }}
+{{#> markup/dynamic-level-h level=2 }}Description{{/markup/dynamic-level-h~}}
+{{~/unless}}
+{{> doc/block/document symbol.doc.description }}
 </div>
 {{/unless}}
 {{/if}}
 {{! Using symbols }}
 {{#if symbol.shadows}}
 <div>
-{{#> markup/dynamic-level-h level=2 }}Introduced Symbols{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h level=2 }}Introduced Symbols{{/markup/dynamic-level-h~}}
 {{#if (any_of_by symbol.shadows "doc")}}
 <table>
 <thead>
@@ -198,7 +199,7 @@
 {{#each symbol.shadows}}
 <tr>
 <td>{{> symbol/qualified-name . }}</td>
-<td>{{> javadoc/inline-brief doc.brief }}</td>
+<td>{{> doc/block/inline-brief doc.brief }}</td>
 </tr>
 {{/each}}
 </tbody>
@@ -225,7 +226,7 @@
 {{! Exceptions }}
 {{#if symbol.doc.exceptions}}
 <div>
-{{#> markup/dynamic-level-h level=2 }}Exceptions{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h level=2 }}Exceptions{{/markup/dynamic-level-h~}}
 <table>
 <thead>
 <tr>
@@ -236,8 +237,8 @@
 <tbody>
 {{#each symbol.doc.exceptions}}
 <tr>
-<td>{{> javadoc/reference exception}}</td>
-<td>{{> javadoc/block .}}</td>
+<td>{{> doc/inline/reference exception}}</td>
+<td>{{> doc/block .}}</td>
 </tr>
 {{/each}}
 </tbody>
@@ -247,14 +248,14 @@
 {{! Return value }}
 {{#if symbol.doc.returns}}
 <div>
-{{#> markup/dynamic-level-h level=2 }}Return Value{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h level=2 }}Return Value{{/markup/dynamic-level-h~}}
 {{#if (eq (size symbol.doc.returns) 1)}}
-{{> javadoc/returns symbol.doc.returns.[0]}}
+{{> doc/block/returns symbol.doc.returns.[0]}}
 
 {{else}}
 <ul>
 {{#each symbol.doc.returns}}
-<li>{{> javadoc/returns .}}</li>
+<li>{{> doc/block/returns .}}</li>
 {{/each}}
 </ul>
 {{/if}}
@@ -263,7 +264,7 @@
 {{! Template Parameters }}
 {{#if symbol.doc.tparams}}
 <div>
-{{#> markup/dynamic-level-h level=2 }}Template Parameters{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h level=2 }}Template Parameters{{/markup/dynamic-level-h~}}
 <table>
 <thead>
 <tr>
@@ -275,7 +276,7 @@
 {{#each symbol.doc.tparams}}
 <tr>
 <td><strong>{{name}}</strong></td>
-<td>{{>javadoc/block .}}</td>
+<td>{{>doc/block .}}</td>
 </tr>
 {{/each}}
 </tbody>
@@ -285,7 +286,7 @@
 {{! Parameters }}
 {{#if symbol.doc.params}}
 <div>
-{{#> markup/dynamic-level-h level=2 }}Parameters{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h level=2 }}Parameters{{/markup/dynamic-level-h~}}
 <table>
 <thead>
 <tr>
@@ -297,7 +298,7 @@
 {{#each symbol.doc.params}}
 <tr>
 <td><strong>{{name}}</strong>{{#if direction}} [{{direction}}]{{/if}}</td>
-<td>{{>javadoc/block .}}</td>
+<td>{{>doc/block .}}</td>
 </tr>
 {{/each}}
 </tbody>
@@ -307,10 +308,10 @@
 {{! Preconditions }}
 {{#if symbol.doc.preconditions}}
 <div>
-{{#> markup/dynamic-level-h level=2 }}Preconditions{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h level=2 }}Preconditions{{/markup/dynamic-level-h~}}
 <ul>
 {{#each symbol.doc.preconditions}}
-<li>{{>javadoc/block .}}</li>
+<li>{{>doc/block .}}</li>
 {{/each}}
 </ul>
 </div>
@@ -318,10 +319,10 @@
 {{! Postconditions }}
 {{#if symbol.doc.postconditions}}
 <div>
-{{#> markup/dynamic-level-h level=2 }}Postconditions{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h level=2 }}Postconditions{{/markup/dynamic-level-h~}}
 <ul>
 {{#each symbol.doc.postconditions}}
-<li>{{>javadoc/block .}}</li>
+<li>{{>doc/block .}}</li>
 {{/each}}
 </ul>
 </div>
@@ -329,9 +330,9 @@
 {{! See Also }}
 {{#if symbol.doc.sees}}
 <div>
-{{#> markup/dynamic-level-h level=2 }}See Also{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h level=2 }}See Also{{/markup/dynamic-level-h~}}
 {{#each symbol.doc.sees}}
-<p>{{>javadoc/block .}}</p>
+<p>{{>doc/block .}}</p>
 {{/each}}
 </div>
 {{/if}}
@@ -339,7 +340,7 @@
 {{#if (and (eq symbol.kind "namespace") @root.config.multipage @root.config.global-namespace-index (eq @root.symbol.kind "namespace") (not @root.symbol.name) (not @root.symbol.parent)) }}
 {{#each symbol.members.namespaces}}
 {{#if isRegular}}
-{{#> markup/dynamic-level-h id=null }}{{> symbol/qualified-name . }} namespace{{/markup/dynamic-level-h}}
+{{#> markup/dynamic-level-h id=null }}{{> symbol/qualified-name . }} namespace{{/markup/dynamic-level-h~}}
 {{> symbol symbol=. id=null traversing-global-namespace=true }}
 {{/if}}
 {{/each}}
diff --git a/src/lib/AST/ASTVisitor.cpp b/src/lib/AST/ASTVisitor.cpp
index 17deb40bc..508f77b81 100644
--- a/src/lib/AST/ASTVisitor.cpp
+++ b/src/lib/AST/ASTVisitor.cpp
@@ -14,8 +14,8 @@
 #include <mrdocs/Platform.hpp>
 #include <lib/AST/ASTVisitor.hpp>
 #include <lib/AST/ClangHelpers.hpp>
+#include <lib/AST/ExtractDocComment.hpp>
 #include <lib/AST/NameBuilder.hpp>
-#include <lib/AST/ParseJavadoc.hpp>
 #include <lib/AST/TypeBuilder.hpp>
 #include <lib/Diagnostics.hpp>
 #include <lib/Support/Path.hpp>
@@ -525,7 +525,7 @@ void
 ASTVisitor::
 populate(Symbol& I, bool const isNew, DeclTy const* D)
 {
-    populate(I.javadoc, D);
+    populate(I.doc, D);
     populate(I.Loc, D);
 
     // All other information is redundant if the symbol is not new
@@ -561,7 +561,7 @@ populate(SourceInfo& I, DeclTy const* D)
 bool
 ASTVisitor::
 populate(
-    Optional<Javadoc>& javadoc,
+    Optional<DocComment>& doc,
     clang::Decl const* D)
 {
     clang::RawComment const* RC = getDocumentation(D);
@@ -569,7 +569,7 @@ populate(
     clang::comments::FullComment* FC =
         RC->parse(D->getASTContext(), &sema_.getPreprocessor(), D);
     MRDOCS_CHECK_OR(FC, false);
-    parseJavadoc(javadoc, FC, D, config_, diags_);
+    populateDocComment(doc, FC, D, config_, diags_);
     return true;
 }
 
@@ -1210,8 +1210,8 @@ populate(
     MRDOCS_CHECK_OR(isDocumented(D));
     Symbol* TI = find(I.id);
     MRDOCS_CHECK_OR(TI);
-    MRDOCS_CHECK_OR(!TI->javadoc);
-    populate(TI->javadoc, D);
+    MRDOCS_CHECK_OR(!TI->doc);
+    populate(TI->doc, D);
 }
 
 void
@@ -3530,7 +3530,7 @@ checkUndocumented(
     // documented version before.
     if (auto const infoIt = info_.find(id);
         infoIt != info_.end() &&
-        infoIt->get()->javadoc)
+        infoIt->get()->doc)
     {
         return {};
     }
diff --git a/src/lib/AST/ASTVisitor.hpp b/src/lib/AST/ASTVisitor.hpp
index b5379c31d..7d2130f3d 100644
--- a/src/lib/AST/ASTVisitor.hpp
+++ b/src/lib/AST/ASTVisitor.hpp
@@ -492,18 +492,18 @@ class ASTVisitor
     void
     populate(SourceInfo& I, DeclTy const* D);
 
-    /*  Parse the comments above a declaration as Javadoc
+    /*  Parse the comments above a declaration as DocComment
 
         This function will parse the comments above a declaration
-        as Javadoc, and store the results in the `javadoc` input
+        as DocComment, and store the results in the `doc` input
         parameter.
 
         @return true if the comments were successfully parsed as
-        Javadoc, and false otherwise.
+        DocComment, and false otherwise.
      */
     bool
     populate(
-        Optional<Javadoc>& javadoc,
+        Optional<DocComment>& doc,
         clang::Decl const* D);
 
     void
diff --git a/src/lib/AST/ExtractDocComment.cpp b/src/lib/AST/ExtractDocComment.cpp
new file mode 100644
index 000000000..93b498096
--- /dev/null
+++ b/src/lib/AST/ExtractDocComment.cpp
@@ -0,0 +1,1188 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2024 Alan de Freitas (alandefreitas@gmail.com)
+// Copyright (c) 2025 Gennaro Prota (gennaro.prota@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#include "ExtractDocComment.hpp"
+#include <lib/AST/ParseRef.hpp>
+#include <mrdocs/Metadata/DocComment.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/Parts.hpp>
+#include <mrdocs/Support/Algorithm.hpp>
+#include <mrdocs/Support/Error.hpp>
+#include <mrdocs/Support/Path.hpp>
+#include <mrdocs/Support/ScopeExit.hpp>
+#include <mrdocs/Support/String.hpp>
+#include <clang/AST/ASTContext.h>
+#include <clang/AST/Comment.h>
+#include <clang/AST/CommentCommandTraits.h>
+#include <clang/AST/CommentVisitor.h>
+#include <clang/AST/RawCommentList.h>
+#include <clang/Basic/SourceLocation.h>
+#include <clang/Basic/SourceManager.h>
+#include <clang/Lex/Lexer.h>
+#include <llvm/ADT/SmallVector.h>
+#include <llvm/ADT/StringExtras.h>
+#include <llvm/Support/JSON.h>
+#include <cctype>
+#include <format>
+#include <ranges>
+#include <string_view>
+
+#ifdef _MSC_VER
+#    pragma warning(push)
+#    pragma warning(disable: 5054)
+#    pragma warning(pop)
+#endif
+
+#ifdef NDEBUG
+#    define MRDOCS_COMMENT_TRACE(D, Ctx)
+#else
+#    define MRDOCS_COMMENT_TRACE_MERGE_(a, b) a##b
+#    define MRDOCS_COMMENT_TRACE_LABEL_(a) \
+        MRDOCS_COMMENT_TRACE_MERGE_(comment_content_, a)
+#    define MRDOCS_COMMENT_TRACE_UNIQUE_NAME \
+        MRDOCS_COMMENT_TRACE_LABEL_(__LINE__)
+namespace detail {
+template <class T>
+static void
+dumpCommentContent(
+    T const* C,
+    clang::ASTContext const& Ctx,
+    llvm::SmallString<1024>& contents)
+{
+    if (!C)
+    {
+        return;
+    }
+
+    if constexpr (std::derived_from<T, clang::comments::Comment>)
+    {
+        auto const* CC = static_cast<clang::comments::Comment const*>(C);
+        clang::SourceRange const R = CC->getSourceRange();
+        clang::SourceManager const& SM = Ctx.getSourceManager();
+        contents = clang::Lexer::getSourceText(
+            clang::CharSourceRange::getTokenRange(R),
+            SM,
+            Ctx.getLangOpts());
+    }
+}
+template <class T>
+requires(!std::is_pointer_v<T>)
+static void
+dumpCommentContent(
+    T const& C,
+    clang::ASTContext const& Ctx,
+    llvm::SmallString<1024>& contents)
+{
+    dumpCommentContent(&C, Ctx, contents);
+}
+} // namespace detail
+
+#    define MRDOCS_COMMENT_TRACE(D, Ctx)                                        \
+        llvm::SmallString<1024> MRDOCS_COMMENT_TRACE_UNIQUE_NAME;               \
+        ::detail::dumpCommentContent(D, Ctx, MRDOCS_COMMENT_TRACE_UNIQUE_NAME); \
+        report::trace(                                                          \
+            "{}",                                                               \
+            std::string_view(MRDOCS_COMMENT_TRACE_UNIQUE_NAME.str()))
+#endif
+
+namespace mrdocs {
+namespace {
+
+// -------- Small helpers
+
+static std::string
+ensureUTF8(std::string s)
+{
+    if (!llvm::json::isUTF8(s))
+    {
+        s = llvm::json::fixUTF8(s);
+    }
+    return s;
+}
+
+static doc::InlineKind
+convertStyle(clang::comments::InlineCommandRenderKind k)
+{
+    using K = clang::comments::InlineCommandRenderKind;
+    switch (k)
+    {
+    case K::Monospaced:
+        return doc::InlineKind::Code;
+    case K::Bold:
+        return doc::InlineKind::Strong;
+    case K::Emphasized:
+        return doc::InlineKind::Emph;
+    case K::Normal:
+    case K::Anchor:
+    default:
+        return doc::InlineKind::Text;
+    }
+}
+
+static doc::ParamDirection
+convertDirection(clang::comments::ParamCommandPassDirection d)
+{
+    using D = clang::comments::ParamCommandPassDirection;
+    switch (d)
+    {
+    case D::In:
+        return doc::ParamDirection::in;
+    case D::Out:
+        return doc::ParamDirection::out;
+    case D::InOut:
+        return doc::ParamDirection::inout;
+    }
+    report::error(
+        "error: unsupported ParamCommandPassDirection <{}>",
+        static_cast<int>(d));
+    MRDOCS_UNREACHABLE();
+}
+
+static doc::Parts
+convertCopydoc(unsigned id)
+{
+    using T = clang::comments::CommandTraits;
+    switch (id)
+    {
+    case T::KCI_copydoc:
+        return doc::Parts::all;
+    case T::KCI_copybrief:
+        return doc::Parts::brief;
+    case T::KCI_copydetails:
+        return doc::Parts::description;
+    default:
+        report::error("error: unsupported CommandTrait id <{}>", id);
+        MRDOCS_UNREACHABLE();
+    }
+}
+
+// Cursor: immutable snapshot of children with index-based look-ahead/consume.
+struct Cursor {
+    llvm::SmallVector<clang::comments::Comment const*, 8> children;
+    std::size_t i{ 0 };
+
+    Cursor() = default;
+    explicit Cursor(clang::comments::Comment const* parent)
+    {
+        children.assign(parent->child_begin(), parent->child_end());
+    }
+
+    bool
+    done() const
+    {
+        return i >= children.size();
+    }
+    clang::comments::Comment const*
+    cur() const
+    {
+        return done() ? nullptr : children[i];
+    }
+    clang::comments::Comment const*
+    peek(std::size_t k = 1) const
+    {
+        std::size_t j = i + k;
+        return (j < children.size()) ? children[j] : nullptr;
+    }
+    void
+    advance()
+    {
+        if (!done())
+        {
+            ++i;
+        }
+    }
+    // consume n *intermediate* siblings after current (not including current)
+    void
+    consume_intermediate(std::size_t n)
+    {
+        // We will call this only after we've already processed current;
+        // It should skip *n* immediately following items.
+        i += n;
+        if (i > children.size())
+        {
+            i = children.size();
+        }
+    }
+};
+
+//------------------------------------------------
+
+class DocCommentVisitor
+    : public clang::comments::ConstCommentVisitor<DocCommentVisitor> {
+    Config const& config_;
+    clang::ASTContext const& ctx_;
+    clang::SourceManager const& sm_;
+    clang::comments::FullComment const* FC_;
+    Diagnostics& diags_;
+
+    DocComment jd_;
+    doc::InlineContainer* curInlines_{ nullptr };
+    bool newline_blocks_merge_{ false };
+
+    // --- inline assembly
+
+    template <std::derived_from<doc::Inline> InlineTy, class... Args>
+    void
+    emplaceInline(bool end_with_nl, Args&&... args)
+    {
+        MRDOCS_ASSERT(curInlines_ != nullptr);
+        auto& vec = curInlines_->children;
+
+        auto mergeable = [](doc::InlineKind k) {
+            return is_one_of(
+                k,
+                { doc::InlineKind::Text,
+                  doc::InlineKind::Emph,
+                  doc::InlineKind::Strong,
+                  doc::InlineKind::Code });
+        };
+
+        InlineTy elem(std::forward<Args>(args)...);
+
+        if (!newline_blocks_merge_ && !vec.empty())
+        {
+            doc::Inline& last = *vec.back();
+            if (last.Kind == elem.Kind && mergeable(elem.Kind))
+            {
+                if constexpr (std::is_same_v<InlineTy, doc::TextInline>)
+                {
+                    last.asText().literal.append(elem.asText().literal);
+                    newline_blocks_merge_ = end_with_nl;
+                    return;
+                }
+                // For Emph/Strong/Code we preserve node boundaries (safer).
+            }
+        }
+
+        vec.emplace_back(std::in_place_type<InlineTy>, std::move(elem));
+        newline_blocks_merge_ = end_with_nl;
+    }
+
+    struct BlockScope {
+        DocCommentVisitor& v_;
+        doc::InlineContainer* prev_;
+        bool prev_merge_;
+        BlockScope(DocCommentVisitor& v, doc::InlineContainer* dst)
+            : v_(v)
+            , prev_(v.curInlines_)
+            , prev_merge_(v.newline_blocks_merge_)
+        {
+            v.curInlines_ = dst;
+            v.newline_blocks_merge_ = false;
+        }
+        ~BlockScope()
+        {
+            v_.curInlines_ = prev_;
+            v_.newline_blocks_merge_ = prev_merge_;
+        }
+    };
+
+    BlockScope
+    enterScope(doc::InlineContainer& dst)
+    {
+        return BlockScope(*this, &dst);
+    }
+
+    // --- diagnostics helpers
+
+    bool
+    goodArgCount(std::size_t n, clang::comments::InlineCommandComment const& C)
+    {
+        if (C.getNumArgs() != n)
+        {
+            auto loc = sm_.getPresumedLoc(C.getBeginLoc());
+            diags_.error(
+                std::format(
+                    "Expected {} but got {} args\nFile: {}, line {}, col {}\n",
+                    n,
+                    C.getNumArgs(),
+                    files::makePosixStyle(loc.getFilename()),
+                    loc.getLine(),
+                    loc.getColumn()));
+            return false;
+        }
+        return true;
+    }
+
+    // --- “peek next text” & reference fixer using Cursor
+
+    Optional<std::string_view>
+    peekNextText(Cursor const& cur) const
+    {
+        using namespace clang::comments;
+        auto* n = cur.peek();
+        if (!n || n->getCommentKind() != CommentKind::TextComment)
+        {
+            return std::nullopt;
+        }
+        return static_cast<TextComment const*>(n)->getText();
+    }
+
+    std::string
+    fixReference(std::string& ref, Cursor& cur)
+    {
+        ParsedRef v;
+        for (;;)
+        {
+            char const* first = ref.data();
+            char const* last = first + ref.size();
+            auto pres = parse(first, last, v);
+            if (!pres)
+            {
+                if (auto nextText = peekNextText(cur))
+                {
+                    ref += *nextText;
+                    cur.advance(); // consume that sibling
+                    continue;
+                }
+                return {};
+            }
+
+            if (pres.ptr != last)
+            {
+                std::string leftover(pres.ptr, last - pres.ptr);
+                if (!isWhitespace(leftover))
+                {
+                    ref.erase(pres.ptr - first);
+                    return leftover;
+                }
+            }
+
+            bool const mightHaveMoreQualifiers
+                = v.HasFunctionParameters && v.ExceptionSpec.Implicit
+                  && v.ExceptionSpec.Operand.empty();
+
+            if (mightHaveMoreQualifiers)
+            {
+                llvm::SmallVector<std::string_view, 4> quals;
+                if (v.Kind == ReferenceKind::None)
+                {
+                    if (!v.IsConst)
+                    {
+                        quals.push_back("const");
+                    }
+                    if (!v.IsVolatile)
+                    {
+                        quals.push_back("volatile");
+                    }
+                    quals.push_back("&");
+                }
+                else if (v.Kind == ReferenceKind::LValue && ref.ends_with('&'))
+                {
+                    quals.push_back("&");
+                }
+                quals.push_back("noexcept");
+
+                if (auto nextText = peekNextText(cur))
+                {
+                    auto trimmed = ltrim(*nextText);
+                    if (trimmed.empty()
+                        || std::ranges::any_of(quals, [&](std::string_view s) {
+                        return trimmed.starts_with(s);
+                    }))
+                    {
+                        ref += *nextText;
+                        cur.advance();
+                        continue;
+                    }
+                }
+                else
+                {
+                    std::string leftover(pres.ptr, last - pres.ptr);
+                    ref.erase(pres.ptr - first);
+                    return leftover;
+                }
+            }
+
+            if (!v.HasFunctionParameters)
+            {
+                if (auto nextText = peekNextText(cur))
+                {
+                    std::string_view trimmed = ltrim(*nextText);
+                    static constexpr std::string_view idChars
+                        = "abcdefghijklmnopqrstuvwxyz"
+                          "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                          "0123456789"
+                          "_:";
+                    if (trimmed.empty() || contains(idChars, trimmed.front()))
+                    {
+                        ref += *nextText;
+                        cur.advance();
+                        continue;
+                    }
+                }
+                else
+                {
+                    std::string leftover(pres.ptr, last - pres.ptr);
+                    ref.erase(pres.ptr - first);
+                    return leftover;
+                }
+            }
+
+            return {};
+        }
+    }
+
+    // --- Visiting using Cursor (no member iterators)
+
+    void
+    visitChildrenWithCursor(clang::comments::Comment const* C)
+    {
+        MRDOCS_COMMENT_TRACE(C, ctx_);
+        Cursor cur(C);
+        while (!cur.done())
+        {
+            auto* n = cur.cur();
+            MRDOCS_COMMENT_TRACE(n, ctx_);
+            visitNode(n, cur); // may advance/consume
+            cur.advance();
+        }
+    }
+
+    // “HTML <span>…</span> text gatherer” equivalent with cursor
+    struct TagComponents {
+        std::string tag;
+        std::string text;
+        std::size_t n_intermediate{ 0 };
+    };
+
+    Expected<TagComponents>
+    parseHTMLStartSpan(
+        clang::comments::HTMLStartTagComment const* C,
+        Cursor const& cur) const
+    {
+        TagComponents res;
+        res.tag = C->getTagName().str();
+
+        static constexpr std::array noEndTag = {
+            "br",    "img",    "input", "hr",      "meta",  "link",
+            "base",  "area",   "col",   "command", "embed", "keygen",
+            "param", "source", "track", "wbr"
+        };
+        bool requiresEnd = std::ranges::find(noEndTag, res.tag)
+                           == noEndTag.end();
+        if (!requiresEnd)
+        {
+            return res;
+        }
+
+        using namespace clang::comments;
+        // find matching end tag ahead
+        std::size_t j = 1;
+        for (; cur.i + j < cur.children.size(); ++j)
+        {
+            auto* c = cur.children[cur.i + j];
+            if (c->getCommentKind() != CommentKind::HTMLEndTagComment)
+            {
+                continue;
+            }
+            auto* e = static_cast<HTMLEndTagComment const*>(c);
+            if (e->getTagName() == res.tag)
+            {
+                break;
+            }
+        }
+        if (cur.i + j >= cur.children.size())
+        {
+            return Unexpected(formatError(
+                "warning: HTML <{}> tag not followed by end tag",
+                res.tag));
+        }
+
+        // ensure all in-between are TextComment
+        for (std::size_t k = 1; k < j; ++k)
+        {
+            if (cur.children[cur.i + k]->getCommentKind()
+                != clang::comments::CommentKind::TextComment)
+            {
+                return Unexpected(Error(
+                    std::format(
+                        "warning: HTML <{}> tag not followed by pure text",
+                        res.tag)));
+            }
+        }
+
+        res.n_intermediate = j - 1;
+        for (std::size_t k = 1; k < j; ++k)
+        {
+            auto* t = static_cast<clang::comments::TextComment const*>(
+                cur.children[cur.i + k]);
+            res.text += t->getText();
+        }
+        return res;
+    }
+
+    // Single-dispatch “node” entry that can use/modify the cursor
+    void
+    visitNode(clang::comments::Comment const* C, Cursor& cur)
+    {
+        using namespace clang::comments;
+        switch (C->getCommentKind())
+        {
+        case CommentKind::TextComment:
+            visitText(static_cast<TextComment const*>(C));
+            return;
+
+        case CommentKind::HTMLStartTagComment:
+            visitHTMLStart(static_cast<HTMLStartTagComment const*>(C), cur);
+            return;
+
+        case CommentKind::HTMLEndTagComment:
+            // noop; already handled when start is processed
+            return;
+
+        case CommentKind::InlineCommandComment:
+            visitInlineCommand(static_cast<InlineCommandComment const*>(C), cur);
+            return;
+
+        case CommentKind::ParagraphComment:
+            visitParagraph(static_cast<ParagraphComment const*>(C));
+            return;
+
+        case CommentKind::BlockCommandComment:
+            visitBlockCommand(static_cast<BlockCommandComment const*>(C));
+            return;
+
+        case CommentKind::ParamCommandComment:
+            visitParam(static_cast<ParamCommandComment const*>(C));
+            return;
+
+        case CommentKind::TParamCommandComment:
+            visitTParam(static_cast<TParamCommandComment const*>(C));
+            return;
+
+        case CommentKind::VerbatimBlockComment:
+            visitVerbatimBlock(static_cast<VerbatimBlockComment const*>(C));
+            return;
+
+        case CommentKind::VerbatimBlockLineComment:
+            visitVerbatimBlockLine(
+                static_cast<VerbatimBlockLineComment const*>(C));
+            return;
+
+        case CommentKind::VerbatimLineComment:
+            // not used
+            return;
+
+        default:
+            // generic: recurse
+            visitChildrenWithCursor(C);
+            return;
+        }
+    }
+
+    // ---- Implementations
+
+    void
+    visitText(clang::comments::TextComment const* C)
+    {
+        MRDOCS_COMMENT_TRACE(C, ctx_);
+        llvm::StringRef s = C->getText();
+        if (curInlines_ && curInlines_->children.empty())
+        {
+            s = s.ltrim();
+        }
+        if (!s.empty())
+        {
+            emplaceInline<
+                doc::TextInline>(C->hasTrailingNewline(), ensureUTF8(s.str()));
+        }
+    }
+
+    void
+    visitHTMLStart(clang::comments::HTMLStartTagComment const* C, Cursor& cur)
+    {
+        MRDOCS_COMMENT_TRACE(C, ctx_);
+        MRDOCS_ASSERT(C->child_begin() == C->child_end());
+
+        auto loc = sm_.getPresumedLoc(C->getBeginLoc());
+        auto filename = files::makePosixStyle(loc.getFilename());
+
+        auto getAttr = [&C](llvm::StringRef name) -> Expected<std::string> {
+            for (unsigned i = 0, n = C->getNumAttrs(); i < n; ++i)
+            {
+                auto const& a = C->getAttr(i);
+                if (a.Name == name)
+                {
+                    return std::string(a.Value);
+                }
+            }
+            return Unexpected(Error(
+                std::format(
+                    "warning: HTML <{}> tag has no {} attribute",
+                    C->getTagName().str(),
+                    name.str())));
+        };
+
+        auto compsExp = parseHTMLStartSpan(C, cur);
+        if (!compsExp)
+        {
+            report::error(
+                "{} at {} ({})",
+                compsExp.error().message(),
+                filename,
+                loc.getLine());
+            return;
+        }
+        auto comps = *compsExp;
+
+        if (comps.tag == "a")
+        {
+            auto r = getAttr("href");
+            if (!r)
+            {
+                report::error(r.error().message());
+                return;
+            }
+            emplaceInline<doc::LinkInline>(
+                C->hasTrailingNewline(),
+                ensureUTF8(std::move(comps.text)),
+                ensureUTF8(std::move(*r)));
+        }
+        else if (comps.tag == "br")
+        {
+            emplaceInline<doc::TextInline>(true, "");
+        }
+        else if (comps.tag == "em")
+        {
+            emplaceInline<doc::EmphInline>(
+                C->hasTrailingNewline(),
+                ensureUTF8(std::move(comps.text)));
+        }
+        else
+        {
+            report::warn(
+                std::format("warning: unsupported HTML tag <{}>", comps.tag),
+                filename,
+                loc.getLine());
+        }
+
+        // Skip the intermediate siblings consumed for text gathering
+        cur.consume_intermediate(comps.n_intermediate);
+    }
+
+    void
+    visitInlineCommand(
+        clang::comments::InlineCommandComment const* C,
+        Cursor& cur)
+    {
+        MRDOCS_COMMENT_TRACE(C, ctx_);
+        auto const* cmd = ctx_.getCommentCommandTraits().getCommandInfo(
+            C->getCommandID());
+        MRDOCS_ASSERT(cmd != nullptr);
+
+        using T = clang::comments::CommandTraits;
+        switch (unsigned ID = cmd->getID())
+        {
+        case T::KCI_n:
+            if (!goodArgCount(0, *C))
+            {
+                return;
+            }
+            emplaceInline<doc::TextInline>(true, "\n");
+            return;
+
+        case T::KCI_a:
+        case T::KCI_e:
+        case T::KCI_em:
+        {
+            MRDOCS_CHECK_OR(goodArgCount(1, *C));
+            emplaceInline<doc::EmphInline>(
+                C->hasTrailingNewline(),
+                C->getArgText(0).str());
+            return;
+        }
+
+        case T::KCI_copybrief:
+        case T::KCI_copydetails:
+        case T::KCI_copydoc:
+        {
+            MRDOCS_CHECK_OR(goodArgCount(1, *C));
+            std::string ref = C->getArgText(0).str();
+            std::string leftover = fixReference(ref, cur);
+            bool hasExtra = !leftover.empty();
+
+            doc::Parts parts = convertCopydoc(ID);
+            bool copyBrief = parts == doc::Parts::brief
+                             || parts == doc::Parts::all;
+            bool copyDetails = parts == doc::Parts::description
+                               || parts == doc::Parts::all;
+
+            if (copyBrief)
+            {
+                if (!jd_.brief)
+                {
+                    jd_.brief.emplace();
+                }
+                if (!contains(jd_.brief->copiedFrom, ref))
+                {
+                    jd_.brief->copiedFrom.emplace_back(ref);
+                }
+            }
+            if (copyDetails)
+            {
+                emplaceInline<doc::CopyDetailsInline>(
+                    C->hasTrailingNewline() && !hasExtra,
+                    ref);
+            }
+            if (hasExtra)
+            {
+                emplaceInline<doc::TextInline>(
+                    C->hasTrailingNewline(),
+                    std::move(leftover));
+            }
+            return;
+        }
+
+        case T::KCI_ref:
+        {
+            MRDOCS_CHECK_OR(goodArgCount(1, *C));
+            std::string ref = C->getArgText(0).str();
+            std::string leftover = fixReference(ref, cur);
+            bool hasExtra = !leftover.empty();
+            emplaceInline<
+                doc::ReferenceInline>(C->hasTrailingNewline() && !hasExtra, ref);
+            if (hasExtra)
+            {
+                emplaceInline<doc::TextInline>(
+                    C->hasTrailingNewline(),
+                    std::move(leftover));
+            }
+            return;
+        }
+
+        case T::KCI_related:
+        case T::KCI_relates:
+        case T::KCI_relatedalso:
+        case T::KCI_relatesalso:
+        case T::KCI_memberof:
+        {
+            MRDOCS_CHECK_OR(goodArgCount(1, *C));
+            std::string ref = C->getArgText(0).str();
+            std::string leftover = fixReference(ref, cur);
+            bool hasExtra = !leftover.empty();
+            jd_.relates.emplace_back(std::move(ref));
+            if (hasExtra)
+            {
+                emplaceInline<doc::TextInline>(
+                    C->hasTrailingNewline(),
+                    std::move(leftover));
+            }
+            return;
+        }
+
+        default:
+            break;
+        }
+
+        // default rendering: concatenate all args and style accordingly
+        std::string s;
+        s.reserve([&] {
+            size_t n = 0;
+            for (unsigned i = 0; i < C->getNumArgs(); ++i)
+            {
+                n += C->getArgText(i).size();
+            }
+            return n;
+        }());
+        for (unsigned i = 0; i < C->getNumArgs(); ++i)
+        {
+            s.append(C->getArgText(i));
+        }
+
+        switch (convertStyle(C->getRenderKind()))
+        {
+        case doc::InlineKind::Emph:
+            emplaceInline<
+                doc::EmphInline>(C->hasTrailingNewline(), std::move(s));
+            break;
+        case doc::InlineKind::Strong:
+            emplaceInline<
+                doc::StrongInline>(C->hasTrailingNewline(), std::move(s));
+            break;
+        case doc::InlineKind::Code:
+            emplaceInline<
+                doc::CodeInline>(C->hasTrailingNewline(), std::move(s));
+            break;
+        default:
+            emplaceInline<
+                doc::TextInline>(C->hasTrailingNewline(), std::move(s));
+            break;
+        }
+    }
+
+    void
+    visitParagraph(clang::comments::ParagraphComment const* C)
+    {
+        MRDOCS_COMMENT_TRACE(C, ctx_);
+        if (curInlines_)
+        {
+            visitChildrenWithCursor(C);
+            return;
+        }
+        doc::ParagraphBlock paragraph;
+        auto scope = enterScope(paragraph);
+        visitChildrenWithCursor(C);
+        if (!paragraph.empty())
+        {
+            jd_.Document.emplace_back(std::move(paragraph));
+        }
+    }
+
+    void
+    visitBlockCommand(clang::comments::BlockCommandComment const* C)
+    {
+        MRDOCS_COMMENT_TRACE(C, ctx_);
+        auto const* cmd = ctx_.getCommentCommandTraits().getCommandInfo(
+            C->getCommandID());
+        if (!cmd)
+        {
+            return;
+        }
+
+        auto parseBlock =
+            [this, C]<class BlockTy>(std::in_place_type_t<BlockTy>) -> BlockTy
+        requires std::derived_from<BlockTy, doc::Block>
+                 && std::derived_from<BlockTy, doc::InlineContainer>
+        {
+            BlockTy b;
+            auto& inlines = static_cast<doc::InlineContainer&>(b);
+            auto scope = enterScope(inlines);
+
+            // Paragraph may be null for some block commands; guard it.
+            if (auto* P = C->getParagraph())
+            {
+                visitChildrenWithCursor(P);
+            }
+
+            if constexpr (requires { BlockTy::name; })
+            {
+                if (C->getNumArgs() > 0)
+                {
+                    b.name = C->getArgText(0).str();
+                }
+            }
+            if (!inlines.children.empty())
+            {
+                trim(inlines);
+            }
+            return b;
+        };
+
+        using T = clang::comments::CommandTraits;
+        switch (cmd->getID())
+        {
+        case T::KCI_brief:
+        case T::KCI_short:
+        {
+            auto b = parseBlock(std::in_place_type<doc::BriefBlock>);
+            jd_.brief.emplace(std::move(b));
+            return;
+        }
+        case T::KCI_return:
+        case T::KCI_returns:
+        case T::KCI_result:
+        {
+            auto b = parseBlock(std::in_place_type<doc::ReturnsBlock>);
+            jd_.returns.push_back(std::move(b));
+            return;
+        }
+        case T::KCI_throw:
+        case T::KCI_throws:
+        case T::KCI_exception:
+        {
+            auto b = parseBlock(std::in_place_type<doc::ThrowsBlock>);
+            if (C->getNumArgs() > 0)
+            {
+                b.exception.literal = C->getArgText(0).str();
+            }
+            jd_.exceptions.push_back(std::move(b));
+            return;
+        }
+        case T::KCI_note:
+        case T::KCI_warning:
+        {
+            auto p = parseBlock(std::in_place_type<doc::ParagraphBlock>);
+            doc::AdmonitionKind k = (cmd->getID() == T::KCI_note) ?
+                                        doc::AdmonitionKind::note :
+                                        doc::AdmonitionKind::warning;
+            doc::AdmonitionBlock adm(k);
+            adm.blocks.emplace_back(std::move(p));
+            jd_.Document.emplace_back(std::move(adm));
+            return;
+        }
+        case T::KCI_par:
+        {
+            auto paragraph = parseBlock(
+                std::in_place_type<doc::ParagraphBlock>);
+            if (C->getNumArgs() > 0)
+            {
+                jd_.Document.emplace_back(
+                    doc::HeadingBlock(C->getArgText(0).str()));
+            }
+
+            if (!paragraph.children.empty()
+                && paragraph.children.front()->isText())
+            {
+                if (C->getNumArgs() == 0)
+                {
+                    std::string text = std::move(
+                        paragraph.children.front()->asText().literal);
+                    if (auto s = trim(text); s.size() != text.size())
+                    {
+                        text = s;
+                    }
+                    jd_.Document.emplace_back(
+                        doc::HeadingBlock(std::move(text)));
+                    paragraph.children.erase(paragraph.children.begin());
+                }
+                if (!paragraph.children.empty())
+                {
+                    jd_.Document.emplace_back(std::move(paragraph));
+                }
+            }
+            return;
+        }
+        case T::KCI_li:
+        {
+            if (jd_.Document.empty() || !jd_.Document.back()->isList())
+            {
+                jd_.Document.emplace_back(doc::ListBlock{});
+            }
+            auto& list = jd_.Document.back()->asList();
+            auto& item = list.items.emplace_back();
+            auto p = parseBlock(std::in_place_type<doc::ParagraphBlock>);
+            item.blocks.emplace_back(std::move(p));
+            return;
+        }
+        case T::KCI_details:
+        {
+            auto details = parseBlock(std::in_place_type<doc::ParagraphBlock>);
+            jd_.Document.emplace_back(std::move(details));
+            return;
+        }
+        case T::KCI_see:
+        {
+            auto see = parseBlock(std::in_place_type<doc::SeeBlock>);
+            jd_.sees.push_back(std::move(see));
+            return;
+        }
+        case T::KCI_pre:
+        {
+            auto pre = parseBlock(std::in_place_type<doc::PreconditionBlock>);
+            jd_.preconditions.push_back(std::move(pre));
+            return;
+        }
+        case T::KCI_post:
+        {
+            auto post = parseBlock(std::in_place_type<doc::PostconditionBlock>);
+            jd_.postconditions.push_back(std::move(post));
+            return;
+        }
+
+        // Inline-only kinds here would be a logic error:
+        case T::KCI_a:
+        case T::KCI_e:
+        case T::KCI_em:
+        case T::KCI_n:
+        case T::KCI_copybrief:
+        case T::KCI_copydetails:
+        case T::KCI_copydoc:
+            report::error(
+                "error: inline command {} should be handled elsewhere",
+                cmd->Name);
+            MRDOCS_UNREACHABLE();
+
+        default:
+            // unsupported → ignore
+            return;
+        }
+    }
+
+    void
+    visitParam(clang::comments::ParamCommandComment const* C)
+    {
+        MRDOCS_COMMENT_TRACE(C, ctx_);
+        doc::ParamBlock param;
+        if (C->hasParamName())
+        {
+            param.name = ensureUTF8(C->getParamNameAsWritten().str());
+        }
+        else
+        {
+            diags_.error("Missing parameter name in @param");
+            param.name = "@anon";
+        }
+
+        if (C->isDirectionExplicit())
+        {
+            param.direction = convertDirection(C->getDirection());
+        }
+
+        if (auto* P = C->getParagraph())
+        {
+            auto scope = enterScope(param);
+            visitChildrenWithCursor(P);
+        }
+
+        // warn on duplicates
+        auto it = std::ranges::
+            find_if(jd_.Document, [&](Polymorphic<doc::Block> const& b) {
+            if (!b->isParam())
+            {
+                return false;
+            }
+            auto const* p = dynamic_cast<doc::ParamBlock const*>(
+                b.operator->());
+            MRDOCS_ASSERT(p != nullptr);
+            return p->name == param.name;
+        });
+        if (it != jd_.Document.end())
+        {
+            report::warn(
+                "{}: Duplicate @param for argument {}",
+                C->getBeginLoc().printToString(sm_),
+                param.name);
+        }
+
+        jd_.params.push_back(std::move(param));
+    }
+
+    void
+    visitTParam(clang::comments::TParamCommandComment const* C)
+    {
+        MRDOCS_COMMENT_TRACE(C, ctx_);
+        doc::TParamBlock tparam;
+        if (C->hasParamName())
+        {
+            tparam.name = ensureUTF8(C->getParamNameAsWritten().str());
+        }
+        else
+        {
+            diags_.error("Missing parameter name in @tparam");
+            tparam.name = "@anon";
+        }
+
+        if (auto* P = C->getParagraph())
+        {
+            auto scope = enterScope(tparam);
+            visitChildrenWithCursor(P);
+        }
+
+        auto it = std::ranges::
+            find_if(jd_.Document, [&](Polymorphic<doc::Block> const& b) {
+            if (!b->isTParam())
+            {
+                return false;
+            }
+            auto const* tp = dynamic_cast<doc::TParamBlock const*>(
+                b.operator->());
+            MRDOCS_ASSERT(tp != nullptr);
+            return tp->name == tparam.name;
+        });
+        if (it != jd_.Document.end())
+        {
+            report::warn(
+                "{}: Duplicate @tparam for argument {}",
+                C->getBeginLoc().printToString(sm_),
+                tparam.name);
+        }
+
+        jd_.tparams.push_back(std::move(tparam));
+    }
+
+    void
+    visitVerbatimBlock(clang::comments::VerbatimBlockComment const* C)
+    {
+        MRDOCS_COMMENT_TRACE(C, ctx_);
+        doc::CodeBlock code;
+        std::string payload;
+        unsigned n = C->getNumLines();
+        for (unsigned i = 0; i < n; ++i)
+        {
+            llvm::StringRef line = C->getText(i);
+            payload.append(line.data(), line.size());
+            if (i + 1 != n)
+            {
+                payload.push_back('\n');
+            }
+        }
+        code.literal = std::move(payload);
+        jd_.Document.emplace_back(std::move(code));
+    }
+
+    void
+    visitVerbatimBlockLine(clang::comments::VerbatimBlockLineComment const* C)
+    {
+        MRDOCS_COMMENT_TRACE(C, ctx_);
+        emplaceInline<doc::TextInline>(true, C->getText().str());
+    }
+
+public:
+    DocCommentVisitor(
+        clang::comments::FullComment const* FC,
+        clang::Decl const* D,
+        Config const& config,
+        Diagnostics& diags)
+        : config_(config)
+        , ctx_(D->getASTContext())
+        , sm_(ctx_.getSourceManager())
+        , FC_(FC)
+        , diags_(diags)
+    {}
+
+    DocComment
+    build()
+    {
+        MRDOCS_COMMENT_TRACE(FC_, ctx_);
+        visitChildrenWithCursor(FC_);
+        return std::move(jd_);
+    }
+};
+
+//------------------------------------------------
+
+} // namespace
+
+void
+initCustomCommentCommands(clang::ASTContext& context)
+{
+    (void) context;
+    // Reserved for future custom commands registration.
+}
+
+void
+populateDocComment(
+    Optional<DocComment>& jd,
+    clang::comments::FullComment const* FC,
+    clang::Decl const* D,
+    Config const& config,
+    Diagnostics& diags)
+{
+    MRDOCS_COMMENT_TRACE(FC, D->getASTContext());
+    DocCommentVisitor visitor(FC, D, config, diags);
+    auto result = visitor.build();
+    if (!result.empty())
+    {
+        if (!jd)
+        {
+            jd = std::move(result);
+        }
+        else if (*jd != result)
+        {
+            jd->append(std::move(result));
+        }
+    }
+}
+
+} // namespace mrdocs
diff --git a/src/lib/AST/ParseJavadoc.hpp b/src/lib/AST/ExtractDocComment.hpp
similarity index 72%
rename from src/lib/AST/ParseJavadoc.hpp
rename to src/lib/AST/ExtractDocComment.hpp
index e6d744ee3..627efeb40 100644
--- a/src/lib/AST/ParseJavadoc.hpp
+++ b/src/lib/AST/ExtractDocComment.hpp
@@ -9,13 +9,13 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_AST_PARSEJAVADOC_HPP
-#define MRDOCS_LIB_AST_PARSEJAVADOC_HPP
+#ifndef MRDOCS_LIB_AST_EXTRACTDOCCOMMENT_HPP
+#define MRDOCS_LIB_AST_EXTRACTDOCCOMMENT_HPP
 
 #include <mrdocs/Platform.hpp>
 #include <lib/Diagnostics.hpp>
 #include <mrdocs/Config.hpp>
-#include <mrdocs/Metadata/Javadoc.hpp>
+#include <mrdocs/Metadata/DocComment.hpp>
 
 namespace clang {
 class Decl;
@@ -37,20 +37,20 @@ void
 initCustomCommentCommands(
     clang::ASTContext& ctx);
 
-/** Parse doc comments from a declaration
+/** Extract doc comments from a declaration
 
-    Parse the Javadoc from a declaration, populating the
-    Javadoc object with the parsed information.
+    Extract the DocComment from a declaration, populating the
+    DocComment object with the information parsed by clang.
 
-    @param jd The Javadoc object to populate
+    @param jd The DocComment object to populate
     @param FC The full comment to parse
     @param D The declaration to which the comment applies
     @param config The MrDocs configuration object
     @param diags The diagnostics object
 */
 void
-parseJavadoc(
-    Optional<Javadoc>& jd,
+populateDocComment(
+    Optional<DocComment>& jd,
     clang::comments::FullComment const* FC,
     clang::Decl const* D,
     Config const& config,
@@ -59,4 +59,4 @@ parseJavadoc(
 } // mrdocs
 
 
-#endif // MRDOCS_LIB_AST_PARSEJAVADOC_HPP
+#endif // MRDOCS_LIB_AST_EXTRACTDOCCOMMENT_HPP
diff --git a/src/lib/AST/NameBuilder.hpp b/src/lib/AST/NameBuilder.hpp
index bc3f6ae0f..17d094e99 100644
--- a/src/lib/AST/NameBuilder.hpp
+++ b/src/lib/AST/NameBuilder.hpp
@@ -31,8 +31,11 @@ class NameBuilder
     Polymorphic<Name>
     result()
     {
-        MRDOCS_ASSERT(Result.has_value());
-        return std::move(*Result);
+        if (Result.has_value())
+        {
+            return std::move(*Result);
+        }
+        return Polymorphic<Name>(std::in_place_type<IdentifierName>);
     }
 
     constexpr bool
diff --git a/src/lib/AST/ParseJavadoc.cpp b/src/lib/AST/ParseJavadoc.cpp
deleted file mode 100644
index 31aaa6c15..000000000
--- a/src/lib/AST/ParseJavadoc.cpp
+++ /dev/null
@@ -1,1819 +0,0 @@
-//
-// This is a derivative work. originally part of the LLVM Project.
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-// Copyright (c) 2024 Alan de Freitas (alandefreitas@gmail.com)
-// Copyright (c) 2025 Gennaro Prota (gennaro.prota@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#include "ParseJavadoc.hpp"
-#include <lib/AST/ParseRef.hpp>
-#include <mrdocs/Metadata/Javadoc.hpp>
-#include <mrdocs/Metadata/Javadoc/Inline/Parts.hpp>
-#include <mrdocs/Support/Algorithm.hpp>
-#include <mrdocs/Support/Error.hpp>
-#include <mrdocs/Support/Path.hpp>
-#include <mrdocs/Support/ScopeExit.hpp>
-#include <mrdocs/Support/String.hpp>
-#include <clang/AST/ASTContext.h>
-#include <clang/AST/CommentCommandTraits.h>
-#include <clang/AST/RawCommentList.h>
-#include <clang/Basic/SourceLocation.h>
-#include <clang/Lex/Lexer.h>
-#include <cctype>
-#include <format>
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 5054) // C5054: operator '+': deprecated between enumerations of different types
-#endif
-#include <clang/AST/Comment.h>
-#include <clang/AST/CommentVisitor.h>
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-#include <clang/Basic/SourceManager.h>
-#include <llvm/ADT/StringExtras.h>
-#include <llvm/Support/JSON.h>
-#include <ranges>
-
-#ifdef NDEBUG
-#define MRDOCS_COMMENT_TRACE(D, C)
-#else
-
-#    define MRDOCS_COMMENT_TRACE_MERGE_(a, b) a## b
-#    define MRDOCS_COMMENT_TRACE_LABEL_(a)    MRDOCS_COMMENT_TRACE_MERGE_(comment_content_, a)
-#    define MRDOCS_COMMENT_TRACE_UNIQUE_NAME  MRDOCS_COMMENT_TRACE_LABEL_(__LINE__)
-
-namespace detail {
-    template <class T>
-    void
-    dumpCommentContent(T const* C, clang::ASTContext const& Ctx, llvm::SmallString<1024>& contents)
-    {
-        if (!C)
-        {
-            return;
-        }
-        llvm::raw_svector_ostream os(contents);
-        if constexpr (std::derived_from<T, clang::comments::Comment>)
-        {
-            auto const* CC = static_cast<clang::comments::Comment const*>(C);
-            clang::SourceRange const R = CC->getSourceRange();
-            clang::SourceManager const& SM = Ctx.getSourceManager();
-            contents = clang::Lexer::getSourceText(
-                clang::CharSourceRange::getTokenRange(R),
-                SM,
-                Ctx.getLangOpts());
-        }
-    }
-
-    template <class T>
-    requires (!std::is_pointer_v<T>)
-    void
-    dumpCommentContent(T const& C, clang::ASTContext const& Ctx, llvm::SmallString<1024>& contents)
-    {
-        dumpCommentContent(&C, Ctx, contents);
-    }
-} // namespace detail
-
-#define MRDOCS_COMMENT_TRACE(D, C) \
-    llvm::SmallString<1024> MRDOCS_COMMENT_TRACE_UNIQUE_NAME;                 \
-    ::detail::dumpCommentContent(D, C, MRDOCS_COMMENT_TRACE_UNIQUE_NAME);        \
-    report::trace("{}", std::string_view(MRDOCS_COMMENT_TRACE_UNIQUE_NAME.str()))
-#endif
-
-
-/*  AST Types
-
-    Comment
-        abstract base for all comments
-
-        FullComment : Comment
-            The entire extracted comment(s) attached to a declaration.
-
-        InlineContentComment : Comment
-            contained within a block, abstract
-
-            TextComment : InlineContentComment
-                plain text
-
-            InlineCommandComment : InlineContentComment
-                command with args as inline content
-
-            HTMLTagComment : InlineContentComment
-                Abstract class for opening and closing HTML tags, inline content
-
-                HTMLStartTagComment : HTMLTagComment
-                    opening HTML tag with attributes.
-
-                HTMLEndTagComment : HTMLTagComment
-                     closing HTML tag.
-
-        BlockContentComment : Comment
-            Block content (contains inline content). abstract
-
-            ParagraphComment : BlockContentComment
-                A single paragraph that contains inline content.
-
-            BlockCommandComment : BlockContentComment
-                zero or more word-like arguments, then a paragraph
-
-                ParamCommandComment : BlockCommandComment
-                    describes a parameter
-
-                TParamCommandComment : BlockCommandComment
-                    describes a template parameter.
-
-                VerbatimBlockComment : BlockCommandComment
-                    A verbatim block command (e. g., preformatted code). Verbatim
-                    block has an opening and a closing command and contains multiple
-                    lines of text (VerbatimBlockLineComment nodes).
-
-                VerbatimLineComment : BlockCommandComment
-                    A verbatim line command.  Verbatim line has an opening command,
-                    a single line of text (up to the newline after the opening command)
-                    and has no closing command.
-
-        VerbatimBlockLineComment : Comment
-            A line of text contained in a verbatim block.
-
-    BlockCommandComment
-        Always has one child of type ParagraphComment child?
-
-*/
-
-namespace mrdocs {
-
-namespace {
-
-//------------------------------------------------
-
-/** A visitor for extracting javadoc from comments.
-
-    This class is a visitor for extracting javadoc from
-    comments in `clang::comments::FullComment` objects.
-
-  */
-class JavadocVisitor
-    : public clang::comments::ConstCommentVisitor<JavadocVisitor>
-{
-    Config const& config_;
-    clang::ASTContext const& ctx_;
-    clang::SourceManager const& sm_;
-    clang::comments::FullComment const* FC_;
-    Javadoc jd_;
-    Diagnostics& diags_;
-    doc::Block* block_ = nullptr;
-    doc::Text* last_child_ = nullptr;
-    std::size_t htmlTagNesting_ = 0;
-
-    // Used to visit children of a comment
-    clang::comments::Comment const* parent_ = nullptr;
-    clang::comments::Comment::child_iterator it_{};
-    clang::comments::Comment::child_iterator end_{};
-
-    /** Ensure that a string is valid UTF-8.
-
-        This function checks if the specified string is valid
-        UTF-8, and if not it fixes it and returns the result.
-
-     */
-    static std::string& ensureUTF8(std::string&&);
-
-    /** Visit the children of a comment.
-
-        This is a helper function that sets the current
-        iterator to the beginning of the children of the
-        specified comment, and then restores the original
-        iterator when the function returns.
-
-        The children of the comment are visited in order
-        and appended to the current block.
-
-     */
-    void visitChildren(clang::comments::Comment const* C);
-
-
-    /** Temporarily set a block as the current block.
-
-        This sets the current block of the visitor to the
-        specified block, and restores the previous block
-        when the scope is exited.
-
-        The current block is where the visitor will
-        append new children when visiting comments.
-
-     */
-    class [[nodiscard]] BlockScope
-    {
-        JavadocVisitor& visitor_;
-        doc::Block* prev_;
-
-    public:
-        BlockScope(
-            JavadocVisitor& visitor,
-            doc::Block* blk)
-            : visitor_(visitor)
-            , prev_(visitor.block_)
-        {
-            visitor_.block_ = blk;
-            visitor_.last_child_ = nullptr;
-        }
-
-        ~BlockScope()
-        {
-            visitor_.block_ = prev_;
-            visitor_.last_child_ = nullptr;
-        }
-    };
-
-    /** Enter a block scope.
-
-        This function creates a `BlockScope` object associated
-        to the visitor to temporarily set the current block to
-        the specified block.
-
-        New children will be appended to the specified block
-        until the `BlockScope` object goes out of scope.
-
-        @param blk The block to set as the current block
-        @returns A `BlockScope` object that will restore
-                 the previous block when it goes out of scope
-
-     */
-    BlockScope enterScope(doc::Block& blk)
-    {
-        return {*this, &blk};
-    }
-
-    struct TagComponents
-    {
-        std::string tag;
-        std::string text;
-        std::size_t n_siblings{0};
-    };
-
-public:
-    /** Constructor
-
-        Construct a JavadocVisitor to visit the specified
-        comment and extract javadoc from it.
-
-        @param FC The full comment to visit
-        @param D The declaration to which the comment is attached
-        @param config The MrDocs configuration
-        @param diags The diagnostics sink
-
-     */
-    JavadocVisitor(
-        clang::comments::FullComment const*, clang::Decl const*,
-        Config const&, Diagnostics&);
-
-    /** Extract the javadoc from the comment.
-
-        The comment specified in the constructor is visited
-        and the javadoc is extracted. The result is returned
-        by the function.
-
-     */
-    Javadoc build();
-
-    /** Visit any abstract comment.
-
-        This is the base case for all comments.
-        It simply attempts to visit the children
-        of the comment.
-
-     */
-    void
-    visitComment(clang::comments::Comment const* C);
-
-    /** Visit a plain text comment.
-     */
-    void
-    visitTextComment(clang::comments::TextComment const* C);
-
-    /** Visit an opening HTML tag with attributes.
-     */
-    void
-    visitHTMLStartTagComment(clang::comments::HTMLStartTagComment const* C);
-
-    /** Visit a closing HTML tag.
-     */
-    void
-    visitHTMLEndTagComment(clang::comments::HTMLEndTagComment const* C);
-
-    /** Visit a command with word-like arguments that is considered inline content.
-
-        This is a command with word-like arguments that is considered
-        inline content. The number of arguments depends on the command
-        name.
-
-        For instance, this could be something like "@ref foo",
-        where "foo" is the argument.
-
-     */
-    void
-    visitInlineCommandComment(clang::comments::InlineCommandComment const* C);
-
-    /** Fix a reference string
-
-        The clang parser considers all chars up to the first
-        whitespace as part of the reference.
-
-        In some cases, this causes the reference to be incomplete,
-        especially when handling a function signature. In this
-        case, we have to extract the text from the next comments
-        to complete the reference.
-
-        In other cases, the reference may contain characters that
-        are not valid in identifiers. For instance, when the
-        identifier is followed by punctuation. In this case, we
-        have to truncate the reference at the last valid identifier
-        character.
-
-        @param ref The reference string to fix
-        @return Any leftover text that removed from the reference
-     */
-    std::string
-    fixReference(std::string& ref);
-
-    /** Visit a single paragraph that contains inline content.
-     */
-    void
-    visitParagraphComment(clang::comments::ParagraphComment const* C);
-
-    /** Visit a command that has zero or more word-like arguments
-
-       The number of word-like arguments depends on command name and
-       a paragraph as an argument (e. g., @brief).
-
-     */
-    void
-    visitBlockCommandComment(clang::comments::BlockCommandComment const* C);
-
-    /** Visit the doxygen @param command.
-     */
-    void
-    visitParamCommandComment(clang::comments::ParamCommandComment const* C);
-
-
-    /** Visit the doxygen @tparam command
-
-        The @tparam describes a template parameter.
-    */
-    void
-    visitTParamCommandComment(clang::comments::TParamCommandComment const* C);
-
-    /** Visit a verbatim block command (e. g., preformatted code).
-
-        Verbatim block has an opening and a closing command and contains
-        multiple lines of text (VerbatimBlockLineComment nodes).
-     */
-    void
-    visitVerbatimBlockComment(clang::comments::VerbatimBlockComment const* C);
-
-    /** Visit a verbatim line command.
-
-        Verbatim line has an opening command, a single line of text
-        (up to the newline after the opening command) and has no
-        closing command.
-     */
-    void
-    visitVerbatimLineComment(clang::comments::VerbatimLineComment const* C);
-
-    /** Visit a line of text contained in a verbatim block.
-     */
-    void
-    visitVerbatimBlockLineComment(clang::comments::VerbatimBlockLineComment const* C);
-
-    /** @name Helpers
-     * @{
-     */
-
-    /** Check if the number of arguments is correct for a command.
-
-        This function checks if the number of arguments
-        in the specified command is correct, and if not
-        it emits a diagnostic and returns false.
-
-        @returns `true` if the number of arguments is correct
-     */
-    bool
-    goodArgCount(std::size_t n, clang::comments::InlineCommandComment const& C);
-
-
-    Expected<TagComponents>
-    parseHTMLTag(clang::comments::HTMLStartTagComment const* C);
-
-    /** Append a text node to the current block.
-
-        This function appends a text node to the current
-        block.
-
-        If the previous child appended was of the same type,
-        the content is merged instead of creating a new node.
-
-        If the text ends with a newline, it sets the last
-        child to null to indicate the next element cannot be
-        merged.
-
-        @param end_with_nl `true` if the text ends with a newline
-        @param args The arguments to construct the text node
-     */
-    template<std::derived_from<doc::Text> TextTy, typename... Args>
-    void
-    emplaceText(bool const end_with_nl, Args&&... args)
-    {
-        TextTy elem(std::forward<Args>(args)...);
-        bool can_merge = false;
-
-        if (last_child_ && last_child_->Kind == elem.Kind)
-        {
-            if constexpr(TextTy::static_kind == doc::NodeKind::text)
-                can_merge = true;
-
-            if constexpr(TextTy::static_kind == doc::NodeKind::styled)
-                can_merge = dynamic_cast<doc::Styled*>(
-                    last_child_)->style == elem.style;
-        }
-
-        if (!can_merge)
-        {
-            last_child_ = &*block_->children.emplace_back(
-                std::in_place_type<TextTy>, std::move(elem));
-        }
-        else
-        {
-            last_child_->string.append(elem.string);
-        }
-
-        if (end_with_nl)
-        {
-            last_child_ = nullptr;
-        }
-    }
-
-    /** @} */
-};
-
-//------------------------------------------------
-
-std::string &JavadocVisitor::ensureUTF8(std::string &&s) {
-  if (!llvm::json::isUTF8(s))
-    s = llvm::json::fixUTF8(s);
-  return static_cast<std::string &>(s);
-}
-
-/*  Parse the inline content of a text
-
-    This function takes a string from a comment
-    and parses it into a sequence of styled text
-    nodes.
-
-    The string may contain inline commands that
-    change the style of the text:
-
-    Regular text is stored as a doc::Text.
-    Styled text is stored as a doc::Styled.
-
-    The styles can be one of: mono, bold, or italic.
-
-    The tags "`", "*", and "_" are used to indicate
-    the start and end of styled text. They can be
-    escaped by prefixing them with a backslash.
-
- */
-std::vector<Polymorphic<doc::Text>>
-parseStyled(llvm::StringRef s)
-{
-    std::vector<Polymorphic<doc::Text>> result;
-    std::string currentText;
-    auto currentStyle = doc::Style::none;
-    bool escapeNext = false;
-
-    auto isStyleMarker = [](char c) {
-        return c == '`' || c == '*' || c == '_';
-    };
-
-    auto flushCurrentText = [&]() {
-        if (!currentText.empty()) {
-            if (currentStyle == doc::Style::none) {
-                bool const lastIsSame =
-                    !result.empty() &&
-                    result.back()->Kind == doc::NodeKind::text;
-                if (lastIsSame)
-                {
-                    auto& lastText = static_cast<doc::Text&>(*result.back());
-                    lastText.string.append(currentText);
-                }
-                else
-                {
-                    result.emplace_back(std::in_place_type<doc::Text>,
-                                        std::move(currentText));
-                }
-            } else {
-                bool const lastIsSame =
-                    !result.empty() &&
-                    result.back()->Kind == doc::NodeKind::styled &&
-                    dynamic_cast<doc::Styled&>(*result.back()).style == currentStyle;
-                if (lastIsSame)
-                {
-                    auto& lastStyled = dynamic_cast<doc::Styled&>(*result.back());
-                    lastStyled.string.append(currentText);
-                }
-                else
-                {
-                    result.emplace_back(std::in_place_type<doc::Styled>,
-                                        std::move(currentText), currentStyle);
-                }
-            }
-            currentText.clear();
-        }
-    };
-
-    auto isPunctuationOrSpace = [](unsigned char c) {
-        return std::isspace(c) || std::ispunct(c);
-    };
-
-    for (std::size_t i = 0; i < s.size(); ++i) {
-        char c = s[i];
-        if (escapeNext) {
-            currentText.push_back(c);
-            escapeNext = false;
-        } else if (c == '\\') {
-            escapeNext = true;
-        } else if (isStyleMarker(c)) {
-            bool const atWordBoundary =
-                (currentStyle == doc::Style::none && ((i == 0) || isPunctuationOrSpace(s[i - 1]))) ||
-                (currentStyle != doc::Style::none && ((i == s.size() - 1) || isPunctuationOrSpace(s[i + 1])));
-            if (atWordBoundary) {
-                flushCurrentText();
-                if (c == '`') {
-                    currentStyle = (currentStyle == doc::Style::mono) ? doc::Style::none : doc::Style::mono;
-                } else if (c == '*') {
-                    currentStyle = (currentStyle == doc::Style::bold) ? doc::Style::none : doc::Style::bold;
-                } else if (c == '_') {
-                    currentStyle = (currentStyle == doc::Style::italic) ? doc::Style::none : doc::Style::italic;
-                }
-            } else {
-                currentText.push_back(c);
-            }
-        } else {
-            currentText.push_back(c);
-        }
-    }
-
-    // Whatever style we started, we should end it because
-    // we reached the end of the string without a closing
-    // marker.
-    currentStyle = doc::Style::none;
-    flushCurrentText();
-
-    return result;
-}
-
-void
-JavadocVisitor::
-visitChildren(
-    clang::comments::Comment const* C)
-{
-    MRDOCS_COMMENT_TRACE(C, ctx_);
-    ScopeExitRestore s1(it_, C->child_begin());
-    ScopeExitRestore s2(end_, C->child_end());
-    ScopeExitRestore s3(parent_, C);
-    while(it_ != end_)
-    {
-        MRDOCS_COMMENT_TRACE(*it_, ctx_);
-        visit(*it_);
-        ++it_;
-    }
-
-    if (!block_)
-    {
-        return;
-    }
-
-    bool const isVerbatim = block_->Kind == doc::NodeKind::code;
-    if (isVerbatim)
-    {
-        return;
-    }
-
-    // Merge consecutive plain text nodes in the current block
-    auto it = block_->children.begin();
-    while(it != block_->children.end())
-    {
-        if (auto& child = *it;
-            child->Kind == doc::NodeKind::text)
-        {
-            auto* text = dynamic_cast<doc::Text*>(child.operator->());
-            MRDOCS_ASSERT(text);
-            auto next = std::next(it);
-            if(next != block_->children.end())
-            {
-                if((*next)->Kind == doc::NodeKind::text)
-                {
-                    auto* next_text = dynamic_cast<doc::Text*>(next->operator->());
-                    MRDOCS_ASSERT(next_text);
-                    text->string.append(next_text->string);
-                    it = block_->children.erase(next);
-                    continue;
-                }
-            }
-        }
-        ++it;
-    }
-
-    // Parse any Text nodes for styled text
-    for (auto cIt = block_->children.begin(); cIt != block_->children.end();)
-    {
-        MRDOCS_ASSERT(cIt->operator->());
-        if ((*cIt)->Kind == doc::NodeKind::text)
-        {
-            auto* text = dynamic_cast<doc::Text*>(cIt->operator->());
-            auto styledText = parseStyled(text->string);
-            std::size_t const offset = std::distance(block_->children.begin(), cIt);
-            std::size_t const n = styledText.size();
-            block_->children.erase(cIt);
-            block_->children.insert(
-                block_->children.begin() + offset,
-                std::make_move_iterator(styledText.begin()),
-                std::make_move_iterator(styledText.end()));
-            cIt = block_->children.begin() + offset + n;
-        }
-        else
-        {
-            ++cIt;
-        }
-    }
-}
-
-//------------------------------------------------
-
-JavadocVisitor::
-JavadocVisitor(
-    clang::comments::FullComment const* FC,
-    clang::Decl const* D,
-    Config const& config,
-    Diagnostics& diags)
-    : config_(config)
-    , ctx_(D->getASTContext())
-    , sm_(ctx_.getSourceManager())
-    , FC_(FC)
-    , diags_(diags)
-{
-}
-
-Javadoc
-JavadocVisitor::
-build()
-{
-    MRDOCS_COMMENT_TRACE(FC_, ctx_);
-    visit(FC_);
-
-    // Merge ListItems into UnorderedList
-    auto& blocks = jd_.getBlocks();
-    for (auto it = blocks.begin(); it != blocks.end(); ) {
-        if ((*it)->Kind == doc::NodeKind::list_item) {
-            doc::UnorderedList ul;
-            // Find last list item
-            auto const begin = it;
-            auto last = it;
-            while (last != blocks.end() && (*last)->Kind == doc::NodeKind::list_item) {
-                ++last;
-            }
-            // Move list items to ul.items
-            ul.items.reserve(std::distance(it, last));
-            for (auto li_it = begin; li_it != last; ++li_it) {
-                auto *li = dynamic_cast<doc::ListItem *>(&**li_it);
-                MRDOCS_ASSERT(li != nullptr);
-                ul.items.emplace_back(std::move(*li));
-            }
-            // Remove the list items and insert the ul
-            it = blocks.erase(begin, last);
-            it = blocks.emplace(
-                it,
-                std::in_place_type<doc::UnorderedList>,
-                std::move(ul));
-        }
-        ++it;
-    }
-
-    return std::move(jd_);
-}
-
-void
-JavadocVisitor::
-visitComment(
-    clang::comments::Comment const* C)
-{
-    MRDOCS_COMMENT_TRACE(C, ctx_);
-    visitChildren(C);
-}
-
-//------------------------------------------------
-//
-// inline content
-//
-//------------------------------------------------
-
-void
-JavadocVisitor::
-visitTextComment(
-    clang::comments::TextComment const* C)
-{
-    MRDOCS_COMMENT_TRACE(C, ctx_);
-    llvm::StringRef s = C->getText();
-    // If this is the first text comment in the
-    // paragraph then remove all the leading space.
-    // Otherwise, just remove the trailing space.
-    if (block_->children.empty())
-    {
-        s = s.ltrim();
-    }
-
-    // Only insert non-empty text nodes
-    if (!s.empty())
-    {
-        emplaceText<doc::Text>(
-            C->hasTrailingNewline(),
-            ensureUTF8(s.str()));
-    }
-}
-
-Expected<JavadocVisitor::TagComponents>
-JavadocVisitor::
-parseHTMLTag(clang::comments::HTMLStartTagComment const* C)
-{
-    MRDOCS_COMMENT_TRACE(C, ctx_);
-    TagComponents res;
-    res.tag = C->getTagName().str();
-
-    static constexpr std::array noEndTagTags =
-            {"br", "img", "input", "hr", "meta", "link", "base", "area", "col",
-             "command", "embed", "keygen", "param", "source", "track", "wbr"};
-    bool const requiresEndTag = std::ranges::find(noEndTagTags, res.tag) == noEndTagTags.end();
-    if (!requiresEndTag)
-    {
-        return res;
-    }
-
-    // Find Comment::HTMLEndTagCommentKind
-    auto const tagEndIt =
-        requiresEndTag ? std::ranges::find_if(it_ + 1, end_, [](clang::comments::Comment const* c)
-        {
-            return c->getCommentKind() == clang::comments::CommentKind::HTMLEndTagComment;
-        }) : it_;
-    if (tagEndIt == end_)
-    {
-        return Unexpected(formatError("warning: HTML <{}> tag not followed by end tag", res.tag));
-    }
-
-    // Check if end tag matches start tag
-    auto const& cEndTag =
-        *static_cast<clang::comments::HTMLEndTagComment const*>(*tagEndIt);
-    if(cEndTag.getTagName() != res.tag)
-    {
-      return Unexpected(Error(std::format(
-          "warning: HTML <{}> tag not followed by same end tag (</{}> found)",
-          res.tag, cEndTag.getTagName().str())));
-    }
-
-    // Check if all the siblings are text nodes
-    bool const areAllText = std::all_of(it_ + 1, tagEndIt, [](clang::comments::Comment const* c)
-    {
-        return c->getCommentKind() == clang::comments::CommentKind::TextComment;
-    });
-    if (!areAllText)
-    {
-      return Unexpected(Error(
-          std::format("warning: HTML <{}> tag not followed by text", res.tag)));
-    }
-
-    // Extract text from all the siblings
-    res.n_siblings = std::distance(it_, tagEndIt);
-    for (auto it = std::next(it_); it != tagEndIt; ++it)
-    {
-        auto const& cText =
-            *static_cast<clang::comments::TextComment const*>(*it);
-        res.text += cText.getText();
-    }
-
-    return res;
-}
-
-void
-JavadocVisitor::
-visitHTMLStartTagComment(
-    clang::comments::HTMLStartTagComment const* C)
-{
-    MRDOCS_COMMENT_TRACE(C, ctx_);
-    MRDOCS_ASSERT(C->child_begin() == C->child_end());
-    clang::PresumedLoc const loc = sm_.getPresumedLoc(C->getBeginLoc());
-    auto filename = files::makePosixStyle(loc.getFilename());
-
-    auto getAttribute = [&C](llvm::StringRef name) -> Expected<std::string>
-    {
-        auto idxs = std::views::iota(unsigned(0), C->getNumAttrs());
-        auto attr_it = std::ranges::find_if(idxs, [&C, name](std::size_t i)
-        {
-            return C->getAttr(i).Name == name;
-        });
-        if (attr_it == idxs.end())
-        {
-          return Unexpected(
-              Error(std::format("warning: HTML <{}> tag has no {} attribute",
-                                C->getTagName().str(), name.str())));
-        }
-        return C->getAttr(*attr_it).Value.str();
-    };
-
-    last_child_ = nullptr;
-    auto tagComponentsExp = parseHTMLTag(C);
-    if (!tagComponentsExp)
-    {
-        Error e = tagComponentsExp.error();
-        report::error("{} at {} ({})", e.message(), filename, loc.getLine());
-        return;
-    }
-    auto tagComponents = *tagComponentsExp;
-    if(tagComponents.tag == "a")
-    {
-        auto r = getAttribute("href");
-        if (!r)
-        {
-            report::error(r.error().message());
-            return;
-        }
-        std::string href = *r;
-        emplaceText<doc::Link>(
-            C->hasTrailingNewline(),
-            ensureUTF8(std::move(tagComponents.text)),
-            ensureUTF8(std::move(href)));
-    }
-    else if(tagComponents.tag == "br")
-    {
-        emplaceText<doc::Text>(true,"");
-    }
-    else if(tagComponents.tag == "em")
-    {
-        emplaceText<doc::Styled>(
-            C->hasTrailingNewline(),
-            ensureUTF8(std::move(tagComponents.text)),
-            doc::Style::italic);
-    }
-    else
-    {
-      report::warn(
-          std::format("warning: unsupported HTML tag <{}>", tagComponents.tag),
-          filename, loc.getLine());
-    }
-    // Skip the children we consumed in parseHTMLTag
-    it_ += tagComponents.n_siblings;
-    --htmlTagNesting_;
-}
-
-void
-JavadocVisitor::
-visitHTMLEndTagComment(
-    clang::comments::HTMLEndTagComment const* C)
-{
-    MRDOCS_COMMENT_TRACE(C, ctx_);
-    MRDOCS_ASSERT(C->child_begin() == C->child_end());
-    --htmlTagNesting_;
-}
-
-static
-doc::Parts
-convertCopydoc(unsigned id)
-{
-    switch(id)
-    {
-    case clang::comments::CommandTraits::KCI_copydoc:
-        return doc::Parts::all;
-    case clang::comments::CommandTraits::KCI_copybrief:
-        return doc::Parts::brief;
-    case clang::comments::CommandTraits::KCI_copydetails:
-        return doc::Parts::description;
-    default:
-    {
-        report::error("error: unsupported CommandTrait id <{}>", id);
-        MRDOCS_UNREACHABLE();
-    }
-    }
-}
-
-static
-doc::Style
-convertStyle(clang::comments::InlineCommandRenderKind kind)
-{
-    switch(kind)
-    {
-    case clang::comments::InlineCommandRenderKind::Monospaced:
-        return doc::Style::mono;
-    case clang::comments::InlineCommandRenderKind::Bold:
-        return doc::Style::bold;
-    case clang::comments::InlineCommandRenderKind::Emphasized:
-        return doc::Style::italic;
-    case clang::comments::InlineCommandRenderKind::Normal:
-    case clang::comments::InlineCommandRenderKind::Anchor:
-        return doc::Style::none;
-    default:
-        // unknown RenderKind
-        report::error("error: unsupported clang::comments::InlineCommandRenderKind <{}>", static_cast<int>(kind));
-        MRDOCS_UNREACHABLE();
-    }
-}
-
-static
-doc::ParamDirection
-convertDirection(clang::comments::ParamCommandPassDirection kind)
-{
-    switch(kind)
-    {
-    case clang::comments::ParamCommandPassDirection::In:
-        return doc::ParamDirection::in;
-    case clang::comments::ParamCommandPassDirection::Out:
-        return doc::ParamDirection::out;
-    case clang::comments::ParamCommandPassDirection::InOut:
-        return doc::ParamDirection::inout;
-    default:
-        report::error("error: unsupported clang::comments::ParamCommandPassDirection <{}>", static_cast<int>(kind));
-        MRDOCS_UNREACHABLE();
-    }
-}
-
-void
-JavadocVisitor::
-visitInlineCommandComment(
-    clang::comments::InlineCommandComment const* C)
-{
-    MRDOCS_COMMENT_TRACE(C, ctx_);
-    auto const* cmd = ctx_
-        .getCommentCommandTraits()
-        .getCommandInfo(C->getCommandID());
-
-    // VFALCO I'd like to know when this happens
-    MRDOCS_ASSERT(cmd != nullptr);
-
-    switch(unsigned ID = cmd->getID())
-    {
-    // Newline
-    case clang::comments::CommandTraits::KCI_n:
-    {
-        if(! goodArgCount(0, *C))
-            return;
-        last_child_ = nullptr;
-        emplaceText<doc::Text>(true, "\n");
-        return;
-    }
-    // Emphasis
-    case clang::comments::CommandTraits::KCI_a:
-    case clang::comments::CommandTraits::KCI_e:
-    case clang::comments::CommandTraits::KCI_em:
-    {
-        MRDOCS_CHECK_OR(goodArgCount(1, *C));
-        auto style = doc::Style::italic;
-        emplaceText<doc::Styled>(
-            C->hasTrailingNewline(),
-            C->getArgText(0).str(),
-            style);
-        return;
-    }
-
-    // copy
-    case clang::comments::CommandTraits::KCI_copybrief:
-    case clang::comments::CommandTraits::KCI_copydetails:
-    case clang::comments::CommandTraits::KCI_copydoc:
-    {
-        MRDOCS_CHECK_OR(goodArgCount(1, *C));
-        std::string ref = C->getArgText(0).str();
-        std::string leftOver = fixReference(ref);
-        bool const hasExtra = !leftOver.empty();
-        doc::Parts const parts = convertCopydoc(ID);
-        bool const copyBrief = parts == doc::Parts::brief || parts == doc::Parts::all;
-        bool const copyDetails = parts == doc::Parts::description || parts == doc::Parts::all;
-        MRDOCS_ASSERT(copyBrief || copyDetails);
-        if (copyBrief)
-        {
-            // The brief is metadata associated with the javadoc
-            if (!jd_.brief)
-            {
-                jd_.brief.emplace();
-            }
-            if (!contains(jd_.brief->copiedFrom, ref))
-            {
-                jd_.brief->copiedFrom.emplace_back(ref);
-            }
-        }
-        if (copyDetails)
-        {
-            // The details are in the main body of the javadoc
-            // and are replaced at the same position as the command
-            emplaceText<doc::CopyDetails>(
-                C->hasTrailingNewline() && !hasExtra,
-                ref);
-        }
-        if (hasExtra)
-        {
-            emplaceText<doc::Text>(
-                C->hasTrailingNewline(),
-                leftOver);
-        }
-        return;
-    }
-    case clang::comments::CommandTraits::KCI_ref:
-    {
-        MRDOCS_CHECK_OR(goodArgCount(1, *C));
-        std::string ref = C->getArgText(0).str();
-        std::string leftOver = fixReference(ref);
-        bool const hasExtra = !leftOver.empty();
-        emplaceText<doc::Reference>(
-            C->hasTrailingNewline() && !hasExtra,
-            ref);
-        if (hasExtra)
-        {
-            emplaceText<doc::Text>(
-                C->hasTrailingNewline(),
-                leftOver);
-        }
-        return;
-    }
-    // KRYSTIAN FIXME: these need to be made inline commands in clang
-    case clang::comments::CommandTraits::KCI_related:
-    case clang::comments::CommandTraits::KCI_relates:
-    // MrDocs doesn't document members inline, so there's no
-    // distinction between "related" and "relatedalso"
-    case clang::comments::CommandTraits::KCI_relatedalso:
-    case clang::comments::CommandTraits::KCI_relatesalso:
-    // Member of is a concept used only in C. MrDocs handles
-    // it as a non-member function is all cases.
-    case clang::comments::CommandTraits::KCI_memberof:
-    {
-        MRDOCS_CHECK_OR(goodArgCount(1, *C));
-        std::string ref = C->getArgText(0).str();
-        std::string leftOver = fixReference(ref);
-        bool const hasExtra = !leftOver.empty();
-        jd_.relates.emplace_back(std::move(ref));
-        if (hasExtra)
-        {
-            emplaceText<doc::Text>(
-                    C->hasTrailingNewline(),
-                    leftOver);
-        }
-        return;
-    }
-
-    default:
-        break;
-    }
-
-    // It looks like the clang parser does not
-    // emit nested styles, so only one inline
-    // style command can be applied per args.
-    std::string s;
-    std::size_t n = 0;
-    for (unsigned i = 0; i < C->getNumArgs(); ++i)
-    {
-        n += C->getArgText(i).size();
-    }
-    s.reserve(n);
-    for (unsigned i = 0; i < C->getNumArgs(); ++i)
-    {
-        s.append(C->getArgText(i));
-    }
-
-    if (doc::Style style = convertStyle(C->getRenderKind());
-        style != doc::Style::none)
-    {
-        emplaceText<doc::Styled>(C->hasTrailingNewline(), std::move(s), style);
-    } else
-    {
-        emplaceText<doc::Text>(C->hasTrailingNewline(), std::move(s));
-    }
-}
-
-std::string
-JavadocVisitor::
-fixReference(std::string& ref)
-{
-    auto peekNextIt = [&]() -> Optional<std::string_view>
-    {
-        ++it_;
-        if (it_ == end_ ||
-            (*it_)->getCommentKind() != clang::comments::CommentKind::TextComment)
-        {
-            --it_;
-            return std::nullopt;
-        }
-        clang::comments::Comment const* c = *it_;
-        std::string_view text = static_cast<clang::comments::TextComment const*>(c)->getText();
-        --it_;
-        return text;
-    };
-
-    ParsedRef v;
-    while (true)
-    {
-        // Attempt to parse ref
-        char const* first = ref.data();
-        char const* last = first + ref.size();
-        auto const pres = parse(first, last, v);
-        if (!pres)
-        {
-            // The ref could not be parsed, add content from next
-            // text comment to the ref
-            auto const nextTextOpt = peekNextIt();
-            if (!nextTextOpt)
-            {
-                return {};
-            }
-            ref += *nextTextOpt;
-            ++it_;
-            continue;
-        }
-
-        // The ref is not fully parsed
-        if (pres.ptr != last)
-        {
-            // The ref didn't consume all the text, so we need to
-            // remove the leftover text from the ref and return it
-            auto leftover = std::string(pres.ptr, last - pres.ptr);
-            // If leftover is only whitespace, the ref might need
-            // the next text comment to complete it.
-            if (!isWhitespace(leftover))
-            {
-                ref.erase(pres.ptr - first);
-                return leftover;
-            }
-        }
-
-        // The ref is fully parsed, but we might want to
-        // include the next text comment if it contains
-        // a valid continuation to the ref.
-        bool const mightHaveMoreQualifiers =
-            v.HasFunctionParameters &&
-            v.ExceptionSpec.Implicit &&
-            v.ExceptionSpec.Operand.empty();
-        if (mightHaveMoreQualifiers)
-        {
-            llvm::SmallVector<std::string_view, 4> potentialQualifiers;
-            if (v.Kind == ReferenceKind::None)
-            {
-                // "&&" or "&" not defined yet
-                if (!v.IsConst)
-                {
-                    potentialQualifiers.push_back("const");
-                }
-                if (!v.IsVolatile)
-                {
-                    potentialQualifiers.push_back("volatile");
-                }
-                potentialQualifiers.push_back("&");
-            }
-            else if (
-                v.Kind == ReferenceKind::LValue &&
-                ref.ends_with('&'))
-            {
-                // The second "&" might be in the next Text block
-                potentialQualifiers.push_back("&");
-            }
-            potentialQualifiers.push_back("noexcept");
-            auto const nextTextOpt = peekNextIt();
-            if (!nextTextOpt)
-            {
-                auto leftover = std::string(pres.ptr, last - pres.ptr);
-                ref.erase(pres.ptr - first);
-                return leftover;
-            }
-            std::string_view const nextText = *nextTextOpt;
-            std::string_view const trimmed = ltrim(nextText);
-            if (trimmed.empty() ||
-                std::ranges::any_of(
-                    potentialQualifiers,
-                    [&](std::string_view s)
-                    {
-                        return trimmed.starts_with(s);
-                    }))
-            {
-                ref += nextText;
-                ++it_;
-                continue;
-            }
-        }
-
-        // The ref might have more components
-        bool const mightHaveMoreComponents =
-            !v.HasFunctionParameters;
-        if (mightHaveMoreComponents)
-        {
-            auto const nextTextOpt = peekNextIt();
-            if (!nextTextOpt)
-            {
-                auto leftover = std::string(pres.ptr, last - pres.ptr);
-                ref.erase(pres.ptr - first);
-                return leftover;
-            }
-            std::string_view const nextText = *nextTextOpt;
-            std::string_view const trimmed = ltrim(nextText);
-            static constexpr std::string_view idChars
-                   = "abcdefghijklmnopqrstuvwxyz"
-                     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                     "0123456789"
-                     "_:";
-            if (trimmed.empty() ||
-                contains(idChars, trimmed.front()))
-            {
-                ref += nextText;
-                ++it_;
-                continue;
-            }
-        }
-
-        return {};
-    }
-}
-
-//------------------------------------------------
-//
-// block Content
-//
-//------------------------------------------------
-
-void
-JavadocVisitor::
-visitParagraphComment(
-    clang::comments::ParagraphComment const* C)
-{
-    MRDOCS_COMMENT_TRACE(C, ctx_);
-    if(block_)
-        return visitChildren(C);
-    doc::Paragraph paragraph;
-    auto scope = enterScope(paragraph);
-    visitChildren(C);
-    // VFALCO Figure out why we get empty ParagraphComment
-    if(! paragraph.empty())
-        jd_.emplace_back(std::move(paragraph));
-}
-
-void
-JavadocVisitor::
-visitBlockCommandComment(
-    clang::comments::BlockCommandComment const* C)
-{
-    MRDOCS_COMMENT_TRACE(C, ctx_);
-    auto const* cmd = ctx_
-        .getCommentCommandTraits()
-        .getCommandInfo(C->getCommandID());
-    if(cmd == nullptr)
-    {
-        // ignore this command and the
-        // text that follows for now.
-        return;
-    }
-
-    switch(cmd->getID())
-    {
-    case clang::comments::CommandTraits::KCI_brief:
-    case clang::comments::CommandTraits::KCI_short:
-    {
-        doc::Brief brief;
-        auto scope = enterScope(brief);
-        // Scope scope(brief, block_);
-        visitChildren(C->getParagraph());
-        // Here, we want empty briefs, because
-        // the @brief command was explicitly given.
-        if (!brief.children.empty())
-        {
-            jd_.brief.emplace(std::move(brief));
-        }
-        return;
-    }
-
-    case clang::comments::CommandTraits::KCI_return:
-    case clang::comments::CommandTraits::KCI_returns:
-    case clang::comments::CommandTraits::KCI_result:
-    {
-        doc::Returns returns;
-        auto scope = enterScope(returns);
-        visitChildren(C->getParagraph());
-        if (!returns.children.empty())
-        {
-            returns.children.front()->string = ltrim(returns.children.front()->string);
-            returns.children.back()->string = rtrim(returns.children.back()->string);
-            jd_.returns.push_back(std::move(returns));
-        }
-        return;
-    }
-    case clang::comments::CommandTraits::KCI_throw:
-    case clang::comments::CommandTraits::KCI_throws:
-    case clang::comments::CommandTraits::KCI_exception:
-    {
-        doc::Throws throws;
-        auto scope = enterScope(throws);
-        visitChildren(C->getParagraph());
-        if (C->getNumArgs())
-        {
-            throws.exception.string = C->getArgText(0);
-        }
-        else
-        {
-            throws.exception.string = "undefined";
-        }
-        jd_.exceptions.push_back(std::move(throws));
-        return;
-    }
-    case clang::comments::CommandTraits::KCI_note:
-    case clang::comments::CommandTraits::KCI_warning:
-    {
-        doc::Admonish admonish = cmd->getID() == clang::comments::CommandTraits::KCI_note
-            ? doc::Admonish::note
-            : doc::Admonish::warning;
-        doc::Admonition paragraph(admonish);
-        auto scope = enterScope(paragraph);
-        visitChildren(C->getParagraph());
-        jd_.emplace_back(std::move(paragraph));
-        return;
-    }
-    case clang::comments::CommandTraits::KCI_par:
-    {
-        // VFALCO This is legacy compatibility
-        // for Boost libraries using @par as a
-        // section heading.
-        doc::Paragraph paragraph;
-        auto scope = enterScope(paragraph);
-        visitChildren(C->getParagraph());
-        if (C->getNumArgs() > 0)
-        {
-            jd_.emplace_back(doc::Heading(C->getArgText(0).str()));
-        }
-        if (!paragraph.children.empty())
-        {
-            // the first TextComment is the heading text
-            if (C->getNumArgs() == 0)
-            {
-                std::string text(std::move(
-                        paragraph.children.front()->string));
-
-                // VFALCO Unfortunately clang puts at least
-                // one space in front of the text, which seems
-                // incorrect.
-                if (auto const s = trim(text);
-                    s.size() != text.size())
-                {
-                    text = s;
-                }
-
-                doc::Heading heading(std::move(text));
-                jd_.emplace_back(std::move(heading));
-
-                // remaining TextComment, if any
-                paragraph.children.erase(paragraph.children.begin());
-            }
-
-            if (!paragraph.children.empty())
-            {
-                jd_.emplace_back(std::move(paragraph));
-            }
-        }
-        return;
-    }
-    case clang::comments::CommandTraits::KCI_li:
-    {
-        doc::ListItem paragraph;
-        auto scope = enterScope(paragraph);
-        visitChildren(C->getParagraph());
-        jd_.emplace_back(std::move(paragraph));
-        return;
-    }
-    case clang::comments::CommandTraits::KCI_details:
-    {
-        doc::Paragraph paragraph;
-        auto scope = enterScope(paragraph);
-        visitChildren(C->getParagraph());
-        jd_.emplace_back(std::move(paragraph));
-        return;
-    }
-    case clang::comments::CommandTraits::KCI_see:
-    {
-        doc::See see;
-        auto scope = enterScope(see);
-        visitChildren(C->getParagraph());
-        jd_.sees.push_back(std::move(see));
-        return;
-    }
-    case clang::comments::CommandTraits::KCI_pre:
-    {
-        doc::Precondition pre;
-        auto scope = enterScope(pre);
-        visitChildren(C->getParagraph());
-        jd_.preconditions.push_back(std::move(pre));
-        return;
-    }
-    case clang::comments::CommandTraits::KCI_post:
-    {
-        doc::Postcondition post;
-        auto scope = enterScope(post);
-        visitChildren(C->getParagraph());
-        jd_.postconditions.push_back(std::move(post));
-        return;
-    }
-
-    case clang::comments::CommandTraits::KCI_addindex:
-    case clang::comments::CommandTraits::KCI_addtogroup:
-    case clang::comments::CommandTraits::KCI_anchor:
-    case clang::comments::CommandTraits::KCI_arg:
-    case clang::comments::CommandTraits::KCI_attention:
-    case clang::comments::CommandTraits::KCI_author:
-    case clang::comments::CommandTraits::KCI_authors:
-    case clang::comments::CommandTraits::KCI_b:
-    case clang::comments::CommandTraits::KCI_bug:
-    case clang::comments::CommandTraits::KCI_c:
-    case clang::comments::CommandTraits::KCI_callergraph:
-    case clang::comments::CommandTraits::KCI_callgraph:
-    case clang::comments::CommandTraits::KCI_category:
-    case clang::comments::CommandTraits::KCI_cite:
-    case clang::comments::CommandTraits::KCI_class:
-    case clang::comments::CommandTraits::KCI_code:
-    case clang::comments::CommandTraits::KCI_concept:
-    case clang::comments::CommandTraits::KCI_cond:
-    case clang::comments::CommandTraits::KCI_copyright:
-    case clang::comments::CommandTraits::KCI_date:
-    case clang::comments::CommandTraits::KCI_def:
-    case clang::comments::CommandTraits::KCI_defgroup:
-    case clang::comments::CommandTraits::KCI_deprecated:
-    case clang::comments::CommandTraits::KCI_diafile:
-    case clang::comments::CommandTraits::KCI_dir:
-    case clang::comments::CommandTraits::KCI_docbookinclude:
-    case clang::comments::CommandTraits::KCI_docbookonly:
-    case clang::comments::CommandTraits::KCI_dontinclude:
-    case clang::comments::CommandTraits::KCI_dot:
-    case clang::comments::CommandTraits::KCI_dotfile:
-    //case clang::comments::CommandTraits::KCI_doxyconfig:
-    case clang::comments::CommandTraits::KCI_else:
-    case clang::comments::CommandTraits::KCI_elseif:
-    case clang::comments::CommandTraits::KCI_emoji:
-    case clang::comments::CommandTraits::KCI_endcode:
-    case clang::comments::CommandTraits::KCI_endcond:
-    case clang::comments::CommandTraits::KCI_enddocbookonly:
-    case clang::comments::CommandTraits::KCI_enddot:
-    case clang::comments::CommandTraits::KCI_endhtmlonly:
-    case clang::comments::CommandTraits::KCI_endif:
-    case clang::comments::CommandTraits::KCI_endinternal:
-    case clang::comments::CommandTraits::KCI_endlatexonly:
-    //case clang::comments::CommandTraits::KCI_endlink:
-    case clang::comments::CommandTraits::KCI_endmanonly:
-    case clang::comments::CommandTraits::KCI_endmsc:
-    case clang::comments::CommandTraits::KCI_endparblock:
-    case clang::comments::CommandTraits::KCI_endrtfonly:
-    case clang::comments::CommandTraits::KCI_endsecreflist:
-    case clang::comments::CommandTraits::KCI_endverbatim:
-    case clang::comments::CommandTraits::KCI_enduml:
-    case clang::comments::CommandTraits::KCI_endxmlonly:
-    case clang::comments::CommandTraits::KCI_enum:
-    case clang::comments::CommandTraits::KCI_example:
-    case clang::comments::CommandTraits::KCI_extends:
-    case clang::comments::CommandTraits::KCI_flparen:  // @f(
-    case clang::comments::CommandTraits::KCI_frparen:  // @f)
-    case clang::comments::CommandTraits::KCI_fdollar:  // @f$
-    case clang::comments::CommandTraits::KCI_flsquare: // @f[
-    case clang::comments::CommandTraits::KCI_frsquare: // @f]
-    case clang::comments::CommandTraits::KCI_flbrace:  // @f{
-    case clang::comments::CommandTraits::KCI_frbrace:  // @f}
-    case clang::comments::CommandTraits::KCI_file:
-    //case clang::comments::CommandTraits::KCI_fileinfo:
-    case clang::comments::CommandTraits::KCI_fn:
-    case clang::comments::CommandTraits::KCI_headerfile:
-    case clang::comments::CommandTraits::KCI_hidecallergraph:
-    case clang::comments::CommandTraits::KCI_hidecallgraph:
-    case clang::comments::CommandTraits::KCI_hiderefby:
-    case clang::comments::CommandTraits::KCI_hiderefs:
-    case clang::comments::CommandTraits::KCI_hideinitializer:
-    case clang::comments::CommandTraits::KCI_htmlinclude:
-    case clang::comments::CommandTraits::KCI_htmlonly:
-    case clang::comments::CommandTraits::KCI_idlexcept:
-    case clang::comments::CommandTraits::KCI_if:
-    case clang::comments::CommandTraits::KCI_ifnot:
-    case clang::comments::CommandTraits::KCI_image:
-    case clang::comments::CommandTraits::KCI_implements:
-    case clang::comments::CommandTraits::KCI_include:
-    //case clang::comments::CommandTraits::KCI_includedoc:
-    //case clang::comments::CommandTraits::KCI_includelineno:
-    case clang::comments::CommandTraits::KCI_ingroup:
-    case clang::comments::CommandTraits::KCI_internal:
-    case clang::comments::CommandTraits::KCI_invariant:
-    case clang::comments::CommandTraits::KCI_interface:
-    case clang::comments::CommandTraits::KCI_latexinclude:
-    case clang::comments::CommandTraits::KCI_latexonly:
-    case clang::comments::CommandTraits::KCI_line:
-    //case clang::comments::CommandTraits::KCI_lineinfo:
-    case clang::comments::CommandTraits::KCI_link:
-    case clang::comments::CommandTraits::KCI_mainpage:
-    case clang::comments::CommandTraits::KCI_maninclude:
-    case clang::comments::CommandTraits::KCI_manonly:
-    case clang::comments::CommandTraits::KCI_memberof:
-    case clang::comments::CommandTraits::KCI_msc:
-    case clang::comments::CommandTraits::KCI_mscfile:
-    case clang::comments::CommandTraits::KCI_name:
-    case clang::comments::CommandTraits::KCI_namespace:
-    case clang::comments::CommandTraits::KCI_noop:
-    case clang::comments::CommandTraits::KCI_nosubgrouping:
-    case clang::comments::CommandTraits::KCI_overload:
-    case clang::comments::CommandTraits::KCI_p:
-    //case clang::comments::CommandTraits::KCI_package:
-    case clang::comments::CommandTraits::KCI_page:
-    case clang::comments::CommandTraits::KCI_paragraph:
-    case clang::comments::CommandTraits::KCI_param:
-    case clang::comments::CommandTraits::KCI_parblock:
-    case clang::comments::CommandTraits::KCI_private:
-    case clang::comments::CommandTraits::KCI_privatesection:
-    case clang::comments::CommandTraits::KCI_property:
-    case clang::comments::CommandTraits::KCI_protected:
-    case clang::comments::CommandTraits::KCI_protectedsection:
-    case clang::comments::CommandTraits::KCI_protocol:
-    case clang::comments::CommandTraits::KCI_public:
-    case clang::comments::CommandTraits::KCI_publicsection:
-    case clang::comments::CommandTraits::KCI_pure:
-    //case clang::comments::CommandTraits::KCI_qualifier:
-    //case clang::comments::CommandTraits::KCI_raisewarning:
-    case clang::comments::CommandTraits::KCI_ref:
-    case clang::comments::CommandTraits::KCI_refitem:
-    case clang::comments::CommandTraits::KCI_related:
-    case clang::comments::CommandTraits::KCI_relates:
-    case clang::comments::CommandTraits::KCI_relatedalso:
-    case clang::comments::CommandTraits::KCI_relatesalso:
-    case clang::comments::CommandTraits::KCI_remark:
-    case clang::comments::CommandTraits::KCI_remarks:
-
-    case clang::comments::CommandTraits::KCI_retval:
-    case clang::comments::CommandTraits::KCI_rtfinclude:
-    case clang::comments::CommandTraits::KCI_rtfonly:
-    case clang::comments::CommandTraits::KCI_sa:
-    case clang::comments::CommandTraits::KCI_secreflist:
-    case clang::comments::CommandTraits::KCI_section:
-    //case clang::comments::CommandTraits::KCI_showdate:
-    case clang::comments::CommandTraits::KCI_showinitializer:
-    case clang::comments::CommandTraits::KCI_showrefby:
-    case clang::comments::CommandTraits::KCI_showrefs:
-    case clang::comments::CommandTraits::KCI_since:
-    case clang::comments::CommandTraits::KCI_skip:
-    case clang::comments::CommandTraits::KCI_skipline:
-    case clang::comments::CommandTraits::KCI_snippet:
-    //case clang::comments::CommandTraits::KCI_snippetdoc:
-    //case clang::comments::CommandTraits::KCI_snippetlineno:
-    case clang::comments::CommandTraits::KCI_static:
-    case clang::comments::CommandTraits::KCI_startuml:
-    case clang::comments::CommandTraits::KCI_struct:
-    case clang::comments::CommandTraits::KCI_subpage:
-    case clang::comments::CommandTraits::KCI_subsection:
-    case clang::comments::CommandTraits::KCI_subsubsection:
-    case clang::comments::CommandTraits::KCI_tableofcontents:
-    case clang::comments::CommandTraits::KCI_test:
-    case clang::comments::CommandTraits::KCI_todo:
-    case clang::comments::CommandTraits::KCI_tparam:
-    case clang::comments::CommandTraits::KCI_typedef:
-    case clang::comments::CommandTraits::KCI_union:
-    case clang::comments::CommandTraits::KCI_until:
-    case clang::comments::CommandTraits::KCI_var:
-    case clang::comments::CommandTraits::KCI_verbatim:
-    case clang::comments::CommandTraits::KCI_verbinclude:
-    case clang::comments::CommandTraits::KCI_version:
-    //case clang::comments::CommandTraits::KCI_vhdlflow:
-    case clang::comments::CommandTraits::KCI_weakgroup:
-    case clang::comments::CommandTraits::KCI_xmlinclude:
-    case clang::comments::CommandTraits::KCI_xmlonly:
-    case clang::comments::CommandTraits::KCI_xrefitem:
-    /*
-        @$
-        @@
-        @\
-        @&
-        @~
-        @<
-        @=
-        @>
-        @#
-        @%
-        @"
-        @.
-        @::
-        @|
-        @--
-        @---
-    */
-        break;
-
-    // inline commands handled elsewhere
-    case clang::comments::CommandTraits::KCI_a:
-    case clang::comments::CommandTraits::KCI_e:
-    case clang::comments::CommandTraits::KCI_em:
-    case clang::comments::CommandTraits::KCI_n:
-    case clang::comments::CommandTraits::KCI_copybrief:
-    case clang::comments::CommandTraits::KCI_copydetails:
-        case clang::comments::CommandTraits::KCI_copydoc:
-        report::error("error: inline command {} should be handled elsewhere", cmd->Name);
-        MRDOCS_UNREACHABLE();
-    default:
-        report::error("error: unsupported block command {}", cmd->Name);
-        MRDOCS_UNREACHABLE();
-    }
-}
-
-void
-JavadocVisitor::
-visitParamCommandComment(
-    clang::comments::ParamCommandComment const* C)
-{
-    MRDOCS_COMMENT_TRACE(C, ctx_);
-    doc::Param param;
-    if(C->hasParamName())
-    {
-        param.name = ensureUTF8(C->getParamNameAsWritten().str());
-    }
-    else
-    {
-        // VFALCO report SourceLocation here
-        diags_.error("Missing parameter name in @param");
-        param.name = "@anon";
-    }
-    if(C->isDirectionExplicit())
-        param.direction = convertDirection(C->getDirection());
-
-    auto scope = enterScope(param);
-    visitChildren(C->getParagraph());
-
-    auto const itr = std::ranges::find_if(
-        jd_.getBlocks(),
-        [&](Polymorphic<doc::Block> const& b)
-    {
-        if (b->Kind != doc::NodeKind::param)
-        {
-            return false;
-        }
-        auto p = dynamic_cast<doc::Param const*>(b.operator->());
-        MRDOCS_ASSERT(p != nullptr);
-        return p->name == param.name;
-    });
-    if (itr != jd_.getBlocks().end())
-    {
-        report::warn(
-            "{}: Duplicate @param for argument {}",
-            C->getBeginLoc().printToString(sm_), param.name);
-    }
-
-    // We want the node even if it is empty
-    jd_.params.push_back(std::move(param));
-}
-
-void
-JavadocVisitor::
-visitTParamCommandComment(
-    clang::comments::TParamCommandComment const* C)
-{
-    MRDOCS_COMMENT_TRACE(C, ctx_);
-    doc::TParam tparam;
-    if(C->hasParamName())
-    {
-        tparam.name = ensureUTF8(C->getParamNameAsWritten().str());
-    }
-    else
-    {
-        // VFALCO report SourceLocation here
-        diags_.error("Missing parameter name in @tparam");
-        tparam.name = "@anon";
-    }
-    auto scope = enterScope(tparam);
-    visitChildren(C->getParagraph());
-
-    auto const itr = std::ranges::find_if(
-        jd_.getBlocks(),
-        [&](Polymorphic<doc::Block> const& b)
-    {
-        if (b->Kind != doc::NodeKind::tparam)
-        {
-            return false;
-        }
-        auto const tp = dynamic_cast<doc::TParam const*>(b.operator->());
-        MRDOCS_ASSERT(tp != nullptr);
-        return tp->name == tparam.name;
-    });
-    if (itr != jd_.getBlocks().end())
-    {
-        report::warn(
-            "{}: Duplicate @tparam for argument {}",
-            C->getBeginLoc().printToString(sm_), tparam.name);
-    }
-
-    // We want the node even if it is empty
-    jd_.tparams.push_back(std::move(tparam));
-}
-
-void
-JavadocVisitor::
-visitVerbatimBlockComment(
-    clang::comments::VerbatimBlockComment const* C)
-{
-    MRDOCS_COMMENT_TRACE(C, ctx_);
-    doc::Code code;
-    auto scope = enterScope(code);
-    //if(C->hasNonWhitespaceParagraph())
-    visitChildren(C);
-    jd_.emplace_back(std::move(code));
-}
-
-void
-JavadocVisitor::
-visitVerbatimLineComment(
-    clang::comments::VerbatimLineComment const* C)
-{
-    MRDOCS_COMMENT_TRACE(C, ctx_);
-    // VFALCO This doesn't seem to be used
-    //        in any of my codebases, follow up
-}
-
-void
-JavadocVisitor::
-visitVerbatimBlockLineComment(
-    clang::comments::VerbatimBlockLineComment const* C)
-{
-    MRDOCS_COMMENT_TRACE(C, ctx_);
-    emplaceText<doc::Text>(true, C->getText().str());
-}
-
-//------------------------------------------------
-
-bool
-JavadocVisitor::
-goodArgCount(std::size_t n,
-    clang::comments::InlineCommandComment const& C)
-{
-    MRDOCS_COMMENT_TRACE(C, ctx_);
-    if(C.getNumArgs() != n)
-    {
-        auto loc = sm_.getPresumedLoc(C.getBeginLoc());
-
-        diags_.error(std::format("Expected {} but got {} args\n"
-                                 "File: {}, line {}, col {}\n",
-                                 n, C.getNumArgs(), loc.getFilename(),
-                                 loc.getLine(), loc.getColumn()));
-
-        return false;
-    }
-    return true;
-}
-
-//------------------------------------------------
-
-} // (anon)
-
-void
-initCustomCommentCommands(clang::ASTContext& context)
-{
-    auto& traits = context.getCommentCommandTraits();
-
-    {
-        //auto cmd = traits.registerBlockCommand("mrdocs");
-        //auto cmd = traits.registerBlockCommand("par");
-
-        //CommentOptions opt;
-        //opt.BlockCommandNames.push_back("par");
-        //traits.registerCommentOptions(opt);
-    }
-
-    (void)traits;
-}
-
-void
-parseJavadoc(
-    Optional<Javadoc>& jd,
-    clang::comments::FullComment const* FC,
-    clang::Decl const* D,
-    Config const& config,
-    Diagnostics& diags)
-{
-    MRDOCS_COMMENT_TRACE(FC, D->getASTContext());
-    JavadocVisitor visitor(FC, D, config, diags);
-    auto result = visitor.build();
-    if (!result.empty())
-    {
-        if (!jd)
-        {
-            jd = std::move(result);
-        }
-        else if(*jd != result)
-        {
-            // merge
-            jd->append(std::move(result));
-        }
-    }
-
-}
-
-} // mrdocs
diff --git a/src/lib/AST/ParseRef.cpp b/src/lib/AST/ParseRef.cpp
index 726be5344..541bff34e 100644
--- a/src/lib/AST/ParseRef.cpp
+++ b/src/lib/AST/ParseRef.cpp
@@ -10,7 +10,6 @@
 
 #include <lib/AST/ParseRef.hpp>
 #include <mrdocs/Metadata/Name.hpp>
-#include <mrdocs/Metadata/Symbol/Function.hpp>
 #include <mrdocs/Metadata/Type.hpp>
 #include <mrdocs/Support/Algorithm.hpp>
 #include <mrdocs/Support/Expected.hpp>
diff --git a/src/lib/CorpusImpl.cpp b/src/lib/CorpusImpl.cpp
index c8f68a0ed..e7cd73038 100644
--- a/src/lib/CorpusImpl.cpp
+++ b/src/lib/CorpusImpl.cpp
@@ -17,7 +17,7 @@
 #include <lib/AST/MrDocsFileSystem.hpp>
 #include <lib/Metadata/Finalizers/BaseMembersFinalizer.hpp>
 #include <lib/Metadata/Finalizers/DerivedFinalizer.hpp>
-#include <lib/Metadata/Finalizers/JavadocFinalizer.hpp>
+#include <lib/Metadata/Finalizers/DocCommentFinalizer.hpp>
 #include <lib/Metadata/Finalizers/NamespacesFinalizer.hpp>
 #include <lib/Metadata/Finalizers/OverloadsFinalizer.hpp>
 #include <lib/Metadata/Finalizers/SortMembersFinalizer.hpp>
@@ -643,7 +643,7 @@ lookupImpl(
             // This is an intermediary level because among choices that
             // doesn't exactly match the function parameters, we prefer
             // the one that is documented as the most "natural" choice.
-            if (F.javadoc)
+            if (F.doc)
             {
                 matchRes = MatchLevel::FunctionParametersSizeAndDocumented;
             }
@@ -1074,10 +1074,10 @@ CorpusImpl::finalize()
         finalizer.build();
     }
 
-    // Finalize javadoc
+    // Finalize documentation comments
     {
-        report::debug("  - Finalizing javadoc");
-        JavadocFinalizer finalizer(*this);
+        report::debug("  - Finalizing documentation comments");
+        DocCommentFinalizer finalizer(*this);
         finalizer.build();
     }
 }
diff --git a/src/lib/CorpusImpl.hpp b/src/lib/CorpusImpl.hpp
index c0e0f5b12..1b6dd772c 100644
--- a/src/lib/CorpusImpl.hpp
+++ b/src/lib/CorpusImpl.hpp
@@ -59,7 +59,7 @@ class CorpusImpl final : public Corpus
     friend class BaseMembersFinalizer;
     friend class OverloadsFinalizer;
     friend class SortMembersFinalizer;
-    friend class JavadocFinalizer;
+    friend class DocCommentFinalizer;
     friend class NamespacesFinalizer;
     friend class DerivedFinalizer;
 
diff --git a/src/lib/Gen/hbs/HandlebarsCorpus.hpp b/src/lib/Gen/hbs/HandlebarsCorpus.hpp
index 73c85ba6f..4d11b5091 100644
--- a/src/lib/Gen/hbs/HandlebarsCorpus.hpp
+++ b/src/lib/Gen/hbs/HandlebarsCorpus.hpp
@@ -15,8 +15,8 @@
 #include <mrdocs/Platform.hpp>
 #include <lib/Support/LegibleNames.hpp>
 #include <mrdocs/Corpus.hpp>
+#include <mrdocs/Metadata/DocComment.hpp>
 #include <mrdocs/Metadata/DomCorpus.hpp>
-#include <mrdocs/Metadata/Javadoc.hpp>
 
 namespace mrdocs::hbs {
 
@@ -42,7 +42,7 @@ class HandlebarsCorpus final : public DomCorpus
 
         @param corpus The base corpus.
         @param fileExtension The file extension for the generated files.
-        @param toStringFn The function to convert a Javadoc node to a string.
+        @param toStringFn The function to convert a DocComment node to a string.
     */
     HandlebarsCorpus(
         Corpus const& corpus,
diff --git a/src/lib/Gen/xml/CXXTags.hpp b/src/lib/Gen/xml/CXXTags.hpp
index dd8cf2ffa..66f6f74d7 100644
--- a/src/lib/Gen/xml/CXXTags.hpp
+++ b/src/lib/Gen/xml/CXXTags.hpp
@@ -33,7 +33,7 @@ constexpr auto baseTagName           = "base";
 constexpr auto bitfieldTagName       = "bitfield";
 constexpr auto classTagName          = "class";
 constexpr auto dataMemberTagName     = "field";
-constexpr auto javadocTagName        = "doc";
+constexpr auto docTagName            = "doc";
 constexpr auto paramTagName          = "param";
 constexpr auto returnTagName         = "return";
 constexpr auto deducedTagName        = "deduced";
diff --git a/src/lib/Gen/xml/XMLGenerator.hpp b/src/lib/Gen/xml/XMLGenerator.hpp
index 18bbcbba6..32e4cd21d 100644
--- a/src/lib/Gen/xml/XMLGenerator.hpp
+++ b/src/lib/Gen/xml/XMLGenerator.hpp
@@ -14,7 +14,7 @@
 
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Generator.hpp>
-#include <mrdocs/Metadata/Javadoc.hpp>
+#include <mrdocs/Metadata/DocComment.hpp>
 #include <optional>
 
 namespace mrdocs::xml {
diff --git a/src/lib/Gen/xml/XMLTags.hpp b/src/lib/Gen/xml/XMLTags.hpp
index 728492b00..85ae67f4e 100644
--- a/src/lib/Gen/xml/XMLTags.hpp
+++ b/src/lib/Gen/xml/XMLTags.hpp
@@ -13,7 +13,7 @@
 #define MRDOCS_LIB_GEN_XML_XMLTAGS_HPP
 
 #include <mrdocs/Dom.hpp>
-#include <mrdocs/Metadata/Javadoc.hpp>
+#include <mrdocs/Metadata/DocComment.hpp>
 #include <mrdocs/Metadata/Symbol/SymbolID.hpp>
 #include <mrdocs/Metadata/Type.hpp>
 #include <clang/Basic/Specifiers.h>
diff --git a/src/lib/Gen/xml/XMLWriter.cpp b/src/lib/Gen/xml/XMLWriter.cpp
index 6c06ea8f8..3aebf8c73 100644
--- a/src/lib/Gen/xml/XMLWriter.cpp
+++ b/src/lib/Gen/xml/XMLWriter.cpp
@@ -6,6 +6,7 @@
 //
 // Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
 // Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
 //
 // Official repository: https://github.com/cppalliance/mrdocs
 //
@@ -13,11 +14,8 @@
 #include "XMLWriter.hpp"
 #include <mrdocs/Platform.hpp>
 #include "CXXTags.hpp"
-#include <lib/ConfigImpl.hpp>
 #include <lib/Support/LegibleNames.hpp>
 #include <lib/Support/Radix.hpp>
-#include <lib/Support/Yaml.hpp>
-#include <llvm/Support/YAMLParser.h>
 #include <llvm/Support/YAMLTraits.h>
 
 //------------------------------------------------
@@ -53,52 +51,24 @@ build()
         "<mrdocs xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
         "       xsi:noNamespaceSchemaLocation=\"https://github.com/cppalliance/mrdocs/raw/develop/mrdocs.rnc\">\n";
 
-    // writeIndex();
-
-    visit(corpus_.globalNamespace(), *this);
+    this->operator()(corpus_.globalNamespace());
 
     os_ << "</mrdocs>\n";
 
     return {};
 }
 
-//------------------------------------------------
-
-void
-XMLWriter::
-writeIndex()
-{
-    std::string temp;
-    temp.reserve(256);
-    tags_.open("symbols");
-    LegibleNames const names(corpus_, true);
-    for(auto& I : corpus_)
-    {
-        corpus_.qualifiedName(I, temp);
-        auto legible_name = names.getUnqualified(I.id);
-        tags_.write("symbol", {}, {
-            { "legible", legible_name },
-            { "name", temp },
-            { "tag", toString(I.Kind) },
-            { I.id } });
-    }
-    tags_.close("symbols");
-}
-
-//------------------------------------------------
-
-template<class T>
+template <std::derived_from<Symbol> SymbolTy>
 void
 XMLWriter::
-operator()(
-    T const& I)
+operator()(SymbolTy const& I)
 {
     if (Symbol const& base = I;
         base.Extraction == ExtractionMode::Dependency)
     {
         return;
     }
-    #define INFO(Type) if constexpr(T::is##Type()) write##Type(I);
+    #define INFO(Type) if constexpr(SymbolTy::is##Type()) write##Type(I);
 #include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
 }
 
@@ -116,7 +86,7 @@ writeNamespace(
         { "is-anonymous", "1", I.IsAnonymous},
         { "is-inline", "1", I.IsInline}
     });
-    writeJavadoc(I.javadoc);
+    writeDocComment(I.doc);
     for (Name const& NI: I.UsingDirectives)
     {
         if (auto const& id = NI.id; id != SymbolID::invalid)
@@ -149,7 +119,7 @@ writeEnum(
 
     writeSourceInfo(I.Loc);
 
-    writeJavadoc(I.javadoc);
+    writeDocComment(I.doc);
 
     corpus_.traverse(I, *this);
 
@@ -175,7 +145,7 @@ writeEnumConstant(
 
     writeSourceInfo(I.Loc);
 
-    writeJavadoc(I.javadoc);
+    writeDocComment(I.doc);
 
     tags_.close(enumConstantTagName);
 }
@@ -256,10 +226,10 @@ writeFunction(
 
     for (auto const& J: I.Params)
     {
-        writeParam(J, tags_);
+        ::mrdocs::xml::writeParam(J, tags_);
     }
 
-    writeJavadoc(I.javadoc);
+    writeDocComment(I.doc);
 
     tags_.close(functionTagName);
 
@@ -298,10 +268,12 @@ writeGuide(
     writeType(I.Deduced, tags_);
     tags_.close(deducedTagName);
 
-    for(auto const& J : I.Params)
-        writeParam(J, tags_);
+    for (auto const& J: I.Params)
+    {
+        xml::writeParam(J, tags_);
+    }
 
-    writeJavadoc(I.javadoc);
+    writeDocComment(I.doc);
 
     tags_.close(guideTagName);
 
@@ -325,7 +297,7 @@ writeConcept(
 
     writeSourceInfo(I.Loc);
 
-    writeJavadoc(I.javadoc);
+    writeDocComment(I.doc);
 
     tags_.close(conceptTagName);
 
@@ -346,7 +318,7 @@ writeNamespaceAlias(
 
     writeSourceInfo(I.Loc);
 
-    writeJavadoc(I.javadoc);
+    writeDocComment(I.doc);
 
     tags_.write("aliased", {}, {
         {"name", toString(I.AliasedSymbol)},
@@ -390,7 +362,7 @@ XMLWriter::
 
     writeSourceInfo(I.Loc);
 
-    writeJavadoc(I.javadoc);
+    writeDocComment(I.doc);
 
     for (auto const& id : I.ShadowDeclarations)
         tags_.write("named", {}, { id });
@@ -433,7 +405,7 @@ writeRecord(
         writeFriend(F);
     }
 
-    writeJavadoc(I.javadoc);
+    writeDocComment(I.doc);
 
     corpus_.traverse(I, *this);
 
@@ -469,7 +441,7 @@ writeTypedef(
 
     writeType(I.Type, tags_);
 
-    writeJavadoc(I.javadoc);
+    writeDocComment(I.doc);
 
     tags_.close(tag);
 
@@ -519,7 +491,7 @@ writeVariable(
 
     writeType(I.Type, tags_);
 
-    writeJavadoc(I.javadoc);
+    writeDocComment(I.doc);
 
     tags_.close(varTagName);
 
@@ -564,8 +536,10 @@ XMLWriter::
 openTemplate(
     Optional<TemplateInfo> const& I)
 {
-    if(! I)
+    if (!I)
+    {
         return;
+    }
 
     tags_.open(templateTagName, {
         {"class", toString(I->specializationKind()),
@@ -575,10 +549,14 @@ openTemplate(
         {I->Primary}
     });
 
-    for(auto const& tparam : I->Params)
+    for (auto const& tparam: I->Params)
+    {
         writeTemplateParam(*tparam, tags_);
-    for(auto const& targ : I->Args)
+    }
+    for (auto const& targ: I->Args)
+    {
         writeTemplateArg(*targ, tags_);
+    }
 }
 
 void
@@ -595,125 +573,90 @@ closeTemplate(
 
 void
 XMLWriter::
-writeJavadoc(
-    Optional<Javadoc> const& javadoc)
+writeDocComment(
+    Optional<DocComment> const& doc)
 {
-    if (!javadoc)
+    if (!doc)
     {
         return;
     }
-    tags_.open(javadocTagName);
-    if (javadoc->brief)
+    tags_.open(docTagName);
+    if (doc->brief)
     {
-        writeNode(*javadoc->brief);
+        writeBrief(*doc->brief);
     }
-    writeNodes(javadoc->getBlocks());
-    writeNodes(javadoc->returns);
-    writeNodes(javadoc->params);
-    writeNodes(javadoc->tparams);
-    writeNodes(javadoc->exceptions);
-    writeNodes(javadoc->sees);
-    writeNodes(javadoc->preconditions);
-    writeNodes(javadoc->postconditions);
-    if (!javadoc->relates.empty())
+    writeBlocks(doc->Document);
+    writeBlocks(doc->returns);
+    writeBlocks(doc->params);
+    writeBlocks(doc->tparams);
+    writeBlocks(doc->exceptions);
+    writeBlocks(doc->sees);
+    writeBlocks(doc->preconditions);
+    writeBlocks(doc->postconditions);
+    if (!doc->relates.empty())
     {
         tags_.open(relatesTagName);
-        writeNodes(javadoc->relates);
+        writeInlines(doc->relates);
         tags_.close(relatesTagName);
     }
-    if (!javadoc->related.empty())
+    if (!doc->related.empty())
     {
         tags_.open(relatedTagName);
-        writeNodes(javadoc->related);
+        writeInlines(doc->related);
         tags_.close(relatedTagName);
     }
-    tags_.close(javadocTagName);
+    tags_.close(docTagName);
 }
 
 
-void
-XMLWriter::
-writeNode(doc::Node const& node)
-{
-    switch(node.Kind)
-    {
-    case doc::NodeKind::text:
-        writeText(dynamic_cast<doc::Text const&>(node));
-        break;
-    case doc::NodeKind::styled:
-        writeStyledText(dynamic_cast<doc::Styled const&>(node));
-        break;
-    case doc::NodeKind::heading:
-        writeHeading(dynamic_cast<doc::Heading const&>(node));
-        break;
-    case doc::NodeKind::paragraph:
-        writeParagraph(dynamic_cast<doc::Paragraph const&>(node));
-        break;
-    case doc::NodeKind::link:
-        writeLink(dynamic_cast<doc::Link const&>(node));
-        break;
-    case doc::NodeKind::list_item:
-        writeListItem(dynamic_cast<doc::ListItem const&>(node));
-        break;
-    case doc::NodeKind::unordered_list:
-        writeUnorderedList(dynamic_cast<doc::UnorderedList const&>(node));
-        break;
-    case doc::NodeKind::brief:
-        writeBrief(dynamic_cast<doc::Brief const&>(node));
-        break;
-    case doc::NodeKind::admonition:
-        writeAdmonition(dynamic_cast<doc::Admonition const&>(node));
-        break;
-    case doc::NodeKind::code:
-        writeCode(dynamic_cast<doc::Code const&>(node));
-        break;
-    case doc::NodeKind::param:
-        writeJParam(dynamic_cast<doc::Param const&>(node));
-        break;
-    case doc::NodeKind::tparam:
-        writeTParam(dynamic_cast<doc::TParam const&>(node));
-        break;
-    case doc::NodeKind::returns:
-        writeReturns(dynamic_cast<doc::Returns const&>(node));
-        break;
-    case doc::NodeKind::reference:
-        writeReference(dynamic_cast<doc::Reference const&>(node));
-        break;
-    case doc::NodeKind::copy_details:
-        writeCopied(dynamic_cast<doc::CopyDetails const&>(node));
-        break;
-    case doc::NodeKind::throws:
-        writeThrows(dynamic_cast<doc::Throws const&>(node));
-        break;
-    case doc::NodeKind::see:
-        writeSee(dynamic_cast<doc::See const&>(node));
-        break;
-    case doc::NodeKind::precondition:
-        writePrecondition(dynamic_cast<doc::Precondition const&>(node));
-        break;
-    case doc::NodeKind::postcondition:
-        writePostcondition(dynamic_cast<doc::Postcondition const&>(node));
-        break;
-    default:
-        // unknown kind
-        MRDOCS_UNREACHABLE();
-    }
-}
+//void
+//XMLWriter::
+//writeNode(doc::Node const& node)
+//{
+//    auto* nodePtr = &node;
+//    auto* blockPtr = dynamic_cast<doc::Block const*>(nodePtr);
+//    if (blockPtr)
+//    {
+//        switch (blockPtr->Kind)
+//        {
+//            #define INFO(Type) case doc::BlockKind::Type: \
+//                write##Type(dynamic_cast<doc::Type##Block const&>(node)); \
+//                return;
+//#include <mrdocs/Metadata/DocComment/Block/BlockNodes.inc>
+//        default:
+//            MRDOCS_UNREACHABLE();
+//        }
+//    }
+//    auto* inlinePtr = dynamic_cast<doc::Inline const*>(nodePtr);
+//    if (inlinePtr)
+//    {
+//        switch (inlinePtr->Kind)
+//        {
+//            #define INFO(Type) case doc::InlineKind::Type: \
+//                write##Type(dynamic_cast<doc::Type##Inline const&>(node)); \
+//                return;
+//#include <mrdocs/Metadata/DocComment/Inline/InlineNodes.inc>
+//        default:
+//            MRDOCS_UNREACHABLE();
+//        }
+//    }
+//    MRDOCS_UNREACHABLE();
+//}
 
 void
 XMLWriter::
 writeReference(
-    doc::Reference const& node)
+    doc::ReferenceInline const& node)
 {
-    tags_.write("reference", node.string, {
+    tags_.write("reference", node.literal, {
         { node.id }
         });
 }
 
 void
 XMLWriter::
-writeCopied(
-    doc::CopyDetails const& node)
+writeCopyDetails(
+    doc::CopyDetailsInline const& node)
 {
     std::string_view constexpr tag_name = "copydetails";
     tags_.write(tag_name, node.string, {
@@ -724,11 +667,12 @@ writeCopied(
 void
 XMLWriter::
 writeLink(
-    doc::Link const& node)
+    doc::LinkInline const& node)
 {
-    tags_.write("link", node.string, {
-        { "href", node.href }
-        });
+
+    tags_.write(
+        "link", doc::getAsPlainText(node.asInline()),
+        {{ "href", node.href }});
 }
 
 void
@@ -737,174 +681,201 @@ writeListItem(
     doc::ListItem const& node)
 {
     tags_.open("listitem");
-    writeNodes(node.children);
+    // flatten blocks to write their inlines directly when possible
+    // this maintains the schema, but it would be best to
+    // just render the blocks directly
+    for (auto const& childb : node.blocks)
+    {
+        auto* ilnPtr = dynamic_cast<doc::InlineContainer const*>(&*childb);
+        MRDOCS_CHECK_OR_CONTINUE(ilnPtr);
+        writeInlines(ilnPtr->children);
+    }
     tags_.close("listitem");
 }
 
 void
 XMLWriter::
-writeUnorderedList(
-    doc::UnorderedList const& node)
+writeList(
+    doc::ListBlock const& node)
 {
     tags_.open("unorderedlist");
-    writeNodes(node.items);
+    for (auto const& li: node.items)
+    {
+        writeListItem(li);
+    }
     tags_.close("unorderedlist");
 }
 
 void
 XMLWriter::
 writeBrief(
-    doc::Paragraph const& node)
+    doc::BriefBlock const& node)
 {
     tags_.open("brief");
-    writeNodes(node.children);
+    writeInlines(node.children);
     tags_.close("brief");
 }
 
 void
 XMLWriter::
 writeText(
-    doc::Text const& node)
+    doc::TextInline const& node)
 {
     tags_.indent() <<
         "<text>" <<
-        xmlEscape(node.string) <<
+        xmlEscape(node.literal) <<
         "</text>\n";
 }
 
 void
 XMLWriter::
-writeStyledText(
-    doc::Styled const& node)
+writeCode(doc::CodeInline const& node)
+{
+    tags_.write("mono", doc::getAsPlainText(node.asInline()));
+}
+
+void
+XMLWriter::
+writeStrong(doc::StrongInline const& node)
 {
-    tags_.write(toString(node.style), node.string);
+    tags_.write("bold", doc::getAsPlainText(node.asInline()));
+}
+
+void
+XMLWriter::
+writeEmph(doc::EmphInline const& node)
+{
+    tags_.write("italic", doc::getAsPlainText(node.asInline()));
 }
 
 void
 XMLWriter::
 writeHeading(
-    doc::Heading const& heading)
+    doc::HeadingBlock const& heading)
 {
-    tags_.write("head", heading.string);
+    tags_.write("head", doc::getAsPlainText(heading.asInlineContainer()));
 }
 
 void
 XMLWriter::
-writeParagraph(
-    doc::Paragraph const& para,
-    llvm::StringRef tag)
+writeInlineContainer(
+    doc::InlineContainer const& node,
+    std::string_view tag)
 {
-    tags_.open("para", {
-        { "class", tag, ! tag.empty() }});
-    writeNodes(para.children);
+    tags_.open("para", {{ "class", tag, !tag.empty() }});
+    writeInlines(node.children);
     tags_.close("para");
 }
 
 void
 XMLWriter::
-writeSee(
-    doc::See const& para,
-    llvm::StringRef tag)
+writeSee(doc::SeeBlock const& para)
 {
-    tags_.open("see", {
-        { "class", tag, ! tag.empty() }});
-    writeNodes(para.children);
+    tags_.open("see");
+    writeInlines(para.children);
     tags_.close("see");
 }
 
 void
 XMLWriter::
 writePrecondition(
-    doc::Precondition const& para)
+    doc::PreconditionBlock const& para)
 {
     tags_.open("pre", {});
-    writeNodes(para.children);
+    writeInlines(para.children);
     tags_.close("pre");
 }
 
 void
 XMLWriter::
 writePostcondition(
-    doc::Postcondition const& para)
+    doc::PostconditionBlock const& para)
 {
     tags_.open("post", {});
-    writeNodes(para.children);
+    writeInlines(para.children);
     tags_.close("post");
 }
 
 void
 XMLWriter::
 writeAdmonition(
-    doc::Admonition const& admonition)
+    doc::AdmonitionBlock const& admonition)
 {
     llvm::StringRef tag;
     switch(admonition.admonish)
     {
-    case doc::Admonish::note:
+    case doc::AdmonitionKind::note:
         tag = "note";
         break;
-    case doc::Admonish::tip:
+    case doc::AdmonitionKind::tip:
         tag = "tip";
         break;
-    case doc::Admonish::important:
+    case doc::AdmonitionKind::important:
         tag = "important";
         break;
-    case doc::Admonish::caution:
+    case doc::AdmonitionKind::caution:
         tag = "caution";
         break;
-    case doc::Admonish::warning:
+    case doc::AdmonitionKind::warning:
         tag = "warning";
         break;
     default:
         // unknown style
         MRDOCS_UNREACHABLE();
     }
-    writeParagraph(admonition, tag);
+    MRDOCS_CHECK_OR(!admonition.blocks.empty());
+    auto& firstBlock = admonition.blocks.front();
+    auto const* asInlineContainer = dynamic_cast<doc::InlineContainer const*>(&*firstBlock);
+    if (asInlineContainer)
+    {
+        writeInlineContainer(*asInlineContainer, tag);
+    }
 }
 
 void
 XMLWriter::
-writeCode(doc::Code const& code)
+writeCode(doc::CodeBlock const& code)
 {
-    if(code.children.empty())
+    if(code.literal.empty())
     {
         tags_.indent() << "<code/>\n";
         return;
     }
 
     tags_.open("code");
-    writeNodes(code.children);
+    tags_.indent() << "<text>" << xmlEscape(code.literal) << "</text>\n";
     tags_.close("code");
 }
 
 void
 XMLWriter::
 writeReturns(
-    doc::Returns const& returns)
+    doc::ReturnsBlock const& returns)
 {
-    if(returns.empty())
+    if (returns.empty())
+    {
         return;
+    }
     tags_.open("returns");
-    writeNodes(returns.children);
+    writeInlines(returns.children);
     tags_.close("returns");
 }
 
 void
 XMLWriter::
 writeThrows(
-    doc::Throws const& throws)
+    doc::ThrowsBlock const& throws)
 {
     if(throws.empty())
         return;
     tags_.open("throws");
-    writeNodes(throws.children);
+    writeInlines(throws.children);
     tags_.close("throws");
 }
 
 void
 XMLWriter::
-writeJParam(
-    doc::Param const& param)
+writeParam(doc::ParamBlock const& param)
 {
     dom::String direction;
     switch(param.direction)
@@ -928,19 +899,240 @@ writeJParam(
         { "name", param.name, ! param.name.empty() },
         { "class", direction, ! direction.empty() }
     });
-    writeNodes(param.children);
+    writeInlines(param.children);
     tags_.close("param");
 }
 
 void
 XMLWriter::
 writeTParam(
-    doc::TParam const& tparam)
+    doc::TParamBlock const& tparam)
 {
     tags_.open("tparam", {
         { "name", tparam.name, ! tparam.name.empty() }});
-    writeNodes(tparam.children);
+    writeInlines(tparam.children);
     tags_.close("tparam");
 }
 
+void
+XMLWriter::
+writeImage(doc::ImageInline const& el)
+{
+    tags_.open("image");
+    auto text = doc::getAsPlainText(el.asInline());
+    if (!text.empty())
+    {
+        tags_.write("alt", text);
+    }
+    tags_.close("image");
+}
+
+void
+XMLWriter::
+writeQuote(doc::QuoteBlock const& el)
+{
+    tags_.open("quote");
+    writeBlocks(el.blocks);
+    tags_.close("quote");
+}
+
+void
+XMLWriter::
+writeTable(doc::TableBlock const& el)
+{
+    tags_.open("table");
+    for (auto const& row : el.items)
+    {
+        tags_.open("tablerow");
+        for (auto const& cell : row.Cells)
+        {
+            tags_.open("tablecell");
+            auto str = doc::getAsPlainText(cell.asInlineContainer());
+            if (!str.empty())
+            {
+                tags_.write("celltext",  str);
+            }
+            tags_.close("tablecell");
+        }
+        tags_.close("tablerow");
+    }
+    tags_.close("table");
+}
+
+void
+XMLWriter::
+writeHighlight(doc::HighlightInline const& el)
+{
+    tags_.open("highlight");
+    auto text = doc::getAsPlainText(el.asInline());
+    tags_.close("highlight");
+}
+
+void
+XMLWriter::
+writeLineBreak(doc::LineBreakInline const& el)
+{
+    tags_.write("linebreak", {});
+}
+
+void
+XMLWriter::
+writeParagraph(doc::ParagraphBlock const& el)
+{
+    tags_.open("para");
+    for (Polymorphic<doc::Inline> const& child : el.children)
+    {
+        writeInline(*child);
+    }
+    tags_.close("para");
+}
+
+void
+XMLWriter::
+writeSoftBreak(doc::SoftBreakInline const& el)
+{
+    tags_.write("softbreak", {});
+}
+
+void
+XMLWriter::
+writeSubscript(doc::SubscriptInline const& el)
+{
+    tags_.open("subscript");
+    auto text = doc::getAsPlainText(el.asInline());
+    if (!text.empty())
+    {
+        tags_.indent() << xmlEscape(text) << "\n";
+    }
+    tags_.close("subscript");
+}
+
+void
+XMLWriter::
+writeSuperscript(doc::SuperscriptInline const& el)
+{
+    tags_.open("superscript");
+    auto text = doc::getAsPlainText(el.asInline());
+    if (!text.empty())
+    {
+        tags_.indent() << xmlEscape(text) << "\n";
+    }
+    tags_.close("superscript");
+}
+
+void
+XMLWriter::
+writeStrikethrough(doc::StrikethroughInline const& el)
+{
+    tags_.open("strikethrough");
+    auto text = doc::getAsPlainText(el.asInline());
+    if (!text.empty())
+    {
+        tags_.indent() << xmlEscape(text) << "\n";
+    }
+    tags_.close("strikethrough");
+}
+
+void
+XMLWriter::
+writeThematicBreak(doc::ThematicBreakBlock const& el)
+{
+    tags_.write("thematicbreak", {});
+}
+
+void
+XMLWriter::
+writeFootnoteReference(doc::FootnoteReferenceInline const& el)
+{
+    tags_.open("footnotereference");
+    if (!el.label.empty())
+    {
+        tags_.write("label", el.label);
+    }
+    tags_.close("footnotereference");
+}
+
+void
+XMLWriter::
+writeFootnoteDefinition(doc::FootnoteDefinitionBlock const& el)
+{
+    tags_.open("footnotedefinition");
+    if (!el.label.empty())
+    {
+        tags_.write("label", el.label);
+    }
+    writeBlocks(el.blocks);
+    tags_.close("footnotedefinition");
+}
+
+void
+XMLWriter::
+writeMath(doc::MathInline const& el)
+{
+    tags_.open("math");
+    if (!el.literal.empty())
+    {
+        tags_.indent() << xmlEscape(el.literal) << "\n";
+    }
+    tags_.close("math");
+}
+
+void
+XMLWriter::
+writeMath(doc::MathBlock const& el)
+{
+    tags_.open("mathblock");
+    if (!el.literal.empty())
+    {
+        tags_.indent() << xmlEscape(el.literal) << "\n";
+    }
+    tags_.close("mathblock");
+}
+
+void
+XMLWriter::
+writeDefinitionList(doc::DefinitionListBlock const& el)
+{
+    tags_.open("definitionlist");
+    for (auto const& item : el.items)
+    {
+        tags_.open("definitionitem");
+        tags_.open("term");
+        writeInlines(item.term.children);
+        tags_.close("term");
+        tags_.open("definition");
+        writeBlocks(item.blocks);
+        tags_.close("definition");
+        tags_.close("definitionitem");
+    }
+    tags_.close("definitionlist");
+}
+
+void
+XMLWriter::
+writeBlock(doc::Block const& node)
+{
+    switch (node.Kind)
+    {
+        #define INFO(Type) case doc::BlockKind::Type: \
+            write##Type(node.as##Type()); \
+            return;
+#include <mrdocs/Metadata/DocComment/Block/BlockNodes.inc>
+    }
+}
+
+void
+XMLWriter::
+writeInline(doc::Inline const& node)
+{
+    switch (node.Kind)
+    {
+        #define INFO(Type) case doc::InlineKind::Type: \
+            write##Type(node.as##Type()); \
+            return;
+#include <mrdocs/Metadata/DocComment/Inline/InlineNodes.inc>
+    }
+}
+
+
 } // mrdocs::xml
diff --git a/src/lib/Gen/xml/XMLWriter.hpp b/src/lib/Gen/xml/XMLWriter.hpp
index 831dbe26e..c6ad19714 100644
--- a/src/lib/Gen/xml/XMLWriter.hpp
+++ b/src/lib/Gen/xml/XMLWriter.hpp
@@ -43,10 +43,9 @@ class XMLWriter
     Expected<void>
     build();
 
-    void writeIndex();
-
-    template<class T>
-    void operator()(T const&);
+    template <std::derived_from<Symbol> SymbolTy>
+    void
+    operator()(SymbolTy const& I);
 
 
     // ---------------
@@ -57,54 +56,93 @@ class XMLWriter
 
     void writeSourceInfo(SourceInfo const& I);
     void writeLocation(Location const& loc, bool def = false);
-    void writeJavadoc(Optional<Javadoc> const& javadoc);
+    void writeDocComment(Optional<DocComment> const& doc);
     void writeFriend(FriendInfo const& I);
     void openTemplate(Optional<TemplateInfo> const& I);
     void closeTemplate(Optional<TemplateInfo> const& I);
 
     // ---------------
-    // Javadoc types
-
-    void writeAdmonition(doc::Admonition const& node);
-    void writeBrief(doc::Paragraph const& node);
-    void writeCode(doc::Code const& node);
-    void writeHeading(doc::Heading const& node);
-    void writeLink(doc::Link const& node);
-    void writeListItem(doc::ListItem const& node);
-    void writeUnorderedList(doc::UnorderedList const& node);
-    void writeParagraph(doc::Paragraph const& node, llvm::StringRef tag = "");
-    void writeJParam(doc::Param const& node);
-    void writeReturns(doc::Returns const& node);
-    void writeStyledText(doc::Styled const& node);
-    void writeText(doc::Text const& node);
-    void writeTParam(doc::TParam const& node);
-    void writeReference(doc::Reference const& node);
-    void writeCopied(doc::CopyDetails const& node);
-    void writeThrows(doc::Throws const& node);
-    void writeSee(doc::See const& node, llvm::StringRef tag = "");
-    void writePrecondition(doc::Precondition const& node);
-    void writePostcondition(doc::Postcondition const& node);
-
-    void writeNode(doc::Node const& node);
+    // DocComment types
+
+#define INFO(Type) void write##Type(doc::Type##Block const&);
+#include <mrdocs/Metadata/DocComment/Block/BlockNodes.inc>
 
-    template <class T>
     void
-    writeNodes(std::vector<Polymorphic<T>> const& list)
+    writeBlock(doc::Block const& node);
+
+    template <std::derived_from<doc::Block> T>
+    void
+    writeBlocks(std::vector<T> const& list)
     {
         for (auto const& node: list)
         {
-            writeNode(*node);
+            writeBlock(node);
+        }
+    }
+
+    void
+    writeBlocks(std::vector<Polymorphic<doc::Block>> const& list)
+    {
+        for (auto const& node: list)
+        {
+            writeBlock(*node);
         }
     }
 
-    template <std::derived_from<doc::Node> T>
-    void writeNodes(std::vector<T> const& list)
+#define INFO(Type) void write##Type(doc::Type##Inline const&);
+#include <mrdocs/Metadata/DocComment/Inline/InlineNodes.inc>
+
+    void
+    writeInline(doc::Inline const& node);
+
+    template <std::derived_from<doc::Inline> T>
+    void
+    writeInlines(std::vector<T> const& list)
     {
         for (auto const& node: list)
         {
-            writeNode(node);
+            writeInline(node);
         }
     }
+
+    void
+    writeInlines(std::vector<Polymorphic<doc::Inline>> const& list)
+    {
+        for (auto const& node: list)
+        {
+            writeInline(*node);
+        }
+    }
+
+    void
+    writeInlineContainer(
+        doc::InlineContainer const& node,
+        std::string_view tag);
+
+    void
+    writeListItem(doc::ListItem const& node);
+
+//    void
+//    writeNode(doc::Node const& node);
+
+    template <class T>
+    void
+    writeNodes(std::vector<Polymorphic<T>> const& list)
+    {
+        for (auto const& node: list)
+        {
+            writeNode(*node);
+        }
+    }
+
+//    template <std::derived_from<doc::Node> T>
+//    void writeNodes(std::vector<T> const& list)
+//    {
+//        for (auto const& node: list)
+//        {
+//            writeNode(node);
+//        }
+//    }
 };
 
 } // mrdocs::xml
diff --git a/src/lib/Metadata/DocComment.cpp b/src/lib/Metadata/DocComment.cpp
new file mode 100644
index 000000000..74318b8eb
--- /dev/null
+++ b/src/lib/Metadata/DocComment.cpp
@@ -0,0 +1,182 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#include <lib/Support/Debug.hpp>
+#include <mrdocs/Corpus.hpp>
+#include <mrdocs/Metadata/DocComment.hpp>
+#include <mrdocs/Metadata/DocComment/Inline/Parts.hpp>
+#include <mrdocs/Metadata/DomCorpus.hpp>
+#include <llvm/Support/Error.h>
+#include <llvm/Support/Path.h>
+#include <format>
+
+
+namespace mrdocs {
+namespace doc {
+
+dom::String
+toString(AdmonitionKind kind) noexcept
+{
+    switch(kind)
+    {
+    case AdmonitionKind::none:
+        return "";
+    case AdmonitionKind::note:
+        return "note";
+    case AdmonitionKind::tip:
+        return "tip";
+    case AdmonitionKind::important:
+        return "important";
+    case AdmonitionKind::caution:
+        return "caution";
+    case AdmonitionKind::warning:
+        return "warning";
+    default:
+        MRDOCS_UNREACHABLE();
+    }
+}
+
+dom::String
+toString(ParamDirection kind) noexcept
+{
+    switch(kind)
+    {
+    case ParamDirection::none:
+        return "";
+    case ParamDirection::in:
+        return "in";
+    case ParamDirection::out:
+        return "out";
+    case ParamDirection::inout:
+        return "inout";
+    default:
+        MRDOCS_UNREACHABLE();
+    }
+}
+
+dom::String
+toString(Parts kind) noexcept
+{
+    switch(kind)
+    {
+    case Parts::all:
+        return "all";
+    case Parts::brief:
+        return "brief";
+    case Parts::description:
+        return "description";
+    default:
+        MRDOCS_UNREACHABLE();
+    }
+}
+
+std::strong_ordering
+operator<=>(Polymorphic<TextInline> const& lhs, Polymorphic<TextInline> const& rhs)
+{
+    MRDOCS_ASSERT(!lhs.valueless_after_move());
+    MRDOCS_ASSERT(!rhs.valueless_after_move());
+    if (lhs->Kind == rhs->Kind)
+    {
+        return visit(*lhs, detail::VisitCompareFn<TextInline>(*rhs));
+    }
+    return lhs->Kind <=> rhs->Kind;
+}
+
+} // doc
+
+//------------------------------------------------
+
+DocComment::DocComment() noexcept = default;
+
+DocComment::DocComment(
+    std::vector<Polymorphic<doc::Block>> blocks)
+    : Document(std::move(blocks))
+{
+}
+
+bool
+DocComment::
+operator!=(DocComment const& other) const noexcept
+{
+    return !(*this == other);
+}
+
+void
+DocComment::
+append(DocComment&& other)
+{
+    using std::ranges::find;
+    using std::ranges::copy_if;
+    using std::views::transform;
+
+    // blocks
+    for (auto&& block: other.Document)
+    {
+        Document.emplace_back(std::move(block));
+    }
+    // returns
+    copy_if(other.returns, std::back_inserter(returns),
+        [&](auto const& r)
+        {
+            return find(returns, r) == returns.end();
+        });
+    // params
+    copy_if(other.params, std::back_inserter(params),
+        [&](auto const& p)
+        {
+            auto namesAndDirection = transform(params, [](auto const& q)
+            {
+                return std::make_pair(std::string_view(q.name), q.direction);
+            });
+            auto el = std::make_pair(std::string_view(p.name), p.direction);
+            return find(namesAndDirection, el) == namesAndDirection.end();
+        });
+    // tparams
+    copy_if(other.tparams, std::back_inserter(tparams),
+        [&](auto const& p)
+        {
+            auto names = transform(tparams, &doc::TParamBlock::name);
+            return find(names, p.name) == names.end();
+        });
+    // exceptions
+    copy_if(other.exceptions, std::back_inserter(exceptions),
+        [&](auto const& e)
+        {
+            // e.exception.string
+            auto exceptionRefs = transform(exceptions, &doc::ThrowsBlock::exception);
+            static_assert(range_of<decltype(exceptionRefs), doc::ReferenceInline>);
+            auto exceptionStrs = transform(exceptionRefs, &doc::ReferenceInline::literal);
+            static_assert(range_of<decltype(exceptionStrs), std::string>);
+            return find(exceptionStrs, e.exception.literal) == exceptionStrs.end();
+        });
+    // sees
+    copy_if(other.sees, std::back_inserter(sees),
+        [&](auto const& s)
+        {
+            return find(sees, s) == sees.end();
+        });
+    // preconditions
+    copy_if(other.preconditions, std::back_inserter(preconditions),
+        [&](auto const& p)
+        {
+            return find(preconditions, p) == preconditions.end();
+        });
+    // postconditions
+    copy_if(other.postconditions, std::back_inserter(postconditions),
+        [&](auto const& p)
+        {
+            return find(postconditions, p) == postconditions.end();
+        });
+}
+
+} // mrdocs
+
diff --git a/src/lib/Metadata/DocComment/Block.cpp b/src/lib/Metadata/DocComment/Block.cpp
new file mode 100644
index 000000000..b95d2f259
--- /dev/null
+++ b/src/lib/Metadata/DocComment/Block.cpp
@@ -0,0 +1,26 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#include <mrdocs/Metadata/DocComment/Block.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <mrdocs/Support/String.hpp>
+
+namespace mrdocs {
+namespace doc {
+
+std::strong_ordering
+operator<=>(Polymorphic<Block> const& lhs, Polymorphic<Block> const& rhs)
+{
+    return CompareDerived(lhs, rhs);
+}
+
+}
+} // mrdocs
\ No newline at end of file
diff --git a/src/lib/Metadata/DocComment/Block/BlockBase.cpp b/src/lib/Metadata/DocComment/Block/BlockBase.cpp
new file mode 100644
index 000000000..4ccf1e77a
--- /dev/null
+++ b/src/lib/Metadata/DocComment/Block/BlockBase.cpp
@@ -0,0 +1,199 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#include <mrdocs/Metadata/DocComment/Block.hpp>
+#include <mrdocs/Metadata/DocComment/Block/BlockBase.hpp>
+#include <mrdocs/Metadata/DomCorpus.hpp>
+#include <mrdocs/Support/Algorithm.hpp>
+#include <mrdocs/Support/String.hpp>
+#include <iostream>
+
+namespace mrdocs {
+namespace doc {
+
+void
+ltrim(Block& el)
+{
+    visit(el, []<class BlockTy>(BlockTy& N)
+    {
+        if constexpr (std::derived_from<BlockTy, BlockContainer>)
+        {
+            ltrim(N.asBlockContainer());
+        }
+        if constexpr (std::derived_from<BlockTy, InlineContainer>)
+        {
+            ltrim(N.asInlineContainer());
+        }
+        if constexpr (requires { { N.literal } -> std::same_as<std::string>; })
+        {
+            std::string& text = N.literal;
+            text = mrdocs::ltrim(text);
+        }
+    });
+}
+
+void
+rtrim(Block& el)
+{
+    visit(el, []<class BlockTy>(BlockTy& N) {
+        if constexpr (std::derived_from<BlockTy, BlockContainer>)
+        {
+            rtrim(N.asBlockContainer());
+        }
+        else if constexpr (std::derived_from<BlockTy, InlineContainer>)
+        {
+            rtrim(N.asInlineContainer());
+        }
+        else if constexpr (requires { { N.literal } -> std::same_as<std::string>; })
+        {
+            std::string& text = N.literal;
+            text = mrdocs::rtrim(text);
+        }
+    });
+}
+
+bool
+isEmpty(Block const& el)
+{
+    return visit(el, []<class BlockTy>(BlockTy const& N) -> bool
+    {
+        if constexpr (std::derived_from<BlockTy, BlockContainer>)
+        {
+            return N.blocks.empty();
+        }
+        else if constexpr (std::derived_from<BlockTy, InlineContainer>)
+        {
+            return N.children.empty();
+        }
+        else if constexpr (requires { { N.literal } -> std::same_as<std::string>; })
+        {
+            return N.literal.empty();
+        }
+        else
+        {
+            return is_one_of(
+                N.Kind,
+                {BlockKind::ThematicBreak});
+        }
+    });
+}
+
+
+std::strong_ordering
+BlockContainer::
+operator<=>(BlockContainer const& rhs) const
+{
+    return this->blocks <=> rhs.blocks;
+}
+
+void
+ltrim(BlockContainer& container)
+{
+    for (auto it = container.blocks.begin(); it != container.blocks.end();)
+    {
+        auto& child = *it;
+        visit(*child, []<class BlockTy>(BlockTy& N) {
+            if constexpr (std::derived_from<BlockTy, BlockContainer>)
+            {
+                ltrim(N.asBlockContainer());
+            }
+            else if constexpr (std::same_as<TableBlock, BlockTy>)
+            {
+                for (TableRow& row : N.items)
+                {
+                    for (TableCell& cell : row.Cells)
+                    {
+                        ltrim(cell.asInlineContainer());
+                        if (!cell.children.empty())
+                        {
+                            break;
+                        }
+                    }
+                }
+            }
+            else if constexpr (std::same_as<ListBlock, BlockTy>)
+            {
+                for (ListItem& item : N.items)
+                {
+                    ltrim(item.asBlockContainer());
+                    if (!item.blocks.empty())
+                    {
+                        break;
+                    }
+                }
+            }
+            else if constexpr (requires { { N.literal } -> std::same_as<std::string>; })
+            {
+                std::string& text = N.literal;
+                text = mrdocs::ltrim(text);
+            }
+        });
+        if (!isEmpty(child))
+        {
+            break;
+        }
+        it = container.blocks.erase(it);
+    }
+}
+
+void
+rtrim(BlockContainer& container)
+{
+    for (auto it = container.blocks.rbegin(); it != container.blocks.rend();)
+    {
+        auto& child = *it;
+        visit(*child, []<class BlockTy>(BlockTy& N) {
+            if constexpr (std::derived_from<BlockTy, BlockContainer>)
+            {
+                rtrim(N.asBlockContainer());
+            }
+            else if constexpr (std::same_as<TableBlock, BlockTy>)
+            {
+                for (TableRow& row : N.items)
+                {
+                    for (TableCell& cell : row.Cells)
+                    {
+                        ltrim(cell.asInlineContainer());
+                        if (!cell.children.empty())
+                        {
+                            break;
+                        }
+                    }
+                }
+            }
+            else if constexpr (std::same_as<ListBlock, BlockTy>)
+            {
+                for (ListItem& item: N.items)
+                {
+                    rtrim(item.asBlockContainer());
+                    if (!item.blocks.empty())
+                    {
+                        break;
+                    }
+                }
+            }
+            else if constexpr (requires { { N.literal } -> std::same_as<std::string>; })
+            {
+                std::string& text = N.literal;
+                text = mrdocs::rtrim(text);
+            }
+        });
+        if (!isEmpty(child))
+        {
+            break;
+        }
+        it = decltype(it){ container.blocks.erase(std::next(it).base()) };
+    }
+}
+
+
+}
+} // mrdocs
\ No newline at end of file
diff --git a/src/lib/Metadata/DocComment/Inline.cpp b/src/lib/Metadata/DocComment/Inline.cpp
new file mode 100644
index 000000000..f0abb0228
--- /dev/null
+++ b/src/lib/Metadata/DocComment/Inline.cpp
@@ -0,0 +1,87 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#include <mrdocs/Metadata/DocComment/Inline.hpp>
+#include <mrdocs/Support/Algorithm.hpp>
+
+namespace mrdocs::doc {
+
+std::strong_ordering
+operator<=>(Polymorphic<Inline> const& lhs, Polymorphic<Inline> const& rhs)
+{
+    return CompareDerived(lhs, rhs);
+}
+
+void
+ltrim(Polymorphic<Inline>& el)
+{
+    // An inline element can contain:
+    // 1. nothing: the ones that represent whitespace should be removed
+    // 2. literal text: the initial whitespace should be removed
+    // 3. other inlines: we should remove all whitespace-only inlines
+    visit(*el, []<class InlineTy>(InlineTy& N)
+    {
+        if constexpr (std::derived_from<InlineTy, InlineContainer>)
+        {
+            ltrim(N.asInlineContainer());
+        }
+        else if constexpr (requires { { N.literal } -> std::same_as<std::string>; })
+        {
+            std::string& text = N.literal;
+            text = mrdocs::ltrim(text);
+        }
+    });
+}
+
+void
+rtrim(Polymorphic<Inline>& el)
+{
+    // Same as ltrim but for the end of the element
+    visit(*el, []<class InlineTy>(InlineTy& N)
+    {
+        if constexpr (std::derived_from<InlineTy, InlineContainer>)
+        {
+            rtrim(N.asInlineContainer());
+        }
+        else if constexpr (requires { { N.literal } -> std::same_as<std::string>; })
+        {
+            std::string& text = N.literal;
+            text = mrdocs::rtrim(text);
+        }
+    });
+}
+
+MRDOCS_DECL
+bool
+isEmpty(Polymorphic<Inline> const& el)
+{
+    return visit(*el, []<class InlineTy>(InlineTy const& N) -> bool
+    {
+        if constexpr (std::derived_from<InlineTy, InlineContainer>)
+        {
+            return N.children.empty();
+        }
+        else if constexpr (requires { { N.literal } -> std::same_as<std::string const&>; })
+        {
+            return N.literal.empty();
+        }
+        else
+        {
+            return is_one_of(
+                N.Kind,
+                { InlineKind::LineBreak, InlineKind::SoftBreak });
+        }
+    });
+}
+
+
+} // mrdocs::doc
\ No newline at end of file
diff --git a/src/lib/Metadata/DocComment/Inline/InlineBase.cpp b/src/lib/Metadata/DocComment/Inline/InlineBase.cpp
new file mode 100644
index 000000000..256c49624
--- /dev/null
+++ b/src/lib/Metadata/DocComment/Inline/InlineBase.cpp
@@ -0,0 +1,148 @@
+//
+// This is a derivative work. originally part of the LLVM Project.
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#include <mrdocs/Metadata/DocComment/Inline.hpp>
+#include <mrdocs/Metadata/DomCorpus.hpp>
+#include <mrdocs/Support/String.hpp>
+
+namespace mrdocs::doc {
+
+void
+getAsPlainText(doc::Inline const& in, std::string& dst)
+{
+    if (auto const* text = dynamic_cast<doc::TextInline const*>(&in))
+    {
+        dst += text->literal;
+        return;
+    }
+    else if (in.isSoftBreak())
+    {
+        dst += ' ';
+        return;
+    }
+    else if (in.isLineBreak())
+    {
+        dst += '\n';
+        return;
+    }
+    else if (auto const* container = dynamic_cast<doc::InlineContainer const*>(&in))
+    {
+        getAsPlainText(*container, dst);
+        return;
+    }
+}
+
+std::strong_ordering
+InlineContainer::
+operator<=>(InlineContainer const& rhs) const
+{
+    return this->children <=> rhs.children;
+}
+
+InlineContainer::
+InlineContainer(std::string_view text)
+{
+    operator=(text);
+}
+
+InlineContainer::
+InlineContainer(std::string const& text)
+    : InlineContainer(std::string_view(text))
+{}
+
+
+InlineContainer::
+InlineContainer(std::string&& text)
+    : InlineContainer(std::string_view(text))
+{}
+
+
+InlineContainer&
+InlineContainer::
+operator=(std::string_view text)
+{
+    this->children.clear();
+    return append(text);
+}
+
+
+InlineContainer&
+InlineContainer::
+append(std::string_view text)
+{
+    if (!text.empty())
+    {
+        this->children.push_back(Polymorphic<Inline>(std::in_place_type<TextInline>, text));
+    }
+    return *this;
+}
+
+void
+ltrim(InlineContainer& inlines)
+{
+    for (auto it = inlines.children.begin(); it != inlines.children.end();)
+    {
+        auto& child = *it;
+        visit(*child, []<class InlineTy>(InlineTy& N) {
+            if constexpr (std::derived_from<InlineTy, InlineContainer>)
+            {
+                ltrim(N.asInlineContainer());
+            }
+            if constexpr (requires { { N.literal } -> std::same_as<std::string&>; })
+            {
+                std::string& text = N.literal;
+                text = mrdocs::ltrim(text);
+            }
+        });
+        if (!isEmpty(child))
+        {
+            break;
+        }
+        it = inlines.children.erase(it);
+    }
+}
+
+void
+rtrim(InlineContainer& inlines)
+{
+    for (auto it = inlines.children.rbegin(); it != inlines.children.rend();)
+    {
+        auto& child = *it;
+        visit(*child, []<class InlineTy>(InlineTy& N) {
+            if constexpr (std::derived_from<InlineTy, InlineContainer>)
+            {
+                rtrim(N.asInlineContainer());
+            }
+            if constexpr (requires { { N.literal } -> std::same_as<std::string&>; })
+            {
+                std::string& text = N.literal;
+                text = mrdocs::rtrim(text);
+            }
+        });
+        if (!isEmpty(child))
+        {
+            break;
+        }
+        it = decltype(it){ inlines.children.erase(std::next(it).base()) };
+    }
+}
+
+void
+getAsPlainText(doc::InlineContainer const& in, std::string& dst)
+{
+    for (auto const& child : in.children)
+    {
+        getAsPlainText(*child, dst);
+    }
+}
+
+} // mrdocs::doc
\ No newline at end of file
diff --git a/src/lib/Metadata/DomCorpus.cpp b/src/lib/Metadata/DomCorpus.cpp
index f6cf32dc6..62af85736 100644
--- a/src/lib/Metadata/DomCorpus.cpp
+++ b/src/lib/Metadata/DomCorpus.cpp
@@ -10,16 +10,12 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <lib/Support/LegibleNames.hpp>
-#include <lib/Support/Radix.hpp>
 #include <mrdocs/Corpus.hpp>
 #include <mrdocs/Dom/LazyArray.hpp>
-#include <mrdocs/Dom/LazyObject.hpp>
 #include <mrdocs/Metadata.hpp>
+#include <mrdocs/Metadata/DocComment.hpp>
 #include <mrdocs/Metadata/DomCorpus.hpp>
 #include <memory>
-#include <mutex>
-#include <variant>
 
 namespace mrdocs {
 
@@ -103,7 +99,7 @@ get(SymbolID const& id) const
 
 dom::Value
 DomCorpus::
-getJavadoc(Javadoc const&) const
+getDocComment(DocComment const&) const
 {
     // Default implementation returns null.
     return nullptr;
diff --git a/src/lib/Metadata/Finalizers/DerivedFinalizer.hpp b/src/lib/Metadata/Finalizers/DerivedFinalizer.hpp
index ca0ddb7e2..edb99a218 100644
--- a/src/lib/Metadata/Finalizers/DerivedFinalizer.hpp
+++ b/src/lib/Metadata/Finalizers/DerivedFinalizer.hpp
@@ -22,7 +22,7 @@ namespace mrdocs {
 
     This finalizer finds non-member functions
     for a record and populate the related
-    field of the javadoc.
+    field of the doc.
 */
 class DerivedFinalizer
 {
diff --git a/src/lib/Metadata/Finalizers/Javadoc/Function.hpp b/src/lib/Metadata/Finalizers/DocComment/Function.hpp
similarity index 80%
rename from src/lib/Metadata/Finalizers/Javadoc/Function.hpp
rename to src/lib/Metadata/Finalizers/DocComment/Function.hpp
index fea0a5a9b..dd0168472 100644
--- a/src/lib/Metadata/Finalizers/Javadoc/Function.hpp
+++ b/src/lib/Metadata/Finalizers/DocComment/Function.hpp
@@ -8,8 +8,8 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_METADATA_FINALIZERS_JAVADOC_FUNCTION_HPP
-#define MRDOCS_LIB_METADATA_FINALIZERS_JAVADOC_FUNCTION_HPP
+#ifndef MRDOCS_LIB_METADATA_FINALIZERS_DOCCOMMENT_FUNCTION_HPP
+#define MRDOCS_LIB_METADATA_FINALIZERS_DOCCOMMENT_FUNCTION_HPP
 
 #include <lib/CorpusImpl.hpp>
 #include <lib/Metadata/SymbolSet.hpp>
@@ -128,17 +128,17 @@ populateFunctionBriefFromClass(FunctionSymbol& I, CorpusImpl const& corpus)
         {
             if (isDefaultConstructor(I))
             {
-                I.javadoc->brief = "Default constructor";
+                I.doc->brief = "Default constructor";
                 return true;
             }
             if (isCopyConstructor(I))
             {
-                I.javadoc->brief = "Copy constructor";
+                I.doc->brief = "Copy constructor";
                 return true;
             }
             if (isMoveConstructor(I))
             {
-                I.javadoc->brief = "Move constructor";
+                I.doc->brief = "Move constructor";
                 return true;
             }
             if (I.Params.size() == 1)
@@ -146,27 +146,22 @@ populateFunctionBriefFromClass(FunctionSymbol& I, CorpusImpl const& corpus)
                 auto const& param = I.Params[0];
                 if (auto const res = innermostTypenameString(param.Type))
                 {
-                    if (!I.javadoc->brief)
+                    if (!I.doc->brief)
                     {
-                        I.javadoc->brief.emplace();
+                        I.doc->brief.emplace();
                     }
-                    I.javadoc->brief->children.clear();
-                    I.javadoc->brief->children.emplace_back(
-                        Polymorphic<doc::Text>(std::in_place_type<doc::Text>,
-                                               std::string("Construct from ")));
-                    I.javadoc->brief->children.emplace_back(
-                        Polymorphic<doc::Text>(std::in_place_type<doc::Styled>,
-                                               std::string(*res),
-                                               doc::Style::mono));
+                    I.doc->brief->clear();
+                    I.doc->brief->append("Construct from ");
+                    I.doc->brief->append<doc::CodeInline>(*res);
                     return true;
                 }
             }
-            I.javadoc->brief = "Constructor";
+            I.doc->brief = "Constructor";
             return true;
         }
         case FunctionClass::Destructor:
         {
-            I.javadoc->brief = "Destructor";
+            I.doc->brief = "Destructor";
             return true;
         }
         case FunctionClass::Conversion:
@@ -174,17 +169,13 @@ populateFunctionBriefFromClass(FunctionSymbol& I, CorpusImpl const& corpus)
             if (auto const R = innermostTypenameString(I.ReturnType))
             {
                 auto const RStr = *R;
-                I.javadoc->brief.emplace();
-                I.javadoc->brief->children.emplace_back(
-                    Polymorphic<doc::Text>(std::in_place_type<doc::Text>,
-                                           std::string("Conversion to ")));
-                I.javadoc->brief->children.emplace_back(Polymorphic<doc::Text>(
-                    std::in_place_type<doc::Styled>, std::string(RStr),
-                    doc::Style::mono));
+                I.doc->brief.emplace();
+                I.doc->brief->emplace_back<doc::TextInline>("Conversion to ");
+                I.doc->brief->emplace_back<doc::CodeInline>(RStr);
             }
             else
             {
-                I.javadoc->brief = "Conversion operator";
+                I.doc->brief = "Conversion operator";
             }
             return true;
         }
@@ -193,6 +184,10 @@ populateFunctionBriefFromClass(FunctionSymbol& I, CorpusImpl const& corpus)
     }
 }
 
+// Check if the function is a stream insertion operator by
+// checking if it is a non-member function with two parameters
+// where the first parameter is a mutable reference to a named type
+// and the return type is the same as the first parameter type.
 bool
 isStreamInsertion(FunctionSymbol const& function)
 {
@@ -223,19 +218,19 @@ populateFunctionBriefFromOperator(FunctionSymbol& I)
     // Stream insertion operators are implemented as an exception to the operator name
     if (isStreamInsertion(I))
     {
-        I.javadoc->brief = "Stream insertion operator";
+        I.doc->brief = "Stream insertion operator";
         return true;
     }
 
     if (isCopyAssignment(I))
     {
-        I.javadoc->brief = "Copy assignment operator";
+        I.doc->brief = "Copy assignment operator";
         return true;
     }
 
     if (isMoveAssignment(I))
     {
-        I.javadoc->brief = "Move assignment operator";
+        I.doc->brief = "Move assignment operator";
         return true;
     }
 
@@ -247,14 +242,14 @@ populateFunctionBriefFromOperator(FunctionSymbol& I)
     MRDOCS_CHECK_OR(res, false);
     std::string briefStr(*res);
     briefStr += " operator";
-    I.javadoc->brief = std::move(briefStr);
+    I.doc->brief = std::move(briefStr);
     return true;
 }
 
 void
 populateFunctionBrief(FunctionSymbol& I, CorpusImpl const& corpus)
 {
-    MRDOCS_CHECK_OR(!I.javadoc->brief);
+    MRDOCS_CHECK_OR(!I.doc->brief);
     MRDOCS_CHECK_OR(!populateFunctionBriefFromClass(I, corpus));
     MRDOCS_CHECK_OR(!populateFunctionBriefFromOperator(I));
 }
@@ -271,27 +266,27 @@ getInfo(
     return Rinfo;
 }
 
-doc::Brief const*
+doc::BriefBlock const*
 getInfoBrief(
     Polymorphic<Type> const& R,
     CorpusImpl const& corpus)
 {
     Symbol const* Rinfo = getInfo(R, corpus);
     MRDOCS_CHECK_OR(Rinfo, nullptr);
-    MRDOCS_CHECK_OR(Rinfo->javadoc, nullptr);
-    MRDOCS_CHECK_OR(Rinfo->javadoc->brief, nullptr);
-    return &*Rinfo->javadoc->brief;
+    MRDOCS_CHECK_OR(Rinfo->doc, nullptr);
+    MRDOCS_CHECK_OR(Rinfo->doc->brief, nullptr);
+    return &*Rinfo->doc->brief;
 }
 
 bool
 populateFunctionReturnsFromFunctionBrief(
     FunctionSymbol& I)
 {
-    MRDOCS_CHECK_OR(I.javadoc->brief, false);
-    MRDOCS_CHECK_OR(I.javadoc->brief->children.size() == 1, false);
-    auto& brief = I.javadoc->brief->children[0];
-    MRDOCS_CHECK_OR(brief->Kind == doc::NodeKind::text, false);
-    std::string_view briefText = brief->string;
+    MRDOCS_CHECK_OR(I.doc->brief, false);
+    MRDOCS_CHECK_OR(I.doc->brief->children.size() == 1, false);
+    auto& briefInline = I.doc->brief->children[0];
+    MRDOCS_CHECK_OR(briefInline->Kind == doc::InlineKind::Text, false);
+    std::string_view briefText = briefInline->asText().literal;
     static constexpr std::string_view briefPrefixes[] = {
         "Returns ",
         "Return ",
@@ -305,7 +300,7 @@ populateFunctionReturnsFromFunctionBrief(
         if (briefText.starts_with(prefix))
         {
             briefText.remove_prefix(prefix.size());
-            I.javadoc->returns.emplace_back(std::string(briefText));
+            I.doc->returns.emplace_back(briefText);
             return true;
         }
     }
@@ -322,19 +317,16 @@ populateFunctionReturnsForSpecial(
     {
         if (auto* brief = getInfoBrief(innerR, corpus))
         {
-            I.javadoc->returns.emplace_back(*brief);
+            doc::ReturnsBlock r;
+            r.children = brief->children;
+            I.doc->returns.emplace_back(std::move(r));
             return true;
         }
         auto const exp = innermostTypenameString(innerR);
         MRDOCS_CHECK_OR(exp, false);
-        doc::Returns r;
-        r.children.emplace_back(
-            Polymorphic<doc::Text>(std::in_place_type<doc::Text>,
-                                   std::string("The object converted to ")));
-        r.children.emplace_back(
-            Polymorphic<doc::Text>(std::in_place_type<doc::Styled>,
-                                   std::string(*exp), doc::Style::mono));
-        I.javadoc->returns.emplace_back(std::move(r));
+        doc::ReturnsBlock r("The object converted to ");
+        r.emplace_back<doc::CodeInline>(std::string(*exp));
+        I.doc->returns.emplace_back(std::move(r));
         return true;
     }
     MRDOCS_CHECK_OR(I.OverloadedOperator != OperatorKind::None, false);
@@ -342,7 +334,7 @@ populateFunctionReturnsForSpecial(
     // Stream operator
     if (isStreamInsertion(I))
     {
-        I.javadoc->returns.emplace_back("Reference to the current output stream");
+        I.doc->returns.emplace_back("Reference to the current output stream");
         return true;
     }
 
@@ -353,7 +345,7 @@ populateFunctionReturnsForSpecial(
         Symbol const* RInfo = getInfo(innerR, corpus);
         MRDOCS_CHECK_OR(RInfo, false);
         MRDOCS_CHECK_OR(RInfo->id == I.Parent, false);
-        I.javadoc->returns.emplace_back("Reference to the current object");
+        I.doc->returns.emplace_back("Reference to the current object");
         return true;
     }
     else if (I.ReturnType->isPointer())
@@ -361,7 +353,7 @@ populateFunctionReturnsForSpecial(
         Symbol const* RInfo = getInfo(innerR, corpus);
         MRDOCS_CHECK_OR(RInfo, false);
         MRDOCS_CHECK_OR(RInfo->id == I.Parent, false);
-        I.javadoc->returns.emplace_back("Pointer to the current object");
+        I.doc->returns.emplace_back("Pointer to the current object");
         return true;
     }
 
@@ -382,10 +374,8 @@ populateFunctionReturnsForSpecial(
             dynamic_cast<NamedType &>(*I.ReturnType).FundamentalType ==
                 FundamentalTypeKind::Bool,
             false);
-        doc::Returns r;
-        r.children.emplace_back(
-            Polymorphic<doc::Text>(std::in_place_type<doc::Styled>,
-                                   std::string("true"), doc::Style::mono));
+        doc::ReturnsBlock r;
+        r.emplace_back<doc::CodeInline>("true");
         std::string_view midText;
         switch (I.OverloadedOperator)
         {
@@ -413,21 +403,17 @@ populateFunctionReturnsForSpecial(
             default:
                 MRDOCS_UNREACHABLE();
         }
-        r.children.emplace_back(Polymorphic<doc::Text>(
-            std::in_place_type<doc::Text>, std::string(midText)));
-        r.children.emplace_back(
-            Polymorphic<doc::Text>(std::in_place_type<doc::Styled>,
-                                   std::string("false"), doc::Style::mono));
-        r.children.emplace_back(Polymorphic<doc::Text>(
-            std::in_place_type<doc::Text>, std::string(" otherwise")));
-        I.javadoc->returns.emplace_back(std::move(r));
+        r += midText;
+        r += doc::CodeInline("false");
+        r += " otherwise";
+        I.doc->returns.emplace_back(std::move(r));
         return false;
     }
 
     // Spaceship operator
     if (I.OverloadedOperator == OperatorKind::Spaceship)
     {
-        I.javadoc->returns.emplace_back("The relative order of the objects");
+        I.doc->returns.emplace_back("The relative order of the objects");
         return true;
     }
 
@@ -442,20 +428,20 @@ populateFunctionReturnsForSpecial(
         MRDOCS_ASSERT(!I.ReturnType.valueless_after_move());
         if (I.ReturnType->isLValueReference())
         {
-            I.javadoc->returns.emplace_back("Reference to the current object");
+            I.doc->returns.emplace_back("Reference to the current object");
         }
         else if (I.ReturnType->isRValueReference())
         {
-            I.javadoc->returns.emplace_back(
+            I.doc->returns.emplace_back(
                 "Rvalue reference to the current object");
         }
         else if (I.ReturnType->isPointer())
         {
-            I.javadoc->returns.emplace_back("Pointer to the current object");
+            I.doc->returns.emplace_back("Pointer to the current object");
         }
         else
         {
-            I.javadoc->returns.emplace_back("Another instance of the object");
+            I.doc->returns.emplace_back("Another instance of the object");
         }
         return true;
     }
@@ -471,7 +457,7 @@ populateFunctionReturnsFromReturnTypeBrief(
 {
     if (auto* brief = getInfoBrief(innerR, corpus))
     {
-        I.javadoc->returns.emplace_back(*brief);
+        I.doc->returns.emplace_back(*brief);
         return true;
     }
     return false;
@@ -480,7 +466,7 @@ populateFunctionReturnsFromReturnTypeBrief(
 void
 populateFunctionReturns(FunctionSymbol& I, CorpusImpl const& corpus)
 {
-    MRDOCS_CHECK_OR(I.javadoc->returns.empty());
+    MRDOCS_CHECK_OR(I.doc->returns.empty());
 
     // Populate the return doc from brief of the function
     // when the brief is "Returns ..."
@@ -507,19 +493,19 @@ populateFunctionReturns(FunctionSymbol& I, CorpusImpl const& corpus)
     MRDOCS_CHECK_OR(!populateFunctionReturnsFromReturnTypeBrief(I, inner, corpus));
 }
 
-/* Get a list of all parameter names in javadoc
+/* Get a list of all parameter names in doc
 
-    The javadoc parameter names can contain a single parameter or
+    The doc parameter names can contain a single parameter or
     a list of parameters separated by commas. This function
-    returns a list of all parameter names in the javadoc.
+    returns a list of all parameter names in the doc.
  */
 llvm::SmallVector<std::string_view, 32>
-getJavadocParamNames(Javadoc const& javadoc)
+getDocCommentParamNames(DocComment const& doc)
 {
     llvm::SmallVector<std::string_view, 32> result;
-    for (auto const& javadocParam: javadoc.params)
+    for (auto const& docParam: doc.params)
     {
-        auto const& paramNamesStr = javadocParam.name;
+        auto const& paramNamesStr = docParam.name;
         for (auto paramNames = std::views::split(paramNamesStr, ',');
              auto const& paramName: paramNames)
         {
@@ -686,8 +672,9 @@ setCntrOrAssignParamDoc(
         }
         return !isAssign ? "construct" : "assign";
     }();
-    I.javadoc->params.emplace_back(
-        *param.Name, std::format("The {} to {} from", paramNoun, functionVerb));
+    I.doc->params.emplace_back(
+        *param.Name,
+        std::format("The {} to {} from", paramNoun, functionVerb));
     return true;
 }
 
@@ -705,7 +692,7 @@ setBinaryOpParamDoc(
 
     // Set the parameter description if we can
     std::string_view const paramAdj = indexFree == 0 ? "left" : "right";
-    I.javadoc->params.emplace_back(*param.Name,
+    I.doc->params.emplace_back(*param.Name,
                                    std::format("The {} operand", paramAdj));
     return true;
 }
@@ -722,7 +709,7 @@ setUnaryOpParamDoc(
     MRDOCS_CHECK_OR(I.Params.size() == 1, false);
 
     // Set the parameter description if we can
-    I.javadoc->params.emplace_back(*param.Name, "The operand");
+    I.doc->params.emplace_back(*param.Name, "The operand");
     return true;
 }
 
@@ -736,11 +723,11 @@ setStreamOperatorParamDoc(
     MRDOCS_CHECK_OR(isStreamInsertion(I), false);
     if (index == 0)
     {
-        I.javadoc->params.emplace_back(*param.Name, "An output stream");
+        I.doc->params.emplace_back(*param.Name, "An output stream");
     }
     else
     {
-        I.javadoc->params.emplace_back(*param.Name, "The object to output");
+        I.doc->params.emplace_back(*param.Name, "The object to output");
     }
     return true;
 }
@@ -764,7 +751,6 @@ setFunctionParamDoc(
     {
         return;
     }
-
     if (setUnaryOpParamDoc(I, param, index))
     {
         return;
@@ -774,9 +760,11 @@ setFunctionParamDoc(
     // as a description for the parameter
     MRDOCS_ASSERT(!param.Type.valueless_after_move());
     auto const& innerParam = innermostType(param.Type);
-    doc::Brief const* paramBrief = getInfoBrief(innerParam, corpus);
+    doc::BriefBlock const* paramBrief = getInfoBrief(innerParam, corpus);
     MRDOCS_CHECK_OR(paramBrief);
-    I.javadoc->params.emplace_back(*param.Name, *paramBrief);
+    doc::ParamBlock p(paramBrief->asInlineContainer());
+    p.name = *param.Name;
+    I.doc->params.emplace_back(std::move(p));
 }
 
 void
@@ -802,7 +790,7 @@ populateFunctionParam(
 void
 populateFunctionParams(FunctionSymbol& I, CorpusImpl const& corpus)
 {
-    auto documentedParams = getJavadocParamNames(*I.javadoc);
+    auto documentedParams = getDocCommentParamNames(*I.doc);
     for (std::size_t i = 0; i < I.Params.size(); ++i)
     {
         populateFunctionParam(I, I.Params[i], i, documentedParams, corpus);
@@ -812,4 +800,4 @@ populateFunctionParams(FunctionSymbol& I, CorpusImpl const& corpus)
 }
 } // mrdocs
 
-#endif // MRDOCS_LIB_METADATA_FINALIZERS_JAVADOC_FUNCTION_HPP
+#endif // MRDOCS_LIB_METADATA_FINALIZERS_DOCCOMMENT_FUNCTION_HPP
diff --git a/src/lib/Metadata/Finalizers/Javadoc/Overloads.hpp b/src/lib/Metadata/Finalizers/DocComment/Overloads.hpp
similarity index 64%
rename from src/lib/Metadata/Finalizers/Javadoc/Overloads.hpp
rename to src/lib/Metadata/Finalizers/DocComment/Overloads.hpp
index b13bdf50f..c48ba576f 100644
--- a/src/lib/Metadata/Finalizers/Javadoc/Overloads.hpp
+++ b/src/lib/Metadata/Finalizers/DocComment/Overloads.hpp
@@ -8,16 +8,18 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#ifndef MRDOCS_LIB_METADATA_FINALIZERS_JAVADOC_OVERLOADS_HPP
-#define MRDOCS_LIB_METADATA_FINALIZERS_JAVADOC_OVERLOADS_HPP
+#ifndef MRDOCS_LIB_METADATA_FINALIZERS_DOCCOMMENT_OVERLOADS_HPP
+#define MRDOCS_LIB_METADATA_FINALIZERS_DOCCOMMENT_OVERLOADS_HPP
 
 #include <lib/CorpusImpl.hpp>
-#include <lib/Metadata/Finalizers/Javadoc/Function.hpp>
+#include <lib/Metadata/Finalizers/DocComment/Function.hpp>
 #include <lib/Metadata/SymbolSet.hpp>
 #include <utility>
 
 namespace mrdocs {
 namespace {
+
+// Create a view of all functions in an overload set
 auto
 overloadFunctionsRange(OverloadsSymbol const& O, CorpusImpl& corpus_)
 {
@@ -44,15 +46,15 @@ bool
 populateOverloadsBriefIfAllSameBrief(OverloadsSymbol& I, Range&& functionsWithBrief)
 {
     auto first = *functionsWithBrief.begin();
-    doc::Brief const& firstBrief = *first.javadoc->brief;
+    doc::BriefBlock const& firstBrief = *first.doc->brief;
     if (auto otherFunctions = std::views::drop(functionsWithBrief, 1);
         std::ranges::all_of(otherFunctions, [&](FunctionSymbol const& otherFunction)
         {
-            doc::Brief const& otherBrief = *otherFunction.javadoc->brief;
+            doc::BriefBlock const& otherBrief = *otherFunction.doc->brief;
             return otherBrief.children == firstBrief.children;
         }))
     {
-        I.javadoc->brief = firstBrief;
+        I.doc->brief = firstBrief;
         return true;
     }
     return false;
@@ -67,17 +69,17 @@ populateOverloadsFromClass(OverloadsSymbol& I)
         return false;
     case FunctionClass::Constructor:
     {
-        I.javadoc->brief = "Constructors";
+        I.doc->brief = "Constructors";
         return true;
     }
     case FunctionClass::Destructor:
     {
-        I.javadoc->brief = "Destructors";
+        I.doc->brief = "Destructors";
         return true;
     }
     case FunctionClass::Conversion:
     {
-        I.javadoc->brief = "Conversion operators";
+        I.doc->brief = "Conversion operators";
         return true;
     }
     default:
@@ -95,7 +97,7 @@ populateOverloadsFromOperator(OverloadsSymbol& I, Range&& functions)
     if (I.OverloadedOperator == OperatorKind::LessLess &&
         std::ranges::all_of(functions, isStreamInsertion))
     {
-        I.javadoc->brief = "Stream insertion operators";
+        I.doc->brief = "Stream insertion operators";
         return true;
     }
 
@@ -109,7 +111,7 @@ populateOverloadsFromOperator(OverloadsSymbol& I, Range&& functions)
     MRDOCS_CHECK_OR(res, false);
     std::string briefStr(*res);
     briefStr += " operators";
-    I.javadoc->brief = std::move(briefStr);
+    I.doc->brief = std::move(briefStr);
     return true;
 }
 
@@ -126,22 +128,30 @@ populateOverloadsFromFunctionName(OverloadsSymbol& I)
     {
         return false;
     }
-    I.javadoc->brief.emplace();
-    I.javadoc->brief->children.emplace_back(
-        std::in_place_type<doc::Styled>, std::string(name), doc::Style::mono);
-    I.javadoc->brief->children.emplace_back(
-        std::in_place_type<doc::Text>, std::string(" overloads"));
+    I.doc->brief.emplace();
+    I.doc->brief->emplace_back<doc::CodeInline>(name);
+    I.doc->brief->children.emplace_back(
+        std::in_place_type<doc::TextInline>, std::string(" overloads"));
     return true;
 }
 
+// Populate the brief of an overload set according to the following rules:
+// 1. If all functions have the same brief, use that brief
+// 2. Otherwise, if the overload set is for a special function (constructor, destructor
+//    or conversion operator), use a generic brief according to the function class
+// 3. Otherwise, if the overload set is for an operator, use a generic brief
+//    according to the operator name
+// 4. Otherwise, if any function has a brief, use the function name as the brief
+// 5. Otherwise, do not populate the brief
+//
 template <class Range>
 void
 populateOverloadsBrief(OverloadsSymbol& I, Range&& functions, CorpusImpl& corpus)
 {
     auto functionsWithBrief = std::views::
         filter(functions, [](FunctionSymbol const& function) {
-        return function.javadoc && function.javadoc->brief
-               && !function.javadoc->brief->empty();
+        return function.doc && function.doc->brief
+               && !function.doc->brief->empty();
     });
     auto anyMemberBrief = !std::ranges::empty(functionsWithBrief);
     if (!corpus.config->autoFunctionMetadata &&
@@ -174,24 +184,24 @@ populateOverloadsReturns(OverloadsSymbol& I, Range&& functions) {
     auto functionReturns = functions |
         std::views::filter([](FunctionSymbol const& function)
             {
-                return function.javadoc && !function.javadoc->returns.empty();
+                return function.doc && !function.doc->returns.empty();
             }) |
         std::views::transform([](FunctionSymbol const& function)
             {
-                return function.javadoc->returns;
+                return function.doc->returns;
             }) |
         std::views::join;
-    for (doc::Returns const& functionReturn: functionReturns)
+    for (doc::ReturnsBlock const& functionReturn: functionReturns)
     {
         auto sameIt = std::ranges::find_if(
-            I.javadoc->returns,
-            [&functionReturn](doc::Returns const& overloadReturns)
+            I.doc->returns,
+            [&functionReturn](doc::ReturnsBlock const& overloadReturns)
             {
                 return overloadReturns == functionReturn;
             });
-        if (sameIt == I.javadoc->returns.end())
+        if (sameIt == I.doc->returns.end())
         {
-            I.javadoc->returns.push_back(functionReturn);
+            I.doc->returns.push_back(functionReturn);
         }
     }
 }
@@ -202,24 +212,24 @@ populateOverloadsParams(OverloadsSymbol& I, Range& functions) {
     auto functionParams = functions |
         std::views::filter([](FunctionSymbol const& function)
             {
-                return function.javadoc && !function.javadoc->params.empty();
+                return function.doc && !function.doc->params.empty();
             }) |
         std::views::transform([](FunctionSymbol const& function)
             {
-                return function.javadoc->params;
+                return function.doc->params;
             }) |
         std::views::join;
-    for (doc::Param const& functionParam: functionParams)
+    for (doc::ParamBlock const& functionParam: functionParams)
     {
         auto sameIt = std::ranges::find_if(
-            I.javadoc->params,
-            [&functionParam](doc::Param const& overloadParam)
+            I.doc->params,
+            [&functionParam](doc::ParamBlock const& overloadParam)
             {
                 return overloadParam.name == functionParam.name;
             });
-        if (sameIt == I.javadoc->params.end())
+        if (sameIt == I.doc->params.end())
         {
-            I.javadoc->params.push_back(functionParam);
+            I.doc->params.push_back(functionParam);
         }
     }
 }
@@ -230,24 +240,24 @@ populateOverloadsTParams(OverloadsSymbol& I, Range& functions) {
     auto functionTParams = functions |
         std::views::filter([](FunctionSymbol const& function)
             {
-                return function.javadoc && !function.javadoc->tparams.empty();
+                return function.doc && !function.doc->tparams.empty();
             }) |
         std::views::transform([](FunctionSymbol const& function)
             {
-                return function.javadoc->tparams;
+                return function.doc->tparams;
             }) |
         std::views::join;
-    for (doc::TParam const& functionTParam: functionTParams)
+    for (doc::TParamBlock const& functionTParam: functionTParams)
     {
         auto sameIt = std::ranges::find_if(
-            I.javadoc->tparams,
-            [&functionTParam](doc::TParam const& overloadTParam)
+            I.doc->tparams,
+            [&functionTParam](doc::TParamBlock const& overloadTParam)
             {
                 return overloadTParam.name == functionTParam.name;
             });
-        if (sameIt == I.javadoc->tparams.end())
+        if (sameIt == I.doc->tparams.end())
         {
-            I.javadoc->tparams.push_back(functionTParam);
+            I.doc->tparams.push_back(functionTParam);
         }
     }
 }
@@ -258,24 +268,24 @@ populateOverloadsExceptions(OverloadsSymbol& I, Range& functions) {
     auto functionExceptions = functions |
         std::views::filter([](FunctionSymbol const& function)
             {
-                return function.javadoc && !function.javadoc->exceptions.empty();
+                return function.doc && !function.doc->exceptions.empty();
             }) |
         std::views::transform([](FunctionSymbol const& function)
             {
-                return function.javadoc->exceptions;
+                return function.doc->exceptions;
             }) |
         std::views::join;
-    for (doc::Throws const& functionException: functionExceptions)
+    for (doc::ThrowsBlock const& functionException: functionExceptions)
     {
         auto sameIt = std::ranges::find_if(
-            I.javadoc->exceptions,
-            [&functionException](doc::Throws const& overloadException)
+            I.doc->exceptions,
+            [&functionException](doc::ThrowsBlock const& overloadException)
             {
-                return overloadException.exception.string == functionException.exception.string;
+                return overloadException.exception.literal == functionException.exception.literal;
             });
-        if (sameIt == I.javadoc->exceptions.end())
+        if (sameIt == I.doc->exceptions.end())
         {
-            I.javadoc->exceptions.push_back(functionException);
+            I.doc->exceptions.push_back(functionException);
         }
     }
 }
@@ -286,24 +296,24 @@ populateOverloadsSees(OverloadsSymbol& I, Range& functions) {
     auto functionSees = functions |
         std::views::filter([](FunctionSymbol const& function)
             {
-                return function.javadoc && !function.javadoc->sees.empty();
+                return function.doc && !function.doc->sees.empty();
             }) |
         std::views::transform([](FunctionSymbol const& function)
             {
-                return function.javadoc->sees;
+                return function.doc->sees;
             }) |
         std::views::join;
-    for (doc::See const& functionSee: functionSees)
+    for (doc::SeeBlock const& functionSee: functionSees)
     {
         auto sameIt = std::ranges::find_if(
-            I.javadoc->sees,
-            [&functionSee](doc::See const& overloadSee)
+            I.doc->sees,
+            [&functionSee](doc::SeeBlock const& overloadSee)
             {
                 return overloadSee.children == functionSee.children;
             });
-        if (sameIt == I.javadoc->sees.end())
+        if (sameIt == I.doc->sees.end())
         {
-            I.javadoc->sees.push_back(functionSee);
+            I.doc->sees.push_back(functionSee);
         }
     }
 }
@@ -314,24 +324,24 @@ populateOverloadsPreconditions(OverloadsSymbol& I, Range& functions) {
     auto functionsPres = functions |
         std::views::filter([](FunctionSymbol const& function)
             {
-                return function.javadoc && !function.javadoc->preconditions.empty();
+                return function.doc && !function.doc->preconditions.empty();
             }) |
         std::views::transform([](FunctionSymbol const& function)
             {
-                return function.javadoc->preconditions;
+                return function.doc->preconditions;
             }) |
         std::views::join;
-    for (doc::Precondition const& functionPre: functionsPres)
+    for (doc::PreconditionBlock const& functionPre: functionsPres)
     {
         auto sameIt = std::ranges::find_if(
-            I.javadoc->preconditions,
-            [&functionPre](doc::Precondition const& overloadPre)
+            I.doc->preconditions,
+            [&functionPre](doc::PreconditionBlock const& overloadPre)
             {
                 return overloadPre.children == functionPre.children;
             });
-        if (sameIt == I.javadoc->preconditions.end())
+        if (sameIt == I.doc->preconditions.end())
         {
-            I.javadoc->preconditions.push_back(functionPre);
+            I.doc->preconditions.push_back(functionPre);
         }
     }
 }
@@ -342,24 +352,24 @@ populateOverloadsPostconditions(OverloadsSymbol& I, Range& functions) {
     auto functionsPosts = functions |
         std::views::filter([](FunctionSymbol const& function)
             {
-                return function.javadoc && !function.javadoc->postconditions.empty();
+                return function.doc && !function.doc->postconditions.empty();
             }) |
         std::views::transform([](FunctionSymbol const& function)
             {
-                return function.javadoc->postconditions;
+                return function.doc->postconditions;
             }) |
         std::views::join;
-    for (doc::Postcondition const& functionPost: functionsPosts)
+    for (doc::PostconditionBlock const& functionPost: functionsPosts)
     {
         auto sameIt = std::ranges::find_if(
-            I.javadoc->postconditions,
-            [&functionPost](doc::Postcondition const& overloadPost)
+            I.doc->postconditions,
+            [&functionPost](doc::PostconditionBlock const& overloadPost)
             {
                 return overloadPost.children == functionPost.children;
             });
-        if (sameIt == I.javadoc->postconditions.end())
+        if (sameIt == I.doc->postconditions.end())
         {
-            I.javadoc->postconditions.push_back(functionPost);
+            I.doc->postconditions.push_back(functionPost);
         }
     }
 }
@@ -367,4 +377,4 @@ populateOverloadsPostconditions(OverloadsSymbol& I, Range& functions) {
 }
 } // mrdocs
 
-#endif // MRDOCS_LIB_METADATA_FINALIZERS_JAVADOC_OVERLOADS_HPP
+#endif // MRDOCS_LIB_METADATA_FINALIZERS_DOCCOMMENT_OVERLOADS_HPP
diff --git a/src/lib/Metadata/Finalizers/DocComment/parseInlines.hpp b/src/lib/Metadata/Finalizers/DocComment/parseInlines.hpp
new file mode 100644
index 000000000..36b76f165
--- /dev/null
+++ b/src/lib/Metadata/Finalizers/DocComment/parseInlines.hpp
@@ -0,0 +1,1062 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_LIB_METADATA_FINALIZERS_DOCCOMMENT_PARSEINLINES_HPP
+#define MRDOCS_LIB_METADATA_FINALIZERS_DOCCOMMENT_PARSEINLINES_HPP
+
+#include <mrdocs/Metadata/DocComment/Inline.hpp>
+#include <mrdocs/Support/Algorithm.hpp>
+#include <mrdocs/Support/Parse.hpp>
+#include <mrdocs/Support/String.hpp>
+#include <utility>
+
+namespace mrdocs::doc {
+namespace {
+inline
+bool
+isPunctuation(char c)
+{
+    // ASCII punctuation per CommonMark (§2.2) (includes '_')
+    return is_one_of(c, R"(!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~)");
+}
+
+// ========================== RULE TABLE & FLAGS ===============================
+
+/// Flags that configure how a token behaves in the inline parser.
+/// Multiple flags may be OR'ed together for a rule.
+enum class RuleFlags : unsigned {
+    /// No special behavior.
+    None           = 0,
+
+    /// The token follows Markdown semantics (e.g., emphasis/strong rules).
+    /// Used to apply CommonMark-style delimiter and boundary logic.
+    Markdown       = 1u << 0,
+
+    /// The token represents an HTML tag (case-insensitive), allowing optional
+    /// whitespace and attributes inside angle brackets (e.g., <em>, <a href="">).
+    Html           = 1u << 1,
+
+    /// Apply CommonMark left/right “flanking” checks to decide whether a
+    /// delimiter may open and/or close. Crucial for underscores near identifiers.
+    RequiresFlank  = 1u << 2,
+
+    /// Allows a closing delimiter to pop through intervening frames until a
+    /// matching kind is found (typical Markdown/HTML implicit closing behavior).
+    ImplicitClose  = 1u << 3,
+
+    /// Do not scan nested delimiters inside
+    Barrier       = 1u << 4,
+
+    /// The token cannot be used intraword (e.g., '^' and '~' for super/subscript).
+    /// This is stricter than RequiresFlank.
+    NoIntraWord = 1u << 5,
+};
+
+/// Bitwise OR operator for RuleFlags.
+constexpr
+RuleFlags
+operator|(RuleFlags a, RuleFlags b)
+{
+    return static_cast<RuleFlags>(static_cast<unsigned>(a) | static_cast<unsigned>(b));
+}
+
+/// Bitwise AND operator for RuleFlags.
+constexpr
+bool
+has(RuleFlags f, RuleFlags bit)
+{
+    return (static_cast<unsigned>(f) & static_cast<unsigned>(bit)) != 0;
+}
+
+/// Single inline markup rule
+struct TagRule {
+    /// The kind of inline node this rule produces (e.g., Emph, Strong, Code, etc.)
+    InlineKind kind;
+    /// The exact string that triggers this rule when opening (e.g., "*", "<em>", "^")
+    std::string_view open;
+    /// The exact string that closes this rule (may equal `open` for symmetric tokens)
+    std::string_view close;
+    /// Flags describing behavior (Markdown, HTML, AsciiDoc, boundary rules, etc.)
+    RuleFlags flags;
+};
+
+// Table of tag rules
+// Order matters: try longer tokens first to disambiguate (** before *).
+inline
+constexpr
+TagRule
+kRules[] = {
+    // Markdown strong/emph/strike/code
+    { doc::InlineKind::Strong,       "**", "**", RuleFlags::Markdown | RuleFlags::RequiresFlank | RuleFlags::ImplicitClose },
+    { doc::InlineKind::Strong,       "__", "__", RuleFlags::Markdown | RuleFlags::RequiresFlank | RuleFlags::ImplicitClose | RuleFlags::NoIntraWord },
+    { doc::InlineKind::Strikethrough,"~~", "~~", RuleFlags::Markdown | RuleFlags::RequiresFlank | RuleFlags::ImplicitClose },
+    { doc::InlineKind::Emph,         "*",  "*",  RuleFlags::Markdown | RuleFlags::RequiresFlank | RuleFlags::ImplicitClose },
+    { doc::InlineKind::Emph,         "_",  "_",  RuleFlags::Markdown | RuleFlags::RequiresFlank | RuleFlags::ImplicitClose | RuleFlags::NoIntraWord },
+    { doc::InlineKind::Code,         "`",  "`",  RuleFlags::Markdown | RuleFlags::ImplicitClose | RuleFlags::Barrier },
+    { doc::InlineKind::Math,         "$$", "$$", RuleFlags::Markdown | RuleFlags::ImplicitClose | RuleFlags::Barrier },
+    { doc::InlineKind::Math,         "$",  "$",  RuleFlags::Markdown | RuleFlags::ImplicitClose | RuleFlags::Barrier },
+    { doc::InlineKind::Superscript,  "^",  "^",  RuleFlags::Markdown | RuleFlags::RequiresFlank | RuleFlags::ImplicitClose | RuleFlags::NoIntraWord },
+    { doc::InlineKind::Subscript,    "~",  "~",  RuleFlags::Markdown | RuleFlags::RequiresFlank | RuleFlags::ImplicitClose | RuleFlags::NoIntraWord },
+    { doc::InlineKind::Highlight,    "==", "==", RuleFlags::Markdown | RuleFlags::RequiresFlank | RuleFlags::ImplicitClose },
+
+    // HTML tags (case-insensitive). Allow spaces around names/attrs.
+    { doc::InlineKind::Emph,         "<em>",         "</em>",         RuleFlags::Html | RuleFlags::ImplicitClose },
+    { doc::InlineKind::Strong,       "<strong>",     "</strong>",     RuleFlags::Html | RuleFlags::ImplicitClose },
+    { doc::InlineKind::Code,         "<code>",       "</code>",       RuleFlags::Html | RuleFlags::ImplicitClose },
+    { doc::InlineKind::Superscript,  "<sup>",        "</sup>",        RuleFlags::Html | RuleFlags::ImplicitClose },
+    { doc::InlineKind::Subscript,    "<sub>",        "</sub>",        RuleFlags::Html | RuleFlags::ImplicitClose },
+    { doc::InlineKind::Strikethrough,"<del>",        "</del>",        RuleFlags::Html | RuleFlags::ImplicitClose },
+    { doc::InlineKind::Highlight,    "<mark>",       "</mark>",       RuleFlags::Html | RuleFlags::ImplicitClose },
+    { doc::InlineKind::LineBreak,    "<br>",         "",              RuleFlags::Html }, // also accept <br/> at runtime
+};
+
+// Synthetic rule to tag frames as "HTML-ish" so the stack logic can
+// consult its flags (ImplicitClose etc.). Needs to be visible to helpers.
+inline constexpr TagRule kHtmlRule{
+    doc::InlineKind::Text, "", "", RuleFlags::Html | RuleFlags::ImplicitClose
+};
+
+// Map supported HTML tag names to InlineKind
+inline
+std::optional<doc::InlineKind>
+html_inline_kind(std::string const& n)
+{
+    if (n == "em")
+    {
+        return doc::InlineKind::Emph;
+    }
+    if (n == "strong")
+    {
+        return doc::InlineKind::Strong;
+    }
+    if (n == "code")
+    {
+        return doc::InlineKind::Code;
+    }
+    if (n == "sub")
+    {
+        return doc::InlineKind::Subscript;
+    }
+    if (n == "sup")
+    {
+        return doc::InlineKind::Superscript;
+    }
+    if (n == "del")
+    {
+        return doc::InlineKind::Strikethrough;
+    }
+    if (n == "mark")
+    {
+        return doc::InlineKind::Highlight;
+    }
+    return std::nullopt;
+}
+
+
+// Find the first rule whose token matches s at i (opening or closing).
+template <bool opening>
+TagRule const*
+matchRuleImpl(std::string_view s, std::size_t i)
+{
+    for (auto const& r: kRules)
+    {
+        auto tok = opening ? r.open : r.close;
+        if (tok.empty())
+        {
+            continue;
+        }
+        if (i + tok.size() > s.size())
+        {
+            continue;
+        }
+        if (s.compare(i, tok.size(), tok) == 0)
+        {
+            return &r;
+        }
+    }
+    return nullptr;
+}
+
+inline
+TagRule const*
+matchOpeningRule(std::string_view s, std::size_t i)
+{
+    return matchRuleImpl<true>(s, i);
+}
+
+inline
+TagRule const*
+matchClosingRule(std::string_view s, std::size_t i)
+{
+    return matchRuleImpl<false>(s, i);
+}
+
+// ========================== COMMONMARK FLANKING ==============================
+//
+// left/right-flanking per CM 0.30: this basically disallows opening/closing
+// inside words: prev and next both alnum.
+//
+
+/// Evaluate left/right flanking at position i for a token of length len.
+struct Flank {
+    /// The position to the left is left-flanking, meaning the token can open
+    bool left  = false;
+    /// The position to the right is right-flanking, meaning the token can close
+    bool right = false;
+};
+
+inline
+Flank
+flank_at(std::string_view s, std::size_t i, std::size_t len)
+{
+    const char prev = (i == 0) ? '\0' : s[i - 1];
+    const char next = (i + len >= s.size()) ? '\0' : s[i + len];
+
+    const bool prev_space = (i == 0) || isWhitespace(prev);
+    const bool next_space = (i + len >= s.size()) || isWhitespace(next);
+    const bool prev_punct = (i > 0) && isPunctuation(prev);
+    const bool next_punct = (i + len < s.size()) && isPunctuation(next);
+
+    Flank f;
+    f.left  = !next_space && (!next_punct || prev_space || prev_punct);
+    f.right = !prev_space && (!prev_punct || next_space || next_punct);
+    return f;
+}
+
+inline
+bool
+can_open(TagRule const& r, std::string_view s, std::size_t i)
+{
+    if (!has(r.flags, RuleFlags::RequiresFlank))
+    {
+        return true;
+    }
+
+    std::size_t const len = r.open.size();
+    Flank const f = flank_at(s, i, len);
+
+    // Stricter rule: never open intraword
+    if (has(r.flags, RuleFlags::NoIntraWord))
+    {
+        char const prev = (i == 0) ? '\0' : s[i - 1];
+        char const next = (i + len >= s.size()) ? '\0' : s[i + len];
+        bool const is_intraword = isAlphaNumeric(prev) && isAlphaNumeric(next);
+        if (is_intraword)
+        {
+            return false;
+        }
+        return f.left;
+    }
+
+    // '*', '==', '~~' use standard flanking
+    return f.left;
+}
+
+inline
+bool
+can_close(TagRule const& r, std::string_view s, std::size_t i)
+{
+    if (!has(r.flags, RuleFlags::RequiresFlank))
+    {
+        return true;
+    }
+
+    std::size_t const len = r.close.size();
+    Flank const f = flank_at(s, i, len);
+
+    // Stricter rule: never close intraword
+    if (has(r.flags, RuleFlags::NoIntraWord))
+    {
+        char const prev = (i == 0) ? '\0' : s[i - 1];
+        char const next = (i + len >= s.size()) ? '\0' : s[i + len];
+        bool is_intraword = isAlphaNumeric(prev) && isAlphaNumeric(next);
+        if (is_intraword)
+        {
+            return false;
+        }
+        return f.right;
+    }
+
+    return f.right;
+}
+
+// ============================ EMIT/START HELPERS =============================
+
+// Emit text to the inline container, merging with previous text if possible.
+inline
+void
+emit_text(doc::InlineContainer& out, std::string&& text)
+{
+    if (text.empty())
+    {
+        return;
+    }
+    if (!out.empty() && out.back()->isText())
+    {
+        out.back()->asText().literal += text;
+        return;
+    }
+    out.emplace_back<doc::TextInline>(std::move(text));
+}
+
+// Start a new inline container of kind k, appending it to out.
+// Returns a reference to the new container for appending children.
+inline
+doc::InlineContainer&
+start_container(doc::InlineContainer& out, doc::InlineKind k)
+{
+    // Create k and return its child container.
+    switch (k)
+    {
+    case doc::InlineKind::Emph:
+        out.emplace_back<doc::EmphInline>();
+        break;
+    case doc::InlineKind::Strong:
+        out.emplace_back<doc::StrongInline>();
+        break;
+    case doc::InlineKind::Strikethrough:
+        out.emplace_back<doc::StrikethroughInline>();
+        break;
+    case doc::InlineKind::Highlight:
+        out.emplace_back<doc::HighlightInline>();
+        break;
+    case doc::InlineKind::Superscript:
+        out.emplace_back<doc::SuperscriptInline>();
+        break;
+    case doc::InlineKind::Subscript:
+        out.emplace_back<doc::SubscriptInline>();
+        break;
+    case doc::InlineKind::Code:
+        out.emplace_back<doc::CodeInline>();
+        break;
+    default:
+        MRDOCS_UNREACHABLE();
+    }
+    auto* ic = dynamic_cast<doc::InlineContainer*>(&*out.back());
+    MRDOCS_ASSERT(ic != nullptr); // container types must derive InlineContainer
+    return *ic;
+}
+
+// Emit a line break (hard or soft) to the output container.
+inline
+void
+emit_break(doc::InlineContainer& out, bool hard)
+{
+    if (hard)
+    {
+        out.emplace_back<doc::LineBreakInline>();
+    }
+    else
+    {
+        out.emplace_back<doc::SoftBreakInline>();
+    }
+}
+
+// Link/Image helpers
+inline
+doc::InlineContainer&
+start_link(doc::InlineContainer& out, std::string&& href) {
+    out.emplace_back<doc::LinkInline>();
+    auto& link = out.back()->asLink();
+    link.href = std::move(href);
+    auto* ic = dynamic_cast<doc::InlineContainer*>(&*out.back());
+    MRDOCS_ASSERT(ic != nullptr);
+    return *ic;
+}
+
+inline
+doc::InlineContainer&
+emit_image(doc::InlineContainer& out, std::string&& src, std::string&& alt)
+{
+    out.emplace_back<doc::ImageInline>();
+    auto& img = out.back()->asImage();
+    img.src = std::move(src);
+    img.alt = std::move(alt);
+    auto* ic = dynamic_cast<doc::InlineContainer*>(&*out.back());
+    MRDOCS_ASSERT(ic != nullptr);
+    return *ic;
+}
+
+// Flatten a temporary InlineContainer to plain text (for alt text fallback).
+inline
+std::string
+flatten_text(doc::InlineContainer const& c)
+{
+    std::string r;
+    for (auto const& el: c.children)
+    {
+        switch (el->Kind)
+        {
+        case doc::InlineKind::Text:
+            r += el->asText().literal;
+            break;
+        default: /* ignore formatting for alt */
+            break;
+        }
+    }
+    return r;
+}
+
+// Move all children from src → dst and clear src
+inline
+void move_children(doc::InlineContainer& dst, doc::InlineContainer& src)
+{
+    dst.insert(
+        dst.end(),
+        std::make_move_iterator(src.begin()),
+        std::make_move_iterator(src.end()));
+    src.clear();
+}
+
+// ================================ FRAMES =====================================
+
+// A Frame represents an opened container collecting children until its
+// corresponding close token is encountered.
+struct Frame {
+    // what we're building
+    doc::InlineKind kind;
+    // the rule that opened it
+    TagRule const* rule;
+    // where the finished node will be inserted
+    doc::InlineContainer* parent;
+    // children collected while open
+    doc::InlineContainer scratch;
+    // literal open token (for fallback)
+    std::string open_tok;
+};
+
+// For pending [label] or ![alt]
+struct Bracket {
+    bool is_image = false;
+    // where link/image will be emitted
+    doc::InlineContainer* parent = nullptr;
+    // label/alt children
+    doc::InlineContainer label;
+};
+
+// HTML parsing helpers ---------------------------------------------------------
+
+inline
+std::size_t
+skip_spaces(std::string_view s, std::size_t i)
+{
+    while (i < s.size() && isWhitespace(s[i]))
+    {
+        ++i;
+    }
+    return i;
+}
+
+// Parse a case-insensitive HTML tag with optional spaces/attrs.
+struct HtmlTag {
+    bool closing = false;
+    // lowercased name
+    std::string name;
+    // raw inside <> minus name and /, for simple attr parsing
+    std::string attrs;
+    // index of char after '>'
+    std::size_t end = 0;
+};
+
+// Parse an HTML tag at s[i], returning nullopt if not a tag.
+// On success, end is the index after '>'.
+inline
+std::optional<HtmlTag>
+parse_html_tag(std::string_view s, std::size_t i)
+{
+    if (i >= s.size() || s[i] != '<')
+    {
+        return std::nullopt;
+    }
+
+    std::size_t j = i + 1;
+    j = skip_spaces(s, j);
+
+    // is it a closing tag?
+    bool closing = false;
+    if (j < s.size() && s[j] == '/')
+    {
+        closing = true;
+        j = skip_spaces(s, j + 1);
+    }
+
+    // tag name
+    std::size_t name_start = j;
+    while (j < s.size() && isAlphaNumeric(s[j]))
+    {
+        ++j;
+    }
+    if (j == name_start)
+    {
+        return std::nullopt;
+    }
+    std::string name = toLowerCase(s.substr(name_start, j - name_start));
+
+    // attrs up to '>'
+    std::size_t attrs_start = j;
+    while (j < s.size() && s[j] != '>') ++j;
+    if (j >= s.size()) return std::nullopt;
+    // may include spaces and '/'
+    std::string attrs(s.substr(attrs_start, j - attrs_start));
+
+    return HtmlTag{closing, std::move(name), std::move(attrs), j + 1};
+}
+
+// read attribute value for key (case-insensitive). Accepts key="..."/'...' or key=bare.
+inline
+std::optional<std::string>
+html_get_attr(std::string const& attrs, std::string_view key)
+{
+    auto k = toLowerCase(key);
+    std::size_t i = 0;
+    while (i < attrs.size()) {
+        while (i < attrs.size() && isWhitespace(attrs[i]))
+        {
+            ++i;
+        }
+        std::size_t kstart = i;
+        while (
+            i < attrs.size()
+            && (isAlphaNumeric(attrs[i]) || attrs[i] == '-' || attrs[i] == '_'))
+        {
+            ++i;
+        }
+        if (i == kstart)
+        {
+            break;
+        }
+        std::string name = toLowerCase(std::string_view(attrs).substr(kstart, i - kstart));
+        i = skip_spaces(attrs, i);
+        if (i >= attrs.size() || attrs[i] != '=')
+        {
+            if (name == k)
+            {
+                return std::string{};
+            }
+            while (i < attrs.size() && !isWhitespace(attrs[i]))
+            {
+                ++i;
+            }
+            continue;
+        }
+        ++i;
+        i = skip_spaces(attrs, i);
+        if (i >= attrs.size())
+        {
+            break;
+        }
+        std::string value;
+        if (attrs[i] == '"' || attrs[i] == '\'') {
+            char q = attrs[i++];
+            std::size_t vstart = i;
+            while (i < attrs.size() && attrs[i] != q)
+            {
+                ++i;
+            }
+            value.assign(attrs.substr(vstart, i - vstart));
+            if (i < attrs.size())
+            {
+                ++i;
+            }
+        }
+        else
+        {
+            std::size_t vstart = i;
+            while (
+                i < attrs.size() &&
+                !isWhitespace(attrs[i]) &&
+                attrs[i] != '/')
+            {
+                ++i;
+            }
+            value.assign(attrs.substr(vstart, i - vstart));
+        }
+        if (name == k)
+        {
+            return value;
+        }
+    }
+    return std::nullopt;
+}
+
+// Minimal state holder to replace lots of lambdas in parse()
+struct ParserState {
+    // input
+    std::string_view s;
+    // stack of open frames
+    std::vector<Frame> frames;
+    // stack of open [label] or ![alt]
+    std::vector<Bracket> brackets;
+    // current container for text accumulation
+    doc::InlineContainer* cur{};
+    // output
+    std::string text;
+    // whether the next char is escaped
+    bool escape_next{ false };
+
+    void
+    flush_text()
+    {
+        if (!text.empty())
+        {
+            emit_text(*cur, std::move(text));
+            text.clear();
+        }
+    }
+
+    static void
+    push_text_node(doc::InlineContainer& out, std::string_view sv)
+    {
+        out.emplace_back<doc::TextInline>(std::string(sv));
+    }
+
+    void
+    push_frame(TagRule const* r)
+    {
+        flush_text();
+        frames.push_back(Frame{ r->kind, r, cur, {}, std::string(r->open) });
+        cur = &frames.back().scratch;
+    }
+
+    // Emit the opening token + flattened contents as literal text into its
+    // parent.
+    void
+    fallback_unclosed(Frame& f)
+    {
+        std::string literal(f.open_tok);
+        for (auto& el: f.scratch)
+        {
+            getAsPlainText(*el, literal);
+        }
+        emit_text(*f.parent, std::move(literal));
+    }
+
+    // Materialize a finished frame to its parent
+    inline
+    void
+    materialize_and_pop(Frame f)
+    {
+        // Line breaks are leaf inlines
+        if (f.kind == doc::InlineKind::LineBreak)
+        {
+            emit_break(*f.parent, /*hard*/ true);
+            cur = f.parent;
+            return;
+        }
+        if (f.kind == doc::InlineKind::SoftBreak)
+        {
+            emit_break(*f.parent, /*hard*/ false);
+            cur = f.parent;
+            return;
+        }
+
+        // Math is a *leaf* (not an InlineContainer): emit a single literal payload.
+        if (f.kind == doc::InlineKind::Math)
+        {
+            // We recorded its body into f.scratch (as Text children) while inside the barrier.
+            // Flatten to a single string and emit a MathInline leaf.
+            std::string lit = flatten_text(f.scratch);
+            f.parent->emplace_back<doc::MathInline>();
+            f.parent->back()->asMath().literal = std::move(lit);
+            cur = f.parent;
+            return;
+        }
+
+        // Links opened from HTML <a ...> keep href in open_tok
+        if (f.kind == doc::InlineKind::Link && f.rule
+            && has(f.rule->flags, RuleFlags::Html))
+        {
+            doc::InlineContainer& outC = start_link(*f.parent, std::move(f.open_tok));
+            move_children(outC, f.scratch);
+            cur = f.parent;
+            return;
+        }
+
+        // All remaining supported formatting kinds are containers
+        doc::InlineContainer* outC = &start_container(*f.parent, f.kind);
+        move_children(*outC, f.scratch);
+        cur = f.parent;
+    }
+
+    // Try to close the topmost frame of kind k, popping frames as needed.
+    bool
+    close_to_kind(doc::InlineKind k)
+    {
+        std::size_t match = frames.size();
+        while (match > 0)
+        {
+            --match;
+            if (frames[match].kind == k)
+            {
+                break;
+            }
+            auto* rr = frames[match].rule;
+            bool const can_cross = rr
+                                   && has(rr->flags, RuleFlags::ImplicitClose)
+                                   && !has(rr->flags, RuleFlags::Barrier);
+            if (!can_cross)
+            {
+                return false;
+            }
+        }
+        if (match == frames.size() || frames[match].kind != k)
+        {
+            return false;
+        }
+
+        flush_text();
+
+        // Literalize intervening crossed frames
+        while (frames.size() > match + 1)
+        {
+            Frame f = std::move(frames.back());
+            frames.pop_back();
+            fallback_unclosed(f);
+            cur = f.parent;
+        }
+
+        // Materialize the match
+        Frame f = std::move(frames.back());
+        frames.pop_back();
+        materialize_and_pop(std::move(f));
+        return true;
+    }
+
+    // Markdown link/image finalization at ']'
+    std::optional<std::size_t>
+    try_close_bracket(std::size_t i)
+    {
+        if (brackets.empty())
+        {
+            return std::nullopt;
+        }
+
+        flush_text();
+
+        Bracket b = std::move(brackets.back());
+        brackets.pop_back();
+
+        // After ']', expect optional spaces then '(' dest [title] ')'
+        std::size_t j = i + 1;
+        j = skip_spaces(s, j);
+        if (j >= s.size() || s[j] != '(')
+        {
+            // Not a link/image — emit literal "[...]" back to parent
+            push_text_node(*b.parent, b.is_image ? "![" : "[");
+            if (!b.label.empty())
+            {
+                move_children(*b.parent, b.label);
+            }
+            push_text_node(*b.parent, "]");
+            cur = b.parent;
+            return j - i; // we consumed ']'
+        }
+        ++j;
+        j = skip_spaces(s, j);
+
+        // Parse destination
+        std::string dest, title;
+        if (j < s.size() && (s[j] == '"' || s[j] == '\''))
+        {
+            char q = s[j++];
+            std::size_t start = j;
+            while (j < s.size() && s[j] != q)
+            {
+                ++j;
+            }
+            dest.assign(s.substr(start, j - start));
+            if (j < s.size())
+            {
+                ++j;
+            }
+        }
+        else
+        {
+            std::size_t start = j;
+            while (j < s.size() && s[j] != ')' && !isWhitespace(s[j]))
+            {
+                ++j;
+            }
+            dest.assign(s.substr(start, j - start));
+        }
+        j = skip_spaces(s, j);
+
+        // Optional title (ignored, but must be consumed)
+        if (j < s.size() && (s[j] == '"' || s[j] == '\''))
+        {
+            char q = s[j++];
+            std::size_t start = j;
+            while (j < s.size() && s[j] != q)
+            {
+                ++j;
+            }
+            title.assign(s.substr(start, j - start));
+            if (j < s.size())
+            {
+                ++j;
+            }
+            j = skip_spaces(s, j);
+        }
+
+        if (j >= s.size() || s[j] != ')')
+        {
+            // Invalid link — degrade to literal
+            push_text_node(*b.parent, b.is_image ? "![" : "[");
+            if (!b.label.empty())
+            {
+                move_children(*b.parent, b.label);
+            }
+            push_text_node(*b.parent, "]");
+            cur = b.parent;
+            return j - i;
+        }
+        ++j; // consume ')'
+
+        // Materialize
+        if (b.is_image)
+        {
+            emit_image(*b.parent, std::move(dest), flatten_text(b.label));
+        }
+        else
+        {
+            doc::InlineContainer& linkC = start_link(*b.parent, std::move(dest));
+            move_children(linkC, b.label);
+        }
+        cur = b.parent;
+        return j - i;
+    }
+};
+
+
+}
+
+
+/*  Parse the inline content of a text
+
+    The furthest clang goes is
+    clang::comments::TextComment, which we parse
+    as doc::TextInline. However, these still contain
+    javadoc, HTML, and markdown-like inline elements
+    that we want to parse and to represent in the corpus,
+    as they are supported by doxygen.
+
+    This parsing happens in a post-processing finalizer step
+    because the javadoc parser needs to concatenate
+    text nodes in multiple forms and we won't
+    have the tidied up text until after the
+    post-processing.
+
+    This is a focused implementation; it does not implement every last
+    corner of CommonMark, but only the features that exist in Doxygen.
+    It should implement the critical delimiter-run algorithm accurately.
+
+    What this parsing function implements:
+
+    - CommonMark-correct emphasis (* and _) including underscore
+      intraword rules and the “multiple-of-3” restriction.
+    - Backtick code spans per CommonMark (no parsing inside; we still emit a
+      container Code node with a single Text child).
+    - HTML tags with optional spacing and attributes; support <em>, <strong>,
+      <code>, <sup>, <sub>, <del>, <mark>, <br>, <a>, <img>.
+    - Markdown links/images: [text](dest "title") and ![alt](src "title").
+    - Nesting via a container stack; text nodes are terminal.
+    - Compact rule table for non-HTML markers.
+    - No <cctype>; all checks are explicit ASCII.
+    - Clear, rationale-heavy comments.
+ */
+inline
+ParseResult
+parse(char const* first, char const* last, doc::InlineContainer& out_root)
+{
+    std::string_view s(first, static_cast<std::size_t>(last - first));
+
+    ParserState st{
+        .s = s,
+        .frames = {},
+        .brackets = {},
+        .cur = &out_root,
+        .text = {},
+        .escape_next = false
+    };
+    st.frames.reserve(8);
+    st.brackets.reserve(4);
+    st.text.reserve(64);
+
+    for (std::size_t i = 0; i < s.size();) {
+        // If inside a barrier (e.g. backticks), only look for its own closer
+        if (!st.frames.empty() &&
+            st.frames.back().rule &&
+            has(st.frames.back().rule->flags, RuleFlags::Barrier))
+        {
+            TagRule const* br = st.frames.back().rule;
+            if (i + br->close.size() <= s.size() &&
+                s.compare(i, br->close.size(), br->close) == 0)
+            {
+                st.flush_text();
+                Frame f = std::move(st.frames.back());
+                st.frames.pop_back();
+                st.materialize_and_pop(std::move(f));
+                i += br->close.size();
+                continue;
+            }
+            st.text.push_back(s[i++]); // literal inside code span
+            continue;
+        }
+
+        char c = s[i];
+
+        // Backslash escape
+        if (st.escape_next) { st.text.push_back(c); st.escape_next = false; ++i; continue; }
+        if (c == '\\')      { st.escape_next = true; ++i; continue; }
+
+        // Markdown link/image openers
+        if (c == '!' && i + 1 < s.size() && s[i + 1] == '[') {
+            st.flush_text();
+            st.brackets.push_back(Bracket{ true, st.cur, {} });
+            st.cur = &st.brackets.back().label;
+            i += 2;
+            continue;
+        }
+        if (c == '[') {
+            st.flush_text();
+            st.brackets.push_back(Bracket{ false, st.cur, {} });
+            st.cur = &st.brackets.back().label;
+            ++i;
+            continue;
+        }
+        if (c == ']') {
+            if (auto adv = st.try_close_bracket(i)) { i += *adv; continue; }
+            st.text.push_back(c);
+            ++i;
+            continue;
+        }
+
+        // HTML tags (with spaces, attrs, case-insensitive)
+        if (c == '<') {
+            if (auto tag = parse_html_tag(s, i)) {
+                std::string const& name = tag->name;
+
+                // <br> and <br/>
+                if (!tag->closing && name == "br") {
+                    st.flush_text();
+                    emit_break(*st.cur, /*hard*/true);
+                    i = tag->end;
+                    continue;
+                }
+
+                // <img ...>
+                if (!tag->closing && name == "img") {
+                    st.flush_text();
+                    auto src = html_get_attr(tag->attrs, "src").value_or(std::string{});
+                    auto alt = html_get_attr(tag->attrs, "alt").value_or(std::string{});
+                    emit_image(*st.cur, std::move(src), std::move(alt));
+                    i = tag->end;
+                    continue;
+                }
+
+                // <a ...> / </a>
+                if (name == "a") {
+                    if (tag->closing) {
+                        if (st.close_to_kind(doc::InlineKind::Link)) {
+                            i = tag->end;
+                            continue;
+                        }
+                    } else {
+                        auto href = html_get_attr(tag->attrs, "href").value_or(std::string{});
+                        st.flush_text();
+                        st.frames.push_back(Frame{ doc::InlineKind::Link, &kHtmlRule, st.cur, {}, std::string{} });
+                        st.cur = &st.frames.back().scratch;
+                        st.frames.back().open_tok = std::move(href); // own the href bytes
+                    }
+                    i = tag->end;
+                    continue;
+                }
+
+                // Other supported phrasing tags
+                if (auto kind = html_inline_kind(name)) {
+                    if (tag->closing) {
+                        if (st.close_to_kind(*kind)) {
+                            i = tag->end;
+                            continue;
+                        }
+                    } else {
+                        st.flush_text();
+                        st.frames.push_back(Frame{ *kind, &kHtmlRule, st.cur, {}, "<tag>" });
+                        st.cur = &st.frames.back().scratch;
+                    }
+                    i = tag->end;
+                    continue;
+                }
+                // Unknown <foo>… — fall through to literal
+            }
+        }
+
+        // Try a closer first (for symmetric tokens)
+        if (TagRule const* rc = matchClosingRule(s, i)) {
+            const bool ok_close =
+                !has(rc->flags, RuleFlags::Markdown) || can_close(*rc, s, i);
+            if (ok_close && st.close_to_kind(rc->kind)) {
+                i += rc->close.size();
+                continue;
+            }
+        }
+
+        // Then an opener
+        if (TagRule const* ro = matchOpeningRule(s, i)) {
+            if (has(ro->flags, RuleFlags::Markdown) && !can_open(*ro, s, i)) {
+                st.text.append(ro->open);
+                i += ro->open.size();
+                continue;
+            }
+            st.push_frame(ro);
+            i += ro->open.size();
+            continue;
+        }
+
+        // Plain char
+        st.text.push_back(c);
+        ++i;
+    }
+
+    // EOF: flush and unwind
+    st.flush_text();
+
+    // Unclosed brackets → literal "[...]" back to parent
+    while (!st.brackets.empty()) {
+        Bracket b = std::move(st.brackets.back());
+        st.brackets.pop_back();
+        ParserState::push_text_node(*b.parent, b.is_image ? "![" : "[");
+        if (!b.label.empty())
+            move_children(*b.parent, b.label);
+        ParserState::push_text_node(*b.parent, "]");
+        st.cur = b.parent;
+    }
+
+    // Unclosed frames: HTML autoclosed, Markdown literalized
+    st.flush_text();
+    while (!st.frames.empty()) {
+        Frame f = std::move(st.frames.back());
+        st.frames.pop_back();
+        if (f.rule && has(f.rule->flags, RuleFlags::Html)) {
+            st.materialize_and_pop(std::move(f));
+        } else {
+            st.fallback_unclosed(f);
+            st.cur = f.parent;
+        }
+    }
+
+    ParseResult res{};
+    res.ptr = last;
+    return res;
+}
+
+} // mrdocs::doc
+
+#endif // MRDOCS_LIB_METADATA_FINALIZERS_DOCCOMMENT_PARSEINLINES_HPP
diff --git a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp b/src/lib/Metadata/Finalizers/DocCommentFinalizer.cpp
similarity index 54%
rename from src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
rename to src/lib/Metadata/Finalizers/DocCommentFinalizer.cpp
index 874d77ea1..68d741410 100644
--- a/src/lib/Metadata/Finalizers/JavadocFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/DocCommentFinalizer.cpp
@@ -9,10 +9,13 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <lib/Metadata/Finalizers/Javadoc/Function.hpp>
-#include <lib/Metadata/Finalizers/Javadoc/Overloads.hpp>
-#include <lib/Metadata/Finalizers/JavadocFinalizer.hpp>
+#include <lib/Metadata/Finalizers/DocComment/Function.hpp>
+#include <lib/Metadata/Finalizers/DocComment/Overloads.hpp>
+#include <lib/Metadata/Finalizers/DocComment/parseInlines.hpp>
+#include <lib/Metadata/Finalizers/DocCommentFinalizer.hpp>
+#include <mrdocs/ADT/Overload.hpp>
 #include <mrdocs/ADT/Polymorphic.hpp>
+#include <mrdocs/Metadata/DocComment.hpp>
 #include <mrdocs/Support/Algorithm.hpp>
 #include <mrdocs/Support/Path.hpp>
 #include <mrdocs/Support/ScopeExit.hpp>
@@ -22,97 +25,110 @@
 namespace mrdocs {
 
 void
-JavadocFinalizer::
+DocCommentFinalizer::
 build()
 {
-    // This function finalizes groups of javadoc components in
-    // different loops. This allows us to resolve references
-    // that are only related to that component group without
-    // creating circular dependencies.
+    auto infos =
+        corpus_.info_ |
+        std::views::filter([](std::unique_ptr<Symbol> const& ptr) {
+            return ptr && ptr->Extraction != ExtractionMode::Dependency;
+        }) |
+        std::views::transform([](std::unique_ptr<Symbol> const& ptr) -> Symbol& {
+            MRDOCS_ASSERT(ptr);
+            return *ptr;
+        });
 
     // Finalize briefs:
     // We do it first because all other steps require accessing
     // the brief of other functions, these often need to be resolved
     // with @copybrief or auto-brief, and we need to ensure that
     // there are no circular dependencies for other metadata.
-    for (auto& infoPtr : corpus_.info_)
+    for (auto& I : infos)
     {
-        MRDOCS_ASSERT(infoPtr);
-        Symbol& I = *infoPtr;
-        MRDOCS_CHECK_OR_CONTINUE(I.Extraction != ExtractionMode::Dependency);
         finalizeBrief(I);
     }
 
     // Finalize metadata:
     // A @copydetails command also implies we should copy
     // other metadata from the referenced symbol.
-    // We do it now because we need the complete metadata
-    // for all objects to generate javadoc for overloads.
+    // The metadata from other symbols includes things
+    // like function parameters, return types, etc...
+    // We copy this now because we need the complete metadata
+    // for all objects to generate doc for overloads.
     // For instance, overloads cannot aggregate function
     // parameters as if the parameters are not resolved.
-    for (auto& infoPtr : corpus_.info_)
+    for (auto& I : infos)
     {
-        MRDOCS_ASSERT(infoPtr);
-        Symbol& I = *infoPtr;
-        MRDOCS_CHECK_OR_CONTINUE(I.Extraction != ExtractionMode::Dependency);
-        finalizeMetadataCopies(I);
+        copyDetails(I);
     }
 
-    // Create javadoc for overloads
-    // - We do it before the references because the overloads
-    //   themselves can be used in the references. For instance,
-    //   `@ref foo` refers to the overload set because it doesn't
-    //   specify the function signature.
+    // Create doc for overloads:
+    // We do it before the references because the overloads
+    // themselves can be used in the references. For instance,
+    // `@ref foo` refers to the overload set because it doesn't
+    // specify the function signature.
     if (corpus_.config->overloads)
     {
-        for (auto& infoPtr : corpus_.info_)
+        for (auto& I : infos)
         {
-            MRDOCS_ASSERT(infoPtr);
-            Symbol& I = *infoPtr;
             MRDOCS_CHECK_OR_CONTINUE(I.isOverloads());
-            MRDOCS_CHECK_OR_CONTINUE(I.Extraction != ExtractionMode::Dependency);
-            if (!I.javadoc)
-            {
-                I.javadoc.emplace();
-            }
-            populateOverloadJavadoc(infoPtr->asOverloads());
+            generateOverloadDocs(I.asOverloads());
         }
     }
 
-    // Resolve references in the javadoc
-    for (auto& infoPtr : corpus_.info_)
+    // Resolve references in the doc:
+    // We do this before resolving overloads because a reference
+    // to a function without signature should resolve to the
+    // overload set, not to a specific function.
+    for (auto& I : infos)
     {
-        MRDOCS_ASSERT(infoPtr);
-        Symbol& I = *infoPtr;
-        MRDOCS_CHECK_OR_CONTINUE(I.Extraction != ExtractionMode::Dependency);
-        finalizeJavadoc(I);
+        // Rename this to "finalizeReferences" and move other
+        // functionality to other loops.
+        resolveReferences(I);
     }
 
     // Populate trivial function metadata
     // - We do it after the overloads because they should not
-    //   rely on metadata inherited from automatic generated javadoc
+    //   rely on metadata inherited from automatic generated doc
     // - We also do it after the references because some metadata
     //   might be resolved from references with @copydetails
     if (corpus_.config->autoFunctionMetadata)
     {
-        for (auto& infoPtr : corpus_.info_)
+        for (auto& I : infos)
         {
-            MRDOCS_ASSERT(infoPtr);
-            Symbol& I = *infoPtr;
             MRDOCS_CHECK_OR_CONTINUE(I.isFunction());
-            MRDOCS_CHECK_OR_CONTINUE(I.Extraction != ExtractionMode::Dependency);
-            populateFunctionJavadoc(I.asFunction());
+            generateAutoFunctionMetadata(I.asFunction());
         }
     }
 
-    // Remove invalid references in the Info objects
-    for (auto& infoPtr : corpus_.info_)
+    // Process relates
+    for (auto& I : infos)
     {
-        MRDOCS_ASSERT(infoPtr);
-        Symbol& I = *infoPtr;
-        visit(I, [&](auto& U) {
-            finalizeInfoData(U);
-        });
+        processRelates(I);
+    }
+
+    // Normalize siblings
+    for (auto& I : infos)
+    {
+        normalizeSiblings(I);
+    }
+
+    // Tidy up doc
+    for (auto& I : infos)
+    {
+        tidyUp(I);
+    }
+
+    // Parse inlines in terminal text nodes
+    for (auto& I : infos)
+    {
+        parseInlines(I);
+    }
+
+    // Remove invalid references
+    for (auto& I : infos)
+    {
+        removeInvalidReferences(I);
     }
 
     // - Emitting param warning require everything to be completely
@@ -121,12 +137,11 @@ build()
 }
 
 void
-JavadocFinalizer::
+DocCommentFinalizer::
 finalizeBrief(Symbol& I)
 {
     MRDOCS_CHECK_OR(!finalized_brief_.contains(&I));
     finalized_brief_.emplace(&I);
-    ScopeExitRestore s(current_context_, &I);
 
     report::trace(
             "Finalizing brief for '{}'",
@@ -134,11 +149,11 @@ finalizeBrief(Symbol& I)
 
     if (I.isOverloads())
     {
-        // Overloads are expected not to have javadoc.
-        // We'll create a javadoc for them if they don't have one.
-        if (!I.javadoc)
+        // Overloads are expected not to have doc.
+        // We'll create a doc for them if they don't have one.
+        if (!I.doc)
         {
-            I.javadoc.emplace();
+            I.doc.emplace();
         }
         // The brief of an overload is always empty
         auto& OI = I.asOverloads();
@@ -154,38 +169,39 @@ finalizeBrief(Symbol& I)
         return;
     }
 
-    MRDOCS_CHECK_OR(I.javadoc);
+    MRDOCS_CHECK_OR(I.doc);
+    auto& doc = *I.doc;
     // Copy brief from other symbols if there's a @copydoc
-    copyBrief(*I.javadoc);
+    copyBrief(I, doc);
     // Set auto brief if brief is still empty
-    setAutoBrief(*I.javadoc);
+    setAutoBrief(doc);
 }
 
 void
-JavadocFinalizer::
-copyBrief(Javadoc& javadoc)
+DocCommentFinalizer::
+copyBrief(Symbol const& ctx, DocComment& doc)
 {
-    MRDOCS_CHECK_OR(javadoc.brief);
-    MRDOCS_CHECK_OR(!javadoc.brief->copiedFrom.empty());
-    MRDOCS_CHECK_OR(javadoc.brief->children.empty());
+    MRDOCS_CHECK_OR(doc.brief);
+    MRDOCS_CHECK_OR(!doc.brief->copiedFrom.empty());
+    MRDOCS_CHECK_OR(doc.brief->children.empty());
 
-    for (std::string const& ref: javadoc.brief->copiedFrom)
+    for (std::string const& ref: doc.brief->copiedFrom)
     {
         // Look for source
-        auto resRef =
-            corpus_.lookup(current_context_->id, ref);
+        auto resRef = corpus_.lookup(ctx.id, ref);
 
         // Check if the source exists
         if (!resRef)
         {
             if (corpus_.config->warnings &&
                 corpus_.config->warnBrokenRef &&
-                !refWarned_.contains({ref, current_context_->Name}))
+                !refWarned_.contains({ref, ctx.Name}))
             {
                 this->warn(
+                    ctx,
                     "{}: Failed to copy brief from '{}' (symbol not found)\n"
                     "    {}",
-                    corpus_.Corpus::qualifiedName(*current_context_),
+                    corpus_.Corpus::qualifiedName(ctx),
                     ref,
                     resRef.error().reason());
             }
@@ -197,20 +213,21 @@ copyBrief(Javadoc& javadoc)
         finalizeBrief(const_cast<Symbol&>(res));
 
         // Check if the source has a brief
-        if (!res.javadoc ||
-            !res.javadoc->brief.has_value())
+        if (!res.doc ||
+            !res.doc->brief.has_value())
         {
             if (corpus_.config->warnings &&
                 corpus_.config->warnBrokenRef &&
-                !refWarned_.contains({ref, current_context_->Name}))
+                !refWarned_.contains({ref, ctx.Name}))
             {
                 auto resPrimaryLoc = getPrimaryLocation(res);
                 this->warn(
+                    ctx,
                     "{}: Failed to copy brief from {} '{}' (no brief available).\n"
                     "    No brief available.\n"
                     "        {}:{}\n"
                     "        Note: No brief available for '{}'.",
-                    corpus_.Corpus::qualifiedName(*current_context_),
+                    corpus_.Corpus::qualifiedName(ctx),
                     toString(res.Kind),
                     ref,
                     resPrimaryLoc->FullPath,
@@ -220,112 +237,95 @@ copyBrief(Javadoc& javadoc)
             continue;
         }
 
-        Javadoc const& src = *res.javadoc;
-        javadoc.brief->children = src.brief->children;
+        DocComment const& src = *res.doc;
+        doc.brief->children = src.brief->children;
         return;
     }
 }
 
 void
-JavadocFinalizer::
-setAutoBrief(Javadoc& javadoc) const
+DocCommentFinalizer::
+setAutoBrief(DocComment& doc) const
 {
     MRDOCS_CHECK_OR(corpus_.config->autoBrief);
-    MRDOCS_CHECK_OR(!javadoc.brief);
-    MRDOCS_CHECK_OR(!javadoc.blocks.empty());
-
-    auto isInvalidBriefText = [](Polymorphic<doc::Text> const& text) {
-        return text.valueless_after_move()
-               || text->string.empty()
-               || text->Kind == doc::NodeKind::copy_details
-               || isWhitespace(text->string);
-    };
+    MRDOCS_CHECK_OR(!doc.brief);
+    MRDOCS_CHECK_OR(!doc.Document.empty());
+
+    auto isInvalidBriefText = [](
+        Polymorphic<doc::Inline> const& el)
+        {
+            MRDOCS_ASSERT(!el.valueless_after_move());
+            return !el->isText() ||
+                   el->asText().literal.empty() ||
+                   el->asText().Kind == doc::InlineKind::CopyDetails ||
+                   isWhitespace(el->asText().literal);
+        };
 
-    for (auto it = javadoc.blocks.begin(); it != javadoc.blocks.end();)
+    for (auto it = doc.Document.begin(); it != doc.Document.end();)
     {
         if (auto& block = *it;
-            block->Kind == doc::NodeKind::paragraph ||
-            block->Kind == doc::NodeKind::details)
+            block->Kind == doc::BlockKind::Paragraph)
         {
-            auto& para = dynamic_cast<doc::Paragraph&>(*block);
+            auto& para = dynamic_cast<doc::ParagraphBlock&>(*block);
             if (std::ranges::all_of(para.children, isInvalidBriefText))
             {
                 ++it;
                 continue;
             }
-            javadoc.brief.emplace();
-            javadoc.brief->children = para.children;
-            it = javadoc.blocks.erase(it);
+            doc.brief.emplace();
+            doc.brief->children = para.children;
+            it = doc.Document.erase(it);
             return;
         }
         ++it;
     }
 }
 
-namespace {
-TemplateInfo const*
-getTemplateInfo(Symbol& I)
-{
-    return visit(I, [](auto& I) -> TemplateInfo const* {
-        if constexpr (requires { I.Template; })
-        {
-            if (I.Template)
-            {
-                return &*I.Template;
-            }
-        }
-        return nullptr;
-    });
-}
-}
-
 void
-JavadocFinalizer::
-finalizeMetadataCopies(Symbol& I)
+DocCommentFinalizer::
+copyDetails(Symbol& I)
 {
     MRDOCS_CHECK_OR(!finalized_metadata_.contains(&I));
     finalized_metadata_.emplace(&I);
-    ScopeExitRestore s(current_context_, &I);
 
     report::trace(
             "Finalizing metadata for '{}'",
             corpus_.Corpus::qualifiedName(I));
 
-    MRDOCS_CHECK_OR(I.javadoc);
-    MRDOCS_CHECK_OR(!I.javadoc->blocks.empty());
-    Javadoc& destJavadoc = *I.javadoc;
+    MRDOCS_CHECK_OR(I.doc);
+    MRDOCS_CHECK_OR(!I.doc->Document.empty());
+    DocComment& destDoc = *I.doc;
 
-    llvm::SmallVector<doc::CopyDetails, 16> copiedRefs;
-    for (auto& block: destJavadoc.blocks)
+    llvm::SmallVector<doc::CopyDetailsInline, 16> copiedRefs;
+    for (auto& block: destDoc.Document)
     {
-        MRDOCS_CHECK_OR_CONTINUE(
-            block->Kind == doc::NodeKind::paragraph
-            || block->Kind == doc::NodeKind::details);
-        auto& para = dynamic_cast<doc::Paragraph&>(*block);
+        MRDOCS_CHECK_OR_CONTINUE(block->isParagraph());
+        auto& para = dynamic_cast<doc::ParagraphBlock&>(*block);
         MRDOCS_CHECK_OR_CONTINUE(!para.children.empty());
 
         for (auto& text: para.children)
         {
-            MRDOCS_CHECK_OR_CONTINUE(text->Kind == doc::NodeKind::copy_details);
-            copiedRefs.emplace_back(dynamic_cast<doc::CopyDetails&>(*text));
+            MRDOCS_CHECK_OR_CONTINUE(text->isCopyDetails());
+            copiedRefs.emplace_back(dynamic_cast<doc::CopyDetailsInline&>(*text));
         }
         MRDOCS_CHECK_OR_CONTINUE(!copiedRefs.empty());
     }
 
-    for (doc::CopyDetails const& copied: copiedRefs)
+    for (doc::CopyDetailsInline const& copied: copiedRefs)
     {
         // Find element
-        auto resRef = corpus_.lookup(current_context_->id, copied.string);
+        auto resRef = corpus_.lookup(I.id, copied.string);
         if (!resRef)
         {
             if (corpus_.config->warnings &&
                 corpus_.config->warnBrokenRef &&
-                !refWarned_.contains({copied.string, current_context_->Name}))
+                !refWarned_.contains({copied.string, I.Name}))
             {
                 this->warn(
+                    I,
                     "{}: Failed to copy metadata from '{}' (symbol not found)\n"
                     "    {}",
-                    corpus_.Corpus::qualifiedName(*current_context_),
+                    corpus_.Corpus::qualifiedName(I),
                     copied.string,
                     resRef.error().reason());
             }
@@ -351,19 +351,19 @@ finalizeMetadataCopies(Symbol& I)
             for (auto& srcInfo: srcInfos)
             {
                 auto& mutSrcInfo = const_cast<Symbol&>(srcInfo);
-                finalizeMetadataCopies(mutSrcInfo);
+                copyDetails(mutSrcInfo);
             }
 
             // Copy returns only if destination is empty
-            if (destJavadoc.returns.empty())
+            if (destDoc.returns.empty())
             {
                 for (auto const& srcInfo: srcInfos)
                 {
-                    MRDOCS_CHECK_OR_CONTINUE(srcInfo.javadoc);
-                    for (doc::Returns const& returnsEl: srcInfo.javadoc->returns)
+                    MRDOCS_CHECK_OR_CONTINUE(srcInfo.doc);
+                    for (doc::ReturnsBlock const& returnsEl: srcInfo.doc->returns)
                     {
-                        MRDOCS_CHECK_OR_CONTINUE(!contains(destJavadoc.returns, returnsEl));
-                        destJavadoc.returns.push_back(returnsEl);
+                        MRDOCS_CHECK_OR_CONTINUE(!contains(destDoc.returns, returnsEl));
+                        destDoc.returns.push_back(returnsEl);
                     }
                 }
             }
@@ -378,15 +378,15 @@ finalizeMetadataCopies(Symbol& I)
                 {
                     MRDOCS_CHECK_OR_CONTINUE(srcInfo.isFunction());
                     auto const& srcFunction = srcInfo.asFunction();
-                    MRDOCS_CHECK_OR_CONTINUE(srcFunction.javadoc);
-                    for (Javadoc const& srcJavadoc = *srcFunction.javadoc;
-                         auto const& srcDocParam: srcJavadoc.params)
+                    MRDOCS_CHECK_OR_CONTINUE(srcFunction.doc);
+                    for (DocComment const& srcDocComment = *srcFunction.doc;
+                         auto const& srcDocParam: srcDocComment.params)
                     {
                         // check if param doc doesn't already exist
                         MRDOCS_CHECK_OR_CONTINUE(
                             std::ranges::none_of(
-                                destJavadoc.params,
-                                [&srcDocParam](doc::Param const& destDocParam) {
+                                destDoc.params,
+                                [&srcDocParam](doc::ParamBlock const& destDocParam) {
                             return srcDocParam.name == destDocParam.name;
                         }));
 
@@ -399,7 +399,7 @@ finalizeMetadataCopies(Symbol& I)
                         }));
 
                         // Push the new param ot the
-                        destJavadoc.params.push_back(srcDocParam);
+                        destDoc.params.push_back(srcDocParam);
                     }
                 }
             }
@@ -407,19 +407,34 @@ finalizeMetadataCopies(Symbol& I)
             // Copy only tparams that don't exist at the destination
             // documentation but that do exist in the destination
             // template parameters.
+            auto getTemplateInfo = [](Symbol& I) -> TemplateInfo const*
+            {
+                return visit(I, [](auto& I) -> TemplateInfo const* {
+                    if constexpr (requires { I.Template; })
+                    {
+                        if (I.Template)
+                        {
+                            return &*I.Template;
+                        }
+                    }
+                    return nullptr;
+                });
+            };
+
+
             if (auto const destTemplateInfo = getTemplateInfo(I))
             {
                 for (Symbol const& srcInfo: srcInfos)
                 {
-                    MRDOCS_CHECK_OR_CONTINUE(srcInfo.javadoc);
-                    for (Javadoc const& srcJavadoc = *srcInfo.javadoc;
-                         auto const& srcTParam: srcJavadoc.tparams)
+                    MRDOCS_CHECK_OR_CONTINUE(srcInfo.doc);
+                    for (DocComment const& srcDocComment = *srcInfo.doc;
+                         auto const& srcTParam: srcDocComment.tparams)
                     {
                         // tparam doesn't already exist at the destination
                         MRDOCS_CHECK_OR_CONTINUE(
                             std::ranges::none_of(
-                                destJavadoc.tparams,
-                                [&srcTParam](doc::TParam const& destTParam) {
+                                destDoc.tparams,
+                                [&srcTParam](doc::TParamBlock const& destTParam) {
                             return srcTParam.name == destTParam.name;
                         }));
 
@@ -433,7 +448,7 @@ finalizeMetadataCopies(Symbol& I)
                         }));
 
                         // Push the new param
-                        destJavadoc.tparams.push_back(srcTParam);
+                        destDoc.tparams.push_back(srcTParam);
                     }
                 }
             }
@@ -443,61 +458,61 @@ finalizeMetadataCopies(Symbol& I)
             bool const destIsNoExcept =
                 I.isFunction() &&
                 I.asFunction().Noexcept.Kind == NoexceptKind::False;
-            if (destJavadoc.exceptions.empty() &&
+            if (destDoc.exceptions.empty() &&
                 !destIsNoExcept)
             {
                 for (Symbol const& srcInfo: srcInfos)
                 {
-                    MRDOCS_CHECK_OR_CONTINUE(srcInfo.javadoc);
-                    for (doc::Throws const& exceptionsEl: srcInfo.javadoc->exceptions)
+                    MRDOCS_CHECK_OR_CONTINUE(srcInfo.doc);
+                    for (doc::ThrowsBlock const& exceptionsEl: srcInfo.doc->exceptions)
                     {
-                        MRDOCS_CHECK_OR_CONTINUE(!contains(destJavadoc.exceptions, exceptionsEl));
-                        destJavadoc.exceptions.push_back(exceptionsEl);
+                        MRDOCS_CHECK_OR_CONTINUE(!contains(destDoc.exceptions, exceptionsEl));
+                        destDoc.exceptions.push_back(exceptionsEl);
                     }
                 }
             }
 
             // Copy sees only if destination sees are empty
-            if (destJavadoc.sees.empty())
+            if (destDoc.sees.empty())
             {
                 for (Symbol const& srcInfo: srcInfos)
                 {
-                    MRDOCS_CHECK_OR_CONTINUE(srcInfo.javadoc);
-                    for (doc::See const& seesEl: srcInfo.javadoc->sees)
+                    MRDOCS_CHECK_OR_CONTINUE(srcInfo.doc);
+                    for (doc::SeeBlock const& seesEl: srcInfo.doc->sees)
                     {
-                        MRDOCS_CHECK_OR_CONTINUE(!contains(destJavadoc.sees, seesEl));
-                        destJavadoc.sees.push_back(seesEl);
+                        MRDOCS_CHECK_OR_CONTINUE(!contains(destDoc.sees, seesEl));
+                        destDoc.sees.push_back(seesEl);
                     }
                 }
             }
 
             // Copy preconditions only if destination preconditions is empty
-            if (destJavadoc.preconditions.empty())
+            if (destDoc.preconditions.empty())
             {
                 for (Symbol const& srcInfo: srcInfos)
                 {
-                    MRDOCS_CHECK_OR_CONTINUE(srcInfo.javadoc);
-                    for (doc::Precondition const& preconditionsEl: srcInfo.javadoc->preconditions)
+                    MRDOCS_CHECK_OR_CONTINUE(srcInfo.doc);
+                    for (doc::PreconditionBlock const& preconditionsEl: srcInfo.doc->preconditions)
                     {
-                        MRDOCS_CHECK_OR_CONTINUE(!contains(destJavadoc.preconditions, preconditionsEl));
-                        destJavadoc.preconditions.push_back(preconditionsEl);
+                        MRDOCS_CHECK_OR_CONTINUE(!contains(destDoc.preconditions, preconditionsEl));
+                        destDoc.preconditions.push_back(preconditionsEl);
                     }
                 }
             }
 
             // Copy postconditions only if destination postconditions is empty
-            if (destJavadoc.postconditions.empty())
+            if (destDoc.postconditions.empty())
             {
                 for (Symbol const& srcInfo: srcInfos)
                 {
-                    MRDOCS_CHECK_OR_CONTINUE(srcInfo.javadoc);
-                    for (doc::Postcondition const& postconditionsEl:
-                         srcInfo.javadoc->postconditions)
+                    MRDOCS_CHECK_OR_CONTINUE(srcInfo.doc);
+                    for (doc::PostconditionBlock const& postconditionsEl:
+                         srcInfo.doc->postconditions)
                     {
                         MRDOCS_CHECK_OR_CONTINUE(!contains(
-                            destJavadoc.postconditions,
+                            destDoc.postconditions,
                             postconditionsEl));
-                        destJavadoc.postconditions.push_back(postconditionsEl);
+                        destDoc.postconditions.push_back(postconditionsEl);
                     }
                 }
             }
@@ -507,20 +522,21 @@ finalizeMetadataCopies(Symbol& I)
         Symbol const& res = *resRef;
         if (!res.isOverloads())
         {
-            // If it's a single element, we check the element javadoc
-            if (!res.javadoc)
+            // If it's a single element, we check the element doc
+            if (!res.doc)
             {
                 if (corpus_.config->warnings &&
                     corpus_.config->warnBrokenRef &&
-                    !refWarned_.contains({copied.string, current_context_->Name}))
+                    !refWarned_.contains({copied.string, I.Name}))
                 {
                     auto resPrimaryLoc = getPrimaryLocation(res);
                     this->warn(
+                        I,
                         "{}: Failed to copy metadata from {} '{}' (no documentation available).\n"
                         "    No metadata available.\n"
                         "        {}:{}\n"
                         "        Note: No documentation available for '{}'.",
-                        corpus_.Corpus::qualifiedName(*current_context_),
+                        corpus_.Corpus::qualifiedName(I),
                         toString(res.Kind),
                         copied.string,
                         resPrimaryLoc->FullPath,
@@ -546,89 +562,145 @@ finalizeMetadataCopies(Symbol& I)
             copyInfoRangeMetadata(srcInfos);
         }
     }
+
+    if (I.doc)
+    {
+        copyDetails(I,*I.doc);
+    }
 }
 
 void
-JavadocFinalizer::
-populateFunctionJavadoc(FunctionSymbol& I) const
+DocCommentFinalizer::
+copyDetails(Symbol const& ctx, DocComment& doc)
 {
-    // For special functions (constructors, destructors, ...),
-    // we create the javadoc if it does not exist because
-    // we can populate all the fields from the function category.
-    // For other types of functions, we'll only populate
-    // the missing fields when the javadoc already exists.
-    bool const isSpecial = isSpecialFunction(I);
-    MRDOCS_CHECK_OR(isSpecial || I.javadoc);
-    bool forceEmplaced = false;
-    if (isSpecial &&
-        !I.javadoc)
+    for (auto blockIt = doc.Document.begin(); blockIt != doc.Document.end();)
     {
-        I.javadoc.emplace();
-        forceEmplaced = true;
-    }
+        // Get paragraph
+        auto& block = *blockIt;
+        if (!block->isParagraph())
+        {
+            ++blockIt;
+            continue;
+        }
+        auto& para = block->asParagraph();
+        if (para.empty())
+        {
+            ++blockIt;
+            continue;
+        }
 
-    // Populate a missing javadoc brief
-    populateFunctionBrief(I, corpus_);
+        // Find copydetails command
+        Optional<doc::CopyDetailsInline> copied;
+        for (auto inlineIt = para.children.begin(); inlineIt != para.children.end();)
+        {
+            // Find copydoc command
+            auto& inlineEl = *inlineIt;
+            if (!inlineEl->isCopyDetails())
+            {
+                ++inlineIt;
+                continue;
+            }
+            // Copy reference
+            copied = inlineEl->asCopyDetails();
 
-    // Populate a missing javadoc returns
-    populateFunctionReturns(I, corpus_);
+            // Remove copied node from the inlineEl
+            /* it2 = */ para.children.erase(inlineIt);
+            break;
+        }
 
-    // Populate missing javadoc params
-    populateFunctionParams(I, corpus_);
+        // Trim the paragraph after removing the copydetails command
+        doc::trim(para.asInlineContainer());
 
-    // If we forcefully created the javadoc, we need to
-    // check if the function was able to populate all the
-    // fields. If not, we'll remove the javadoc.
-    if (forceEmplaced)
-    {
-        // Check brief and returns
-        if (!I.javadoc->brief)
+        // Remove empty children from the paragraph
+        std::erase_if(para.children, [](Polymorphic<doc::Inline> const& child) {
+            return doc::isEmpty(child);
+        });
+
+        // We should merge consecutive text nodes that have exactly the
+        // same terminal kind
+
+        // Remove the entire paragraph block from the doc if it is empty
+        if (para.empty())
         {
-            I.javadoc.reset();
-            return;
+            blockIt = doc.Document.erase(blockIt);
+            MRDOCS_CHECK_OR_CONTINUE(copied);
         }
 
-        if (!is_one_of(I.Class, {
-            FunctionClass::Constructor,
-            FunctionClass::Destructor }) &&
-            I.javadoc->returns.empty())
+        // Nothing to copy: continue to the next block
+        if (!copied)
         {
-            I.javadoc.reset();
-            return;
+            ++blockIt;
+            continue;
         }
 
-        // Check params size
-        std::size_t const nNamedParams = std::ranges::
-            count_if(I.Params, [](Param const& p) -> bool {
-            return p.Name.has_value();
-        });
-        auto const documentedParams = getJavadocParamNames(*I.javadoc);
-        if (nNamedParams != documentedParams.size())
+        // Find the node to copy from
+        auto resRef = corpus_.lookup(ctx.id, copied->string);
+        if (!resRef)
         {
-            I.javadoc.reset();
-            return;
+            if (corpus_.config->warnings &&
+                corpus_.config->warnBrokenRef &&
+                !refWarned_.contains({copied->string, ctx.Name}))
+            {
+                this->warn(
+                    ctx,
+                    "{}: Failed to copy documentation from '{}' (symbol not found)\n"
+                    "    {}",
+                    corpus_.Corpus::qualifiedName(ctx),
+                    copied->string,
+                    resRef.error().reason());
+            }
+            continue;
         }
 
-        // Check param names
-        if (!std::ranges::all_of(I.Params, [&](Param const& param) {
-            if (param.Name)
+        // Ensure the source node is finalized
+        Symbol const& res = *resRef;
+        resolveReferences(const_cast<Symbol&>(res));
+
+        // Check if there's any documentation details to copy
+        if (!res.doc)
+        {
+            if (corpus_.config->warnings &&
+                corpus_.config->warnBrokenRef &&
+                !refWarned_.contains({copied->string, ctx.Name}))
             {
-                return contains(documentedParams, *param.Name);
+                auto resPrimaryLoc = getPrimaryLocation(res);
+                this->warn(
+                    ctx,
+                    "{}: Failed to copy documentation from {} '{}' (no documentation available).\n"
+                    "    No documentation available.\n"
+                    "        {}:{}\n"
+                    "        Note: No documentation available for '{}'.",
+                    corpus_.Corpus::qualifiedName(ctx),
+                    toString(res.Kind),
+                    copied->string,
+                    resPrimaryLoc->FullPath,
+                    resPrimaryLoc->LineNumber,
+                    corpus_.Corpus::qualifiedName(res));
             }
-            return true;
-        }))
+            continue;
+        }
+
+        // Copy detail blocks from source to destination to
+        // the same position in the destination
+        DocComment const& src = *res.doc;
+        if (!src.Document.empty())
         {
-            I.javadoc.reset();
+            blockIt = doc.Document.insert(blockIt, src.Document.begin(), src.Document.end());
+            blockIt += src.Document.size();
         }
     }
 }
 
 void
-JavadocFinalizer::
-populateOverloadJavadoc(OverloadsSymbol& I)
+DocCommentFinalizer::generateOverloadDocs(OverloadsSymbol& I)
 {
+    if (!I.doc)
+    {
+        I.doc.emplace();
+    }
+
     // Create a view all Info members of I.
-    // The javadoc for these function should already be as
+    // The doc for these function should already be as
     // complete as possible
     auto functions =
         I.Members |
@@ -644,13 +716,13 @@ populateOverloadJavadoc(OverloadsSymbol& I)
             {
                 return infoPtr->asFunction();
             });
-    if (!I.javadoc)
+    if (!I.doc)
     {
-        I.javadoc.emplace();
+        I.doc.emplace();
     }
 
     // briefs: populated in a previous step
-    // blocks: we do not copy javadoc detail blocks because
+    // blocks: we do not copy doc detail blocks because
     // it's impossible to guarantee that the details for
     // any of the functions make sense for all overloads.
     // We can only merge metadata.
@@ -664,139 +736,36 @@ populateOverloadJavadoc(OverloadsSymbol& I)
 }
 
 void
-JavadocFinalizer::
-finalizeJavadoc(Symbol& I)
+DocCommentFinalizer::resolveReferences(Symbol& I)
 {
     MRDOCS_CHECK_OR(!finalized_.contains(&I));
     finalized_.emplace(&I);
-    ScopeExitRestore s(current_context_, &I);
 
     report::trace(
-        "Finalizing javadoc for '{}'",
+        "Finalizing doc for '{}'",
         corpus_.Corpus::qualifiedName(I));
 
-    if (I.javadoc)
-    {
-        finalize(*I.javadoc);
-    }
-}
-
-template <class InfoTy>
-void
-JavadocFinalizer::
-finalizeInfoData(InfoTy& I)
-{
-#ifndef NDEBUG
-    // Check references
-    if (I.Parent)
-    {
-        checkExists(I.Parent);
-    }
-    if constexpr (SymbolParent<InfoTy>)
-    {
-        checkExists(allMembers(I));
-    }
-#endif
-
-    if constexpr (requires { I.UsingDirectives; })
-    {
-        finalize(I.UsingDirectives);
-    }
-    if constexpr (requires { I.Template; })
-    {
-        finalize(I.Template);
-    }
-    if constexpr (requires { I.Bases; })
-    {
-        finalize(I.Bases);
-    }
-    if constexpr (requires { I.Primary; })
-    {
-        finalize(I.Primary);
-    }
-    if constexpr (requires { I.Args; })
-    {
-        finalize(I.Args);
-    }
-    if constexpr (requires { I.ReturnType; })
-    {
-        MRDOCS_ASSERT(!I.ReturnType.valueless_after_move());
-        finalize(*I.ReturnType);
-    }
-    if constexpr (requires { I.Params; })
-    {
-        finalize(I.Params);
-    }
-    if constexpr (requires { I.Type; })
-    {
-        if constexpr (detail::isOptionalV<decltype(I.Type)>)
-        {
-            if (I.Type)
-            {
-                finalize(**I.Type);
-            }
-        }
-        else if constexpr (detail::IsPolymorphic<decltype(I.Type)>)
-        {
-            if (!I.Type.valueless_after_move())
-            {
-                finalize(*I.Type);
-            }
-        }
-        else if (I.Type)
-        {
-            finalize(*I.Type);
-        }
-    }
-    if constexpr (requires { I.UnderlyingType; })
-    {
-        if (I.UnderlyingType)
-        {
-            finalize(**I.UnderlyingType);
-        }
-    }
-    if constexpr (requires { I.FriendSymbol; })
-    {
-        finalize(I.FriendSymbol);
-    }
-    if constexpr (requires { I.FriendType; })
-    {
-        finalize(I.FriendType);
-    }
-    if constexpr (requires { I.AliasedSymbol; })
-    {
-        finalize(I.AliasedSymbol);
-    }
-    if constexpr (requires { I.IntroducedName; })
-    {
-        if (!I.IntroducedName.valueless_after_move())
-        {
-            finalize(*I.IntroducedName);
-        }
-    }
-    if constexpr (requires { I.ShadowDeclarations; })
-    {
-        finalize(I.ShadowDeclarations);
-    }
-    if constexpr (requires { I.Deduced; })
+    if (I.doc)
     {
-        finalize(*I.Deduced);
+        auto& doc = *I.doc;
+        bottomUpTraverse(doc, makeOverload(
+          [this, &I](doc::ReferenceInline& node) { this->resolveReference(I, node, true); },
+          [this, &I](doc::ThrowsBlock& node) { this->resolveReference(I, node.exception, false); }));
     }
 }
 
-#define INFO(T) template void JavadocFinalizer::finalizeInfoData<T##Symbol>(T## Symbol&);
-#include <mrdocs/Metadata/Symbol/SymbolNodes.inc>
-
 void
-JavadocFinalizer::
-finalize(doc::Reference& ref, bool const emitWarning)
+DocCommentFinalizer::resolveReference(
+    Symbol const& ctx,
+    doc::ReferenceInline& ref,
+    bool const emitWarning)
 {
     if (ref.id != SymbolID::invalid)
     {
         // Already resolved
         return;
     }
-    if (auto resRef = corpus_.lookup(current_context_->id, ref.string))
+    if (auto resRef = corpus_.lookup(ctx.id, ref.literal))
     {
         // KRYSTIAN NOTE: We should provide an overload that
         // returns a non-const reference.
@@ -808,442 +777,211 @@ finalize(doc::Reference& ref, bool const emitWarning)
         corpus_.config->warnings &&
         corpus_.config->warnBrokenRef &&
         // Only warn once per reference
-        !refWarned_.contains({ref.string, current_context_->Name}) &&
+        !refWarned_.contains({ref.literal, ctx.Name}) &&
         // Ignore std:: references
-        !ref.string.starts_with("std::") &&
-        // Ignore other reference types that can't be replaced by `...`
-        ref.Kind == doc::NodeKind::reference)
+        !ref.literal.starts_with("std::"))
     {
-        MRDOCS_ASSERT(current_context_);
         this->warn(
+            ctx,
             "{}: Failed to resolve reference to '{}'\n"
             "    {}",
-            corpus_.Corpus::qualifiedName(*current_context_),
-            ref.string,
+            corpus_.Corpus::qualifiedName(ctx),
+            ref.literal,
             resRef.error().reason());
-        refWarned_.insert({ref.string, current_context_->Name});
+        refWarned_.insert({ref.literal, ctx.Name});
     }
 }
 
 void
-JavadocFinalizer::
-finalize(doc::Node& node)
+DocCommentFinalizer::
+generateAutoFunctionMetadata(FunctionSymbol& I) const
 {
-    visit(node, [&]<typename NodeTy>(NodeTy& N)
+    // For special functions (constructors, destructors, ...),
+    // we create the doc if it does not exist because
+    // we can populate all the fields from the function category.
+    // For other types of functions, we'll only populate
+    // the missing fields when the doc already exists.
+    bool const isSpecial = isSpecialFunction(I);
+    MRDOCS_CHECK_OR(isSpecial || I.doc);
+    bool forceEmplaced = false;
+    if (isSpecial &&
+        !I.doc)
+    {
+        I.doc.emplace();
+        forceEmplaced = true;
+    }
+
+    // Populate a missing doc brief
+    populateFunctionBrief(I, corpus_);
+
+    // Populate a missing doc returns
+    populateFunctionReturns(I, corpus_);
+
+    // Populate missing doc params
+    populateFunctionParams(I, corpus_);
+
+    // If we forcefully created the doc, we need to
+    // check if the function was able to populate all the
+    // fields. If not, we'll remove the doc.
+    if (forceEmplaced)
     {
-        if constexpr (requires { N.children; })
+        // Check brief and returns
+        if (!I.doc->brief)
         {
-            finalize(N.children);
+            I.doc.reset();
+            return;
         }
 
-        if constexpr(std::same_as<NodeTy, doc::Reference>)
+        if (!is_one_of(I.Class, {
+            FunctionClass::Constructor,
+            FunctionClass::Destructor }) &&
+            I.doc->returns.empty())
         {
-            finalize(dynamic_cast<doc::Reference&>(N), true);
+            I.doc.reset();
+            return;
         }
-        else if constexpr (std::same_as<NodeTy, doc::Throws>)
+
+        // Check params size
+        std::size_t const nNamedParams = std::ranges::
+            count_if(I.Params, [](Param const& p) -> bool {
+            return p.Name.has_value();
+        });
+        auto const documentedParams = getDocCommentParamNames(*I.doc);
+        if (nNamedParams != documentedParams.size())
         {
-            finalize(dynamic_cast<doc::Throws&>(N).exception, false);
+            I.doc.reset();
+            return;
         }
-    });
-}
 
-void
-JavadocFinalizer::
-finalize(Javadoc& javadoc)
-{
-    finalize(javadoc.blocks);
-    finalize(javadoc.brief);
-    finalize(javadoc.returns);
-    finalize(javadoc.params);
-    finalize(javadoc.tparams);
-    finalize(javadoc.exceptions);
-    finalize(javadoc.sees);
-    finalize(javadoc.preconditions);
-    finalize(javadoc.postconditions);
-    processRelates(javadoc);
-    copyDetails(javadoc);
-    removeTempTextNodes(javadoc);
-    trimBlocks(javadoc);
-    unindentCodeBlocks(javadoc);
+        // Check param names
+        if (!std::ranges::all_of(I.Params, [&](Param const& param) {
+            if (param.Name)
+            {
+                return contains(documentedParams, *param.Name);
+            }
+            return true;
+        }))
+        {
+            I.doc.reset();
+        }
+    }
 }
 
 namespace {
+// Comparison function for reference to keep the related
+// references sorted by name.
 bool
 referenceCmp(
-    doc::Reference const& lhs,
-    doc::Reference const& rhs) {
-    bool const lhsIsGlobal = lhs.string.starts_with("::");
-    bool const rhsIsGlobal = rhs.string.starts_with("::");
+    doc::ReferenceInline const& lhs,
+    doc::ReferenceInline const& rhs) {
+    bool const lhsIsGlobal = lhs.literal.starts_with("::");
+    bool const rhsIsGlobal = rhs.literal.starts_with("::");
     if (lhsIsGlobal != rhsIsGlobal)
     {
         return lhsIsGlobal < rhsIsGlobal;
     }
-    std::size_t const lhsCount = std::ranges::count(lhs.string, ':');
-    std::size_t const rhsCount = std::ranges::count(rhs.string, ':');
+    std::size_t const lhsCount = std::ranges::count(lhs.literal, ':');
+    std::size_t const rhsCount = std::ranges::count(rhs.literal, ':');
     if (lhsCount != rhsCount)
     {
         return lhsCount < rhsCount;
     }
-    if (lhs.string != rhs.string)
+    if (lhs.literal != rhs.literal)
     {
-        return lhs.string < rhs.string;
+        return lhs.literal < rhs.literal;
     }
     return lhs.id < rhs.id;
 }
 }
 
 void
-JavadocFinalizer::
-processRelates(Javadoc& javadoc)
+DocCommentFinalizer::
+processRelates(Symbol& ctx, DocComment& doc)
 {
     if (corpus_.config->autoRelates)
     {
-        setAutoRelates();
+        setAutoRelates(ctx);
     }
 
-    MRDOCS_CHECK_OR(!javadoc.relates.empty());
+    MRDOCS_CHECK_OR(!doc.relates.empty());
 
-    Symbol const* currentPtr = corpus_.find(current_context_->id);
+    Symbol const* currentPtr = corpus_.find(ctx.id);
     MRDOCS_ASSERT(currentPtr);
     Symbol const& current = *currentPtr;
 
     if (!current.isFunction())
     {
         this->warn(
+            ctx,
             "{}: `@relates` only allowed for functions",
             corpus_.Corpus::qualifiedName(current));
-        javadoc.relates.clear();
+        doc.relates.clear();
         return;
     }
 
-    for (doc::Reference& ref: javadoc.relates)
+    for (doc::ReferenceInline& ref: doc.relates)
     {
-        finalize(ref, true);
+        resolveReference(ctx, ref, true);
         Symbol* relatedPtr = corpus_.find(ref.id);
         MRDOCS_CHECK_OR_CONTINUE(relatedPtr);
         Symbol& related = *relatedPtr;
-        if (!related.javadoc)
+        if (!related.doc)
         {
-            related.javadoc.emplace();
+            related.doc.emplace();
         }
         if (std::ranges::none_of(
-                related.javadoc->related,
-                [this](doc::Reference const& otherRef) {
-            return otherRef.id == current_context_->id;
-        }))
+            related.doc->related,
+               [&ctx](doc::ReferenceInline const& otherRef) {
+                    return otherRef.id == ctx.id;
+                }))
         {
             std::string currentName = corpus_.Corpus::qualifiedName(current, relatedPtr->Parent);
-            doc::Reference relatedRef(std::move(currentName));
-            relatedRef.id = current_context_->id;
+            doc::ReferenceInline relatedRef(std::move(currentName));
+            relatedRef.id = ctx.id;
             // Insert in order by name
             auto const it = std::ranges::lower_bound(
-                related.javadoc->related,
+                related.doc->related,
                 relatedRef,
                 referenceCmp);
-            related.javadoc->related.insert(it, std::move(relatedRef));
+            related.doc->related.insert(it, std::move(relatedRef));
         }
     }
 
-    // Erase anything in the javadoc without a valid id
-    std::erase_if(javadoc.relates, [](doc::Reference const& ref) {
+    // Erase anything in the doc without a valid id
+    std::erase_if(doc.relates, [](doc::ReferenceInline const& ref) {
         return !ref.id;
     });
 }
 
+namespace {
 void
-JavadocFinalizer::
-removeTempTextNodes(Javadoc& javadoc)
+pushAllDerivedClasses(
+    RecordSymbol const* record,
+    llvm::SmallVector<Symbol*, 16>& relatedRecordsOrEnums,
+    CorpusImpl& corpus)
 {
-    removeTempTextNodes(javadoc.blocks);
-    if (javadoc.brief)
+    for (auto& derivedId : record->Derived)
     {
-        removeTempTextNodes(*javadoc.brief);
+        Symbol* derivedPtr = corpus.find(derivedId);
+        MRDOCS_CHECK_OR_CONTINUE(derivedPtr);
+        MRDOCS_CHECK_OR_CONTINUE(derivedPtr->Extraction == ExtractionMode::Regular);
+        auto derived = dynamic_cast<RecordSymbol*>(derivedPtr);
+        MRDOCS_CHECK_OR_CONTINUE(derived);
+        relatedRecordsOrEnums.push_back(derived);
+        // Recursively get derived classes of the derived class
+        pushAllDerivedClasses(derived, relatedRecordsOrEnums, corpus);
     }
-    removeTempTextNodes(javadoc.returns);
-    removeTempTextNodes(javadoc.params);
-    removeTempTextNodes(javadoc.tparams);
-    removeTempTextNodes(javadoc.exceptions);
-    removeTempTextNodes(javadoc.sees);
-    removeTempTextNodes(javadoc.preconditions);
-    removeTempTextNodes(javadoc.postconditions);
+}
 }
 
 void
-JavadocFinalizer::
-removeTempTextNodes(std::vector<Polymorphic<doc::Block>>& blocks)
+DocCommentFinalizer::
+setAutoRelates(Symbol& ctx)
 {
-    for (auto& block: blocks)
-    {
-        removeTempTextNodes(*block);
-    }
-    // Erase all blocks of zero elements
-    std::erase_if(blocks, [](Polymorphic<doc::Block> const& block) {
-        if (block->Kind == doc::NodeKind::unordered_list)
-        {
-            return static_cast<doc::UnorderedList const &>(*block).items.empty();
-        }
-        if (block->Kind == doc::NodeKind::heading)
-        {
-            return static_cast<doc::Heading const &>(*block).string.empty();
-        }
-        return block->children.empty();
-    });
-}
-
-void
-JavadocFinalizer::
-removeTempTextNodes(doc::Block& block)
-{
-    std::erase_if(block.children, [](Polymorphic<doc::Text> const& child) {
-        return is_one_of(
-            child->Kind,
-            { doc::NodeKind::copy_details });
-    });
-}
-
-void
-JavadocFinalizer::
-trimBlocks(Javadoc& javadoc)
-{
-    trimBlocks(javadoc.blocks);
-    if (javadoc.brief)
-    {
-        trimBlock(*javadoc.brief);
-    }
-    trimBlocks(javadoc.returns);
-    trimBlocks(javadoc.params);
-    trimBlocks(javadoc.tparams);
-    trimBlocks(javadoc.exceptions);
-    trimBlocks(javadoc.sees);
-    trimBlocks(javadoc.preconditions);
-    trimBlocks(javadoc.postconditions);
-}
-
-void
-JavadocFinalizer::
-trimBlocks(std::vector<Polymorphic<doc::Block>>& blocks)
-{
-    for (auto& block: blocks)
-    {
-        bool const isVerbatim = block->Kind == doc::NodeKind::code;
-        MRDOCS_CHECK_OR_CONTINUE(!isVerbatim);
-        trimBlock(*block);
-    }
-}
-
-void
-JavadocFinalizer::
-trimBlock(doc::Block& block)
-{
-    if (block.Kind == doc::NodeKind::unordered_list)
-    {
-        auto& ul = dynamic_cast<doc::UnorderedList&>(block);
-        trimBlocks(ul.items);
-        return;
-    }
-
-    MRDOCS_CHECK_OR(!block.children.empty());
-
-    // Helper functions
-    static constexpr std::string_view whitespace_chars = " \t\n\v\f\r";
-    auto endsWithSpace = [](std::string_view const str) {
-        return endsWithOneOf(str, whitespace_chars);
-    };
-    auto startsWithSpace = [](std::string_view const str) {
-        return startsWithOneOf(str, whitespace_chars);
-    };
-
-    // The first children are ltrimmed as one
-    while (!block.children.empty())
-    {
-        auto& first = block.children.front()->string;
-        if (startsWithSpace(first))
-        {
-            first = ltrim(first);
-        }
-        if (first.empty())
-        {
-            // "pop_front"
-            block.children.erase(block.children.begin());
-        }
-        else
-        {
-            break;
-        }
-    }
-
-    // The last children are rtrimmed as one
-    while (!block.children.empty())
-    {
-        auto& last = block.children.back()->string;
-        if (endsWithSpace(last))
-        {
-            last = rtrim(last);
-        }
-        if (last.empty())
-        {
-            block.children.pop_back();
-        }
-        else
-        {
-            break;
-        }
-    }
-
-    // Like in HTML, multiple whitespaces (spaces, tabs, and newlines)
-    // between and within child nodes are collapsed into a single space.
-    if (!block.children.empty())
-    {
-        for (
-            auto it = block.children.begin() + 1;
-            it != block.children.end();
-            ++it)
-        {
-            auto& child = *it;
-            auto& prev = *std::prev(it);
-            if (endsWithSpace(prev->string) && startsWithSpace(child->string))
-            {
-                // The first visible space character is maintained.
-                // All others are removed.
-                prev->string = rtrim(prev->string);
-                prev->string.push_back(' ');
-                child->string = ltrim(child->string);
-            }
-        }
-    }
-
-    // Like in HTML, multiple whitespaces (spaces, tabs, and newlines)
-    // within child nodes are collapsed into a single space.
-    for (auto& child: block.children)
-    {
-        auto& str = child->string;
-        for (std::size_t i = 0; i < str.size();)
-        {
-            if (contains(whitespace_chars, str[i]))
-            {
-                std::size_t const runStart = i;
-                std::size_t runEnd = i + 1;
-                while (
-                    runEnd < str.size() &&
-                    contains(whitespace_chars, str[runEnd]))
-                {
-                    ++runEnd;
-                }
-                if (runEnd > runStart + 1)
-                {
-                    std::size_t const runSize = runEnd - runStart;
-                    str.erase(runStart + 1, runSize - 1);
-                    str[runStart] = ' ';
-                }
-                i = runEnd;
-            }
-            else
-            {
-                ++i;
-            }
-        }
-    }
-}
-
-void
-JavadocFinalizer::
-unindentCodeBlocks(Javadoc& javadoc)
-{
-    unindentCodeBlocks(javadoc.blocks);
-    if (javadoc.brief)
-    {
-        unindentCodeBlocks(*javadoc.brief);
-    }
-    unindentCodeBlocks(javadoc.returns);
-    unindentCodeBlocks(javadoc.params);
-    unindentCodeBlocks(javadoc.tparams);
-    unindentCodeBlocks(javadoc.exceptions);
-    unindentCodeBlocks(javadoc.sees);
-    unindentCodeBlocks(javadoc.preconditions);
-    unindentCodeBlocks(javadoc.postconditions);
-}
-
-void
-JavadocFinalizer::
-unindentCodeBlocks(std::vector<Polymorphic<doc::Block>>& blocks)
-{
-    for (auto& block: blocks)
-    {
-        if (block->Kind == doc::NodeKind::code)
-        {
-            unindentCodeBlocks(*block);
-        }
-    }
-}
-
-void
-JavadocFinalizer::
-unindentCodeBlocks(doc::Block& block)
-{
-    MRDOCS_CHECK_OR(block.Kind == doc::NodeKind::code);
-    MRDOCS_CHECK_OR(!block.children.empty());
-
-    // Determine the left margin
-    std::size_t leftMargin = std::numeric_limits<std::size_t>::max();
-    for (auto& pText: block.children)
-    {
-        auto& text = dynamic_cast<doc::Text&>(*pText);
-        if (text.string.empty())
-        {
-            continue;
-        }
-        std::size_t const margin = text.string.find_first_not_of(" \t");
-        if (margin == std::string::npos)
-        {
-            continue;
-        }
-        leftMargin = std::min(leftMargin, margin);
-    }
-
-    MRDOCS_CHECK_OR(leftMargin != std::numeric_limits<std::size_t>::max());
-
-    // Remove the left margin
-    for (auto& pText: block.children)
-    {
-        auto& text = dynamic_cast<doc::Text&>(*pText);
-        if (text.string.size() < leftMargin)
-        {
-            continue;
-        }
-        text.string = text.string.substr(leftMargin);
-    }
-}
-
-namespace {
-void
-pushAllDerivedClasses(
-    RecordSymbol const* record,
-    llvm::SmallVector<Symbol*, 16>& relatedRecordsOrEnums,
-    CorpusImpl& corpus)
-{
-    for (auto& derivedId : record->Derived)
-    {
-        Symbol* derivedPtr = corpus.find(derivedId);
-        MRDOCS_CHECK_OR_CONTINUE(derivedPtr);
-        MRDOCS_CHECK_OR_CONTINUE(derivedPtr->Extraction == ExtractionMode::Regular);
-        auto derived = dynamic_cast<RecordSymbol*>(derivedPtr);
-        MRDOCS_CHECK_OR_CONTINUE(derived);
-        relatedRecordsOrEnums.push_back(derived);
-        // Recursively get derived classes of the derived class
-        pushAllDerivedClasses(derived, relatedRecordsOrEnums, corpus);
-    }
-}
-}
-
-void
-JavadocFinalizer::
-setAutoRelates()
-{
-    MRDOCS_ASSERT(current_context_);
-    MRDOCS_CHECK_OR(current_context_->Extraction == ExtractionMode::Regular);
-    MRDOCS_CHECK_OR(current_context_->isFunction());
-    MRDOCS_CHECK_OR(current_context_->javadoc);
-    auto& I = dynamic_cast<FunctionSymbol&>(*current_context_);
+    MRDOCS_CHECK_OR(ctx.Extraction == ExtractionMode::Regular);
+    MRDOCS_CHECK_OR(ctx.isFunction());
+    MRDOCS_CHECK_OR(ctx.doc);
+    auto& I = ctx.asFunction();
     MRDOCS_CHECK_OR(!I.IsRecordMethod);
     auto* parentPtr = corpus_.find(I.Parent);
     MRDOCS_CHECK_OR(parentPtr);
@@ -1286,7 +1024,7 @@ setAutoRelates()
             I.Params.front().Type->isRValueReference() ||
             I.Params.front().Type->isPointer());
         // Get all transitively derived classes of firstParamRecord
-       pushAllDerivedClasses(firstParamRecord, relatedRecordsOrEnums, corpus_);
+        pushAllDerivedClasses(firstParamRecord, relatedRecordsOrEnums, corpus_);
     }();
 
     // 3) The return type of the function
@@ -1326,15 +1064,15 @@ setAutoRelates()
         std::ranges::unique(relatedRecordsOrEnums).begin(),
         relatedRecordsOrEnums.end());
 
-    // Insert the records with valid ids into the javadoc relates section
-    std::size_t const prevRelatesSize = I.javadoc->relates.size();
+    // Insert the records with valid ids into the doc relates section
+    std::size_t const prevRelatesSize = I.doc->relates.size();
     for (Symbol const* relatedRecordOrEnumPtr : relatedRecordsOrEnums)
     {
         MRDOCS_CHECK_OR_CONTINUE(relatedRecordOrEnumPtr);
-        MRDOCS_ASSERT(I.javadoc);
+        MRDOCS_ASSERT(I.doc);
         Symbol const& recordOrEnum = *relatedRecordOrEnumPtr;
         MRDOCS_CHECK_OR_CONTINUE(recordOrEnum.Extraction == ExtractionMode::Regular);
-        doc::Reference ref(recordOrEnum.Name);
+        doc::ReferenceInline ref(recordOrEnum.Name);
         ref.id = recordOrEnum.id;
 
         // Check if already listed as friend
@@ -1350,331 +1088,452 @@ setAutoRelates()
 
         // Ensure no duplicates
         if (std::ranges::none_of(
-                I.javadoc->relates,
-                [&ref](doc::Reference const& otherRef) {
-            return otherRef.string == ref.string || otherRef.id == ref.id;
+                I.doc->relates,
+                [&ref](doc::ReferenceInline const& otherRef) {
+            return otherRef.literal == ref.literal || otherRef.id == ref.id;
         }))
         {
             // Insert in order by name
             auto const it = std::ranges::lower_bound(
-                I.javadoc->relates.begin() + prevRelatesSize,
-                I.javadoc->relates.end(),
+                I.doc->relates.begin() + prevRelatesSize,
+                I.doc->relates.end(),
                 ref,
                 referenceCmp);
-            I.javadoc->relates.insert(it, std::move(ref));
+            I.doc->relates.insert(it, std::move(ref));
         }
     }
 }
 
 void
-JavadocFinalizer::
-copyDetails(Javadoc& javadoc)
+DocCommentFinalizer::
+tidyUp(DocComment& doc)
 {
-    for (auto blockIt = javadoc.blocks.begin(); blockIt != javadoc.blocks.end();)
-    {
-        // Get paragraph
-        auto& block = *blockIt;
-        if (block->Kind != doc::NodeKind::paragraph &&
-            block->Kind != doc::NodeKind::details)
-        {
-            ++blockIt;
-            continue;
-        }
-        auto& para = dynamic_cast<doc::Paragraph&>(*block);
-        if (para.children.empty())
+    // Bottom-up traversal cleaning up the doc
+    bottomUpTraverse(doc, []<class NodeTy>(NodeTy& node) {
+        // Remove any @copy* nodes that got left behind
+        if constexpr (requires { { node.children } -> range_of<Polymorphic<doc::Inline>>; })
         {
-            ++blockIt;
-            continue;
-        }
-
-        // Find copydetails command
-        Optional<doc::CopyDetails> copied;
-        for (auto textIt = para.children.begin(); textIt != para.children.end();)
-        {
-            // Find copydoc command
-            auto& text = *textIt;
-            if (text->Kind != doc::NodeKind::copy_details)
+            std::erase_if(node.children, [](Polymorphic<doc::Inline> const& el)
             {
-                ++textIt;
-                continue;
-            }
-            // Copy reference
-            copied = dynamic_cast<doc::CopyDetails&>(*text);
-
-            // Remove copied node from the text
-            /* it2 = */ para.children.erase(textIt);
-            break;
+                return el->isCopyDetails();
+            });
         }
 
-        // Remove leading children from the paragraph that are
-        // either empty or only white spaces. We also ltrim
-        // the first child with content.
-        while (!para.children.empty())
+        // - Trim leading and trailing empty inlines in the node
+        // - Merging consecutive empty blocks (like HTML whitespace normalization)
+        //   To be implemented and improved as needed
+        if constexpr (std::derived_from<NodeTy, doc::Block>)
         {
-            if (para.children.front()->string.find_first_not_of(" \t\n\v\f\r") == std::string::npos)
-            {
-                para.children.erase(para.children.begin());
-            }
-            else
-            {
-                para.children.front()->string = ltrim(para.children.front()->string);
-                break;
-            }
+            doc::trim(node.asBlock());
         }
 
-        // Remove trailing children from the paragraph that are
-        // either empty or only white spaces. We also rtrim
-        // the last child with content.
-        while (!para.children.empty())
+        // Remove consecutive whitespace characters in text nodes
+        if constexpr (std::same_as<NodeTy, doc::TextInline>)
         {
-            if (para.children.back()->string.find_first_not_of(" \t\n\v\f\r") == std::string::npos)
-            {
-                para.children.pop_back();
-            }
-            else
+            auto& textNode = static_cast<doc::TextInline&>(node);
+            std::string_view sv = textNode.literal;
+
+            // Early out if there is NO consecutive whitespace.
+            auto it = std::ranges::adjacent_find(sv, [](char a, char b) {
+                return isWhitespace(a) && isWhitespace(b);
+            });
+            if (it == sv.end())
             {
-                para.children.back()->string = rtrim(para.children.back()->string);
-                break;
+                return;
             }
-        }
 
-        // Remove empty completely empty children from the paragraph
-        std::erase_if(para.children, [](Polymorphic<doc::Text> const& child) {
-            return child->string.empty();
-        });
+            std::string out;
+            out.reserve(sv.size());
 
-        // Merge consecutive text nodes that have exactly the same terminal kind
-        for (auto textIt = para.children.begin(); textIt != para.children.end();)
-        {
-            auto& text = *textIt;
-            if (textIt != para.children.begin())
+            bool lastWasSpace = false; // whether we last EMITTED a space
+            for (char c: sv)
             {
-                if (auto& prev = *std::prev(textIt);
-                    prev->Kind == text->Kind)
+                if (isWhitespace(c))
                 {
-                    prev->string += text->string;
-                    textIt = para.children.erase(textIt);
-                    continue;
+                    if (!lastWasSpace)
+                    {
+                        out.push_back(' ');
+                        lastWasSpace = true;
+                    }
+                }
+                else
+                {
+                    out.push_back(c);
+                    lastWasSpace = false;
                 }
             }
-            ++textIt;
-        }
 
-        // Remove the entire paragraph block from the javadoc if it is empty
-        if (para.empty())
-        {
-            blockIt = javadoc.blocks.erase(blockIt);
-            MRDOCS_CHECK_OR_CONTINUE(copied);
+            textNode.literal = std::move(out);
         }
 
-        // Nothing to copy: continue to the next block
-        if (!copied)
+        // - Remove any child blocks or inlines without content
+        //   (especially after we do the trimming bottom up)
+        if constexpr (requires { { node.children } -> range_of<Polymorphic<doc::Inline>>; })
         {
-            ++blockIt;
-            continue;
+            std::erase_if(node.children, [](Polymorphic<doc::Inline> const& el)
+            {
+                return isEmpty(el);
+            });
         }
-
-        // Find the node to copy from
-        auto resRef = corpus_.lookup(current_context_->id, copied->string);
-        if (!resRef)
+        if constexpr (requires { { node.blocks } -> range_of<Polymorphic<doc::Block>>; })
         {
-            if (corpus_.config->warnings &&
-                corpus_.config->warnBrokenRef &&
-                !refWarned_.contains({copied->string, current_context_->Name}))
+            std::erase_if(node.blocks, [](Polymorphic<doc::Block> const& el)
             {
-                this->warn(
-                    "{}: Failed to copy documentation from '{}' (symbol not found)\n"
-                    "    {}",
-                    corpus_.Corpus::qualifiedName(*current_context_),
-                    copied->string,
-                    resRef.error().reason());
-            }
-            continue;
+                return isEmpty(el);
+            });
         }
-
-        // Ensure the source node is finalized
-        Symbol const& res = *resRef;
-        finalizeJavadoc(const_cast<Symbol&>(res));
-
-        // Check if there's any documentation details to copy
-        if (!res.javadoc)
+        if constexpr (requires { { node.Document } -> range_of<Polymorphic<doc::Block>>; })
         {
-            if (corpus_.config->warnings &&
-                corpus_.config->warnBrokenRef &&
-                !refWarned_.contains({copied->string, current_context_->Name}))
+            std::erase_if(node.Document, [](Polymorphic<doc::Block> const& el)
             {
-                auto resPrimaryLoc = getPrimaryLocation(res);
-                this->warn(
-                    "{}: Failed to copy documentation from {} '{}' (no documentation available).\n"
-                    "    No documentation available.\n"
-                    "        {}:{}\n"
-                    "        Note: No documentation available for '{}'.",
-                    corpus_.Corpus::qualifiedName(*current_context_),
-                    toString(res.Kind),
-                    copied->string,
-                    resPrimaryLoc->FullPath,
-                    resPrimaryLoc->LineNumber,
-                    corpus_.Corpus::qualifiedName(res));
-            }
-            continue;
+                return isEmpty(el);
+            });
         }
 
-        // Copy detail blocks from source to destination to
-        // the same position in the destination
-        Javadoc const& src = *res.javadoc;
-        if (!src.blocks.empty())
+        // - Unindenting code blocks (but not Code inlines)
+        if constexpr (std::same_as<NodeTy, doc::CodeBlock>)
         {
-            blockIt = javadoc.blocks.insert(blockIt, src.blocks.begin(), src.blocks.end());
-            blockIt += src.blocks.size();
+            auto& codeBlock = static_cast<doc::CodeBlock&>(node);
+            codeBlock.literal = reindentCode(codeBlock.literal, 0);
         }
+    });
+
+    // Remove elements of main DocComment that happen to be empty after trimming
+    // Lambda that takes a vector of T and removes elements for which isEmpty returns true
+    auto removeEmpty = [](auto& vec) {
+        std::erase_if(vec, [](auto const& el) {
+            return isEmpty(el);
+        });
+    };
+    removeEmpty(doc.Document);
+    removeEmpty(doc.returns);
+    removeEmpty(doc.params);
+    removeEmpty(doc.tparams);
+    removeEmpty(doc.exceptions);
+    removeEmpty(doc.sees);
+    removeEmpty(doc.preconditions);
+    removeEmpty(doc.postconditions);
+    // removeEmpty(doc.relates);
+    // removeEmpty(doc.related);
+    if (doc.brief && isEmpty(*doc.brief))
+    {
+        doc.brief.reset();
     }
 }
 
 void
-JavadocFinalizer::
-finalize(SymbolID& id)
+DocCommentFinalizer::
+normalizeSiblings(DocComment& doc)
 {
-    if (id && !corpus_.info_.contains(id))
-    {
-        id = SymbolID::invalid;
-    }
+    // Bottom-up traversal cleaning up the doc
+    bottomUpTraverse(doc, [](doc::InlineContainer& node) {
+        // Only containers with inline children can participate in merging
+        // (1) Optional: flatten trivial same-type single-child wrappers
+        //     e.g. <mono><mono>...</mono></mono> → <mono>...</mono>
+        // We do this locally for each child to prevent unnecessary barriers
+        // to sibling merge.
+        for (auto& ch: node.children)
+        {
+            visit(*ch, []<class InlineTy>(InlineTy& inl) {
+                auto* outer = dynamic_cast<doc::InlineContainer*>(&inl);
+                MRDOCS_CHECK_OR(outer);
+                MRDOCS_CHECK_OR(outer->children.size() == 1);
+                auto& only = outer->children.front();
+                MRDOCS_CHECK_OR(only->Kind == inl.Kind);
+                auto* only_inner = dynamic_cast<doc::InlineContainer*>(&*only);
+                MRDOCS_CHECK_OR(only_inner);
+                // Move grandchildren up into outer
+                outer->children.insert(
+                    outer->children.end(),
+                    std::make_move_iterator(only_inner->children.begin()),
+                    std::make_move_iterator(only_inner->children.end()));
+                only_inner->children.clear();
+                // make `only` a moved-from node to be removed later
+                // (we can't just reset/move it out because we're in a
+                // reference to it in the vector)
+                auto tmp = std::move(only);
+            });
+        }
+        // Filter out any nulls created by the flatten step
+        std::erase_if(node.children, [](Polymorphic<doc::Inline> const& el) {
+            return el.valueless_after_move();
+        });
+
+        // (2) Single left→right pass that coalesces adjacent siblings
+        //     - Text + Text: concatenate
+        //     - Same-kind wrappers: move-append children
+        //       (attributes must match if you model them; keep the check
+        //       next to Kind)
+        std::vector<Polymorphic<doc::Inline>> out;
+        out.reserve(node.children.size());
+        auto can_merge_same_kind =
+            [](doc::Inline const& a, doc::Inline const& b) {
+            // Filter out kinds that don't make sense to merge,
+            // like images and links.
+            return a.Kind == b.Kind
+                   && !is_one_of(
+                       a.Kind,
+                       { doc::InlineKind::Link,
+                         doc::InlineKind::Image,
+                         doc::InlineKind::LineBreak,
+                         doc::InlineKind::SoftBreak });
+        };
+        for (auto& cur: node.children)
+        {
+            MRDOCS_ASSERT(!cur.valueless_after_move());
+
+            if (!out.empty())
+            {
+                auto& prev = out.back();
+
+                // Text + Text
+                if (prev->isText() &&
+                    cur->isText())
+                {
+                    prev->asText().literal += cur->asText().literal;
+                    // drop cur
+                    continue;
+                }
+
+                // Same-kind wrappers: merge containers by moving children
+                if (can_merge_same_kind(*prev, *cur))
+                {
+                    // Try to view both as InlineContainer (non-text
+                    // wrappers should be)
+                    auto* pc = dynamic_cast<doc::InlineContainer*>(&*prev);
+                    auto* cc = dynamic_cast<doc::InlineContainer*>(&*cur);
+                    if (pc && cc)
+                    {
+                        pc->children.insert(
+                            pc->children.end(),
+                            std::make_move_iterator(cc->children.begin()),
+                            std::make_move_iterator(cc->children.end()));
+                        cc->children.clear();
+                        // merged; drop cur
+                        continue;
+                    }
+                }
+            }
+
+            out.emplace_back(std::move(cur));
+        }
+
+        node.children = std::move(out);
+    });
 }
 
 void
-JavadocFinalizer::
-finalize(std::vector<SymbolID>& ids)
+DocCommentFinalizer::
+parseInlines(DocComment& doc)
 {
-    std::erase_if(ids, [this](SymbolID const& id)
-    {
-        return !id || ! corpus_.info_.contains(id);
+    bottomUpTraverse(doc, []<std::derived_from<doc::InlineContainer> NodeTy>(NodeTy& node) {
+        if constexpr (requires { { node.children } -> range_of<Polymorphic<doc::Inline>>; })
+        {
+            auto it = node.children.begin();
+            while (it != node.children.end())
+            {
+                Polymorphic<doc::Inline>& el = *it;
+
+                // Advance when doesn't text
+                if (!el->isText()) {
+                    ++it;
+                    continue;
+                }
+
+                auto& textEl = el->asText();
+                doc::InlineContainer v;
+                ParseResult r = parse(textEl.literal, v);
+
+                // advance on parse failure
+                if (!r)
+                {
+                    ++it;
+                    continue;
+                }
+
+                // Remove the original text node; 'it' becomes the
+                // insertion position.
+                it = node.children.erase(it);
+
+                // Move-insert each parsed child;
+                // advance using returned iterators.
+                for (auto& child : v.children)
+                {
+                    it = node.children.insert(it, std::move(child));
+                    ++it;
+                }
+            }
+        }
     });
 }
 
-void
-JavadocFinalizer::
-finalize(TArg& arg)
+namespace {
+// A function erases all references in a vector that don't exist
+// in the corpus with invalid references.
+inline void
+removeInvalidIds(CorpusImpl& corpus, std::vector<SymbolID>& refs)
 {
-    visit(arg, [this]<typename Ty>(Ty& A)
-    {
-        if constexpr (Ty::isType())
+    std::erase_if(refs, [&corpus](SymbolID const& id) {
+        if (id == SymbolID::invalid)
         {
-            MRDOCS_ASSERT(!A.Type.valueless_after_move());
-            finalize(*A.Type);
+            return true;
         }
-        if constexpr (Ty::isTemplate())
+        if (!corpus.find(id))
         {
-            finalize(A.Template);
+            return true;
         }
+        return false;
     });
 }
 
-void
-JavadocFinalizer::
-finalize(TParam& param)
+inline void
+removeInvalidIds(CorpusImpl& corpus, std::vector<struct Name>& refs)
 {
-    if (param.Default)
-    {
-        finalize(**param.Default);
-    }
-    visit(param, [this]<typename Ty>(Ty& P)
-    {
-        if constexpr (Ty::isType())
+    std::erase_if(refs, [&corpus](struct Name const& N) {
+        if (N.id == SymbolID::invalid)
         {
-            if (P.Constraint)
-            {
-                finalize(**P.Constraint);
-            }
+            return true;
         }
-        if constexpr (Ty::isConstant())
+        if (!corpus.find(N.id))
         {
-            MRDOCS_ASSERT(!P.Type.valueless_after_move());
-            finalize(*P.Type);
+            return true;
         }
-
-        if constexpr (Ty::isTemplate())
+        if (N.isSpecialization())
         {
-            finalize(P.Params);
+            if (!corpus.find(N.asSpecialization().specializationID))
+            {
+                return true;
+            }
         }
+        return false;
     });
 }
 
-void
-JavadocFinalizer::
-finalize(Param& param)
+inline void
+removeInvalidIds(CorpusImpl& corpus, std::vector<doc::ReferenceInline>& refs)
 {
-    MRDOCS_ASSERT(!param.Type.valueless_after_move());
-    finalize(*param.Type);
+    std::erase_if(refs, [&corpus](doc::ReferenceInline const& ref) {
+        if (ref.id == SymbolID::invalid)
+        {
+            return true;
+        }
+        if (!corpus.find(ref.id))
+        {
+            return true;
+        }
+        return false;
+    });
 }
 
-void
-JavadocFinalizer::
-finalize(BaseInfo& info)
+inline void
+removeInvalidIds(CorpusImpl& corpus, TemplateInfo& T)
 {
-    MRDOCS_ASSERT(!info.Type.valueless_after_move());
-    finalize(*info.Type);
+    if (T.Primary != SymbolID::invalid &&
+        !corpus.find(T.Primary))
+    {
+        T.Primary = SymbolID::invalid;
+    }
 }
-
-void
-JavadocFinalizer::
-finalize(TemplateInfo& info)
-{
-    finalize(info.Args);
-    finalize(info.Params);
-    finalize(info.Primary);
 }
 
 void
-JavadocFinalizer::
-finalize(Type& type)
+DocCommentFinalizer::
+removeInvalidReferences(Symbol& I)
 {
-    finalize(innerTypePtr(type));
-
-    visit(type, [this]<typename Ty>(Ty& T)
+    if (auto* asUsing = dynamic_cast<UsingSymbol*>(&I))
     {
-        if constexpr (requires { T.ParentType; })
+        removeInvalidIds(corpus_, asUsing->ShadowDeclarations);
+    }
+    else if (auto* asNamespace = dynamic_cast<NamespaceSymbol*>(&I))
+    {
+        removeInvalidIds(corpus_, asNamespace->UsingDirectives);
+    }
+    else if (auto* asNamespaceAlias = dynamic_cast<NamespaceAliasSymbol*>(&I))
+    {
+        if (!corpus_.find(asNamespaceAlias->AliasedSymbol.id))
         {
-            finalize(T.ParentType);
+            asNamespaceAlias->AliasedSymbol.id = SymbolID::invalid;
         }
-
-        if constexpr (Ty::isNamed())
+    }
+    else if (auto* asFunction = dynamic_cast<FunctionSymbol*>(&I))
+    {
+        if (asFunction->Template)
         {
-            finalize(T.Name);
+            removeInvalidIds(corpus_, *asFunction->Template);
         }
-
-        if constexpr (Ty::isAuto())
+    }
+    else if (auto* asRecord = dynamic_cast<RecordSymbol*>(&I))
+    {
+        if (asRecord->Template)
         {
-            finalize(T.Constraint);
+            removeInvalidIds(corpus_, *asRecord->Template);
         }
-    });
-}
-
-void
-JavadocFinalizer::
-finalize(Name& name)
-{
-    visit(name, [this]<typename Ty>(Ty& T)
+    }
+    else if (auto* asTypedef = dynamic_cast<TypedefSymbol*>(&I))
     {
-        finalize(T.Prefix);
-        if constexpr(requires { T.TemplateArgs; })
+        if (asTypedef->Template)
         {
-            finalize(T.TemplateArgs);
+            removeInvalidIds(corpus_, *asTypedef->Template);
         }
-        finalize(T.id);
-    });
+    }
+    else if (auto* asVariable = dynamic_cast<VariableSymbol*>(&I))
+    {
+        if (asVariable->Template)
+        {
+            removeInvalidIds(corpus_, *asVariable->Template);
+        }
+    }
+    else if (auto* asConcept = dynamic_cast<ConceptSymbol*>(&I))
+    {
+        if (asConcept->Template)
+        {
+            removeInvalidIds(corpus_, *asConcept->Template);
+        }
+    }
+
+    MRDOCS_CHECK_OR(I.doc);
+    auto& J = *I.doc;
+    removeInvalidReferences(J);
 }
 
 void
-JavadocFinalizer::
-checkExists(SymbolID const& id) const
+DocCommentFinalizer::
+removeInvalidReferences(DocComment& doc)
 {
-    MRDOCS_ASSERT(corpus_.info_.contains(id));
+    // Use the bottom up traversal to ensure that
+    // we resolve references in inner nodes.
+    // The only nodes that can contain references
+    // are ReferenceInline and ThrowsBlock.
+    bottomUpTraverse(doc, Overload(
+        [this](DocComment& node) {
+            removeInvalidIds(corpus_, node.relates);
+            removeInvalidIds(corpus_, node.related);
+        },
+        [this](doc::ReferenceInline& node) {
+            if (node.id != SymbolID::invalid)
+            {
+                if (!corpus_.find(node.id))
+                {
+                    node.id = SymbolID::invalid;
+                }
+            }
+        },
+        [this](doc::ThrowsBlock& node) {
+            if (node.exception.id != SymbolID::invalid)
+            {
+                if (!corpus_.find(node.exception.id))
+                {
+                    node.exception.id = SymbolID::invalid;
+                }
+            }
+        }));
 }
 
 namespace {
 // Expand tabs to spaces using a tab stop of 8 (common in toolchains)
 inline
 std::string
-expand_tabs(std::string_view s, std::size_t tabw = 8)
+expand_tabs(std::string_view s, std::size_t tabw)
 {
     std::string out;
     out.reserve(s.size());
@@ -1727,7 +1586,7 @@ split_lines(std::string const& text)
 } // namespace
 
 void
-JavadocFinalizer::emitWarnings()
+DocCommentFinalizer::emitWarnings()
 {
     MRDOCS_CHECK_OR(corpus_.config->warnings);
     warnUndocumented();
@@ -1833,7 +1692,7 @@ JavadocFinalizer::emitWarnings()
 }
 
 void
-JavadocFinalizer::warnUndocumented()
+DocCommentFinalizer::warnUndocumented()
 {
     MRDOCS_CHECK_OR(corpus_.config->warnIfUndocumented);
     for (auto& undocI: corpus_.undocumented_)
@@ -1841,10 +1700,10 @@ JavadocFinalizer::warnUndocumented()
         if (Symbol const* I = corpus_.find(undocI.id))
         {
             MRDOCS_CHECK_OR(
-                !I->javadoc || I->Extraction == ExtractionMode::Regular);
+                !I->doc || I->Extraction == ExtractionMode::Regular);
         }
-        bool const prefer_definition = undocI.kind == SymbolKind::Record
-                                       || undocI.kind == SymbolKind::Enum;
+        bool const prefer_definition = is_one_of(
+            undocI.kind, {SymbolKind::Record, SymbolKind::Enum});
         this->warn(
             *getPrimaryLocation(undocI.Loc, prefer_definition),
             "{}: Symbol is undocumented",
@@ -1854,7 +1713,7 @@ JavadocFinalizer::warnUndocumented()
 }
 
 void
-JavadocFinalizer::
+DocCommentFinalizer::
 warnDocErrors()
 {
     MRDOCS_CHECK_OR(corpus_.config->warnIfDocError);
@@ -1867,15 +1726,15 @@ warnDocErrors()
 }
 
 void
-JavadocFinalizer::
+DocCommentFinalizer::
 warnParamErrors(FunctionSymbol const& I)
 {
-    MRDOCS_CHECK_OR(I.javadoc);
+    MRDOCS_CHECK_OR(I.doc);
 
-    // Check for duplicate javadoc parameters
-    auto javadocParamNames = getJavadocParamNames(*I.javadoc);
-    std::ranges::sort(javadocParamNames);
-    auto [firstDup, lastUnique] = std::ranges::unique(javadocParamNames);
+    // Check for duplicate doc parameters
+    auto docParamNames = getDocCommentParamNames(*I.doc);
+    std::ranges::sort(docParamNames);
+    auto [firstDup, lastUnique] = std::ranges::unique(docParamNames);
     auto duplicateParamNames = std::ranges::subrange(firstDup, lastUnique);
     auto [firstDupDup, _] = std::ranges::unique(duplicateParamNames);
     for (auto const uniqueDuplicateParamNames = std::ranges::subrange(firstDup, firstDupDup);
@@ -1887,29 +1746,29 @@ warnParamErrors(FunctionSymbol const& I)
             corpus_.Corpus::qualifiedName(I),
             duplicateParamName);
     }
-    javadocParamNames.erase(lastUnique, javadocParamNames.end());
+    docParamNames.erase(lastUnique, docParamNames.end());
 
     // Check for documented parameters that don't exist in the function
     auto paramNames =
         std::views::transform(I.Params, &Param::Name) |
         std::views::filter([](Optional<std::string> const& name) { return static_cast<bool>(name); }) |
         std::views::transform([](Optional<std::string> const& name) -> std::string_view { return *name; });
-    for (std::string_view javadocParamName: javadocParamNames)
+    for (std::string_view docParamName: docParamNames)
     {
-        if (std::ranges::find(paramNames, javadocParamName) == paramNames.end())
+        if (std::ranges::find(paramNames, docParamName) == paramNames.end())
         {
             this->warn(
                 *getPrimaryLocation(I),
                 "{}: Documented parameter '{}' does not exist",
                 corpus_.Corpus::qualifiedName(I),
-                javadocParamName);
+                docParamName);
         }
     }
 
 }
 
 void
-JavadocFinalizer::
+DocCommentFinalizer::
 warnNoParamDocs()
 {
     MRDOCS_CHECK_OR(corpus_.config->warnNoParamdoc);
@@ -1917,18 +1776,18 @@ warnNoParamDocs()
     {
         MRDOCS_CHECK_OR_CONTINUE(I->Extraction == ExtractionMode::Regular);
         MRDOCS_CHECK_OR_CONTINUE(I->isFunction());
-        MRDOCS_CHECK_OR_CONTINUE(I->javadoc);
+        MRDOCS_CHECK_OR_CONTINUE(I->doc);
         warnNoParamDocs(dynamic_cast<FunctionSymbol const&>(*I));
     }
 }
 
 void
-JavadocFinalizer::
+DocCommentFinalizer::
 warnNoParamDocs(FunctionSymbol const& I)
 {
     MRDOCS_CHECK_OR(!I.IsDeleted);
-    // Check for function parameters that are not documented in javadoc
-    auto javadocParamNames = getJavadocParamNames(*I.javadoc);
+    // Check for function parameters that are not documented in doc
+    auto docParamNames = getDocCommentParamNames(*I.doc);
     auto paramNames =
         std::views::transform(I.Params, &Param::Name) |
         std::views::filter([](Optional<std::string> const& name) { return name.has_value(); }) |
@@ -1936,7 +1795,7 @@ warnNoParamDocs(FunctionSymbol const& I)
         std::views::filter([](std::string_view const& name) { return !name.empty(); });
     for (auto const& paramName: paramNames)
     {
-        if (std::ranges::find(javadocParamNames, paramName) == javadocParamNames.end())
+        if (std::ranges::find(docParamNames, paramName) == docParamNames.end())
         {
             this->warn(
                 *getPrimaryLocation(I),
@@ -1947,7 +1806,7 @@ warnNoParamDocs(FunctionSymbol const& I)
     }
 
     // Check for undocumented return type
-    if (I.javadoc->returns.empty())
+    if (I.doc->returns.empty())
     {
         MRDOCS_ASSERT(!I.ReturnType.valueless_after_move());
         auto isVoid = [](Type const& returnType) -> bool
@@ -1970,7 +1829,7 @@ warnNoParamDocs(FunctionSymbol const& I)
 }
 
 void
-JavadocFinalizer::
+DocCommentFinalizer::
 warnUndocEnumValues()
 {
     MRDOCS_CHECK_OR(corpus_.config->warnIfUndocEnumVal);
@@ -1978,7 +1837,7 @@ warnUndocEnumValues()
     {
         MRDOCS_CHECK_OR_CONTINUE(I->isEnumConstant());
         MRDOCS_CHECK_OR_CONTINUE(I->Extraction == ExtractionMode::Regular);
-        MRDOCS_CHECK_OR_CONTINUE(!I->javadoc);
+        MRDOCS_CHECK_OR_CONTINUE(!I->doc);
         this->warn(
             *getPrimaryLocation(*I),
             "{}: Missing documentation for enum value",
@@ -1987,7 +1846,7 @@ warnUndocEnumValues()
 }
 
 void
-JavadocFinalizer::
+DocCommentFinalizer::
 warnUnnamedParams()
 {
     MRDOCS_CHECK_OR(corpus_.config->warnUnnamedParam);
@@ -1995,13 +1854,13 @@ warnUnnamedParams()
     {
         MRDOCS_CHECK_OR_CONTINUE(I->isFunction());
         MRDOCS_CHECK_OR_CONTINUE(I->Extraction == ExtractionMode::Regular);
-        MRDOCS_CHECK_OR_CONTINUE(I->javadoc);
+        MRDOCS_CHECK_OR_CONTINUE(I->doc);
         warnUnnamedParams(dynamic_cast<FunctionSymbol const&>(*I));
     }
 }
 
 void
-JavadocFinalizer::
+DocCommentFinalizer::
 warnUnnamedParams(FunctionSymbol const& I)
 {
     auto orderSuffix = [](std::size_t const i) -> std::string
diff --git a/src/lib/Metadata/Finalizers/DocCommentFinalizer.hpp b/src/lib/Metadata/Finalizers/DocCommentFinalizer.hpp
new file mode 100644
index 000000000..a80d87c54
--- /dev/null
+++ b/src/lib/Metadata/Finalizers/DocCommentFinalizer.hpp
@@ -0,0 +1,333 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#ifndef MRDOCS_LIB_METADATA_FINALIZERS_DOCCOMMENTFINALIZER_HPP
+#define MRDOCS_LIB_METADATA_FINALIZERS_DOCCOMMENTFINALIZER_HPP
+
+#include <lib/CorpusImpl.hpp>
+#include <lib/Metadata/SymbolSet.hpp>
+#include <mrdocs/Support/Report.hpp>
+#include <mrdocs/Support/ScopeExit.hpp>
+#include <format>
+#include <set>
+#include <utility>
+
+namespace mrdocs {
+
+/** Finalizes a set of Info.
+
+    This removes any references to SymbolIDs
+    which do not exist.
+
+    References which should always be valid
+    are not checked.
+*/
+class DocCommentFinalizer {
+    CorpusImpl& corpus_;
+
+    /* Broken references for which we have already emitted
+       a warning.
+     */
+    std::set<std::pair<std::string, std::string>> refWarned_;
+
+    /* Info objects whose briefs have been finalized
+     */
+    std::set<Symbol const*> finalized_brief_;
+
+    /* Info objects whose metadata has been finalized
+     */
+    std::set<Symbol const*> finalized_metadata_;
+
+    /* Info objects that have been finalized
+
+        This is used to avoid recursion when finalizing
+        references.
+     */
+    std::set<Symbol const*> finalized_;
+
+    // A comparison function that sorts locations by:
+    // 1) ascending full path
+    // 2) descending line number
+    // This is the most convenient order for users to fix
+    // warnings in the source code. This is because fixing a problem
+    // at a particular line, without this ordering, would invalidate
+    // the line numbers of all subsequent warnings.
+    struct WarningLocationCompare
+    {
+        bool
+        operator()(Location const& lhs, Location const& rhs) const
+        {
+            if (lhs.FullPath != rhs.FullPath)
+            {
+                return lhs.FullPath < rhs.FullPath;
+            }
+            if (lhs.LineNumber != rhs.LineNumber)
+            {
+                return lhs.LineNumber > rhs.LineNumber;
+            }
+            return lhs.ColumnNumber > rhs.ColumnNumber;
+        }
+    };
+
+    /*  Warnings that should be emitted after finalization
+
+        The warnings are initially stored in this container
+        where the messages are sorted by location.
+
+        This makes it easier for the user to go through
+        the warnings in the order they appear in the source
+        code and fix them.
+     */
+    std::map<Location, std::vector<std::string>, WarningLocationCompare> warnings_;
+
+public:
+    DocCommentFinalizer(CorpusImpl& corpus)
+        : corpus_(corpus)
+    {
+    }
+
+    /** Finalize the doc for all symbols
+     */
+    void
+    build();
+
+private:
+    /*  Finalize the brief of a symbol
+
+        This might mean copying the brief from another
+        symbol (when there's a copybrief command) or
+        populating it automatically (first sentence).
+     */
+    void
+    finalizeBrief(Symbol& I);
+
+    void
+    copyBrief(Symbol const& ctx, DocComment& doc);
+
+    void
+    setAutoBrief(DocComment& doc) const;
+
+    /*  Finalize the metadata copies
+
+        Copy the details and metadata from other symbols to
+        the current symbol context whenever the current
+        context contains a reference to another symbol
+        created with \@copydoc or \@copydetails.
+     */
+    void
+    copyDetails(Symbol& I);
+
+    void
+    copyDetails(Symbol const& ctx, DocComment& doc);
+
+    /*  Populate the metadata of overloads
+
+        This function populates the metadata of overloads
+        with the metadata of the functions it overloads.
+     */
+    void
+    generateOverloadDocs(OverloadsSymbol&);
+
+    /*  Resolve references in the doc
+
+        This function traverses the doc tree
+        of a symbol and resolves all references
+        to other symbols.
+
+        The references are resolved by looking
+        up the symbol in the corpus and setting the ID of
+        the reference.
+     */
+    void
+    resolveReferences(Symbol& I);
+
+    void
+    resolveReference(
+        Symbol const& I,
+        doc::ReferenceInline& ref,
+        bool emitWarning);
+
+    /*  Populate function doc from with missing fields
+
+        This function populates the function doc with
+        missing fields of special functions.
+     */
+    void
+    generateAutoFunctionMetadata(FunctionSymbol&) const;
+
+    /*  Populate and resolve \@relates references
+
+        This function populates the "relates" symbols
+        of a doc (if the option is enabled), then
+        finds the related symbols, resolves them.
+        In other words, it also sets the inverse
+        of the "relates" reference so that the related
+        symbol also knows about the function that
+        relates to it and can generate a link to it
+        in the non-member functions section.
+     */
+    void
+    processRelates(Symbol& I)
+    {
+        MRDOCS_CHECK_OR(I.doc);
+        processRelates(I, *I.doc);
+    }
+
+    void
+    processRelates(Symbol& I, DocComment& doc);
+
+
+    void
+    setAutoRelates(Symbol& I);
+
+    /* Normalize doc siblings
+
+      We first do a post-order structural merge/flatten so that, by the time we
+      run the tidy-up pass below, each container's children are already in a
+      canonical form:
+
+      - adjacent Text nodes are coalesced,
+      - adjacent wrappers of the same kind/attributes are merged,
+      - trivial same-type nesting is flattened.
+
+      Doing this in a dedicated pass avoids backtracking and iterator
+      invalidation in the tidy-up phase, and guarantees that the tidy-up can
+      make a single linear scan over each child list without missing newly
+      created adjacencies.
+    */
+    void
+    normalizeSiblings(DocComment& doc);
+
+    void
+    normalizeSiblings(Symbol& I)
+    {
+        MRDOCS_CHECK_OR(I.doc);
+        normalizeSiblings(*I.doc);
+    }
+
+    /* Tidy up the doc:
+
+       This function performs various bottom-up
+       tidying operations on the doc, such as:
+
+       - Remove any @copy* nodes that got left behind
+       - Trimming leading and trailing empty inlines
+       - Merging consecutive empty blocks (like HTML whitespace normalization)
+       - Remove any blocks or inlines without content
+         (especially after we do the trimming bottom up)
+       - Unindenting code blocks.
+    */
+    void
+    tidyUp(DocComment& doc);
+
+    void
+    tidyUp(Symbol& I)
+    {
+        MRDOCS_CHECK_OR(I.doc);
+        tidyUp(*I.doc);
+        if (I.doc->empty())
+        {
+            I.doc.reset();
+        }
+    }
+
+    /* Parse inlines in terminal text nodes.
+    */
+    void
+    parseInlines(DocComment& doc);
+
+    void
+    parseInlines(Symbol& I)
+    {
+        MRDOCS_CHECK_OR(I.doc);
+        parseInlines(*I.doc);
+    }
+
+    /* Remove references to symbols that are not in the corpus
+
+       This function traverses the symbol and DocComment
+       tree of a symbol and removes all references
+       to symbols that do not exist in the corpus.
+
+       These are references clang was able to resolve
+       when generating the AST, but which do not exist
+       in the final MrDocs corpus, so they are invalid
+       references in the context of MrDocs output.
+    */
+    void
+    removeInvalidReferences(DocComment& doc);
+
+    void
+    removeInvalidReferences(Symbol& I);
+
+    /*  Check the documentation for problems and creates warnings
+
+        We first collect all warnings and then print
+        them at once at the end of the finalization
+        process. This way, the warnings can be sorted
+        by location and the user can fix them in order.
+     */
+    void
+    emitWarnings();
+
+    template<class... Args>
+    void
+    warn(
+        Location const& loc,
+        report::Located<std::string_view> const format,
+        Args&&... args)
+    {
+        MRDOCS_CHECK_OR(corpus_.config->warnings);
+        std::string const str =
+            std::vformat(format.value, std::make_format_args(args...));
+        warnings_[loc].push_back(str);
+    }
+
+    template<class... Args>
+    void
+    warn(
+        Symbol const& ctx,
+        report::Located<std::string_view> const format,
+        Args&&... args)
+    {
+        MRDOCS_CHECK_OR(corpus_.config->warnings);
+        auto loc = getPrimaryLocation(ctx);
+        warn(*loc, format, std::forward<Args>(args)...);
+    }
+
+    void
+    warnUndocumented();
+
+    void
+    warnDocErrors();
+
+    void
+    warnParamErrors(FunctionSymbol const& I);
+
+    void
+    warnNoParamDocs();
+
+    void
+    warnNoParamDocs(FunctionSymbol const& I);
+
+    void
+    warnUndocEnumValues();
+
+    void
+    warnUnnamedParams();
+
+    void
+    warnUnnamedParams(FunctionSymbol const& I);
+};
+
+} // mrdocs
+
+#endif // MRDOCS_LIB_METADATA_FINALIZERS_DOCCOMMENTFINALIZER_HPP
diff --git a/src/lib/Metadata/Finalizers/JavadocFinalizer.hpp b/src/lib/Metadata/Finalizers/JavadocFinalizer.hpp
deleted file mode 100644
index 790f7b686..000000000
--- a/src/lib/Metadata/Finalizers/JavadocFinalizer.hpp
+++ /dev/null
@@ -1,455 +0,0 @@
-//
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#ifndef MRDOCS_LIB_METADATA_FINALIZERS_JAVADOCFINALIZER_HPP
-#define MRDOCS_LIB_METADATA_FINALIZERS_JAVADOCFINALIZER_HPP
-
-#include <lib/CorpusImpl.hpp>
-#include <lib/Metadata/SymbolSet.hpp>
-#include <mrdocs/Support/Report.hpp>
-#include <mrdocs/Support/ScopeExit.hpp>
-#include <format>
-#include <set>
-#include <utility>
-
-namespace mrdocs {
-
-/** Finalizes a set of Info.
-
-    This removes any references to SymbolIDs
-    which do not exist.
-
-    References which should always be valid
-    are not checked.
-*/
-class JavadocFinalizer
-{
-    CorpusImpl& corpus_;
-    Symbol* current_context_ = nullptr;
-
-    /* Broken references for which we have already emitted
-       a warning.
-     */
-    std::set<std::pair<std::string, std::string>> refWarned_;
-
-    /* Info objects that have been finalized
-
-       This is used to avoid allow recursion when
-       finalizing references.
-     */
-    std::set<Symbol const*> finalized_;
-
-    /* Info objects whose brief have been finalized
-     */
-    std::set<Symbol const*> finalized_brief_;
-
-    /* Info objects whose metadata have been finalized
-     */
-    std::set<Symbol const*> finalized_metadata_;
-
-    // A comparison function that sorts locations by:
-    // 1) ascending full path
-    // 2) descending line number
-    // This is the most convenient order to fix
-    // warnings in the source code because fixing a problem
-    // at a certain line will invalidate the line numbers
-    // of all subsequent warnings.
-    struct WarningLocationCompare
-    {
-        bool
-        operator()(Location const& lhs, Location const& rhs) const
-        {
-            if (lhs.FullPath != rhs.FullPath)
-            {
-                return lhs.FullPath < rhs.FullPath;
-            }
-            if (lhs.LineNumber != rhs.LineNumber)
-            {
-                return lhs.LineNumber > rhs.LineNumber;
-            }
-            return lhs.ColumnNumber > rhs.ColumnNumber;
-        }
-    };
-
-    /*  Warnings that should be emitted after finalization
-
-        The warnings are initially stored in this container
-        where the messages are sorted by location.
-
-        This makes it easier for the user to go through
-        the warnings in the order they appear in the source
-        code and fix them.
-     */
-    std::map<Location, std::vector<std::string>, WarningLocationCompare> warnings_;
-
-public:
-    JavadocFinalizer(CorpusImpl& corpus)
-        : corpus_(corpus)
-    {
-    }
-
-    /** Finalize the javadoc for all symbols
-
-        The procedure is composed of steps that resolve
-        groups of javadoc components for each symbol.
-
-        Groups of components processed later might depend
-        on components processed earlier. For example, a
-        function's javadoc might depend on the brief of
-        the return type and the parameters. Or, the
-        javadoc of an overload depends on the complete
-        documentation of the functions it overloads.
-     */
-    void
-    build();
-
-private:
-    /** Finalize the brief of a symbol
-
-        The brief is the first paragraph of the documentation
-        and is used in the index and in the documentation
-        summary.
-     */
-    void
-    finalizeBrief(Symbol& I);
-
-    /** Copy the brief from another symbol
-
-        This function copies the brief from another symbol
-        to the current context. The brief is copied only if
-        the brief of the current context is empty and
-        it contains a reference to another symbol created
-        with \@copybrief or \@copydoc.
-     */
-    void
-    copyBrief(Javadoc& javadoc);
-
-    /** Set brief content automatically
-
-        If the brief is empty, this function sets the brief
-        to the first paragraph of the documentation.
-     */
-    void
-    setAutoBrief(Javadoc& javadoc) const;
-
-    /** Finalize the metadata copies
-
-        Copy the metadata from other symbols to the current
-        context whenever the current context contains a
-        reference to another symbol created with \@copydoc.
-     */
-    void
-    finalizeMetadataCopies(Symbol& I);
-
-    /** Populate function javadoc from with missing fields
-
-        This function populates the function javadoc with
-        missing fields of special functions.
-     */
-    void
-    populateFunctionJavadoc(FunctionSymbol&) const;
-
-    /** Populate the metadata of overloads
-
-        This function populates the metadata of overloads
-        with the metadata of the functions it overloads.
-     */
-    void
-    populateOverloadJavadoc(OverloadsSymbol&);
-
-    /** Resolve references in the javadoc
-
-        This function resolves references in the javadoc
-        of a symbol. The references are resolved by looking
-        up the symbol in the corpus and setting the id of
-        the reference.
-     */
-    void
-    finalizeJavadoc(Symbol& I);
-
-    /** Recursively finalize javadoc members
-
-        This function also processes related symbols,
-        merges consecutive blocks, trims blocks, and
-        unindents code blocks.
-     */
-    void
-    finalize(Javadoc& javadoc);
-
-    /** Resolve \@relates references
-
-        This function finds the ID of "relates" symbols
-        and populates the "related" symbol with the inverse.
-     */
-    void
-    processRelates(Javadoc& javadoc);
-
-    /** Remove all temporary text nodes from a block
-
-        The temporary nodes (copied, related, etc...) should
-        have been processed by the previous steps and should
-        not be present in the final output.
-     */
-    void
-    removeTempTextNodes(Javadoc& javadoc);
-
-    /// A range of values derived from blocks
-    template <std::ranges::range R>
-    requires std::derived_from<std::ranges::range_value_t<R>, doc::Block>
-    void
-    removeTempTextNodes(R&& blocks)
-    {
-        for (auto& block: blocks)
-        {
-            removeTempTextNodes(block);
-        }
-    }
-
-    /// Remove temporary text nodes from a block
-    void
-    removeTempTextNodes(std::vector<Polymorphic<doc::Block>>& blocks);
-
-    /// Remove temporary text nodes from a block
-    void
-    removeTempTextNodes(doc::Block& block);
-
-    /** Trim all block childen in the javadoc
-
-        The first child is rtrimmed and the last child is ltrimmed.
-
-        Like in HTML, multiple whitespaces (spaces, tabs, and newlines)
-        between and within child nodes are collapsed into a single space.
-     */
-    void
-    trimBlocks(Javadoc& javadoc);
-
-    /// A range of values derived from blocks
-    template <std::ranges::range R>
-    requires std::derived_from<std::ranges::range_value_t<R>, doc::Block>
-    void
-    trimBlocks(R&& blocks)
-    {
-        for (auto& block: blocks)
-        {
-            trimBlock(block);
-        }
-    }
-
-    /// Trim a block
-    void
-    trimBlocks(std::vector<Polymorphic<doc::Block>>& blocks);
-
-    /// Trim a block
-    void
-    trimBlock(doc::Block& block);
-
-    /// Unindent all code blocks in the javadoc
-    void
-    unindentCodeBlocks(Javadoc& javadoc);
-
-    /// Unindent code blocks in a range
-    template <std::ranges::range R>
-    requires std::derived_from<std::ranges::range_value_t<R>, doc::Block>
-    void
-    unindentCodeBlocks(R&& blocks)
-    {
-        for (auto& block: blocks)
-        {
-            unindentCodeBlocks(block);
-        }
-    }
-
-    /// Unindent code blocks in a vector
-    void
-    unindentCodeBlocks(std::vector<Polymorphic<doc::Block>>& blocks);
-
-    /// Unindent a code block
-    void
-    unindentCodeBlocks(doc::Block& block);
-
-    /** Check and finalize data unrelated to javadoc
-
-        This checks if all symbol IDs are valid and
-        removes invalid IDs from the Info data.
-     */
-    template <class InfoTy>
-    void
-    finalizeInfoData(InfoTy& I);
-
-    /** Check the documentation for problems and creates warnings
-     */
-    void
-    emitWarnings();
-
-    // Look for symbol and set the id of a reference
-    void
-    finalize(doc::Reference& ref, bool emitWarning = true);
-
-    // Recursively finalize references in a javadoc node
-    void
-    finalize(doc::Node& node);
-
-    // Automatically find related symbols
-    void
-    setAutoRelates();
-
-    // Copy brief and details to the current context
-    void
-    copyDetails(Javadoc& javadoc);
-
-    // Set id to invalid if it does not exist
-    void
-    finalize(SymbolID& id);
-
-    // Remove invalid ids from a vector
-    void
-    finalize(std::vector<SymbolID>& ids);
-
-    // Remove invalid ids from TArg members
-    void
-    finalize(TArg& arg);
-
-    // Remove invalid ids from TParam members
-    void
-    finalize(TParam& param);
-
-    // Remove invalid ids from Javadoc members
-    void
-    finalize(Param& param);
-
-    /// Remove invalid ids from BaseInfo members
-    void
-    finalize(BaseInfo& info);
-
-    /// Remove invalid ids from TemplateInfo members
-    void
-    finalize(TemplateInfo& info);
-
-    /// Remove invalid ids from Type members
-    void
-    finalize(Type& type);
-
-    /// Remove invalid ids from Name members
-    void
-    finalize(Name& name);
-
-    /// Finalize polymorphic
-    template <class T>
-    void
-    finalize(Polymorphic<T>&& val)
-    {
-        MRDOCS_ASSERT(!val.valueless_after_move());
-        finalize(*val);
-    }
-
-    template <class T>
-    void
-    finalize(Polymorphic<T>& val)
-    {
-        MRDOCS_ASSERT(!val.valueless_after_move());
-        finalize(*val);
-    }
-
-    /// Finalize optional and pointer-like members
-    template <dereferenceable T>
-    void
-    finalize(T&& val) requires
-    requires { this->finalize(*val); }
-    {
-        if (val)
-        {
-            finalize(*val);
-        }
-    }
-
-    /// Finalize a range of elements
-    template<typename Range>
-    requires std::ranges::input_range<Range>
-    void
-    finalize(Range&& range)
-    {
-        for (auto&& elem: range)
-        {
-            finalize(elem);
-        }
-    }
-
-    // Check if SymbolID exists in info
-    void
-    checkExists(SymbolID const& id) const;
-
-    // Check if SymbolIDs exist in info
-    template <range_of<SymbolID> T>
-    void
-    checkExists(T&& ids) const
-    {
-        MRDOCS_ASSERT(std::ranges::all_of(ids,
-            [this](SymbolID const& id)
-            {
-                return corpus_.find(id) != nullptr;
-            }));
-    }
-
-
-
-    template<class... Args>
-    void
-    warn(
-        Location const& loc,
-        report::Located<std::string_view> const format,
-        Args&&... args)
-    {
-        MRDOCS_CHECK_OR(corpus_.config->warnings);
-        std::string const str =
-            std::vformat(format.value, std::make_format_args(args...));
-        warnings_[loc].push_back(str);
-    }
-
-    template<class... Args>
-    void
-    warn(
-        report::Located<std::string_view> const format,
-        Args&&... args)
-    {
-        MRDOCS_CHECK_OR(corpus_.config->warnings);
-        MRDOCS_ASSERT(current_context_);
-        auto loc = getPrimaryLocation(*current_context_);
-        warn(*loc, format, std::forward<Args>(args)...);
-    }
-
-    void
-    warnUndocumented();
-
-    void
-    warnDocErrors();
-
-    void
-    warnParamErrors(FunctionSymbol const& I);
-
-    void
-    warnNoParamDocs();
-
-    void
-    warnNoParamDocs(FunctionSymbol const& I);
-
-    void
-    warnUndocEnumValues();
-
-    void
-    warnUnnamedParams();
-
-    void
-    warnUnnamedParams(FunctionSymbol const& I);
-};
-
-} // mrdocs
-
-#endif // MRDOCS_LIB_METADATA_FINALIZERS_JAVADOCFINALIZER_HPP
diff --git a/src/lib/Metadata/Finalizers/NamespacesFinalizer.cpp b/src/lib/Metadata/Finalizers/NamespacesFinalizer.cpp
index b8c6d4be1..64c2ab47c 100644
--- a/src/lib/Metadata/Finalizers/NamespacesFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/NamespacesFinalizer.cpp
@@ -46,7 +46,7 @@ operator()(NamespaceSymbol& I)
     MRDOCS_CHECK_OR(I.id != SymbolID::global, FinalizerResult::None);
 
     // No more steps for documented namespaces
-    MRDOCS_CHECK_OR(!I.javadoc, FinalizerResult::None);
+    MRDOCS_CHECK_OR(!I.doc, FinalizerResult::None);
 
     // 3) Remove empty undocumented namespaces
     auto memberIds = allMembers(I);
diff --git a/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp b/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp
index f36233856..c6fd50ca7 100644
--- a/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp
+++ b/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp
@@ -243,6 +243,11 @@ struct SymbolIDCompareFn
             {
                 return std::is_lt(cmp);
             }
+            if (auto const cmp = lhsLoc->ColumnNumber <=> rhsLoc->ColumnNumber;
+                cmp != 0)
+            {
+                return std::is_lt(cmp);
+            }
             break;
         }
         default:
diff --git a/src/lib/Metadata/Info.cpp b/src/lib/Metadata/Info.cpp
index 721b7d55a..397e770b1 100644
--- a/src/lib/Metadata/Info.cpp
+++ b/src/lib/Metadata/Info.cpp
@@ -56,14 +56,14 @@ merge(Symbol& I, Symbol&& Other)
     }
     I.Extraction = leastSpecific(I.Extraction, Other.Extraction);
 
-    // Append javadocs
-    if (!I.javadoc)
+    // Append docs
+    if (!I.doc)
     {
-        I.javadoc = std::move(Other.javadoc);
+        I.doc = std::move(Other.doc);
     }
-    else if (Other.javadoc)
+    else if (Other.doc)
     {
-        merge(*I.javadoc, std::move(*Other.javadoc));
+        merge(*I.doc, std::move(*Other.doc));
     }
 }
 
diff --git a/src/lib/Metadata/Javadoc.cpp b/src/lib/Metadata/Javadoc.cpp
deleted file mode 100644
index 3afddee5f..000000000
--- a/src/lib/Metadata/Javadoc.cpp
+++ /dev/null
@@ -1,387 +0,0 @@
-//
-// This is a derivative work. originally part of the LLVM Project.
-// Licensed under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Copyright (c) 2023 Vinnie Falco (vinnie.falco@gmail.com)
-// Copyright (c) 2023 Krystian Stasiowski (sdkrystian@gmail.com)
-//
-// Official repository: https://github.com/cppalliance/mrdocs
-//
-
-#include <lib/Support/Debug.hpp>
-#include <mrdocs/Corpus.hpp>
-#include <mrdocs/Metadata/DomCorpus.hpp>
-#include <mrdocs/Metadata/Javadoc.hpp>
-#include <mrdocs/Metadata/Javadoc/Inline/Parts.hpp>
-#include <llvm/Support/Error.h>
-#include <llvm/Support/Path.h>
-#include <format>
-
-
-namespace mrdocs {
-namespace doc {
-
-dom::String
-toString(NodeKind kind) noexcept
-{
-    switch(kind)
-    {
-        case NodeKind::text:
-            return "text";
-        case NodeKind::admonition:
-            return "admonition";
-        case NodeKind::brief:
-            return "brief";
-        case NodeKind::code:
-            return "code";
-        case NodeKind::heading:
-            return "heading";
-        case NodeKind::link:
-            return "link";
-        case NodeKind::list_item:
-            return "list_item";
-        case NodeKind::unordered_list:
-            return "unordered_list";
-        case NodeKind::paragraph:
-            return "paragraph";
-        case NodeKind::param:
-            return "param";
-        case NodeKind::returns:
-            return "returns";
-        case NodeKind::styled:
-            return "styled";
-        case NodeKind::tparam:
-            return "tparam";
-        case NodeKind::reference:
-            return "reference";
-        case NodeKind::copy_details:
-            return "copied";
-        case NodeKind::throws:
-            return "throws";
-        case NodeKind::details:
-            return "details";
-        case NodeKind::see:
-            return "see";
-        case NodeKind::precondition:
-            return "precondition";
-        case NodeKind::postcondition:
-            return "postcondition";
-        default:
-            MRDOCS_UNREACHABLE();
-    }
-}
-
-dom::String
-toString(Style kind) noexcept
-{
-    switch(kind)
-    {
-    case Style::none:
-        return "";
-    case Style::mono:
-        return "mono";
-    case Style::bold:
-        return "bold";
-    case Style::italic:
-        return "italic";
-    default:
-        MRDOCS_UNREACHABLE();
-    }
-}
-
-dom::String
-toString(Admonish kind) noexcept
-{
-    switch(kind)
-    {
-    case Admonish::none:
-        return "";
-    case Admonish::note:
-        return "note";
-    case Admonish::tip:
-        return "tip";
-    case Admonish::important:
-        return "important";
-    case Admonish::caution:
-        return "caution";
-    case Admonish::warning:
-        return "warning";
-    default:
-        MRDOCS_UNREACHABLE();
-    }
-}
-
-dom::String
-toString(ParamDirection kind) noexcept
-{
-    switch(kind)
-    {
-    case ParamDirection::none:
-        return "";
-    case ParamDirection::in:
-        return "in";
-    case ParamDirection::out:
-        return "out";
-    case ParamDirection::inout:
-        return "inout";
-    default:
-        MRDOCS_UNREACHABLE();
-    }
-}
-
-dom::String
-toString(Parts kind) noexcept
-{
-    switch(kind)
-    {
-    case Parts::all:
-        return "all";
-    case Parts::brief:
-        return "brief";
-    case Parts::description:
-        return "description";
-    default:
-        MRDOCS_UNREACHABLE();
-    }
-}
-
-Text&
-Block::
-emplace_back(
-    Polymorphic<Text> text)
-{
-    MRDOCS_ASSERT(text->isText());
-    return *children.emplace_back(std::move(text));
-}
-
-void
-Block::
-append(std::vector<Polymorphic<Node>>&& blocks)
-{
-    children.reserve(children.size() + blocks.size());
-    for (auto&& block : blocks)
-    {
-        MRDOCS_ASSERT(block->isText());
-        emplace_back(Polymorphic<Text>(std::in_place_type<Text>,
-                                       dynamic_cast<Text &&>(*block)));
-    }
-}
-
-void
-Block::
-append(std::vector<Polymorphic<Text>> const& otherChildren)
-{
-    children.insert(
-        children.end(),
-        otherChildren.begin(),
-        otherChildren.end());
-}
-
-
-std::strong_ordering
-operator<=>(Polymorphic<Text> const& lhs, Polymorphic<Text> const& rhs)
-{
-    MRDOCS_ASSERT(!lhs.valueless_after_move());
-    MRDOCS_ASSERT(!rhs.valueless_after_move());
-    if (lhs->Kind == rhs->Kind)
-    {
-        return visit(*lhs, detail::VisitCompareFn<Node>(*rhs));
-    }
-    return lhs->Kind <=> rhs->Kind;
-}
-
-Paragraph&
-Paragraph::
-operator=(std::string_view str)
-{
-    this->children.clear();
-    this->children.emplace_back(Polymorphic<doc::Text>(
-        std::in_place_type<doc::Text>, std::string(str)));
-    return *this;
-}
-
-} // doc
-
-//------------------------------------------------
-
-Javadoc::
-Javadoc() noexcept = default;
-
-Javadoc::
-Javadoc(
-    std::vector<Polymorphic<doc::Block>> blocks)
-    : blocks(std::move(blocks))
-{
-}
-
-bool
-Javadoc::
-operator==(Javadoc const& other) const noexcept
-{
-    return std::ranges::equal(blocks, other.blocks,
-        [](auto const& a, auto const& b)
-        {
-            return a->equals(static_cast<doc::Node const&>(*b));
-        }) &&
-        returns == other.returns &&
-        brief == other.brief &&
-        params == other.params &&
-        tparams == other.tparams &&
-        exceptions == other.exceptions &&
-        sees == other.sees &&
-        related == other.related &&
-        preconditions == other.preconditions &&
-        postconditions == other.postconditions;
-}
-
-bool
-Javadoc::
-operator!=(
-    Javadoc const& other) const noexcept
-{
-    return !(*this == other);
-}
-
-std::string
-Javadoc::
-emplace_back(
-    Polymorphic<doc::Block> block)
-{
-    MRDOCS_ASSERT(block->isBlock());
-
-    std::string result;
-    switch(block->Kind)
-    {
-    case doc::NodeKind::param:
-    {
-        // check for duplicate parameter name
-        auto t = dynamic_cast<doc::Param const*>(block.operator->());
-        for(auto const& q : blocks)
-        {
-            if(q->Kind == doc::NodeKind::param)
-            {
-                auto u = dynamic_cast<doc::Param const*>(q.operator->());
-                if(u->name == t->name)
-                {
-                  result = std::format("duplicate param {}", t->name);
-                  break;
-                }
-            }
-        }
-        break;
-    }
-    case doc::NodeKind::tparam:
-    {
-        // check for duplicate template parameter name
-        auto t = dynamic_cast<doc::TParam const*>(block.operator->());
-        for(auto const& q : blocks)
-        {
-            if(q->Kind == doc::NodeKind::tparam)
-            {
-                auto u = dynamic_cast<doc::TParam const*>(q.operator->());
-                if(u->name == t->name)
-                {
-                  result = std::format("duplicate tparam {}", t->name);
-                  break;
-                }
-            }
-        }
-        break;
-    }
-    default:
-        break;
-    }
-
-    blocks.emplace_back(std::move(block));
-    return result;
-}
-
-void
-Javadoc::
-append(
-    Javadoc&& other)
-{
-    using std::ranges::find;
-    using std::ranges::copy_if;
-    using std::views::transform;
-
-    // blocks
-    for (auto&& block: other.blocks)
-    {
-        emplace_back(std::move(block));
-    }
-    // returns
-    copy_if(other.returns, std::back_inserter(returns),
-        [&](auto const& r)
-        {
-            return find(returns, r) == returns.end();
-        });
-    // params
-    copy_if(other.params, std::back_inserter(params),
-        [&](auto const& p)
-        {
-            auto namesAndDirection = transform(params, [](auto const& q)
-            {
-                return std::make_pair(std::string_view(q.name), q.direction);
-            });
-            auto el = std::make_pair(std::string_view(p.name), p.direction);
-            return find(namesAndDirection, el) == namesAndDirection.end();
-        });
-    // tparams
-    copy_if(other.tparams, std::back_inserter(tparams),
-        [&](auto const& p)
-        {
-            auto names = transform(tparams, &doc::TParam::name);
-            return find(names, p.name) == names.end();
-        });
-    // exceptions
-    copy_if(other.exceptions, std::back_inserter(exceptions),
-        [&](auto const& e)
-        {
-            // e.exception.string
-            auto exceptionRefs = transform(exceptions, &doc::Throws::exception);
-            auto exceptionStrs = transform(exceptionRefs, &doc::Reference::string);
-            return find(exceptionStrs, e) == exceptionStrs.end();
-        });
-    // sees
-    copy_if(other.sees, std::back_inserter(sees),
-        [&](auto const& s)
-        {
-            return find(sees, s) == sees.end();
-        });
-    // preconditions
-    copy_if(other.preconditions, std::back_inserter(preconditions),
-        [&](auto const& p)
-        {
-            return find(preconditions, p) == preconditions.end();
-        });
-    // postconditions
-    copy_if(other.postconditions, std::back_inserter(postconditions),
-        [&](auto const& p)
-        {
-            return find(postconditions, p) == postconditions.end();
-        });
-}
-
-void
-Javadoc::
-append(std::vector<Polymorphic<doc::Node>>&& blocks)
-{
-    blocks.reserve(blocks.size() + blocks.size());
-    for(auto&& blockAsNode : blocks)
-    {
-        if (auto *Block = dynamic_cast<doc::Block *>(&*blockAsNode))
-        {
-            emplace_back(std::move(*Block));
-        }
-        else
-        {
-            Polymorphic<doc::Node> tmp = std::move(blockAsNode);
-        }
-    }
-}
-
-} // mrdocs
-
diff --git a/src/lib/Metadata/Info/Concept.cpp b/src/lib/Metadata/Symbol/Concept.cpp
similarity index 100%
rename from src/lib/Metadata/Info/Concept.cpp
rename to src/lib/Metadata/Symbol/Concept.cpp
diff --git a/src/lib/Metadata/Info/Enum.cpp b/src/lib/Metadata/Symbol/Enum.cpp
similarity index 100%
rename from src/lib/Metadata/Info/Enum.cpp
rename to src/lib/Metadata/Symbol/Enum.cpp
diff --git a/src/lib/Metadata/Info/EnumConstant.cpp b/src/lib/Metadata/Symbol/EnumConstant.cpp
similarity index 100%
rename from src/lib/Metadata/Info/EnumConstant.cpp
rename to src/lib/Metadata/Symbol/EnumConstant.cpp
diff --git a/src/lib/Metadata/Info/Friend.cpp b/src/lib/Metadata/Symbol/Friend.cpp
similarity index 100%
rename from src/lib/Metadata/Info/Friend.cpp
rename to src/lib/Metadata/Symbol/Friend.cpp
diff --git a/src/lib/Metadata/Info/Function.cpp b/src/lib/Metadata/Symbol/Function.cpp
similarity index 100%
rename from src/lib/Metadata/Info/Function.cpp
rename to src/lib/Metadata/Symbol/Function.cpp
diff --git a/src/lib/Metadata/Info/Guide.cpp b/src/lib/Metadata/Symbol/Guide.cpp
similarity index 100%
rename from src/lib/Metadata/Info/Guide.cpp
rename to src/lib/Metadata/Symbol/Guide.cpp
diff --git a/src/lib/Metadata/Info/Namespace.cpp b/src/lib/Metadata/Symbol/Namespace.cpp
similarity index 100%
rename from src/lib/Metadata/Info/Namespace.cpp
rename to src/lib/Metadata/Symbol/Namespace.cpp
diff --git a/src/lib/Metadata/Info/NamespaceAlias.cpp b/src/lib/Metadata/Symbol/NamespaceAlias.cpp
similarity index 100%
rename from src/lib/Metadata/Info/NamespaceAlias.cpp
rename to src/lib/Metadata/Symbol/NamespaceAlias.cpp
diff --git a/src/lib/Metadata/Info/Overloads.cpp b/src/lib/Metadata/Symbol/Overloads.cpp
similarity index 100%
rename from src/lib/Metadata/Info/Overloads.cpp
rename to src/lib/Metadata/Symbol/Overloads.cpp
diff --git a/src/lib/Metadata/Info/Record.cpp b/src/lib/Metadata/Symbol/Record.cpp
similarity index 100%
rename from src/lib/Metadata/Info/Record.cpp
rename to src/lib/Metadata/Symbol/Record.cpp
diff --git a/src/lib/Metadata/Info/Typedef.cpp b/src/lib/Metadata/Symbol/Typedef.cpp
similarity index 100%
rename from src/lib/Metadata/Info/Typedef.cpp
rename to src/lib/Metadata/Symbol/Typedef.cpp
diff --git a/src/lib/Metadata/Info/Using.cpp b/src/lib/Metadata/Symbol/Using.cpp
similarity index 100%
rename from src/lib/Metadata/Info/Using.cpp
rename to src/lib/Metadata/Symbol/Using.cpp
diff --git a/src/lib/Metadata/Info/Variable.cpp b/src/lib/Metadata/Symbol/Variable.cpp
similarity index 100%
rename from src/lib/Metadata/Info/Variable.cpp
rename to src/lib/Metadata/Symbol/Variable.cpp
diff --git a/src/lib/Support/ExecutionContext.cpp b/src/lib/Support/ExecutionContext.cpp
index b7173e343..ac724cc0e 100644
--- a/src/lib/Support/ExecutionContext.cpp
+++ b/src/lib/Support/ExecutionContext.cpp
@@ -89,7 +89,7 @@ report(
     {
         if (auto infoIt = info_.find(it->id);
             infoIt != info_.end() &&
-            infoIt->get()->javadoc)
+            infoIt->get()->doc)
         {
             it = undocumented_.erase(it);
         }
diff --git a/src/lib/Support/Generator.cpp b/src/lib/Support/Generator.cpp
index 4f4e6ccd0..76f42c761 100644
--- a/src/lib/Support/Generator.cpp
+++ b/src/lib/Support/Generator.cpp
@@ -9,7 +9,7 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
-#include <lib/AST/ParseJavadoc.hpp>
+#include <lib/AST/ExtractDocComment.hpp>
 #include <lib/Support/Chrono.hpp>
 #include <lib/Support/Path.hpp>
 #include <mrdocs/Generator.hpp>
diff --git a/src/lib/Support/Handlebars.cpp b/src/lib/Support/Handlebars.cpp
index cdab1c0b2..115db29f7 100644
--- a/src/lib/Support/Handlebars.cpp
+++ b/src/lib/Support/Handlebars.cpp
@@ -6493,9 +6493,7 @@ registerContainerHelpers(Handlebars& hbs)
                 // whichever has the key
                 auto matchIt = std::ranges::find_if(keys, [&](dom::Value const& key)
                 {
-                    return
-                        el.getObject().exists(key.getString()) &&
-                        el.getObject().get(key.getString()).isTruthy();
+                    return el.lookup(key.getString()).isTruthy();
                 });
                 if (bool const matchAny = matchIt != keys.end();
                     !matchAny)
diff --git a/src/lib/Support/String.cpp b/src/lib/Support/String.cpp
index 479146049..14a68d19f 100644
--- a/src/lib/Support/String.cpp
+++ b/src/lib/Support/String.cpp
@@ -8,7 +8,9 @@
 // Official repository: https://github.com/cppalliance/mrdocs
 //
 
+#include <mrdocs/Support/SplitLines.hpp>
 #include <mrdocs/Support/String.hpp>
+#include <limits>
 
 namespace mrdocs {
 
@@ -25,4 +27,87 @@ replace(std::string& s, std::string_view from, std::string_view to)
     }
 }
 
+namespace {
+// Return true if c is space or tab
+constexpr
+bool
+isSpaceOrTab(char c) noexcept { return c == ' ' || c == '\t'; }
+
+// Return true if s ends with a line break sequence
+constexpr
+bool
+endsWithLineBreak(std::string_view s) noexcept
+{
+    // Recognize if s ends exactly at a line break sequence handled by lbLen
+    for (std::size_t k = 1; k <= 3 && k <= s.size(); ++k)
+    {
+        const std::size_t i = s.size() - k;
+        if (detail::lbLen(s, i) == k) return true;
+    }
+    return false;
+}
+} // namespace
+
+std::string
+reindentCode(std::string_view code, std::size_t indent)
+{
+    auto lines = splitLines(code);
+
+    // 1) Compute common indentation (spaces/tabs) across non-blank lines
+    std::size_t common = std::numeric_limits<std::size_t>::max();
+    bool sawContent = false;
+    for (std::string_view line : lines)
+    {
+        auto it = std::ranges::find_if_not(line, isSpaceOrTab);
+        if (it == line.end())
+        {
+            // blank/whitespace-only -> skip
+            continue;
+        }
+        auto lead = static_cast<std::size_t>(it - line.begin());
+        common = std::min(common, lead);
+        sawContent = true;
+    }
+    if (!sawContent)
+    {
+        // all blank lines -> nothing to do
+        common = 0;
+    }
+
+    // 2) Build output: remove common, add requested indent to non-blank lines
+    std::string out;
+    out.reserve(code.size()); // heuristic; result is often similar size
+    const std::string indentStr(indent, ' ');
+    const bool hadTrailingLB = endsWithLineBreak(code);
+
+    bool first = true;
+    for (std::string_view line : lines) {
+        if (!first)
+        {
+            out.push_back('\n');
+        }
+        first = false;
+
+        // Keep blank lines blank (no added indentation)
+        auto it = std::ranges::find_if_not(line, isSpaceOrTab);
+        if (it == line.end())
+        {
+            // blank -> nothing to append on this line
+            continue;
+        }
+
+        auto lead = static_cast<std::size_t>(it - line.begin());
+        std::size_t remove = std::min(common, lead);
+        std::string_view tail = line.substr(remove);
+
+        out.append(indentStr);
+        out.append(tail.data(), tail.size());
+    }
+    if (hadTrailingLB)
+    {
+        out.push_back('\n');
+    }
+    return out;
+}
+
 } // mrdocs
diff --git a/src/test/ADT/ArrayView.cpp b/src/test/ADT/ArrayView.cpp
new file mode 100644
index 000000000..f287bd2b9
--- /dev/null
+++ b/src/test/ADT/ArrayView.cpp
@@ -0,0 +1,171 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#include <mrdocs/ADT/ArrayView.hpp>
+#include <test_suite/test_suite.hpp>
+
+namespace mrdocs {
+
+struct ArrayViewTest {
+    template <class T>
+    static bool equal(ArrayView<T> v, std::initializer_list<T> il) {
+        if (v.size() != il.size())
+            return false;
+        return std::equal(v.begin(), v.end(), il.begin(), il.end());
+    }
+
+    void
+    run()
+    {
+        // default ctor
+        {
+            ArrayView<int> v;
+            BOOST_TEST(v.empty());
+            BOOST_TEST_EQ(v.size(), 0u);
+            BOOST_TEST(v.begin() == v.end());
+            BOOST_TEST(v.data() == nullptr);
+        }
+
+        // array ctor + deduction guide
+        {
+            int a[] = {1,2,3,4};
+            ArrayView v(a); // CTAD
+            static_assert(std::is_same_v<decltype(v), ArrayView<int>>);
+            BOOST_TEST(!v.empty());
+            BOOST_TEST_EQ(v.size(), 4u);
+            BOOST_TEST_EQ(v.front(), 1);
+            BOOST_TEST_EQ(v.back(), 4);
+            BOOST_TEST(v.data() == a);
+            BOOST_TEST(equal(v, {1,2,3,4}));
+        }
+
+        // pointer + size ctor
+        {
+            int a[] = {10,20,30,40,50};
+            ArrayView<int> v(a + 1, 3);
+            BOOST_TEST_EQ(v.size(), 3u);
+            BOOST_TEST(equal(v, {20,30,40}));
+            BOOST_TEST_EQ(v[0], 20);
+            BOOST_TEST_EQ(v[2], 40);
+        }
+
+        // iterator + count ctor (contiguous iterators)
+        {
+            int a[] = {7,8,9};
+            auto first = a;
+            ArrayView<int> v(first, 2);
+            BOOST_TEST_EQ(v.size(), 2u);
+            BOOST_TEST(equal(v, {7,8}));
+        }
+
+        // iterators and reverse iterators
+        {
+            int a[] = {1,2,3};
+            ArrayView<int> v(a);
+            BOOST_TEST(std::distance(v.begin(), v.end()) == 3);
+            BOOST_TEST(*v.begin() == 1);
+            BOOST_TEST(*(v.end() - 1) == 3);
+
+            auto r = v.rbegin();
+            BOOST_TEST(*r == 3);
+            ++r;
+            BOOST_TEST(*r == 2);
+        }
+
+        // at(), bounds-checked (via assert in debug); just verify value here
+        {
+            int a[] = {11,22};
+            ArrayView<int> v(a);
+            BOOST_TEST_EQ(v.at(0), 11);
+            BOOST_TEST_EQ(v.at(1), 22);
+        }
+
+        // remove_prefix / remove_suffix adjust the view only
+        {
+            int a[] = {1,2,3,4,5};
+            ArrayView<int> v(a);
+            v.remove_prefix(1);
+            BOOST_TEST(equal(v, {2,3,4,5}));
+            v.remove_suffix(2);
+            BOOST_TEST(equal(v, {2,3}));
+        }
+
+        // slice / take_* / drop_* helpers
+        {
+            int a[] = {5,6,7,8,9};
+            ArrayView<int> v(a);
+            auto s1 = v.slice(1, 3);
+            BOOST_TEST(equal(s1, {6,7,8}));
+
+            auto s2 = v.slice(3, ArrayView<int>::npos);
+            BOOST_TEST(equal(s2, {8,9}));
+
+            auto tf = v.take_front(2);
+            BOOST_TEST(equal(tf, {5,6}));
+
+            auto tb = v.take_back(3);
+            BOOST_TEST(equal(tb, {7,8,9}));
+
+            auto df = v.drop_front(4);
+            BOOST_TEST(equal(df, {9}));
+
+            auto db = v.drop_back(5);
+            BOOST_TEST(db.empty());
+        }
+
+        // comparisons: == and <=>
+        {
+            int a[] = {1,2,3};
+            int b[] = {1,2,3};
+            int c[] = {1,2,4};
+            int d[] = {1,2,3,0};
+
+            ArrayView<int> va(a), vb(b), vc(c), vd(d);
+
+            // equality
+            BOOST_TEST(va == vb);
+            BOOST_TEST(!(va == vc));
+
+            // three-way: va vs vc (3 < 4)
+            {
+                auto ord = (va <=> vc);
+                BOOST_TEST(ord == std::strong_ordering::less);
+            }
+            // three-way: vc vs va
+            {
+                auto ord = (vc <=> va);
+                BOOST_TEST(ord == std::strong_ordering::greater);
+            }
+            // prefix vs longer with same prefix: va (3) vs vd (3,0)
+            {
+                auto ord = (va <=> vd);
+                BOOST_TEST(ord == std::strong_ordering::less);
+            }
+            // identical content
+            {
+                auto ord = (va <=> vb);
+                BOOST_TEST(ord == std::strong_ordering::equal);
+            }
+        }
+
+        // data() exposure and aliasing (view must not modify underlying)
+        {
+            int a[] = {42,43};
+            ArrayView<int> v(a);
+            // mutate underlying array; view should reflect it
+            a[1] = 99;
+            BOOST_TEST_EQ(v.back(), 99);
+        }
+    }
+};
+
+TEST_SUITE(ArrayViewTest, "clang.mrdocs.ADT.ArrayView");
+
+} // namespace mrdocs
diff --git a/src/test/ADT/Nullable.cpp b/src/test/ADT/Nullable.cpp
index 54976aa1e..e9d13c734 100644
--- a/src/test/ADT/Nullable.cpp
+++ b/src/test/ADT/Nullable.cpp
@@ -9,11 +9,11 @@
 //
 
 #include <mrdocs/ADT/Nullable.hpp>
+#include <test_suite/test_suite.hpp>
 #include <cmath>
 #include <optional>
 #include <string>
 #include <vector>
-#include <test_suite/test_suite.hpp>
 
 namespace mrdocs {
 
@@ -63,12 +63,12 @@ struct NullableTest {
         static_assert(!HasSentinel<NoTraits>);
 
         // ClearableEmpty: string, vector qualify
-        static_assert(ClearableEmpty<std::string>);
-        static_assert(ClearableEmpty<std::vector<int>>);
+        static_assert(ClearableContainerLike<std::string>);
+        static_assert(ClearableContainerLike<std::vector<int>>);
 
         // ClearableEmpty should NOT hold for primitive or pointer
-        static_assert(!ClearableEmpty<int>);
-        static_assert(!ClearableEmpty<int*>);
+        static_assert(!ClearableContainerLike<int>);
+        static_assert(!ClearableContainerLike<int*>);
 
         // has_nullable_traits_v (the concept) should be true when either
         // sentinel or clearable-empty applies
diff --git a/src/test/ADT/Optional.cpp b/src/test/ADT/Optional.cpp
index 59c7e8c1c..b76b133af 100644
--- a/src/test/ADT/Optional.cpp
+++ b/src/test/ADT/Optional.cpp
@@ -10,9 +10,9 @@
 
 #include <mrdocs/ADT/Optional.hpp>
 #include <mrdocs/Metadata/Symbol/Source.hpp>
+#include <test_suite/test_suite.hpp>
 #include <optional>
 #include <type_traits>
-#include <test_suite/test_suite.hpp>
 
 namespace mrdocs {
 
diff --git a/src/test/Support/Expected.cpp b/src/test/Support/Expected.cpp
index 1bd5ba439..8e7a03a9d 100644
--- a/src/test/Support/Expected.cpp
+++ b/src/test/Support/Expected.cpp
@@ -17,10 +17,10 @@
 //
 
 #include <mrdocs/Support/Expected.hpp>
+#include <test_suite/test_suite.hpp>
 #include <string>
 #include <type_traits>
 #include <utility>
-#include <test_suite/test_suite.hpp>
 
 
 namespace mrdocs {
diff --git a/src/test/Support/JavaScript.cpp b/src/test/Support/JavaScript.cpp
index ab2edbf15..c9edbe9a1 100644
--- a/src/test/Support/JavaScript.cpp
+++ b/src/test/Support/JavaScript.cpp
@@ -10,8 +10,8 @@
 
 #include <mrdocs/Support/Handlebars.hpp>
 #include <mrdocs/Support/JavaScript.hpp>
-#include <array>
 #include <test_suite/test_suite.hpp>
+#include <array>
 
 
 namespace mrdocs {
diff --git a/src/test/TestMain.cpp b/src/test/TestMain.cpp
index d74ef9b91..85fb91df3 100644
--- a/src/test/TestMain.cpp
+++ b/src/test/TestMain.cpp
@@ -16,12 +16,12 @@
 #include <mrdocs/Support/Error.hpp>
 #include <mrdocs/Support/Path.hpp>
 #include <mrdocs/Version.hpp>
+#include <test_suite/test_suite.hpp>
 #include <llvm/Support/FileSystem.h>
 #include <llvm/Support/PrettyStackTrace.h>
 #include <llvm/Support/Signals.h>
 #include <llvm/Support/raw_ostream.h>
 #include <stdlib.h>
-#include <test_suite/test_suite.hpp>
 
 int main(int argc, char const** argv);
 
diff --git a/src/test/TestRunner.cpp b/src/test/TestRunner.cpp
index 150e93cae..13de6b806 100644
--- a/src/test/TestRunner.cpp
+++ b/src/test/TestRunner.cpp
@@ -22,13 +22,13 @@
 #include <mrdocs/Config.hpp>
 #include <mrdocs/Generators.hpp>
 #include <mrdocs/Support/Error.hpp>
+#include <test_suite/diff.hpp>
 #include <llvm/Support/CommandLine.h>
 #include <llvm/Support/FileSystem.h>
 #include <llvm/Support/Path.h>
 #include <llvm/Support/Program.h>
 #include <atomic>
 #include <iostream>
-#include <test_suite/diff.hpp>
 
 namespace mrdocs {
 
diff --git a/src/test/lib/Dom/Dom.cpp b/src/test/lib/Dom/Dom.cpp
index 12686c67e..cc688ab27 100644
--- a/src/test/lib/Dom/Dom.cpp
+++ b/src/test/lib/Dom/Dom.cpp
@@ -9,8 +9,8 @@
 //
 
 #include <mrdocs/Dom.hpp>
-#include <format>
 #include <test_suite/test_suite.hpp>
+#include <format>
 
 
 namespace mrdocs {
diff --git a/src/test/lib/Metadata/Finalizers/Javadoc/parseInlines.cpp b/src/test/lib/Metadata/Finalizers/Javadoc/parseInlines.cpp
new file mode 100644
index 000000000..7e1ffbb4a
--- /dev/null
+++ b/src/test/lib/Metadata/Finalizers/Javadoc/parseInlines.cpp
@@ -0,0 +1,322 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+//
+// Official repository: https://github.com/cppalliance/mrdocs
+//
+
+#include <lib/Metadata/Finalizers/DocComment/parseInlines.hpp>
+#include <test_suite/test_suite.hpp>
+#include <cassert>
+#include <string>
+#include <string_view>
+
+namespace mrdocs {
+namespace {
+
+using namespace doc;
+
+// ---------- helpers to drive the public parser and assert results
+
+std::string
+dumpInline(Inline const& n);
+
+// Dump all children of a container, concatenated
+std::string
+dumpContainer(InlineContainer const& c)
+{
+    std::string r;
+    for (auto const& p: c.children)
+    {
+        r += dumpInline(*p);
+    }
+    return r;
+}
+
+std::string
+esc(std::string const& s)
+{
+    std::string out;
+    out.reserve(s.size());
+    for (char ch: s)
+    {
+        if (ch == '\\')
+        {
+            out += "\\\\";
+        }
+        else if (ch == '"')
+        {
+            out += "\\\"";
+        }
+        else
+        {
+            out += ch;
+        }
+    }
+    return out;
+}
+
+// Dump a single Inline node as a string with its type and key data
+std::string
+dumpInline(Inline const& n)
+{
+    switch (n.Kind)
+    {
+    case InlineKind::Text:
+        return "T(\"" + esc(n.asText().literal) + "\")";
+    case InlineKind::Emph:
+        return "Em{" + dumpContainer(n.asEmph()) + "}";
+    case InlineKind::Strong:
+        return "Str{" + dumpContainer(n.asStrong()) + "}";
+    case InlineKind::Strikethrough:
+        return "Del{" + dumpContainer(n.asStrikethrough()) + "}";
+    case InlineKind::Highlight:
+        return "Mark{" + dumpContainer(n.asHighlight()) + "}";
+    case InlineKind::Superscript:
+        return "Sup{" + dumpContainer(n.asSuperscript()) + "}";
+    case InlineKind::Subscript:
+        return "Sub{" + dumpContainer(n.asSubscript()) + "}";
+    case InlineKind::Code:
+        return "Code{" + dumpContainer(n.asCode()) + "}";
+    case InlineKind::LineBreak:
+        return "BR";
+    case InlineKind::SoftBreak:
+        return "SBR";
+    case InlineKind::Link:
+        return "A(href=\"" + esc(n.asLink().href) + "\"){"
+               + dumpContainer(n.asLink()) + "}";
+    case InlineKind::Image:
+        return "IMG(src=\"" + esc(n.asImage().src) + "\",alt=\""
+               + esc(n.asImage().alt) + "\")";
+    default:
+        // If new kinds appear, fail loudly so tests get updated
+        assert(false && "Unhandled InlineKind in dumpInline");
+        return {};
+    }
+}
+
+std::string
+parse_to_dump(std::string_view in)
+{
+    InlineContainer root;
+    auto res = parse(in.data(), in.data() + in.size(), root);
+    (void) res;
+    return dumpContainer(root);
+}
+
+void
+expect_dump(std::string_view input, std::string_view expect)
+{
+    auto got = parse_to_dump(input);
+    BOOST_TEST_EQ(expect, got);
+}
+
+} // namespace
+
+// ---------------------------------- Tests ------------------------------------
+
+struct parseInlinesTest {
+    void
+    test_plain_and_merge()
+    {
+        // Plain text + merge of consecutive text nodes
+        // Adjacent text from literal degradation should merge too.
+        // This is exercised later.
+        expect_dump("hello world", R"(T("hello world"))");
+    }
+
+    void
+    test_escaping()
+    {
+        // Backslash escapes next char
+        expect_dump(R"(foo\*bar)", R"(T("foo*bar"))");
+        // Two backslashes before special -> one escapes the other
+        expect_dump(R"(foo\\*bar)", R"(T("foo\\*bar"))");
+        expect_dump(R"(*foo)", R"(T("*foo"))");
+        expect_dump(R"(__x)", R"(T("__x"))");
+        expect_dump(R"(~~x)", R"(T("~~x"))");
+    }
+
+    void
+    test_markdown_basic()
+    {
+        expect_dump("*em*", R"(Em{T("em")})");
+        expect_dump("**strong**", R"(Str{T("strong")})");
+        expect_dump("~~strike~~", R"(Del{T("strike")})");
+        expect_dump("==mark==", R"(Mark{T("mark")})");
+        expect_dump("^sup^", R"(Sup{T("sup")})");
+        expect_dump("~sub~", R"(Sub{T("sub")})");
+        expect_dump("`code`", R"(Code{T("code")})");
+
+        // mixed and interleaved with text
+        expect_dump("pre *em* mid **st** end",
+                    R"(T("pre ")Em{T("em")}T(" mid ")Str{T("st")}T(" end"))");
+        expect_dump("a ~~del~~ b ==mark== c ^sup^ d ~sub~ e",
+                    R"(T("a ")Del{T("del")}T(" b ")Mark{T("mark")}T(" c ")Sup{T("sup")}T(" d ")Sub{T("sub")}T(" e"))");
+
+        // nested inline elements
+        expect_dump("**a *b* c**",
+                    R"(Str{T("a ")Em{T("b")}T(" c")})");
+        expect_dump("*em **strong** em*",
+                    R"(Em{T("em ")Str{T("strong")}T(" em")})");
+        expect_dump("~~x ==y== z~~",
+                    R"(Del{T("x ")Mark{T("y")}T(" z")})");
+        expect_dump("**x ~y~ z**",
+                    R"(Str{T("x ")Sub{T("y")}T(" z")})");
+        expect_dump("==m ^s^ n==",
+                    R"(Mark{T("m ")Sup{T("s")}T(" n")})");
+
+        // nested with a barrier inside (markdown code should not parse inner markup)
+        expect_dump("**a `b * c` d**",
+                    R"(Str{T("a ")Code{T("b * c")}T(" d")})");
+    }
+
+    void
+    test_flanking_intraword_rules()
+    {
+        // '_' and '__' are NoIntraWord; shouldn't trigger inside identifiers
+        expect_dump("foo_bar_baz", R"(T("foo_bar_baz"))");
+        expect_dump("foo__bar__baz", R"(T("foo__bar__baz"))");
+
+        // '*' is allowed intraword; still needs flanking
+        expect_dump("foo*bar*", R"(T("foo")Em{T("bar")})");
+
+        // Leading/trailing spaces affect flank
+        // not left-flanking (space after token)
+        expect_dump("* a*", R"(T("* a*"))");
+        // not right-flanking (space before close)
+        expect_dump("*a *", R"(T("*a *"))");
+    }
+
+    void
+    test_barrier_code_span()
+    {
+        // Everything inside backticks is literal text children of Code
+        expect_dump("`a*b_[c]`", R"(Code{T("a*b_[c]")})");
+
+        // Ensure barrier close path: multiple text pushes until matching '`'
+        expect_dump("x`y`z", R"(T("x")Code{T("y")}T("z"))");
+
+        // Unclosed barrier at EOF -> literal fallback of opening + contents
+        expect_dump("pre `code", R"(T("pre `code"))");
+    }
+
+    void
+    test_html_phrasing_and_breaks()
+    {
+        // Simple phrasing tags open/close
+        expect_dump("<em>x</em>", R"(Em{T("x")})");
+        expect_dump("<strong>x</strong>", R"(Str{T("x")})");
+        expect_dump("<code>x</code>", R"(Code{T("x")})");
+        expect_dump("<sub>x</sub>", R"(Sub{T("x")})");
+        expect_dump("<sup>x</sup>", R"(Sup{T("x")})");
+        expect_dump("<del>x</del>", R"(Del{T("x")})");
+        expect_dump("<mark>x</mark>", R"(Mark{T("x")})");
+
+        // <br> becomes hard break
+        expect_dump("a<br>b", R"(T("a")BRT("b"))");
+
+        // Unknown tag -> literal
+        expect_dump("<foo>bar</foo>", R"(T("<foo>bar</foo>"))");
+    }
+
+    void
+    test_html_a_img_attrs()
+    {
+        // <a href>…</a> with content
+        expect_dump("<a href=\"/x\">y</a>", R"(A(href="/x"){T("y")})");
+
+        // Attribute permutations and spaces
+        expect_dump(
+            "<a    href='/p?q=1'   >t</a>",
+            R"(A(href="/p?q=1"){T("t")})");
+
+        // <img> with src/alt, self-contained
+        expect_dump(
+            R"(<img src="/i.png" alt="pic">)",
+            R"(IMG(src="/i.png",alt="pic"))");
+
+        // Missing attributes tolerated → empty strings
+        expect_dump("<img>", R"(IMG(src="",alt=""))");
+    }
+
+    void
+    test_markdown_links_and_images()
+    {
+        // Link: [label](dest)
+        expect_dump("[x](y)", R"(A(href="y"){T("x")})");
+
+        // Quoted destination and title (title ignored in current model, but
+        // path still consumed)
+        expect_dump(R"([x]("/p?q" "t"))", R"(A(href="/p?q"){T("x")})");
+
+        // Image: ![alt](src)
+        expect_dump("![pic](/i.png)", R"(IMG(src="/i.png",alt="pic"))");
+
+        // Invalid: missing closing paren → degrade to literal "[label]"
+        expect_dump("[x](y", R"(T("[")T("x")T("]"))");
+
+        // Unmatched '[' at EOF → literal
+        expect_dump("[unclosed", R"(T("[")T("unclosed")T("]"))");
+
+        // Unmatched '!' '[' at EOF → literal
+        expect_dump("![alt", R"(T("![")T("alt")T("]"))");
+    }
+
+    void
+    test_implicit_close_crossing()
+    {
+        // Strong opened, then emph opened, emph closes, then strong closes
+        // (proper nesting)
+        expect_dump("**a *b* c**", R"(Str{T("a ")Em{T("b")}T(" c")})");
+
+        // Crossing with implicit-close allowed: ~~ can close past * if needed
+        // '*' left unclosed → literal later
+        expect_dump(
+            "~~a *b~~ c*",
+            R"(Del{T("a *b")}T(" c*"))");
+    }
+
+    void
+    test_closing_without_open()
+    {
+        // Lone closing tokens should be literal text because close_to_kind fails
+        // first '**' treated as literal, then '*' parsed
+        expect_dump("**a*b", R"(T("**a*b"))");
+        expect_dump(") stray", R"(T(") stray"))");
+    }
+
+    void
+    test_unclosed_frames_fallback_literal()
+    {
+        // Open emph but never close → literal '*' + contents
+        expect_dump("*x", R"(T("*x"))");
+
+        // Open HTML <em> but never close → literal open + contents
+        // open_tok for HTML containers is "<tag>"
+        expect_dump("<em>x", R"(Em{T("x")})");
+    }
+
+    void
+    run()
+    {
+        test_plain_and_merge();
+        test_escaping();
+        test_markdown_basic();
+        test_flanking_intraword_rules();
+        test_barrier_code_span();
+        test_html_phrasing_and_breaks();
+        test_html_a_img_attrs();
+        test_markdown_links_and_images();
+        test_implicit_close_crossing();
+        test_closing_without_open();
+        test_unclosed_frames_fallback_literal();
+    }
+};
+
+TEST_SUITE(parseInlinesTest, "clang.mrdocs.Metadata.Finalizers.Javadoc.parseInlines");
+
+} // namespace mrdocs
diff --git a/src/test/lib/Support/Handlebars.cpp b/src/test/lib/Support/Handlebars.cpp
index bf7db7957..b54c6a139 100644
--- a/src/test/lib/Support/Handlebars.cpp
+++ b/src/test/lib/Support/Handlebars.cpp
@@ -9,14 +9,14 @@
 #include <mrdocs/Support/Handlebars.hpp>
 #include <mrdocs/Support/Path.hpp>
 #include <mrdocs/Support/String.hpp>
+#include <test_suite/detail/decomposer.hpp>
+#include <test_suite/diff.hpp>
+#include <test_suite/test_suite.hpp>
 #include <llvm/Support/JSON.h>
 #include <llvm/Support/MemoryBuffer.h>
 #include <filesystem>
 #include <format>
 #include <utility>
-#include <test_suite/detail/decomposer.hpp>
-#include <test_suite/diff.hpp>
-#include <test_suite/test_suite.hpp>
 
 
 namespace mrdocs {
@@ -116,10 +116,10 @@ setup_context() const
     page.set("name", "from_chars");
     page.set("decl", "std::from_chars");
     page.set("loc", "charconv");
-    dom::Object javadoc;
-    javadoc.set("brief", "Converts strings to numbers");
-    javadoc.set("details", "This function converts strings to numbers");
-    page.set("javadoc", javadoc);
+    dom::Object doc;
+    doc.set("brief", "Converts strings to numbers");
+    doc.set("details", "This function converts strings to numbers");
+    page.set("doc", doc);
     page.set("synopsis", "This is the from_chars function");
     dom::Object person;
     person.set("firstname", "John");
diff --git a/src/test_suite/test_suite.hpp b/src/test_suite/test_suite.hpp
index 256005fc2..1a41ee773 100644
--- a/src/test_suite/test_suite.hpp
+++ b/src/test_suite/test_suite.hpp
@@ -15,10 +15,10 @@
 #endif
 
 //#include <boost/current_function.hpp>
+#include <test_suite/detail/decomposer.hpp>
 #include <cctype>
 #include <sstream>
 #include <type_traits>
-#include <test_suite/detail/decomposer.hpp>
 
 //  This is a derivative work
 //  Copyright 2002-2018 Peter Dimov
@@ -250,15 +250,15 @@ constexpr detail::log_type log{};
   if (!(static_cast<bool>(__VA_ARGS__)))                         \
   {                                                              \
       DETAIL_START_WARNINGS_SUPPRESSION                          \
-      std::string d = DETAIL_STRINGIFY(__VA_ARGS__);             \
-      d += "\n    (";                                            \
+      std::string detail_boost_test_error_str = DETAIL_STRINGIFY(__VA_ARGS__); \
+      detail_boost_test_error_str += "\n    (";                                \
       DETAIL_SUPPRESS_PARENTHESES_WARNINGS                       \
-      d += (test_suite::detail::decomposer() <= __VA_ARGS__).format(); \
+      detail_boost_test_error_str += (test_suite::detail::decomposer() <= __VA_ARGS__).format(); \
       DETAIL_STOP_WARNINGS_SUPPRESSION                           \
-      d += ")";                                                  \
+      detail_boost_test_error_str += ")";                        \
       return ::test_suite::detail::test_impl(                    \
           false,                                                 \
-          d.data(),                                              \
+          detail_boost_test_error_str.data(),                    \
           "@anon",                                               \
           __FILE__,                                              \
           __LINE__ );                                            \
diff --git a/test-files/golden-tests/config/auto-brief/auto-brief.html b/test-files/golden-tests/config/auto-brief/auto-brief.html
index 85b45bcbe..dc5d44dc3 100644
--- a/test-files/golden-tests/config/auto-brief/auto-brief.html
+++ b/test-files/golden-tests/config/auto-brief/auto-brief.html
@@ -19,37 +19,37 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#copyBriefFromCopyBrief"><code>copyBriefFromCopyBrief</code></a> </td><td><span>This is the explicit brief.</span></td></tr><tr>
-<td><a href="#copyBriefFromExplicitBrief"><code>copyBriefFromExplicitBrief</code></a> </td><td><span>This is the explicit brief.</span></td></tr><tr>
-<td><a href="#copyBriefFromFirstSentenceAsBrief"><code>copyBriefFromFirstSentenceAsBrief</code></a> </td><td><span>This is the brief.</span></td></tr><tr>
-<td><a href="#copyBriefFromFirstValid"><code>copyBriefFromFirstValid</code></a> </td><td><span>This function has documentation but no brief.</span></td></tr><tr>
-<td><a href="#copyDetailsFromCopyBrief"><code>copyDetailsFromCopyBrief</code></a> </td><td><span>Details will be copied</span></td></tr><tr>
-<td><a href="#copyDetailsFromDocNoBrief"><code>copyDetailsFromDocNoBrief</code></a> </td><td><span>Custom brief</span></td></tr><tr>
-<td><a href="#copyDetailsFromExplicitBrief"><code>copyDetailsFromExplicitBrief</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#copyDetailsFromFirstSentenceAsBrief"><code>copyDetailsFromFirstSentenceAsBrief</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#copyDetailsFromNoDoc"><code>copyDetailsFromNoDoc</code></a> </td><td><span>Custom brief</span></td></tr><tr>
-<td><a href="#copyDocFromCopyBrief"><code>copyDocFromCopyBrief</code></a> </td><td><span>This is the explicit brief.</span></td></tr><tr>
-<td><a href="#copyDocFromExplicitBrief"><code>copyDocFromExplicitBrief</code></a> </td><td><span>This is the explicit brief.</span></td></tr><tr>
-<td><a href="#copyDocFromFirstSentenceAsBrief"><code>copyDocFromFirstSentenceAsBrief</code></a> </td><td><span>This is the brief.</span></td></tr><tr>
-<td><a href="#docNoBriefFunction"><code>docNoBriefFunction</code></a> </td><td><span>This function has documentation but no brief.</span></td></tr><tr>
-<td><a href="#explicitBriefFunction"><code>explicitBriefFunction</code></a> </td><td><span>This is the explicit brief.</span></td></tr><tr>
-<td><a href="#explicitBriefFunction2"><code>explicitBriefFunction2</code></a> </td><td><span>This is the explicit brief.</span></td></tr><tr>
-<td><a href="#failCircularReferenceCopyFunction"><code>failCircularReferenceCopyFunction</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#failCircularSourceFunctionA"><code>failCircularSourceFunctionA</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#failCircularSourceFunctionB"><code>failCircularSourceFunctionB</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#failCopyBriefFromDocNoBrief"><code>failCopyBriefFromDocNoBrief</code></a> </td><td><span>This function has documentation but no brief.</span></td></tr><tr>
-<td><a href="#failCopyBriefFromInvalidReference"><code>failCopyBriefFromInvalidReference</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#failCopyBriefFromNoDoc"><code>failCopyBriefFromNoDoc</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#failCopyDetailsFromInvalidReference"><code>failCopyDetailsFromInvalidReference</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#failCopyDocFromDocNoBrief"><code>failCopyDocFromDocNoBrief</code></a> </td><td><span>This function has documentation but no brief.</span></td></tr><tr>
-<td><a href="#failCopyDocFromInvalidReference"><code>failCopyDocFromInvalidReference</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#failCopyDocFromNoDoc"><code>failCopyDocFromNoDoc</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#failInvalidReferenceCopyFunctions"><code>failInvalidReferenceCopyFunctions</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#firstSentenceAsBriefFunction"><code>firstSentenceAsBriefFunction</code></a> </td><td><span>This is the brief.</span></td></tr><tr>
-<td><a href="#noDocFunction"><code>noDocFunction</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#recursiveReferenceCopyFunction"><code>recursiveReferenceCopyFunction</code></a> </td><td><span>Final recursive brief</span></td></tr><tr>
-<td><a href="#recursiveSourceFunctionA"><code>recursiveSourceFunctionA</code></a> </td><td><span>Final recursive brief</span></td></tr><tr>
-<td><a href="#recursiveSourceFunctionB"><code>recursiveSourceFunctionB</code></a> </td><td><span>Final recursive brief</span></td></tr>
+<td><a href="#copyBriefFromCopyBrief"><code>copyBriefFromCopyBrief</code></a> </td><td>This is the explicit brief.</td></tr><tr>
+<td><a href="#copyBriefFromExplicitBrief"><code>copyBriefFromExplicitBrief</code></a> </td><td>This is the explicit brief.</td></tr><tr>
+<td><a href="#copyBriefFromFirstSentenceAsBrief"><code>copyBriefFromFirstSentenceAsBrief</code></a> </td><td>This is the brief.</td></tr><tr>
+<td><a href="#copyBriefFromFirstValid"><code>copyBriefFromFirstValid</code></a> </td><td>This function has documentation but no brief.</td></tr><tr>
+<td><a href="#copyDetailsFromCopyBrief"><code>copyDetailsFromCopyBrief</code></a> </td><td>Details will be copied</td></tr><tr>
+<td><a href="#copyDetailsFromDocNoBrief"><code>copyDetailsFromDocNoBrief</code></a> </td><td>Custom brief</td></tr><tr>
+<td><a href="#copyDetailsFromExplicitBrief"><code>copyDetailsFromExplicitBrief</code></a> </td><td></td></tr><tr>
+<td><a href="#copyDetailsFromFirstSentenceAsBrief"><code>copyDetailsFromFirstSentenceAsBrief</code></a> </td><td></td></tr><tr>
+<td><a href="#copyDetailsFromNoDoc"><code>copyDetailsFromNoDoc</code></a> </td><td>Custom brief</td></tr><tr>
+<td><a href="#copyDocFromCopyBrief"><code>copyDocFromCopyBrief</code></a> </td><td>This is the explicit brief.</td></tr><tr>
+<td><a href="#copyDocFromExplicitBrief"><code>copyDocFromExplicitBrief</code></a> </td><td>This is the explicit brief.</td></tr><tr>
+<td><a href="#copyDocFromFirstSentenceAsBrief"><code>copyDocFromFirstSentenceAsBrief</code></a> </td><td>This is the brief.</td></tr><tr>
+<td><a href="#docNoBriefFunction"><code>docNoBriefFunction</code></a> </td><td>This function has documentation but no brief.</td></tr><tr>
+<td><a href="#explicitBriefFunction"><code>explicitBriefFunction</code></a> </td><td>This is the explicit brief.</td></tr><tr>
+<td><a href="#explicitBriefFunction2"><code>explicitBriefFunction2</code></a> </td><td>This is the explicit brief.</td></tr><tr>
+<td><a href="#failCircularReferenceCopyFunction"><code>failCircularReferenceCopyFunction</code></a> </td><td></td></tr><tr>
+<td><a href="#failCircularSourceFunctionA"><code>failCircularSourceFunctionA</code></a> </td><td></td></tr><tr>
+<td><a href="#failCircularSourceFunctionB"><code>failCircularSourceFunctionB</code></a> </td><td></td></tr><tr>
+<td><a href="#failCopyBriefFromDocNoBrief"><code>failCopyBriefFromDocNoBrief</code></a> </td><td>This function has documentation but no brief.</td></tr><tr>
+<td><a href="#failCopyBriefFromInvalidReference"><code>failCopyBriefFromInvalidReference</code></a> </td><td></td></tr><tr>
+<td><a href="#failCopyBriefFromNoDoc"><code>failCopyBriefFromNoDoc</code></a> </td><td></td></tr><tr>
+<td><a href="#failCopyDetailsFromInvalidReference"><code>failCopyDetailsFromInvalidReference</code></a> </td><td></td></tr><tr>
+<td><a href="#failCopyDocFromDocNoBrief"><code>failCopyDocFromDocNoBrief</code></a> </td><td>This function has documentation but no brief.</td></tr><tr>
+<td><a href="#failCopyDocFromInvalidReference"><code>failCopyDocFromInvalidReference</code></a> </td><td></td></tr><tr>
+<td><a href="#failCopyDocFromNoDoc"><code>failCopyDocFromNoDoc</code></a> </td><td></td></tr><tr>
+<td><a href="#failInvalidReferenceCopyFunctions"><code>failInvalidReferenceCopyFunctions</code></a> </td><td></td></tr><tr>
+<td><a href="#firstSentenceAsBriefFunction"><code>firstSentenceAsBriefFunction</code></a> </td><td>This is the brief.</td></tr><tr>
+<td><a href="#noDocFunction"><code>noDocFunction</code></a> </td><td></td></tr><tr>
+<td><a href="#recursiveReferenceCopyFunction"><code>recursiveReferenceCopyFunction</code></a> </td><td>Final recursive brief</td></tr><tr>
+<td><a href="#recursiveSourceFunctionA"><code>recursiveSourceFunctionA</code></a> </td><td>Final recursive brief</td></tr><tr>
+<td><a href="#recursiveSourceFunctionB"><code>recursiveSourceFunctionB</code></a> </td><td>Final recursive brief</td></tr>
 </tbody>
 </table>
 
@@ -58,8 +58,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="copyBriefFromCopyBrief">copyBriefFromCopyBrief</h2>
 <div>
-<span>This is the explicit brief.</span>
-
+<p>This is the explicit brief.</p>
 </div>
 </div>
 <div>
@@ -68,9 +67,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyBriefFromCopyBrief();
-
-</code>
+copyBriefFromCopyBrief();</code>
 </pre>
 </div>
 </div>
@@ -78,8 +75,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="copyBriefFromExplicitBrief">copyBriefFromExplicitBrief</h2>
 <div>
-<span>This is the explicit brief.</span>
-
+<p>This is the explicit brief.</p>
 </div>
 </div>
 <div>
@@ -88,9 +84,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyBriefFromExplicitBrief();
-
-</code>
+copyBriefFromExplicitBrief();</code>
 </pre>
 </div>
 </div>
@@ -98,8 +92,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="copyBriefFromFirstSentenceAsBrief">copyBriefFromFirstSentenceAsBrief</h2>
 <div>
-<span>This is the brief.</span>
-
+<p>This is the brief.</p>
 </div>
 </div>
 <div>
@@ -108,9 +101,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyBriefFromFirstSentenceAsBrief();
-
-</code>
+copyBriefFromFirstSentenceAsBrief();</code>
 </pre>
 </div>
 </div>
@@ -118,8 +109,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="copyBriefFromFirstValid">copyBriefFromFirstValid</h2>
 <div>
-<span>This function has documentation but no brief.</span>
-
+<p>This function has documentation but no brief.</p>
 </div>
 </div>
 <div>
@@ -128,9 +118,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyBriefFromFirstValid();
-
-</code>
+copyBriefFromFirstValid();</code>
 </pre>
 </div>
 </div>
@@ -138,8 +126,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="copyDetailsFromCopyBrief">copyDetailsFromCopyBrief</h2>
 <div>
-<span>Details will be copied</span>
-
+<p>Details will be copied</p>
 </div>
 </div>
 <div>
@@ -148,9 +135,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyDetailsFromCopyBrief();
-
-</code>
+copyDetailsFromCopyBrief();</code>
 </pre>
 </div>
 </div>
@@ -158,8 +143,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="copyDetailsFromDocNoBrief">copyDetailsFromDocNoBrief</h2>
 <div>
-<span>Custom brief</span>
-
+<p>Custom brief</p>
 </div>
 </div>
 <div>
@@ -168,9 +152,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyDetailsFromDocNoBrief();
-
-</code>
+copyDetailsFromDocNoBrief();</code>
 </pre>
 </div>
 </div>
@@ -184,9 +166,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyDetailsFromExplicitBrief();
-
-</code>
+copyDetailsFromExplicitBrief();</code>
 </pre>
 </div>
 <div>
@@ -204,9 +184,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyDetailsFromFirstSentenceAsBrief();
-
-</code>
+copyDetailsFromFirstSentenceAsBrief();</code>
 </pre>
 </div>
 <div>
@@ -218,8 +196,7 @@ <h3>Description</h3>
 <div>
 <h2 id="copyDetailsFromNoDoc">copyDetailsFromNoDoc</h2>
 <div>
-<span>Custom brief</span>
-
+<p>Custom brief</p>
 </div>
 </div>
 <div>
@@ -228,9 +205,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyDetailsFromNoDoc();
-
-</code>
+copyDetailsFromNoDoc();</code>
 </pre>
 </div>
 </div>
@@ -238,8 +213,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="copyDocFromCopyBrief">copyDocFromCopyBrief</h2>
 <div>
-<span>This is the explicit brief.</span>
-
+<p>This is the explicit brief.</p>
 </div>
 </div>
 <div>
@@ -248,9 +222,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyDocFromCopyBrief();
-
-</code>
+copyDocFromCopyBrief();</code>
 </pre>
 </div>
 <div>
@@ -262,8 +234,7 @@ <h3>Description</h3>
 <div>
 <h2 id="copyDocFromExplicitBrief">copyDocFromExplicitBrief</h2>
 <div>
-<span>This is the explicit brief.</span>
-
+<p>This is the explicit brief.</p>
 </div>
 </div>
 <div>
@@ -272,9 +243,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyDocFromExplicitBrief();
-
-</code>
+copyDocFromExplicitBrief();</code>
 </pre>
 </div>
 <div>
@@ -286,8 +255,7 @@ <h3>Description</h3>
 <div>
 <h2 id="copyDocFromFirstSentenceAsBrief">copyDocFromFirstSentenceAsBrief</h2>
 <div>
-<span>This is the brief.</span>
-
+<p>This is the brief.</p>
 </div>
 </div>
 <div>
@@ -296,9 +264,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyDocFromFirstSentenceAsBrief();
-
-</code>
+copyDocFromFirstSentenceAsBrief();</code>
 </pre>
 </div>
 <div>
@@ -310,8 +276,7 @@ <h3>Description</h3>
 <div>
 <h2 id="docNoBriefFunction">docNoBriefFunction</h2>
 <div>
-<span>This function has documentation but no brief.</span>
-
+<p>This function has documentation but no brief.</p>
 </div>
 </div>
 <div>
@@ -320,9 +285,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-docNoBriefFunction();
-
-</code>
+docNoBriefFunction();</code>
 </pre>
 </div>
 </div>
@@ -330,8 +293,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="explicitBriefFunction">explicitBriefFunction</h2>
 <div>
-<span>This is the explicit brief.</span>
-
+<p>This is the explicit brief.</p>
 </div>
 </div>
 <div>
@@ -340,9 +302,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-explicitBriefFunction();
-
-</code>
+explicitBriefFunction();</code>
 </pre>
 </div>
 <div>
@@ -354,8 +314,7 @@ <h3>Description</h3>
 <div>
 <h2 id="explicitBriefFunction2">explicitBriefFunction2</h2>
 <div>
-<span>This is the explicit brief.</span>
-
+<p>This is the explicit brief.</p>
 </div>
 </div>
 <div>
@@ -364,9 +323,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-explicitBriefFunction2();
-
-</code>
+explicitBriefFunction2();</code>
 </pre>
 </div>
 <div>
@@ -384,9 +341,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCircularReferenceCopyFunction();
-
-</code>
+failCircularReferenceCopyFunction();</code>
 </pre>
 </div>
 </div>
@@ -400,9 +355,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCircularSourceFunctionA();
-
-</code>
+failCircularSourceFunctionA();</code>
 </pre>
 </div>
 </div>
@@ -416,9 +369,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCircularSourceFunctionB();
-
-</code>
+failCircularSourceFunctionB();</code>
 </pre>
 </div>
 </div>
@@ -426,8 +377,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="failCopyBriefFromDocNoBrief">failCopyBriefFromDocNoBrief</h2>
 <div>
-<span>This function has documentation but no brief.</span>
-
+<p>This function has documentation but no brief.</p>
 </div>
 </div>
 <div>
@@ -436,9 +386,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCopyBriefFromDocNoBrief();
-
-</code>
+failCopyBriefFromDocNoBrief();</code>
 </pre>
 </div>
 </div>
@@ -452,9 +400,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCopyBriefFromInvalidReference();
-
-</code>
+failCopyBriefFromInvalidReference();</code>
 </pre>
 </div>
 </div>
@@ -468,9 +414,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCopyBriefFromNoDoc();
-
-</code>
+failCopyBriefFromNoDoc();</code>
 </pre>
 </div>
 </div>
@@ -484,9 +428,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCopyDetailsFromInvalidReference();
-
-</code>
+failCopyDetailsFromInvalidReference();</code>
 </pre>
 </div>
 </div>
@@ -494,8 +436,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="failCopyDocFromDocNoBrief">failCopyDocFromDocNoBrief</h2>
 <div>
-<span>This function has documentation but no brief.</span>
-
+<p>This function has documentation but no brief.</p>
 </div>
 </div>
 <div>
@@ -504,9 +445,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCopyDocFromDocNoBrief();
-
-</code>
+failCopyDocFromDocNoBrief();</code>
 </pre>
 </div>
 </div>
@@ -520,9 +459,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCopyDocFromInvalidReference();
-
-</code>
+failCopyDocFromInvalidReference();</code>
 </pre>
 </div>
 </div>
@@ -536,9 +473,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCopyDocFromNoDoc();
-
-</code>
+failCopyDocFromNoDoc();</code>
 </pre>
 </div>
 </div>
@@ -552,9 +487,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failInvalidReferenceCopyFunctions();
-
-</code>
+failInvalidReferenceCopyFunctions();</code>
 </pre>
 </div>
 </div>
@@ -562,8 +495,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="firstSentenceAsBriefFunction">firstSentenceAsBriefFunction</h2>
 <div>
-<span>This is the brief.</span>
-
+<p>This is the brief.</p>
 </div>
 </div>
 <div>
@@ -572,9 +504,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-firstSentenceAsBriefFunction();
-
-</code>
+firstSentenceAsBriefFunction();</code>
 </pre>
 </div>
 <div>
@@ -592,9 +522,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-noDocFunction();
-
-</code>
+noDocFunction();</code>
 </pre>
 </div>
 </div>
@@ -602,8 +530,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="recursiveReferenceCopyFunction">recursiveReferenceCopyFunction</h2>
 <div>
-<span>Final recursive brief</span>
-
+<p>Final recursive brief</p>
 </div>
 </div>
 <div>
@@ -612,9 +539,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-recursiveReferenceCopyFunction();
-
-</code>
+recursiveReferenceCopyFunction();</code>
 </pre>
 </div>
 </div>
@@ -622,8 +547,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="recursiveSourceFunctionA">recursiveSourceFunctionA</h2>
 <div>
-<span>Final recursive brief</span>
-
+<p>Final recursive brief</p>
 </div>
 </div>
 <div>
@@ -632,9 +556,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-recursiveSourceFunctionA();
-
-</code>
+recursiveSourceFunctionA();</code>
 </pre>
 </div>
 </div>
@@ -642,8 +564,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="recursiveSourceFunctionB">recursiveSourceFunctionB</h2>
 <div>
-<span>Final recursive brief</span>
-
+<p>Final recursive brief</p>
 </div>
 </div>
 <div>
@@ -652,9 +573,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-recursiveSourceFunctionB();
-
-</code>
+recursiveSourceFunctionB();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/auto-brief/auto-brief.xml b/test-files/golden-tests/config/auto-brief/auto-brief.xml
index a53007dee..359691cbd 100644
--- a/test-files/golden-tests/config/auto-brief/auto-brief.xml
+++ b/test-files/golden-tests/config/auto-brief/auto-brief.xml
@@ -139,24 +139,12 @@
   </function>
   <function name="failCircularReferenceCopyFunction" id="/W9Gcu/9mPpmnlcLzqb07fE5NfU=">
     <file short-path="auto-brief.cpp" source-path="auto-brief.cpp" line="175"/>
-    <doc>
-      <brief>
-      </brief>
-    </doc>
   </function>
   <function name="failCircularSourceFunctionA" id="w0nnzgrgQArkJmBNTMgQndCvLEY=">
     <file short-path="auto-brief.cpp" source-path="auto-brief.cpp" line="165"/>
-    <doc>
-      <brief>
-      </brief>
-    </doc>
   </function>
   <function name="failCircularSourceFunctionB" id="DLgwr/zhr5/zU7XTTW0xwbX8xDk=">
     <file short-path="auto-brief.cpp" source-path="auto-brief.cpp" line="170"/>
-    <doc>
-      <brief>
-      </brief>
-    </doc>
   </function>
   <function name="failCopyBriefFromDocNoBrief" id="4XIirlBtHiS1Bj+U07f22Hbf6xo=">
     <file short-path="auto-brief.cpp" source-path="auto-brief.cpp" line="43"/>
@@ -168,22 +156,12 @@
   </function>
   <function name="failCopyBriefFromInvalidReference" id="IV37E8LGcb3UZ4VcCoFGoFRXMAA=">
     <file short-path="auto-brief.cpp" source-path="auto-brief.cpp" line="65"/>
-    <doc>
-      <brief>
-      </brief>
-    </doc>
   </function>
   <function name="failCopyBriefFromNoDoc" id="nfm5DhGLP53urgKVUj7/azRbGiU=">
     <file short-path="auto-brief.cpp" source-path="auto-brief.cpp" line="38"/>
-    <doc>
-      <brief>
-      </brief>
-    </doc>
   </function>
   <function name="failCopyDetailsFromInvalidReference" id="y3EB6VotLcEDqzU5ye611iQpd08=">
     <file short-path="auto-brief.cpp" source-path="auto-brief.cpp" line="98"/>
-    <doc>
-    </doc>
   </function>
   <function name="failCopyDocFromDocNoBrief" id="+OInO9eRUKfg4w7+GGNQIRlBYDQ=">
     <file short-path="auto-brief.cpp" source-path="auto-brief.cpp" line="115"/>
@@ -195,24 +173,12 @@
   </function>
   <function name="failCopyDocFromInvalidReference" id="QQUSujFeIVZnajdM74smV6sAtdw=">
     <file short-path="auto-brief.cpp" source-path="auto-brief.cpp" line="130"/>
-    <doc>
-      <brief>
-      </brief>
-    </doc>
   </function>
   <function name="failCopyDocFromNoDoc" id="pMmcF/A3wZTg9BwAWar3xDZO3o0=">
     <file short-path="auto-brief.cpp" source-path="auto-brief.cpp" line="110"/>
-    <doc>
-      <brief>
-      </brief>
-    </doc>
   </function>
   <function name="failInvalidReferenceCopyFunctions" id="Je9QqhEaYHLFVdcnYkfNWXAGjJw=">
     <file short-path="auto-brief.cpp" source-path="auto-brief.cpp" line="143"/>
-    <doc>
-      <brief>
-      </brief>
-    </doc>
   </function>
   <function name="firstSentenceAsBriefFunction" id="EQ4aeACGgJCKgpkBFTm+KrTKM08=">
     <file short-path="auto-brief.cpp" source-path="auto-brief.cpp" line="32"/>
diff --git a/test-files/golden-tests/config/auto-brief/no-auto-brief.html b/test-files/golden-tests/config/auto-brief/no-auto-brief.html
index 9e0553b81..ef3572b66 100644
--- a/test-files/golden-tests/config/auto-brief/no-auto-brief.html
+++ b/test-files/golden-tests/config/auto-brief/no-auto-brief.html
@@ -19,37 +19,37 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#copyBriefFromCopyBrief"><code>copyBriefFromCopyBrief</code></a> </td><td><span>This is the explicit brief.</span></td></tr><tr>
-<td><a href="#copyBriefFromExplicitBrief"><code>copyBriefFromExplicitBrief</code></a> </td><td><span>This is the explicit brief.</span></td></tr><tr>
-<td><a href="#copyBriefFromFirstSentenceAsBrief"><code>copyBriefFromFirstSentenceAsBrief</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#copyBriefFromFirstValid"><code>copyBriefFromFirstValid</code></a> </td><td><span>This is the explicit brief.</span></td></tr><tr>
-<td><a href="#copyDetailsFromCopyBrief"><code>copyDetailsFromCopyBrief</code></a> </td><td><span>Details will be copied</span></td></tr><tr>
-<td><a href="#copyDetailsFromDocNoBrief"><code>copyDetailsFromDocNoBrief</code></a> </td><td><span>Custom brief</span></td></tr><tr>
-<td><a href="#copyDetailsFromExplicitBrief"><code>copyDetailsFromExplicitBrief</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#copyDetailsFromFirstSentenceAsBrief"><code>copyDetailsFromFirstSentenceAsBrief</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#copyDetailsFromNoDoc"><code>copyDetailsFromNoDoc</code></a> </td><td><span>Custom brief</span></td></tr><tr>
-<td><a href="#copyDocFromCopyBrief"><code>copyDocFromCopyBrief</code></a> </td><td><span>This is the explicit brief.</span></td></tr><tr>
-<td><a href="#copyDocFromExplicitBrief"><code>copyDocFromExplicitBrief</code></a> </td><td><span>This is the explicit brief.</span></td></tr><tr>
-<td><a href="#copyDocFromFirstSentenceAsBrief"><code>copyDocFromFirstSentenceAsBrief</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#docNoBriefFunction"><code>docNoBriefFunction</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#explicitBriefFunction"><code>explicitBriefFunction</code></a> </td><td><span>This is the explicit brief.</span></td></tr><tr>
-<td><a href="#explicitBriefFunction2"><code>explicitBriefFunction2</code></a> </td><td><span>This is the explicit brief.</span></td></tr><tr>
-<td><a href="#failCircularReferenceCopyFunction"><code>failCircularReferenceCopyFunction</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#failCircularSourceFunctionA"><code>failCircularSourceFunctionA</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#failCircularSourceFunctionB"><code>failCircularSourceFunctionB</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#failCopyBriefFromDocNoBrief"><code>failCopyBriefFromDocNoBrief</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#failCopyBriefFromInvalidReference"><code>failCopyBriefFromInvalidReference</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#failCopyBriefFromNoDoc"><code>failCopyBriefFromNoDoc</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#failCopyDetailsFromInvalidReference"><code>failCopyDetailsFromInvalidReference</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#failCopyDocFromDocNoBrief"><code>failCopyDocFromDocNoBrief</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#failCopyDocFromInvalidReference"><code>failCopyDocFromInvalidReference</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#failCopyDocFromNoDoc"><code>failCopyDocFromNoDoc</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#failInvalidReferenceCopyFunctions"><code>failInvalidReferenceCopyFunctions</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#firstSentenceAsBriefFunction"><code>firstSentenceAsBriefFunction</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#noDocFunction"><code>noDocFunction</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#recursiveReferenceCopyFunction"><code>recursiveReferenceCopyFunction</code></a> </td><td><span>Final recursive brief</span></td></tr><tr>
-<td><a href="#recursiveSourceFunctionA"><code>recursiveSourceFunctionA</code></a> </td><td><span>Final recursive brief</span></td></tr><tr>
-<td><a href="#recursiveSourceFunctionB"><code>recursiveSourceFunctionB</code></a> </td><td><span>Final recursive brief</span></td></tr>
+<td><a href="#copyBriefFromCopyBrief"><code>copyBriefFromCopyBrief</code></a> </td><td>This is the explicit brief.</td></tr><tr>
+<td><a href="#copyBriefFromExplicitBrief"><code>copyBriefFromExplicitBrief</code></a> </td><td>This is the explicit brief.</td></tr><tr>
+<td><a href="#copyBriefFromFirstSentenceAsBrief"><code>copyBriefFromFirstSentenceAsBrief</code></a> </td><td></td></tr><tr>
+<td><a href="#copyBriefFromFirstValid"><code>copyBriefFromFirstValid</code></a> </td><td>This is the explicit brief.</td></tr><tr>
+<td><a href="#copyDetailsFromCopyBrief"><code>copyDetailsFromCopyBrief</code></a> </td><td>Details will be copied</td></tr><tr>
+<td><a href="#copyDetailsFromDocNoBrief"><code>copyDetailsFromDocNoBrief</code></a> </td><td>Custom brief</td></tr><tr>
+<td><a href="#copyDetailsFromExplicitBrief"><code>copyDetailsFromExplicitBrief</code></a> </td><td></td></tr><tr>
+<td><a href="#copyDetailsFromFirstSentenceAsBrief"><code>copyDetailsFromFirstSentenceAsBrief</code></a> </td><td></td></tr><tr>
+<td><a href="#copyDetailsFromNoDoc"><code>copyDetailsFromNoDoc</code></a> </td><td>Custom brief</td></tr><tr>
+<td><a href="#copyDocFromCopyBrief"><code>copyDocFromCopyBrief</code></a> </td><td>This is the explicit brief.</td></tr><tr>
+<td><a href="#copyDocFromExplicitBrief"><code>copyDocFromExplicitBrief</code></a> </td><td>This is the explicit brief.</td></tr><tr>
+<td><a href="#copyDocFromFirstSentenceAsBrief"><code>copyDocFromFirstSentenceAsBrief</code></a> </td><td></td></tr><tr>
+<td><a href="#docNoBriefFunction"><code>docNoBriefFunction</code></a> </td><td></td></tr><tr>
+<td><a href="#explicitBriefFunction"><code>explicitBriefFunction</code></a> </td><td>This is the explicit brief.</td></tr><tr>
+<td><a href="#explicitBriefFunction2"><code>explicitBriefFunction2</code></a> </td><td>This is the explicit brief.</td></tr><tr>
+<td><a href="#failCircularReferenceCopyFunction"><code>failCircularReferenceCopyFunction</code></a> </td><td></td></tr><tr>
+<td><a href="#failCircularSourceFunctionA"><code>failCircularSourceFunctionA</code></a> </td><td></td></tr><tr>
+<td><a href="#failCircularSourceFunctionB"><code>failCircularSourceFunctionB</code></a> </td><td></td></tr><tr>
+<td><a href="#failCopyBriefFromDocNoBrief"><code>failCopyBriefFromDocNoBrief</code></a> </td><td></td></tr><tr>
+<td><a href="#failCopyBriefFromInvalidReference"><code>failCopyBriefFromInvalidReference</code></a> </td><td></td></tr><tr>
+<td><a href="#failCopyBriefFromNoDoc"><code>failCopyBriefFromNoDoc</code></a> </td><td></td></tr><tr>
+<td><a href="#failCopyDetailsFromInvalidReference"><code>failCopyDetailsFromInvalidReference</code></a> </td><td></td></tr><tr>
+<td><a href="#failCopyDocFromDocNoBrief"><code>failCopyDocFromDocNoBrief</code></a> </td><td></td></tr><tr>
+<td><a href="#failCopyDocFromInvalidReference"><code>failCopyDocFromInvalidReference</code></a> </td><td></td></tr><tr>
+<td><a href="#failCopyDocFromNoDoc"><code>failCopyDocFromNoDoc</code></a> </td><td></td></tr><tr>
+<td><a href="#failInvalidReferenceCopyFunctions"><code>failInvalidReferenceCopyFunctions</code></a> </td><td></td></tr><tr>
+<td><a href="#firstSentenceAsBriefFunction"><code>firstSentenceAsBriefFunction</code></a> </td><td></td></tr><tr>
+<td><a href="#noDocFunction"><code>noDocFunction</code></a> </td><td></td></tr><tr>
+<td><a href="#recursiveReferenceCopyFunction"><code>recursiveReferenceCopyFunction</code></a> </td><td>Final recursive brief</td></tr><tr>
+<td><a href="#recursiveSourceFunctionA"><code>recursiveSourceFunctionA</code></a> </td><td>Final recursive brief</td></tr><tr>
+<td><a href="#recursiveSourceFunctionB"><code>recursiveSourceFunctionB</code></a> </td><td>Final recursive brief</td></tr>
 </tbody>
 </table>
 
@@ -58,8 +58,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="copyBriefFromCopyBrief">copyBriefFromCopyBrief</h2>
 <div>
-<span>This is the explicit brief.</span>
-
+<p>This is the explicit brief.</p>
 </div>
 </div>
 <div>
@@ -68,9 +67,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyBriefFromCopyBrief();
-
-</code>
+copyBriefFromCopyBrief();</code>
 </pre>
 </div>
 </div>
@@ -78,8 +75,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="copyBriefFromExplicitBrief">copyBriefFromExplicitBrief</h2>
 <div>
-<span>This is the explicit brief.</span>
-
+<p>This is the explicit brief.</p>
 </div>
 </div>
 <div>
@@ -88,9 +84,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyBriefFromExplicitBrief();
-
-</code>
+copyBriefFromExplicitBrief();</code>
 </pre>
 </div>
 </div>
@@ -104,9 +98,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyBriefFromFirstSentenceAsBrief();
-
-</code>
+copyBriefFromFirstSentenceAsBrief();</code>
 </pre>
 </div>
 </div>
@@ -114,8 +106,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="copyBriefFromFirstValid">copyBriefFromFirstValid</h2>
 <div>
-<span>This is the explicit brief.</span>
-
+<p>This is the explicit brief.</p>
 </div>
 </div>
 <div>
@@ -124,9 +115,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyBriefFromFirstValid();
-
-</code>
+copyBriefFromFirstValid();</code>
 </pre>
 </div>
 </div>
@@ -134,8 +123,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="copyDetailsFromCopyBrief">copyDetailsFromCopyBrief</h2>
 <div>
-<span>Details will be copied</span>
-
+<p>Details will be copied</p>
 </div>
 </div>
 <div>
@@ -144,9 +132,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyDetailsFromCopyBrief();
-
-</code>
+copyDetailsFromCopyBrief();</code>
 </pre>
 </div>
 </div>
@@ -154,8 +140,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="copyDetailsFromDocNoBrief">copyDetailsFromDocNoBrief</h2>
 <div>
-<span>Custom brief</span>
-
+<p>Custom brief</p>
 </div>
 </div>
 <div>
@@ -164,9 +149,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyDetailsFromDocNoBrief();
-
-</code>
+copyDetailsFromDocNoBrief();</code>
 </pre>
 </div>
 </div>
@@ -180,9 +163,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyDetailsFromExplicitBrief();
-
-</code>
+copyDetailsFromExplicitBrief();</code>
 </pre>
 </div>
 <div>
@@ -200,9 +181,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyDetailsFromFirstSentenceAsBrief();
-
-</code>
+copyDetailsFromFirstSentenceAsBrief();</code>
 </pre>
 </div>
 <div>
@@ -215,8 +194,7 @@ <h3>Description</h3>
 <div>
 <h2 id="copyDetailsFromNoDoc">copyDetailsFromNoDoc</h2>
 <div>
-<span>Custom brief</span>
-
+<p>Custom brief</p>
 </div>
 </div>
 <div>
@@ -225,9 +203,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyDetailsFromNoDoc();
-
-</code>
+copyDetailsFromNoDoc();</code>
 </pre>
 </div>
 </div>
@@ -235,8 +211,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="copyDocFromCopyBrief">copyDocFromCopyBrief</h2>
 <div>
-<span>This is the explicit brief.</span>
-
+<p>This is the explicit brief.</p>
 </div>
 </div>
 <div>
@@ -245,9 +220,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyDocFromCopyBrief();
-
-</code>
+copyDocFromCopyBrief();</code>
 </pre>
 </div>
 <div>
@@ -259,8 +232,7 @@ <h3>Description</h3>
 <div>
 <h2 id="copyDocFromExplicitBrief">copyDocFromExplicitBrief</h2>
 <div>
-<span>This is the explicit brief.</span>
-
+<p>This is the explicit brief.</p>
 </div>
 </div>
 <div>
@@ -269,9 +241,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyDocFromExplicitBrief();
-
-</code>
+copyDocFromExplicitBrief();</code>
 </pre>
 </div>
 <div>
@@ -289,9 +259,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-copyDocFromFirstSentenceAsBrief();
-
-</code>
+copyDocFromFirstSentenceAsBrief();</code>
 </pre>
 </div>
 <div>
@@ -310,9 +278,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-docNoBriefFunction();
-
-</code>
+docNoBriefFunction();</code>
 </pre>
 </div>
 <div>
@@ -324,8 +290,7 @@ <h3>Description</h3>
 <div>
 <h2 id="explicitBriefFunction">explicitBriefFunction</h2>
 <div>
-<span>This is the explicit brief.</span>
-
+<p>This is the explicit brief.</p>
 </div>
 </div>
 <div>
@@ -334,9 +299,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-explicitBriefFunction();
-
-</code>
+explicitBriefFunction();</code>
 </pre>
 </div>
 <div>
@@ -348,8 +311,7 @@ <h3>Description</h3>
 <div>
 <h2 id="explicitBriefFunction2">explicitBriefFunction2</h2>
 <div>
-<span>This is the explicit brief.</span>
-
+<p>This is the explicit brief.</p>
 </div>
 </div>
 <div>
@@ -358,9 +320,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-explicitBriefFunction2();
-
-</code>
+explicitBriefFunction2();</code>
 </pre>
 </div>
 <div>
@@ -378,9 +338,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCircularReferenceCopyFunction();
-
-</code>
+failCircularReferenceCopyFunction();</code>
 </pre>
 </div>
 </div>
@@ -394,9 +352,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCircularSourceFunctionA();
-
-</code>
+failCircularSourceFunctionA();</code>
 </pre>
 </div>
 </div>
@@ -410,9 +366,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCircularSourceFunctionB();
-
-</code>
+failCircularSourceFunctionB();</code>
 </pre>
 </div>
 </div>
@@ -426,9 +380,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCopyBriefFromDocNoBrief();
-
-</code>
+failCopyBriefFromDocNoBrief();</code>
 </pre>
 </div>
 </div>
@@ -442,9 +394,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCopyBriefFromInvalidReference();
-
-</code>
+failCopyBriefFromInvalidReference();</code>
 </pre>
 </div>
 </div>
@@ -458,9 +408,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCopyBriefFromNoDoc();
-
-</code>
+failCopyBriefFromNoDoc();</code>
 </pre>
 </div>
 </div>
@@ -474,9 +422,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCopyDetailsFromInvalidReference();
-
-</code>
+failCopyDetailsFromInvalidReference();</code>
 </pre>
 </div>
 </div>
@@ -490,9 +436,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCopyDocFromDocNoBrief();
-
-</code>
+failCopyDocFromDocNoBrief();</code>
 </pre>
 </div>
 <div>
@@ -510,9 +454,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCopyDocFromInvalidReference();
-
-</code>
+failCopyDocFromInvalidReference();</code>
 </pre>
 </div>
 </div>
@@ -526,9 +468,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failCopyDocFromNoDoc();
-
-</code>
+failCopyDocFromNoDoc();</code>
 </pre>
 </div>
 </div>
@@ -542,9 +482,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-failInvalidReferenceCopyFunctions();
-
-</code>
+failInvalidReferenceCopyFunctions();</code>
 </pre>
 </div>
 </div>
@@ -558,9 +496,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-firstSentenceAsBriefFunction();
-
-</code>
+firstSentenceAsBriefFunction();</code>
 </pre>
 </div>
 <div>
@@ -579,9 +515,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-noDocFunction();
-
-</code>
+noDocFunction();</code>
 </pre>
 </div>
 </div>
@@ -589,8 +523,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="recursiveReferenceCopyFunction">recursiveReferenceCopyFunction</h2>
 <div>
-<span>Final recursive brief</span>
-
+<p>Final recursive brief</p>
 </div>
 </div>
 <div>
@@ -599,9 +532,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-recursiveReferenceCopyFunction();
-
-</code>
+recursiveReferenceCopyFunction();</code>
 </pre>
 </div>
 </div>
@@ -609,8 +540,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="recursiveSourceFunctionA">recursiveSourceFunctionA</h2>
 <div>
-<span>Final recursive brief</span>
-
+<p>Final recursive brief</p>
 </div>
 </div>
 <div>
@@ -619,9 +549,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-recursiveSourceFunctionA();
-
-</code>
+recursiveSourceFunctionA();</code>
 </pre>
 </div>
 </div>
@@ -629,8 +557,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="recursiveSourceFunctionB">recursiveSourceFunctionB</h2>
 <div>
-<span>Final recursive brief</span>
-
+<p>Final recursive brief</p>
 </div>
 </div>
 <div>
@@ -639,9 +566,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-recursiveSourceFunctionB();
-
-</code>
+recursiveSourceFunctionB();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/auto-brief/no-auto-brief.xml b/test-files/golden-tests/config/auto-brief/no-auto-brief.xml
index 14eaf504a..21f3ea0a0 100644
--- a/test-files/golden-tests/config/auto-brief/no-auto-brief.xml
+++ b/test-files/golden-tests/config/auto-brief/no-auto-brief.xml
@@ -20,10 +20,6 @@
   </function>
   <function name="copyBriefFromFirstSentenceAsBrief" id="8m+HcfJ//1hM71kLKl4eg3ubQRo=">
     <file short-path="no-auto-brief.cpp" source-path="no-auto-brief.cpp" line="59"/>
-    <doc>
-      <brief>
-      </brief>
-    </doc>
   </function>
   <function name="copyBriefFromFirstValid" id="1TGakYl7bDnE2QttJ28contJFuk=">
     <file short-path="no-auto-brief.cpp" source-path="no-auto-brief.cpp" line="54"/>
@@ -101,8 +97,6 @@
   <function name="copyDocFromFirstSentenceAsBrief" id="TsgZNU1zRr56zndlZFaoDMc3HYY=">
     <file short-path="no-auto-brief.cpp" source-path="no-auto-brief.cpp" line="124"/>
     <doc>
-      <brief>
-      </brief>
       <para>
         <text>This is the brief.</text>
       </para>
@@ -143,56 +137,28 @@
   </function>
   <function name="failCircularReferenceCopyFunction" id="/W9Gcu/9mPpmnlcLzqb07fE5NfU=">
     <file short-path="no-auto-brief.cpp" source-path="no-auto-brief.cpp" line="174"/>
-    <doc>
-      <brief>
-      </brief>
-    </doc>
   </function>
   <function name="failCircularSourceFunctionA" id="w0nnzgrgQArkJmBNTMgQndCvLEY=">
     <file short-path="no-auto-brief.cpp" source-path="no-auto-brief.cpp" line="164"/>
-    <doc>
-      <brief>
-      </brief>
-    </doc>
   </function>
   <function name="failCircularSourceFunctionB" id="DLgwr/zhr5/zU7XTTW0xwbX8xDk=">
     <file short-path="no-auto-brief.cpp" source-path="no-auto-brief.cpp" line="169"/>
-    <doc>
-      <brief>
-      </brief>
-    </doc>
   </function>
   <function name="failCopyBriefFromDocNoBrief" id="4XIirlBtHiS1Bj+U07f22Hbf6xo=">
     <file short-path="no-auto-brief.cpp" source-path="no-auto-brief.cpp" line="42"/>
-    <doc>
-      <brief>
-      </brief>
-    </doc>
   </function>
   <function name="failCopyBriefFromInvalidReference" id="IV37E8LGcb3UZ4VcCoFGoFRXMAA=">
     <file short-path="no-auto-brief.cpp" source-path="no-auto-brief.cpp" line="64"/>
-    <doc>
-      <brief>
-      </brief>
-    </doc>
   </function>
   <function name="failCopyBriefFromNoDoc" id="nfm5DhGLP53urgKVUj7/azRbGiU=">
     <file short-path="no-auto-brief.cpp" source-path="no-auto-brief.cpp" line="37"/>
-    <doc>
-      <brief>
-      </brief>
-    </doc>
   </function>
   <function name="failCopyDetailsFromInvalidReference" id="y3EB6VotLcEDqzU5ye611iQpd08=">
     <file short-path="no-auto-brief.cpp" source-path="no-auto-brief.cpp" line="97"/>
-    <doc>
-    </doc>
   </function>
   <function name="failCopyDocFromDocNoBrief" id="+OInO9eRUKfg4w7+GGNQIRlBYDQ=">
     <file short-path="no-auto-brief.cpp" source-path="no-auto-brief.cpp" line="114"/>
     <doc>
-      <brief>
-      </brief>
       <para>
         <text>This function has documentation but no brief.</text>
       </para>
@@ -200,24 +166,12 @@
   </function>
   <function name="failCopyDocFromInvalidReference" id="QQUSujFeIVZnajdM74smV6sAtdw=">
     <file short-path="no-auto-brief.cpp" source-path="no-auto-brief.cpp" line="129"/>
-    <doc>
-      <brief>
-      </brief>
-    </doc>
   </function>
   <function name="failCopyDocFromNoDoc" id="pMmcF/A3wZTg9BwAWar3xDZO3o0=">
     <file short-path="no-auto-brief.cpp" source-path="no-auto-brief.cpp" line="109"/>
-    <doc>
-      <brief>
-      </brief>
-    </doc>
   </function>
   <function name="failInvalidReferenceCopyFunctions" id="Je9QqhEaYHLFVdcnYkfNWXAGjJw=">
     <file short-path="no-auto-brief.cpp" source-path="no-auto-brief.cpp" line="142"/>
-    <doc>
-      <brief>
-      </brief>
-    </doc>
   </function>
   <function name="firstSentenceAsBriefFunction" id="EQ4aeACGgJCKgpkBFTm+KrTKM08=">
     <file short-path="no-auto-brief.cpp" source-path="no-auto-brief.cpp" line="31"/>
diff --git a/test-files/golden-tests/config/auto-function-metadata/brief-from-function-class.html b/test-files/golden-tests/config/auto-function-metadata/brief-from-function-class.html
index 75326725d..44301b34e 100644
--- a/test-files/golden-tests/config/auto-function-metadata/brief-from-function-class.html
+++ b/test-files/golden-tests/config/auto-function-metadata/brief-from-function-class.html
@@ -19,8 +19,8 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A"><code>A</code></a> </td><td><span>A helper tag</span></td></tr><tr>
-<td><a href="#X"><code>X</code></a> </td><td><span>Test class</span></td></tr>
+<td><a href="#A"><code>A</code></a> </td><td>A helper tag</td></tr><tr>
+<td><a href="#X"><code>X</code></a> </td><td>Test class</td></tr>
 </tbody>
 </table>
 
@@ -29,8 +29,7 @@ <h2>Types</h2>
 <div>
 <h2 id="A">A</h2>
 <div>
-<span>A helper tag</span>
-
+<p>A helper tag</p>
 </div>
 </div>
 <div>
@@ -38,9 +37,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;brief-from-function-class.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 
@@ -50,8 +47,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="X">X</h2>
 <div>
-<span>Test class</span>
-
+<p>Test class</p>
 </div>
 </div>
 <div>
@@ -59,9 +55,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;brief-from-function-class.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct X;
-
-</code>
+<code class="source-code cpp">struct X;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -74,10 +68,10 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#X-2constructor-08"><code>X</code></a>         <span class="small">[constructor]</span></td><td><span>Constructors</span></td></tr><tr>
-<td><a href="#X-2destructor"><code>~X</code></a> <span class="small">[destructor]</span></td><td><span>Destructor</span></td></tr><tr>
-<td><a href="#X-2conversion-00"><code>operator A</code></a> </td><td><span>Conversion to <code>A</code></span></td></tr><tr>
-<td><a href="#X-2conversion-0b"><code>operator int</code></a> </td><td><span>Conversion to <code>int</code></span></td></tr>
+<td><a href="#X-2constructor-08"><code>X</code></a>         <span class="small">[constructor]</span></td><td>Constructors</td></tr><tr>
+<td><a href="#X-2destructor"><code>~X</code></a> <span class="small">[destructor]</span></td><td>Destructor</td></tr><tr>
+<td><a href="#X-2conversion-00"><code>operator A</code></a> </td><td>Conversion to <code>A</code></td></tr><tr>
+<td><a href="#X-2conversion-0b"><code>operator int</code></a> </td><td>Conversion to <code>int</code></td></tr>
 </tbody>
 </table>
 
@@ -88,57 +82,44 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="X-2constructor-08">X::X</h2>
 <div>
-<span>Constructors</span>
-
+<p>Constructors</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;brief-from-function-class.cpp&gt;</code></div>
-<span>Default constructor</span>
+<p>Default constructor</p>
 <pre>
 <code class="source-code cpp">constexpr
-<a href="#X-2constructor-0e8">X</a>() = default;
-
-</code>
+<a href="#X-2constructor-0e8">X</a>() = default;</code>
 </pre><span class="small"><a href="#X-2constructor-0e8"><em>» more...</em></a></span>
 
-<span>Copy constructor</span>
+<p>Copy constructor</p>
 <pre>
 <code class="source-code cpp">constexpr
-<a href="#X-2constructor-0e0">X</a>(<a href="#X">X</a> const& other) = default;
-
-</code>
+<a href="#X-2constructor-0e0">X</a>(<a href="#X">X</a> const& other) = default;</code>
 </pre><span class="small"><a href="#X-2constructor-0e0"><em>» more...</em></a></span>
 
-<span>Move constructor</span>
+<p>Move constructor</p>
 <pre>
 <code class="source-code cpp">constexpr
-<a href="#X-2constructor-06">X</a>(<a href="#X">X</a>&& other) = default;
-
-</code>
+<a href="#X-2constructor-06">X</a>(<a href="#X">X</a>&& other) = default;</code>
 </pre><span class="small"><a href="#X-2constructor-06"><em>» more...</em></a></span>
 
-<span>Construct from <code>int</code></span>
+<p>Construct from <code>int</code></p>
 <pre>
-<code class="source-code cpp"><a href="#X-2constructor-07">X</a>(int value);
-
-</code>
+<code class="source-code cpp"><a href="#X-2constructor-07">X</a>(int value);</code>
 </pre><span class="small"><a href="#X-2constructor-07"><em>» more...</em></a></span>
 
-<span>Construct from <code>A</code></span>
+<p>Construct from <code>A</code></p>
 <pre>
-<code class="source-code cpp"><a href="#X-2constructor-0b">X</a>(<a href="#A">A</a> const& value);
-
-</code>
+<code class="source-code cpp"><a href="#X-2constructor-0b">X</a>(<a href="#A">A</a> const& value);</code>
 </pre><span class="small"><a href="#X-2constructor-0b"><em>» more...</em></a></span>
 
-<span>Construct from <code>A</code></span>
+<p>Construct from <code>A</code></p>
 <pre>
-<code class="source-code cpp"><a href="#X-2constructor-00">X</a>(<a href="#A">A</a>&& value);
-
-</code>
+<code class="source-code cpp"><a href="#X-2constructor-00">X</a>(<a href="#A">A</a>&& value);</code>
 </pre><span class="small"><a href="#X-2constructor-00"><em>» more...</em></a></span>
 
 
@@ -148,8 +129,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="X-2constructor-0e8">X::X</h2>
 <div>
-<span>Default constructor</span>
-
+<p>Default constructor</p>
 </div>
 </div>
 <div>
@@ -158,9 +138,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-from-function-class.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">constexpr
-X() = default;
-
-</code>
+X() = default;</code>
 </pre>
 </div>
 </div>
@@ -168,8 +146,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="X-2constructor-0e0">X::X</h2>
 <div>
-<span>Copy constructor</span>
-
+<p>Copy constructor</p>
 </div>
 </div>
 <div>
@@ -178,9 +155,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-from-function-class.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">constexpr
-X(<a href="#X">X</a> const& other) = default;
-
-</code>
+X(<a href="#X">X</a> const& other) = default;</code>
 </pre>
 </div>
 <div>
@@ -195,7 +170,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The object to copy construct from</span></td>
+<td>The object to copy construct from</td>
 </tr>
 </tbody>
 </table>
@@ -205,8 +180,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-2constructor-06">X::X</h2>
 <div>
-<span>Move constructor</span>
-
+<p>Move constructor</p>
 </div>
 </div>
 <div>
@@ -215,9 +189,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-from-function-class.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">constexpr
-X(<a href="#X">X</a>&& other) = default;
-
-</code>
+X(<a href="#X">X</a>&& other) = default;</code>
 </pre>
 </div>
 <div>
@@ -232,7 +204,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The object to move construct from</span></td>
+<td>The object to move construct from</td>
 </tr>
 </tbody>
 </table>
@@ -242,8 +214,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-2constructor-07">X::X</h2>
 <div>
-<span>Construct from <code>int</code></span>
-
+<p>Construct from <code>int</code></p>
 </div>
 </div>
 <div>
@@ -251,9 +222,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;brief-from-function-class.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">X(int value);
-
-</code>
+<code class="source-code cpp">X(int value);</code>
 </pre>
 </div>
 <div>
@@ -268,7 +237,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The value to construct from</span></td>
+<td>The value to construct from</td>
 </tr>
 </tbody>
 </table>
@@ -278,8 +247,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-2constructor-0b">X::X</h2>
 <div>
-<span>Construct from <code>A</code></span>
-
+<p>Construct from <code>A</code></p>
 </div>
 </div>
 <div>
@@ -287,9 +255,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;brief-from-function-class.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">X(<a href="#A">A</a> const& value);
-
-</code>
+<code class="source-code cpp">X(<a href="#A">A</a> const& value);</code>
 </pre>
 </div>
 <div>
@@ -304,7 +270,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The object to copy construct from</span></td>
+<td>The object to copy construct from</td>
 </tr>
 </tbody>
 </table>
@@ -314,8 +280,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-2constructor-00">X::X</h2>
 <div>
-<span>Construct from <code>A</code></span>
-
+<p>Construct from <code>A</code></p>
 </div>
 </div>
 <div>
@@ -323,9 +288,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;brief-from-function-class.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">X(<a href="#A">A</a>&& value);
-
-</code>
+<code class="source-code cpp">X(<a href="#A">A</a>&& value);</code>
 </pre>
 </div>
 <div>
@@ -340,7 +303,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The object to move construct from</span></td>
+<td>The object to move construct from</td>
 </tr>
 </tbody>
 </table>
@@ -350,8 +313,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-2destructor">X::~X</h2>
 <div>
-<span>Destructor</span>
-
+<p>Destructor</p>
 </div>
 </div>
 <div>
@@ -359,9 +321,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;brief-from-function-class.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">~X();
-
-</code>
+<code class="source-code cpp">~X();</code>
 </pre>
 </div>
 </div>
@@ -369,8 +329,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="X-2conversion-00">X::operator A</h2>
 <div>
-<span>Conversion to <code>A</code></span>
-
+<p>Conversion to <code>A</code></p>
 </div>
 </div>
 <div>
@@ -378,22 +337,19 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;brief-from-function-class.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">operator <a href="#A">A</a>() const;
-
-</code>
+<code class="source-code cpp">operator <a href="#A">A</a>() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A helper tag</span>
+A helper tag
 </div>
 </div>
 <div>
 <div>
 <h2 id="X-2conversion-0b">X::operator int</h2>
 <div>
-<span>Conversion to <code>int</code></span>
-
+<p>Conversion to <code>int</code></p>
 </div>
 </div>
 <div>
@@ -401,14 +357,12 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;brief-from-function-class.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">operator int() const;
-
-</code>
+<code class="source-code cpp">operator int() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The object converted to <code>int</code></span>
+The object converted to <code>int</code>
 </div>
 </div>
 
diff --git a/test-files/golden-tests/config/auto-function-metadata/brief-from-operator.adoc b/test-files/golden-tests/config/auto-function-metadata/brief-from-operator.adoc
index 8fb246f40..d6b2b01e1 100644
--- a/test-files/golden-tests/config/auto-function-metadata/brief-from-operator.adoc
+++ b/test-files/golden-tests/config/auto-function-metadata/brief-from-operator.adoc
@@ -240,6 +240,16 @@ Declared in `&lt;brief&hyphen;from&hyphen;operator&period;cpp&gt;`
 struct ostream;
 ----
 
+=== Non-Member Functions
+
+[cols=2]
+|===
+| Name
+| Description
+| link:#operator_lshift[`operator&lt;&lt;`]
+| Stream insertion operator
+|===
+
 [#operator_lshift]
 == operator&lt;&lt;
 
diff --git a/test-files/golden-tests/config/auto-function-metadata/brief-from-operator.html b/test-files/golden-tests/config/auto-function-metadata/brief-from-operator.html
index 99f4a1f7d..9127351ba 100644
--- a/test-files/golden-tests/config/auto-function-metadata/brief-from-operator.html
+++ b/test-files/golden-tests/config/auto-function-metadata/brief-from-operator.html
@@ -19,9 +19,9 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A"><code>A</code></a> </td><td><span>A helper tag</span></td></tr><tr>
-<td><a href="#X"><code>X</code></a> </td><td><span>Test class</span></td></tr><tr>
-<td><a href="#ostream"><code>ostream</code></a> </td><td><span>A dumb ostream class</span></td></tr>
+<td><a href="#A"><code>A</code></a> </td><td>A helper tag</td></tr><tr>
+<td><a href="#X"><code>X</code></a> </td><td>Test class</td></tr><tr>
+<td><a href="#ostream"><code>ostream</code></a> </td><td>A dumb ostream class</td></tr>
 </tbody>
 </table>
 
@@ -35,7 +35,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#operator_lshift"><code>operator&lt;&lt;</code></a> </td><td><span>Stream insertion operator</span></td></tr>
+<td><a href="#operator_lshift"><code>operator&lt;&lt;</code></a> </td><td>Stream insertion operator</td></tr>
 </tbody>
 </table>
 
@@ -44,8 +44,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="A">A</h2>
 <div>
-<span>A helper tag</span>
-
+<p>A helper tag</p>
 </div>
 </div>
 <div>
@@ -53,9 +52,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;brief-from-operator.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 
@@ -65,8 +62,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="X">X</h2>
 <div>
-<span>Test class</span>
-
+<p>Test class</p>
 </div>
 </div>
 <div>
@@ -74,9 +70,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;brief-from-operator.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct X;
-
-</code>
+<code class="source-code cpp">struct X;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -89,8 +83,8 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#X-operator_assign-0a"><code>operator&#x3D;</code></a> </td><td><span>Assignment operators</span></td></tr><tr>
-<td><a href="#X-operator_plus_eq"><code>operator+&#x3D;</code></a> </td><td><span>Addition assignment operator</span></td></tr>
+<td><a href="#X-operator_assign-0a"><code>operator&#x3D;</code></a> </td><td>Assignment operators</td></tr><tr>
+<td><a href="#X-operator_plus_eq"><code>operator+&#x3D;</code></a> </td><td>Addition assignment operator</td></tr>
 </tbody>
 </table>
 
@@ -101,36 +95,29 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="X-operator_assign-0a">X::operator&#x3D;</h2>
 <div>
-<span>Assignment operators</span>
-
+<p>Assignment operators</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;brief-from-operator.cpp&gt;</code></div>
-<span>Copy assignment operator</span>
+<p>Copy assignment operator</p>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&
-<a href="#X-operator_assign-06">operator&#x3D;</a>(<a href="#X">X</a> const& other);
-
-</code>
+<a href="#X-operator_assign-06">operator&#x3D;</a>(<a href="#X">X</a> const& other);</code>
 </pre><span class="small"><a href="#X-operator_assign-06"><em>» more...</em></a></span>
 
-<span>Move assignment operator</span>
+<p>Move assignment operator</p>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&
-<a href="#X-operator_assign-0e">operator&#x3D;</a>(<a href="#X">X</a>&& other);
-
-</code>
+<a href="#X-operator_assign-0e">operator&#x3D;</a>(<a href="#X">X</a>&& other);</code>
 </pre><span class="small"><a href="#X-operator_assign-0e"><em>» more...</em></a></span>
 
-<span>Assignment operator</span>
+<p>Assignment operator</p>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&
-<a href="#X-operator_assign-0d">operator&#x3D;</a>(<a href="#A">A</a> const& value);
-
-</code>
+<a href="#X-operator_assign-0d">operator&#x3D;</a>(<a href="#A">A</a> const& value);</code>
 </pre><span class="small"><a href="#X-operator_assign-0d"><em>» more...</em></a></span>
 
 
@@ -140,8 +127,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="X-operator_assign-06">X::operator&#x3D;</h2>
 <div>
-<span>Copy assignment operator</span>
-
+<p>Copy assignment operator</p>
 </div>
 </div>
 <div>
@@ -150,14 +136,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-from-operator.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&
-operator&#x3D;(<a href="#X">X</a> const& other);
-
-</code>
+operator&#x3D;(<a href="#X">X</a> const& other);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Reference to the current object</span>
+Reference to the current object
 </div>
 <div>
 <h3>Parameters</h3>
@@ -171,7 +155,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The object to copy assign from</span></td>
+<td>The object to copy assign from</td>
 </tr>
 </tbody>
 </table>
@@ -181,8 +165,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-operator_assign-0e">X::operator&#x3D;</h2>
 <div>
-<span>Move assignment operator</span>
-
+<p>Move assignment operator</p>
 </div>
 </div>
 <div>
@@ -191,14 +174,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-from-operator.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&
-operator&#x3D;(<a href="#X">X</a>&& other);
-
-</code>
+operator&#x3D;(<a href="#X">X</a>&& other);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Reference to the current object</span>
+Reference to the current object
 </div>
 <div>
 <h3>Parameters</h3>
@@ -212,7 +193,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The object to move assign from</span></td>
+<td>The object to move assign from</td>
 </tr>
 </tbody>
 </table>
@@ -222,8 +203,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-operator_assign-0d">X::operator&#x3D;</h2>
 <div>
-<span>Assignment operator</span>
-
+<p>Assignment operator</p>
 </div>
 </div>
 <div>
@@ -232,14 +212,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-from-operator.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&
-operator&#x3D;(<a href="#A">A</a> const& value);
-
-</code>
+operator&#x3D;(<a href="#A">A</a> const& value);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Reference to the current object</span>
+Reference to the current object
 </div>
 <div>
 <h3>Parameters</h3>
@@ -253,7 +231,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The object to copy assign from</span></td>
+<td>The object to copy assign from</td>
 </tr>
 </tbody>
 </table>
@@ -263,8 +241,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-operator_plus_eq">X::operator+&#x3D;</h2>
 <div>
-<span>Addition assignment operator</span>
-
+<p>Addition assignment operator</p>
 </div>
 </div>
 <div>
@@ -273,14 +250,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-from-operator.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&
-operator+&#x3D;(<a href="#X">X</a> const& rhs);
-
-</code>
+operator+&#x3D;(<a href="#X">X</a> const& rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Reference to the current object</span>
+Reference to the current object
 </div>
 <div>
 <h3>Parameters</h3>
@@ -294,7 +269,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -304,8 +279,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="ostream">ostream</h2>
 <div>
-<span>A dumb ostream class</span>
-
+<p>A dumb ostream class</p>
 </div>
 </div>
 <div>
@@ -313,20 +287,31 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;brief-from-operator.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct ostream;
-
-</code>
+<code class="source-code cpp">struct ostream;</code>
 </pre>
 </div>
 
 
+<div>
+<h2>Non-Member Functions</h2>
+<table>
+<thead>
+<tr>
+<th>Name</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr><td><a href="#operator_lshift"><code>operator&lt;&lt;</code></a></td><td>Stream insertion operator</td></tr>
+</tbody>
+</table>
+</div>
 </div>
 <div>
 <div>
 <h2 id="operator_lshift">operator&lt;&lt;</h2>
 <div>
-<span>Stream insertion operator</span>
-
+<p>Stream insertion operator</p>
 </div>
 </div>
 <div>
@@ -337,14 +322,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp"><a href="#ostream">ostream</a>&
 operator&lt;&lt;(
     <a href="#ostream">ostream</a>& os,
-    <a href="#X">X</a> const& x);
-
-</code>
+    <a href="#X">X</a> const& x);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Reference to the current output stream</span>
+Reference to the current output stream
 </div>
 <div>
 <h3>Parameters</h3>
@@ -358,11 +341,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>os</strong></td>
-<td><span>An output stream</span></td>
+<td>An output stream</td>
 </tr>
 <tr>
 <td><strong>x</strong></td>
-<td><span>The object to output</span></td>
+<td>The object to output</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/config/auto-function-metadata/brief-from-operator.xml b/test-files/golden-tests/config/auto-function-metadata/brief-from-operator.xml
index 7acdca1ae..1e28354a3 100644
--- a/test-files/golden-tests/config/auto-function-metadata/brief-from-operator.xml
+++ b/test-files/golden-tests/config/auto-function-metadata/brief-from-operator.xml
@@ -124,6 +124,9 @@
       <brief>
         <text>A dumb ostream class</text>
       </brief>
+      <related>
+        <reference id="G/x48jnXaICOdnZlZThSByV21NY=">operator&lt;&lt;</reference>
+      </related>
     </doc>
   </struct>
   <function name="operator&lt;&lt;" id="G/x48jnXaICOdnZlZThSByV21NY=">
@@ -157,6 +160,9 @@
       <param name="x">
         <text>The object to output</text>
       </param>
+      <relates>
+        <reference id="S6h+1uM4q9FLs9aohvL2EV9oRbs=">ostream</reference>
+      </relates>
     </doc>
   </function>
 </namespace>
diff --git a/test-files/golden-tests/config/auto-function-metadata/param-from-function-class.html b/test-files/golden-tests/config/auto-function-metadata/param-from-function-class.html
index 4c17e06fc..318ce0098 100644
--- a/test-files/golden-tests/config/auto-function-metadata/param-from-function-class.html
+++ b/test-files/golden-tests/config/auto-function-metadata/param-from-function-class.html
@@ -19,8 +19,8 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A"><code>A</code></a> </td><td><span>A helper tag</span></td></tr><tr>
-<td><a href="#X"><code>X</code></a> </td><td><span>Test class</span></td></tr>
+<td><a href="#A"><code>A</code></a> </td><td>A helper tag</td></tr><tr>
+<td><a href="#X"><code>X</code></a> </td><td>Test class</td></tr>
 </tbody>
 </table>
 
@@ -29,8 +29,7 @@ <h2>Types</h2>
 <div>
 <h2 id="A">A</h2>
 <div>
-<span>A helper tag</span>
-
+<p>A helper tag</p>
 </div>
 </div>
 <div>
@@ -38,9 +37,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;param-from-function-class.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 
@@ -50,8 +47,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="X">X</h2>
 <div>
-<span>Test class</span>
-
+<p>Test class</p>
 </div>
 </div>
 <div>
@@ -59,9 +55,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;param-from-function-class.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct X;
-
-</code>
+<code class="source-code cpp">struct X;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -74,8 +68,8 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#X-2constructor-08"><code>X</code></a>         <span class="small">[constructor]</span></td><td><span>Constructors</span></td></tr><tr>
-<td><a href="#X-operator_assign-0a"><code>operator&#x3D;</code></a> </td><td><span>Assignment operators</span></td></tr>
+<td><a href="#X-2constructor-08"><code>X</code></a>         <span class="small">[constructor]</span></td><td>Constructors</td></tr><tr>
+<td><a href="#X-operator_assign-0a"><code>operator&#x3D;</code></a> </td><td>Assignment operators</td></tr>
 </tbody>
 </table>
 
@@ -86,47 +80,36 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="X-2constructor-08">X::X</h2>
 <div>
-<span>Constructors</span>
-
+<p>Constructors</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;param-from-function-class.cpp&gt;</code></div>
-<span>Copy constructor</span>
+<p>Copy constructor</p>
 <pre>
-<code class="source-code cpp"><a href="#X-2constructor-0e">X</a>(<a href="#X">X</a> const& other);
-
-</code>
+<code class="source-code cpp"><a href="#X-2constructor-0e">X</a>(<a href="#X">X</a> const& other);</code>
 </pre><span class="small"><a href="#X-2constructor-0e"><em>» more...</em></a></span>
 
-<span>Move constructor</span>
+<p>Move constructor</p>
 <pre>
-<code class="source-code cpp"><a href="#X-2constructor-06">X</a>(<a href="#X">X</a>&& other);
-
-</code>
+<code class="source-code cpp"><a href="#X-2constructor-06">X</a>(<a href="#X">X</a>&& other);</code>
 </pre><span class="small"><a href="#X-2constructor-06"><em>» more...</em></a></span>
 
-<span>Construct from <code>int</code></span>
+<p>Construct from <code>int</code></p>
 <pre>
-<code class="source-code cpp"><a href="#X-2constructor-07">X</a>(int value);
-
-</code>
+<code class="source-code cpp"><a href="#X-2constructor-07">X</a>(int value);</code>
 </pre><span class="small"><a href="#X-2constructor-07"><em>» more...</em></a></span>
 
-<span>Construct from <code>A</code></span>
+<p>Construct from <code>A</code></p>
 <pre>
-<code class="source-code cpp"><a href="#X-2constructor-0b">X</a>(<a href="#A">A</a> const& value);
-
-</code>
+<code class="source-code cpp"><a href="#X-2constructor-0b">X</a>(<a href="#A">A</a> const& value);</code>
 </pre><span class="small"><a href="#X-2constructor-0b"><em>» more...</em></a></span>
 
-<span>Construct from <code>A</code></span>
+<p>Construct from <code>A</code></p>
 <pre>
-<code class="source-code cpp"><a href="#X-2constructor-00">X</a>(<a href="#A">A</a>&& value);
-
-</code>
+<code class="source-code cpp"><a href="#X-2constructor-00">X</a>(<a href="#A">A</a>&& value);</code>
 </pre><span class="small"><a href="#X-2constructor-00"><em>» more...</em></a></span>
 
 
@@ -136,8 +119,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="X-2constructor-0e">X::X</h2>
 <div>
-<span>Copy constructor</span>
-
+<p>Copy constructor</p>
 </div>
 </div>
 <div>
@@ -145,9 +127,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;param-from-function-class.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">X(<a href="#X">X</a> const& other);
-
-</code>
+<code class="source-code cpp">X(<a href="#X">X</a> const& other);</code>
 </pre>
 </div>
 <div>
@@ -162,7 +142,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The object to copy construct from</span></td>
+<td>The object to copy construct from</td>
 </tr>
 </tbody>
 </table>
@@ -172,8 +152,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-2constructor-06">X::X</h2>
 <div>
-<span>Move constructor</span>
-
+<p>Move constructor</p>
 </div>
 </div>
 <div>
@@ -181,9 +160,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;param-from-function-class.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">X(<a href="#X">X</a>&& other);
-
-</code>
+<code class="source-code cpp">X(<a href="#X">X</a>&& other);</code>
 </pre>
 </div>
 <div>
@@ -198,7 +175,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The object to move construct from</span></td>
+<td>The object to move construct from</td>
 </tr>
 </tbody>
 </table>
@@ -208,8 +185,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-2constructor-07">X::X</h2>
 <div>
-<span>Construct from <code>int</code></span>
-
+<p>Construct from <code>int</code></p>
 </div>
 </div>
 <div>
@@ -217,9 +193,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;param-from-function-class.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">X(int value);
-
-</code>
+<code class="source-code cpp">X(int value);</code>
 </pre>
 </div>
 <div>
@@ -234,7 +208,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The value to construct from</span></td>
+<td>The value to construct from</td>
 </tr>
 </tbody>
 </table>
@@ -244,8 +218,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-2constructor-0b">X::X</h2>
 <div>
-<span>Construct from <code>A</code></span>
-
+<p>Construct from <code>A</code></p>
 </div>
 </div>
 <div>
@@ -253,9 +226,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;param-from-function-class.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">X(<a href="#A">A</a> const& value);
-
-</code>
+<code class="source-code cpp">X(<a href="#A">A</a> const& value);</code>
 </pre>
 </div>
 <div>
@@ -270,7 +241,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The object to copy construct from</span></td>
+<td>The object to copy construct from</td>
 </tr>
 </tbody>
 </table>
@@ -280,8 +251,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-2constructor-00">X::X</h2>
 <div>
-<span>Construct from <code>A</code></span>
-
+<p>Construct from <code>A</code></p>
 </div>
 </div>
 <div>
@@ -289,9 +259,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;param-from-function-class.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">X(<a href="#A">A</a>&& value);
-
-</code>
+<code class="source-code cpp">X(<a href="#A">A</a>&& value);</code>
 </pre>
 </div>
 <div>
@@ -306,7 +274,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The object to move construct from</span></td>
+<td>The object to move construct from</td>
 </tr>
 </tbody>
 </table>
@@ -316,52 +284,41 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-operator_assign-0a">X::operator&#x3D;</h2>
 <div>
-<span>Assignment operators</span>
-
+<p>Assignment operators</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;param-from-function-class.cpp&gt;</code></div>
-<span>Copy assignment operator</span>
+<p>Copy assignment operator</p>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&
-<a href="#X-operator_assign-06">operator&#x3D;</a>(<a href="#X">X</a> const& other);
-
-</code>
+<a href="#X-operator_assign-06">operator&#x3D;</a>(<a href="#X">X</a> const& other);</code>
 </pre><span class="small"><a href="#X-operator_assign-06"><em>» more...</em></a></span>
 
-<span>Move assignment operator</span>
+<p>Move assignment operator</p>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&
-<a href="#X-operator_assign-0e">operator&#x3D;</a>(<a href="#X">X</a>&& other);
-
-</code>
+<a href="#X-operator_assign-0e">operator&#x3D;</a>(<a href="#X">X</a>&& other);</code>
 </pre><span class="small"><a href="#X-operator_assign-0e"><em>» more...</em></a></span>
 
-<span>Assignment operator</span>
+<p>Assignment operator</p>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&
-<a href="#X-operator_assign-07f">operator&#x3D;</a>(int value);
-
-</code>
+<a href="#X-operator_assign-07f">operator&#x3D;</a>(int value);</code>
 </pre><span class="small"><a href="#X-operator_assign-07f"><em>» more...</em></a></span>
 
-<span>Assignment operator</span>
+<p>Assignment operator</p>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&
-<a href="#X-operator_assign-0d">operator&#x3D;</a>(<a href="#A">A</a> const& value);
-
-</code>
+<a href="#X-operator_assign-0d">operator&#x3D;</a>(<a href="#A">A</a> const& value);</code>
 </pre><span class="small"><a href="#X-operator_assign-0d"><em>» more...</em></a></span>
 
-<span>Assignment operator</span>
+<p>Assignment operator</p>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&
-<a href="#X-operator_assign-07e">operator&#x3D;</a>(<a href="#A">A</a>&& value);
-
-</code>
+<a href="#X-operator_assign-07e">operator&#x3D;</a>(<a href="#A">A</a>&& value);</code>
 </pre><span class="small"><a href="#X-operator_assign-07e"><em>» more...</em></a></span>
 
 
@@ -371,8 +328,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="X-operator_assign-06">X::operator&#x3D;</h2>
 <div>
-<span>Copy assignment operator</span>
-
+<p>Copy assignment operator</p>
 </div>
 </div>
 <div>
@@ -381,14 +337,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-from-function-class.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&
-operator&#x3D;(<a href="#X">X</a> const& other);
-
-</code>
+operator&#x3D;(<a href="#X">X</a> const& other);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Reference to the current object</span>
+Reference to the current object
 </div>
 <div>
 <h3>Parameters</h3>
@@ -402,7 +356,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The object to copy assign from</span></td>
+<td>The object to copy assign from</td>
 </tr>
 </tbody>
 </table>
@@ -412,8 +366,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-operator_assign-0e">X::operator&#x3D;</h2>
 <div>
-<span>Move assignment operator</span>
-
+<p>Move assignment operator</p>
 </div>
 </div>
 <div>
@@ -422,14 +375,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-from-function-class.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&
-operator&#x3D;(<a href="#X">X</a>&& other);
-
-</code>
+operator&#x3D;(<a href="#X">X</a>&& other);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Reference to the current object</span>
+Reference to the current object
 </div>
 <div>
 <h3>Parameters</h3>
@@ -443,7 +394,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The object to move assign from</span></td>
+<td>The object to move assign from</td>
 </tr>
 </tbody>
 </table>
@@ -453,8 +404,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-operator_assign-07f">X::operator&#x3D;</h2>
 <div>
-<span>Assignment operator</span>
-
+<p>Assignment operator</p>
 </div>
 </div>
 <div>
@@ -463,14 +413,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-from-function-class.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&
-operator&#x3D;(int value);
-
-</code>
+operator&#x3D;(int value);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Reference to the current object</span>
+Reference to the current object
 </div>
 <div>
 <h3>Parameters</h3>
@@ -484,7 +432,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The value to assign from</span></td>
+<td>The value to assign from</td>
 </tr>
 </tbody>
 </table>
@@ -494,8 +442,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-operator_assign-0d">X::operator&#x3D;</h2>
 <div>
-<span>Assignment operator</span>
-
+<p>Assignment operator</p>
 </div>
 </div>
 <div>
@@ -504,14 +451,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-from-function-class.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&
-operator&#x3D;(<a href="#A">A</a> const& value);
-
-</code>
+operator&#x3D;(<a href="#A">A</a> const& value);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Reference to the current object</span>
+Reference to the current object
 </div>
 <div>
 <h3>Parameters</h3>
@@ -525,7 +470,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The object to copy assign from</span></td>
+<td>The object to copy assign from</td>
 </tr>
 </tbody>
 </table>
@@ -535,8 +480,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-operator_assign-07e">X::operator&#x3D;</h2>
 <div>
-<span>Assignment operator</span>
-
+<p>Assignment operator</p>
 </div>
 </div>
 <div>
@@ -545,14 +489,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-from-function-class.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&
-operator&#x3D;(<a href="#A">A</a>&& value);
-
-</code>
+operator&#x3D;(<a href="#A">A</a>&& value);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Reference to the current object</span>
+Reference to the current object
 </div>
 <div>
 <h3>Parameters</h3>
@@ -566,7 +508,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The object to move assign from</span></td>
+<td>The object to move assign from</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/config/auto-function-metadata/param-from-operator.adoc b/test-files/golden-tests/config/auto-function-metadata/param-from-operator.adoc
index 2814e9be7..5ffba3d13 100644
--- a/test-files/golden-tests/config/auto-function-metadata/param-from-operator.adoc
+++ b/test-files/golden-tests/config/auto-function-metadata/param-from-operator.adoc
@@ -70,6 +70,18 @@ struct X;
 | Addition operator
 |===
 
+=== Non-Member Functions
+
+[cols=2]
+|===
+| Name
+| Description
+| link:#operator_not[`operator!`]
+| Negation operator
+| link:#operator_minus[`operator&hyphen;`]
+| Subtraction operator
+|===
+
 [#X-operator_plus]
 == link:#X[X]::operator&plus;
 
@@ -113,6 +125,16 @@ Declared in `&lt;param&hyphen;from&hyphen;operator&period;cpp&gt;`
 struct ostream;
 ----
 
+=== Non-Member Functions
+
+[cols=2]
+|===
+| Name
+| Description
+| link:#operator_lshift[`operator&lt;&lt;`]
+| Stream insertion operator
+|===
+
 [#operator_minus]
 == operator&hyphen;
 
diff --git a/test-files/golden-tests/config/auto-function-metadata/param-from-operator.html b/test-files/golden-tests/config/auto-function-metadata/param-from-operator.html
index bf8d60a2a..b87e0880b 100644
--- a/test-files/golden-tests/config/auto-function-metadata/param-from-operator.html
+++ b/test-files/golden-tests/config/auto-function-metadata/param-from-operator.html
@@ -19,9 +19,9 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A"><code>A</code></a> </td><td><span>A helper tag</span></td></tr><tr>
-<td><a href="#X"><code>X</code></a> </td><td><span>Test class</span></td></tr><tr>
-<td><a href="#ostream"><code>ostream</code></a> </td><td><span>A dumb ostream class</span></td></tr>
+<td><a href="#A"><code>A</code></a> </td><td>A helper tag</td></tr><tr>
+<td><a href="#X"><code>X</code></a> </td><td>Test class</td></tr><tr>
+<td><a href="#ostream"><code>ostream</code></a> </td><td>A dumb ostream class</td></tr>
 </tbody>
 </table>
 
@@ -35,9 +35,9 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#operator_minus"><code>operator-</code></a> </td><td><span>Subtraction operator</span></td></tr><tr>
-<td><a href="#operator_lshift"><code>operator&lt;&lt;</code></a> </td><td><span>Stream insertion operator</span></td></tr><tr>
-<td><a href="#operator_not"><code>operator!</code></a> </td><td><span>Negation operator</span></td></tr>
+<td><a href="#operator_minus"><code>operator-</code></a> </td><td>Subtraction operator</td></tr><tr>
+<td><a href="#operator_lshift"><code>operator&lt;&lt;</code></a> </td><td>Stream insertion operator</td></tr><tr>
+<td><a href="#operator_not"><code>operator!</code></a> </td><td>Negation operator</td></tr>
 </tbody>
 </table>
 
@@ -46,8 +46,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="A">A</h2>
 <div>
-<span>A helper tag</span>
-
+<p>A helper tag</p>
 </div>
 </div>
 <div>
@@ -55,9 +54,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;param-from-operator.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 
@@ -67,8 +64,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="X">X</h2>
 <div>
-<span>Test class</span>
-
+<p>Test class</p>
 </div>
 </div>
 <div>
@@ -76,9 +72,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;param-from-operator.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct X;
-
-</code>
+<code class="source-code cpp">struct X;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -91,19 +85,33 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#X-operator_plus"><code>operator+</code></a> </td><td><span>Addition operator</span></td></tr>
+<td><a href="#X-operator_plus"><code>operator+</code></a> </td><td>Addition operator</td></tr>
 </tbody>
 </table>
 
 
 
+<div>
+<h2>Non-Member Functions</h2>
+<table>
+<thead>
+<tr>
+<th>Name</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr><td><a href="#operator_not"><code>operator!</code></a></td><td>Negation operator</td></tr>
+<tr><td><a href="#operator_minus"><code>operator-</code></a></td><td>Subtraction operator</td></tr>
+</tbody>
+</table>
+</div>
 </div>
 <div>
 <div>
 <h2 id="X-operator_plus">X::operator+</h2>
 <div>
-<span>Addition operator</span>
-
+<p>Addition operator</p>
 </div>
 </div>
 <div>
@@ -112,14 +120,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-from-operator.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>
-operator+(<a href="#X">X</a> const& x) const;
-
-</code>
+operator+(<a href="#X">X</a> const& x) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Another instance of the object</span>
+Another instance of the object
 </div>
 <div>
 <h3>Parameters</h3>
@@ -133,7 +139,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>x</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -143,8 +149,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="ostream">ostream</h2>
 <div>
-<span>A dumb ostream class</span>
-
+<p>A dumb ostream class</p>
 </div>
 </div>
 <div>
@@ -152,20 +157,31 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;param-from-operator.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct ostream;
-
-</code>
+<code class="source-code cpp">struct ostream;</code>
 </pre>
 </div>
 
 
+<div>
+<h2>Non-Member Functions</h2>
+<table>
+<thead>
+<tr>
+<th>Name</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr><td><a href="#operator_lshift"><code>operator&lt;&lt;</code></a></td><td>Stream insertion operator</td></tr>
+</tbody>
+</table>
+</div>
 </div>
 <div>
 <div>
 <h2 id="operator_minus">operator-</h2>
 <div>
-<span>Subtraction operator</span>
-
+<p>Subtraction operator</p>
 </div>
 </div>
 <div>
@@ -176,14 +192,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp"><a href="#X">X</a>
 operator-(
     <a href="#X">X</a> const& x,
-    <a href="#X">X</a> const& y);
-
-</code>
+    <a href="#X">X</a> const& y);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Test class</span>
+Test class
 </div>
 <div>
 <h3>Parameters</h3>
@@ -197,11 +211,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>x</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>y</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -211,8 +225,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_lshift">operator&lt;&lt;</h2>
 <div>
-<span>Stream insertion operator</span>
-
+<p>Stream insertion operator</p>
 </div>
 </div>
 <div>
@@ -223,14 +236,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp"><a href="#ostream">ostream</a>&
 operator&lt;&lt;(
     <a href="#ostream">ostream</a>& os,
-    <a href="#X">X</a> const& x);
-
-</code>
+    <a href="#X">X</a> const& x);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Reference to the current output stream</span>
+Reference to the current output stream
 </div>
 <div>
 <h3>Parameters</h3>
@@ -244,11 +255,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>os</strong></td>
-<td><span>An output stream</span></td>
+<td>An output stream</td>
 </tr>
 <tr>
 <td><strong>x</strong></td>
-<td><span>The object to output</span></td>
+<td>The object to output</td>
 </tr>
 </tbody>
 </table>
@@ -258,8 +269,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_not">operator!</h2>
 <div>
-<span>Negation operator</span>
-
+<p>Negation operator</p>
 </div>
 </div>
 <div>
@@ -268,14 +278,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-from-operator.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>
-operator!(<a href="#X">X</a> const& x);
-
-</code>
+operator!(<a href="#X">X</a> const& x);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Test class</span>
+Test class
 </div>
 <div>
 <h3>Parameters</h3>
@@ -289,7 +297,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>x</strong></td>
-<td><span>The operand</span></td>
+<td>The operand</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/config/auto-function-metadata/param-from-operator.xml b/test-files/golden-tests/config/auto-function-metadata/param-from-operator.xml
index 534f8bc38..5a42b6340 100644
--- a/test-files/golden-tests/config/auto-function-metadata/param-from-operator.xml
+++ b/test-files/golden-tests/config/auto-function-metadata/param-from-operator.xml
@@ -16,6 +16,10 @@
       <brief>
         <text>Test class</text>
       </brief>
+      <related>
+        <reference id="c9Ca2VyG7d8PUZZCax8n0T1PyGA=">operator!</reference>
+        <reference id="isSEjqdTA5x7DKpSqZK6cD0PZgY=">operator-</reference>
+      </related>
     </doc>
     <function name="operator+" id="KAGpjhkArISJuf2yO8ueGRkoMRY=">
       <file short-path="param-from-operator.cpp" source-path="param-from-operator.cpp" line="11"/>
@@ -48,6 +52,9 @@
       <brief>
         <text>A dumb ostream class</text>
       </brief>
+      <related>
+        <reference id="G/x48jnXaICOdnZlZThSByV21NY=">operator&lt;&lt;</reference>
+      </related>
     </doc>
   </struct>
   <function name="operator-" id="isSEjqdTA5x7DKpSqZK6cD0PZgY=">
@@ -79,6 +86,9 @@
       <param name="y">
         <text>The right operand</text>
       </param>
+      <relates>
+        <reference id="ynx5NXMLXqzSXwgOnIP6CHzNx14=">X</reference>
+      </relates>
     </doc>
   </function>
   <function name="operator&lt;&lt;" id="G/x48jnXaICOdnZlZThSByV21NY=">
@@ -112,6 +122,9 @@
       <param name="x">
         <text>The object to output</text>
       </param>
+      <relates>
+        <reference id="S6h+1uM4q9FLs9aohvL2EV9oRbs=">ostream</reference>
+      </relates>
     </doc>
   </function>
   <function name="operator!" id="c9Ca2VyG7d8PUZZCax8n0T1PyGA=">
@@ -135,6 +148,9 @@
       <param name="x">
         <text>The operand</text>
       </param>
+      <relates>
+        <reference id="ynx5NXMLXqzSXwgOnIP6CHzNx14=">X</reference>
+      </relates>
     </doc>
   </function>
 </namespace>
diff --git a/test-files/golden-tests/config/auto-function-metadata/returns-from-brief.html b/test-files/golden-tests/config/auto-function-metadata/returns-from-brief.html
index ae649787b..e397c6107 100644
--- a/test-files/golden-tests/config/auto-function-metadata/returns-from-brief.html
+++ b/test-files/golden-tests/config/auto-function-metadata/returns-from-brief.html
@@ -19,7 +19,7 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#X"><code>X</code></a> </td><td><span>Test class</span></td></tr>
+<td><a href="#X"><code>X</code></a> </td><td>Test class</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Types</h2>
 <div>
 <h2 id="X">X</h2>
 <div>
-<span>Test class</span>
-
+<p>Test class</p>
 </div>
 </div>
 <div>
@@ -37,9 +36,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;returns-from-brief.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct X;
-
-</code>
+<code class="source-code cpp">struct X;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -52,9 +49,9 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#X-empty"><code>empty</code></a> </td><td><span>Determines whether the range is empty.</span></td></tr><tr>
-<td><a href="#X-front"><code>front</code></a> </td><td><span>Returns the first element of the range.</span></td></tr><tr>
-<td><a href="#X-size"><code>size</code></a> </td><td><span>Get the range size.</span></td></tr>
+<td><a href="#X-empty"><code>empty</code></a> </td><td>Determines whether the range is empty.</td></tr><tr>
+<td><a href="#X-front"><code>front</code></a> </td><td>Returns the first element of the range.</td></tr><tr>
+<td><a href="#X-size"><code>size</code></a> </td><td>Get the range size.</td></tr>
 </tbody>
 </table>
 
@@ -65,8 +62,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="X-empty">X::empty</h2>
 <div>
-<span>Determines whether the range is empty.</span>
-
+<p>Determines whether the range is empty.</p>
 </div>
 </div>
 <div>
@@ -75,22 +71,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;returns-from-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-empty();
-
-</code>
+empty();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>whether the range is empty.</span>
+whether the range is empty.
 </div>
 </div>
 <div>
 <div>
 <h2 id="X-front">X::front</h2>
 <div>
-<span>Returns the first element of the range.</span>
-
+<p>Returns the first element of the range.</p>
 </div>
 </div>
 <div>
@@ -99,22 +92,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;returns-from-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int
-front() const;
-
-</code>
+front() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>the first element of the range.</span>
+the first element of the range.
 </div>
 </div>
 <div>
 <div>
 <h2 id="X-size">X::size</h2>
 <div>
-<span>Get the range size.</span>
-
+<p>Get the range size.</p>
 </div>
 </div>
 <div>
@@ -123,14 +113,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;returns-from-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int
-size() const;
-
-</code>
+size() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>the range size.</span>
+the range size.
 </div>
 </div>
 
diff --git a/test-files/golden-tests/config/auto-function-metadata/returns-from-return-brief.html b/test-files/golden-tests/config/auto-function-metadata/returns-from-return-brief.html
index ca2b4f66b..5cdc9840a 100644
--- a/test-files/golden-tests/config/auto-function-metadata/returns-from-return-brief.html
+++ b/test-files/golden-tests/config/auto-function-metadata/returns-from-return-brief.html
@@ -19,7 +19,7 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#R"><code>R</code></a> </td><td><span>The return type of the function</span></td></tr>
+<td><a href="#R"><code>R</code></a> </td><td>The return type of the function</td></tr>
 </tbody>
 </table>
 
@@ -33,7 +33,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#getR"><code>getR</code></a> </td><td><span>Test function</span></td></tr>
+<td><a href="#getR"><code>getR</code></a> </td><td>Test function</td></tr>
 </tbody>
 </table>
 
@@ -42,8 +42,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="R">R</h2>
 <div>
-<span>The return type of the function</span>
-
+<p>The return type of the function</p>
 </div>
 </div>
 <div>
@@ -51,9 +50,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;returns-from-return-brief.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct R;
-
-</code>
+<code class="source-code cpp">struct R;</code>
 </pre>
 </div>
 
@@ -68,7 +65,7 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#getR"><code>getR</code></a></td><td><span>Test function</span></td></tr>
+<tr><td><a href="#getR"><code>getR</code></a></td><td>Test function</td></tr>
 </tbody>
 </table>
 </div>
@@ -77,8 +74,7 @@ <h2>Non-Member Functions</h2>
 <div>
 <h2 id="getR">getR</h2>
 <div>
-<span>Test function</span>
-
+<p>Test function</p>
 </div>
 </div>
 <div>
@@ -87,14 +83,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;returns-from-return-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#R">R</a>
-getR();
-
-</code>
+getR();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The return type of the function</span>
+The return type of the function
 </div>
 </div>
 
diff --git a/test-files/golden-tests/config/auto-function-metadata/returns-from-special.adoc b/test-files/golden-tests/config/auto-function-metadata/returns-from-special.adoc
index d753647a4..20faf5a1e 100644
--- a/test-files/golden-tests/config/auto-function-metadata/returns-from-special.adoc
+++ b/test-files/golden-tests/config/auto-function-metadata/returns-from-special.adoc
@@ -60,6 +60,30 @@ Declared in `&lt;returns&hyphen;from&hyphen;special&period;cpp&gt;`
 struct A;
 ----
 
+=== Non-Member Functions
+
+[cols=2]
+|===
+| Name
+| Description
+| link:#operator_not[`operator!`]
+| Negation operator
+| link:#operator_not_eq[`operator!&equals;`]
+| Inequality operator
+| link:#operator_lt[`operator&lt;`]
+| Less&hyphen;than operator
+| link:#operator_le[`operator&lt;&equals;`]
+| Less&hyphen;than&hyphen;or&hyphen;equal operator
+| link:#operator_3way[`operator&lt;&equals;&gt;`]
+| Three&hyphen;way comparison operator
+| link:#operator_eq[`operator&equals;&equals;`]
+| Equality operator
+| link:#operator_gt[`operator&gt;`]
+| Greater&hyphen;than operator
+| link:#operator_ge[`operator&gt;&equals;`]
+| Greater&hyphen;than&hyphen;or&hyphen;equal operator
+|===
+
 [#Undoc]
 == Undoc
 
@@ -529,6 +553,16 @@ Declared in `&lt;returns&hyphen;from&hyphen;special&period;cpp&gt;`
 struct ostream;
 ----
 
+=== Non-Member Functions
+
+[cols=2]
+|===
+| Name
+| Description
+| link:#operator_lshift[`operator&lt;&lt;`]
+| Stream insertion operator
+|===
+
 [#operator_lshift]
 == operator&lt;&lt;
 
diff --git a/test-files/golden-tests/config/auto-function-metadata/returns-from-special.html b/test-files/golden-tests/config/auto-function-metadata/returns-from-special.html
index 0fa92a3a6..e60a481f2 100644
--- a/test-files/golden-tests/config/auto-function-metadata/returns-from-special.html
+++ b/test-files/golden-tests/config/auto-function-metadata/returns-from-special.html
@@ -19,10 +19,10 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A"><code>A</code></a> </td><td><span>A helper class</span></td></tr><tr>
-<td><a href="#Undoc"><code>Undoc</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#X"><code>X</code></a> </td><td><span>Test class</span></td></tr><tr>
-<td><a href="#ostream"><code>ostream</code></a> </td><td><span>A fake output stream</span></td></tr>
+<td><a href="#A"><code>A</code></a> </td><td>A helper class</td></tr><tr>
+<td><a href="#Undoc"><code>Undoc</code></a> </td><td></td></tr><tr>
+<td><a href="#X"><code>X</code></a> </td><td>Test class</td></tr><tr>
+<td><a href="#ostream"><code>ostream</code></a> </td><td>A fake output stream</td></tr>
 </tbody>
 </table>
 
@@ -36,15 +36,15 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#operator_lshift"><code>operator&lt;&lt;</code></a> </td><td><span>Stream insertion operator</span></td></tr><tr>
-<td><a href="#operator_not"><code>operator!</code></a> </td><td><span>Negation operator</span></td></tr><tr>
-<td><a href="#operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td><span>Equality operator</span></td></tr><tr>
-<td><a href="#operator_not_eq"><code>operator!&#x3D;</code></a> </td><td><span>Inequality operator</span></td></tr><tr>
-<td><a href="#operator_lt"><code>operator&lt;</code></a> </td><td><span>Less-than operator</span></td></tr><tr>
-<td><a href="#operator_le"><code>operator&lt;&#x3D;</code></a> </td><td><span>Less-than-or-equal operator</span></td></tr><tr>
-<td><a href="#operator_gt"><code>operator&gt;</code></a> </td><td><span>Greater-than operator</span></td></tr><tr>
-<td><a href="#operator_ge"><code>operator&gt;&#x3D;</code></a> </td><td><span>Greater-than-or-equal operator</span></td></tr><tr>
-<td><a href="#operator_3way"><code>operator&lt;&#x3D;&gt;</code></a> </td><td><span>Three-way comparison operator</span></td></tr>
+<td><a href="#operator_lshift"><code>operator&lt;&lt;</code></a> </td><td>Stream insertion operator</td></tr><tr>
+<td><a href="#operator_not"><code>operator!</code></a> </td><td>Negation operator</td></tr><tr>
+<td><a href="#operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td>Equality operator</td></tr><tr>
+<td><a href="#operator_not_eq"><code>operator!&#x3D;</code></a> </td><td>Inequality operator</td></tr><tr>
+<td><a href="#operator_lt"><code>operator&lt;</code></a> </td><td>Less-than operator</td></tr><tr>
+<td><a href="#operator_le"><code>operator&lt;&#x3D;</code></a> </td><td>Less-than-or-equal operator</td></tr><tr>
+<td><a href="#operator_gt"><code>operator&gt;</code></a> </td><td>Greater-than operator</td></tr><tr>
+<td><a href="#operator_ge"><code>operator&gt;&#x3D;</code></a> </td><td>Greater-than-or-equal operator</td></tr><tr>
+<td><a href="#operator_3way"><code>operator&lt;&#x3D;&gt;</code></a> </td><td>Three-way comparison operator</td></tr>
 </tbody>
 </table>
 
@@ -53,8 +53,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="A">A</h2>
 <div>
-<span>A helper class</span>
-
+<p>A helper class</p>
 </div>
 </div>
 <div>
@@ -62,13 +61,32 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 
 
+<div>
+<h2>Non-Member Functions</h2>
+<table>
+<thead>
+<tr>
+<th>Name</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr><td><a href="#operator_not"><code>operator!</code></a></td><td>Negation operator</td></tr>
+<tr><td><a href="#operator_not_eq"><code>operator!&#x3D;</code></a></td><td>Inequality operator</td></tr>
+<tr><td><a href="#operator_lt"><code>operator&lt;</code></a></td><td>Less-than operator</td></tr>
+<tr><td><a href="#operator_le"><code>operator&lt;&#x3D;</code></a></td><td>Less-than-or-equal operator</td></tr>
+<tr><td><a href="#operator_3way"><code>operator&lt;&#x3D;&gt;</code></a></td><td>Three-way comparison operator</td></tr>
+<tr><td><a href="#operator_eq"><code>operator&#x3D;&#x3D;</code></a></td><td>Equality operator</td></tr>
+<tr><td><a href="#operator_gt"><code>operator&gt;</code></a></td><td>Greater-than operator</td></tr>
+<tr><td><a href="#operator_ge"><code>operator&gt;&#x3D;</code></a></td><td>Greater-than-or-equal operator</td></tr>
+</tbody>
+</table>
+</div>
 </div>
 <div>
 <div>
@@ -79,9 +97,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct Undoc;
-
-</code>
+<code class="source-code cpp">struct Undoc;</code>
 </pre>
 </div>
 
@@ -91,8 +107,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="X">X</h2>
 <div>
-<span>Test class</span>
-
+<p>Test class</p>
 </div>
 </div>
 <div>
@@ -100,9 +115,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct X;
-
-</code>
+<code class="source-code cpp">struct X;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -115,19 +128,19 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#X-operator_assign-0a"><code>operator&#x3D;</code></a> </td><td><span>Assignment operators</span></td></tr><tr>
-<td><a href="#X-operator_plus"><code>operator+</code></a> </td><td><span>Addition operator</span></td></tr><tr>
-<td><a href="#X-operator_ptr"><code>operator-&gt;</code></a> </td><td><span>Member access operator</span></td></tr><tr>
-<td><a href="#X-2conversion-00"><code>operator A</code></a> </td><td><span>Conversion to <code>A</code></span></td></tr><tr>
-<td><a href="#X-2conversion-03"><code>operator Undoc</code></a> </td><td><span>Conversion to <code>Undoc</code></span></td></tr><tr>
-<td><a href="#X-operator_not"><code>operator!</code></a> </td><td><span>Negation operator</span></td></tr><tr>
-<td><a href="#X-operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td><span>Equality operator</span></td></tr><tr>
-<td><a href="#X-operator_not_eq"><code>operator!&#x3D;</code></a> </td><td><span>Inequality operator</span></td></tr><tr>
-<td><a href="#X-operator_lt"><code>operator&lt;</code></a> </td><td><span>Less-than operator</span></td></tr><tr>
-<td><a href="#X-operator_le"><code>operator&lt;&#x3D;</code></a> </td><td><span>Less-than-or-equal operator</span></td></tr><tr>
-<td><a href="#X-operator_gt"><code>operator&gt;</code></a> </td><td><span>Greater-than operator</span></td></tr><tr>
-<td><a href="#X-operator_ge"><code>operator&gt;&#x3D;</code></a> </td><td><span>Greater-than-or-equal operator</span></td></tr><tr>
-<td><a href="#X-operator_3way"><code>operator&lt;&#x3D;&gt;</code></a> </td><td><span>Three-way comparison operator</span></td></tr>
+<td><a href="#X-operator_assign-0a"><code>operator&#x3D;</code></a> </td><td>Assignment operators</td></tr><tr>
+<td><a href="#X-operator_plus"><code>operator+</code></a> </td><td>Addition operator</td></tr><tr>
+<td><a href="#X-operator_ptr"><code>operator-&gt;</code></a> </td><td>Member access operator</td></tr><tr>
+<td><a href="#X-2conversion-00"><code>operator A</code></a> </td><td>Conversion to <code>A</code></td></tr><tr>
+<td><a href="#X-2conversion-03"><code>operator Undoc</code></a> </td><td>Conversion to <code>Undoc</code></td></tr><tr>
+<td><a href="#X-operator_not"><code>operator!</code></a> </td><td>Negation operator</td></tr><tr>
+<td><a href="#X-operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td>Equality operator</td></tr><tr>
+<td><a href="#X-operator_not_eq"><code>operator!&#x3D;</code></a> </td><td>Inequality operator</td></tr><tr>
+<td><a href="#X-operator_lt"><code>operator&lt;</code></a> </td><td>Less-than operator</td></tr><tr>
+<td><a href="#X-operator_le"><code>operator&lt;&#x3D;</code></a> </td><td>Less-than-or-equal operator</td></tr><tr>
+<td><a href="#X-operator_gt"><code>operator&gt;</code></a> </td><td>Greater-than operator</td></tr><tr>
+<td><a href="#X-operator_ge"><code>operator&gt;&#x3D;</code></a> </td><td>Greater-than-or-equal operator</td></tr><tr>
+<td><a href="#X-operator_3way"><code>operator&lt;&#x3D;&gt;</code></a> </td><td>Three-way comparison operator</td></tr>
 </tbody>
 </table>
 
@@ -138,28 +151,23 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="X-operator_assign-0a">X::operator&#x3D;</h2>
 <div>
-<span>Assignment operators</span>
-
+<p>Assignment operators</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
-<span>Assignment operator</span>
+<p>Assignment operator</p>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&
-<a href="#X-operator_assign-0d">operator&#x3D;</a>(<a href="#A">A</a> const& value);
-
-</code>
+<a href="#X-operator_assign-0d">operator&#x3D;</a>(<a href="#A">A</a> const& value);</code>
 </pre><span class="small"><a href="#X-operator_assign-0d"><em>» more...</em></a></span>
 
-<span>Assignment operator</span>
+<p>Assignment operator</p>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&&
-<a href="#X-operator_assign-07">operator&#x3D;</a>(<a href="#A">A</a>&& value);
-
-</code>
+<a href="#X-operator_assign-07">operator&#x3D;</a>(<a href="#A">A</a>&& value);</code>
 </pre><span class="small"><a href="#X-operator_assign-07"><em>» more...</em></a></span>
 
 
@@ -169,8 +177,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="X-operator_assign-0d">X::operator&#x3D;</h2>
 <div>
-<span>Assignment operator</span>
-
+<p>Assignment operator</p>
 </div>
 </div>
 <div>
@@ -179,14 +186,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&
-operator&#x3D;(<a href="#A">A</a> const& value);
-
-</code>
+operator&#x3D;(<a href="#A">A</a> const& value);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Reference to the current object</span>
+Reference to the current object
 </div>
 <div>
 <h3>Parameters</h3>
@@ -200,7 +205,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The object to copy assign from</span></td>
+<td>The object to copy assign from</td>
 </tr>
 </tbody>
 </table>
@@ -210,8 +215,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-operator_assign-07">X::operator&#x3D;</h2>
 <div>
-<span>Assignment operator</span>
-
+<p>Assignment operator</p>
 </div>
 </div>
 <div>
@@ -220,14 +224,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>&&
-operator&#x3D;(<a href="#A">A</a>&& value);
-
-</code>
+operator&#x3D;(<a href="#A">A</a>&& value);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Rvalue reference to the current object</span>
+Rvalue reference to the current object
 </div>
 <div>
 <h3>Parameters</h3>
@@ -241,7 +243,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The object to move assign from</span></td>
+<td>The object to move assign from</td>
 </tr>
 </tbody>
 </table>
@@ -251,8 +253,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-operator_plus">X::operator+</h2>
 <div>
-<span>Addition operator</span>
-
+<p>Addition operator</p>
 </div>
 </div>
 <div>
@@ -261,14 +262,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>
-operator+(<a href="#X">X</a> const& rhs) const;
-
-</code>
+operator+(<a href="#X">X</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Another instance of the object</span>
+Another instance of the object
 </div>
 <div>
 <h3>Parameters</h3>
@@ -282,7 +281,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -292,8 +291,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-operator_ptr">X::operator-&gt;</h2>
 <div>
-<span>Member access operator</span>
-
+<p>Member access operator</p>
 </div>
 </div>
 <div>
@@ -302,22 +300,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#X">X</a>*
-operator-&gt;();
-
-</code>
+operator-&gt;();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Pointer to the current object</span>
+Pointer to the current object
 </div>
 </div>
 <div>
 <div>
 <h2 id="X-2conversion-00">X::operator A</h2>
 <div>
-<span>Conversion to <code>A</code></span>
-
+<p>Conversion to <code>A</code></p>
 </div>
 </div>
 <div>
@@ -325,22 +320,19 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">operator <a href="#A">A</a>() const;
-
-</code>
+<code class="source-code cpp">operator <a href="#A">A</a>() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A helper class</span>
+A helper class
 </div>
 </div>
 <div>
 <div>
 <h2 id="X-2conversion-03">X::operator Undoc</h2>
 <div>
-<span>Conversion to <code>Undoc</code></span>
-
+<p>Conversion to <code>Undoc</code></p>
 </div>
 </div>
 <div>
@@ -348,22 +340,19 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">operator <a href="#Undoc">Undoc</a>() const;
-
-</code>
+<code class="source-code cpp">operator <a href="#Undoc">Undoc</a>() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The object converted to <code>Undoc</code></span>
+The object converted to <code>Undoc</code>
 </div>
 </div>
 <div>
 <div>
 <h2 id="X-operator_not">X::operator!</h2>
 <div>
-<span>Negation operator</span>
-
+<p>Negation operator</p>
 </div>
 </div>
 <div>
@@ -372,22 +361,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator!() const;
-
-</code>
+operator!() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the object is falsy, <code>false</code> otherwise</span>
+<code>true</code> if the object is falsy, <code>false</code> otherwise
 </div>
 </div>
 <div>
 <div>
 <h2 id="X-operator_eq">X::operator&#x3D;&#x3D;</h2>
 <div>
-<span>Equality operator</span>
-
+<p>Equality operator</p>
 </div>
 </div>
 <div>
@@ -396,14 +382,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator&#x3D;&#x3D;(<a href="#X">X</a> const& rhs) const;
-
-</code>
+operator&#x3D;&#x3D;(<a href="#X">X</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -417,7 +401,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -427,8 +411,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-operator_not_eq">X::operator!&#x3D;</h2>
 <div>
-<span>Inequality operator</span>
-
+<p>Inequality operator</p>
 </div>
 </div>
 <div>
@@ -437,14 +420,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator!&#x3D;(<a href="#X">X</a> const& rhs) const;
-
-</code>
+operator!&#x3D;(<a href="#X">X</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are not equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are not equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -458,7 +439,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -468,8 +449,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-operator_lt">X::operator&lt;</h2>
 <div>
-<span>Less-than operator</span>
-
+<p>Less-than operator</p>
 </div>
 </div>
 <div>
@@ -478,14 +458,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator&lt;(<a href="#X">X</a> const& rhs) const;
-
-</code>
+operator&lt;(<a href="#X">X</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the left object is less than the right object, <code>false</code> otherwise</span>
+<code>true</code> if the left object is less than the right object, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -499,7 +477,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -509,8 +487,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-operator_le">X::operator&lt;&#x3D;</h2>
 <div>
-<span>Less-than-or-equal operator</span>
-
+<p>Less-than-or-equal operator</p>
 </div>
 </div>
 <div>
@@ -519,14 +496,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator&lt;&#x3D;(<a href="#X">X</a> const& rhs) const;
-
-</code>
+operator&lt;&#x3D;(<a href="#X">X</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the left object is less than or equal to the right object, <code>false</code> otherwise</span>
+<code>true</code> if the left object is less than or equal to the right object, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -540,7 +515,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -550,8 +525,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-operator_gt">X::operator&gt;</h2>
 <div>
-<span>Greater-than operator</span>
-
+<p>Greater-than operator</p>
 </div>
 </div>
 <div>
@@ -560,14 +534,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator&gt;(<a href="#X">X</a> const& rhs) const;
-
-</code>
+operator&gt;(<a href="#X">X</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the left object is greater than the right object, <code>false</code> otherwise</span>
+<code>true</code> if the left object is greater than the right object, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -581,7 +553,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -591,8 +563,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-operator_ge">X::operator&gt;&#x3D;</h2>
 <div>
-<span>Greater-than-or-equal operator</span>
-
+<p>Greater-than-or-equal operator</p>
 </div>
 </div>
 <div>
@@ -601,14 +572,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator&gt;&#x3D;(<a href="#X">X</a> const& rhs) const;
-
-</code>
+operator&gt;&#x3D;(<a href="#X">X</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the left object is greater than or equal to the right object, <code>false</code> otherwise</span>
+<code>true</code> if the left object is greater than or equal to the right object, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -622,7 +591,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -632,8 +601,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-operator_3way">X::operator&lt;&#x3D;&gt;</h2>
 <div>
-<span>Three-way comparison operator</span>
-
+<p>Three-way comparison operator</p>
 </div>
 </div>
 <div>
@@ -642,14 +610,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">auto
-operator&lt;&#x3D;&gt;(<a href="#X">X</a> const& rhs) const;
-
-</code>
+operator&lt;&#x3D;&gt;(<a href="#X">X</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The relative order of the objects</span>
+The relative order of the objects
 </div>
 <div>
 <h3>Parameters</h3>
@@ -663,7 +629,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -673,8 +639,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="ostream">ostream</h2>
 <div>
-<span>A fake output stream</span>
-
+<p>A fake output stream</p>
 </div>
 </div>
 <div>
@@ -682,20 +647,31 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct ostream;
-
-</code>
+<code class="source-code cpp">struct ostream;</code>
 </pre>
 </div>
 
 
+<div>
+<h2>Non-Member Functions</h2>
+<table>
+<thead>
+<tr>
+<th>Name</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr><td><a href="#operator_lshift"><code>operator&lt;&lt;</code></a></td><td>Stream insertion operator</td></tr>
+</tbody>
+</table>
+</div>
 </div>
 <div>
 <div>
 <h2 id="operator_lshift">operator&lt;&lt;</h2>
 <div>
-<span>Stream insertion operator</span>
-
+<p>Stream insertion operator</p>
 </div>
 </div>
 <div>
@@ -706,14 +682,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp"><a href="#ostream">ostream</a>&
 operator&lt;&lt;(
     <a href="#ostream">ostream</a>& os,
-    <a href="#A">A</a> const& value);
-
-</code>
+    <a href="#A">A</a> const& value);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Reference to the current output stream</span>
+Reference to the current output stream
 </div>
 <div>
 <h3>Parameters</h3>
@@ -727,11 +701,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>os</strong></td>
-<td><span>An output stream</span></td>
+<td>An output stream</td>
 </tr>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The object to output</span></td>
+<td>The object to output</td>
 </tr>
 </tbody>
 </table>
@@ -741,8 +715,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_not">operator!</h2>
 <div>
-<span>Negation operator</span>
-
+<p>Negation operator</p>
 </div>
 </div>
 <div>
@@ -751,14 +724,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;returns-from-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator!(<a href="#A">A</a> const& value);
-
-</code>
+operator!(<a href="#A">A</a> const& value);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the object is falsy, <code>false</code> otherwise</span>
+<code>true</code> if the object is falsy, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -772,7 +743,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The operand</span></td>
+<td>The operand</td>
 </tr>
 </tbody>
 </table>
@@ -782,8 +753,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_eq">operator&#x3D;&#x3D;</h2>
 <div>
-<span>Equality operator</span>
-
+<p>Equality operator</p>
 </div>
 </div>
 <div>
@@ -794,14 +764,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">bool
 operator&#x3D;&#x3D;(
     <a href="#A">A</a> const& lhs,
-    <a href="#A">A</a> const& rhs);
-
-</code>
+    <a href="#A">A</a> const& rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -815,11 +783,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -829,8 +797,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_not_eq">operator!&#x3D;</h2>
 <div>
-<span>Inequality operator</span>
-
+<p>Inequality operator</p>
 </div>
 </div>
 <div>
@@ -841,14 +808,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">bool
 operator!&#x3D;(
     <a href="#A">A</a> const& lhs,
-    <a href="#A">A</a> const& rhs);
-
-</code>
+    <a href="#A">A</a> const& rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are not equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are not equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -862,11 +827,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -876,8 +841,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_lt">operator&lt;</h2>
 <div>
-<span>Less-than operator</span>
-
+<p>Less-than operator</p>
 </div>
 </div>
 <div>
@@ -888,14 +852,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">bool
 operator&lt;(
     <a href="#A">A</a> const& lhs,
-    <a href="#A">A</a> const& rhs);
-
-</code>
+    <a href="#A">A</a> const& rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the left object is less than the right object, <code>false</code> otherwise</span>
+<code>true</code> if the left object is less than the right object, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -909,11 +871,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -923,8 +885,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_le">operator&lt;&#x3D;</h2>
 <div>
-<span>Less-than-or-equal operator</span>
-
+<p>Less-than-or-equal operator</p>
 </div>
 </div>
 <div>
@@ -935,14 +896,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">bool
 operator&lt;&#x3D;(
     <a href="#A">A</a> const& lhs,
-    <a href="#A">A</a> const& rhs);
-
-</code>
+    <a href="#A">A</a> const& rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the left object is less than or equal to the right object, <code>false</code> otherwise</span>
+<code>true</code> if the left object is less than or equal to the right object, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -956,11 +915,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -970,8 +929,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_gt">operator&gt;</h2>
 <div>
-<span>Greater-than operator</span>
-
+<p>Greater-than operator</p>
 </div>
 </div>
 <div>
@@ -982,14 +940,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">bool
 operator&gt;(
     <a href="#A">A</a> const& lhs,
-    <a href="#A">A</a> const& rhs);
-
-</code>
+    <a href="#A">A</a> const& rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the left object is greater than the right object, <code>false</code> otherwise</span>
+<code>true</code> if the left object is greater than the right object, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -1003,11 +959,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -1017,8 +973,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_ge">operator&gt;&#x3D;</h2>
 <div>
-<span>Greater-than-or-equal operator</span>
-
+<p>Greater-than-or-equal operator</p>
 </div>
 </div>
 <div>
@@ -1029,14 +984,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">bool
 operator&gt;&#x3D;(
     <a href="#A">A</a> const& lhs,
-    <a href="#A">A</a> const& rhs);
-
-</code>
+    <a href="#A">A</a> const& rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the left object is greater than or equal to the right object, <code>false</code> otherwise</span>
+<code>true</code> if the left object is greater than or equal to the right object, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -1050,11 +1003,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -1064,8 +1017,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_3way">operator&lt;&#x3D;&gt;</h2>
 <div>
-<span>Three-way comparison operator</span>
-
+<p>Three-way comparison operator</p>
 </div>
 </div>
 <div>
@@ -1076,14 +1028,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">auto
 operator&lt;&#x3D;&gt;(
     <a href="#A">A</a> const& lhs,
-    <a href="#A">A</a> const& rhs);
-
-</code>
+    <a href="#A">A</a> const& rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The relative order of the objects</span>
+The relative order of the objects
 </div>
 <div>
 <h3>Parameters</h3>
@@ -1097,11 +1047,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/config/auto-function-metadata/returns-from-special.xml b/test-files/golden-tests/config/auto-function-metadata/returns-from-special.xml
index 91b8ee830..79acf1842 100644
--- a/test-files/golden-tests/config/auto-function-metadata/returns-from-special.xml
+++ b/test-files/golden-tests/config/auto-function-metadata/returns-from-special.xml
@@ -8,6 +8,16 @@
       <brief>
         <text>A helper class</text>
       </brief>
+      <related>
+        <reference id="yuKyBhGbND+Kyypyb9UsuC4Qe3E=">operator!</reference>
+        <reference id="4MuN1V3fHVfOMvtg2LT+QVm/XmE=">operator!=</reference>
+        <reference id="TFzwjGmsRFw8/0KXWcNJ2hjptZA=">operator&lt;</reference>
+        <reference id="PCL/yV8DLimc1O5rgMCsXr2rz7s=">operator&lt;=</reference>
+        <reference id="89EonDQZVWNcdopm5CdG3ShJQjo=">operator&lt;=&gt;</reference>
+        <reference id="kibUx6k1SXB+HsXkRXroJl9f59w=">operator==</reference>
+        <reference id="mFT9ttIGXVcpN6jtSrnEnclPRwU=">operator&gt;</reference>
+        <reference id="dl5ECjWFv+MMFzli4qz59OqD2Z4=">operator&gt;=</reference>
+      </related>
     </doc>
   </struct>
   <struct name="Undoc" id="9rZb+QO/AFLNBwbIrSOzFktZiVY=">
@@ -357,6 +367,9 @@
       <brief>
         <text>A fake output stream</text>
       </brief>
+      <related>
+        <reference id="YufiLU3QRbcE/EbZ/1/y0UPKQxo=">operator&lt;&lt;</reference>
+      </related>
     </doc>
   </struct>
   <function name="operator&lt;&lt;" id="YufiLU3QRbcE/EbZ/1/y0UPKQxo=">
@@ -390,6 +403,9 @@
       <param name="value">
         <text>The object to output</text>
       </param>
+      <relates>
+        <reference id="S6h+1uM4q9FLs9aohvL2EV9oRbs=">ostream</reference>
+      </relates>
     </doc>
   </function>
   <function name="operator!" id="yuKyBhGbND+Kyypyb9UsuC4Qe3E=">
@@ -416,6 +432,9 @@
       <param name="value">
         <text>The operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
   <function name="operator==" id="kibUx6k1SXB+HsXkRXroJl9f59w=">
@@ -450,6 +469,9 @@
       <param name="rhs">
         <text>The right operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
   <function name="operator!=" id="4MuN1V3fHVfOMvtg2LT+QVm/XmE=">
@@ -484,6 +506,9 @@
       <param name="rhs">
         <text>The right operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
   <function name="operator&lt;" id="TFzwjGmsRFw8/0KXWcNJ2hjptZA=">
@@ -518,6 +543,9 @@
       <param name="rhs">
         <text>The right operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
   <function name="operator&lt;=" id="PCL/yV8DLimc1O5rgMCsXr2rz7s=">
@@ -552,6 +580,9 @@
       <param name="rhs">
         <text>The right operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
   <function name="operator&gt;" id="mFT9ttIGXVcpN6jtSrnEnclPRwU=">
@@ -586,6 +617,9 @@
       <param name="rhs">
         <text>The right operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
   <function name="operator&gt;=" id="dl5ECjWFv+MMFzli4qz59OqD2Z4=">
@@ -620,6 +654,9 @@
       <param name="rhs">
         <text>The right operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
   <function name="operator&lt;=&gt;" id="89EonDQZVWNcdopm5CdG3ShJQjo=">
@@ -652,6 +689,9 @@
       <param name="rhs">
         <text>The right operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
 </namespace>
diff --git a/test-files/golden-tests/config/auto-relates/auto-relates.html b/test-files/golden-tests/config/auto-relates/auto-relates.html
index 864536adf..f50d7347a 100644
--- a/test-files/golden-tests/config/auto-relates/auto-relates.html
+++ b/test-files/golden-tests/config/auto-relates/auto-relates.html
@@ -19,7 +19,7 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A"><code>A</code></a> </td><td><span>A class with non-member functions</span></td></tr>
+<td><a href="#A"><code>A</code></a> </td><td>A class with non-member functions</td></tr>
 </tbody>
 </table>
 
@@ -33,12 +33,12 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f1"><code>f1</code></a> </td><td><span>A non-member function of A</span></td></tr><tr>
-<td><a href="#f2"><code>f2</code></a> </td><td><span>A non-member function of A</span></td></tr><tr>
-<td><a href="#f3"><code>f3</code></a> </td><td><span>A non-member function of A</span></td></tr><tr>
-<td><a href="#f4"><code>f4</code></a> </td><td><span>A non-member function of A</span></td></tr><tr>
-<td><a href="#f5"><code>f5</code></a> </td><td><span>A non-member function of A</span></td></tr><tr>
-<td><a href="#f6"><code>f6</code></a> </td><td><span>A non-member function of A</span></td></tr>
+<td><a href="#f1"><code>f1</code></a> </td><td>A non-member function of A</td></tr><tr>
+<td><a href="#f2"><code>f2</code></a> </td><td>A non-member function of A</td></tr><tr>
+<td><a href="#f3"><code>f3</code></a> </td><td>A non-member function of A</td></tr><tr>
+<td><a href="#f4"><code>f4</code></a> </td><td>A non-member function of A</td></tr><tr>
+<td><a href="#f5"><code>f5</code></a> </td><td>A non-member function of A</td></tr><tr>
+<td><a href="#f6"><code>f6</code></a> </td><td>A non-member function of A</td></tr>
 </tbody>
 </table>
 
@@ -47,8 +47,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="A">A</h2>
 <div>
-<span>A class with non-member functions</span>
-
+<p>A class with non-member functions</p>
 </div>
 </div>
 <div>
@@ -56,9 +55,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;auto-relates.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class A;
-
-</code>
+<code class="source-code cpp">class A;</code>
 </pre>
 </div>
 
@@ -73,12 +70,12 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#f1"><code>f1</code></a></td><td><span>A non-member function of A</span></td></tr>
-<tr><td><a href="#f2"><code>f2</code></a></td><td><span>A non-member function of A</span></td></tr>
-<tr><td><a href="#f3"><code>f3</code></a></td><td><span>A non-member function of A</span></td></tr>
-<tr><td><a href="#f4"><code>f4</code></a></td><td><span>A non-member function of A</span></td></tr>
-<tr><td><a href="#f5"><code>f5</code></a></td><td><span>A non-member function of A</span></td></tr>
-<tr><td><a href="#f6"><code>f6</code></a></td><td><span>A non-member function of A</span></td></tr>
+<tr><td><a href="#f1"><code>f1</code></a></td><td>A non-member function of A</td></tr>
+<tr><td><a href="#f2"><code>f2</code></a></td><td>A non-member function of A</td></tr>
+<tr><td><a href="#f3"><code>f3</code></a></td><td>A non-member function of A</td></tr>
+<tr><td><a href="#f4"><code>f4</code></a></td><td>A non-member function of A</td></tr>
+<tr><td><a href="#f5"><code>f5</code></a></td><td>A non-member function of A</td></tr>
+<tr><td><a href="#f6"><code>f6</code></a></td><td>A non-member function of A</td></tr>
 </tbody>
 </table>
 </div>
@@ -87,8 +84,7 @@ <h2>Non-Member Functions</h2>
 <div>
 <h2 id="f1">f1</h2>
 <div>
-<span>A non-member function of A</span>
-
+<p>A non-member function of A</p>
 </div>
 </div>
 <div>
@@ -97,9 +93,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-relates.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1(<a href="#A">A</a>);
-
-</code>
+f1(<a href="#A">A</a>);</code>
 </pre>
 </div>
 </div>
@@ -107,8 +101,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f2">f2</h2>
 <div>
-<span>A non-member function of A</span>
-
+<p>A non-member function of A</p>
 </div>
 </div>
 <div>
@@ -117,9 +110,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-relates.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2(<a href="#A">A</a>&);
-
-</code>
+f2(<a href="#A">A</a>&);</code>
 </pre>
 </div>
 </div>
@@ -127,8 +118,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f3">f3</h2>
 <div>
-<span>A non-member function of A</span>
-
+<p>A non-member function of A</p>
 </div>
 </div>
 <div>
@@ -137,9 +127,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-relates.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f3(<a href="#A">A</a> const&);
-
-</code>
+f3(<a href="#A">A</a> const&);</code>
 </pre>
 </div>
 </div>
@@ -147,8 +135,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f4">f4</h2>
 <div>
-<span>A non-member function of A</span>
-
+<p>A non-member function of A</p>
 </div>
 </div>
 <div>
@@ -157,9 +144,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-relates.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f4(<a href="#A">A</a>*);
-
-</code>
+f4(<a href="#A">A</a>*);</code>
 </pre>
 </div>
 </div>
@@ -167,8 +152,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f5">f5</h2>
 <div>
-<span>A non-member function of A</span>
-
+<p>A non-member function of A</p>
 </div>
 </div>
 <div>
@@ -177,9 +161,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-relates.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5(<a href="#A">A</a> const*);
-
-</code>
+f5(<a href="#A">A</a> const*);</code>
 </pre>
 </div>
 </div>
@@ -187,8 +169,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f6">f6</h2>
 <div>
-<span>A non-member function of A</span>
-
+<p>A non-member function of A</p>
 </div>
 </div>
 <div>
@@ -197,9 +178,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto-relates.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6(<a href="#A">A</a> const*);
-
-</code>
+f6(<a href="#A">A</a> const*);</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/auto-relates/derived.html b/test-files/golden-tests/config/auto-relates/derived.html
index eec4965d0..89399b3fe 100644
--- a/test-files/golden-tests/config/auto-relates/derived.html
+++ b/test-files/golden-tests/config/auto-relates/derived.html
@@ -19,10 +19,10 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A"><code>A</code></a> </td><td><span>A concrete implementation for ABase</span></td></tr><tr>
-<td><a href="#ABase"><code>ABase</code></a> </td><td><span>A base class for non-member functions</span></td></tr><tr>
-<td><a href="#AView"><code>AView</code></a> </td><td><span>A view of A</span></td></tr><tr>
-<td><a href="#AView2"><code>AView2</code></a> </td><td><span>Another view of A</span></td></tr>
+<td><a href="#A"><code>A</code></a> </td><td>A concrete implementation for ABase</td></tr><tr>
+<td><a href="#ABase"><code>ABase</code></a> </td><td>A base class for non-member functions</td></tr><tr>
+<td><a href="#AView"><code>AView</code></a> </td><td>A view of A</td></tr><tr>
+<td><a href="#AView2"><code>AView2</code></a> </td><td>Another view of A</td></tr>
 </tbody>
 </table>
 
@@ -36,12 +36,12 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f1"><code>f1</code></a> </td><td><span>A non-member function of ABase</span></td></tr><tr>
-<td><a href="#f2"><code>f2</code></a> </td><td><span>A non-member function of ABase</span></td></tr><tr>
-<td><a href="#f3"><code>f3</code></a> </td><td><span>A non-member function of ABase</span></td></tr><tr>
-<td><a href="#f4"><code>f4</code></a> </td><td><span>A non-member function of ABase</span></td></tr><tr>
-<td><a href="#f5"><code>f5</code></a> </td><td><span>A non-member function of ABase</span></td></tr><tr>
-<td><a href="#n"><code>n</code></a> </td><td><span>A non-member function of ABase only</span></td></tr>
+<td><a href="#f1"><code>f1</code></a> </td><td>A non-member function of ABase</td></tr><tr>
+<td><a href="#f2"><code>f2</code></a> </td><td>A non-member function of ABase</td></tr><tr>
+<td><a href="#f3"><code>f3</code></a> </td><td>A non-member function of ABase</td></tr><tr>
+<td><a href="#f4"><code>f4</code></a> </td><td>A non-member function of ABase</td></tr><tr>
+<td><a href="#f5"><code>f5</code></a> </td><td>A non-member function of ABase</td></tr><tr>
+<td><a href="#n"><code>n</code></a> </td><td>A non-member function of ABase only</td></tr>
 </tbody>
 </table>
 
@@ -50,8 +50,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="A">A</h2>
 <div>
-<span>A concrete implementation for ABase</span>
-
+<p>A concrete implementation for ABase</p>
 </div>
 </div>
 <div>
@@ -60,9 +59,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;derived.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct A
-    : <a href="#ABase">ABase</a>
-
-</code>
+    : <a href="#ABase">ABase</a></code>
 </pre>
 </div>
 <div>
@@ -75,7 +72,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#ABase">ABase</a></code></td><td><span>A base class for non-member functions</span></td></tr>
+<tr><td><code><a href="#ABase">ABase</a></code></td><td>A base class for non-member functions</td></tr>
 </tbody>
 </table>
 </div>
@@ -91,11 +88,11 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#f1"><code>f1</code></a></td><td><span>A non-member function of ABase</span></td></tr>
-<tr><td><a href="#f2"><code>f2</code></a></td><td><span>A non-member function of ABase</span></td></tr>
-<tr><td><a href="#f3"><code>f3</code></a></td><td><span>A non-member function of ABase</span></td></tr>
-<tr><td><a href="#f4"><code>f4</code></a></td><td><span>A non-member function of ABase</span></td></tr>
-<tr><td><a href="#f5"><code>f5</code></a></td><td><span>A non-member function of ABase</span></td></tr>
+<tr><td><a href="#f1"><code>f1</code></a></td><td>A non-member function of ABase</td></tr>
+<tr><td><a href="#f2"><code>f2</code></a></td><td>A non-member function of ABase</td></tr>
+<tr><td><a href="#f3"><code>f3</code></a></td><td>A non-member function of ABase</td></tr>
+<tr><td><a href="#f4"><code>f4</code></a></td><td>A non-member function of ABase</td></tr>
+<tr><td><a href="#f5"><code>f5</code></a></td><td>A non-member function of ABase</td></tr>
 </tbody>
 </table>
 </div>
@@ -104,8 +101,7 @@ <h2>Non-Member Functions</h2>
 <div>
 <h2 id="ABase">ABase</h2>
 <div>
-<span>A base class for non-member functions</span>
-
+<p>A base class for non-member functions</p>
 </div>
 </div>
 <div>
@@ -113,9 +109,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;derived.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct ABase;
-
-</code>
+<code class="source-code cpp">struct ABase;</code>
 </pre>
 </div>
 
@@ -130,12 +124,12 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#f1"><code>f1</code></a></td><td><span>A non-member function of ABase</span></td></tr>
-<tr><td><a href="#f2"><code>f2</code></a></td><td><span>A non-member function of ABase</span></td></tr>
-<tr><td><a href="#f3"><code>f3</code></a></td><td><span>A non-member function of ABase</span></td></tr>
-<tr><td><a href="#f4"><code>f4</code></a></td><td><span>A non-member function of ABase</span></td></tr>
-<tr><td><a href="#f5"><code>f5</code></a></td><td><span>A non-member function of ABase</span></td></tr>
-<tr><td><a href="#n"><code>n</code></a></td><td><span>A non-member function of ABase only</span></td></tr>
+<tr><td><a href="#f1"><code>f1</code></a></td><td>A non-member function of ABase</td></tr>
+<tr><td><a href="#f2"><code>f2</code></a></td><td>A non-member function of ABase</td></tr>
+<tr><td><a href="#f3"><code>f3</code></a></td><td>A non-member function of ABase</td></tr>
+<tr><td><a href="#f4"><code>f4</code></a></td><td>A non-member function of ABase</td></tr>
+<tr><td><a href="#f5"><code>f5</code></a></td><td>A non-member function of ABase</td></tr>
+<tr><td><a href="#n"><code>n</code></a></td><td>A non-member function of ABase only</td></tr>
 </tbody>
 </table>
 </div>
@@ -150,9 +144,9 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#A"><code>A</code></a>
-    </td><td><span>A concrete implementation for ABase</span></td></tr>
+    </td><td>A concrete implementation for ABase</td></tr>
 <tr><td><a href="#AView"><code>AView</code></a>
-    </td><td><span>A view of A</span></td></tr>
+    </td><td>A view of A</td></tr>
 </tbody>
 </table>
 </div>
@@ -161,8 +155,7 @@ <h2>Derived Classes</h2>
 <div>
 <h2 id="AView">AView</h2>
 <div>
-<span>A view of A</span>
-
+<p>A view of A</p>
 </div>
 </div>
 <div>
@@ -171,9 +164,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;derived.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct AView
-    : <a href="#ABase">ABase</a>
-
-</code>
+    : <a href="#ABase">ABase</a></code>
 </pre>
 </div>
 <div>
@@ -186,7 +177,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#ABase">ABase</a></code></td><td><span>A base class for non-member functions</span></td></tr>
+<tr><td><code><a href="#ABase">ABase</a></code></td><td>A base class for non-member functions</td></tr>
 </tbody>
 </table>
 </div>
@@ -202,11 +193,11 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#f1"><code>f1</code></a></td><td><span>A non-member function of ABase</span></td></tr>
-<tr><td><a href="#f2"><code>f2</code></a></td><td><span>A non-member function of ABase</span></td></tr>
-<tr><td><a href="#f3"><code>f3</code></a></td><td><span>A non-member function of ABase</span></td></tr>
-<tr><td><a href="#f4"><code>f4</code></a></td><td><span>A non-member function of ABase</span></td></tr>
-<tr><td><a href="#f5"><code>f5</code></a></td><td><span>A non-member function of ABase</span></td></tr>
+<tr><td><a href="#f1"><code>f1</code></a></td><td>A non-member function of ABase</td></tr>
+<tr><td><a href="#f2"><code>f2</code></a></td><td>A non-member function of ABase</td></tr>
+<tr><td><a href="#f3"><code>f3</code></a></td><td>A non-member function of ABase</td></tr>
+<tr><td><a href="#f4"><code>f4</code></a></td><td>A non-member function of ABase</td></tr>
+<tr><td><a href="#f5"><code>f5</code></a></td><td>A non-member function of ABase</td></tr>
 </tbody>
 </table>
 </div>
@@ -221,7 +212,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#AView2"><code>AView2</code></a>
-    </td><td><span>Another view of A</span></td></tr>
+    </td><td>Another view of A</td></tr>
 </tbody>
 </table>
 </div>
@@ -230,8 +221,7 @@ <h2>Derived Classes</h2>
 <div>
 <h2 id="AView2">AView2</h2>
 <div>
-<span>Another view of A</span>
-
+<p>Another view of A</p>
 </div>
 </div>
 <div>
@@ -240,9 +230,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;derived.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct AView2
-    : <a href="#AView">AView</a>
-
-</code>
+    : <a href="#AView">AView</a></code>
 </pre>
 </div>
 <div>
@@ -255,7 +243,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#AView">AView</a></code></td><td><span>A view of A</span></td></tr>
+<tr><td><code><a href="#AView">AView</a></code></td><td>A view of A</td></tr>
 </tbody>
 </table>
 </div>
@@ -271,11 +259,11 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#f1"><code>f1</code></a></td><td><span>A non-member function of ABase</span></td></tr>
-<tr><td><a href="#f2"><code>f2</code></a></td><td><span>A non-member function of ABase</span></td></tr>
-<tr><td><a href="#f3"><code>f3</code></a></td><td><span>A non-member function of ABase</span></td></tr>
-<tr><td><a href="#f4"><code>f4</code></a></td><td><span>A non-member function of ABase</span></td></tr>
-<tr><td><a href="#f5"><code>f5</code></a></td><td><span>A non-member function of ABase</span></td></tr>
+<tr><td><a href="#f1"><code>f1</code></a></td><td>A non-member function of ABase</td></tr>
+<tr><td><a href="#f2"><code>f2</code></a></td><td>A non-member function of ABase</td></tr>
+<tr><td><a href="#f3"><code>f3</code></a></td><td>A non-member function of ABase</td></tr>
+<tr><td><a href="#f4"><code>f4</code></a></td><td>A non-member function of ABase</td></tr>
+<tr><td><a href="#f5"><code>f5</code></a></td><td>A non-member function of ABase</td></tr>
 </tbody>
 </table>
 </div>
@@ -288,8 +276,7 @@ <h3>Description</h3>
 <div>
 <h2 id="f1">f1</h2>
 <div>
-<span>A non-member function of ABase</span>
-
+<p>A non-member function of ABase</p>
 </div>
 </div>
 <div>
@@ -298,9 +285,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;derived.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1(<a href="#ABase">ABase</a> const&);
-
-</code>
+f1(<a href="#ABase">ABase</a> const&);</code>
 </pre>
 </div>
 </div>
@@ -308,8 +293,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f2">f2</h2>
 <div>
-<span>A non-member function of ABase</span>
-
+<p>A non-member function of ABase</p>
 </div>
 </div>
 <div>
@@ -318,9 +302,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;derived.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2(<a href="#ABase">ABase</a>&);
-
-</code>
+f2(<a href="#ABase">ABase</a>&);</code>
 </pre>
 </div>
 </div>
@@ -328,8 +310,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f3">f3</h2>
 <div>
-<span>A non-member function of ABase</span>
-
+<p>A non-member function of ABase</p>
 </div>
 </div>
 <div>
@@ -338,9 +319,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;derived.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f3(<a href="#ABase">ABase</a> const*);
-
-</code>
+f3(<a href="#ABase">ABase</a> const*);</code>
 </pre>
 </div>
 </div>
@@ -348,8 +327,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f4">f4</h2>
 <div>
-<span>A non-member function of ABase</span>
-
+<p>A non-member function of ABase</p>
 </div>
 </div>
 <div>
@@ -358,9 +336,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;derived.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f4(<a href="#ABase">ABase</a>*);
-
-</code>
+f4(<a href="#ABase">ABase</a>*);</code>
 </pre>
 </div>
 </div>
@@ -368,8 +344,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f5">f5</h2>
 <div>
-<span>A non-member function of ABase</span>
-
+<p>A non-member function of ABase</p>
 </div>
 </div>
 <div>
@@ -378,9 +353,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;derived.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5(<a href="#ABase">ABase</a> const*);
-
-</code>
+f5(<a href="#ABase">ABase</a> const*);</code>
 </pre>
 </div>
 </div>
@@ -388,8 +361,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="n">n</h2>
 <div>
-<span>A non-member function of ABase only</span>
-
+<p>A non-member function of ABase only</p>
 </div>
 </div>
 <div>
@@ -398,9 +370,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;derived.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-n(<a href="#ABase">ABase</a>);
-
-</code>
+n(<a href="#ABase">ABase</a>);</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/auto-relates/enum.html b/test-files/golden-tests/config/auto-relates/enum.html
index d7067e504..ba6073a7a 100644
--- a/test-files/golden-tests/config/auto-relates/enum.html
+++ b/test-files/golden-tests/config/auto-relates/enum.html
@@ -19,8 +19,8 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#Result"><code>Result</code></a> </td><td><span>Helper result class</span></td></tr><tr>
-<td><a href="#SmallVector"><code>SmallVector</code></a> </td><td><span>Helper result class</span></td></tr>
+<td><a href="#Result"><code>Result</code></a> </td><td>Helper result class</td></tr><tr>
+<td><a href="#SmallVector"><code>SmallVector</code></a> </td><td>Helper result class</td></tr>
 </tbody>
 </table>
 
@@ -34,7 +34,7 @@ <h2>Enums</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#E"><code>E</code></a> </td><td><span>An enum with non-member functions</span></td></tr>
+<td><a href="#E"><code>E</code></a> </td><td>An enum with non-member functions</td></tr>
 </tbody>
 </table>
 
@@ -48,9 +48,9 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#makeE"><code>makeE</code></a> </td><td><span>Function that returns A</span></td></tr><tr>
-<td><a href="#makeEs"><code>makeEs</code></a> </td><td><span>Function that returns template on A</span></td></tr><tr>
-<td><a href="#tryMakeE"><code>tryMakeE</code></a> </td><td><span>Function that returns template on A</span></td></tr>
+<td><a href="#makeE"><code>makeE</code></a> </td><td>Function that returns A</td></tr><tr>
+<td><a href="#makeEs"><code>makeEs</code></a> </td><td>Function that returns template on A</td></tr><tr>
+<td><a href="#tryMakeE"><code>tryMakeE</code></a> </td><td>Function that returns template on A</td></tr>
 </tbody>
 </table>
 
@@ -59,8 +59,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="Result">Result</h2>
 <div>
-<span>Helper result class</span>
-
+<p>Helper result class</p>
 </div>
 </div>
 <div>
@@ -69,9 +68,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;enum.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class T&gt;
-class Result;
-
-</code>
+class Result;</code>
 </pre>
 </div>
 
@@ -86,7 +83,7 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#tryMakeE"><code>tryMakeE</code></a></td><td><span>Function that returns template on A</span></td></tr>
+<tr><td><a href="#tryMakeE"><code>tryMakeE</code></a></td><td>Function that returns template on A</td></tr>
 </tbody>
 </table>
 </div>
@@ -95,8 +92,7 @@ <h2>Non-Member Functions</h2>
 <div>
 <h2 id="SmallVector">SmallVector</h2>
 <div>
-<span>Helper result class</span>
-
+<p>Helper result class</p>
 </div>
 </div>
 <div>
@@ -107,9 +103,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     class T,
     unsigned long N&gt;
-class SmallVector;
-
-</code>
+class SmallVector;</code>
 </pre>
 </div>
 
@@ -124,7 +118,7 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#makeEs"><code>makeEs</code></a></td><td><span>Function that returns template on A</span></td></tr>
+<tr><td><a href="#makeEs"><code>makeEs</code></a></td><td>Function that returns template on A</td></tr>
 </tbody>
 </table>
 </div>
@@ -133,8 +127,7 @@ <h2>Non-Member Functions</h2>
 <div>
 <h2 id="E">E</h2>
 <div>
-<span>An enum with non-member functions</span>
-
+<p>An enum with non-member functions</p>
 </div>
 </div>
 <div>
@@ -142,9 +135,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;enum.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">enum class E : int;
-
-</code>
+<code class="source-code cpp">enum class E : int;</code>
 </pre>
 </div>
 <div>
@@ -157,9 +148,9 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#makeE"><code>makeE</code></a></td><td><span>Function that returns A</span></td></tr>
-<tr><td><a href="#makeEs"><code>makeEs</code></a></td><td><span>Function that returns template on A</span></td></tr>
-<tr><td><a href="#tryMakeE"><code>tryMakeE</code></a></td><td><span>Function that returns template on A</span></td></tr>
+<tr><td><a href="#makeE"><code>makeE</code></a></td><td>Function that returns A</td></tr>
+<tr><td><a href="#makeEs"><code>makeEs</code></a></td><td>Function that returns template on A</td></tr>
+<tr><td><a href="#tryMakeE"><code>tryMakeE</code></a></td><td>Function that returns template on A</td></tr>
 </tbody>
 </table>
 </div>
@@ -168,8 +159,7 @@ <h2>Non-Member Functions</h2>
 <div>
 <h2 id="makeE">makeE</h2>
 <div>
-<span>Function that returns A</span>
-
+<p>Function that returns A</p>
 </div>
 </div>
 <div>
@@ -178,22 +168,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;enum.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#E">E</a>
-makeE();
-
-</code>
+makeE();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>An instance of A</span>
+An instance of A
 </div>
 </div>
 <div>
 <div>
 <h2 id="makeEs">makeEs</h2>
 <div>
-<span>Function that returns template on A</span>
-
+<p>Function that returns template on A</p>
 </div>
 </div>
 <div>
@@ -202,22 +189,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;enum.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#SmallVector">SmallVector&lt;E, 3&gt;</a>
-makeEs();
-
-</code>
+makeEs();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A vector of As</span>
+A vector of As
 </div>
 </div>
 <div>
 <div>
 <h2 id="tryMakeE">tryMakeE</h2>
 <div>
-<span>Function that returns template on A</span>
-
+<p>Function that returns template on A</p>
 </div>
 </div>
 <div>
@@ -226,14 +210,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;enum.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#Result">Result&lt;E&gt;</a>
-tryMakeE();
-
-</code>
+tryMakeE();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>An instance of A or an error</span>
+An instance of A or an error
 </div>
 </div>
 
diff --git a/test-files/golden-tests/config/auto-relates/no-auto-relates.html b/test-files/golden-tests/config/auto-relates/no-auto-relates.html
index cf48c0f84..082ac009f 100644
--- a/test-files/golden-tests/config/auto-relates/no-auto-relates.html
+++ b/test-files/golden-tests/config/auto-relates/no-auto-relates.html
@@ -19,7 +19,7 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A"><code>A</code></a> </td><td><span>A class with non-member functions</span></td></tr>
+<td><a href="#A"><code>A</code></a> </td><td>A class with non-member functions</td></tr>
 </tbody>
 </table>
 
@@ -33,12 +33,12 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f1"><code>f1</code></a> </td><td><span>A non-member function of A</span></td></tr><tr>
-<td><a href="#f2"><code>f2</code></a> </td><td><span>A non-member function of A</span></td></tr><tr>
-<td><a href="#f3"><code>f3</code></a> </td><td><span>A non-member function of A</span></td></tr><tr>
-<td><a href="#f4"><code>f4</code></a> </td><td><span>A non-member function of A</span></td></tr><tr>
-<td><a href="#f5"><code>f5</code></a> </td><td><span>A non-member function of A</span></td></tr><tr>
-<td><a href="#f6"><code>f6</code></a> </td><td><span>A non-member function of A</span></td></tr>
+<td><a href="#f1"><code>f1</code></a> </td><td>A non-member function of A</td></tr><tr>
+<td><a href="#f2"><code>f2</code></a> </td><td>A non-member function of A</td></tr><tr>
+<td><a href="#f3"><code>f3</code></a> </td><td>A non-member function of A</td></tr><tr>
+<td><a href="#f4"><code>f4</code></a> </td><td>A non-member function of A</td></tr><tr>
+<td><a href="#f5"><code>f5</code></a> </td><td>A non-member function of A</td></tr><tr>
+<td><a href="#f6"><code>f6</code></a> </td><td>A non-member function of A</td></tr>
 </tbody>
 </table>
 
@@ -47,8 +47,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="A">A</h2>
 <div>
-<span>A class with non-member functions</span>
-
+<p>A class with non-member functions</p>
 </div>
 </div>
 <div>
@@ -56,9 +55,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;no-auto-relates.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class A;
-
-</code>
+<code class="source-code cpp">class A;</code>
 </pre>
 </div>
 
@@ -68,8 +65,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f1">f1</h2>
 <div>
-<span>A non-member function of A</span>
-
+<p>A non-member function of A</p>
 </div>
 </div>
 <div>
@@ -78,9 +74,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-relates.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1(<a href="#A">A</a>);
-
-</code>
+f1(<a href="#A">A</a>);</code>
 </pre>
 </div>
 </div>
@@ -88,8 +82,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f2">f2</h2>
 <div>
-<span>A non-member function of A</span>
-
+<p>A non-member function of A</p>
 </div>
 </div>
 <div>
@@ -98,9 +91,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-relates.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2(<a href="#A">A</a>&);
-
-</code>
+f2(<a href="#A">A</a>&);</code>
 </pre>
 </div>
 </div>
@@ -108,8 +99,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f3">f3</h2>
 <div>
-<span>A non-member function of A</span>
-
+<p>A non-member function of A</p>
 </div>
 </div>
 <div>
@@ -118,9 +108,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-relates.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f3(<a href="#A">A</a> const&);
-
-</code>
+f3(<a href="#A">A</a> const&);</code>
 </pre>
 </div>
 </div>
@@ -128,8 +116,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f4">f4</h2>
 <div>
-<span>A non-member function of A</span>
-
+<p>A non-member function of A</p>
 </div>
 </div>
 <div>
@@ -138,9 +125,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-relates.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f4(<a href="#A">A</a>*);
-
-</code>
+f4(<a href="#A">A</a>*);</code>
 </pre>
 </div>
 </div>
@@ -148,8 +133,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f5">f5</h2>
 <div>
-<span>A non-member function of A</span>
-
+<p>A non-member function of A</p>
 </div>
 </div>
 <div>
@@ -158,9 +142,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-relates.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5(<a href="#A">A</a> const*);
-
-</code>
+f5(<a href="#A">A</a> const*);</code>
 </pre>
 </div>
 </div>
@@ -168,8 +150,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f6">f6</h2>
 <div>
-<span>A non-member function of A</span>
-
+<p>A non-member function of A</p>
 </div>
 </div>
 <div>
@@ -178,9 +159,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-auto-relates.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6(<a href="#A">A</a> const*);
-
-</code>
+f6(<a href="#A">A</a> const*);</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/auto-relates/qualified.html b/test-files/golden-tests/config/auto-relates/qualified.html
index 78c5c329d..fa739bf85 100644
--- a/test-files/golden-tests/config/auto-relates/qualified.html
+++ b/test-files/golden-tests/config/auto-relates/qualified.html
@@ -33,7 +33,7 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A"><code>A</code></a> </td><td><span>A class with non-member functions</span></td></tr>
+<td><a href="#A"><code>A</code></a> </td><td>A class with non-member functions</td></tr>
 </tbody>
 </table>
 
@@ -47,8 +47,8 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f1"><code>f1</code></a> </td><td><span>A non-member function of A</span></td></tr><tr>
-<td><a href="#f5"><code>f5</code></a> </td><td><span>A non-member function of ::N::B</span></td></tr>
+<td><a href="#f1"><code>f1</code></a> </td><td>A non-member function of A</td></tr><tr>
+<td><a href="#f5"><code>f5</code></a> </td><td>A non-member function of ::N::B</td></tr>
 </tbody>
 </table>
 
@@ -80,7 +80,7 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#N-B"><code>B</code></a> </td><td><span>A nested class with non-member functions</span></td></tr>
+<td><a href="#N-B"><code>B</code></a> </td><td>A nested class with non-member functions</td></tr>
 </tbody>
 </table>
 
@@ -94,8 +94,8 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#N-f2"><code>f2</code></a> </td><td><span>A non-member function of A</span></td></tr><tr>
-<td><a href="#N-f3"><code>f3</code></a> </td><td><span>A non-member function of B</span></td></tr>
+<td><a href="#N-f2"><code>f2</code></a> </td><td>A non-member function of A</td></tr><tr>
+<td><a href="#N-f3"><code>f3</code></a> </td><td>A non-member function of B</td></tr>
 </tbody>
 </table>
 
@@ -114,7 +114,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#N-M-f4"><code>f4</code></a> </td><td><span>A non-member function of ::N::B</span></td></tr>
+<td><a href="#N-M-f4"><code>f4</code></a> </td><td>A non-member function of ::N::B</td></tr>
 </tbody>
 </table>
 
@@ -123,8 +123,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="N-M-f4">N::M::f4</h2>
 <div>
-<span>A non-member function of ::N::B</span>
-
+<p>A non-member function of ::N::B</p>
 </div>
 </div>
 <div>
@@ -133,9 +132,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f4(<a href="#N-B">N::B</a> const&);
-
-</code>
+f4(<a href="#N-B">N::B</a> const&);</code>
 </pre>
 </div>
 </div>
@@ -143,8 +140,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="N-B">N::B</h2>
 <div>
-<span>A nested class with non-member functions</span>
-
+<p>A nested class with non-member functions</p>
 </div>
 </div>
 <div>
@@ -152,9 +148,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct B;
-
-</code>
+<code class="source-code cpp">struct B;</code>
 </pre>
 </div>
 
@@ -169,10 +163,10 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#N-f3"><code>f3</code></a></td><td><span>A non-member function of B</span></td></tr>
-<tr><td><a href="#N-M-f4"><code>M::f4</code></a></td><td><span>A non-member function of ::N::B</span></td></tr>
-<tr><td><a href="#f5"><code>::f5</code></a></td><td><span>A non-member function of ::N::B</span></td></tr>
-<tr><td><a href="#O-f6"><code>::O::f6</code></a></td><td><span>A non-member function of ::N::B</span></td></tr>
+<tr><td><a href="#N-f3"><code>f3</code></a></td><td>A non-member function of B</td></tr>
+<tr><td><a href="#N-M-f4"><code>M::f4</code></a></td><td>A non-member function of ::N::B</td></tr>
+<tr><td><a href="#f5"><code>::f5</code></a></td><td>A non-member function of ::N::B</td></tr>
+<tr><td><a href="#O-f6"><code>::O::f6</code></a></td><td>A non-member function of ::N::B</td></tr>
 </tbody>
 </table>
 </div>
@@ -181,8 +175,7 @@ <h2>Non-Member Functions</h2>
 <div>
 <h2 id="N-f2">N::f2</h2>
 <div>
-<span>A non-member function of A</span>
-
+<p>A non-member function of A</p>
 </div>
 </div>
 <div>
@@ -191,9 +184,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2(<a href="#A">A</a>&);
-
-</code>
+f2(<a href="#A">A</a>&);</code>
 </pre>
 </div>
 </div>
@@ -201,8 +192,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="N-f3">N::f3</h2>
 <div>
-<span>A non-member function of B</span>
-
+<p>A non-member function of B</p>
 </div>
 </div>
 <div>
@@ -211,9 +201,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f3(<a href="#N-B">N::B</a> const&);
-
-</code>
+f3(<a href="#N-B">N::B</a> const&);</code>
 </pre>
 </div>
 </div>
@@ -231,7 +219,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#O-f6"><code>f6</code></a> </td><td><span>A non-member function of ::N::B</span></td></tr>
+<td><a href="#O-f6"><code>f6</code></a> </td><td>A non-member function of ::N::B</td></tr>
 </tbody>
 </table>
 
@@ -240,8 +228,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="O-f6">O::f6</h2>
 <div>
-<span>A non-member function of ::N::B</span>
-
+<p>A non-member function of ::N::B</p>
 </div>
 </div>
 <div>
@@ -250,9 +237,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6(<a href="#N-B">N::B</a> const&);
-
-</code>
+f6(<a href="#N-B">N::B</a> const&);</code>
 </pre>
 </div>
 </div>
@@ -260,8 +245,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="A">A</h2>
 <div>
-<span>A class with non-member functions</span>
-
+<p>A class with non-member functions</p>
 </div>
 </div>
 <div>
@@ -269,9 +253,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 
@@ -286,8 +268,8 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#f1"><code>f1</code></a></td><td><span>A non-member function of A</span></td></tr>
-<tr><td><a href="#N-f2"><code>N::f2</code></a></td><td><span>A non-member function of A</span></td></tr>
+<tr><td><a href="#f1"><code>f1</code></a></td><td>A non-member function of A</td></tr>
+<tr><td><a href="#N-f2"><code>N::f2</code></a></td><td>A non-member function of A</td></tr>
 </tbody>
 </table>
 </div>
@@ -296,8 +278,7 @@ <h2>Non-Member Functions</h2>
 <div>
 <h2 id="f1">f1</h2>
 <div>
-<span>A non-member function of A</span>
-
+<p>A non-member function of A</p>
 </div>
 </div>
 <div>
@@ -306,9 +287,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1(<a href="#A">A</a> const&);
-
-</code>
+f1(<a href="#A">A</a> const&);</code>
 </pre>
 </div>
 </div>
@@ -316,8 +295,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f5">f5</h2>
 <div>
-<span>A non-member function of ::N::B</span>
-
+<p>A non-member function of ::N::B</p>
 </div>
 </div>
 <div>
@@ -326,9 +304,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5(<a href="#N-B">N::B</a> const&);
-
-</code>
+f5(<a href="#N-B">N::B</a> const&);</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/auto-relates/remove-friend.html b/test-files/golden-tests/config/auto-relates/remove-friend.html
index d1420b279..3d37741eb 100644
--- a/test-files/golden-tests/config/auto-relates/remove-friend.html
+++ b/test-files/golden-tests/config/auto-relates/remove-friend.html
@@ -19,7 +19,7 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A"><code>A</code></a> </td><td><span>A record with non-member functions</span></td></tr>
+<td><a href="#A"><code>A</code></a> </td><td>A record with non-member functions</td></tr>
 </tbody>
 </table>
 
@@ -33,8 +33,8 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#to_string"><code>to_string</code></a> </td><td><span>Non-member function of A</span></td></tr><tr>
-<td><a href="#operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td><span>Friend function not listed as non-member</span></td></tr>
+<td><a href="#to_string"><code>to_string</code></a> </td><td>Non-member function of A</td></tr><tr>
+<td><a href="#operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td>Friend function not listed as non-member</td></tr>
 </tbody>
 </table>
 
@@ -43,8 +43,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="A">A</h2>
 <div>
-<span>A record with non-member functions</span>
-
+<p>A record with non-member functions</p>
 </div>
 </div>
 <div>
@@ -52,9 +51,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;remove-friend.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class A;
-
-</code>
+<code class="source-code cpp">class A;</code>
 </pre>
 </div>
 
@@ -71,7 +68,7 @@ <h2>Friends</h2>
 <tbody>
 <tr>
 <td><code><a href="#operator_eq">operator&#x3D;&#x3D;</a></code></td>
-<td><span>Friend function not listed as non-member</span></td>
+<td>Friend function not listed as non-member</td>
 </tr>
 |===
 </tbody>
@@ -87,7 +84,7 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#to_string"><code>to_string</code></a></td><td><span>Non-member function of A</span></td></tr>
+<tr><td><a href="#to_string"><code>to_string</code></a></td><td>Non-member function of A</td></tr>
 </tbody>
 </table>
 </div>
@@ -96,8 +93,7 @@ <h2>Non-Member Functions</h2>
 <div>
 <h2 id="to_string">to_string</h2>
 <div>
-<span>Non-member function of A</span>
-
+<p>Non-member function of A</p>
 </div>
 </div>
 <div>
@@ -106,14 +102,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;remove-friend.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">char const*
-to_string(<a href="#A">A</a> const& a);
-
-</code>
+to_string(<a href="#A">A</a> const& a);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The string representation of the object</span>
+The string representation of the object
 </div>
 <div>
 <h3>Parameters</h3>
@@ -127,7 +121,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The object to stringify</span></td>
+<td>The object to stringify</td>
 </tr>
 </tbody>
 </table>
@@ -137,8 +131,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_eq">operator&#x3D;&#x3D;</h2>
 <div>
-<span>Friend function not listed as non-member</span>
-
+<p>Friend function not listed as non-member</p>
 </div>
 </div>
 <div>
@@ -149,9 +142,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">bool
 operator&#x3D;&#x3D;(
     <a href="#A">A</a> const& lhs,
-    <a href="#A">A</a> const& rhs);
-
-</code>
+    <a href="#A">A</a> const& rhs);</code>
 </pre>
 </div>
 <div>
@@ -160,7 +151,7 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are equal</span>
+<code>true</code> if the objects are equal
 </div>
 <div>
 <h3>Parameters</h3>
@@ -174,11 +165,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left-hand side of the comparison</span></td>
+<td>The left-hand side of the comparison</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right-hand side of the comparison</span></td>
+<td>The right-hand side of the comparison</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/config/auto-relates/return-type.html b/test-files/golden-tests/config/auto-relates/return-type.html
index da9cdc6dc..67c8fa0a7 100644
--- a/test-files/golden-tests/config/auto-relates/return-type.html
+++ b/test-files/golden-tests/config/auto-relates/return-type.html
@@ -19,9 +19,9 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A"><code>A</code></a> </td><td><span>A class with non-member functions</span></td></tr><tr>
-<td><a href="#Result"><code>Result</code></a> </td><td><span>Helper result class</span></td></tr><tr>
-<td><a href="#SmallVector"><code>SmallVector</code></a> </td><td><span>Helper result class</span></td></tr>
+<td><a href="#A"><code>A</code></a> </td><td>A class with non-member functions</td></tr><tr>
+<td><a href="#Result"><code>Result</code></a> </td><td>Helper result class</td></tr><tr>
+<td><a href="#SmallVector"><code>SmallVector</code></a> </td><td>Helper result class</td></tr>
 </tbody>
 </table>
 
@@ -35,9 +35,9 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#makeA"><code>makeA</code></a> </td><td><span>Function that returns A</span></td></tr><tr>
-<td><a href="#makeAs"><code>makeAs</code></a> </td><td><span>Function that returns template on A</span></td></tr><tr>
-<td><a href="#tryMakeA"><code>tryMakeA</code></a> </td><td><span>Function that returns template on A</span></td></tr>
+<td><a href="#makeA"><code>makeA</code></a> </td><td>Function that returns A</td></tr><tr>
+<td><a href="#makeAs"><code>makeAs</code></a> </td><td>Function that returns template on A</td></tr><tr>
+<td><a href="#tryMakeA"><code>tryMakeA</code></a> </td><td>Function that returns template on A</td></tr>
 </tbody>
 </table>
 
@@ -46,8 +46,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="A">A</h2>
 <div>
-<span>A class with non-member functions</span>
-
+<p>A class with non-member functions</p>
 </div>
 </div>
 <div>
@@ -55,9 +54,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;return-type.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class A;
-
-</code>
+<code class="source-code cpp">class A;</code>
 </pre>
 </div>
 
@@ -72,9 +69,9 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#makeA"><code>makeA</code></a></td><td><span>Function that returns A</span></td></tr>
-<tr><td><a href="#makeAs"><code>makeAs</code></a></td><td><span>Function that returns template on A</span></td></tr>
-<tr><td><a href="#tryMakeA"><code>tryMakeA</code></a></td><td><span>Function that returns template on A</span></td></tr>
+<tr><td><a href="#makeA"><code>makeA</code></a></td><td>Function that returns A</td></tr>
+<tr><td><a href="#makeAs"><code>makeAs</code></a></td><td>Function that returns template on A</td></tr>
+<tr><td><a href="#tryMakeA"><code>tryMakeA</code></a></td><td>Function that returns template on A</td></tr>
 </tbody>
 </table>
 </div>
@@ -83,8 +80,7 @@ <h2>Non-Member Functions</h2>
 <div>
 <h2 id="Result">Result</h2>
 <div>
-<span>Helper result class</span>
-
+<p>Helper result class</p>
 </div>
 </div>
 <div>
@@ -93,9 +89,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;return-type.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class T&gt;
-class Result;
-
-</code>
+class Result;</code>
 </pre>
 </div>
 
@@ -110,7 +104,7 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#tryMakeA"><code>tryMakeA</code></a></td><td><span>Function that returns template on A</span></td></tr>
+<tr><td><a href="#tryMakeA"><code>tryMakeA</code></a></td><td>Function that returns template on A</td></tr>
 </tbody>
 </table>
 </div>
@@ -119,8 +113,7 @@ <h2>Non-Member Functions</h2>
 <div>
 <h2 id="SmallVector">SmallVector</h2>
 <div>
-<span>Helper result class</span>
-
+<p>Helper result class</p>
 </div>
 </div>
 <div>
@@ -131,9 +124,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     class T,
     unsigned long N&gt;
-class SmallVector;
-
-</code>
+class SmallVector;</code>
 </pre>
 </div>
 
@@ -148,7 +139,7 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#makeAs"><code>makeAs</code></a></td><td><span>Function that returns template on A</span></td></tr>
+<tr><td><a href="#makeAs"><code>makeAs</code></a></td><td>Function that returns template on A</td></tr>
 </tbody>
 </table>
 </div>
@@ -157,8 +148,7 @@ <h2>Non-Member Functions</h2>
 <div>
 <h2 id="makeA">makeA</h2>
 <div>
-<span>Function that returns A</span>
-
+<p>Function that returns A</p>
 </div>
 </div>
 <div>
@@ -167,22 +157,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;return-type.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>
-makeA();
-
-</code>
+makeA();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>An instance of A</span>
+An instance of A
 </div>
 </div>
 <div>
 <div>
 <h2 id="makeAs">makeAs</h2>
 <div>
-<span>Function that returns template on A</span>
-
+<p>Function that returns template on A</p>
 </div>
 </div>
 <div>
@@ -191,22 +178,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;return-type.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#SmallVector">SmallVector&lt;A, 3&gt;</a>
-makeAs();
-
-</code>
+makeAs();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A vector of As</span>
+A vector of As
 </div>
 </div>
 <div>
 <div>
 <h2 id="tryMakeA">tryMakeA</h2>
 <div>
-<span>Function that returns template on A</span>
-
+<p>Function that returns template on A</p>
 </div>
 </div>
 <div>
@@ -215,14 +199,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;return-type.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#Result">Result&lt;A&gt;</a>
-tryMakeA();
-
-</code>
+tryMakeA();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>An instance of A or an error</span>
+An instance of A or an error
 </div>
 </div>
 
diff --git a/test-files/golden-tests/config/extract-all/no-extract-all.html b/test-files/golden-tests/config/extract-all/no-extract-all.html
index 9e1d32b46..d7b96dca0 100644
--- a/test-files/golden-tests/config/extract-all/no-extract-all.html
+++ b/test-files/golden-tests/config/extract-all/no-extract-all.html
@@ -19,8 +19,8 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#docFunction"><code>docFunction</code></a> </td><td><span>Documented function</span></td></tr><tr>
-<td><a href="#sometimesDocFunction"><code>sometimesDocFunction</code></a> </td><td><span>Sometimes documented function</span></td></tr>
+<td><a href="#docFunction"><code>docFunction</code></a> </td><td>Documented function</td></tr><tr>
+<td><a href="#sometimesDocFunction"><code>sometimesDocFunction</code></a> </td><td>Sometimes documented function</td></tr>
 </tbody>
 </table>
 
@@ -29,8 +29,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="docFunction">docFunction</h2>
 <div>
-<span>Documented function</span>
-
+<p>Documented function</p>
 </div>
 </div>
 <div>
@@ -39,9 +38,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-extract-all.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-docFunction();
-
-</code>
+docFunction();</code>
 </pre>
 </div>
 </div>
@@ -49,8 +46,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="sometimesDocFunction">sometimesDocFunction</h2>
 <div>
-<span>Sometimes documented function</span>
-
+<p>Sometimes documented function</p>
 </div>
 </div>
 <div>
@@ -59,9 +55,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-extract-all.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-sometimesDocFunction();
-
-</code>
+sometimesDocFunction();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/extract-empty-namespaces/no-extract-empty-namespaces.adoc b/test-files/golden-tests/config/extract-empty-namespaces/no-extract-empty-namespaces.adoc
index f1c9a99fb..d96c4b1bc 100644
--- a/test-files/golden-tests/config/extract-empty-namespaces/no-extract-empty-namespaces.adoc
+++ b/test-files/golden-tests/config/extract-empty-namespaces/no-extract-empty-namespaces.adoc
@@ -40,7 +40,6 @@
 |===
 | Name
 | link:#regular_ns[`regular&lowbar;ns`]
-| empty&lowbar;ns
 |===
 
 
diff --git a/test-files/golden-tests/config/extract-empty-namespaces/no-extract-empty-namespaces.html b/test-files/golden-tests/config/extract-empty-namespaces/no-extract-empty-namespaces.html
index f86f17833..c183f1751 100644
--- a/test-files/golden-tests/config/extract-empty-namespaces/no-extract-empty-namespaces.html
+++ b/test-files/golden-tests/config/extract-empty-namespaces/no-extract-empty-namespaces.html
@@ -19,11 +19,11 @@ <h2>Namespaces</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#documented_ns"><code>documented_ns</code></a> </td><td><span>Namespace documentation</span></td></tr><tr>
-<td><a href="#mixed_ns"><code>mixed_ns</code></a> </td><td><span>Should decay to see-below</span></td></tr><tr>
-<td><a href="#mixed_regular_ns"><code>mixed_regular_ns</code></a> </td><td><span>Should decay to regular</span></td></tr><tr>
-<td><a href="#regular_ns"><code>regular_ns</code></a> </td><td><span>Regular namespace</span></td></tr><tr>
-<td><a href="#see_below_ns"><code>see_below_ns</code></a> </td><td><span>Should decay to see-below</span></td></tr>
+<td><a href="#documented_ns"><code>documented_ns</code></a> </td><td>Namespace documentation</td></tr><tr>
+<td><a href="#mixed_ns"><code>mixed_ns</code></a> </td><td>Should decay to see-below</td></tr><tr>
+<td><a href="#mixed_regular_ns"><code>mixed_regular_ns</code></a> </td><td>Should decay to regular</td></tr><tr>
+<td><a href="#regular_ns"><code>regular_ns</code></a> </td><td>Regular namespace</td></tr><tr>
+<td><a href="#see_below_ns"><code>see_below_ns</code></a> </td><td>Should decay to see-below</td></tr>
 </tbody>
 </table>
 
@@ -37,8 +37,8 @@ <h2>Namespace Aliases</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#empty_ns_alias"><code>empty_ns_alias</code></a> </td><td><span>Should still work</span></td></tr><tr>
-<td><a href="#regular_ns_alias"><code>regular_ns_alias</code></a> </td><td><span>Should work</span></td></tr>
+<td><a href="#empty_ns_alias"><code>empty_ns_alias</code></a> </td><td>Should still work</td></tr><tr>
+<td><a href="#regular_ns_alias"><code>regular_ns_alias</code></a> </td><td>Should work</td></tr>
 </tbody>
 </table>
 
@@ -52,8 +52,7 @@ <h2>Using Namespace Directives</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#regular_ns"><code>regular_ns</code></a></td></tr><tr>
-<td>empty_ns</td></tr>
+<td><a href="#regular_ns"><code>regular_ns</code></a></td></tr>
 </tbody>
 </table>
 
@@ -65,8 +64,7 @@ <h2>Using Namespace Directives</h2>
 <div>
 <h2 id="documented_ns">documented_ns</h2>
 <div>
-<span>Namespace documentation</span>
-
+<p>Namespace documentation</p>
 </div>
 </div>
 </div>
@@ -74,8 +72,7 @@ <h2 id="documented_ns">documented_ns</h2>
 <div>
 <h2 id="mixed_ns">mixed_ns</h2>
 <div>
-<span>Should decay to see-below</span>
-
+<p>Should decay to see-below</p>
 </div>
 </div>
 <h2>Types</h2>
@@ -101,9 +98,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;no-extract-empty-namespaces.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct SeeBelowStructA { /* see-below */ };
-
-</code>
+<code class="source-code cpp">struct SeeBelowStructA { /* see-below */ };</code>
 </pre>
 </div>
 
@@ -113,8 +108,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="mixed_regular_ns">mixed_regular_ns</h2>
 <div>
-<span>Should decay to regular</span>
-
+<p>Should decay to regular</p>
 </div>
 </div>
 <h2>Types</h2>
@@ -141,9 +135,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;no-extract-empty-namespaces.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct RegularStructA;
-
-</code>
+<code class="source-code cpp">struct RegularStructA;</code>
 </pre>
 </div>
 
@@ -158,9 +150,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;no-extract-empty-namespaces.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct SeeBelowStructB { /* see-below */ };
-
-</code>
+<code class="source-code cpp">struct SeeBelowStructB { /* see-below */ };</code>
 </pre>
 </div>
 
@@ -170,8 +160,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="regular_ns">regular_ns</h2>
 <div>
-<span>Regular namespace</span>
-
+<p>Regular namespace</p>
 </div>
 </div>
 <h2>Types</h2>
@@ -197,9 +186,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;no-extract-empty-namespaces.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 
@@ -209,8 +196,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="see_below_ns">see_below_ns</h2>
 <div>
-<span>Should decay to see-below</span>
-
+<p>Should decay to see-below</p>
 </div>
 </div>
 <h2>Types</h2>
@@ -237,9 +223,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;no-extract-empty-namespaces.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct SeeBelowStructA { /* see-below */ };
-
-</code>
+<code class="source-code cpp">struct SeeBelowStructA { /* see-below */ };</code>
 </pre>
 </div>
 
@@ -254,9 +238,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;no-extract-empty-namespaces.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct SeeBelowStructB { /* see-below */ };
-
-</code>
+<code class="source-code cpp">struct SeeBelowStructB { /* see-below */ };</code>
 </pre>
 </div>
 
@@ -266,8 +248,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="empty_ns_alias">empty_ns_alias</h2>
 <div>
-<span>Should still work</span>
-
+<p>Should still work</p>
 </div>
 </div>
 <div>
@@ -275,9 +256,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;no-extract-empty-namespaces.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">namespace empty_ns_alias = empty_ns;
-
-</code>
+<code class="source-code cpp">namespace empty_ns_alias = empty_ns;</code>
 </pre>
 </div>
 </div>
@@ -285,8 +264,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="regular_ns_alias">regular_ns_alias</h2>
 <div>
-<span>Should work</span>
-
+<p>Should work</p>
 </div>
 </div>
 <div>
@@ -294,9 +272,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;no-extract-empty-namespaces.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">namespace regular_ns_alias = <a href="#regular_ns">regular_ns</a>;
-
-</code>
+<code class="source-code cpp">namespace regular_ns_alias = <a href="#regular_ns">regular_ns</a>;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/extract-friends/extract-friends.html b/test-files/golden-tests/config/extract-friends/extract-friends.html
index a3d3a6dcd..adaeb360f 100644
--- a/test-files/golden-tests/config/extract-friends/extract-friends.html
+++ b/test-files/golden-tests/config/extract-friends/extract-friends.html
@@ -65,9 +65,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;extract-friends.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class T&gt;
-class hash;
-
-</code>
+class hash;</code>
 </pre>
 </div>
 
@@ -83,9 +81,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;extract-friends.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-class <a href="#std-hash-03">hash</a>&lt;<a href="#A">A</a>&gt;;
-
-</code>
+class <a href="#std-hash-03">hash</a>&lt;<a href="#A">A</a>&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -114,9 +110,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;extract-friends.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">unsigned long long
-operator()(<a href="#A">A</a> const& rhs) const noexcept;
-
-</code>
+operator()(<a href="#A">A</a> const& rhs) const noexcept;</code>
 </pre>
 </div>
 </div>
@@ -129,9 +123,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;extract-friends.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class A;
-
-</code>
+<code class="source-code cpp">class A;</code>
 </pre>
 </div>
 
@@ -148,7 +140,7 @@ <h2>Friends</h2>
 <tbody>
 <tr>
 <td><code><a href="#std-hash-08">hash&lt;A&gt;</a></code></td>
-<td><span></span></td>
+<td></td>
 </tr>
 |===
 </tbody>
diff --git a/test-files/golden-tests/config/extract-friends/no-extract-friends.html b/test-files/golden-tests/config/extract-friends/no-extract-friends.html
index 39b59f654..3fd1f45ec 100644
--- a/test-files/golden-tests/config/extract-friends/no-extract-friends.html
+++ b/test-files/golden-tests/config/extract-friends/no-extract-friends.html
@@ -65,9 +65,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-extract-friends.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class T&gt;
-class hash;
-
-</code>
+class hash;</code>
 </pre>
 </div>
 
@@ -83,9 +81,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-extract-friends.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-class <a href="#std-hash-03">hash</a>&lt;<a href="#A">A</a>&gt;;
-
-</code>
+class <a href="#std-hash-03">hash</a>&lt;<a href="#A">A</a>&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -114,9 +110,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-extract-friends.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">unsigned long long
-operator()(<a href="#A">A</a> const& rhs) const noexcept;
-
-</code>
+operator()(<a href="#A">A</a> const& rhs) const noexcept;</code>
 </pre>
 </div>
 </div>
@@ -129,9 +123,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;no-extract-friends.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class A;
-
-</code>
+<code class="source-code cpp">class A;</code>
 </pre>
 </div>
 
diff --git a/test-files/golden-tests/config/extract-implicit-specializations/base.html b/test-files/golden-tests/config/extract-implicit-specializations/base.html
index 080cd6166..3e46df884 100644
--- a/test-files/golden-tests/config/extract-implicit-specializations/base.html
+++ b/test-files/golden-tests/config/extract-implicit-specializations/base.html
@@ -34,9 +34,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;base.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct A
-    : <a href="#B">B</a>
-
-</code>
+    : <a href="#B">B</a></code>
 </pre>
 </div>
 <div>
@@ -49,7 +47,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#B">B</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#B">B</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -78,9 +76,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;base.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct B;
-
-</code>
+<code class="source-code cpp">struct B;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -109,7 +105,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#A"><code>A</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -124,9 +120,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;base.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int
-value();
-
-</code>
+value();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/extract-implicit-specializations/extract-implicit-specializations.html b/test-files/golden-tests/config/extract-implicit-specializations/extract-implicit-specializations.html
index a0445f7d8..6ab21a496 100644
--- a/test-files/golden-tests/config/extract-implicit-specializations/extract-implicit-specializations.html
+++ b/test-files/golden-tests/config/extract-implicit-specializations/extract-implicit-specializations.html
@@ -34,9 +34,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;extract-implicit-specializations.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct A
-    : <a href="#B-00">B&lt;int&gt;</a>
-
-</code>
+    : <a href="#B-00">B&lt;int&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -49,7 +47,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#B-00">B&lt;int&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#B-00">B&lt;int&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -79,9 +77,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;extract-implicit-specializations.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int&
-value();
-
-</code>
+value();</code>
 </pre>
 </div>
 </div>
@@ -95,9 +91,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;extract-implicit-specializations.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -126,7 +120,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#A"><code>A</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -141,9 +135,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;extract-implicit-specializations.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">T&
-value();
-
-</code>
+value();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/extract-implicit-specializations/no-extract-implicit-specializations.html b/test-files/golden-tests/config/extract-implicit-specializations/no-extract-implicit-specializations.html
index a74e7f1bd..10d24cf79 100644
--- a/test-files/golden-tests/config/extract-implicit-specializations/no-extract-implicit-specializations.html
+++ b/test-files/golden-tests/config/extract-implicit-specializations/no-extract-implicit-specializations.html
@@ -34,9 +34,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-extract-implicit-specializations.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct A
-    : <a href="#B">B&lt;int&gt;</a>
-
-</code>
+    : <a href="#B">B&lt;int&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -49,7 +47,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#B">B&lt;int&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#B">B&lt;int&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -79,9 +77,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-extract-implicit-specializations.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -110,7 +106,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#A"><code>A</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -125,9 +121,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-extract-implicit-specializations.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">T&
-value();
-
-</code>
+value();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/extract-local-classes/extract-local-classes.html b/test-files/golden-tests/config/extract-local-classes/extract-local-classes.html
index 76f34a006..3dc82446d 100644
--- a/test-files/golden-tests/config/extract-local-classes/extract-local-classes.html
+++ b/test-files/golden-tests/config/extract-local-classes/extract-local-classes.html
@@ -46,9 +46,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;extract-local-classes.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class local_class;
-
-</code>
+<code class="source-code cpp">class local_class;</code>
 </pre>
 </div>
 
@@ -63,9 +61,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;extract-local-classes.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct local_struct;
-
-</code>
+<code class="source-code cpp">struct local_struct;</code>
 </pre>
 </div>
 
@@ -81,9 +77,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;extract-local-classes.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-local_function();
-
-</code>
+local_function();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/extract-local-classes/no-extract-local-classes.html b/test-files/golden-tests/config/extract-local-classes/no-extract-local-classes.html
index cd05f7b23..9e4ff6f33 100644
--- a/test-files/golden-tests/config/extract-local-classes/no-extract-local-classes.html
+++ b/test-files/golden-tests/config/extract-local-classes/no-extract-local-classes.html
@@ -33,9 +33,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no-extract-local-classes.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-local_function();
-
-</code>
+local_function();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/extract-private-virtual/extract-private-virtual.html b/test-files/golden-tests/config/extract-private-virtual/extract-private-virtual.html
index 6e01f1352..e74a6ff89 100644
--- a/test-files/golden-tests/config/extract-private-virtual/extract-private-virtual.html
+++ b/test-files/golden-tests/config/extract-private-virtual/extract-private-virtual.html
@@ -32,9 +32,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;extract-private-virtual.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class A;
-
-</code>
+<code class="source-code cpp">class A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -77,9 +75,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">virtual
 void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -94,9 +90,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">virtual
 void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/extract-private-virtual/no-extract-private-virtual.html b/test-files/golden-tests/config/extract-private-virtual/no-extract-private-virtual.html
index a793a0559..8bdd2cb9f 100644
--- a/test-files/golden-tests/config/extract-private-virtual/no-extract-private-virtual.html
+++ b/test-files/golden-tests/config/extract-private-virtual/no-extract-private-virtual.html
@@ -32,9 +32,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;no-extract-private-virtual.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class A;
-
-</code>
+<code class="source-code cpp">class A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -64,9 +62,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">virtual
 void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/inherit-base-members/base-overload-set.adoc b/test-files/golden-tests/config/inherit-base-members/base-overload-set.adoc
index 2d333005a..7f73875e1 100644
--- a/test-files/golden-tests/config/inherit-base-members/base-overload-set.adoc
+++ b/test-files/golden-tests/config/inherit-base-members/base-overload-set.adoc
@@ -39,12 +39,10 @@ class Base
 
 === Member Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#Base-foo-04[`foo`] 
-| 
 |===
 
 === Derived Classes
@@ -133,12 +131,10 @@ class C
 
 === Member Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#Base-foo-04[`foo`] 
-| 
 |===
 
 [#ConstBase]
diff --git a/test-files/golden-tests/config/inherit-base-members/base-overload-set.html b/test-files/golden-tests/config/inherit-base-members/base-overload-set.html
index 52b355ad6..cafd1e029 100644
--- a/test-files/golden-tests/config/inherit-base-members/base-overload-set.html
+++ b/test-files/golden-tests/config/inherit-base-members/base-overload-set.html
@@ -35,9 +35,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;base-overload-set.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">class Base
-    : public <a href="#ConstBase">ConstBase</a>
-
-</code>
+    : public <a href="#ConstBase">ConstBase</a></code>
 </pre>
 </div>
 <div>
@@ -50,7 +48,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#ConstBase">ConstBase</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#ConstBase">ConstBase</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -59,12 +57,11 @@ <h2>Member Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#Base-foo-04"><code>foo</code></a> </td><td><span></span></td></tr>
+<td><a href="#Base-foo-04"><code>foo</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -81,7 +78,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#C"><code>C</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -97,17 +94,13 @@ <h3>Synopses</h3>
 
 <pre>
 <code class="source-code cpp">int&
-<a href="#Base-foo-0a">foo</a>();
-
-</code>
+<a href="#Base-foo-0a">foo</a>();</code>
 </pre><span class="small"><a href="#Base-foo-0a"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">int&
-<a href="#Base-foo-08">foo</a>() const;
-
-</code>
+<a href="#Base-foo-08">foo</a>() const;</code>
 </pre><span class="small"><a href="#Base-foo-08"><em>» more...</em></a></span>
 
 
@@ -123,9 +116,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;base-overload-set.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int&
-foo();
-
-</code>
+foo();</code>
 </pre>
 </div>
 </div>
@@ -139,9 +130,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;base-overload-set.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int&
-foo() const;
-
-</code>
+foo() const;</code>
 </pre>
 </div>
 </div>
@@ -155,9 +144,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;base-overload-set.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">class C
-    : public <a href="#Base">Base</a>
-
-</code>
+    : public <a href="#Base">Base</a></code>
 </pre>
 </div>
 <div>
@@ -170,7 +157,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#Base">Base</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#Base">Base</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -179,12 +166,11 @@ <h2>Member Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#Base-foo-04"><code>foo</code></a> </td><td><span></span></td></tr>
+<td><a href="#Base-foo-04"><code>foo</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -200,9 +186,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;base-overload-set.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class ConstBase;
-
-</code>
+<code class="source-code cpp">class ConstBase;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -231,7 +215,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#Base"><code>Base</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -246,9 +230,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;base-overload-set.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int&
-foo() const;
-
-</code>
+foo() const;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/inherit-base-members/copy-dependencies.html b/test-files/golden-tests/config/inherit-base-members/copy-dependencies.html
index 049110be7..c2da370fb 100644
--- a/test-files/golden-tests/config/inherit-base-members/copy-dependencies.html
+++ b/test-files/golden-tests/config/inherit-base-members/copy-dependencies.html
@@ -19,11 +19,11 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base"><code>base</code></a> </td><td><span>A base class to test inheritance and shadowing</span></td></tr><tr>
-<td><a href="#base_base"><code>base_base</code></a> </td><td><span>A second-order base class to test indirect inheritance</span></td></tr><tr>
-<td><a href="#derived"><code>derived</code></a> </td><td><span>A class that derives from base and excluded_base</span></td></tr><tr>
-<td><a href="#private_derived"><code>private_derived</code></a> </td><td><span>A class that uses private inheritance only</span></td></tr><tr>
-<td><a href="#protected_derived"><code>protected_derived</code></a> </td><td><span>A class that should inherit functions as protected.</span></td></tr>
+<td><a href="#base"><code>base</code></a> </td><td>A base class to test inheritance and shadowing</td></tr><tr>
+<td><a href="#base_base"><code>base_base</code></a> </td><td>A second-order base class to test indirect inheritance</td></tr><tr>
+<td><a href="#derived"><code>derived</code></a> </td><td>A class that derives from base and excluded_base</td></tr><tr>
+<td><a href="#private_derived"><code>private_derived</code></a> </td><td>A class that uses private inheritance only</td></tr><tr>
+<td><a href="#protected_derived"><code>protected_derived</code></a> </td><td>A class that should inherit functions as protected.</td></tr>
 </tbody>
 </table>
 
@@ -32,8 +32,7 @@ <h2>Types</h2>
 <div>
 <h2 id="base">base</h2>
 <div>
-<span>A base class to test inheritance and shadowing</span>
-
+<p>A base class to test inheritance and shadowing</p>
 </div>
 </div>
 <div>
@@ -42,9 +41,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">class base
-    : public <a href="#base_base">base_base</a>
-
-</code>
+    : public <a href="#base_base">base_base</a></code>
 </pre>
 </div>
 <div>
@@ -57,7 +54,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#base_base">base_base</a></code></td><td><span>A second-order base class to test indirect inheritance</span></td></tr>
+<tr><td><code><a href="#base_base">base_base</a></code></td><td>A second-order base class to test indirect inheritance</td></tr>
 </tbody>
 </table>
 </div>
@@ -71,11 +68,11 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#base-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr><tr>
-<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr>
+<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#base-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr><tr>
+<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -90,9 +87,9 @@ <h2>Protected Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr>
+<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -108,7 +105,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#derived"><code>derived</code></a>
-    </td><td><span>A class that derives from base and excluded_base</span></td></tr>
+    </td><td>A class that derives from base and excluded_base</td></tr>
 </tbody>
 </table>
 </div>
@@ -117,8 +114,7 @@ <h2>Derived Classes</h2>
 <div>
 <h2 id="base-base_inherited">base::base_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -127,22 +123,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-base_inherited();
-
-</code>
+base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-base_shadowed">base::base_shadowed</h2>
 <div>
-<span>This function should shadow the excluded_base function.</span>
-
+<p>This function should shadow the excluded_base function.</p>
 </div>
 </div>
 <div>
@@ -151,22 +144,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-base_shadowed();
-
-</code>
+base_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-derived_shadowed">base::derived_shadowed</h2>
 <div>
-<span>This function should be shadowed by derived classes.</span>
-
+<p>This function should be shadowed by derived classes.</p>
 </div>
 </div>
 <div>
@@ -175,22 +165,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-do_base_inherited">base::do_base_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -199,22 +186,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_base_inherited();
-
-</code>
+do_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-do_base_shadowed">base::do_base_shadowed</h2>
 <div>
-<span>This function should shadow the excluded_base function.</span>
-
+<p>This function should shadow the excluded_base function.</p>
 </div>
 </div>
 <div>
@@ -223,22 +207,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_base_shadowed();
-
-</code>
+do_base_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-do_derived_shadowed">base::do_derived_shadowed</h2>
 <div>
-<span>This function should be shadowed by derived classes.</span>
-
+<p>This function should be shadowed by derived classes.</p>
 </div>
 </div>
 <div>
@@ -247,22 +228,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base_base">base_base</h2>
 <div>
-<span>A second-order base class to test indirect inheritance</span>
-
+<p>A second-order base class to test indirect inheritance</p>
 </div>
 </div>
 <div>
@@ -270,9 +248,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class base_base;
-
-</code>
+<code class="source-code cpp">class base_base;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -285,8 +261,8 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr>
+<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -303,7 +279,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#base"><code>base</code></a>
-    </td><td><span>A base class to test inheritance and shadowing</span></td></tr>
+    </td><td>A base class to test inheritance and shadowing</td></tr>
 </tbody>
 </table>
 </div>
@@ -312,8 +288,7 @@ <h2>Derived Classes</h2>
 <div>
 <h2 id="base_base-base_base_inherited">base_base::base_base_inherited</h2>
 <div>
-<span>This function should be indirectly inherited by derived classes.</span>
-
+<p>This function should be indirectly inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -322,22 +297,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base_base">base_base</a>&
-base_base_inherited();
-
-</code>
+base_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A second-order base class to test indirect inheritance</span>
+A second-order base class to test indirect inheritance
 </div>
 </div>
 <div>
 <div>
 <h2 id="base_base-do_base_base_inherited">base_base::do_base_base_inherited</h2>
 <div>
-<span>This function should be indirectly inherited by derived classes.</span>
-
+<p>This function should be indirectly inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -346,22 +318,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base_base">base_base</a>&
-do_base_base_inherited();
-
-</code>
+do_base_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A second-order base class to test indirect inheritance</span>
+A second-order base class to test indirect inheritance
 </div>
 </div>
 <div>
 <div>
 <h2 id="derived">derived</h2>
 <div>
-<span>A class that derives from base and excluded_base</span>
-
+<p>A class that derives from base and excluded_base</p>
 </div>
 </div>
 <div>
@@ -371,9 +340,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">class derived
     : public <a href="#base">base</a>
-    , public excluded_base
-
-</code>
+    , public excluded_base</code>
 </pre>
 </div>
 <div>
@@ -386,8 +353,8 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#base">base</a></code></td><td><span>A base class to test inheritance and shadowing</span></td></tr>
-<tr><td><code>excluded_base</code></td><td><span></span></td></tr>
+<tr><td><code><a href="#base">base</a></code></td><td>A base class to test inheritance and shadowing</td></tr>
+<tr><td><code>excluded_base</code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -401,13 +368,13 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr><tr>
-<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr><tr>
-<td><a href="#derived-excluded_inherited"><code>excluded_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr>
+<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr><tr>
+<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr><tr>
+<td><a href="#derived-excluded_inherited"><code>excluded_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -422,11 +389,11 @@ <h2>Protected Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr><tr>
-<td><a href="#derived-do_excluded_inherited"><code>do_excluded_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#derived-do_shadowed"><code>do_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr>
+<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr><tr>
+<td><a href="#derived-do_excluded_inherited"><code>do_excluded_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#derived-do_shadowed"><code>do_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -436,8 +403,7 @@ <h2>Protected Member Functions</h2>
 <div>
 <h2 id="derived-derived_shadowed">derived::derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -446,22 +412,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#derived">derived</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that derives from base and excluded_base</span>
+A class that derives from base and excluded_base
 </div>
 </div>
 <div>
 <div>
 <h2 id="derived-do_derived_shadowed">derived::do_derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -470,22 +433,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#derived">derived</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that derives from base and excluded_base</span>
+A class that derives from base and excluded_base
 </div>
 </div>
 <div>
 <div>
 <h2 id="derived-excluded_inherited">derived::excluded_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -494,9 +454,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">excluded_base&
-excluded_inherited();
-
-</code>
+excluded_inherited();</code>
 </pre>
 </div>
 </div>
@@ -504,8 +462,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="derived-do_excluded_inherited">derived::do_excluded_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -514,9 +471,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">excluded_base&
-do_excluded_inherited();
-
-</code>
+do_excluded_inherited();</code>
 </pre>
 </div>
 </div>
@@ -524,8 +479,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="derived-do_shadowed">derived::do_shadowed</h2>
 <div>
-<span>This function should be shadowed by derived classes.</span>
-
+<p>This function should be shadowed by derived classes.</p>
 </div>
 </div>
 <div>
@@ -534,9 +488,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">excluded_base&
-do_shadowed();
-
-</code>
+do_shadowed();</code>
 </pre>
 </div>
 </div>
@@ -544,8 +496,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="private_derived">private_derived</h2>
 <div>
-<span>A class that uses private inheritance only</span>
-
+<p>A class that uses private inheritance only</p>
 </div>
 </div>
 <div>
@@ -555,9 +506,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">class private_derived
     : <a href="#base">base</a>
-    , excluded_base
-
-</code>
+    , excluded_base</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -570,8 +519,8 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#private_derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr><tr>
-<td><a href="#private_derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr>
+<td><a href="#private_derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr><tr>
+<td><a href="#private_derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr>
 </tbody>
 </table>
 
@@ -582,8 +531,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="private_derived-derived_shadowed">private_derived::derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -592,22 +540,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#private_derived">private_derived</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that uses private inheritance only</span>
+A class that uses private inheritance only
 </div>
 </div>
 <div>
 <div>
 <h2 id="private_derived-do_derived_shadowed">private_derived::do_derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -616,22 +561,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#private_derived">private_derived</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that uses private inheritance only</span>
+A class that uses private inheritance only
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived">protected_derived</h2>
 <div>
-<span>A class that should inherit functions as protected.</span>
-
+<p>A class that should inherit functions as protected.</p>
 </div>
 </div>
 <div>
@@ -641,9 +583,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">class protected_derived
     : protected <a href="#base">base</a>
-    , protected excluded_base
-
-</code>
+    , protected excluded_base</code>
 </pre>
 </div>
 <div>
@@ -656,8 +596,8 @@ <h2>Protected Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#base">base</a></code></td><td><span>A base class to test inheritance and shadowing</span></td></tr>
-<tr><td><code>excluded_base</code></td><td><span></span></td></tr>
+<tr><td><code><a href="#base">base</a></code></td><td>A base class to test inheritance and shadowing</td></tr>
+<tr><td><code>excluded_base</code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -671,8 +611,8 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#protected_derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr><tr>
-<td><a href="#protected_derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr>
+<td><a href="#protected_derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr><tr>
+<td><a href="#protected_derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr>
 </tbody>
 </table>
 
@@ -687,17 +627,17 @@ <h2>Protected Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#base-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr><tr>
-<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr><tr>
-<td><a href="#protected_derived-do_excluded_inherited"><code>do_excluded_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#protected_derived-do_shadowed"><code>do_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr><tr>
-<td><a href="#protected_derived-excluded_inherited"><code>excluded_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr>
+<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#base-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr><tr>
+<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr><tr>
+<td><a href="#protected_derived-do_excluded_inherited"><code>do_excluded_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#protected_derived-do_shadowed"><code>do_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr><tr>
+<td><a href="#protected_derived-excluded_inherited"><code>excluded_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -707,8 +647,7 @@ <h2>Protected Member Functions</h2>
 <div>
 <h2 id="protected_derived-derived_shadowed">protected_derived::derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -717,22 +656,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#protected_derived">protected_derived</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that should inherit functions as protected.</span>
+A class that should inherit functions as protected.
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived-do_derived_shadowed">protected_derived::do_derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -741,22 +677,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#protected_derived">protected_derived</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that should inherit functions as protected.</span>
+A class that should inherit functions as protected.
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived-do_excluded_inherited">protected_derived::do_excluded_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -765,9 +698,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">excluded_base&
-do_excluded_inherited();
-
-</code>
+do_excluded_inherited();</code>
 </pre>
 </div>
 </div>
@@ -775,8 +706,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="protected_derived-do_shadowed">protected_derived::do_shadowed</h2>
 <div>
-<span>This function should be shadowed by derived classes.</span>
-
+<p>This function should be shadowed by derived classes.</p>
 </div>
 </div>
 <div>
@@ -785,9 +715,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">excluded_base&
-do_shadowed();
-
-</code>
+do_shadowed();</code>
 </pre>
 </div>
 </div>
@@ -795,8 +723,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="protected_derived-excluded_inherited">protected_derived::excluded_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -805,9 +732,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy-dependencies.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">excluded_base&
-excluded_inherited();
-
-</code>
+excluded_inherited();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/inherit-base-members/copy.html b/test-files/golden-tests/config/inherit-base-members/copy.html
index 8e6d67daf..b7b8da27f 100644
--- a/test-files/golden-tests/config/inherit-base-members/copy.html
+++ b/test-files/golden-tests/config/inherit-base-members/copy.html
@@ -19,11 +19,11 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base"><code>base</code></a> </td><td><span>A base class to test inheritance and shadowing</span></td></tr><tr>
-<td><a href="#base_base"><code>base_base</code></a> </td><td><span>A second-order base class to test indirect inheritance</span></td></tr><tr>
-<td><a href="#derived"><code>derived</code></a> </td><td><span>A class that derives from base and excluded_base</span></td></tr><tr>
-<td><a href="#private_derived"><code>private_derived</code></a> </td><td><span>A class that uses private inheritance only</span></td></tr><tr>
-<td><a href="#protected_derived"><code>protected_derived</code></a> </td><td><span>A class that should inherit functions as protected.</span></td></tr>
+<td><a href="#base"><code>base</code></a> </td><td>A base class to test inheritance and shadowing</td></tr><tr>
+<td><a href="#base_base"><code>base_base</code></a> </td><td>A second-order base class to test indirect inheritance</td></tr><tr>
+<td><a href="#derived"><code>derived</code></a> </td><td>A class that derives from base and excluded_base</td></tr><tr>
+<td><a href="#private_derived"><code>private_derived</code></a> </td><td>A class that uses private inheritance only</td></tr><tr>
+<td><a href="#protected_derived"><code>protected_derived</code></a> </td><td>A class that should inherit functions as protected.</td></tr>
 </tbody>
 </table>
 
@@ -32,8 +32,7 @@ <h2>Types</h2>
 <div>
 <h2 id="base">base</h2>
 <div>
-<span>A base class to test inheritance and shadowing</span>
-
+<p>A base class to test inheritance and shadowing</p>
 </div>
 </div>
 <div>
@@ -42,9 +41,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">class base
-    : public <a href="#base_base">base_base</a>
-
-</code>
+    : public <a href="#base_base">base_base</a></code>
 </pre>
 </div>
 <div>
@@ -57,7 +54,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#base_base">base_base</a></code></td><td><span>A second-order base class to test indirect inheritance</span></td></tr>
+<tr><td><code><a href="#base_base">base_base</a></code></td><td>A second-order base class to test indirect inheritance</td></tr>
 </tbody>
 </table>
 </div>
@@ -71,11 +68,11 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base-base_base_inherited"><code>base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#base-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr><tr>
-<td><a href="#base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr>
+<td><a href="#base-base_base_inherited"><code>base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#base-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr><tr>
+<td><a href="#base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -90,9 +87,9 @@ <h2>Protected Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr>
+<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -108,7 +105,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#derived"><code>derived</code></a>
-    </td><td><span>A class that derives from base and excluded_base</span></td></tr>
+    </td><td>A class that derives from base and excluded_base</td></tr>
 </tbody>
 </table>
 </div>
@@ -117,8 +114,7 @@ <h2>Derived Classes</h2>
 <div>
 <h2 id="base-base_base_inherited">base::base_base_inherited</h2>
 <div>
-<span>This function should be indirectly inherited by derived classes.</span>
-
+<p>This function should be indirectly inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -127,22 +123,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base_base">base_base</a>&
-base_base_inherited();
-
-</code>
+base_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A second-order base class to test indirect inheritance</span>
+A second-order base class to test indirect inheritance
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-base_inherited">base::base_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -151,22 +144,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-base_inherited();
-
-</code>
+base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-base_shadowed">base::base_shadowed</h2>
 <div>
-<span>This function should shadow the excluded_base function.</span>
-
+<p>This function should shadow the excluded_base function.</p>
 </div>
 </div>
 <div>
@@ -175,22 +165,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-base_shadowed();
-
-</code>
+base_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-derived_shadowed">base::derived_shadowed</h2>
 <div>
-<span>This function should be shadowed by derived classes.</span>
-
+<p>This function should be shadowed by derived classes.</p>
 </div>
 </div>
 <div>
@@ -199,22 +186,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-do_base_base_inherited">base::do_base_base_inherited</h2>
 <div>
-<span>This function should be indirectly inherited by derived classes.</span>
-
+<p>This function should be indirectly inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -223,22 +207,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base_base">base_base</a>&
-do_base_base_inherited();
-
-</code>
+do_base_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A second-order base class to test indirect inheritance</span>
+A second-order base class to test indirect inheritance
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-do_base_inherited">base::do_base_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -247,22 +228,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_base_inherited();
-
-</code>
+do_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-do_base_shadowed">base::do_base_shadowed</h2>
 <div>
-<span>This function should shadow the excluded_base function.</span>
-
+<p>This function should shadow the excluded_base function.</p>
 </div>
 </div>
 <div>
@@ -271,22 +249,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_base_shadowed();
-
-</code>
+do_base_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-do_derived_shadowed">base::do_derived_shadowed</h2>
 <div>
-<span>This function should be shadowed by derived classes.</span>
-
+<p>This function should be shadowed by derived classes.</p>
 </div>
 </div>
 <div>
@@ -295,22 +270,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base_base">base_base</h2>
 <div>
-<span>A second-order base class to test indirect inheritance</span>
-
+<p>A second-order base class to test indirect inheritance</p>
 </div>
 </div>
 <div>
@@ -318,9 +290,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class base_base;
-
-</code>
+<code class="source-code cpp">class base_base;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -333,8 +303,8 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr>
+<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -351,7 +321,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#base"><code>base</code></a>
-    </td><td><span>A base class to test inheritance and shadowing</span></td></tr>
+    </td><td>A base class to test inheritance and shadowing</td></tr>
 </tbody>
 </table>
 </div>
@@ -360,8 +330,7 @@ <h2>Derived Classes</h2>
 <div>
 <h2 id="base_base-base_base_inherited">base_base::base_base_inherited</h2>
 <div>
-<span>This function should be indirectly inherited by derived classes.</span>
-
+<p>This function should be indirectly inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -370,22 +339,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base_base">base_base</a>&
-base_base_inherited();
-
-</code>
+base_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A second-order base class to test indirect inheritance</span>
+A second-order base class to test indirect inheritance
 </div>
 </div>
 <div>
 <div>
 <h2 id="base_base-do_base_base_inherited">base_base::do_base_base_inherited</h2>
 <div>
-<span>This function should be indirectly inherited by derived classes.</span>
-
+<p>This function should be indirectly inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -394,22 +360,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base_base">base_base</a>&
-do_base_base_inherited();
-
-</code>
+do_base_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A second-order base class to test indirect inheritance</span>
+A second-order base class to test indirect inheritance
 </div>
 </div>
 <div>
 <div>
 <h2 id="derived">derived</h2>
 <div>
-<span>A class that derives from base and excluded_base</span>
-
+<p>A class that derives from base and excluded_base</p>
 </div>
 </div>
 <div>
@@ -419,9 +382,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">class derived
     : public <a href="#base">base</a>
-    , public excluded_base
-
-</code>
+    , public excluded_base</code>
 </pre>
 </div>
 <div>
@@ -434,8 +395,8 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#base">base</a></code></td><td><span>A base class to test inheritance and shadowing</span></td></tr>
-<tr><td><code>excluded_base</code></td><td><span></span></td></tr>
+<tr><td><code><a href="#base">base</a></code></td><td>A base class to test inheritance and shadowing</td></tr>
+<tr><td><code>excluded_base</code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -449,13 +410,13 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#derived-base_base_inherited"><code>base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#derived-base_inherited"><code>base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#derived-base_shadowed"><code>base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr><tr>
-<td><a href="#derived-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#derived-do_derived_shadowed-0a"><code>do_derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr><tr>
-<td><a href="#derived-excluded_inherited"><code>excluded_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr>
+<td><a href="#derived-base_base_inherited"><code>base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#derived-base_inherited"><code>base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#derived-base_shadowed"><code>base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr><tr>
+<td><a href="#derived-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#derived-do_derived_shadowed-0a"><code>do_derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr><tr>
+<td><a href="#derived-excluded_inherited"><code>excluded_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -470,11 +431,11 @@ <h2>Protected Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#derived-do_base_inherited"><code>do_base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#derived-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#derived-do_derived_shadowed-0d"><code>do_derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr><tr>
-<td><a href="#derived-do_excluded_inherited"><code>do_excluded_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#derived-do_shadowed"><code>do_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr>
+<td><a href="#derived-do_base_inherited"><code>do_base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#derived-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#derived-do_derived_shadowed-0d"><code>do_derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr><tr>
+<td><a href="#derived-do_excluded_inherited"><code>do_excluded_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#derived-do_shadowed"><code>do_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -484,8 +445,7 @@ <h2>Protected Member Functions</h2>
 <div>
 <h2 id="derived-base_base_inherited">derived::base_base_inherited</h2>
 <div>
-<span>This function should be indirectly inherited by derived classes.</span>
-
+<p>This function should be indirectly inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -494,22 +454,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base_base">base_base</a>&
-base_base_inherited();
-
-</code>
+base_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A second-order base class to test indirect inheritance</span>
+A second-order base class to test indirect inheritance
 </div>
 </div>
 <div>
 <div>
 <h2 id="derived-base_inherited">derived::base_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -518,22 +475,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-base_inherited();
-
-</code>
+base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="derived-base_shadowed">derived::base_shadowed</h2>
 <div>
-<span>This function should shadow the excluded_base function.</span>
-
+<p>This function should shadow the excluded_base function.</p>
 </div>
 </div>
 <div>
@@ -542,22 +496,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-base_shadowed();
-
-</code>
+base_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="derived-derived_shadowed">derived::derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -566,22 +517,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#derived">derived</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that derives from base and excluded_base</span>
+A class that derives from base and excluded_base
 </div>
 </div>
 <div>
 <div>
 <h2 id="derived-do_base_base_inherited">derived::do_base_base_inherited</h2>
 <div>
-<span>This function should be indirectly inherited by derived classes.</span>
-
+<p>This function should be indirectly inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -590,22 +538,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base_base">base_base</a>&
-do_base_base_inherited();
-
-</code>
+do_base_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A second-order base class to test indirect inheritance</span>
+A second-order base class to test indirect inheritance
 </div>
 </div>
 <div>
 <div>
 <h2 id="derived-do_derived_shadowed-0a">derived::do_derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -614,22 +559,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#derived">derived</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that derives from base and excluded_base</span>
+A class that derives from base and excluded_base
 </div>
 </div>
 <div>
 <div>
 <h2 id="derived-excluded_inherited">derived::excluded_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -638,9 +580,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">excluded_base&
-excluded_inherited();
-
-</code>
+excluded_inherited();</code>
 </pre>
 </div>
 </div>
@@ -648,8 +588,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="derived-do_base_inherited">derived::do_base_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -658,22 +597,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_base_inherited();
-
-</code>
+do_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="derived-do_base_shadowed">derived::do_base_shadowed</h2>
 <div>
-<span>This function should shadow the excluded_base function.</span>
-
+<p>This function should shadow the excluded_base function.</p>
 </div>
 </div>
 <div>
@@ -682,22 +618,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_base_shadowed();
-
-</code>
+do_base_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="derived-do_derived_shadowed-0d">derived::do_derived_shadowed</h2>
 <div>
-<span>This function should be shadowed by derived classes.</span>
-
+<p>This function should be shadowed by derived classes.</p>
 </div>
 </div>
 <div>
@@ -706,22 +639,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="derived-do_excluded_inherited">derived::do_excluded_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -730,9 +660,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">excluded_base&
-do_excluded_inherited();
-
-</code>
+do_excluded_inherited();</code>
 </pre>
 </div>
 </div>
@@ -740,8 +668,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="derived-do_shadowed">derived::do_shadowed</h2>
 <div>
-<span>This function should be shadowed by derived classes.</span>
-
+<p>This function should be shadowed by derived classes.</p>
 </div>
 </div>
 <div>
@@ -750,9 +677,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">excluded_base&
-do_shadowed();
-
-</code>
+do_shadowed();</code>
 </pre>
 </div>
 </div>
@@ -760,8 +685,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="private_derived">private_derived</h2>
 <div>
-<span>A class that uses private inheritance only</span>
-
+<p>A class that uses private inheritance only</p>
 </div>
 </div>
 <div>
@@ -771,9 +695,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">class private_derived
     : <a href="#base">base</a>
-    , excluded_base
-
-</code>
+    , excluded_base</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -786,8 +708,8 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#private_derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr><tr>
-<td><a href="#private_derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr>
+<td><a href="#private_derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr><tr>
+<td><a href="#private_derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr>
 </tbody>
 </table>
 
@@ -798,8 +720,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="private_derived-derived_shadowed">private_derived::derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -808,22 +729,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#private_derived">private_derived</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that uses private inheritance only</span>
+A class that uses private inheritance only
 </div>
 </div>
 <div>
 <div>
 <h2 id="private_derived-do_derived_shadowed">private_derived::do_derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -832,22 +750,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#private_derived">private_derived</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that uses private inheritance only</span>
+A class that uses private inheritance only
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived">protected_derived</h2>
 <div>
-<span>A class that should inherit functions as protected.</span>
-
+<p>A class that should inherit functions as protected.</p>
 </div>
 </div>
 <div>
@@ -857,9 +772,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">class protected_derived
     : protected <a href="#base">base</a>
-    , protected excluded_base
-
-</code>
+    , protected excluded_base</code>
 </pre>
 </div>
 <div>
@@ -872,8 +785,8 @@ <h2>Protected Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#base">base</a></code></td><td><span>A base class to test inheritance and shadowing</span></td></tr>
-<tr><td><code>excluded_base</code></td><td><span></span></td></tr>
+<tr><td><code><a href="#base">base</a></code></td><td>A base class to test inheritance and shadowing</td></tr>
+<tr><td><code>excluded_base</code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -887,8 +800,8 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#protected_derived-derived_shadowed-0a"><code>derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr><tr>
-<td><a href="#protected_derived-do_derived_shadowed-0e"><code>do_derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr>
+<td><a href="#protected_derived-derived_shadowed-0a"><code>derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr><tr>
+<td><a href="#protected_derived-do_derived_shadowed-0e"><code>do_derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr>
 </tbody>
 </table>
 
@@ -903,17 +816,17 @@ <h2>Protected Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#protected_derived-base_base_inherited"><code>base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#protected_derived-base_inherited"><code>base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#protected_derived-base_shadowed"><code>base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#protected_derived-derived_shadowed-0f"><code>derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr><tr>
-<td><a href="#protected_derived-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#protected_derived-do_base_inherited"><code>do_base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#protected_derived-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#protected_derived-do_derived_shadowed-06"><code>do_derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr><tr>
-<td><a href="#protected_derived-do_excluded_inherited"><code>do_excluded_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#protected_derived-do_shadowed"><code>do_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr><tr>
-<td><a href="#protected_derived-excluded_inherited"><code>excluded_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr>
+<td><a href="#protected_derived-base_base_inherited"><code>base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#protected_derived-base_inherited"><code>base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#protected_derived-base_shadowed"><code>base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#protected_derived-derived_shadowed-0f"><code>derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr><tr>
+<td><a href="#protected_derived-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#protected_derived-do_base_inherited"><code>do_base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#protected_derived-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#protected_derived-do_derived_shadowed-06"><code>do_derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr><tr>
+<td><a href="#protected_derived-do_excluded_inherited"><code>do_excluded_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#protected_derived-do_shadowed"><code>do_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr><tr>
+<td><a href="#protected_derived-excluded_inherited"><code>excluded_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -923,8 +836,7 @@ <h2>Protected Member Functions</h2>
 <div>
 <h2 id="protected_derived-derived_shadowed-0a">protected_derived::derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -933,22 +845,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#protected_derived">protected_derived</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that should inherit functions as protected.</span>
+A class that should inherit functions as protected.
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived-do_derived_shadowed-0e">protected_derived::do_derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -957,22 +866,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#protected_derived">protected_derived</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that should inherit functions as protected.</span>
+A class that should inherit functions as protected.
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived-base_base_inherited">protected_derived::base_base_inherited</h2>
 <div>
-<span>This function should be indirectly inherited by derived classes.</span>
-
+<p>This function should be indirectly inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -981,22 +887,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base_base">base_base</a>&
-base_base_inherited();
-
-</code>
+base_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A second-order base class to test indirect inheritance</span>
+A second-order base class to test indirect inheritance
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived-base_inherited">protected_derived::base_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -1005,22 +908,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-base_inherited();
-
-</code>
+base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived-base_shadowed">protected_derived::base_shadowed</h2>
 <div>
-<span>This function should shadow the excluded_base function.</span>
-
+<p>This function should shadow the excluded_base function.</p>
 </div>
 </div>
 <div>
@@ -1029,22 +929,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-base_shadowed();
-
-</code>
+base_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived-derived_shadowed-0f">protected_derived::derived_shadowed</h2>
 <div>
-<span>This function should be shadowed by derived classes.</span>
-
+<p>This function should be shadowed by derived classes.</p>
 </div>
 </div>
 <div>
@@ -1053,22 +950,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived-do_base_base_inherited">protected_derived::do_base_base_inherited</h2>
 <div>
-<span>This function should be indirectly inherited by derived classes.</span>
-
+<p>This function should be indirectly inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -1077,22 +971,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base_base">base_base</a>&
-do_base_base_inherited();
-
-</code>
+do_base_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A second-order base class to test indirect inheritance</span>
+A second-order base class to test indirect inheritance
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived-do_base_inherited">protected_derived::do_base_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -1101,22 +992,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_base_inherited();
-
-</code>
+do_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived-do_base_shadowed">protected_derived::do_base_shadowed</h2>
 <div>
-<span>This function should shadow the excluded_base function.</span>
-
+<p>This function should shadow the excluded_base function.</p>
 </div>
 </div>
 <div>
@@ -1125,22 +1013,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_base_shadowed();
-
-</code>
+do_base_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived-do_derived_shadowed-06">protected_derived::do_derived_shadowed</h2>
 <div>
-<span>This function should be shadowed by derived classes.</span>
-
+<p>This function should be shadowed by derived classes.</p>
 </div>
 </div>
 <div>
@@ -1149,22 +1034,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived-do_excluded_inherited">protected_derived::do_excluded_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -1173,9 +1055,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">excluded_base&
-do_excluded_inherited();
-
-</code>
+do_excluded_inherited();</code>
 </pre>
 </div>
 </div>
@@ -1183,8 +1063,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="protected_derived-do_shadowed">protected_derived::do_shadowed</h2>
 <div>
-<span>This function should be shadowed by derived classes.</span>
-
+<p>This function should be shadowed by derived classes.</p>
 </div>
 </div>
 <div>
@@ -1193,9 +1072,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">excluded_base&
-do_shadowed();
-
-</code>
+do_shadowed();</code>
 </pre>
 </div>
 </div>
@@ -1203,8 +1080,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="protected_derived-excluded_inherited">protected_derived::excluded_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -1213,9 +1089,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copy.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">excluded_base&
-excluded_inherited();
-
-</code>
+excluded_inherited();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/inherit-base-members/never.html b/test-files/golden-tests/config/inherit-base-members/never.html
index 24a2a51a2..4a6878211 100644
--- a/test-files/golden-tests/config/inherit-base-members/never.html
+++ b/test-files/golden-tests/config/inherit-base-members/never.html
@@ -19,11 +19,11 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base"><code>base</code></a> </td><td><span>A base class to test inheritance and shadowing</span></td></tr><tr>
-<td><a href="#base_base"><code>base_base</code></a> </td><td><span>A second-order base class to test indirect inheritance</span></td></tr><tr>
-<td><a href="#derived"><code>derived</code></a> </td><td><span>A class that derives from base and excluded_base</span></td></tr><tr>
-<td><a href="#private_derived"><code>private_derived</code></a> </td><td><span>A class that uses private inheritance only</span></td></tr><tr>
-<td><a href="#protected_derived"><code>protected_derived</code></a> </td><td><span>A class that should inherit functions as protected.</span></td></tr>
+<td><a href="#base"><code>base</code></a> </td><td>A base class to test inheritance and shadowing</td></tr><tr>
+<td><a href="#base_base"><code>base_base</code></a> </td><td>A second-order base class to test indirect inheritance</td></tr><tr>
+<td><a href="#derived"><code>derived</code></a> </td><td>A class that derives from base and excluded_base</td></tr><tr>
+<td><a href="#private_derived"><code>private_derived</code></a> </td><td>A class that uses private inheritance only</td></tr><tr>
+<td><a href="#protected_derived"><code>protected_derived</code></a> </td><td>A class that should inherit functions as protected.</td></tr>
 </tbody>
 </table>
 
@@ -32,8 +32,7 @@ <h2>Types</h2>
 <div>
 <h2 id="base">base</h2>
 <div>
-<span>A base class to test inheritance and shadowing</span>
-
+<p>A base class to test inheritance and shadowing</p>
 </div>
 </div>
 <div>
@@ -42,9 +41,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;never.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">class base
-    : public <a href="#base_base">base_base</a>
-
-</code>
+    : public <a href="#base_base">base_base</a></code>
 </pre>
 </div>
 <div>
@@ -57,7 +54,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#base_base">base_base</a></code></td><td><span>A second-order base class to test indirect inheritance</span></td></tr>
+<tr><td><code><a href="#base_base">base_base</a></code></td><td>A second-order base class to test indirect inheritance</td></tr>
 </tbody>
 </table>
 </div>
@@ -71,9 +68,9 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#base-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr>
+<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#base-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -88,9 +85,9 @@ <h2>Protected Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr>
+<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -106,7 +103,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#derived"><code>derived</code></a>
-    </td><td><span>A class that derives from base and excluded_base</span></td></tr>
+    </td><td>A class that derives from base and excluded_base</td></tr>
 </tbody>
 </table>
 </div>
@@ -115,8 +112,7 @@ <h2>Derived Classes</h2>
 <div>
 <h2 id="base-base_inherited">base::base_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -125,22 +121,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;never.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-base_inherited();
-
-</code>
+base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-base_shadowed">base::base_shadowed</h2>
 <div>
-<span>This function should shadow the excluded_base function.</span>
-
+<p>This function should shadow the excluded_base function.</p>
 </div>
 </div>
 <div>
@@ -149,22 +142,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;never.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-base_shadowed();
-
-</code>
+base_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-derived_shadowed">base::derived_shadowed</h2>
 <div>
-<span>This function should be shadowed by derived classes.</span>
-
+<p>This function should be shadowed by derived classes.</p>
 </div>
 </div>
 <div>
@@ -173,22 +163,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;never.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-do_base_inherited">base::do_base_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -197,22 +184,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;never.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_base_inherited();
-
-</code>
+do_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-do_base_shadowed">base::do_base_shadowed</h2>
 <div>
-<span>This function should shadow the excluded_base function.</span>
-
+<p>This function should shadow the excluded_base function.</p>
 </div>
 </div>
 <div>
@@ -221,22 +205,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;never.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_base_shadowed();
-
-</code>
+do_base_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-do_derived_shadowed">base::do_derived_shadowed</h2>
 <div>
-<span>This function should be shadowed by derived classes.</span>
-
+<p>This function should be shadowed by derived classes.</p>
 </div>
 </div>
 <div>
@@ -245,22 +226,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;never.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base_base">base_base</h2>
 <div>
-<span>A second-order base class to test indirect inheritance</span>
-
+<p>A second-order base class to test indirect inheritance</p>
 </div>
 </div>
 <div>
@@ -268,9 +246,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;never.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class base_base;
-
-</code>
+<code class="source-code cpp">class base_base;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -283,8 +259,8 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr>
+<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -301,7 +277,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#base"><code>base</code></a>
-    </td><td><span>A base class to test inheritance and shadowing</span></td></tr>
+    </td><td>A base class to test inheritance and shadowing</td></tr>
 </tbody>
 </table>
 </div>
@@ -310,8 +286,7 @@ <h2>Derived Classes</h2>
 <div>
 <h2 id="base_base-base_base_inherited">base_base::base_base_inherited</h2>
 <div>
-<span>This function should be indirectly inherited by derived classes.</span>
-
+<p>This function should be indirectly inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -320,22 +295,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;never.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base_base">base_base</a>&
-base_base_inherited();
-
-</code>
+base_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A second-order base class to test indirect inheritance</span>
+A second-order base class to test indirect inheritance
 </div>
 </div>
 <div>
 <div>
 <h2 id="base_base-do_base_base_inherited">base_base::do_base_base_inherited</h2>
 <div>
-<span>This function should be indirectly inherited by derived classes.</span>
-
+<p>This function should be indirectly inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -344,22 +316,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;never.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base_base">base_base</a>&
-do_base_base_inherited();
-
-</code>
+do_base_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A second-order base class to test indirect inheritance</span>
+A second-order base class to test indirect inheritance
 </div>
 </div>
 <div>
 <div>
 <h2 id="derived">derived</h2>
 <div>
-<span>A class that derives from base and excluded_base</span>
-
+<p>A class that derives from base and excluded_base</p>
 </div>
 </div>
 <div>
@@ -369,9 +338,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">class derived
     : public <a href="#base">base</a>
-    , public excluded_base
-
-</code>
+    , public excluded_base</code>
 </pre>
 </div>
 <div>
@@ -384,8 +351,8 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#base">base</a></code></td><td><span>A base class to test inheritance and shadowing</span></td></tr>
-<tr><td><code>excluded_base</code></td><td><span></span></td></tr>
+<tr><td><code><a href="#base">base</a></code></td><td>A base class to test inheritance and shadowing</td></tr>
+<tr><td><code>excluded_base</code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -399,8 +366,8 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr><tr>
-<td><a href="#derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr>
+<td><a href="#derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr><tr>
+<td><a href="#derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr>
 </tbody>
 </table>
 
@@ -411,8 +378,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="derived-derived_shadowed">derived::derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -421,22 +387,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;never.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#derived">derived</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that derives from base and excluded_base</span>
+A class that derives from base and excluded_base
 </div>
 </div>
 <div>
 <div>
 <h2 id="derived-do_derived_shadowed">derived::do_derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -445,22 +408,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;never.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#derived">derived</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that derives from base and excluded_base</span>
+A class that derives from base and excluded_base
 </div>
 </div>
 <div>
 <div>
 <h2 id="private_derived">private_derived</h2>
 <div>
-<span>A class that uses private inheritance only</span>
-
+<p>A class that uses private inheritance only</p>
 </div>
 </div>
 <div>
@@ -470,9 +430,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">class private_derived
     : <a href="#base">base</a>
-    , excluded_base
-
-</code>
+    , excluded_base</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -485,8 +443,8 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#private_derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr><tr>
-<td><a href="#private_derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr>
+<td><a href="#private_derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr><tr>
+<td><a href="#private_derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr>
 </tbody>
 </table>
 
@@ -497,8 +455,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="private_derived-derived_shadowed">private_derived::derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -507,22 +464,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;never.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#private_derived">private_derived</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that uses private inheritance only</span>
+A class that uses private inheritance only
 </div>
 </div>
 <div>
 <div>
 <h2 id="private_derived-do_derived_shadowed">private_derived::do_derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -531,22 +485,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;never.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#private_derived">private_derived</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that uses private inheritance only</span>
+A class that uses private inheritance only
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived">protected_derived</h2>
 <div>
-<span>A class that should inherit functions as protected.</span>
-
+<p>A class that should inherit functions as protected.</p>
 </div>
 </div>
 <div>
@@ -556,9 +507,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">class protected_derived
     : protected <a href="#base">base</a>
-    , protected excluded_base
-
-</code>
+    , protected excluded_base</code>
 </pre>
 </div>
 <div>
@@ -571,8 +520,8 @@ <h2>Protected Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#base">base</a></code></td><td><span>A base class to test inheritance and shadowing</span></td></tr>
-<tr><td><code>excluded_base</code></td><td><span></span></td></tr>
+<tr><td><code><a href="#base">base</a></code></td><td>A base class to test inheritance and shadowing</td></tr>
+<tr><td><code>excluded_base</code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -586,8 +535,8 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#protected_derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr><tr>
-<td><a href="#protected_derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr>
+<td><a href="#protected_derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr><tr>
+<td><a href="#protected_derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr>
 </tbody>
 </table>
 
@@ -598,8 +547,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="protected_derived-derived_shadowed">protected_derived::derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -608,22 +556,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;never.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#protected_derived">protected_derived</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that should inherit functions as protected.</span>
+A class that should inherit functions as protected.
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived-do_derived_shadowed">protected_derived::do_derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -632,14 +577,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;never.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#protected_derived">protected_derived</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that should inherit functions as protected.</span>
+A class that should inherit functions as protected.
 </div>
 </div>
 
diff --git a/test-files/golden-tests/config/inherit-base-members/reference.html b/test-files/golden-tests/config/inherit-base-members/reference.html
index 51f3458e8..10e0c2786 100644
--- a/test-files/golden-tests/config/inherit-base-members/reference.html
+++ b/test-files/golden-tests/config/inherit-base-members/reference.html
@@ -19,11 +19,11 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base"><code>base</code></a> </td><td><span>A base class to test inheritance and shadowing</span></td></tr><tr>
-<td><a href="#base_base"><code>base_base</code></a> </td><td><span>A second-order base class to test indirect inheritance</span></td></tr><tr>
-<td><a href="#derived"><code>derived</code></a> </td><td><span>A class that derives from base and excluded_base</span></td></tr><tr>
-<td><a href="#private_derived"><code>private_derived</code></a> </td><td><span>A class that uses private inheritance only</span></td></tr><tr>
-<td><a href="#protected_derived"><code>protected_derived</code></a> </td><td><span>A class that should inherit functions as protected.</span></td></tr>
+<td><a href="#base"><code>base</code></a> </td><td>A base class to test inheritance and shadowing</td></tr><tr>
+<td><a href="#base_base"><code>base_base</code></a> </td><td>A second-order base class to test indirect inheritance</td></tr><tr>
+<td><a href="#derived"><code>derived</code></a> </td><td>A class that derives from base and excluded_base</td></tr><tr>
+<td><a href="#private_derived"><code>private_derived</code></a> </td><td>A class that uses private inheritance only</td></tr><tr>
+<td><a href="#protected_derived"><code>protected_derived</code></a> </td><td>A class that should inherit functions as protected.</td></tr>
 </tbody>
 </table>
 
@@ -32,8 +32,7 @@ <h2>Types</h2>
 <div>
 <h2 id="base">base</h2>
 <div>
-<span>A base class to test inheritance and shadowing</span>
-
+<p>A base class to test inheritance and shadowing</p>
 </div>
 </div>
 <div>
@@ -42,9 +41,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;reference.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">class base
-    : public <a href="#base_base">base_base</a>
-
-</code>
+    : public <a href="#base_base">base_base</a></code>
 </pre>
 </div>
 <div>
@@ -57,7 +54,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#base_base">base_base</a></code></td><td><span>A second-order base class to test indirect inheritance</span></td></tr>
+<tr><td><code><a href="#base_base">base_base</a></code></td><td>A second-order base class to test indirect inheritance</td></tr>
 </tbody>
 </table>
 </div>
@@ -71,11 +68,11 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#base-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr><tr>
-<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr>
+<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#base-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr><tr>
+<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -90,9 +87,9 @@ <h2>Protected Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr>
+<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -108,7 +105,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#derived"><code>derived</code></a>
-    </td><td><span>A class that derives from base and excluded_base</span></td></tr>
+    </td><td>A class that derives from base and excluded_base</td></tr>
 </tbody>
 </table>
 </div>
@@ -117,8 +114,7 @@ <h2>Derived Classes</h2>
 <div>
 <h2 id="base-base_inherited">base::base_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -127,22 +123,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;reference.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-base_inherited();
-
-</code>
+base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-base_shadowed">base::base_shadowed</h2>
 <div>
-<span>This function should shadow the excluded_base function.</span>
-
+<p>This function should shadow the excluded_base function.</p>
 </div>
 </div>
 <div>
@@ -151,22 +144,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;reference.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-base_shadowed();
-
-</code>
+base_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-derived_shadowed">base::derived_shadowed</h2>
 <div>
-<span>This function should be shadowed by derived classes.</span>
-
+<p>This function should be shadowed by derived classes.</p>
 </div>
 </div>
 <div>
@@ -175,22 +165,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;reference.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-do_base_inherited">base::do_base_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -199,22 +186,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;reference.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_base_inherited();
-
-</code>
+do_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-do_base_shadowed">base::do_base_shadowed</h2>
 <div>
-<span>This function should shadow the excluded_base function.</span>
-
+<p>This function should shadow the excluded_base function.</p>
 </div>
 </div>
 <div>
@@ -223,22 +207,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;reference.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_base_shadowed();
-
-</code>
+do_base_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base-do_derived_shadowed">base::do_derived_shadowed</h2>
 <div>
-<span>This function should be shadowed by derived classes.</span>
-
+<p>This function should be shadowed by derived classes.</p>
 </div>
 </div>
 <div>
@@ -247,22 +228,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;reference.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A base class to test inheritance and shadowing</span>
+A base class to test inheritance and shadowing
 </div>
 </div>
 <div>
 <div>
 <h2 id="base_base">base_base</h2>
 <div>
-<span>A second-order base class to test indirect inheritance</span>
-
+<p>A second-order base class to test indirect inheritance</p>
 </div>
 </div>
 <div>
@@ -270,9 +248,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;reference.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class base_base;
-
-</code>
+<code class="source-code cpp">class base_base;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -285,8 +261,8 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr>
+<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -303,7 +279,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#base"><code>base</code></a>
-    </td><td><span>A base class to test inheritance and shadowing</span></td></tr>
+    </td><td>A base class to test inheritance and shadowing</td></tr>
 </tbody>
 </table>
 </div>
@@ -312,8 +288,7 @@ <h2>Derived Classes</h2>
 <div>
 <h2 id="base_base-base_base_inherited">base_base::base_base_inherited</h2>
 <div>
-<span>This function should be indirectly inherited by derived classes.</span>
-
+<p>This function should be indirectly inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -322,22 +297,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;reference.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base_base">base_base</a>&
-base_base_inherited();
-
-</code>
+base_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A second-order base class to test indirect inheritance</span>
+A second-order base class to test indirect inheritance
 </div>
 </div>
 <div>
 <div>
 <h2 id="base_base-do_base_base_inherited">base_base::do_base_base_inherited</h2>
 <div>
-<span>This function should be indirectly inherited by derived classes.</span>
-
+<p>This function should be indirectly inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -346,22 +318,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;reference.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base_base">base_base</a>&
-do_base_base_inherited();
-
-</code>
+do_base_base_inherited();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A second-order base class to test indirect inheritance</span>
+A second-order base class to test indirect inheritance
 </div>
 </div>
 <div>
 <div>
 <h2 id="derived">derived</h2>
 <div>
-<span>A class that derives from base and excluded_base</span>
-
+<p>A class that derives from base and excluded_base</p>
 </div>
 </div>
 <div>
@@ -371,9 +340,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">class derived
     : public <a href="#base">base</a>
-    , public excluded_base
-
-</code>
+    , public excluded_base</code>
 </pre>
 </div>
 <div>
@@ -386,8 +353,8 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#base">base</a></code></td><td><span>A base class to test inheritance and shadowing</span></td></tr>
-<tr><td><code>excluded_base</code></td><td><span></span></td></tr>
+<tr><td><code><a href="#base">base</a></code></td><td>A base class to test inheritance and shadowing</td></tr>
+<tr><td><code>excluded_base</code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -401,12 +368,12 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr><tr>
-<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr>
+<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr><tr>
+<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr>
 </tbody>
 </table>
 
@@ -421,9 +388,9 @@ <h2>Protected Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr>
+<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -433,8 +400,7 @@ <h2>Protected Member Functions</h2>
 <div>
 <h2 id="derived-derived_shadowed">derived::derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -443,22 +409,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;reference.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#derived">derived</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that derives from base and excluded_base</span>
+A class that derives from base and excluded_base
 </div>
 </div>
 <div>
 <div>
 <h2 id="derived-do_derived_shadowed">derived::do_derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -467,22 +430,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;reference.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#derived">derived</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that derives from base and excluded_base</span>
+A class that derives from base and excluded_base
 </div>
 </div>
 <div>
 <div>
 <h2 id="private_derived">private_derived</h2>
 <div>
-<span>A class that uses private inheritance only</span>
-
+<p>A class that uses private inheritance only</p>
 </div>
 </div>
 <div>
@@ -492,9 +452,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">class private_derived
     : <a href="#base">base</a>
-    , excluded_base
-
-</code>
+    , excluded_base</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -507,8 +465,8 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#private_derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr><tr>
-<td><a href="#private_derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr>
+<td><a href="#private_derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr><tr>
+<td><a href="#private_derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr>
 </tbody>
 </table>
 
@@ -519,8 +477,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="private_derived-derived_shadowed">private_derived::derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -529,22 +486,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;reference.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#private_derived">private_derived</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that uses private inheritance only</span>
+A class that uses private inheritance only
 </div>
 </div>
 <div>
 <div>
 <h2 id="private_derived-do_derived_shadowed">private_derived::do_derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -553,22 +507,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;reference.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#private_derived">private_derived</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that uses private inheritance only</span>
+A class that uses private inheritance only
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived">protected_derived</h2>
 <div>
-<span>A class that should inherit functions as protected.</span>
-
+<p>A class that should inherit functions as protected.</p>
 </div>
 </div>
 <div>
@@ -578,9 +529,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">class protected_derived
     : protected <a href="#base">base</a>
-    , protected excluded_base
-
-</code>
+    , protected excluded_base</code>
 </pre>
 </div>
 <div>
@@ -593,8 +542,8 @@ <h2>Protected Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#base">base</a></code></td><td><span>A base class to test inheritance and shadowing</span></td></tr>
-<tr><td><code>excluded_base</code></td><td><span></span></td></tr>
+<tr><td><code><a href="#base">base</a></code></td><td>A base class to test inheritance and shadowing</td></tr>
+<tr><td><code>excluded_base</code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -608,8 +557,8 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#protected_derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr><tr>
-<td><a href="#protected_derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr>
+<td><a href="#protected_derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr><tr>
+<td><a href="#protected_derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr>
 </tbody>
 </table>
 
@@ -624,14 +573,14 @@ <h2>Protected Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#base-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr><tr>
-<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr>
+<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#base-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr><tr>
+<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -641,8 +590,7 @@ <h2>Protected Member Functions</h2>
 <div>
 <h2 id="protected_derived-derived_shadowed">protected_derived::derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -651,22 +599,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;reference.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#protected_derived">protected_derived</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that should inherit functions as protected.</span>
+A class that should inherit functions as protected.
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived-do_derived_shadowed">protected_derived::do_derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -675,14 +620,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;reference.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#protected_derived">protected_derived</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A class that should inherit functions as protected.</span>
+A class that should inherit functions as protected.
 </div>
 </div>
 
diff --git a/test-files/golden-tests/config/inherit-base-members/skip-special.html b/test-files/golden-tests/config/inherit-base-members/skip-special.html
index 5f0a10951..650896a0c 100644
--- a/test-files/golden-tests/config/inherit-base-members/skip-special.html
+++ b/test-files/golden-tests/config/inherit-base-members/skip-special.html
@@ -19,11 +19,11 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base"><code>base</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#base_base"><code>base_base</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#derived"><code>derived</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#private_derived"><code>private_derived</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#protected_derived"><code>protected_derived</code></a> </td><td><span>Should inherit functions as protected.</span></td></tr>
+<td><a href="#base"><code>base</code></a> </td><td></td></tr><tr>
+<td><a href="#base_base"><code>base_base</code></a> </td><td></td></tr><tr>
+<td><a href="#derived"><code>derived</code></a> </td><td></td></tr><tr>
+<td><a href="#private_derived"><code>private_derived</code></a> </td><td></td></tr><tr>
+<td><a href="#protected_derived"><code>protected_derived</code></a> </td><td>Should inherit functions as protected.</td></tr>
 </tbody>
 </table>
 
@@ -38,9 +38,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">class base
-    : public <a href="#base_base">base_base</a>
-
-</code>
+    : public <a href="#base_base">base_base</a></code>
 </pre>
 </div>
 <div>
@@ -53,7 +51,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#base_base">base_base</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#base_base">base_base</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -67,13 +65,13 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base-2constructor"><code>base</code></a>         <span class="small">[constructor]</span></td><td><span>Constructor should not be inherited</span></td></tr><tr>
-<td><a href="#base-2destructor"><code>~base</code></a> <span class="small">[destructor]</span></td><td><span>Destructor should not be inherited</span></td></tr><tr>
-<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#base-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr><tr>
-<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr>
+<td><a href="#base-2constructor"><code>base</code></a>         <span class="small">[constructor]</span></td><td>Constructor should not be inherited</td></tr><tr>
+<td><a href="#base-2destructor"><code>~base</code></a> <span class="small">[destructor]</span></td><td>Destructor should not be inherited</td></tr><tr>
+<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#base-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr><tr>
+<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -88,9 +86,9 @@ <h2>Protected Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr>
+<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -106,7 +104,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#derived"><code>derived</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -115,8 +113,7 @@ <h2>Derived Classes</h2>
 <div>
 <h2 id="base-2constructor">base::base</h2>
 <div>
-<span>Constructor should not be inherited</span>
-
+<p>Constructor should not be inherited</p>
 </div>
 </div>
 <div>
@@ -124,9 +121,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">base();
-
-</code>
+<code class="source-code cpp">base();</code>
 </pre>
 </div>
 </div>
@@ -134,8 +129,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="base-2destructor">base::~base</h2>
 <div>
-<span>Destructor should not be inherited</span>
-
+<p>Destructor should not be inherited</p>
 </div>
 </div>
 <div>
@@ -143,9 +137,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">~base();
-
-</code>
+<code class="source-code cpp">~base();</code>
 </pre>
 </div>
 </div>
@@ -153,8 +145,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="base-base_inherited">base::base_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -163,9 +154,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-base_inherited();
-
-</code>
+base_inherited();</code>
 </pre>
 </div>
 </div>
@@ -173,8 +162,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="base-base_shadowed">base::base_shadowed</h2>
 <div>
-<span>This function should shadow the excluded_base function.</span>
-
+<p>This function should shadow the excluded_base function.</p>
 </div>
 </div>
 <div>
@@ -183,9 +171,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-base_shadowed();
-
-</code>
+base_shadowed();</code>
 </pre>
 </div>
 </div>
@@ -193,8 +179,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="base-derived_shadowed">base::derived_shadowed</h2>
 <div>
-<span>This function should be shadowed by derived classes.</span>
-
+<p>This function should be shadowed by derived classes.</p>
 </div>
 </div>
 <div>
@@ -203,9 +188,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 </div>
@@ -213,8 +196,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="base-do_base_inherited">base::do_base_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -223,9 +205,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_base_inherited();
-
-</code>
+do_base_inherited();</code>
 </pre>
 </div>
 </div>
@@ -233,8 +213,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="base-do_base_shadowed">base::do_base_shadowed</h2>
 <div>
-<span>This function should shadow the excluded_base function.</span>
-
+<p>This function should shadow the excluded_base function.</p>
 </div>
 </div>
 <div>
@@ -243,9 +222,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_base_shadowed();
-
-</code>
+do_base_shadowed();</code>
 </pre>
 </div>
 </div>
@@ -253,8 +230,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="base-do_derived_shadowed">base::do_derived_shadowed</h2>
 <div>
-<span>This function should be shadowed by derived classes.</span>
-
+<p>This function should be shadowed by derived classes.</p>
 </div>
 </div>
 <div>
@@ -263,9 +239,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base">base</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 </div>
@@ -278,9 +252,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class base_base;
-
-</code>
+<code class="source-code cpp">class base_base;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -293,10 +265,10 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base_base-2constructor"><code>base_base</code></a>         <span class="small">[constructor]</span></td><td><span>Constructor should not be inherited</span></td></tr><tr>
-<td><a href="#base_base-2destructor"><code>~base_base</code></a> <span class="small">[destructor]</span></td><td><span>Destructor should not be inherited</span></td></tr><tr>
-<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr>
+<td><a href="#base_base-2constructor"><code>base_base</code></a>         <span class="small">[constructor]</span></td><td>Constructor should not be inherited</td></tr><tr>
+<td><a href="#base_base-2destructor"><code>~base_base</code></a> <span class="small">[destructor]</span></td><td>Destructor should not be inherited</td></tr><tr>
+<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -313,7 +285,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#base"><code>base</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -322,8 +294,7 @@ <h2>Derived Classes</h2>
 <div>
 <h2 id="base_base-2constructor">base_base::base_base</h2>
 <div>
-<span>Constructor should not be inherited</span>
-
+<p>Constructor should not be inherited</p>
 </div>
 </div>
 <div>
@@ -331,9 +302,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">base_base();
-
-</code>
+<code class="source-code cpp">base_base();</code>
 </pre>
 </div>
 </div>
@@ -341,8 +310,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="base_base-2destructor">base_base::~base_base</h2>
 <div>
-<span>Destructor should not be inherited</span>
-
+<p>Destructor should not be inherited</p>
 </div>
 </div>
 <div>
@@ -350,9 +318,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">~base_base();
-
-</code>
+<code class="source-code cpp">~base_base();</code>
 </pre>
 </div>
 </div>
@@ -360,8 +326,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="base_base-base_base_inherited">base_base::base_base_inherited</h2>
 <div>
-<span>This function should be indirectly inherited by derived classes.</span>
-
+<p>This function should be indirectly inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -370,9 +335,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base_base">base_base</a>&
-base_base_inherited();
-
-</code>
+base_base_inherited();</code>
 </pre>
 </div>
 </div>
@@ -380,8 +343,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="base_base-do_base_base_inherited">base_base::do_base_base_inherited</h2>
 <div>
-<span>This function should be indirectly inherited by derived classes.</span>
-
+<p>This function should be indirectly inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -390,9 +352,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#base_base">base_base</a>&
-do_base_base_inherited();
-
-</code>
+do_base_base_inherited();</code>
 </pre>
 </div>
 </div>
@@ -407,9 +367,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">class derived
     : public <a href="#base">base</a>
-    , public excluded_base
-
-</code>
+    , public excluded_base</code>
 </pre>
 </div>
 <div>
@@ -422,8 +380,8 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#base">base</a></code></td><td><span></span></td></tr>
-<tr><td><code>excluded_base</code></td><td><span></span></td></tr>
+<tr><td><code><a href="#base">base</a></code></td><td></td></tr>
+<tr><td><code>excluded_base</code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -437,15 +395,15 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#derived-2constructor"><code>derived</code></a>         <span class="small">[constructor]</span></td><td><span>Constructor should not be inherited</span></td></tr><tr>
-<td><a href="#derived-2destructor"><code>~derived</code></a> <span class="small">[destructor]</span></td><td><span>Destructor should not be inherited</span></td></tr><tr>
-<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr><tr>
-<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr><tr>
-<td><a href="#derived-excluded_inherited"><code>excluded_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr>
+<td><a href="#derived-2constructor"><code>derived</code></a>         <span class="small">[constructor]</span></td><td>Constructor should not be inherited</td></tr><tr>
+<td><a href="#derived-2destructor"><code>~derived</code></a> <span class="small">[destructor]</span></td><td>Destructor should not be inherited</td></tr><tr>
+<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr><tr>
+<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr><tr>
+<td><a href="#derived-excluded_inherited"><code>excluded_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -460,11 +418,11 @@ <h2>Protected Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr><tr>
-<td><a href="#derived-do_excluded_inherited"><code>do_excluded_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#derived-do_shadowed"><code>do_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr>
+<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr><tr>
+<td><a href="#derived-do_excluded_inherited"><code>do_excluded_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#derived-do_shadowed"><code>do_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -474,8 +432,7 @@ <h2>Protected Member Functions</h2>
 <div>
 <h2 id="derived-2constructor">derived::derived</h2>
 <div>
-<span>Constructor should not be inherited</span>
-
+<p>Constructor should not be inherited</p>
 </div>
 </div>
 <div>
@@ -483,9 +440,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">derived();
-
-</code>
+<code class="source-code cpp">derived();</code>
 </pre>
 </div>
 </div>
@@ -493,8 +448,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="derived-2destructor">derived::~derived</h2>
 <div>
-<span>Destructor should not be inherited</span>
-
+<p>Destructor should not be inherited</p>
 </div>
 </div>
 <div>
@@ -502,9 +456,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">~derived();
-
-</code>
+<code class="source-code cpp">~derived();</code>
 </pre>
 </div>
 </div>
@@ -512,8 +464,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="derived-derived_shadowed">derived::derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -522,9 +473,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#derived">derived</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 </div>
@@ -532,8 +481,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="derived-do_derived_shadowed">derived::do_derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -542,9 +490,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#derived">derived</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 </div>
@@ -552,8 +498,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="derived-excluded_inherited">derived::excluded_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -562,9 +507,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">excluded_base&
-excluded_inherited();
-
-</code>
+excluded_inherited();</code>
 </pre>
 </div>
 </div>
@@ -572,8 +515,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="derived-do_excluded_inherited">derived::do_excluded_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -582,9 +524,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">excluded_base&
-do_excluded_inherited();
-
-</code>
+do_excluded_inherited();</code>
 </pre>
 </div>
 </div>
@@ -592,8 +532,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="derived-do_shadowed">derived::do_shadowed</h2>
 <div>
-<span>This function should be shadowed by derived classes.</span>
-
+<p>This function should be shadowed by derived classes.</p>
 </div>
 </div>
 <div>
@@ -602,9 +541,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">excluded_base&
-do_shadowed();
-
-</code>
+do_shadowed();</code>
 </pre>
 </div>
 </div>
@@ -619,9 +556,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">class private_derived
     : <a href="#base">base</a>
-    , excluded_base
-
-</code>
+    , excluded_base</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -634,10 +569,10 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#private_derived-2constructor"><code>private_derived</code></a>         <span class="small">[constructor]</span></td><td><span>Constructor should not be inherited</span></td></tr><tr>
-<td><a href="#private_derived-2destructor"><code>~private_derived</code></a> <span class="small">[destructor]</span></td><td><span>Destructor should not be inherited</span></td></tr><tr>
-<td><a href="#private_derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr><tr>
-<td><a href="#private_derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr>
+<td><a href="#private_derived-2constructor"><code>private_derived</code></a>         <span class="small">[constructor]</span></td><td>Constructor should not be inherited</td></tr><tr>
+<td><a href="#private_derived-2destructor"><code>~private_derived</code></a> <span class="small">[destructor]</span></td><td>Destructor should not be inherited</td></tr><tr>
+<td><a href="#private_derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr><tr>
+<td><a href="#private_derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr>
 </tbody>
 </table>
 
@@ -648,8 +583,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="private_derived-2constructor">private_derived::private_derived</h2>
 <div>
-<span>Constructor should not be inherited</span>
-
+<p>Constructor should not be inherited</p>
 </div>
 </div>
 <div>
@@ -657,9 +591,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">private_derived();
-
-</code>
+<code class="source-code cpp">private_derived();</code>
 </pre>
 </div>
 </div>
@@ -667,8 +599,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="private_derived-2destructor">private_derived::~private_derived</h2>
 <div>
-<span>Destructor should not be inherited</span>
-
+<p>Destructor should not be inherited</p>
 </div>
 </div>
 <div>
@@ -676,9 +607,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">~private_derived();
-
-</code>
+<code class="source-code cpp">~private_derived();</code>
 </pre>
 </div>
 </div>
@@ -686,8 +615,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="private_derived-derived_shadowed">private_derived::derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -696,9 +624,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#private_derived">private_derived</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 </div>
@@ -706,8 +632,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="private_derived-do_derived_shadowed">private_derived::do_derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -716,9 +641,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#private_derived">private_derived</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 </div>
@@ -726,8 +649,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="protected_derived">protected_derived</h2>
 <div>
-<span>Should inherit functions as protected.</span>
-
+<p>Should inherit functions as protected.</p>
 </div>
 </div>
 <div>
@@ -737,9 +659,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">class protected_derived
     : protected <a href="#base">base</a>
-    , protected excluded_base
-
-</code>
+    , protected excluded_base</code>
 </pre>
 </div>
 <div>
@@ -752,8 +672,8 @@ <h2>Protected Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#base">base</a></code></td><td><span></span></td></tr>
-<tr><td><code>excluded_base</code></td><td><span></span></td></tr>
+<tr><td><code><a href="#base">base</a></code></td><td></td></tr>
+<tr><td><code>excluded_base</code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -767,10 +687,10 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#protected_derived-2constructor"><code>protected_derived</code></a>         <span class="small">[constructor]</span></td><td><span>Constructor should not be inherited</span></td></tr><tr>
-<td><a href="#protected_derived-2destructor"><code>~protected_derived</code></a> <span class="small">[destructor]</span></td><td><span>Destructor should not be inherited</span></td></tr><tr>
-<td><a href="#protected_derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr><tr>
-<td><a href="#protected_derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should shadow the base class function.</span></td></tr>
+<td><a href="#protected_derived-2constructor"><code>protected_derived</code></a>         <span class="small">[constructor]</span></td><td>Constructor should not be inherited</td></tr><tr>
+<td><a href="#protected_derived-2destructor"><code>~protected_derived</code></a> <span class="small">[destructor]</span></td><td>Destructor should not be inherited</td></tr><tr>
+<td><a href="#protected_derived-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr><tr>
+<td><a href="#protected_derived-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should shadow the base class function.</td></tr>
 </tbody>
 </table>
 
@@ -785,17 +705,17 @@ <h2>Protected Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#base-derived_shadowed"><code>derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr><tr>
-<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td><span>This function should be indirectly inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td><span>This function should shadow the excluded_base function.</span></td></tr><tr>
-<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr><tr>
-<td><a href="#protected_derived-do_excluded_inherited"><code>do_excluded_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr><tr>
-<td><a href="#protected_derived-do_shadowed"><code>do_shadowed</code></a> </td><td><span>This function should be shadowed by derived classes.</span></td></tr><tr>
-<td><a href="#protected_derived-excluded_inherited"><code>excluded_inherited</code></a> </td><td><span>This function should be inherited by derived classes.</span></td></tr>
+<td><a href="#base_base-base_base_inherited"><code>base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_inherited"><code>base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-base_shadowed"><code>base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#base-derived_shadowed"><code>derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr><tr>
+<td><a href="#base_base-do_base_base_inherited"><code>do_base_base_inherited</code></a> </td><td>This function should be indirectly inherited by derived classes.</td></tr><tr>
+<td><a href="#base-do_base_inherited"><code>do_base_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#base-do_base_shadowed"><code>do_base_shadowed</code></a> </td><td>This function should shadow the excluded_base function.</td></tr><tr>
+<td><a href="#base-do_derived_shadowed"><code>do_derived_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr><tr>
+<td><a href="#protected_derived-do_excluded_inherited"><code>do_excluded_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr><tr>
+<td><a href="#protected_derived-do_shadowed"><code>do_shadowed</code></a> </td><td>This function should be shadowed by derived classes.</td></tr><tr>
+<td><a href="#protected_derived-excluded_inherited"><code>excluded_inherited</code></a> </td><td>This function should be inherited by derived classes.</td></tr>
 </tbody>
 </table>
 
@@ -805,8 +725,7 @@ <h2>Protected Member Functions</h2>
 <div>
 <h2 id="protected_derived-2constructor">protected_derived::protected_derived</h2>
 <div>
-<span>Constructor should not be inherited</span>
-
+<p>Constructor should not be inherited</p>
 </div>
 </div>
 <div>
@@ -814,9 +733,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">protected_derived();
-
-</code>
+<code class="source-code cpp">protected_derived();</code>
 </pre>
 </div>
 </div>
@@ -824,8 +741,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="protected_derived-2destructor">protected_derived::~protected_derived</h2>
 <div>
-<span>Destructor should not be inherited</span>
-
+<p>Destructor should not be inherited</p>
 </div>
 </div>
 <div>
@@ -833,9 +749,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">~protected_derived();
-
-</code>
+<code class="source-code cpp">~protected_derived();</code>
 </pre>
 </div>
 </div>
@@ -843,8 +757,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="protected_derived-derived_shadowed">protected_derived::derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -853,22 +766,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#protected_derived">protected_derived</a>&
-derived_shadowed();
-
-</code>
+derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Should inherit functions as protected.</span>
+Should inherit functions as protected.
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived-do_derived_shadowed">protected_derived::do_derived_shadowed</h2>
 <div>
-<span>This function should shadow the base class function.</span>
-
+<p>This function should shadow the base class function.</p>
 </div>
 </div>
 <div>
@@ -877,22 +787,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#protected_derived">protected_derived</a>&
-do_derived_shadowed();
-
-</code>
+do_derived_shadowed();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Should inherit functions as protected.</span>
+Should inherit functions as protected.
 </div>
 </div>
 <div>
 <div>
 <h2 id="protected_derived-do_excluded_inherited">protected_derived::do_excluded_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -901,9 +808,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">excluded_base&
-do_excluded_inherited();
-
-</code>
+do_excluded_inherited();</code>
 </pre>
 </div>
 </div>
@@ -911,8 +816,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="protected_derived-do_shadowed">protected_derived::do_shadowed</h2>
 <div>
-<span>This function should be shadowed by derived classes.</span>
-
+<p>This function should be shadowed by derived classes.</p>
 </div>
 </div>
 <div>
@@ -921,9 +825,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">excluded_base&
-do_shadowed();
-
-</code>
+do_shadowed();</code>
 </pre>
 </div>
 </div>
@@ -931,8 +833,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="protected_derived-excluded_inherited">protected_derived::excluded_inherited</h2>
 <div>
-<span>This function should be inherited by derived classes.</span>
-
+<p>This function should be inherited by derived classes.</p>
 </div>
 </div>
 <div>
@@ -941,9 +842,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;skip-special.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">excluded_base&
-excluded_inherited();
-
-</code>
+excluded_inherited();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/legible-names/constructor.html b/test-files/golden-tests/config/legible-names/constructor.html
index bb40070c9..f20945858 100644
--- a/test-files/golden-tests/config/legible-names/constructor.html
+++ b/test-files/golden-tests/config/legible-names/constructor.html
@@ -32,9 +32,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;constructor.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct X;
-
-</code>
+<code class="source-code cpp">struct X;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -47,7 +45,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#X-2constructor-08"><code>X</code></a>         <span class="small">[constructor]</span></td><td><span>Constructors</span></td></tr>
+<td><a href="#X-2constructor-08"><code>X</code></a>         <span class="small">[constructor]</span></td><td>Constructors</td></tr>
 </tbody>
 </table>
 
@@ -58,47 +56,36 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="X-2constructor-08">X::X</h2>
 <div>
-<span>Constructors</span>
-
+<p>Constructors</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;constructor.cpp&gt;</code></div>
-<span>Default constructor</span>
+<p>Default constructor</p>
 <pre>
-<code class="source-code cpp"><a href="#X-2constructor-0e8">X</a>();
-
-</code>
+<code class="source-code cpp"><a href="#X-2constructor-0e8">X</a>();</code>
 </pre><span class="small"><a href="#X-2constructor-0e8"><em>» more...</em></a></span>
 
-<span>Copy constructor</span>
+<p>Copy constructor</p>
 <pre>
-<code class="source-code cpp"><a href="#X-2constructor-0e0">X</a>(<a href="#X">X</a> const& other);
-
-</code>
+<code class="source-code cpp"><a href="#X-2constructor-0e0">X</a>(<a href="#X">X</a> const& other);</code>
 </pre><span class="small"><a href="#X-2constructor-0e0"><em>» more...</em></a></span>
 
-<span>Move constructor</span>
+<p>Move constructor</p>
 <pre>
-<code class="source-code cpp"><a href="#X-2constructor-069">X</a>(<a href="#X">X</a>&& other);
-
-</code>
+<code class="source-code cpp"><a href="#X-2constructor-069">X</a>(<a href="#X">X</a>&& other);</code>
 </pre><span class="small"><a href="#X-2constructor-069"><em>» more...</em></a></span>
 
-<span>Construct from <code>int</code></span>
+<p>Construct from <code>int</code></p>
 <pre>
-<code class="source-code cpp"><a href="#X-2constructor-07">X</a>(int value);
-
-</code>
+<code class="source-code cpp"><a href="#X-2constructor-07">X</a>(int value);</code>
 </pre><span class="small"><a href="#X-2constructor-07"><em>» more...</em></a></span>
 
-<span>Construct from <code>double</code></span>
+<p>Construct from <code>double</code></p>
 <pre>
-<code class="source-code cpp"><a href="#X-2constructor-06f">X</a>(double value);
-
-</code>
+<code class="source-code cpp"><a href="#X-2constructor-06f">X</a>(double value);</code>
 </pre><span class="small"><a href="#X-2constructor-06f"><em>» more...</em></a></span>
 
 
@@ -108,8 +95,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="X-2constructor-0e8">X::X</h2>
 <div>
-<span>Default constructor</span>
-
+<p>Default constructor</p>
 </div>
 </div>
 <div>
@@ -117,9 +103,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;constructor.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">X();
-
-</code>
+<code class="source-code cpp">X();</code>
 </pre>
 </div>
 </div>
@@ -127,8 +111,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="X-2constructor-0e0">X::X</h2>
 <div>
-<span>Copy constructor</span>
-
+<p>Copy constructor</p>
 </div>
 </div>
 <div>
@@ -136,9 +119,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;constructor.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">X(<a href="#X">X</a> const& other);
-
-</code>
+<code class="source-code cpp">X(<a href="#X">X</a> const& other);</code>
 </pre>
 </div>
 <div>
@@ -153,7 +134,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The object to copy construct from</span></td>
+<td>The object to copy construct from</td>
 </tr>
 </tbody>
 </table>
@@ -163,8 +144,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-2constructor-069">X::X</h2>
 <div>
-<span>Move constructor</span>
-
+<p>Move constructor</p>
 </div>
 </div>
 <div>
@@ -172,9 +152,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;constructor.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">X(<a href="#X">X</a>&& other);
-
-</code>
+<code class="source-code cpp">X(<a href="#X">X</a>&& other);</code>
 </pre>
 </div>
 <div>
@@ -189,7 +167,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The object to move construct from</span></td>
+<td>The object to move construct from</td>
 </tr>
 </tbody>
 </table>
@@ -199,8 +177,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-2constructor-07">X::X</h2>
 <div>
-<span>Construct from <code>int</code></span>
-
+<p>Construct from <code>int</code></p>
 </div>
 </div>
 <div>
@@ -208,9 +185,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;constructor.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">X(int value);
-
-</code>
+<code class="source-code cpp">X(int value);</code>
 </pre>
 </div>
 <div>
@@ -225,7 +200,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The value to construct from</span></td>
+<td>The value to construct from</td>
 </tr>
 </tbody>
 </table>
@@ -235,8 +210,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="X-2constructor-06f">X::X</h2>
 <div>
-<span>Construct from <code>double</code></span>
-
+<p>Construct from <code>double</code></p>
 </div>
 </div>
 <div>
@@ -244,9 +218,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;constructor.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">X(double value);
-
-</code>
+<code class="source-code cpp">X(double value);</code>
 </pre>
 </div>
 <div>
@@ -261,7 +233,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The value to construct from</span></td>
+<td>The value to construct from</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/config/missing-include-prefixes/main.html b/test-files/golden-tests/config/missing-include-prefixes/main.html
index 08f392245..90febb921 100644
--- a/test-files/golden-tests/config/missing-include-prefixes/main.html
+++ b/test-files/golden-tests/config/missing-include-prefixes/main.html
@@ -34,9 +34,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;main.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">unknown_type
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -50,9 +48,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;main.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">unknown_ns::unknown_type
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/missing-include-shims/main.html b/test-files/golden-tests/config/missing-include-shims/main.html
index f40715328..c62a988b3 100644
--- a/test-files/golden-tests/config/missing-include-shims/main.html
+++ b/test-files/golden-tests/config/missing-include-shims/main.html
@@ -19,7 +19,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>Function satisfied by missing-include-shims</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>Function satisfied by missing-include-shims</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>Function satisfied by missing-include-shims</span>
-
+<p>Function satisfied by missing-include-shims</p>
 </div>
 </div>
 <div>
@@ -38,14 +37,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;main.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">llvm::StringRef
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>An empty string of a type defined in the shims.</span>
+An empty string of a type defined in the shims.
 </div>
 </div>
 
diff --git a/test-files/golden-tests/config/overloads/const-mutable.adoc b/test-files/golden-tests/config/overloads/const-mutable.adoc
index 1c99cbc9b..524ed5421 100644
--- a/test-files/golden-tests/config/overloads/const-mutable.adoc
+++ b/test-files/golden-tests/config/overloads/const-mutable.adoc
@@ -26,12 +26,10 @@ class C;
 
 === Member Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#C-foo-0e[`foo`] 
-| 
 |===
 
 [#C-foo-0e]
diff --git a/test-files/golden-tests/config/overloads/const-mutable.html b/test-files/golden-tests/config/overloads/const-mutable.html
index 1edc7e2ce..476d9fae3 100644
--- a/test-files/golden-tests/config/overloads/const-mutable.html
+++ b/test-files/golden-tests/config/overloads/const-mutable.html
@@ -32,9 +32,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;const-mutable.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class C;
-
-</code>
+<code class="source-code cpp">class C;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -42,12 +40,11 @@ <h2>Member Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#C-foo-0e"><code>foo</code></a> </td><td><span></span></td></tr>
+<td><a href="#C-foo-0e"><code>foo</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -65,17 +62,13 @@ <h3>Synopses</h3>
 
 <pre>
 <code class="source-code cpp">int&
-<a href="#C-foo-0b">foo</a>();
-
-</code>
+<a href="#C-foo-0b">foo</a>();</code>
 </pre><span class="small"><a href="#C-foo-0b"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">int&
-<a href="#C-foo-07">foo</a>() const;
-
-</code>
+<a href="#C-foo-07">foo</a>() const;</code>
 </pre><span class="small"><a href="#C-foo-07"><em>» more...</em></a></span>
 
 
@@ -91,9 +84,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;const-mutable.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int&
-foo();
-
-</code>
+foo();</code>
 </pre>
 </div>
 </div>
@@ -107,9 +98,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;const-mutable.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int&
-foo() const;
-
-</code>
+foo() const;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/overloads/visibility.adoc b/test-files/golden-tests/config/overloads/visibility.adoc
index 320d4062f..2c4dacd81 100644
--- a/test-files/golden-tests/config/overloads/visibility.adoc
+++ b/test-files/golden-tests/config/overloads/visibility.adoc
@@ -26,42 +26,34 @@ class C;
 
 === Member Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#C-foo-0e[`foo`] 
-| 
 |===
 
 === Static Member Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#C-foo-03[`foo`] 
-| 
 |===
 
 === Protected Member Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#C-foo-04c[`foo`] 
-| 
 |===
 
 === Protected Static Member Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#C-foo-048[`foo`] 
-| 
 |===
 
 [#C-foo-0e]
diff --git a/test-files/golden-tests/config/overloads/visibility.html b/test-files/golden-tests/config/overloads/visibility.html
index 41883e144..9cf60cc67 100644
--- a/test-files/golden-tests/config/overloads/visibility.html
+++ b/test-files/golden-tests/config/overloads/visibility.html
@@ -32,9 +32,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;visibility.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class C;
-
-</code>
+<code class="source-code cpp">class C;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -42,12 +40,11 @@ <h2>Member Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#C-foo-0e"><code>foo</code></a> </td><td><span></span></td></tr>
+<td><a href="#C-foo-0e"><code>foo</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -56,12 +53,11 @@ <h2>Static Member Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#C-foo-03"><code>foo</code></a> </td><td><span></span></td></tr>
+<td><a href="#C-foo-03"><code>foo</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -71,12 +67,11 @@ <h2>Protected Member Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#C-foo-04c"><code>foo</code></a> </td><td><span></span></td></tr>
+<td><a href="#C-foo-04c"><code>foo</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -85,12 +80,11 @@ <h2>Protected Static Member Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#C-foo-048"><code>foo</code></a> </td><td><span></span></td></tr>
+<td><a href="#C-foo-048"><code>foo</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -107,17 +101,13 @@ <h3>Synopses</h3>
 
 <pre>
 <code class="source-code cpp">int
-<a href="#C-foo-0b">foo</a>();
-
-</code>
+<a href="#C-foo-0b">foo</a>();</code>
 </pre><span class="small"><a href="#C-foo-0b"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">int
-<a href="#C-foo-06">foo</a>(bool);
-
-</code>
+<a href="#C-foo-06">foo</a>(bool);</code>
 </pre><span class="small"><a href="#C-foo-06"><em>» more...</em></a></span>
 
 
@@ -133,9 +123,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;visibility.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int
-foo();
-
-</code>
+foo();</code>
 </pre>
 </div>
 </div>
@@ -149,9 +137,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;visibility.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int
-foo(bool);
-
-</code>
+foo(bool);</code>
 </pre>
 </div>
 </div>
@@ -167,9 +153,7 @@ <h3>Synopses</h3>
 <pre>
 <code class="source-code cpp">static
 int
-<a href="#C-foo-0fc">foo</a>(int);
-
-</code>
+<a href="#C-foo-0fc">foo</a>(int);</code>
 </pre><span class="small"><a href="#C-foo-0fc"><em>» more...</em></a></span>
 
 
@@ -178,9 +162,7 @@ <h3>Synopses</h3>
 int
 <a href="#C-foo-05">foo</a>(
     int,
-    bool);
-
-</code>
+    bool);</code>
 </pre><span class="small"><a href="#C-foo-05"><em>» more...</em></a></span>
 
 
@@ -197,9 +179,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">static
 int
-foo(int);
-
-</code>
+foo(int);</code>
 </pre>
 </div>
 </div>
@@ -216,9 +196,7 @@ <h3>Synopsis</h3>
 int
 foo(
     int,
-    bool);
-
-</code>
+    bool);</code>
 </pre>
 </div>
 </div>
@@ -235,9 +213,7 @@ <h3>Synopses</h3>
 <code class="source-code cpp">int
 <a href="#C-foo-0a">foo</a>(
     int,
-    int);
-
-</code>
+    int);</code>
 </pre><span class="small"><a href="#C-foo-0a"><em>» more...</em></a></span>
 
 
@@ -246,9 +222,7 @@ <h3>Synopses</h3>
 <a href="#C-foo-0c">foo</a>(
     int,
     int,
-    bool);
-
-</code>
+    bool);</code>
 </pre><span class="small"><a href="#C-foo-0c"><em>» more...</em></a></span>
 
 
@@ -266,9 +240,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">int
 foo(
     int,
-    int);
-
-</code>
+    int);</code>
 </pre>
 </div>
 </div>
@@ -285,9 +257,7 @@ <h3>Synopsis</h3>
 foo(
     int,
     int,
-    bool);
-
-</code>
+    bool);</code>
 </pre>
 </div>
 </div>
@@ -306,9 +276,7 @@ <h3>Synopses</h3>
 <a href="#C-foo-00">foo</a>(
     int,
     int,
-    int);
-
-</code>
+    int);</code>
 </pre><span class="small"><a href="#C-foo-00"><em>» more...</em></a></span>
 
 
@@ -319,9 +287,7 @@ <h3>Synopses</h3>
     int,
     int,
     int,
-    bool);
-
-</code>
+    bool);</code>
 </pre><span class="small"><a href="#C-foo-0f5"><em>» more...</em></a></span>
 
 
@@ -341,9 +307,7 @@ <h3>Synopsis</h3>
 foo(
     int,
     int,
-    int);
-
-</code>
+    int);</code>
 </pre>
 </div>
 </div>
@@ -362,9 +326,7 @@ <h3>Synopsis</h3>
     int,
     int,
     int,
-    bool);
-
-</code>
+    bool);</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/sfinae/redeclare.html b/test-files/golden-tests/config/sfinae/redeclare.html
index 207f80385..84a6ac37d 100644
--- a/test-files/golden-tests/config/sfinae/redeclare.html
+++ b/test-files/golden-tests/config/sfinae/redeclare.html
@@ -35,9 +35,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;typename T&gt;
 void
 f(void)
-requires std::is_class_v&lt;T&gt;;
-
-</code>
+requires std::is_class_v&lt;T&gt;;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/sfinae/return-based.html b/test-files/golden-tests/config/sfinae/return-based.html
index a64428920..bab64f561 100644
--- a/test-files/golden-tests/config/sfinae/return-based.html
+++ b/test-files/golden-tests/config/sfinae/return-based.html
@@ -35,9 +35,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;typename T&gt;
 int
 f()
-requires std::is_class_v&lt;T&gt;;
-
-</code>
+requires std::is_class_v&lt;T&gt;;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.html b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.html
index 8c07c4e70..07e582383 100644
--- a/test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.html
+++ b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-false.html
@@ -19,7 +19,7 @@ <h2>Enums</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#Color"><code>Color</code></a> </td><td><span>A simple enum</span></td></tr>
+<td><a href="#Color"><code>Color</code></a> </td><td>A simple enum</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Enums</h2>
 <div>
 <h2 id="Color">Color</h2>
 <div>
-<span>A simple enum</span>
-
+<p>A simple enum</p>
 </div>
 </div>
 <div>
@@ -37,9 +36,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;show-enum-constants-false.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">enum class Color : int;
-
-</code>
+<code class="source-code cpp">enum class Color : int;</code>
 </pre>
 </div>
 <h2>Members</h2>
@@ -52,9 +49,9 @@ <h2>Members</h2>
 </thead>
 <tbody>
 <tr>
-<td><code>Red</code> </td><td><span>The color red</span></td></tr><tr>
-<td><code>Green</code> </td><td><span>The color green</span></td></tr><tr>
-<td><code>Blue</code> </td><td><span>The color blue</span></td></tr>
+<td><code>Red</code> </td><td>The color red</td></tr><tr>
+<td><code>Green</code> </td><td>The color green</td></tr><tr>
+<td><code>Blue</code> </td><td>The color blue</td></tr>
 </tbody>
 </table>
 
diff --git a/test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.html b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.html
index 6dde51084..d763b2040 100644
--- a/test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.html
+++ b/test-files/golden-tests/config/show-enum-constants/show-enum-constants-true.html
@@ -19,7 +19,7 @@ <h2>Enums</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#Color"><code>Color</code></a> </td><td><span>A simple enum</span></td></tr>
+<td><a href="#Color"><code>Color</code></a> </td><td>A simple enum</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Enums</h2>
 <div>
 <h2 id="Color">Color</h2>
 <div>
-<span>A simple enum</span>
-
+<p>A simple enum</p>
 </div>
 </div>
 <div>
@@ -37,9 +36,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;show-enum-constants-true.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">enum class Color : int;
-
-</code>
+<code class="source-code cpp">enum class Color : int;</code>
 </pre>
 </div>
 <h2>Members</h2>
@@ -52,9 +49,9 @@ <h2>Members</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#Color-Red"><code>Red</code></a> </td><td><span>The color red</span></td></tr><tr>
-<td><a href="#Color-Green"><code>Green</code></a> </td><td><span>The color green</span></td></tr><tr>
-<td><a href="#Color-Blue"><code>Blue</code></a> </td><td><span>The color blue</span></td></tr>
+<td><a href="#Color-Red"><code>Red</code></a> </td><td>The color red</td></tr><tr>
+<td><a href="#Color-Green"><code>Green</code></a> </td><td>The color green</td></tr><tr>
+<td><a href="#Color-Blue"><code>Blue</code></a> </td><td>The color blue</td></tr>
 </tbody>
 </table>
 
@@ -63,8 +60,7 @@ <h2>Members</h2>
 <div>
 <h2 id="Color-Red">Color::Red</h2>
 <div>
-<span>The color red</span>
-
+<p>The color red</p>
 </div>
 </div>
 <div>
@@ -72,9 +68,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;show-enum-constants-true.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">Red
-
-</code>
+<code class="source-code cpp">Red</code>
 </pre>
 </div>
 </div>
@@ -82,8 +76,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="Color-Green">Color::Green</h2>
 <div>
-<span>The color green</span>
-
+<p>The color green</p>
 </div>
 </div>
 <div>
@@ -91,9 +84,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;show-enum-constants-true.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">Green
-
-</code>
+<code class="source-code cpp">Green</code>
 </pre>
 </div>
 </div>
@@ -101,8 +92,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="Color-Blue">Color::Blue</h2>
 <div>
-<span>The color blue</span>
-
+<p>The color blue</p>
 </div>
 </div>
 <div>
@@ -110,9 +100,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;show-enum-constants-true.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">Blue
-
-</code>
+<code class="source-code cpp">Blue</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/show-namespaces/show-namespaces.html b/test-files/golden-tests/config/show-namespaces/show-namespaces.html
index 1ed532aeb..d158a60b8 100644
--- a/test-files/golden-tests/config/show-namespaces/show-namespaces.html
+++ b/test-files/golden-tests/config/show-namespaces/show-namespaces.html
@@ -15,9 +15,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;show-namespaces.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-c();
-
-</code>
+c();</code>
 </pre>
 </div>
 </div>
@@ -31,9 +29,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;show-namespaces.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-b();
-
-</code>
+b();</code>
 </pre>
 </div>
 </div>
@@ -47,9 +43,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;show-namespaces.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-a();
-
-</code>
+a();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/sort-members-by/sort-members-by-location.html b/test-files/golden-tests/config/sort-members-by/sort-members-by-location.html
index e6fd0d68d..05bbb2612 100644
--- a/test-files/golden-tests/config/sort-members-by/sort-members-by-location.html
+++ b/test-files/golden-tests/config/sort-members-by/sort-members-by-location.html
@@ -32,9 +32,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-members-by-location.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct Z;
-
-</code>
+<code class="source-code cpp">struct Z;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -47,15 +45,15 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#Z-2constructor-00"><code>Z</code></a>         <span class="small">[constructor]</span></td><td><span>Constructors</span></td></tr><tr>
-<td><a href="#Z-2destructor"><code>~Z</code></a> <span class="small">[destructor]</span></td><td><span>Destructor</span></td></tr><tr>
-<td><a href="#Z-foo"><code>foo</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#Z-bar"><code>bar</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#Z-2conversion"><code>operator bool</code></a> </td><td><span>Conversion to <code>bool</code></span></td></tr><tr>
-<td><a href="#Z-operator_not"><code>operator!</code></a> </td><td><span>Negation operator</span></td></tr><tr>
-<td><a href="#Z-operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td><span>Equality operator</span></td></tr><tr>
-<td><a href="#Z-operator_not_eq"><code>operator!&#x3D;</code></a> </td><td><span>Inequality operator</span></td></tr><tr>
-<td><a href="#Z-operator_3way"><code>operator&lt;&#x3D;&gt;</code></a> </td><td><span>Three-way comparison operator</span></td></tr>
+<td><a href="#Z-2constructor-00"><code>Z</code></a>         <span class="small">[constructor]</span></td><td>Constructors</td></tr><tr>
+<td><a href="#Z-2destructor"><code>~Z</code></a> <span class="small">[destructor]</span></td><td>Destructor</td></tr><tr>
+<td><a href="#Z-foo"><code>foo</code></a> </td><td></td></tr><tr>
+<td><a href="#Z-bar"><code>bar</code></a> </td><td></td></tr><tr>
+<td><a href="#Z-2conversion"><code>operator bool</code></a> </td><td>Conversion to <code>bool</code></td></tr><tr>
+<td><a href="#Z-operator_not"><code>operator!</code></a> </td><td>Negation operator</td></tr><tr>
+<td><a href="#Z-operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td>Equality operator</td></tr><tr>
+<td><a href="#Z-operator_not_eq"><code>operator!&#x3D;</code></a> </td><td>Inequality operator</td></tr><tr>
+<td><a href="#Z-operator_3way"><code>operator&lt;&#x3D;&gt;</code></a> </td><td>Three-way comparison operator</td></tr>
 </tbody>
 </table>
 
@@ -66,26 +64,21 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="Z-2constructor-00">Z::Z</h2>
 <div>
-<span>Constructors</span>
-
+<p>Constructors</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;sort-members-by-location.cpp&gt;</code></div>
-<span>Construct from <code>int</code></span>
+<p>Construct from <code>int</code></p>
 <pre>
-<code class="source-code cpp"><a href="#Z-2constructor-06">Z</a>(int value);
-
-</code>
+<code class="source-code cpp"><a href="#Z-2constructor-06">Z</a>(int value);</code>
 </pre><span class="small"><a href="#Z-2constructor-06"><em>» more...</em></a></span>
 
-<span>Default constructor</span>
+<p>Default constructor</p>
 <pre>
-<code class="source-code cpp"><a href="#Z-2constructor-05">Z</a>();
-
-</code>
+<code class="source-code cpp"><a href="#Z-2constructor-05">Z</a>();</code>
 </pre><span class="small"><a href="#Z-2constructor-05"><em>» more...</em></a></span>
 
 
@@ -95,8 +88,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="Z-2constructor-06">Z::Z</h2>
 <div>
-<span>Construct from <code>int</code></span>
-
+<p>Construct from <code>int</code></p>
 </div>
 </div>
 <div>
@@ -104,9 +96,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-members-by-location.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">Z(int value);
-
-</code>
+<code class="source-code cpp">Z(int value);</code>
 </pre>
 </div>
 <div>
@@ -121,7 +111,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The value to construct from</span></td>
+<td>The value to construct from</td>
 </tr>
 </tbody>
 </table>
@@ -131,8 +121,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Z-2constructor-05">Z::Z</h2>
 <div>
-<span>Default constructor</span>
-
+<p>Default constructor</p>
 </div>
 </div>
 <div>
@@ -140,9 +129,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-members-by-location.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">Z();
-
-</code>
+<code class="source-code cpp">Z();</code>
 </pre>
 </div>
 </div>
@@ -150,8 +137,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="Z-2destructor">Z::~Z</h2>
 <div>
-<span>Destructor</span>
-
+<p>Destructor</p>
 </div>
 </div>
 <div>
@@ -159,9 +145,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-members-by-location.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">~Z();
-
-</code>
+<code class="source-code cpp">~Z();</code>
 </pre>
 </div>
 </div>
@@ -175,9 +159,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-foo() const;
-
-</code>
+foo() const;</code>
 </pre>
 </div>
 </div>
@@ -191,9 +173,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-bar() const;
-
-</code>
+bar() const;</code>
 </pre>
 </div>
 </div>
@@ -201,8 +181,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="Z-2conversion">Z::operator bool</h2>
 <div>
-<span>Conversion to <code>bool</code></span>
-
+<p>Conversion to <code>bool</code></p>
 </div>
 </div>
 <div>
@@ -210,22 +189,19 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-members-by-location.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">operator bool() const;
-
-</code>
+<code class="source-code cpp">operator bool() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The object converted to <code>bool</code></span>
+The object converted to <code>bool</code>
 </div>
 </div>
 <div>
 <div>
 <h2 id="Z-operator_not">Z::operator!</h2>
 <div>
-<span>Negation operator</span>
-
+<p>Negation operator</p>
 </div>
 </div>
 <div>
@@ -234,22 +210,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator!() const;
-
-</code>
+operator!() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the object is falsy, <code>false</code> otherwise</span>
+<code>true</code> if the object is falsy, <code>false</code> otherwise
 </div>
 </div>
 <div>
 <div>
 <h2 id="Z-operator_eq">Z::operator&#x3D;&#x3D;</h2>
 <div>
-<span>Equality operator</span>
-
+<p>Equality operator</p>
 </div>
 </div>
 <div>
@@ -258,14 +231,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator&#x3D;&#x3D;(<a href="#Z">Z</a> const& rhs) const;
-
-</code>
+operator&#x3D;&#x3D;(<a href="#Z">Z</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -279,7 +250,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -289,8 +260,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Z-operator_not_eq">Z::operator!&#x3D;</h2>
 <div>
-<span>Inequality operator</span>
-
+<p>Inequality operator</p>
 </div>
 </div>
 <div>
@@ -299,14 +269,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator!&#x3D;(<a href="#Z">Z</a> const& rhs) const;
-
-</code>
+operator!&#x3D;(<a href="#Z">Z</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are not equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are not equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -320,7 +288,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -330,8 +298,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Z-operator_3way">Z::operator&lt;&#x3D;&gt;</h2>
 <div>
-<span>Three-way comparison operator</span>
-
+<p>Three-way comparison operator</p>
 </div>
 </div>
 <div>
@@ -340,14 +307,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">auto
-operator&lt;&#x3D;&gt;(<a href="#Z">Z</a> const& rhs) const;
-
-</code>
+operator&lt;&#x3D;&gt;(<a href="#Z">Z</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The relative order of the objects</span>
+The relative order of the objects
 </div>
 <div>
 <h3>Parameters</h3>
@@ -361,7 +326,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/config/sort-members-by/sort-members-by-name.html b/test-files/golden-tests/config/sort-members-by/sort-members-by-name.html
index 575e608a3..ac4fdcaf4 100644
--- a/test-files/golden-tests/config/sort-members-by/sort-members-by-name.html
+++ b/test-files/golden-tests/config/sort-members-by/sort-members-by-name.html
@@ -32,9 +32,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-members-by-name.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct Z;
-
-</code>
+<code class="source-code cpp">struct Z;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -47,15 +45,15 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#Z-2constructor-00"><code>Z</code></a>         <span class="small">[constructor]</span></td><td><span>Constructors</span></td></tr><tr>
-<td><a href="#Z-2destructor"><code>~Z</code></a> <span class="small">[destructor]</span></td><td><span>Destructor</span></td></tr><tr>
-<td><a href="#Z-bar"><code>bar</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#Z-foo"><code>foo</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#Z-2conversion"><code>operator bool</code></a> </td><td><span>Conversion to <code>bool</code></span></td></tr><tr>
-<td><a href="#Z-operator_not"><code>operator!</code></a> </td><td><span>Negation operator</span></td></tr><tr>
-<td><a href="#Z-operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td><span>Equality operator</span></td></tr><tr>
-<td><a href="#Z-operator_not_eq"><code>operator!&#x3D;</code></a> </td><td><span>Inequality operator</span></td></tr><tr>
-<td><a href="#Z-operator_3way"><code>operator&lt;&#x3D;&gt;</code></a> </td><td><span>Three-way comparison operator</span></td></tr>
+<td><a href="#Z-2constructor-00"><code>Z</code></a>         <span class="small">[constructor]</span></td><td>Constructors</td></tr><tr>
+<td><a href="#Z-2destructor"><code>~Z</code></a> <span class="small">[destructor]</span></td><td>Destructor</td></tr><tr>
+<td><a href="#Z-bar"><code>bar</code></a> </td><td></td></tr><tr>
+<td><a href="#Z-foo"><code>foo</code></a> </td><td></td></tr><tr>
+<td><a href="#Z-2conversion"><code>operator bool</code></a> </td><td>Conversion to <code>bool</code></td></tr><tr>
+<td><a href="#Z-operator_not"><code>operator!</code></a> </td><td>Negation operator</td></tr><tr>
+<td><a href="#Z-operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td>Equality operator</td></tr><tr>
+<td><a href="#Z-operator_not_eq"><code>operator!&#x3D;</code></a> </td><td>Inequality operator</td></tr><tr>
+<td><a href="#Z-operator_3way"><code>operator&lt;&#x3D;&gt;</code></a> </td><td>Three-way comparison operator</td></tr>
 </tbody>
 </table>
 
@@ -66,26 +64,21 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="Z-2constructor-00">Z::Z</h2>
 <div>
-<span>Constructors</span>
-
+<p>Constructors</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;sort-members-by-name.cpp&gt;</code></div>
-<span>Default constructor</span>
+<p>Default constructor</p>
 <pre>
-<code class="source-code cpp"><a href="#Z-2constructor-05">Z</a>();
-
-</code>
+<code class="source-code cpp"><a href="#Z-2constructor-05">Z</a>();</code>
 </pre><span class="small"><a href="#Z-2constructor-05"><em>» more...</em></a></span>
 
-<span>Construct from <code>int</code></span>
+<p>Construct from <code>int</code></p>
 <pre>
-<code class="source-code cpp"><a href="#Z-2constructor-06">Z</a>(int value);
-
-</code>
+<code class="source-code cpp"><a href="#Z-2constructor-06">Z</a>(int value);</code>
 </pre><span class="small"><a href="#Z-2constructor-06"><em>» more...</em></a></span>
 
 
@@ -95,8 +88,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="Z-2constructor-05">Z::Z</h2>
 <div>
-<span>Default constructor</span>
-
+<p>Default constructor</p>
 </div>
 </div>
 <div>
@@ -104,9 +96,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-members-by-name.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">Z();
-
-</code>
+<code class="source-code cpp">Z();</code>
 </pre>
 </div>
 </div>
@@ -114,8 +104,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="Z-2constructor-06">Z::Z</h2>
 <div>
-<span>Construct from <code>int</code></span>
-
+<p>Construct from <code>int</code></p>
 </div>
 </div>
 <div>
@@ -123,9 +112,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-members-by-name.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">Z(int value);
-
-</code>
+<code class="source-code cpp">Z(int value);</code>
 </pre>
 </div>
 <div>
@@ -140,7 +127,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The value to construct from</span></td>
+<td>The value to construct from</td>
 </tr>
 </tbody>
 </table>
@@ -150,8 +137,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Z-2destructor">Z::~Z</h2>
 <div>
-<span>Destructor</span>
-
+<p>Destructor</p>
 </div>
 </div>
 <div>
@@ -159,9 +145,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-members-by-name.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">~Z();
-
-</code>
+<code class="source-code cpp">~Z();</code>
 </pre>
 </div>
 </div>
@@ -175,9 +159,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-bar() const;
-
-</code>
+bar() const;</code>
 </pre>
 </div>
 </div>
@@ -191,9 +173,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-foo() const;
-
-</code>
+foo() const;</code>
 </pre>
 </div>
 </div>
@@ -201,8 +181,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="Z-2conversion">Z::operator bool</h2>
 <div>
-<span>Conversion to <code>bool</code></span>
-
+<p>Conversion to <code>bool</code></p>
 </div>
 </div>
 <div>
@@ -210,22 +189,19 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-members-by-name.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">operator bool() const;
-
-</code>
+<code class="source-code cpp">operator bool() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The object converted to <code>bool</code></span>
+The object converted to <code>bool</code>
 </div>
 </div>
 <div>
 <div>
 <h2 id="Z-operator_not">Z::operator!</h2>
 <div>
-<span>Negation operator</span>
-
+<p>Negation operator</p>
 </div>
 </div>
 <div>
@@ -234,22 +210,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator!() const;
-
-</code>
+operator!() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the object is falsy, <code>false</code> otherwise</span>
+<code>true</code> if the object is falsy, <code>false</code> otherwise
 </div>
 </div>
 <div>
 <div>
 <h2 id="Z-operator_eq">Z::operator&#x3D;&#x3D;</h2>
 <div>
-<span>Equality operator</span>
-
+<p>Equality operator</p>
 </div>
 </div>
 <div>
@@ -258,14 +231,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator&#x3D;&#x3D;(<a href="#Z">Z</a> const& rhs) const;
-
-</code>
+operator&#x3D;&#x3D;(<a href="#Z">Z</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -279,7 +250,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -289,8 +260,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Z-operator_not_eq">Z::operator!&#x3D;</h2>
 <div>
-<span>Inequality operator</span>
-
+<p>Inequality operator</p>
 </div>
 </div>
 <div>
@@ -299,14 +269,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator!&#x3D;(<a href="#Z">Z</a> const& rhs) const;
-
-</code>
+operator!&#x3D;(<a href="#Z">Z</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are not equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are not equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -320,7 +288,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -330,8 +298,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Z-operator_3way">Z::operator&lt;&#x3D;&gt;</h2>
 <div>
-<span>Three-way comparison operator</span>
-
+<p>Three-way comparison operator</p>
 </div>
 </div>
 <div>
@@ -340,14 +307,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">auto
-operator&lt;&#x3D;&gt;(<a href="#Z">Z</a> const& rhs) const;
-
-</code>
+operator&lt;&#x3D;&gt;(<a href="#Z">Z</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The relative order of the objects</span>
+The relative order of the objects
 </div>
 <div>
 <h3>Parameters</h3>
@@ -361,7 +326,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-location.adoc b/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-location.adoc
index 5819d534a..0ee4e63c7 100644
--- a/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-location.adoc
+++ b/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-location.adoc
@@ -146,6 +146,20 @@ Declared in `&lt;sort&hyphen;namespace&hyphen;members&hyphen;by&hyphen;location&
 struct A;
 ----
 
+=== Non-Member Functions
+
+[cols=2]
+|===
+| Name
+| Description
+| link:#operator_not[`operator!`]
+| Negation operator
+| link:#operator_not_eq[`operator!&equals;`]
+| Inequality operator
+| link:#operator_eq[`operator&equals;&equals;`]
+| Equality operator
+|===
+
 [#Z]
 == Z
 
diff --git a/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-location.html b/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-location.html
index 2a7014d68..b2ac897a1 100644
--- a/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-location.html
+++ b/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-location.html
@@ -40,12 +40,12 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#h"><code>h</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#g-0f"><code>g</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#f"><code>f</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#operator_not"><code>operator!</code></a> </td><td><span>Negation operator</span></td></tr><tr>
-<td><a href="#operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td><span>Equality operator</span></td></tr><tr>
-<td><a href="#operator_not_eq"><code>operator!&#x3D;</code></a> </td><td><span>Inequality operator</span></td></tr>
+<td><a href="#h"><code>h</code></a> </td><td></td></tr><tr>
+<td><a href="#g-0f"><code>g</code></a> </td><td></td></tr><tr>
+<td><a href="#f"><code>f</code></a> </td><td></td></tr><tr>
+<td><a href="#operator_not"><code>operator!</code></a> </td><td>Negation operator</td></tr><tr>
+<td><a href="#operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td>Equality operator</td></tr><tr>
+<td><a href="#operator_not_eq"><code>operator!&#x3D;</code></a> </td><td>Inequality operator</td></tr>
 </tbody>
 </table>
 
@@ -59,9 +59,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct D;
-
-</code>
+<code class="source-code cpp">struct D;</code>
 </pre>
 </div>
 
@@ -79,9 +77,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     class T,
     class U = void&gt;
-struct C;
-
-</code>
+struct C;</code>
 </pre>
 </div>
 
@@ -97,9 +93,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#C-0f">C</a>&lt;int, char&gt;;
-
-</code>
+struct <a href="#C-0f">C</a>&lt;int, char&gt;;</code>
 </pre>
 </div>
 
@@ -115,9 +109,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#C-0f">C</a>&lt;int&gt;;
-
-</code>
+struct <a href="#C-0f">C</a>&lt;int&gt;;</code>
 </pre>
 </div>
 
@@ -135,9 +127,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     class T,
     class U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 
@@ -153,9 +143,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#B-0b">B</a>&lt;int, char&gt;;
-
-</code>
+struct <a href="#B-0b">B</a>&lt;int, char&gt;;</code>
 </pre>
 </div>
 
@@ -171,9 +159,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class U&gt;
-struct <a href="#B-0b">B</a>&lt;int, U&gt;;
-
-</code>
+struct <a href="#B-0b">B</a>&lt;int, U&gt;;</code>
 </pre>
 </div>
 
@@ -188,13 +174,27 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 
 
+<div>
+<h2>Non-Member Functions</h2>
+<table>
+<thead>
+<tr>
+<th>Name</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr><td><a href="#operator_not"><code>operator!</code></a></td><td>Negation operator</td></tr>
+<tr><td><a href="#operator_not_eq"><code>operator!&#x3D;</code></a></td><td>Inequality operator</td></tr>
+<tr><td><a href="#operator_eq"><code>operator&#x3D;&#x3D;</code></a></td><td>Equality operator</td></tr>
+</tbody>
+</table>
+</div>
 </div>
 <div>
 <div>
@@ -205,9 +205,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct Z;
-
-</code>
+<code class="source-code cpp">struct Z;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -220,14 +218,14 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#Z-2constructor-00"><code>Z</code></a>         <span class="small">[constructor]</span></td><td><span>Constructors</span></td></tr><tr>
-<td><a href="#Z-2destructor"><code>~Z</code></a> <span class="small">[destructor]</span></td><td><span>Destructor</span></td></tr><tr>
-<td><a href="#Z-foo"><code>foo</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#Z-2conversion"><code>operator bool</code></a> </td><td><span>Conversion to <code>bool</code></span></td></tr><tr>
-<td><a href="#Z-operator_not"><code>operator!</code></a> </td><td><span>Negation operator</span></td></tr><tr>
-<td><a href="#Z-operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td><span>Equality operator</span></td></tr><tr>
-<td><a href="#Z-operator_not_eq"><code>operator!&#x3D;</code></a> </td><td><span>Inequality operator</span></td></tr><tr>
-<td><a href="#Z-operator_3way"><code>operator&lt;&#x3D;&gt;</code></a> </td><td><span>Three-way comparison operator</span></td></tr>
+<td><a href="#Z-2constructor-00"><code>Z</code></a>         <span class="small">[constructor]</span></td><td>Constructors</td></tr><tr>
+<td><a href="#Z-2destructor"><code>~Z</code></a> <span class="small">[destructor]</span></td><td>Destructor</td></tr><tr>
+<td><a href="#Z-foo"><code>foo</code></a> </td><td></td></tr><tr>
+<td><a href="#Z-2conversion"><code>operator bool</code></a> </td><td>Conversion to <code>bool</code></td></tr><tr>
+<td><a href="#Z-operator_not"><code>operator!</code></a> </td><td>Negation operator</td></tr><tr>
+<td><a href="#Z-operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td>Equality operator</td></tr><tr>
+<td><a href="#Z-operator_not_eq"><code>operator!&#x3D;</code></a> </td><td>Inequality operator</td></tr><tr>
+<td><a href="#Z-operator_3way"><code>operator&lt;&#x3D;&gt;</code></a> </td><td>Three-way comparison operator</td></tr>
 </tbody>
 </table>
 
@@ -238,26 +236,21 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="Z-2constructor-00">Z::Z</h2>
 <div>
-<span>Constructors</span>
-
+<p>Constructors</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
-<span>Default constructor</span>
+<p>Default constructor</p>
 <pre>
-<code class="source-code cpp"><a href="#Z-2constructor-05">Z</a>();
-
-</code>
+<code class="source-code cpp"><a href="#Z-2constructor-05">Z</a>();</code>
 </pre><span class="small"><a href="#Z-2constructor-05"><em>» more...</em></a></span>
 
-<span>Construct from <code>int</code></span>
+<p>Construct from <code>int</code></p>
 <pre>
-<code class="source-code cpp"><a href="#Z-2constructor-06">Z</a>(int value);
-
-</code>
+<code class="source-code cpp"><a href="#Z-2constructor-06">Z</a>(int value);</code>
 </pre><span class="small"><a href="#Z-2constructor-06"><em>» more...</em></a></span>
 
 
@@ -267,8 +260,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="Z-2constructor-05">Z::Z</h2>
 <div>
-<span>Default constructor</span>
-
+<p>Default constructor</p>
 </div>
 </div>
 <div>
@@ -276,9 +268,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">Z();
-
-</code>
+<code class="source-code cpp">Z();</code>
 </pre>
 </div>
 </div>
@@ -286,8 +276,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="Z-2constructor-06">Z::Z</h2>
 <div>
-<span>Construct from <code>int</code></span>
-
+<p>Construct from <code>int</code></p>
 </div>
 </div>
 <div>
@@ -295,9 +284,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">Z(int value);
-
-</code>
+<code class="source-code cpp">Z(int value);</code>
 </pre>
 </div>
 <div>
@@ -312,7 +299,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The value to construct from</span></td>
+<td>The value to construct from</td>
 </tr>
 </tbody>
 </table>
@@ -322,8 +309,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Z-2destructor">Z::~Z</h2>
 <div>
-<span>Destructor</span>
-
+<p>Destructor</p>
 </div>
 </div>
 <div>
@@ -331,9 +317,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">~Z();
-
-</code>
+<code class="source-code cpp">~Z();</code>
 </pre>
 </div>
 </div>
@@ -347,9 +331,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-foo() const;
-
-</code>
+foo() const;</code>
 </pre>
 </div>
 </div>
@@ -357,8 +339,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="Z-2conversion">Z::operator bool</h2>
 <div>
-<span>Conversion to <code>bool</code></span>
-
+<p>Conversion to <code>bool</code></p>
 </div>
 </div>
 <div>
@@ -366,22 +347,19 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">operator bool() const;
-
-</code>
+<code class="source-code cpp">operator bool() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The object converted to <code>bool</code></span>
+The object converted to <code>bool</code>
 </div>
 </div>
 <div>
 <div>
 <h2 id="Z-operator_not">Z::operator!</h2>
 <div>
-<span>Negation operator</span>
-
+<p>Negation operator</p>
 </div>
 </div>
 <div>
@@ -390,22 +368,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator!() const;
-
-</code>
+operator!() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the object is falsy, <code>false</code> otherwise</span>
+<code>true</code> if the object is falsy, <code>false</code> otherwise
 </div>
 </div>
 <div>
 <div>
 <h2 id="Z-operator_eq">Z::operator&#x3D;&#x3D;</h2>
 <div>
-<span>Equality operator</span>
-
+<p>Equality operator</p>
 </div>
 </div>
 <div>
@@ -414,14 +389,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator&#x3D;&#x3D;(<a href="#Z">Z</a> const& rhs) const;
-
-</code>
+operator&#x3D;&#x3D;(<a href="#Z">Z</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -435,7 +408,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -445,8 +418,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Z-operator_not_eq">Z::operator!&#x3D;</h2>
 <div>
-<span>Inequality operator</span>
-
+<p>Inequality operator</p>
 </div>
 </div>
 <div>
@@ -455,14 +427,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator!&#x3D;(<a href="#Z">Z</a> const& rhs) const;
-
-</code>
+operator!&#x3D;(<a href="#Z">Z</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are not equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are not equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -476,7 +446,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -486,8 +456,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Z-operator_3way">Z::operator&lt;&#x3D;&gt;</h2>
 <div>
-<span>Three-way comparison operator</span>
-
+<p>Three-way comparison operator</p>
 </div>
 </div>
 <div>
@@ -496,14 +465,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">auto
-operator&lt;&#x3D;&gt;(<a href="#Z">Z</a> const& rhs) const;
-
-</code>
+operator&lt;&#x3D;&gt;(<a href="#Z">Z</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The relative order of the objects</span>
+The relative order of the objects
 </div>
 <div>
 <h3>Parameters</h3>
@@ -517,7 +484,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -533,9 +500,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h();
-
-</code>
+h();</code>
 </pre>
 </div>
 </div>
@@ -554,9 +519,7 @@ <h3>Synopses</h3>
 <a href="#g-03c">g</a>(
     T,
     T,
-    T);
-
-</code>
+    T);</code>
 </pre><span class="small"><a href="#g-03c"><em>» more...</em></a></span>
 
 
@@ -566,9 +529,7 @@ <h3>Synopses</h3>
 <a href="#g-0e4">g&lt;int&gt;</a>(
     int,
     int,
-    int);
-
-</code>
+    int);</code>
 </pre><span class="small"><a href="#g-0e4"><em>» more...</em></a></span>
 
 
@@ -577,9 +538,7 @@ <h3>Synopses</h3>
 <a href="#g-0a">g</a>(
     char,
     char,
-    char);
-
-</code>
+    char);</code>
 </pre><span class="small"><a href="#g-0a"><em>» more...</em></a></span>
 
 
@@ -587,33 +546,25 @@ <h3>Synopses</h3>
 <code class="source-code cpp">char
 <a href="#g-03a">g</a>(
     double,
-    char);
-
-</code>
+    char);</code>
 </pre><span class="small"><a href="#g-03a"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">char
-<a href="#g-06">g</a>(double);
-
-</code>
+<a href="#g-06">g</a>(double);</code>
 </pre><span class="small"><a href="#g-06"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">char
-<a href="#g-04">g</a>(int);
-
-</code>
+<a href="#g-04">g</a>(int);</code>
 </pre><span class="small"><a href="#g-04"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">void
-<a href="#g-0e3">g</a>();
-
-</code>
+<a href="#g-0e3">g</a>();</code>
 </pre><span class="small"><a href="#g-0e3"><em>» more...</em></a></span>
 
 
@@ -633,9 +584,7 @@ <h3>Synopsis</h3>
 g(
     T,
     T,
-    T);
-
-</code>
+    T);</code>
 </pre>
 </div>
 </div>
@@ -653,9 +602,7 @@ <h3>Synopsis</h3>
 <a href="#g-03c">g</a>&lt;int&gt;(
     int,
     int,
-    int);
-
-</code>
+    int);</code>
 </pre>
 </div>
 </div>
@@ -672,9 +619,7 @@ <h3>Synopsis</h3>
 g(
     char,
     char,
-    char);
-
-</code>
+    char);</code>
 </pre>
 </div>
 </div>
@@ -690,9 +635,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">char
 g(
     double,
-    char);
-
-</code>
+    char);</code>
 </pre>
 </div>
 </div>
@@ -706,9 +649,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">char
-g(double);
-
-</code>
+g(double);</code>
 </pre>
 </div>
 </div>
@@ -722,9 +663,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">char
-g(int);
-
-</code>
+g(int);</code>
 </pre>
 </div>
 </div>
@@ -738,9 +677,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
@@ -754,9 +691,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -764,8 +699,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="operator_not">operator!</h2>
 <div>
-<span>Negation operator</span>
-
+<p>Negation operator</p>
 </div>
 </div>
 <div>
@@ -774,14 +708,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-location.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator!(<a href="#A">A</a> const& v);
-
-</code>
+operator!(<a href="#A">A</a> const& v);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the object is falsy, <code>false</code> otherwise</span>
+<code>true</code> if the object is falsy, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -795,7 +727,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>v</strong></td>
-<td><span>The operand</span></td>
+<td>The operand</td>
 </tr>
 </tbody>
 </table>
@@ -805,8 +737,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_eq">operator&#x3D;&#x3D;</h2>
 <div>
-<span>Equality operator</span>
-
+<p>Equality operator</p>
 </div>
 </div>
 <div>
@@ -817,14 +748,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">bool
 operator&#x3D;&#x3D;(
     <a href="#A">A</a> const& lhs,
-    <a href="#A">A</a> const& rhs);
-
-</code>
+    <a href="#A">A</a> const& rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -838,11 +767,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -852,8 +781,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_not_eq">operator!&#x3D;</h2>
 <div>
-<span>Inequality operator</span>
-
+<p>Inequality operator</p>
 </div>
 </div>
 <div>
@@ -864,14 +792,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">bool
 operator!&#x3D;(
     <a href="#A">A</a> const& lhs,
-    <a href="#A">A</a> const& rhs);
-
-</code>
+    <a href="#A">A</a> const& rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are not equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are not equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -885,11 +811,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-location.xml b/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-location.xml
index 0071193ec..b33407e14 100644
--- a/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-location.xml
+++ b/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-location.xml
@@ -49,6 +49,13 @@
   </template>
   <struct name="A" id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">
     <file short-path="sort-namespace-members-by-location.cpp" source-path="sort-namespace-members-by-location.cpp" line="21" class="def"/>
+    <doc>
+      <related>
+        <reference id="yuKyBhGbND+Kyypyb9UsuC4Qe3E=">operator!</reference>
+        <reference id="4MuN1V3fHVfOMvtg2LT+QVm/XmE=">operator!=</reference>
+        <reference id="kibUx6k1SXB+HsXkRXroJl9f59w=">operator==</reference>
+      </related>
+    </doc>
   </struct>
   <struct name="Z" id="NQ8uQgTcafPcttyBMHHLHAXA4MA=">
     <file short-path="sort-namespace-members-by-location.cpp" source-path="sort-namespace-members-by-location.cpp" line="23" class="def"/>
@@ -318,6 +325,9 @@
       <param name="v">
         <text>The operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
   <function name="operator==" id="kibUx6k1SXB+HsXkRXroJl9f59w=">
@@ -352,6 +362,9 @@
       <param name="rhs">
         <text>The right operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
   <function name="operator!=" id="4MuN1V3fHVfOMvtg2LT+QVm/XmE=">
@@ -386,6 +399,9 @@
       <param name="rhs">
         <text>The right operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
 </namespace>
diff --git a/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-name.adoc b/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-name.adoc
index 1ba8bff7f..6c59c4d92 100644
--- a/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-name.adoc
+++ b/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-name.adoc
@@ -52,6 +52,20 @@ Declared in `&lt;sort&hyphen;namespace&hyphen;members&hyphen;by&hyphen;name&peri
 struct A;
 ----
 
+=== Non-Member Functions
+
+[cols=2]
+|===
+| Name
+| Description
+| link:#operator_not[`operator!`]
+| Negation operator
+| link:#operator_not_eq[`operator!&equals;`]
+| Inequality operator
+| link:#operator_eq[`operator&equals;&equals;`]
+| Equality operator
+|===
+
 [#B-0b]
 == B
 
diff --git a/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-name.html b/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-name.html
index d0c60f782..948aabf43 100644
--- a/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-name.html
+++ b/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-name.html
@@ -40,12 +40,12 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#g-0f"><code>g</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#h"><code>h</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#operator_not"><code>operator!</code></a> </td><td><span>Negation operator</span></td></tr><tr>
-<td><a href="#operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td><span>Equality operator</span></td></tr><tr>
-<td><a href="#operator_not_eq"><code>operator!&#x3D;</code></a> </td><td><span>Inequality operator</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td></td></tr><tr>
+<td><a href="#g-0f"><code>g</code></a> </td><td></td></tr><tr>
+<td><a href="#h"><code>h</code></a> </td><td></td></tr><tr>
+<td><a href="#operator_not"><code>operator!</code></a> </td><td>Negation operator</td></tr><tr>
+<td><a href="#operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td>Equality operator</td></tr><tr>
+<td><a href="#operator_not_eq"><code>operator!&#x3D;</code></a> </td><td>Inequality operator</td></tr>
 </tbody>
 </table>
 
@@ -59,13 +59,27 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 
 
+<div>
+<h2>Non-Member Functions</h2>
+<table>
+<thead>
+<tr>
+<th>Name</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr><td><a href="#operator_not"><code>operator!</code></a></td><td>Negation operator</td></tr>
+<tr><td><a href="#operator_not_eq"><code>operator!&#x3D;</code></a></td><td>Inequality operator</td></tr>
+<tr><td><a href="#operator_eq"><code>operator&#x3D;&#x3D;</code></a></td><td>Equality operator</td></tr>
+</tbody>
+</table>
+</div>
 </div>
 <div>
 <div>
@@ -79,9 +93,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     class T,
     class U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 
@@ -97,9 +109,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#B-0b">B</a>&lt;int, char&gt;;
-
-</code>
+struct <a href="#B-0b">B</a>&lt;int, char&gt;;</code>
 </pre>
 </div>
 
@@ -115,9 +125,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class U&gt;
-struct <a href="#B-0b">B</a>&lt;int, U&gt;;
-
-</code>
+struct <a href="#B-0b">B</a>&lt;int, U&gt;;</code>
 </pre>
 </div>
 
@@ -135,9 +143,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     class T,
     class U = void&gt;
-struct C;
-
-</code>
+struct C;</code>
 </pre>
 </div>
 
@@ -153,9 +159,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#C-0f">C</a>&lt;int&gt;;
-
-</code>
+struct <a href="#C-0f">C</a>&lt;int&gt;;</code>
 </pre>
 </div>
 
@@ -171,9 +175,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#C-0f">C</a>&lt;int, char&gt;;
-
-</code>
+struct <a href="#C-0f">C</a>&lt;int, char&gt;;</code>
 </pre>
 </div>
 
@@ -188,9 +190,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct D;
-
-</code>
+<code class="source-code cpp">struct D;</code>
 </pre>
 </div>
 
@@ -205,9 +205,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct Z;
-
-</code>
+<code class="source-code cpp">struct Z;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -220,14 +218,14 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#Z-2constructor-00"><code>Z</code></a>         <span class="small">[constructor]</span></td><td><span>Constructors</span></td></tr><tr>
-<td><a href="#Z-2destructor"><code>~Z</code></a> <span class="small">[destructor]</span></td><td><span>Destructor</span></td></tr><tr>
-<td><a href="#Z-foo"><code>foo</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#Z-2conversion"><code>operator bool</code></a> </td><td><span>Conversion to <code>bool</code></span></td></tr><tr>
-<td><a href="#Z-operator_not"><code>operator!</code></a> </td><td><span>Negation operator</span></td></tr><tr>
-<td><a href="#Z-operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td><span>Equality operator</span></td></tr><tr>
-<td><a href="#Z-operator_not_eq"><code>operator!&#x3D;</code></a> </td><td><span>Inequality operator</span></td></tr><tr>
-<td><a href="#Z-operator_3way"><code>operator&lt;&#x3D;&gt;</code></a> </td><td><span>Three-way comparison operator</span></td></tr>
+<td><a href="#Z-2constructor-00"><code>Z</code></a>         <span class="small">[constructor]</span></td><td>Constructors</td></tr><tr>
+<td><a href="#Z-2destructor"><code>~Z</code></a> <span class="small">[destructor]</span></td><td>Destructor</td></tr><tr>
+<td><a href="#Z-foo"><code>foo</code></a> </td><td></td></tr><tr>
+<td><a href="#Z-2conversion"><code>operator bool</code></a> </td><td>Conversion to <code>bool</code></td></tr><tr>
+<td><a href="#Z-operator_not"><code>operator!</code></a> </td><td>Negation operator</td></tr><tr>
+<td><a href="#Z-operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td>Equality operator</td></tr><tr>
+<td><a href="#Z-operator_not_eq"><code>operator!&#x3D;</code></a> </td><td>Inequality operator</td></tr><tr>
+<td><a href="#Z-operator_3way"><code>operator&lt;&#x3D;&gt;</code></a> </td><td>Three-way comparison operator</td></tr>
 </tbody>
 </table>
 
@@ -238,26 +236,21 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="Z-2constructor-00">Z::Z</h2>
 <div>
-<span>Constructors</span>
-
+<p>Constructors</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
-<span>Default constructor</span>
+<p>Default constructor</p>
 <pre>
-<code class="source-code cpp"><a href="#Z-2constructor-05">Z</a>();
-
-</code>
+<code class="source-code cpp"><a href="#Z-2constructor-05">Z</a>();</code>
 </pre><span class="small"><a href="#Z-2constructor-05"><em>» more...</em></a></span>
 
-<span>Construct from <code>int</code></span>
+<p>Construct from <code>int</code></p>
 <pre>
-<code class="source-code cpp"><a href="#Z-2constructor-06">Z</a>(int value);
-
-</code>
+<code class="source-code cpp"><a href="#Z-2constructor-06">Z</a>(int value);</code>
 </pre><span class="small"><a href="#Z-2constructor-06"><em>» more...</em></a></span>
 
 
@@ -267,8 +260,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="Z-2constructor-05">Z::Z</h2>
 <div>
-<span>Default constructor</span>
-
+<p>Default constructor</p>
 </div>
 </div>
 <div>
@@ -276,9 +268,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">Z();
-
-</code>
+<code class="source-code cpp">Z();</code>
 </pre>
 </div>
 </div>
@@ -286,8 +276,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="Z-2constructor-06">Z::Z</h2>
 <div>
-<span>Construct from <code>int</code></span>
-
+<p>Construct from <code>int</code></p>
 </div>
 </div>
 <div>
@@ -295,9 +284,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">Z(int value);
-
-</code>
+<code class="source-code cpp">Z(int value);</code>
 </pre>
 </div>
 <div>
@@ -312,7 +299,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The value to construct from</span></td>
+<td>The value to construct from</td>
 </tr>
 </tbody>
 </table>
@@ -322,8 +309,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Z-2destructor">Z::~Z</h2>
 <div>
-<span>Destructor</span>
-
+<p>Destructor</p>
 </div>
 </div>
 <div>
@@ -331,9 +317,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">~Z();
-
-</code>
+<code class="source-code cpp">~Z();</code>
 </pre>
 </div>
 </div>
@@ -347,9 +331,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-foo() const;
-
-</code>
+foo() const;</code>
 </pre>
 </div>
 </div>
@@ -357,8 +339,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="Z-2conversion">Z::operator bool</h2>
 <div>
-<span>Conversion to <code>bool</code></span>
-
+<p>Conversion to <code>bool</code></p>
 </div>
 </div>
 <div>
@@ -366,22 +347,19 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">operator bool() const;
-
-</code>
+<code class="source-code cpp">operator bool() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The object converted to <code>bool</code></span>
+The object converted to <code>bool</code>
 </div>
 </div>
 <div>
 <div>
 <h2 id="Z-operator_not">Z::operator!</h2>
 <div>
-<span>Negation operator</span>
-
+<p>Negation operator</p>
 </div>
 </div>
 <div>
@@ -390,22 +368,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator!() const;
-
-</code>
+operator!() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the object is falsy, <code>false</code> otherwise</span>
+<code>true</code> if the object is falsy, <code>false</code> otherwise
 </div>
 </div>
 <div>
 <div>
 <h2 id="Z-operator_eq">Z::operator&#x3D;&#x3D;</h2>
 <div>
-<span>Equality operator</span>
-
+<p>Equality operator</p>
 </div>
 </div>
 <div>
@@ -414,14 +389,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator&#x3D;&#x3D;(<a href="#Z">Z</a> const& rhs) const;
-
-</code>
+operator&#x3D;&#x3D;(<a href="#Z">Z</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -435,7 +408,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -445,8 +418,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Z-operator_not_eq">Z::operator!&#x3D;</h2>
 <div>
-<span>Inequality operator</span>
-
+<p>Inequality operator</p>
 </div>
 </div>
 <div>
@@ -455,14 +427,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator!&#x3D;(<a href="#Z">Z</a> const& rhs) const;
-
-</code>
+operator!&#x3D;(<a href="#Z">Z</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are not equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are not equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -476,7 +446,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -486,8 +456,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Z-operator_3way">Z::operator&lt;&#x3D;&gt;</h2>
 <div>
-<span>Three-way comparison operator</span>
-
+<p>Three-way comparison operator</p>
 </div>
 </div>
 <div>
@@ -496,14 +465,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">auto
-operator&lt;&#x3D;&gt;(<a href="#Z">Z</a> const& rhs) const;
-
-</code>
+operator&lt;&#x3D;&gt;(<a href="#Z">Z</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The relative order of the objects</span>
+The relative order of the objects
 </div>
 <div>
 <h3>Parameters</h3>
@@ -517,7 +484,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -533,9 +500,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -550,25 +515,19 @@ <h3>Synopses</h3>
 
 <pre>
 <code class="source-code cpp">void
-<a href="#g-0e3">g</a>();
-
-</code>
+<a href="#g-0e3">g</a>();</code>
 </pre><span class="small"><a href="#g-0e3"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">char
-<a href="#g-04">g</a>(int);
-
-</code>
+<a href="#g-04">g</a>(int);</code>
 </pre><span class="small"><a href="#g-04"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">char
-<a href="#g-06">g</a>(double);
-
-</code>
+<a href="#g-06">g</a>(double);</code>
 </pre><span class="small"><a href="#g-06"><em>» more...</em></a></span>
 
 
@@ -576,9 +535,7 @@ <h3>Synopses</h3>
 <code class="source-code cpp">char
 <a href="#g-03a">g</a>(
     double,
-    char);
-
-</code>
+    char);</code>
 </pre><span class="small"><a href="#g-03a"><em>» more...</em></a></span>
 
 
@@ -587,9 +544,7 @@ <h3>Synopses</h3>
 <a href="#g-0a">g</a>(
     char,
     char,
-    char);
-
-</code>
+    char);</code>
 </pre><span class="small"><a href="#g-0a"><em>» more...</em></a></span>
 
 
@@ -599,9 +554,7 @@ <h3>Synopses</h3>
 <a href="#g-03c">g</a>(
     T,
     T,
-    T);
-
-</code>
+    T);</code>
 </pre><span class="small"><a href="#g-03c"><em>» more...</em></a></span>
 
 
@@ -611,9 +564,7 @@ <h3>Synopses</h3>
 <a href="#g-0e4">g&lt;int&gt;</a>(
     int,
     int,
-    int);
-
-</code>
+    int);</code>
 </pre><span class="small"><a href="#g-0e4"><em>» more...</em></a></span>
 
 
@@ -629,9 +580,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
@@ -645,9 +594,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">char
-g(int);
-
-</code>
+g(int);</code>
 </pre>
 </div>
 </div>
@@ -661,9 +608,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">char
-g(double);
-
-</code>
+g(double);</code>
 </pre>
 </div>
 </div>
@@ -679,9 +624,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">char
 g(
     double,
-    char);
-
-</code>
+    char);</code>
 </pre>
 </div>
 </div>
@@ -698,9 +641,7 @@ <h3>Synopsis</h3>
 g(
     char,
     char,
-    char);
-
-</code>
+    char);</code>
 </pre>
 </div>
 </div>
@@ -718,9 +659,7 @@ <h3>Synopsis</h3>
 g(
     T,
     T,
-    T);
-
-</code>
+    T);</code>
 </pre>
 </div>
 </div>
@@ -738,9 +677,7 @@ <h3>Synopsis</h3>
 <a href="#g-03c">g</a>&lt;int&gt;(
     int,
     int,
-    int);
-
-</code>
+    int);</code>
 </pre>
 </div>
 </div>
@@ -754,9 +691,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h();
-
-</code>
+h();</code>
 </pre>
 </div>
 </div>
@@ -764,8 +699,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="operator_not">operator!</h2>
 <div>
-<span>Negation operator</span>
-
+<p>Negation operator</p>
 </div>
 </div>
 <div>
@@ -774,14 +708,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-namespace-members-by-name.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator!(<a href="#A">A</a> const& v);
-
-</code>
+operator!(<a href="#A">A</a> const& v);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the object is falsy, <code>false</code> otherwise</span>
+<code>true</code> if the object is falsy, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -795,7 +727,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>v</strong></td>
-<td><span>The operand</span></td>
+<td>The operand</td>
 </tr>
 </tbody>
 </table>
@@ -805,8 +737,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_eq">operator&#x3D;&#x3D;</h2>
 <div>
-<span>Equality operator</span>
-
+<p>Equality operator</p>
 </div>
 </div>
 <div>
@@ -817,14 +748,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">bool
 operator&#x3D;&#x3D;(
     <a href="#A">A</a> const& lhs,
-    <a href="#A">A</a> const& rhs);
-
-</code>
+    <a href="#A">A</a> const& rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -838,11 +767,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -852,8 +781,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_not_eq">operator!&#x3D;</h2>
 <div>
-<span>Inequality operator</span>
-
+<p>Inequality operator</p>
 </div>
 </div>
 <div>
@@ -864,14 +792,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">bool
 operator!&#x3D;(
     <a href="#A">A</a> const& lhs,
-    <a href="#A">A</a> const& rhs);
-
-</code>
+    <a href="#A">A</a> const& rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are not equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are not equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -885,11 +811,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-name.xml b/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-name.xml
index db912f484..3d1b59bda 100644
--- a/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-name.xml
+++ b/test-files/golden-tests/config/sort-namespace-members-by/sort-namespace-members-by-name.xml
@@ -4,6 +4,13 @@
 <namespace id="//////////////////////////8=">
   <struct name="A" id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">
     <file short-path="sort-namespace-members-by-name.cpp" source-path="sort-namespace-members-by-name.cpp" line="21" class="def"/>
+    <doc>
+      <related>
+        <reference id="yuKyBhGbND+Kyypyb9UsuC4Qe3E=">operator!</reference>
+        <reference id="4MuN1V3fHVfOMvtg2LT+QVm/XmE=">operator!=</reference>
+        <reference id="kibUx6k1SXB+HsXkRXroJl9f59w=">operator==</reference>
+      </related>
+    </doc>
   </struct>
   <template>
     <tparam name="T" class="type"/>
@@ -318,6 +325,9 @@
       <param name="v">
         <text>The operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
   <function name="operator==" id="kibUx6k1SXB+HsXkRXroJl9f59w=">
@@ -352,6 +362,9 @@
       <param name="rhs">
         <text>The right operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
   <function name="operator!=" id="4MuN1V3fHVfOMvtg2LT+QVm/XmE=">
@@ -386,6 +399,9 @@
       <param name="rhs">
         <text>The right operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
 </namespace>
diff --git a/test-files/golden-tests/config/sort/sort-members.adoc b/test-files/golden-tests/config/sort/sort-members.adoc
index d0b9a0b30..3dd7b2dff 100644
--- a/test-files/golden-tests/config/sort/sort-members.adoc
+++ b/test-files/golden-tests/config/sort/sort-members.adoc
@@ -52,6 +52,20 @@ Declared in `&lt;sort&hyphen;members&period;cpp&gt;`
 struct A;
 ----
 
+=== Non-Member Functions
+
+[cols=2]
+|===
+| Name
+| Description
+| link:#operator_not[`operator!`]
+| Negation operator
+| link:#operator_not_eq[`operator!&equals;`]
+| Inequality operator
+| link:#operator_eq[`operator&equals;&equals;`]
+| Equality operator
+|===
+
 [#B-0b]
 == B
 
diff --git a/test-files/golden-tests/config/sort/sort-members.html b/test-files/golden-tests/config/sort/sort-members.html
index 53e1ac6bf..a1261d558 100644
--- a/test-files/golden-tests/config/sort/sort-members.html
+++ b/test-files/golden-tests/config/sort/sort-members.html
@@ -40,12 +40,12 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#g-0f"><code>g</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#h"><code>h</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#operator_not"><code>operator!</code></a> </td><td><span>Negation operator</span></td></tr><tr>
-<td><a href="#operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td><span>Equality operator</span></td></tr><tr>
-<td><a href="#operator_not_eq"><code>operator!&#x3D;</code></a> </td><td><span>Inequality operator</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td></td></tr><tr>
+<td><a href="#g-0f"><code>g</code></a> </td><td></td></tr><tr>
+<td><a href="#h"><code>h</code></a> </td><td></td></tr><tr>
+<td><a href="#operator_not"><code>operator!</code></a> </td><td>Negation operator</td></tr><tr>
+<td><a href="#operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td>Equality operator</td></tr><tr>
+<td><a href="#operator_not_eq"><code>operator!&#x3D;</code></a> </td><td>Inequality operator</td></tr>
 </tbody>
 </table>
 
@@ -59,13 +59,27 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 
 
+<div>
+<h2>Non-Member Functions</h2>
+<table>
+<thead>
+<tr>
+<th>Name</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr><td><a href="#operator_not"><code>operator!</code></a></td><td>Negation operator</td></tr>
+<tr><td><a href="#operator_not_eq"><code>operator!&#x3D;</code></a></td><td>Inequality operator</td></tr>
+<tr><td><a href="#operator_eq"><code>operator&#x3D;&#x3D;</code></a></td><td>Equality operator</td></tr>
+</tbody>
+</table>
+</div>
 </div>
 <div>
 <div>
@@ -79,9 +93,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     class T,
     class U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 
@@ -97,9 +109,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#B-0b">B</a>&lt;int, char&gt;;
-
-</code>
+struct <a href="#B-0b">B</a>&lt;int, char&gt;;</code>
 </pre>
 </div>
 
@@ -115,9 +125,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class U&gt;
-struct <a href="#B-0b">B</a>&lt;int, U&gt;;
-
-</code>
+struct <a href="#B-0b">B</a>&lt;int, U&gt;;</code>
 </pre>
 </div>
 
@@ -135,9 +143,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     class T,
     class U = void&gt;
-struct C;
-
-</code>
+struct C;</code>
 </pre>
 </div>
 
@@ -153,9 +159,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#C-0f">C</a>&lt;int&gt;;
-
-</code>
+struct <a href="#C-0f">C</a>&lt;int&gt;;</code>
 </pre>
 </div>
 
@@ -171,9 +175,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#C-0f">C</a>&lt;int, char&gt;;
-
-</code>
+struct <a href="#C-0f">C</a>&lt;int, char&gt;;</code>
 </pre>
 </div>
 
@@ -188,9 +190,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct D;
-
-</code>
+<code class="source-code cpp">struct D;</code>
 </pre>
 </div>
 
@@ -205,9 +205,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct Z;
-
-</code>
+<code class="source-code cpp">struct Z;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -220,14 +218,14 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#Z-2constructor-00"><code>Z</code></a>         <span class="small">[constructor]</span></td><td><span>Constructors</span></td></tr><tr>
-<td><a href="#Z-2destructor"><code>~Z</code></a> <span class="small">[destructor]</span></td><td><span>Destructor</span></td></tr><tr>
-<td><a href="#Z-foo"><code>foo</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#Z-2conversion"><code>operator bool</code></a> </td><td><span>Conversion to <code>bool</code></span></td></tr><tr>
-<td><a href="#Z-operator_not"><code>operator!</code></a> </td><td><span>Negation operator</span></td></tr><tr>
-<td><a href="#Z-operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td><span>Equality operator</span></td></tr><tr>
-<td><a href="#Z-operator_not_eq"><code>operator!&#x3D;</code></a> </td><td><span>Inequality operator</span></td></tr><tr>
-<td><a href="#Z-operator_3way"><code>operator&lt;&#x3D;&gt;</code></a> </td><td><span>Three-way comparison operator</span></td></tr>
+<td><a href="#Z-2constructor-00"><code>Z</code></a>         <span class="small">[constructor]</span></td><td>Constructors</td></tr><tr>
+<td><a href="#Z-2destructor"><code>~Z</code></a> <span class="small">[destructor]</span></td><td>Destructor</td></tr><tr>
+<td><a href="#Z-foo"><code>foo</code></a> </td><td></td></tr><tr>
+<td><a href="#Z-2conversion"><code>operator bool</code></a> </td><td>Conversion to <code>bool</code></td></tr><tr>
+<td><a href="#Z-operator_not"><code>operator!</code></a> </td><td>Negation operator</td></tr><tr>
+<td><a href="#Z-operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td>Equality operator</td></tr><tr>
+<td><a href="#Z-operator_not_eq"><code>operator!&#x3D;</code></a> </td><td>Inequality operator</td></tr><tr>
+<td><a href="#Z-operator_3way"><code>operator&lt;&#x3D;&gt;</code></a> </td><td>Three-way comparison operator</td></tr>
 </tbody>
 </table>
 
@@ -238,26 +236,21 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="Z-2constructor-00">Z::Z</h2>
 <div>
-<span>Constructors</span>
-
+<p>Constructors</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
-<span>Default constructor</span>
+<p>Default constructor</p>
 <pre>
-<code class="source-code cpp"><a href="#Z-2constructor-05">Z</a>();
-
-</code>
+<code class="source-code cpp"><a href="#Z-2constructor-05">Z</a>();</code>
 </pre><span class="small"><a href="#Z-2constructor-05"><em>» more...</em></a></span>
 
-<span>Construct from <code>int</code></span>
+<p>Construct from <code>int</code></p>
 <pre>
-<code class="source-code cpp"><a href="#Z-2constructor-06">Z</a>(int value);
-
-</code>
+<code class="source-code cpp"><a href="#Z-2constructor-06">Z</a>(int value);</code>
 </pre><span class="small"><a href="#Z-2constructor-06"><em>» more...</em></a></span>
 
 
@@ -267,8 +260,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="Z-2constructor-05">Z::Z</h2>
 <div>
-<span>Default constructor</span>
-
+<p>Default constructor</p>
 </div>
 </div>
 <div>
@@ -276,9 +268,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">Z();
-
-</code>
+<code class="source-code cpp">Z();</code>
 </pre>
 </div>
 </div>
@@ -286,8 +276,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="Z-2constructor-06">Z::Z</h2>
 <div>
-<span>Construct from <code>int</code></span>
-
+<p>Construct from <code>int</code></p>
 </div>
 </div>
 <div>
@@ -295,9 +284,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">Z(int value);
-
-</code>
+<code class="source-code cpp">Z(int value);</code>
 </pre>
 </div>
 <div>
@@ -312,7 +299,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The value to construct from</span></td>
+<td>The value to construct from</td>
 </tr>
 </tbody>
 </table>
@@ -322,8 +309,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Z-2destructor">Z::~Z</h2>
 <div>
-<span>Destructor</span>
-
+<p>Destructor</p>
 </div>
 </div>
 <div>
@@ -331,9 +317,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">~Z();
-
-</code>
+<code class="source-code cpp">~Z();</code>
 </pre>
 </div>
 </div>
@@ -347,9 +331,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-foo() const;
-
-</code>
+foo() const;</code>
 </pre>
 </div>
 </div>
@@ -357,8 +339,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="Z-2conversion">Z::operator bool</h2>
 <div>
-<span>Conversion to <code>bool</code></span>
-
+<p>Conversion to <code>bool</code></p>
 </div>
 </div>
 <div>
@@ -366,22 +347,19 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">operator bool() const;
-
-</code>
+<code class="source-code cpp">operator bool() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The object converted to <code>bool</code></span>
+The object converted to <code>bool</code>
 </div>
 </div>
 <div>
 <div>
 <h2 id="Z-operator_not">Z::operator!</h2>
 <div>
-<span>Negation operator</span>
-
+<p>Negation operator</p>
 </div>
 </div>
 <div>
@@ -390,22 +368,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator!() const;
-
-</code>
+operator!() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the object is falsy, <code>false</code> otherwise</span>
+<code>true</code> if the object is falsy, <code>false</code> otherwise
 </div>
 </div>
 <div>
 <div>
 <h2 id="Z-operator_eq">Z::operator&#x3D;&#x3D;</h2>
 <div>
-<span>Equality operator</span>
-
+<p>Equality operator</p>
 </div>
 </div>
 <div>
@@ -414,14 +389,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator&#x3D;&#x3D;(<a href="#Z">Z</a> const& rhs) const;
-
-</code>
+operator&#x3D;&#x3D;(<a href="#Z">Z</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -435,7 +408,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -445,8 +418,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Z-operator_not_eq">Z::operator!&#x3D;</h2>
 <div>
-<span>Inequality operator</span>
-
+<p>Inequality operator</p>
 </div>
 </div>
 <div>
@@ -455,14 +427,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator!&#x3D;(<a href="#Z">Z</a> const& rhs) const;
-
-</code>
+operator!&#x3D;(<a href="#Z">Z</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are not equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are not equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -476,7 +446,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -486,8 +456,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Z-operator_3way">Z::operator&lt;&#x3D;&gt;</h2>
 <div>
-<span>Three-way comparison operator</span>
-
+<p>Three-way comparison operator</p>
 </div>
 </div>
 <div>
@@ -496,14 +465,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">auto
-operator&lt;&#x3D;&gt;(<a href="#Z">Z</a> const& rhs) const;
-
-</code>
+operator&lt;&#x3D;&gt;(<a href="#Z">Z</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The relative order of the objects</span>
+The relative order of the objects
 </div>
 <div>
 <h3>Parameters</h3>
@@ -517,7 +484,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -533,9 +500,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -550,25 +515,19 @@ <h3>Synopses</h3>
 
 <pre>
 <code class="source-code cpp">void
-<a href="#g-0e3">g</a>();
-
-</code>
+<a href="#g-0e3">g</a>();</code>
 </pre><span class="small"><a href="#g-0e3"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">char
-<a href="#g-04">g</a>(int);
-
-</code>
+<a href="#g-04">g</a>(int);</code>
 </pre><span class="small"><a href="#g-04"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">char
-<a href="#g-06">g</a>(double);
-
-</code>
+<a href="#g-06">g</a>(double);</code>
 </pre><span class="small"><a href="#g-06"><em>» more...</em></a></span>
 
 
@@ -576,9 +535,7 @@ <h3>Synopses</h3>
 <code class="source-code cpp">char
 <a href="#g-03a">g</a>(
     double,
-    char);
-
-</code>
+    char);</code>
 </pre><span class="small"><a href="#g-03a"><em>» more...</em></a></span>
 
 
@@ -587,9 +544,7 @@ <h3>Synopses</h3>
 <a href="#g-0a">g</a>(
     char,
     char,
-    char);
-
-</code>
+    char);</code>
 </pre><span class="small"><a href="#g-0a"><em>» more...</em></a></span>
 
 
@@ -599,9 +554,7 @@ <h3>Synopses</h3>
 <a href="#g-03c">g</a>(
     T,
     T,
-    T);
-
-</code>
+    T);</code>
 </pre><span class="small"><a href="#g-03c"><em>» more...</em></a></span>
 
 
@@ -611,9 +564,7 @@ <h3>Synopses</h3>
 <a href="#g-0e4">g&lt;int&gt;</a>(
     int,
     int,
-    int);
-
-</code>
+    int);</code>
 </pre><span class="small"><a href="#g-0e4"><em>» more...</em></a></span>
 
 
@@ -629,9 +580,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
@@ -645,9 +594,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">char
-g(int);
-
-</code>
+g(int);</code>
 </pre>
 </div>
 </div>
@@ -661,9 +608,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">char
-g(double);
-
-</code>
+g(double);</code>
 </pre>
 </div>
 </div>
@@ -679,9 +624,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">char
 g(
     double,
-    char);
-
-</code>
+    char);</code>
 </pre>
 </div>
 </div>
@@ -698,9 +641,7 @@ <h3>Synopsis</h3>
 g(
     char,
     char,
-    char);
-
-</code>
+    char);</code>
 </pre>
 </div>
 </div>
@@ -718,9 +659,7 @@ <h3>Synopsis</h3>
 g(
     T,
     T,
-    T);
-
-</code>
+    T);</code>
 </pre>
 </div>
 </div>
@@ -738,9 +677,7 @@ <h3>Synopsis</h3>
 <a href="#g-03c">g</a>&lt;int&gt;(
     int,
     int,
-    int);
-
-</code>
+    int);</code>
 </pre>
 </div>
 </div>
@@ -754,9 +691,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h();
-
-</code>
+h();</code>
 </pre>
 </div>
 </div>
@@ -764,8 +699,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="operator_not">operator!</h2>
 <div>
-<span>Negation operator</span>
-
+<p>Negation operator</p>
 </div>
 </div>
 <div>
@@ -774,14 +708,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sort-members.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator!(<a href="#A">A</a> const& v);
-
-</code>
+operator!(<a href="#A">A</a> const& v);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the object is falsy, <code>false</code> otherwise</span>
+<code>true</code> if the object is falsy, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -795,7 +727,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>v</strong></td>
-<td><span>The operand</span></td>
+<td>The operand</td>
 </tr>
 </tbody>
 </table>
@@ -805,8 +737,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_eq">operator&#x3D;&#x3D;</h2>
 <div>
-<span>Equality operator</span>
-
+<p>Equality operator</p>
 </div>
 </div>
 <div>
@@ -817,14 +748,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">bool
 operator&#x3D;&#x3D;(
     <a href="#A">A</a> const& lhs,
-    <a href="#A">A</a> const& rhs);
-
-</code>
+    <a href="#A">A</a> const& rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -838,11 +767,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -852,8 +781,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_not_eq">operator!&#x3D;</h2>
 <div>
-<span>Inequality operator</span>
-
+<p>Inequality operator</p>
 </div>
 </div>
 <div>
@@ -864,14 +792,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">bool
 operator!&#x3D;(
     <a href="#A">A</a> const& lhs,
-    <a href="#A">A</a> const& rhs);
-
-</code>
+    <a href="#A">A</a> const& rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are not equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are not equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -885,11 +811,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/config/sort/sort-members.xml b/test-files/golden-tests/config/sort/sort-members.xml
index 143cabb54..95e3e764c 100644
--- a/test-files/golden-tests/config/sort/sort-members.xml
+++ b/test-files/golden-tests/config/sort/sort-members.xml
@@ -4,6 +4,13 @@
 <namespace id="//////////////////////////8=">
   <struct name="A" id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">
     <file short-path="sort-members.cpp" source-path="sort-members.cpp" line="21" class="def"/>
+    <doc>
+      <related>
+        <reference id="yuKyBhGbND+Kyypyb9UsuC4Qe3E=">operator!</reference>
+        <reference id="4MuN1V3fHVfOMvtg2LT+QVm/XmE=">operator!=</reference>
+        <reference id="kibUx6k1SXB+HsXkRXroJl9f59w=">operator==</reference>
+      </related>
+    </doc>
   </struct>
   <template>
     <tparam name="T" class="type"/>
@@ -318,6 +325,9 @@
       <param name="v">
         <text>The operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
   <function name="operator==" id="kibUx6k1SXB+HsXkRXroJl9f59w=">
@@ -352,6 +362,9 @@
       <param name="rhs">
         <text>The right operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
   <function name="operator!=" id="4MuN1V3fHVfOMvtg2LT+QVm/XmE=">
@@ -386,6 +399,9 @@
       <param name="rhs">
         <text>The right operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
 </namespace>
diff --git a/test-files/golden-tests/config/sort/unordered.adoc b/test-files/golden-tests/config/sort/unordered.adoc
index f615bc695..91a785a15 100644
--- a/test-files/golden-tests/config/sort/unordered.adoc
+++ b/test-files/golden-tests/config/sort/unordered.adoc
@@ -146,6 +146,20 @@ Declared in `&lt;unordered&period;cpp&gt;`
 struct A;
 ----
 
+=== Non-Member Functions
+
+[cols=2]
+|===
+| Name
+| Description
+| link:#operator_not[`operator!`]
+| Negation operator
+| link:#operator_not_eq[`operator!&equals;`]
+| Inequality operator
+| link:#operator_eq[`operator&equals;&equals;`]
+| Equality operator
+|===
+
 [#Z]
 == Z
 
diff --git a/test-files/golden-tests/config/sort/unordered.html b/test-files/golden-tests/config/sort/unordered.html
index 99c3fe256..fbe5eff33 100644
--- a/test-files/golden-tests/config/sort/unordered.html
+++ b/test-files/golden-tests/config/sort/unordered.html
@@ -40,12 +40,12 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#operator_not_eq"><code>operator!&#x3D;</code></a> </td><td><span>Inequality operator</span></td></tr><tr>
-<td><a href="#operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td><span>Equality operator</span></td></tr><tr>
-<td><a href="#operator_not"><code>operator!</code></a> </td><td><span>Negation operator</span></td></tr><tr>
-<td><a href="#h"><code>h</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#g-0f"><code>g</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#f"><code>f</code></a> </td><td><span></span></td></tr>
+<td><a href="#operator_not_eq"><code>operator!&#x3D;</code></a> </td><td>Inequality operator</td></tr><tr>
+<td><a href="#operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td>Equality operator</td></tr><tr>
+<td><a href="#operator_not"><code>operator!</code></a> </td><td>Negation operator</td></tr><tr>
+<td><a href="#h"><code>h</code></a> </td><td></td></tr><tr>
+<td><a href="#g-0f"><code>g</code></a> </td><td></td></tr><tr>
+<td><a href="#f"><code>f</code></a> </td><td></td></tr>
 </tbody>
 </table>
 
@@ -59,9 +59,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct D;
-
-</code>
+<code class="source-code cpp">struct D;</code>
 </pre>
 </div>
 
@@ -79,9 +77,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     class T,
     class U = void&gt;
-struct C;
-
-</code>
+struct C;</code>
 </pre>
 </div>
 
@@ -97,9 +93,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#C-0f">C</a>&lt;int, char&gt;;
-
-</code>
+struct <a href="#C-0f">C</a>&lt;int, char&gt;;</code>
 </pre>
 </div>
 
@@ -115,9 +109,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#C-0f">C</a>&lt;int&gt;;
-
-</code>
+struct <a href="#C-0f">C</a>&lt;int&gt;;</code>
 </pre>
 </div>
 
@@ -135,9 +127,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     class T,
     class U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 
@@ -153,9 +143,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#B-0b">B</a>&lt;int, char&gt;;
-
-</code>
+struct <a href="#B-0b">B</a>&lt;int, char&gt;;</code>
 </pre>
 </div>
 
@@ -171,9 +159,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class U&gt;
-struct <a href="#B-0b">B</a>&lt;int, U&gt;;
-
-</code>
+struct <a href="#B-0b">B</a>&lt;int, U&gt;;</code>
 </pre>
 </div>
 
@@ -188,13 +174,27 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 
 
+<div>
+<h2>Non-Member Functions</h2>
+<table>
+<thead>
+<tr>
+<th>Name</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr><td><a href="#operator_not"><code>operator!</code></a></td><td>Negation operator</td></tr>
+<tr><td><a href="#operator_not_eq"><code>operator!&#x3D;</code></a></td><td>Inequality operator</td></tr>
+<tr><td><a href="#operator_eq"><code>operator&#x3D;&#x3D;</code></a></td><td>Equality operator</td></tr>
+</tbody>
+</table>
+</div>
 </div>
 <div>
 <div>
@@ -205,9 +205,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct Z;
-
-</code>
+<code class="source-code cpp">struct Z;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -220,14 +218,14 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#Z-operator_3way"><code>operator&lt;&#x3D;&gt;</code></a> </td><td><span>Three-way comparison operator</span></td></tr><tr>
-<td><a href="#Z-operator_not_eq"><code>operator!&#x3D;</code></a> </td><td><span>Inequality operator</span></td></tr><tr>
-<td><a href="#Z-operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td><span>Equality operator</span></td></tr><tr>
-<td><a href="#Z-operator_not"><code>operator!</code></a> </td><td><span>Negation operator</span></td></tr><tr>
-<td><a href="#Z-2conversion"><code>operator bool</code></a> </td><td><span>Conversion to <code>bool</code></span></td></tr><tr>
-<td><a href="#Z-foo"><code>foo</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#Z-2destructor"><code>~Z</code></a> <span class="small">[destructor]</span></td><td><span>Destructor</span></td></tr><tr>
-<td><a href="#Z-2constructor-00"><code>Z</code></a>         <span class="small">[constructor]</span></td><td><span>Constructors</span></td></tr>
+<td><a href="#Z-operator_3way"><code>operator&lt;&#x3D;&gt;</code></a> </td><td>Three-way comparison operator</td></tr><tr>
+<td><a href="#Z-operator_not_eq"><code>operator!&#x3D;</code></a> </td><td>Inequality operator</td></tr><tr>
+<td><a href="#Z-operator_eq"><code>operator&#x3D;&#x3D;</code></a> </td><td>Equality operator</td></tr><tr>
+<td><a href="#Z-operator_not"><code>operator!</code></a> </td><td>Negation operator</td></tr><tr>
+<td><a href="#Z-2conversion"><code>operator bool</code></a> </td><td>Conversion to <code>bool</code></td></tr><tr>
+<td><a href="#Z-foo"><code>foo</code></a> </td><td></td></tr><tr>
+<td><a href="#Z-2destructor"><code>~Z</code></a> <span class="small">[destructor]</span></td><td>Destructor</td></tr><tr>
+<td><a href="#Z-2constructor-00"><code>Z</code></a>         <span class="small">[constructor]</span></td><td>Constructors</td></tr>
 </tbody>
 </table>
 
@@ -238,8 +236,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="Z-operator_3way">Z::operator&lt;&#x3D;&gt;</h2>
 <div>
-<span>Three-way comparison operator</span>
-
+<p>Three-way comparison operator</p>
 </div>
 </div>
 <div>
@@ -248,14 +245,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">auto
-operator&lt;&#x3D;&gt;(<a href="#Z">Z</a> const& rhs) const;
-
-</code>
+operator&lt;&#x3D;&gt;(<a href="#Z">Z</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The relative order of the objects</span>
+The relative order of the objects
 </div>
 <div>
 <h3>Parameters</h3>
@@ -269,7 +264,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -279,8 +274,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Z-operator_not_eq">Z::operator!&#x3D;</h2>
 <div>
-<span>Inequality operator</span>
-
+<p>Inequality operator</p>
 </div>
 </div>
 <div>
@@ -289,14 +283,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator!&#x3D;(<a href="#Z">Z</a> const& rhs) const;
-
-</code>
+operator!&#x3D;(<a href="#Z">Z</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are not equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are not equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -310,7 +302,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -320,8 +312,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Z-operator_eq">Z::operator&#x3D;&#x3D;</h2>
 <div>
-<span>Equality operator</span>
-
+<p>Equality operator</p>
 </div>
 </div>
 <div>
@@ -330,14 +321,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator&#x3D;&#x3D;(<a href="#Z">Z</a> const& rhs) const;
-
-</code>
+operator&#x3D;&#x3D;(<a href="#Z">Z</a> const& rhs) const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -351,7 +340,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -361,8 +350,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Z-operator_not">Z::operator!</h2>
 <div>
-<span>Negation operator</span>
-
+<p>Negation operator</p>
 </div>
 </div>
 <div>
@@ -371,22 +359,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator!() const;
-
-</code>
+operator!() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the object is falsy, <code>false</code> otherwise</span>
+<code>true</code> if the object is falsy, <code>false</code> otherwise
 </div>
 </div>
 <div>
 <div>
 <h2 id="Z-2conversion">Z::operator bool</h2>
 <div>
-<span>Conversion to <code>bool</code></span>
-
+<p>Conversion to <code>bool</code></p>
 </div>
 </div>
 <div>
@@ -394,14 +379,12 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">operator bool() const;
-
-</code>
+<code class="source-code cpp">operator bool() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The object converted to <code>bool</code></span>
+The object converted to <code>bool</code>
 </div>
 </div>
 <div>
@@ -414,9 +397,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-foo() const;
-
-</code>
+foo() const;</code>
 </pre>
 </div>
 </div>
@@ -424,8 +405,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="Z-2destructor">Z::~Z</h2>
 <div>
-<span>Destructor</span>
-
+<p>Destructor</p>
 </div>
 </div>
 <div>
@@ -433,9 +413,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">~Z();
-
-</code>
+<code class="source-code cpp">~Z();</code>
 </pre>
 </div>
 </div>
@@ -443,26 +421,21 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="Z-2constructor-00">Z::Z</h2>
 <div>
-<span>Constructors</span>
-
+<p>Constructors</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
-<span>Default constructor</span>
+<p>Default constructor</p>
 <pre>
-<code class="source-code cpp"><a href="#Z-2constructor-05">Z</a>();
-
-</code>
+<code class="source-code cpp"><a href="#Z-2constructor-05">Z</a>();</code>
 </pre><span class="small"><a href="#Z-2constructor-05"><em>» more...</em></a></span>
 
-<span>Construct from <code>int</code></span>
+<p>Construct from <code>int</code></p>
 <pre>
-<code class="source-code cpp"><a href="#Z-2constructor-06">Z</a>(int value);
-
-</code>
+<code class="source-code cpp"><a href="#Z-2constructor-06">Z</a>(int value);</code>
 </pre><span class="small"><a href="#Z-2constructor-06"><em>» more...</em></a></span>
 
 
@@ -472,8 +445,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="Z-2constructor-05">Z::Z</h2>
 <div>
-<span>Default constructor</span>
-
+<p>Default constructor</p>
 </div>
 </div>
 <div>
@@ -481,9 +453,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">Z();
-
-</code>
+<code class="source-code cpp">Z();</code>
 </pre>
 </div>
 </div>
@@ -491,8 +461,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="Z-2constructor-06">Z::Z</h2>
 <div>
-<span>Construct from <code>int</code></span>
-
+<p>Construct from <code>int</code></p>
 </div>
 </div>
 <div>
@@ -500,9 +469,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">Z(int value);
-
-</code>
+<code class="source-code cpp">Z(int value);</code>
 </pre>
 </div>
 <div>
@@ -517,7 +484,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The value to construct from</span></td>
+<td>The value to construct from</td>
 </tr>
 </tbody>
 </table>
@@ -527,8 +494,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_not_eq">operator!&#x3D;</h2>
 <div>
-<span>Inequality operator</span>
-
+<p>Inequality operator</p>
 </div>
 </div>
 <div>
@@ -539,14 +505,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">bool
 operator!&#x3D;(
     <a href="#A">A</a> const& lhs,
-    <a href="#A">A</a> const& rhs);
-
-</code>
+    <a href="#A">A</a> const& rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are not equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are not equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -560,11 +524,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -574,8 +538,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_eq">operator&#x3D;&#x3D;</h2>
 <div>
-<span>Equality operator</span>
-
+<p>Equality operator</p>
 </div>
 </div>
 <div>
@@ -586,14 +549,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">bool
 operator&#x3D;&#x3D;(
     <a href="#A">A</a> const& lhs,
-    <a href="#A">A</a> const& rhs);
-
-</code>
+    <a href="#A">A</a> const& rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -607,11 +568,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -621,8 +582,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_not">operator!</h2>
 <div>
-<span>Negation operator</span>
-
+<p>Negation operator</p>
 </div>
 </div>
 <div>
@@ -631,14 +591,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-operator!(<a href="#A">A</a> const& v);
-
-</code>
+operator!(<a href="#A">A</a> const& v);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the object is falsy, <code>false</code> otherwise</span>
+<code>true</code> if the object is falsy, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -652,7 +610,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>v</strong></td>
-<td><span>The operand</span></td>
+<td>The operand</td>
 </tr>
 </tbody>
 </table>
@@ -668,9 +626,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h();
-
-</code>
+h();</code>
 </pre>
 </div>
 </div>
@@ -689,9 +645,7 @@ <h3>Synopses</h3>
 <a href="#g-03c">g</a>(
     T,
     T,
-    T);
-
-</code>
+    T);</code>
 </pre><span class="small"><a href="#g-03c"><em>» more...</em></a></span>
 
 
@@ -701,9 +655,7 @@ <h3>Synopses</h3>
 <a href="#g-0e4">g&lt;int&gt;</a>(
     int,
     int,
-    int);
-
-</code>
+    int);</code>
 </pre><span class="small"><a href="#g-0e4"><em>» more...</em></a></span>
 
 
@@ -712,9 +664,7 @@ <h3>Synopses</h3>
 <a href="#g-0a">g</a>(
     char,
     char,
-    char);
-
-</code>
+    char);</code>
 </pre><span class="small"><a href="#g-0a"><em>» more...</em></a></span>
 
 
@@ -722,33 +672,25 @@ <h3>Synopses</h3>
 <code class="source-code cpp">char
 <a href="#g-03a">g</a>(
     double,
-    char);
-
-</code>
+    char);</code>
 </pre><span class="small"><a href="#g-03a"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">char
-<a href="#g-06">g</a>(double);
-
-</code>
+<a href="#g-06">g</a>(double);</code>
 </pre><span class="small"><a href="#g-06"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">char
-<a href="#g-04">g</a>(int);
-
-</code>
+<a href="#g-04">g</a>(int);</code>
 </pre><span class="small"><a href="#g-04"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">void
-<a href="#g-0e3">g</a>();
-
-</code>
+<a href="#g-0e3">g</a>();</code>
 </pre><span class="small"><a href="#g-0e3"><em>» more...</em></a></span>
 
 
@@ -768,9 +710,7 @@ <h3>Synopsis</h3>
 g(
     T,
     T,
-    T);
-
-</code>
+    T);</code>
 </pre>
 </div>
 </div>
@@ -788,9 +728,7 @@ <h3>Synopsis</h3>
 <a href="#g-03c">g</a>&lt;int&gt;(
     int,
     int,
-    int);
-
-</code>
+    int);</code>
 </pre>
 </div>
 </div>
@@ -807,9 +745,7 @@ <h3>Synopsis</h3>
 g(
     char,
     char,
-    char);
-
-</code>
+    char);</code>
 </pre>
 </div>
 </div>
@@ -825,9 +761,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">char
 g(
     double,
-    char);
-
-</code>
+    char);</code>
 </pre>
 </div>
 </div>
@@ -841,9 +775,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">char
-g(double);
-
-</code>
+g(double);</code>
 </pre>
 </div>
 </div>
@@ -857,9 +789,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">char
-g(int);
-
-</code>
+g(int);</code>
 </pre>
 </div>
 </div>
@@ -873,9 +803,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
@@ -889,9 +817,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;unordered.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/config/sort/unordered.xml b/test-files/golden-tests/config/sort/unordered.xml
index 1715fe9d1..7438abb84 100644
--- a/test-files/golden-tests/config/sort/unordered.xml
+++ b/test-files/golden-tests/config/sort/unordered.xml
@@ -49,6 +49,13 @@
   </template>
   <struct name="A" id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">
     <file short-path="unordered.cpp" source-path="unordered.cpp" line="21" class="def"/>
+    <doc>
+      <related>
+        <reference id="yuKyBhGbND+Kyypyb9UsuC4Qe3E=">operator!</reference>
+        <reference id="4MuN1V3fHVfOMvtg2LT+QVm/XmE=">operator!=</reference>
+        <reference id="kibUx6k1SXB+HsXkRXroJl9f59w=">operator==</reference>
+      </related>
+    </doc>
   </struct>
   <struct name="Z" id="NQ8uQgTcafPcttyBMHHLHAXA4MA=">
     <file short-path="unordered.cpp" source-path="unordered.cpp" line="23" class="def"/>
@@ -235,6 +242,9 @@
       <param name="rhs">
         <text>The right operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
   <function name="operator==" id="kibUx6k1SXB+HsXkRXroJl9f59w=">
@@ -269,6 +279,9 @@
       <param name="rhs">
         <text>The right operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
   <function name="operator!" id="yuKyBhGbND+Kyypyb9UsuC4Qe3E=">
@@ -295,6 +308,9 @@
       <param name="v">
         <text>The operand</text>
       </param>
+      <relates>
+        <reference id="YrPSaKAbmXgzCAX5WByx4eVoqBM=">A</reference>
+      </relates>
     </doc>
   </function>
   <function name="h" id="rvT6OxIrrSI0KxJ2nkfEgBz/Lz4=">
diff --git a/test-files/golden-tests/core/libcxx.html b/test-files/golden-tests/core/libcxx.html
index 33d4df60d..34d65f72d 100644
--- a/test-files/golden-tests/core/libcxx.html
+++ b/test-files/golden-tests/core/libcxx.html
@@ -19,7 +19,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#sqrt"><code>sqrt</code></a> </td><td><span>Computes the square root of an integral value.</span></td></tr>
+<td><a href="#sqrt"><code>sqrt</code></a> </td><td>Computes the square root of an integral value.</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="sqrt">sqrt</h2>
 <div>
-<span>Computes the square root of an integral value.</span>
-
+<p>Computes the square root of an integral value.</p>
 </div>
 </div>
 <div>
@@ -40,9 +39,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;typename T&gt;
 T
 sqrt(T value)
-requires std::is_integral_v&lt;T&gt;;
-
-</code>
+requires std::is_integral_v&lt;T&gt;;</code>
 </pre>
 </div>
 <div>
@@ -61,14 +58,14 @@ <h3>Exceptions</h3>
 <tbody>
 <tr>
 <td><code>std::invalid_argument</code></td>
-<td><span>if the input value is negative.</span></td>
+<td>if the input value is negative.</td>
 </tr>
 </tbody>
 </table>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The square root of the input value.</span>
+The square root of the input value.
 </div>
 <div>
 <h3>Template Parameters</h3>
@@ -82,7 +79,7 @@ <h3>Template Parameters</h3>
 <tbody>
 <tr>
 <td><strong>T</strong></td>
-<td><span>The type of the input value. Must be an integral type.</span></td>
+<td>The type of the input value. Must be an integral type.</td>
 </tr>
 </tbody>
 </table>
@@ -99,7 +96,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The integral value to compute the square root of.</span></td>
+<td>The integral value to compute the square root of.</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/core/utf-8.html b/test-files/golden-tests/core/utf-8.html
index a032af748..76f5e369a 100644
--- a/test-files/golden-tests/core/utf-8.html
+++ b/test-files/golden-tests/core/utf-8.html
@@ -33,9 +33,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;utf-8.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-Христос_воскрес();
-
-</code>
+Христос_воскрес();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/filters/file/include-self.html b/test-files/golden-tests/filters/file/include-self.html
index 274afee73..72968dd61 100644
--- a/test-files/golden-tests/filters/file/include-self.html
+++ b/test-files/golden-tests/filters/file/include-self.html
@@ -50,9 +50,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;include-self.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct SUCCESS;
-
-</code>
+<code class="source-code cpp">struct SUCCESS;</code>
 </pre>
 </div>
 
diff --git a/test-files/golden-tests/filters/file/include-symlink.html b/test-files/golden-tests/filters/file/include-symlink.html
index a4f6f953a..a465e1f3f 100644
--- a/test-files/golden-tests/filters/file/include-symlink.html
+++ b/test-files/golden-tests/filters/file/include-symlink.html
@@ -19,7 +19,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>A brief.</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>A brief.</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>A brief.</span>
-
+<p>A brief.</p>
 </div>
 </div>
 <div>
@@ -38,9 +37,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;included.hpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/filters/file/subdirectories.html b/test-files/golden-tests/filters/file/subdirectories.html
index eed814455..ad78f0971 100644
--- a/test-files/golden-tests/filters/file/subdirectories.html
+++ b/test-files/golden-tests/filters/file/subdirectories.html
@@ -19,7 +19,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>A brief.</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>A brief.</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>A brief.</span>
-
+<p>A brief.</p>
 </div>
 </div>
 <div>
@@ -38,9 +37,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;a/included.hpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/filters/file/subdirectories2.html b/test-files/golden-tests/filters/file/subdirectories2.html
index eed814455..ad78f0971 100644
--- a/test-files/golden-tests/filters/file/subdirectories2.html
+++ b/test-files/golden-tests/filters/file/subdirectories2.html
@@ -19,7 +19,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>A brief.</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>A brief.</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>A brief.</span>
-
+<p>A brief.</p>
 </div>
 </div>
 <div>
@@ -38,9 +37,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;a/included.hpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/filters/symbol-name/blacklist_0.html b/test-files/golden-tests/filters/symbol-name/blacklist_0.html
index 9d0cceee2..245ac2fb8 100644
--- a/test-files/golden-tests/filters/symbol-name/blacklist_0.html
+++ b/test-files/golden-tests/filters/symbol-name/blacklist_0.html
@@ -53,9 +53,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;blacklist_0.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -106,9 +104,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;blacklist_0.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -140,9 +136,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;blacklist_0.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -192,9 +186,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;blacklist_0.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g0();
-
-</code>
+g0();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/filters/symbol-name/excluded-base-class.html b/test-files/golden-tests/filters/symbol-name/excluded-base-class.html
index 3c3f80243..5eead8405 100644
--- a/test-files/golden-tests/filters/symbol-name/excluded-base-class.html
+++ b/test-files/golden-tests/filters/symbol-name/excluded-base-class.html
@@ -52,9 +52,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;excluded-base-class.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">class D
-    : public B::C
-
-</code>
+    : public B::C</code>
 </pre>
 </div>
 <div>
@@ -67,7 +65,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code>B::C</code></td><td><span></span></td></tr>
+<tr><td><code>B::C</code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -100,9 +98,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;excluded-base-class.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -117,9 +113,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">virtual
 void
-g() override;
-
-</code>
+g() override;</code>
 </pre>
 </div>
 </div>
@@ -134,9 +128,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">virtual
 void
-h() override;
-
-</code>
+h() override;</code>
 </pre>
 </div>
 </div>
@@ -150,9 +142,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;excluded-base-class.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-i();
-
-</code>
+i();</code>
 </pre>
 </div>
 </div>
@@ -166,9 +156,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;excluded-base-class.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">class E
-    : public B::C
-
-</code>
+    : public B::C</code>
 </pre>
 </div>
 <div>
@@ -181,7 +169,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code>B::C</code></td><td><span></span></td></tr>
+<tr><td><code>B::C</code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -214,9 +202,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;excluded-base-class.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -231,9 +217,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">virtual
 void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
@@ -248,9 +232,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">virtual
 void
-h() override;
-
-</code>
+h() override;</code>
 </pre>
 </div>
 </div>
@@ -264,9 +246,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;excluded-base-class.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-i();
-
-</code>
+i();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/filters/symbol-name/excluded-namespace-alias.html b/test-files/golden-tests/filters/symbol-name/excluded-namespace-alias.html
index dff0319e5..5c8caba5a 100644
--- a/test-files/golden-tests/filters/symbol-name/excluded-namespace-alias.html
+++ b/test-files/golden-tests/filters/symbol-name/excluded-namespace-alias.html
@@ -68,9 +68,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;excluded-namespace-alias.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">namespace E = B::S::E;
-
-</code>
+<code class="source-code cpp">namespace E = B::S::E;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/filters/symbol-name/extraction-mode.html b/test-files/golden-tests/filters/symbol-name/extraction-mode.html
index 9e1d1f0df..c99c5acbc 100644
--- a/test-files/golden-tests/filters/symbol-name/extraction-mode.html
+++ b/test-files/golden-tests/filters/symbol-name/extraction-mode.html
@@ -19,8 +19,8 @@ <h2>Namespaces</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#regular_ns"><code>regular_ns</code></a> </td><td><span>A regular namespace with different filters for members</span></td></tr><tr>
-<td><a href="#see_below_ns"><code>see_below_ns</code></a> </td><td><span>A see-below namespace</span></td></tr>
+<td><a href="#regular_ns"><code>regular_ns</code></a> </td><td>A regular namespace with different filters for members</td></tr><tr>
+<td><a href="#see_below_ns"><code>see_below_ns</code></a> </td><td>A see-below namespace</td></tr>
 </tbody>
 </table>
 
@@ -34,9 +34,9 @@ <h2>Namespace Aliases</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#dependency_ns_alias"><code>dependency_ns_alias</code></a> </td><td><span>Namespace alias to form the dependency on dependency_ns</span></td></tr><tr>
-<td><a href="#implementation_defined_ns_alias"><code>implementation_defined_ns_alias</code></a> </td><td><span>Namespace alias to form a dependency on the implementation-defined namespace</span></td></tr><tr>
-<td><a href="#see_below_ns_alias"><code>see_below_ns_alias</code></a> </td><td><span>Namespace alias to form a dependency on the see-below namespace</span></td></tr>
+<td><a href="#dependency_ns_alias"><code>dependency_ns_alias</code></a> </td><td>Namespace alias to form the dependency on dependency_ns</td></tr><tr>
+<td><a href="#implementation_defined_ns_alias"><code>implementation_defined_ns_alias</code></a> </td><td>Namespace alias to form a dependency on the implementation-defined namespace</td></tr><tr>
+<td><a href="#see_below_ns_alias"><code>see_below_ns_alias</code></a> </td><td>Namespace alias to form a dependency on the see-below namespace</td></tr>
 </tbody>
 </table>
 
@@ -50,8 +50,8 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#regular"><code>regular</code></a> </td><td><span>A regular symbol in the global namespace</span></td></tr><tr>
-<td><a href="#see_below"><code>see_below</code></a> </td><td><span>A see-below symbol in the global namespace</span></td></tr>
+<td><a href="#regular"><code>regular</code></a> </td><td>A regular symbol in the global namespace</td></tr><tr>
+<td><a href="#see_below"><code>see_below</code></a> </td><td>A see-below symbol in the global namespace</td></tr>
 </tbody>
 </table>
 
@@ -65,10 +65,10 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#get_dependency"><code>get_dependency</code></a> </td><td><span>A function to get a dependency symbol on the global namespace</span></td></tr><tr>
-<td><a href="#get_implementation_defined"><code>get_implementation_defined</code></a> </td><td><span>A function to get an implementation-defined symbol in the global namespace</span></td></tr><tr>
-<td><a href="#get_regular"><code>get_regular</code></a> </td><td><span>A function to get a regular symbol in the global namespace</span></td></tr><tr>
-<td><a href="#get_see_below"><code>get_see_below</code></a> </td><td><span>A function to get a see-below symbol in the global namespace</span></td></tr>
+<td><a href="#get_dependency"><code>get_dependency</code></a> </td><td>A function to get a dependency symbol on the global namespace</td></tr><tr>
+<td><a href="#get_implementation_defined"><code>get_implementation_defined</code></a> </td><td>A function to get an implementation-defined symbol in the global namespace</td></tr><tr>
+<td><a href="#get_regular"><code>get_regular</code></a> </td><td>A function to get a regular symbol in the global namespace</td></tr><tr>
+<td><a href="#get_see_below"><code>get_see_below</code></a> </td><td>A function to get a see-below symbol in the global namespace</td></tr>
 </tbody>
 </table>
 
@@ -77,8 +77,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="regular_ns">regular_ns</h2>
 <div>
-<span>A regular namespace with different filters for members</span>
-
+<p>A regular namespace with different filters for members</p>
 </div>
 </div>
 <h2>Types</h2>
@@ -91,8 +90,8 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#regular_ns-regular"><code>regular</code></a> </td><td><span>A symbol that passes the filters</span></td></tr><tr>
-<td><a href="#regular_ns-see_below"><code>see_below</code></a> </td><td><span>A symbol that passes the see-below filter</span></td></tr>
+<td><a href="#regular_ns-regular"><code>regular</code></a> </td><td>A symbol that passes the filters</td></tr><tr>
+<td><a href="#regular_ns-see_below"><code>see_below</code></a> </td><td>A symbol that passes the see-below filter</td></tr>
 </tbody>
 </table>
 
@@ -106,10 +105,10 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#regular_ns-get_dependency"><code>get_dependency</code></a> </td><td><span>A function to get an excluded symbol</span></td></tr><tr>
-<td><a href="#regular_ns-get_implementation_defined"><code>get_implementation_defined</code></a> </td><td><span>A function to get an implementation-defined symbol</span></td></tr><tr>
-<td><a href="#regular_ns-get_regular"><code>get_regular</code></a> </td><td><span>A function to get a regular symbol</span></td></tr><tr>
-<td><a href="#regular_ns-get_see_below"><code>get_see_below</code></a> </td><td><span>A function to get a see-below symbol</span></td></tr>
+<td><a href="#regular_ns-get_dependency"><code>get_dependency</code></a> </td><td>A function to get an excluded symbol</td></tr><tr>
+<td><a href="#regular_ns-get_implementation_defined"><code>get_implementation_defined</code></a> </td><td>A function to get an implementation-defined symbol</td></tr><tr>
+<td><a href="#regular_ns-get_regular"><code>get_regular</code></a> </td><td>A function to get a regular symbol</td></tr><tr>
+<td><a href="#regular_ns-get_see_below"><code>get_see_below</code></a> </td><td>A function to get a see-below symbol</td></tr>
 </tbody>
 </table>
 
@@ -118,8 +117,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="regular_ns-regular">regular_ns::regular</h2>
 <div>
-<span>A symbol that passes the filters</span>
-
+<p>A symbol that passes the filters</p>
 </div>
 </div>
 <div>
@@ -127,9 +125,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct regular;
-
-</code>
+<code class="source-code cpp">struct regular;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -142,7 +138,7 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#regular_ns-regular-also_regular"><code>also_regular</code></a> </td><td><span>Child of a regular symbol extracted as regular</span></td></tr>
+<td><a href="#regular_ns-regular-also_regular"><code>also_regular</code></a> </td><td>Child of a regular symbol extracted as regular</td></tr>
 </tbody>
 </table>
 
@@ -158,7 +154,7 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#regular_ns-get_regular"><code>get_regular</code></a></td><td><span>A function to get a regular symbol</span></td></tr>
+<tr><td><a href="#regular_ns-get_regular"><code>get_regular</code></a></td><td>A function to get a regular symbol</td></tr>
 </tbody>
 </table>
 </div>
@@ -171,8 +167,7 @@ <h3>Description</h3>
 <div>
 <h2 id="regular_ns-regular-also_regular">regular_ns::regular::also_regular</h2>
 <div>
-<span>Child of a regular symbol extracted as regular</span>
-
+<p>Child of a regular symbol extracted as regular</p>
 </div>
 </div>
 <div>
@@ -180,9 +175,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct also_regular;
-
-</code>
+<code class="source-code cpp">struct also_regular;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -195,7 +188,7 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#regular_ns-regular-also_regular-regular_as_well"><code>regular_as_well</code></a> </td><td><span>Grandchild of a regular symbol extracted as regular</span></td></tr>
+<td><a href="#regular_ns-regular-also_regular-regular_as_well"><code>regular_as_well</code></a> </td><td>Grandchild of a regular symbol extracted as regular</td></tr>
 </tbody>
 </table>
 
@@ -206,8 +199,7 @@ <h2>Types</h2>
 <div>
 <h2 id="regular_ns-regular-also_regular-regular_as_well">regular_ns::regular::also_regular::regular_as_well</h2>
 <div>
-<span>Grandchild of a regular symbol extracted as regular</span>
-
+<p>Grandchild of a regular symbol extracted as regular</p>
 </div>
 </div>
 <div>
@@ -215,9 +207,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct regular_as_well;
-
-</code>
+<code class="source-code cpp">struct regular_as_well;</code>
 </pre>
 </div>
 
@@ -227,8 +217,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="regular_ns-see_below">regular_ns::see_below</h2>
 <div>
-<span>A symbol that passes the see-below filter</span>
-
+<p>A symbol that passes the see-below filter</p>
 </div>
 </div>
 <div>
@@ -236,9 +225,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct see_below { /* see-below */ };
-
-</code>
+<code class="source-code cpp">struct see_below { /* see-below */ };</code>
 </pre>
 </div>
 
@@ -252,8 +239,7 @@ <h3>Description</h3>
 <div>
 <h2 id="regular_ns-get_dependency">regular_ns::get_dependency</h2>
 <div>
-<span>A function to get an excluded symbol</span>
-
+<p>A function to get an excluded symbol</p>
 </div>
 </div>
 <div>
@@ -262,9 +248,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">dependency
-get_dependency();
-
-</code>
+get_dependency();</code>
 </pre>
 </div>
 <div>
@@ -276,8 +260,7 @@ <h3>Description</h3>
 <div>
 <h2 id="regular_ns-get_implementation_defined">regular_ns::get_implementation_defined</h2>
 <div>
-<span>A function to get an implementation-defined symbol</span>
-
+<p>A function to get an implementation-defined symbol</p>
 </div>
 </div>
 <div>
@@ -286,9 +269,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">/* implementation-defined */
-get_implementation_defined();
-
-</code>
+get_implementation_defined();</code>
 </pre>
 </div>
 <div>
@@ -298,15 +279,14 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A symbol that passes the implementation-defined filter</span>
+A symbol that passes the implementation-defined filter
 </div>
 </div>
 <div>
 <div>
 <h2 id="regular_ns-get_regular">regular_ns::get_regular</h2>
 <div>
-<span>A function to get a regular symbol</span>
-
+<p>A function to get a regular symbol</p>
 </div>
 </div>
 <div>
@@ -315,9 +295,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#regular_ns-regular">regular</a>
-get_regular();
-
-</code>
+get_regular();</code>
 </pre>
 </div>
 <div>
@@ -326,15 +304,14 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A symbol that passes the filters</span>
+A symbol that passes the filters
 </div>
 </div>
 <div>
 <div>
 <h2 id="regular_ns-get_see_below">regular_ns::get_see_below</h2>
 <div>
-<span>A function to get a see-below symbol</span>
-
+<p>A function to get a see-below symbol</p>
 </div>
 </div>
 <div>
@@ -343,9 +320,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#regular_ns-see_below">see_below</a>
-get_see_below();
-
-</code>
+get_see_below();</code>
 </pre>
 </div>
 <div>
@@ -354,15 +329,14 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A symbol that passes the see-below filter</span>
+A symbol that passes the see-below filter
 </div>
 </div>
 <div>
 <div>
 <h2 id="see_below_ns">see_below_ns</h2>
 <div>
-<span>A see-below namespace</span>
-
+<p>A see-below namespace</p>
 </div>
 </div>
 <h2>Types</h2>
@@ -375,8 +349,8 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#see_below_ns-regular"><code>regular</code></a> </td><td><span>Regular symbol in a see-below namespace</span></td></tr><tr>
-<td><a href="#see_below_ns-see_below"><code>see_below</code></a> </td><td><span>See-below symbol in a see-below namespace</span></td></tr>
+<td><a href="#see_below_ns-regular"><code>regular</code></a> </td><td>Regular symbol in a see-below namespace</td></tr><tr>
+<td><a href="#see_below_ns-see_below"><code>see_below</code></a> </td><td>See-below symbol in a see-below namespace</td></tr>
 </tbody>
 </table>
 
@@ -390,8 +364,8 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#see_below_ns-get_dependency"><code>get_dependency</code></a> </td><td><span>A function to get a dependency symbol in a see-below namespace</span></td></tr><tr>
-<td><a href="#see_below_ns-get_implementation_defined"><code>get_implementation_defined</code></a> </td><td><span>A function to get an implementation-defined symbol in a see-below namespace</span></td></tr>
+<td><a href="#see_below_ns-get_dependency"><code>get_dependency</code></a> </td><td>A function to get a dependency symbol in a see-below namespace</td></tr><tr>
+<td><a href="#see_below_ns-get_implementation_defined"><code>get_implementation_defined</code></a> </td><td>A function to get an implementation-defined symbol in a see-below namespace</td></tr>
 </tbody>
 </table>
 
@@ -405,8 +379,7 @@ <h3>Description</h3>
 <div>
 <h2 id="see_below_ns-regular">see_below_ns::regular</h2>
 <div>
-<span>Regular symbol in a see-below namespace</span>
-
+<p>Regular symbol in a see-below namespace</p>
 </div>
 </div>
 <div>
@@ -414,9 +387,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct regular { /* see-below */ };
-
-</code>
+<code class="source-code cpp">struct regular { /* see-below */ };</code>
 </pre>
 </div>
 
@@ -430,8 +401,7 @@ <h3>Description</h3>
 <div>
 <h2 id="see_below_ns-see_below">see_below_ns::see_below</h2>
 <div>
-<span>See-below symbol in a see-below namespace</span>
-
+<p>See-below symbol in a see-below namespace</p>
 </div>
 </div>
 <div>
@@ -439,9 +409,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct see_below { /* see-below */ };
-
-</code>
+<code class="source-code cpp">struct see_below { /* see-below */ };</code>
 </pre>
 </div>
 
@@ -455,8 +423,7 @@ <h3>Description</h3>
 <div>
 <h2 id="see_below_ns-get_dependency">see_below_ns::get_dependency</h2>
 <div>
-<span>A function to get a dependency symbol in a see-below namespace</span>
-
+<p>A function to get a dependency symbol in a see-below namespace</p>
 </div>
 </div>
 <div>
@@ -465,9 +432,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">dependency
-get_dependency();
-
-</code>
+get_dependency();</code>
 </pre>
 </div>
 <div>
@@ -480,8 +445,7 @@ <h3>Description</h3>
 <div>
 <h2 id="see_below_ns-get_implementation_defined">see_below_ns::get_implementation_defined</h2>
 <div>
-<span>A function to get an implementation-defined symbol in a see-below namespace</span>
-
+<p>A function to get an implementation-defined symbol in a see-below namespace</p>
 </div>
 </div>
 <div>
@@ -490,9 +454,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">/* implementation-defined */
-get_implementation_defined();
-
-</code>
+get_implementation_defined();</code>
 </pre>
 </div>
 <div>
@@ -502,15 +464,14 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Implementation-defined symbol in a see-below namespace</span>
+Implementation-defined symbol in a see-below namespace
 </div>
 </div>
 <div>
 <div>
 <h2 id="dependency_ns_alias">dependency_ns_alias</h2>
 <div>
-<span>Namespace alias to form the dependency on dependency_ns</span>
-
+<p>Namespace alias to form the dependency on dependency_ns</p>
 </div>
 </div>
 <div>
@@ -518,9 +479,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">namespace dependency_ns_alias = dependency_ns;
-
-</code>
+<code class="source-code cpp">namespace dependency_ns_alias = dependency_ns;</code>
 </pre>
 </div>
 </div>
@@ -528,8 +487,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="implementation_defined_ns_alias">implementation_defined_ns_alias</h2>
 <div>
-<span>Namespace alias to form a dependency on the implementation-defined namespace</span>
-
+<p>Namespace alias to form a dependency on the implementation-defined namespace</p>
 </div>
 </div>
 <div>
@@ -537,9 +495,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">namespace implementation_defined_ns_alias = /* implementation-defined */;
-
-</code>
+<code class="source-code cpp">namespace implementation_defined_ns_alias = /* implementation-defined */;</code>
 </pre>
 </div>
 </div>
@@ -547,8 +503,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="see_below_ns_alias">see_below_ns_alias</h2>
 <div>
-<span>Namespace alias to form a dependency on the see-below namespace</span>
-
+<p>Namespace alias to form a dependency on the see-below namespace</p>
 </div>
 </div>
 <div>
@@ -556,9 +511,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">namespace see_below_ns_alias = <a href="#see_below_ns">see_below_ns</a>;
-
-</code>
+<code class="source-code cpp">namespace see_below_ns_alias = <a href="#see_below_ns">see_below_ns</a>;</code>
 </pre>
 </div>
 <div>
@@ -570,8 +523,7 @@ <h3>Description</h3>
 <div>
 <h2 id="regular">regular</h2>
 <div>
-<span>A regular symbol in the global namespace</span>
-
+<p>A regular symbol in the global namespace</p>
 </div>
 </div>
 <div>
@@ -579,9 +531,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct regular;
-
-</code>
+<code class="source-code cpp">struct regular;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -594,7 +544,7 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#regular-also_regular"><code>also_regular</code></a> </td><td><span>Child of a regular symbol: should be traversed as usual</span></td></tr>
+<td><a href="#regular-also_regular"><code>also_regular</code></a> </td><td>Child of a regular symbol: should be traversed as usual</td></tr>
 </tbody>
 </table>
 
@@ -610,7 +560,7 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#get_regular"><code>get_regular</code></a></td><td><span>A function to get a regular symbol in the global namespace</span></td></tr>
+<tr><td><a href="#get_regular"><code>get_regular</code></a></td><td>A function to get a regular symbol in the global namespace</td></tr>
 </tbody>
 </table>
 </div>
@@ -623,8 +573,7 @@ <h3>Description</h3>
 <div>
 <h2 id="regular-also_regular">regular::also_regular</h2>
 <div>
-<span>Child of a regular symbol: should be traversed as usual</span>
-
+<p>Child of a regular symbol: should be traversed as usual</p>
 </div>
 </div>
 <div>
@@ -632,9 +581,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct also_regular;
-
-</code>
+<code class="source-code cpp">struct also_regular;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -647,7 +594,7 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#regular-also_regular-regular_as_well"><code>regular_as_well</code></a> </td><td><span>Grandchild of a regular symbol: should be traversed as usual</span></td></tr>
+<td><a href="#regular-also_regular-regular_as_well"><code>regular_as_well</code></a> </td><td>Grandchild of a regular symbol: should be traversed as usual</td></tr>
 </tbody>
 </table>
 
@@ -658,8 +605,7 @@ <h2>Types</h2>
 <div>
 <h2 id="regular-also_regular-regular_as_well">regular::also_regular::regular_as_well</h2>
 <div>
-<span>Grandchild of a regular symbol: should be traversed as usual</span>
-
+<p>Grandchild of a regular symbol: should be traversed as usual</p>
 </div>
 </div>
 <div>
@@ -667,9 +613,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct regular_as_well;
-
-</code>
+<code class="source-code cpp">struct regular_as_well;</code>
 </pre>
 </div>
 
@@ -679,8 +623,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="see_below">see_below</h2>
 <div>
-<span>A see-below symbol in the global namespace</span>
-
+<p>A see-below symbol in the global namespace</p>
 </div>
 </div>
 <div>
@@ -688,9 +631,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct see_below { /* see-below */ };
-
-</code>
+<code class="source-code cpp">struct see_below { /* see-below */ };</code>
 </pre>
 </div>
 
@@ -705,8 +646,7 @@ <h3>Description</h3>
 <div>
 <h2 id="get_dependency">get_dependency</h2>
 <div>
-<span>A function to get a dependency symbol on the global namespace</span>
-
+<p>A function to get a dependency symbol on the global namespace</p>
 </div>
 </div>
 <div>
@@ -715,9 +655,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">dependency
-get_dependency();
-
-</code>
+get_dependency();</code>
 </pre>
 </div>
 <div>
@@ -729,8 +667,7 @@ <h3>Description</h3>
 <div>
 <h2 id="get_implementation_defined">get_implementation_defined</h2>
 <div>
-<span>A function to get an implementation-defined symbol in the global namespace</span>
-
+<p>A function to get an implementation-defined symbol in the global namespace</p>
 </div>
 </div>
 <div>
@@ -739,9 +676,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">/* implementation-defined */
-get_implementation_defined();
-
-</code>
+get_implementation_defined();</code>
 </pre>
 </div>
 <div>
@@ -751,15 +686,14 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>An implementation-defined symbol in the global namespace</span>
+An implementation-defined symbol in the global namespace
 </div>
 </div>
 <div>
 <div>
 <h2 id="get_regular">get_regular</h2>
 <div>
-<span>A function to get a regular symbol in the global namespace</span>
-
+<p>A function to get a regular symbol in the global namespace</p>
 </div>
 </div>
 <div>
@@ -768,9 +702,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#regular">regular</a>
-get_regular();
-
-</code>
+get_regular();</code>
 </pre>
 </div>
 <div>
@@ -779,15 +711,14 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A regular symbol in the global namespace</span>
+A regular symbol in the global namespace
 </div>
 </div>
 <div>
 <div>
 <h2 id="get_see_below">get_see_below</h2>
 <div>
-<span>A function to get a see-below symbol in the global namespace</span>
-
+<p>A function to get a see-below symbol in the global namespace</p>
 </div>
 </div>
 <div>
@@ -796,9 +727,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;extraction-mode.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#see_below">see_below</a>
-get_see_below();
-
-</code>
+get_see_below();</code>
 </pre>
 </div>
 <div>
@@ -807,7 +736,7 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A see-below symbol in the global namespace</span>
+A see-below symbol in the global namespace
 </div>
 </div>
 
diff --git a/test-files/golden-tests/filters/symbol-name/impl-defined-member.html b/test-files/golden-tests/filters/symbol-name/impl-defined-member.html
index 92b08bc7d..8ed76a977 100644
--- a/test-files/golden-tests/filters/symbol-name/impl-defined-member.html
+++ b/test-files/golden-tests/filters/symbol-name/impl-defined-member.html
@@ -64,9 +64,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;impl-defined-member.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct absolute_uri_rule_t;
-
-</code>
+<code class="source-code cpp">struct absolute_uri_rule_t;</code>
 </pre>
 </div>
 
@@ -81,9 +79,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;impl-defined-member.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">constexpr /* implementation-defined */ absolute_uri_rule = {};
-
-</code>
+<code class="source-code cpp">constexpr /* implementation-defined */ absolute_uri_rule = {};</code>
 </pre>
 </div>
 </div>
@@ -96,9 +92,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;impl-defined-member.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">constexpr <a href="#regular-absolute_uri_rule_t">regular::absolute_uri_rule_t</a> regular_absolute_uri_rule = {};
-
-</code>
+<code class="source-code cpp">constexpr <a href="#regular-absolute_uri_rule_t">regular::absolute_uri_rule_t</a> regular_absolute_uri_rule = {};</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/filters/symbol-name/whitelist_0.html b/test-files/golden-tests/filters/symbol-name/whitelist_0.html
index 2f46d7230..230852e3f 100644
--- a/test-files/golden-tests/filters/symbol-name/whitelist_0.html
+++ b/test-files/golden-tests/filters/symbol-name/whitelist_0.html
@@ -19,9 +19,9 @@ <h2>Namespaces</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#N0"><code>N0</code></a> </td><td><span>This namespace should extracted because it&#x27;s implied by <code>N0::f0_WL</code></span></td></tr><tr>
-<td><a href="#N1"><code>N1</code></a> </td><td><span>This namespace should extracted because it&#x27;s implied by <code>N1::N3_WL</code> and <code>N1::N4::f1_WL</code></span></td></tr><tr>
-<td><a href="#N5"><code>N5</code></a> </td><td><span>This namespace should extracted because it&#x27;s implied by <code>N5::N6::*7</code></span></td></tr>
+<td><a href="#N0"><code>N0</code></a> </td><td>This namespace should extracted because it&#x27;s implied by <code>N0::f0_WL</code></td></tr><tr>
+<td><a href="#N1"><code>N1</code></a> </td><td>This namespace should extracted because it&#x27;s implied by <code>N1::N3_WL</code> and <code>N1::N4::f1_WL</code></td></tr><tr>
+<td><a href="#N5"><code>N5</code></a> </td><td>This namespace should extracted because it&#x27;s implied by <code>N5::N6::*7</code></td></tr>
 </tbody>
 </table>
 
@@ -35,7 +35,7 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#C"><code>C</code></a> </td><td><span>This namespace should be included because it strictly matches <code>C</code></span></td></tr>
+<td><a href="#C"><code>C</code></a> </td><td>This namespace should be included because it strictly matches <code>C</code></td></tr>
 </tbody>
 </table>
 
@@ -44,8 +44,7 @@ <h2>Types</h2>
 <div>
 <h2 id="N0">N0</h2>
 <div>
-<span>This namespace should extracted because it&#x27;s implied by <code>N0::f0_WL</code></span>
-
+<p>This namespace should extracted because it&#x27;s implied by <code>N0::f0_WL</code></p>
 </div>
 </div>
 <h2>Functions</h2>
@@ -58,7 +57,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#N0-f0_WL"><code>f0_WL</code></a> </td><td><span>This function should be included because it matches <code>N0::f0_WL</code></span></td></tr>
+<td><a href="#N0-f0_WL"><code>f0_WL</code></a> </td><td>This function should be included because it matches <code>N0::f0_WL</code></td></tr>
 </tbody>
 </table>
 
@@ -67,8 +66,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="N0-f0_WL">N0::f0_WL</h2>
 <div>
-<span>This function should be included because it matches <code>N0::f0_WL</code></span>
-
+<p>This function should be included because it matches <code>N0::f0_WL</code></p>
 </div>
 </div>
 <div>
@@ -77,9 +75,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;whitelist_0.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0_WL();
-
-</code>
+f0_WL();</code>
 </pre>
 </div>
 </div>
@@ -87,8 +83,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="N1">N1</h2>
 <div>
-<span>This namespace should extracted because it&#x27;s implied by <code>N1::N3_WL</code> and <code>N1::N4::f1_WL</code></span>
-
+<p>This namespace should extracted because it&#x27;s implied by <code>N1::N3_WL</code> and <code>N1::N4::f1_WL</code></p>
 </div>
 </div>
 <h2>Namespaces</h2>
@@ -101,8 +96,8 @@ <h2>Namespaces</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#N1-N3_WL"><code>N3_WL</code></a> </td><td><span>This namespace should extracted because it&#x27;s explicitly included by <code>N1::N3_WL</code></span></td></tr><tr>
-<td><a href="#N1-N4"><code>N4</code></a> </td><td><span>This namespace should extracted because it&#x27;s implied by <code>N1::N4::f1_WL</code></span></td></tr>
+<td><a href="#N1-N3_WL"><code>N3_WL</code></a> </td><td>This namespace should extracted because it&#x27;s explicitly included by <code>N1::N3_WL</code></td></tr><tr>
+<td><a href="#N1-N4"><code>N4</code></a> </td><td>This namespace should extracted because it&#x27;s implied by <code>N1::N4::f1_WL</code></td></tr>
 </tbody>
 </table>
 
@@ -111,8 +106,7 @@ <h2>Namespaces</h2>
 <div>
 <h2 id="N1-N3_WL">N1::N3_WL</h2>
 <div>
-<span>This namespace should extracted because it&#x27;s explicitly included by <code>N1::N3_WL</code></span>
-
+<p>This namespace should extracted because it&#x27;s explicitly included by <code>N1::N3_WL</code></p>
 </div>
 </div>
 <h2>Functions</h2>
@@ -125,7 +119,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#N1-N3_WL-f1_WL"><code>f1_WL</code></a> </td><td><span>This function should extracted because the namespace <code>N1::N3_WL</code> is included as a literal.</span></td></tr>
+<td><a href="#N1-N3_WL-f1_WL"><code>f1_WL</code></a> </td><td>This function should extracted because the namespace <code>N1::N3_WL</code> is included as a literal.</td></tr>
 </tbody>
 </table>
 
@@ -134,8 +128,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="N1-N3_WL-f1_WL">N1::N3_WL::f1_WL</h2>
 <div>
-<span>This function should extracted because the namespace <code>N1::N3_WL</code> is included as a literal.</span>
-
+<p>This function should extracted because the namespace <code>N1::N3_WL</code> is included as a literal.</p>
 </div>
 </div>
 <div>
@@ -144,9 +137,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;whitelist_0.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1_WL();
-
-</code>
+f1_WL();</code>
 </pre>
 </div>
 </div>
@@ -154,8 +145,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="N1-N4">N1::N4</h2>
 <div>
-<span>This namespace should extracted because it&#x27;s implied by <code>N1::N4::f1_WL</code></span>
-
+<p>This namespace should extracted because it&#x27;s implied by <code>N1::N4::f1_WL</code></p>
 </div>
 </div>
 <h2>Functions</h2>
@@ -168,7 +158,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#N1-N4-f1_WL"><code>f1_WL</code></a> </td><td><span>This function should extracted because it matches <code>N1::N4::f1_WL</code></span></td></tr>
+<td><a href="#N1-N4-f1_WL"><code>f1_WL</code></a> </td><td>This function should extracted because it matches <code>N1::N4::f1_WL</code></td></tr>
 </tbody>
 </table>
 
@@ -177,8 +167,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="N1-N4-f1_WL">N1::N4::f1_WL</h2>
 <div>
-<span>This function should extracted because it matches <code>N1::N4::f1_WL</code></span>
-
+<p>This function should extracted because it matches <code>N1::N4::f1_WL</code></p>
 </div>
 </div>
 <div>
@@ -187,9 +176,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;whitelist_0.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1_WL();
-
-</code>
+f1_WL();</code>
 </pre>
 </div>
 </div>
@@ -197,8 +184,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="N5">N5</h2>
 <div>
-<span>This namespace should extracted because it&#x27;s implied by <code>N5::N6::*7</code></span>
-
+<p>This namespace should extracted because it&#x27;s implied by <code>N5::N6::*7</code></p>
 </div>
 </div>
 <h2>Namespaces</h2>
@@ -211,7 +197,7 @@ <h2>Namespaces</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#N5-N6"><code>N6</code></a> </td><td><span>This namespace should extracted because it&#x27;s implied by <code>N5::N6::*7</code></span></td></tr>
+<td><a href="#N5-N6"><code>N6</code></a> </td><td>This namespace should extracted because it&#x27;s implied by <code>N5::N6::*7</code></td></tr>
 </tbody>
 </table>
 
@@ -220,8 +206,7 @@ <h2>Namespaces</h2>
 <div>
 <h2 id="N5-N6">N5::N6</h2>
 <div>
-<span>This namespace should extracted because it&#x27;s implied by <code>N5::N6::*7</code></span>
-
+<p>This namespace should extracted because it&#x27;s implied by <code>N5::N6::*7</code></p>
 </div>
 </div>
 <h2>Namespaces</h2>
@@ -234,8 +219,8 @@ <h2>Namespaces</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#N5-N6-M7"><code>M7</code></a> </td><td><span>This namespace should be included because it matches <code>N5::N6::*7</code></span></td></tr><tr>
-<td><a href="#N5-N6-N7"><code>N7</code></a> </td><td><span>This namespace should be included because it matches <code>N5::N6::*7</code></span></td></tr>
+<td><a href="#N5-N6-M7"><code>M7</code></a> </td><td>This namespace should be included because it matches <code>N5::N6::*7</code></td></tr><tr>
+<td><a href="#N5-N6-N7"><code>N7</code></a> </td><td>This namespace should be included because it matches <code>N5::N6::*7</code></td></tr>
 </tbody>
 </table>
 
@@ -244,8 +229,7 @@ <h2>Namespaces</h2>
 <div>
 <h2 id="N5-N6-M7">N5::N6::M7</h2>
 <div>
-<span>This namespace should be included because it matches <code>N5::N6::*7</code></span>
-
+<p>This namespace should be included because it matches <code>N5::N6::*7</code></p>
 </div>
 </div>
 <h2>Functions</h2>
@@ -258,7 +242,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#N5-N6-M7-f2_WL"><code>f2_WL</code></a> </td><td><span>This function should be included because it&#x27;s a member of <code>M7</code>, which matches <code>N5::N6::*7</code></span></td></tr>
+<td><a href="#N5-N6-M7-f2_WL"><code>f2_WL</code></a> </td><td>This function should be included because it&#x27;s a member of <code>M7</code>, which matches <code>N5::N6::*7</code></td></tr>
 </tbody>
 </table>
 
@@ -267,8 +251,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="N5-N6-M7-f2_WL">N5::N6::M7::f2_WL</h2>
 <div>
-<span>This function should be included because it&#x27;s a member of <code>M7</code>, which matches <code>N5::N6::*7</code></span>
-
+<p>This function should be included because it&#x27;s a member of <code>M7</code>, which matches <code>N5::N6::*7</code></p>
 </div>
 </div>
 <div>
@@ -277,9 +260,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;whitelist_0.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2_WL();
-
-</code>
+f2_WL();</code>
 </pre>
 </div>
 </div>
@@ -287,8 +268,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="N5-N6-N7">N5::N6::N7</h2>
 <div>
-<span>This namespace should be included because it matches <code>N5::N6::*7</code></span>
-
+<p>This namespace should be included because it matches <code>N5::N6::*7</code></p>
 </div>
 </div>
 <h2>Functions</h2>
@@ -301,7 +281,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#N5-N6-N7-f2_WL"><code>f2_WL</code></a> </td><td><span>This function should be included because it&#x27;s a member of <code>N7</code>, which matches <code>N5::N6::*7</code></span></td></tr>
+<td><a href="#N5-N6-N7-f2_WL"><code>f2_WL</code></a> </td><td>This function should be included because it&#x27;s a member of <code>N7</code>, which matches <code>N5::N6::*7</code></td></tr>
 </tbody>
 </table>
 
@@ -310,8 +290,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="N5-N6-N7-f2_WL">N5::N6::N7::f2_WL</h2>
 <div>
-<span>This function should be included because it&#x27;s a member of <code>N7</code>, which matches <code>N5::N6::*7</code></span>
-
+<p>This function should be included because it&#x27;s a member of <code>N7</code>, which matches <code>N5::N6::*7</code></p>
 </div>
 </div>
 <div>
@@ -320,9 +299,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;whitelist_0.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2_WL();
-
-</code>
+f2_WL();</code>
 </pre>
 </div>
 </div>
@@ -330,8 +307,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="C">C</h2>
 <div>
-<span>This namespace should be included because it strictly matches <code>C</code></span>
-
+<p>This namespace should be included because it strictly matches <code>C</code></p>
 </div>
 </div>
 <div>
@@ -339,9 +315,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;whitelist_0.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct C;
-
-</code>
+<code class="source-code cpp">struct C;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -354,7 +328,7 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#C-D"><code>D</code></a> </td><td><span>This struct should be included because it&#x27;s a member of <code>C</code></span></td></tr>
+<td><a href="#C-D"><code>D</code></a> </td><td>This struct should be included because it&#x27;s a member of <code>C</code></td></tr>
 </tbody>
 </table>
 
@@ -368,7 +342,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#C-f0_WL"><code>f0_WL</code></a> </td><td><span>This function should be included because it&#x27;s a member of <code>C</code></span></td></tr>
+<td><a href="#C-f0_WL"><code>f0_WL</code></a> </td><td>This function should be included because it&#x27;s a member of <code>C</code></td></tr>
 </tbody>
 </table>
 
@@ -379,8 +353,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="C-D">C::D</h2>
 <div>
-<span>This struct should be included because it&#x27;s a member of <code>C</code></span>
-
+<p>This struct should be included because it&#x27;s a member of <code>C</code></p>
 </div>
 </div>
 <div>
@@ -388,9 +361,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;whitelist_0.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct D;
-
-</code>
+<code class="source-code cpp">struct D;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -403,7 +374,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#C-D-f1_WL"><code>f1_WL</code></a> </td><td><span>This function should be included because it&#x27;s a member of <code>D</code></span></td></tr>
+<td><a href="#C-D-f1_WL"><code>f1_WL</code></a> </td><td>This function should be included because it&#x27;s a member of <code>D</code></td></tr>
 </tbody>
 </table>
 
@@ -414,8 +385,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="C-D-f1_WL">C::D::f1_WL</h2>
 <div>
-<span>This function should be included because it&#x27;s a member of <code>D</code></span>
-
+<p>This function should be included because it&#x27;s a member of <code>D</code></p>
 </div>
 </div>
 <div>
@@ -424,9 +394,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;whitelist_0.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1_WL();
-
-</code>
+f1_WL();</code>
 </pre>
 </div>
 </div>
@@ -434,8 +402,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="C-f0_WL">C::f0_WL</h2>
 <div>
-<span>This function should be included because it&#x27;s a member of <code>C</code></span>
-
+<p>This function should be included because it&#x27;s a member of <code>C</code></p>
 </div>
 </div>
 <div>
@@ -444,9 +411,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;whitelist_0.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0_WL();
-
-</code>
+f0_WL();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/filters/symbol-name/whitelist_0.xml b/test-files/golden-tests/filters/symbol-name/whitelist_0.xml
index 1150be74d..9c4c2d8c0 100644
--- a/test-files/golden-tests/filters/symbol-name/whitelist_0.xml
+++ b/test-files/golden-tests/filters/symbol-name/whitelist_0.xml
@@ -41,8 +41,7 @@
           <brief>
             <text>This function should extracted because the namespace </text>
             <mono>N1::N3_WL</mono>
-            <text> is included</text>
-            <text> as a literal.</text>
+            <text> is included as a literal.</text>
           </brief>
         </doc>
       </function>
@@ -92,8 +91,7 @@
             <brief>
               <text>This function should be included because it&apos;s a member of </text>
               <mono>M7</mono>
-              <text>, which matches</text>
-              <text> </text>
+              <text>, which matches </text>
               <mono>N5::N6::*7</mono>
             </brief>
           </doc>
@@ -112,8 +110,7 @@
             <brief>
               <text>This function should be included because it&apos;s a member of </text>
               <mono>N7</mono>
-              <text>, which matches</text>
-              <text> </text>
+              <text>, which matches </text>
               <mono>N5::N6::*7</mono>
             </brief>
           </doc>
diff --git a/test-files/golden-tests/filters/symbol-type/nested-private-template.html b/test-files/golden-tests/filters/symbol-type/nested-private-template.html
index e5de5fe34..7d0f96672 100644
--- a/test-files/golden-tests/filters/symbol-type/nested-private-template.html
+++ b/test-files/golden-tests/filters/symbol-type/nested-private-template.html
@@ -33,9 +33,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;nested-private-template.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class T&gt;
-class range;
-
-</code>
+class range;</code>
 </pre>
 </div>
 
@@ -67,9 +65,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     class R,
     bool&gt;
-struct impl;
-
-</code>
+struct impl;</code>
 </pre>
 </div>
 
@@ -85,9 +81,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;nested-private-template.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class R&gt;
-struct <a href="#range-impl-0e">impl</a>&lt;R, false&gt;;
-
-</code>
+struct <a href="#range-impl-0e">impl</a>&lt;R, false&gt;;</code>
 </pre>
 </div>
 
diff --git a/test-files/golden-tests/javadoc/brief/brief-1.html b/test-files/golden-tests/javadoc/brief/brief-1.html
index 0b14485e0..bbd45a71d 100644
--- a/test-files/golden-tests/javadoc/brief/brief-1.html
+++ b/test-files/golden-tests/javadoc/brief/brief-1.html
@@ -19,8 +19,8 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f5"><code>f5</code></a> </td><td><span>brief bold it continues to the line.</span></td></tr><tr>
-<td><a href="#f6"><code>f6</code></a> </td><td><span>brief</span></td></tr>
+<td><a href="#f5"><code>f5</code></a> </td><td>brief bold it continues to the line.</td></tr><tr>
+<td><a href="#f6"><code>f6</code></a> </td><td>brief</td></tr>
 </tbody>
 </table>
 
@@ -29,8 +29,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="f5">f5</h2>
 <div>
-<span>brief bold it continues to the line.</span>
-
+<p>brief bold it continues to the line.</p>
 </div>
 </div>
 <div>
@@ -39,9 +38,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -49,8 +46,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f6">f6</h2>
 <div>
-<span>brief</span>
-
+<p>brief</p>
 </div>
 </div>
 <div>
@@ -59,9 +55,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 <div>
diff --git a/test-files/golden-tests/javadoc/brief/brief-2.html b/test-files/golden-tests/javadoc/brief/brief-2.html
index 07c8b1579..e1cd4c8d5 100644
--- a/test-files/golden-tests/javadoc/brief/brief-2.html
+++ b/test-files/golden-tests/javadoc/brief/brief-2.html
@@ -19,12 +19,12 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f1"><code>f1</code></a> </td><td><span>brief</span></td></tr><tr>
-<td><a href="#f2"><code>f2</code></a> </td><td><span>brief</span></td></tr><tr>
-<td><a href="#f3"><code>f3</code></a> </td><td><span>brief</span></td></tr><tr>
-<td><a href="#f4"><code>f4</code></a> </td><td><span>brief x</span></td></tr><tr>
-<td><a href="#f5"><code>f5</code></a> </td><td><span>brief</span></td></tr><tr>
-<td><a href="#f6"><code>f6</code></a> </td><td><span>brief</span></td></tr>
+<td><a href="#f1"><code>f1</code></a> </td><td>brief</td></tr><tr>
+<td><a href="#f2"><code>f2</code></a> </td><td>brief</td></tr><tr>
+<td><a href="#f3"><code>f3</code></a> </td><td>brief</td></tr><tr>
+<td><a href="#f4"><code>f4</code></a> </td><td>brief x</td></tr><tr>
+<td><a href="#f5"><code>f5</code></a> </td><td>brief</td></tr><tr>
+<td><a href="#f6"><code>f6</code></a> </td><td>brief</td></tr>
 </tbody>
 </table>
 
@@ -33,8 +33,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="f1">f1</h2>
 <div>
-<span>brief</span>
-
+<p>brief</p>
 </div>
 </div>
 <div>
@@ -43,9 +42,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -53,8 +50,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f2">f2</h2>
 <div>
-<span>brief</span>
-
+<p>brief</p>
 </div>
 </div>
 <div>
@@ -63,9 +59,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -73,8 +67,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f3">f3</h2>
 <div>
-<span>brief</span>
-
+<p>brief</p>
 </div>
 </div>
 <div>
@@ -83,9 +76,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f3();
-
-</code>
+f3();</code>
 </pre>
 </div>
 </div>
@@ -93,8 +84,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f4">f4</h2>
 <div>
-<span>brief x</span>
-
+<p>brief x</p>
 </div>
 </div>
 <div>
@@ -103,9 +93,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f4();
-
-</code>
+f4();</code>
 </pre>
 </div>
 <div>
@@ -117,8 +105,7 @@ <h3>Description</h3>
 <div>
 <h2 id="f5">f5</h2>
 <div>
-<span>brief</span>
-
+<p>brief</p>
 </div>
 </div>
 <div>
@@ -127,9 +114,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -137,8 +122,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f6">f6</h2>
 <div>
-<span>brief</span>
-
+<p>brief</p>
 </div>
 </div>
 <div>
@@ -147,9 +131,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 <div>
diff --git a/test-files/golden-tests/javadoc/brief/brief-3.html b/test-files/golden-tests/javadoc/brief/brief-3.html
index 009ac67db..159fa6c37 100644
--- a/test-files/golden-tests/javadoc/brief/brief-3.html
+++ b/test-files/golden-tests/javadoc/brief/brief-3.html
@@ -19,7 +19,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f-0c"><code>f</code></a> </td><td><span><code>f</code> overloads</span></td></tr>
+<td><a href="#f-0c"><code>f</code></a> </td><td><code>f</code> overloads</td></tr>
 </tbody>
 </table>
 
@@ -28,44 +28,35 @@ <h2>Functions</h2>
 <div>
 <h2 id="f-0c">f</h2>
 <div>
-<span><code>f</code> overloads</span>
-
+<p><code>f</code> overloads</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;brief-3.cpp&gt;</code></div>
-<span>Integer overload.</span>
+<p>Integer overload.</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#f-06">f</a>(int);
-
-</code>
+<a href="#f-06">f</a>(int);</code>
 </pre><span class="small"><a href="#f-06"><em>» more...</em></a></span>
 
-<span>Integer overload.</span>
+<p>Integer overload.</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#f-0f">f</a>(double);
-
-</code>
+<a href="#f-0f">f</a>(double);</code>
 </pre><span class="small"><a href="#f-0f"><em>» more...</em></a></span>
 
-<span>C string overload.</span>
+<p>C string overload.</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#f-07">f</a>(char const*);
-
-</code>
+<a href="#f-07">f</a>(char const*);</code>
 </pre><span class="small"><a href="#f-07"><em>» more...</em></a></span>
 
-<span>C string overload.</span>
+<p>C string overload.</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#f-0b">f</a>(float const*);
-
-</code>
+<a href="#f-0b">f</a>(float const*);</code>
 </pre><span class="small"><a href="#f-0b"><em>» more...</em></a></span>
 
 
@@ -75,8 +66,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="f-06">f</h2>
 <div>
-<span>Integer overload.</span>
-
+<p>Integer overload.</p>
 </div>
 </div>
 <div>
@@ -85,9 +75,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(int);
-
-</code>
+f(int);</code>
 </pre>
 </div>
 <div>
@@ -99,8 +87,7 @@ <h3>Description</h3>
 <div>
 <h2 id="f-0f">f</h2>
 <div>
-<span>Integer overload.</span>
-
+<p>Integer overload.</p>
 </div>
 </div>
 <div>
@@ -109,9 +96,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(double);
-
-</code>
+f(double);</code>
 </pre>
 </div>
 </div>
@@ -119,8 +104,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f-07">f</h2>
 <div>
-<span>C string overload.</span>
-
+<p>C string overload.</p>
 </div>
 </div>
 <div>
@@ -129,9 +113,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(char const*);
-
-</code>
+f(char const*);</code>
 </pre>
 </div>
 <div>
@@ -143,8 +125,7 @@ <h3>Description</h3>
 <div>
 <h2 id="f-0b">f</h2>
 <div>
-<span>C string overload.</span>
-
+<p>C string overload.</p>
 </div>
 </div>
 <div>
@@ -153,9 +134,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(float const*);
-
-</code>
+f(float const*);</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/javadoc/brief/brief-4.html b/test-files/golden-tests/javadoc/brief/brief-4.html
index d92240515..b33de55be 100644
--- a/test-files/golden-tests/javadoc/brief/brief-4.html
+++ b/test-files/golden-tests/javadoc/brief/brief-4.html
@@ -36,9 +36,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-4.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -52,9 +50,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-4.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -68,9 +64,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-4.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -84,9 +78,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-4.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f3();
-
-</code>
+f3();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/javadoc/brief/brief-5.html b/test-files/golden-tests/javadoc/brief/brief-5.html
index 2020cff37..c17730c23 100644
--- a/test-files/golden-tests/javadoc/brief/brief-5.html
+++ b/test-files/golden-tests/javadoc/brief/brief-5.html
@@ -19,12 +19,12 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f0"><code>f0</code></a> </td><td><span>brief</span></td></tr><tr>
-<td><a href="#f1"><code>f1</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#f2"><code>f2</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#f3"><code>f3</code></a> </td><td><span>brief</span></td></tr><tr>
-<td><a href="#f4"><code>f4</code></a> </td><td><span>brief</span></td></tr><tr>
-<td><a href="#f5"><code>f5</code></a> </td><td><span>brief</span></td></tr>
+<td><a href="#f0"><code>f0</code></a> </td><td>brief</td></tr><tr>
+<td><a href="#f1"><code>f1</code></a> </td><td></td></tr><tr>
+<td><a href="#f2"><code>f2</code></a> </td><td></td></tr><tr>
+<td><a href="#f3"><code>f3</code></a> </td><td>brief</td></tr><tr>
+<td><a href="#f4"><code>f4</code></a> </td><td>brief</td></tr><tr>
+<td><a href="#f5"><code>f5</code></a> </td><td>brief</td></tr>
 </tbody>
 </table>
 
@@ -33,8 +33,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="f0">f0</h2>
 <div>
-<span>brief</span>
-
+<p>brief</p>
 </div>
 </div>
 <div>
@@ -43,9 +42,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-5.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -59,9 +56,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-5.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -75,9 +70,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-5.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -85,8 +78,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f3">f3</h2>
 <div>
-<span>brief</span>
-
+<p>brief</p>
 </div>
 </div>
 <div>
@@ -95,9 +87,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-5.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f3();
-
-</code>
+f3();</code>
 </pre>
 </div>
 </div>
@@ -105,8 +95,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f4">f4</h2>
 <div>
-<span>brief</span>
-
+<p>brief</p>
 </div>
 </div>
 <div>
@@ -115,9 +104,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-5.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f4();
-
-</code>
+f4();</code>
 </pre>
 </div>
 </div>
@@ -125,8 +112,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f5">f5</h2>
 <div>
-<span>brief</span>
-
+<p>brief</p>
 </div>
 </div>
 <div>
@@ -135,9 +121,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-5.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/javadoc/brief/brief-6.html b/test-files/golden-tests/javadoc/brief/brief-6.html
index 76f44e7bf..828cd5d17 100644
--- a/test-files/golden-tests/javadoc/brief/brief-6.html
+++ b/test-files/golden-tests/javadoc/brief/brief-6.html
@@ -19,7 +19,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f0"><code>f0</code></a> </td><td><span>brief</span></td></tr>
+<td><a href="#f0"><code>f0</code></a> </td><td>brief</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="f0">f0</h2>
 <div>
-<span>brief</span>
-
+<p>brief</p>
 </div>
 </div>
 <div>
@@ -38,9 +37,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;brief-6.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 <div>
diff --git a/test-files/golden-tests/javadoc/code/code.html b/test-files/golden-tests/javadoc/code/code.html
index 351de615c..d131fd881 100644
--- a/test-files/golden-tests/javadoc/code/code.html
+++ b/test-files/golden-tests/javadoc/code/code.html
@@ -19,7 +19,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>brief</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>brief</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>brief</span>
-
+<p>brief</p>
 </div>
 </div>
 <div>
@@ -38,26 +37,23 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;code.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 <div>
 <h3>Description</h3>
 <p>This description contains code:</p>
-<code>
+<code class="language-cpp">
 // code comment
 // code comment
-template < class T >
+template &lt; class T &gt;
 auto
-algorithm( T&& v = {} ) ->
+algorithm( T&amp;&amp; v = {} ) -&gt;
     typename T::result_type
 {
     return v.result();
 }
-</code>
-</div>
+</code></div>
 </div>
 
 </div>
diff --git a/test-files/golden-tests/javadoc/code/code.xml b/test-files/golden-tests/javadoc/code/code.xml
index 57c06dbd9..3b00a4f24 100644
--- a/test-files/golden-tests/javadoc/code/code.xml
+++ b/test-files/golden-tests/javadoc/code/code.xml
@@ -12,15 +12,15 @@
         <text>This description contains code:</text>
       </para>
       <code>
-        <text>// code comment</text>
-        <text>// code comment</text>
-        <text>template &lt; class T &gt;</text>
-        <text>auto</text>
-        <text>algorithm( T&amp;&amp; v = {} ) -&gt;</text>
-        <text>    typename T::result_type</text>
-        <text>{</text>
-        <text>    return v.result();</text>
-        <text>}</text>
+        <text>// code comment
+// code comment
+template &lt; class T &gt;
+auto
+algorithm( T&amp;&amp; v = {} ) -&gt;
+    typename T::result_type
+{
+    return v.result();
+}</text>
       </code>
     </doc>
   </function>
diff --git a/test-files/golden-tests/javadoc/copybrief/copybrief.html b/test-files/golden-tests/javadoc/copybrief/copybrief.html
index fedbf564a..7c1af691a 100644
--- a/test-files/golden-tests/javadoc/copybrief/copybrief.html
+++ b/test-files/golden-tests/javadoc/copybrief/copybrief.html
@@ -19,9 +19,9 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f1"><code>f1</code></a> </td><td><span>brief1</span></td></tr><tr>
-<td><a href="#f2"><code>f2</code></a> </td><td><span>brief1</span></td></tr><tr>
-<td><a href="#f3"><code>f3</code></a> </td><td><span>brief1</span></td></tr>
+<td><a href="#f1"><code>f1</code></a> </td><td>brief1</td></tr><tr>
+<td><a href="#f2"><code>f2</code></a> </td><td>brief1</td></tr><tr>
+<td><a href="#f3"><code>f3</code></a> </td><td>brief1</td></tr>
 </tbody>
 </table>
 
@@ -30,8 +30,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="f1">f1</h2>
 <div>
-<span>brief1</span>
-
+<p>brief1</p>
 </div>
 </div>
 <div>
@@ -40,9 +39,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copybrief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -50,8 +47,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f2">f2</h2>
 <div>
-<span>brief1</span>
-
+<p>brief1</p>
 </div>
 </div>
 <div>
@@ -60,9 +56,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copybrief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -70,8 +64,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f3">f3</h2>
 <div>
-<span>brief1</span>
-
+<p>brief1</p>
 </div>
 </div>
 <div>
@@ -80,9 +73,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;copybrief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f3();
-
-</code>
+f3();</code>
 </pre>
 </div>
 <div>
diff --git a/test-files/golden-tests/javadoc/copydetails/copydetails.html b/test-files/golden-tests/javadoc/copydetails/copydetails.html
index 6cc9d5da8..955345387 100644
--- a/test-files/golden-tests/javadoc/copydetails/copydetails.html
+++ b/test-files/golden-tests/javadoc/copydetails/copydetails.html
@@ -19,9 +19,9 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#dest"><code>dest</code></a> </td><td><span>Destination doc function</span></td></tr><tr>
-<td><a href="#destOverride"><code>destOverride</code></a> </td><td><span>Destination doc function</span></td></tr><tr>
-<td><a href="#source"><code>source</code></a> </td><td><span>Source doc function</span></td></tr>
+<td><a href="#dest"><code>dest</code></a> </td><td>Destination doc function</td></tr><tr>
+<td><a href="#destOverride"><code>destOverride</code></a> </td><td>Destination doc function</td></tr><tr>
+<td><a href="#source"><code>source</code></a> </td><td>Source doc function</td></tr>
 </tbody>
 </table>
 
@@ -30,8 +30,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="dest">dest</h2>
 <div>
-<span>Destination doc function</span>
-
+<p>Destination doc function</p>
 </div>
 </div>
 <div>
@@ -45,9 +44,7 @@ <h3>Synopsis</h3>
 int
 dest(
     int a,
-    int b);
-
-</code>
+    int b);</code>
 </pre>
 </div>
 <div>
@@ -58,7 +55,7 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A nice integer</span>
+A nice integer
 </div>
 <div>
 <h3>Template Parameters</h3>
@@ -72,11 +69,11 @@ <h3>Template Parameters</h3>
 <tbody>
 <tr>
 <td><strong>A</strong></td>
-<td><span>The template parameter A.</span></td>
+<td>The template parameter A.</td>
 </tr>
 <tr>
 <td><strong>B</strong></td>
-<td><span>The template parameter B.</span></td>
+<td>The template parameter B.</td>
 </tr>
 </tbody>
 </table>
@@ -93,11 +90,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The parameter a.</span></td>
+<td>The parameter a.</td>
 </tr>
 <tr>
 <td><strong>b</strong></td>
-<td><span>The parameter b.</span></td>
+<td>The parameter b.</td>
 </tr>
 </tbody>
 </table>
@@ -105,26 +102,26 @@ <h3>Parameters</h3>
 <div>
 <h3>Preconditions</h3>
 <ul>
-<li><span>a must be greater than 0.</span></li>
+<li>a must be greater than 0.</li>
 </ul>
 </div>
 <div>
 <h3>Postconditions</h3>
 <ul>
-<li><span>The return value is greater than 0.</span></li>
+<li>The return value is greater than 0.</li>
 </ul>
 </div>
 <div>
 <h3>See Also</h3>
-<p><span>dest</span></p>
+<p><p>dest</p>
+</p>
 </div>
 </div>
 <div>
 <div>
 <h2 id="destOverride">destOverride</h2>
 <div>
-<span>Destination doc function</span>
-
+<p>Destination doc function</p>
 </div>
 </div>
 <div>
@@ -140,9 +137,7 @@ <h3>Synopsis</h3>
 destOverride(
     int a,
     int c,
-    int d);
-
-</code>
+    int d);</code>
 </pre>
 </div>
 <div>
@@ -164,14 +159,14 @@ <h3>Exceptions</h3>
 <tbody>
 <tr>
 <td><code>std::runtime_error</code></td>
-<td><span>Overwrites the exception.</span></td>
+<td>Overwrites the exception.</td>
 </tr>
 </tbody>
 </table>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>An integer meaning something else.</span>
+An integer meaning something else.
 </div>
 <div>
 <h3>Template Parameters</h3>
@@ -185,15 +180,15 @@ <h3>Template Parameters</h3>
 <tbody>
 <tr>
 <td><strong>A</strong></td>
-<td><span>Overwrites the template parameter A.</span></td>
+<td>Overwrites the template parameter A.</td>
 </tr>
 <tr>
 <td><strong>C</strong></td>
-<td><span>The template parameter C.</span></td>
+<td>The template parameter C.</td>
 </tr>
 <tr>
 <td><strong>D</strong></td>
-<td><span>The template parameter D.</span></td>
+<td>The template parameter D.</td>
 </tr>
 </tbody>
 </table>
@@ -210,15 +205,15 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Overwrites the parameter a.</span></td>
+<td>Overwrites the parameter a.</td>
 </tr>
 <tr>
 <td><strong>c</strong></td>
-<td><span>The parameter c.</span></td>
+<td>The parameter c.</td>
 </tr>
 <tr>
 <td><strong>d</strong></td>
-<td><span>The parameter d.</span></td>
+<td>The parameter d.</td>
 </tr>
 </tbody>
 </table>
@@ -226,26 +221,26 @@ <h3>Parameters</h3>
 <div>
 <h3>Preconditions</h3>
 <ul>
-<li><span>overriden precondition</span></li>
+<li>overriden precondition</li>
 </ul>
 </div>
 <div>
 <h3>Postconditions</h3>
 <ul>
-<li><span>overriden postcondition</span></li>
+<li>overriden postcondition</li>
 </ul>
 </div>
 <div>
 <h3>See Also</h3>
-<p><span>source</span></p>
+<p><p>source</p>
+</p>
 </div>
 </div>
 <div>
 <div>
 <h2 id="source">source</h2>
 <div>
-<span>Source doc function</span>
-
+<p>Source doc function</p>
 </div>
 </div>
 <div>
@@ -259,9 +254,7 @@ <h3>Synopsis</h3>
 int
 source(
     int a,
-    int b);
-
-</code>
+    int b);</code>
 </pre>
 </div>
 <div>
@@ -280,14 +273,14 @@ <h3>Exceptions</h3>
 <tbody>
 <tr>
 <td><code>std::runtime_error</code></td>
-<td><span>If something goes wrong.</span></td>
+<td>If something goes wrong.</td>
 </tr>
 </tbody>
 </table>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A nice integer</span>
+A nice integer
 </div>
 <div>
 <h3>Template Parameters</h3>
@@ -301,11 +294,11 @@ <h3>Template Parameters</h3>
 <tbody>
 <tr>
 <td><strong>A</strong></td>
-<td><span>The template parameter A.</span></td>
+<td>The template parameter A.</td>
 </tr>
 <tr>
 <td><strong>B</strong></td>
-<td><span>The template parameter B.</span></td>
+<td>The template parameter B.</td>
 </tr>
 </tbody>
 </table>
@@ -322,11 +315,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The parameter a.</span></td>
+<td>The parameter a.</td>
 </tr>
 <tr>
 <td><strong>b</strong></td>
-<td><span>The parameter b.</span></td>
+<td>The parameter b.</td>
 </tr>
 </tbody>
 </table>
@@ -334,18 +327,19 @@ <h3>Parameters</h3>
 <div>
 <h3>Preconditions</h3>
 <ul>
-<li><span>a must be greater than 0.</span></li>
+<li>a must be greater than 0.</li>
 </ul>
 </div>
 <div>
 <h3>Postconditions</h3>
 <ul>
-<li><span>The return value is greater than 0.</span></li>
+<li>The return value is greater than 0.</li>
 </ul>
 </div>
 <div>
 <h3>See Also</h3>
-<p><span>dest</span></p>
+<p><p>dest</p>
+</p>
 </div>
 </div>
 
diff --git a/test-files/golden-tests/javadoc/copydoc/conversion.html b/test-files/golden-tests/javadoc/copydoc/conversion.html
index 77aba528e..5152c5e24 100644
--- a/test-files/golden-tests/javadoc/copydoc/conversion.html
+++ b/test-files/golden-tests/javadoc/copydoc/conversion.html
@@ -34,9 +34,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;conversion.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -49,9 +47,9 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-operator_assign-04"><code>operator&#x3D;</code></a> </td><td><span>Convert a string to A</span></td></tr><tr>
-<td><a href="#A-2conversion-02"><code>operator string_type</code></a> </td><td><span>Convert A to a string</span></td></tr><tr>
-<td><a href="#A-2conversion-00"><code>operator string_view_type</code></a> </td><td><span>Convert A to a string</span></td></tr>
+<td><a href="#A-operator_assign-04"><code>operator&#x3D;</code></a> </td><td>Convert a string to A</td></tr><tr>
+<td><a href="#A-2conversion-02"><code>operator string_type</code></a> </td><td>Convert A to a string</td></tr><tr>
+<td><a href="#A-2conversion-00"><code>operator string_view_type</code></a> </td><td>Convert A to a string</td></tr>
 </tbody>
 </table>
 
@@ -62,35 +60,30 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="A-operator_assign-04">A::operator&#x3D;</h2>
 <div>
-<span>Convert a string to A</span>
-
+<p>Convert a string to A</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;conversion.cpp&gt;</code></div>
-<span>Convert a string to A</span>
+<p>Convert a string to A</p>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>&
-<a href="#A-operator_assign-08">operator&#x3D;</a>(<a href="#string_type">string_type</a> const& other);
-
-</code>
+<a href="#A-operator_assign-08">operator&#x3D;</a>(<a href="#string_type">string_type</a> const& other);</code>
 </pre><span class="small"><a href="#A-operator_assign-08"><em>» more...</em></a></span>
 
-<span>Convert a string to A</span>
+<p>Convert a string to A</p>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>&
-<a href="#A-operator_assign-00">operator&#x3D;</a>(<a href="#string_view_type">string_view_type</a> const& other);
-
-</code>
+<a href="#A-operator_assign-00">operator&#x3D;</a>(<a href="#string_view_type">string_view_type</a> const& other);</code>
 </pre><span class="small"><a href="#A-operator_assign-00"><em>» more...</em></a></span>
 
 
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A representation of the string</span>
+A representation of the string
 </div>
 <div>
 <h3>Parameters</h3>
@@ -104,7 +97,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The string to convert</span></td>
+<td>The string to convert</td>
 </tr>
 </tbody>
 </table>
@@ -114,8 +107,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="A-operator_assign-08">A::operator&#x3D;</h2>
 <div>
-<span>Convert a string to A</span>
-
+<p>Convert a string to A</p>
 </div>
 </div>
 <div>
@@ -124,14 +116,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;conversion.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>&
-operator&#x3D;(<a href="#string_type">string_type</a> const& other);
-
-</code>
+operator&#x3D;(<a href="#string_type">string_type</a> const& other);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A representation of the string</span>
+A representation of the string
 </div>
 <div>
 <h3>Parameters</h3>
@@ -145,7 +135,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The string to convert</span></td>
+<td>The string to convert</td>
 </tr>
 </tbody>
 </table>
@@ -155,8 +145,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="A-operator_assign-00">A::operator&#x3D;</h2>
 <div>
-<span>Convert a string to A</span>
-
+<p>Convert a string to A</p>
 </div>
 </div>
 <div>
@@ -165,14 +154,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;conversion.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>&
-operator&#x3D;(<a href="#string_view_type">string_view_type</a> const& other);
-
-</code>
+operator&#x3D;(<a href="#string_view_type">string_view_type</a> const& other);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A representation of the string</span>
+A representation of the string
 </div>
 <div>
 <h3>Parameters</h3>
@@ -186,7 +173,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The string to convert</span></td>
+<td>The string to convert</td>
 </tr>
 </tbody>
 </table>
@@ -196,8 +183,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="A-2conversion-02">A::operator string_type</h2>
 <div>
-<span>Convert A to a string</span>
-
+<p>Convert A to a string</p>
 </div>
 </div>
 <div>
@@ -205,22 +191,19 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;conversion.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">operator <a href="#string_type">string_type</a>() const;
-
-</code>
+<code class="source-code cpp">operator <a href="#string_type">string_type</a>() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A string representation of A</span>
+A string representation of A
 </div>
 </div>
 <div>
 <div>
 <h2 id="A-2conversion-00">A::operator string_view_type</h2>
 <div>
-<span>Convert A to a string</span>
-
+<p>Convert A to a string</p>
 </div>
 </div>
 <div>
@@ -228,14 +211,12 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;conversion.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">operator <a href="#string_view_type">string_view_type</a>() const;
-
-</code>
+<code class="source-code cpp">operator <a href="#string_view_type">string_view_type</a>() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A string representation of A</span>
+A string representation of A
 </div>
 </div>
 <div>
@@ -247,9 +228,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;conversion.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class string_type;
-
-</code>
+<code class="source-code cpp">class string_type;</code>
 </pre>
 </div>
 
@@ -264,9 +243,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;conversion.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class string_view_type;
-
-</code>
+<code class="source-code cpp">class string_view_type;</code>
 </pre>
 </div>
 
diff --git a/test-files/golden-tests/javadoc/copydoc/decay-params.html b/test-files/golden-tests/javadoc/copydoc/decay-params.html
index 4cd0cb61c..e54937b47 100644
--- a/test-files/golden-tests/javadoc/copydoc/decay-params.html
+++ b/test-files/golden-tests/javadoc/copydoc/decay-params.html
@@ -19,8 +19,8 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#bar"><code>bar</code></a> </td><td><span>Brief from <code>foo()</code></span></td></tr><tr>
-<td><a href="#foo-02"><code>foo</code></a> </td><td><span><code>foo</code> overloads</span></td></tr>
+<td><a href="#bar"><code>bar</code></a> </td><td>Brief from <code>foo()</code></td></tr><tr>
+<td><a href="#foo-02"><code>foo</code></a> </td><td><code>foo</code> overloads</td></tr>
 </tbody>
 </table>
 
@@ -29,8 +29,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="bar">bar</h2>
 <div>
-<span>Brief from <code>foo()</code></span>
-
+<p>Brief from <code>foo()</code></p>
 </div>
 </div>
 <div>
@@ -40,9 +39,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">constexpr
 bool
-bar(int* a);
-
-</code>
+bar(int* a);</code>
 </pre>
 </div>
 <div>
@@ -51,7 +48,7 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A boolean value.</span>
+A boolean value.
 </div>
 <div>
 <h3>Parameters</h3>
@@ -65,7 +62,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>An array of integers.</span></td>
+<td>An array of integers.</td>
 </tr>
 </tbody>
 </table>
@@ -75,44 +72,37 @@ <h3>Parameters</h3>
 <div>
 <h2 id="foo-02">foo</h2>
 <div>
-<span><code>foo</code> overloads</span>
-
+<p><code>foo</code> overloads</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;decay-params.cpp&gt;</code></div>
-<span>We should not copy this doc</span>
+<p>We should not copy this doc</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#foo-0c">foo</a>();
-
-</code>
+<a href="#foo-0c">foo</a>();</code>
 </pre><span class="small"><a href="#foo-0c"><em>» more...</em></a></span>
 
-<span>We should not copy this doc</span>
+<p>We should not copy this doc</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#foo-01">foo</a>(int a);
-
-</code>
+<a href="#foo-01">foo</a>(int a);</code>
 </pre><span class="small"><a href="#foo-01"><em>» more...</em></a></span>
 
-<span>Brief from <code>foo()</code></span>
+<p>Brief from <code>foo()</code></p>
 <pre>
 <code class="source-code cpp">constexpr
 bool
-<a href="#foo-0e">foo</a>(int a[3]);
-
-</code>
+<a href="#foo-0e">foo</a>(int a[3]);</code>
 </pre><span class="small"><a href="#foo-0e"><em>» more...</em></a></span>
 
 
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A boolean value.</span>
+A boolean value.
 </div>
 <div>
 <h3>Parameters</h3>
@@ -126,7 +116,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>An integer.</span></td>
+<td>An integer.</td>
 </tr>
 </tbody>
 </table>
@@ -136,8 +126,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="foo-0c">foo</h2>
 <div>
-<span>We should not copy this doc</span>
-
+<p>We should not copy this doc</p>
 </div>
 </div>
 <div>
@@ -146,9 +135,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;decay-params.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-foo();
-
-</code>
+foo();</code>
 </pre>
 </div>
 <div>
@@ -160,8 +147,7 @@ <h3>Description</h3>
 <div>
 <h2 id="foo-01">foo</h2>
 <div>
-<span>We should not copy this doc</span>
-
+<p>We should not copy this doc</p>
 </div>
 </div>
 <div>
@@ -170,9 +156,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;decay-params.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-foo(int a);
-
-</code>
+foo(int a);</code>
 </pre>
 </div>
 <div>
@@ -191,7 +175,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>An integer.</span></td>
+<td>An integer.</td>
 </tr>
 </tbody>
 </table>
@@ -201,8 +185,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="foo-0e">foo</h2>
 <div>
-<span>Brief from <code>foo()</code></span>
-
+<p>Brief from <code>foo()</code></p>
 </div>
 </div>
 <div>
@@ -212,9 +195,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">constexpr
 bool
-foo(int a[3]);
-
-</code>
+foo(int a[3]);</code>
 </pre>
 </div>
 <div>
@@ -223,7 +204,7 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A boolean value.</span>
+A boolean value.
 </div>
 <div>
 <h3>Parameters</h3>
@@ -237,7 +218,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>An array of integers.</span></td>
+<td>An array of integers.</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/javadoc/copydoc/fundamental.html b/test-files/golden-tests/javadoc/copydoc/fundamental.html
index 73b03a9af..e364ef8f5 100644
--- a/test-files/golden-tests/javadoc/copydoc/fundamental.html
+++ b/test-files/golden-tests/javadoc/copydoc/fundamental.html
@@ -19,9 +19,9 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f-0c"><code>f</code></a> </td><td><span><code>f</code> overloads</span></td></tr><tr>
-<td><a href="#g"><code>g</code></a> </td><td><span>Brief</span></td></tr><tr>
-<td><a href="#h"><code>h</code></a> </td><td><span>Brief</span></td></tr>
+<td><a href="#f-0c"><code>f</code></a> </td><td><code>f</code> overloads</td></tr><tr>
+<td><a href="#g"><code>g</code></a> </td><td>Brief</td></tr><tr>
+<td><a href="#h"><code>h</code></a> </td><td>Brief</td></tr>
 </tbody>
 </table>
 
@@ -30,28 +30,23 @@ <h2>Functions</h2>
 <div>
 <h2 id="f-0c">f</h2>
 <div>
-<span><code>f</code> overloads</span>
-
+<p><code>f</code> overloads</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;fundamental.cpp&gt;</code></div>
-<span>Fail</span>
+<p>Fail</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#f-06">f</a>(int a);
-
-</code>
+<a href="#f-06">f</a>(int a);</code>
 </pre><span class="small"><a href="#f-06"><em>» more...</em></a></span>
 
-<span>Brief</span>
+<p>Brief</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#f-04">f</a>(long a);
-
-</code>
+<a href="#f-04">f</a>(long a);</code>
 </pre><span class="small"><a href="#f-04"><em>» more...</em></a></span>
 
 
@@ -68,7 +63,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Fail param</span></td>
+<td>Fail param</td>
 </tr>
 </tbody>
 </table>
@@ -78,8 +73,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="f-06">f</h2>
 <div>
-<span>Fail</span>
-
+<p>Fail</p>
 </div>
 </div>
 <div>
@@ -88,9 +82,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;fundamental.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(int a);
-
-</code>
+f(int a);</code>
 </pre>
 </div>
 <div>
@@ -105,7 +97,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Fail param</span></td>
+<td>Fail param</td>
 </tr>
 </tbody>
 </table>
@@ -115,8 +107,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="f-04">f</h2>
 <div>
-<span>Brief</span>
-
+<p>Brief</p>
 </div>
 </div>
 <div>
@@ -125,9 +116,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;fundamental.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(long a);
-
-</code>
+f(long a);</code>
 </pre>
 </div>
 <div>
@@ -146,7 +135,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Param description</span></td>
+<td>Param description</td>
 </tr>
 </tbody>
 </table>
@@ -156,8 +145,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="g">g</h2>
 <div>
-<span>Brief</span>
-
+<p>Brief</p>
 </div>
 </div>
 <div>
@@ -166,9 +154,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;fundamental.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g(long a);
-
-</code>
+g(long a);</code>
 </pre>
 </div>
 <div>
@@ -187,7 +173,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Param description</span></td>
+<td>Param description</td>
 </tr>
 </tbody>
 </table>
@@ -197,8 +183,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="h">h</h2>
 <div>
-<span>Brief</span>
-
+<p>Brief</p>
 </div>
 </div>
 <div>
@@ -207,9 +192,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;fundamental.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h(long a);
-
-</code>
+h(long a);</code>
 </pre>
 </div>
 <div>
@@ -228,7 +211,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Param description</span></td>
+<td>Param description</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/javadoc/copydoc/no-param.html b/test-files/golden-tests/javadoc/copydoc/no-param.html
index 3151a787f..03b44d62d 100644
--- a/test-files/golden-tests/javadoc/copydoc/no-param.html
+++ b/test-files/golden-tests/javadoc/copydoc/no-param.html
@@ -19,9 +19,9 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#copyFromNoParam"><code>copyFromNoParam</code></a> </td><td><span>Brief from <code>foo()</code></span></td></tr><tr>
-<td><a href="#copyfromOverloads"><code>copyfromOverloads</code></a> </td><td><span>Brief from <code>foo()</code></span></td></tr><tr>
-<td><a href="#foo-02"><code>foo</code></a> </td><td><span>Brief from <code>foo()</code></span></td></tr>
+<td><a href="#copyFromNoParam"><code>copyFromNoParam</code></a> </td><td>Brief from <code>foo()</code></td></tr><tr>
+<td><a href="#copyfromOverloads"><code>copyfromOverloads</code></a> </td><td>Brief from <code>foo()</code></td></tr><tr>
+<td><a href="#foo-02"><code>foo</code></a> </td><td>Brief from <code>foo()</code></td></tr>
 </tbody>
 </table>
 
@@ -30,8 +30,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="copyFromNoParam">copyFromNoParam</h2>
 <div>
-<span>Brief from <code>foo()</code></span>
-
+<p>Brief from <code>foo()</code></p>
 </div>
 </div>
 <div>
@@ -41,9 +40,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">constexpr
 bool
-copyFromNoParam();
-
-</code>
+copyFromNoParam();</code>
 </pre>
 </div>
 <div>
@@ -53,15 +50,14 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A boolean value.</span>
+A boolean value.
 </div>
 </div>
 <div>
 <div>
 <h2 id="copyfromOverloads">copyfromOverloads</h2>
 <div>
-<span>Brief from <code>foo()</code></span>
-
+<p>Brief from <code>foo()</code></p>
 </div>
 </div>
 <div>
@@ -71,9 +67,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">constexpr
 bool
-copyfromOverloads();
-
-</code>
+copyfromOverloads();</code>
 </pre>
 </div>
 <div>
@@ -82,44 +76,39 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A boolean value.</span>
+A boolean value.
 </div>
 </div>
 <div>
 <div>
 <h2 id="foo-02">foo</h2>
 <div>
-<span>Brief from <code>foo()</code></span>
-
+<p>Brief from <code>foo()</code></p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;no-param.cpp&gt;</code></div>
-<span>Brief from <code>foo()</code></span>
+<p>Brief from <code>foo()</code></p>
 <pre>
 <code class="source-code cpp">constexpr
 bool
-<a href="#foo-0c">foo</a>();
-
-</code>
+<a href="#foo-0c">foo</a>();</code>
 </pre><span class="small"><a href="#foo-0c"><em>» more...</em></a></span>
 
-<span>Brief from <code>foo()</code></span>
+<p>Brief from <code>foo()</code></p>
 <pre>
 <code class="source-code cpp">constexpr
 bool
-<a href="#foo-0a">foo</a>(char ch);
-
-</code>
+<a href="#foo-0a">foo</a>(char ch);</code>
 </pre><span class="small"><a href="#foo-0a"><em>» more...</em></a></span>
 
 
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A boolean value.</span>
+A boolean value.
 </div>
 <div>
 <h3>Parameters</h3>
@@ -133,7 +122,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>ch</strong></td>
-<td><span>A character.</span></td>
+<td>A character.</td>
 </tr>
 </tbody>
 </table>
@@ -143,8 +132,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="foo-0c">foo</h2>
 <div>
-<span>Brief from <code>foo()</code></span>
-
+<p>Brief from <code>foo()</code></p>
 </div>
 </div>
 <div>
@@ -154,9 +142,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">constexpr
 bool
-foo();
-
-</code>
+foo();</code>
 </pre>
 </div>
 <div>
@@ -165,15 +151,14 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A boolean value.</span>
+A boolean value.
 </div>
 </div>
 <div>
 <div>
 <h2 id="foo-0a">foo</h2>
 <div>
-<span>Brief from <code>foo()</code></span>
-
+<p>Brief from <code>foo()</code></p>
 </div>
 </div>
 <div>
@@ -183,9 +168,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">constexpr
 bool
-foo(char ch);
-
-</code>
+foo(char ch);</code>
 </pre>
 </div>
 <div>
@@ -194,7 +177,7 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A boolean value.</span>
+A boolean value.
 </div>
 <div>
 <h3>Parameters</h3>
@@ -208,7 +191,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>ch</strong></td>
-<td><span>A character.</span></td>
+<td>A character.</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/javadoc/copydoc/operator-param.html b/test-files/golden-tests/javadoc/copydoc/operator-param.html
index 62c5ec86b..101eafeee 100644
--- a/test-files/golden-tests/javadoc/copydoc/operator-param.html
+++ b/test-files/golden-tests/javadoc/copydoc/operator-param.html
@@ -32,9 +32,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;operator-param.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -47,7 +45,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-operator_call-08"><code>operator()</code></a> </td><td><span>Return true if ch is in the character set.</span></td></tr>
+<td><a href="#A-operator_call-08"><code>operator()</code></a> </td><td>Return true if ch is in the character set.</td></tr>
 </tbody>
 </table>
 
@@ -58,37 +56,32 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="A-operator_call-08">A::operator()</h2>
 <div>
-<span>Return true if ch is in the character set.</span>
-
+<p>Return true if ch is in the character set.</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;operator-param.cpp&gt;</code></div>
-<span>Return true if ch is in the character set.</span>
+<p>Return true if ch is in the character set.</p>
 <pre>
 <code class="source-code cpp">constexpr
 bool
-<a href="#A-operator_call-0f">operator()</a>(char ch) const noexcept;
-
-</code>
+<a href="#A-operator_call-0f">operator()</a>(char ch) const noexcept;</code>
 </pre><span class="small"><a href="#A-operator_call-0f"><em>» more...</em></a></span>
 
-<span>Return true if ch is in the character set.</span>
+<p>Return true if ch is in the character set.</p>
 <pre>
 <code class="source-code cpp">constexpr
 bool
-<a href="#A-operator_call-0b">operator()</a>(unsigned char ch) const noexcept;
-
-</code>
+<a href="#A-operator_call-0b">operator()</a>(unsigned char ch) const noexcept;</code>
 </pre><span class="small"><a href="#A-operator_call-0b"><em>» more...</em></a></span>
 
 
 </div>
 <div>
 <h3>Return Value</h3>
-<span>True if ch is in the set, otherwise false.</span>
+True if ch is in the set, otherwise false.
 </div>
 <div>
 <h3>Parameters</h3>
@@ -102,7 +95,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>ch</strong></td>
-<td><span>The signed character to test.</span></td>
+<td>The signed character to test.</td>
 </tr>
 </tbody>
 </table>
@@ -112,8 +105,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="A-operator_call-0f">A::operator()</h2>
 <div>
-<span>Return true if ch is in the character set.</span>
-
+<p>Return true if ch is in the character set.</p>
 </div>
 </div>
 <div>
@@ -123,9 +115,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">constexpr
 bool
-operator()(char ch) const noexcept;
-
-</code>
+operator()(char ch) const noexcept;</code>
 </pre>
 </div>
 <div>
@@ -134,7 +124,7 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>True if ch is in the set, otherwise false.</span>
+True if ch is in the set, otherwise false.
 </div>
 <div>
 <h3>Parameters</h3>
@@ -148,7 +138,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>ch</strong></td>
-<td><span>The signed character to test.</span></td>
+<td>The signed character to test.</td>
 </tr>
 </tbody>
 </table>
@@ -158,8 +148,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="A-operator_call-0b">A::operator()</h2>
 <div>
-<span>Return true if ch is in the character set.</span>
-
+<p>Return true if ch is in the character set.</p>
 </div>
 </div>
 <div>
@@ -169,9 +158,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">constexpr
 bool
-operator()(unsigned char ch) const noexcept;
-
-</code>
+operator()(unsigned char ch) const noexcept;</code>
 </pre>
 </div>
 <div>
@@ -180,7 +167,7 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>True if ch is in the set, otherwise false.</span>
+True if ch is in the set, otherwise false.
 </div>
 <div>
 <h3>Parameters</h3>
@@ -194,7 +181,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>ch</strong></td>
-<td><span>The unsigned character to test.</span></td>
+<td>The unsigned character to test.</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/javadoc/copydoc/param-types.adoc b/test-files/golden-tests/javadoc/copydoc/param-types.adoc
index f1482b4ef..4e55b48dc 100644
--- a/test-files/golden-tests/javadoc/copydoc/param-types.adoc
+++ b/test-files/golden-tests/javadoc/copydoc/param-types.adoc
@@ -28,12 +28,10 @@
 
 === Enums
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#testEnum[`testEnum`] 
-| 
 |===
 
 === Functions
diff --git a/test-files/golden-tests/javadoc/copydoc/param-types.html b/test-files/golden-tests/javadoc/copydoc/param-types.html
index 66e84ee33..8643bebd6 100644
--- a/test-files/golden-tests/javadoc/copydoc/param-types.html
+++ b/test-files/golden-tests/javadoc/copydoc/param-types.html
@@ -19,7 +19,7 @@ <h2>Namespaces</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#N"><code>N</code></a> </td><td><span>Namespace to test qualified identifier parameters.</span></td></tr>
+<td><a href="#N"><code>N</code></a> </td><td>Namespace to test qualified identifier parameters.</td></tr>
 </tbody>
 </table>
 
@@ -33,8 +33,8 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A"><code>A</code></a> </td><td><span>Struct to test explicit object member functions.</span></td></tr><tr>
-<td><a href="#paramType"><code>paramType</code></a> </td><td><span>Struct used to vary the parameter type.</span></td></tr>
+<td><a href="#A"><code>A</code></a> </td><td>Struct to test explicit object member functions.</td></tr><tr>
+<td><a href="#paramType"><code>paramType</code></a> </td><td>Struct used to vary the parameter type.</td></tr>
 </tbody>
 </table>
 
@@ -43,12 +43,11 @@ <h2>Enums</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#testEnum"><code>testEnum</code></a> </td><td><span></span></td></tr>
+<td><a href="#testEnum"><code>testEnum</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -62,8 +61,8 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f-0c7"><code>f</code></a> </td><td><span><code>f</code> overloads</span></td></tr><tr>
-<td><a href="#g-0f"><code>g</code></a> </td><td><span><code>g</code> overloads</span></td></tr>
+<td><a href="#f-0c7"><code>f</code></a> </td><td><code>f</code> overloads</td></tr><tr>
+<td><a href="#g-0f"><code>g</code></a> </td><td><code>g</code> overloads</td></tr>
 </tbody>
 </table>
 
@@ -72,8 +71,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="N">N</h2>
 <div>
-<span>Namespace to test qualified identifier parameters.</span>
-
+<p>Namespace to test qualified identifier parameters.</p>
 </div>
 </div>
 <h2>Namespaces</h2>
@@ -86,7 +84,7 @@ <h2>Namespaces</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#N-M"><code>M</code></a> </td><td><span>Namespace to test qualified identifier parameters.</span></td></tr>
+<td><a href="#N-M"><code>M</code></a> </td><td>Namespace to test qualified identifier parameters.</td></tr>
 </tbody>
 </table>
 
@@ -95,8 +93,7 @@ <h2>Namespaces</h2>
 <div>
 <h2 id="N-M">N::M</h2>
 <div>
-<span>Namespace to test qualified identifier parameters.</span>
-
+<p>Namespace to test qualified identifier parameters.</p>
 </div>
 </div>
 <h2>Types</h2>
@@ -109,7 +106,7 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#N-M-Q"><code>Q</code></a> </td><td><span>Struct to test qualified identifier parameters.</span></td></tr>
+<td><a href="#N-M-Q"><code>Q</code></a> </td><td>Struct to test qualified identifier parameters.</td></tr>
 </tbody>
 </table>
 
@@ -118,8 +115,7 @@ <h2>Types</h2>
 <div>
 <h2 id="N-M-Q">N::M::Q</h2>
 <div>
-<span>Struct to test qualified identifier parameters.</span>
-
+<p>Struct to test qualified identifier parameters.</p>
 </div>
 </div>
 <div>
@@ -127,9 +123,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct Q;
-
-</code>
+<code class="source-code cpp">struct Q;</code>
 </pre>
 </div>
 
@@ -144,7 +138,7 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#g-09c"><code>::g</code></a></td><td><span>Qualified identifier param function</span></td></tr>
+<tr><td><a href="#g-09c"><code>::g</code></a></td><td>Qualified identifier param function</td></tr>
 </tbody>
 </table>
 </div>
@@ -153,8 +147,7 @@ <h2>Non-Member Functions</h2>
 <div>
 <h2 id="A">A</h2>
 <div>
-<span>Struct to test explicit object member functions.</span>
-
+<p>Struct to test explicit object member functions.</p>
 </div>
 </div>
 <div>
@@ -162,9 +155,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -177,8 +168,8 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-f"><code>f</code></a> </td><td><span>Reference member function.</span></td></tr><tr>
-<td><a href="#A-g"><code>g</code></a> </td><td><span>Reference member function.</span></td></tr>
+<td><a href="#A-f"><code>f</code></a> </td><td>Reference member function.</td></tr><tr>
+<td><a href="#A-g"><code>g</code></a> </td><td>Reference member function.</td></tr>
 </tbody>
 </table>
 
@@ -194,7 +185,7 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#g-05"><code>g</code></a></td><td><span>struct param function</span></td></tr>
+<tr><td><a href="#g-05"><code>g</code></a></td><td>struct param function</td></tr>
 </tbody>
 </table>
 </div>
@@ -203,8 +194,7 @@ <h2>Non-Member Functions</h2>
 <div>
 <h2 id="A-f">A::f</h2>
 <div>
-<span>Reference member function.</span>
-
+<p>Reference member function.</p>
 </div>
 </div>
 <div>
@@ -213,9 +203,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#paramType">paramType&lt;4&gt;</a> a);
-
-</code>
+f(<a href="#paramType">paramType&lt;4&gt;</a> a);</code>
 </pre>
 </div>
 <div>
@@ -235,7 +223,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of g</span></td>
+<td>The first parameter of g</td>
 </tr>
 </tbody>
 </table>
@@ -245,8 +233,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="A-g">A::g</h2>
 <div>
-<span>Reference member function.</span>
-
+<p>Reference member function.</p>
 </div>
 </div>
 <div>
@@ -257,9 +244,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">void
 g(this 
     <a href="#A">A</a>& self,
-    int a);
-
-</code>
+    int a);</code>
 </pre>
 </div>
 <div>
@@ -278,11 +263,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>self</strong></td>
-<td><span>The object to operate on</span></td>
+<td>The object to operate on</td>
 </tr>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of g</span></td>
+<td>The first parameter of g</td>
 </tr>
 </tbody>
 </table>
@@ -292,8 +277,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="paramType">paramType</h2>
 <div>
-<span>Struct used to vary the parameter type.</span>
-
+<p>Struct used to vary the parameter type.</p>
 </div>
 </div>
 <div>
@@ -302,9 +286,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;int Idx&gt;
-struct paramType;
-
-</code>
+struct paramType;</code>
 </pre>
 </div>
 
@@ -319,15 +301,15 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#f-00"><code>f</code></a></td><td><span>Reference function.</span></td></tr>
-<tr><td><a href="#f-010"><code>f</code></a></td><td><span>Enum param function</span></td></tr>
-<tr><td><a href="#f-012"><code>f</code></a></td><td><span>Variadic function</span></td></tr>
-<tr><td><a href="#f-03"><code>f</code></a></td><td><span>struct param function</span></td></tr>
-<tr><td><a href="#f-04"><code>f</code></a></td><td><span>Decltype function</span></td></tr>
-<tr><td><a href="#f-081"><code>f</code></a></td><td><span>Qualified identifier param function</span></td></tr>
-<tr><td><a href="#f-08c"><code>f</code></a></td><td><span>Reference function.</span></td></tr>
-<tr><td><a href="#f-0b5"><code>f</code></a></td><td><span>struct param function</span></td></tr>
-<tr><td><a href="#f-0c1"><code>f</code></a></td><td><span>Non-variadic function</span></td></tr>
+<tr><td><a href="#f-00"><code>f</code></a></td><td>Reference function.</td></tr>
+<tr><td><a href="#f-010"><code>f</code></a></td><td>Enum param function</td></tr>
+<tr><td><a href="#f-012"><code>f</code></a></td><td>Variadic function</td></tr>
+<tr><td><a href="#f-03"><code>f</code></a></td><td>struct param function</td></tr>
+<tr><td><a href="#f-04"><code>f</code></a></td><td>Decltype function</td></tr>
+<tr><td><a href="#f-081"><code>f</code></a></td><td>Qualified identifier param function</td></tr>
+<tr><td><a href="#f-08c"><code>f</code></a></td><td>Reference function.</td></tr>
+<tr><td><a href="#f-0b5"><code>f</code></a></td><td>struct param function</td></tr>
+<tr><td><a href="#f-0c1"><code>f</code></a></td><td>Non-variadic function</td></tr>
 </tbody>
 </table>
 </div>
@@ -341,9 +323,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">enum testEnum;
-
-</code>
+<code class="source-code cpp">enum testEnum;</code>
 </pre>
 </div>
 <div>
@@ -356,7 +336,7 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#g-04c"><code>g</code></a></td><td><span>Enum param function</span></td></tr>
+<tr><td><a href="#g-04c"><code>g</code></a></td><td>Enum param function</td></tr>
 </tbody>
 </table>
 </div>
@@ -365,92 +345,71 @@ <h2>Non-Member Functions</h2>
 <div>
 <h2 id="f-0c7">f</h2>
 <div>
-<span><code>f</code> overloads</span>
-
+<p><code>f</code> overloads</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
-<span>Reference function.</span>
+<p>Reference function.</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#f-0b3">f</a>();
-
-</code>
+<a href="#f-0b3">f</a>();</code>
 </pre><span class="small"><a href="#f-0b3"><em>» more...</em></a></span>
 
-<span>Reference function.</span>
+<p>Reference function.</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#f-00">f</a>(<a href="#paramType">paramType&lt;0&gt;</a> a);
-
-</code>
+<a href="#f-00">f</a>(<a href="#paramType">paramType&lt;0&gt;</a> a);</code>
 </pre><span class="small"><a href="#f-00"><em>» more...</em></a></span>
 
-<span>Reference function.</span>
+<p>Reference function.</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#f-08c">f</a>(<a href="#paramType">paramType&lt;1&gt;</a> a);
-
-</code>
+<a href="#f-08c">f</a>(<a href="#paramType">paramType&lt;1&gt;</a> a);</code>
 </pre><span class="small"><a href="#f-08c"><em>» more...</em></a></span>
 
-<span>Variadic function</span>
+<p>Variadic function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#f-012">f</a>(<a href="#paramType">paramType&lt;2&gt;</a> a);
-
-</code>
+<a href="#f-012">f</a>(<a href="#paramType">paramType&lt;2&gt;</a> a);</code>
 </pre><span class="small"><a href="#f-012"><em>» more...</em></a></span>
 
-<span>Non-variadic function</span>
+<p>Non-variadic function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#f-0c1">f</a>(<a href="#paramType">paramType&lt;3&gt;</a> a);
-
-</code>
+<a href="#f-0c1">f</a>(<a href="#paramType">paramType&lt;3&gt;</a> a);</code>
 </pre><span class="small"><a href="#f-0c1"><em>» more...</em></a></span>
 
-<span>struct param function</span>
+<p>struct param function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#f-03">f</a>(<a href="#paramType">paramType&lt;5&gt;</a> a);
-
-</code>
+<a href="#f-03">f</a>(<a href="#paramType">paramType&lt;5&gt;</a> a);</code>
 </pre><span class="small"><a href="#f-03"><em>» more...</em></a></span>
 
-<span>Decltype function</span>
+<p>Decltype function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#f-04">f</a>(<a href="#paramType">paramType&lt;6&gt;</a> a);
-
-</code>
+<a href="#f-04">f</a>(<a href="#paramType">paramType&lt;6&gt;</a> a);</code>
 </pre><span class="small"><a href="#f-04"><em>» more...</em></a></span>
 
-<span>struct param function</span>
+<p>struct param function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#f-0b5">f</a>(<a href="#paramType">paramType&lt;7&gt;</a> a);
-
-</code>
+<a href="#f-0b5">f</a>(<a href="#paramType">paramType&lt;7&gt;</a> a);</code>
 </pre><span class="small"><a href="#f-0b5"><em>» more...</em></a></span>
 
-<span>Enum param function</span>
+<p>Enum param function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#f-010">f</a>(<a href="#paramType">paramType&lt;8&gt;</a> a);
-
-</code>
+<a href="#f-010">f</a>(<a href="#paramType">paramType&lt;8&gt;</a> a);</code>
 </pre><span class="small"><a href="#f-010"><em>» more...</em></a></span>
 
-<span>Qualified identifier param function</span>
+<p>Qualified identifier param function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#f-081">f</a>(<a href="#paramType">paramType&lt;9&gt;</a> a);
-
-</code>
+<a href="#f-081">f</a>(<a href="#paramType">paramType&lt;9&gt;</a> a);</code>
 </pre><span class="small"><a href="#f-081"><em>» more...</em></a></span>
 
 
@@ -467,7 +426,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of f</span></td>
+<td>The first parameter of f</td>
 </tr>
 </tbody>
 </table>
@@ -477,8 +436,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="f-0b3">f</h2>
 <div>
-<span>Reference function.</span>
-
+<p>Reference function.</p>
 </div>
 </div>
 <div>
@@ -487,9 +445,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 <div>
@@ -501,8 +457,7 @@ <h3>Description</h3>
 <div>
 <h2 id="f-00">f</h2>
 <div>
-<span>Reference function.</span>
-
+<p>Reference function.</p>
 </div>
 </div>
 <div>
@@ -511,9 +466,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#paramType">paramType&lt;0&gt;</a> a);
-
-</code>
+f(<a href="#paramType">paramType&lt;0&gt;</a> a);</code>
 </pre>
 </div>
 <div>
@@ -533,7 +486,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of f</span></td>
+<td>The first parameter of f</td>
 </tr>
 </tbody>
 </table>
@@ -543,8 +496,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="f-08c">f</h2>
 <div>
-<span>Reference function.</span>
-
+<p>Reference function.</p>
 </div>
 </div>
 <div>
@@ -553,9 +505,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#paramType">paramType&lt;1&gt;</a> a);
-
-</code>
+f(<a href="#paramType">paramType&lt;1&gt;</a> a);</code>
 </pre>
 </div>
 <div>
@@ -575,7 +525,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of f</span></td>
+<td>The first parameter of f</td>
 </tr>
 </tbody>
 </table>
@@ -585,8 +535,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="f-012">f</h2>
 <div>
-<span>Variadic function</span>
-
+<p>Variadic function</p>
 </div>
 </div>
 <div>
@@ -595,9 +544,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#paramType">paramType&lt;2&gt;</a> a);
-
-</code>
+f(<a href="#paramType">paramType&lt;2&gt;</a> a);</code>
 </pre>
 </div>
 <div>
@@ -617,7 +564,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of g</span></td>
+<td>The first parameter of g</td>
 </tr>
 </tbody>
 </table>
@@ -627,8 +574,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="f-0c1">f</h2>
 <div>
-<span>Non-variadic function</span>
-
+<p>Non-variadic function</p>
 </div>
 </div>
 <div>
@@ -637,9 +583,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#paramType">paramType&lt;3&gt;</a> a);
-
-</code>
+f(<a href="#paramType">paramType&lt;3&gt;</a> a);</code>
 </pre>
 </div>
 <div>
@@ -659,7 +603,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of g</span></td>
+<td>The first parameter of g</td>
 </tr>
 </tbody>
 </table>
@@ -669,8 +613,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="f-03">f</h2>
 <div>
-<span>struct param function</span>
-
+<p>struct param function</p>
 </div>
 </div>
 <div>
@@ -679,9 +622,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#paramType">paramType&lt;5&gt;</a> a);
-
-</code>
+f(<a href="#paramType">paramType&lt;5&gt;</a> a);</code>
 </pre>
 </div>
 <div>
@@ -701,7 +642,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of g</span></td>
+<td>The first parameter of g</td>
 </tr>
 </tbody>
 </table>
@@ -711,8 +652,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="f-04">f</h2>
 <div>
-<span>Decltype function</span>
-
+<p>Decltype function</p>
 </div>
 </div>
 <div>
@@ -721,9 +661,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#paramType">paramType&lt;6&gt;</a> a);
-
-</code>
+f(<a href="#paramType">paramType&lt;6&gt;</a> a);</code>
 </pre>
 </div>
 <div>
@@ -743,7 +681,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of g</span></td>
+<td>The first parameter of g</td>
 </tr>
 </tbody>
 </table>
@@ -753,8 +691,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="f-0b5">f</h2>
 <div>
-<span>struct param function</span>
-
+<p>struct param function</p>
 </div>
 </div>
 <div>
@@ -763,9 +700,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#paramType">paramType&lt;7&gt;</a> a);
-
-</code>
+f(<a href="#paramType">paramType&lt;7&gt;</a> a);</code>
 </pre>
 </div>
 <div>
@@ -785,7 +720,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of g</span></td>
+<td>The first parameter of g</td>
 </tr>
 </tbody>
 </table>
@@ -795,8 +730,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="f-010">f</h2>
 <div>
-<span>Enum param function</span>
-
+<p>Enum param function</p>
 </div>
 </div>
 <div>
@@ -805,9 +739,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#paramType">paramType&lt;8&gt;</a> a);
-
-</code>
+f(<a href="#paramType">paramType&lt;8&gt;</a> a);</code>
 </pre>
 </div>
 <div>
@@ -827,7 +759,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of g</span></td>
+<td>The first parameter of g</td>
 </tr>
 </tbody>
 </table>
@@ -837,8 +769,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="f-081">f</h2>
 <div>
-<span>Qualified identifier param function</span>
-
+<p>Qualified identifier param function</p>
 </div>
 </div>
 <div>
@@ -847,9 +778,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#paramType">paramType&lt;9&gt;</a> a);
-
-</code>
+f(<a href="#paramType">paramType&lt;9&gt;</a> a);</code>
 </pre>
 </div>
 <div>
@@ -869,7 +798,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of g</span></td>
+<td>The first parameter of g</td>
 </tr>
 </tbody>
 </table>
@@ -879,70 +808,55 @@ <h3>Parameters</h3>
 <div>
 <h2 id="g-0f">g</h2>
 <div>
-<span><code>g</code> overloads</span>
-
+<p><code>g</code> overloads</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
-<span>struct param function</span>
+<p>struct param function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#g-05">g</a>(<a href="#A">A</a> a);
-
-</code>
+<a href="#g-05">g</a>(<a href="#A">A</a> a);</code>
 </pre><span class="small"><a href="#g-05"><em>» more...</em></a></span>
 
-<span>Qualified identifier param function</span>
+<p>Qualified identifier param function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#g-09c">g</a>(<a href="#N-M-Q">N::M::Q</a> a);
-
-</code>
+<a href="#g-09c">g</a>(<a href="#N-M-Q">N::M::Q</a> a);</code>
 </pre><span class="small"><a href="#g-09c"><em>» more...</em></a></span>
 
-<span>Auto function</span>
+<p>Auto function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#g-0b">g</a>(auto a);
-
-</code>
+<a href="#g-0b">g</a>(auto a);</code>
 </pre><span class="small"><a href="#g-0b"><em>» more...</em></a></span>
 
-<span>Enum param function</span>
+<p>Enum param function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#g-04c">g</a>(<a href="#testEnum">testEnum</a> a);
-
-</code>
+<a href="#g-04c">g</a>(<a href="#testEnum">testEnum</a> a);</code>
 </pre><span class="small"><a href="#g-04c"><em>» more...</em></a></span>
 
-<span>Variadic function</span>
+<p>Variadic function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#g-096">g</a>(int a, ...);
-
-</code>
+<a href="#g-096">g</a>(int a, ...);</code>
 </pre><span class="small"><a href="#g-096"><em>» more...</em></a></span>
 
-<span>Non-variadic function</span>
+<p>Non-variadic function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#g-04a">g</a>(int a);
-
-</code>
+<a href="#g-04a">g</a>(int a);</code>
 </pre><span class="small"><a href="#g-04a"><em>» more...</em></a></span>
 
-<span>Decltype function</span>
+<p>Decltype function</p>
 <pre>
 <code class="source-code cpp">void
 <a href="#g-0c">g</a>(
     int a,
-    decltype(a) b);
-
-</code>
+    decltype(a) b);</code>
 </pre><span class="small"><a href="#g-0c"><em>» more...</em></a></span>
 
 
@@ -959,11 +873,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of g</span></td>
+<td>The first parameter of g</td>
 </tr>
 <tr>
 <td><strong>b</strong></td>
-<td><span>The second parameter of g</span></td>
+<td>The second parameter of g</td>
 </tr>
 </tbody>
 </table>
@@ -973,8 +887,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="g-05">g</h2>
 <div>
-<span>struct param function</span>
-
+<p>struct param function</p>
 </div>
 </div>
 <div>
@@ -983,9 +896,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g(<a href="#A">A</a> a);
-
-</code>
+g(<a href="#A">A</a> a);</code>
 </pre>
 </div>
 <div>
@@ -1004,7 +915,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of g</span></td>
+<td>The first parameter of g</td>
 </tr>
 </tbody>
 </table>
@@ -1014,8 +925,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="g-09c">g</h2>
 <div>
-<span>Qualified identifier param function</span>
-
+<p>Qualified identifier param function</p>
 </div>
 </div>
 <div>
@@ -1024,9 +934,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g(<a href="#N-M-Q">N::M::Q</a> a);
-
-</code>
+g(<a href="#N-M-Q">N::M::Q</a> a);</code>
 </pre>
 </div>
 <div>
@@ -1045,7 +953,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of g</span></td>
+<td>The first parameter of g</td>
 </tr>
 </tbody>
 </table>
@@ -1055,8 +963,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="g-0b">g</h2>
 <div>
-<span>Auto function</span>
-
+<p>Auto function</p>
 </div>
 </div>
 <div>
@@ -1065,9 +972,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g(auto a);
-
-</code>
+g(auto a);</code>
 </pre>
 </div>
 <div>
@@ -1086,7 +991,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of g</span></td>
+<td>The first parameter of g</td>
 </tr>
 </tbody>
 </table>
@@ -1096,8 +1001,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="g-04c">g</h2>
 <div>
-<span>Enum param function</span>
-
+<p>Enum param function</p>
 </div>
 </div>
 <div>
@@ -1106,9 +1010,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g(<a href="#testEnum">testEnum</a> a);
-
-</code>
+g(<a href="#testEnum">testEnum</a> a);</code>
 </pre>
 </div>
 <div>
@@ -1127,7 +1029,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of g</span></td>
+<td>The first parameter of g</td>
 </tr>
 </tbody>
 </table>
@@ -1137,8 +1039,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="g-096">g</h2>
 <div>
-<span>Variadic function</span>
-
+<p>Variadic function</p>
 </div>
 </div>
 <div>
@@ -1147,9 +1048,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g(int a, ...);
-
-</code>
+g(int a, ...);</code>
 </pre>
 </div>
 <div>
@@ -1168,7 +1067,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of g</span></td>
+<td>The first parameter of g</td>
 </tr>
 </tbody>
 </table>
@@ -1178,8 +1077,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="g-04a">g</h2>
 <div>
-<span>Non-variadic function</span>
-
+<p>Non-variadic function</p>
 </div>
 </div>
 <div>
@@ -1188,9 +1086,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-types.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g(int a);
-
-</code>
+g(int a);</code>
 </pre>
 </div>
 <div>
@@ -1209,7 +1105,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of g</span></td>
+<td>The first parameter of g</td>
 </tr>
 </tbody>
 </table>
@@ -1219,8 +1115,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="g-0c">g</h2>
 <div>
-<span>Decltype function</span>
-
+<p>Decltype function</p>
 </div>
 </div>
 <div>
@@ -1231,9 +1126,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">void
 g(
     int a,
-    decltype(a) b);
-
-</code>
+    decltype(a) b);</code>
 </pre>
 </div>
 <div>
@@ -1252,11 +1145,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter of g</span></td>
+<td>The first parameter of g</td>
 </tr>
 <tr>
 <td><strong>b</strong></td>
-<td><span>The second parameter of g</span></td>
+<td>The second parameter of g</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/javadoc/copydoc/qualified.html b/test-files/golden-tests/javadoc/copydoc/qualified.html
index 32607e767..cba3c4c46 100644
--- a/test-files/golden-tests/javadoc/copydoc/qualified.html
+++ b/test-files/golden-tests/javadoc/copydoc/qualified.html
@@ -32,7 +32,7 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#param_t"><code>param_t</code></a> </td><td><span>Helper class for distinct parameter types</span></td></tr>
+<td><a href="#param_t"><code>param_t</code></a> </td><td>Helper class for distinct parameter types</td></tr>
 </tbody>
 </table>
 
@@ -64,9 +64,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -92,9 +90,9 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#N-A-f-05"><code>f</code></a> </td><td><span>Reference function</span></td></tr><tr>
-<td><a href="#N-A-g-06e"><code>g</code></a> </td><td><span><code>g</code> overloads</span></td></tr><tr>
-<td><a href="#N-A-h-05"><code>h</code></a> </td><td><span><code>h</code> overloads</span></td></tr>
+<td><a href="#N-A-f-05"><code>f</code></a> </td><td>Reference function</td></tr><tr>
+<td><a href="#N-A-g-06e"><code>g</code></a> </td><td><code>g</code> overloads</td></tr><tr>
+<td><a href="#N-A-h-05"><code>h</code></a> </td><td><code>h</code> overloads</td></tr>
 </tbody>
 </table>
 
@@ -110,9 +108,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct B;
-
-</code>
+<code class="source-code cpp">struct B;</code>
 </pre>
 </div>
 
@@ -122,76 +118,59 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="N-A-f-05">N::A::f</h2>
 <div>
-<span>Reference function</span>
-
+<p>Reference function</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
-<span>Reference function</span>
+<p>Reference function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#N-A-f-0a">f</a>(<a href="#param_t">param_t&lt;0&gt;</a> a);
-
-</code>
+<a href="#N-A-f-0a">f</a>(<a href="#param_t">param_t&lt;0&gt;</a> a);</code>
 </pre><span class="small"><a href="#N-A-f-0a"><em>» more...</em></a></span>
 
-<span>Reference function</span>
+<p>Reference function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#N-A-f-0b">f</a>(<a href="#param_t">param_t&lt;1&gt;</a> a);
-
-</code>
+<a href="#N-A-f-0b">f</a>(<a href="#param_t">param_t&lt;1&gt;</a> a);</code>
 </pre><span class="small"><a href="#N-A-f-0b"><em>» more...</em></a></span>
 
-<span>Reference function</span>
+<p>Reference function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#N-A-f-0e">f</a>(<a href="#param_t">param_t&lt;2&gt;</a> a);
-
-</code>
+<a href="#N-A-f-0e">f</a>(<a href="#param_t">param_t&lt;2&gt;</a> a);</code>
 </pre><span class="small"><a href="#N-A-f-0e"><em>» more...</em></a></span>
 
-<span>Reference function</span>
+<p>Reference function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#N-A-f-00">f</a>(<a href="#param_t">param_t&lt;3&gt;</a> a);
-
-</code>
+<a href="#N-A-f-00">f</a>(<a href="#param_t">param_t&lt;3&gt;</a> a);</code>
 </pre><span class="small"><a href="#N-A-f-00"><em>» more...</em></a></span>
 
-<span>Reference function</span>
+<p>Reference function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#N-A-f-02">f</a>(<a href="#param_t">param_t&lt;4&gt;</a> a);
-
-</code>
+<a href="#N-A-f-02">f</a>(<a href="#param_t">param_t&lt;4&gt;</a> a);</code>
 </pre><span class="small"><a href="#N-A-f-02"><em>» more...</em></a></span>
 
-<span>Reference function</span>
+<p>Reference function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#N-A-f-092">f</a>(<a href="#param_t">param_t&lt;5&gt;</a> a);
-
-</code>
+<a href="#N-A-f-092">f</a>(<a href="#param_t">param_t&lt;5&gt;</a> a);</code>
 </pre><span class="small"><a href="#N-A-f-092"><em>» more...</em></a></span>
 
-<span>Reference function</span>
+<p>Reference function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#N-A-f-097">f</a>(<a href="#param_t">param_t&lt;6&gt;</a> a);
-
-</code>
+<a href="#N-A-f-097">f</a>(<a href="#param_t">param_t&lt;6&gt;</a> a);</code>
 </pre><span class="small"><a href="#N-A-f-097"><em>» more...</em></a></span>
 
-<span>Reference function</span>
+<p>Reference function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#N-A-f-07">f</a>(<a href="#param_t">param_t&lt;7&gt;</a> a);
-
-</code>
+<a href="#N-A-f-07">f</a>(<a href="#param_t">param_t&lt;7&gt;</a> a);</code>
 </pre><span class="small"><a href="#N-A-f-07"><em>» more...</em></a></span>
 
 
@@ -208,7 +187,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Qualified param</span></td>
+<td>Qualified param</td>
 </tr>
 </tbody>
 </table>
@@ -218,8 +197,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="N-A-f-0a">N::A::f</h2>
 <div>
-<span>Reference function</span>
-
+<p>Reference function</p>
 </div>
 </div>
 <div>
@@ -228,9 +206,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#param_t">param_t&lt;0&gt;</a> a);
-
-</code>
+f(<a href="#param_t">param_t&lt;0&gt;</a> a);</code>
 </pre>
 </div>
 <div>
@@ -249,7 +225,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Qualified param</span></td>
+<td>Qualified param</td>
 </tr>
 </tbody>
 </table>
@@ -259,8 +235,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="N-A-f-0b">N::A::f</h2>
 <div>
-<span>Reference function</span>
-
+<p>Reference function</p>
 </div>
 </div>
 <div>
@@ -269,9 +244,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#param_t">param_t&lt;1&gt;</a> a);
-
-</code>
+f(<a href="#param_t">param_t&lt;1&gt;</a> a);</code>
 </pre>
 </div>
 <div>
@@ -290,7 +263,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Qualified param</span></td>
+<td>Qualified param</td>
 </tr>
 </tbody>
 </table>
@@ -300,8 +273,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="N-A-f-0e">N::A::f</h2>
 <div>
-<span>Reference function</span>
-
+<p>Reference function</p>
 </div>
 </div>
 <div>
@@ -310,9 +282,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#param_t">param_t&lt;2&gt;</a> a);
-
-</code>
+f(<a href="#param_t">param_t&lt;2&gt;</a> a);</code>
 </pre>
 </div>
 <div>
@@ -331,7 +301,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Qualified param</span></td>
+<td>Qualified param</td>
 </tr>
 </tbody>
 </table>
@@ -341,8 +311,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="N-A-f-00">N::A::f</h2>
 <div>
-<span>Reference function</span>
-
+<p>Reference function</p>
 </div>
 </div>
 <div>
@@ -351,9 +320,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#param_t">param_t&lt;3&gt;</a> a);
-
-</code>
+f(<a href="#param_t">param_t&lt;3&gt;</a> a);</code>
 </pre>
 </div>
 <div>
@@ -372,7 +339,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Qualified param</span></td>
+<td>Qualified param</td>
 </tr>
 </tbody>
 </table>
@@ -382,8 +349,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="N-A-f-02">N::A::f</h2>
 <div>
-<span>Reference function</span>
-
+<p>Reference function</p>
 </div>
 </div>
 <div>
@@ -392,9 +358,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#param_t">param_t&lt;4&gt;</a> a);
-
-</code>
+f(<a href="#param_t">param_t&lt;4&gt;</a> a);</code>
 </pre>
 </div>
 <div>
@@ -413,7 +377,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Qualified param</span></td>
+<td>Qualified param</td>
 </tr>
 </tbody>
 </table>
@@ -423,8 +387,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="N-A-f-092">N::A::f</h2>
 <div>
-<span>Reference function</span>
-
+<p>Reference function</p>
 </div>
 </div>
 <div>
@@ -433,9 +396,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#param_t">param_t&lt;5&gt;</a> a);
-
-</code>
+f(<a href="#param_t">param_t&lt;5&gt;</a> a);</code>
 </pre>
 </div>
 <div>
@@ -454,7 +415,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Qualified param</span></td>
+<td>Qualified param</td>
 </tr>
 </tbody>
 </table>
@@ -464,8 +425,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="N-A-f-097">N::A::f</h2>
 <div>
-<span>Reference function</span>
-
+<p>Reference function</p>
 </div>
 </div>
 <div>
@@ -474,9 +434,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#param_t">param_t&lt;6&gt;</a> a);
-
-</code>
+f(<a href="#param_t">param_t&lt;6&gt;</a> a);</code>
 </pre>
 </div>
 <div>
@@ -495,7 +453,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Qualified param</span></td>
+<td>Qualified param</td>
 </tr>
 </tbody>
 </table>
@@ -505,8 +463,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="N-A-f-07">N::A::f</h2>
 <div>
-<span>Reference function</span>
-
+<p>Reference function</p>
 </div>
 </div>
 <div>
@@ -515,9 +472,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#param_t">param_t&lt;7&gt;</a> a);
-
-</code>
+f(<a href="#param_t">param_t&lt;7&gt;</a> a);</code>
 </pre>
 </div>
 <div>
@@ -536,7 +491,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Qualified param</span></td>
+<td>Qualified param</td>
 </tr>
 </tbody>
 </table>
@@ -546,28 +501,23 @@ <h3>Parameters</h3>
 <div>
 <h2 id="N-A-g-06e">N::A::g</h2>
 <div>
-<span><code>g</code> overloads</span>
-
+<p><code>g</code> overloads</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
-<span>Reference function</span>
+<p>Reference function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#N-A-g-0a">g</a>(<a href="#N-A-B">B</a> a);
-
-</code>
+<a href="#N-A-g-0a">g</a>(<a href="#N-A-B">B</a> a);</code>
 </pre><span class="small"><a href="#N-A-g-0a"><em>» more...</em></a></span>
 
-<span>Fail</span>
+<p>Fail</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#N-A-g-06c">g</a>(int a);
-
-</code>
+<a href="#N-A-g-06c">g</a>(int a);</code>
 </pre><span class="small"><a href="#N-A-g-06c"><em>» more...</em></a></span>
 
 
@@ -584,7 +534,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Qualified param</span></td>
+<td>Qualified param</td>
 </tr>
 </tbody>
 </table>
@@ -594,8 +544,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="N-A-g-0a">N::A::g</h2>
 <div>
-<span>Reference function</span>
-
+<p>Reference function</p>
 </div>
 </div>
 <div>
@@ -604,9 +553,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g(<a href="#N-A-B">B</a> a);
-
-</code>
+g(<a href="#N-A-B">B</a> a);</code>
 </pre>
 </div>
 <div>
@@ -625,7 +572,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Qualified param</span></td>
+<td>Qualified param</td>
 </tr>
 </tbody>
 </table>
@@ -635,8 +582,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="N-A-g-06c">N::A::g</h2>
 <div>
-<span>Fail</span>
-
+<p>Fail</p>
 </div>
 </div>
 <div>
@@ -645,9 +591,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g(int a);
-
-</code>
+g(int a);</code>
 </pre>
 </div>
 <div>
@@ -666,7 +610,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Fundamental type parameter</span></td>
+<td>Fundamental type parameter</td>
 </tr>
 </tbody>
 </table>
@@ -676,28 +620,23 @@ <h3>Parameters</h3>
 <div>
 <h2 id="N-A-h-05">N::A::h</h2>
 <div>
-<span><code>h</code> overloads</span>
-
+<p><code>h</code> overloads</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
-<span>Reference function</span>
+<p>Reference function</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#N-A-h-0f">h</a>(<a href="#N-A-B">N::A::B</a> a);
-
-</code>
+<a href="#N-A-h-0f">h</a>(<a href="#N-A-B">N::A::B</a> a);</code>
 </pre><span class="small"><a href="#N-A-h-0f"><em>» more...</em></a></span>
 
-<span>Fail</span>
+<p>Fail</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#N-A-h-06">h</a>(int a);
-
-</code>
+<a href="#N-A-h-06">h</a>(int a);</code>
 </pre><span class="small"><a href="#N-A-h-06"><em>» more...</em></a></span>
 
 
@@ -714,7 +653,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Qualified param</span></td>
+<td>Qualified param</td>
 </tr>
 </tbody>
 </table>
@@ -724,8 +663,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="N-A-h-0f">N::A::h</h2>
 <div>
-<span>Reference function</span>
-
+<p>Reference function</p>
 </div>
 </div>
 <div>
@@ -734,9 +672,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h(<a href="#N-A-B">N::A::B</a> a);
-
-</code>
+h(<a href="#N-A-B">N::A::B</a> a);</code>
 </pre>
 </div>
 <div>
@@ -755,7 +691,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Qualified param</span></td>
+<td>Qualified param</td>
 </tr>
 </tbody>
 </table>
@@ -765,8 +701,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="N-A-h-06">N::A::h</h2>
 <div>
-<span>Fail</span>
-
+<p>Fail</p>
 </div>
 </div>
 <div>
@@ -775,9 +710,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h(int a);
-
-</code>
+h(int a);</code>
 </pre>
 </div>
 <div>
@@ -796,7 +729,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Fundamental type parameter</span></td>
+<td>Fundamental type parameter</td>
 </tr>
 </tbody>
 </table>
@@ -806,8 +739,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="param_t">param_t</h2>
 <div>
-<span>Helper class for distinct parameter types</span>
-
+<p>Helper class for distinct parameter types</p>
 </div>
 </div>
 <div>
@@ -816,9 +748,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;int N&gt;
-class param_t;
-
-</code>
+class param_t;</code>
 </pre>
 </div>
 
diff --git a/test-files/golden-tests/javadoc/copydoc/qualifiers.html b/test-files/golden-tests/javadoc/copydoc/qualifiers.html
index 0f2a7feb7..4f6e94688 100644
--- a/test-files/golden-tests/javadoc/copydoc/qualifiers.html
+++ b/test-files/golden-tests/javadoc/copydoc/qualifiers.html
@@ -32,9 +32,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;qualifiers.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -61,11 +59,11 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-begin-03"><code>begin</code></a> </td><td><span><code>begin</code> overloads</span></td></tr><tr>
-<td><a href="#A-cbegin"><code>cbegin</code></a> </td><td><span>Return a const iterator to the beginning</span></td></tr><tr>
-<td><a href="#A-crvalue"><code>crvalue</code></a> </td><td><span>An const rvalue reference to A</span></td></tr><tr>
-<td><a href="#A-ref-05f"><code>ref</code></a> </td><td><span><code>ref</code> overloads</span></td></tr><tr>
-<td><a href="#A-rvalue"><code>rvalue</code></a> </td><td><span>An rvalue reference to A</span></td></tr>
+<td><a href="#A-begin-03"><code>begin</code></a> </td><td><code>begin</code> overloads</td></tr><tr>
+<td><a href="#A-cbegin"><code>cbegin</code></a> </td><td>Return a const iterator to the beginning</td></tr><tr>
+<td><a href="#A-crvalue"><code>crvalue</code></a> </td><td>An const rvalue reference to A</td></tr><tr>
+<td><a href="#A-ref-05f"><code>ref</code></a> </td><td><code>ref</code> overloads</td></tr><tr>
+<td><a href="#A-rvalue"><code>rvalue</code></a> </td><td>An rvalue reference to A</td></tr>
 </tbody>
 </table>
 
@@ -81,9 +79,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;qualifiers.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class const_iterator;
-
-</code>
+<code class="source-code cpp">class const_iterator;</code>
 </pre>
 </div>
 
@@ -98,9 +94,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;qualifiers.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class iterator;
-
-</code>
+<code class="source-code cpp">class iterator;</code>
 </pre>
 </div>
 
@@ -110,28 +104,23 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="A-begin-03">A::begin</h2>
 <div>
-<span><code>begin</code> overloads</span>
-
+<p><code>begin</code> overloads</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;qualifiers.cpp&gt;</code></div>
-<span>Returns an iterator to the beginning</span>
+<p>Returns an iterator to the beginning</p>
 <pre>
 <code class="source-code cpp"><a href="#A-iterator">iterator</a>
-<a href="#A-begin-06">begin</a>();
-
-</code>
+<a href="#A-begin-06">begin</a>();</code>
 </pre><span class="small"><a href="#A-begin-06"><em>» more...</em></a></span>
 
-<span>Return a const iterator to the beginning</span>
+<p>Return a const iterator to the beginning</p>
 <pre>
 <code class="source-code cpp"><a href="#A-const_iterator">const_iterator</a>
-<a href="#A-begin-0c">begin</a>() const;
-
-</code>
+<a href="#A-begin-0c">begin</a>() const;</code>
 </pre><span class="small"><a href="#A-begin-0c"><em>» more...</em></a></span>
 
 
@@ -139,8 +128,8 @@ <h3>Synopses</h3>
 <div>
 <h3>Return Value</h3>
 <ul>
-<li><span>Iterator to the first element.</span></li>
-<li><span>Const iterator to the first element.</span></li>
+<li>Iterator to the first element.</li>
+<li>Const iterator to the first element.</li>
 </ul>
 </div>
 </div>
@@ -148,8 +137,7 @@ <h3>Return Value</h3>
 <div>
 <h2 id="A-begin-06">A::begin</h2>
 <div>
-<span>Returns an iterator to the beginning</span>
-
+<p>Returns an iterator to the beginning</p>
 </div>
 </div>
 <div>
@@ -158,9 +146,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualifiers.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#A-iterator">iterator</a>
-begin();
-
-</code>
+begin();</code>
 </pre>
 </div>
 <div>
@@ -169,15 +155,14 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Iterator to the first element.</span>
+Iterator to the first element.
 </div>
 </div>
 <div>
 <div>
 <h2 id="A-begin-0c">A::begin</h2>
 <div>
-<span>Return a const iterator to the beginning</span>
-
+<p>Return a const iterator to the beginning</p>
 </div>
 </div>
 <div>
@@ -186,9 +171,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualifiers.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#A-const_iterator">const_iterator</a>
-begin() const;
-
-</code>
+begin() const;</code>
 </pre>
 </div>
 <div>
@@ -197,15 +180,14 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Const iterator to the first element.</span>
+Const iterator to the first element.
 </div>
 </div>
 <div>
 <div>
 <h2 id="A-cbegin">A::cbegin</h2>
 <div>
-<span>Return a const iterator to the beginning</span>
-
+<p>Return a const iterator to the beginning</p>
 </div>
 </div>
 <div>
@@ -214,9 +196,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualifiers.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#A-const_iterator">const_iterator</a>
-cbegin() const;
-
-</code>
+cbegin() const;</code>
 </pre>
 </div>
 <div>
@@ -225,15 +205,14 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Const iterator to the first element.</span>
+Const iterator to the first element.
 </div>
 </div>
 <div>
 <div>
 <h2 id="A-crvalue">A::crvalue</h2>
 <div>
-<span>An const rvalue reference to A</span>
-
+<p>An const rvalue reference to A</p>
 </div>
 </div>
 <div>
@@ -242,73 +221,61 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualifiers.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>&&
-crvalue() const &amp;&amp;;
-
-</code>
+crvalue() const &amp;&amp;;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A reference to A</span>
+A reference to A
 </div>
 </div>
 <div>
 <div>
 <h2 id="A-ref-05f">A::ref</h2>
 <div>
-<span><code>ref</code> overloads</span>
-
+<p><code>ref</code> overloads</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;qualifiers.cpp&gt;</code></div>
-<span>An lvalue reference to A</span>
+<p>An lvalue reference to A</p>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>&
-<a href="#A-ref-051">ref</a>() &amp;;
-
-</code>
+<a href="#A-ref-051">ref</a>() &amp;;</code>
 </pre><span class="small"><a href="#A-ref-051"><em>» more...</em></a></span>
 
-<span>An rvalue reference to A</span>
+<p>An rvalue reference to A</p>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>&&
-<a href="#A-ref-0e">ref</a>() &amp;&amp;;
-
-</code>
+<a href="#A-ref-0e">ref</a>() &amp;&amp;;</code>
 </pre><span class="small"><a href="#A-ref-0e"><em>» more...</em></a></span>
 
-<span>An const lvalue reference to A</span>
+<p>An const lvalue reference to A</p>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a> const&
-<a href="#A-ref-04">ref</a>() const &amp;;
-
-</code>
+<a href="#A-ref-04">ref</a>() const &amp;;</code>
 </pre><span class="small"><a href="#A-ref-04"><em>» more...</em></a></span>
 
-<span>An const rvalue reference to A</span>
+<p>An const rvalue reference to A</p>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a> const&&
-<a href="#A-ref-07">ref</a>() const &amp;&amp;;
-
-</code>
+<a href="#A-ref-07">ref</a>() const &amp;&amp;;</code>
 </pre><span class="small"><a href="#A-ref-07"><em>» more...</em></a></span>
 
 
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A reference to A</span>
+A reference to A
 </div>
 </div>
 <div>
 <div>
 <h2 id="A-ref-051">A::ref</h2>
 <div>
-<span>An lvalue reference to A</span>
-
+<p>An lvalue reference to A</p>
 </div>
 </div>
 <div>
@@ -317,22 +284,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualifiers.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>&
-ref() &amp;;
-
-</code>
+ref() &amp;;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A reference to A</span>
+A reference to A
 </div>
 </div>
 <div>
 <div>
 <h2 id="A-ref-0e">A::ref</h2>
 <div>
-<span>An rvalue reference to A</span>
-
+<p>An rvalue reference to A</p>
 </div>
 </div>
 <div>
@@ -341,22 +305,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualifiers.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>&&
-ref() &amp;&amp;;
-
-</code>
+ref() &amp;&amp;;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A reference to A</span>
+A reference to A
 </div>
 </div>
 <div>
 <div>
 <h2 id="A-ref-04">A::ref</h2>
 <div>
-<span>An const lvalue reference to A</span>
-
+<p>An const lvalue reference to A</p>
 </div>
 </div>
 <div>
@@ -365,22 +326,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualifiers.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a> const&
-ref() const &amp;;
-
-</code>
+ref() const &amp;;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A reference to A</span>
+A reference to A
 </div>
 </div>
 <div>
 <div>
 <h2 id="A-ref-07">A::ref</h2>
 <div>
-<span>An const rvalue reference to A</span>
-
+<p>An const rvalue reference to A</p>
 </div>
 </div>
 <div>
@@ -389,22 +347,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualifiers.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a> const&&
-ref() const &amp;&amp;;
-
-</code>
+ref() const &amp;&amp;;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A reference to A</span>
+A reference to A
 </div>
 </div>
 <div>
 <div>
 <h2 id="A-rvalue">A::rvalue</h2>
 <div>
-<span>An rvalue reference to A</span>
-
+<p>An rvalue reference to A</p>
 </div>
 </div>
 <div>
@@ -413,14 +368,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualifiers.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>&&
-rvalue() &amp;&amp;;
-
-</code>
+rvalue() &amp;&amp;;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A reference to A</span>
+A reference to A
 </div>
 </div>
 
diff --git a/test-files/golden-tests/javadoc/copydoc/template-arguments.html b/test-files/golden-tests/javadoc/copydoc/template-arguments.html
index c83844de5..68cde37f7 100644
--- a/test-files/golden-tests/javadoc/copydoc/template-arguments.html
+++ b/test-files/golden-tests/javadoc/copydoc/template-arguments.html
@@ -37,19 +37,19 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-B-08"><code>B</code></a> </td><td><span>Main class template for B.</span></td></tr><tr>
-<td><a href="#A-B-09"><code>B&lt;int&gt;</code></a> </td><td><span>Specialization of B for int.</span></td></tr><tr>
-<td><a href="#A-B-0c"><code>B&lt;int, 2&gt;</code></a> </td><td><span>Specialization of B for int with value 2.</span></td></tr><tr>
-<td><a href="#A-C-05"><code>C</code></a> </td><td><span>Main class template for C.</span></td></tr><tr>
-<td><a href="#A-C-0f"><code>C&lt;D, true&gt;</code></a> </td><td><span>Specialization of C for D with true.</span></td></tr><tr>
-<td><a href="#A-C-0c"><code>C&lt;int, true&gt;</code></a> </td><td><span>Specialization of C for int with true.</span></td></tr><tr>
-<td><a href="#A-D"><code>D</code></a> </td><td><span>Helper struct D.</span></td></tr><tr>
-<td><a href="#A-BInt"><code>BInt</code></a> </td><td><span>Specialization of B for int.</span></td></tr><tr>
-<td><a href="#A-BInt2"><code>BInt2</code></a> </td><td><span>Specialization of B for int with value 2.</span></td></tr><tr>
-<td><a href="#A-B_t"><code>B_t</code></a> </td><td><span>Main class template for B.</span></td></tr><tr>
-<td><a href="#A-CDTrue"><code>CDTrue</code></a> </td><td><span>Specialization of C for D with true.</span></td></tr><tr>
-<td><a href="#A-CIntTrue"><code>CIntTrue</code></a> </td><td><span>Specialization of C for D with true.</span></td></tr><tr>
-<td><a href="#A-C_t"><code>C_t</code></a> </td><td><span>Main class template for C.</span></td></tr>
+<td><a href="#A-B-08"><code>B</code></a> </td><td>Main class template for B.</td></tr><tr>
+<td><a href="#A-B-09"><code>B&lt;int&gt;</code></a> </td><td>Specialization of B for int.</td></tr><tr>
+<td><a href="#A-B-0c"><code>B&lt;int, 2&gt;</code></a> </td><td>Specialization of B for int with value 2.</td></tr><tr>
+<td><a href="#A-C-05"><code>C</code></a> </td><td>Main class template for C.</td></tr><tr>
+<td><a href="#A-C-0f"><code>C&lt;D, true&gt;</code></a> </td><td>Specialization of C for D with true.</td></tr><tr>
+<td><a href="#A-C-0c"><code>C&lt;int, true&gt;</code></a> </td><td>Specialization of C for int with true.</td></tr><tr>
+<td><a href="#A-D"><code>D</code></a> </td><td>Helper struct D.</td></tr><tr>
+<td><a href="#A-BInt"><code>BInt</code></a> </td><td>Specialization of B for int.</td></tr><tr>
+<td><a href="#A-BInt2"><code>BInt2</code></a> </td><td>Specialization of B for int with value 2.</td></tr><tr>
+<td><a href="#A-B_t"><code>B_t</code></a> </td><td>Main class template for B.</td></tr><tr>
+<td><a href="#A-CDTrue"><code>CDTrue</code></a> </td><td>Specialization of C for D with true.</td></tr><tr>
+<td><a href="#A-CIntTrue"><code>CIntTrue</code></a> </td><td>Specialization of C for D with true.</td></tr><tr>
+<td><a href="#A-C_t"><code>C_t</code></a> </td><td>Main class template for C.</td></tr>
 </tbody>
 </table>
 
@@ -58,8 +58,7 @@ <h2>Types</h2>
 <div>
 <h2 id="A-BInt">A::BInt</h2>
 <div>
-<span>Specialization of B for int.</span>
-
+<p>Specialization of B for int.</p>
 </div>
 </div>
 <div>
@@ -67,9 +66,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;template-arguments.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using BInt = <a href="#A-B-09">B&lt;int&gt;</a>;
-
-</code>
+<code class="source-code cpp">using BInt = <a href="#A-B-09">B&lt;int&gt;</a>;</code>
 </pre>
 </div>
 </div>
@@ -77,8 +74,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="A-BInt2">A::BInt2</h2>
 <div>
-<span>Specialization of B for int with value 2.</span>
-
+<p>Specialization of B for int with value 2.</p>
 </div>
 </div>
 <div>
@@ -86,9 +82,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;template-arguments.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using BInt2 = <a href="#A-B-0c">B&lt;int, 2&gt;</a>;
-
-</code>
+<code class="source-code cpp">using BInt2 = <a href="#A-B-0c">B&lt;int, 2&gt;</a>;</code>
 </pre>
 </div>
 </div>
@@ -96,8 +90,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="A-B_t">A::B_t</h2>
 <div>
-<span>Main class template for B.</span>
-
+<p>Main class template for B.</p>
 </div>
 </div>
 <div>
@@ -108,9 +101,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     class T,
     int I&gt;
-using B_t = <a href="#A-B-08">B&lt;T, I&gt;</a>;
-
-</code>
+using B_t = <a href="#A-B-08">B&lt;T, I&gt;</a>;</code>
 </pre>
 </div>
 <div>
@@ -125,7 +116,7 @@ <h3>Template Parameters</h3>
 <tbody>
 <tr>
 <td><strong>T</strong></td>
-<td><span>The type parameter.</span></td>
+<td>The type parameter.</td>
 </tr>
 </tbody>
 </table>
@@ -135,8 +126,7 @@ <h3>Template Parameters</h3>
 <div>
 <h2 id="A-CDTrue">A::CDTrue</h2>
 <div>
-<span>Specialization of C for D with true.</span>
-
+<p>Specialization of C for D with true.</p>
 </div>
 </div>
 <div>
@@ -144,9 +134,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;template-arguments.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using CDTrue = <a href="#A-C-0f">C&lt;D, true&gt;</a>;
-
-</code>
+<code class="source-code cpp">using CDTrue = <a href="#A-C-0f">C&lt;D, true&gt;</a>;</code>
 </pre>
 </div>
 </div>
@@ -154,8 +142,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="A-CIntTrue">A::CIntTrue</h2>
 <div>
-<span>Specialization of C for D with true.</span>
-
+<p>Specialization of C for D with true.</p>
 </div>
 </div>
 <div>
@@ -163,9 +150,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;template-arguments.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using CIntTrue = <a href="#A-C-0c">C&lt;int, true&gt;</a>;
-
-</code>
+<code class="source-code cpp">using CIntTrue = <a href="#A-C-0c">C&lt;int, true&gt;</a>;</code>
 </pre>
 </div>
 </div>
@@ -173,8 +158,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="A-C_t">A::C_t</h2>
 <div>
-<span>Main class template for C.</span>
-
+<p>Main class template for C.</p>
 </div>
 </div>
 <div>
@@ -185,9 +169,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     class T,
     bool B&gt;
-using C_t = <a href="#A-C-05">C&lt;T, B&gt;</a>;
-
-</code>
+using C_t = <a href="#A-C-05">C&lt;T, B&gt;</a>;</code>
 </pre>
 </div>
 <div>
@@ -202,7 +184,7 @@ <h3>Template Parameters</h3>
 <tbody>
 <tr>
 <td><strong>T</strong></td>
-<td><span>The type parameter.</span></td>
+<td>The type parameter.</td>
 </tr>
 </tbody>
 </table>
@@ -212,8 +194,7 @@ <h3>Template Parameters</h3>
 <div>
 <h2 id="A-B-08">A::B</h2>
 <div>
-<span>Main class template for B.</span>
-
+<p>Main class template for B.</p>
 </div>
 </div>
 <div>
@@ -224,9 +205,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     class T,
     int = 0&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 
@@ -243,11 +222,11 @@ <h3>Template Parameters</h3>
 <tbody>
 <tr>
 <td><strong>T</strong></td>
-<td><span>The type parameter.</span></td>
+<td>The type parameter.</td>
 </tr>
 <tr>
 <td><strong>int</strong></td>
-<td><span>The integer parameter with a default value of 0.</span></td>
+<td>The integer parameter with a default value of 0.</td>
 </tr>
 </tbody>
 </table>
@@ -257,8 +236,7 @@ <h3>Template Parameters</h3>
 <div>
 <h2 id="A-B-09">A::B&lt;int&gt;</h2>
 <div>
-<span>Specialization of B for int.</span>
-
+<p>Specialization of B for int.</p>
 </div>
 </div>
 <div>
@@ -267,9 +245,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;template-arguments.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-B-08">B</a>&lt;int&gt;;
-
-</code>
+struct <a href="#A-B-08">B</a>&lt;int&gt;;</code>
 </pre>
 </div>
 
@@ -279,8 +255,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="A-B-0c">A::B&lt;int, 2&gt;</h2>
 <div>
-<span>Specialization of B for int with value 2.</span>
-
+<p>Specialization of B for int with value 2.</p>
 </div>
 </div>
 <div>
@@ -289,9 +264,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;template-arguments.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-B-08">B</a>&lt;int, 2&gt;;
-
-</code>
+struct <a href="#A-B-08">B</a>&lt;int, 2&gt;;</code>
 </pre>
 </div>
 
@@ -301,8 +274,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="A-C-05">A::C</h2>
 <div>
-<span>Main class template for C.</span>
-
+<p>Main class template for C.</p>
 </div>
 </div>
 <div>
@@ -313,9 +285,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     class T,
     bool = false&gt;
-struct C;
-
-</code>
+struct C;</code>
 </pre>
 </div>
 
@@ -332,11 +302,11 @@ <h3>Template Parameters</h3>
 <tbody>
 <tr>
 <td><strong>T</strong></td>
-<td><span>The type parameter.</span></td>
+<td>The type parameter.</td>
 </tr>
 <tr>
 <td><strong>bool</strong></td>
-<td><span>The boolean parameter with a default value of false.</span></td>
+<td>The boolean parameter with a default value of false.</td>
 </tr>
 </tbody>
 </table>
@@ -346,8 +316,7 @@ <h3>Template Parameters</h3>
 <div>
 <h2 id="A-C-0f">A::C&lt;D, true&gt;</h2>
 <div>
-<span>Specialization of C for D with true.</span>
-
+<p>Specialization of C for D with true.</p>
 </div>
 </div>
 <div>
@@ -356,9 +325,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;template-arguments.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-C-05">C</a>&lt;<a href="#A-D">D</a>, true&gt;;
-
-</code>
+struct <a href="#A-C-05">C</a>&lt;<a href="#A-D">D</a>, true&gt;;</code>
 </pre>
 </div>
 
@@ -368,8 +335,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="A-C-0c">A::C&lt;int, true&gt;</h2>
 <div>
-<span>Specialization of C for int with true.</span>
-
+<p>Specialization of C for int with true.</p>
 </div>
 </div>
 <div>
@@ -378,9 +344,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;template-arguments.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-C-05">C</a>&lt;int, true&gt;;
-
-</code>
+struct <a href="#A-C-05">C</a>&lt;int, true&gt;;</code>
 </pre>
 </div>
 
@@ -390,8 +354,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="A-D">A::D</h2>
 <div>
-<span>Helper struct D.</span>
-
+<p>Helper struct D.</p>
 </div>
 </div>
 <div>
@@ -399,9 +362,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;template-arguments.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct D;
-
-</code>
+<code class="source-code cpp">struct D;</code>
 </pre>
 </div>
 
diff --git a/test-files/golden-tests/javadoc/inline/styled.cpp b/test-files/golden-tests/javadoc/inline/styled.cpp
index 1dd48096a..4cf7fb97b 100644
--- a/test-files/golden-tests/javadoc/inline/styled.cpp
+++ b/test-files/golden-tests/javadoc/inline/styled.cpp
@@ -1,6 +1,6 @@
 /** Brief for A
 
-    Paragraph with `code`, *bold* text, and _italic_ text.
+    Paragraph with `code`, **bold** text, and _italic_ text.
 
     We can also escape these markers: \`, \*, and \_.
 
diff --git a/test-files/golden-tests/javadoc/inline/styled.html b/test-files/golden-tests/javadoc/inline/styled.html
index 0a91b8585..e83d4787b 100644
--- a/test-files/golden-tests/javadoc/inline/styled.html
+++ b/test-files/golden-tests/javadoc/inline/styled.html
@@ -19,7 +19,7 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A"><code>A</code></a> </td><td><span>Brief for A</span></td></tr>
+<td><a href="#A"><code>A</code></a> </td><td>Brief for A</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Types</h2>
 <div>
 <h2 id="A">A</h2>
 <div>
-<span>Brief for A</span>
-
+<p>Brief for A</p>
 </div>
 </div>
 <div>
@@ -37,9 +36,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;styled.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -52,7 +49,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-compare"><code>compare</code></a> </td><td><span>Compare function</span></td></tr>
+<td><a href="#A-compare"><code>compare</code></a> </td><td>Compare function</td></tr>
 </tbody>
 </table>
 
@@ -68,8 +65,7 @@ <h3>Description</h3>
 <div>
 <h2 id="A-compare">A::compare</h2>
 <div>
-<span>Compare function</span>
-
+<p>Compare function</p>
 </div>
 </div>
 <div>
@@ -78,14 +74,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;styled.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int
-compare(<a href="#A">A</a> const& other) const noexcept;
-
-</code>
+compare(<a href="#A">A</a> const& other) const noexcept;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>-1</code> if <code>*this &lt; other</code>, <code>0</code> if <code>this &#x3D;&#x3D; other</code>, and 1 if <code>this &gt; other</code>.</span>
+<code>-1</code> if <code>*this &lt; other</code>, <code>0</code> if <code>this &#x3D;&#x3D; other</code>, and 1 if <code>this &gt; other</code>.
 </div>
 <div>
 <h3>Parameters</h3>
@@ -99,7 +93,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The other object to compare against.</span></td>
+<td>The other object to compare against.</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/javadoc/link/link.adoc b/test-files/golden-tests/javadoc/link/link.adoc
index e9cdc1d0d..779a13a3e 100644
--- a/test-files/golden-tests/javadoc/link/link.adoc
+++ b/test-files/golden-tests/javadoc/link/link.adoc
@@ -31,7 +31,7 @@ f();
 
 === Description
 
-This is a function with a link to https://www.boost.org[]&period;
+This is a function with a link to https://www.boost.org[Boost]&period;
 
 
 [.small]#Created with https://www.mrdocs.com[MrDocs]#
diff --git a/test-files/golden-tests/javadoc/link/link.html b/test-files/golden-tests/javadoc/link/link.html
index d639a73a7..3dacd95ed 100644
--- a/test-files/golden-tests/javadoc/link/link.html
+++ b/test-files/golden-tests/javadoc/link/link.html
@@ -19,7 +19,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>A function with a link</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>A function with a link</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>A function with a link</span>
-
+<p>A function with a link</p>
 </div>
 </div>
 <div>
@@ -38,14 +37,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;link.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 <div>
 <h3>Description</h3>
-<p>This is a function with a link to <a href="https://www.boost.org"><span></span></a>.</p>
+<p>This is a function with a link to <a href="https://www.boost.org">Boost</a>.</p>
 </div>
 </div>
 
diff --git a/test-files/golden-tests/javadoc/lists/li.html b/test-files/golden-tests/javadoc/lists/li.html
index 99eba04f3..9cb8586da 100644
--- a/test-files/golden-tests/javadoc/lists/li.html
+++ b/test-files/golden-tests/javadoc/lists/li.html
@@ -19,7 +19,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>A function</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>A function</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>A function</span>
-
+<p>A function</p>
 </div>
 </div>
 <div>
@@ -38,19 +37,18 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;li.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 <div>
 <h3>Description</h3>
 <p>Description:</p>
 <ul>
-<li><span>Point 1</span></li>
-<li><span>Point 2</span></li>
-</ul>
-<p>Another paragraph.</p>
+<li><p>Point 1</p>
+</li>
+<li><p>Point 2</p>
+</li>
+</ul><p>Another paragraph.</p>
 </div>
 </div>
 
diff --git a/test-files/golden-tests/javadoc/lists/listitem.html b/test-files/golden-tests/javadoc/lists/listitem.html
index b559e68dd..b93f8d64a 100644
--- a/test-files/golden-tests/javadoc/lists/listitem.html
+++ b/test-files/golden-tests/javadoc/lists/listitem.html
@@ -19,10 +19,10 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f0"><code>f0</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#f1"><code>f1</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#f2"><code>f2</code></a> </td><td><span>brief</span></td></tr><tr>
-<td><a href="#f3"><code>f3</code></a> </td><td><span>brief</span></td></tr>
+<td><a href="#f0"><code>f0</code></a> </td><td></td></tr><tr>
+<td><a href="#f1"><code>f1</code></a> </td><td></td></tr><tr>
+<td><a href="#f2"><code>f2</code></a> </td><td>brief</td></tr><tr>
+<td><a href="#f3"><code>f3</code></a> </td><td>brief</td></tr>
 </tbody>
 </table>
 
@@ -37,17 +37,15 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;listitem.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 <div>
 <h3>Description</h3>
 <ul>
-<li><span>item</span></li>
-</ul>
-</div>
+<li><p>item</p>
+</li>
+</ul></div>
 </div>
 <div>
 <div>
@@ -59,25 +57,23 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;listitem.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 <div>
 <h3>Description</h3>
 <ul>
-<li><span>item 1</span></li>
-<li><span>item 2</span></li>
-</ul>
-</div>
+<li><p>item 1</p>
+</li>
+<li><p>item 2</p>
+</li>
+</ul></div>
 </div>
 <div>
 <div>
 <h2 id="f2">f2</h2>
 <div>
-<span>brief</span>
-
+<p>brief</p>
 </div>
 </div>
 <div>
@@ -86,25 +82,23 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;listitem.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 <div>
 <h3>Description</h3>
 <ul>
-<li><span>item 1</span></li>
-<li><span>item 2</span></li>
-</ul>
-</div>
+<li><p>item 1</p>
+</li>
+<li><p>item 2</p>
+</li>
+</ul></div>
 </div>
 <div>
 <div>
 <h2 id="f3">f3</h2>
 <div>
-<span>brief</span>
-
+<p>brief</p>
 </div>
 </div>
 <div>
@@ -113,19 +107,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;listitem.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f3();
-
-</code>
+f3();</code>
 </pre>
 </div>
 <div>
 <h3>Description</h3>
 <ul>
-<li><span>item 1</span></li>
-<li><span>item 2</span></li>
-<li><span>item 3</span></li>
-</ul>
-</div>
+<li><p>item 1</p>
+</li>
+<li><p>item 2</p>
+</li>
+<li><p>item 3</p>
+</li>
+</ul></div>
 </div>
 
 </div>
diff --git a/test-files/golden-tests/javadoc/paragraph/par-1.adoc b/test-files/golden-tests/javadoc/paragraph/par-1.adoc
index 7078e5ba9..d5175acf1 100644
--- a/test-files/golden-tests/javadoc/paragraph/par-1.adoc
+++ b/test-files/golden-tests/javadoc/paragraph/par-1.adoc
@@ -35,9 +35,8 @@ void
 f1();
 ----
 
-=== Description
-
 === Custom par
+
 Paragraph 1
 
 [,cpp]
@@ -59,9 +58,8 @@ void
 f2();
 ----
 
-=== Description
-
 === Custom par
+
 Paragraph 2
 
 [,cpp]
@@ -83,9 +81,8 @@ void
 f3();
 ----
 
-=== Description
-
 === Custom par
+
 [,cpp]
 ----
 void f3();
@@ -105,9 +102,8 @@ void
 f4();
 ----
 
-=== Description
-
 === Custom par
+
 [,cpp]
 ----
 void f4();
diff --git a/test-files/golden-tests/javadoc/paragraph/par-1.html b/test-files/golden-tests/javadoc/paragraph/par-1.html
index fef4b8892..bdb6f9aa0 100644
--- a/test-files/golden-tests/javadoc/paragraph/par-1.html
+++ b/test-files/golden-tests/javadoc/paragraph/par-1.html
@@ -19,10 +19,10 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f1"><code>f1</code></a> </td><td><span>Brief</span></td></tr><tr>
-<td><a href="#f2"><code>f2</code></a> </td><td><span>Brief</span></td></tr><tr>
-<td><a href="#f3"><code>f3</code></a> </td><td><span>Brief</span></td></tr><tr>
-<td><a href="#f4"><code>f4</code></a> </td><td><span>Brief</span></td></tr>
+<td><a href="#f1"><code>f1</code></a> </td><td>Brief</td></tr><tr>
+<td><a href="#f2"><code>f2</code></a> </td><td>Brief</td></tr><tr>
+<td><a href="#f3"><code>f3</code></a> </td><td>Brief</td></tr><tr>
+<td><a href="#f4"><code>f4</code></a> </td><td>Brief</td></tr>
 </tbody>
 </table>
 
@@ -31,8 +31,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="f1">f1</h2>
 <div>
-<span>Brief</span>
-
+<p>Brief</p>
 </div>
 </div>
 <div>
@@ -41,26 +40,21 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;par-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 <div>
-<h3>Description</h3>
-<h3>Custom par</h3>
+<h2>Custom par</h2>
 <p>Paragraph 1</p>
-<code>
+<code class="language-cpp">
 void f1();
-</code>
-</div>
+</code></div>
 </div>
 <div>
 <div>
 <h2 id="f2">f2</h2>
 <div>
-<span>Brief</span>
-
+<p>Brief</p>
 </div>
 </div>
 <div>
@@ -69,26 +63,21 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;par-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 <div>
-<h3>Description</h3>
-<h3>Custom par</h3>
+<h2>Custom par</h2>
 <p>Paragraph 2</p>
-<code>
+<code class="language-cpp">
 void f2();
-</code>
-</div>
+</code></div>
 </div>
 <div>
 <div>
 <h2 id="f3">f3</h2>
 <div>
-<span>Brief</span>
-
+<p>Brief</p>
 </div>
 </div>
 <div>
@@ -97,25 +86,20 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;par-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f3();
-
-</code>
+f3();</code>
 </pre>
 </div>
 <div>
-<h3>Description</h3>
-<h3>Custom par</h3>
-<code>
+<h2>Custom par</h2>
+<code class="language-cpp">
 void f3();
-</code>
-</div>
+</code></div>
 </div>
 <div>
 <div>
 <h2 id="f4">f4</h2>
 <div>
-<span>Brief</span>
-
+<p>Brief</p>
 </div>
 </div>
 <div>
@@ -124,18 +108,14 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;par-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f4();
-
-</code>
+f4();</code>
 </pre>
 </div>
 <div>
-<h3>Description</h3>
-<h3>Custom par</h3>
-<code>
+<h2>Custom par</h2>
+<code class="language-cpp">
 void f4();
-</code>
-</div>
+</code></div>
 </div>
 
 </div>
diff --git a/test-files/golden-tests/javadoc/paragraph/para-1.html b/test-files/golden-tests/javadoc/paragraph/para-1.html
index 55e6b1514..6395d4af0 100644
--- a/test-files/golden-tests/javadoc/paragraph/para-1.html
+++ b/test-files/golden-tests/javadoc/paragraph/para-1.html
@@ -19,10 +19,10 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f1"><code>f1</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#f2"><code>f2</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#f3"><code>f3</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#f4"><code>f4</code></a> </td><td><span>brief</span></td></tr>
+<td><a href="#f1"><code>f1</code></a> </td><td></td></tr><tr>
+<td><a href="#f2"><code>f2</code></a> </td><td></td></tr><tr>
+<td><a href="#f3"><code>f3</code></a> </td><td></td></tr><tr>
+<td><a href="#f4"><code>f4</code></a> </td><td>brief</td></tr>
 </tbody>
 </table>
 
@@ -37,9 +37,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;para-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -53,9 +51,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;para-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -69,9 +65,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;para-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f3();
-
-</code>
+f3();</code>
 </pre>
 </div>
 </div>
@@ -79,8 +73,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f4">f4</h2>
 <div>
-<span>brief</span>
-
+<p>brief</p>
 </div>
 </div>
 <div>
@@ -89,9 +82,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;para-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f4();
-
-</code>
+f4();</code>
 </pre>
 </div>
 <div>
diff --git a/test-files/golden-tests/javadoc/paragraph/para-2.html b/test-files/golden-tests/javadoc/paragraph/para-2.html
index 1f8acbc3e..11116750e 100644
--- a/test-files/golden-tests/javadoc/paragraph/para-2.html
+++ b/test-files/golden-tests/javadoc/paragraph/para-2.html
@@ -19,7 +19,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f1"><code>f1</code></a> </td><td><span>brief</span></td></tr>
+<td><a href="#f1"><code>f1</code></a> </td><td>brief</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="f1">f1</h2>
 <div>
-<span>brief</span>
-
+<p>brief</p>
 </div>
 </div>
 <div>
@@ -38,9 +37,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;para-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 <div>
diff --git a/test-files/golden-tests/javadoc/paragraph/para-3.adoc b/test-files/golden-tests/javadoc/paragraph/para-3.adoc
index 044967ae5..912431777 100644
--- a/test-files/golden-tests/javadoc/paragraph/para-3.adoc
+++ b/test-files/golden-tests/javadoc/paragraph/para-3.adoc
@@ -29,14 +29,16 @@ void
 my&lowbar;function();
 ----
 
-=== Description
+=== A heading&period;
+
+Some text&period;
 
-=== A heading&period; Some text&period;
 More text&period;&period;&period;
 
 Another paragraph Next line
 
 === Exception safety
+
 No&hyphen;throw guarantee&period;
 
 
diff --git a/test-files/golden-tests/javadoc/paragraph/para-3.html b/test-files/golden-tests/javadoc/paragraph/para-3.html
index be604e693..a19e0cdb3 100644
--- a/test-files/golden-tests/javadoc/paragraph/para-3.html
+++ b/test-files/golden-tests/javadoc/paragraph/para-3.html
@@ -19,7 +19,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#my_function"><code>my_function</code></a> </td><td><span>A function</span></td></tr>
+<td><a href="#my_function"><code>my_function</code></a> </td><td>A function</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="my_function">my_function</h2>
 <div>
-<span>A function</span>
-
+<p>A function</p>
 </div>
 </div>
 <div>
@@ -38,17 +37,15 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;para-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-my_function();
-
-</code>
+my_function();</code>
 </pre>
 </div>
 <div>
-<h3>Description</h3>
-<h3>A heading. Some text.</h3>
+<h2>A heading.</h2>
+<p>Some text.</p>
 <p>More text...</p>
 <p>Another paragraph Next line</p>
-<h3>Exception safety</h3>
+<h2>Exception safety</h2>
 <p>No-throw guarantee.</p>
 </div>
 </div>
diff --git a/test-files/golden-tests/javadoc/paragraph/para-3.xml b/test-files/golden-tests/javadoc/paragraph/para-3.xml
index 33ab8f05c..20e2e654d 100644
--- a/test-files/golden-tests/javadoc/paragraph/para-3.xml
+++ b/test-files/golden-tests/javadoc/paragraph/para-3.xml
@@ -8,7 +8,10 @@
       <brief>
         <text>A function</text>
       </brief>
-      <head>A heading. Some text.</head>
+      <head>A heading.</head>
+      <para>
+        <text>Some text.</text>
+      </para>
       <para>
         <text>More text...</text>
       </para>
diff --git a/test-files/golden-tests/javadoc/param/param-1.adoc b/test-files/golden-tests/javadoc/param/param-1.adoc
index 0d1d7ea9c..4e3f5f038 100644
--- a/test-files/golden-tests/javadoc/param/param-1.adoc
+++ b/test-files/golden-tests/javadoc/param/param-1.adoc
@@ -6,20 +6,14 @@
 
 === Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#f0[`f0`] 
-| 
 | link:#f1[`f1`] 
-| 
 | link:#f2[`f2`] 
-| 
 | link:#f3[`f3`] 
-| 
 | link:#f4[`f4`] 
-| 
 |===
 
 [#f0]
diff --git a/test-files/golden-tests/javadoc/param/param-1.html b/test-files/golden-tests/javadoc/param/param-1.html
index 38e59035d..fd57226ea 100644
--- a/test-files/golden-tests/javadoc/param/param-1.html
+++ b/test-files/golden-tests/javadoc/param/param-1.html
@@ -14,16 +14,15 @@ <h2>Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f0"><code>f0</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#f1"><code>f1</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#f2"><code>f2</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#f3"><code>f3</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#f4"><code>f4</code></a> </td><td><span></span></td></tr>
+<td><a href="#f0"><code>f0</code></a> </td></tr><tr>
+<td><a href="#f1"><code>f1</code></a> </td></tr><tr>
+<td><a href="#f2"><code>f2</code></a> </td></tr><tr>
+<td><a href="#f3"><code>f3</code></a> </td></tr><tr>
+<td><a href="#f4"><code>f4</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -38,9 +37,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0(int i);
-
-</code>
+f0(int i);</code>
 </pre>
 </div>
 <div>
@@ -55,7 +52,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>i</strong></td>
-<td><span>int</span></td>
+<td>int</td>
 </tr>
 </tbody>
 </table>
@@ -71,9 +68,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1(int i);
-
-</code>
+f1(int i);</code>
 </pre>
 </div>
 <div>
@@ -88,7 +83,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>i</strong> [in]</td>
-<td><span>int</span></td>
+<td>int</td>
 </tr>
 </tbody>
 </table>
@@ -104,9 +99,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2(int& i);
-
-</code>
+f2(int& i);</code>
 </pre>
 </div>
 <div>
@@ -121,7 +114,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>i</strong> [out]</td>
-<td><span>int</span></td>
+<td>int</td>
 </tr>
 </tbody>
 </table>
@@ -137,9 +130,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f3(int& i);
-
-</code>
+f3(int& i);</code>
 </pre>
 </div>
 <div>
@@ -154,7 +145,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>i</strong> [inout]</td>
-<td><span>int</span></td>
+<td>int</td>
 </tr>
 </tbody>
 </table>
@@ -172,9 +163,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">void
 f4(
     int i,
-    double j);
-
-</code>
+    double j);</code>
 </pre>
 </div>
 <div>
@@ -189,7 +178,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>i,j</strong></td>
-<td><span>numbers</span></td>
+<td>numbers</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/javadoc/param/param-direction.adoc b/test-files/golden-tests/javadoc/param/param-direction.adoc
index 847b20dad..a70c0068d 100644
--- a/test-files/golden-tests/javadoc/param/param-direction.adoc
+++ b/test-files/golden-tests/javadoc/param/param-direction.adoc
@@ -6,30 +6,19 @@
 
 === Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#f[`f`] 
-| 
 | link:#g[`g`] 
-| 
 | link:#h[`h`] 
-| 
 | link:#i[`i`] 
-| 
 | link:#j[`j`] 
-| 
 | link:#k[`k`] 
-| 
 | link:#l[`l`] 
-| 
 | link:#m[`m`] 
-| 
 | link:#n[`n`] 
-| 
 | link:#o[`o`] 
-| 
 |===
 
 [#f]
@@ -52,7 +41,7 @@ f(int x0);
 | Name
 | Description
 | *x0*
-| 
+| An integer `x0`
 |===
 
 [#g]
@@ -77,9 +66,9 @@ g(
 | Name
 | Description
 | *x1*
-| 
+| An integer `x1`
 | *y1* [in]
-| 
+| An integer `y1`
 |===
 
 [#h]
@@ -104,9 +93,9 @@ h(
 | Name
 | Description
 | *x2*
-| 
+| An integer `x2`
 | *y2* [out]
-| 
+| An integer `y2`
 |===
 
 [#i]
@@ -131,9 +120,9 @@ i(
 | Name
 | Description
 | *x3* [in]
-| 
+| An integer `x3`
 | *y3* [out]
-| 
+| An integer `y3`
 |===
 
 [#j]
@@ -158,9 +147,9 @@ j(
 | Name
 | Description
 | *x4*
-| 
+| An integer `x4`
 | *y4* [inout]
-| 
+| An integer `y4`
 |===
 
 [#k]
@@ -186,11 +175,11 @@ k(
 | Name
 | Description
 | *x5* [out]
-| 
+| An integer `x5`
 | *y5* [in]
-| 
+| An integer `y5`
 | *z5*
-| 
+| An integer `z5`
 |===
 
 [#l]
@@ -217,11 +206,11 @@ l(
 | Name
 | Description
 | *x6* [out]
-| 
+| An integer `x6`
 | *y6*
-| 
+| An integer `y6`
 | *z6* [in]
-| 
+| An integer `z6`
 |===
 
 [#m]
@@ -246,9 +235,9 @@ m(
 | Name
 | Description
 | *x7* [in]
-| 
+| An integer `x7`
 | *y7* [out]
-| 
+| An integer `y7`
 |===
 
 [#n]
@@ -271,7 +260,7 @@ n(int x8);
 | Name
 | Description
 | *x8* [in]
-| 
+| An integer `x8`
 |===
 
 [#o]
@@ -294,9 +283,9 @@ o(int x9);
 | Name
 | Description
 | *x9* [in]
-| 
+| An integer `x9`
 | *x9* [out]
-| 
+| An integer `x9`
 |===
 
 
diff --git a/test-files/golden-tests/javadoc/param/param-direction.cpp b/test-files/golden-tests/javadoc/param/param-direction.cpp
index d39d78892..738f78bed 100644
--- a/test-files/golden-tests/javadoc/param/param-direction.cpp
+++ b/test-files/golden-tests/javadoc/param/param-direction.cpp
@@ -1,72 +1,72 @@
 /**
- * @param x0
+ * @param x0 An integer `x0`
 **/
 void f(int x0) { }
 
 /**
- * @param x1
- * @param[in] y1
+ * @param x1 An integer `x1`
+ * @param[in] y1 An integer `y1`
 **/
 void g(int x1, int y1) { }
 
 /**
- * @param x2
- * @param[out] y2
+ * @param x2 An integer `x2`
+ * @param[out] y2 An integer `y2`
 **/
 void h(int x2, int y2) { }
 
 /**
- * @param[in] x3
- * @param[out] y3
+ * @param[in] x3 An integer `x3`
+ * @param[out] y3 An integer `y3`
 **/
 void i(int x3, int y3) { }
 
 /**
- * @param x4
- * @param[in,out] y4
+ * @param x4 An integer `x4`
+ * @param[in,out] y4 An integer `y4`
 **/
 void j(int x4, int y4) { }
 
 /**
- * @param[out] x5
- * @param[in] y5
- * @param z5
+ * @param[out] x5 An integer `x5`
+ * @param[in] y5 An integer `y5`
+ * @param z5 An integer `z5`
 **/
 void k(int x5, int y5, int z5) { }
 
 /**
- * @param[out] x6
- * @param y6
- * @param[in] z6
+ * @param[out] x6 An integer `x6`
+ * @param y6 An integer `y6`
+ * @param[in] z6 An integer `z6`
 **/
 void l(int x6, int y6, int, int z6) { }
 
 /**
- * @param[in] x7
+ * @param[in] x7 An integer `x7`
 **/
 void m(int x7, int y7);
 
 /**
- * @param[out] y7
+ * @param[out] y7 An integer `y7`
 **/
 void m(int x7, int y7);
 
 /**
- * @param[in] x8
+ * @param[in] x8 An integer `x8`
 **/
 void n(int x8);
 
 /**
- * @param[in] x8
+ * @param[in] x8 An integer `x8`
 **/
 void n(int x8);
 
 /**
- * @param[in] x9
+ * @param[in] x9 An integer `x9`
 **/
 void o(int x9);
 
 /**
- * @param[out] x9
+ * @param[out] x9 An integer `x9`
 **/
 void o(int x9);
diff --git a/test-files/golden-tests/javadoc/param/param-direction.html b/test-files/golden-tests/javadoc/param/param-direction.html
index 32b08d7ed..e788716c0 100644
--- a/test-files/golden-tests/javadoc/param/param-direction.html
+++ b/test-files/golden-tests/javadoc/param/param-direction.html
@@ -14,21 +14,20 @@ <h2>Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#g"><code>g</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#h"><code>h</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#i"><code>i</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#j"><code>j</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#k"><code>k</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#l"><code>l</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#m"><code>m</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#n"><code>n</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#o"><code>o</code></a> </td><td><span></span></td></tr>
+<td><a href="#f"><code>f</code></a> </td></tr><tr>
+<td><a href="#g"><code>g</code></a> </td></tr><tr>
+<td><a href="#h"><code>h</code></a> </td></tr><tr>
+<td><a href="#i"><code>i</code></a> </td></tr><tr>
+<td><a href="#j"><code>j</code></a> </td></tr><tr>
+<td><a href="#k"><code>k</code></a> </td></tr><tr>
+<td><a href="#l"><code>l</code></a> </td></tr><tr>
+<td><a href="#m"><code>m</code></a> </td></tr><tr>
+<td><a href="#n"><code>n</code></a> </td></tr><tr>
+<td><a href="#o"><code>o</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -43,9 +42,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-direction.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(int x0);
-
-</code>
+f(int x0);</code>
 </pre>
 </div>
 <div>
@@ -60,7 +57,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>x0</strong></td>
-<td><span></span></td>
+<td>An integer <code>x0</code></td>
 </tr>
 </tbody>
 </table>
@@ -78,9 +75,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">void
 g(
     int x1,
-    int y1);
-
-</code>
+    int y1);</code>
 </pre>
 </div>
 <div>
@@ -95,11 +90,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>x1</strong></td>
-<td><span></span></td>
+<td>An integer <code>x1</code></td>
 </tr>
 <tr>
 <td><strong>y1</strong> [in]</td>
-<td><span></span></td>
+<td>An integer <code>y1</code></td>
 </tr>
 </tbody>
 </table>
@@ -117,9 +112,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">void
 h(
     int x2,
-    int y2);
-
-</code>
+    int y2);</code>
 </pre>
 </div>
 <div>
@@ -134,11 +127,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>x2</strong></td>
-<td><span></span></td>
+<td>An integer <code>x2</code></td>
 </tr>
 <tr>
 <td><strong>y2</strong> [out]</td>
-<td><span></span></td>
+<td>An integer <code>y2</code></td>
 </tr>
 </tbody>
 </table>
@@ -156,9 +149,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">void
 i(
     int x3,
-    int y3);
-
-</code>
+    int y3);</code>
 </pre>
 </div>
 <div>
@@ -173,11 +164,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>x3</strong> [in]</td>
-<td><span></span></td>
+<td>An integer <code>x3</code></td>
 </tr>
 <tr>
 <td><strong>y3</strong> [out]</td>
-<td><span></span></td>
+<td>An integer <code>y3</code></td>
 </tr>
 </tbody>
 </table>
@@ -195,9 +186,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">void
 j(
     int x4,
-    int y4);
-
-</code>
+    int y4);</code>
 </pre>
 </div>
 <div>
@@ -212,11 +201,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>x4</strong></td>
-<td><span></span></td>
+<td>An integer <code>x4</code></td>
 </tr>
 <tr>
 <td><strong>y4</strong> [inout]</td>
-<td><span></span></td>
+<td>An integer <code>y4</code></td>
 </tr>
 </tbody>
 </table>
@@ -235,9 +224,7 @@ <h3>Synopsis</h3>
 k(
     int x5,
     int y5,
-    int z5);
-
-</code>
+    int z5);</code>
 </pre>
 </div>
 <div>
@@ -252,15 +239,15 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>x5</strong> [out]</td>
-<td><span></span></td>
+<td>An integer <code>x5</code></td>
 </tr>
 <tr>
 <td><strong>y5</strong> [in]</td>
-<td><span></span></td>
+<td>An integer <code>y5</code></td>
 </tr>
 <tr>
 <td><strong>z5</strong></td>
-<td><span></span></td>
+<td>An integer <code>z5</code></td>
 </tr>
 </tbody>
 </table>
@@ -280,9 +267,7 @@ <h3>Synopsis</h3>
     int x6,
     int y6,
     int,
-    int z6);
-
-</code>
+    int z6);</code>
 </pre>
 </div>
 <div>
@@ -297,15 +282,15 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>x6</strong> [out]</td>
-<td><span></span></td>
+<td>An integer <code>x6</code></td>
 </tr>
 <tr>
 <td><strong>y6</strong></td>
-<td><span></span></td>
+<td>An integer <code>y6</code></td>
 </tr>
 <tr>
 <td><strong>z6</strong> [in]</td>
-<td><span></span></td>
+<td>An integer <code>z6</code></td>
 </tr>
 </tbody>
 </table>
@@ -323,9 +308,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">void
 m(
     int x7,
-    int y7);
-
-</code>
+    int y7);</code>
 </pre>
 </div>
 <div>
@@ -340,11 +323,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>x7</strong> [in]</td>
-<td><span></span></td>
+<td>An integer <code>x7</code></td>
 </tr>
 <tr>
 <td><strong>y7</strong> [out]</td>
-<td><span></span></td>
+<td>An integer <code>y7</code></td>
 </tr>
 </tbody>
 </table>
@@ -360,9 +343,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-direction.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-n(int x8);
-
-</code>
+n(int x8);</code>
 </pre>
 </div>
 <div>
@@ -377,7 +358,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>x8</strong> [in]</td>
-<td><span></span></td>
+<td>An integer <code>x8</code></td>
 </tr>
 </tbody>
 </table>
@@ -393,9 +374,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-direction.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-o(int x9);
-
-</code>
+o(int x9);</code>
 </pre>
 </div>
 <div>
@@ -410,11 +389,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>x9</strong> [in]</td>
-<td><span></span></td>
+<td>An integer <code>x9</code></td>
 </tr>
 <tr>
 <td><strong>x9</strong> [out]</td>
-<td><span></span></td>
+<td>An integer <code>x9</code></td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/javadoc/param/param-direction.xml b/test-files/golden-tests/javadoc/param/param-direction.xml
index 4bd8a0ef1..6bbcb0318 100644
--- a/test-files/golden-tests/javadoc/param/param-direction.xml
+++ b/test-files/golden-tests/javadoc/param/param-direction.xml
@@ -9,6 +9,8 @@
     </param>
     <doc>
       <param name="x0">
+        <text>An integer </text>
+        <mono>x0</mono>
       </param>
     </doc>
   </function>
@@ -22,8 +24,12 @@
     </param>
     <doc>
       <param name="x1">
+        <text>An integer </text>
+        <mono>x1</mono>
       </param>
       <param name="y1" class="in">
+        <text>An integer </text>
+        <mono>y1</mono>
       </param>
     </doc>
   </function>
@@ -37,8 +43,12 @@
     </param>
     <doc>
       <param name="x2">
+        <text>An integer </text>
+        <mono>x2</mono>
       </param>
       <param name="y2" class="out">
+        <text>An integer </text>
+        <mono>y2</mono>
       </param>
     </doc>
   </function>
@@ -52,8 +62,12 @@
     </param>
     <doc>
       <param name="x3" class="in">
+        <text>An integer </text>
+        <mono>x3</mono>
       </param>
       <param name="y3" class="out">
+        <text>An integer </text>
+        <mono>y3</mono>
       </param>
     </doc>
   </function>
@@ -67,8 +81,12 @@
     </param>
     <doc>
       <param name="x4">
+        <text>An integer </text>
+        <mono>x4</mono>
       </param>
       <param name="y4" class="inout">
+        <text>An integer </text>
+        <mono>y4</mono>
       </param>
     </doc>
   </function>
@@ -85,10 +103,16 @@
     </param>
     <doc>
       <param name="x5" class="out">
+        <text>An integer </text>
+        <mono>x5</mono>
       </param>
       <param name="y5" class="in">
+        <text>An integer </text>
+        <mono>y5</mono>
       </param>
       <param name="z5">
+        <text>An integer </text>
+        <mono>z5</mono>
       </param>
     </doc>
   </function>
@@ -108,10 +132,16 @@
     </param>
     <doc>
       <param name="x6" class="out">
+        <text>An integer </text>
+        <mono>x6</mono>
       </param>
       <param name="y6">
+        <text>An integer </text>
+        <mono>y6</mono>
       </param>
       <param name="z6" class="in">
+        <text>An integer </text>
+        <mono>z6</mono>
       </param>
     </doc>
   </function>
@@ -126,8 +156,12 @@
     </param>
     <doc>
       <param name="x7" class="in">
+        <text>An integer </text>
+        <mono>x7</mono>
       </param>
       <param name="y7" class="out">
+        <text>An integer </text>
+        <mono>y7</mono>
       </param>
     </doc>
   </function>
@@ -139,6 +173,8 @@
     </param>
     <doc>
       <param name="x8" class="in">
+        <text>An integer </text>
+        <mono>x8</mono>
       </param>
     </doc>
   </function>
@@ -150,8 +186,12 @@
     </param>
     <doc>
       <param name="x9" class="in">
+        <text>An integer </text>
+        <mono>x9</mono>
       </param>
       <param name="x9" class="out">
+        <text>An integer </text>
+        <mono>x9</mono>
       </param>
     </doc>
   </function>
diff --git a/test-files/golden-tests/javadoc/param/param-duplicate.html b/test-files/golden-tests/javadoc/param/param-duplicate.html
index e8079c271..607e9361e 100644
--- a/test-files/golden-tests/javadoc/param/param-duplicate.html
+++ b/test-files/golden-tests/javadoc/param/param-duplicate.html
@@ -19,12 +19,12 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f0"><code>f0</code></a> </td><td><span>f0 brief</span></td></tr><tr>
-<td><a href="#f1"><code>f1</code></a> </td><td><span>f1 brief</span></td></tr><tr>
-<td><a href="#g0"><code>g0</code></a> </td><td><span>g0 brief</span></td></tr><tr>
-<td><a href="#g1"><code>g1</code></a> </td><td><span>g1 brief</span></td></tr><tr>
-<td><a href="#h0"><code>h0</code></a> </td><td><span>h0 brief</span></td></tr><tr>
-<td><a href="#h1"><code>h1</code></a> </td><td><span>h1 brief</span></td></tr>
+<td><a href="#f0"><code>f0</code></a> </td><td>f0 brief</td></tr><tr>
+<td><a href="#f1"><code>f1</code></a> </td><td>f1 brief</td></tr><tr>
+<td><a href="#g0"><code>g0</code></a> </td><td>g0 brief</td></tr><tr>
+<td><a href="#g1"><code>g1</code></a> </td><td>g1 brief</td></tr><tr>
+<td><a href="#h0"><code>h0</code></a> </td><td>h0 brief</td></tr><tr>
+<td><a href="#h1"><code>h1</code></a> </td><td>h1 brief</td></tr>
 </tbody>
 </table>
 
@@ -33,8 +33,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="f0">f0</h2>
 <div>
-<span>f0 brief</span>
-
+<p>f0 brief</p>
 </div>
 </div>
 <div>
@@ -43,16 +42,14 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-duplicate.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
 <ul>
-<li><span>int</span></li>
-<li><span>int</span></li>
+<li>int</li>
+<li>int</li>
 </ul>
 </div>
 </div>
@@ -60,8 +57,7 @@ <h3>Return Value</h3>
 <div>
 <h2 id="f1">f1</h2>
 <div>
-<span>f1 brief</span>
-
+<p>f1 brief</p>
 </div>
 </div>
 <div>
@@ -70,16 +66,14 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-duplicate.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
 <ul>
-<li><span>int</span></li>
-<li><span>bool</span></li>
+<li>int</li>
+<li>bool</li>
 </ul>
 </div>
 </div>
@@ -87,8 +81,7 @@ <h3>Return Value</h3>
 <div>
 <h2 id="g0">g0</h2>
 <div>
-<span>g0 brief</span>
-
+<p>g0 brief</p>
 </div>
 </div>
 <div>
@@ -97,9 +90,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-duplicate.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g0(int a);
-
-</code>
+g0(int a);</code>
 </pre>
 </div>
 <div>
@@ -114,11 +105,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>one</span></td>
+<td>one</td>
 </tr>
 <tr>
 <td><strong>a</strong></td>
-<td><span>one</span></td>
+<td>one</td>
 </tr>
 </tbody>
 </table>
@@ -128,8 +119,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="g1">g1</h2>
 <div>
-<span>g1 brief</span>
-
+<p>g1 brief</p>
 </div>
 </div>
 <div>
@@ -138,9 +128,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param-duplicate.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g1(int a);
-
-</code>
+g1(int a);</code>
 </pre>
 </div>
 <div>
@@ -155,11 +143,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>one</span></td>
+<td>one</td>
 </tr>
 <tr>
 <td><strong>b</strong></td>
-<td><span>two</span></td>
+<td>two</td>
 </tr>
 </tbody>
 </table>
@@ -169,8 +157,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="h0">h0</h2>
 <div>
-<span>h0 brief</span>
-
+<p>h0 brief</p>
 </div>
 </div>
 <div>
@@ -180,9 +167,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
 void
-h0();
-
-</code>
+h0();</code>
 </pre>
 </div>
 <div>
@@ -197,11 +182,11 @@ <h3>Template Parameters</h3>
 <tbody>
 <tr>
 <td><strong>T</strong></td>
-<td><span>one</span></td>
+<td>one</td>
 </tr>
 <tr>
 <td><strong>T</strong></td>
-<td><span>one</span></td>
+<td>one</td>
 </tr>
 </tbody>
 </table>
@@ -211,8 +196,7 @@ <h3>Template Parameters</h3>
 <div>
 <h2 id="h1">h1</h2>
 <div>
-<span>h1 brief</span>
-
+<p>h1 brief</p>
 </div>
 </div>
 <div>
@@ -222,9 +206,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
 void
-h1();
-
-</code>
+h1();</code>
 </pre>
 </div>
 <div>
@@ -239,11 +221,11 @@ <h3>Template Parameters</h3>
 <tbody>
 <tr>
 <td><strong>T</strong></td>
-<td><span>one</span></td>
+<td>one</td>
 </tr>
 <tr>
 <td><strong>U</strong></td>
-<td><span>two</span></td>
+<td>two</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/javadoc/param/param.adoc b/test-files/golden-tests/javadoc/param/param.adoc
index b1af2b5a7..f1e7bb06f 100644
--- a/test-files/golden-tests/javadoc/param/param.adoc
+++ b/test-files/golden-tests/javadoc/param/param.adoc
@@ -6,18 +6,13 @@
 
 === Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#f[`f`] 
-| 
 | link:#g[`g`] 
-| 
 | link:#h[`h`] 
-| 
 | link:#i[`i`] 
-| 
 |===
 
 [#f]
@@ -40,7 +35,7 @@ f(int x);
 | Name
 | Description
 | *x*
-| 
+| An integer `x`
 |===
 
 [#g]
@@ -65,9 +60,9 @@ g(
 | Name
 | Description
 | *x*
-| 
+| An integer `x`
 | *y*
-| 
+| An integer `y`
 |===
 
 [#h]
@@ -93,11 +88,11 @@ h(
 | Name
 | Description
 | *x*
-| 
+| An integer `x`
 | *y*
-| 
+| An integer `y`
 | *z*
-| 
+| An integer `z`
 |===
 
 [#i]
@@ -124,13 +119,13 @@ i(
 | Name
 | Description
 | *w*
-| 
+| An integer `w`
 | *x*
-| 
+| An integer `x`
 | *y*
-| 
+| An integer `y`
 | *z*
-| 
+| An integer `z`
 |===
 
 
diff --git a/test-files/golden-tests/javadoc/param/param.cpp b/test-files/golden-tests/javadoc/param/param.cpp
index 0790e643b..1cf9be503 100644
--- a/test-files/golden-tests/javadoc/param/param.cpp
+++ b/test-files/golden-tests/javadoc/param/param.cpp
@@ -1,25 +1,25 @@
 /**
- * @param x
+ * @param x An integer `x`
 **/
 void f(int x) { }
 
 /**
- * @param x
- * @param y
+ * @param x An integer `x`
+ * @param y An integer `y`
 **/
 void g(int x, int y) { }
 
 /**
- * @param x
- * @param y
- * @param z
+ * @param x An integer `x`
+ * @param y An integer `y`
+ * @param z An integer `z`
 **/
 void h(int x, int y, int z) { }
 
 /**
- * @param w
- * @param x
- * @param y
- * @param z
+ * @param w An integer `w`
+ * @param x An integer `x`
+ * @param y An integer `y`
+ * @param z An integer `z`
 **/
 void i(int w, int x, int y, int z) { }
diff --git a/test-files/golden-tests/javadoc/param/param.html b/test-files/golden-tests/javadoc/param/param.html
index 018cc9243..e1d0e4b75 100644
--- a/test-files/golden-tests/javadoc/param/param.html
+++ b/test-files/golden-tests/javadoc/param/param.html
@@ -14,15 +14,14 @@ <h2>Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#g"><code>g</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#h"><code>h</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#i"><code>i</code></a> </td><td><span></span></td></tr>
+<td><a href="#f"><code>f</code></a> </td></tr><tr>
+<td><a href="#g"><code>g</code></a> </td></tr><tr>
+<td><a href="#h"><code>h</code></a> </td></tr><tr>
+<td><a href="#i"><code>i</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -37,9 +36,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;param.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(int x);
-
-</code>
+f(int x);</code>
 </pre>
 </div>
 <div>
@@ -54,7 +51,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>x</strong></td>
-<td><span></span></td>
+<td>An integer <code>x</code></td>
 </tr>
 </tbody>
 </table>
@@ -72,9 +69,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">void
 g(
     int x,
-    int y);
-
-</code>
+    int y);</code>
 </pre>
 </div>
 <div>
@@ -89,11 +84,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>x</strong></td>
-<td><span></span></td>
+<td>An integer <code>x</code></td>
 </tr>
 <tr>
 <td><strong>y</strong></td>
-<td><span></span></td>
+<td>An integer <code>y</code></td>
 </tr>
 </tbody>
 </table>
@@ -112,9 +107,7 @@ <h3>Synopsis</h3>
 h(
     int x,
     int y,
-    int z);
-
-</code>
+    int z);</code>
 </pre>
 </div>
 <div>
@@ -129,15 +122,15 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>x</strong></td>
-<td><span></span></td>
+<td>An integer <code>x</code></td>
 </tr>
 <tr>
 <td><strong>y</strong></td>
-<td><span></span></td>
+<td>An integer <code>y</code></td>
 </tr>
 <tr>
 <td><strong>z</strong></td>
-<td><span></span></td>
+<td>An integer <code>z</code></td>
 </tr>
 </tbody>
 </table>
@@ -157,9 +150,7 @@ <h3>Synopsis</h3>
     int w,
     int x,
     int y,
-    int z);
-
-</code>
+    int z);</code>
 </pre>
 </div>
 <div>
@@ -174,19 +165,19 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>w</strong></td>
-<td><span></span></td>
+<td>An integer <code>w</code></td>
 </tr>
 <tr>
 <td><strong>x</strong></td>
-<td><span></span></td>
+<td>An integer <code>x</code></td>
 </tr>
 <tr>
 <td><strong>y</strong></td>
-<td><span></span></td>
+<td>An integer <code>y</code></td>
 </tr>
 <tr>
 <td><strong>z</strong></td>
-<td><span></span></td>
+<td>An integer <code>z</code></td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/javadoc/param/param.xml b/test-files/golden-tests/javadoc/param/param.xml
index 70aaa0e21..6b86f1c59 100644
--- a/test-files/golden-tests/javadoc/param/param.xml
+++ b/test-files/golden-tests/javadoc/param/param.xml
@@ -9,6 +9,8 @@
     </param>
     <doc>
       <param name="x">
+        <text>An integer </text>
+        <mono>x</mono>
       </param>
     </doc>
   </function>
@@ -22,8 +24,12 @@
     </param>
     <doc>
       <param name="x">
+        <text>An integer </text>
+        <mono>x</mono>
       </param>
       <param name="y">
+        <text>An integer </text>
+        <mono>y</mono>
       </param>
     </doc>
   </function>
@@ -40,10 +46,16 @@
     </param>
     <doc>
       <param name="x">
+        <text>An integer </text>
+        <mono>x</mono>
       </param>
       <param name="y">
+        <text>An integer </text>
+        <mono>y</mono>
       </param>
       <param name="z">
+        <text>An integer </text>
+        <mono>z</mono>
       </param>
     </doc>
   </function>
@@ -63,12 +75,20 @@
     </param>
     <doc>
       <param name="w">
+        <text>An integer </text>
+        <mono>w</mono>
       </param>
       <param name="x">
+        <text>An integer </text>
+        <mono>x</mono>
       </param>
       <param name="y">
+        <text>An integer </text>
+        <mono>y</mono>
       </param>
       <param name="z">
+        <text>An integer </text>
+        <mono>z</mono>
       </param>
     </doc>
   </function>
diff --git a/test-files/golden-tests/javadoc/pre/pre-post.adoc b/test-files/golden-tests/javadoc/pre/pre-post.adoc
index cbdb8096b..c0e14005f 100644
--- a/test-files/golden-tests/javadoc/pre/pre-post.adoc
+++ b/test-files/golden-tests/javadoc/pre/pre-post.adoc
@@ -6,12 +6,10 @@
 
 === Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#f[`f`] 
-| 
 |===
 
 [#f]
diff --git a/test-files/golden-tests/javadoc/pre/pre-post.html b/test-files/golden-tests/javadoc/pre/pre-post.html
index b54fa0958..05a53b720 100644
--- a/test-files/golden-tests/javadoc/pre/pre-post.html
+++ b/test-files/golden-tests/javadoc/pre/pre-post.html
@@ -14,12 +14,11 @@ <h2>Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span></span></td></tr>
+<td><a href="#f"><code>f</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -34,22 +33,20 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;pre-post.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 <div>
 <h3>Preconditions</h3>
 <ul>
-<li><span>first precondition</span></li>
-<li><span>second precondition</span></li>
+<li>first precondition</li>
+<li>second precondition</li>
 </ul>
 </div>
 <div>
 <h3>Postconditions</h3>
 <ul>
-<li><span>first postcondition</span></li>
+<li>first postcondition</li>
 </ul>
 </div>
 </div>
diff --git a/test-files/golden-tests/javadoc/ref/broken-ref.html b/test-files/golden-tests/javadoc/ref/broken-ref.html
index 9e98684a5..c5d4c4ca5 100644
--- a/test-files/golden-tests/javadoc/ref/broken-ref.html
+++ b/test-files/golden-tests/javadoc/ref/broken-ref.html
@@ -19,8 +19,8 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f0"><code>f0</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#f1"><code>f1</code></a> </td><td><span>See <a href="#f0"><code>f0</code></a></span></td></tr>
+<td><a href="#f0"><code>f0</code></a> </td><td></td></tr><tr>
+<td><a href="#f1"><code>f1</code></a> </td><td>See <a href="#f0"><code>f0</code></a></td></tr>
 </tbody>
 </table>
 
@@ -35,9 +35,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;broken-ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -45,8 +43,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f1">f1</h2>
 <div>
-<span>See <a href="#f0"><code>f0</code></a></span>
-
+<p>See <a href="#f0"><code>f0</code></a></p>
 </div>
 </div>
 <div>
@@ -55,9 +52,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;broken-ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 <div>
diff --git a/test-files/golden-tests/javadoc/ref/parent_context.adoc b/test-files/golden-tests/javadoc/ref/parent_context.adoc
index a1ef66643..af8e530e7 100644
--- a/test-files/golden-tests/javadoc/ref/parent_context.adoc
+++ b/test-files/golden-tests/javadoc/ref/parent_context.adoc
@@ -36,12 +36,10 @@
 
 === Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#boost-openmethod-final_virtual_ptr-04[`final&lowbar;virtual&lowbar;ptr`] 
-| 
 |===
 
 [#boost-openmethod-policies]
diff --git a/test-files/golden-tests/javadoc/ref/parent_context.html b/test-files/golden-tests/javadoc/ref/parent_context.html
index a1b5e20a9..b571eebf8 100644
--- a/test-files/golden-tests/javadoc/ref/parent_context.html
+++ b/test-files/golden-tests/javadoc/ref/parent_context.html
@@ -63,12 +63,11 @@ <h2>Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#boost-openmethod-final_virtual_ptr-04"><code>final_virtual_ptr</code></a> </td><td><span></span></td></tr>
+<td><a href="#boost-openmethod-final_virtual_ptr-04"><code>final_virtual_ptr</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -105,7 +104,7 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#boost-openmethod-policies-runtime_checks-runtime_checks"><code>runtime_checks</code></a> </td><td><span>Documentation with ref to final_virtual_ptr</span></td></tr>
+<td><a href="#boost-openmethod-policies-runtime_checks-runtime_checks"><code>runtime_checks</code></a> </td><td>Documentation with ref to final_virtual_ptr</td></tr>
 </tbody>
 </table>
 
@@ -114,8 +113,7 @@ <h2>Types</h2>
 <div>
 <h2 id="boost-openmethod-policies-runtime_checks-runtime_checks">boost::openmethod::policies::runtime_checks::runtime_checks</h2>
 <div>
-<span>Documentation with ref to final_virtual_ptr</span>
-
+<p>Documentation with ref to final_virtual_ptr</p>
 </div>
 </div>
 <div>
@@ -123,9 +121,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;parent_context.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct runtime_checks;
-
-</code>
+<code class="source-code cpp">struct runtime_checks;</code>
 </pre>
 </div>
 
@@ -147,9 +143,7 @@ <h3>Synopses</h3>
 <pre>
 <code class="source-code cpp">template&lt;class Arg&gt;
 auto
-<a href="#boost-openmethod-final_virtual_ptr-08">final_virtual_ptr</a>(Arg&& obj);
-
-</code>
+<a href="#boost-openmethod-final_virtual_ptr-08">final_virtual_ptr</a>(Arg&& obj);</code>
 </pre><span class="small"><a href="#boost-openmethod-final_virtual_ptr-08"><em>» more...</em></a></span>
 
 
@@ -158,9 +152,7 @@ <h3>Synopses</h3>
     class Registry,
     typename Arg&gt;
 auto
-<a href="#boost-openmethod-final_virtual_ptr-03">final_virtual_ptr</a>(Arg&& obj);
-
-</code>
+<a href="#boost-openmethod-final_virtual_ptr-03">final_virtual_ptr</a>(Arg&& obj);</code>
 </pre><span class="small"><a href="#boost-openmethod-final_virtual_ptr-03"><em>» more...</em></a></span>
 
 
@@ -177,9 +169,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;class Arg&gt;
 auto
-final_virtual_ptr(Arg&& obj);
-
-</code>
+final_virtual_ptr(Arg&& obj);</code>
 </pre>
 </div>
 </div>
@@ -196,9 +186,7 @@ <h3>Synopsis</h3>
     class Registry,
     typename Arg&gt;
 auto
-final_virtual_ptr(Arg&& obj);
-
-</code>
+final_virtual_ptr(Arg&& obj);</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/javadoc/ref/parent_context.xml b/test-files/golden-tests/javadoc/ref/parent_context.xml
index 26c885851..932c8d6b7 100644
--- a/test-files/golden-tests/javadoc/ref/parent_context.xml
+++ b/test-files/golden-tests/javadoc/ref/parent_context.xml
@@ -7,7 +7,7 @@
       <namespace name="policies" id="iyqzr2bAIIz4tcVOh2wjYTkCOC0=">
         <namespace name="runtime_checks" id="TVhmFYxnwUAmcG327zb+ghem758=">
           <struct name="runtime_checks" id="1Jkj+l8tdM+DGWC1GVMWML70iGA=">
-            <file short-path="parent_context.cpp" source-path="parent_context.cpp" line="14" class="def"/>
+            <file short-path="parent_context.cpp" source-path="parent_context.cpp" line="14"/>
             <doc>
               <brief>
                 <text>Documentation with ref to final_virtual_ptr</text>
diff --git a/test-files/golden-tests/javadoc/ref/punctuation.html b/test-files/golden-tests/javadoc/ref/punctuation.html
index ea20b9166..7fcc22732 100644
--- a/test-files/golden-tests/javadoc/ref/punctuation.html
+++ b/test-files/golden-tests/javadoc/ref/punctuation.html
@@ -19,9 +19,9 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f0"><code>f0</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#f1"><code>f1</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#f2"><code>f2</code></a> </td><td><span>See <a href="#f0"><code>f0</code></a>, <a href="#f1"><code>f1</code></a>.</span></td></tr>
+<td><a href="#f0"><code>f0</code></a> </td><td></td></tr><tr>
+<td><a href="#f1"><code>f1</code></a> </td><td></td></tr><tr>
+<td><a href="#f2"><code>f2</code></a> </td><td>See <a href="#f0"><code>f0</code></a>, <a href="#f1"><code>f1</code></a>.</td></tr>
 </tbody>
 </table>
 
@@ -36,9 +36,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;punctuation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -52,9 +50,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;punctuation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -62,8 +58,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f2">f2</h2>
 <div>
-<span>See <a href="#f0"><code>f0</code></a>, <a href="#f1"><code>f1</code></a>.</span>
-
+<p>See <a href="#f0"><code>f0</code></a>, <a href="#f1"><code>f1</code></a>.</p>
 </div>
 </div>
 <div>
@@ -72,9 +67,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;punctuation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/javadoc/ref/ref.html b/test-files/golden-tests/javadoc/ref/ref.html
index 11b42ac3a..30eb752f0 100644
--- a/test-files/golden-tests/javadoc/ref/ref.html
+++ b/test-files/golden-tests/javadoc/ref/ref.html
@@ -45,9 +45,9 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f0"><code>f0</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#f5"><code>f5</code></a> </td><td><span>See <a href="#A-f1"><code>A::f1</code></a></span></td></tr><tr>
-<td><a href="#f6"><code>f6</code></a> </td><td><span>See <a href="#F-operator_bitnot"><code>F::operator~</code></a></span></td></tr>
+<td><a href="#f0"><code>f0</code></a> </td><td></td></tr><tr>
+<td><a href="#f5"><code>f5</code></a> </td><td>See <a href="#A-f1"><code>A::f1</code></a></td></tr><tr>
+<td><a href="#f6"><code>f6</code></a> </td><td>See <a href="#F-operator_bitnot"><code>F::operator~</code></a></td></tr>
 </tbody>
 </table>
 
@@ -66,9 +66,9 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-B"><code>B</code></a> </td><td><span>See <a href="#A-f1"><code>f1</code></a></span></td></tr><tr>
-<td><a href="#A-C"><code>C</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#A-D"><code>D</code></a> </td><td><span></span></td></tr>
+<td><a href="#A-B"><code>B</code></a> </td><td>See <a href="#A-f1"><code>f1</code></a></td></tr><tr>
+<td><a href="#A-C"><code>C</code></a> </td><td></td></tr><tr>
+<td><a href="#A-D"><code>D</code></a> </td><td></td></tr>
 </tbody>
 </table>
 
@@ -82,7 +82,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-f1"><code>f1</code></a> </td><td><span>See <a href="#f0"><code>f0</code></a></span></td></tr>
+<td><a href="#A-f1"><code>f1</code></a> </td><td>See <a href="#f0"><code>f0</code></a></td></tr>
 </tbody>
 </table>
 
@@ -91,8 +91,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="A-B">A::B</h2>
 <div>
-<span>See <a href="#A-f1"><code>f1</code></a></span>
-
+<p>See <a href="#A-f1"><code>f1</code></a></p>
 </div>
 </div>
 <div>
@@ -101,9 +100,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -137,9 +134,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -152,9 +147,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct C;
-
-</code>
+<code class="source-code cpp">struct C;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -184,7 +177,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#A-D"><code>D</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -199,9 +192,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f3();
-
-</code>
+f3();</code>
 </pre>
 </div>
 </div>
@@ -215,9 +206,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f4();
-
-</code>
+f4();</code>
 </pre>
 </div>
 </div>
@@ -231,9 +220,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct D
-    : <a href="#A-C">C</a>
-
-</code>
+    : <a href="#A-C">C</a></code>
 </pre>
 </div>
 <div>
@@ -246,7 +233,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#A-C">C</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#A-C">C</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -260,7 +247,7 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-D-E"><code>E</code></a> </td><td><span>See <a href="#A-C-f3"><code>f3</code></a></span></td></tr>
+<td><a href="#A-D-E"><code>E</code></a> </td><td>See <a href="#A-C-f3"><code>f3</code></a></td></tr>
 </tbody>
 </table>
 
@@ -285,8 +272,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="A-D-E">A::D::E</h2>
 <div>
-<span>See <a href="#A-C-f3"><code>f3</code></a></span>
-
+<p>See <a href="#A-C-f3"><code>f3</code></a></p>
 </div>
 </div>
 <div>
@@ -294,9 +280,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct E;
-
-</code>
+<code class="source-code cpp">struct E;</code>
 </pre>
 </div>
 
@@ -317,9 +301,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f4();
-
-</code>
+f4();</code>
 </pre>
 </div>
 </div>
@@ -327,8 +309,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="A-f1">A::f1</h2>
 <div>
-<span>See <a href="#f0"><code>f0</code></a></span>
-
+<p>See <a href="#f0"><code>f0</code></a></p>
 </div>
 </div>
 <div>
@@ -337,9 +318,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 <div>
@@ -356,9 +335,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct F;
-
-</code>
+<code class="source-code cpp">struct F;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -425,9 +402,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator&#x3D;(<a href="#F">F</a>& other);
-
-</code>
+operator&#x3D;(<a href="#F">F</a>& other);</code>
 </pre>
 </div>
 </div>
@@ -441,9 +416,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator%(<a href="#F">F</a>& rhs);
-
-</code>
+operator%(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -457,9 +430,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator%&#x3D;(<a href="#F">F</a>& rhs);
-
-</code>
+operator%&#x3D;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -473,9 +444,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator&amp;(<a href="#F">F</a>& rhs);
-
-</code>
+operator&amp;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -489,9 +458,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator&amp;&amp;(<a href="#F">F</a>& rhs);
-
-</code>
+operator&amp;&amp;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -505,9 +472,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator&amp;&#x3D;(<a href="#F">F</a>& rhs);
-
-</code>
+operator&amp;&#x3D;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -521,9 +486,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator()(<a href="#F">F</a>& rhs);
-
-</code>
+operator()(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -537,9 +500,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator*(<a href="#F">F</a>& rhs);
-
-</code>
+operator*(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -553,9 +514,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator*&#x3D;(<a href="#F">F</a>& rhs);
-
-</code>
+operator*&#x3D;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -569,9 +528,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator+(<a href="#F">F</a>& rhs);
-
-</code>
+operator+(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -585,9 +542,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator++();
-
-</code>
+operator++();</code>
 </pre>
 </div>
 </div>
@@ -601,9 +556,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator+&#x3D;(<a href="#F">F</a>& rhs);
-
-</code>
+operator+&#x3D;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -617,9 +570,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator,(<a href="#F">F</a>& rhs);
-
-</code>
+operator,(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -633,9 +584,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator-(<a href="#F">F</a>& rhs);
-
-</code>
+operator-(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -649,9 +598,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator--();
-
-</code>
+operator--();</code>
 </pre>
 </div>
 </div>
@@ -665,9 +612,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator-&#x3D;(<a href="#F">F</a>& rhs);
-
-</code>
+operator-&#x3D;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -681,9 +626,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator-&gt;();
-
-</code>
+operator-&gt;();</code>
 </pre>
 </div>
 </div>
@@ -697,9 +640,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator-&gt;*(<a href="#F">F</a>& rhs);
-
-</code>
+operator-&gt;*(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -713,9 +654,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator/(<a href="#F">F</a>& rhs);
-
-</code>
+operator/(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -729,9 +668,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator/&#x3D;(<a href="#F">F</a>& rhs);
-
-</code>
+operator/&#x3D;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -745,9 +682,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator&lt;&lt;&#x3D;(<a href="#F">F</a>& rhs);
-
-</code>
+operator&lt;&lt;&#x3D;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -761,9 +696,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator&gt;&gt;(<a href="#F">F</a>& rhs);
-
-</code>
+operator&gt;&gt;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -777,9 +710,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator&gt;&gt;&#x3D;(<a href="#F">F</a>& rhs);
-
-</code>
+operator&gt;&gt;&#x3D;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -793,9 +724,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator[](<a href="#F">F</a>& rhs);
-
-</code>
+operator[](<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -809,9 +738,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator^(<a href="#F">F</a>& rhs);
-
-</code>
+operator^(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -825,9 +752,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator^&#x3D;(<a href="#F">F</a>& rhs);
-
-</code>
+operator^&#x3D;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -841,9 +766,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator|(<a href="#F">F</a>& rhs);
-
-</code>
+operator|(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -857,9 +780,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator|&#x3D;(<a href="#F">F</a>& rhs);
-
-</code>
+operator|&#x3D;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -873,9 +794,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator||(<a href="#F">F</a>& rhs);
-
-</code>
+operator||(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -889,9 +808,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator~();
-
-</code>
+operator~();</code>
 </pre>
 </div>
 </div>
@@ -905,9 +822,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator&lt;&lt;(<a href="#F">F</a>& rhs);
-
-</code>
+operator&lt;&lt;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -921,9 +836,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator!();
-
-</code>
+operator!();</code>
 </pre>
 </div>
 </div>
@@ -937,9 +850,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator&#x3D;&#x3D;(<a href="#F">F</a>& rhs);
-
-</code>
+operator&#x3D;&#x3D;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -953,9 +864,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator!&#x3D;(<a href="#F">F</a>& rhs);
-
-</code>
+operator!&#x3D;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -969,9 +878,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator&lt;(<a href="#F">F</a>& rhs);
-
-</code>
+operator&lt;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -985,9 +892,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator&lt;&#x3D;(<a href="#F">F</a>& rhs);
-
-</code>
+operator&lt;&#x3D;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -1001,9 +906,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator&gt;(<a href="#F">F</a>& rhs);
-
-</code>
+operator&gt;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -1017,9 +920,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator&gt;&#x3D;(<a href="#F">F</a>& rhs);
-
-</code>
+operator&gt;&#x3D;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -1033,9 +934,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator&lt;&#x3D;&gt;(<a href="#F">F</a>& rhs);
-
-</code>
+operator&lt;&#x3D;&gt;(<a href="#F">F</a>& rhs);</code>
 </pre>
 </div>
 </div>
@@ -1049,9 +948,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -1059,8 +956,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f5">f5</h2>
 <div>
-<span>See <a href="#A-f1"><code>A::f1</code></a></span>
-
+<p>See <a href="#A-f1"><code>A::f1</code></a></p>
 </div>
 </div>
 <div>
@@ -1069,9 +965,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 <div>
@@ -1083,8 +977,7 @@ <h3>Description</h3>
 <div>
 <h2 id="f6">f6</h2>
 <div>
-<span>See <a href="#F-operator_bitnot"><code>F::operator~</code></a></span>
-
+<p>See <a href="#F-operator_bitnot"><code>F::operator~</code></a></p>
 </div>
 </div>
 <div>
@@ -1093,9 +986,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 <div>
diff --git a/test-files/golden-tests/javadoc/relates/relates.html b/test-files/golden-tests/javadoc/relates/relates.html
index 5477de080..1768c86ec 100644
--- a/test-files/golden-tests/javadoc/relates/relates.html
+++ b/test-files/golden-tests/javadoc/relates/relates.html
@@ -19,8 +19,8 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A"><code>A</code></a> </td><td><span>A brief for A.</span></td></tr><tr>
-<td><a href="#B"><code>B</code></a> </td><td><span>A brief for B</span></td></tr>
+<td><a href="#A"><code>A</code></a> </td><td>A brief for A.</td></tr><tr>
+<td><a href="#B"><code>B</code></a> </td><td>A brief for B</td></tr>
 </tbody>
 </table>
 
@@ -34,7 +34,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>A brief for f.</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>A brief for f.</td></tr>
 </tbody>
 </table>
 
@@ -43,8 +43,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="A">A</h2>
 <div>
-<span>A brief for A.</span>
-
+<p>A brief for A.</p>
 </div>
 </div>
 <div>
@@ -52,9 +51,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;relates.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 
@@ -69,7 +66,7 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#f"><code>f</code></a></td><td><span>A brief for f.</span></td></tr>
+<tr><td><a href="#f"><code>f</code></a></td><td>A brief for f.</td></tr>
 </tbody>
 </table>
 </div>
@@ -78,8 +75,7 @@ <h2>Non-Member Functions</h2>
 <div>
 <h2 id="B">B</h2>
 <div>
-<span>A brief for B</span>
-
+<p>A brief for B</p>
 </div>
 </div>
 <div>
@@ -87,9 +83,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;relates.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct B;
-
-</code>
+<code class="source-code cpp">struct B;</code>
 </pre>
 </div>
 
@@ -99,8 +93,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>A brief for f.</span>
-
+<p>A brief for f.</p>
 </div>
 </div>
 <div>
@@ -109,9 +102,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;relates.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/javadoc/returns/returns.adoc b/test-files/golden-tests/javadoc/returns/returns.adoc
index 777d3a197..671c43c1a 100644
--- a/test-files/golden-tests/javadoc/returns/returns.adoc
+++ b/test-files/golden-tests/javadoc/returns/returns.adoc
@@ -6,12 +6,10 @@
 
 === Types
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#pair[`pair`] 
-| 
 |===
 
 === Functions
diff --git a/test-files/golden-tests/javadoc/returns/returns.html b/test-files/golden-tests/javadoc/returns/returns.html
index 3e04fbaf3..ff55927bd 100644
--- a/test-files/golden-tests/javadoc/returns/returns.html
+++ b/test-files/golden-tests/javadoc/returns/returns.html
@@ -14,12 +14,11 @@ <h2>Types</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#pair"><code>pair</code></a> </td><td><span></span></td></tr>
+<td><a href="#pair"><code>pair</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -33,8 +32,8 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>A function with a single return value.</span></td></tr><tr>
-<td><a href="#g"><code>g</code></a> </td><td><span>A function with multiple return values.</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>A function with a single return value.</td></tr><tr>
+<td><a href="#g"><code>g</code></a> </td><td>A function with multiple return values.</td></tr>
 </tbody>
 </table>
 
@@ -51,9 +50,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     class T,
     class U&gt;
-struct pair;
-
-</code>
+struct pair;</code>
 </pre>
 </div>
 <h2>Data Members</h2>
@@ -82,7 +79,7 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#g"><code>g</code></a></td><td><span>A function with multiple return values.</span></td></tr>
+<tr><td><a href="#g"><code>g</code></a></td><td>A function with multiple return values.</td></tr>
 </tbody>
 </table>
 </div>
@@ -96,9 +93,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;returns.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">T first;
-
-</code>
+<code class="source-code cpp">T first;</code>
 </pre>
 </div>
 </div>
@@ -111,9 +106,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;returns.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">U second;
-
-</code>
+<code class="source-code cpp">U second;</code>
 </pre>
 </div>
 </div>
@@ -121,8 +114,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>A function with a single return value.</span>
-
+<p>A function with a single return value.</p>
 </div>
 </div>
 <div>
@@ -131,22 +123,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;returns.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The return value of the function.</span>
+The return value of the function.
 </div>
 </div>
 <div>
 <div>
 <h2 id="g">g</h2>
 <div>
-<span>A function with multiple return values.</span>
-
+<p>A function with multiple return values.</p>
 </div>
 </div>
 <div>
@@ -155,16 +144,14 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;returns.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#pair">pair&lt;int, int&gt;</a>
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
 <ul>
-<li><span>The first return value of the function.</span></li>
-<li><span>The second return value of the function.</span></li>
+<li>The first return value of the function.</li>
+<li>The second return value of the function.</li>
 </ul>
 </div>
 </div>
diff --git a/test-files/golden-tests/javadoc/throw/throw.html b/test-files/golden-tests/javadoc/throw/throw.html
index 35d763f5e..e35235544 100644
--- a/test-files/golden-tests/javadoc/throw/throw.html
+++ b/test-files/golden-tests/javadoc/throw/throw.html
@@ -19,7 +19,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>brief</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>brief</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>brief</span>
-
+<p>brief</p>
 </div>
 </div>
 <div>
@@ -38,9 +37,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;throw.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 <div>
@@ -55,7 +52,7 @@ <h3>Exceptions</h3>
 <tbody>
 <tr>
 <td><code>std::length_error</code></td>
-<td><span><code>dest_size &lt; ipv4_address::max_str_len</code></span></td>
+<td><code>dest_size &lt; ipv4_address::max_str_len</code></td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/javadoc/tparam/tparam-1.adoc b/test-files/golden-tests/javadoc/tparam/tparam-1.adoc
index 842062aeb..d85a5ad00 100644
--- a/test-files/golden-tests/javadoc/tparam/tparam-1.adoc
+++ b/test-files/golden-tests/javadoc/tparam/tparam-1.adoc
@@ -37,7 +37,7 @@ f0();
 | Name
 | Description
 | *T*
-| 
+| Template parameter `T`
 |===
 
 [#f1]
diff --git a/test-files/golden-tests/javadoc/tparam/tparam-1.cpp b/test-files/golden-tests/javadoc/tparam/tparam-1.cpp
index 045b66ccb..e910e90fe 100644
--- a/test-files/golden-tests/javadoc/tparam/tparam-1.cpp
+++ b/test-files/golden-tests/javadoc/tparam/tparam-1.cpp
@@ -1,4 +1,4 @@
-/// @tparam T
+/// @tparam T Template parameter `T`
 template<class T>
 void f0();
 
diff --git a/test-files/golden-tests/javadoc/tparam/tparam-1.html b/test-files/golden-tests/javadoc/tparam/tparam-1.html
index a29cc323d..fd1ad2863 100644
--- a/test-files/golden-tests/javadoc/tparam/tparam-1.html
+++ b/test-files/golden-tests/javadoc/tparam/tparam-1.html
@@ -19,8 +19,8 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f0"><code>f0</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#f1"><code>f1</code></a> </td><td><span>brief</span></td></tr>
+<td><a href="#f0"><code>f0</code></a> </td><td></td></tr><tr>
+<td><a href="#f1"><code>f1</code></a> </td><td>brief</td></tr>
 </tbody>
 </table>
 
@@ -36,9 +36,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;class T&gt;
 void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 <div>
@@ -53,7 +51,7 @@ <h3>Template Parameters</h3>
 <tbody>
 <tr>
 <td><strong>T</strong></td>
-<td><span></span></td>
+<td>Template parameter <code>T</code></td>
 </tr>
 </tbody>
 </table>
@@ -63,8 +61,7 @@ <h3>Template Parameters</h3>
 <div>
 <h2 id="f1">f1</h2>
 <div>
-<span>brief</span>
-
+<p>brief</p>
 </div>
 </div>
 <div>
@@ -74,9 +71,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;class T&gt;
 void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 <div>
@@ -95,7 +90,7 @@ <h3>Template Parameters</h3>
 <tbody>
 <tr>
 <td><strong>T</strong></td>
-<td><span>type</span></td>
+<td>type</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/javadoc/tparam/tparam-1.xml b/test-files/golden-tests/javadoc/tparam/tparam-1.xml
index 80b3716df..9e4e5706f 100644
--- a/test-files/golden-tests/javadoc/tparam/tparam-1.xml
+++ b/test-files/golden-tests/javadoc/tparam/tparam-1.xml
@@ -8,6 +8,8 @@
       <file short-path="tparam-1.cpp" source-path="tparam-1.cpp" line="2"/>
       <doc>
         <tparam name="T">
+          <text>Template parameter </text>
+          <mono>T</mono>
         </tparam>
       </doc>
     </function>
diff --git a/test-files/golden-tests/output/canonical_1.html b/test-files/golden-tests/output/canonical_1.html
index c5b115cc8..b4fea15a5 100644
--- a/test-files/golden-tests/output/canonical_1.html
+++ b/test-files/golden-tests/output/canonical_1.html
@@ -39,9 +39,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;canonical_1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 
@@ -56,9 +54,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;canonical_1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct B;
-
-</code>
+<code class="source-code cpp">struct B;</code>
 </pre>
 </div>
 
@@ -73,9 +69,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;canonical_1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct Ba;
-
-</code>
+<code class="source-code cpp">struct Ba;</code>
 </pre>
 </div>
 
@@ -90,9 +84,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;canonical_1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct Bx;
-
-</code>
+<code class="source-code cpp">struct Bx;</code>
 </pre>
 </div>
 
@@ -107,9 +99,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;canonical_1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct a;
-
-</code>
+<code class="source-code cpp">struct a;</code>
 </pre>
 </div>
 
@@ -124,9 +114,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;canonical_1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct b;
-
-</code>
+<code class="source-code cpp">struct b;</code>
 </pre>
 </div>
 
@@ -141,9 +129,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;canonical_1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct bA;
-
-</code>
+<code class="source-code cpp">struct bA;</code>
 </pre>
 </div>
 
@@ -158,9 +144,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;canonical_1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct ba;
-
-</code>
+<code class="source-code cpp">struct ba;</code>
 </pre>
 </div>
 
diff --git a/test-files/golden-tests/snippets/distance.html b/test-files/golden-tests/snippets/distance.html
index 01aeab45e..d31b597af 100644
--- a/test-files/golden-tests/snippets/distance.html
+++ b/test-files/golden-tests/snippets/distance.html
@@ -9,8 +9,7 @@ <h1>Reference</h1>
 <div>
 <h2 id="distance">distance</h2>
 <div>
-<span>Return the distance between two points</span>
-
+<p>Return the distance between two points</p>
 </div>
 </div>
 <div>
@@ -23,9 +22,7 @@ <h3>Synopsis</h3>
     double x0,
     double y0,
     double x1,
-    double y1);
-
-</code>
+    double y1);</code>
 </pre>
 </div>
 <div>
@@ -34,7 +31,7 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The distance between the two points</span>
+The distance between the two points
 </div>
 <div>
 <h3>Parameters</h3>
@@ -48,19 +45,19 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>x0</strong></td>
-<td><span>The x-coordinate of the first point</span></td>
+<td>The x-coordinate of the first point</td>
 </tr>
 <tr>
 <td><strong>y0</strong></td>
-<td><span>The y-coordinate of the first point</span></td>
+<td>The y-coordinate of the first point</td>
 </tr>
 <tr>
 <td><strong>x1</strong></td>
-<td><span>The x-coordinate of the second point</span></td>
+<td>The x-coordinate of the second point</td>
 </tr>
 <tr>
 <td><strong>y1</strong></td>
-<td><span>The y-coordinate of the second point</span></td>
+<td>The y-coordinate of the second point</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/snippets/is_prime.adoc b/test-files/golden-tests/snippets/is_prime.adoc
index 3c2597476..33eab6a6e 100644
--- a/test-files/golden-tests/snippets/is_prime.adoc
+++ b/test-files/golden-tests/snippets/is_prime.adoc
@@ -16,14 +16,13 @@ bool
 is&lowbar;prime(unsigned long long n) noexcept;
 ----
 
-=== Description
-
 === Complexity
+
 Linear in n&period;
 
 === Return Value
 
-Whether or not n is prime&period;
+Whether `n` is prime&period;
 
 === Parameters
 
diff --git a/test-files/golden-tests/snippets/is_prime.cpp b/test-files/golden-tests/snippets/is_prime.cpp
index b13810c01..9330eaf30 100644
--- a/test-files/golden-tests/snippets/is_prime.cpp
+++ b/test-files/golden-tests/snippets/is_prime.cpp
@@ -4,9 +4,8 @@
 
     Linear in n.
 
-    @return Whether or not n is prime.
+    @return Whether `n` is prime.
     @param n The number to test
-
 */
 bool
 is_prime(unsigned long long n) noexcept;
\ No newline at end of file
diff --git a/test-files/golden-tests/snippets/is_prime.html b/test-files/golden-tests/snippets/is_prime.html
index ff9dc1172..2c441454e 100644
--- a/test-files/golden-tests/snippets/is_prime.html
+++ b/test-files/golden-tests/snippets/is_prime.html
@@ -9,8 +9,7 @@ <h1>Reference</h1>
 <div>
 <h2 id="is_prime">is_prime</h2>
 <div>
-<span>Return true if a number is prime.</span>
-
+<p>Return true if a number is prime.</p>
 </div>
 </div>
 <div>
@@ -19,19 +18,16 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;is_prime.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">bool
-is_prime(unsigned long long n) noexcept;
-
-</code>
+is_prime(unsigned long long n) noexcept;</code>
 </pre>
 </div>
 <div>
-<h3>Description</h3>
-<h3>Complexity</h3>
+<h2>Complexity</h2>
 <p>Linear in n.</p>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Whether or not n is prime.</span>
+Whether <code>n</code> is prime.
 </div>
 <div>
 <h3>Parameters</h3>
@@ -45,7 +41,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>n</strong></td>
-<td><span>The number to test</span></td>
+<td>The number to test</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/snippets/is_prime.xml b/test-files/golden-tests/snippets/is_prime.xml
index de0670265..972005cd6 100644
--- a/test-files/golden-tests/snippets/is_prime.xml
+++ b/test-files/golden-tests/snippets/is_prime.xml
@@ -3,7 +3,7 @@
        xsi:noNamespaceSchemaLocation="https://github.com/cppalliance/mrdocs/raw/develop/mrdocs.rnc">
 <namespace id="//////////////////////////8=">
   <function name="is_prime" exception-spec="noexcept" id="X6uKu3BxyFPud2u42zNKbyA0XfU=">
-    <file short-path="is_prime.cpp" source-path="is_prime.cpp" line="11"/>
+    <file short-path="is_prime.cpp" source-path="is_prime.cpp" line="10"/>
     <return>
       <type name="bool"/>
     </return>
@@ -19,7 +19,9 @@
         <text>Linear in n.</text>
       </para>
       <returns>
-        <text>Whether or not n is prime.</text>
+        <text>Whether </text>
+        <mono>n</mono>
+        <text> is prime.</text>
       </returns>
       <param name="n">
         <text>The number to test</text>
diff --git a/test-files/golden-tests/snippets/sqrt.html b/test-files/golden-tests/snippets/sqrt.html
index f1b40e706..427a866e8 100644
--- a/test-files/golden-tests/snippets/sqrt.html
+++ b/test-files/golden-tests/snippets/sqrt.html
@@ -9,8 +9,7 @@ <h1>Reference</h1>
 <div>
 <h2 id="sqrt">sqrt</h2>
 <div>
-<span>Computes the square root of an integral value.</span>
-
+<p>Computes the square root of an integral value.</p>
 </div>
 </div>
 <div>
@@ -21,9 +20,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;typename T&gt;
 T
 sqrt(T value)
-requires std::is_integral_v&lt;T&gt;;
-
-</code>
+requires std::is_integral_v&lt;T&gt;;</code>
 </pre>
 </div>
 <div>
@@ -42,14 +39,14 @@ <h3>Exceptions</h3>
 <tbody>
 <tr>
 <td><code>std::invalid_argument</code></td>
-<td><span>if the input value is negative.</span></td>
+<td>if the input value is negative.</td>
 </tr>
 </tbody>
 </table>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The square root of the input value.</span>
+The square root of the input value.
 </div>
 <div>
 <h3>Template Parameters</h3>
@@ -63,7 +60,7 @@ <h3>Template Parameters</h3>
 <tbody>
 <tr>
 <td><strong>T</strong></td>
-<td><span>The type of the input value. Must be an integral type.</span></td>
+<td>The type of the input value. Must be an integral type.</td>
 </tr>
 </tbody>
 </table>
@@ -80,7 +77,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The integral value to compute the square root of.</span></td>
+<td>The integral value to compute the square root of.</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/snippets/terminate.adoc b/test-files/golden-tests/snippets/terminate.adoc
index 5798be6df..8ab1e8238 100644
--- a/test-files/golden-tests/snippets/terminate.adoc
+++ b/test-files/golden-tests/snippets/terminate.adoc
@@ -22,7 +22,10 @@ terminate() noexcept;
 The program will end immediately&period;
 
 [NOTE]
+====
 This function does not return&period;
 
+====
+
 
 [.small]#Created with https://www.mrdocs.com[MrDocs]#
diff --git a/test-files/golden-tests/snippets/terminate.html b/test-files/golden-tests/snippets/terminate.html
index 35523ee81..d81f31211 100644
--- a/test-files/golden-tests/snippets/terminate.html
+++ b/test-files/golden-tests/snippets/terminate.html
@@ -9,8 +9,7 @@ <h1>Reference</h1>
 <div>
 <h2 id="terminate">terminate</h2>
 <div>
-<span>Exit the program.</span>
-
+<p>Exit the program.</p>
 </div>
 </div>
 <div>
@@ -20,9 +19,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">[[noreturn]]
 void
-terminate() noexcept;
-
-</code>
+terminate() noexcept;</code>
 </pre>
 </div>
 <div>
@@ -30,9 +27,10 @@ <h3>Description</h3>
 <p>The program will end immediately.</p>
 <div class="admonition">
 <h4>NOTE</h4>
+<div>
 <p>This function does not return.</p>
 </div>
-</div>
+</div></div>
 </div>
 
 </div>
diff --git a/test-files/golden-tests/symbols/concept/concept.html b/test-files/golden-tests/symbols/concept/concept.html
index 8809d66f0..a0c5f3c29 100644
--- a/test-files/golden-tests/symbols/concept/concept.html
+++ b/test-files/golden-tests/symbols/concept/concept.html
@@ -60,9 +60,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;<a href="#C">C</a> T&gt;
 void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -75,9 +73,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;concept.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#C">C</a> auto x = 0;
-
-</code>
+<code class="source-code cpp"><a href="#C">C</a> auto x = 0;</code>
 </pre>
 </div>
 </div>
@@ -91,9 +87,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;concept.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-concept C = sizeof(T) &#x3D;&#x3D; sizeof(int);
-
-</code>
+concept C = sizeof(T) &#x3D;&#x3D; sizeof(int);</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/concept/requires-clause.adoc b/test-files/golden-tests/symbols/concept/requires-clause.adoc
index 766a1318c..2edd8f71d 100644
--- a/test-files/golden-tests/symbols/concept/requires-clause.adoc
+++ b/test-files/golden-tests/symbols/concept/requires-clause.adoc
@@ -15,14 +15,11 @@
 
 === Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#f[`f`] 
-| 
 | link:#g-0f[`g`] 
-| 
 |===
 
 [#A-08]
diff --git a/test-files/golden-tests/symbols/concept/requires-clause.html b/test-files/golden-tests/symbols/concept/requires-clause.html
index 2e4b2b27b..17813a4c7 100644
--- a/test-files/golden-tests/symbols/concept/requires-clause.html
+++ b/test-files/golden-tests/symbols/concept/requires-clause.html
@@ -28,13 +28,12 @@ <h2>Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#g-0f"><code>g</code></a> </td><td><span></span></td></tr>
+<td><a href="#f"><code>f</code></a> </td></tr><tr>
+<td><a href="#g-0f"><code>g</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -50,9 +49,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
 requires (sizeof(T) &#x3D;&#x3D; 2)
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 
@@ -69,9 +66,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
 requires (sizeof(U) &#x3D;&#x3D; 2)
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 
@@ -89,9 +84,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;typename T&gt;
 void
 f()
-requires (sizeof(U) &#x3D;&#x3D; 2);
-
-</code>
+requires (sizeof(U) &#x3D;&#x3D; 2);</code>
 </pre>
 </div>
 </div>
@@ -108,9 +101,7 @@ <h3>Synopses</h3>
 <code class="source-code cpp">template&lt;typename T&gt;
 requires (sizeof(T) &#x3D;&#x3D; 2)
 void
-<a href="#g-0e">g</a>();
-
-</code>
+<a href="#g-0e">g</a>();</code>
 </pre><span class="small"><a href="#g-0e"><em>» more...</em></a></span>
 
 
@@ -118,9 +109,7 @@ <h3>Synopses</h3>
 <code class="source-code cpp">template&lt;typename T&gt;
 requires (sizeof(T) &#x3D;&#x3D; 4)
 void
-<a href="#g-02">g</a>();
-
-</code>
+<a href="#g-02">g</a>();</code>
 </pre><span class="small"><a href="#g-02"><em>» more...</em></a></span>
 
 
@@ -128,9 +117,7 @@ <h3>Synopses</h3>
 <code class="source-code cpp">template&lt;typename U&gt;
 requires (sizeof(U) &#x3D;&#x3D; 2)
 void
-<a href="#g-08">g</a>();
-
-</code>
+<a href="#g-08">g</a>();</code>
 </pre><span class="small"><a href="#g-08"><em>» more...</em></a></span>
 
 
@@ -148,9 +135,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;typename T&gt;
 requires (sizeof(T) &#x3D;&#x3D; 2)
 void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
@@ -166,9 +151,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;typename T&gt;
 requires (sizeof(T) &#x3D;&#x3D; 4)
 void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
@@ -184,9 +167,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;typename U&gt;
 requires (sizeof(U) &#x3D;&#x3D; 2)
 void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/enum/enum.html b/test-files/golden-tests/symbols/enum/enum.html
index 28da750e4..656077a9f 100644
--- a/test-files/golden-tests/symbols/enum/enum.html
+++ b/test-files/golden-tests/symbols/enum/enum.html
@@ -19,10 +19,10 @@ <h2>Enums</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#E0"><code>E0</code></a> </td><td><span>E0 brief.</span></td></tr><tr>
-<td><a href="#E1"><code>E1</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#E2"><code>E2</code></a> </td><td><span>E2 brief.</span></td></tr><tr>
-<td><a href="#E3"><code>E3</code></a> </td><td><span></span></td></tr>
+<td><a href="#E0"><code>E0</code></a> </td><td>E0 brief.</td></tr><tr>
+<td><a href="#E1"><code>E1</code></a> </td><td></td></tr><tr>
+<td><a href="#E2"><code>E2</code></a> </td><td>E2 brief.</td></tr><tr>
+<td><a href="#E3"><code>E3</code></a> </td><td></td></tr>
 </tbody>
 </table>
 
@@ -31,8 +31,7 @@ <h2>Enums</h2>
 <div>
 <h2 id="E0">E0</h2>
 <div>
-<span>E0 brief.</span>
-
+<p>E0 brief.</p>
 </div>
 </div>
 <div>
@@ -40,9 +39,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;enum.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">enum E0;
-
-</code>
+<code class="source-code cpp">enum E0;</code>
 </pre>
 </div>
 <h2>Members</h2>
@@ -55,8 +52,8 @@ <h2>Members</h2>
 </thead>
 <tbody>
 <tr>
-<td><code>e0</code> </td><td><span>e0 brief.</span></td></tr><tr>
-<td><code>e1</code> </td><td><span>e1 brief.</span></td></tr>
+<td><code>e0</code> </td><td>e0 brief.</td></tr><tr>
+<td><code>e1</code> </td><td>e1 brief.</td></tr>
 </tbody>
 </table>
 
@@ -74,9 +71,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;enum.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">enum E1 : char;
-
-</code>
+<code class="source-code cpp">enum E1 : char;</code>
 </pre>
 </div>
 <h2>Members</h2>
@@ -98,8 +93,7 @@ <h2>Members</h2>
 <div>
 <h2 id="E2">E2</h2>
 <div>
-<span>E2 brief.</span>
-
+<p>E2 brief.</p>
 </div>
 </div>
 <div>
@@ -107,9 +101,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;enum.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">enum class E2 : int;
-
-</code>
+<code class="source-code cpp">enum class E2 : int;</code>
 </pre>
 </div>
 <h2>Members</h2>
@@ -122,8 +114,8 @@ <h2>Members</h2>
 </thead>
 <tbody>
 <tr>
-<td><code>e4</code> </td><td><span>e4 brief.</span></td></tr><tr>
-<td><code>e5</code> </td><td><span>e5 brief.</span></td></tr>
+<td><code>e4</code> </td><td>e4 brief.</td></tr><tr>
+<td><code>e5</code> </td><td>e5 brief.</td></tr>
 </tbody>
 </table>
 
@@ -141,9 +133,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;enum.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">enum class E3 : char;
-
-</code>
+<code class="source-code cpp">enum class E3 : char;</code>
 </pre>
 </div>
 <h2>Members</h2>
diff --git a/test-files/golden-tests/symbols/function/attributes-2.html b/test-files/golden-tests/symbols/function/attributes-2.html
index c510ae5a0..004ddec12 100644
--- a/test-files/golden-tests/symbols/function/attributes-2.html
+++ b/test-files/golden-tests/symbols/function/attributes-2.html
@@ -35,9 +35,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;class T&gt;
 [[nodiscard]]
 int
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/function/attributes_1.html b/test-files/golden-tests/symbols/function/attributes_1.html
index cb40440b7..3c67d0474 100644
--- a/test-files/golden-tests/symbols/function/attributes_1.html
+++ b/test-files/golden-tests/symbols/function/attributes_1.html
@@ -34,9 +34,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">[[nodiscard]]
 bool
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/function/auto.html b/test-files/golden-tests/symbols/function/auto.html
index 2dc16e98f..9fff4e62e 100644
--- a/test-files/golden-tests/symbols/function/auto.html
+++ b/test-files/golden-tests/symbols/function/auto.html
@@ -19,7 +19,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>A function that uses auto</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>A function that uses auto</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>A function that uses auto</span>
-
+<p>A function that uses auto</p>
 </div>
 </div>
 <div>
@@ -38,14 +37,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;auto.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int
-f(auto value);
-
-</code>
+f(auto value);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The result.</span>
+The result.
 </div>
 <div>
 <h3>Parameters</h3>
@@ -59,7 +56,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The value to use.</span></td>
+<td>The value to use.</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/symbols/function/explicit-conv-operator.html b/test-files/golden-tests/symbols/function/explicit-conv-operator.html
index d453de0a0..e8f80b495 100644
--- a/test-files/golden-tests/symbols/function/explicit-conv-operator.html
+++ b/test-files/golden-tests/symbols/function/explicit-conv-operator.html
@@ -35,9 +35,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;explicit-conv-operator.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct Explicit;
-
-</code>
+<code class="source-code cpp">struct Explicit;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -50,7 +48,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#Explicit-2conversion"><code>operator bool</code></a> </td><td><span>Conversion to <code>bool</code></span></td></tr>
+<td><a href="#Explicit-2conversion"><code>operator bool</code></a> </td><td>Conversion to <code>bool</code></td></tr>
 </tbody>
 </table>
 
@@ -61,8 +59,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="Explicit-2conversion">Explicit::operator bool</h2>
 <div>
-<span>Conversion to <code>bool</code></span>
-
+<p>Conversion to <code>bool</code></p>
 </div>
 </div>
 <div>
@@ -71,14 +68,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-conv-operator.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit
-operator bool();
-
-</code>
+operator bool();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The object converted to <code>bool</code></span>
+The object converted to <code>bool</code>
 </div>
 </div>
 <div>
@@ -91,9 +86,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-conv-operator.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;bool B&gt;
-struct ExplicitExpression;
-
-</code>
+struct ExplicitExpression;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -106,7 +99,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#ExplicitExpression-2conversion"><code>operator bool</code></a> </td><td><span>Conversion to <code>bool</code></span></td></tr>
+<td><a href="#ExplicitExpression-2conversion"><code>operator bool</code></a> </td><td>Conversion to <code>bool</code></td></tr>
 </tbody>
 </table>
 
@@ -117,8 +110,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="ExplicitExpression-2conversion">ExplicitExpression::operator bool</h2>
 <div>
-<span>Conversion to <code>bool</code></span>
-
+<p>Conversion to <code>bool</code></p>
 </div>
 </div>
 <div>
@@ -127,14 +119,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-conv-operator.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit(B)
-operator bool();
-
-</code>
+operator bool();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The object converted to <code>bool</code></span>
+The object converted to <code>bool</code>
 </div>
 </div>
 <div>
@@ -146,9 +136,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;explicit-conv-operator.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct ExplicitFalse;
-
-</code>
+<code class="source-code cpp">struct ExplicitFalse;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -161,7 +149,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#ExplicitFalse-2conversion"><code>operator bool</code></a> </td><td><span>Conversion to <code>bool</code></span></td></tr>
+<td><a href="#ExplicitFalse-2conversion"><code>operator bool</code></a> </td><td>Conversion to <code>bool</code></td></tr>
 </tbody>
 </table>
 
@@ -172,8 +160,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="ExplicitFalse-2conversion">ExplicitFalse::operator bool</h2>
 <div>
-<span>Conversion to <code>bool</code></span>
-
+<p>Conversion to <code>bool</code></p>
 </div>
 </div>
 <div>
@@ -182,14 +169,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-conv-operator.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit(false)
-operator bool();
-
-</code>
+operator bool();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The object converted to <code>bool</code></span>
+The object converted to <code>bool</code>
 </div>
 </div>
 <div>
@@ -201,9 +186,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;explicit-conv-operator.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct ExplicitTrue;
-
-</code>
+<code class="source-code cpp">struct ExplicitTrue;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -216,7 +199,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#ExplicitTrue-2conversion"><code>operator bool</code></a> </td><td><span>Conversion to <code>bool</code></span></td></tr>
+<td><a href="#ExplicitTrue-2conversion"><code>operator bool</code></a> </td><td>Conversion to <code>bool</code></td></tr>
 </tbody>
 </table>
 
@@ -227,8 +210,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="ExplicitTrue-2conversion">ExplicitTrue::operator bool</h2>
 <div>
-<span>Conversion to <code>bool</code></span>
-
+<p>Conversion to <code>bool</code></p>
 </div>
 </div>
 <div>
@@ -237,14 +219,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-conv-operator.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit(true)
-operator bool();
-
-</code>
+operator bool();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The object converted to <code>bool</code></span>
+The object converted to <code>bool</code>
 </div>
 </div>
 
diff --git a/test-files/golden-tests/symbols/function/explicit-ctor.html b/test-files/golden-tests/symbols/function/explicit-ctor.html
index 6927f3756..4f58082af 100644
--- a/test-files/golden-tests/symbols/function/explicit-ctor.html
+++ b/test-files/golden-tests/symbols/function/explicit-ctor.html
@@ -35,9 +35,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct Explicit;
-
-</code>
+<code class="source-code cpp">struct Explicit;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -50,7 +48,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#Explicit-2constructor-04"><code>Explicit</code></a>         <span class="small">[constructor]</span></td><td><span>Constructors</span></td></tr>
+<td><a href="#Explicit-2constructor-04"><code>Explicit</code></a>         <span class="small">[constructor]</span></td><td>Constructors</td></tr>
 </tbody>
 </table>
 
@@ -61,46 +59,37 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="Explicit-2constructor-04">Explicit::Explicit</h2>
 <div>
-<span>Constructors</span>
-
+<p>Constructors</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
-<span>Default constructor</span>
+<p>Default constructor</p>
 <pre>
 <code class="source-code cpp">explicit
-<a href="#Explicit-2constructor-02">Explicit</a>();
-
-</code>
+<a href="#Explicit-2constructor-02">Explicit</a>();</code>
 </pre><span class="small"><a href="#Explicit-2constructor-02"><em>» more...</em></a></span>
 
-<span>Copy constructor</span>
+<p>Copy constructor</p>
 <pre>
 <code class="source-code cpp">explicit
-<a href="#Explicit-2constructor-00">Explicit</a>(<a href="#Explicit">Explicit</a> const& other);
-
-</code>
+<a href="#Explicit-2constructor-00">Explicit</a>(<a href="#Explicit">Explicit</a> const& other);</code>
 </pre><span class="small"><a href="#Explicit-2constructor-00"><em>» more...</em></a></span>
 
-<span>Move constructor</span>
+<p>Move constructor</p>
 <pre>
 <code class="source-code cpp">explicit
-<a href="#Explicit-2constructor-0b">Explicit</a>(<a href="#Explicit">Explicit</a>&& other) noexcept;
-
-</code>
+<a href="#Explicit-2constructor-0b">Explicit</a>(<a href="#Explicit">Explicit</a>&& other) noexcept;</code>
 </pre><span class="small"><a href="#Explicit-2constructor-0b"><em>» more...</em></a></span>
 
-<span>Constructor</span>
+<p>Constructor</p>
 <pre>
 <code class="source-code cpp">explicit
 <a href="#Explicit-2constructor-03">Explicit</a>(
     int,
-    int);
-
-</code>
+    int);</code>
 </pre><span class="small"><a href="#Explicit-2constructor-03"><em>» more...</em></a></span>
 
 
@@ -110,8 +99,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="Explicit-2constructor-02">Explicit::Explicit</h2>
 <div>
-<span>Default constructor</span>
-
+<p>Default constructor</p>
 </div>
 </div>
 <div>
@@ -120,9 +108,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit
-Explicit();
-
-</code>
+Explicit();</code>
 </pre>
 </div>
 </div>
@@ -130,8 +116,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="Explicit-2constructor-00">Explicit::Explicit</h2>
 <div>
-<span>Copy constructor</span>
-
+<p>Copy constructor</p>
 </div>
 </div>
 <div>
@@ -140,9 +125,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit
-Explicit(<a href="#Explicit">Explicit</a> const& other);
-
-</code>
+Explicit(<a href="#Explicit">Explicit</a> const& other);</code>
 </pre>
 </div>
 <div>
@@ -157,7 +140,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The object to copy construct from</span></td>
+<td>The object to copy construct from</td>
 </tr>
 </tbody>
 </table>
@@ -167,8 +150,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Explicit-2constructor-0b">Explicit::Explicit</h2>
 <div>
-<span>Move constructor</span>
-
+<p>Move constructor</p>
 </div>
 </div>
 <div>
@@ -177,9 +159,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit
-Explicit(<a href="#Explicit">Explicit</a>&& other) noexcept;
-
-</code>
+Explicit(<a href="#Explicit">Explicit</a>&& other) noexcept;</code>
 </pre>
 </div>
 <div>
@@ -194,7 +174,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The object to move construct from</span></td>
+<td>The object to move construct from</td>
 </tr>
 </tbody>
 </table>
@@ -204,8 +184,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="Explicit-2constructor-03">Explicit::Explicit</h2>
 <div>
-<span>Constructor</span>
-
+<p>Constructor</p>
 </div>
 </div>
 <div>
@@ -216,9 +195,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">explicit
 Explicit(
     int,
-    int);
-
-</code>
+    int);</code>
 </pre>
 </div>
 </div>
@@ -232,9 +209,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;bool B&gt;
-struct ExplicitExpression;
-
-</code>
+struct ExplicitExpression;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -247,7 +222,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#ExplicitExpression-2constructor-07"><code>ExplicitExpression</code></a>         <span class="small">[constructor]</span></td><td><span>Constructors</span></td></tr>
+<td><a href="#ExplicitExpression-2constructor-07"><code>ExplicitExpression</code></a>         <span class="small">[constructor]</span></td><td>Constructors</td></tr>
 </tbody>
 </table>
 
@@ -258,46 +233,37 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="ExplicitExpression-2constructor-07">ExplicitExpression::ExplicitExpression</h2>
 <div>
-<span>Constructors</span>
-
+<p>Constructors</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
-<span>Default constructor</span>
+<p>Default constructor</p>
 <pre>
 <code class="source-code cpp">explicit(B)
-<a href="#ExplicitExpression-2constructor-0b">ExplicitExpression</a>();
-
-</code>
+<a href="#ExplicitExpression-2constructor-0b">ExplicitExpression</a>();</code>
 </pre><span class="small"><a href="#ExplicitExpression-2constructor-0b"><em>» more...</em></a></span>
 
-<span>Copy constructor</span>
+<p>Copy constructor</p>
 <pre>
 <code class="source-code cpp">explicit(B)
-<a href="#ExplicitExpression-2constructor-04">ExplicitExpression</a>(<a href="#ExplicitExpression">ExplicitExpression</a> const& other);
-
-</code>
+<a href="#ExplicitExpression-2constructor-04">ExplicitExpression</a>(<a href="#ExplicitExpression">ExplicitExpression</a> const& other);</code>
 </pre><span class="small"><a href="#ExplicitExpression-2constructor-04"><em>» more...</em></a></span>
 
-<span>Move constructor</span>
+<p>Move constructor</p>
 <pre>
 <code class="source-code cpp">explicit(B)
-<a href="#ExplicitExpression-2constructor-08">ExplicitExpression</a>(<a href="#ExplicitExpression">ExplicitExpression</a>&& other) noexcept;
-
-</code>
+<a href="#ExplicitExpression-2constructor-08">ExplicitExpression</a>(<a href="#ExplicitExpression">ExplicitExpression</a>&& other) noexcept;</code>
 </pre><span class="small"><a href="#ExplicitExpression-2constructor-08"><em>» more...</em></a></span>
 
-<span>Constructor</span>
+<p>Constructor</p>
 <pre>
 <code class="source-code cpp">explicit(B)
 <a href="#ExplicitExpression-2constructor-02">ExplicitExpression</a>(
     int,
-    int);
-
-</code>
+    int);</code>
 </pre><span class="small"><a href="#ExplicitExpression-2constructor-02"><em>» more...</em></a></span>
 
 
@@ -307,8 +273,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="ExplicitExpression-2constructor-0b">ExplicitExpression::ExplicitExpression</h2>
 <div>
-<span>Default constructor</span>
-
+<p>Default constructor</p>
 </div>
 </div>
 <div>
@@ -317,9 +282,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit(B)
-ExplicitExpression();
-
-</code>
+ExplicitExpression();</code>
 </pre>
 </div>
 </div>
@@ -327,8 +290,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="ExplicitExpression-2constructor-04">ExplicitExpression::ExplicitExpression</h2>
 <div>
-<span>Copy constructor</span>
-
+<p>Copy constructor</p>
 </div>
 </div>
 <div>
@@ -337,9 +299,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit(B)
-ExplicitExpression(<a href="#ExplicitExpression">ExplicitExpression</a> const& other);
-
-</code>
+ExplicitExpression(<a href="#ExplicitExpression">ExplicitExpression</a> const& other);</code>
 </pre>
 </div>
 <div>
@@ -354,7 +314,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The object to copy construct from</span></td>
+<td>The object to copy construct from</td>
 </tr>
 </tbody>
 </table>
@@ -364,8 +324,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="ExplicitExpression-2constructor-08">ExplicitExpression::ExplicitExpression</h2>
 <div>
-<span>Move constructor</span>
-
+<p>Move constructor</p>
 </div>
 </div>
 <div>
@@ -374,9 +333,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit(B)
-ExplicitExpression(<a href="#ExplicitExpression">ExplicitExpression</a>&& other) noexcept;
-
-</code>
+ExplicitExpression(<a href="#ExplicitExpression">ExplicitExpression</a>&& other) noexcept;</code>
 </pre>
 </div>
 <div>
@@ -391,7 +348,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The object to move construct from</span></td>
+<td>The object to move construct from</td>
 </tr>
 </tbody>
 </table>
@@ -401,8 +358,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="ExplicitExpression-2constructor-02">ExplicitExpression::ExplicitExpression</h2>
 <div>
-<span>Constructor</span>
-
+<p>Constructor</p>
 </div>
 </div>
 <div>
@@ -413,9 +369,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">explicit(B)
 ExplicitExpression(
     int,
-    int);
-
-</code>
+    int);</code>
 </pre>
 </div>
 </div>
@@ -428,9 +382,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct ExplicitFalse;
-
-</code>
+<code class="source-code cpp">struct ExplicitFalse;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -443,7 +395,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#ExplicitFalse-2constructor-07"><code>ExplicitFalse</code></a>         <span class="small">[constructor]</span></td><td><span>Constructors</span></td></tr>
+<td><a href="#ExplicitFalse-2constructor-07"><code>ExplicitFalse</code></a>         <span class="small">[constructor]</span></td><td>Constructors</td></tr>
 </tbody>
 </table>
 
@@ -454,46 +406,37 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="ExplicitFalse-2constructor-07">ExplicitFalse::ExplicitFalse</h2>
 <div>
-<span>Constructors</span>
-
+<p>Constructors</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
-<span>Default constructor</span>
+<p>Default constructor</p>
 <pre>
 <code class="source-code cpp">explicit(false)
-<a href="#ExplicitFalse-2constructor-01">ExplicitFalse</a>();
-
-</code>
+<a href="#ExplicitFalse-2constructor-01">ExplicitFalse</a>();</code>
 </pre><span class="small"><a href="#ExplicitFalse-2constructor-01"><em>» more...</em></a></span>
 
-<span>Copy constructor</span>
+<p>Copy constructor</p>
 <pre>
 <code class="source-code cpp">explicit(false)
-<a href="#ExplicitFalse-2constructor-08">ExplicitFalse</a>(<a href="#ExplicitFalse">ExplicitFalse</a> const& other);
-
-</code>
+<a href="#ExplicitFalse-2constructor-08">ExplicitFalse</a>(<a href="#ExplicitFalse">ExplicitFalse</a> const& other);</code>
 </pre><span class="small"><a href="#ExplicitFalse-2constructor-08"><em>» more...</em></a></span>
 
-<span>Move constructor</span>
+<p>Move constructor</p>
 <pre>
 <code class="source-code cpp">explicit(false)
-<a href="#ExplicitFalse-2constructor-0a">ExplicitFalse</a>(<a href="#ExplicitFalse">ExplicitFalse</a>&& other) noexcept;
-
-</code>
+<a href="#ExplicitFalse-2constructor-0a">ExplicitFalse</a>(<a href="#ExplicitFalse">ExplicitFalse</a>&& other) noexcept;</code>
 </pre><span class="small"><a href="#ExplicitFalse-2constructor-0a"><em>» more...</em></a></span>
 
-<span>Constructor</span>
+<p>Constructor</p>
 <pre>
 <code class="source-code cpp">explicit(false)
 <a href="#ExplicitFalse-2constructor-04">ExplicitFalse</a>(
     int,
-    int);
-
-</code>
+    int);</code>
 </pre><span class="small"><a href="#ExplicitFalse-2constructor-04"><em>» more...</em></a></span>
 
 
@@ -503,8 +446,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="ExplicitFalse-2constructor-01">ExplicitFalse::ExplicitFalse</h2>
 <div>
-<span>Default constructor</span>
-
+<p>Default constructor</p>
 </div>
 </div>
 <div>
@@ -513,9 +455,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit(false)
-ExplicitFalse();
-
-</code>
+ExplicitFalse();</code>
 </pre>
 </div>
 </div>
@@ -523,8 +463,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="ExplicitFalse-2constructor-08">ExplicitFalse::ExplicitFalse</h2>
 <div>
-<span>Copy constructor</span>
-
+<p>Copy constructor</p>
 </div>
 </div>
 <div>
@@ -533,9 +472,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit(false)
-ExplicitFalse(<a href="#ExplicitFalse">ExplicitFalse</a> const& other);
-
-</code>
+ExplicitFalse(<a href="#ExplicitFalse">ExplicitFalse</a> const& other);</code>
 </pre>
 </div>
 <div>
@@ -550,7 +487,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The object to copy construct from</span></td>
+<td>The object to copy construct from</td>
 </tr>
 </tbody>
 </table>
@@ -560,8 +497,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="ExplicitFalse-2constructor-0a">ExplicitFalse::ExplicitFalse</h2>
 <div>
-<span>Move constructor</span>
-
+<p>Move constructor</p>
 </div>
 </div>
 <div>
@@ -570,9 +506,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit(false)
-ExplicitFalse(<a href="#ExplicitFalse">ExplicitFalse</a>&& other) noexcept;
-
-</code>
+ExplicitFalse(<a href="#ExplicitFalse">ExplicitFalse</a>&& other) noexcept;</code>
 </pre>
 </div>
 <div>
@@ -587,7 +521,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The object to move construct from</span></td>
+<td>The object to move construct from</td>
 </tr>
 </tbody>
 </table>
@@ -597,8 +531,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="ExplicitFalse-2constructor-04">ExplicitFalse::ExplicitFalse</h2>
 <div>
-<span>Constructor</span>
-
+<p>Constructor</p>
 </div>
 </div>
 <div>
@@ -609,9 +542,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">explicit(false)
 ExplicitFalse(
     int,
-    int);
-
-</code>
+    int);</code>
 </pre>
 </div>
 </div>
@@ -624,9 +555,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct ExplicitTrue;
-
-</code>
+<code class="source-code cpp">struct ExplicitTrue;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -639,7 +568,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#ExplicitTrue-2constructor-01"><code>ExplicitTrue</code></a>         <span class="small">[constructor]</span></td><td><span>Constructors</span></td></tr>
+<td><a href="#ExplicitTrue-2constructor-01"><code>ExplicitTrue</code></a>         <span class="small">[constructor]</span></td><td>Constructors</td></tr>
 </tbody>
 </table>
 
@@ -650,46 +579,37 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="ExplicitTrue-2constructor-01">ExplicitTrue::ExplicitTrue</h2>
 <div>
-<span>Constructors</span>
-
+<p>Constructors</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
-<span>Default constructor</span>
+<p>Default constructor</p>
 <pre>
 <code class="source-code cpp">explicit(true)
-<a href="#ExplicitTrue-2constructor-0d">ExplicitTrue</a>();
-
-</code>
+<a href="#ExplicitTrue-2constructor-0d">ExplicitTrue</a>();</code>
 </pre><span class="small"><a href="#ExplicitTrue-2constructor-0d"><em>» more...</em></a></span>
 
-<span>Copy constructor</span>
+<p>Copy constructor</p>
 <pre>
 <code class="source-code cpp">explicit(true)
-<a href="#ExplicitTrue-2constructor-04">ExplicitTrue</a>(<a href="#ExplicitTrue">ExplicitTrue</a> const& other);
-
-</code>
+<a href="#ExplicitTrue-2constructor-04">ExplicitTrue</a>(<a href="#ExplicitTrue">ExplicitTrue</a> const& other);</code>
 </pre><span class="small"><a href="#ExplicitTrue-2constructor-04"><em>» more...</em></a></span>
 
-<span>Move constructor</span>
+<p>Move constructor</p>
 <pre>
 <code class="source-code cpp">explicit(true)
-<a href="#ExplicitTrue-2constructor-08">ExplicitTrue</a>(<a href="#ExplicitTrue">ExplicitTrue</a>&& other) noexcept;
-
-</code>
+<a href="#ExplicitTrue-2constructor-08">ExplicitTrue</a>(<a href="#ExplicitTrue">ExplicitTrue</a>&& other) noexcept;</code>
 </pre><span class="small"><a href="#ExplicitTrue-2constructor-08"><em>» more...</em></a></span>
 
-<span>Constructor</span>
+<p>Constructor</p>
 <pre>
 <code class="source-code cpp">explicit(true)
 <a href="#ExplicitTrue-2constructor-05">ExplicitTrue</a>(
     int,
-    int);
-
-</code>
+    int);</code>
 </pre><span class="small"><a href="#ExplicitTrue-2constructor-05"><em>» more...</em></a></span>
 
 
@@ -699,8 +619,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="ExplicitTrue-2constructor-0d">ExplicitTrue::ExplicitTrue</h2>
 <div>
-<span>Default constructor</span>
-
+<p>Default constructor</p>
 </div>
 </div>
 <div>
@@ -709,9 +628,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit(true)
-ExplicitTrue();
-
-</code>
+ExplicitTrue();</code>
 </pre>
 </div>
 </div>
@@ -719,8 +636,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="ExplicitTrue-2constructor-04">ExplicitTrue::ExplicitTrue</h2>
 <div>
-<span>Copy constructor</span>
-
+<p>Copy constructor</p>
 </div>
 </div>
 <div>
@@ -729,9 +645,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit(true)
-ExplicitTrue(<a href="#ExplicitTrue">ExplicitTrue</a> const& other);
-
-</code>
+ExplicitTrue(<a href="#ExplicitTrue">ExplicitTrue</a> const& other);</code>
 </pre>
 </div>
 <div>
@@ -746,7 +660,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The object to copy construct from</span></td>
+<td>The object to copy construct from</td>
 </tr>
 </tbody>
 </table>
@@ -756,8 +670,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="ExplicitTrue-2constructor-08">ExplicitTrue::ExplicitTrue</h2>
 <div>
-<span>Move constructor</span>
-
+<p>Move constructor</p>
 </div>
 </div>
 <div>
@@ -766,9 +679,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-ctor.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit(true)
-ExplicitTrue(<a href="#ExplicitTrue">ExplicitTrue</a>&& other) noexcept;
-
-</code>
+ExplicitTrue(<a href="#ExplicitTrue">ExplicitTrue</a>&& other) noexcept;</code>
 </pre>
 </div>
 <div>
@@ -783,7 +694,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>other</strong></td>
-<td><span>The object to move construct from</span></td>
+<td>The object to move construct from</td>
 </tr>
 </tbody>
 </table>
@@ -793,8 +704,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="ExplicitTrue-2constructor-05">ExplicitTrue::ExplicitTrue</h2>
 <div>
-<span>Constructor</span>
-
+<p>Constructor</p>
 </div>
 </div>
 <div>
@@ -805,9 +715,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">explicit(true)
 ExplicitTrue(
     int,
-    int);
-
-</code>
+    int);</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/function/explicit-object-parameter.adoc b/test-files/golden-tests/symbols/function/explicit-object-parameter.adoc
index a401df24a..f1f1d9450 100644
--- a/test-files/golden-tests/symbols/function/explicit-object-parameter.adoc
+++ b/test-files/golden-tests/symbols/function/explicit-object-parameter.adoc
@@ -26,12 +26,10 @@ struct Optional;
 
 === Member Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#Optional-value-0c[`value`] 
-| 
 |===
 
 [#Optional-value-0c]
diff --git a/test-files/golden-tests/symbols/function/explicit-object-parameter.html b/test-files/golden-tests/symbols/function/explicit-object-parameter.html
index 10d983100..2da844869 100644
--- a/test-files/golden-tests/symbols/function/explicit-object-parameter.html
+++ b/test-files/golden-tests/symbols/function/explicit-object-parameter.html
@@ -32,9 +32,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;explicit-object-parameter.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct Optional;
-
-</code>
+<code class="source-code cpp">struct Optional;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -42,12 +40,11 @@ <h2>Member Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#Optional-value-0c"><code>value</code></a> </td><td><span></span></td></tr>
+<td><a href="#Optional-value-0c"><code>value</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -67,9 +64,7 @@ <h3>Synopses</h3>
 <code class="source-code cpp">template&lt;typename Self&gt;
 constexpr
 auto&&
-<a href="#Optional-value-05">value</a>(this Self&& self);
-
-</code>
+<a href="#Optional-value-05">value</a>(this Self&& self);</code>
 </pre><span class="small"><a href="#Optional-value-05"><em>» more...</em></a></span>
 
 
@@ -79,9 +74,7 @@ <h3>Synopses</h3>
 auto&&
 <a href="#Optional-value-06">value</a>(this 
     Self&& self,
-    int x);
-
-</code>
+    int x);</code>
 </pre><span class="small"><a href="#Optional-value-06"><em>» more...</em></a></span>
 
 
@@ -99,9 +92,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;typename Self&gt;
 constexpr
 auto&&
-value(this Self&& self);
-
-</code>
+value(this Self&& self);</code>
 </pre>
 </div>
 </div>
@@ -119,9 +110,7 @@ <h3>Synopsis</h3>
 auto&&
 value(this 
     Self&& self,
-    int x);
-
-</code>
+    int x);</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/function/function-parm-decay.html b/test-files/golden-tests/symbols/function/function-parm-decay.html
index 97a0a2a1f..e9c3d74ce 100644
--- a/test-files/golden-tests/symbols/function/function-parm-decay.html
+++ b/test-files/golden-tests/symbols/function/function-parm-decay.html
@@ -49,9 +49,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;function-parm-decay.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using T = int;
-
-</code>
+<code class="source-code cpp">using T = int;</code>
 </pre>
 </div>
 </div>
@@ -64,9 +62,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;function-parm-decay.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using U = int const;
-
-</code>
+<code class="source-code cpp">using U = int const;</code>
 </pre>
 </div>
 </div>
@@ -80,9 +76,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;function-parm-decay.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(int const x);
-
-</code>
+f(int const x);</code>
 </pre>
 </div>
 </div>
@@ -96,9 +90,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;function-parm-decay.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g(int* x);
-
-</code>
+g(int* x);</code>
 </pre>
 </div>
 </div>
@@ -112,9 +104,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;function-parm-decay.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h(int x(bool));
-
-</code>
+h(int x(bool));</code>
 </pre>
 </div>
 </div>
@@ -128,9 +118,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;function-parm-decay.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-i(<a href="#T">T</a>);
-
-</code>
+i(<a href="#T">T</a>);</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/function/function-template-template.html b/test-files/golden-tests/symbols/function/function-template-template.html
index 8427930fe..01929bfdc 100644
--- a/test-files/golden-tests/symbols/function/function-template-template.html
+++ b/test-files/golden-tests/symbols/function/function-template-template.html
@@ -35,9 +35,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;template&lt;class...&gt; typename ListType&gt;
 constexpr
 void
-f(ListType&lt;int&gt; param);
-
-</code>
+f(ListType&lt;int&gt; param);</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/function/function-template.html b/test-files/golden-tests/symbols/function/function-template.html
index 052d67749..a6437f17e 100644
--- a/test-files/golden-tests/symbols/function/function-template.html
+++ b/test-files/golden-tests/symbols/function/function-template.html
@@ -45,9 +45,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
 void
-f0(int x);
-
-</code>
+f0(int x);</code>
 </pre>
 </div>
 </div>
@@ -62,9 +60,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
 void
-f1(T t);
-
-</code>
+f1(T t);</code>
 </pre>
 </div>
 </div>
@@ -79,9 +75,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename T = int&gt;
 void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -98,9 +92,7 @@ <h3>Synopsis</h3>
     typename T,
     class U = int&gt;
 void
-f3();
-
-</code>
+f3();</code>
 </pre>
 </div>
 </div>
@@ -115,9 +107,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;int I&gt;
 void
-g0(int x);
-
-</code>
+g0(int x);</code>
 </pre>
 </div>
 </div>
@@ -132,9 +122,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;int I = 1&gt;
 void
-g1();
-
-</code>
+g1();</code>
 </pre>
 </div>
 </div>
@@ -151,9 +139,7 @@ <h3>Synopsis</h3>
     int J,
     int I = 1&gt;
 void
-g2();
-
-</code>
+g2();</code>
 </pre>
 </div>
 </div>
@@ -167,9 +153,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;function-template.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h0(auto x);
-
-</code>
+h0(auto x);</code>
 </pre>
 </div>
 </div>
@@ -185,9 +169,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">void
 h1(
     auto x,
-    auto);
-
-</code>
+    auto);</code>
 </pre>
 </div>
 </div>
@@ -204,9 +186,7 @@ <h3>Synopsis</h3>
     typename T = int,
     int I = 1&gt;
 void
-i();
-
-</code>
+i();</code>
 </pre>
 </div>
 </div>
@@ -221,9 +201,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;template&lt;typename U&gt; typename T&gt;
 void
-j0();
-
-</code>
+j0();</code>
 </pre>
 </div>
 </div>
@@ -240,9 +218,7 @@ <h3>Synopsis</h3>
     template&lt;typename W&gt; typename X,
     template&lt;typename Y&gt; typename Z&gt;
 void
-j1();
-
-</code>
+j1();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/function/function-tparm-decay.html b/test-files/golden-tests/symbols/function/function-tparm-decay.html
index 56e41cbb8..e7a0a8df1 100644
--- a/test-files/golden-tests/symbols/function/function-tparm-decay.html
+++ b/test-files/golden-tests/symbols/function/function-tparm-decay.html
@@ -49,9 +49,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;function-tparm-decay.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using T = int;
-
-</code>
+<code class="source-code cpp">using T = int;</code>
 </pre>
 </div>
 </div>
@@ -64,9 +62,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;function-tparm-decay.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using U = int const;
-
-</code>
+<code class="source-code cpp">using U = int const;</code>
 </pre>
 </div>
 </div>
@@ -81,9 +77,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;int x&gt;
 void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -98,9 +92,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;int x[4]&gt;
 void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
@@ -115,9 +107,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;int(* x)(bool const)&gt;
 void
-h();
-
-</code>
+h();</code>
 </pre>
 </div>
 </div>
@@ -132,9 +122,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;int&gt;
 void
-i();
-
-</code>
+i();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/function/mem-fn.html b/test-files/golden-tests/symbols/function/mem-fn.html
index e9a7a6700..92ffb41a6 100644
--- a/test-files/golden-tests/symbols/function/mem-fn.html
+++ b/test-files/golden-tests/symbols/function/mem-fn.html
@@ -49,9 +49,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T01;
-
-</code>
+<code class="source-code cpp">struct T01;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -80,9 +78,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -95,9 +91,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T02;
-
-</code>
+<code class="source-code cpp">struct T02;</code>
 </pre>
 </div>
 <h2>Static Member Functions</h2>
@@ -127,9 +121,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">static
 void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -142,9 +134,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T03;
-
-</code>
+<code class="source-code cpp">struct T03;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -173,9 +163,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f() &amp;;
-
-</code>
+f() &amp;;</code>
 </pre>
 </div>
 </div>
@@ -188,9 +176,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T04;
-
-</code>
+<code class="source-code cpp">struct T04;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -219,9 +205,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f() &amp;&amp;;
-
-</code>
+f() &amp;&amp;;</code>
 </pre>
 </div>
 </div>
@@ -234,9 +218,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T05;
-
-</code>
+<code class="source-code cpp">struct T05;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -265,9 +247,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f() const;
-
-</code>
+f() const;</code>
 </pre>
 </div>
 </div>
@@ -280,9 +260,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T06;
-
-</code>
+<code class="source-code cpp">struct T06;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -312,9 +290,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">constexpr
 void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -327,9 +303,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T08;
-
-</code>
+<code class="source-code cpp">struct T08;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -358,9 +332,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -373,9 +345,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T09;
-
-</code>
+<code class="source-code cpp">struct T09;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -404,9 +374,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f() noexcept;
-
-</code>
+f() noexcept;</code>
 </pre>
 </div>
 </div>
@@ -419,9 +387,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T10;
-
-</code>
+<code class="source-code cpp">struct T10;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -450,9 +416,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -465,9 +429,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T11;
-
-</code>
+<code class="source-code cpp">struct T11;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -496,9 +458,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -511,9 +471,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T12;
-
-</code>
+<code class="source-code cpp">struct T12;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -542,9 +500,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(...);
-
-</code>
+f(...);</code>
 </pre>
 </div>
 </div>
@@ -557,9 +513,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T13;
-
-</code>
+<code class="source-code cpp">struct T13;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -589,9 +543,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">virtual
 void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -604,9 +556,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T14;
-
-</code>
+<code class="source-code cpp">struct T14;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -635,7 +585,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#T17"><code>T17</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -651,9 +601,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">virtual
 void
-f() = 0;
-
-</code>
+f() = 0;</code>
 </pre>
 </div>
 </div>
@@ -666,9 +614,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T15;
-
-</code>
+<code class="source-code cpp">struct T15;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -697,9 +643,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f() volatile;
-
-</code>
+f() volatile;</code>
 </pre>
 </div>
 </div>
@@ -712,9 +656,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T16;
-
-</code>
+<code class="source-code cpp">struct T16;</code>
 </pre>
 </div>
 <h2>Static Member Functions</h2>
@@ -744,9 +686,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">static
 void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -760,9 +700,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct T17
-    : <a href="#T14">T14</a>
-
-</code>
+    : <a href="#T14">T14</a></code>
 </pre>
 </div>
 <div>
@@ -775,7 +713,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#T14">T14</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#T14">T14</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -806,9 +744,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">virtual
 void
-f() override;
-
-</code>
+f() override;</code>
 </pre>
 </div>
 </div>
@@ -821,9 +757,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct U;
-
-</code>
+<code class="source-code cpp">struct U;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -866,7 +800,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#V"><code>V</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -882,9 +816,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">constexpr
 void
-f1(...) const volatile noexcept;
-
-</code>
+f1(...) const volatile noexcept;</code>
 </pre>
 </div>
 </div>
@@ -899,9 +831,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">virtual
 int
-f3() const volatile noexcept = 0;
-
-</code>
+f3() const volatile noexcept = 0;</code>
 </pre>
 </div>
 </div>
@@ -917,9 +847,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">constexpr
 static
 char
-f2() noexcept;
-
-</code>
+f2() noexcept;</code>
 </pre>
 </div>
 </div>
@@ -933,9 +861,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;mem-fn.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct V
-    : <a href="#U">U</a>
-
-</code>
+    : <a href="#U">U</a></code>
 </pre>
 </div>
 <div>
@@ -948,7 +874,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#U">U</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#U">U</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -993,9 +919,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">virtual
 int
-f3() const volatile noexcept override;
-
-</code>
+f3() const volatile noexcept override;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/function/merge-params.html b/test-files/golden-tests/symbols/function/merge-params.html
index 15087f964..284ca8c91 100644
--- a/test-files/golden-tests/symbols/function/merge-params.html
+++ b/test-files/golden-tests/symbols/function/merge-params.html
@@ -19,7 +19,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>Function</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>Function</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>Function</span>
-
+<p>Function</p>
 </div>
 </div>
 <div>
@@ -40,9 +39,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">void
 f(
     int a,
-    int b);
-
-</code>
+    int b);</code>
 </pre>
 </div>
 <div>
@@ -57,11 +54,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>The first parameter.</span></td>
+<td>The first parameter.</td>
 </tr>
 <tr>
 <td><strong>b</strong></td>
-<td><span>The second parameter.</span></td>
+<td>The second parameter.</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/symbols/function/merge-tparams.html b/test-files/golden-tests/symbols/function/merge-tparams.html
index 7fa1e2b41..79b3bd85b 100644
--- a/test-files/golden-tests/symbols/function/merge-tparams.html
+++ b/test-files/golden-tests/symbols/function/merge-tparams.html
@@ -19,7 +19,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>Function</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>Function</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>Function</span>
-
+<p>Function</p>
 </div>
 </div>
 <div>
@@ -41,9 +40,7 @@ <h3>Synopsis</h3>
     class T,
     class U&gt;
 void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 <div>
@@ -58,11 +55,11 @@ <h3>Template Parameters</h3>
 <tbody>
 <tr>
 <td><strong>T</strong></td>
-<td><span>The first template parameter.</span></td>
+<td>The first template parameter.</td>
 </tr>
 <tr>
 <td><strong>U</strong></td>
-<td><span>The second template parameter.</span></td>
+<td>The second template parameter.</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/symbols/function/noreturn.html b/test-files/golden-tests/symbols/function/noreturn.html
index 162023d8d..912c36fcd 100644
--- a/test-files/golden-tests/symbols/function/noreturn.html
+++ b/test-files/golden-tests/symbols/function/noreturn.html
@@ -45,9 +45,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;noreturn.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T;
-
-</code>
+<code class="source-code cpp">struct T;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -90,7 +88,7 @@ <h2>Friends</h2>
 <tbody>
 <tr>
 <td><code><a href="#f1">f1</a></code></td>
-<td><span></span></td>
+<td></td>
 </tr>
 |===
 </tbody>
@@ -108,9 +106,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">[[noreturn]]
 void
-f3();
-
-</code>
+f3();</code>
 </pre>
 </div>
 </div>
@@ -126,9 +122,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">[[noreturn]]
 static
 void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -143,9 +137,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">[[noreturn]]
 void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/function/overloaded-op-1.html b/test-files/golden-tests/symbols/function/overloaded-op-1.html
index b5ef87702..48d60685d 100644
--- a/test-files/golden-tests/symbols/function/overloaded-op-1.html
+++ b/test-files/golden-tests/symbols/function/overloaded-op-1.html
@@ -32,9 +32,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;overloaded-op-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T;
-
-</code>
+<code class="source-code cpp">struct T;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -47,7 +45,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#T-operator_plus"><code>operator+</code></a> </td><td><span>Unary plus operator</span></td></tr>
+<td><a href="#T-operator_plus"><code>operator+</code></a> </td><td>Unary plus operator</td></tr>
 </tbody>
 </table>
 
@@ -58,8 +56,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="T-operator_plus">T::operator+</h2>
 <div>
-<span>Unary plus operator</span>
-
+<p>Unary plus operator</p>
 </div>
 </div>
 <div>
@@ -68,14 +65,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;overloaded-op-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#T">T</a>
-operator+();
-
-</code>
+operator+();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Another instance of the object</span>
+Another instance of the object
 </div>
 </div>
 
diff --git a/test-files/golden-tests/symbols/function/overloaded-op-2.html b/test-files/golden-tests/symbols/function/overloaded-op-2.html
index 56a115b00..781b25ac1 100644
--- a/test-files/golden-tests/symbols/function/overloaded-op-2.html
+++ b/test-files/golden-tests/symbols/function/overloaded-op-2.html
@@ -32,9 +32,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;overloaded-op-2.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T;
-
-</code>
+<code class="source-code cpp">struct T;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -47,7 +45,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#T-operator_plus"><code>operator+</code></a> </td><td><span>Addition operator</span></td></tr>
+<td><a href="#T-operator_plus"><code>operator+</code></a> </td><td>Addition operator</td></tr>
 </tbody>
 </table>
 
@@ -58,8 +56,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="T-operator_plus">T::operator+</h2>
 <div>
-<span>Addition operator</span>
-
+<p>Addition operator</p>
 </div>
 </div>
 <div>
@@ -68,14 +65,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;overloaded-op-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#T">T</a>
-operator+(<a href="#T">T</a> rhs);
-
-</code>
+operator+(<a href="#T">T</a> rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Another instance of the object</span>
+Another instance of the object
 </div>
 <div>
 <h3>Parameters</h3>
@@ -89,7 +84,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/symbols/function/qualified-params.html b/test-files/golden-tests/symbols/function/qualified-params.html
index 1c38f4064..7ecbdc3f0 100644
--- a/test-files/golden-tests/symbols/function/qualified-params.html
+++ b/test-files/golden-tests/symbols/function/qualified-params.html
@@ -64,9 +64,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;qualified-params.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class D;
-
-</code>
+<code class="source-code cpp">class D;</code>
 </pre>
 </div>
 
@@ -99,9 +97,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;qualified-params.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class C;
-
-</code>
+<code class="source-code cpp">class C;</code>
 </pre>
 </div>
 
@@ -117,9 +113,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;qualified-params.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#N-C">N::C</a>
-foo(<a href="#M-D">M::D</a> v);
-
-</code>
+foo(<a href="#M-D">M::D</a> v);</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/function/sfinae.adoc b/test-files/golden-tests/symbols/function/sfinae.adoc
index eba76049c..8a7b8d406 100644
--- a/test-files/golden-tests/symbols/function/sfinae.adoc
+++ b/test-files/golden-tests/symbols/function/sfinae.adoc
@@ -61,12 +61,10 @@
 
 === Types
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#B-C[`C`] 
-| 
 |===
 
 [#B-C]
diff --git a/test-files/golden-tests/symbols/function/sfinae.html b/test-files/golden-tests/symbols/function/sfinae.html
index 2bc059188..334c5c3c8 100644
--- a/test-files/golden-tests/symbols/function/sfinae.html
+++ b/test-files/golden-tests/symbols/function/sfinae.html
@@ -32,10 +32,10 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-09"><code>A</code></a> </td><td><span>The partial specialization of A is enabled via a template parameter</span></td></tr><tr>
-<td><a href="#A-07"><code>A&lt;T&gt;</code></a> </td><td><span>Specialization for integral types</span></td></tr><tr>
-<td><a href="#S-02"><code>S</code></a> </td><td><span>SFINAE with std::void_t</span></td></tr><tr>
-<td><a href="#S-08"><code>S&lt;T, std::void_t&lt;T::a::b&gt;&gt;</code></a> </td><td><span>SFINAE with std::void_t</span></td></tr>
+<td><a href="#A-09"><code>A</code></a> </td><td>The partial specialization of A is enabled via a template parameter</td></tr><tr>
+<td><a href="#A-07"><code>A&lt;T&gt;</code></a> </td><td>Specialization for integral types</td></tr><tr>
+<td><a href="#S-02"><code>S</code></a> </td><td>SFINAE with std::void_t</td></tr><tr>
+<td><a href="#S-08"><code>S&lt;T, std::void_t&lt;T::a::b&gt;&gt;</code></a> </td><td>SFINAE with std::void_t</td></tr>
 </tbody>
 </table>
 
@@ -49,16 +49,16 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f1"><code>f1</code></a> </td><td><span>Enabled via return type</span></td></tr><tr>
-<td><a href="#f10"><code>f10</code></a> </td><td><span>Enabled via type template parameter</span></td></tr><tr>
-<td><a href="#f2"><code>f2</code></a> </td><td><span>Enabling a specified return type</span></td></tr><tr>
-<td><a href="#f3"><code>f3</code></a> </td><td><span>Enabling a specified return type in another namespace</span></td></tr><tr>
-<td><a href="#f4"><code>f4</code></a> </td><td><span>Enabled via return type with std::enable_if</span></td></tr><tr>
-<td><a href="#f5"><code>f5</code></a> </td><td><span>Enabled via a non-type template parameter with helper</span></td></tr><tr>
-<td><a href="#f6"><code>f6</code></a> </td><td><span>Enabled via a non-type template parameter without helper</span></td></tr><tr>
-<td><a href="#f7"><code>f7</code></a> </td><td><span>Enabled via a non-type template parameter using int instead of bool</span></td></tr><tr>
-<td><a href="#f8"><code>f8</code></a> </td><td><span>Enabled via parameter without helper</span></td></tr><tr>
-<td><a href="#f9"><code>f9</code></a> </td><td><span>Enabled via parameter with helper</span></td></tr>
+<td><a href="#f1"><code>f1</code></a> </td><td>Enabled via return type</td></tr><tr>
+<td><a href="#f10"><code>f10</code></a> </td><td>Enabled via type template parameter</td></tr><tr>
+<td><a href="#f2"><code>f2</code></a> </td><td>Enabling a specified return type</td></tr><tr>
+<td><a href="#f3"><code>f3</code></a> </td><td>Enabling a specified return type in another namespace</td></tr><tr>
+<td><a href="#f4"><code>f4</code></a> </td><td>Enabled via return type with std::enable_if</td></tr><tr>
+<td><a href="#f5"><code>f5</code></a> </td><td>Enabled via a non-type template parameter with helper</td></tr><tr>
+<td><a href="#f6"><code>f6</code></a> </td><td>Enabled via a non-type template parameter without helper</td></tr><tr>
+<td><a href="#f7"><code>f7</code></a> </td><td>Enabled via a non-type template parameter using int instead of bool</td></tr><tr>
+<td><a href="#f8"><code>f8</code></a> </td><td>Enabled via parameter without helper</td></tr><tr>
+<td><a href="#f9"><code>f9</code></a> </td><td>Enabled via parameter with helper</td></tr>
 </tbody>
 </table>
 
@@ -72,12 +72,11 @@ <h2>Types</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#B-C"><code>C</code></a> </td><td><span></span></td></tr>
+<td><a href="#B-C"><code>C</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -91,9 +90,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;sfinae.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct C;
-
-</code>
+<code class="source-code cpp">struct C;</code>
 </pre>
 </div>
 
@@ -108,7 +105,7 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#f3"><code>::f3</code></a></td><td><span>Enabling a specified return type in another namespace</span></td></tr>
+<tr><td><a href="#f3"><code>::f3</code></a></td><td>Enabling a specified return type in another namespace</td></tr>
 </tbody>
 </table>
 </div>
@@ -117,8 +114,7 @@ <h2>Non-Member Functions</h2>
 <div>
 <h2 id="A-09">A</h2>
 <div>
-<span>The partial specialization of A is enabled via a template parameter</span>
-
+<p>The partial specialization of A is enabled via a template parameter</p>
 </div>
 </div>
 <div>
@@ -129,9 +125,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     class T,
     class Enable = void&gt;
-class A;
-
-</code>
+class A;</code>
 </pre>
 </div>
 
@@ -141,8 +135,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="A-07">A&lt;T&gt;</h2>
 <div>
-<span>Specialization for integral types</span>
-
+<p>Specialization for integral types</p>
 </div>
 </div>
 <div>
@@ -152,9 +145,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;class T&gt;
 requires std::is_integral_v&lt;T&gt;
-class <a href="#A-09">A</a>&lt;T&gt;;
-
-</code>
+class <a href="#A-09">A</a>&lt;T&gt;;</code>
 </pre>
 </div>
 
@@ -164,8 +155,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="S-02">S</h2>
 <div>
-<span>SFINAE with std::void_t</span>
-
+<p>SFINAE with std::void_t</p>
 </div>
 </div>
 <div>
@@ -176,9 +166,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     class T,
     class Enable = void&gt;
-struct S;
-
-</code>
+struct S;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -207,9 +195,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sfinae.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-store(void const*);
-
-</code>
+store(void const*);</code>
 </pre>
 </div>
 </div>
@@ -217,8 +203,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="S-08">S&lt;T, std::void_t&lt;T::a::b&gt;&gt;</h2>
 <div>
-<span>SFINAE with std::void_t</span>
-
+<p>SFINAE with std::void_t</p>
 </div>
 </div>
 <div>
@@ -227,9 +212,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sfinae.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class T&gt;
-struct <a href="#S-02">S</a>&lt;T, std::void_t&lt;T::a::b&gt;&gt;;
-
-</code>
+struct <a href="#S-02">S</a>&lt;T, std::void_t&lt;T::a::b&gt;&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -258,9 +241,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;sfinae.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-store(void const*);
-
-</code>
+store(void const*);</code>
 </pre>
 </div>
 </div>
@@ -268,8 +249,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f1">f1</h2>
 <div>
-<span>Enabled via return type</span>
-
+<p>Enabled via return type</p>
 </div>
 </div>
 <div>
@@ -280,9 +260,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;class T&gt;
 T
 f1(T value)
-requires std::is_integral_v&lt;T&gt;;
-
-</code>
+requires std::is_integral_v&lt;T&gt;;</code>
 </pre>
 </div>
 </div>
@@ -290,8 +268,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f10">f10</h2>
 <div>
-<span>Enabled via type template parameter</span>
-
+<p>Enabled via type template parameter</p>
 </div>
 </div>
 <div>
@@ -302,9 +279,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;class T&gt;
 requires std::is_integral_v&lt;T&gt;
 void
-f10(T value);
-
-</code>
+f10(T value);</code>
 </pre>
 </div>
 <div>
@@ -318,8 +293,7 @@ <h3>Description</h3>
 <div>
 <h2 id="f2">f2</h2>
 <div>
-<span>Enabling a specified return type</span>
-
+<p>Enabling a specified return type</p>
 </div>
 </div>
 <div>
@@ -330,9 +304,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;class T&gt;
 int
 f2(T value)
-requires std::is_integral_v&lt;T&gt;;
-
-</code>
+requires std::is_integral_v&lt;T&gt;;</code>
 </pre>
 </div>
 </div>
@@ -340,8 +312,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f3">f3</h2>
 <div>
-<span>Enabling a specified return type in another namespace</span>
-
+<p>Enabling a specified return type in another namespace</p>
 </div>
 </div>
 <div>
@@ -352,9 +323,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;class T&gt;
 <a href="#B-C">B::C</a>
 f3(T value)
-requires std::is_integral_v&lt;T&gt;;
-
-</code>
+requires std::is_integral_v&lt;T&gt;;</code>
 </pre>
 </div>
 </div>
@@ -362,8 +331,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f4">f4</h2>
 <div>
-<span>Enabled via return type with std::enable_if</span>
-
+<p>Enabled via return type with std::enable_if</p>
 </div>
 </div>
 <div>
@@ -374,9 +342,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;class T&gt;
 T
 f4(T value)
-requires std::is_integral_v&lt;T&gt;;
-
-</code>
+requires std::is_integral_v&lt;T&gt;;</code>
 </pre>
 </div>
 </div>
@@ -384,8 +350,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f5">f5</h2>
 <div>
-<span>Enabled via a non-type template parameter with helper</span>
-
+<p>Enabled via a non-type template parameter with helper</p>
 </div>
 </div>
 <div>
@@ -396,9 +361,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;class T&gt;
 requires std::is_integral_v&lt;T&gt;
 T
-f5(T value);
-
-</code>
+f5(T value);</code>
 </pre>
 </div>
 </div>
@@ -406,8 +369,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f6">f6</h2>
 <div>
-<span>Enabled via a non-type template parameter without helper</span>
-
+<p>Enabled via a non-type template parameter without helper</p>
 </div>
 </div>
 <div>
@@ -418,9 +380,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;class T&gt;
 requires std::is_integral_v&lt;T&gt;
 T
-f6(T value);
-
-</code>
+f6(T value);</code>
 </pre>
 </div>
 </div>
@@ -428,8 +388,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f7">f7</h2>
 <div>
-<span>Enabled via a non-type template parameter using int instead of bool</span>
-
+<p>Enabled via a non-type template parameter using int instead of bool</p>
 </div>
 </div>
 <div>
@@ -440,9 +399,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;class T&gt;
 requires std::is_integral_v&lt;T&gt;
 void
-f7(T value);
-
-</code>
+f7(T value);</code>
 </pre>
 </div>
 </div>
@@ -450,8 +407,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f8">f8</h2>
 <div>
-<span>Enabled via parameter without helper</span>
-
+<p>Enabled via parameter without helper</p>
 </div>
 </div>
 <div>
@@ -462,9 +418,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;class T&gt;
 T
 f8(T value)
-requires std::is_integral_v&lt;T&gt;;
-
-</code>
+requires std::is_integral_v&lt;T&gt;;</code>
 </pre>
 </div>
 </div>
@@ -472,8 +426,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f9">f9</h2>
 <div>
-<span>Enabled via parameter with helper</span>
-
+<p>Enabled via parameter with helper</p>
 </div>
 </div>
 <div>
@@ -484,9 +437,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;class T&gt;
 T
 f9(T value)
-requires std::is_integral_v&lt;T&gt;;
-
-</code>
+requires std::is_integral_v&lt;T&gt;;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/function/spec-mem-implicit-instantiation.html b/test-files/golden-tests/symbols/function/spec-mem-implicit-instantiation.html
index 9df0e4959..83384091b 100644
--- a/test-files/golden-tests/symbols/function/spec-mem-implicit-instantiation.html
+++ b/test-files/golden-tests/symbols/function/spec-mem-implicit-instantiation.html
@@ -37,9 +37,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -82,9 +80,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -113,9 +109,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
@@ -129,9 +123,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct C;
-
-</code>
+struct C;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -160,9 +152,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h();
-
-</code>
+h();</code>
 </pre>
 </div>
 </div>
@@ -176,9 +166,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -192,9 +180,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e">A</a>&lt;bool&gt;;
-
-</code>
+struct <a href="#A-0e">A</a>&lt;bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -239,9 +225,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 
@@ -257,9 +241,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct C;
-
-</code>
+struct C;</code>
 </pre>
 </div>
 
@@ -275,9 +257,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e-C">C</a>&lt;double*&gt;;
-
-</code>
+struct <a href="#A-0e-C">C</a>&lt;double*&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -306,9 +286,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-j();
-
-</code>
+j();</code>
 </pre>
 </div>
 </div>
@@ -322,9 +300,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct <a href="#A-0e-C">C</a>&lt;U*&gt;;
-
-</code>
+struct <a href="#A-0e-C">C</a>&lt;U*&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -353,9 +329,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-j();
-
-</code>
+j();</code>
 </pre>
 </div>
 </div>
@@ -369,9 +343,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -385,9 +357,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e">A</a>&lt;short&gt;;
-
-</code>
+struct <a href="#A-0e">A</a>&lt;short&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -430,9 +400,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 
@@ -448,9 +416,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct C;
-
-</code>
+struct C;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -479,9 +445,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-i();
-
-</code>
+i();</code>
 </pre>
 </div>
 </div>
@@ -495,9 +459,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -511,9 +473,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e">A</a>&lt;int&gt;;
-
-</code>
+struct <a href="#A-0e">A</a>&lt;int&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -557,9 +517,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 
@@ -575,9 +533,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e-B">B</a>&lt;long&gt;;
-
-</code>
+struct <a href="#A-0e-B">B</a>&lt;long&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -606,9 +562,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
@@ -622,9 +576,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct C;
-
-</code>
+struct C;</code>
 </pre>
 </div>
 
@@ -640,9 +592,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -655,9 +605,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct D;
-
-</code>
+<code class="source-code cpp">struct D;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -687,9 +635,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct E;
-
-</code>
+struct E;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -718,9 +664,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-k();
-
-</code>
+k();</code>
 </pre>
 </div>
 </div>
@@ -734,9 +678,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#D-E-0e">E</a>&lt;int&gt;;
-
-</code>
+struct <a href="#D-E-0e">E</a>&lt;int&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -765,9 +707,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;spec-mem-implicit-instantiation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-k();
-
-</code>
+k();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/function/type-resolution.html b/test-files/golden-tests/symbols/function/type-resolution.html
index 6f5806efa..32ac1f93d 100644
--- a/test-files/golden-tests/symbols/function/type-resolution.html
+++ b/test-files/golden-tests/symbols/function/type-resolution.html
@@ -93,9 +93,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using C = <a href="#A">A</a>;
-
-</code>
+<code class="source-code cpp">using C = <a href="#A">A</a>;</code>
 </pre>
 </div>
 </div>
@@ -108,9 +106,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using D = <a href="#B">B&lt;short, long&gt;</a>;
-
-</code>
+<code class="source-code cpp">using D = <a href="#B">B&lt;short, long&gt;</a>;</code>
 </pre>
 </div>
 </div>
@@ -124,9 +120,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-using E = <a href="#B">B&lt;T, long&gt;</a>;
-
-</code>
+using E = <a href="#B">B&lt;T, long&gt;</a>;</code>
 </pre>
 </div>
 </div>
@@ -139,9 +133,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 
@@ -159,9 +151,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     typename T,
     typename U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 
@@ -177,9 +167,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0(<a href="#A">A</a>);
-
-</code>
+f0(<a href="#A">A</a>);</code>
 </pre>
 </div>
 </div>
@@ -193,9 +181,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1(<a href="#A">A</a> const);
-
-</code>
+f1(<a href="#A">A</a> const);</code>
 </pre>
 </div>
 </div>
@@ -209,9 +195,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2(<a href="#A">A</a>&);
-
-</code>
+f2(<a href="#A">A</a>&);</code>
 </pre>
 </div>
 </div>
@@ -225,9 +209,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f3(<a href="#A">A</a> const&);
-
-</code>
+f3(<a href="#A">A</a> const&);</code>
 </pre>
 </div>
 </div>
@@ -241,9 +223,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f4(<a href="#A">A</a>*);
-
-</code>
+f4(<a href="#A">A</a>*);</code>
 </pre>
 </div>
 </div>
@@ -257,9 +237,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5(<a href="#A">A</a> const*);
-
-</code>
+f5(<a href="#A">A</a> const*);</code>
 </pre>
 </div>
 </div>
@@ -273,9 +251,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6(<a href="#A">A</a>**);
-
-</code>
+f6(<a href="#A">A</a>**);</code>
 </pre>
 </div>
 </div>
@@ -289,9 +265,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f7(<a href="#A">A</a> const**);
-
-</code>
+f7(<a href="#A">A</a> const**);</code>
 </pre>
 </div>
 </div>
@@ -305,9 +279,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f8(<a href="#A">A</a> const const**);
-
-</code>
+f8(<a href="#A">A</a> const const**);</code>
 </pre>
 </div>
 </div>
@@ -321,9 +293,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g0(<a href="#C">C</a>);
-
-</code>
+g0(<a href="#C">C</a>);</code>
 </pre>
 </div>
 </div>
@@ -337,9 +307,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g1(<a href="#C">C</a> const);
-
-</code>
+g1(<a href="#C">C</a> const);</code>
 </pre>
 </div>
 </div>
@@ -353,9 +321,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g2(<a href="#C">C</a>&);
-
-</code>
+g2(<a href="#C">C</a>&);</code>
 </pre>
 </div>
 </div>
@@ -369,9 +335,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g3(<a href="#C">C</a> const&);
-
-</code>
+g3(<a href="#C">C</a> const&);</code>
 </pre>
 </div>
 </div>
@@ -385,9 +349,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g4(<a href="#C">C</a>*);
-
-</code>
+g4(<a href="#C">C</a>*);</code>
 </pre>
 </div>
 </div>
@@ -401,9 +363,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g5(<a href="#C">C</a> const*);
-
-</code>
+g5(<a href="#C">C</a> const*);</code>
 </pre>
 </div>
 </div>
@@ -417,9 +377,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g6(<a href="#C">C</a>**);
-
-</code>
+g6(<a href="#C">C</a>**);</code>
 </pre>
 </div>
 </div>
@@ -433,9 +391,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g7(<a href="#C">C</a> const**);
-
-</code>
+g7(<a href="#C">C</a> const**);</code>
 </pre>
 </div>
 </div>
@@ -449,9 +405,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g8(<a href="#C">C</a> const const**);
-
-</code>
+g8(<a href="#C">C</a> const const**);</code>
 </pre>
 </div>
 </div>
@@ -465,9 +419,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h0(<a href="#B">B&lt;short, long&gt;</a>);
-
-</code>
+h0(<a href="#B">B&lt;short, long&gt;</a>);</code>
 </pre>
 </div>
 </div>
@@ -481,9 +433,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h1(<a href="#B">B&lt;short, long&gt;</a> const);
-
-</code>
+h1(<a href="#B">B&lt;short, long&gt;</a> const);</code>
 </pre>
 </div>
 </div>
@@ -497,9 +447,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h2(<a href="#B">B&lt;short, long&gt;</a>&);
-
-</code>
+h2(<a href="#B">B&lt;short, long&gt;</a>&);</code>
 </pre>
 </div>
 </div>
@@ -513,9 +461,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h3(<a href="#B">B&lt;short, long&gt;</a> const&);
-
-</code>
+h3(<a href="#B">B&lt;short, long&gt;</a> const&);</code>
 </pre>
 </div>
 </div>
@@ -529,9 +475,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h4(<a href="#B">B&lt;short, long&gt;</a>*);
-
-</code>
+h4(<a href="#B">B&lt;short, long&gt;</a>*);</code>
 </pre>
 </div>
 </div>
@@ -545,9 +489,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h5(<a href="#B">B&lt;short, long&gt;</a> const*);
-
-</code>
+h5(<a href="#B">B&lt;short, long&gt;</a> const*);</code>
 </pre>
 </div>
 </div>
@@ -561,9 +503,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h6(<a href="#B">B&lt;short, long&gt;</a>**);
-
-</code>
+h6(<a href="#B">B&lt;short, long&gt;</a>**);</code>
 </pre>
 </div>
 </div>
@@ -577,9 +517,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h7(<a href="#B">B&lt;short, long&gt;</a> const**);
-
-</code>
+h7(<a href="#B">B&lt;short, long&gt;</a> const**);</code>
 </pre>
 </div>
 </div>
@@ -593,9 +531,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h8(<a href="#B">B&lt;short, long&gt;</a> const const**);
-
-</code>
+h8(<a href="#B">B&lt;short, long&gt;</a> const const**);</code>
 </pre>
 </div>
 </div>
@@ -609,9 +545,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-i0(<a href="#D">D</a>);
-
-</code>
+i0(<a href="#D">D</a>);</code>
 </pre>
 </div>
 </div>
@@ -625,9 +559,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-i1(<a href="#D">D</a> const);
-
-</code>
+i1(<a href="#D">D</a> const);</code>
 </pre>
 </div>
 </div>
@@ -641,9 +573,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-i2(<a href="#D">D</a>&);
-
-</code>
+i2(<a href="#D">D</a>&);</code>
 </pre>
 </div>
 </div>
@@ -657,9 +587,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-i3(<a href="#D">D</a> const&);
-
-</code>
+i3(<a href="#D">D</a> const&);</code>
 </pre>
 </div>
 </div>
@@ -673,9 +601,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-i4(<a href="#D">D</a>*);
-
-</code>
+i4(<a href="#D">D</a>*);</code>
 </pre>
 </div>
 </div>
@@ -689,9 +615,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-i5(<a href="#D">D</a> const*);
-
-</code>
+i5(<a href="#D">D</a> const*);</code>
 </pre>
 </div>
 </div>
@@ -705,9 +629,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-i6(<a href="#D">D</a>**);
-
-</code>
+i6(<a href="#D">D</a>**);</code>
 </pre>
 </div>
 </div>
@@ -721,9 +643,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-i7(<a href="#D">D</a> const**);
-
-</code>
+i7(<a href="#D">D</a> const**);</code>
 </pre>
 </div>
 </div>
@@ -737,9 +657,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-i8(<a href="#D">D</a> const const**);
-
-</code>
+i8(<a href="#D">D</a> const const**);</code>
 </pre>
 </div>
 </div>
@@ -753,9 +671,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-j0(<a href="#E">E&lt;short&gt;</a>);
-
-</code>
+j0(<a href="#E">E&lt;short&gt;</a>);</code>
 </pre>
 </div>
 </div>
@@ -769,9 +685,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-j1(<a href="#E">E&lt;short&gt;</a> const);
-
-</code>
+j1(<a href="#E">E&lt;short&gt;</a> const);</code>
 </pre>
 </div>
 </div>
@@ -785,9 +699,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-j2(<a href="#E">E&lt;short&gt;</a>&);
-
-</code>
+j2(<a href="#E">E&lt;short&gt;</a>&);</code>
 </pre>
 </div>
 </div>
@@ -801,9 +713,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-j3(<a href="#E">E&lt;short&gt;</a> const&);
-
-</code>
+j3(<a href="#E">E&lt;short&gt;</a> const&);</code>
 </pre>
 </div>
 </div>
@@ -817,9 +727,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-j4(<a href="#E">E&lt;short&gt;</a>*);
-
-</code>
+j4(<a href="#E">E&lt;short&gt;</a>*);</code>
 </pre>
 </div>
 </div>
@@ -833,9 +741,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-j5(<a href="#E">E&lt;short&gt;</a> const*);
-
-</code>
+j5(<a href="#E">E&lt;short&gt;</a> const*);</code>
 </pre>
 </div>
 </div>
@@ -849,9 +755,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-j6(<a href="#E">E&lt;short&gt;</a>**);
-
-</code>
+j6(<a href="#E">E&lt;short&gt;</a>**);</code>
 </pre>
 </div>
 </div>
@@ -865,9 +769,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-j7(<a href="#E">E&lt;short&gt;</a> const**);
-
-</code>
+j7(<a href="#E">E&lt;short&gt;</a> const**);</code>
 </pre>
 </div>
 </div>
@@ -881,9 +783,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;type-resolution.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-j8(<a href="#E">E&lt;short&gt;</a> const const**);
-
-</code>
+j8(<a href="#E">E&lt;short&gt;</a> const const**);</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/function/variadic-function.html b/test-files/golden-tests/symbols/function/variadic-function.html
index b1908b0b1..075f8b5fd 100644
--- a/test-files/golden-tests/symbols/function/variadic-function.html
+++ b/test-files/golden-tests/symbols/function/variadic-function.html
@@ -48,9 +48,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;variadic-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using T = void(...);
-
-</code>
+<code class="source-code cpp">using T = void(...);</code>
 </pre>
 </div>
 </div>
@@ -63,9 +61,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;variadic-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using U = void(int, ...);
-
-</code>
+<code class="source-code cpp">using U = void(int, ...);</code>
 </pre>
 </div>
 </div>
@@ -81,9 +77,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     typename A = void(...),
     typename B = void(int, ...)&gt;
-struct C;
-
-</code>
+struct C;</code>
 </pre>
 </div>
 
@@ -99,9 +93,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;variadic-function.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(...);
-
-</code>
+f(...);</code>
 </pre>
 </div>
 </div>
@@ -115,9 +107,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;variadic-function.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g(int, ...);
-
-</code>
+g(int, ...);</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/guide/explicit-deduct-guide.html b/test-files/golden-tests/symbols/guide/explicit-deduct-guide.html
index f1794a8ff..440ae2f93 100644
--- a/test-files/golden-tests/symbols/guide/explicit-deduct-guide.html
+++ b/test-files/golden-tests/symbols/guide/explicit-deduct-guide.html
@@ -49,9 +49,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-deduct-guide.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;int&gt;
-struct X;
-
-</code>
+struct X;</code>
 </pre>
 </div>
 
@@ -66,9 +64,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;explicit-deduct-guide.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#X-0e">X&lt;0&gt;</a>(bool) -> <a href="#X-0e">X&lt;0&gt;</a>;
-
-</code>
+<code class="source-code cpp"><a href="#X-0e">X&lt;0&gt;</a>(bool) -> <a href="#X-0e">X&lt;0&gt;</a>;</code>
 </pre>
 </div>
 </div>
@@ -81,9 +77,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;explicit-deduct-guide.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#X-0e">X&lt;0&gt;</a>(char) -> <a href="#X-0e">X&lt;0&gt;</a>;
-
-</code>
+<code class="source-code cpp"><a href="#X-0e">X&lt;0&gt;</a>(char) -> <a href="#X-0e">X&lt;0&gt;</a>;</code>
 </pre>
 </div>
 </div>
@@ -96,9 +90,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;explicit-deduct-guide.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#X-0e">X&lt;0&gt;</a>(int) -> <a href="#X-0e">X&lt;0&gt;</a>;
-
-</code>
+<code class="source-code cpp"><a href="#X-0e">X&lt;0&gt;</a>(int) -> <a href="#X-0e">X&lt;0&gt;</a>;</code>
 </pre>
 </div>
 </div>
@@ -112,9 +104,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;explicit-deduct-guide.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;bool B = true&gt;
-<a href="#X-0e">X&lt;0&gt;</a>(long) -> <a href="#X-0e">X&lt;0&gt;</a>;
-
-</code>
+<a href="#X-0e">X&lt;0&gt;</a>(long) -> <a href="#X-0e">X&lt;0&gt;</a>;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/namespace-alias/namespace-alias-1.html b/test-files/golden-tests/symbols/namespace-alias/namespace-alias-1.html
index 01a94b44a..4ecb806ba 100644
--- a/test-files/golden-tests/symbols/namespace-alias/namespace-alias-1.html
+++ b/test-files/golden-tests/symbols/namespace-alias/namespace-alias-1.html
@@ -63,9 +63,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;namespace-alias-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 
@@ -80,9 +78,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;namespace-alias-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">namespace A = <a href="#LongName">LongName</a>;
-
-</code>
+<code class="source-code cpp">namespace A = <a href="#LongName">LongName</a>;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/namespace-alias/namespace-alias-2.html b/test-files/golden-tests/symbols/namespace-alias/namespace-alias-2.html
index 5f9cef62f..4e8ce2cec 100644
--- a/test-files/golden-tests/symbols/namespace-alias/namespace-alias-2.html
+++ b/test-files/golden-tests/symbols/namespace-alias/namespace-alias-2.html
@@ -64,9 +64,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;namespace-alias-2.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 
@@ -81,9 +79,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;namespace-alias-2.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">namespace A = <a href="#LongName">LongName</a>;
-
-</code>
+<code class="source-code cpp">namespace A = <a href="#LongName">LongName</a>;</code>
 </pre>
 </div>
 </div>
@@ -96,9 +92,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;namespace-alias-2.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">namespace B = <a href="#LongName">LongName</a>;
-
-</code>
+<code class="source-code cpp">namespace B = <a href="#LongName">LongName</a>;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/namespace-alias/namespace-alias-3.html b/test-files/golden-tests/symbols/namespace-alias/namespace-alias-3.html
index fb2790f40..a2e49dfbe 100644
--- a/test-files/golden-tests/symbols/namespace-alias/namespace-alias-3.html
+++ b/test-files/golden-tests/symbols/namespace-alias/namespace-alias-3.html
@@ -64,9 +64,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;namespace-alias-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 
@@ -81,9 +79,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;namespace-alias-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">namespace A = <a href="#LongName">LongName</a>;
-
-</code>
+<code class="source-code cpp">namespace A = <a href="#LongName">LongName</a>;</code>
 </pre>
 </div>
 </div>
@@ -96,9 +92,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;namespace-alias-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">namespace B = <a href="#A">A</a>;
-
-</code>
+<code class="source-code cpp">namespace B = <a href="#A">A</a>;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/namespace/namespace.html b/test-files/golden-tests/symbols/namespace/namespace.html
index 27c1b20ff..fe6c6508b 100644
--- a/test-files/golden-tests/symbols/namespace/namespace.html
+++ b/test-files/golden-tests/symbols/namespace/namespace.html
@@ -104,9 +104,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;namespace.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -120,9 +118,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;namespace.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -136,9 +132,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;namespace.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -152,9 +146,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;namespace.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f3();
-
-</code>
+f3();</code>
 </pre>
 </div>
 </div>
@@ -186,9 +178,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;namespace.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 </div>
@@ -220,9 +210,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;namespace.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f11();
-
-</code>
+f11();</code>
 </pre>
 </div>
 </div>
@@ -254,9 +242,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;namespace.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f14();
-
-</code>
+f14();</code>
 </pre>
 </div>
 </div>
@@ -270,9 +256,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;namespace.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f10();
-
-</code>
+f10();</code>
 </pre>
 </div>
 </div>
@@ -286,9 +270,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;namespace.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f12();
-
-</code>
+f12();</code>
 </pre>
 </div>
 </div>
@@ -302,9 +284,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;namespace.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -318,9 +298,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;namespace.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f7();
-
-</code>
+f7();</code>
 </pre>
 </div>
 </div>
@@ -334,9 +312,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;namespace.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f8();
-
-</code>
+f8();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/overloads/overloads-brief.html b/test-files/golden-tests/symbols/overloads/overloads-brief.html
index 619d4b9f8..7878e8958 100644
--- a/test-files/golden-tests/symbols/overloads/overloads-brief.html
+++ b/test-files/golden-tests/symbols/overloads/overloads-brief.html
@@ -19,8 +19,8 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A"><code>A</code></a> </td><td><span>Overload briefs from function or operator classes</span></td></tr><tr>
-<td><a href="#B"><code>B</code></a> </td><td><span>Auxiliary class</span></td></tr>
+<td><a href="#A"><code>A</code></a> </td><td>Overload briefs from function or operator classes</td></tr><tr>
+<td><a href="#B"><code>B</code></a> </td><td>Auxiliary class</td></tr>
 </tbody>
 </table>
 
@@ -34,9 +34,9 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#no_way_to_infer_this_brief-04"><code>no_way_to_infer_this_brief</code></a> </td><td><span><code>no_way_to_infer_this_brief</code> overloads</span></td></tr><tr>
-<td><a href="#operator_plus-09"><code>operator+</code></a> </td><td><span>Unary plus operators</span></td></tr><tr>
-<td><a href="#sameBrief-07"><code>sameBrief</code></a> </td><td><span>Function with same brief</span></td></tr>
+<td><a href="#no_way_to_infer_this_brief-04"><code>no_way_to_infer_this_brief</code></a> </td><td><code>no_way_to_infer_this_brief</code> overloads</td></tr><tr>
+<td><a href="#operator_plus-09"><code>operator+</code></a> </td><td>Unary plus operators</td></tr><tr>
+<td><a href="#sameBrief-07"><code>sameBrief</code></a> </td><td>Function with same brief</td></tr>
 </tbody>
 </table>
 
@@ -45,8 +45,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="A">A</h2>
 <div>
-<span>Overload briefs from function or operator classes</span>
-
+<p>Overload briefs from function or operator classes</p>
 </div>
 </div>
 <div>
@@ -54,9 +53,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -69,10 +66,10 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-2constructor-0f"><code>A</code></a>         <span class="small">[constructor]</span></td><td><span>Constructors</span></td></tr><tr>
-<td><a href="#A-operator_assign-04c"><code>operator&#x3D;</code></a> </td><td><span>Assignment operators</span></td></tr><tr>
-<td><a href="#A-operator_plus-00"><code>operator+</code></a> </td><td><span>Addition operators</span></td></tr><tr>
-<td><a href="#A-operator_minus-09"><code>operator-</code></a> </td><td><span>Unary minus operators</span></td></tr>
+<td><a href="#A-2constructor-0f"><code>A</code></a>         <span class="small">[constructor]</span></td><td>Constructors</td></tr><tr>
+<td><a href="#A-operator_assign-04c"><code>operator&#x3D;</code></a> </td><td>Assignment operators</td></tr><tr>
+<td><a href="#A-operator_plus-00"><code>operator+</code></a> </td><td>Addition operators</td></tr><tr>
+<td><a href="#A-operator_minus-09"><code>operator-</code></a> </td><td>Unary minus operators</td></tr>
 </tbody>
 </table>
 
@@ -88,7 +85,7 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#operator_plus-0d"><code>operator+</code></a></td><td><span>Unary operator for A</span></td></tr>
+<tr><td><a href="#operator_plus-0d"><code>operator+</code></a></td><td>Unary operator for A</td></tr>
 </tbody>
 </table>
 </div>
@@ -97,26 +94,21 @@ <h2>Non-Member Functions</h2>
 <div>
 <h2 id="A-2constructor-0f">A::A</h2>
 <div>
-<span>Constructors</span>
-
+<p>Constructors</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
-<span>First constructor</span>
+<p>First constructor</p>
 <pre>
-<code class="source-code cpp"><a href="#A-2constructor-03">A</a>();
-
-</code>
+<code class="source-code cpp"><a href="#A-2constructor-03">A</a>();</code>
 </pre><span class="small"><a href="#A-2constructor-03"><em>» more...</em></a></span>
 
-<span>Second constructor</span>
+<p>Second constructor</p>
 <pre>
-<code class="source-code cpp"><a href="#A-2constructor-01">A</a>(int a);
-
-</code>
+<code class="source-code cpp"><a href="#A-2constructor-01">A</a>(int a);</code>
 </pre><span class="small"><a href="#A-2constructor-01"><em>» more...</em></a></span>
 
 
@@ -133,7 +125,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Describe a</span></td>
+<td>Describe a</td>
 </tr>
 </tbody>
 </table>
@@ -143,8 +135,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="A-2constructor-03">A::A</h2>
 <div>
-<span>First constructor</span>
-
+<p>First constructor</p>
 </div>
 </div>
 <div>
@@ -152,9 +143,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">A();
-
-</code>
+<code class="source-code cpp">A();</code>
 </pre>
 </div>
 </div>
@@ -162,8 +151,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="A-2constructor-01">A::A</h2>
 <div>
-<span>Second constructor</span>
-
+<p>Second constructor</p>
 </div>
 </div>
 <div>
@@ -171,9 +159,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">A(int a);
-
-</code>
+<code class="source-code cpp">A(int a);</code>
 </pre>
 </div>
 <div>
@@ -188,7 +174,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Describe a</span></td>
+<td>Describe a</td>
 </tr>
 </tbody>
 </table>
@@ -198,35 +184,30 @@ <h3>Parameters</h3>
 <div>
 <h2 id="A-operator_assign-04c">A::operator&#x3D;</h2>
 <div>
-<span>Assignment operators</span>
-
+<p>Assignment operators</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
-<span>Assign from A</span>
+<p>Assign from A</p>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>&
-<a href="#A-operator_assign-045">operator&#x3D;</a>(<a href="#A">A</a> const& a);
-
-</code>
+<a href="#A-operator_assign-045">operator&#x3D;</a>(<a href="#A">A</a> const& a);</code>
 </pre><span class="small"><a href="#A-operator_assign-045"><em>» more...</em></a></span>
 
-<span>Assign from int</span>
+<p>Assign from int</p>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>&
-<a href="#A-operator_assign-06">operator&#x3D;</a>(int a);
-
-</code>
+<a href="#A-operator_assign-06">operator&#x3D;</a>(int a);</code>
 </pre><span class="small"><a href="#A-operator_assign-06"><em>» more...</em></a></span>
 
 
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>*this</code></span>
+<code>*this</code>
 </div>
 <div>
 <h3>Parameters</h3>
@@ -240,7 +221,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Describe a</span></td>
+<td>Describe a</td>
 </tr>
 </tbody>
 </table>
@@ -250,8 +231,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="A-operator_assign-045">A::operator&#x3D;</h2>
 <div>
-<span>Assign from A</span>
-
+<p>Assign from A</p>
 </div>
 </div>
 <div>
@@ -260,14 +240,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>&
-operator&#x3D;(<a href="#A">A</a> const& a);
-
-</code>
+operator&#x3D;(<a href="#A">A</a> const& a);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>*this</code></span>
+<code>*this</code>
 </div>
 <div>
 <h3>Parameters</h3>
@@ -281,7 +259,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Describe a</span></td>
+<td>Describe a</td>
 </tr>
 </tbody>
 </table>
@@ -291,8 +269,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="A-operator_assign-06">A::operator&#x3D;</h2>
 <div>
-<span>Assign from int</span>
-
+<p>Assign from int</p>
 </div>
 </div>
 <div>
@@ -301,14 +278,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>&
-operator&#x3D;(int a);
-
-</code>
+operator&#x3D;(int a);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>*this</code></span>
+<code>*this</code>
 </div>
 <div>
 <h3>Parameters</h3>
@@ -322,7 +297,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Describe b</span></td>
+<td>Describe b</td>
 </tr>
 </tbody>
 </table>
@@ -332,35 +307,30 @@ <h3>Parameters</h3>
 <div>
 <h2 id="A-operator_plus-00">A::operator+</h2>
 <div>
-<span>Addition operators</span>
-
+<p>Addition operators</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
-<span>Addition operator for ints</span>
+<p>Addition operator for ints</p>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>
-<a href="#A-operator_plus-0c">operator+</a>(int a);
-
-</code>
+<a href="#A-operator_plus-0c">operator+</a>(int a);</code>
 </pre><span class="small"><a href="#A-operator_plus-0c"><em>» more...</em></a></span>
 
-<span>Addition operator for As</span>
+<p>Addition operator for As</p>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>
-<a href="#A-operator_plus-0e">operator+</a>(<a href="#A">A</a> const& a);
-
-</code>
+<a href="#A-operator_plus-0e">operator+</a>(<a href="#A">A</a> const& a);</code>
 </pre><span class="small"><a href="#A-operator_plus-0e"><em>» more...</em></a></span>
 
 
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>*this</code></span>
+<code>*this</code>
 </div>
 <div>
 <h3>Parameters</h3>
@@ -374,7 +344,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Describe a</span></td>
+<td>Describe a</td>
 </tr>
 </tbody>
 </table>
@@ -384,8 +354,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="A-operator_plus-0c">A::operator+</h2>
 <div>
-<span>Addition operator for ints</span>
-
+<p>Addition operator for ints</p>
 </div>
 </div>
 <div>
@@ -394,14 +363,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>
-operator+(int a);
-
-</code>
+operator+(int a);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>*this</code></span>
+<code>*this</code>
 </div>
 <div>
 <h3>Parameters</h3>
@@ -415,7 +382,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Describe a</span></td>
+<td>Describe a</td>
 </tr>
 </tbody>
 </table>
@@ -425,8 +392,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="A-operator_plus-0e">A::operator+</h2>
 <div>
-<span>Addition operator for As</span>
-
+<p>Addition operator for As</p>
 </div>
 </div>
 <div>
@@ -435,14 +401,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>
-operator+(<a href="#A">A</a> const& a);
-
-</code>
+operator+(<a href="#A">A</a> const& a);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>*this</code></span>
+<code>*this</code>
 </div>
 <div>
 <h3>Parameters</h3>
@@ -456,7 +420,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Describe a</span></td>
+<td>Describe a</td>
 </tr>
 </tbody>
 </table>
@@ -466,43 +430,37 @@ <h3>Parameters</h3>
 <div>
 <h2 id="A-operator_minus-09">A::operator-</h2>
 <div>
-<span>Unary minus operators</span>
-
+<p>Unary minus operators</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
-<span>Unary operator- for A</span>
+<p>Unary operator- for A</p>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>
-<a href="#A-operator_minus-02">operator-</a>();
-
-</code>
+<a href="#A-operator_minus-02">operator-</a>();</code>
 </pre><span class="small"><a href="#A-operator_minus-02"><em>» more...</em></a></span>
 
-<span>Binary operator- for A</span>
+<p>Binary operator- for A</p>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>
-<a href="#A-operator_minus-0c">operator-</a>(<a href="#A">A</a> const& rhs);
-
-</code>
+<a href="#A-operator_minus-0c">operator-</a>(<a href="#A">A</a> const& rhs);</code>
 </pre><span class="small"><a href="#A-operator_minus-0c"><em>» more...</em></a></span>
 
 
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Result</span>
+Result
 </div>
 </div>
 <div>
 <div>
 <h2 id="A-operator_minus-02">A::operator-</h2>
 <div>
-<span>Unary operator- for A</span>
-
+<p>Unary operator- for A</p>
 </div>
 </div>
 <div>
@@ -511,9 +469,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>
-operator-();
-
-</code>
+operator-();</code>
 </pre>
 </div>
 <div>
@@ -522,15 +478,14 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Result</span>
+Result
 </div>
 </div>
 <div>
 <div>
 <h2 id="A-operator_minus-0c">A::operator-</h2>
 <div>
-<span>Binary operator- for A</span>
-
+<p>Binary operator- for A</p>
 </div>
 </div>
 <div>
@@ -539,9 +494,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#A">A</a>
-operator-(<a href="#A">A</a> const& rhs);
-
-</code>
+operator-(<a href="#A">A</a> const& rhs);</code>
 </pre>
 </div>
 <div>
@@ -550,7 +503,7 @@ <h3>Description</h3>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Result</span>
+Result
 </div>
 <div>
 <h3>Parameters</h3>
@@ -564,7 +517,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -574,8 +527,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="B">B</h2>
 <div>
-<span>Auxiliary class</span>
-
+<p>Auxiliary class</p>
 </div>
 </div>
 <div>
@@ -583,9 +535,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct B;
-
-</code>
+<code class="source-code cpp">struct B;</code>
 </pre>
 </div>
 
@@ -600,7 +550,7 @@ <h2>Non-Member Functions</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><a href="#operator_plus-06"><code>operator+</code></a></td><td><span>Unary operator for B</span></td></tr>
+<tr><td><a href="#operator_plus-06"><code>operator+</code></a></td><td>Unary operator for B</td></tr>
 </tbody>
 </table>
 </div>
@@ -609,28 +559,23 @@ <h2>Non-Member Functions</h2>
 <div>
 <h2 id="no_way_to_infer_this_brief-04">no_way_to_infer_this_brief</h2>
 <div>
-<span><code>no_way_to_infer_this_brief</code> overloads</span>
-
+<p><code>no_way_to_infer_this_brief</code> overloads</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
-<span>Function with no params</span>
+<p>Function with no params</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#no_way_to_infer_this_brief-02">no_way_to_infer_this_brief</a>();
-
-</code>
+<a href="#no_way_to_infer_this_brief-02">no_way_to_infer_this_brief</a>();</code>
 </pre><span class="small"><a href="#no_way_to_infer_this_brief-02"><em>» more...</em></a></span>
 
-<span>Function with single param</span>
+<p>Function with single param</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#no_way_to_infer_this_brief-01">no_way_to_infer_this_brief</a>(int a);
-
-</code>
+<a href="#no_way_to_infer_this_brief-01">no_way_to_infer_this_brief</a>(int a);</code>
 </pre><span class="small"><a href="#no_way_to_infer_this_brief-01"><em>» more...</em></a></span>
 
 
@@ -647,7 +592,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Describe a</span></td>
+<td>Describe a</td>
 </tr>
 </tbody>
 </table>
@@ -657,8 +602,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="no_way_to_infer_this_brief-02">no_way_to_infer_this_brief</h2>
 <div>
-<span>Function with no params</span>
-
+<p>Function with no params</p>
 </div>
 </div>
 <div>
@@ -667,9 +611,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-no_way_to_infer_this_brief();
-
-</code>
+no_way_to_infer_this_brief();</code>
 </pre>
 </div>
 </div>
@@ -677,8 +619,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="no_way_to_infer_this_brief-01">no_way_to_infer_this_brief</h2>
 <div>
-<span>Function with single param</span>
-
+<p>Function with single param</p>
 </div>
 </div>
 <div>
@@ -687,9 +628,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-no_way_to_infer_this_brief(int a);
-
-</code>
+no_way_to_infer_this_brief(int a);</code>
 </pre>
 </div>
 <div>
@@ -704,7 +643,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Describe a</span></td>
+<td>Describe a</td>
 </tr>
 </tbody>
 </table>
@@ -714,43 +653,37 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_plus-09">operator+</h2>
 <div>
-<span>Unary plus operators</span>
-
+<p>Unary plus operators</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
-<span>Unary operator for A</span>
+<p>Unary operator for A</p>
 <pre>
 <code class="source-code cpp">int
-<a href="#operator_plus-0d">operator+</a>(<a href="#A">A</a> const& value);
-
-</code>
+<a href="#operator_plus-0d">operator+</a>(<a href="#A">A</a> const& value);</code>
 </pre><span class="small"><a href="#operator_plus-0d"><em>» more...</em></a></span>
 
-<span>Unary operator for B</span>
+<p>Unary operator for B</p>
 <pre>
 <code class="source-code cpp">int
-<a href="#operator_plus-06">operator+</a>(<a href="#B">B</a> const& value);
-
-</code>
+<a href="#operator_plus-06">operator+</a>(<a href="#B">B</a> const& value);</code>
 </pre><span class="small"><a href="#operator_plus-06"><em>» more...</em></a></span>
 
 
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Result</span>
+Result
 </div>
 </div>
 <div>
 <div>
 <h2 id="operator_plus-0d">operator+</h2>
 <div>
-<span>Unary operator for A</span>
-
+<p>Unary operator for A</p>
 </div>
 </div>
 <div>
@@ -759,14 +692,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int
-operator+(<a href="#A">A</a> const& value);
-
-</code>
+operator+(<a href="#A">A</a> const& value);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Result</span>
+Result
 </div>
 <div>
 <h3>Parameters</h3>
@@ -780,7 +711,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The operand</span></td>
+<td>The operand</td>
 </tr>
 </tbody>
 </table>
@@ -790,8 +721,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_plus-06">operator+</h2>
 <div>
-<span>Unary operator for B</span>
-
+<p>Unary operator for B</p>
 </div>
 </div>
 <div>
@@ -800,14 +730,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int
-operator+(<a href="#B">B</a> const& value);
-
-</code>
+operator+(<a href="#B">B</a> const& value);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Result</span>
+Result
 </div>
 <div>
 <h3>Parameters</h3>
@@ -821,7 +749,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The operand</span></td>
+<td>The operand</td>
 </tr>
 </tbody>
 </table>
@@ -831,30 +759,25 @@ <h3>Parameters</h3>
 <div>
 <h2 id="sameBrief-07">sameBrief</h2>
 <div>
-<span>Function with same brief</span>
-
+<p>Function with same brief</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
-<span>Function with same brief</span>
+<p>Function with same brief</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#sameBrief-0a">sameBrief</a>(int a);
-
-</code>
+<a href="#sameBrief-0a">sameBrief</a>(int a);</code>
 </pre><span class="small"><a href="#sameBrief-0a"><em>» more...</em></a></span>
 
-<span>Function with same brief</span>
+<p>Function with same brief</p>
 <pre>
 <code class="source-code cpp">void
 <a href="#sameBrief-0e">sameBrief</a>(
     int a,
-    int b);
-
-</code>
+    int b);</code>
 </pre><span class="small"><a href="#sameBrief-0e"><em>» more...</em></a></span>
 
 
@@ -871,11 +794,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Describe a</span></td>
+<td>Describe a</td>
 </tr>
 <tr>
 <td><strong>b</strong></td>
-<td><span>Describe b</span></td>
+<td>Describe b</td>
 </tr>
 </tbody>
 </table>
@@ -885,8 +808,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="sameBrief-0a">sameBrief</h2>
 <div>
-<span>Function with same brief</span>
-
+<p>Function with same brief</p>
 </div>
 </div>
 <div>
@@ -895,9 +817,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;overloads-brief.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-sameBrief(int a);
-
-</code>
+sameBrief(int a);</code>
 </pre>
 </div>
 <div>
@@ -912,7 +832,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Describe a</span></td>
+<td>Describe a</td>
 </tr>
 </tbody>
 </table>
@@ -922,8 +842,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="sameBrief-0e">sameBrief</h2>
 <div>
-<span>Function with same brief</span>
-
+<p>Function with same brief</p>
 </div>
 </div>
 <div>
@@ -934,9 +853,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">void
 sameBrief(
     int a,
-    int b);
-
-</code>
+    int b);</code>
 </pre>
 </div>
 <div>
@@ -951,11 +868,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Describe a again</span></td>
+<td>Describe a again</td>
 </tr>
 <tr>
 <td><strong>b</strong></td>
-<td><span>Describe b</span></td>
+<td>Describe b</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/symbols/overloads/overloads-metadata.html b/test-files/golden-tests/symbols/overloads/overloads-metadata.html
index b481f6ff3..0c547a937 100644
--- a/test-files/golden-tests/symbols/overloads/overloads-metadata.html
+++ b/test-files/golden-tests/symbols/overloads/overloads-metadata.html
@@ -19,7 +19,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f-0c"><code>f</code></a> </td><td><span>Test function</span></td></tr>
+<td><a href="#f-0c"><code>f</code></a> </td><td>Test function</td></tr>
 </tbody>
 </table>
 
@@ -28,34 +28,29 @@ <h2>Functions</h2>
 <div>
 <h2 id="f-0c">f</h2>
 <div>
-<span>Test function</span>
-
+<p>Test function</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;overloads-metadata.cpp&gt;</code></div>
-<span>Test function</span>
+<p>Test function</p>
 <pre>
 <code class="source-code cpp">template&lt;class A&gt;
 int
-<a href="#f-08">f</a>(int a);
-
-</code>
+<a href="#f-08">f</a>(int a);</code>
 </pre><span class="small"><a href="#f-08"><em>» more...</em></a></span>
 
-<span>Test function</span>
+<p>Test function</p>
 <pre>
 <code class="source-code cpp">int
 <a href="#f-04">f</a>(
     int a,
-    void*);
-
-</code>
+    void*);</code>
 </pre><span class="small"><a href="#f-04"><em>» more...</em></a></span>
 
-<span>Test function</span>
+<p>Test function</p>
 <pre>
 <code class="source-code cpp">template&lt;
     class A,
@@ -63,9 +58,7 @@ <h3>Synopses</h3>
 int
 <a href="#f-02">f</a>(
     int a,
-    int b);
-
-</code>
+    int b);</code>
 </pre><span class="small"><a href="#f-02"><em>» more...</em></a></span>
 
 
@@ -82,11 +75,11 @@ <h3>Exceptions</h3>
 <tbody>
 <tr>
 <td><code>std::runtime_error</code></td>
-<td><span>Describe the exception</span></td>
+<td>Describe the exception</td>
 </tr>
 <tr>
 <td><code>std::logic_error</code></td>
-<td><span>Describe the exception</span></td>
+<td>Describe the exception</td>
 </tr>
 </tbody>
 </table>
@@ -94,8 +87,8 @@ <h3>Exceptions</h3>
 <div>
 <h3>Return Value</h3>
 <ul>
-<li><span>The number corresponding to a</span></li>
-<li><span>The number corresponding to a and b</span></li>
+<li>The number corresponding to a</li>
+<li>The number corresponding to a and b</li>
 </ul>
 </div>
 <div>
@@ -110,11 +103,11 @@ <h3>Template Parameters</h3>
 <tbody>
 <tr>
 <td><strong>A</strong></td>
-<td><span>Describe A</span></td>
+<td>Describe A</td>
 </tr>
 <tr>
 <td><strong>B</strong></td>
-<td><span>Describe B</span></td>
+<td>Describe B</td>
 </tr>
 </tbody>
 </table>
@@ -131,11 +124,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Describe a</span></td>
+<td>Describe a</td>
 </tr>
 <tr>
 <td><strong>b</strong></td>
-<td><span>Describe b</span></td>
+<td>Describe b</td>
 </tr>
 </tbody>
 </table>
@@ -143,29 +136,30 @@ <h3>Parameters</h3>
 <div>
 <h3>Preconditions</h3>
 <ul>
-<li><span>a must be greater than 0</span></li>
-<li><span>b must be greater than 0</span></li>
+<li>a must be greater than 0</li>
+<li>b must be greater than 0</li>
 </ul>
 </div>
 <div>
 <h3>Postconditions</h3>
 <ul>
-<li><span>The return value is greater than 0</span></li>
-<li><span>The return value is greater than 10</span></li>
+<li>The return value is greater than 0</li>
+<li>The return value is greater than 10</li>
 </ul>
 </div>
 <div>
 <h3>See Also</h3>
-<p><span>Interesting information 1</span></p>
-<p><span>Interesting information 2</span></p>
+<p><p>Interesting information 1</p>
+</p>
+<p><p>Interesting information 2</p>
+</p>
 </div>
 </div>
 <div>
 <div>
 <h2 id="f-08">f</h2>
 <div>
-<span>Test function</span>
-
+<p>Test function</p>
 </div>
 </div>
 <div>
@@ -175,9 +169,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;class A&gt;
 int
-f(int a);
-
-</code>
+f(int a);</code>
 </pre>
 </div>
 <div>
@@ -192,14 +184,14 @@ <h3>Exceptions</h3>
 <tbody>
 <tr>
 <td><code>std::runtime_error</code></td>
-<td><span>Describe the exception</span></td>
+<td>Describe the exception</td>
 </tr>
 </tbody>
 </table>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The number corresponding to a</span>
+The number corresponding to a
 </div>
 <div>
 <h3>Template Parameters</h3>
@@ -213,7 +205,7 @@ <h3>Template Parameters</h3>
 <tbody>
 <tr>
 <td><strong>A</strong></td>
-<td><span>Describe A</span></td>
+<td>Describe A</td>
 </tr>
 </tbody>
 </table>
@@ -230,7 +222,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Describe a</span></td>
+<td>Describe a</td>
 </tr>
 </tbody>
 </table>
@@ -238,26 +230,26 @@ <h3>Parameters</h3>
 <div>
 <h3>Preconditions</h3>
 <ul>
-<li><span>a must be greater than 0</span></li>
+<li>a must be greater than 0</li>
 </ul>
 </div>
 <div>
 <h3>Postconditions</h3>
 <ul>
-<li><span>The return value is greater than 0</span></li>
+<li>The return value is greater than 0</li>
 </ul>
 </div>
 <div>
 <h3>See Also</h3>
-<p><span>Interesting information 1</span></p>
+<p><p>Interesting information 1</p>
+</p>
 </div>
 </div>
 <div>
 <div>
 <h2 id="f-04">f</h2>
 <div>
-<span>Test function</span>
-
+<p>Test function</p>
 </div>
 </div>
 <div>
@@ -268,14 +260,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">int
 f(
     int a,
-    void*);
-
-</code>
+    void*);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The number corresponding to a</span>
+The number corresponding to a
 </div>
 <div>
 <h3>Parameters</h3>
@@ -289,22 +279,22 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Describe a again</span></td>
+<td>Describe a again</td>
 </tr>
 </tbody>
 </table>
 </div>
 <div>
 <h3>See Also</h3>
-<p><span>Interesting information 2</span></p>
+<p><p>Interesting information 2</p>
+</p>
 </div>
 </div>
 <div>
 <div>
 <h2 id="f-02">f</h2>
 <div>
-<span>Test function</span>
-
+<p>Test function</p>
 </div>
 </div>
 <div>
@@ -318,9 +308,7 @@ <h3>Synopsis</h3>
 int
 f(
     int a,
-    int b);
-
-</code>
+    int b);</code>
 </pre>
 </div>
 <div>
@@ -335,14 +323,14 @@ <h3>Exceptions</h3>
 <tbody>
 <tr>
 <td><code>std::logic_error</code></td>
-<td><span>Describe the exception</span></td>
+<td>Describe the exception</td>
 </tr>
 </tbody>
 </table>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The number corresponding to a and b</span>
+The number corresponding to a and b
 </div>
 <div>
 <h3>Template Parameters</h3>
@@ -356,11 +344,11 @@ <h3>Template Parameters</h3>
 <tbody>
 <tr>
 <td><strong>A</strong></td>
-<td><span>Describe A again</span></td>
+<td>Describe A again</td>
 </tr>
 <tr>
 <td><strong>B</strong></td>
-<td><span>Describe B</span></td>
+<td>Describe B</td>
 </tr>
 </tbody>
 </table>
@@ -377,11 +365,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>a</strong></td>
-<td><span>Describe a again</span></td>
+<td>Describe a again</td>
 </tr>
 <tr>
 <td><strong>b</strong></td>
-<td><span>Describe b</span></td>
+<td>Describe b</td>
 </tr>
 </tbody>
 </table>
@@ -389,14 +377,14 @@ <h3>Parameters</h3>
 <div>
 <h3>Preconditions</h3>
 <ul>
-<li><span>a must be greater than 0</span></li>
-<li><span>b must be greater than 0</span></li>
+<li>a must be greater than 0</li>
+<li>b must be greater than 0</li>
 </ul>
 </div>
 <div>
 <h3>Postconditions</h3>
 <ul>
-<li><span>The return value is greater than 10</span></li>
+<li>The return value is greater than 10</li>
 </ul>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/overloads/overloads-ostream.adoc b/test-files/golden-tests/symbols/overloads/overloads-ostream.adoc
index 4394ab870..4880f82e3 100644
--- a/test-files/golden-tests/symbols/overloads/overloads-ostream.adoc
+++ b/test-files/golden-tests/symbols/overloads/overloads-ostream.adoc
@@ -227,6 +227,18 @@ Declared in `&lt;overloads&hyphen;ostream&period;cpp&gt;`
 class OStream;
 ----
 
+=== Non-Member Functions
+
+[cols=2]
+|===
+| Name
+| Description
+| link:#ostream-operator_lshift-0a[`operator&lt;&lt;`]
+| Stream insertion operator
+| link:#ostream-operator_lshift-0d[`operator&lt;&lt;`]
+| Stream insertion operator
+|===
+
 [#ostream-operator_lshift-0f]
 == link:#ostream[ostream]::operator&lt;&lt;
 
diff --git a/test-files/golden-tests/symbols/overloads/overloads-ostream.html b/test-files/golden-tests/symbols/overloads/overloads-ostream.html
index 37019a9fc..16ff20b5f 100644
--- a/test-files/golden-tests/symbols/overloads/overloads-ostream.html
+++ b/test-files/golden-tests/symbols/overloads/overloads-ostream.html
@@ -64,9 +64,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;overloads-ostream.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class A;
-
-</code>
+<code class="source-code cpp">class A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -79,7 +77,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#left_shift-A-operator_lshift-00"><code>operator&lt;&lt;</code></a> </td><td><span>Left shift operators</span></td></tr>
+<td><a href="#left_shift-A-operator_lshift-00"><code>operator&lt;&lt;</code></a> </td><td>Left shift operators</td></tr>
 </tbody>
 </table>
 
@@ -90,28 +88,23 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="left_shift-A-operator_lshift-00">left_shift::A::operator&lt;&lt;</h2>
 <div>
-<span>Left shift operators</span>
-
+<p>Left shift operators</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;overloads-ostream.cpp&gt;</code></div>
-<span>Left shift operator</span>
+<p>Left shift operator</p>
 <pre>
 <code class="source-code cpp"><a href="#left_shift-A">A</a>&
-<a href="#left_shift-A-operator_lshift-0f">operator&lt;&lt;</a>(unsigned int shift);
-
-</code>
+<a href="#left_shift-A-operator_lshift-0f">operator&lt;&lt;</a>(unsigned int shift);</code>
 </pre><span class="small"><a href="#left_shift-A-operator_lshift-0f"><em>» more...</em></a></span>
 
-<span>Left shift operator</span>
+<p>Left shift operator</p>
 <pre>
 <code class="source-code cpp"><a href="#left_shift-A">A</a>&
-<a href="#left_shift-A-operator_lshift-0b">operator&lt;&lt;</a>(char shift);
-
-</code>
+<a href="#left_shift-A-operator_lshift-0b">operator&lt;&lt;</a>(char shift);</code>
 </pre><span class="small"><a href="#left_shift-A-operator_lshift-0b"><em>» more...</em></a></span>
 
 
@@ -121,8 +114,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="left_shift-A-operator_lshift-0f">left_shift::A::operator&lt;&lt;</h2>
 <div>
-<span>Left shift operator</span>
-
+<p>Left shift operator</p>
 </div>
 </div>
 <div>
@@ -131,14 +123,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;overloads-ostream.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#left_shift-A">A</a>&
-operator&lt;&lt;(unsigned int shift);
-
-</code>
+operator&lt;&lt;(unsigned int shift);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Reference to the current object</span>
+Reference to the current object
 </div>
 <div>
 <h3>Parameters</h3>
@@ -152,7 +142,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>shift</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -162,8 +152,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="left_shift-A-operator_lshift-0b">left_shift::A::operator&lt;&lt;</h2>
 <div>
-<span>Left shift operator</span>
-
+<p>Left shift operator</p>
 </div>
 </div>
 <div>
@@ -172,14 +161,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;overloads-ostream.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp"><a href="#left_shift-A">A</a>&
-operator&lt;&lt;(char shift);
-
-</code>
+operator&lt;&lt;(char shift);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Reference to the current object</span>
+Reference to the current object
 </div>
 <div>
 <h3>Parameters</h3>
@@ -193,7 +180,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>shift</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -211,9 +198,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp"><a href="#left_shift-A">A</a>
 operator&lt;&lt;(
     <a href="#left_shift-A">A</a> const& obj,
-    double shift);
-
-</code>
+    double shift);</code>
 </pre>
 </div>
 </div>
@@ -246,7 +231,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#ostream-operator_lshift-0f"><code>operator&lt;&lt;</code></a> </td><td><span>Stream insertion operators</span></td></tr>
+<td><a href="#ostream-operator_lshift-0f"><code>operator&lt;&lt;</code></a> </td><td>Stream insertion operators</td></tr>
 </tbody>
 </table>
 
@@ -260,9 +245,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;overloads-ostream.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class B;
-
-</code>
+<code class="source-code cpp">class B;</code>
 </pre>
 </div>
 
@@ -279,7 +262,7 @@ <h2>Friends</h2>
 <tbody>
 <tr>
 <td><code><a href="#ostream-operator_lshift-0d">operator&lt;&lt;</a></code></td>
-<td><span>Stream insertion operator</span></td>
+<td>Stream insertion operator</td>
 </tr>
 |===
 </tbody>
@@ -295,9 +278,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;overloads-ostream.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class C;
-
-</code>
+<code class="source-code cpp">class C;</code>
 </pre>
 </div>
 
@@ -312,44 +293,52 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;overloads-ostream.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class OStream;
-
-</code>
+<code class="source-code cpp">class OStream;</code>
 </pre>
 </div>
 
 
+<div>
+<h2>Non-Member Functions</h2>
+<table>
+<thead>
+<tr>
+<th>Name</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr><td><a href="#ostream-operator_lshift-0a"><code>operator&lt;&lt;</code></a></td><td>Stream insertion operator</td></tr>
+<tr><td><a href="#ostream-operator_lshift-0d"><code>operator&lt;&lt;</code></a></td><td>Stream insertion operator</td></tr>
+</tbody>
+</table>
+</div>
 </div>
 <div>
 <div>
 <h2 id="ostream-operator_lshift-0f">ostream::operator&lt;&lt;</h2>
 <div>
-<span>Stream insertion operators</span>
-
+<p>Stream insertion operators</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;overloads-ostream.cpp&gt;</code></div>
-<span>Stream insertion operator</span>
+<p>Stream insertion operator</p>
 <pre>
 <code class="source-code cpp"><a href="#ostream-OStream">OStream</a>&
 <a href="#ostream-operator_lshift-0d">operator&lt;&lt;</a>(
     <a href="#ostream-OStream">OStream</a>& os,
-    <a href="#ostream-B">B</a> value);
-
-</code>
+    <a href="#ostream-B">B</a> value);</code>
 </pre><span class="small"><a href="#ostream-operator_lshift-0d"><em>» more...</em></a></span>
 
-<span>Stream insertion operator</span>
+<p>Stream insertion operator</p>
 <pre>
 <code class="source-code cpp"><a href="#ostream-OStream">OStream</a>&
 <a href="#ostream-operator_lshift-0a">operator&lt;&lt;</a>(
     <a href="#ostream-OStream">OStream</a>& os,
-    <a href="#ostream-C">C</a> value);
-
-</code>
+    <a href="#ostream-C">C</a> value);</code>
 </pre><span class="small"><a href="#ostream-operator_lshift-0a"><em>» more...</em></a></span>
 
 
@@ -359,8 +348,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="ostream-operator_lshift-0d">ostream::operator&lt;&lt;</h2>
 <div>
-<span>Stream insertion operator</span>
-
+<p>Stream insertion operator</p>
 </div>
 </div>
 <div>
@@ -371,14 +359,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp"><a href="#ostream-OStream">OStream</a>&
 operator&lt;&lt;(
     <a href="#ostream-OStream">OStream</a>& os,
-    <a href="#ostream-B">B</a> value);
-
-</code>
+    <a href="#ostream-B">B</a> value);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Reference to the current output stream</span>
+Reference to the current output stream
 </div>
 <div>
 <h3>Parameters</h3>
@@ -392,11 +378,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>os</strong></td>
-<td><span>An output stream</span></td>
+<td>An output stream</td>
 </tr>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The object to output</span></td>
+<td>The object to output</td>
 </tr>
 </tbody>
 </table>
@@ -406,8 +392,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="ostream-operator_lshift-0a">ostream::operator&lt;&lt;</h2>
 <div>
-<span>Stream insertion operator</span>
-
+<p>Stream insertion operator</p>
 </div>
 </div>
 <div>
@@ -418,14 +403,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp"><a href="#ostream-OStream">OStream</a>&
 operator&lt;&lt;(
     <a href="#ostream-OStream">OStream</a>& os,
-    <a href="#ostream-C">C</a> value);
-
-</code>
+    <a href="#ostream-C">C</a> value);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>Reference to the current output stream</span>
+Reference to the current output stream
 </div>
 <div>
 <h3>Parameters</h3>
@@ -439,11 +422,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>os</strong></td>
-<td><span>An output stream</span></td>
+<td>An output stream</td>
 </tr>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The object to output</span></td>
+<td>The object to output</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/symbols/overloads/overloads-ostream.xml b/test-files/golden-tests/symbols/overloads/overloads-ostream.xml
index 647cfab7b..8ec2df854 100644
--- a/test-files/golden-tests/symbols/overloads/overloads-ostream.xml
+++ b/test-files/golden-tests/symbols/overloads/overloads-ostream.xml
@@ -80,6 +80,12 @@
     </class>
     <class name="OStream" id="A6n++lhHK0l+ailOmBfa/TZCXd8=">
       <file short-path="overloads-ostream.cpp" source-path="overloads-ostream.cpp" line="21" class="def"/>
+      <doc>
+        <related>
+          <reference id="ojxr+36qVG3RcL9uyYCrmeMtpKQ=">operator&lt;&lt;</reference>
+          <reference id="1fuMcZHDrARpZPSclbAk4IYVnps=">operator&lt;&lt;</reference>
+        </related>
+      </doc>
     </class>
     <function name="operator&lt;&lt;" id="1fuMcZHDrARpZPSclbAk4IYVnps=">
       <file short-path="overloads-ostream.cpp" source-path="overloads-ostream.cpp" line="25"/>
@@ -110,6 +116,9 @@
         <param name="value">
           <text>The object to output</text>
         </param>
+        <relates>
+          <reference id="A6n++lhHK0l+ailOmBfa/TZCXd8=">OStream</reference>
+        </relates>
       </doc>
     </function>
     <function name="operator&lt;&lt;" id="ojxr+36qVG3RcL9uyYCrmeMtpKQ=">
@@ -141,6 +150,9 @@
         <param name="value">
           <text>The object to output</text>
         </param>
+        <relates>
+          <reference id="A6n++lhHK0l+ailOmBfa/TZCXd8=">OStream</reference>
+        </relates>
       </doc>
     </function>
   </namespace>
diff --git a/test-files/golden-tests/symbols/overloads/overloads.adoc b/test-files/golden-tests/symbols/overloads/overloads.adoc
index 8020a8cd7..5dd6b59df 100644
--- a/test-files/golden-tests/symbols/overloads/overloads.adoc
+++ b/test-files/golden-tests/symbols/overloads/overloads.adoc
@@ -39,22 +39,18 @@ struct A;
 
 === Member Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#A-f-07[`f`] 
-| 
 |===
 
 === Static Member Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#A-g-0d[`g`] 
-| 
 |===
 
 === Friends
@@ -187,6 +183,18 @@ Declared in `&lt;overloads&period;cpp&gt;`
 struct B;
 ----
 
+=== Non-Member Functions
+
+[cols=2]
+|===
+| Name
+| Description
+| link:#operator_eq-071[`operator&equals;&equals;`]
+| Equality operator
+| link:#operator_eq-08[`operator&equals;&equals;`]
+| Equality operator
+|===
+
 [#f-0c]
 == f
 
diff --git a/test-files/golden-tests/symbols/overloads/overloads.html b/test-files/golden-tests/symbols/overloads/overloads.html
index 4e9e28895..8ca5961ea 100644
--- a/test-files/golden-tests/symbols/overloads/overloads.html
+++ b/test-files/golden-tests/symbols/overloads/overloads.html
@@ -33,8 +33,8 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f-0c"><code>f</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#operator_eq-073"><code>operator&#x3D;&#x3D;</code></a> </td><td><span>Equality operators</span></td></tr>
+<td><a href="#f-0c"><code>f</code></a> </td><td></td></tr><tr>
+<td><a href="#operator_eq-073"><code>operator&#x3D;&#x3D;</code></a> </td><td>Equality operators</td></tr>
 </tbody>
 </table>
 
@@ -48,9 +48,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;overloads.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -58,12 +56,11 @@ <h2>Member Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-f-07"><code>f</code></a> </td><td><span></span></td></tr>
+<td><a href="#A-f-07"><code>f</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -72,12 +69,11 @@ <h2>Static Member Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-g-0d"><code>g</code></a> </td><td><span></span></td></tr>
+<td><a href="#A-g-0d"><code>g</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -95,11 +91,11 @@ <h2>Friends</h2>
 <tbody>
 <tr>
 <td><code><a href="#operator_eq-0e">operator&#x3D;&#x3D;</a></code></td>
-<td><span>Equality operator</span></td>
+<td>Equality operator</td>
 </tr>
 <tr>
 <td><code><a href="#operator_eq-0a">operator&#x3D;&#x3D;</a></code></td>
-<td><span>Equality operator</span></td>
+<td>Equality operator</td>
 </tr>
 |===
 </tbody>
@@ -117,17 +113,13 @@ <h3>Synopses</h3>
 
 <pre>
 <code class="source-code cpp">void
-<a href="#A-f-08">f</a>();
-
-</code>
+<a href="#A-f-08">f</a>();</code>
 </pre><span class="small"><a href="#A-f-08"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">int
-<a href="#A-f-0e">f</a>(int);
-
-</code>
+<a href="#A-f-0e">f</a>(int);</code>
 </pre><span class="small"><a href="#A-f-0e"><em>» more...</em></a></span>
 
 
@@ -143,9 +135,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;overloads.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -159,9 +149,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;overloads.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int
-f(int);
-
-</code>
+f(int);</code>
 </pre>
 </div>
 </div>
@@ -177,18 +165,14 @@ <h3>Synopses</h3>
 <pre>
 <code class="source-code cpp">static
 void
-<a href="#A-g-0a">g</a>();
-
-</code>
+<a href="#A-g-0a">g</a>();</code>
 </pre><span class="small"><a href="#A-g-0a"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">static
 int
-<a href="#A-g-01">g</a>(int);
-
-</code>
+<a href="#A-g-01">g</a>(int);</code>
 </pre><span class="small"><a href="#A-g-01"><em>» more...</em></a></span>
 
 
@@ -205,9 +189,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">static
 void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
@@ -222,9 +204,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">static
 int
-g(int);
-
-</code>
+g(int);</code>
 </pre>
 </div>
 </div>
@@ -237,13 +217,26 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;overloads.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct B;
-
-</code>
+<code class="source-code cpp">struct B;</code>
 </pre>
 </div>
 
 
+<div>
+<h2>Non-Member Functions</h2>
+<table>
+<thead>
+<tr>
+<th>Name</th>
+<th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr><td><a href="#operator_eq-071"><code>operator&#x3D;&#x3D;</code></a></td><td>Equality operator</td></tr>
+<tr><td><a href="#operator_eq-08"><code>operator&#x3D;&#x3D;</code></a></td><td>Equality operator</td></tr>
+</tbody>
+</table>
+</div>
 </div>
 <div>
 <div>
@@ -256,17 +249,13 @@ <h3>Synopses</h3>
 
 <pre>
 <code class="source-code cpp">void
-<a href="#f-0b">f</a>();
-
-</code>
+<a href="#f-0b">f</a>();</code>
 </pre><span class="small"><a href="#f-0b"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">int
-<a href="#f-06">f</a>(int);
-
-</code>
+<a href="#f-06">f</a>(int);</code>
 </pre><span class="small"><a href="#f-06"><em>» more...</em></a></span>
 
 
@@ -282,9 +271,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;overloads.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -298,9 +285,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;overloads.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int
-f(int);
-
-</code>
+f(int);</code>
 </pre>
 </div>
 </div>
@@ -308,52 +293,43 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="operator_eq-073">operator&#x3D;&#x3D;</h2>
 <div>
-<span>Equality operators</span>
-
+<p>Equality operators</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;overloads.cpp&gt;</code></div>
-<span>Equality operator</span>
+<p>Equality operator</p>
 <pre>
 <code class="source-code cpp">bool
 <a href="#operator_eq-0e">operator&#x3D;&#x3D;</a>(
     <a href="#A">A</a> lhs,
-    int rhs);
-
-</code>
+    int rhs);</code>
 </pre><span class="small"><a href="#operator_eq-0e"><em>» more...</em></a></span>
 
-<span>Equality operator</span>
+<p>Equality operator</p>
 <pre>
 <code class="source-code cpp">bool
 <a href="#operator_eq-0a">operator&#x3D;&#x3D;</a>(
     <a href="#A">A</a> lhs,
-    <a href="#A">A</a> rhs);
-
-</code>
+    <a href="#A">A</a> rhs);</code>
 </pre><span class="small"><a href="#operator_eq-0a"><em>» more...</em></a></span>
 
-<span>Equality operator</span>
+<p>Equality operator</p>
 <pre>
 <code class="source-code cpp">bool
 <a href="#operator_eq-08">operator&#x3D;&#x3D;</a>(
     <a href="#B">B</a> lhs,
-    <a href="#B">B</a> rhs);
-
-</code>
+    <a href="#B">B</a> rhs);</code>
 </pre><span class="small"><a href="#operator_eq-08"><em>» more...</em></a></span>
 
-<span>Equality operator</span>
+<p>Equality operator</p>
 <pre>
 <code class="source-code cpp">bool
 <a href="#operator_eq-071">operator&#x3D;&#x3D;</a>(
     <a href="#B">B</a> lhs,
-    int rhs);
-
-</code>
+    int rhs);</code>
 </pre><span class="small"><a href="#operator_eq-071"><em>» more...</em></a></span>
 
 
@@ -363,8 +339,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="operator_eq-0e">operator&#x3D;&#x3D;</h2>
 <div>
-<span>Equality operator</span>
-
+<p>Equality operator</p>
 </div>
 </div>
 <div>
@@ -375,14 +350,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">bool
 operator&#x3D;&#x3D;(
     <a href="#A">A</a> lhs,
-    int rhs);
-
-</code>
+    int rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -396,11 +369,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -410,8 +383,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_eq-0a">operator&#x3D;&#x3D;</h2>
 <div>
-<span>Equality operator</span>
-
+<p>Equality operator</p>
 </div>
 </div>
 <div>
@@ -422,14 +394,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">bool
 operator&#x3D;&#x3D;(
     <a href="#A">A</a> lhs,
-    <a href="#A">A</a> rhs);
-
-</code>
+    <a href="#A">A</a> rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -443,11 +413,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -457,8 +427,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_eq-08">operator&#x3D;&#x3D;</h2>
 <div>
-<span>Equality operator</span>
-
+<p>Equality operator</p>
 </div>
 </div>
 <div>
@@ -469,14 +438,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">bool
 operator&#x3D;&#x3D;(
     <a href="#B">B</a> lhs,
-    <a href="#B">B</a> rhs);
-
-</code>
+    <a href="#B">B</a> rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -490,11 +457,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
@@ -504,8 +471,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="operator_eq-071">operator&#x3D;&#x3D;</h2>
 <div>
-<span>Equality operator</span>
-
+<p>Equality operator</p>
 </div>
 </div>
 <div>
@@ -516,14 +482,12 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">bool
 operator&#x3D;&#x3D;(
     <a href="#B">B</a> lhs,
-    int rhs);
-
-</code>
+    int rhs);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span><code>true</code> if the objects are equal, <code>false</code> otherwise</span>
+<code>true</code> if the objects are equal, <code>false</code> otherwise
 </div>
 <div>
 <h3>Parameters</h3>
@@ -537,11 +501,11 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>lhs</strong></td>
-<td><span>The left operand</span></td>
+<td>The left operand</td>
 </tr>
 <tr>
 <td><strong>rhs</strong></td>
-<td><span>The right operand</span></td>
+<td>The right operand</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/symbols/overloads/overloads.xml b/test-files/golden-tests/symbols/overloads/overloads.xml
index 702365ced..c2dbb0e39 100644
--- a/test-files/golden-tests/symbols/overloads/overloads.xml
+++ b/test-files/golden-tests/symbols/overloads/overloads.xml
@@ -39,6 +39,12 @@
   </struct>
   <struct name="B" id="3JsK1DO0O+wZhv+0meptQrbs3fY=">
     <file short-path="overloads.cpp" source-path="overloads.cpp" line="15" class="def"/>
+    <doc>
+      <related>
+        <reference id="cVrZLPSmQHMz47ziL64cElytjh0=">operator==</reference>
+        <reference id="gddLjn5hKdr6Ei8xKgtcB3bktI4=">operator==</reference>
+      </related>
+    </doc>
   </struct>
   <function name="f" id="s6nsa+zVhpzzrN+yUVPP5rvdXqs=">
     <file short-path="overloads.cpp" source-path="overloads.cpp" line="12"/>
@@ -140,6 +146,9 @@
       <param name="rhs">
         <text>The right operand</text>
       </param>
+      <relates>
+        <reference id="3JsK1DO0O+wZhv+0meptQrbs3fY=">B</reference>
+      </relates>
     </doc>
   </function>
   <function name="operator==" id="cVrZLPSmQHMz47ziL64cElytjh0=">
@@ -170,6 +179,9 @@
       <param name="rhs">
         <text>The right operand</text>
       </param>
+      <relates>
+        <reference id="3JsK1DO0O+wZhv+0meptQrbs3fY=">B</reference>
+      </relates>
     </doc>
   </function>
 </namespace>
diff --git a/test-files/golden-tests/symbols/record/class-private-alias.html b/test-files/golden-tests/symbols/record/class-private-alias.html
index 733e64feb..694cc5980 100644
--- a/test-files/golden-tests/symbols/record/class-private-alias.html
+++ b/test-files/golden-tests/symbols/record/class-private-alias.html
@@ -32,9 +32,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-private-alias.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class S;
-
-</code>
+<code class="source-code cpp">class S;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -63,9 +61,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-private-alias.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#S">type</a>);
-
-</code>
+f(<a href="#S">type</a>);</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/record/class-template-partial-spec.html b/test-files/golden-tests/symbols/record/class-template-partial-spec.html
index d17e7f87f..af4b53829 100644
--- a/test-files/golden-tests/symbols/record/class-template-partial-spec.html
+++ b/test-files/golden-tests/symbols/record/class-template-partial-spec.html
@@ -33,9 +33,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-partial-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -68,9 +66,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     typename U,
     typename V&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 
@@ -86,9 +82,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-partial-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-B-0a">B</a>&lt;T, long&gt;;
-
-</code>
+struct <a href="#A-B-0a">B</a>&lt;T, long&gt;;</code>
 </pre>
 </div>
 
@@ -104,9 +98,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-partial-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct <a href="#A-B-0a">B</a>&lt;U*, T&gt;;
-
-</code>
+struct <a href="#A-B-0a">B</a>&lt;U*, T&gt;;</code>
 </pre>
 </div>
 
diff --git a/test-files/golden-tests/symbols/record/class-template-spec.html b/test-files/golden-tests/symbols/record/class-template-spec.html
index eeb7130c7..8c50c8bee 100644
--- a/test-files/golden-tests/symbols/record/class-template-spec.html
+++ b/test-files/golden-tests/symbols/record/class-template-spec.html
@@ -41,9 +41,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -72,9 +70,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -88,9 +84,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e">A</a>&lt;int&gt;;
-
-</code>
+struct <a href="#A-0e">A</a>&lt;int&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -119,9 +113,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
@@ -135,9 +127,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e">A</a>&lt;long&gt;;
-
-</code>
+struct <a href="#A-0e">A</a>&lt;long&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -166,9 +156,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h();
-
-</code>
+h();</code>
 </pre>
 </div>
 </div>
@@ -182,9 +170,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -213,9 +199,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -229,9 +213,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct <a href="#B-00">B</a>&lt;T&&gt;;
-
-</code>
+struct <a href="#B-00">B</a>&lt;T&&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -260,9 +242,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h();
-
-</code>
+h();</code>
 </pre>
 </div>
 </div>
@@ -276,9 +256,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct <a href="#B-00">B</a>&lt;T*&gt;;
-
-</code>
+struct <a href="#B-00">B</a>&lt;T*&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -307,9 +285,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
@@ -325,9 +301,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     typename T,
     typename U&gt;
-struct C;
-
-</code>
+struct C;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -356,9 +330,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -372,9 +344,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#C-0f">C</a>&lt;int, int&gt;;
-
-</code>
+struct <a href="#C-0f">C</a>&lt;int, int&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -403,9 +373,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
@@ -419,9 +387,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct <a href="#C-0f">C</a>&lt;T*, int&gt;;
-
-</code>
+struct <a href="#C-0f">C</a>&lt;T*, int&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -450,9 +416,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-spec.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-h();
-
-</code>
+h();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/record/class-template-specializations-1.html b/test-files/golden-tests/symbols/record/class-template-specializations-1.html
index 74e1e7f06..b75e69271 100644
--- a/test-files/golden-tests/symbols/record/class-template-specializations-1.html
+++ b/test-files/golden-tests/symbols/record/class-template-specializations-1.html
@@ -123,9 +123,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R0
-    : <a href="#S0-0cf">S0&lt;-1&gt;</a>
-
-</code>
+    : <a href="#S0-0cf">S0&lt;-1&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -138,7 +136,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0cf">S0&lt;-1&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0cf">S0&lt;-1&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -182,9 +180,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R1
-    : <a href="#S0-0be">S0&lt;0&gt;</a>
-
-</code>
+    : <a href="#S0-0be">S0&lt;0&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -197,7 +193,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0be">S0&lt;0&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0be">S0&lt;0&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -214,9 +210,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R10
-    : <a href="#S0-08-S1-S2-08-S4">S0&lt;10&gt;::S1::S2&lt;11&gt;::S4&lt;-1&gt;</a>
-
-</code>
+    : <a href="#S0-08-S1-S2-08-S4">S0&lt;10&gt;::S1::S2&lt;11&gt;::S4&lt;-1&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -229,7 +223,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-08-S1-S2-08-S4">S0&lt;10&gt;::S1::S2&lt;11&gt;::S4&lt;-1&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-08-S1-S2-08-S4">S0&lt;10&gt;::S1::S2&lt;11&gt;::S4&lt;-1&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -246,9 +240,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R11
-    : <a href="#S0-0e-S1-S2-02-S4-0c">S0&lt;12&gt;::S1::S2&lt;13&gt;::S4&lt;14&gt;</a>
-
-</code>
+    : <a href="#S0-0e-S1-S2-02-S4-0c">S0&lt;12&gt;::S1::S2&lt;13&gt;::S4&lt;14&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -261,7 +253,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0e-S1-S2-02-S4-0c">S0&lt;12&gt;::S1::S2&lt;13&gt;::S4&lt;14&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0e-S1-S2-02-S4-0c">S0&lt;12&gt;::S1::S2&lt;13&gt;::S4&lt;14&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -278,9 +270,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R12
-    : <a href="#S0-09e4-S1-S2-02-S4-00">S0&lt;15&gt;::S1::S2&lt;16&gt;::S4&lt;17, void*&gt;</a>
-
-</code>
+    : <a href="#S0-09e4-S1-S2-02-S4-00">S0&lt;15&gt;::S1::S2&lt;16&gt;::S4&lt;17, void*&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -293,7 +283,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-09e4-S1-S2-02-S4-00">S0&lt;15&gt;::S1::S2&lt;16&gt;::S4&lt;17, void*&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-09e4-S1-S2-02-S4-00">S0&lt;15&gt;::S1::S2&lt;16&gt;::S4&lt;17, void*&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -310,9 +300,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R13
-    : <a href="#S0-09e4-S1-S2-02-S4-02">S0&lt;15&gt;::S1::S2&lt;16&gt;::S4&lt;17, int*&gt;</a>
-
-</code>
+    : <a href="#S0-09e4-S1-S2-02-S4-02">S0&lt;15&gt;::S1::S2&lt;16&gt;::S4&lt;17, int*&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -325,7 +313,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-09e4-S1-S2-02-S4-02">S0&lt;15&gt;::S1::S2&lt;16&gt;::S4&lt;17, int*&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-09e4-S1-S2-02-S4-02">S0&lt;15&gt;::S1::S2&lt;16&gt;::S4&lt;17, int*&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -342,9 +330,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R14
-    : <a href="#S0-07a-S5">S0&lt;18&gt;::S5&lt;-1&gt;</a>
-
-</code>
+    : <a href="#S0-07a-S5">S0&lt;18&gt;::S5&lt;-1&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -357,7 +343,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-07a-S5">S0&lt;18&gt;::S5&lt;-1&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-07a-S5">S0&lt;18&gt;::S5&lt;-1&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -374,9 +360,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R15
-    : <a href="#S0-0a7-S5-07">S0&lt;19&gt;::S5&lt;20&gt;</a>
-
-</code>
+    : <a href="#S0-0a7-S5-07">S0&lt;19&gt;::S5&lt;20&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -389,7 +373,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0a7-S5-07">S0&lt;19&gt;::S5&lt;20&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0a7-S5-07">S0&lt;19&gt;::S5&lt;20&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -406,9 +390,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R16
-    : <a href="#S0-0314-S5-07">S0&lt;21&gt;::S5&lt;22, void*&gt;</a>
-
-</code>
+    : <a href="#S0-0314-S5-07">S0&lt;21&gt;::S5&lt;22, void*&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -421,7 +403,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0314-S5-07">S0&lt;21&gt;::S5&lt;22, void*&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0314-S5-07">S0&lt;21&gt;::S5&lt;22, void*&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -438,9 +420,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R17
-    : <a href="#S0-0314-S5-03">S0&lt;21&gt;::S5&lt;22, int*&gt;</a>
-
-</code>
+    : <a href="#S0-0314-S5-03">S0&lt;21&gt;::S5&lt;22, int*&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -453,7 +433,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0314-S5-03">S0&lt;21&gt;::S5&lt;22, int*&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0314-S5-03">S0&lt;21&gt;::S5&lt;22, int*&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -470,9 +450,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R18
-    : <a href="#S0-058-S5-09-S6">S0&lt;23&gt;::S5&lt;24&gt;::S6</a>
-
-</code>
+    : <a href="#S0-058-S5-09-S6">S0&lt;23&gt;::S5&lt;24&gt;::S6</a></code>
 </pre>
 </div>
 <div>
@@ -485,7 +463,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-058-S5-09-S6">S0&lt;23&gt;::S5&lt;24&gt;::S6</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-058-S5-09-S6">S0&lt;23&gt;::S5&lt;24&gt;::S6</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -502,9 +480,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R19
-    : <a href="#S0-0a2-S5-02-S6-S7">S0&lt;25&gt;::S5&lt;26&gt;::S6::S7&lt;-1&gt;</a>
-
-</code>
+    : <a href="#S0-0a2-S5-02-S6-S7">S0&lt;25&gt;::S5&lt;26&gt;::S6::S7&lt;-1&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -517,7 +493,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0a2-S5-02-S6-S7">S0&lt;25&gt;::S5&lt;26&gt;::S6::S7&lt;-1&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0a2-S5-02-S6-S7">S0&lt;25&gt;::S5&lt;26&gt;::S6::S7&lt;-1&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -534,9 +510,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R2
-    : <a href="#S0-0cf">S0&lt;1, void*&gt;</a>
-
-</code>
+    : <a href="#S0-0cf">S0&lt;1, void*&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -549,7 +523,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0cf">S0&lt;1, void*&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0cf">S0&lt;1, void*&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -593,9 +567,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R20
-    : <a href="#S0-09e2-S5-0c-S6-S7-0b">S0&lt;27&gt;::S5&lt;28&gt;::S6::S7&lt;29, void*&gt;</a>
-
-</code>
+    : <a href="#S0-09e2-S5-0c-S6-S7-0b">S0&lt;27&gt;::S5&lt;28&gt;::S6::S7&lt;29, void*&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -608,7 +580,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-09e2-S5-0c-S6-S7-0b">S0&lt;27&gt;::S5&lt;28&gt;::S6::S7&lt;29, void*&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-09e2-S5-0c-S6-S7-0b">S0&lt;27&gt;::S5&lt;28&gt;::S6::S7&lt;29, void*&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -625,9 +597,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R21
-    : <a href="#S0-09e2-S5-0c-S6-S7-0d">S0&lt;27&gt;::S5&lt;28&gt;::S6::S7&lt;29, int*&gt;</a>
-
-</code>
+    : <a href="#S0-09e2-S5-0c-S6-S7-0d">S0&lt;27&gt;::S5&lt;28&gt;::S6::S7&lt;29, int*&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -640,7 +610,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-09e2-S5-0c-S6-S7-0d">S0&lt;27&gt;::S5&lt;28&gt;::S6::S7&lt;29, int*&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-09e2-S5-0c-S6-S7-0d">S0&lt;27&gt;::S5&lt;28&gt;::S6::S7&lt;29, int*&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -657,9 +627,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R22
-    : <a href="#S0-01-S5-04-S6-S7-05">S0&lt;30&gt;::S5&lt;31&gt;::S6::S7&lt;32&gt;</a>
-
-</code>
+    : <a href="#S0-01-S5-04-S6-S7-05">S0&lt;30&gt;::S5&lt;31&gt;::S6::S7&lt;32&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -672,7 +640,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-01-S5-04-S6-S7-05">S0&lt;30&gt;::S5&lt;31&gt;::S6::S7&lt;32&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-01-S5-04-S6-S7-05">S0&lt;30&gt;::S5&lt;31&gt;::S6::S7&lt;32&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -689,9 +657,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R23
-    : <a href="#S0-09ee-S5-02-S6-S7-03-S8">S0&lt;33&gt;::S5&lt;34&gt;::S6::S7&lt;35&gt;::S8</a>
-
-</code>
+    : <a href="#S0-09ee-S5-02-S6-S7-03-S8">S0&lt;33&gt;::S5&lt;34&gt;::S6::S7&lt;35&gt;::S8</a></code>
 </pre>
 </div>
 <div>
@@ -704,7 +670,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-09ee-S5-02-S6-S7-03-S8">S0&lt;33&gt;::S5&lt;34&gt;::S6::S7&lt;35&gt;::S8</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-09ee-S5-02-S6-S7-03-S8">S0&lt;33&gt;::S5&lt;34&gt;::S6::S7&lt;35&gt;::S8</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -721,9 +687,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R24
-    : <a href="#S0-033-S5-0f-S6-S7-0d-S9">S0&lt;36&gt;::S5&lt;37&gt;::S6::S7&lt;38&gt;::S9&lt;-1&gt;</a>
-
-</code>
+    : <a href="#S0-033-S5-0f-S6-S7-0d-S9">S0&lt;36&gt;::S5&lt;37&gt;::S6::S7&lt;38&gt;::S9&lt;-1&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -736,7 +700,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-033-S5-0f-S6-S7-0d-S9">S0&lt;36&gt;::S5&lt;37&gt;::S6::S7&lt;38&gt;::S9&lt;-1&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-033-S5-0f-S6-S7-0d-S9">S0&lt;36&gt;::S5&lt;37&gt;::S6::S7&lt;38&gt;::S9&lt;-1&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -753,9 +717,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R25
-    : <a href="#S0-06-S5-07-S6-S7-0a-S9-05">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;::S9&lt;42, void*&gt;</a>
-
-</code>
+    : <a href="#S0-06-S5-07-S6-S7-0a-S9-05">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;::S9&lt;42, void*&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -768,7 +730,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-06-S5-07-S6-S7-0a-S9-05">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;::S9&lt;42, void*&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-06-S5-07-S6-S7-0a-S9-05">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;::S9&lt;42, void*&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -785,9 +747,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R26
-    : <a href="#S0-06-S5-07-S6-S7-0a-S9-08">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;::S9&lt;42, int*&gt;</a>
-
-</code>
+    : <a href="#S0-06-S5-07-S6-S7-0a-S9-08">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;::S9&lt;42, int*&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -800,7 +760,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-06-S5-07-S6-S7-0a-S9-08">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;::S9&lt;42, int*&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-06-S5-07-S6-S7-0a-S9-08">S0&lt;39&gt;::S5&lt;40&gt;::S6::S7&lt;41&gt;::S9&lt;42, int*&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -817,9 +777,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R27
-    : <a href="#S0-0ba-S5-08-S6-S7-02-S9-0f">S0&lt;43&gt;::S5&lt;44&gt;::S6::S7&lt;45&gt;::S9&lt;46&gt;</a>
-
-</code>
+    : <a href="#S0-0ba-S5-08-S6-S7-02-S9-0f">S0&lt;43&gt;::S5&lt;44&gt;::S6::S7&lt;45&gt;::S9&lt;46&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -832,7 +790,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0ba-S5-08-S6-S7-02-S9-0f">S0&lt;43&gt;::S5&lt;44&gt;::S6::S7&lt;45&gt;::S9&lt;46&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0ba-S5-08-S6-S7-02-S9-0f">S0&lt;43&gt;::S5&lt;44&gt;::S6::S7&lt;45&gt;::S9&lt;46&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -849,9 +807,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R28
-    : <a href="#S0-0cf">S0&lt;0, bool&gt;</a>
-
-</code>
+    : <a href="#S0-0cf">S0&lt;0, bool&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -864,7 +820,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0cf">S0&lt;0, bool&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0cf">S0&lt;0, bool&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -908,9 +864,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R29
-    : <a href="#S0-0cf">S0&lt;1, int&gt;</a>
-
-</code>
+    : <a href="#S0-0cf">S0&lt;1, int&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -923,7 +877,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0cf">S0&lt;1, int&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0cf">S0&lt;1, int&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -967,9 +921,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R3
-    : <a href="#S0-020a">S0&lt;1, int*&gt;</a>
-
-</code>
+    : <a href="#S0-020a">S0&lt;1, int*&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -982,7 +934,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-020a">S0&lt;1, int*&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-020a">S0&lt;1, int*&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -999,9 +951,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R30
-    : <a href="#S0-03c-S1">S0&lt;2, bool&gt;::S1</a>
-
-</code>
+    : <a href="#S0-03c-S1">S0&lt;2, bool&gt;::S1</a></code>
 </pre>
 </div>
 <div>
@@ -1014,7 +964,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-03c-S1">S0&lt;2, bool&gt;::S1</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-03c-S1">S0&lt;2, bool&gt;::S1</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1060,9 +1010,7 @@ <h3>Synopsis</h3>
     int I,
     typename T&gt;
 struct R31
-    : <a href="#S0-092-S1-S2">S0&lt;3, bool&gt;::S1::S2&lt;I, T&gt;</a>
-
-</code>
+    : <a href="#S0-092-S1-S2">S0&lt;3, bool&gt;::S1::S2&lt;I, T&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -1075,7 +1023,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-092-S1-S2">S0&lt;3, bool&gt;::S1::S2&lt;I, T&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-092-S1-S2">S0&lt;3, bool&gt;::S1::S2&lt;I, T&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1092,9 +1040,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R32
-    : <a href="#S0-0b6-S1-S2">S0&lt;4, bool&gt;::S1::S2&lt;5, bool&gt;</a>
-
-</code>
+    : <a href="#S0-0b6-S1-S2">S0&lt;4, bool&gt;::S1::S2&lt;5, bool&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -1107,7 +1053,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0b6-S1-S2">S0&lt;4, bool&gt;::S1::S2&lt;5, bool&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0b6-S1-S2">S0&lt;4, bool&gt;::S1::S2&lt;5, bool&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1124,9 +1070,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R33
-    : <a href="#S0-023-S1-S2">S0&lt;6, bool&gt;::S1::S2&lt;7, int&gt;</a>
-
-</code>
+    : <a href="#S0-023-S1-S2">S0&lt;6, bool&gt;::S1::S2&lt;7, int&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -1139,7 +1083,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-023-S1-S2">S0&lt;6, bool&gt;::S1::S2&lt;7, int&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-023-S1-S2">S0&lt;6, bool&gt;::S1::S2&lt;7, int&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1156,9 +1100,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R34
-    : <a href="#S0-04-S1-S2-0a-S3">S0&lt;8, bool&gt;::S1::S2&lt;9, bool&gt;::S3</a>
-
-</code>
+    : <a href="#S0-04-S1-S2-0a-S3">S0&lt;8, bool&gt;::S1::S2&lt;9, bool&gt;::S3</a></code>
 </pre>
 </div>
 <div>
@@ -1171,7 +1113,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-04-S1-S2-0a-S3">S0&lt;8, bool&gt;::S1::S2&lt;9, bool&gt;::S3</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-04-S1-S2-0a-S3">S0&lt;8, bool&gt;::S1::S2&lt;9, bool&gt;::S3</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1204,9 +1146,7 @@ <h3>Synopsis</h3>
     int I,
     typename T&gt;
 struct R35
-    : <a href="#S0-05a-S1-S2-0b-S4">S0&lt;10, bool&gt;::S1::S2&lt;11, bool&gt;::S4&lt;I, T&gt;</a>
-
-</code>
+    : <a href="#S0-05a-S1-S2-0b-S4">S0&lt;10, bool&gt;::S1::S2&lt;11, bool&gt;::S4&lt;I, T&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -1219,7 +1159,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-05a-S1-S2-0b-S4">S0&lt;10, bool&gt;::S1::S2&lt;11, bool&gt;::S4&lt;I, T&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-05a-S1-S2-0b-S4">S0&lt;10, bool&gt;::S1::S2&lt;11, bool&gt;::S4&lt;I, T&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1236,9 +1176,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R36
-    : <a href="#S0-0cd-S1-S2-05-S4">S0&lt;12, bool&gt;::S1::S2&lt;13, bool&gt;::S4&lt;14, bool&gt;</a>
-
-</code>
+    : <a href="#S0-0cd-S1-S2-05-S4">S0&lt;12, bool&gt;::S1::S2&lt;13, bool&gt;::S4&lt;14, bool&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -1251,7 +1189,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0cd-S1-S2-05-S4">S0&lt;12, bool&gt;::S1::S2&lt;13, bool&gt;::S4&lt;14, bool&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0cd-S1-S2-05-S4">S0&lt;12, bool&gt;::S1::S2&lt;13, bool&gt;::S4&lt;14, bool&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1268,9 +1206,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R37
-    : <a href="#S0-000-S1-S2-03-S4">S0&lt;15, bool&gt;::S1::S2&lt;16, bool&gt;::S4&lt;17, int&gt;</a>
-
-</code>
+    : <a href="#S0-000-S1-S2-03-S4">S0&lt;15, bool&gt;::S1::S2&lt;16, bool&gt;::S4&lt;17, int&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -1283,7 +1219,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-000-S1-S2-03-S4">S0&lt;15, bool&gt;::S1::S2&lt;16, bool&gt;::S4&lt;17, int&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-000-S1-S2-03-S4">S0&lt;15, bool&gt;::S1::S2&lt;16, bool&gt;::S4&lt;17, int&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1303,9 +1239,7 @@ <h3>Synopsis</h3>
     int I,
     typename T&gt;
 struct R38
-    : <a href="#S0-051-S5">S0&lt;18, bool&gt;::S5&lt;I, T&gt;</a>
-
-</code>
+    : <a href="#S0-051-S5">S0&lt;18, bool&gt;::S5&lt;I, T&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -1318,7 +1252,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-051-S5">S0&lt;18, bool&gt;::S5&lt;I, T&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-051-S5">S0&lt;18, bool&gt;::S5&lt;I, T&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1335,9 +1269,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R39
-    : <a href="#S0-002-S5">S0&lt;19, bool&gt;::S5&lt;20, bool&gt;</a>
-
-</code>
+    : <a href="#S0-002-S5">S0&lt;19, bool&gt;::S5&lt;20, bool&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -1350,7 +1282,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-002-S5">S0&lt;19, bool&gt;::S5&lt;20, bool&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-002-S5">S0&lt;19, bool&gt;::S5&lt;20, bool&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1367,9 +1299,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R4
-    : <a href="#S0-09c-S1">S0&lt;2&gt;::S1</a>
-
-</code>
+    : <a href="#S0-09c-S1">S0&lt;2&gt;::S1</a></code>
 </pre>
 </div>
 <div>
@@ -1382,7 +1312,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-09c-S1">S0&lt;2&gt;::S1</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-09c-S1">S0&lt;2&gt;::S1</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1399,9 +1329,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R40
-    : <a href="#S0-003-S5">S0&lt;21, bool&gt;::S5&lt;22, int&gt;</a>
-
-</code>
+    : <a href="#S0-003-S5">S0&lt;21, bool&gt;::S5&lt;22, int&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -1414,7 +1342,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-003-S5">S0&lt;21, bool&gt;::S5&lt;22, int&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-003-S5">S0&lt;21, bool&gt;::S5&lt;22, int&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1431,9 +1359,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R41
-    : <a href="#S0-0c7-S5-0f-S6">S0&lt;23, bool&gt;::S5&lt;24, bool&gt;::S6</a>
-
-</code>
+    : <a href="#S0-0c7-S5-0f-S6">S0&lt;23, bool&gt;::S5&lt;24, bool&gt;::S6</a></code>
 </pre>
 </div>
 <div>
@@ -1446,7 +1372,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0c7-S5-0f-S6">S0&lt;23, bool&gt;::S5&lt;24, bool&gt;::S6</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0c7-S5-0f-S6">S0&lt;23, bool&gt;::S5&lt;24, bool&gt;::S6</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1492,9 +1418,7 @@ <h3>Synopsis</h3>
     int I,
     typename T&gt;
 struct R42
-    : <a href="#S0-0529f-S5-05c-S6-S7">S0&lt;25, bool&gt;::S5&lt;26, bool&gt;::S6::S7&lt;I, T&gt;</a>
-
-</code>
+    : <a href="#S0-0529f-S5-05c-S6-S7">S0&lt;25, bool&gt;::S5&lt;26, bool&gt;::S6::S7&lt;I, T&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -1507,7 +1431,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0529f-S5-05c-S6-S7">S0&lt;25, bool&gt;::S5&lt;26, bool&gt;::S6::S7&lt;I, T&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0529f-S5-05c-S6-S7">S0&lt;25, bool&gt;::S5&lt;26, bool&gt;::S6::S7&lt;I, T&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1524,9 +1448,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R43
-    : <a href="#S0-007-S5-0d-S6-S7">S0&lt;27, bool&gt;::S5&lt;28, bool&gt;::S6::S7&lt;29, int&gt;</a>
-
-</code>
+    : <a href="#S0-007-S5-0d-S6-S7">S0&lt;27, bool&gt;::S5&lt;28, bool&gt;::S6::S7&lt;29, int&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -1539,7 +1461,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-007-S5-0d-S6-S7">S0&lt;27, bool&gt;::S5&lt;28, bool&gt;::S6::S7&lt;29, int&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-007-S5-0d-S6-S7">S0&lt;27, bool&gt;::S5&lt;28, bool&gt;::S6::S7&lt;29, int&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1556,9 +1478,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R44
-    : <a href="#S0-021-S5-0b-S6-S7">S0&lt;30, bool&gt;::S5&lt;31, bool&gt;::S6::S7&lt;32, bool&gt;</a>
-
-</code>
+    : <a href="#S0-021-S5-0b-S6-S7">S0&lt;30, bool&gt;::S5&lt;31, bool&gt;::S6::S7&lt;32, bool&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -1571,7 +1491,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-021-S5-0b-S6-S7">S0&lt;30, bool&gt;::S5&lt;31, bool&gt;::S6::S7&lt;32, bool&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-021-S5-0b-S6-S7">S0&lt;30, bool&gt;::S5&lt;31, bool&gt;::S6::S7&lt;32, bool&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1588,9 +1508,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R45
-    : <a href="#S0-0318-S5-0b-S6-S7-05-S8">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6::S7&lt;35, bool&gt;::S8</a>
-
-</code>
+    : <a href="#S0-0318-S5-0b-S6-S7-05-S8">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6::S7&lt;35, bool&gt;::S8</a></code>
 </pre>
 </div>
 <div>
@@ -1603,7 +1521,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0318-S5-0b-S6-S7-05-S8">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6::S7&lt;35, bool&gt;::S8</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0318-S5-0b-S6-S7-05-S8">S0&lt;33, bool&gt;::S5&lt;34, bool&gt;::S6::S7&lt;35, bool&gt;::S8</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1636,9 +1554,7 @@ <h3>Synopsis</h3>
     int I,
     typename T&gt;
 struct R46
-    : <a href="#S0-0d-S5-0b-S6-S7-0d-S9">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::S6::S7&lt;38, bool&gt;::S9&lt;I, T&gt;</a>
-
-</code>
+    : <a href="#S0-0d-S5-0b-S6-S7-0d-S9">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::S6::S7&lt;38, bool&gt;::S9&lt;I, T&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -1651,7 +1567,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0d-S5-0b-S6-S7-0d-S9">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::S6::S7&lt;38, bool&gt;::S9&lt;I, T&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0d-S5-0b-S6-S7-0d-S9">S0&lt;36, bool&gt;::S5&lt;37, bool&gt;::S6::S7&lt;38, bool&gt;::S9&lt;I, T&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1668,9 +1584,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R47
-    : <a href="#S0-0206-S5-08-S6-S7-01-S9">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::S6::S7&lt;41, bool&gt;::S9&lt;42, int&gt;</a>
-
-</code>
+    : <a href="#S0-0206-S5-08-S6-S7-01-S9">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::S6::S7&lt;41, bool&gt;::S9&lt;42, int&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -1683,7 +1597,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0206-S5-08-S6-S7-01-S9">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::S6::S7&lt;41, bool&gt;::S9&lt;42, int&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0206-S5-08-S6-S7-01-S9">S0&lt;39, bool&gt;::S5&lt;40, bool&gt;::S6::S7&lt;41, bool&gt;::S9&lt;42, int&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1700,9 +1614,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R48
-    : <a href="#S0-05291-S5-0e-S6-S7-0f-S9">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::S6::S7&lt;45, bool&gt;::S9&lt;46, bool&gt;</a>
-
-</code>
+    : <a href="#S0-05291-S5-0e-S6-S7-0f-S9">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::S6::S7&lt;45, bool&gt;::S9&lt;46, bool&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -1715,7 +1627,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-05291-S5-0e-S6-S7-0f-S9">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::S6::S7&lt;45, bool&gt;::S9&lt;46, bool&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-05291-S5-0e-S6-S7-0f-S9">S0&lt;43, bool&gt;::S5&lt;44, bool&gt;::S6::S7&lt;45, bool&gt;::S9&lt;46, bool&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1732,9 +1644,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R5
-    : <a href="#S0-073-S1-S2">S0&lt;3&gt;::S1::S2&lt;-1&gt;</a>
-
-</code>
+    : <a href="#S0-073-S1-S2">S0&lt;3&gt;::S1::S2&lt;-1&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -1747,7 +1657,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-073-S1-S2">S0&lt;3&gt;::S1::S2&lt;-1&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-073-S1-S2">S0&lt;3&gt;::S1::S2&lt;-1&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1764,9 +1674,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R6
-    : <a href="#S0-0a1-S1-S2-0f">S0&lt;4&gt;::S1::S2&lt;5&gt;</a>
-
-</code>
+    : <a href="#S0-0a1-S1-S2-0f">S0&lt;4&gt;::S1::S2&lt;5&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -1779,7 +1687,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0a1-S1-S2-0f">S0&lt;4&gt;::S1::S2&lt;5&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0a1-S1-S2-0f">S0&lt;4&gt;::S1::S2&lt;5&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1796,9 +1704,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R7
-    : <a href="#S0-07e-S1-S2-04">S0&lt;6&gt;::S1::S2&lt;7, void*&gt;</a>
-
-</code>
+    : <a href="#S0-07e-S1-S2-04">S0&lt;6&gt;::S1::S2&lt;7, void*&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -1811,7 +1717,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-07e-S1-S2-04">S0&lt;6&gt;::S1::S2&lt;7, void*&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-07e-S1-S2-04">S0&lt;6&gt;::S1::S2&lt;7, void*&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1828,9 +1734,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R8
-    : <a href="#S0-07e-S1-S2-07">S0&lt;6&gt;::S1::S2&lt;7, int*&gt;</a>
-
-</code>
+    : <a href="#S0-07e-S1-S2-07">S0&lt;6&gt;::S1::S2&lt;7, int*&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -1843,7 +1747,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-07e-S1-S2-07">S0&lt;6&gt;::S1::S2&lt;7, int*&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-07e-S1-S2-07">S0&lt;6&gt;::S1::S2&lt;7, int*&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1860,9 +1764,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R9
-    : <a href="#S0-0a3-S1-S2-0c-S3">S0&lt;8&gt;::S1::S2&lt;9&gt;::S3</a>
-
-</code>
+    : <a href="#S0-0a3-S1-S2-0c-S3">S0&lt;8&gt;::S1::S2&lt;9&gt;::S3</a></code>
 </pre>
 </div>
 <div>
@@ -1875,7 +1777,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0a3-S1-S2-0c-S3">S0&lt;8&gt;::S1::S2&lt;9&gt;::S3</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0a3-S1-S2-0c-S3">S0&lt;8&gt;::S1::S2&lt;9&gt;::S3</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1894,9 +1796,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int I,
     typename T = void&gt;
-struct S0;
-
-</code>
+struct S0;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -1939,13 +1839,13 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R0"><code>R0</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 <tr><td><a href="#R2"><code>R2</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 <tr><td><a href="#R28"><code>R28</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 <tr><td><a href="#R29"><code>R29</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -1959,9 +1859,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -2005,9 +1903,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S2;
-
-</code>
+struct S2;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -2049,9 +1945,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S3;
-
-</code>
+<code class="source-code cpp">struct S3;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -2080,9 +1974,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f3();
-
-</code>
+f3();</code>
 </pre>
 </div>
 </div>
@@ -2098,9 +1990,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S4;
-
-</code>
+struct S4;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -2129,9 +2019,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f4();
-
-</code>
+f4();</code>
 </pre>
 </div>
 </div>
@@ -2145,9 +2033,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -2161,9 +2047,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -2179,9 +2063,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -2222,9 +2104,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S6;
-
-</code>
+<code class="source-code cpp">struct S6;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -2268,9 +2148,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S7;
-
-</code>
+struct S7;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -2312,9 +2190,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S8;
-
-</code>
+<code class="source-code cpp">struct S8;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -2343,9 +2219,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f8();
-
-</code>
+f8();</code>
 </pre>
 </div>
 </div>
@@ -2361,9 +2235,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int L,
     typename W = void&gt;
-struct S9;
-
-</code>
+struct S9;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -2392,9 +2264,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f9();
-
-</code>
+f9();</code>
 </pre>
 </div>
 </div>
@@ -2408,9 +2278,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f7();
-
-</code>
+f7();</code>
 </pre>
 </div>
 </div>
@@ -2424,9 +2292,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 </div>
@@ -2440,9 +2306,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -2456,9 +2320,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -2472,9 +2334,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;0&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;0&gt;;</code>
 </pre>
 </div>
 
@@ -2490,7 +2350,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R1"><code>R1</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -2505,9 +2365,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;10&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;10&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -2549,9 +2407,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -2596,9 +2452,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S2;
-
-</code>
+struct S2;</code>
 </pre>
 </div>
 
@@ -2614,9 +2468,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S1-S2">S2</a>&lt;11&gt;;
-
-</code>
+struct <a href="#S0-0cf-S1-S2">S2</a>&lt;11&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -2658,9 +2510,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S3;
-
-</code>
+<code class="source-code cpp">struct S3;</code>
 </pre>
 </div>
 
@@ -2678,9 +2528,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int I,
     typename T = void&gt;
-struct S4;
-
-</code>
+struct S4;</code>
 </pre>
 </div>
 
@@ -2696,7 +2544,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R10"><code>R10</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -2711,9 +2559,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -2727,9 +2573,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -2745,9 +2589,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -2763,9 +2605,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -2779,9 +2619,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;12&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;12&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -2823,9 +2661,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -2870,9 +2706,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S2;
-
-</code>
+struct S2;</code>
 </pre>
 </div>
 
@@ -2888,9 +2722,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S1-S2">S2</a>&lt;13&gt;;
-
-</code>
+struct <a href="#S0-0cf-S1-S2">S2</a>&lt;13&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -2933,9 +2765,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S3;
-
-</code>
+<code class="source-code cpp">struct S3;</code>
 </pre>
 </div>
 
@@ -2953,9 +2783,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S4;
-
-</code>
+struct S4;</code>
 </pre>
 </div>
 
@@ -2971,9 +2799,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S1-S2-S4">S4</a>&lt;14&gt;;
-
-</code>
+struct <a href="#S0-0cf-S1-S2-S4">S4</a>&lt;14&gt;;</code>
 </pre>
 </div>
 
@@ -2989,7 +2815,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R11"><code>R11</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -3004,9 +2830,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -3020,9 +2844,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -3038,9 +2860,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -3056,9 +2876,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -3072,9 +2890,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;15&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;15&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -3116,9 +2932,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -3163,9 +2977,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S2;
-
-</code>
+struct S2;</code>
 </pre>
 </div>
 
@@ -3181,9 +2993,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S1-S2">S2</a>&lt;16&gt;;
-
-</code>
+struct <a href="#S0-0cf-S1-S2">S2</a>&lt;16&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -3227,9 +3037,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S3;
-
-</code>
+<code class="source-code cpp">struct S3;</code>
 </pre>
 </div>
 
@@ -3247,9 +3055,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S4;
-
-</code>
+struct S4;</code>
 </pre>
 </div>
 
@@ -3265,7 +3071,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R12"><code>R12</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -3280,9 +3086,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S1-S2-S4">S4</a>&lt;17, int*&gt;;
-
-</code>
+struct <a href="#S0-0cf-S1-S2-S4">S4</a>&lt;17, int*&gt;;</code>
 </pre>
 </div>
 
@@ -3298,7 +3102,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R13"><code>R13</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -3313,9 +3117,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct <a href="#S0-0cf-S1-S2-S4">S4</a>&lt;17, T*&gt;;
-
-</code>
+struct <a href="#S0-0cf-S1-S2-S4">S4</a>&lt;17, T*&gt;;</code>
 </pre>
 </div>
 
@@ -3331,9 +3133,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -3347,9 +3147,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -3365,9 +3163,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -3383,9 +3179,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -3399,9 +3193,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;18&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;18&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -3443,9 +3235,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -3463,9 +3253,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int I,
     typename T = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -3481,7 +3269,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R14"><code>R14</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -3496,9 +3284,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -3512,9 +3298,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;19&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;19&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -3557,9 +3341,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -3577,9 +3359,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -3595,9 +3375,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5">S5</a>&lt;20&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5">S5</a>&lt;20&gt;;</code>
 </pre>
 </div>
 
@@ -3613,7 +3391,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R15"><code>R15</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -3628,9 +3406,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -3644,9 +3420,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;2&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;2&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -3688,9 +3462,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -3706,7 +3478,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R4"><code>R4</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -3723,9 +3495,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -3741,9 +3511,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -3757,9 +3525,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;21&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;21&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -3803,9 +3569,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -3823,9 +3587,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -3841,7 +3603,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R16"><code>R16</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -3856,9 +3618,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5">S5</a>&lt;22, int*&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5">S5</a>&lt;22, int*&gt;;</code>
 </pre>
 </div>
 
@@ -3874,7 +3634,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R17"><code>R17</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -3889,9 +3649,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct <a href="#S0-0cf-S5">S5</a>&lt;22, T*&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5">S5</a>&lt;22, T*&gt;;</code>
 </pre>
 </div>
 
@@ -3907,9 +3665,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -3923,9 +3679,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;23&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;23&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -3968,9 +3722,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -3988,9 +3740,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -4006,9 +3756,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5">S5</a>&lt;24&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5">S5</a>&lt;24&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -4049,9 +3797,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S6;
-
-</code>
+<code class="source-code cpp">struct S6;</code>
 </pre>
 </div>
 
@@ -4067,7 +3813,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R18"><code>R18</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -4082,9 +3828,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -4098,9 +3842,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -4114,9 +3856,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;25&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;25&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -4159,9 +3899,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -4179,9 +3917,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -4197,9 +3933,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5">S5</a>&lt;26&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5">S5</a>&lt;26&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -4240,9 +3974,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S6;
-
-</code>
+<code class="source-code cpp">struct S6;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -4286,9 +4018,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int I,
     typename T = void&gt;
-struct S7;
-
-</code>
+struct S7;</code>
 </pre>
 </div>
 
@@ -4304,7 +4034,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R19"><code>R19</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -4319,9 +4049,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 </div>
@@ -4335,9 +4063,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -4351,9 +4077,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -4367,9 +4091,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;27&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;27&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -4412,9 +4134,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -4432,9 +4152,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -4450,9 +4168,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5">S5</a>&lt;28&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5">S5</a>&lt;28&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -4493,9 +4209,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S6;
-
-</code>
+<code class="source-code cpp">struct S6;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -4541,9 +4255,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S7;
-
-</code>
+struct S7;</code>
 </pre>
 </div>
 
@@ -4559,7 +4271,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R20"><code>R20</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -4574,9 +4286,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;29, int*&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;29, int*&gt;;</code>
 </pre>
 </div>
 
@@ -4592,7 +4302,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R21"><code>R21</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -4607,9 +4317,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;29, T*&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;29, T*&gt;;</code>
 </pre>
 </div>
 
@@ -4625,9 +4333,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 </div>
@@ -4641,9 +4347,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -4657,9 +4361,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -4673,9 +4375,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;3&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;3&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -4717,9 +4417,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -4763,9 +4461,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int I,
     typename T = void&gt;
-struct S2;
-
-</code>
+struct S2;</code>
 </pre>
 </div>
 
@@ -4781,7 +4477,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R5"><code>R5</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -4796,9 +4492,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -4814,9 +4508,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -4832,9 +4524,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -4848,9 +4538,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;30&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;30&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -4893,9 +4581,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -4913,9 +4599,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -4931,9 +4615,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5">S5</a>&lt;31&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5">S5</a>&lt;31&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -4974,9 +4656,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S6;
-
-</code>
+<code class="source-code cpp">struct S6;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -5021,9 +4701,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S7;
-
-</code>
+struct S7;</code>
 </pre>
 </div>
 
@@ -5039,9 +4717,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;32&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;32&gt;;</code>
 </pre>
 </div>
 
@@ -5057,7 +4733,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R22"><code>R22</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -5072,9 +4748,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 </div>
@@ -5088,9 +4762,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -5104,9 +4776,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -5120,9 +4790,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;33&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;33&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -5165,9 +4833,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -5185,9 +4851,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -5203,9 +4867,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5">S5</a>&lt;34&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5">S5</a>&lt;34&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -5246,9 +4908,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S6;
-
-</code>
+<code class="source-code cpp">struct S6;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -5293,9 +4953,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S7;
-
-</code>
+struct S7;</code>
 </pre>
 </div>
 
@@ -5311,9 +4969,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;35&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;35&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -5355,9 +5011,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S8;
-
-</code>
+<code class="source-code cpp">struct S8;</code>
 </pre>
 </div>
 
@@ -5373,7 +5027,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R23"><code>R23</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -5390,9 +5044,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int L,
     typename W = void&gt;
-struct S9;
-
-</code>
+struct S9;</code>
 </pre>
 </div>
 
@@ -5408,9 +5060,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f7();
-
-</code>
+f7();</code>
 </pre>
 </div>
 </div>
@@ -5424,9 +5074,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 </div>
@@ -5440,9 +5088,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -5456,9 +5102,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -5472,9 +5116,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;36&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;36&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -5517,9 +5159,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -5537,9 +5177,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -5555,9 +5193,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5">S5</a>&lt;37&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5">S5</a>&lt;37&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -5598,9 +5234,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S6;
-
-</code>
+<code class="source-code cpp">struct S6;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -5645,9 +5279,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S7;
-
-</code>
+struct S7;</code>
 </pre>
 </div>
 
@@ -5663,9 +5295,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;38&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;38&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -5707,9 +5337,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S8;
-
-</code>
+<code class="source-code cpp">struct S8;</code>
 </pre>
 </div>
 
@@ -5727,9 +5355,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int I,
     typename T = void&gt;
-struct S9;
-
-</code>
+struct S9;</code>
 </pre>
 </div>
 
@@ -5745,7 +5371,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R24"><code>R24</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -5760,9 +5386,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f7();
-
-</code>
+f7();</code>
 </pre>
 </div>
 </div>
@@ -5776,9 +5400,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 </div>
@@ -5792,9 +5414,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -5808,9 +5428,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -5824,9 +5442,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;39&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;39&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -5869,9 +5485,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -5889,9 +5503,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -5907,9 +5519,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5">S5</a>&lt;40&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5">S5</a>&lt;40&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -5950,9 +5560,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S6;
-
-</code>
+<code class="source-code cpp">struct S6;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -5997,9 +5605,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S7;
-
-</code>
+struct S7;</code>
 </pre>
 </div>
 
@@ -6015,9 +5621,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;41&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;41&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -6061,9 +5665,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S8;
-
-</code>
+<code class="source-code cpp">struct S8;</code>
 </pre>
 </div>
 
@@ -6081,9 +5683,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int L,
     typename W = void&gt;
-struct S9;
-
-</code>
+struct S9;</code>
 </pre>
 </div>
 
@@ -6099,7 +5699,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R25"><code>R25</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -6114,9 +5714,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5-S6-S7-S9">S9</a>&lt;42, int*&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5-S6-S7-S9">S9</a>&lt;42, int*&gt;;</code>
 </pre>
 </div>
 
@@ -6132,7 +5730,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R26"><code>R26</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -6147,9 +5745,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct <a href="#S0-0cf-S5-S6-S7-S9">S9</a>&lt;42, T*&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5-S6-S7-S9">S9</a>&lt;42, T*&gt;;</code>
 </pre>
 </div>
 
@@ -6165,9 +5761,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f7();
-
-</code>
+f7();</code>
 </pre>
 </div>
 </div>
@@ -6181,9 +5775,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 </div>
@@ -6197,9 +5789,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -6213,9 +5803,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -6229,9 +5817,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;4&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;4&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -6273,9 +5859,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -6320,9 +5904,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S2;
-
-</code>
+struct S2;</code>
 </pre>
 </div>
 
@@ -6338,9 +5920,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S1-S2">S2</a>&lt;5&gt;;
-
-</code>
+struct <a href="#S0-0cf-S1-S2">S2</a>&lt;5&gt;;</code>
 </pre>
 </div>
 
@@ -6356,7 +5936,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R6"><code>R6</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -6371,9 +5951,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -6389,9 +5967,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -6407,9 +5983,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -6423,9 +5997,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;43&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;43&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -6468,9 +6040,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -6488,9 +6058,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -6506,9 +6074,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5">S5</a>&lt;44&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5">S5</a>&lt;44&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -6549,9 +6115,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S6;
-
-</code>
+<code class="source-code cpp">struct S6;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -6596,9 +6160,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S7;
-
-</code>
+struct S7;</code>
 </pre>
 </div>
 
@@ -6614,9 +6176,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;45&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;45&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -6659,9 +6219,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S8;
-
-</code>
+<code class="source-code cpp">struct S8;</code>
 </pre>
 </div>
 
@@ -6679,9 +6237,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int L,
     typename W = void&gt;
-struct S9;
-
-</code>
+struct S9;</code>
 </pre>
 </div>
 
@@ -6697,9 +6253,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5-S6-S7-S9">S9</a>&lt;46&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5-S6-S7-S9">S9</a>&lt;46&gt;;</code>
 </pre>
 </div>
 
@@ -6715,7 +6269,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R27"><code>R27</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -6730,9 +6284,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f7();
-
-</code>
+f7();</code>
 </pre>
 </div>
 </div>
@@ -6746,9 +6298,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 </div>
@@ -6762,9 +6312,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -6778,9 +6326,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -6794,9 +6340,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;6&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;6&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -6838,9 +6382,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -6886,9 +6428,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S2;
-
-</code>
+struct S2;</code>
 </pre>
 </div>
 
@@ -6904,7 +6444,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R7"><code>R7</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -6919,9 +6459,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S1-S2">S2</a>&lt;7, int*&gt;;
-
-</code>
+struct <a href="#S0-0cf-S1-S2">S2</a>&lt;7, int*&gt;;</code>
 </pre>
 </div>
 
@@ -6937,7 +6475,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R8"><code>R8</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -6952,9 +6490,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct <a href="#S0-0cf-S1-S2">S2</a>&lt;7, T*&gt;;
-
-</code>
+struct <a href="#S0-0cf-S1-S2">S2</a>&lt;7, T*&gt;;</code>
 </pre>
 </div>
 
@@ -6970,9 +6506,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -6988,9 +6522,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -7006,9 +6538,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -7022,9 +6552,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;8&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;8&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -7066,9 +6594,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -7113,9 +6639,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S2;
-
-</code>
+struct S2;</code>
 </pre>
 </div>
 
@@ -7131,9 +6655,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S1-S2">S2</a>&lt;9&gt;;
-
-</code>
+struct <a href="#S0-0cf-S1-S2">S2</a>&lt;9&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -7175,9 +6697,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S3;
-
-</code>
+<code class="source-code cpp">struct S3;</code>
 </pre>
 </div>
 
@@ -7193,7 +6713,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R9"><code>R9</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -7210,9 +6730,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S4;
-
-</code>
+struct S4;</code>
 </pre>
 </div>
 
@@ -7228,9 +6746,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -7244,9 +6760,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -7262,9 +6776,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -7280,9 +6792,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -7296,9 +6806,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;1, int*&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;1, int*&gt;;</code>
 </pre>
 </div>
 
@@ -7314,7 +6822,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R3"><code>R3</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -7329,9 +6837,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;10, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;10, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -7373,9 +6879,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -7420,9 +6924,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S2;
-
-</code>
+struct S2;</code>
 </pre>
 </div>
 
@@ -7438,9 +6940,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S1-S2">S2</a>&lt;11, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf-S1-S2">S2</a>&lt;11, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -7482,9 +6982,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S3;
-
-</code>
+<code class="source-code cpp">struct S3;</code>
 </pre>
 </div>
 
@@ -7502,9 +7000,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S4;
-
-</code>
+struct S4;</code>
 </pre>
 </div>
 
@@ -7520,7 +7016,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R35"><code>R35</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -7535,9 +7031,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -7551,9 +7045,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -7569,9 +7061,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -7587,9 +7077,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -7603,9 +7091,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;12, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;12, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -7647,9 +7133,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -7694,9 +7178,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S2;
-
-</code>
+struct S2;</code>
 </pre>
 </div>
 
@@ -7712,9 +7194,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S1-S2">S2</a>&lt;13, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf-S1-S2">S2</a>&lt;13, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -7756,9 +7236,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S3;
-
-</code>
+<code class="source-code cpp">struct S3;</code>
 </pre>
 </div>
 
@@ -7776,9 +7254,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S4;
-
-</code>
+struct S4;</code>
 </pre>
 </div>
 
@@ -7794,7 +7270,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R36"><code>R36</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -7809,9 +7285,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -7825,9 +7299,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -7843,9 +7315,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -7861,9 +7331,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -7877,9 +7345,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;15, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;15, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -7921,9 +7387,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -7968,9 +7432,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S2;
-
-</code>
+struct S2;</code>
 </pre>
 </div>
 
@@ -7986,9 +7448,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S1-S2">S2</a>&lt;16, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf-S1-S2">S2</a>&lt;16, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -8030,9 +7490,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S3;
-
-</code>
+<code class="source-code cpp">struct S3;</code>
 </pre>
 </div>
 
@@ -8050,9 +7508,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S4;
-
-</code>
+struct S4;</code>
 </pre>
 </div>
 
@@ -8068,7 +7524,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R37"><code>R37</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -8083,9 +7539,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -8099,9 +7553,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -8117,9 +7569,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -8135,9 +7585,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -8151,9 +7599,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;18, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;18, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -8195,9 +7641,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -8215,9 +7659,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -8233,7 +7675,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R38"><code>R38</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -8248,9 +7690,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -8264,9 +7704,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;19, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;19, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -8308,9 +7746,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -8328,9 +7764,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -8346,7 +7780,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R39"><code>R39</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -8361,9 +7795,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -8377,9 +7809,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;2, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;2, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -8421,9 +7851,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -8465,7 +7893,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R30"><code>R30</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -8482,9 +7910,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S2;
-
-</code>
+struct S2;</code>
 </pre>
 </div>
 
@@ -8500,9 +7926,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -8518,9 +7942,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -8536,9 +7958,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -8552,9 +7972,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;21, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;21, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -8596,9 +8014,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -8616,9 +8032,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -8634,7 +8048,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R40"><code>R40</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -8649,9 +8063,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -8665,9 +8077,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;23, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;23, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -8710,9 +8120,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -8730,9 +8138,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -8748,9 +8154,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5">S5</a>&lt;24, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5">S5</a>&lt;24, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -8791,9 +8195,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S6;
-
-</code>
+<code class="source-code cpp">struct S6;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -8835,7 +8237,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R41"><code>R41</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -8852,9 +8254,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S7;
-
-</code>
+struct S7;</code>
 </pre>
 </div>
 
@@ -8870,9 +8270,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 </div>
@@ -8886,9 +8284,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -8902,9 +8298,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -8918,9 +8312,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;25, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;25, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -8963,9 +8355,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -8983,9 +8373,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -9001,9 +8389,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5">S5</a>&lt;26, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5">S5</a>&lt;26, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -9044,9 +8430,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S6;
-
-</code>
+<code class="source-code cpp">struct S6;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -9090,9 +8474,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S7;
-
-</code>
+struct S7;</code>
 </pre>
 </div>
 
@@ -9108,7 +8490,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R42"><code>R42</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -9123,9 +8505,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 </div>
@@ -9139,9 +8519,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -9155,9 +8533,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -9171,9 +8547,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;27, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;27, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -9216,9 +8590,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -9236,9 +8608,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -9254,9 +8624,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5">S5</a>&lt;28, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5">S5</a>&lt;28, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -9297,9 +8665,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S6;
-
-</code>
+<code class="source-code cpp">struct S6;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -9343,9 +8709,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S7;
-
-</code>
+struct S7;</code>
 </pre>
 </div>
 
@@ -9361,7 +8725,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R43"><code>R43</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -9376,9 +8740,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 </div>
@@ -9392,9 +8754,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -9408,9 +8768,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -9424,9 +8782,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;3, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;3, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -9468,9 +8824,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -9514,9 +8868,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S2;
-
-</code>
+struct S2;</code>
 </pre>
 </div>
 
@@ -9532,7 +8884,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R31"><code>R31</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -9547,9 +8899,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -9565,9 +8915,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -9583,9 +8931,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -9599,9 +8945,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;30, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;30, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -9644,9 +8988,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -9664,9 +9006,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -9682,9 +9022,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5">S5</a>&lt;31, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5">S5</a>&lt;31, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -9725,9 +9063,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S6;
-
-</code>
+<code class="source-code cpp">struct S6;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -9771,9 +9107,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S7;
-
-</code>
+struct S7;</code>
 </pre>
 </div>
 
@@ -9789,7 +9123,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R44"><code>R44</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -9804,9 +9138,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 </div>
@@ -9820,9 +9152,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -9836,9 +9166,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -9852,9 +9180,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;33, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;33, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -9897,9 +9223,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -9917,9 +9241,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -9935,9 +9257,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5">S5</a>&lt;34, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5">S5</a>&lt;34, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -9978,9 +9298,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S6;
-
-</code>
+<code class="source-code cpp">struct S6;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -10025,9 +9343,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S7;
-
-</code>
+struct S7;</code>
 </pre>
 </div>
 
@@ -10043,9 +9359,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;35, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;35, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -10087,9 +9401,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S8;
-
-</code>
+<code class="source-code cpp">struct S8;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -10118,7 +9430,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R45"><code>R45</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -10133,9 +9445,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f8();
-
-</code>
+f8();</code>
 </pre>
 </div>
 </div>
@@ -10151,9 +9461,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int L,
     typename W = void&gt;
-struct S9;
-
-</code>
+struct S9;</code>
 </pre>
 </div>
 
@@ -10169,9 +9477,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f7();
-
-</code>
+f7();</code>
 </pre>
 </div>
 </div>
@@ -10185,9 +9491,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 </div>
@@ -10201,9 +9505,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -10217,9 +9519,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -10233,9 +9533,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;36, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;36, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -10278,9 +9576,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -10298,9 +9594,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -10316,9 +9610,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5">S5</a>&lt;37, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5">S5</a>&lt;37, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -10359,9 +9651,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S6;
-
-</code>
+<code class="source-code cpp">struct S6;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -10406,9 +9696,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S7;
-
-</code>
+struct S7;</code>
 </pre>
 </div>
 
@@ -10424,9 +9712,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;38, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;38, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -10468,9 +9754,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S8;
-
-</code>
+<code class="source-code cpp">struct S8;</code>
 </pre>
 </div>
 
@@ -10488,9 +9772,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int L,
     typename W = void&gt;
-struct S9;
-
-</code>
+struct S9;</code>
 </pre>
 </div>
 
@@ -10506,7 +9788,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R46"><code>R46</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -10521,9 +9803,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f7();
-
-</code>
+f7();</code>
 </pre>
 </div>
 </div>
@@ -10537,9 +9817,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 </div>
@@ -10553,9 +9831,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -10569,9 +9845,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -10585,9 +9859,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;39, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;39, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -10630,9 +9902,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -10650,9 +9920,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -10668,9 +9936,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5">S5</a>&lt;40, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5">S5</a>&lt;40, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -10711,9 +9977,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S6;
-
-</code>
+<code class="source-code cpp">struct S6;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -10758,9 +10022,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S7;
-
-</code>
+struct S7;</code>
 </pre>
 </div>
 
@@ -10776,9 +10038,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;41, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;41, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -10820,9 +10080,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S8;
-
-</code>
+<code class="source-code cpp">struct S8;</code>
 </pre>
 </div>
 
@@ -10840,9 +10098,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int L,
     typename W = void&gt;
-struct S9;
-
-</code>
+struct S9;</code>
 </pre>
 </div>
 
@@ -10858,7 +10114,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R47"><code>R47</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -10873,9 +10129,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f7();
-
-</code>
+f7();</code>
 </pre>
 </div>
 </div>
@@ -10889,9 +10143,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 </div>
@@ -10905,9 +10157,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -10921,9 +10171,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -10937,9 +10185,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;4, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;4, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -10981,9 +10227,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -11027,9 +10271,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S2;
-
-</code>
+struct S2;</code>
 </pre>
 </div>
 
@@ -11045,7 +10287,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R32"><code>R32</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -11060,9 +10302,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -11078,9 +10318,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -11096,9 +10334,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -11112,9 +10348,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;43, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;43, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -11157,9 +10391,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -11177,9 +10409,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -11195,9 +10425,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5">S5</a>&lt;44, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5">S5</a>&lt;44, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -11238,9 +10466,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S6;
-
-</code>
+<code class="source-code cpp">struct S6;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -11285,9 +10511,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S7;
-
-</code>
+struct S7;</code>
 </pre>
 </div>
 
@@ -11303,9 +10527,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;45, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf-S5-S6-S7">S7</a>&lt;45, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -11347,9 +10569,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S8;
-
-</code>
+<code class="source-code cpp">struct S8;</code>
 </pre>
 </div>
 
@@ -11367,9 +10587,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int L,
     typename W = void&gt;
-struct S9;
-
-</code>
+struct S9;</code>
 </pre>
 </div>
 
@@ -11385,7 +10603,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R48"><code>R48</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -11400,9 +10618,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f7();
-
-</code>
+f7();</code>
 </pre>
 </div>
 </div>
@@ -11416,9 +10632,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f6();
-
-</code>
+f6();</code>
 </pre>
 </div>
 </div>
@@ -11432,9 +10646,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f5();
-
-</code>
+f5();</code>
 </pre>
 </div>
 </div>
@@ -11448,9 +10660,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -11464,9 +10674,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;6, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;6, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -11508,9 +10716,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -11554,9 +10760,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S2;
-
-</code>
+struct S2;</code>
 </pre>
 </div>
 
@@ -11572,7 +10776,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R33"><code>R33</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -11587,9 +10791,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -11605,9 +10807,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -11623,9 +10823,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -11639,9 +10837,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf">S0</a>&lt;8, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;8, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -11683,9 +10879,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -11730,9 +10924,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S2;
-
-</code>
+struct S2;</code>
 </pre>
 </div>
 
@@ -11748,9 +10940,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0cf-S1-S2">S2</a>&lt;9, bool&gt;;
-
-</code>
+struct <a href="#S0-0cf-S1-S2">S2</a>&lt;9, bool&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -11792,9 +10982,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S3;
-
-</code>
+<code class="source-code cpp">struct S3;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -11823,7 +11011,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R34"><code>R34</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -11838,9 +11026,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f3();
-
-</code>
+f3();</code>
 </pre>
 </div>
 </div>
@@ -11856,9 +11042,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int K,
     typename V = void&gt;
-struct S4;
-
-</code>
+struct S4;</code>
 </pre>
 </div>
 
@@ -11874,9 +11058,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -11890,9 +11072,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -11908,9 +11088,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int J,
     typename U = void&gt;
-struct S5;
-
-</code>
+struct S5;</code>
 </pre>
 </div>
 
@@ -11926,9 +11104,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -11942,9 +11118,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct <a href="#S0-0cf">S0</a>&lt;1, T*&gt;;
-
-</code>
+struct <a href="#S0-0cf">S0</a>&lt;1, T*&gt;;</code>
 </pre>
 </div>
 
diff --git a/test-files/golden-tests/symbols/record/class-template-specializations-2.html b/test-files/golden-tests/symbols/record/class-template-specializations-2.html
index c68232673..f4fff6eea 100644
--- a/test-files/golden-tests/symbols/record/class-template-specializations-2.html
+++ b/test-files/golden-tests/symbols/record/class-template-specializations-2.html
@@ -36,9 +36,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 
@@ -54,9 +52,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e">A</a>&lt;double&gt;;
-
-</code>
+struct <a href="#A-0e">A</a>&lt;double&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -87,9 +83,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct D;
-
-</code>
+struct D;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -119,9 +113,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct E;
-
-</code>
+struct E;</code>
 </pre>
 </div>
 
@@ -137,9 +129,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct <a href="#A-06-D-0b-E-01">E</a>&lt;T*&gt;;
-
-</code>
+struct <a href="#A-06-D-0b-E-01">E</a>&lt;T*&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -167,9 +157,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct F;
-
-</code>
+<code class="source-code cpp">struct F;</code>
 </pre>
 </div>
 
@@ -185,9 +173,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-06-D-0b">D</a>&lt;short&gt;;
-
-</code>
+struct <a href="#A-06-D-0b">D</a>&lt;short&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -217,9 +203,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct E;
-
-</code>
+struct E;</code>
 </pre>
 </div>
 
@@ -235,9 +219,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-06-D-0b-E-01">E</a>&lt;int*&gt;;
-
-</code>
+struct <a href="#A-06-D-0b-E-01">E</a>&lt;int*&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -265,9 +247,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct F;
-
-</code>
+<code class="source-code cpp">struct F;</code>
 </pre>
 </div>
 
@@ -283,9 +263,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-06-D-0b">D</a>&lt;float&gt;;
-
-</code>
+struct <a href="#A-06-D-0b">D</a>&lt;float&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -315,9 +293,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct G;
-
-</code>
+struct G;</code>
 </pre>
 </div>
 
@@ -333,9 +309,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct <a href="#A-06-D-04-G-06">G</a>&lt;T*&gt;;
-
-</code>
+struct <a href="#A-06-D-04-G-06">G</a>&lt;T*&gt;;</code>
 </pre>
 </div>
 
@@ -351,9 +325,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e">A</a>&lt;long*&gt;;
-
-</code>
+struct <a href="#A-0e">A</a>&lt;long*&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -384,9 +356,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 
@@ -402,9 +372,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-03-B-05">B</a>&lt;int&gt;;
-
-</code>
+struct <a href="#A-03-B-05">B</a>&lt;int&gt;;</code>
 </pre>
 </div>
 
@@ -420,9 +388,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-03-B-05">B</a>&lt;int*&gt;;
-
-</code>
+struct <a href="#A-03-B-05">B</a>&lt;int*&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -450,9 +416,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct C;
-
-</code>
+<code class="source-code cpp">struct C;</code>
 </pre>
 </div>
 
@@ -468,9 +432,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct <a href="#A-0e">A</a>&lt;T*&gt;;
-
-</code>
+struct <a href="#A-0e">A</a>&lt;T*&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -501,9 +463,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 
@@ -519,9 +479,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-03-B-05">B</a>&lt;int&gt;;
-
-</code>
+struct <a href="#A-03-B-05">B</a>&lt;int&gt;;</code>
 </pre>
 </div>
 
@@ -537,9 +495,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct <a href="#A-03-B-05">B</a>&lt;U*&gt;;
-
-</code>
+struct <a href="#A-03-B-05">B</a>&lt;U*&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -567,9 +523,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-2.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct C;
-
-</code>
+<code class="source-code cpp">struct C;</code>
 </pre>
 </div>
 
diff --git a/test-files/golden-tests/symbols/record/class-template-specializations-3.html b/test-files/golden-tests/symbols/record/class-template-specializations-3.html
index e16b4f462..3892e60d1 100644
--- a/test-files/golden-tests/symbols/record/class-template-specializations-3.html
+++ b/test-files/golden-tests/symbols/record/class-template-specializations-3.html
@@ -38,9 +38,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -70,9 +68,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -102,9 +98,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct C;
-
-</code>
+<code class="source-code cpp">struct C;</code>
 </pre>
 </div>
 
@@ -120,9 +114,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename V&gt;
-struct D;
-
-</code>
+struct D;</code>
 </pre>
 </div>
 
@@ -138,9 +130,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e-B-07-D-09">D</a>&lt;bool&gt;;
-
-</code>
+struct <a href="#A-0e-B-07-D-09">D</a>&lt;bool&gt;;</code>
 </pre>
 </div>
 
@@ -156,9 +146,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e-B-07">B</a>&lt;double&gt;;
-
-</code>
+struct <a href="#A-0e-B-07">B</a>&lt;double&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -188,9 +176,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct C;
-
-</code>
+<code class="source-code cpp">struct C;</code>
 </pre>
 </div>
 
@@ -206,9 +192,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename V&gt;
-struct D;
-
-</code>
+struct D;</code>
 </pre>
 </div>
 
@@ -224,9 +208,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e-B-00-D-09">D</a>&lt;bool&gt;;
-
-</code>
+struct <a href="#A-0e-B-00-D-09">D</a>&lt;bool&gt;;</code>
 </pre>
 </div>
 
@@ -242,9 +224,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e">A</a>&lt;short&gt;;
-
-</code>
+struct <a href="#A-0e">A</a>&lt;short&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -275,9 +255,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 
@@ -293,9 +271,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e-B-07">B</a>&lt;void&gt;;
-
-</code>
+struct <a href="#A-0e-B-07">B</a>&lt;void&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -325,9 +301,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct C;
-
-</code>
+<code class="source-code cpp">struct C;</code>
 </pre>
 </div>
 
@@ -343,9 +317,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename V&gt;
-struct D;
-
-</code>
+struct D;</code>
 </pre>
 </div>
 
@@ -361,9 +333,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-00-B-00-D-03">D</a>&lt;bool&gt;;
-
-</code>
+struct <a href="#A-00-B-00-D-03">D</a>&lt;bool&gt;;</code>
 </pre>
 </div>
 
@@ -379,9 +349,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e-B-07">B</a>&lt;double&gt;;
-
-</code>
+struct <a href="#A-0e-B-07">B</a>&lt;double&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -411,9 +379,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct C;
-
-</code>
+<code class="source-code cpp">struct C;</code>
 </pre>
 </div>
 
@@ -429,9 +395,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename V&gt;
-struct D;
-
-</code>
+struct D;</code>
 </pre>
 </div>
 
@@ -447,9 +411,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e-B-00-D-09">D</a>&lt;bool&gt;;
-
-</code>
+struct <a href="#A-0e-B-00-D-09">D</a>&lt;bool&gt;;</code>
 </pre>
 </div>
 
@@ -465,9 +427,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e">A</a>&lt;unsigned int&gt;;
-
-</code>
+struct <a href="#A-0e">A</a>&lt;unsigned int&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -498,9 +458,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 
@@ -516,9 +474,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e-B-07">B</a>&lt;float&gt;;
-
-</code>
+struct <a href="#A-0e-B-07">B</a>&lt;float&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -548,9 +504,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct C;
-
-</code>
+<code class="source-code cpp">struct C;</code>
 </pre>
 </div>
 
@@ -566,9 +520,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename V&gt;
-struct D;
-
-</code>
+struct D;</code>
 </pre>
 </div>
 
@@ -584,9 +536,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e-B-07-D-09">D</a>&lt;bool&gt;;
-
-</code>
+struct <a href="#A-0e-B-07-D-09">D</a>&lt;bool&gt;;</code>
 </pre>
 </div>
 
@@ -602,9 +552,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e-B-07">B</a>&lt;double&gt;;
-
-</code>
+struct <a href="#A-0e-B-07">B</a>&lt;double&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -634,9 +582,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct C;
-
-</code>
+<code class="source-code cpp">struct C;</code>
 </pre>
 </div>
 
@@ -652,9 +598,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename V&gt;
-struct D;
-
-</code>
+struct D;</code>
 </pre>
 </div>
 
@@ -670,9 +614,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e-B-00-D-09">D</a>&lt;bool&gt;;
-
-</code>
+struct <a href="#A-0e-B-00-D-09">D</a>&lt;bool&gt;;</code>
 </pre>
 </div>
 
@@ -688,9 +630,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e">A</a>&lt;long&gt;;
-
-</code>
+struct <a href="#A-0e">A</a>&lt;long&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -721,9 +661,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -753,9 +691,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct C;
-
-</code>
+<code class="source-code cpp">struct C;</code>
 </pre>
 </div>
 
@@ -771,9 +707,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename V&gt;
-struct D;
-
-</code>
+struct D;</code>
 </pre>
 </div>
 
@@ -789,9 +723,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0c-B-0b-D-00">D</a>&lt;bool&gt;;
-
-</code>
+struct <a href="#A-0c-B-0b-D-00">D</a>&lt;bool&gt;;</code>
 </pre>
 </div>
 
@@ -807,9 +739,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0c-B-0b">B</a>&lt;float&gt;;
-
-</code>
+struct <a href="#A-0c-B-0b">B</a>&lt;float&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -839,9 +769,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct C;
-
-</code>
+<code class="source-code cpp">struct C;</code>
 </pre>
 </div>
 
@@ -857,9 +785,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename V&gt;
-struct D;
-
-</code>
+struct D;</code>
 </pre>
 </div>
 
@@ -875,9 +801,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0c-B-0b-D-00">D</a>&lt;bool&gt;;
-
-</code>
+struct <a href="#A-0c-B-0b-D-00">D</a>&lt;bool&gt;;</code>
 </pre>
 </div>
 
@@ -893,9 +817,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0c-B-0b">B</a>&lt;double&gt;;
-
-</code>
+struct <a href="#A-0c-B-0b">B</a>&lt;double&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -925,9 +847,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct C;
-
-</code>
+<code class="source-code cpp">struct C;</code>
 </pre>
 </div>
 
@@ -943,9 +863,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename V&gt;
-struct D;
-
-</code>
+struct D;</code>
 </pre>
 </div>
 
@@ -961,9 +879,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e-B-00-D-09">D</a>&lt;bool&gt;;
-
-</code>
+struct <a href="#A-0e-B-00-D-09">D</a>&lt;bool&gt;;</code>
 </pre>
 </div>
 
@@ -979,9 +895,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e">A</a>&lt;float&gt;;
-
-</code>
+struct <a href="#A-0e">A</a>&lt;float&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -1011,9 +925,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 
@@ -1029,9 +941,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e-B-07">B</a>&lt;double&gt;;
-
-</code>
+struct <a href="#A-0e-B-07">B</a>&lt;double&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -1061,9 +971,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct C;
-
-</code>
+<code class="source-code cpp">struct C;</code>
 </pre>
 </div>
 
@@ -1079,9 +987,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename V&gt;
-struct D;
-
-</code>
+struct D;</code>
 </pre>
 </div>
 
@@ -1097,9 +1003,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e-B-00-D-09">D</a>&lt;bool&gt;;
-
-</code>
+struct <a href="#A-0e-B-00-D-09">D</a>&lt;bool&gt;;</code>
 </pre>
 </div>
 
@@ -1114,9 +1018,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct E;
-
-</code>
+<code class="source-code cpp">struct E;</code>
 </pre>
 </div>
 <h2>Data Members</h2>
@@ -1158,9 +1060,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#A-01-B-08">A&lt;float&gt;::B&lt;double&gt;</a> m0;
-
-</code>
+<code class="source-code cpp"><a href="#A-01-B-08">A&lt;float&gt;::B&lt;double&gt;</a> m0;</code>
 </pre>
 </div>
 </div>
@@ -1173,9 +1073,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#A-0c-B-0d">A&lt;long&gt;::B&lt;double&gt;</a> m1;
-
-</code>
+<code class="source-code cpp"><a href="#A-0c-B-0d">A&lt;long&gt;::B&lt;double&gt;</a> m1;</code>
 </pre>
 </div>
 </div>
@@ -1188,9 +1086,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#A-01-B-08-D-0af">A&lt;float&gt;::B&lt;double&gt;::D&lt;bool&gt;</a> m10;
-
-</code>
+<code class="source-code cpp"><a href="#A-01-B-08-D-0af">A&lt;float&gt;::B&lt;double&gt;::D&lt;bool&gt;</a> m10;</code>
 </pre>
 </div>
 </div>
@@ -1203,9 +1099,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#A-0c-B-0d-D-03">A&lt;long&gt;::B&lt;double&gt;::D&lt;bool&gt;</a> m11;
-
-</code>
+<code class="source-code cpp"><a href="#A-0c-B-0d-D-03">A&lt;long&gt;::B&lt;double&gt;::D&lt;bool&gt;</a> m11;</code>
 </pre>
 </div>
 </div>
@@ -1218,9 +1112,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#A-0c-B-08-D-03">A&lt;long&gt;::B&lt;float&gt;::D&lt;bool&gt;</a> m12;
-
-</code>
+<code class="source-code cpp"><a href="#A-0c-B-08-D-03">A&lt;long&gt;::B&lt;float&gt;::D&lt;bool&gt;</a> m12;</code>
 </pre>
 </div>
 </div>
@@ -1233,9 +1125,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#A-07-B-05-D-01">A&lt;unsigned int&gt;::B&lt;float&gt;::D&lt;bool&gt;</a> m13;
-
-</code>
+<code class="source-code cpp"><a href="#A-07-B-05-D-01">A&lt;unsigned int&gt;::B&lt;float&gt;::D&lt;bool&gt;</a> m13;</code>
 </pre>
 </div>
 </div>
@@ -1248,9 +1138,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#A-00-B-00-D-07">A&lt;short&gt;::B&lt;void&gt;::D&lt;bool&gt;</a> m14;
-
-</code>
+<code class="source-code cpp"><a href="#A-00-B-00-D-07">A&lt;short&gt;::B&lt;void&gt;::D&lt;bool&gt;</a> m14;</code>
 </pre>
 </div>
 </div>
@@ -1263,9 +1151,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#A-0c-B-0b">A&lt;long&gt;::B&lt;float&gt;</a> m2;
-
-</code>
+<code class="source-code cpp"><a href="#A-0c-B-0b">A&lt;long&gt;::B&lt;float&gt;</a> m2;</code>
 </pre>
 </div>
 </div>
@@ -1278,9 +1164,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#A-07-B-03a">A&lt;unsigned int&gt;::B&lt;float&gt;</a> m3;
-
-</code>
+<code class="source-code cpp"><a href="#A-07-B-03a">A&lt;unsigned int&gt;::B&lt;float&gt;</a> m3;</code>
 </pre>
 </div>
 </div>
@@ -1293,9 +1177,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#A-00-B-00">A&lt;short&gt;::B&lt;void&gt;</a> m4;
-
-</code>
+<code class="source-code cpp"><a href="#A-00-B-00">A&lt;short&gt;::B&lt;void&gt;</a> m4;</code>
 </pre>
 </div>
 </div>
@@ -1308,9 +1190,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#A-01-B-08-C">A&lt;float&gt;::B&lt;double&gt;::C</a> m5;
-
-</code>
+<code class="source-code cpp"><a href="#A-01-B-08-C">A&lt;float&gt;::B&lt;double&gt;::C</a> m5;</code>
 </pre>
 </div>
 </div>
@@ -1323,9 +1203,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#A-0c-B-0d-C">A&lt;long&gt;::B&lt;double&gt;::C</a> m6;
-
-</code>
+<code class="source-code cpp"><a href="#A-0c-B-0d-C">A&lt;long&gt;::B&lt;double&gt;::C</a> m6;</code>
 </pre>
 </div>
 </div>
@@ -1338,9 +1216,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#A-0c-B-08-C">A&lt;long&gt;::B&lt;float&gt;::C</a> m7;
-
-</code>
+<code class="source-code cpp"><a href="#A-0c-B-08-C">A&lt;long&gt;::B&lt;float&gt;::C</a> m7;</code>
 </pre>
 </div>
 </div>
@@ -1353,9 +1229,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#A-07-B-05-C">A&lt;unsigned int&gt;::B&lt;float&gt;::C</a> m8;
-
-</code>
+<code class="source-code cpp"><a href="#A-07-B-05-C">A&lt;unsigned int&gt;::B&lt;float&gt;::C</a> m8;</code>
 </pre>
 </div>
 </div>
@@ -1368,9 +1242,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template-specializations-3.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#A-00-B-00-C">A&lt;short&gt;::B&lt;void&gt;::C</a> m9;
-
-</code>
+<code class="source-code cpp"><a href="#A-00-B-00-C">A&lt;short&gt;::B&lt;void&gt;::C</a> m9;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/record/class-template.html b/test-files/golden-tests/symbols/record/class-template.html
index 4c88bc411..3f472e39f 100644
--- a/test-files/golden-tests/symbols/record/class-template.html
+++ b/test-files/golden-tests/symbols/record/class-template.html
@@ -37,9 +37,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct C0;
-
-</code>
+struct C0;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -82,9 +80,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct N0;
-
-</code>
+<code class="source-code cpp">struct N0;</code>
 </pre>
 </div>
 <h2>Data Members</h2>
@@ -112,9 +108,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int z;
-
-</code>
+<code class="source-code cpp">int z;</code>
 </pre>
 </div>
 </div>
@@ -127,9 +121,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int w;
-
-</code>
+<code class="source-code cpp">int w;</code>
 </pre>
 </div>
 </div>
@@ -142,9 +134,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#S">S</a> x;
-
-</code>
+<code class="source-code cpp"><a href="#S">S</a> x;</code>
 </pre>
 </div>
 </div>
@@ -157,9 +147,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">T y;
-
-</code>
+<code class="source-code cpp">T y;</code>
 </pre>
 </div>
 </div>
@@ -172,9 +160,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct C1;
-
-</code>
+<code class="source-code cpp">struct C1;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -216,9 +202,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct N1;
-
-</code>
+struct N1;</code>
 </pre>
 </div>
 <h2>Data Members</h2>
@@ -248,9 +232,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#S">S</a> x;
-
-</code>
+<code class="source-code cpp"><a href="#S">S</a> x;</code>
 </pre>
 </div>
 </div>
@@ -263,9 +245,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">T y;
-
-</code>
+<code class="source-code cpp">T y;</code>
 </pre>
 </div>
 </div>
@@ -278,9 +258,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int z;
-
-</code>
+<code class="source-code cpp">int z;</code>
 </pre>
 </div>
 </div>
@@ -293,9 +271,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int w;
-
-</code>
+<code class="source-code cpp">int w;</code>
 </pre>
 </div>
 </div>
@@ -309,9 +285,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct C2;
-
-</code>
+struct C2;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -353,9 +327,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct N2;
-
-</code>
+struct N2;</code>
 </pre>
 </div>
 <h2>Data Members</h2>
@@ -386,9 +358,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#S">S</a> w;
-
-</code>
+<code class="source-code cpp"><a href="#S">S</a> w;</code>
 </pre>
 </div>
 </div>
@@ -401,9 +371,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">T x;
-
-</code>
+<code class="source-code cpp">T x;</code>
 </pre>
 </div>
 </div>
@@ -416,9 +384,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">U y;
-
-</code>
+<code class="source-code cpp">U y;</code>
 </pre>
 </div>
 </div>
@@ -431,9 +397,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int z;
-
-</code>
+<code class="source-code cpp">int z;</code>
 </pre>
 </div>
 </div>
@@ -446,9 +410,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int v;
-
-</code>
+<code class="source-code cpp">int v;</code>
 </pre>
 </div>
 </div>
@@ -462,9 +424,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct C3;
-
-</code>
+struct C3;</code>
 </pre>
 </div>
 <h2>Data Members</h2>
@@ -492,9 +452,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int v;
-
-</code>
+<code class="source-code cpp">int v;</code>
 </pre>
 </div>
 </div>
@@ -507,9 +465,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;class-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S;
-
-</code>
+<code class="source-code cpp">struct S;</code>
 </pre>
 </div>
 
diff --git a/test-files/golden-tests/symbols/record/conditional-explicit.html b/test-files/golden-tests/symbols/record/conditional-explicit.html
index 5e1439c06..f61115e39 100644
--- a/test-files/golden-tests/symbols/record/conditional-explicit.html
+++ b/test-files/golden-tests/symbols/record/conditional-explicit.html
@@ -33,9 +33,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;conditional-explicit.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -48,11 +46,11 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-2constructor-0f"><code>A</code></a>         <span class="small">[constructor]</span></td><td><span>Constructors</span></td></tr><tr>
-<td><a href="#A-2conversion-0f"><code>operator U</code></a> </td><td><span>Conditional explicit conversion to other types</span></td></tr><tr>
-<td><a href="#A-2conversion-00"><code>operator bool</code></a> </td><td><span>Explicit conversion to bool</span></td></tr><tr>
-<td><a href="#A-2conversion-04"><code>operator char</code></a> </td><td><span>Conditionally explicit conversion to char</span></td></tr><tr>
-<td><a href="#A-2conversion-01"><code>operator double</code></a> </td><td><span>Implicit conversion to double</span></td></tr>
+<td><a href="#A-2constructor-0f"><code>A</code></a>         <span class="small">[constructor]</span></td><td>Constructors</td></tr><tr>
+<td><a href="#A-2conversion-0f"><code>operator U</code></a> </td><td>Conditional explicit conversion to other types</td></tr><tr>
+<td><a href="#A-2conversion-00"><code>operator bool</code></a> </td><td>Explicit conversion to bool</td></tr><tr>
+<td><a href="#A-2conversion-04"><code>operator char</code></a> </td><td>Conditionally explicit conversion to char</td></tr><tr>
+<td><a href="#A-2conversion-01"><code>operator double</code></a> </td><td>Implicit conversion to double</td></tr>
 </tbody>
 </table>
 
@@ -63,44 +61,35 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="A-2constructor-0f">A::A</h2>
 <div>
-<span>Constructors</span>
-
+<p>Constructors</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;conditional-explicit.cpp&gt;</code></div>
-<span>Conditionally explicit conversion from char</span>
+<p>Conditionally explicit conversion from char</p>
 <pre>
 <code class="source-code cpp">explicit(sizeof(T) &gt; 4)
-<a href="#A-2constructor-0b">A</a>(char value);
-
-</code>
+<a href="#A-2constructor-0b">A</a>(char value);</code>
 </pre><span class="small"><a href="#A-2constructor-0b"><em>» more...</em></a></span>
 
-<span>Explicit conversion from int</span>
+<p>Explicit conversion from int</p>
 <pre>
 <code class="source-code cpp">explicit
-<a href="#A-2constructor-01">A</a>(int value);
-
-</code>
+<a href="#A-2constructor-01">A</a>(int value);</code>
 </pre><span class="small"><a href="#A-2constructor-01"><em>» more...</em></a></span>
 
-<span>Implicit conversion from double</span>
+<p>Implicit conversion from double</p>
 <pre>
-<code class="source-code cpp"><a href="#A-2constructor-00">A</a>(double value);
-
-</code>
+<code class="source-code cpp"><a href="#A-2constructor-00">A</a>(double value);</code>
 </pre><span class="small"><a href="#A-2constructor-00"><em>» more...</em></a></span>
 
-<span>Conditionally explicit conversion from other types</span>
+<p>Conditionally explicit conversion from other types</p>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
 explicit(sizeof(U) &gt; 4)
-<a href="#A-2constructor-02">A</a>(U value);
-
-</code>
+<a href="#A-2constructor-02">A</a>(U value);</code>
 </pre><span class="small"><a href="#A-2constructor-02"><em>» more...</em></a></span>
 
 
@@ -110,8 +99,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="A-2constructor-0b">A::A</h2>
 <div>
-<span>Conditionally explicit conversion from char</span>
-
+<p>Conditionally explicit conversion from char</p>
 </div>
 </div>
 <div>
@@ -120,9 +108,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;conditional-explicit.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit(sizeof(T) &gt; 4)
-A(char value);
-
-</code>
+A(char value);</code>
 </pre>
 </div>
 <div>
@@ -137,7 +123,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The value to construct from</span></td>
+<td>The value to construct from</td>
 </tr>
 </tbody>
 </table>
@@ -147,8 +133,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="A-2constructor-01">A::A</h2>
 <div>
-<span>Explicit conversion from int</span>
-
+<p>Explicit conversion from int</p>
 </div>
 </div>
 <div>
@@ -157,9 +142,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;conditional-explicit.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit
-A(int value);
-
-</code>
+A(int value);</code>
 </pre>
 </div>
 <div>
@@ -174,7 +157,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The value to construct from</span></td>
+<td>The value to construct from</td>
 </tr>
 </tbody>
 </table>
@@ -184,8 +167,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="A-2constructor-00">A::A</h2>
 <div>
-<span>Implicit conversion from double</span>
-
+<p>Implicit conversion from double</p>
 </div>
 </div>
 <div>
@@ -193,9 +175,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;conditional-explicit.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">A(double value);
-
-</code>
+<code class="source-code cpp">A(double value);</code>
 </pre>
 </div>
 <div>
@@ -210,7 +190,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The value to construct from</span></td>
+<td>The value to construct from</td>
 </tr>
 </tbody>
 </table>
@@ -220,8 +200,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="A-2constructor-02">A::A</h2>
 <div>
-<span>Conditionally explicit conversion from other types</span>
-
+<p>Conditionally explicit conversion from other types</p>
 </div>
 </div>
 <div>
@@ -231,9 +210,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
 explicit(sizeof(U) &gt; 4)
-A(U value);
-
-</code>
+A(U value);</code>
 </pre>
 </div>
 <div>
@@ -248,7 +225,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>value</strong></td>
-<td><span>The object to construct from</span></td>
+<td>The object to construct from</td>
 </tr>
 </tbody>
 </table>
@@ -258,8 +235,7 @@ <h3>Parameters</h3>
 <div>
 <h2 id="A-2conversion-0f">A::operator U</h2>
 <div>
-<span>Conditional explicit conversion to other types</span>
-
+<p>Conditional explicit conversion to other types</p>
 </div>
 </div>
 <div>
@@ -269,22 +245,19 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
 explicit(sizeof(U) &gt; 1)
-operator U() const;
-
-</code>
+operator U() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The object converted to <code>U</code></span>
+The object converted to <code>U</code>
 </div>
 </div>
 <div>
 <div>
 <h2 id="A-2conversion-00">A::operator bool</h2>
 <div>
-<span>Explicit conversion to bool</span>
-
+<p>Explicit conversion to bool</p>
 </div>
 </div>
 <div>
@@ -293,22 +266,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;conditional-explicit.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit
-operator bool() const;
-
-</code>
+operator bool() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The object converted to <code>bool</code></span>
+The object converted to <code>bool</code>
 </div>
 </div>
 <div>
 <div>
 <h2 id="A-2conversion-04">A::operator char</h2>
 <div>
-<span>Conditionally explicit conversion to char</span>
-
+<p>Conditionally explicit conversion to char</p>
 </div>
 </div>
 <div>
@@ -317,22 +287,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;conditional-explicit.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">explicit(sizeof(T) &gt; 4)
-operator char() const;
-
-</code>
+operator char() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The object converted to <code>char</code></span>
+The object converted to <code>char</code>
 </div>
 </div>
 <div>
 <div>
 <h2 id="A-2conversion-01">A::operator double</h2>
 <div>
-<span>Implicit conversion to double</span>
-
+<p>Implicit conversion to double</p>
 </div>
 </div>
 <div>
@@ -340,14 +307,12 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;conditional-explicit.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">operator double() const;
-
-</code>
+<code class="source-code cpp">operator double() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>The object converted to <code>double</code></span>
+The object converted to <code>double</code>
 </div>
 </div>
 
diff --git a/test-files/golden-tests/symbols/record/dtor-overloads.html b/test-files/golden-tests/symbols/record/dtor-overloads.html
index 8b0378186..fc3416561 100644
--- a/test-files/golden-tests/symbols/record/dtor-overloads.html
+++ b/test-files/golden-tests/symbols/record/dtor-overloads.html
@@ -33,9 +33,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;dtor-overloads.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -48,7 +46,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-2destructor-02"><code>~A</code></a> <span class="small">[destructor]</span></td><td><span>Destructors</span></td></tr>
+<td><a href="#A-2destructor-02"><code>~A</code></a> <span class="small">[destructor]</span></td><td>Destructors</td></tr>
 </tbody>
 </table>
 
@@ -59,28 +57,23 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="A-2destructor-02">A::~A</h2>
 <div>
-<span>Destructors</span>
-
+<p>Destructors</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;dtor-overloads.cpp&gt;</code></div>
-<span>Destructor</span>
+<p>Destructor</p>
 <pre>
 <code class="source-code cpp"><a href="#A-2destructor-0c">~A</a>()
-requires (sizeof(T) &gt; 4);
-
-</code>
+requires (sizeof(T) &gt; 4);</code>
 </pre><span class="small"><a href="#A-2destructor-0c"><em>» more...</em></a></span>
 
-<span>Destructor</span>
+<p>Destructor</p>
 <pre>
 <code class="source-code cpp"><a href="#A-2destructor-07">~A</a>()
-requires (sizeof(T) &lt;&#x3D; 4);
-
-</code>
+requires (sizeof(T) &lt;&#x3D; 4);</code>
 </pre><span class="small"><a href="#A-2destructor-07"><em>» more...</em></a></span>
 
 
@@ -90,8 +83,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="A-2destructor-0c">A::~A</h2>
 <div>
-<span>Destructor</span>
-
+<p>Destructor</p>
 </div>
 </div>
 <div>
@@ -100,9 +92,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;dtor-overloads.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">~A()
-requires (sizeof(T) &gt; 4);
-
-</code>
+requires (sizeof(T) &gt; 4);</code>
 </pre>
 </div>
 </div>
@@ -110,8 +100,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="A-2destructor-07">A::~A</h2>
 <div>
-<span>Destructor</span>
-
+<p>Destructor</p>
 </div>
 </div>
 <div>
@@ -120,9 +109,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;dtor-overloads.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">~A()
-requires (sizeof(T) &lt;&#x3D; 4);
-
-</code>
+requires (sizeof(T) &lt;&#x3D; 4);</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/record/final-class.html b/test-files/golden-tests/symbols/record/final-class.html
index 96efd1b9d..c58efed8e 100644
--- a/test-files/golden-tests/symbols/record/final-class.html
+++ b/test-files/golden-tests/symbols/record/final-class.html
@@ -36,9 +36,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;final-class.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class A1 final
-
-</code>
+<code class="source-code cpp">class A1 final</code>
 </pre>
 </div>
 
@@ -54,9 +52,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;final-class.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-class A2 final
-
-</code>
+class A2 final</code>
 </pre>
 </div>
 
@@ -73,9 +69,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">class A3 final
     : public <a href="#B1">B1</a>
-    , public <a href="#B2">B2</a>
-
-</code>
+    , public <a href="#B2">B2</a></code>
 </pre>
 </div>
 <div>
@@ -88,8 +82,8 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#B1">B1</a></code></td><td><span></span></td></tr>
-<tr><td><code><a href="#B2">B2</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#B1">B1</a></code></td><td></td></tr>
+<tr><td><code><a href="#B2">B2</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -105,9 +99,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;final-class.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class B1;
-
-</code>
+<code class="source-code cpp">class B1;</code>
 </pre>
 </div>
 
@@ -123,7 +115,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#A3"><code>A3</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -137,9 +129,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;final-class.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class B2;
-
-</code>
+<code class="source-code cpp">class B2;</code>
 </pre>
 </div>
 
@@ -155,7 +145,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#A3"><code>A3</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
diff --git a/test-files/golden-tests/symbols/record/friend-duplicate.html b/test-files/golden-tests/symbols/record/friend-duplicate.html
index 6a1417fdd..b004a0103 100644
--- a/test-files/golden-tests/symbols/record/friend-duplicate.html
+++ b/test-files/golden-tests/symbols/record/friend-duplicate.html
@@ -46,9 +46,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-duplicate.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class A;
-
-</code>
+<code class="source-code cpp">class A;</code>
 </pre>
 </div>
 
@@ -65,11 +63,11 @@ <h2>Friends</h2>
 <tbody>
 <tr>
 <td><code><a href="#f">f</a></code></td>
-<td><span></span></td>
+<td></td>
 </tr>
 <tr>
 <td><code><a href="#B">B</a></code></td>
-<td><span></span></td>
+<td></td>
 </tr>
 |===
 </tbody>
@@ -85,9 +83,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-duplicate.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class B;
-
-</code>
+<code class="source-code cpp">class B;</code>
 </pre>
 </div>
 
@@ -103,9 +99,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;friend-duplicate.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/record/friend-excluded.html b/test-files/golden-tests/symbols/record/friend-excluded.html
index 31fb1bd93..ddd9b09f8 100644
--- a/test-files/golden-tests/symbols/record/friend-excluded.html
+++ b/test-files/golden-tests/symbols/record/friend-excluded.html
@@ -46,9 +46,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-excluded.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class A;
-
-</code>
+<code class="source-code cpp">class A;</code>
 </pre>
 </div>
 
@@ -65,11 +63,11 @@ <h2>Friends</h2>
 <tbody>
 <tr>
 <td><code><a href="#f">f</a></code></td>
-<td><span></span></td>
+<td></td>
 </tr>
 <tr>
 <td><code><a href="#B">B</a></code></td>
-<td><span></span></td>
+<td></td>
 </tr>
 |===
 </tbody>
@@ -85,9 +83,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-excluded.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class B;
-
-</code>
+<code class="source-code cpp">class B;</code>
 </pre>
 </div>
 
@@ -103,9 +99,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;friend-excluded.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/record/friend-fn-has-docs.html b/test-files/golden-tests/symbols/record/friend-fn-has-docs.html
index 395192bd8..a4691fa19 100644
--- a/test-files/golden-tests/symbols/record/friend-fn-has-docs.html
+++ b/test-files/golden-tests/symbols/record/friend-fn-has-docs.html
@@ -32,7 +32,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>f</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>f</td></tr>
 </tbody>
 </table>
 
@@ -46,9 +46,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-fn-has-docs.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T;
-
-</code>
+<code class="source-code cpp">struct T;</code>
 </pre>
 </div>
 
@@ -65,7 +63,7 @@ <h2>Friends</h2>
 <tbody>
 <tr>
 <td><code><a href="#f">f</a></code></td>
-<td><span>f</span></td>
+<td>f</td>
 </tr>
 |===
 </tbody>
@@ -76,8 +74,7 @@ <h2>Friends</h2>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>f</span>
-
+<p>f</p>
 </div>
 </div>
 <div>
@@ -86,9 +83,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;friend-fn-has-docs.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/record/friend-fn-member.adoc b/test-files/golden-tests/symbols/record/friend-fn-member.adoc
index 70d6ee1ed..3912a58c6 100644
--- a/test-files/golden-tests/symbols/record/friend-fn-member.adoc
+++ b/test-files/golden-tests/symbols/record/friend-fn-member.adoc
@@ -119,7 +119,7 @@ char&ast;
 | Name
 | Description
 | *i*
-| 
+| Description of i
 |===
 
 
diff --git a/test-files/golden-tests/symbols/record/friend-fn-member.cpp b/test-files/golden-tests/symbols/record/friend-fn-member.cpp
index a4eb11e07..f927fa404 100644
--- a/test-files/golden-tests/symbols/record/friend-fn-member.cpp
+++ b/test-files/golden-tests/symbols/record/friend-fn-member.cpp
@@ -3,7 +3,7 @@ struct X
     X();
     ~X();
     /// Friend member-function
-    /// @param i
+    /// @param i Description of i
     /// @return char*
     char* foo(int i);
 };
diff --git a/test-files/golden-tests/symbols/record/friend-fn-member.html b/test-files/golden-tests/symbols/record/friend-fn-member.html
index a016b96ac..99c31a597 100644
--- a/test-files/golden-tests/symbols/record/friend-fn-member.html
+++ b/test-files/golden-tests/symbols/record/friend-fn-member.html
@@ -33,9 +33,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-fn-member.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct U;
-
-</code>
+<code class="source-code cpp">struct U;</code>
 </pre>
 </div>
 
@@ -52,15 +50,15 @@ <h2>Friends</h2>
 <tbody>
 <tr>
 <td><code><a href="#X-foo">foo</a></code></td>
-<td><span>Friend member-function</span></td>
+<td>Friend member-function</td>
 </tr>
 <tr>
 <td><code><a href="#X-2destructor">~X</a></code></td>
-<td><span>Destructor</span></td>
+<td>Destructor</td>
 </tr>
 <tr>
 <td><code><a href="#X-2constructor">X</a></code></td>
-<td><span>Default constructor</span></td>
+<td>Default constructor</td>
 </tr>
 |===
 </tbody>
@@ -76,9 +74,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-fn-member.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct X;
-
-</code>
+<code class="source-code cpp">struct X;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -91,9 +87,9 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#X-2constructor"><code>X</code></a>         <span class="small">[constructor]</span></td><td><span>Default constructor</span></td></tr><tr>
-<td><a href="#X-2destructor"><code>~X</code></a> <span class="small">[destructor]</span></td><td><span>Destructor</span></td></tr><tr>
-<td><a href="#X-foo"><code>foo</code></a> </td><td><span>Friend member-function</span></td></tr>
+<td><a href="#X-2constructor"><code>X</code></a>         <span class="small">[constructor]</span></td><td>Default constructor</td></tr><tr>
+<td><a href="#X-2destructor"><code>~X</code></a> <span class="small">[destructor]</span></td><td>Destructor</td></tr><tr>
+<td><a href="#X-foo"><code>foo</code></a> </td><td>Friend member-function</td></tr>
 </tbody>
 </table>
 
@@ -104,8 +100,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="X-2constructor">X::X</h2>
 <div>
-<span>Default constructor</span>
-
+<p>Default constructor</p>
 </div>
 </div>
 <div>
@@ -113,9 +108,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-fn-member.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">X();
-
-</code>
+<code class="source-code cpp">X();</code>
 </pre>
 </div>
 </div>
@@ -123,8 +116,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="X-2destructor">X::~X</h2>
 <div>
-<span>Destructor</span>
-
+<p>Destructor</p>
 </div>
 </div>
 <div>
@@ -132,9 +124,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-fn-member.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">~X();
-
-</code>
+<code class="source-code cpp">~X();</code>
 </pre>
 </div>
 </div>
@@ -142,8 +132,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="X-foo">X::foo</h2>
 <div>
-<span>Friend member-function</span>
-
+<p>Friend member-function</p>
 </div>
 </div>
 <div>
@@ -152,14 +141,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;friend-fn-member.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">char*
-foo(int i);
-
-</code>
+foo(int i);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>char*</span>
+char*
 </div>
 <div>
 <h3>Parameters</h3>
@@ -173,7 +160,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>i</strong></td>
-<td><span></span></td>
+<td>Description of i</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/symbols/record/friend-fn-member.xml b/test-files/golden-tests/symbols/record/friend-fn-member.xml
index f11d5fd0f..2a1d89869 100644
--- a/test-files/golden-tests/symbols/record/friend-fn-member.xml
+++ b/test-files/golden-tests/symbols/record/friend-fn-member.xml
@@ -53,6 +53,7 @@
           <text>char*</text>
         </returns>
         <param name="i">
+          <text>Description of i</text>
         </param>
       </doc>
     </function>
diff --git a/test-files/golden-tests/symbols/record/friend-fn-multi-2nd.html b/test-files/golden-tests/symbols/record/friend-fn-multi-2nd.html
index a90ac42c5..4612bceb8 100644
--- a/test-files/golden-tests/symbols/record/friend-fn-multi-2nd.html
+++ b/test-files/golden-tests/symbols/record/friend-fn-multi-2nd.html
@@ -33,7 +33,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>U::f</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>U::f</td></tr>
 </tbody>
 </table>
 
@@ -47,9 +47,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-fn-multi-2nd.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T;
-
-</code>
+<code class="source-code cpp">struct T;</code>
 </pre>
 </div>
 
@@ -66,7 +64,7 @@ <h2>Friends</h2>
 <tbody>
 <tr>
 <td><code><a href="#f">f</a></code></td>
-<td><span>U::f</span></td>
+<td>U::f</td>
 </tr>
 |===
 </tbody>
@@ -82,9 +80,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-fn-multi-2nd.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct U;
-
-</code>
+<code class="source-code cpp">struct U;</code>
 </pre>
 </div>
 
@@ -101,7 +97,7 @@ <h2>Friends</h2>
 <tbody>
 <tr>
 <td><code><a href="#f">f</a></code></td>
-<td><span>U::f</span></td>
+<td>U::f</td>
 </tr>
 |===
 </tbody>
@@ -112,8 +108,7 @@ <h2>Friends</h2>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>U::f</span>
-
+<p>U::f</p>
 </div>
 </div>
 <div>
@@ -122,9 +117,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;friend-fn-multi-2nd.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/record/friend-fn-multi-free.html b/test-files/golden-tests/symbols/record/friend-fn-multi-free.html
index 57b7f7299..f0483d0a0 100644
--- a/test-files/golden-tests/symbols/record/friend-fn-multi-free.html
+++ b/test-files/golden-tests/symbols/record/friend-fn-multi-free.html
@@ -33,7 +33,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>f</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>f</td></tr>
 </tbody>
 </table>
 
@@ -47,9 +47,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-fn-multi-free.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T;
-
-</code>
+<code class="source-code cpp">struct T;</code>
 </pre>
 </div>
 
@@ -66,7 +64,7 @@ <h2>Friends</h2>
 <tbody>
 <tr>
 <td><code><a href="#f">f</a></code></td>
-<td><span>f</span></td>
+<td>f</td>
 </tr>
 |===
 </tbody>
@@ -82,9 +80,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-fn-multi-free.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct U;
-
-</code>
+<code class="source-code cpp">struct U;</code>
 </pre>
 </div>
 
@@ -101,7 +97,7 @@ <h2>Friends</h2>
 <tbody>
 <tr>
 <td><code><a href="#f">f</a></code></td>
-<td><span>f</span></td>
+<td>f</td>
 </tr>
 |===
 </tbody>
@@ -112,8 +108,7 @@ <h2>Friends</h2>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>f</span>
-
+<p>f</p>
 </div>
 </div>
 <div>
@@ -122,9 +117,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;friend-fn-multi-free.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/record/friend-fn-multi.html b/test-files/golden-tests/symbols/record/friend-fn-multi.html
index a3fb41f66..394c48ea3 100644
--- a/test-files/golden-tests/symbols/record/friend-fn-multi.html
+++ b/test-files/golden-tests/symbols/record/friend-fn-multi.html
@@ -33,7 +33,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>T::f</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>T::f</td></tr>
 </tbody>
 </table>
 
@@ -47,9 +47,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-fn-multi.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T;
-
-</code>
+<code class="source-code cpp">struct T;</code>
 </pre>
 </div>
 
@@ -66,7 +64,7 @@ <h2>Friends</h2>
 <tbody>
 <tr>
 <td><code><a href="#f">f</a></code></td>
-<td><span>T::f</span></td>
+<td>T::f</td>
 </tr>
 |===
 </tbody>
@@ -82,9 +80,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-fn-multi.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct U;
-
-</code>
+<code class="source-code cpp">struct U;</code>
 </pre>
 </div>
 
@@ -101,7 +97,7 @@ <h2>Friends</h2>
 <tbody>
 <tr>
 <td><code><a href="#f">f</a></code></td>
-<td><span>T::f</span></td>
+<td>T::f</td>
 </tr>
 |===
 </tbody>
@@ -112,8 +108,7 @@ <h2>Friends</h2>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>T::f</span>
-
+<p>T::f</p>
 </div>
 </div>
 <div>
@@ -122,9 +117,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;friend-fn-multi.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/record/friend-fn.html b/test-files/golden-tests/symbols/record/friend-fn.html
index 133020c70..74b6369f0 100644
--- a/test-files/golden-tests/symbols/record/friend-fn.html
+++ b/test-files/golden-tests/symbols/record/friend-fn.html
@@ -32,7 +32,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>f</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>f</td></tr>
 </tbody>
 </table>
 
@@ -46,9 +46,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-fn.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T;
-
-</code>
+<code class="source-code cpp">struct T;</code>
 </pre>
 </div>
 
@@ -65,7 +63,7 @@ <h2>Friends</h2>
 <tbody>
 <tr>
 <td><code><a href="#f">f</a></code></td>
-<td><span>f</span></td>
+<td>f</td>
 </tr>
 |===
 </tbody>
@@ -76,8 +74,7 @@ <h2>Friends</h2>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>f</span>
-
+<p>f</p>
 </div>
 </div>
 <div>
@@ -86,9 +83,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;friend-fn.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/record/friend-type.html b/test-files/golden-tests/symbols/record/friend-type.html
index 69c654552..888899cee 100644
--- a/test-files/golden-tests/symbols/record/friend-type.html
+++ b/test-files/golden-tests/symbols/record/friend-type.html
@@ -19,10 +19,10 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#T"><code>T</code></a> </td><td><span>Struct T brief</span></td></tr><tr>
-<td><a href="#U"><code>U</code></a> </td><td><span>Struct U brief</span></td></tr><tr>
-<td><a href="#V"><code>V</code></a> </td><td><span>Struct V brief</span></td></tr><tr>
-<td><a href="#Z"><code>Z</code></a> </td><td><span>Friend class Z brief</span></td></tr>
+<td><a href="#T"><code>T</code></a> </td><td>Struct T brief</td></tr><tr>
+<td><a href="#U"><code>U</code></a> </td><td>Struct U brief</td></tr><tr>
+<td><a href="#V"><code>V</code></a> </td><td>Struct V brief</td></tr><tr>
+<td><a href="#Z"><code>Z</code></a> </td><td>Friend class Z brief</td></tr>
 </tbody>
 </table>
 
@@ -31,8 +31,7 @@ <h2>Types</h2>
 <div>
 <h2 id="T">T</h2>
 <div>
-<span>Struct T brief</span>
-
+<p>Struct T brief</p>
 </div>
 </div>
 <div>
@@ -40,9 +39,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-type.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T;
-
-</code>
+<code class="source-code cpp">struct T;</code>
 </pre>
 </div>
 
@@ -59,7 +56,7 @@ <h2>Friends</h2>
 <tbody>
 <tr>
 <td><code><a href="#Z">Z</a></code></td>
-<td><span>Friend class Z brief</span></td>
+<td>Friend class Z brief</td>
 </tr>
 |===
 </tbody>
@@ -70,8 +67,7 @@ <h2>Friends</h2>
 <div>
 <h2 id="U">U</h2>
 <div>
-<span>Struct U brief</span>
-
+<p>Struct U brief</p>
 </div>
 </div>
 <div>
@@ -79,9 +75,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-type.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct U;
-
-</code>
+<code class="source-code cpp">struct U;</code>
 </pre>
 </div>
 
@@ -98,7 +92,7 @@ <h2>Friends</h2>
 <tbody>
 <tr>
 <td><code><a href="#T">T</a></code></td>
-<td><span>Struct T brief</span></td>
+<td>Struct T brief</td>
 </tr>
 |===
 </tbody>
@@ -109,8 +103,7 @@ <h2>Friends</h2>
 <div>
 <h2 id="V">V</h2>
 <div>
-<span>Struct V brief</span>
-
+<p>Struct V brief</p>
 </div>
 </div>
 <div>
@@ -118,9 +111,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-type.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct V;
-
-</code>
+<code class="source-code cpp">struct V;</code>
 </pre>
 </div>
 
@@ -137,7 +128,7 @@ <h2>Friends</h2>
 <tbody>
 <tr>
 <td><code><a href="#U">U</a></code></td>
-<td><span>Struct U brief</span></td>
+<td>Struct U brief</td>
 </tr>
 |===
 </tbody>
@@ -148,8 +139,7 @@ <h2>Friends</h2>
 <div>
 <h2 id="Z">Z</h2>
 <div>
-<span>Friend class Z brief</span>
-
+<p>Friend class Z brief</p>
 </div>
 </div>
 <div>
@@ -157,9 +147,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;friend-type.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class Z;
-
-</code>
+<code class="source-code cpp">class Z;</code>
 </pre>
 </div>
 
diff --git a/test-files/golden-tests/symbols/record/local-class.html b/test-files/golden-tests/symbols/record/local-class.html
index b1f5105c1..382d28e21 100644
--- a/test-files/golden-tests/symbols/record/local-class.html
+++ b/test-files/golden-tests/symbols/record/local-class.html
@@ -46,9 +46,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;local-class.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct B
-    : decltype(f())
-
-</code>
+    : decltype(f())</code>
 </pre>
 </div>
 <div>
@@ -61,7 +59,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code>decltype(f())</code></td><td><span></span></td></tr>
+<tr><td><code>decltype(f())</code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -78,9 +76,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;local-class.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">auto
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/record/out-of-line-record-def.html b/test-files/golden-tests/symbols/record/out-of-line-record-def.html
index cac5ff65e..9cbed3b85 100644
--- a/test-files/golden-tests/symbols/record/out-of-line-record-def.html
+++ b/test-files/golden-tests/symbols/record/out-of-line-record-def.html
@@ -50,9 +50,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;out-of-line-record-def.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S;
-
-</code>
+<code class="source-code cpp">struct S;</code>
 </pre>
 </div>
 
diff --git a/test-files/golden-tests/symbols/record/record-1.html b/test-files/golden-tests/symbols/record/record-1.html
index 217757108..babe66e44 100644
--- a/test-files/golden-tests/symbols/record/record-1.html
+++ b/test-files/golden-tests/symbols/record/record-1.html
@@ -32,9 +32,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T;
-
-</code>
+<code class="source-code cpp">struct T;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -77,9 +75,9 @@ <h2>Protected Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#T-g1"><code>g1</code></a> </td><td><span>brief-g1</span></td></tr><tr>
-<td><a href="#T-g2"><code>g2</code></a> </td><td><span>brief-g2</span></td></tr><tr>
-<td><a href="#T-g3"><code>g3</code></a> </td><td><span>brief-g3</span></td></tr>
+<td><a href="#T-g1"><code>g1</code></a> </td><td>brief-g1</td></tr><tr>
+<td><a href="#T-g2"><code>g2</code></a> </td><td>brief-g2</td></tr><tr>
+<td><a href="#T-g3"><code>g3</code></a> </td><td>brief-g3</td></tr>
 </tbody>
 </table>
 
@@ -94,9 +92,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using U1 = int;
-
-</code>
+<code class="source-code cpp">using U1 = int;</code>
 </pre>
 </div>
 </div>
@@ -109,9 +105,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">typedef char U2;
-
-</code>
+<code class="source-code cpp">typedef char U2;</code>
 </pre>
 </div>
 </div>
@@ -125,9 +119,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -141,9 +133,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -157,9 +147,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">char
-f3();
-
-</code>
+f3();</code>
 </pre>
 </div>
 </div>
@@ -167,8 +155,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="T-g1">T::g1</h2>
 <div>
-<span>brief-g1</span>
-
+<p>brief-g1</p>
 </div>
 </div>
 <div>
@@ -177,9 +164,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g1();
-
-</code>
+g1();</code>
 </pre>
 </div>
 <div>
@@ -191,8 +176,7 @@ <h3>Description</h3>
 <div>
 <h2 id="T-g2">T::g2</h2>
 <div>
-<span>brief-g2</span>
-
+<p>brief-g2</p>
 </div>
 </div>
 <div>
@@ -201,22 +185,19 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">int
-g2();
-
-</code>
+g2();</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>the number 2</span>
+the number 2
 </div>
 </div>
 <div>
 <div>
 <h2 id="T-g3">T::g3</h2>
 <div>
-<span>brief-g3</span>
-
+<p>brief-g3</p>
 </div>
 </div>
 <div>
@@ -225,14 +206,12 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">char
-g3(int x);
-
-</code>
+g3(int x);</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>the separator</span>
+the separator
 </div>
 <div>
 <h3>Parameters</h3>
@@ -246,7 +225,7 @@ <h3>Parameters</h3>
 <tbody>
 <tr>
 <td><strong>x</strong></td>
-<td><span>any old number</span></td>
+<td>any old number</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/symbols/record/record-access.html b/test-files/golden-tests/symbols/record/record-access.html
index fe9b3caf8..de5c0897c 100644
--- a/test-files/golden-tests/symbols/record/record-access.html
+++ b/test-files/golden-tests/symbols/record/record-access.html
@@ -34,9 +34,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-access.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class C0;
-
-</code>
+<code class="source-code cpp">class C0;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -91,9 +89,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-access.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -107,9 +103,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-access.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -123,9 +117,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-access.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -138,9 +130,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-access.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S0;
-
-</code>
+<code class="source-code cpp">struct S0;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -195,9 +185,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-access.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -211,9 +199,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-access.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -227,9 +213,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-access.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
@@ -242,9 +226,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-access.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">union U0;
-
-</code>
+<code class="source-code cpp">union U0;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -299,9 +281,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-access.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f0();
-
-</code>
+f0();</code>
 </pre>
 </div>
 </div>
@@ -315,9 +295,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-access.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f1();
-
-</code>
+f1();</code>
 </pre>
 </div>
 </div>
@@ -331,9 +309,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-access.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f2();
-
-</code>
+f2();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/record/record-data.html b/test-files/golden-tests/symbols/record/record-data.html
index ed8d14f0b..4c1780f74 100644
--- a/test-files/golden-tests/symbols/record/record-data.html
+++ b/test-files/golden-tests/symbols/record/record-data.html
@@ -36,9 +36,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T;
-
-</code>
+<code class="source-code cpp">struct T;</code>
 </pre>
 </div>
 <h2>Data Members</h2>
@@ -70,9 +68,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int i;
-
-</code>
+<code class="source-code cpp">int i;</code>
 </pre>
 </div>
 </div>
@@ -85,9 +81,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">double j;
-
-</code>
+<code class="source-code cpp">double j;</code>
 </pre>
 </div>
 </div>
@@ -101,9 +95,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">mutable
-int k;
-
-</code>
+int k;</code>
 </pre>
 </div>
 </div>
@@ -116,9 +108,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int l : 8;
-
-</code>
+<code class="source-code cpp">int l : 8;</code>
 </pre>
 </div>
 </div>
@@ -131,9 +121,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int m : 4 + 4;
-
-</code>
+<code class="source-code cpp">int m : 4 + 4;</code>
 </pre>
 </div>
 </div>
@@ -146,9 +134,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct U;
-
-</code>
+<code class="source-code cpp">struct U;</code>
 </pre>
 </div>
 <h2>Data Members</h2>
@@ -176,9 +162,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#T">T</a> t;
-
-</code>
+<code class="source-code cpp"><a href="#T">T</a> t;</code>
 </pre>
 </div>
 </div>
@@ -191,9 +175,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class V;
-
-</code>
+<code class="source-code cpp">class V;</code>
 </pre>
 </div>
 
@@ -235,9 +217,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">unsigned long j;
-
-</code>
+<code class="source-code cpp">unsigned long j;</code>
 </pre>
 </div>
 </div>
@@ -250,9 +230,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int i;
-
-</code>
+<code class="source-code cpp">int i;</code>
 </pre>
 </div>
 </div>
@@ -265,9 +243,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">double k;
-
-</code>
+<code class="source-code cpp">double k;</code>
 </pre>
 </div>
 </div>
@@ -280,9 +256,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct W;
-
-</code>
+<code class="source-code cpp">struct W;</code>
 </pre>
 </div>
 <h2>Data Members</h2>
@@ -310,9 +284,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">char buf[64];
-
-</code>
+<code class="source-code cpp">char buf[64];</code>
 </pre>
 </div>
 </div>
@@ -328,9 +300,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     typename P,
     int I&gt;
-struct X;
-
-</code>
+struct X;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -375,9 +345,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using Q = P;
-
-</code>
+<code class="source-code cpp">using Q = P;</code>
 </pre>
 </div>
 </div>
@@ -390,9 +358,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int x0 = 0;
-
-</code>
+<code class="source-code cpp">int x0 = 0;</code>
 </pre>
 </div>
 </div>
@@ -405,9 +371,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">P x1;
-
-</code>
+<code class="source-code cpp">P x1;</code>
 </pre>
 </div>
 </div>
@@ -420,9 +384,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">P const x2[32];
-
-</code>
+<code class="source-code cpp">P const x2[32];</code>
 </pre>
 </div>
 </div>
@@ -435,9 +397,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp"><a href="#X-Q">Q</a> x3;
-
-</code>
+<code class="source-code cpp"><a href="#X-Q">Q</a> x3;</code>
 </pre>
 </div>
 </div>
@@ -450,9 +410,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-data.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int x4 : I + 4;
-
-</code>
+<code class="source-code cpp">int x4 : I + 4;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/record/record-inheritance.html b/test-files/golden-tests/symbols/record/record-inheritance.html
index 1c5765150..58ec3b829 100644
--- a/test-files/golden-tests/symbols/record/record-inheritance.html
+++ b/test-files/golden-tests/symbols/record/record-inheritance.html
@@ -47,9 +47,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-inheritance.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class C0;
-
-</code>
+<code class="source-code cpp">class C0;</code>
 </pre>
 </div>
 
@@ -65,7 +63,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#C2"><code>C2</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -80,9 +78,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-inheritance.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">class C1
-    : <a href="#C0">C0</a>
-
-</code>
+    : <a href="#C0">C0</a></code>
 </pre>
 </div>
 
@@ -98,9 +94,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-inheritance.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">class C2
-    : public <a href="#C0">C0</a>
-
-</code>
+    : public <a href="#C0">C0</a></code>
 </pre>
 </div>
 <div>
@@ -113,7 +107,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#C0">C0</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#C0">C0</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -130,9 +124,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-inheritance.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">class C3
-    : protected <a href="#C0">C0</a>
-
-</code>
+    : protected <a href="#C0">C0</a></code>
 </pre>
 </div>
 <div>
@@ -145,7 +137,7 @@ <h2>Protected Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#C0">C0</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#C0">C0</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -162,9 +154,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-inheritance.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">class C4
-    : <a href="#C0">C0</a>
-
-</code>
+    : <a href="#C0">C0</a></code>
 </pre>
 </div>
 
@@ -180,9 +170,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-inheritance.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">class C5
-    : virtual <a href="#C0">C0</a>
-
-</code>
+    : virtual <a href="#C0">C0</a></code>
 </pre>
 </div>
 
@@ -198,7 +186,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#C7"><code>C7</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -213,9 +201,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-inheritance.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">class C6
-    : virtual <a href="#C1">C1</a>
-
-</code>
+    : virtual <a href="#C1">C1</a></code>
 </pre>
 </div>
 
@@ -231,7 +217,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#C7"><code>C7</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -247,9 +233,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">class C7
     : public <a href="#C5">C5</a>
-    , public <a href="#C6">C6</a>
-
-</code>
+    , public <a href="#C6">C6</a></code>
 </pre>
 </div>
 <div>
@@ -262,8 +246,8 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#C5">C5</a></code></td><td><span></span></td></tr>
-<tr><td><code><a href="#C6">C6</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#C5">C5</a></code></td><td></td></tr>
+<tr><td><code><a href="#C6">C6</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -279,9 +263,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-inheritance.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S0;
-
-</code>
+<code class="source-code cpp">struct S0;</code>
 </pre>
 </div>
 
@@ -297,7 +279,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#S2"><code>S2</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -311,9 +293,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-inheritance.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -329,7 +309,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#S3"><code>S3</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -344,9 +324,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-inheritance.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct S2
-    : <a href="#S0">S0</a>
-
-</code>
+    : <a href="#S0">S0</a></code>
 </pre>
 </div>
 <div>
@@ -359,7 +337,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0">S0</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0">S0</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -376,7 +354,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#S4"><code>S4</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -391,9 +369,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;record-inheritance.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct S3
-    : <a href="#S1">S1</a>
-
-</code>
+    : <a href="#S1">S1</a></code>
 </pre>
 </div>
 <div>
@@ -406,7 +382,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S1">S1</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S1">S1</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -423,7 +399,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#S4"><code>S4</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -439,9 +415,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">struct S4
     : <a href="#S2">S2</a>
-    , <a href="#S3">S3</a>
-
-</code>
+    , <a href="#S3">S3</a></code>
 </pre>
 </div>
 <div>
@@ -454,8 +428,8 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S2">S2</a></code></td><td><span></span></td></tr>
-<tr><td><code><a href="#S3">S3</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S2">S2</a></code></td><td></td></tr>
+<tr><td><code><a href="#S3">S3</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -473,9 +447,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">struct S5
     : private <a href="#S0">S0</a>
-    , protected <a href="#S1">S1</a>
-
-</code>
+    , protected <a href="#S1">S1</a></code>
 </pre>
 </div>
 <div>
@@ -488,7 +460,7 @@ <h2>Protected Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S1">S1</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S1">S1</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -506,9 +478,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename... Ts&gt;
 struct S6
-    : Ts...
-
-</code>
+    : Ts...</code>
 </pre>
 </div>
 <div>
@@ -521,7 +491,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code>Ts...</code></td><td><span></span></td></tr>
+<tr><td><code>Ts...</code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -537,9 +507,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;record-inheritance.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">union U0;
-
-</code>
+<code class="source-code cpp">union U0;</code>
 </pre>
 </div>
 
diff --git a/test-files/golden-tests/symbols/record/template-specialization-inheritance.html b/test-files/golden-tests/symbols/record/template-specialization-inheritance.html
index 1f831414e..5f6f76e31 100644
--- a/test-files/golden-tests/symbols/record/template-specialization-inheritance.html
+++ b/test-files/golden-tests/symbols/record/template-specialization-inheritance.html
@@ -42,9 +42,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;template-specialization-inheritance.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using U1 = <a href="#S0-0c">S0&lt;4&gt;</a>;
-
-</code>
+<code class="source-code cpp">using U1 = <a href="#S0-0c">S0&lt;4&gt;</a>;</code>
 </pre>
 </div>
 </div>
@@ -57,9 +55,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;template-specialization-inheritance.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using U2 = <a href="#S0-0e-S1">S0&lt;5&gt;::S1</a>;
-
-</code>
+<code class="source-code cpp">using U2 = <a href="#S0-0e-S1">S0&lt;5&gt;::S1</a>;</code>
 </pre>
 </div>
 </div>
@@ -72,9 +68,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;template-specialization-inheritance.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using U3 = <a href="#S0-07e">S0&lt;6&gt;</a>;
-
-</code>
+<code class="source-code cpp">using U3 = <a href="#S0-07e">S0&lt;6&gt;</a>;</code>
 </pre>
 </div>
 </div>
@@ -88,9 +82,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;template-specialization-inheritance.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R0
-    : <a href="#S0-0c">S0&lt;1&gt;</a>
-
-</code>
+    : <a href="#S0-0c">S0&lt;1&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -103,7 +95,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-0c">S0&lt;1&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-0c">S0&lt;1&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -133,9 +125,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;template-specialization-inheritance.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R1
-    : <a href="#S0-09-S1">S0&lt;2&gt;::S1</a>
-
-</code>
+    : <a href="#S0-09-S1">S0&lt;2&gt;::S1</a></code>
 </pre>
 </div>
 <div>
@@ -148,7 +138,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-09-S1">S0&lt;2&gt;::S1</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-09-S1">S0&lt;2&gt;::S1</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -165,9 +155,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;template-specialization-inheritance.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct R2
-    : <a href="#S0-073">S0&lt;3&gt;</a>
-
-</code>
+    : <a href="#S0-073">S0&lt;3&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -180,7 +168,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#S0-073">S0&lt;3&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#S0-073">S0&lt;3&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -199,9 +187,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     int I,
     typename T = void&gt;
-struct S0;
-
-</code>
+struct S0;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -230,7 +216,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R0"><code>R0</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -244,9 +230,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;template-specialization-inheritance.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -262,9 +246,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;template-specialization-inheritance.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0c">S0</a>&lt;2&gt;;
-
-</code>
+struct <a href="#S0-0c">S0</a>&lt;2&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -292,9 +274,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;template-specialization-inheritance.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -310,7 +290,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R1"><code>R1</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -325,9 +305,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;template-specialization-inheritance.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0c">S0</a>&lt;3&gt;;
-
-</code>
+struct <a href="#S0-0c">S0</a>&lt;3&gt;;</code>
 </pre>
 </div>
 
@@ -343,7 +321,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#R2"><code>R2</code></a>
-    </td><td><span></span></td></tr>
+    </td><td></td></tr>
 </tbody>
 </table>
 </div>
@@ -358,9 +336,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;template-specialization-inheritance.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0c">S0</a>&lt;5&gt;;
-
-</code>
+struct <a href="#S0-0c">S0</a>&lt;5&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -388,9 +364,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;template-specialization-inheritance.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -406,9 +380,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;template-specialization-inheritance.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-0c">S0</a>&lt;6&gt;;
-
-</code>
+struct <a href="#S0-0c">S0</a>&lt;6&gt;;</code>
 </pre>
 </div>
 
diff --git a/test-files/golden-tests/symbols/record/union.html b/test-files/golden-tests/symbols/record/union.html
index 73c865d34..1c6b7fe54 100644
--- a/test-files/golden-tests/symbols/record/union.html
+++ b/test-files/golden-tests/symbols/record/union.html
@@ -33,9 +33,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;union.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">union A;
-
-</code>
+<code class="source-code cpp">union A;</code>
 </pre>
 </div>
 <h2>Data Members</h2>
@@ -64,9 +62,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;union.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int x;
-
-</code>
+<code class="source-code cpp">int x;</code>
 </pre>
 </div>
 </div>
@@ -79,9 +75,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;union.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">bool y;
-
-</code>
+<code class="source-code cpp">bool y;</code>
 </pre>
 </div>
 </div>
@@ -94,9 +88,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;union.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct B;
-
-</code>
+<code class="source-code cpp">struct B;</code>
 </pre>
 </div>
 <h2>Data Members</h2>
@@ -126,9 +118,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;union.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int x;
-
-</code>
+<code class="source-code cpp">int x;</code>
 </pre>
 </div>
 </div>
@@ -141,9 +131,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;union.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">bool y;
-
-</code>
+<code class="source-code cpp">bool y;</code>
 </pre>
 </div>
 </div>
@@ -156,9 +144,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;union.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int z;
-
-</code>
+<code class="source-code cpp">int z;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/record/unnamed.html b/test-files/golden-tests/symbols/record/unnamed.html
index ed79330bd..b896bf0c2 100644
--- a/test-files/golden-tests/symbols/record/unnamed.html
+++ b/test-files/golden-tests/symbols/record/unnamed.html
@@ -19,8 +19,8 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#_01record-01"><code>Unnamed struct</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#_01record-0f"><code>Unnamed struct</code></a> </td><td><span>A test unnamed class.</span></td></tr>
+<td><a href="#_01record-01"><code>Unnamed struct</code></a> </td><td></td></tr><tr>
+<td><a href="#_01record-0f"><code>Unnamed struct</code></a> </td><td>A test unnamed class.</td></tr>
 </tbody>
 </table>
 
@@ -34,25 +34,23 @@ <h2>Variables</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#F"><code>F</code></a> </td><td><span></span></td></tr><tr>
-<td><a href="#x"><code>x</code></a> </td><td><span>A test variable named &#x27;x&#x27;</span></td></tr><tr>
-<td><a href="#y"><code>y</code></a> </td><td><span>A test variable named &#x27;y&#x27;</span></td></tr>
+<td><a href="#F"><code>F</code></a> </td><td></td></tr><tr>
+<td><a href="#x"><code>x</code></a> </td><td>A test variable named &#x27;x&#x27;</td></tr><tr>
+<td><a href="#y"><code>y</code></a> </td><td>A test variable named &#x27;y&#x27;</td></tr>
 </tbody>
 </table>
 
 </div>
 <div>
 <div>
-<h2 id="_01record-01"><a href="#_01record-01"></a></h2>
+<h2 id="_01record-01"></h2>
 </div>
 <div>
 <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;unnamed.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct Unnamed struct;
-
-</code>
+<code class="source-code cpp">struct Unnamed struct;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -73,7 +71,7 @@ <h2>Member Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="_01record-01-operator_call"><a href="#_01record-01-operator_call">::operator()</a></h2>
+<h2 id="_01record-01-operator_call">::operator()</h2>
 </div>
 <div>
 <h3>Synopsis</h3>
@@ -81,18 +79,15 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;unnamed.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-operator()() const;
-
-</code>
+operator()() const;</code>
 </pre>
 </div>
 </div>
 <div>
 <div>
-<h2 id="_01record-0f"><a href="#_01record-0f"></a></h2>
+<h2 id="_01record-0f"></h2>
 <div>
-<span>A test unnamed class.</span>
-
+<p>A test unnamed class.</p>
 </div>
 </div>
 <div>
@@ -100,9 +95,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;unnamed.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct Unnamed struct;
-
-</code>
+<code class="source-code cpp">struct Unnamed struct;</code>
 </pre>
 </div>
 <h2>Data Members</h2>
@@ -115,7 +108,7 @@ <h2>Data Members</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#_01record-0f-a"><code>a</code></a> </td><td><span>A test field.</span></td></tr>
+<td><a href="#_01record-0f-a"><code>a</code></a> </td><td>A test field.</td></tr>
 </tbody>
 </table>
 
@@ -124,10 +117,9 @@ <h2>Data Members</h2>
 </div>
 <div>
 <div>
-<h2 id="_01record-0f-a"><a href="#_01record-0f-a">::a</a></h2>
+<h2 id="_01record-0f-a">::a</h2>
 <div>
-<span>A test field.</span>
-
+<p>A test field.</p>
 </div>
 </div>
 <div>
@@ -135,9 +127,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;unnamed.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int a;
-
-</code>
+<code class="source-code cpp">int a;</code>
 </pre>
 </div>
 </div>
@@ -150,18 +140,15 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;unnamed.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">constexpr <a href="#_01record-01"></a> F = {};
-
-</code>
+<code class="source-code cpp">constexpr <a href="#_01record-01"></a> F = {};</code>
 </pre>
 </div>
 </div>
 <div>
 <div>
-<h2 id="x"><a href="#x">x</a></h2>
+<h2 id="x">x</h2>
 <div>
-<span>A test variable named &#x27;x&#x27;</span>
-
+<p>A test variable named &#x27;x&#x27;</p>
 </div>
 </div>
 <div>
@@ -170,18 +157,15 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;unnamed.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">extern
-<a href="#_01record-0f"></a> x;
-
-</code>
+<a href="#_01record-0f"></a> x;</code>
 </pre>
 </div>
 </div>
 <div>
 <div>
-<h2 id="y"><a href="#y">y</a></h2>
+<h2 id="y">y</h2>
 <div>
-<span>A test variable named &#x27;y&#x27;</span>
-
+<p>A test variable named &#x27;y&#x27;</p>
 </div>
 </div>
 <div>
@@ -190,9 +174,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;unnamed.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">extern
-<a href="#_01record-0f"></a> y;
-
-</code>
+<a href="#_01record-0f"></a> y;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/typedef/alias-template.html b/test-files/golden-tests/symbols/typedef/alias-template.html
index 64889d567..de4a161a9 100644
--- a/test-files/golden-tests/symbols/typedef/alias-template.html
+++ b/test-files/golden-tests/symbols/typedef/alias-template.html
@@ -36,9 +36,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;alias-template.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-using C = <a href="#A">A&lt;T&gt;</a>;
-
-</code>
+using C = <a href="#A">A&lt;T&gt;</a>;</code>
 </pre>
 </div>
 </div>
@@ -52,9 +50,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;alias-template.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 
@@ -72,9 +68,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">template&lt;
     typename T,
     typename U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 
@@ -90,9 +84,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;alias-template.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct D;
-
-</code>
+struct D;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -121,9 +113,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;alias-template.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-using E = <a href="#B">B&lt;T, U&gt;</a>;
-
-</code>
+using E = <a href="#B">B&lt;T, U&gt;</a>;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/typedef/decay-to-primary.html b/test-files/golden-tests/symbols/typedef/decay-to-primary.html
index f747caa70..4cbb001e7 100644
--- a/test-files/golden-tests/symbols/typedef/decay-to-primary.html
+++ b/test-files/golden-tests/symbols/typedef/decay-to-primary.html
@@ -36,9 +36,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;decay-to-primary.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using A0 = <a href="#S0-03">S0&lt;void&gt;</a>;
-
-</code>
+<code class="source-code cpp">using A0 = <a href="#S0-03">S0&lt;void&gt;</a>;</code>
 </pre>
 </div>
 </div>
@@ -51,9 +49,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;decay-to-primary.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using A1 = <a href="#S0-09-M0">A0::M1&lt;short&gt;::M0</a>;
-
-</code>
+<code class="source-code cpp">using A1 = <a href="#S0-09-M0">A0::M1&lt;short&gt;::M0</a>;</code>
 </pre>
 </div>
 </div>
@@ -67,9 +63,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;decay-to-primary.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct S0;
-
-</code>
+struct S0;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -98,9 +92,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;decay-to-primary.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using M0 = T;
-
-</code>
+<code class="source-code cpp">using M0 = T;</code>
 </pre>
 </div>
 </div>
@@ -114,9 +106,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;decay-to-primary.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-using M1 = <a href="#S0-03">S0&lt;U&gt;</a>;
-
-</code>
+using M1 = <a href="#S0-03">S0&lt;U&gt;</a>;</code>
 </pre>
 </div>
 </div>
@@ -130,9 +120,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;decay-to-primary.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-03">S0</a>&lt;void&gt;;
-
-</code>
+struct <a href="#S0-03">S0</a>&lt;void&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -161,9 +149,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;decay-to-primary.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using M0 = void;
-
-</code>
+<code class="source-code cpp">using M0 = void;</code>
 </pre>
 </div>
 </div>
@@ -177,9 +163,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;decay-to-primary.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-using M1 = <a href="#S0-03">S0&lt;U&gt;</a>;
-
-</code>
+using M1 = <a href="#S0-03">S0&lt;U&gt;</a>;</code>
 </pre>
 </div>
 </div>
@@ -193,9 +177,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;decay-to-primary.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-03">S0</a>&lt;short&gt;;
-
-</code>
+struct <a href="#S0-03">S0</a>&lt;short&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -224,9 +206,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;decay-to-primary.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using M0 = short;
-
-</code>
+<code class="source-code cpp">using M0 = short;</code>
 </pre>
 </div>
 </div>
@@ -240,9 +220,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;decay-to-primary.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-using M1 = <a href="#S0-03">S0&lt;U&gt;</a>;
-
-</code>
+using M1 = <a href="#S0-03">S0&lt;U&gt;</a>;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/typedef/dependency-propagation.html b/test-files/golden-tests/symbols/typedef/dependency-propagation.html
index ee3ddf82a..392f9981b 100644
--- a/test-files/golden-tests/symbols/typedef/dependency-propagation.html
+++ b/test-files/golden-tests/symbols/typedef/dependency-propagation.html
@@ -67,9 +67,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;dependency-propagation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-using B = <a href="#N-A">A&lt;T&gt;</a>;
-
-</code>
+using B = <a href="#N-A">A&lt;T&gt;</a>;</code>
 </pre>
 </div>
 </div>
@@ -83,9 +81,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;dependency-propagation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-using C = <a href="#N-B">B&lt;T&gt;</a>;
-
-</code>
+using C = <a href="#N-B">B&lt;T&gt;</a>;</code>
 </pre>
 </div>
 </div>
@@ -99,9 +95,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;dependency-propagation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 
@@ -116,9 +110,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;dependency-propagation.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct D;
-
-</code>
+<code class="source-code cpp">struct D;</code>
 </pre>
 </div>
 
@@ -134,9 +126,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;dependency-propagation.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct E
-    : <a href="#N-C">N::C&lt;int&gt;</a>
-
-</code>
+    : <a href="#N-C">N::C&lt;int&gt;</a></code>
 </pre>
 </div>
 <div>
@@ -149,7 +139,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#N-C">N::C&lt;int&gt;</a></code></td><td><span></span></td></tr>
+<tr><td><code><a href="#N-C">N::C&lt;int&gt;</a></code></td><td></td></tr>
 </tbody>
 </table>
 </div>
diff --git a/test-files/golden-tests/symbols/typedef/implicit-instantiation-member-ref.html b/test-files/golden-tests/symbols/typedef/implicit-instantiation-member-ref.html
index 9abefa38e..95104b2fa 100644
--- a/test-files/golden-tests/symbols/typedef/implicit-instantiation-member-ref.html
+++ b/test-files/golden-tests/symbols/typedef/implicit-instantiation-member-ref.html
@@ -35,9 +35,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;implicit-instantiation-member-ref.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using A5 = <a href="#S0-03">S0&lt;void&gt;</a>;
-
-</code>
+<code class="source-code cpp">using A5 = <a href="#S0-03">S0&lt;void&gt;</a>;</code>
 </pre>
 </div>
 </div>
@@ -50,9 +48,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;implicit-instantiation-member-ref.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using A9 = <a href="#S0-00-S2-02-M2">A5::S2&lt;char&gt;::M3&lt;int&gt;::M3&lt;unsigned int&gt;::M2</a>;
-
-</code>
+<code class="source-code cpp">using A9 = <a href="#S0-00-S2-02-M2">A5::S2&lt;char&gt;::M3&lt;int&gt;::M3&lt;unsigned int&gt;::M2</a>;</code>
 </pre>
 </div>
 </div>
@@ -66,9 +62,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;implicit-instantiation-member-ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct S0;
-
-</code>
+struct S0;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -97,9 +91,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;implicit-instantiation-member-ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct S2;
-
-</code>
+struct S2;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -128,9 +120,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;implicit-instantiation-member-ref.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using M2 = U;
-
-</code>
+<code class="source-code cpp">using M2 = U;</code>
 </pre>
 </div>
 </div>
@@ -144,9 +134,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;implicit-instantiation-member-ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename V&gt;
-using M3 = <a href="#S0-03-S2">S2&lt;U&gt;</a>;
-
-</code>
+using M3 = <a href="#S0-03-S2">S2&lt;U&gt;</a>;</code>
 </pre>
 </div>
 </div>
@@ -160,9 +148,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;implicit-instantiation-member-ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-03">S0</a>&lt;void&gt;;
-
-</code>
+struct <a href="#S0-03">S0</a>&lt;void&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -192,9 +178,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;implicit-instantiation-member-ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct S2;
-
-</code>
+struct S2;</code>
 </pre>
 </div>
 
@@ -210,9 +194,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;implicit-instantiation-member-ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#S0-03-S2">S2</a>&lt;char&gt;;
-
-</code>
+struct <a href="#S0-03-S2">S2</a>&lt;char&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -241,9 +223,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;implicit-instantiation-member-ref.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using M2 = char;
-
-</code>
+<code class="source-code cpp">using M2 = char;</code>
 </pre>
 </div>
 </div>
@@ -257,9 +237,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;implicit-instantiation-member-ref.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename V&gt;
-using M3 = <a href="#S0-00-S2-0d">S2&lt;char&gt;</a>;
-
-</code>
+using M3 = <a href="#S0-00-S2-0d">S2&lt;char&gt;</a>;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/using-directive/using-1.html b/test-files/golden-tests/symbols/using-directive/using-1.html
index a4295e1a3..2f5f591ed 100644
--- a/test-files/golden-tests/symbols/using-directive/using-1.html
+++ b/test-files/golden-tests/symbols/using-directive/using-1.html
@@ -67,9 +67,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-1.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 
diff --git a/test-files/golden-tests/symbols/using-enum/using-enum-in-ns.html b/test-files/golden-tests/symbols/using-enum/using-enum-in-ns.html
index 0b58c6fbd..185a41ec5 100644
--- a/test-files/golden-tests/symbols/using-enum/using-enum-in-ns.html
+++ b/test-files/golden-tests/symbols/using-enum/using-enum-in-ns.html
@@ -63,9 +63,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-enum-in-ns.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">enum class E : int;
-
-</code>
+<code class="source-code cpp">enum class E : int;</code>
 </pre>
 </div>
 <h2>Members</h2>
@@ -78,7 +76,7 @@ <h2>Members</h2>
 </thead>
 <tbody>
 <tr>
-<td><code>e1</code> </td><td><span>The constant to be introduced</span></td></tr>
+<td><code>e1</code> </td><td>The constant to be introduced</td></tr>
 </tbody>
 </table>
 
@@ -93,9 +91,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-enum-in-ns.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/using-enum/using-enum-in-record.html b/test-files/golden-tests/symbols/using-enum/using-enum-in-record.html
index c10b0f369..c82b82025 100644
--- a/test-files/golden-tests/symbols/using-enum/using-enum-in-record.html
+++ b/test-files/golden-tests/symbols/using-enum/using-enum-in-record.html
@@ -76,9 +76,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-enum-in-record.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">enum class E : int;
-
-</code>
+<code class="source-code cpp">enum class E : int;</code>
 </pre>
 </div>
 <h2>Members</h2>
@@ -91,7 +89,7 @@ <h2>Members</h2>
 </thead>
 <tbody>
 <tr>
-<td><code>e1</code> </td><td><span>The constant to be introduced</span></td></tr>
+<td><code>e1</code> </td><td>The constant to be introduced</td></tr>
 </tbody>
 </table>
 
@@ -105,9 +103,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-enum-in-record.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">class B;
-
-</code>
+<code class="source-code cpp">class B;</code>
 </pre>
 </div>
 
@@ -123,9 +119,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-enum-in-record.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/using/using-function-after.html b/test-files/golden-tests/symbols/using/using-function-after.html
index ae264b91b..427bb5e20 100644
--- a/test-files/golden-tests/symbols/using/using-function-after.html
+++ b/test-files/golden-tests/symbols/using/using-function-after.html
@@ -32,7 +32,7 @@ <h2>Using Declarations</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>f overloads are also available in the global namespace</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>f overloads are also available in the global namespace</td></tr>
 </tbody>
 </table>
 
@@ -51,7 +51,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-f-08"><code>f</code></a> </td><td><span><code>f</code> overloads</span></td></tr>
+<td><a href="#A-f-08"><code>f</code></a> </td><td><code>f</code> overloads</td></tr>
 </tbody>
 </table>
 
@@ -60,28 +60,23 @@ <h2>Functions</h2>
 <div>
 <h2 id="A-f-08">A::f</h2>
 <div>
-<span><code>f</code> overloads</span>
-
+<p><code>f</code> overloads</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;using-function-after.cpp&gt;</code></div>
-<span>A non-shadowing declaration</span>
+<p>A non-shadowing declaration</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#A-f-00">f</a>(char);
-
-</code>
+<a href="#A-f-00">f</a>(char);</code>
 </pre><span class="small"><a href="#A-f-00"><em>» more...</em></a></span>
 
-<span>A shadow declaration</span>
+<p>A shadow declaration</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#A-f-01">f</a>(int);
-
-</code>
+<a href="#A-f-01">f</a>(int);</code>
 </pre><span class="small"><a href="#A-f-01"><em>» more...</em></a></span>
 
 
@@ -91,8 +86,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="A-f-00">A::f</h2>
 <div>
-<span>A non-shadowing declaration</span>
-
+<p>A non-shadowing declaration</p>
 </div>
 </div>
 <div>
@@ -101,9 +95,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-function-after.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(char);
-
-</code>
+f(char);</code>
 </pre>
 </div>
 <div>
@@ -116,8 +108,7 @@ <h3>Description</h3>
 <div>
 <h2 id="A-f-01">A::f</h2>
 <div>
-<span>A shadow declaration</span>
-
+<p>A shadow declaration</p>
 </div>
 </div>
 <div>
@@ -126,9 +117,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-function-after.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(int);
-
-</code>
+f(int);</code>
 </pre>
 </div>
 </div>
@@ -136,8 +125,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>f overloads are also available in the global namespace</span>
-
+<p>f overloads are also available in the global namespace</p>
 </div>
 </div>
 <div>
@@ -145,9 +133,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-function-after.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using A::f;
-
-</code>
+<code class="source-code cpp">using A::f;</code>
 </pre>
 </div>
 <div>
@@ -162,7 +148,7 @@ <h3>Introduced Symbols</h3>
 <tbody>
 <tr>
 <td><a href="#A-f-01">A::f</a></td>
-<td><span>A shadow declaration</span></td>
+<td>A shadow declaration</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/symbols/using/using-function-and-type.html b/test-files/golden-tests/symbols/using/using-function-and-type.html
index 4dc3a5ddd..ff574f1b1 100644
--- a/test-files/golden-tests/symbols/using/using-function-and-type.html
+++ b/test-files/golden-tests/symbols/using/using-function-and-type.html
@@ -32,7 +32,7 @@ <h2>Using Declarations</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>A using declaration that shadows a function and the record.</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>A using declaration that shadows a function and the record.</td></tr>
 </tbody>
 </table>
 
@@ -51,7 +51,7 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-f-05"><code>f</code></a> </td><td><span>A record</span></td></tr>
+<td><a href="#A-f-05"><code>f</code></a> </td><td>A record</td></tr>
 </tbody>
 </table>
 
@@ -65,7 +65,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-f-01"><code>f</code></a> </td><td><span>A function</span></td></tr>
+<td><a href="#A-f-01"><code>f</code></a> </td><td>A function</td></tr>
 </tbody>
 </table>
 
@@ -74,8 +74,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="A-f-05">A::f</h2>
 <div>
-<span>A record</span>
-
+<p>A record</p>
 </div>
 </div>
 <div>
@@ -83,9 +82,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-function-and-type.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct f;
-
-</code>
+<code class="source-code cpp">struct f;</code>
 </pre>
 </div>
 
@@ -95,8 +92,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="A-f-01">A::f</h2>
 <div>
-<span>A function</span>
-
+<p>A function</p>
 </div>
 </div>
 <div>
@@ -105,9 +101,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-function-and-type.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(int);
-
-</code>
+f(int);</code>
 </pre>
 </div>
 </div>
@@ -115,8 +109,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>A using declaration that shadows a function and the record.</span>
-
+<p>A using declaration that shadows a function and the record.</p>
 </div>
 </div>
 <div>
@@ -124,9 +117,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-function-and-type.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using A::f;
-
-</code>
+<code class="source-code cpp">using A::f;</code>
 </pre>
 </div>
 <div>
@@ -141,11 +132,11 @@ <h3>Introduced Symbols</h3>
 <tbody>
 <tr>
 <td><a href="#A-f-05">A::f</a></td>
-<td><span>A record</span></td>
+<td>A record</td>
 </tr>
 <tr>
 <td><a href="#A-f-01">A::f</a></td>
-<td><span>A function</span></td>
+<td>A function</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/symbols/using/using-function-excluded.html b/test-files/golden-tests/symbols/using/using-function-excluded.html
index 3eb65e4b5..6f1bf0cbf 100644
--- a/test-files/golden-tests/symbols/using/using-function-excluded.html
+++ b/test-files/golden-tests/symbols/using/using-function-excluded.html
@@ -19,7 +19,7 @@ <h2>Using Declarations</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>Using excluded function f</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>Using excluded function f</td></tr>
 </tbody>
 </table>
 
@@ -28,8 +28,7 @@ <h2>Using Declarations</h2>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>Using excluded function f</span>
-
+<p>Using excluded function f</p>
 </div>
 </div>
 <div>
@@ -37,9 +36,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-function-excluded.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using A::f;
-
-</code>
+<code class="source-code cpp">using A::f;</code>
 </pre>
 </div>
 <div>
diff --git a/test-files/golden-tests/symbols/using/using-function-local-overloads.html b/test-files/golden-tests/symbols/using/using-function-local-overloads.html
index 01f590816..310694770 100644
--- a/test-files/golden-tests/symbols/using/using-function-local-overloads.html
+++ b/test-files/golden-tests/symbols/using/using-function-local-overloads.html
@@ -32,7 +32,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f-0f"><code>f</code></a> </td><td><span>Local overload</span></td></tr>
+<td><a href="#f-0f"><code>f</code></a> </td><td>Local overload</td></tr>
 </tbody>
 </table>
 
@@ -64,7 +64,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-f-08"><code>f</code></a> </td><td><span><code>f</code> overloads</span></td></tr>
+<td><a href="#A-f-08"><code>f</code></a> </td><td><code>f</code> overloads</td></tr>
 </tbody>
 </table>
 
@@ -73,38 +73,31 @@ <h2>Functions</h2>
 <div>
 <h2 id="A-f-08">A::f</h2>
 <div>
-<span><code>f</code> overloads</span>
-
+<p><code>f</code> overloads</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;using-function-local-overloads.cpp&gt;</code></div>
-<span>Second overload</span>
+<p>Second overload</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#A-f-039">f</a>();
-
-</code>
+<a href="#A-f-039">f</a>();</code>
 </pre><span class="small"><a href="#A-f-039"><em>» more...</em></a></span>
 
-<span>First overload</span>
+<p>First overload</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#A-f-01">f</a>(int);
-
-</code>
+<a href="#A-f-01">f</a>(int);</code>
 </pre><span class="small"><a href="#A-f-01"><em>» more...</em></a></span>
 
-<span>Third overload</span>
+<p>Third overload</p>
 <pre>
 <code class="source-code cpp">void
 <a href="#A-f-037">f</a>(
     char,
-    char);
-
-</code>
+    char);</code>
 </pre><span class="small"><a href="#A-f-037"><em>» more...</em></a></span>
 
 
@@ -114,8 +107,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="A-f-039">A::f</h2>
 <div>
-<span>Second overload</span>
-
+<p>Second overload</p>
 </div>
 </div>
 <div>
@@ -124,9 +116,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-function-local-overloads.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -134,8 +124,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="A-f-01">A::f</h2>
 <div>
-<span>First overload</span>
-
+<p>First overload</p>
 </div>
 </div>
 <div>
@@ -144,9 +133,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-function-local-overloads.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(int);
-
-</code>
+f(int);</code>
 </pre>
 </div>
 </div>
@@ -154,8 +141,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="A-f-037">A::f</h2>
 <div>
-<span>Third overload</span>
-
+<p>Third overload</p>
 </div>
 </div>
 <div>
@@ -166,9 +152,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">void
 f(
     char,
-    char);
-
-</code>
+    char);</code>
 </pre>
 </div>
 </div>
@@ -176,8 +160,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f-0f">f</h2>
 <div>
-<span>Local overload</span>
-
+<p>Local overload</p>
 </div>
 </div>
 <div>
@@ -186,9 +169,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-function-local-overloads.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(double);
-
-</code>
+f(double);</code>
 </pre>
 </div>
 </div>
@@ -201,9 +182,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-function-local-overloads.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using A::f;
-
-</code>
+<code class="source-code cpp">using A::f;</code>
 </pre>
 </div>
 <div>
@@ -218,7 +197,7 @@ <h3>Introduced Symbols</h3>
 <tbody>
 <tr>
 <td><a href="#A-f-08">A::f</a></td>
-<td><span><code>f</code> overloads</span></td>
+<td><code>f</code> overloads</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/symbols/using/using-function-overloads.html b/test-files/golden-tests/symbols/using/using-function-overloads.html
index d8843388c..5f7ca2c1e 100644
--- a/test-files/golden-tests/symbols/using/using-function-overloads.html
+++ b/test-files/golden-tests/symbols/using/using-function-overloads.html
@@ -32,7 +32,7 @@ <h2>Using Declarations</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>Using the overloads from namespace A</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>Using the overloads from namespace A</td></tr>
 </tbody>
 </table>
 
@@ -51,7 +51,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-f-08"><code>f</code></a> </td><td><span><code>f</code> overloads</span></td></tr>
+<td><a href="#A-f-08"><code>f</code></a> </td><td><code>f</code> overloads</td></tr>
 </tbody>
 </table>
 
@@ -60,38 +60,31 @@ <h2>Functions</h2>
 <div>
 <h2 id="A-f-08">A::f</h2>
 <div>
-<span><code>f</code> overloads</span>
-
+<p><code>f</code> overloads</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;using-function-overloads.cpp&gt;</code></div>
-<span>Second overload</span>
+<p>Second overload</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#A-f-039">f</a>();
-
-</code>
+<a href="#A-f-039">f</a>();</code>
 </pre><span class="small"><a href="#A-f-039"><em>» more...</em></a></span>
 
-<span>First overload</span>
+<p>First overload</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#A-f-01">f</a>(int);
-
-</code>
+<a href="#A-f-01">f</a>(int);</code>
 </pre><span class="small"><a href="#A-f-01"><em>» more...</em></a></span>
 
-<span>Third overload</span>
+<p>Third overload</p>
 <pre>
 <code class="source-code cpp">void
 <a href="#A-f-037">f</a>(
     char,
-    char);
-
-</code>
+    char);</code>
 </pre><span class="small"><a href="#A-f-037"><em>» more...</em></a></span>
 
 
@@ -101,8 +94,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="A-f-039">A::f</h2>
 <div>
-<span>Second overload</span>
-
+<p>Second overload</p>
 </div>
 </div>
 <div>
@@ -111,9 +103,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-function-overloads.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -121,8 +111,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="A-f-01">A::f</h2>
 <div>
-<span>First overload</span>
-
+<p>First overload</p>
 </div>
 </div>
 <div>
@@ -131,9 +120,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-function-overloads.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(int);
-
-</code>
+f(int);</code>
 </pre>
 </div>
 </div>
@@ -141,8 +128,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="A-f-037">A::f</h2>
 <div>
-<span>Third overload</span>
-
+<p>Third overload</p>
 </div>
 </div>
 <div>
@@ -153,9 +139,7 @@ <h3>Synopsis</h3>
 <code class="source-code cpp">void
 f(
     char,
-    char);
-
-</code>
+    char);</code>
 </pre>
 </div>
 </div>
@@ -163,8 +147,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>Using the overloads from namespace A</span>
-
+<p>Using the overloads from namespace A</p>
 </div>
 </div>
 <div>
@@ -172,9 +155,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-function-overloads.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using A::f;
-
-</code>
+<code class="source-code cpp">using A::f;</code>
 </pre>
 </div>
 <div>
@@ -189,7 +170,7 @@ <h3>Introduced Symbols</h3>
 <tbody>
 <tr>
 <td><a href="#A-f-08">A::f</a></td>
-<td><span><code>f</code> overloads</span></td>
+<td><code>f</code> overloads</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/symbols/using/using-function.html b/test-files/golden-tests/symbols/using/using-function.html
index 0db8ae859..8be038c76 100644
--- a/test-files/golden-tests/symbols/using/using-function.html
+++ b/test-files/golden-tests/symbols/using/using-function.html
@@ -32,7 +32,7 @@ <h2>Using Declarations</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f"><code>f</code></a> </td><td><span>f is also available in the global namespace</span></td></tr>
+<td><a href="#f"><code>f</code></a> </td><td>f is also available in the global namespace</td></tr>
 </tbody>
 </table>
 
@@ -51,7 +51,7 @@ <h2>Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-f"><code>f</code></a> </td><td><span>Function being used</span></td></tr>
+<td><a href="#A-f"><code>f</code></a> </td><td>Function being used</td></tr>
 </tbody>
 </table>
 
@@ -60,8 +60,7 @@ <h2>Functions</h2>
 <div>
 <h2 id="A-f">A::f</h2>
 <div>
-<span>Function being used</span>
-
+<p>Function being used</p>
 </div>
 </div>
 <div>
@@ -70,9 +69,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-function.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(int);
-
-</code>
+f(int);</code>
 </pre>
 </div>
 </div>
@@ -80,8 +77,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="f">f</h2>
 <div>
-<span>f is also available in the global namespace</span>
-
+<p>f is also available in the global namespace</p>
 </div>
 </div>
 <div>
@@ -89,9 +85,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using A::f;
-
-</code>
+<code class="source-code cpp">using A::f;</code>
 </pre>
 </div>
 <div>
@@ -106,7 +100,7 @@ <h3>Introduced Symbols</h3>
 <tbody>
 <tr>
 <td><a href="#A-f">A::f</a></td>
-<td><span>Function being used</span></td>
+<td>Function being used</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/symbols/using/using-member-conversion.html b/test-files/golden-tests/symbols/using/using-member-conversion.html
index 401abf5a7..3a84fcbd2 100644
--- a/test-files/golden-tests/symbols/using/using-member-conversion.html
+++ b/test-files/golden-tests/symbols/using/using-member-conversion.html
@@ -19,9 +19,9 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#X"><code>X</code></a> </td><td><span>This struct will be inherited as public</span></td></tr><tr>
-<td><a href="#Y"><code>Y</code></a> </td><td><span>This struct inherits from X</span></td></tr><tr>
-<td><a href="#fun_ptr"><code>fun_ptr</code></a> </td><td><span>A pointer to function typedef</span></td></tr>
+<td><a href="#X"><code>X</code></a> </td><td>This struct will be inherited as public</td></tr><tr>
+<td><a href="#Y"><code>Y</code></a> </td><td>This struct inherits from X</td></tr><tr>
+<td><a href="#fun_ptr"><code>fun_ptr</code></a> </td><td>A pointer to function typedef</td></tr>
 </tbody>
 </table>
 
@@ -30,8 +30,7 @@ <h2>Types</h2>
 <div>
 <h2 id="fun_ptr">fun_ptr</h2>
 <div>
-<span>A pointer to function typedef</span>
-
+<p>A pointer to function typedef</p>
 </div>
 </div>
 <div>
@@ -39,9 +38,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-conversion.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using fun_ptr = void(*)();
-
-</code>
+<code class="source-code cpp">using fun_ptr = void(*)();</code>
 </pre>
 </div>
 </div>
@@ -49,8 +46,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="X">X</h2>
 <div>
-<span>This struct will be inherited as public</span>
-
+<p>This struct will be inherited as public</p>
 </div>
 </div>
 <div>
@@ -58,9 +54,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-conversion.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct X;
-
-</code>
+<code class="source-code cpp">struct X;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -73,7 +67,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#X-2conversion"><code>operator fun_ptr</code></a> </td><td><span>Conversion operator to function pointer.</span></td></tr>
+<td><a href="#X-2conversion"><code>operator fun_ptr</code></a> </td><td>Conversion operator to function pointer.</td></tr>
 </tbody>
 </table>
 
@@ -90,7 +84,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#Y"><code>Y</code></a>
-    </td><td><span>This struct inherits from X</span></td></tr>
+    </td><td>This struct inherits from X</td></tr>
 </tbody>
 </table>
 </div>
@@ -99,8 +93,7 @@ <h2>Derived Classes</h2>
 <div>
 <h2 id="X-2conversion">X::operator fun_ptr</h2>
 <div>
-<span>Conversion operator to function pointer.</span>
-
+<p>Conversion operator to function pointer.</p>
 </div>
 </div>
 <div>
@@ -108,22 +101,19 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-conversion.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">operator <a href="#fun_ptr">fun_ptr</a>() const;
-
-</code>
+<code class="source-code cpp">operator <a href="#fun_ptr">fun_ptr</a>() const;</code>
 </pre>
 </div>
 <div>
 <h3>Return Value</h3>
-<span>A pointer to function typedef</span>
+A pointer to function typedef
 </div>
 </div>
 <div>
 <div>
 <h2 id="Y">Y</h2>
 <div>
-<span>This struct inherits from X</span>
-
+<p>This struct inherits from X</p>
 </div>
 </div>
 <div>
@@ -132,9 +122,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-member-conversion.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">struct Y
-    : <a href="#X">X</a>
-
-</code>
+    : <a href="#X">X</a></code>
 </pre>
 </div>
 <div>
@@ -147,7 +135,7 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#X">X</a></code></td><td><span>This struct will be inherited as public</span></td></tr>
+<tr><td><code><a href="#X">X</a></code></td><td>This struct will be inherited as public</td></tr>
 </tbody>
 </table>
 </div>
@@ -161,7 +149,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#X-2conversion"><code>operator fun_ptr</code></a> </td><td><span>Conversion operator to function pointer.</span></td></tr>
+<td><a href="#X-2conversion"><code>operator fun_ptr</code></a> </td><td>Conversion operator to function pointer.</td></tr>
 </tbody>
 </table>
 
@@ -175,7 +163,7 @@ <h2>Using Declarations</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#Y-2conversion"><code>operator void(*)()</code></a> </td><td><span>Bring X::operator fun_ptr into Y.</span></td></tr>
+<td><a href="#Y-2conversion"><code>operator void(*)()</code></a> </td><td>Bring X::operator fun_ptr into Y.</td></tr>
 </tbody>
 </table>
 
@@ -186,8 +174,7 @@ <h2>Using Declarations</h2>
 <div>
 <h2 id="Y-2conversion">Y::operator void(*)()</h2>
 <div>
-<span>Bring X::operator fun_ptr into Y.</span>
-
+<p>Bring X::operator fun_ptr into Y.</p>
 </div>
 </div>
 <div>
@@ -195,9 +182,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-conversion.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using X::operator void(*)();
-
-</code>
+<code class="source-code cpp">using X::operator void(*)();</code>
 </pre>
 </div>
 <div>
@@ -212,7 +197,7 @@ <h3>Introduced Symbols</h3>
 <tbody>
 <tr>
 <td><a href="#X-2conversion">X::operator fun_ptr</a></td>
-<td><span>Conversion operator to function pointer.</span></td>
+<td>Conversion operator to function pointer.</td>
 </tr>
 </tbody>
 </table>
diff --git a/test-files/golden-tests/symbols/using/using-member-function.html b/test-files/golden-tests/symbols/using/using-member-function.html
index 08320e940..af587c006 100644
--- a/test-files/golden-tests/symbols/using/using-member-function.html
+++ b/test-files/golden-tests/symbols/using/using-member-function.html
@@ -19,14 +19,14 @@ <h2>Types</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A"><code>A</code></a> </td><td><span>This struct will be inherited as public</span></td></tr><tr>
-<td><a href="#B"><code>B</code></a> </td><td><span>This struct will be inherited as public</span></td></tr><tr>
-<td><a href="#C"><code>C</code></a> </td><td><span>This struct will be inherited as protected</span></td></tr><tr>
-<td><a href="#D"><code>D</code></a> </td><td><span>This struct will be inherited as protected</span></td></tr><tr>
-<td><a href="#E"><code>E</code></a> </td><td><span>This struct will be inherited as private</span></td></tr><tr>
-<td><a href="#F"><code>F</code></a> </td><td><span>This struct will be inherited as private</span></td></tr><tr>
-<td><a href="#Tag"><code>Tag</code></a> </td><td><span>A tag template to create distinct f functions.</span></td></tr><tr>
-<td><a href="#U"><code>U</code></a> </td><td><span>This struct inherits from A, B, C, D, E, and F in various ways,</span></td></tr>
+<td><a href="#A"><code>A</code></a> </td><td>This struct will be inherited as public</td></tr><tr>
+<td><a href="#B"><code>B</code></a> </td><td>This struct will be inherited as public</td></tr><tr>
+<td><a href="#C"><code>C</code></a> </td><td>This struct will be inherited as protected</td></tr><tr>
+<td><a href="#D"><code>D</code></a> </td><td>This struct will be inherited as protected</td></tr><tr>
+<td><a href="#E"><code>E</code></a> </td><td>This struct will be inherited as private</td></tr><tr>
+<td><a href="#F"><code>F</code></a> </td><td>This struct will be inherited as private</td></tr><tr>
+<td><a href="#Tag"><code>Tag</code></a> </td><td>A tag template to create distinct f functions.</td></tr><tr>
+<td><a href="#U"><code>U</code></a> </td><td>This struct inherits from A, B, C, D, E, and F in various ways,</td></tr>
 </tbody>
 </table>
 
@@ -35,8 +35,7 @@ <h2>Types</h2>
 <div>
 <h2 id="A">A</h2>
 <div>
-<span>This struct will be inherited as public</span>
-
+<p>This struct will be inherited as public</p>
 </div>
 </div>
 <div>
@@ -44,9 +43,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -59,7 +56,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-f"><code>f</code></a> </td><td><span>Public member function f taking a Tag&lt;0&gt;.</span></td></tr>
+<td><a href="#A-f"><code>f</code></a> </td><td>Public member function f taking a Tag&lt;0&gt;.</td></tr>
 </tbody>
 </table>
 
@@ -76,7 +73,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#U"><code>U</code></a>
-    </td><td><span>This struct inherits from A, B, C, D, E, and F in various ways,</span></td></tr>
+    </td><td>This struct inherits from A, B, C, D, E, and F in various ways,</td></tr>
 </tbody>
 </table>
 </div>
@@ -85,8 +82,7 @@ <h2>Derived Classes</h2>
 <div>
 <h2 id="A-f">A::f</h2>
 <div>
-<span>Public member function f taking a Tag&lt;0&gt;.</span>
-
+<p>Public member function f taking a Tag&lt;0&gt;.</p>
 </div>
 </div>
 <div>
@@ -95,9 +91,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#Tag">Tag&lt;0&gt;</a>);
-
-</code>
+f(<a href="#Tag">Tag&lt;0&gt;</a>);</code>
 </pre>
 </div>
 <div>
@@ -109,8 +103,7 @@ <h3>Description</h3>
 <div>
 <h2 id="B">B</h2>
 <div>
-<span>This struct will be inherited as public</span>
-
+<p>This struct will be inherited as public</p>
 </div>
 </div>
 <div>
@@ -118,9 +111,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct B;
-
-</code>
+<code class="source-code cpp">struct B;</code>
 </pre>
 </div>
 
@@ -134,7 +125,7 @@ <h2>Protected Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#B-f"><code>f</code></a> </td><td><span>Protected member function f taking a Tag&lt;1&gt;.</span></td></tr>
+<td><a href="#B-f"><code>f</code></a> </td><td>Protected member function f taking a Tag&lt;1&gt;.</td></tr>
 </tbody>
 </table>
 
@@ -150,7 +141,7 @@ <h2>Derived Classes</h2>
 </thead>
 <tbody>
 <tr><td><a href="#U"><code>U</code></a>
-    </td><td><span>This struct inherits from A, B, C, D, E, and F in various ways,</span></td></tr>
+    </td><td>This struct inherits from A, B, C, D, E, and F in various ways,</td></tr>
 </tbody>
 </table>
 </div>
@@ -159,8 +150,7 @@ <h2>Derived Classes</h2>
 <div>
 <h2 id="B-f">B::f</h2>
 <div>
-<span>Protected member function f taking a Tag&lt;1&gt;.</span>
-
+<p>Protected member function f taking a Tag&lt;1&gt;.</p>
 </div>
 </div>
 <div>
@@ -169,9 +159,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#Tag">Tag&lt;1&gt;</a>);
-
-</code>
+f(<a href="#Tag">Tag&lt;1&gt;</a>);</code>
 </pre>
 </div>
 </div>
@@ -179,8 +167,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="C">C</h2>
 <div>
-<span>This struct will be inherited as protected</span>
-
+<p>This struct will be inherited as protected</p>
 </div>
 </div>
 <div>
@@ -188,9 +175,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct C;
-
-</code>
+<code class="source-code cpp">struct C;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -203,7 +188,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#C-f"><code>f</code></a> </td><td><span>Public member function f taking a Tag&lt;2&gt;.</span></td></tr>
+<td><a href="#C-f"><code>f</code></a> </td><td>Public member function f taking a Tag&lt;2&gt;.</td></tr>
 </tbody>
 </table>
 
@@ -214,8 +199,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="C-f">C::f</h2>
 <div>
-<span>Public member function f taking a Tag&lt;2&gt;.</span>
-
+<p>Public member function f taking a Tag&lt;2&gt;.</p>
 </div>
 </div>
 <div>
@@ -224,9 +208,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#Tag">Tag&lt;2&gt;</a>);
-
-</code>
+f(<a href="#Tag">Tag&lt;2&gt;</a>);</code>
 </pre>
 </div>
 </div>
@@ -234,8 +216,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="D">D</h2>
 <div>
-<span>This struct will be inherited as protected</span>
-
+<p>This struct will be inherited as protected</p>
 </div>
 </div>
 <div>
@@ -243,9 +224,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct D;
-
-</code>
+<code class="source-code cpp">struct D;</code>
 </pre>
 </div>
 
@@ -259,7 +238,7 @@ <h2>Protected Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#D-f"><code>f</code></a> </td><td><span>Protected member function f taking a Tag&lt;3&gt;.</span></td></tr>
+<td><a href="#D-f"><code>f</code></a> </td><td>Protected member function f taking a Tag&lt;3&gt;.</td></tr>
 </tbody>
 </table>
 
@@ -269,8 +248,7 @@ <h2>Protected Member Functions</h2>
 <div>
 <h2 id="D-f">D::f</h2>
 <div>
-<span>Protected member function f taking a Tag&lt;3&gt;.</span>
-
+<p>Protected member function f taking a Tag&lt;3&gt;.</p>
 </div>
 </div>
 <div>
@@ -279,9 +257,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#Tag">Tag&lt;3&gt;</a>);
-
-</code>
+f(<a href="#Tag">Tag&lt;3&gt;</a>);</code>
 </pre>
 </div>
 </div>
@@ -289,8 +265,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="E">E</h2>
 <div>
-<span>This struct will be inherited as private</span>
-
+<p>This struct will be inherited as private</p>
 </div>
 </div>
 <div>
@@ -298,9 +273,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct E;
-
-</code>
+<code class="source-code cpp">struct E;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -313,7 +286,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#E-f"><code>f</code></a> </td><td><span>Public member function f taking a Tag&lt;4&gt;.</span></td></tr>
+<td><a href="#E-f"><code>f</code></a> </td><td>Public member function f taking a Tag&lt;4&gt;.</td></tr>
 </tbody>
 </table>
 
@@ -324,8 +297,7 @@ <h2>Member Functions</h2>
 <div>
 <h2 id="E-f">E::f</h2>
 <div>
-<span>Public member function f taking a Tag&lt;4&gt;.</span>
-
+<p>Public member function f taking a Tag&lt;4&gt;.</p>
 </div>
 </div>
 <div>
@@ -334,9 +306,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#Tag">Tag&lt;4&gt;</a>);
-
-</code>
+f(<a href="#Tag">Tag&lt;4&gt;</a>);</code>
 </pre>
 </div>
 </div>
@@ -344,8 +314,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="F">F</h2>
 <div>
-<span>This struct will be inherited as private</span>
-
+<p>This struct will be inherited as private</p>
 </div>
 </div>
 <div>
@@ -353,9 +322,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct F;
-
-</code>
+<code class="source-code cpp">struct F;</code>
 </pre>
 </div>
 
@@ -369,7 +336,7 @@ <h2>Protected Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#F-f"><code>f</code></a> </td><td><span>Protected member function f taking a Tag&lt;5&gt;.</span></td></tr>
+<td><a href="#F-f"><code>f</code></a> </td><td>Protected member function f taking a Tag&lt;5&gt;.</td></tr>
 </tbody>
 </table>
 
@@ -379,8 +346,7 @@ <h2>Protected Member Functions</h2>
 <div>
 <h2 id="F-f">F::f</h2>
 <div>
-<span>Protected member function f taking a Tag&lt;5&gt;.</span>
-
+<p>Protected member function f taking a Tag&lt;5&gt;.</p>
 </div>
 </div>
 <div>
@@ -389,9 +355,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#Tag">Tag&lt;5&gt;</a>);
-
-</code>
+f(<a href="#Tag">Tag&lt;5&gt;</a>);</code>
 </pre>
 </div>
 </div>
@@ -399,8 +363,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="Tag">Tag</h2>
 <div>
-<span>A tag template to create distinct f functions.</span>
-
+<p>A tag template to create distinct f functions.</p>
 </div>
 </div>
 <div>
@@ -409,9 +372,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;int idx&gt;
-struct Tag;
-
-</code>
+struct Tag;</code>
 </pre>
 </div>
 
@@ -421,8 +382,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="U">U</h2>
 <div>
-<span>This struct inherits from A, B, C, D, E, and F in various ways,</span>
-
+<p>This struct inherits from A, B, C, D, E, and F in various ways,</p>
 </div>
 </div>
 <div>
@@ -434,9 +394,7 @@ <h3>Synopsis</h3>
     : <a href="#A">A</a>
     , <a href="#B">B</a>
     , protected <a href="#C">C</a>
-    , protected <a href="#D">D</a>
-
-</code>
+    , protected <a href="#D">D</a></code>
 </pre>
 </div>
 <div>
@@ -449,8 +407,8 @@ <h2>Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#A">A</a></code></td><td><span>This struct will be inherited as public</span></td></tr>
-<tr><td><code><a href="#B">B</a></code></td><td><span>This struct will be inherited as public</span></td></tr>
+<tr><td><code><a href="#A">A</a></code></td><td>This struct will be inherited as public</td></tr>
+<tr><td><code><a href="#B">B</a></code></td><td>This struct will be inherited as public</td></tr>
 </tbody>
 </table>
 </div>
@@ -464,8 +422,8 @@ <h2>Protected Base Classes</h2>
 </tr>
 </thead>
 <tbody>
-<tr><td><code><a href="#C">C</a></code></td><td><span>This struct will be inherited as protected</span></td></tr>
-<tr><td><code><a href="#D">D</a></code></td><td><span>This struct will be inherited as protected</span></td></tr>
+<tr><td><code><a href="#C">C</a></code></td><td>This struct will be inherited as protected</td></tr>
+<tr><td><code><a href="#D">D</a></code></td><td>This struct will be inherited as protected</td></tr>
 </tbody>
 </table>
 </div>
@@ -479,7 +437,7 @@ <h2>Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-f"><code>f</code></a> </td><td><span>Public member function f taking a Tag&lt;0&gt;.</span></td></tr>
+<td><a href="#A-f"><code>f</code></a> </td><td>Public member function f taking a Tag&lt;0&gt;.</td></tr>
 </tbody>
 </table>
 
@@ -493,18 +451,18 @@ <h2>Using Declarations</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#U-U-0a"><code>U</code></a> </td><td><span>Bring all the A::A constructors into U.</span></td></tr><tr>
-<td><a href="#U-U-01b"><code>U</code></a> </td><td><span>Bring all the B::B constructors into U.</span></td></tr><tr>
-<td><a href="#U-U-01d"><code>U</code></a> </td><td><span>Bring all the C::C constructors into U.</span></td></tr><tr>
-<td><a href="#U-U-0c"><code>U</code></a> </td><td><span>Bring all the D::D constructors into U.</span></td></tr><tr>
-<td><a href="#U-U-04"><code>U</code></a> </td><td><span>Bring all the E::E constructors into U.</span></td></tr><tr>
-<td><a href="#U-U-06"><code>U</code></a> </td><td><span>Bring all the F::F constructors into U.</span></td></tr><tr>
-<td><a href="#U-f-00c"><code>f</code></a> </td><td><span>Bring all the A::f functions into U.</span></td></tr><tr>
-<td><a href="#U-f-0be"><code>f</code></a> </td><td><span>Bring all the B::f functions into U.</span></td></tr><tr>
-<td><a href="#U-f-0f"><code>f</code></a> </td><td><span>Bring all the C::f functions into U.</span></td></tr><tr>
-<td><a href="#U-f-009"><code>f</code></a> </td><td><span>Bring all the D::f functions into U.</span></td></tr><tr>
-<td><a href="#U-f-0bd"><code>f</code></a> </td><td><span>Bring all the E::f functions into U.</span></td></tr><tr>
-<td><a href="#U-f-02"><code>f</code></a> </td><td><span>Bring all the F::f functions into U.</span></td></tr>
+<td><a href="#U-U-0a"><code>U</code></a> </td><td>Bring all the A::A constructors into U.</td></tr><tr>
+<td><a href="#U-U-01b"><code>U</code></a> </td><td>Bring all the B::B constructors into U.</td></tr><tr>
+<td><a href="#U-U-01d"><code>U</code></a> </td><td>Bring all the C::C constructors into U.</td></tr><tr>
+<td><a href="#U-U-0c"><code>U</code></a> </td><td>Bring all the D::D constructors into U.</td></tr><tr>
+<td><a href="#U-U-04"><code>U</code></a> </td><td>Bring all the E::E constructors into U.</td></tr><tr>
+<td><a href="#U-U-06"><code>U</code></a> </td><td>Bring all the F::F constructors into U.</td></tr><tr>
+<td><a href="#U-f-00c"><code>f</code></a> </td><td>Bring all the A::f functions into U.</td></tr><tr>
+<td><a href="#U-f-0be"><code>f</code></a> </td><td>Bring all the B::f functions into U.</td></tr><tr>
+<td><a href="#U-f-0f"><code>f</code></a> </td><td>Bring all the C::f functions into U.</td></tr><tr>
+<td><a href="#U-f-009"><code>f</code></a> </td><td>Bring all the D::f functions into U.</td></tr><tr>
+<td><a href="#U-f-0bd"><code>f</code></a> </td><td>Bring all the E::f functions into U.</td></tr><tr>
+<td><a href="#U-f-02"><code>f</code></a> </td><td>Bring all the F::f functions into U.</td></tr>
 </tbody>
 </table>
 
@@ -519,7 +477,7 @@ <h2>Protected Member Functions</h2>
 </thead>
 <tbody>
 <tr>
-<td><a href="#U-f-07"><code>f</code></a> </td><td><span><code>f</code> overloads</span></td></tr>
+<td><a href="#U-f-07"><code>f</code></a> </td><td><code>f</code> overloads</td></tr>
 </tbody>
 </table>
 
@@ -533,8 +491,7 @@ <h3>Description</h3>
 <div>
 <h2 id="U-U-0a">U::U</h2>
 <div>
-<span>Bring all the A::A constructors into U.</span>
-
+<p>Bring all the A::A constructors into U.</p>
 </div>
 </div>
 <div>
@@ -542,9 +499,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using A::U;
-
-</code>
+<code class="source-code cpp">using A::U;</code>
 </pre>
 </div>
 </div>
@@ -552,8 +507,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="U-U-01b">U::U</h2>
 <div>
-<span>Bring all the B::B constructors into U.</span>
-
+<p>Bring all the B::B constructors into U.</p>
 </div>
 </div>
 <div>
@@ -561,9 +515,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using B::U;
-
-</code>
+<code class="source-code cpp">using B::U;</code>
 </pre>
 </div>
 </div>
@@ -571,8 +523,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="U-U-01d">U::U</h2>
 <div>
-<span>Bring all the C::C constructors into U.</span>
-
+<p>Bring all the C::C constructors into U.</p>
 </div>
 </div>
 <div>
@@ -580,9 +531,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using C::U;
-
-</code>
+<code class="source-code cpp">using C::U;</code>
 </pre>
 </div>
 </div>
@@ -590,8 +539,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="U-U-0c">U::U</h2>
 <div>
-<span>Bring all the D::D constructors into U.</span>
-
+<p>Bring all the D::D constructors into U.</p>
 </div>
 </div>
 <div>
@@ -599,9 +547,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using D::U;
-
-</code>
+<code class="source-code cpp">using D::U;</code>
 </pre>
 </div>
 </div>
@@ -609,8 +555,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="U-U-04">U::U</h2>
 <div>
-<span>Bring all the E::E constructors into U.</span>
-
+<p>Bring all the E::E constructors into U.</p>
 </div>
 </div>
 <div>
@@ -618,9 +563,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using E::U;
-
-</code>
+<code class="source-code cpp">using E::U;</code>
 </pre>
 </div>
 </div>
@@ -628,8 +571,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="U-U-06">U::U</h2>
 <div>
-<span>Bring all the F::F constructors into U.</span>
-
+<p>Bring all the F::F constructors into U.</p>
 </div>
 </div>
 <div>
@@ -637,9 +579,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using F::U;
-
-</code>
+<code class="source-code cpp">using F::U;</code>
 </pre>
 </div>
 </div>
@@ -647,8 +587,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="U-f-00c">U::f</h2>
 <div>
-<span>Bring all the A::f functions into U.</span>
-
+<p>Bring all the A::f functions into U.</p>
 </div>
 </div>
 <div>
@@ -656,9 +595,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using A::f;
-
-</code>
+<code class="source-code cpp">using A::f;</code>
 </pre>
 </div>
 <div>
@@ -673,7 +610,7 @@ <h3>Introduced Symbols</h3>
 <tbody>
 <tr>
 <td><a href="#A-f">A::f</a></td>
-<td><span>Public member function f taking a Tag&lt;0&gt;.</span></td>
+<td>Public member function f taking a Tag&lt;0&gt;.</td>
 </tr>
 </tbody>
 </table>
@@ -684,8 +621,7 @@ <h3>Introduced Symbols</h3>
 <div>
 <h2 id="U-f-0be">U::f</h2>
 <div>
-<span>Bring all the B::f functions into U.</span>
-
+<p>Bring all the B::f functions into U.</p>
 </div>
 </div>
 <div>
@@ -693,9 +629,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using B::f;
-
-</code>
+<code class="source-code cpp">using B::f;</code>
 </pre>
 </div>
 <div>
@@ -710,7 +644,7 @@ <h3>Introduced Symbols</h3>
 <tbody>
 <tr>
 <td><a href="#B-f">B::f</a></td>
-<td><span>Protected member function f taking a Tag&lt;1&gt;.</span></td>
+<td>Protected member function f taking a Tag&lt;1&gt;.</td>
 </tr>
 </tbody>
 </table>
@@ -721,8 +655,7 @@ <h3>Introduced Symbols</h3>
 <div>
 <h2 id="U-f-0f">U::f</h2>
 <div>
-<span>Bring all the C::f functions into U.</span>
-
+<p>Bring all the C::f functions into U.</p>
 </div>
 </div>
 <div>
@@ -730,9 +663,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using C::f;
-
-</code>
+<code class="source-code cpp">using C::f;</code>
 </pre>
 </div>
 <div>
@@ -747,7 +678,7 @@ <h3>Introduced Symbols</h3>
 <tbody>
 <tr>
 <td><a href="#C-f">C::f</a></td>
-<td><span>Public member function f taking a Tag&lt;2&gt;.</span></td>
+<td>Public member function f taking a Tag&lt;2&gt;.</td>
 </tr>
 </tbody>
 </table>
@@ -758,8 +689,7 @@ <h3>Introduced Symbols</h3>
 <div>
 <h2 id="U-f-009">U::f</h2>
 <div>
-<span>Bring all the D::f functions into U.</span>
-
+<p>Bring all the D::f functions into U.</p>
 </div>
 </div>
 <div>
@@ -767,9 +697,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using D::f;
-
-</code>
+<code class="source-code cpp">using D::f;</code>
 </pre>
 </div>
 <div>
@@ -784,7 +712,7 @@ <h3>Introduced Symbols</h3>
 <tbody>
 <tr>
 <td><a href="#D-f">D::f</a></td>
-<td><span>Protected member function f taking a Tag&lt;3&gt;.</span></td>
+<td>Protected member function f taking a Tag&lt;3&gt;.</td>
 </tr>
 </tbody>
 </table>
@@ -795,8 +723,7 @@ <h3>Introduced Symbols</h3>
 <div>
 <h2 id="U-f-0bd">U::f</h2>
 <div>
-<span>Bring all the E::f functions into U.</span>
-
+<p>Bring all the E::f functions into U.</p>
 </div>
 </div>
 <div>
@@ -804,9 +731,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using E::f;
-
-</code>
+<code class="source-code cpp">using E::f;</code>
 </pre>
 </div>
 <div>
@@ -821,7 +746,7 @@ <h3>Introduced Symbols</h3>
 <tbody>
 <tr>
 <td><a href="#E-f">E::f</a></td>
-<td><span>Public member function f taking a Tag&lt;4&gt;.</span></td>
+<td>Public member function f taking a Tag&lt;4&gt;.</td>
 </tr>
 </tbody>
 </table>
@@ -832,8 +757,7 @@ <h3>Introduced Symbols</h3>
 <div>
 <h2 id="U-f-02">U::f</h2>
 <div>
-<span>Bring all the F::f functions into U.</span>
-
+<p>Bring all the F::f functions into U.</p>
 </div>
 </div>
 <div>
@@ -841,9 +765,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using F::f;
-
-</code>
+<code class="source-code cpp">using F::f;</code>
 </pre>
 </div>
 <div>
@@ -858,7 +780,7 @@ <h3>Introduced Symbols</h3>
 <tbody>
 <tr>
 <td><a href="#F-f">F::f</a></td>
-<td><span>Protected member function f taking a Tag&lt;5&gt;.</span></td>
+<td>Protected member function f taking a Tag&lt;5&gt;.</td>
 </tr>
 </tbody>
 </table>
@@ -869,36 +791,29 @@ <h3>Introduced Symbols</h3>
 <div>
 <h2 id="U-f-07">U::f</h2>
 <div>
-<span><code>f</code> overloads</span>
-
+<p><code>f</code> overloads</p>
 </div>
 </div>
 <div>
 <h3>Synopses</h3>
 <div>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
-<span>Protected member function f taking a Tag&lt;1&gt;.</span>
+<p>Protected member function f taking a Tag&lt;1&gt;.</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#B-f">f</a>(<a href="#Tag">Tag&lt;1&gt;</a>);
-
-</code>
+<a href="#B-f">f</a>(<a href="#Tag">Tag&lt;1&gt;</a>);</code>
 </pre><span class="small"><a href="#B-f"><em>» more...</em></a></span>
 
-<span>Public member function f taking a Tag&lt;2&gt;.</span>
+<p>Public member function f taking a Tag&lt;2&gt;.</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#C-f">f</a>(<a href="#Tag">Tag&lt;2&gt;</a>);
-
-</code>
+<a href="#C-f">f</a>(<a href="#Tag">Tag&lt;2&gt;</a>);</code>
 </pre><span class="small"><a href="#C-f"><em>» more...</em></a></span>
 
-<span>Protected member function f taking a Tag&lt;3&gt;.</span>
+<p>Protected member function f taking a Tag&lt;3&gt;.</p>
 <pre>
 <code class="source-code cpp">void
-<a href="#D-f">f</a>(<a href="#Tag">Tag&lt;3&gt;</a>);
-
-</code>
+<a href="#D-f">f</a>(<a href="#Tag">Tag&lt;3&gt;</a>);</code>
 </pre><span class="small"><a href="#D-f"><em>» more...</em></a></span>
 
 
@@ -908,8 +823,7 @@ <h3>Synopses</h3>
 <div>
 <h2 id="B-f">B::f</h2>
 <div>
-<span>Protected member function f taking a Tag&lt;1&gt;.</span>
-
+<p>Protected member function f taking a Tag&lt;1&gt;.</p>
 </div>
 </div>
 <div>
@@ -918,9 +832,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#Tag">Tag&lt;1&gt;</a>);
-
-</code>
+f(<a href="#Tag">Tag&lt;1&gt;</a>);</code>
 </pre>
 </div>
 </div>
@@ -928,8 +840,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="C-f">C::f</h2>
 <div>
-<span>Public member function f taking a Tag&lt;2&gt;.</span>
-
+<p>Public member function f taking a Tag&lt;2&gt;.</p>
 </div>
 </div>
 <div>
@@ -938,9 +849,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#Tag">Tag&lt;2&gt;</a>);
-
-</code>
+f(<a href="#Tag">Tag&lt;2&gt;</a>);</code>
 </pre>
 </div>
 </div>
@@ -948,8 +857,7 @@ <h3>Synopsis</h3>
 <div>
 <h2 id="D-f">D::f</h2>
 <div>
-<span>Protected member function f taking a Tag&lt;3&gt;.</span>
-
+<p>Protected member function f taking a Tag&lt;3&gt;.</p>
 </div>
 </div>
 <div>
@@ -958,9 +866,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-member-function.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(<a href="#Tag">Tag&lt;3&gt;</a>);
-
-</code>
+f(<a href="#Tag">Tag&lt;3&gt;</a>);</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/using/using-multi.html b/test-files/golden-tests/symbols/using/using-multi.html
index 9c491c5bc..fd2ddca94 100644
--- a/test-files/golden-tests/symbols/using/using-multi.html
+++ b/test-files/golden-tests/symbols/using/using-multi.html
@@ -66,9 +66,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-multi.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(int);
-
-</code>
+f(int);</code>
 </pre>
 </div>
 </div>
@@ -82,9 +80,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-multi.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g(int);
-
-</code>
+g(int);</code>
 </pre>
 </div>
 </div>
@@ -97,9 +93,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-multi.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using A::f;
-
-</code>
+<code class="source-code cpp">using A::f;</code>
 </pre>
 </div>
 <div>
@@ -128,9 +122,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-multi.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using A::g;
-
-</code>
+<code class="source-code cpp">using A::g;</code>
 </pre>
 </div>
 <div>
diff --git a/test-files/golden-tests/symbols/using/using-struct-template.html b/test-files/golden-tests/symbols/using/using-struct-template.html
index 595ab3f20..46fe2b539 100644
--- a/test-files/golden-tests/symbols/using/using-struct-template.html
+++ b/test-files/golden-tests/symbols/using/using-struct-template.html
@@ -65,9 +65,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-struct-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -82,9 +80,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-struct-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S2;
-
-</code>
+<code class="source-code cpp">struct S2;</code>
 </pre>
 </div>
 
@@ -99,9 +95,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-struct-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using LongName::S1;
-
-</code>
+<code class="source-code cpp">using LongName::S1;</code>
 </pre>
 </div>
 <div>
@@ -130,9 +124,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-struct-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using LongName::S2;
-
-</code>
+<code class="source-code cpp">using LongName::S2;</code>
 </pre>
 </div>
 <div>
diff --git a/test-files/golden-tests/symbols/using/using-struct.html b/test-files/golden-tests/symbols/using/using-struct.html
index ab8036949..6d545ecae 100644
--- a/test-files/golden-tests/symbols/using/using-struct.html
+++ b/test-files/golden-tests/symbols/using/using-struct.html
@@ -65,9 +65,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-struct.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S1;
-
-</code>
+<code class="source-code cpp">struct S1;</code>
 </pre>
 </div>
 
@@ -82,9 +80,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-struct.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S2;
-
-</code>
+<code class="source-code cpp">struct S2;</code>
 </pre>
 </div>
 
@@ -99,9 +95,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-struct.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using LongName::S1;
-
-</code>
+<code class="source-code cpp">using LongName::S1;</code>
 </pre>
 </div>
 <div>
@@ -130,9 +124,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-struct.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using LongName::S2;
-
-</code>
+<code class="source-code cpp">using LongName::S2;</code>
 </pre>
 </div>
 <div>
diff --git a/test-files/golden-tests/symbols/using/using-template-function.html b/test-files/golden-tests/symbols/using/using-template-function.html
index 9b429bb33..72d220417 100644
--- a/test-files/golden-tests/symbols/using/using-template-function.html
+++ b/test-files/golden-tests/symbols/using/using-template-function.html
@@ -64,9 +64,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-template-function.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f(int);
-
-</code>
+f(int);</code>
 </pre>
 </div>
 </div>
@@ -79,9 +77,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-template-function.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using A::f;
-
-</code>
+<code class="source-code cpp">using A::f;</code>
 </pre>
 </div>
 <div>
diff --git a/test-files/golden-tests/symbols/using/using-typename.html b/test-files/golden-tests/symbols/using/using-typename.html
index 78afc6b1e..9f4514c06 100644
--- a/test-files/golden-tests/symbols/using/using-typename.html
+++ b/test-files/golden-tests/symbols/using/using-typename.html
@@ -34,9 +34,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-typename.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class T&gt;
-class Base;
-
-</code>
+class Base;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -64,9 +62,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;using-typename.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">using V = T;
-
-</code>
+<code class="source-code cpp">using V = T;</code>
 </pre>
 </div>
 </div>
@@ -80,9 +76,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;using-typename.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class T&gt;
-class Derived;
-
-</code>
+class Derived;</code>
 </pre>
 </div>
 
diff --git a/test-files/golden-tests/symbols/variable/no_unique_address.html b/test-files/golden-tests/symbols/variable/no_unique_address.html
index cfd38a0b4..83afba793 100644
--- a/test-files/golden-tests/symbols/variable/no_unique_address.html
+++ b/test-files/golden-tests/symbols/variable/no_unique_address.html
@@ -33,9 +33,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;no_unique_address.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct Empty;
-
-</code>
+<code class="source-code cpp">struct Empty;</code>
 </pre>
 </div>
 
@@ -50,9 +48,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;no_unique_address.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T;
-
-</code>
+<code class="source-code cpp">struct T;</code>
 </pre>
 </div>
 <h2>Data Members</h2>
@@ -82,9 +78,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no_unique_address.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">[[deprecated, maybe_unused]]
-<a href="#Empty">Empty</a> e = Empty{};
-
-</code>
+<a href="#Empty">Empty</a> e = Empty{};</code>
 </pre>
 </div>
 </div>
@@ -97,9 +91,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;no_unique_address.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int i;
-
-</code>
+<code class="source-code cpp">int i;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/variable/ns-variables.html b/test-files/golden-tests/symbols/variable/ns-variables.html
index 60f0156a8..04d02b979 100644
--- a/test-files/golden-tests/symbols/variable/ns-variables.html
+++ b/test-files/golden-tests/symbols/variable/ns-variables.html
@@ -53,9 +53,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;ns-variables.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T;
-
-</code>
+<code class="source-code cpp">struct T;</code>
 </pre>
 </div>
 
@@ -70,9 +68,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;ns-variables.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">constexpr int i = 0;
-
-</code>
+<code class="source-code cpp">constexpr int i = 0;</code>
 </pre>
 </div>
 </div>
@@ -85,9 +81,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;ns-variables.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int j = 0;
-
-</code>
+<code class="source-code cpp">int j = 0;</code>
 </pre>
 </div>
 </div>
@@ -101,9 +95,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ns-variables.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">constexpr extern
-int k = 1;
-
-</code>
+int k = 1;</code>
 </pre>
 </div>
 </div>
@@ -117,9 +109,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ns-variables.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">extern
-int l = 1;
-
-</code>
+int l = 1;</code>
 </pre>
 </div>
 </div>
@@ -132,9 +122,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;ns-variables.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">double pi = 3.14;
-
-</code>
+<code class="source-code cpp">double pi = 3.14;</code>
 </pre>
 </div>
 </div>
@@ -148,9 +136,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ns-variables.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">extern
-<a href="#T">T</a> t;
-
-</code>
+<a href="#T">T</a> t;</code>
 </pre>
 </div>
 </div>
@@ -164,9 +150,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ns-variables.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">thread_local
-int x0 = 0;
-
-</code>
+int x0 = 0;</code>
 </pre>
 </div>
 </div>
@@ -181,9 +165,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">static
 thread_local
-int x1 = 0;
-
-</code>
+int x1 = 0;</code>
 </pre>
 </div>
 </div>
@@ -198,9 +180,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">constexpr static
 thread_local
-int x2 = 0;
-
-</code>
+int x2 = 0;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/variable/static-data-def-constexpr.html b/test-files/golden-tests/symbols/variable/static-data-def-constexpr.html
index c72e144fd..df41117a6 100644
--- a/test-files/golden-tests/symbols/variable/static-data-def-constexpr.html
+++ b/test-files/golden-tests/symbols/variable/static-data-def-constexpr.html
@@ -33,9 +33,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;static-data-def-constexpr.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct S;
-
-</code>
+<code class="source-code cpp">struct S;</code>
 </pre>
 </div>
 <h2>Static Data Members</h2>
@@ -64,9 +62,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;static-data-def-constexpr.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">inline constexpr static
-<a href="#S">S</a> s = S{};
-
-</code>
+<a href="#S">S</a> s = S{};</code>
 </pre>
 </div>
 </div>
@@ -79,9 +75,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;static-data-def-constexpr.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct T;
-
-</code>
+<code class="source-code cpp">struct T;</code>
 </pre>
 </div>
 <h2>Static Data Members</h2>
@@ -110,9 +104,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;static-data-def-constexpr.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">inline constexpr static
-int t = 0;
-
-</code>
+int t = 0;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/variable/static-data-def.html b/test-files/golden-tests/symbols/variable/static-data-def.html
index 18df33ed5..f44909394 100644
--- a/test-files/golden-tests/symbols/variable/static-data-def.html
+++ b/test-files/golden-tests/symbols/variable/static-data-def.html
@@ -47,9 +47,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;static-data-def.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 <h2>Static Data Members</h2>
@@ -85,9 +83,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;static-data-def.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">static
-int v0 = 0;
-
-</code>
+int v0 = 0;</code>
 </pre>
 </div>
 </div>
@@ -101,9 +97,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;static-data-def.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">inline static
-int v1 = 1;
-
-</code>
+int v1 = 1;</code>
 </pre>
 </div>
 </div>
@@ -117,9 +111,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;static-data-def.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">inline constexpr static
-int v2 = 2;
-
-</code>
+int v2 = 2;</code>
 </pre>
 </div>
 </div>
@@ -133,9 +125,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;static-data-def.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">inline static
-int const v3 = 3;
-
-</code>
+int const v3 = 3;</code>
 </pre>
 </div>
 </div>
@@ -149,9 +139,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;static-data-def.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">static
-int const v4 = 4;
-
-</code>
+int const v4 = 4;</code>
 </pre>
 </div>
 </div>
@@ -165,9 +153,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;static-data-def.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">inline static
-int v5 = 5;
-
-</code>
+int v5 = 5;</code>
 </pre>
 </div>
 </div>
@@ -181,9 +167,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;static-data-def.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">inline static
-int const v6 = 6;
-
-</code>
+int const v6 = 6;</code>
 </pre>
 </div>
 </div>
@@ -197,9 +181,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;static-data-def.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">inline constexpr static
-int v7 = 7;
-
-</code>
+int v7 = 7;</code>
 </pre>
 </div>
 </div>
@@ -212,9 +194,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;static-data-def.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct B;
-
-</code>
+<code class="source-code cpp">struct B;</code>
 </pre>
 </div>
 <h2>Static Data Members</h2>
@@ -245,9 +225,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">static
 thread_local
-int const x0 = 0;
-
-</code>
+int const x0 = 0;</code>
 </pre>
 </div>
 </div>
@@ -262,9 +240,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">inline constexpr static
 thread_local
-int x1 = 0;
-
-</code>
+int x1 = 0;</code>
 </pre>
 </div>
 </div>
@@ -278,9 +254,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;static-data-def.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">auto
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/variable/static-data-template.html b/test-files/golden-tests/symbols/variable/static-data-template.html
index 8b201ee43..856943ab5 100644
--- a/test-files/golden-tests/symbols/variable/static-data-template.html
+++ b/test-files/golden-tests/symbols/variable/static-data-template.html
@@ -33,9 +33,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;static-data-template.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 <h2>Static Data Members</h2>
@@ -69,9 +67,7 @@ <h3>Synopsis</h3>
     typename U,
     typename V&gt;
 inline constexpr static
-T x = 0;
-
-</code>
+T x = 0;</code>
 </pre>
 </div>
 </div>
@@ -86,9 +82,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
 inline constexpr static
-bool x&lt;T, long&gt; = 2;
-
-</code>
+bool x&lt;T, long&gt; = 2;</code>
 </pre>
 </div>
 </div>
@@ -103,9 +97,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
 inline constexpr static
-T x&lt;U*, T&gt; = 1;
-
-</code>
+T x&lt;U*, T&gt; = 1;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/variable/var-inline-constexpr.html b/test-files/golden-tests/symbols/variable/var-inline-constexpr.html
index a2dbe268b..e68cc5ce9 100644
--- a/test-files/golden-tests/symbols/variable/var-inline-constexpr.html
+++ b/test-files/golden-tests/symbols/variable/var-inline-constexpr.html
@@ -41,9 +41,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;var-inline-constexpr.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int var = 5;
-
-</code>
+<code class="source-code cpp">int var = 5;</code>
 </pre>
 </div>
 </div>
@@ -56,9 +54,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;var-inline-constexpr.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">int const var_const = 4;
-
-</code>
+<code class="source-code cpp">int const var_const = 4;</code>
 </pre>
 </div>
 </div>
@@ -72,9 +68,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;var-inline-constexpr.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class T&gt;
-T const var_const_t;
-
-</code>
+T const var_const_t;</code>
 </pre>
 </div>
 </div>
@@ -87,9 +81,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;var-inline-constexpr.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">constexpr int var_constexpr = 2;
-
-</code>
+<code class="source-code cpp">constexpr int var_constexpr = 2;</code>
 </pre>
 </div>
 </div>
@@ -103,9 +95,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;var-inline-constexpr.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class T&gt;
-constexpr T var_constexpr_t;
-
-</code>
+constexpr T var_constexpr_t;</code>
 </pre>
 </div>
 </div>
@@ -118,9 +108,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;var-inline-constexpr.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">inline int const var_inline_const = 3;
-
-</code>
+<code class="source-code cpp">inline int const var_inline_const = 3;</code>
 </pre>
 </div>
 </div>
@@ -134,9 +122,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;var-inline-constexpr.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class T&gt;
-inline T const var_inline_const_t;
-
-</code>
+inline T const var_inline_const_t;</code>
 </pre>
 </div>
 </div>
@@ -149,9 +135,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;var-inline-constexpr.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">inline constexpr int var_inline_constexpr = 1;
-
-</code>
+<code class="source-code cpp">inline constexpr int var_inline_constexpr = 1;</code>
 </pre>
 </div>
 </div>
@@ -165,9 +149,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;var-inline-constexpr.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class T&gt;
-inline constexpr T var_inline_constexpr_t;
-
-</code>
+inline constexpr T var_inline_constexpr_t;</code>
 </pre>
 </div>
 </div>
@@ -181,9 +163,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;var-inline-constexpr.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;class T&gt;
-T var_t;
-
-</code>
+T var_t;</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/symbols/variable/var-template.html b/test-files/golden-tests/symbols/variable/var-template.html
index ea25d99e2..0aa8c9815 100644
--- a/test-files/golden-tests/symbols/variable/var-template.html
+++ b/test-files/golden-tests/symbols/variable/var-template.html
@@ -47,9 +47,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;var-template.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct B;
-
-</code>
+<code class="source-code cpp">struct B;</code>
 </pre>
 </div>
 <h2>Static Data Members</h2>
@@ -81,9 +79,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
 inline static
-unsigned int C = 0;
-
-</code>
+unsigned int C = 0;</code>
 </pre>
 </div>
 </div>
@@ -98,9 +94,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
 inline static
-unsigned int C&lt;int&gt; = -1;
-
-</code>
+unsigned int C&lt;int&gt; = -1;</code>
 </pre>
 </div>
 </div>
@@ -115,9 +109,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
 inline static
-unsigned int C&lt;T*&gt; = sizeof(T);
-
-</code>
+unsigned int C&lt;T*&gt; = sizeof(T);</code>
 </pre>
 </div>
 </div>
@@ -131,9 +123,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;var-template.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-unsigned int A = sizeof(T);
-
-</code>
+unsigned int A = sizeof(T);</code>
 </pre>
 </div>
 </div>
@@ -147,9 +137,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;var-template.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-unsigned int A&lt;void&gt; = 0;
-
-</code>
+unsigned int A&lt;void&gt; = 0;</code>
 </pre>
 </div>
 </div>
@@ -163,9 +151,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;var-template.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-unsigned int A&lt;T&&gt; = sizeof(T);
-
-</code>
+unsigned int A&lt;T&&gt; = sizeof(T);</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/templates/c_mct_expl_inline.html b/test-files/golden-tests/templates/c_mct_expl_inline.html
index e1890e8d6..d6f1285da 100644
--- a/test-files/golden-tests/templates/c_mct_expl_inline.html
+++ b/test-files/golden-tests/templates/c_mct_expl_inline.html
@@ -32,9 +32,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;c_mct_expl_inline.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -64,9 +62,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;c_mct_expl_inline.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -95,9 +91,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;c_mct_expl_inline.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -111,9 +105,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;c_mct_expl_inline.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-B-04">B</a>&lt;int&gt;;
-
-</code>
+struct <a href="#A-B-04">B</a>&lt;int&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -142,9 +134,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;c_mct_expl_inline.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/templates/c_mct_expl_outside.html b/test-files/golden-tests/templates/c_mct_expl_outside.html
index 6b8fcd3de..f4feccf05 100644
--- a/test-files/golden-tests/templates/c_mct_expl_outside.html
+++ b/test-files/golden-tests/templates/c_mct_expl_outside.html
@@ -32,9 +32,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;c_mct_expl_outside.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -64,9 +62,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;c_mct_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -95,9 +91,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;c_mct_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -111,9 +105,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;c_mct_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-B-04">B</a>&lt;int&gt;;
-
-</code>
+struct <a href="#A-B-04">B</a>&lt;int&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -142,9 +134,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;c_mct_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/templates/c_mft_expl_inline.adoc b/test-files/golden-tests/templates/c_mft_expl_inline.adoc
index 32c273f5c..6df23d7c3 100644
--- a/test-files/golden-tests/templates/c_mft_expl_inline.adoc
+++ b/test-files/golden-tests/templates/c_mft_expl_inline.adoc
@@ -26,12 +26,10 @@ struct A;
 
 === Member Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#A-f-07[`f`] 
-| 
 |===
 
 [#A-f-07]
diff --git a/test-files/golden-tests/templates/c_mft_expl_inline.html b/test-files/golden-tests/templates/c_mft_expl_inline.html
index f310f8428..8f6b172df 100644
--- a/test-files/golden-tests/templates/c_mft_expl_inline.html
+++ b/test-files/golden-tests/templates/c_mft_expl_inline.html
@@ -32,9 +32,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;c_mft_expl_inline.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -42,12 +40,11 @@ <h2>Member Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-f-07"><code>f</code></a> </td><td><span></span></td></tr>
+<td><a href="#A-f-07"><code>f</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -66,18 +63,14 @@ <h3>Synopses</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
 void
-<a href="#A-f-0e">f</a>();
-
-</code>
+<a href="#A-f-0e">f</a>();</code>
 </pre><span class="small"><a href="#A-f-0e"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">template&lt;&gt;
 void
-<a href="#A-f-0b">f&lt;int&gt;</a>();
-
-</code>
+<a href="#A-f-0b">f&lt;int&gt;</a>();</code>
 </pre><span class="small"><a href="#A-f-0b"><em>» more...</em></a></span>
 
 
@@ -94,9 +87,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
 void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -111,9 +102,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
 void
-<a href="#A-f-0e">f</a>&lt;int&gt;();
-
-</code>
+<a href="#A-f-0e">f</a>&lt;int&gt;();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/templates/c_mft_expl_outside.adoc b/test-files/golden-tests/templates/c_mft_expl_outside.adoc
index fe046ad0d..21efd6b0a 100644
--- a/test-files/golden-tests/templates/c_mft_expl_outside.adoc
+++ b/test-files/golden-tests/templates/c_mft_expl_outside.adoc
@@ -26,12 +26,10 @@ struct A;
 
 === Member Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#A-f-07[`f`] 
-| 
 |===
 
 [#A-f-07]
diff --git a/test-files/golden-tests/templates/c_mft_expl_outside.html b/test-files/golden-tests/templates/c_mft_expl_outside.html
index 2e5d76e68..d82026e46 100644
--- a/test-files/golden-tests/templates/c_mft_expl_outside.html
+++ b/test-files/golden-tests/templates/c_mft_expl_outside.html
@@ -32,9 +32,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;c_mft_expl_outside.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct A;
-
-</code>
+<code class="source-code cpp">struct A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -42,12 +40,11 @@ <h2>Member Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-f-07"><code>f</code></a> </td><td><span></span></td></tr>
+<td><a href="#A-f-07"><code>f</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -66,18 +63,14 @@ <h3>Synopses</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
 void
-<a href="#A-f-0e">f</a>();
-
-</code>
+<a href="#A-f-0e">f</a>();</code>
 </pre><span class="small"><a href="#A-f-0e"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">template&lt;&gt;
 void
-<a href="#A-f-0b">f&lt;int&gt;</a>();
-
-</code>
+<a href="#A-f-0b">f&lt;int&gt;</a>();</code>
 </pre><span class="small"><a href="#A-f-0b"><em>» more...</em></a></span>
 
 
@@ -94,9 +87,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
 void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -111,9 +102,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
 void
-<a href="#A-f-0e">f</a>&lt;int&gt;();
-
-</code>
+<a href="#A-f-0e">f</a>&lt;int&gt;();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/templates/ct_expl.html b/test-files/golden-tests/templates/ct_expl.html
index b5b3c3979..7dcef03ba 100644
--- a/test-files/golden-tests/templates/ct_expl.html
+++ b/test-files/golden-tests/templates/ct_expl.html
@@ -34,9 +34,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_expl.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -65,9 +63,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_expl.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -81,9 +77,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_expl.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e">A</a>&lt;int&gt;;
-
-</code>
+struct <a href="#A-0e">A</a>&lt;int&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -112,9 +106,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_expl.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/templates/ct_expl_dependency.html b/test-files/golden-tests/templates/ct_expl_dependency.html
index c54867004..a0aeea8a5 100644
--- a/test-files/golden-tests/templates/ct_expl_dependency.html
+++ b/test-files/golden-tests/templates/ct_expl_dependency.html
@@ -33,9 +33,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_expl_dependency.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct A&lt;int&gt;;
-
-</code>
+struct A&lt;int&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -64,9 +62,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_expl_dependency.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/templates/ct_mc.html b/test-files/golden-tests/templates/ct_mc.html
index b9bb24124..a0df84123 100644
--- a/test-files/golden-tests/templates/ct_mc.html
+++ b/test-files/golden-tests/templates/ct_mc.html
@@ -33,9 +33,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mc.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -63,9 +61,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;ct_mc.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct B;
-
-</code>
+<code class="source-code cpp">struct B;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -94,9 +90,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mc.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/templates/ct_mc_expl_outside.html b/test-files/golden-tests/templates/ct_mc_expl_outside.html
index 9af63d53c..146639d81 100644
--- a/test-files/golden-tests/templates/ct_mc_expl_outside.html
+++ b/test-files/golden-tests/templates/ct_mc_expl_outside.html
@@ -34,9 +34,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mc_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -64,9 +62,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;ct_mc_expl_outside.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct B;
-
-</code>
+<code class="source-code cpp">struct B;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -95,9 +91,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mc_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -111,9 +105,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mc_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e">A</a>&lt;int&gt;;
-
-</code>
+struct <a href="#A-0e">A</a>&lt;int&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -141,9 +133,7 @@ <h3>Synopsis</h3>
 <div>
 Declared in <code>&lt;ct_mc_expl_outside.cpp&gt;</code></div>
 <pre>
-<code class="source-code cpp">struct B;
-
-</code>
+<code class="source-code cpp">struct B;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -172,9 +162,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mc_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/templates/ct_mct.html b/test-files/golden-tests/templates/ct_mct.html
index 2bc7614d4..a8367b216 100644
--- a/test-files/golden-tests/templates/ct_mct.html
+++ b/test-files/golden-tests/templates/ct_mct.html
@@ -33,9 +33,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mct.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -64,9 +62,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mct.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -95,9 +91,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mct.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/templates/ct_mct_expl_inline.html b/test-files/golden-tests/templates/ct_mct_expl_inline.html
index ec0559aa8..3375317e0 100644
--- a/test-files/golden-tests/templates/ct_mct_expl_inline.html
+++ b/test-files/golden-tests/templates/ct_mct_expl_inline.html
@@ -33,9 +33,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mct_expl_inline.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -65,9 +63,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mct_expl_inline.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -96,9 +92,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mct_expl_inline.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -112,9 +106,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mct_expl_inline.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-B-07">B</a>&lt;int&gt;;
-
-</code>
+struct <a href="#A-B-07">B</a>&lt;int&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -143,9 +135,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mct_expl_inline.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/templates/ct_mct_expl_outside.html b/test-files/golden-tests/templates/ct_mct_expl_outside.html
index 2b3aa4109..591573dd6 100644
--- a/test-files/golden-tests/templates/ct_mct_expl_outside.html
+++ b/test-files/golden-tests/templates/ct_mct_expl_outside.html
@@ -34,9 +34,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mct_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -65,9 +63,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mct_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -96,9 +92,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mct_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -112,9 +106,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mct_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e">A</a>&lt;int&gt;;
-
-</code>
+struct <a href="#A-0e">A</a>&lt;int&gt;;</code>
 </pre>
 </div>
 <h2>Types</h2>
@@ -144,9 +136,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mct_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
-struct B;
-
-</code>
+struct B;</code>
 </pre>
 </div>
 
@@ -162,9 +152,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mct_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e-B">B</a>&lt;int&gt;;
-
-</code>
+struct <a href="#A-0e-B">B</a>&lt;int&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -193,9 +181,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mct_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-g();
-
-</code>
+g();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/templates/ct_mf.html b/test-files/golden-tests/templates/ct_mf.html
index 89e884c26..c5e32485f 100644
--- a/test-files/golden-tests/templates/ct_mf.html
+++ b/test-files/golden-tests/templates/ct_mf.html
@@ -33,9 +33,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mf.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -64,9 +62,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mf.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/templates/ct_mf_expl_outside.html b/test-files/golden-tests/templates/ct_mf_expl_outside.html
index a6646dcae..1c6e98922 100644
--- a/test-files/golden-tests/templates/ct_mf_expl_outside.html
+++ b/test-files/golden-tests/templates/ct_mf_expl_outside.html
@@ -34,9 +34,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mf_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -65,9 +63,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mf_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -81,9 +77,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mf_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e">A</a>&lt;int&gt;;
-
-</code>
+struct <a href="#A-0e">A</a>&lt;int&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -112,9 +106,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mf_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/templates/ct_mft.html b/test-files/golden-tests/templates/ct_mft.html
index 22a329503..f6c67c582 100644
--- a/test-files/golden-tests/templates/ct_mft.html
+++ b/test-files/golden-tests/templates/ct_mft.html
@@ -33,9 +33,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mft.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -65,9 +63,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
 void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/templates/ct_mft_expl_inline.adoc b/test-files/golden-tests/templates/ct_mft_expl_inline.adoc
index df32fe4b9..bf52845b0 100644
--- a/test-files/golden-tests/templates/ct_mft_expl_inline.adoc
+++ b/test-files/golden-tests/templates/ct_mft_expl_inline.adoc
@@ -27,12 +27,10 @@ struct A;
 
 === Member Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#A-f-00[`f`] 
-| 
 |===
 
 [#A-f-00]
diff --git a/test-files/golden-tests/templates/ct_mft_expl_inline.html b/test-files/golden-tests/templates/ct_mft_expl_inline.html
index cac28653c..af61f8742 100644
--- a/test-files/golden-tests/templates/ct_mft_expl_inline.html
+++ b/test-files/golden-tests/templates/ct_mft_expl_inline.html
@@ -33,9 +33,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mft_expl_inline.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -43,12 +41,11 @@ <h2>Member Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-f-00"><code>f</code></a> </td><td><span></span></td></tr>
+<td><a href="#A-f-00"><code>f</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -67,18 +64,14 @@ <h3>Synopses</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
 void
-<a href="#A-f-07">f</a>();
-
-</code>
+<a href="#A-f-07">f</a>();</code>
 </pre><span class="small"><a href="#A-f-07"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">template&lt;&gt;
 void
-<a href="#A-f-04">f&lt;int&gt;</a>();
-
-</code>
+<a href="#A-f-04">f&lt;int&gt;</a>();</code>
 </pre><span class="small"><a href="#A-f-04"><em>» more...</em></a></span>
 
 
@@ -95,9 +88,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
 void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -112,9 +103,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
 void
-<a href="#A-f-07">f</a>&lt;int&gt;();
-
-</code>
+<a href="#A-f-07">f</a>&lt;int&gt;();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/templates/ct_mft_expl_outside.adoc b/test-files/golden-tests/templates/ct_mft_expl_outside.adoc
index 4f264de25..39c851802 100644
--- a/test-files/golden-tests/templates/ct_mft_expl_outside.adoc
+++ b/test-files/golden-tests/templates/ct_mft_expl_outside.adoc
@@ -63,12 +63,10 @@ struct link:#A-0e[A]&lt;int&gt;;
 
 === Member Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#A-00-f-0a[`f`] 
-| 
 |===
 
 [#A-00-f-0a]
diff --git a/test-files/golden-tests/templates/ct_mft_expl_outside.html b/test-files/golden-tests/templates/ct_mft_expl_outside.html
index f8b19fbd5..e4761cff3 100644
--- a/test-files/golden-tests/templates/ct_mft_expl_outside.html
+++ b/test-files/golden-tests/templates/ct_mft_expl_outside.html
@@ -34,9 +34,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mft_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
-struct A;
-
-</code>
+struct A;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -66,9 +64,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
 void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -82,9 +78,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;ct_mft_expl_outside.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
-struct <a href="#A-0e">A</a>&lt;int&gt;;
-
-</code>
+struct <a href="#A-0e">A</a>&lt;int&gt;;</code>
 </pre>
 </div>
 <h2>Member Functions</h2>
@@ -92,12 +86,11 @@ <h2>Member Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#A-00-f-0a"><code>f</code></a> </td><td><span></span></td></tr>
+<td><a href="#A-00-f-0a"><code>f</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -116,18 +109,14 @@ <h3>Synopses</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
 void
-<a href="#A-00-f-03">f</a>();
-
-</code>
+<a href="#A-00-f-03">f</a>();</code>
 </pre><span class="small"><a href="#A-00-f-03"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">template&lt;&gt;
 void
-<a href="#A-00-f-07">f&lt;int&gt;</a>();
-
-</code>
+<a href="#A-00-f-07">f&lt;int&gt;</a>();</code>
 </pre><span class="small"><a href="#A-00-f-07"><em>» more...</em></a></span>
 
 
@@ -144,9 +133,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename U&gt;
 void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -161,9 +148,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
 void
-<a href="#A-0e-f">f</a>&lt;int&gt;();
-
-</code>
+<a href="#A-0e-f">f</a>&lt;int&gt;();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/golden-tests/templates/ft_expl.adoc b/test-files/golden-tests/templates/ft_expl.adoc
index 49da7df1f..9e7c47f0e 100644
--- a/test-files/golden-tests/templates/ft_expl.adoc
+++ b/test-files/golden-tests/templates/ft_expl.adoc
@@ -6,12 +6,10 @@
 
 === Functions
 
-[cols=2]
+[cols=1]
 |===
 | Name
-| Description
 | link:#f-0c7[`f`] 
-| 
 |===
 
 [#f-0c7]
diff --git a/test-files/golden-tests/templates/ft_expl.html b/test-files/golden-tests/templates/ft_expl.html
index 9b51b74cc..d8f652a4f 100644
--- a/test-files/golden-tests/templates/ft_expl.html
+++ b/test-files/golden-tests/templates/ft_expl.html
@@ -14,12 +14,11 @@ <h2>Functions</h2>
 <thead>
 <tr>
 <th>Name</th>
-<th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
-<td><a href="#f-0c7"><code>f</code></a> </td><td><span></span></td></tr>
+<td><a href="#f-0c7"><code>f</code></a> </td></tr>
 </tbody>
 </table>
 
@@ -36,18 +35,14 @@ <h3>Synopses</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
 void
-<a href="#f-03">f</a>();
-
-</code>
+<a href="#f-03">f</a>();</code>
 </pre><span class="small"><a href="#f-03"><em>» more...</em></a></span>
 
 
 <pre>
 <code class="source-code cpp">template&lt;&gt;
 void
-<a href="#f-0ca">f&lt;int&gt;</a>();
-
-</code>
+<a href="#f-0ca">f&lt;int&gt;</a>();</code>
 </pre><span class="small"><a href="#f-0ca"><em>» more...</em></a></span>
 
 
@@ -64,9 +59,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;typename T&gt;
 void
-f();
-
-</code>
+f();</code>
 </pre>
 </div>
 </div>
@@ -81,9 +74,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">template&lt;&gt;
 void
-<a href="#f-03">f</a>&lt;int&gt;();
-
-</code>
+<a href="#f-03">f</a>&lt;int&gt;();</code>
 </pre>
 </div>
 </div>
diff --git a/test-files/handlebars/features_test.adoc b/test-files/handlebars/features_test.adoc
index 135795838..efdf39571 100644
--- a/test-files/handlebars/features_test.adoc
+++ b/test-files/handlebars/features_test.adoc
@@ -57,7 +57,7 @@ People:
         "name": "from_chars",
         "decl": "std::from_chars",
         "loc": "charconv",
-        "javadoc": {
+        "doc": {
             "brief": "Converts strings to numbers",
             "details": "This function converts strings to numbers"
         },

From 944c30fcb27b91307b356597660ceeebc2ceb7c9 Mon Sep 17 00:00:00 2001
From: Alan de Freitas <alandefreitas@gmail.com>
Date: Thu, 9 Oct 2025 17:08:45 -0500
Subject: [PATCH 23/23] refactor(lib): lua is external dependency

---
 .clang-format                      |   11 +-
 .github/workflows/ci.yml           |   23 +
 CMakeLists.txt                     |    5 +-
 bootstrap.py                       |   74 +-
 src/lib/Support/Lua.cpp            |    6 +-
 src/lib/Support/LuaHandlebars.cpp  |    2 -
 src/lib/Support/LuaHandlebars.hpp  |    2 -
 src/lib/lua.cpp                    |   59 -
 third-party/lua/CMakeLists.txt     |   89 ++
 third-party/lua/LuaConfig.cmake.in |   15 +
 third-party/lua/Makefile           |  106 --
 third-party/lua/README             |    6 -
 third-party/lua/src/Makefile       |  225 ----
 third-party/lua/src/lapi.c         | 1463 ---------------------
 third-party/lua/src/lapi.h         |   52 -
 third-party/lua/src/lauxlib.c      | 1112 ----------------
 third-party/lua/src/lauxlib.h      |  301 -----
 third-party/lua/src/lbaselib.c     |  549 --------
 third-party/lua/src/lcode.c        | 1871 --------------------------
 third-party/lua/src/lcode.h        |  104 --
 third-party/lua/src/lcorolib.c     |  210 ---
 third-party/lua/src/lctype.c       |   64 -
 third-party/lua/src/lctype.h       |  101 --
 third-party/lua/src/ldblib.c       |  483 -------
 third-party/lua/src/ldebug.c       |  924 -------------
 third-party/lua/src/ldebug.h       |   63 -
 third-party/lua/src/ldo.c          | 1024 ---------------
 third-party/lua/src/ldo.h          |   88 --
 third-party/lua/src/ldump.c        |  230 ----
 third-party/lua/src/lfunc.c        |  294 -----
 third-party/lua/src/lfunc.h        |   64 -
 third-party/lua/src/lgc.c          | 1739 ------------------------
 third-party/lua/src/lgc.h          |  202 ---
 third-party/lua/src/linit.c        |   65 -
 third-party/lua/src/liolib.c       |  828 ------------
 third-party/lua/src/ljumptab.h     |  112 --
 third-party/lua/src/llex.c         |  581 --------
 third-party/lua/src/llex.h         |   91 --
 third-party/lua/src/llimits.h      |  380 ------
 third-party/lua/src/lmathlib.c     |  764 -----------
 third-party/lua/src/lmem.c         |  215 ---
 third-party/lua/src/lmem.h         |   93 --
 third-party/lua/src/loadlib.c      |  767 -----------
 third-party/lua/src/lobject.c      |  602 ---------
 third-party/lua/src/lobject.h      |  815 ------------
 third-party/lua/src/lopcodes.c     |  104 --
 third-party/lua/src/lopcodes.h     |  405 ------
 third-party/lua/src/lopnames.h     |  103 --
 third-party/lua/src/loslib.c       |  428 ------
 third-party/lua/src/lparser.c      | 1967 ----------------------------
 third-party/lua/src/lparser.h      |  171 ---
 third-party/lua/src/lprefix.h      |   45 -
 third-party/lua/src/lstate.c       |  445 -------
 third-party/lua/src/lstate.h       |  409 ------
 third-party/lua/src/lstring.c      |  273 ----
 third-party/lua/src/lstring.h      |   57 -
 third-party/lua/src/lstrlib.c      | 1874 --------------------------
 third-party/lua/src/ltable.c       |  980 --------------
 third-party/lua/src/ltable.h       |   65 -
 third-party/lua/src/ltablib.c      |  430 ------
 third-party/lua/src/ltm.c          |  271 ----
 third-party/lua/src/ltm.h          |  104 --
 third-party/lua/src/lua.c          |  679 ----------
 third-party/lua/src/lua.h          |  523 --------
 third-party/lua/src/lua.hpp        |    9 -
 third-party/lua/src/luac.c         |  723 ----------
 third-party/lua/src/luaconf.h      |  793 -----------
 third-party/lua/src/lualib.h       |   52 -
 third-party/lua/src/lundump.c      |  335 -----
 third-party/lua/src/lundump.h      |   36 -
 third-party/lua/src/lutf8lib.c     |  291 ----
 third-party/lua/src/lvm.c          | 1901 ---------------------------
 third-party/lua/src/lvm.h          |  141 --
 third-party/lua/src/lzio.c         |   68 -
 third-party/lua/src/lzio.h         |   66 -
 75 files changed, 214 insertions(+), 30408 deletions(-)
 delete mode 100644 src/lib/lua.cpp
 create mode 100644 third-party/lua/CMakeLists.txt
 create mode 100644 third-party/lua/LuaConfig.cmake.in
 delete mode 100644 third-party/lua/Makefile
 delete mode 100644 third-party/lua/README
 delete mode 100644 third-party/lua/src/Makefile
 delete mode 100644 third-party/lua/src/lapi.c
 delete mode 100644 third-party/lua/src/lapi.h
 delete mode 100644 third-party/lua/src/lauxlib.c
 delete mode 100644 third-party/lua/src/lauxlib.h
 delete mode 100644 third-party/lua/src/lbaselib.c
 delete mode 100644 third-party/lua/src/lcode.c
 delete mode 100644 third-party/lua/src/lcode.h
 delete mode 100644 third-party/lua/src/lcorolib.c
 delete mode 100644 third-party/lua/src/lctype.c
 delete mode 100644 third-party/lua/src/lctype.h
 delete mode 100644 third-party/lua/src/ldblib.c
 delete mode 100644 third-party/lua/src/ldebug.c
 delete mode 100644 third-party/lua/src/ldebug.h
 delete mode 100644 third-party/lua/src/ldo.c
 delete mode 100644 third-party/lua/src/ldo.h
 delete mode 100644 third-party/lua/src/ldump.c
 delete mode 100644 third-party/lua/src/lfunc.c
 delete mode 100644 third-party/lua/src/lfunc.h
 delete mode 100644 third-party/lua/src/lgc.c
 delete mode 100644 third-party/lua/src/lgc.h
 delete mode 100644 third-party/lua/src/linit.c
 delete mode 100644 third-party/lua/src/liolib.c
 delete mode 100644 third-party/lua/src/ljumptab.h
 delete mode 100644 third-party/lua/src/llex.c
 delete mode 100644 third-party/lua/src/llex.h
 delete mode 100644 third-party/lua/src/llimits.h
 delete mode 100644 third-party/lua/src/lmathlib.c
 delete mode 100644 third-party/lua/src/lmem.c
 delete mode 100644 third-party/lua/src/lmem.h
 delete mode 100644 third-party/lua/src/loadlib.c
 delete mode 100644 third-party/lua/src/lobject.c
 delete mode 100644 third-party/lua/src/lobject.h
 delete mode 100644 third-party/lua/src/lopcodes.c
 delete mode 100644 third-party/lua/src/lopcodes.h
 delete mode 100644 third-party/lua/src/lopnames.h
 delete mode 100644 third-party/lua/src/loslib.c
 delete mode 100644 third-party/lua/src/lparser.c
 delete mode 100644 third-party/lua/src/lparser.h
 delete mode 100644 third-party/lua/src/lprefix.h
 delete mode 100644 third-party/lua/src/lstate.c
 delete mode 100644 third-party/lua/src/lstate.h
 delete mode 100644 third-party/lua/src/lstring.c
 delete mode 100644 third-party/lua/src/lstring.h
 delete mode 100644 third-party/lua/src/lstrlib.c
 delete mode 100644 third-party/lua/src/ltable.c
 delete mode 100644 third-party/lua/src/ltable.h
 delete mode 100644 third-party/lua/src/ltablib.c
 delete mode 100644 third-party/lua/src/ltm.c
 delete mode 100644 third-party/lua/src/ltm.h
 delete mode 100644 third-party/lua/src/lua.c
 delete mode 100644 third-party/lua/src/lua.h
 delete mode 100644 third-party/lua/src/lua.hpp
 delete mode 100644 third-party/lua/src/luac.c
 delete mode 100644 third-party/lua/src/luaconf.h
 delete mode 100644 third-party/lua/src/lualib.h
 delete mode 100644 third-party/lua/src/lundump.c
 delete mode 100644 third-party/lua/src/lundump.h
 delete mode 100644 third-party/lua/src/lutf8lib.c
 delete mode 100644 third-party/lua/src/lvm.c
 delete mode 100644 third-party/lua/src/lvm.h
 delete mode 100644 third-party/lua/src/lzio.c
 delete mode 100644 third-party/lua/src/lzio.h

diff --git a/.clang-format b/.clang-format
index beac5f6b1..1033103e5 100644
--- a/.clang-format
+++ b/.clang-format
@@ -200,7 +200,7 @@ IncludeCategories:
     Priority: 0
   - Regex: '^".*"'                               # quoted includes come next
     Priority: 1
-  - Regex: '^<lib/.*>'                        # internal project headers
+  - Regex: '^<lib/.*>'                           # internal project headers
     Priority: 2
   - Regex: '^<mrdocs/.*>'                        # internal project headers
     Priority: 3
@@ -214,12 +214,15 @@ IncludeCategories:
     Priority: 7
   - Regex: '^<duktape/.*>'                       # duktape headers
     Priority: 8
-  - Regex: '^<(?!mrdocs/|clang/|llvm/|test_suite/|fmt/|duktape/)[^/]+/.*>' # other angle-bracket includes
+    # Lua headers
+  - Regex: '^<lua.*>'                           # Lua headers
     Priority: 9
-  - Regex: '^<[^/]+>'                            # C++ standard headers like <vector>
+  - Regex: '^<(?!mrdocs/|clang/|llvm/|test_suite/|fmt/|duktape/)[^/]+/.*>' # other angle-bracket includes
     Priority: 10
-  - Regex: '.*'                                  # fallback
+  - Regex: '^<[^/]+>'                            # C++ standard headers like <vector>
     Priority: 11
+  - Regex: '.*'                                  # fallback
+    Priority: 12
 
 # Comments
 FixNamespaceComments: true
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 67a8598a1..5c00b7dd1 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -402,6 +402,26 @@ jobs:
           run-tests: false
           trace-commands: true
 
+      - name: Install Lua
+        uses: alandefreitas/cpp-actions/cmake-workflow@v1.8.12
+        with:
+          source-dir: ../third-party/lua
+          url: https://github.com/lua/lua/archive/refs/tags/v5.4.8.tar.gz
+          patches: |
+            ./third-party/lua/CMakeLists.txt
+            ./third-party/lua/LuaConfig.cmake.in
+          build-dir: ${sourceDir}/build
+          cc: ${{ steps.setup-cpp.outputs.cc }}
+          cxx: ${{ steps.setup-cpp.outputs.cxx }}
+          ccflags: ${{ matrix.common-ccflags }}
+          cxxflags: ${{ steps.rmatrix.outputs.common-cxxflags }}
+          build-type: ${{ matrix.build-type }}
+          shared: false
+          install: true
+          install-prefix: ${sourceDir}/install
+          run-tests: false
+          trace-commands: true
+
       - name: Install Libxml2
         uses: alandefreitas/cpp-actions/cmake-workflow@v1.8.12
         if: matrix.compiler == 'msvc'
@@ -479,6 +499,9 @@ jobs:
             -D CMAKE_EXE_LINKER_FLAGS="${{ steps.rmatrix.outputs.common-ldflags }}"
             -D LLVM_ROOT="${{ steps.rmatrix.outputs.llvm-path }}"
             -D duktape_ROOT="${{ steps.rmatrix.outputs.third-party-dir }}/duktape/install"
+            -D LUA_ROOT="${{ steps.rmatrix.outputs.third-party-dir }}/lua/install"
+            -D Lua_ROOT="${{ steps.rmatrix.outputs.third-party-dir }}/lua/install"
+            -D lua_ROOT="${{ steps.rmatrix.outputs.third-party-dir }}/lua/install"
             ${{ runner.os == 'Windows' && '-D LibXml2_ROOT=../third-party/libxml2/install' || '' }}
           export-compile-commands: true
           run-tests: true
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9d2537463..f96cea1ab 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -284,6 +284,9 @@ if (NOT DUKTAPE_FOUND)
     find_package(Duktape REQUIRED CONFIG)
 endif()
 
+# Lua
+find_package(Lua CONFIG REQUIRED)
+
 unset(CMAKE_FOLDER)
 
 #-------------------------------------------------
@@ -322,7 +325,6 @@ target_include_directories(mrdocs-core
     PRIVATE
     "${PROJECT_SOURCE_DIR}/src"
     "${PROJECT_BINARY_DIR}/src"
-    "${PROJECT_SOURCE_DIR}/third-party/lua/src"
 )
 target_compile_definitions(
     mrdocs-core
@@ -345,6 +347,7 @@ target_include_directories(mrdocs-core
         "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
 )
 target_link_libraries(mrdocs-core PRIVATE ${DUKTAPE_LIBRARY})
+target_link_libraries(mrdocs-core PRIVATE Lua::lua)
 
 # Clang
 if (CLANG_SIMPLE_LIBS)
diff --git a/bootstrap.py b/bootstrap.py
index face0b58f..caaab3605 100644
--- a/bootstrap.py
+++ b/bootstrap.py
@@ -91,6 +91,13 @@ class InstallOptions:
     duktape_build_dir: str = "<duktape-src-dir>/build/<duktape-build-type:lower><\"-\":if(cc)><cc:basename><\"-\":if(sanitizer)><sanitizer:lower>"
     duktape_install_dir: str = "<duktape-src-dir>/install/<duktape-build-type:lower><\"-\":if(cc)><cc:basename><\"-\":if(sanitizer)><sanitizer:lower>"
 
+    # Lua
+    lua_src_dir: str = "<third-party-src-dir>/lua"
+    lua_url: str = "https://github.com/lua/lua/archive/refs/tags/v5.4.8.tar.gz"
+    lua_build_type: str = "<mrdocs-build-type>"
+    lua_build_dir: str = "<lua-src-dir>/build/<lua-build-type:lower><\"-\":if(cc)><cc:basename><\"-\":if(sanitizer)><sanitizer:lower>"
+    lua_install_dir: str = "<lua-src-dir>/install/<lua-build-type:lower><\"-\":if(cc)><cc:basename><\"-\":if(sanitizer)><sanitizer:lower>"
+
     # LLVM
     llvm_src_dir: str = "<third-party-src-dir>/llvm-project"
     llvm_build_type: str = "<mrdocs-build-type>"
@@ -152,6 +159,11 @@ class InstallOptions:
     "duktape_build_type": "CMake build type for Duktape. (Release, Debug, RelWithDebInfo, MilRelSize)",
     "duktape_build_dir": "Directory where Duktape will be built.",
     "duktape_install_dir": "Directory where Duktape will be installed.",
+    "lua_src_dir": "Directory for the Lua source code.",
+    "lua_url": "Download URL for the Lua source archive.",
+    "lua_build_type": "Build type for Lua. (Release, Debug)",
+    "lua_build_dir": "Directory where Lua will be built.",
+    "lua_install_dir": "Directory where Lua will be installed.",
     "libxml2_src_dir": "Directory for the libxml2 source code.",
     "libxml2_build_type": "CMake build type for libxml2: Release always recommended. (Release, Debug, RelWithDebInfo, MilRelSize)",
     "libxml2_build_dir": "Directory where libxml2 will be built.",
@@ -1162,6 +1174,63 @@ def install_duktape(self):
             self.options.duktape_install_dir,
             extra_args)
 
+    def install_lua(self):
+        # Resolve paths/values
+        self.prompt_dependency_path_option("lua_src_dir")
+        if not os.path.exists(self.options.lua_src_dir):
+            self.prompt_option("lua_url")
+            os.makedirs(self.options.lua_src_dir, exist_ok=True)
+            archive_filename = os.path.basename(self.options.lua_url)
+            archive_path = os.path.join(self.options.third_party_src_dir, archive_filename)
+            self.download_file(self.options.lua_url, archive_path)
+
+            # Extract lua-5.4.8.tar.gz, flatten top-level dir into lua_src_dir
+            mode = "r:gz" if archive_filename.endswith(".gz") else "r:*"
+            with tarfile.open(archive_path, mode) as tar:
+                top_level = tar.getmembers()[0].name.split('/')[0]
+                for member in tar.getmembers():
+                    rel = os.path.relpath(member.name, top_level)
+                    if rel == '.' or rel.startswith('..'):
+                        continue
+                    member.name = rel
+                    tar.extract(member, path=self.options.lua_src_dir)
+            os.remove(archive_path)
+
+        # Copy our tiny CMake patch files (like we do for Duktape)
+        lua_patches = os.path.join(self.options.mrdocs_src_dir, 'third-party', 'lua')
+        if os.path.exists(lua_patches):
+            for fname in os.listdir(lua_patches):
+                src = os.path.join(lua_patches, fname)
+                dst = os.path.join(self.options.lua_src_dir, fname)
+                shutil.copy(src, dst)
+
+        # Lua’s own tree puts sources under src/; our CMakeLists handles that.
+        self.prompt_build_type_option("lua_build_type")
+        # align ABI expectations like we do for Duktape:
+        if not self.is_abi_compatible(self.options.mrdocs_build_type, self.options.lua_build_type):
+            if self.options.mrdocs_build_type.lower() == "debug":
+                self.options.lua_build_type = "OptimizedDebug"
+            else:
+                self.options.lua_build_type = self.options.mrdocs_build_type
+
+        self.prompt_dependency_path_option("lua_build_dir")
+        self.prompt_dependency_path_option("lua_install_dir")
+
+        extra_args = []
+        if self.options.sanitizer:
+            flag = self.sanitizer_flag_name(self.options.sanitizer)
+            for arg in ("CMAKE_C_FLAGS", "CMAKE_CXX_FLAGS"):
+                extra_args.append(f"-D{arg}=-fsanitize={flag} -fno-sanitize-recover={flag} -fno-omit-frame-pointer")
+
+        # Standard cmake_workflow like Duktape
+        self.cmake_workflow(
+            self.options.lua_src_dir,
+            self.options.lua_build_type,
+            self.options.lua_build_dir,
+            self.options.lua_install_dir,
+            extra_args
+        )
+
     def install_libxml2(self):
         self.prompt_dependency_path_option("libxml2_src_dir")
         if not os.path.exists(self.options.libxml2_src_dir):
@@ -1338,7 +1407,9 @@ def create_cmake_presets(self):
                 "Duktape_ROOT": self.options.duktape_install_dir,
                 "libxml2_ROOT": self.options.libxml2_install_dir,
                 "LibXml2_ROOT": self.options.libxml2_install_dir,
-                "MRDOCS_BUILD_TESTS": self.options.mrdocs_build_tests,
+                "LUA_ROOT": self.options.lua_install_dir,
+                "Lua_ROOT": self.options.lua_install_dir,
+                "lua_ROOT": self.options.lua_install_dir,
                 "MRDOCS_BUILD_DOCS": False,
                 "MRDOCS_GENERATE_REFERENCE": False,
                 "MRDOCS_GENERATE_ANTORA_REFERENCE": False
@@ -2580,6 +2651,7 @@ def install_all(self):
         self.probe_compilers()
         self.install_ninja()
         self.install_duktape()
+        self.install_lua()
         self.install_llvm()
         if self.prompt_option("mrdocs_build_tests"):
             self.install_libxml2()
diff --git a/src/lib/Support/Lua.cpp b/src/lib/Support/Lua.cpp
index 57482fc5d..b49e6a668 100644
--- a/src/lib/Support/Lua.cpp
+++ b/src/lib/Support/Lua.cpp
@@ -13,11 +13,12 @@
 #include <mrdocs/Support/Path.hpp>
 #include <mrdocs/Support/Report.hpp>
 #include <llvm/Support/raw_ostream.h>
+#include <lua.h>
+#include <lualib.h>
 #include <format>
-#include <lua.hpp>
+#include <lauxlib.h>
 #include <print>
 
-namespace clang {
 namespace mrdocs {
 namespace lua {
 
@@ -1205,4 +1206,3 @@ lua_main()
 
 } // lua
 } // mrdocs
-} // clang
diff --git a/src/lib/Support/LuaHandlebars.cpp b/src/lib/Support/LuaHandlebars.cpp
index 60474aa08..363b0a6cf 100644
--- a/src/lib/Support/LuaHandlebars.cpp
+++ b/src/lib/Support/LuaHandlebars.cpp
@@ -11,7 +11,6 @@
 #include "LuaHandlebars.hpp"
 #include <mrdocs/Support/Lua.hpp>
 
-namespace clang {
 namespace mrdocs {
 
 // VFALCO:
@@ -67,4 +66,3 @@ tryLoadHandlebars(
 }
 
 } // mrdocs
-} // clang
diff --git a/src/lib/Support/LuaHandlebars.hpp b/src/lib/Support/LuaHandlebars.hpp
index 958b48d56..6372fe2b4 100644
--- a/src/lib/Support/LuaHandlebars.hpp
+++ b/src/lib/Support/LuaHandlebars.hpp
@@ -14,7 +14,6 @@
 #include <mrdocs/Platform.hpp>
 #include <mrdocs/Support/Lua.hpp>
 
-namespace clang {
 namespace mrdocs {
 
 /** Add the Handlebars Lua instance as a global
@@ -25,6 +24,5 @@ tryLoadHandlebars(
     lua::Context const& ctx);
 
 } // mrdocs
-} // clang
 
 #endif // MRDOCS_LIB_SUPPORT_LUAHANDLEBARS_HPP
diff --git a/src/lib/lua.cpp b/src/lib/lua.cpp
deleted file mode 100644
index b6810dd9b..000000000
--- a/src/lib/lua.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-extern "C" {
-
-#if defined(__clang__)
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wcast-qual"
-# pragma clang diagnostic ignored "-Wimplicit-fallthrough"
-#elif defined(__GNUC__)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wcast-qual"
-# pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
-#elif defined(_MSC_VER)
-# pragma warning(push)
-# pragma warning(disable: 4334) // result of 32-bit shift implicitly converted to 64 bits (was 64-bit shift intended?)
-#endif
-
-#include <../third-party/lua/src/lapi.c>
-#include <../third-party/lua/src/lauxlib.c>
-#include <../third-party/lua/src/lbaselib.c>
-#include <../third-party/lua/src/lcode.c>
-#include <../third-party/lua/src/lcorolib.c>
-#include <../third-party/lua/src/lctype.c>
-#include <../third-party/lua/src/ldblib.c>
-#include <../third-party/lua/src/ldebug.c>
-#include <../third-party/lua/src/ldo.c>
-#include <../third-party/lua/src/ldump.c>
-#include <../third-party/lua/src/lfunc.c>
-#include <../third-party/lua/src/lgc.c>
-#include <../third-party/lua/src/linit.c>
-#include <../third-party/lua/src/liolib.c>
-#include <../third-party/lua/src/llex.c>
-#include <../third-party/lua/src/lmathlib.c>
-#include <../third-party/lua/src/lmem.c>
-#include <../third-party/lua/src/loadlib.c>
-#include <../third-party/lua/src/lobject.c>
-#include <../third-party/lua/src/lopcodes.c>
-#include <../third-party/lua/src/loslib.c>
-#include <../third-party/lua/src/lparser.c>
-#include <../third-party/lua/src/lstate.c>
-#include <../third-party/lua/src/lstring.c>
-#include <../third-party/lua/src/lstrlib.c>
-#include <../third-party/lua/src/ltable.c>
-#include <../third-party/lua/src/ltablib.c>
-#include <../third-party/lua/src/ltm.c>
-// #include "../third-party/lua/src/lua.c"
-// #include "../third-party/lua/src/luac.c"
-#include <../third-party/lua/src/lundump.c>
-#include <../third-party/lua/src/lutf8lib.c>
-#include <../third-party/lua/src/lvm.c>
-#include <../third-party/lua/src/lzio.c>
-
-#if defined(__clang__)
-# pragma clang diagnostic pop
-#elif defined(__GNUC__)
-# pragma GCC diagnostic pop
-#elif defined(_MSC_VER)
-# pragma warning(pop)
-#endif
-
-} // "C"
diff --git a/third-party/lua/CMakeLists.txt b/third-party/lua/CMakeLists.txt
new file mode 100644
index 000000000..f0213814d
--- /dev/null
+++ b/third-party/lua/CMakeLists.txt
@@ -0,0 +1,89 @@
+#
+# Licensed under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+#
+# Copyright (c) 2025 Alan de Freitas (alandefreitas@gmail.com)
+#
+# Official repository: https://github.com/cppalliance/mrdocs
+#
+#
+
+cmake_minimum_required(VERSION 3.13)
+
+set(lua_MAJOR_VERSION 5)
+set(lua_MINOR_VERSION 4)
+set(lua_PATCH_VERSION 8)
+set(lua_VERSION ${lua_MAJOR_VERSION}.${lua_MINOR_VERSION}.${lua_PATCH_VERSION})
+
+option(CMAKE_VERBOSE_MAKEFILE "Create verbose makefile" OFF)
+option(BUILD_SHARED_LIBS "Create lua as a shared library" OFF)
+
+project(lua VERSION ${lua_VERSION} LANGUAGES C)
+
+# Check if ./src exists
+if (EXISTS "${CMAKE_CURRENT_LIST_DIR}/src")
+    # Lua sources live under ./src
+    file(GLOB LUA_SOURCES "${CMAKE_CURRENT_LIST_DIR}/src/*.c")
+    list(REMOVE_ITEM LUA_SOURCES
+            "${CMAKE_CURRENT_LIST_DIR}/src/lua.c"
+            "${CMAKE_CURRENT_LIST_DIR}/src/luac.c"
+    )
+    file(GLOB LUA_HEADERS "${CMAKE_CURRENT_LIST_DIR}/src/*.h")
+else()
+    # Lua sources live under ./ (github release)
+    file(GLOB LUA_SOURCES "${CMAKE_CURRENT_LIST_DIR}/*.c")
+    list(REMOVE_ITEM LUA_SOURCES
+            "${CMAKE_CURRENT_LIST_DIR}/lua.c"
+            "${CMAKE_CURRENT_LIST_DIR}/luac.c"
+    )
+    file(GLOB LUA_HEADERS "${CMAKE_CURRENT_LIST_DIR}/*.h")
+endif()
+
+add_library(lua ${LUA_SOURCES} ${LUA_HEADERS})
+target_include_directories(lua
+        PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/src>
+        $<INSTALL_INTERFACE:include>
+)
+
+set_target_properties(lua PROPERTIES
+        PUBLIC_HEADER "${LUA_HEADERS}"
+        VERSION ${lua_VERSION}
+        SOVERSION ${lua_MAJOR_VERSION}
+)
+
+# Optional compatibility defines (uncomment if you need them)
+# target_compile_definitions(lua PRIVATE LUA_COMPAT_5_3)
+
+install(TARGETS lua
+        EXPORT LuaTargets
+        ARCHIVE DESTINATION "lib"
+        LIBRARY DESTINATION "lib"
+        RUNTIME DESTINATION "bin"
+        PUBLIC_HEADER DESTINATION "include"
+        COMPONENT dev
+)
+
+install(EXPORT LuaTargets
+        FILE LuaTargets.cmake
+        NAMESPACE Lua::
+        DESTINATION "share/Lua"
+)
+
+export(PACKAGE lua)
+
+include(CMakePackageConfigHelpers)
+write_basic_package_version_file(
+        "${PROJECT_BINARY_DIR}/LuaConfigVersion.cmake"
+        COMPATIBILITY SameMajorVersion
+)
+
+configure_file(LuaConfig.cmake.in
+        "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/LuaConfig.cmake" @ONLY)
+
+install(FILES
+        "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/LuaConfig.cmake"
+        "${PROJECT_BINARY_DIR}/LuaConfigVersion.cmake"
+        DESTINATION "share/Lua"
+)
diff --git a/third-party/lua/LuaConfig.cmake.in b/third-party/lua/LuaConfig.cmake.in
new file mode 100644
index 000000000..8d326e70b
--- /dev/null
+++ b/third-party/lua/LuaConfig.cmake.in
@@ -0,0 +1,15 @@
+@PACKAGE_INIT@
+
+# Bring in our targets
+include("${CMAKE_CURRENT_LIST_DIR}/LuaTargets.cmake")
+
+# Make both names appear “found”
+set(LUA_FOUND TRUE)
+set(Lua_FOUND TRUE)
+
+# Convenience variable; consumers should prefer the imported target lua::lua
+get_target_property(_lua_inc Lua::lua INTERFACE_INCLUDE_DIRECTORIES)
+if(_lua_inc)
+    set(LUA_INCLUDE_DIR "${_lua_inc}")
+endif()
+unset(_lua_inc)
diff --git a/third-party/lua/Makefile b/third-party/lua/Makefile
deleted file mode 100644
index 8efa2eb3f..000000000
--- a/third-party/lua/Makefile
+++ /dev/null
@@ -1,106 +0,0 @@
-# Makefile for installing Lua
-# See doc/readme.html for installation and customization instructions.
-
-# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================
-
-# Your platform. See PLATS for possible values.
-PLAT= guess
-
-# Where to install. The installation starts in the src and doc directories,
-# so take care if INSTALL_TOP is not an absolute path. See the local target.
-# You may want to make INSTALL_LMOD and INSTALL_CMOD consistent with
-# LUA_ROOT, LUA_LDIR, and LUA_CDIR in luaconf.h.
-INSTALL_TOP= /usr/local
-INSTALL_BIN= $(INSTALL_TOP)/bin
-INSTALL_INC= $(INSTALL_TOP)/include
-INSTALL_LIB= $(INSTALL_TOP)/lib
-INSTALL_MAN= $(INSTALL_TOP)/man/man1
-INSTALL_LMOD= $(INSTALL_TOP)/share/lua/$V
-INSTALL_CMOD= $(INSTALL_TOP)/lib/lua/$V
-
-# How to install. If your install program does not support "-p", then
-# you may have to run ranlib on the installed liblua.a.
-INSTALL= install -p
-INSTALL_EXEC= $(INSTALL) -m 0755
-INSTALL_DATA= $(INSTALL) -m 0644
-#
-# If you don't have "install" you can use "cp" instead.
-# INSTALL= cp -p
-# INSTALL_EXEC= $(INSTALL)
-# INSTALL_DATA= $(INSTALL)
-
-# Other utilities.
-MKDIR= mkdir -p
-RM= rm -f
-
-# == END OF USER SETTINGS -- NO NEED TO CHANGE ANYTHING BELOW THIS LINE =======
-
-# Convenience platforms targets.
-PLATS= guess aix bsd c89 freebsd generic ios linux linux-readline macosx mingw posix solaris
-
-# What to install.
-TO_BIN= lua luac
-TO_INC= lua.h luaconf.h lualib.h lauxlib.h lua.hpp
-TO_LIB= liblua.a
-TO_MAN= lua.1 luac.1
-
-# Lua version and release.
-V= 5.4
-R= $V.6
-
-# Targets start here.
-all:	$(PLAT)
-
-$(PLATS) help test clean:
-	@cd src && $(MAKE) $@
-
-install: dummy
-	cd src && $(MKDIR) $(INSTALL_BIN) $(INSTALL_INC) $(INSTALL_LIB) $(INSTALL_MAN) $(INSTALL_LMOD) $(INSTALL_CMOD)
-	cd src && $(INSTALL_EXEC) $(TO_BIN) $(INSTALL_BIN)
-	cd src && $(INSTALL_DATA) $(TO_INC) $(INSTALL_INC)
-	cd src && $(INSTALL_DATA) $(TO_LIB) $(INSTALL_LIB)
-	cd doc && $(INSTALL_DATA) $(TO_MAN) $(INSTALL_MAN)
-
-uninstall:
-	cd src && cd $(INSTALL_BIN) && $(RM) $(TO_BIN)
-	cd src && cd $(INSTALL_INC) && $(RM) $(TO_INC)
-	cd src && cd $(INSTALL_LIB) && $(RM) $(TO_LIB)
-	cd doc && cd $(INSTALL_MAN) && $(RM) $(TO_MAN)
-
-local:
-	$(MAKE) install INSTALL_TOP=../install
-
-# make may get confused with install/ if it does not support .PHONY.
-dummy:
-
-# Echo config parameters.
-echo:
-	@cd src && $(MAKE) -s echo
-	@echo "PLAT= $(PLAT)"
-	@echo "V= $V"
-	@echo "R= $R"
-	@echo "TO_BIN= $(TO_BIN)"
-	@echo "TO_INC= $(TO_INC)"
-	@echo "TO_LIB= $(TO_LIB)"
-	@echo "TO_MAN= $(TO_MAN)"
-	@echo "INSTALL_TOP= $(INSTALL_TOP)"
-	@echo "INSTALL_BIN= $(INSTALL_BIN)"
-	@echo "INSTALL_INC= $(INSTALL_INC)"
-	@echo "INSTALL_LIB= $(INSTALL_LIB)"
-	@echo "INSTALL_MAN= $(INSTALL_MAN)"
-	@echo "INSTALL_LMOD= $(INSTALL_LMOD)"
-	@echo "INSTALL_CMOD= $(INSTALL_CMOD)"
-	@echo "INSTALL_EXEC= $(INSTALL_EXEC)"
-	@echo "INSTALL_DATA= $(INSTALL_DATA)"
-
-# Echo pkg-config data.
-pc:
-	@echo "version=$R"
-	@echo "prefix=$(INSTALL_TOP)"
-	@echo "libdir=$(INSTALL_LIB)"
-	@echo "includedir=$(INSTALL_INC)"
-
-# Targets that do not create files (not all makes understand .PHONY).
-.PHONY: all $(PLATS) help test clean install uninstall local dummy echo pc
-
-# (end of Makefile)
diff --git a/third-party/lua/README b/third-party/lua/README
deleted file mode 100644
index 1ae97165b..000000000
--- a/third-party/lua/README
+++ /dev/null
@@ -1,6 +0,0 @@
-
-This is Lua 5.4.6, released on 02 May 2023.
-
-For installation instructions, license details, and
-further information about Lua, see doc/readme.html.
-
diff --git a/third-party/lua/src/Makefile b/third-party/lua/src/Makefile
deleted file mode 100644
index b7711963b..000000000
--- a/third-party/lua/src/Makefile
+++ /dev/null
@@ -1,225 +0,0 @@
-# Makefile for building Lua
-# See ../doc/readme.html for installation and customization instructions.
-
-# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================
-
-# Your platform. See PLATS for possible values.
-PLAT= guess
-
-CC= gcc -std=gnu99
-CFLAGS= -O2 -Wall -Wextra -DLUA_COMPAT_5_3 $(SYSCFLAGS) $(MYCFLAGS)
-LDFLAGS= $(SYSLDFLAGS) $(MYLDFLAGS)
-LIBS= -lm $(SYSLIBS) $(MYLIBS)
-
-AR= ar rcu
-RANLIB= ranlib
-RM= rm -f
-UNAME= uname
-
-SYSCFLAGS=
-SYSLDFLAGS=
-SYSLIBS=
-
-MYCFLAGS=
-MYLDFLAGS=
-MYLIBS=
-MYOBJS=
-
-# Special flags for compiler modules; -Os reduces code size.
-CMCFLAGS= 
-
-# == END OF USER SETTINGS -- NO NEED TO CHANGE ANYTHING BELOW THIS LINE =======
-
-PLATS= guess aix bsd c89 freebsd generic ios linux linux-readline macosx mingw posix solaris
-
-LUA_A=	liblua.a
-CORE_O=	lapi.o lcode.o lctype.o ldebug.o ldo.o ldump.o lfunc.o lgc.o llex.o lmem.o lobject.o lopcodes.o lparser.o lstate.o lstring.o ltable.o ltm.o lundump.o lvm.o lzio.o
-LIB_O=	lauxlib.o lbaselib.o lcorolib.o ldblib.o liolib.o lmathlib.o loadlib.o loslib.o lstrlib.o ltablib.o lutf8lib.o linit.o
-BASE_O= $(CORE_O) $(LIB_O) $(MYOBJS)
-
-LUA_T=	lua
-LUA_O=	lua.o
-
-LUAC_T=	luac
-LUAC_O=	luac.o
-
-ALL_O= $(BASE_O) $(LUA_O) $(LUAC_O)
-ALL_T= $(LUA_A) $(LUA_T) $(LUAC_T)
-ALL_A= $(LUA_A)
-
-# Targets start here.
-default: $(PLAT)
-
-all:	$(ALL_T)
-
-o:	$(ALL_O)
-
-a:	$(ALL_A)
-
-$(LUA_A): $(BASE_O)
-	$(AR) $@ $(BASE_O)
-	$(RANLIB) $@
-
-$(LUA_T): $(LUA_O) $(LUA_A)
-	$(CC) -o $@ $(LDFLAGS) $(LUA_O) $(LUA_A) $(LIBS)
-
-$(LUAC_T): $(LUAC_O) $(LUA_A)
-	$(CC) -o $@ $(LDFLAGS) $(LUAC_O) $(LUA_A) $(LIBS)
-
-test:
-	./$(LUA_T) -v
-
-clean:
-	$(RM) $(ALL_T) $(ALL_O)
-
-depend:
-	@$(CC) $(CFLAGS) -MM l*.c
-
-echo:
-	@echo "PLAT= $(PLAT)"
-	@echo "CC= $(CC)"
-	@echo "CFLAGS= $(CFLAGS)"
-	@echo "LDFLAGS= $(LDFLAGS)"
-	@echo "LIBS= $(LIBS)"
-	@echo "AR= $(AR)"
-	@echo "RANLIB= $(RANLIB)"
-	@echo "RM= $(RM)"
-	@echo "UNAME= $(UNAME)"
-
-# Convenience targets for popular platforms.
-ALL= all
-
-help:
-	@echo "Do 'make PLATFORM' where PLATFORM is one of these:"
-	@echo "   $(PLATS)"
-	@echo "See doc/readme.html for complete instructions."
-
-guess:
-	@echo Guessing `$(UNAME)`
-	@$(MAKE) `$(UNAME)`
-
-AIX aix:
-	$(MAKE) $(ALL) CC="xlc" CFLAGS="-O2 -DLUA_USE_POSIX -DLUA_USE_DLOPEN" SYSLIBS="-ldl" SYSLDFLAGS="-brtl -bexpall"
-
-bsd:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" SYSLIBS="-Wl,-E"
-
-c89:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_C89" CC="gcc -std=c89"
-	@echo ''
-	@echo '*** C89 does not guarantee 64-bit integers for Lua.'
-	@echo '*** Make sure to compile all external Lua libraries'
-	@echo '*** with LUA_USE_C89 to ensure consistency'
-	@echo ''
-
-FreeBSD NetBSD OpenBSD freebsd:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX -DLUA_USE_READLINE -I/usr/include/edit" SYSLIBS="-Wl,-E -ledit" CC="cc"
-
-generic: $(ALL)
-
-ios:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_IOS"
-
-Linux linux:	linux-noreadline
-
-linux-noreadline:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX" SYSLIBS="-Wl,-E -ldl"
-
-linux-readline:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX -DLUA_USE_READLINE" SYSLIBS="-Wl,-E -ldl -lreadline"
-
-Darwin macos macosx:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_MACOSX -DLUA_USE_READLINE" SYSLIBS="-lreadline"
-
-mingw:
-	$(MAKE) "LUA_A=lua54.dll" "LUA_T=lua.exe" \
-	"AR=$(CC) -shared -o" "RANLIB=strip --strip-unneeded" \
-	"SYSCFLAGS=-DLUA_BUILD_AS_DLL" "SYSLIBS=" "SYSLDFLAGS=-s" lua.exe
-	$(MAKE) "LUAC_T=luac.exe" luac.exe
-
-posix:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX"
-
-SunOS solaris:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN -D_REENTRANT" SYSLIBS="-ldl"
-
-# Targets that do not create files (not all makes understand .PHONY).
-.PHONY: all $(PLATS) help test clean default o a depend echo
-
-# Compiler modules may use special flags.
-llex.o:
-	$(CC) $(CFLAGS) $(CMCFLAGS) -c llex.c
-
-lparser.o:
-	$(CC) $(CFLAGS) $(CMCFLAGS) -c lparser.c
-
-lcode.o:
-	$(CC) $(CFLAGS) $(CMCFLAGS) -c lcode.c
-
-# DO NOT DELETE
-
-lapi.o: lapi.c lprefix.h lua.h luaconf.h lapi.h llimits.h lstate.h \
- lobject.h ltm.h lzio.h lmem.h ldebug.h ldo.h lfunc.h lgc.h lstring.h \
- ltable.h lundump.h lvm.h
-lauxlib.o: lauxlib.c lprefix.h lua.h luaconf.h lauxlib.h
-lbaselib.o: lbaselib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-lcode.o: lcode.c lprefix.h lua.h luaconf.h lcode.h llex.h lobject.h \
- llimits.h lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h \
- ldo.h lgc.h lstring.h ltable.h lvm.h
-lcorolib.o: lcorolib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-lctype.o: lctype.c lprefix.h lctype.h lua.h luaconf.h llimits.h
-ldblib.o: ldblib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-ldebug.o: ldebug.c lprefix.h lua.h luaconf.h lapi.h llimits.h lstate.h \
- lobject.h ltm.h lzio.h lmem.h lcode.h llex.h lopcodes.h lparser.h \
- ldebug.h ldo.h lfunc.h lstring.h lgc.h ltable.h lvm.h
-ldo.o: ldo.c lprefix.h lua.h luaconf.h lapi.h llimits.h lstate.h \
- lobject.h ltm.h lzio.h lmem.h ldebug.h ldo.h lfunc.h lgc.h lopcodes.h \
- lparser.h lstring.h ltable.h lundump.h lvm.h
-ldump.o: ldump.c lprefix.h lua.h luaconf.h lobject.h llimits.h lstate.h \
- ltm.h lzio.h lmem.h lundump.h
-lfunc.o: lfunc.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
- llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h
-lgc.o: lgc.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
- llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h lstring.h ltable.h
-linit.o: linit.c lprefix.h lua.h luaconf.h lualib.h lauxlib.h
-liolib.o: liolib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-llex.o: llex.c lprefix.h lua.h luaconf.h lctype.h llimits.h ldebug.h \
- lstate.h lobject.h ltm.h lzio.h lmem.h ldo.h lgc.h llex.h lparser.h \
- lstring.h ltable.h
-lmathlib.o: lmathlib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-lmem.o: lmem.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
- llimits.h ltm.h lzio.h lmem.h ldo.h lgc.h
-loadlib.o: loadlib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-lobject.o: lobject.c lprefix.h lua.h luaconf.h lctype.h llimits.h \
- ldebug.h lstate.h lobject.h ltm.h lzio.h lmem.h ldo.h lstring.h lgc.h \
- lvm.h
-lopcodes.o: lopcodes.c lprefix.h lopcodes.h llimits.h lua.h luaconf.h
-loslib.o: loslib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-lparser.o: lparser.c lprefix.h lua.h luaconf.h lcode.h llex.h lobject.h \
- llimits.h lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h \
- ldo.h lfunc.h lstring.h lgc.h ltable.h
-lstate.o: lstate.c lprefix.h lua.h luaconf.h lapi.h llimits.h lstate.h \
- lobject.h ltm.h lzio.h lmem.h ldebug.h ldo.h lfunc.h lgc.h llex.h \
- lstring.h ltable.h
-lstring.o: lstring.c lprefix.h lua.h luaconf.h ldebug.h lstate.h \
- lobject.h llimits.h ltm.h lzio.h lmem.h ldo.h lstring.h lgc.h
-lstrlib.o: lstrlib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-ltable.o: ltable.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
- llimits.h ltm.h lzio.h lmem.h ldo.h lgc.h lstring.h ltable.h lvm.h
-ltablib.o: ltablib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-ltm.o: ltm.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
- llimits.h ltm.h lzio.h lmem.h ldo.h lgc.h lstring.h ltable.h lvm.h
-lua.o: lua.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-luac.o: luac.c lprefix.h lua.h luaconf.h lauxlib.h ldebug.h lstate.h \
- lobject.h llimits.h ltm.h lzio.h lmem.h lopcodes.h lopnames.h lundump.h
-lundump.o: lundump.c lprefix.h lua.h luaconf.h ldebug.h lstate.h \
- lobject.h llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lstring.h lgc.h \
- lundump.h
-lutf8lib.o: lutf8lib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-lvm.o: lvm.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
- llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lstring.h \
- ltable.h lvm.h ljumptab.h
-lzio.o: lzio.c lprefix.h lua.h luaconf.h llimits.h lmem.h lstate.h \
- lobject.h ltm.h lzio.h
-
-# (end of Makefile)
diff --git a/third-party/lua/src/lapi.c b/third-party/lua/src/lapi.c
deleted file mode 100644
index 34e64af14..000000000
--- a/third-party/lua/src/lapi.c
+++ /dev/null
@@ -1,1463 +0,0 @@
-/*
-** $Id: lapi.c $
-** Lua API
-** See Copyright Notice in lua.h
-*/
-
-#define lapi_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <limits.h>
-#include <stdarg.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lapi.h"
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lgc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-#include "lundump.h"
-#include "lvm.h"
-
-
-
-const char lua_ident[] =
-  "$LuaVersion: " LUA_COPYRIGHT " $"
-  "$LuaAuthors: " LUA_AUTHORS " $";
-
-
-
-/*
-** Test for a valid index (one that is not the 'nilvalue').
-** '!ttisnil(o)' implies 'o != &G(L)->nilvalue', so it is not needed.
-** However, it covers the most common cases in a faster way.
-*/
-#define isvalid(L, o)	(!ttisnil(o) || o != &G(L)->nilvalue)
-
-
-/* test for pseudo index */
-#define ispseudo(i)		((i) <= LUA_REGISTRYINDEX)
-
-/* test for upvalue */
-#define isupvalue(i)		((i) < LUA_REGISTRYINDEX)
-
-
-/*
-** Convert an acceptable index to a pointer to its respective value.
-** Non-valid indices return the special nil value 'G(L)->nilvalue'.
-*/
-static TValue *index2value (lua_State *L, int idx) {
-  CallInfo *ci = L->ci;
-  if (idx > 0) {
-    StkId o = ci->func.p + idx;
-    api_check(L, idx <= ci->top.p - (ci->func.p + 1), "unacceptable index");
-    if (o >= L->top.p) return &G(L)->nilvalue;
-    else return s2v(o);
-  }
-  else if (!ispseudo(idx)) {  /* negative index */
-    api_check(L, idx != 0 && -idx <= L->top.p - (ci->func.p + 1),
-                 "invalid index");
-    return s2v(L->top.p + idx);
-  }
-  else if (idx == LUA_REGISTRYINDEX)
-    return &G(L)->l_registry;
-  else {  /* upvalues */
-    idx = LUA_REGISTRYINDEX - idx;
-    api_check(L, idx <= MAXUPVAL + 1, "upvalue index too large");
-    if (ttisCclosure(s2v(ci->func.p))) {  /* C closure? */
-      CClosure *func = clCvalue(s2v(ci->func.p));
-      return (idx <= func->nupvalues) ? &func->upvalue[idx-1]
-                                      : &G(L)->nilvalue;
-    }
-    else {  /* light C function or Lua function (through a hook)?) */
-      api_check(L, ttislcf(s2v(ci->func.p)), "caller not a C function");
-      return &G(L)->nilvalue;  /* no upvalues */
-    }
-  }
-}
-
-
-
-/*
-** Convert a valid actual index (not a pseudo-index) to its address.
-*/
-l_sinline StkId index2stack (lua_State *L, int idx) {
-  CallInfo *ci = L->ci;
-  if (idx > 0) {
-    StkId o = ci->func.p + idx;
-    api_check(L, o < L->top.p, "invalid index");
-    return o;
-  }
-  else {    /* non-positive index */
-    api_check(L, idx != 0 && -idx <= L->top.p - (ci->func.p + 1),
-                 "invalid index");
-    api_check(L, !ispseudo(idx), "invalid index");
-    return L->top.p + idx;
-  }
-}
-
-
-LUA_API int lua_checkstack (lua_State *L, int n) {
-  int res;
-  CallInfo *ci;
-  lua_lock(L);
-  ci = L->ci;
-  api_check(L, n >= 0, "negative 'n'");
-  if (L->stack_last.p - L->top.p > n)  /* stack large enough? */
-    res = 1;  /* yes; check is OK */
-  else  /* need to grow stack */
-    res = luaD_growstack(L, n, 0);
-  if (res && ci->top.p < L->top.p + n)
-    ci->top.p = L->top.p + n;  /* adjust frame top */
-  lua_unlock(L);
-  return res;
-}
-
-
-LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {
-  int i;
-  if (from == to) return;
-  lua_lock(to);
-  api_checknelems(from, n);
-  api_check(from, G(from) == G(to), "moving among independent states");
-  api_check(from, to->ci->top.p - to->top.p >= n, "stack overflow");
-  from->top.p -= n;
-  for (i = 0; i < n; i++) {
-    setobjs2s(to, to->top.p, from->top.p + i);
-    to->top.p++;  /* stack already checked by previous 'api_check' */
-  }
-  lua_unlock(to);
-}
-
-
-LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) {
-  lua_CFunction old;
-  lua_lock(L);
-  old = G(L)->panic;
-  G(L)->panic = panicf;
-  lua_unlock(L);
-  return old;
-}
-
-
-LUA_API lua_Number lua_version (lua_State *L) {
-  UNUSED(L);
-  return LUA_VERSION_NUM;
-}
-
-
-
-/*
-** basic stack manipulation
-*/
-
-
-/*
-** convert an acceptable stack index into an absolute index
-*/
-LUA_API int lua_absindex (lua_State *L, int idx) {
-  return (idx > 0 || ispseudo(idx))
-         ? idx
-         : cast_int(L->top.p - L->ci->func.p) + idx;
-}
-
-
-LUA_API int lua_gettop (lua_State *L) {
-  return cast_int(L->top.p - (L->ci->func.p + 1));
-}
-
-
-LUA_API void lua_settop (lua_State *L, int idx) {
-  CallInfo *ci;
-  StkId func, newtop;
-  ptrdiff_t diff;  /* difference for new top */
-  lua_lock(L);
-  ci = L->ci;
-  func = ci->func.p;
-  if (idx >= 0) {
-    api_check(L, idx <= ci->top.p - (func + 1), "new top too large");
-    diff = ((func + 1) + idx) - L->top.p;
-    for (; diff > 0; diff--)
-      setnilvalue(s2v(L->top.p++));  /* clear new slots */
-  }
-  else {
-    api_check(L, -(idx+1) <= (L->top.p - (func + 1)), "invalid new top");
-    diff = idx + 1;  /* will "subtract" index (as it is negative) */
-  }
-  api_check(L, L->tbclist.p < L->top.p, "previous pop of an unclosed slot");
-  newtop = L->top.p + diff;
-  if (diff < 0 && L->tbclist.p >= newtop) {
-    lua_assert(hastocloseCfunc(ci->nresults));
-    newtop = luaF_close(L, newtop, CLOSEKTOP, 0);
-  }
-  L->top.p = newtop;  /* correct top only after closing any upvalue */
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_closeslot (lua_State *L, int idx) {
-  StkId level;
-  lua_lock(L);
-  level = index2stack(L, idx);
-  api_check(L, hastocloseCfunc(L->ci->nresults) && L->tbclist.p == level,
-     "no variable to close at given level");
-  level = luaF_close(L, level, CLOSEKTOP, 0);
-  setnilvalue(s2v(level));
-  lua_unlock(L);
-}
-
-
-/*
-** Reverse the stack segment from 'from' to 'to'
-** (auxiliary to 'lua_rotate')
-** Note that we move(copy) only the value inside the stack.
-** (We do not move additional fields that may exist.)
-*/
-l_sinline void reverse (lua_State *L, StkId from, StkId to) {
-  for (; from < to; from++, to--) {
-    TValue temp;
-    setobj(L, &temp, s2v(from));
-    setobjs2s(L, from, to);
-    setobj2s(L, to, &temp);
-  }
-}
-
-
-/*
-** Let x = AB, where A is a prefix of length 'n'. Then,
-** rotate x n == BA. But BA == (A^r . B^r)^r.
-*/
-LUA_API void lua_rotate (lua_State *L, int idx, int n) {
-  StkId p, t, m;
-  lua_lock(L);
-  t = L->top.p - 1;  /* end of stack segment being rotated */
-  p = index2stack(L, idx);  /* start of segment */
-  api_check(L, (n >= 0 ? n : -n) <= (t - p + 1), "invalid 'n'");
-  m = (n >= 0 ? t - n : p - n - 1);  /* end of prefix */
-  reverse(L, p, m);  /* reverse the prefix with length 'n' */
-  reverse(L, m + 1, t);  /* reverse the suffix */
-  reverse(L, p, t);  /* reverse the entire segment */
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_copy (lua_State *L, int fromidx, int toidx) {
-  TValue *fr, *to;
-  lua_lock(L);
-  fr = index2value(L, fromidx);
-  to = index2value(L, toidx);
-  api_check(L, isvalid(L, to), "invalid index");
-  setobj(L, to, fr);
-  if (isupvalue(toidx))  /* function upvalue? */
-    luaC_barrier(L, clCvalue(s2v(L->ci->func.p)), fr);
-  /* LUA_REGISTRYINDEX does not need gc barrier
-     (collector revisits it before finishing collection) */
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushvalue (lua_State *L, int idx) {
-  lua_lock(L);
-  setobj2s(L, L->top.p, index2value(L, idx));
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-
-/*
-** access functions (stack -> C)
-*/
-
-
-LUA_API int lua_type (lua_State *L, int idx) {
-  const TValue *o = index2value(L, idx);
-  return (isvalid(L, o) ? ttype(o) : LUA_TNONE);
-}
-
-
-LUA_API const char *lua_typename (lua_State *L, int t) {
-  UNUSED(L);
-  api_check(L, LUA_TNONE <= t && t < LUA_NUMTYPES, "invalid type");
-  return ttypename(t);
-}
-
-
-LUA_API int lua_iscfunction (lua_State *L, int idx) {
-  const TValue *o = index2value(L, idx);
-  return (ttislcf(o) || (ttisCclosure(o)));
-}
-
-
-LUA_API int lua_isinteger (lua_State *L, int idx) {
-  const TValue *o = index2value(L, idx);
-  return ttisinteger(o);
-}
-
-
-LUA_API int lua_isnumber (lua_State *L, int idx) {
-  lua_Number n;
-  const TValue *o = index2value(L, idx);
-  return tonumber(o, &n);
-}
-
-
-LUA_API int lua_isstring (lua_State *L, int idx) {
-  const TValue *o = index2value(L, idx);
-  return (ttisstring(o) || cvt2str(o));
-}
-
-
-LUA_API int lua_isuserdata (lua_State *L, int idx) {
-  const TValue *o = index2value(L, idx);
-  return (ttisfulluserdata(o) || ttislightuserdata(o));
-}
-
-
-LUA_API int lua_rawequal (lua_State *L, int index1, int index2) {
-  const TValue *o1 = index2value(L, index1);
-  const TValue *o2 = index2value(L, index2);
-  return (isvalid(L, o1) && isvalid(L, o2)) ? luaV_rawequalobj(o1, o2) : 0;
-}
-
-
-LUA_API void lua_arith (lua_State *L, int op) {
-  lua_lock(L);
-  if (op != LUA_OPUNM && op != LUA_OPBNOT)
-    api_checknelems(L, 2);  /* all other operations expect two operands */
-  else {  /* for unary operations, add fake 2nd operand */
-    api_checknelems(L, 1);
-    setobjs2s(L, L->top.p, L->top.p - 1);
-    api_incr_top(L);
-  }
-  /* first operand at top - 2, second at top - 1; result go to top - 2 */
-  luaO_arith(L, op, s2v(L->top.p - 2), s2v(L->top.p - 1), L->top.p - 2);
-  L->top.p--;  /* remove second operand */
-  lua_unlock(L);
-}
-
-
-LUA_API int lua_compare (lua_State *L, int index1, int index2, int op) {
-  const TValue *o1;
-  const TValue *o2;
-  int i = 0;
-  lua_lock(L);  /* may call tag method */
-  o1 = index2value(L, index1);
-  o2 = index2value(L, index2);
-  if (isvalid(L, o1) && isvalid(L, o2)) {
-    switch (op) {
-      case LUA_OPEQ: i = luaV_equalobj(L, o1, o2); break;
-      case LUA_OPLT: i = luaV_lessthan(L, o1, o2); break;
-      case LUA_OPLE: i = luaV_lessequal(L, o1, o2); break;
-      default: api_check(L, 0, "invalid option");
-    }
-  }
-  lua_unlock(L);
-  return i;
-}
-
-
-LUA_API size_t lua_stringtonumber (lua_State *L, const char *s) {
-  size_t sz = luaO_str2num(s, s2v(L->top.p));
-  if (sz != 0)
-    api_incr_top(L);
-  return sz;
-}
-
-
-LUA_API lua_Number lua_tonumberx (lua_State *L, int idx, int *pisnum) {
-  lua_Number n = 0;
-  const TValue *o = index2value(L, idx);
-  int isnum = tonumber(o, &n);
-  if (pisnum)
-    *pisnum = isnum;
-  return n;
-}
-
-
-LUA_API lua_Integer lua_tointegerx (lua_State *L, int idx, int *pisnum) {
-  lua_Integer res = 0;
-  const TValue *o = index2value(L, idx);
-  int isnum = tointeger(o, &res);
-  if (pisnum)
-    *pisnum = isnum;
-  return res;
-}
-
-
-LUA_API int lua_toboolean (lua_State *L, int idx) {
-  const TValue *o = index2value(L, idx);
-  return !l_isfalse(o);
-}
-
-
-LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) {
-  TValue *o;
-  lua_lock(L);
-  o = index2value(L, idx);
-  if (!ttisstring(o)) {
-    if (!cvt2str(o)) {  /* not convertible? */
-      if (len != NULL) *len = 0;
-      lua_unlock(L);
-      return NULL;
-    }
-    luaO_tostring(L, o);
-    luaC_checkGC(L);
-    o = index2value(L, idx);  /* previous call may reallocate the stack */
-  }
-  if (len != NULL)
-    *len = vslen(o);
-  lua_unlock(L);
-  return svalue(o);
-}
-
-
-LUA_API lua_Unsigned lua_rawlen (lua_State *L, int idx) {
-  const TValue *o = index2value(L, idx);
-  switch (ttypetag(o)) {
-    case LUA_VSHRSTR: return tsvalue(o)->shrlen;
-    case LUA_VLNGSTR: return tsvalue(o)->u.lnglen;
-    case LUA_VUSERDATA: return uvalue(o)->len;
-    case LUA_VTABLE: return luaH_getn(hvalue(o));
-    default: return 0;
-  }
-}
-
-
-LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) {
-  const TValue *o = index2value(L, idx);
-  if (ttislcf(o)) return fvalue(o);
-  else if (ttisCclosure(o))
-    return clCvalue(o)->f;
-  else return NULL;  /* not a C function */
-}
-
-
-l_sinline void *touserdata (const TValue *o) {
-  switch (ttype(o)) {
-    case LUA_TUSERDATA: return getudatamem(uvalue(o));
-    case LUA_TLIGHTUSERDATA: return pvalue(o);
-    default: return NULL;
-  }
-}
-
-
-LUA_API void *lua_touserdata (lua_State *L, int idx) {
-  const TValue *o = index2value(L, idx);
-  return touserdata(o);
-}
-
-
-LUA_API lua_State *lua_tothread (lua_State *L, int idx) {
-  const TValue *o = index2value(L, idx);
-  return (!ttisthread(o)) ? NULL : thvalue(o);
-}
-
-
-/*
-** Returns a pointer to the internal representation of an object.
-** Note that ANSI C does not allow the conversion of a pointer to
-** function to a 'void*', so the conversion here goes through
-** a 'size_t'. (As the returned pointer is only informative, this
-** conversion should not be a problem.)
-*/
-LUA_API const void *lua_topointer (lua_State *L, int idx) {
-  const TValue *o = index2value(L, idx);
-  switch (ttypetag(o)) {
-    case LUA_VLCF: return cast_voidp(cast_sizet(fvalue(o)));
-    case LUA_VUSERDATA: case LUA_VLIGHTUSERDATA:
-      return touserdata(o);
-    default: {
-      if (iscollectable(o))
-        return gcvalue(o);
-      else
-        return NULL;
-    }
-  }
-}
-
-
-
-/*
-** push functions (C -> stack)
-*/
-
-
-LUA_API void lua_pushnil (lua_State *L) {
-  lua_lock(L);
-  setnilvalue(s2v(L->top.p));
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
-  lua_lock(L);
-  setfltvalue(s2v(L->top.p), n);
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {
-  lua_lock(L);
-  setivalue(s2v(L->top.p), n);
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-/*
-** Pushes on the stack a string with given length. Avoid using 's' when
-** 'len' == 0 (as 's' can be NULL in that case), due to later use of
-** 'memcmp' and 'memcpy'.
-*/
-LUA_API const char *lua_pushlstring (lua_State *L, const char *s, size_t len) {
-  TString *ts;
-  lua_lock(L);
-  ts = (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len);
-  setsvalue2s(L, L->top.p, ts);
-  api_incr_top(L);
-  luaC_checkGC(L);
-  lua_unlock(L);
-  return getstr(ts);
-}
-
-
-LUA_API const char *lua_pushstring (lua_State *L, const char *s) {
-  lua_lock(L);
-  if (s == NULL)
-    setnilvalue(s2v(L->top.p));
-  else {
-    TString *ts;
-    ts = luaS_new(L, s);
-    setsvalue2s(L, L->top.p, ts);
-    s = getstr(ts);  /* internal copy's address */
-  }
-  api_incr_top(L);
-  luaC_checkGC(L);
-  lua_unlock(L);
-  return s;
-}
-
-
-LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt,
-                                      va_list argp) {
-  const char *ret;
-  lua_lock(L);
-  ret = luaO_pushvfstring(L, fmt, argp);
-  luaC_checkGC(L);
-  lua_unlock(L);
-  return ret;
-}
-
-
-LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) {
-  const char *ret;
-  va_list argp;
-  lua_lock(L);
-  va_start(argp, fmt);
-  ret = luaO_pushvfstring(L, fmt, argp);
-  va_end(argp);
-  luaC_checkGC(L);
-  lua_unlock(L);
-  return ret;
-}
-
-
-LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
-  lua_lock(L);
-  if (n == 0) {
-    setfvalue(s2v(L->top.p), fn);
-    api_incr_top(L);
-  }
-  else {
-    CClosure *cl;
-    api_checknelems(L, n);
-    api_check(L, n <= MAXUPVAL, "upvalue index too large");
-    cl = luaF_newCclosure(L, n);
-    cl->f = fn;
-    L->top.p -= n;
-    while (n--) {
-      setobj2n(L, &cl->upvalue[n], s2v(L->top.p + n));
-      /* does not need barrier because closure is white */
-      lua_assert(iswhite(cl));
-    }
-    setclCvalue(L, s2v(L->top.p), cl);
-    api_incr_top(L);
-    luaC_checkGC(L);
-  }
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushboolean (lua_State *L, int b) {
-  lua_lock(L);
-  if (b)
-    setbtvalue(s2v(L->top.p));
-  else
-    setbfvalue(s2v(L->top.p));
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_pushlightuserdata (lua_State *L, void *p) {
-  lua_lock(L);
-  setpvalue(s2v(L->top.p), p);
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API int lua_pushthread (lua_State *L) {
-  lua_lock(L);
-  setthvalue(L, s2v(L->top.p), L);
-  api_incr_top(L);
-  lua_unlock(L);
-  return (G(L)->mainthread == L);
-}
-
-
-
-/*
-** get functions (Lua -> stack)
-*/
-
-
-l_sinline int auxgetstr (lua_State *L, const TValue *t, const char *k) {
-  const TValue *slot;
-  TString *str = luaS_new(L, k);
-  if (luaV_fastget(L, t, str, slot, luaH_getstr)) {
-    setobj2s(L, L->top.p, slot);
-    api_incr_top(L);
-  }
-  else {
-    setsvalue2s(L, L->top.p, str);
-    api_incr_top(L);
-    luaV_finishget(L, t, s2v(L->top.p - 1), L->top.p - 1, slot);
-  }
-  lua_unlock(L);
-  return ttype(s2v(L->top.p - 1));
-}
-
-
-/*
-** Get the global table in the registry. Since all predefined
-** indices in the registry were inserted right when the registry
-** was created and never removed, they must always be in the array
-** part of the registry.
-*/
-#define getGtable(L)  \
-	(&hvalue(&G(L)->l_registry)->array[LUA_RIDX_GLOBALS - 1])
-
-
-LUA_API int lua_getglobal (lua_State *L, const char *name) {
-  const TValue *G;
-  lua_lock(L);
-  G = getGtable(L);
-  return auxgetstr(L, G, name);
-}
-
-
-LUA_API int lua_gettable (lua_State *L, int idx) {
-  const TValue *slot;
-  TValue *t;
-  lua_lock(L);
-  t = index2value(L, idx);
-  if (luaV_fastget(L, t, s2v(L->top.p - 1), slot, luaH_get)) {
-    setobj2s(L, L->top.p - 1, slot);
-  }
-  else
-    luaV_finishget(L, t, s2v(L->top.p - 1), L->top.p - 1, slot);
-  lua_unlock(L);
-  return ttype(s2v(L->top.p - 1));
-}
-
-
-LUA_API int lua_getfield (lua_State *L, int idx, const char *k) {
-  lua_lock(L);
-  return auxgetstr(L, index2value(L, idx), k);
-}
-
-
-LUA_API int lua_geti (lua_State *L, int idx, lua_Integer n) {
-  TValue *t;
-  const TValue *slot;
-  lua_lock(L);
-  t = index2value(L, idx);
-  if (luaV_fastgeti(L, t, n, slot)) {
-    setobj2s(L, L->top.p, slot);
-  }
-  else {
-    TValue aux;
-    setivalue(&aux, n);
-    luaV_finishget(L, t, &aux, L->top.p, slot);
-  }
-  api_incr_top(L);
-  lua_unlock(L);
-  return ttype(s2v(L->top.p - 1));
-}
-
-
-l_sinline int finishrawget (lua_State *L, const TValue *val) {
-  if (isempty(val))  /* avoid copying empty items to the stack */
-    setnilvalue(s2v(L->top.p));
-  else
-    setobj2s(L, L->top.p, val);
-  api_incr_top(L);
-  lua_unlock(L);
-  return ttype(s2v(L->top.p - 1));
-}
-
-
-static Table *gettable (lua_State *L, int idx) {
-  TValue *t = index2value(L, idx);
-  api_check(L, ttistable(t), "table expected");
-  return hvalue(t);
-}
-
-
-LUA_API int lua_rawget (lua_State *L, int idx) {
-  Table *t;
-  const TValue *val;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  t = gettable(L, idx);
-  val = luaH_get(t, s2v(L->top.p - 1));
-  L->top.p--;  /* remove key */
-  return finishrawget(L, val);
-}
-
-
-LUA_API int lua_rawgeti (lua_State *L, int idx, lua_Integer n) {
-  Table *t;
-  lua_lock(L);
-  t = gettable(L, idx);
-  return finishrawget(L, luaH_getint(t, n));
-}
-
-
-LUA_API int lua_rawgetp (lua_State *L, int idx, const void *p) {
-  Table *t;
-  TValue k;
-  lua_lock(L);
-  t = gettable(L, idx);
-  setpvalue(&k, cast_voidp(p));
-  return finishrawget(L, luaH_get(t, &k));
-}
-
-
-LUA_API void lua_createtable (lua_State *L, int narray, int nrec) {
-  Table *t;
-  lua_lock(L);
-  t = luaH_new(L);
-  sethvalue2s(L, L->top.p, t);
-  api_incr_top(L);
-  if (narray > 0 || nrec > 0)
-    luaH_resize(L, t, narray, nrec);
-  luaC_checkGC(L);
-  lua_unlock(L);
-}
-
-
-LUA_API int lua_getmetatable (lua_State *L, int objindex) {
-  const TValue *obj;
-  Table *mt;
-  int res = 0;
-  lua_lock(L);
-  obj = index2value(L, objindex);
-  switch (ttype(obj)) {
-    case LUA_TTABLE:
-      mt = hvalue(obj)->metatable;
-      break;
-    case LUA_TUSERDATA:
-      mt = uvalue(obj)->metatable;
-      break;
-    default:
-      mt = G(L)->mt[ttype(obj)];
-      break;
-  }
-  if (mt != NULL) {
-    sethvalue2s(L, L->top.p, mt);
-    api_incr_top(L);
-    res = 1;
-  }
-  lua_unlock(L);
-  return res;
-}
-
-
-LUA_API int lua_getiuservalue (lua_State *L, int idx, int n) {
-  TValue *o;
-  int t;
-  lua_lock(L);
-  o = index2value(L, idx);
-  api_check(L, ttisfulluserdata(o), "full userdata expected");
-  if (n <= 0 || n > uvalue(o)->nuvalue) {
-    setnilvalue(s2v(L->top.p));
-    t = LUA_TNONE;
-  }
-  else {
-    setobj2s(L, L->top.p, &uvalue(o)->uv[n - 1].uv);
-    t = ttype(s2v(L->top.p));
-  }
-  api_incr_top(L);
-  lua_unlock(L);
-  return t;
-}
-
-
-/*
-** set functions (stack -> Lua)
-*/
-
-/*
-** t[k] = value at the top of the stack (where 'k' is a string)
-*/
-static void auxsetstr (lua_State *L, const TValue *t, const char *k) {
-  const TValue *slot;
-  TString *str = luaS_new(L, k);
-  api_checknelems(L, 1);
-  if (luaV_fastget(L, t, str, slot, luaH_getstr)) {
-    luaV_finishfastset(L, t, slot, s2v(L->top.p - 1));
-    L->top.p--;  /* pop value */
-  }
-  else {
-    setsvalue2s(L, L->top.p, str);  /* push 'str' (to make it a TValue) */
-    api_incr_top(L);
-    luaV_finishset(L, t, s2v(L->top.p - 1), s2v(L->top.p - 2), slot);
-    L->top.p -= 2;  /* pop value and key */
-  }
-  lua_unlock(L);  /* lock done by caller */
-}
-
-
-LUA_API void lua_setglobal (lua_State *L, const char *name) {
-  const TValue *G;
-  lua_lock(L);  /* unlock done in 'auxsetstr' */
-  G = getGtable(L);
-  auxsetstr(L, G, name);
-}
-
-
-LUA_API void lua_settable (lua_State *L, int idx) {
-  TValue *t;
-  const TValue *slot;
-  lua_lock(L);
-  api_checknelems(L, 2);
-  t = index2value(L, idx);
-  if (luaV_fastget(L, t, s2v(L->top.p - 2), slot, luaH_get)) {
-    luaV_finishfastset(L, t, slot, s2v(L->top.p - 1));
-  }
-  else
-    luaV_finishset(L, t, s2v(L->top.p - 2), s2v(L->top.p - 1), slot);
-  L->top.p -= 2;  /* pop index and value */
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_setfield (lua_State *L, int idx, const char *k) {
-  lua_lock(L);  /* unlock done in 'auxsetstr' */
-  auxsetstr(L, index2value(L, idx), k);
-}
-
-
-LUA_API void lua_seti (lua_State *L, int idx, lua_Integer n) {
-  TValue *t;
-  const TValue *slot;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  t = index2value(L, idx);
-  if (luaV_fastgeti(L, t, n, slot)) {
-    luaV_finishfastset(L, t, slot, s2v(L->top.p - 1));
-  }
-  else {
-    TValue aux;
-    setivalue(&aux, n);
-    luaV_finishset(L, t, &aux, s2v(L->top.p - 1), slot);
-  }
-  L->top.p--;  /* pop value */
-  lua_unlock(L);
-}
-
-
-static void aux_rawset (lua_State *L, int idx, TValue *key, int n) {
-  Table *t;
-  lua_lock(L);
-  api_checknelems(L, n);
-  t = gettable(L, idx);
-  luaH_set(L, t, key, s2v(L->top.p - 1));
-  invalidateTMcache(t);
-  luaC_barrierback(L, obj2gco(t), s2v(L->top.p - 1));
-  L->top.p -= n;
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_rawset (lua_State *L, int idx) {
-  aux_rawset(L, idx, s2v(L->top.p - 2), 2);
-}
-
-
-LUA_API void lua_rawsetp (lua_State *L, int idx, const void *p) {
-  TValue k;
-  setpvalue(&k, cast_voidp(p));
-  aux_rawset(L, idx, &k, 1);
-}
-
-
-LUA_API void lua_rawseti (lua_State *L, int idx, lua_Integer n) {
-  Table *t;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  t = gettable(L, idx);
-  luaH_setint(L, t, n, s2v(L->top.p - 1));
-  luaC_barrierback(L, obj2gco(t), s2v(L->top.p - 1));
-  L->top.p--;
-  lua_unlock(L);
-}
-
-
-LUA_API int lua_setmetatable (lua_State *L, int objindex) {
-  TValue *obj;
-  Table *mt;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  obj = index2value(L, objindex);
-  if (ttisnil(s2v(L->top.p - 1)))
-    mt = NULL;
-  else {
-    api_check(L, ttistable(s2v(L->top.p - 1)), "table expected");
-    mt = hvalue(s2v(L->top.p - 1));
-  }
-  switch (ttype(obj)) {
-    case LUA_TTABLE: {
-      hvalue(obj)->metatable = mt;
-      if (mt) {
-        luaC_objbarrier(L, gcvalue(obj), mt);
-        luaC_checkfinalizer(L, gcvalue(obj), mt);
-      }
-      break;
-    }
-    case LUA_TUSERDATA: {
-      uvalue(obj)->metatable = mt;
-      if (mt) {
-        luaC_objbarrier(L, uvalue(obj), mt);
-        luaC_checkfinalizer(L, gcvalue(obj), mt);
-      }
-      break;
-    }
-    default: {
-      G(L)->mt[ttype(obj)] = mt;
-      break;
-    }
-  }
-  L->top.p--;
-  lua_unlock(L);
-  return 1;
-}
-
-
-LUA_API int lua_setiuservalue (lua_State *L, int idx, int n) {
-  TValue *o;
-  int res;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  o = index2value(L, idx);
-  api_check(L, ttisfulluserdata(o), "full userdata expected");
-  if (!(cast_uint(n) - 1u < cast_uint(uvalue(o)->nuvalue)))
-    res = 0;  /* 'n' not in [1, uvalue(o)->nuvalue] */
-  else {
-    setobj(L, &uvalue(o)->uv[n - 1].uv, s2v(L->top.p - 1));
-    luaC_barrierback(L, gcvalue(o), s2v(L->top.p - 1));
-    res = 1;
-  }
-  L->top.p--;
-  lua_unlock(L);
-  return res;
-}
-
-
-/*
-** 'load' and 'call' functions (run Lua code)
-*/
-
-
-#define checkresults(L,na,nr) \
-     api_check(L, (nr) == LUA_MULTRET \
-               || (L->ci->top.p - L->top.p >= (nr) - (na)), \
-	"results from function overflow current stack size")
-
-
-LUA_API void lua_callk (lua_State *L, int nargs, int nresults,
-                        lua_KContext ctx, lua_KFunction k) {
-  StkId func;
-  lua_lock(L);
-  api_check(L, k == NULL || !isLua(L->ci),
-    "cannot use continuations inside hooks");
-  api_checknelems(L, nargs+1);
-  api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread");
-  checkresults(L, nargs, nresults);
-  func = L->top.p - (nargs+1);
-  if (k != NULL && yieldable(L)) {  /* need to prepare continuation? */
-    L->ci->u.c.k = k;  /* save continuation */
-    L->ci->u.c.ctx = ctx;  /* save context */
-    luaD_call(L, func, nresults);  /* do the call */
-  }
-  else  /* no continuation or no yieldable */
-    luaD_callnoyield(L, func, nresults);  /* just do the call */
-  adjustresults(L, nresults);
-  lua_unlock(L);
-}
-
-
-
-/*
-** Execute a protected call.
-*/
-struct CallS {  /* data to 'f_call' */
-  StkId func;
-  int nresults;
-};
-
-
-static void f_call (lua_State *L, void *ud) {
-  struct CallS *c = cast(struct CallS *, ud);
-  luaD_callnoyield(L, c->func, c->nresults);
-}
-
-
-
-LUA_API int lua_pcallk (lua_State *L, int nargs, int nresults, int errfunc,
-                        lua_KContext ctx, lua_KFunction k) {
-  struct CallS c;
-  int status;
-  ptrdiff_t func;
-  lua_lock(L);
-  api_check(L, k == NULL || !isLua(L->ci),
-    "cannot use continuations inside hooks");
-  api_checknelems(L, nargs+1);
-  api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread");
-  checkresults(L, nargs, nresults);
-  if (errfunc == 0)
-    func = 0;
-  else {
-    StkId o = index2stack(L, errfunc);
-    api_check(L, ttisfunction(s2v(o)), "error handler must be a function");
-    func = savestack(L, o);
-  }
-  c.func = L->top.p - (nargs+1);  /* function to be called */
-  if (k == NULL || !yieldable(L)) {  /* no continuation or no yieldable? */
-    c.nresults = nresults;  /* do a 'conventional' protected call */
-    status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
-  }
-  else {  /* prepare continuation (call is already protected by 'resume') */
-    CallInfo *ci = L->ci;
-    ci->u.c.k = k;  /* save continuation */
-    ci->u.c.ctx = ctx;  /* save context */
-    /* save information for error recovery */
-    ci->u2.funcidx = cast_int(savestack(L, c.func));
-    ci->u.c.old_errfunc = L->errfunc;
-    L->errfunc = func;
-    setoah(ci->callstatus, L->allowhook);  /* save value of 'allowhook' */
-    ci->callstatus |= CIST_YPCALL;  /* function can do error recovery */
-    luaD_call(L, c.func, nresults);  /* do the call */
-    ci->callstatus &= ~CIST_YPCALL;
-    L->errfunc = ci->u.c.old_errfunc;
-    status = LUA_OK;  /* if it is here, there were no errors */
-  }
-  adjustresults(L, nresults);
-  lua_unlock(L);
-  return status;
-}
-
-
-LUA_API int lua_load (lua_State *L, lua_Reader reader, void *data,
-                      const char *chunkname, const char *mode) {
-  ZIO z;
-  int status;
-  lua_lock(L);
-  if (!chunkname) chunkname = "?";
-  luaZ_init(L, &z, reader, data);
-  status = luaD_protectedparser(L, &z, chunkname, mode);
-  if (status == LUA_OK) {  /* no errors? */
-    LClosure *f = clLvalue(s2v(L->top.p - 1));  /* get new function */
-    if (f->nupvalues >= 1) {  /* does it have an upvalue? */
-      /* get global table from registry */
-      const TValue *gt = getGtable(L);
-      /* set global table as 1st upvalue of 'f' (may be LUA_ENV) */
-      setobj(L, f->upvals[0]->v.p, gt);
-      luaC_barrier(L, f->upvals[0], gt);
-    }
-  }
-  lua_unlock(L);
-  return status;
-}
-
-
-LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data, int strip) {
-  int status;
-  TValue *o;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  o = s2v(L->top.p - 1);
-  if (isLfunction(o))
-    status = luaU_dump(L, getproto(o), writer, data, strip);
-  else
-    status = 1;
-  lua_unlock(L);
-  return status;
-}
-
-
-LUA_API int lua_status (lua_State *L) {
-  return L->status;
-}
-
-
-/*
-** Garbage-collection function
-*/
-LUA_API int lua_gc (lua_State *L, int what, ...) {
-  va_list argp;
-  int res = 0;
-  global_State *g = G(L);
-  if (g->gcstp & GCSTPGC)  /* internal stop? */
-    return -1;  /* all options are invalid when stopped */
-  lua_lock(L);
-  va_start(argp, what);
-  switch (what) {
-    case LUA_GCSTOP: {
-      g->gcstp = GCSTPUSR;  /* stopped by the user */
-      break;
-    }
-    case LUA_GCRESTART: {
-      luaE_setdebt(g, 0);
-      g->gcstp = 0;  /* (GCSTPGC must be already zero here) */
-      break;
-    }
-    case LUA_GCCOLLECT: {
-      luaC_fullgc(L, 0);
-      break;
-    }
-    case LUA_GCCOUNT: {
-      /* GC values are expressed in Kbytes: #bytes/2^10 */
-      res = cast_int(gettotalbytes(g) >> 10);
-      break;
-    }
-    case LUA_GCCOUNTB: {
-      res = cast_int(gettotalbytes(g) & 0x3ff);
-      break;
-    }
-    case LUA_GCSTEP: {
-      int data = va_arg(argp, int);
-      l_mem debt = 1;  /* =1 to signal that it did an actual step */
-      lu_byte oldstp = g->gcstp;
-      g->gcstp = 0;  /* allow GC to run (GCSTPGC must be zero here) */
-      if (data == 0) {
-        luaE_setdebt(g, 0);  /* do a basic step */
-        luaC_step(L);
-      }
-      else {  /* add 'data' to total debt */
-        debt = cast(l_mem, data) * 1024 + g->GCdebt;
-        luaE_setdebt(g, debt);
-        luaC_checkGC(L);
-      }
-      g->gcstp = oldstp;  /* restore previous state */
-      if (debt > 0 && g->gcstate == GCSpause)  /* end of cycle? */
-        res = 1;  /* signal it */
-      break;
-    }
-    case LUA_GCSETPAUSE: {
-      int data = va_arg(argp, int);
-      res = getgcparam(g->gcpause);
-      setgcparam(g->gcpause, data);
-      break;
-    }
-    case LUA_GCSETSTEPMUL: {
-      int data = va_arg(argp, int);
-      res = getgcparam(g->gcstepmul);
-      setgcparam(g->gcstepmul, data);
-      break;
-    }
-    case LUA_GCISRUNNING: {
-      res = gcrunning(g);
-      break;
-    }
-    case LUA_GCGEN: {
-      int minormul = va_arg(argp, int);
-      int majormul = va_arg(argp, int);
-      res = isdecGCmodegen(g) ? LUA_GCGEN : LUA_GCINC;
-      if (minormul != 0)
-        g->genminormul = minormul;
-      if (majormul != 0)
-        setgcparam(g->genmajormul, majormul);
-      luaC_changemode(L, KGC_GEN);
-      break;
-    }
-    case LUA_GCINC: {
-      int pause = va_arg(argp, int);
-      int stepmul = va_arg(argp, int);
-      int stepsize = va_arg(argp, int);
-      res = isdecGCmodegen(g) ? LUA_GCGEN : LUA_GCINC;
-      if (pause != 0)
-        setgcparam(g->gcpause, pause);
-      if (stepmul != 0)
-        setgcparam(g->gcstepmul, stepmul);
-      if (stepsize != 0)
-        g->gcstepsize = stepsize;
-      luaC_changemode(L, KGC_INC);
-      break;
-    }
-    default: res = -1;  /* invalid option */
-  }
-  va_end(argp);
-  lua_unlock(L);
-  return res;
-}
-
-
-
-/*
-** miscellaneous functions
-*/
-
-
-LUA_API int lua_error (lua_State *L) {
-  TValue *errobj;
-  lua_lock(L);
-  errobj = s2v(L->top.p - 1);
-  api_checknelems(L, 1);
-  /* error object is the memory error message? */
-  if (ttisshrstring(errobj) && eqshrstr(tsvalue(errobj), G(L)->memerrmsg))
-    luaM_error(L);  /* raise a memory error */
-  else
-    luaG_errormsg(L);  /* raise a regular error */
-  /* code unreachable; will unlock when control actually leaves the kernel */
-  return 0;  /* to avoid warnings */
-}
-
-
-LUA_API int lua_next (lua_State *L, int idx) {
-  Table *t;
-  int more;
-  lua_lock(L);
-  api_checknelems(L, 1);
-  t = gettable(L, idx);
-  more = luaH_next(L, t, L->top.p - 1);
-  if (more) {
-    api_incr_top(L);
-  }
-  else  /* no more elements */
-    L->top.p -= 1;  /* remove key */
-  lua_unlock(L);
-  return more;
-}
-
-
-LUA_API void lua_toclose (lua_State *L, int idx) {
-  int nresults;
-  StkId o;
-  lua_lock(L);
-  o = index2stack(L, idx);
-  nresults = L->ci->nresults;
-  api_check(L, L->tbclist.p < o, "given index below or equal a marked one");
-  luaF_newtbcupval(L, o);  /* create new to-be-closed upvalue */
-  if (!hastocloseCfunc(nresults))  /* function not marked yet? */
-    L->ci->nresults = codeNresults(nresults);  /* mark it */
-  lua_assert(hastocloseCfunc(L->ci->nresults));
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_concat (lua_State *L, int n) {
-  lua_lock(L);
-  api_checknelems(L, n);
-  if (n > 0)
-    luaV_concat(L, n);
-  else {  /* nothing to concatenate */
-    setsvalue2s(L, L->top.p, luaS_newlstr(L, "", 0));  /* push empty string */
-    api_incr_top(L);
-  }
-  luaC_checkGC(L);
-  lua_unlock(L);
-}
-
-
-LUA_API void lua_len (lua_State *L, int idx) {
-  TValue *t;
-  lua_lock(L);
-  t = index2value(L, idx);
-  luaV_objlen(L, L->top.p, t);
-  api_incr_top(L);
-  lua_unlock(L);
-}
-
-
-LUA_API lua_Alloc lua_getallocf (lua_State *L, void **ud) {
-  lua_Alloc f;
-  lua_lock(L);
-  if (ud) *ud = G(L)->ud;
-  f = G(L)->frealloc;
-  lua_unlock(L);
-  return f;
-}
-
-
-LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud) {
-  lua_lock(L);
-  G(L)->ud = ud;
-  G(L)->frealloc = f;
-  lua_unlock(L);
-}
-
-
-void lua_setwarnf (lua_State *L, lua_WarnFunction f, void *ud) {
-  lua_lock(L);
-  G(L)->ud_warn = ud;
-  G(L)->warnf = f;
-  lua_unlock(L);
-}
-
-
-void lua_warning (lua_State *L, const char *msg, int tocont) {
-  lua_lock(L);
-  luaE_warning(L, msg, tocont);
-  lua_unlock(L);
-}
-
-
-
-LUA_API void *lua_newuserdatauv (lua_State *L, size_t size, int nuvalue) {
-  Udata *u;
-  lua_lock(L);
-  api_check(L, 0 <= nuvalue && nuvalue < USHRT_MAX, "invalid value");
-  u = luaS_newudata(L, size, nuvalue);
-  setuvalue(L, s2v(L->top.p), u);
-  api_incr_top(L);
-  luaC_checkGC(L);
-  lua_unlock(L);
-  return getudatamem(u);
-}
-
-
-
-static const char *aux_upvalue (TValue *fi, int n, TValue **val,
-                                GCObject **owner) {
-  switch (ttypetag(fi)) {
-    case LUA_VCCL: {  /* C closure */
-      CClosure *f = clCvalue(fi);
-      if (!(cast_uint(n) - 1u < cast_uint(f->nupvalues)))
-        return NULL;  /* 'n' not in [1, f->nupvalues] */
-      *val = &f->upvalue[n-1];
-      if (owner) *owner = obj2gco(f);
-      return "";
-    }
-    case LUA_VLCL: {  /* Lua closure */
-      LClosure *f = clLvalue(fi);
-      TString *name;
-      Proto *p = f->p;
-      if (!(cast_uint(n) - 1u  < cast_uint(p->sizeupvalues)))
-        return NULL;  /* 'n' not in [1, p->sizeupvalues] */
-      *val = f->upvals[n-1]->v.p;
-      if (owner) *owner = obj2gco(f->upvals[n - 1]);
-      name = p->upvalues[n-1].name;
-      return (name == NULL) ? "(no name)" : getstr(name);
-    }
-    default: return NULL;  /* not a closure */
-  }
-}
-
-
-LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) {
-  const char *name;
-  TValue *val = NULL;  /* to avoid warnings */
-  lua_lock(L);
-  name = aux_upvalue(index2value(L, funcindex), n, &val, NULL);
-  if (name) {
-    setobj2s(L, L->top.p, val);
-    api_incr_top(L);
-  }
-  lua_unlock(L);
-  return name;
-}
-
-
-LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {
-  const char *name;
-  TValue *val = NULL;  /* to avoid warnings */
-  GCObject *owner = NULL;  /* to avoid warnings */
-  TValue *fi;
-  lua_lock(L);
-  fi = index2value(L, funcindex);
-  api_checknelems(L, 1);
-  name = aux_upvalue(fi, n, &val, &owner);
-  if (name) {
-    L->top.p--;
-    setobj(L, val, s2v(L->top.p));
-    luaC_barrier(L, owner, val);
-  }
-  lua_unlock(L);
-  return name;
-}
-
-
-static UpVal **getupvalref (lua_State *L, int fidx, int n, LClosure **pf) {
-  static const UpVal *const nullup = NULL;
-  LClosure *f;
-  TValue *fi = index2value(L, fidx);
-  api_check(L, ttisLclosure(fi), "Lua function expected");
-  f = clLvalue(fi);
-  if (pf) *pf = f;
-  if (1 <= n && n <= f->p->sizeupvalues)
-    return &f->upvals[n - 1];  /* get its upvalue pointer */
-  else
-    return (UpVal**)&nullup;
-}
-
-
-LUA_API void *lua_upvalueid (lua_State *L, int fidx, int n) {
-  TValue *fi = index2value(L, fidx);
-  switch (ttypetag(fi)) {
-    case LUA_VLCL: {  /* lua closure */
-      return *getupvalref(L, fidx, n, NULL);
-    }
-    case LUA_VCCL: {  /* C closure */
-      CClosure *f = clCvalue(fi);
-      if (1 <= n && n <= f->nupvalues)
-        return &f->upvalue[n - 1];
-      /* else */
-    }  /* FALLTHROUGH */
-    case LUA_VLCF:
-      return NULL;  /* light C functions have no upvalues */
-    default: {
-      api_check(L, 0, "function expected");
-      return NULL;
-    }
-  }
-}
-
-
-LUA_API void lua_upvaluejoin (lua_State *L, int fidx1, int n1,
-                                            int fidx2, int n2) {
-  LClosure *f1;
-  UpVal **up1 = getupvalref(L, fidx1, n1, &f1);
-  UpVal **up2 = getupvalref(L, fidx2, n2, NULL);
-  api_check(L, *up1 != NULL && *up2 != NULL, "invalid upvalue index");
-  *up1 = *up2;
-  luaC_objbarrier(L, f1, *up1);
-}
-
-
diff --git a/third-party/lua/src/lapi.h b/third-party/lua/src/lapi.h
deleted file mode 100644
index a742427cd..000000000
--- a/third-party/lua/src/lapi.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-** $Id: lapi.h $
-** Auxiliary functions from Lua API
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lapi_h
-#define lapi_h
-
-
-#include "llimits.h"
-#include "lstate.h"
-
-
-/* Increments 'L->top.p', checking for stack overflows */
-#define api_incr_top(L)	{L->top.p++; \
-			 api_check(L, L->top.p <= L->ci->top.p, \
-					"stack overflow");}
-
-
-/*
-** If a call returns too many multiple returns, the callee may not have
-** stack space to accommodate all results. In this case, this macro
-** increases its stack space ('L->ci->top.p').
-*/
-#define adjustresults(L,nres) \
-    { if ((nres) <= LUA_MULTRET && L->ci->top.p < L->top.p) \
-	L->ci->top.p = L->top.p; }
-
-
-/* Ensure the stack has at least 'n' elements */
-#define api_checknelems(L,n) \
-	api_check(L, (n) < (L->top.p - L->ci->func.p), \
-			  "not enough elements in the stack")
-
-
-/*
-** To reduce the overhead of returning from C functions, the presence of
-** to-be-closed variables in these functions is coded in the CallInfo's
-** field 'nresults', in a way that functions with no to-be-closed variables
-** with zero, one, or "all" wanted results have no overhead. Functions
-** with other number of wanted results, as well as functions with
-** variables to be closed, have an extra check.
-*/
-
-#define hastocloseCfunc(n)	((n) < LUA_MULTRET)
-
-/* Map [-1, inf) (range of 'nresults') into (-inf, -2] */
-#define codeNresults(n)		(-(n) - 3)
-#define decodeNresults(n)	(-(n) - 3)
-
-#endif
diff --git a/third-party/lua/src/lauxlib.c b/third-party/lua/src/lauxlib.c
deleted file mode 100644
index 4ca6c6548..000000000
--- a/third-party/lua/src/lauxlib.c
+++ /dev/null
@@ -1,1112 +0,0 @@
-/*
-** $Id: lauxlib.c $
-** Auxiliary functions for building Lua libraries
-** See Copyright Notice in lua.h
-*/
-
-#define lauxlib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <errno.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-
-/*
-** This file uses only the official API of Lua.
-** Any function declared here could be written as an application function.
-*/
-
-#include "lua.h"
-
-#include "lauxlib.h"
-
-
-#if !defined(MAX_SIZET)
-/* maximum value for size_t */
-#define MAX_SIZET	((size_t)(~(size_t)0))
-#endif
-
-
-/*
-** {======================================================
-** Traceback
-** =======================================================
-*/
-
-
-#define LEVELS1	10	/* size of the first part of the stack */
-#define LEVELS2	11	/* size of the second part of the stack */
-
-
-
-/*
-** Search for 'objidx' in table at index -1. ('objidx' must be an
-** absolute index.) Return 1 + string at top if it found a good name.
-*/
-static int findfield (lua_State *L, int objidx, int level) {
-  if (level == 0 || !lua_istable(L, -1))
-    return 0;  /* not found */
-  lua_pushnil(L);  /* start 'next' loop */
-  while (lua_next(L, -2)) {  /* for each pair in table */
-    if (lua_type(L, -2) == LUA_TSTRING) {  /* ignore non-string keys */
-      if (lua_rawequal(L, objidx, -1)) {  /* found object? */
-        lua_pop(L, 1);  /* remove value (but keep name) */
-        return 1;
-      }
-      else if (findfield(L, objidx, level - 1)) {  /* try recursively */
-        /* stack: lib_name, lib_table, field_name (top) */
-        lua_pushliteral(L, ".");  /* place '.' between the two names */
-        lua_replace(L, -3);  /* (in the slot occupied by table) */
-        lua_concat(L, 3);  /* lib_name.field_name */
-        return 1;
-      }
-    }
-    lua_pop(L, 1);  /* remove value */
-  }
-  return 0;  /* not found */
-}
-
-
-/*
-** Search for a name for a function in all loaded modules
-*/
-static int pushglobalfuncname (lua_State *L, lua_Debug *ar) {
-  int top = lua_gettop(L);
-  lua_getinfo(L, "f", ar);  /* push function */
-  lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
-  if (findfield(L, top + 1, 2)) {
-    const char *name = lua_tostring(L, -1);
-    if (strncmp(name, LUA_GNAME ".", 3) == 0) {  /* name start with '_G.'? */
-      lua_pushstring(L, name + 3);  /* push name without prefix */
-      lua_remove(L, -2);  /* remove original name */
-    }
-    lua_copy(L, -1, top + 1);  /* copy name to proper place */
-    lua_settop(L, top + 1);  /* remove table "loaded" and name copy */
-    return 1;
-  }
-  else {
-    lua_settop(L, top);  /* remove function and global table */
-    return 0;
-  }
-}
-
-
-static void pushfuncname (lua_State *L, lua_Debug *ar) {
-  if (pushglobalfuncname(L, ar)) {  /* try first a global name */
-    lua_pushfstring(L, "function '%s'", lua_tostring(L, -1));
-    lua_remove(L, -2);  /* remove name */
-  }
-  else if (*ar->namewhat != '\0')  /* is there a name from code? */
-    lua_pushfstring(L, "%s '%s'", ar->namewhat, ar->name);  /* use it */
-  else if (*ar->what == 'm')  /* main? */
-      lua_pushliteral(L, "main chunk");
-  else if (*ar->what != 'C')  /* for Lua functions, use <file:line> */
-    lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined);
-  else  /* nothing left... */
-    lua_pushliteral(L, "?");
-}
-
-
-static int lastlevel (lua_State *L) {
-  lua_Debug ar;
-  int li = 1, le = 1;
-  /* find an upper bound */
-  while (lua_getstack(L, le, &ar)) { li = le; le *= 2; }
-  /* do a binary search */
-  while (li < le) {
-    int m = (li + le)/2;
-    if (lua_getstack(L, m, &ar)) li = m + 1;
-    else le = m;
-  }
-  return le - 1;
-}
-
-
-LUALIB_API void luaL_traceback (lua_State *L, lua_State *L1,
-                                const char *msg, int level) {
-  luaL_Buffer b;
-  lua_Debug ar;
-  int last = lastlevel(L1);
-  int limit2show = (last - level > LEVELS1 + LEVELS2) ? LEVELS1 : -1;
-  luaL_buffinit(L, &b);
-  if (msg) {
-    luaL_addstring(&b, msg);
-    luaL_addchar(&b, '\n');
-  }
-  luaL_addstring(&b, "stack traceback:");
-  while (lua_getstack(L1, level++, &ar)) {
-    if (limit2show-- == 0) {  /* too many levels? */
-      int n = last - level - LEVELS2 + 1;  /* number of levels to skip */
-      lua_pushfstring(L, "\n\t...\t(skipping %d levels)", n);
-      luaL_addvalue(&b);  /* add warning about skip */
-      level += n;  /* and skip to last levels */
-    }
-    else {
-      lua_getinfo(L1, "Slnt", &ar);
-      if (ar.currentline <= 0)
-        lua_pushfstring(L, "\n\t%s: in ", ar.short_src);
-      else
-        lua_pushfstring(L, "\n\t%s:%d: in ", ar.short_src, ar.currentline);
-      luaL_addvalue(&b);
-      pushfuncname(L, &ar);
-      luaL_addvalue(&b);
-      if (ar.istailcall)
-        luaL_addstring(&b, "\n\t(...tail calls...)");
-    }
-  }
-  luaL_pushresult(&b);
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Error-report functions
-** =======================================================
-*/
-
-LUALIB_API int luaL_argerror (lua_State *L, int arg, const char *extramsg) {
-  lua_Debug ar;
-  if (!lua_getstack(L, 0, &ar))  /* no stack frame? */
-    return luaL_error(L, "bad argument #%d (%s)", arg, extramsg);
-  lua_getinfo(L, "n", &ar);
-  if (strcmp(ar.namewhat, "method") == 0) {
-    arg--;  /* do not count 'self' */
-    if (arg == 0)  /* error is in the self argument itself? */
-      return luaL_error(L, "calling '%s' on bad self (%s)",
-                           ar.name, extramsg);
-  }
-  if (ar.name == NULL)
-    ar.name = (pushglobalfuncname(L, &ar)) ? lua_tostring(L, -1) : "?";
-  return luaL_error(L, "bad argument #%d to '%s' (%s)",
-                        arg, ar.name, extramsg);
-}
-
-
-LUALIB_API int luaL_typeerror (lua_State *L, int arg, const char *tname) {
-  const char *msg;
-  const char *typearg;  /* name for the type of the actual argument */
-  if (luaL_getmetafield(L, arg, "__name") == LUA_TSTRING)
-    typearg = lua_tostring(L, -1);  /* use the given type name */
-  else if (lua_type(L, arg) == LUA_TLIGHTUSERDATA)
-    typearg = "light userdata";  /* special name for messages */
-  else
-    typearg = luaL_typename(L, arg);  /* standard name */
-  msg = lua_pushfstring(L, "%s expected, got %s", tname, typearg);
-  return luaL_argerror(L, arg, msg);
-}
-
-
-static void tag_error (lua_State *L, int arg, int tag) {
-  luaL_typeerror(L, arg, lua_typename(L, tag));
-}
-
-
-/*
-** The use of 'lua_pushfstring' ensures this function does not
-** need reserved stack space when called.
-*/
-LUALIB_API void luaL_where (lua_State *L, int level) {
-  lua_Debug ar;
-  if (lua_getstack(L, level, &ar)) {  /* check function at level */
-    lua_getinfo(L, "Sl", &ar);  /* get info about it */
-    if (ar.currentline > 0) {  /* is there info? */
-      lua_pushfstring(L, "%s:%d: ", ar.short_src, ar.currentline);
-      return;
-    }
-  }
-  lua_pushfstring(L, "");  /* else, no information available... */
-}
-
-
-/*
-** Again, the use of 'lua_pushvfstring' ensures this function does
-** not need reserved stack space when called. (At worst, it generates
-** an error with "stack overflow" instead of the given message.)
-*/
-LUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) {
-  va_list argp;
-  va_start(argp, fmt);
-  luaL_where(L, 1);
-  lua_pushvfstring(L, fmt, argp);
-  va_end(argp);
-  lua_concat(L, 2);
-  return lua_error(L);
-}
-
-
-LUALIB_API int luaL_fileresult (lua_State *L, int stat, const char *fname) {
-  int en = errno;  /* calls to Lua API may change this value */
-  if (stat) {
-    lua_pushboolean(L, 1);
-    return 1;
-  }
-  else {
-    luaL_pushfail(L);
-    if (fname)
-      lua_pushfstring(L, "%s: %s", fname, strerror(en));
-    else
-      lua_pushstring(L, strerror(en));
-    lua_pushinteger(L, en);
-    return 3;
-  }
-}
-
-
-#if !defined(l_inspectstat)	/* { */
-
-#if defined(LUA_USE_POSIX)
-
-#include <sys/wait.h>
-
-/*
-** use appropriate macros to interpret 'pclose' return status
-*/
-#define l_inspectstat(stat,what)  \
-   if (WIFEXITED(stat)) { stat = WEXITSTATUS(stat); } \
-   else if (WIFSIGNALED(stat)) { stat = WTERMSIG(stat); what = "signal"; }
-
-#else
-
-#define l_inspectstat(stat,what)  /* no op */
-
-#endif
-
-#endif				/* } */
-
-
-LUALIB_API int luaL_execresult (lua_State *L, int stat) {
-  if (stat != 0 && errno != 0)  /* error with an 'errno'? */
-    return luaL_fileresult(L, 0, NULL);
-  else {
-    const char *what = "exit";  /* type of termination */
-    l_inspectstat(stat, what);  /* interpret result */
-    if (*what == 'e' && stat == 0)  /* successful termination? */
-      lua_pushboolean(L, 1);
-    else
-      luaL_pushfail(L);
-    lua_pushstring(L, what);
-    lua_pushinteger(L, stat);
-    return 3;  /* return true/fail,what,code */
-  }
-}
-
-/* }====================================================== */
-
-
-
-/*
-** {======================================================
-** Userdata's metatable manipulation
-** =======================================================
-*/
-
-LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {
-  if (luaL_getmetatable(L, tname) != LUA_TNIL)  /* name already in use? */
-    return 0;  /* leave previous value on top, but return 0 */
-  lua_pop(L, 1);
-  lua_createtable(L, 0, 2);  /* create metatable */
-  lua_pushstring(L, tname);
-  lua_setfield(L, -2, "__name");  /* metatable.__name = tname */
-  lua_pushvalue(L, -1);
-  lua_setfield(L, LUA_REGISTRYINDEX, tname);  /* registry.name = metatable */
-  return 1;
-}
-
-
-LUALIB_API void luaL_setmetatable (lua_State *L, const char *tname) {
-  luaL_getmetatable(L, tname);
-  lua_setmetatable(L, -2);
-}
-
-
-LUALIB_API void *luaL_testudata (lua_State *L, int ud, const char *tname) {
-  void *p = lua_touserdata(L, ud);
-  if (p != NULL) {  /* value is a userdata? */
-    if (lua_getmetatable(L, ud)) {  /* does it have a metatable? */
-      luaL_getmetatable(L, tname);  /* get correct metatable */
-      if (!lua_rawequal(L, -1, -2))  /* not the same? */
-        p = NULL;  /* value is a userdata with wrong metatable */
-      lua_pop(L, 2);  /* remove both metatables */
-      return p;
-    }
-  }
-  return NULL;  /* value is not a userdata with a metatable */
-}
-
-
-LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) {
-  void *p = luaL_testudata(L, ud, tname);
-  luaL_argexpected(L, p != NULL, ud, tname);
-  return p;
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Argument check functions
-** =======================================================
-*/
-
-LUALIB_API int luaL_checkoption (lua_State *L, int arg, const char *def,
-                                 const char *const lst[]) {
-  const char *name = (def) ? luaL_optstring(L, arg, def) :
-                             luaL_checkstring(L, arg);
-  int i;
-  for (i=0; lst[i]; i++)
-    if (strcmp(lst[i], name) == 0)
-      return i;
-  return luaL_argerror(L, arg,
-                       lua_pushfstring(L, "invalid option '%s'", name));
-}
-
-
-/*
-** Ensures the stack has at least 'space' extra slots, raising an error
-** if it cannot fulfill the request. (The error handling needs a few
-** extra slots to format the error message. In case of an error without
-** this extra space, Lua will generate the same 'stack overflow' error,
-** but without 'msg'.)
-*/
-LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg) {
-  if (l_unlikely(!lua_checkstack(L, space))) {
-    if (msg)
-      luaL_error(L, "stack overflow (%s)", msg);
-    else
-      luaL_error(L, "stack overflow");
-  }
-}
-
-
-LUALIB_API void luaL_checktype (lua_State *L, int arg, int t) {
-  if (l_unlikely(lua_type(L, arg) != t))
-    tag_error(L, arg, t);
-}
-
-
-LUALIB_API void luaL_checkany (lua_State *L, int arg) {
-  if (l_unlikely(lua_type(L, arg) == LUA_TNONE))
-    luaL_argerror(L, arg, "value expected");
-}
-
-
-LUALIB_API const char *luaL_checklstring (lua_State *L, int arg, size_t *len) {
-  const char *s = lua_tolstring(L, arg, len);
-  if (l_unlikely(!s)) tag_error(L, arg, LUA_TSTRING);
-  return s;
-}
-
-
-LUALIB_API const char *luaL_optlstring (lua_State *L, int arg,
-                                        const char *def, size_t *len) {
-  if (lua_isnoneornil(L, arg)) {
-    if (len)
-      *len = (def ? strlen(def) : 0);
-    return def;
-  }
-  else return luaL_checklstring(L, arg, len);
-}
-
-
-LUALIB_API lua_Number luaL_checknumber (lua_State *L, int arg) {
-  int isnum;
-  lua_Number d = lua_tonumberx(L, arg, &isnum);
-  if (l_unlikely(!isnum))
-    tag_error(L, arg, LUA_TNUMBER);
-  return d;
-}
-
-
-LUALIB_API lua_Number luaL_optnumber (lua_State *L, int arg, lua_Number def) {
-  return luaL_opt(L, luaL_checknumber, arg, def);
-}
-
-
-static void interror (lua_State *L, int arg) {
-  if (lua_isnumber(L, arg))
-    luaL_argerror(L, arg, "number has no integer representation");
-  else
-    tag_error(L, arg, LUA_TNUMBER);
-}
-
-
-LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int arg) {
-  int isnum;
-  lua_Integer d = lua_tointegerx(L, arg, &isnum);
-  if (l_unlikely(!isnum)) {
-    interror(L, arg);
-  }
-  return d;
-}
-
-
-LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int arg,
-                                                      lua_Integer def) {
-  return luaL_opt(L, luaL_checkinteger, arg, def);
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Generic Buffer manipulation
-** =======================================================
-*/
-
-/* userdata to box arbitrary data */
-typedef struct UBox {
-  void *box;
-  size_t bsize;
-} UBox;
-
-
-static void *resizebox (lua_State *L, int idx, size_t newsize) {
-  void *ud;
-  lua_Alloc allocf = lua_getallocf(L, &ud);
-  UBox *box = (UBox *)lua_touserdata(L, idx);
-  void *temp = allocf(ud, box->box, box->bsize, newsize);
-  if (l_unlikely(temp == NULL && newsize > 0)) {  /* allocation error? */
-    lua_pushliteral(L, "not enough memory");
-    lua_error(L);  /* raise a memory error */
-  }
-  box->box = temp;
-  box->bsize = newsize;
-  return temp;
-}
-
-
-static int boxgc (lua_State *L) {
-  resizebox(L, 1, 0);
-  return 0;
-}
-
-
-static const luaL_Reg boxmt[] = {  /* box metamethods */
-  {"__gc", boxgc},
-  {"__close", boxgc},
-  {NULL, NULL}
-};
-
-
-static void newbox (lua_State *L) {
-  UBox *box = (UBox *)lua_newuserdatauv(L, sizeof(UBox), 0);
-  box->box = NULL;
-  box->bsize = 0;
-  if (luaL_newmetatable(L, "_UBOX*"))  /* creating metatable? */
-    luaL_setfuncs(L, boxmt, 0);  /* set its metamethods */
-  lua_setmetatable(L, -2);
-}
-
-
-/*
-** check whether buffer is using a userdata on the stack as a temporary
-** buffer
-*/
-#define buffonstack(B)	((B)->b != (B)->init.b)
-
-
-/*
-** Whenever buffer is accessed, slot 'idx' must either be a box (which
-** cannot be NULL) or it is a placeholder for the buffer.
-*/
-#define checkbufferlevel(B,idx)  \
-  lua_assert(buffonstack(B) ? lua_touserdata(B->L, idx) != NULL  \
-                            : lua_touserdata(B->L, idx) == (void*)B)
-
-
-/*
-** Compute new size for buffer 'B', enough to accommodate extra 'sz'
-** bytes. (The test for "not big enough" also gets the case when the
-** computation of 'newsize' overflows.)
-*/
-static size_t newbuffsize (luaL_Buffer *B, size_t sz) {
-  size_t newsize = (B->size / 2) * 3;  /* buffer size * 1.5 */
-  if (l_unlikely(MAX_SIZET - sz < B->n))  /* overflow in (B->n + sz)? */
-    return luaL_error(B->L, "buffer too large");
-  if (newsize < B->n + sz)  /* not big enough? */
-    newsize = B->n + sz;
-  return newsize;
-}
-
-
-/*
-** Returns a pointer to a free area with at least 'sz' bytes in buffer
-** 'B'. 'boxidx' is the relative position in the stack where is the
-** buffer's box or its placeholder.
-*/
-static char *prepbuffsize (luaL_Buffer *B, size_t sz, int boxidx) {
-  checkbufferlevel(B, boxidx);
-  if (B->size - B->n >= sz)  /* enough space? */
-    return B->b + B->n;
-  else {
-    lua_State *L = B->L;
-    char *newbuff;
-    size_t newsize = newbuffsize(B, sz);
-    /* create larger buffer */
-    if (buffonstack(B))  /* buffer already has a box? */
-      newbuff = (char *)resizebox(L, boxidx, newsize);  /* resize it */
-    else {  /* no box yet */
-      lua_remove(L, boxidx);  /* remove placeholder */
-      newbox(L);  /* create a new box */
-      lua_insert(L, boxidx);  /* move box to its intended position */
-      lua_toclose(L, boxidx);
-      newbuff = (char *)resizebox(L, boxidx, newsize);
-      memcpy(newbuff, B->b, B->n * sizeof(char));  /* copy original content */
-    }
-    B->b = newbuff;
-    B->size = newsize;
-    return newbuff + B->n;
-  }
-}
-
-/*
-** returns a pointer to a free area with at least 'sz' bytes
-*/
-LUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) {
-  return prepbuffsize(B, sz, -1);
-}
-
-
-LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {
-  if (l > 0) {  /* avoid 'memcpy' when 's' can be NULL */
-    char *b = prepbuffsize(B, l, -1);
-    memcpy(b, s, l * sizeof(char));
-    luaL_addsize(B, l);
-  }
-}
-
-
-LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) {
-  luaL_addlstring(B, s, strlen(s));
-}
-
-
-LUALIB_API void luaL_pushresult (luaL_Buffer *B) {
-  lua_State *L = B->L;
-  checkbufferlevel(B, -1);
-  lua_pushlstring(L, B->b, B->n);
-  if (buffonstack(B))
-    lua_closeslot(L, -2);  /* close the box */
-  lua_remove(L, -2);  /* remove box or placeholder from the stack */
-}
-
-
-LUALIB_API void luaL_pushresultsize (luaL_Buffer *B, size_t sz) {
-  luaL_addsize(B, sz);
-  luaL_pushresult(B);
-}
-
-
-/*
-** 'luaL_addvalue' is the only function in the Buffer system where the
-** box (if existent) is not on the top of the stack. So, instead of
-** calling 'luaL_addlstring', it replicates the code using -2 as the
-** last argument to 'prepbuffsize', signaling that the box is (or will
-** be) below the string being added to the buffer. (Box creation can
-** trigger an emergency GC, so we should not remove the string from the
-** stack before we have the space guaranteed.)
-*/
-LUALIB_API void luaL_addvalue (luaL_Buffer *B) {
-  lua_State *L = B->L;
-  size_t len;
-  const char *s = lua_tolstring(L, -1, &len);
-  char *b = prepbuffsize(B, len, -2);
-  memcpy(b, s, len * sizeof(char));
-  luaL_addsize(B, len);
-  lua_pop(L, 1);  /* pop string */
-}
-
-
-LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) {
-  B->L = L;
-  B->b = B->init.b;
-  B->n = 0;
-  B->size = LUAL_BUFFERSIZE;
-  lua_pushlightuserdata(L, (void*)B);  /* push placeholder */
-}
-
-
-LUALIB_API char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz) {
-  luaL_buffinit(L, B);
-  return prepbuffsize(B, sz, -1);
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Reference system
-** =======================================================
-*/
-
-/* index of free-list header (after the predefined values) */
-#define freelist	(LUA_RIDX_LAST + 1)
-
-/*
-** The previously freed references form a linked list:
-** t[freelist] is the index of a first free index, or zero if list is
-** empty; t[t[freelist]] is the index of the second element; etc.
-*/
-LUALIB_API int luaL_ref (lua_State *L, int t) {
-  int ref;
-  if (lua_isnil(L, -1)) {
-    lua_pop(L, 1);  /* remove from stack */
-    return LUA_REFNIL;  /* 'nil' has a unique fixed reference */
-  }
-  t = lua_absindex(L, t);
-  if (lua_rawgeti(L, t, freelist) == LUA_TNIL) {  /* first access? */
-    ref = 0;  /* list is empty */
-    lua_pushinteger(L, 0);  /* initialize as an empty list */
-    lua_rawseti(L, t, freelist);  /* ref = t[freelist] = 0 */
-  }
-  else {  /* already initialized */
-    lua_assert(lua_isinteger(L, -1));
-    ref = (int)lua_tointeger(L, -1);  /* ref = t[freelist] */
-  }
-  lua_pop(L, 1);  /* remove element from stack */
-  if (ref != 0) {  /* any free element? */
-    lua_rawgeti(L, t, ref);  /* remove it from list */
-    lua_rawseti(L, t, freelist);  /* (t[freelist] = t[ref]) */
-  }
-  else  /* no free elements */
-    ref = (int)lua_rawlen(L, t) + 1;  /* get a new reference */
-  lua_rawseti(L, t, ref);
-  return ref;
-}
-
-
-LUALIB_API void luaL_unref (lua_State *L, int t, int ref) {
-  if (ref >= 0) {
-    t = lua_absindex(L, t);
-    lua_rawgeti(L, t, freelist);
-    lua_assert(lua_isinteger(L, -1));
-    lua_rawseti(L, t, ref);  /* t[ref] = t[freelist] */
-    lua_pushinteger(L, ref);
-    lua_rawseti(L, t, freelist);  /* t[freelist] = ref */
-  }
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Load functions
-** =======================================================
-*/
-
-typedef struct LoadF {
-  int n;  /* number of pre-read characters */
-  FILE *f;  /* file being read */
-  char buff[BUFSIZ];  /* area for reading file */
-} LoadF;
-
-
-static const char *getF (lua_State *L, void *ud, size_t *size) {
-  LoadF *lf = (LoadF *)ud;
-  (void)L;  /* not used */
-  if (lf->n > 0) {  /* are there pre-read characters to be read? */
-    *size = lf->n;  /* return them (chars already in buffer) */
-    lf->n = 0;  /* no more pre-read characters */
-  }
-  else {  /* read a block from file */
-    /* 'fread' can return > 0 *and* set the EOF flag. If next call to
-       'getF' called 'fread', it might still wait for user input.
-       The next check avoids this problem. */
-    if (feof(lf->f)) return NULL;
-    *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f);  /* read block */
-  }
-  return lf->buff;
-}
-
-
-static int errfile (lua_State *L, const char *what, int fnameindex) {
-  const char *serr = strerror(errno);
-  const char *filename = lua_tostring(L, fnameindex) + 1;
-  lua_pushfstring(L, "cannot %s %s: %s", what, filename, serr);
-  lua_remove(L, fnameindex);
-  return LUA_ERRFILE;
-}
-
-
-/*
-** Skip an optional BOM at the start of a stream. If there is an
-** incomplete BOM (the first character is correct but the rest is
-** not), returns the first character anyway to force an error
-** (as no chunk can start with 0xEF).
-*/
-static int skipBOM (FILE *f) {
-  int c = getc(f);  /* read first character */
-  if (c == 0xEF && getc(f) == 0xBB && getc(f) == 0xBF)  /* correct BOM? */
-    return getc(f);  /* ignore BOM and return next char */
-  else  /* no (valid) BOM */
-    return c;  /* return first character */
-}
-
-
-/*
-** reads the first character of file 'f' and skips an optional BOM mark
-** in its beginning plus its first line if it starts with '#'. Returns
-** true if it skipped the first line.  In any case, '*cp' has the
-** first "valid" character of the file (after the optional BOM and
-** a first-line comment).
-*/
-static int skipcomment (FILE *f, int *cp) {
-  int c = *cp = skipBOM(f);
-  if (c == '#') {  /* first line is a comment (Unix exec. file)? */
-    do {  /* skip first line */
-      c = getc(f);
-    } while (c != EOF && c != '\n');
-    *cp = getc(f);  /* next character after comment, if present */
-    return 1;  /* there was a comment */
-  }
-  else return 0;  /* no comment */
-}
-
-
-LUALIB_API int luaL_loadfilex (lua_State *L, const char *filename,
-                                             const char *mode) {
-  LoadF lf;
-  int status, readstatus;
-  int c;
-  int fnameindex = lua_gettop(L) + 1;  /* index of filename on the stack */
-  if (filename == NULL) {
-    lua_pushliteral(L, "=stdin");
-    lf.f = stdin;
-  }
-  else {
-    lua_pushfstring(L, "@%s", filename);
-    lf.f = fopen(filename, "r");
-    if (lf.f == NULL) return errfile(L, "open", fnameindex);
-  }
-  lf.n = 0;
-  if (skipcomment(lf.f, &c))  /* read initial portion */
-    lf.buff[lf.n++] = '\n';  /* add newline to correct line numbers */
-  if (c == LUA_SIGNATURE[0]) {  /* binary file? */
-    lf.n = 0;  /* remove possible newline */
-    if (filename) {  /* "real" file? */
-      lf.f = freopen(filename, "rb", lf.f);  /* reopen in binary mode */
-      if (lf.f == NULL) return errfile(L, "reopen", fnameindex);
-      skipcomment(lf.f, &c);  /* re-read initial portion */
-    }
-  }
-  if (c != EOF)
-    lf.buff[lf.n++] = c;  /* 'c' is the first character of the stream */
-  status = lua_load(L, getF, &lf, lua_tostring(L, -1), mode);
-  readstatus = ferror(lf.f);
-  if (filename) fclose(lf.f);  /* close file (even in case of errors) */
-  if (readstatus) {
-    lua_settop(L, fnameindex);  /* ignore results from 'lua_load' */
-    return errfile(L, "read", fnameindex);
-  }
-  lua_remove(L, fnameindex);
-  return status;
-}
-
-
-typedef struct LoadS {
-  const char *s;
-  size_t size;
-} LoadS;
-
-
-static const char *getS (lua_State *L, void *ud, size_t *size) {
-  LoadS *ls = (LoadS *)ud;
-  (void)L;  /* not used */
-  if (ls->size == 0) return NULL;
-  *size = ls->size;
-  ls->size = 0;
-  return ls->s;
-}
-
-
-LUALIB_API int luaL_loadbufferx (lua_State *L, const char *buff, size_t size,
-                                 const char *name, const char *mode) {
-  LoadS ls;
-  ls.s = buff;
-  ls.size = size;
-  return lua_load(L, getS, &ls, name, mode);
-}
-
-
-LUALIB_API int luaL_loadstring (lua_State *L, const char *s) {
-  return luaL_loadbuffer(L, s, strlen(s), s);
-}
-
-/* }====================================================== */
-
-
-
-LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) {
-  if (!lua_getmetatable(L, obj))  /* no metatable? */
-    return LUA_TNIL;
-  else {
-    int tt;
-    lua_pushstring(L, event);
-    tt = lua_rawget(L, -2);
-    if (tt == LUA_TNIL)  /* is metafield nil? */
-      lua_pop(L, 2);  /* remove metatable and metafield */
-    else
-      lua_remove(L, -2);  /* remove only metatable */
-    return tt;  /* return metafield type */
-  }
-}
-
-
-LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {
-  obj = lua_absindex(L, obj);
-  if (luaL_getmetafield(L, obj, event) == LUA_TNIL)  /* no metafield? */
-    return 0;
-  lua_pushvalue(L, obj);
-  lua_call(L, 1, 1);
-  return 1;
-}
-
-
-LUALIB_API lua_Integer luaL_len (lua_State *L, int idx) {
-  lua_Integer l;
-  int isnum;
-  lua_len(L, idx);
-  l = lua_tointegerx(L, -1, &isnum);
-  if (l_unlikely(!isnum))
-    luaL_error(L, "object length is not an integer");
-  lua_pop(L, 1);  /* remove object */
-  return l;
-}
-
-
-LUALIB_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) {
-  idx = lua_absindex(L,idx);
-  if (luaL_callmeta(L, idx, "__tostring")) {  /* metafield? */
-    if (!lua_isstring(L, -1))
-      luaL_error(L, "'__tostring' must return a string");
-  }
-  else {
-    switch (lua_type(L, idx)) {
-      case LUA_TNUMBER: {
-        if (lua_isinteger(L, idx))
-          lua_pushfstring(L, "%I", (LUAI_UACINT)lua_tointeger(L, idx));
-        else
-          lua_pushfstring(L, "%f", (LUAI_UACNUMBER)lua_tonumber(L, idx));
-        break;
-      }
-      case LUA_TSTRING:
-        lua_pushvalue(L, idx);
-        break;
-      case LUA_TBOOLEAN:
-        lua_pushstring(L, (lua_toboolean(L, idx) ? "true" : "false"));
-        break;
-      case LUA_TNIL:
-        lua_pushliteral(L, "nil");
-        break;
-      default: {
-        int tt = luaL_getmetafield(L, idx, "__name");  /* try name */
-        const char *kind = (tt == LUA_TSTRING) ? lua_tostring(L, -1) :
-                                                 luaL_typename(L, idx);
-        lua_pushfstring(L, "%s: %p", kind, lua_topointer(L, idx));
-        if (tt != LUA_TNIL)
-          lua_remove(L, -2);  /* remove '__name' */
-        break;
-      }
-    }
-  }
-  return lua_tolstring(L, -1, len);
-}
-
-
-/*
-** set functions from list 'l' into table at top - 'nup'; each
-** function gets the 'nup' elements at the top as upvalues.
-** Returns with only the table at the stack.
-*/
-LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) {
-  luaL_checkstack(L, nup, "too many upvalues");
-  for (; l->name != NULL; l++) {  /* fill the table with given functions */
-    if (l->func == NULL)  /* place holder? */
-      lua_pushboolean(L, 0);
-    else {
-      int i;
-      for (i = 0; i < nup; i++)  /* copy upvalues to the top */
-        lua_pushvalue(L, -nup);
-      lua_pushcclosure(L, l->func, nup);  /* closure with those upvalues */
-    }
-    lua_setfield(L, -(nup + 2), l->name);
-  }
-  lua_pop(L, nup);  /* remove upvalues */
-}
-
-
-/*
-** ensure that stack[idx][fname] has a table and push that table
-** into the stack
-*/
-LUALIB_API int luaL_getsubtable (lua_State *L, int idx, const char *fname) {
-  if (lua_getfield(L, idx, fname) == LUA_TTABLE)
-    return 1;  /* table already there */
-  else {
-    lua_pop(L, 1);  /* remove previous result */
-    idx = lua_absindex(L, idx);
-    lua_newtable(L);
-    lua_pushvalue(L, -1);  /* copy to be left at top */
-    lua_setfield(L, idx, fname);  /* assign new table to field */
-    return 0;  /* false, because did not find table there */
-  }
-}
-
-
-/*
-** Stripped-down 'require': After checking "loaded" table, calls 'openf'
-** to open a module, registers the result in 'package.loaded' table and,
-** if 'glb' is true, also registers the result in the global table.
-** Leaves resulting module on the top.
-*/
-LUALIB_API void luaL_requiref (lua_State *L, const char *modname,
-                               lua_CFunction openf, int glb) {
-  luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
-  lua_getfield(L, -1, modname);  /* LOADED[modname] */
-  if (!lua_toboolean(L, -1)) {  /* package not already loaded? */
-    lua_pop(L, 1);  /* remove field */
-    lua_pushcfunction(L, openf);
-    lua_pushstring(L, modname);  /* argument to open function */
-    lua_call(L, 1, 1);  /* call 'openf' to open module */
-    lua_pushvalue(L, -1);  /* make copy of module (call result) */
-    lua_setfield(L, -3, modname);  /* LOADED[modname] = module */
-  }
-  lua_remove(L, -2);  /* remove LOADED table */
-  if (glb) {
-    lua_pushvalue(L, -1);  /* copy of module */
-    lua_setglobal(L, modname);  /* _G[modname] = module */
-  }
-}
-
-
-LUALIB_API void luaL_addgsub (luaL_Buffer *b, const char *s,
-                                     const char *p, const char *r) {
-  const char *wild;
-  size_t l = strlen(p);
-  while ((wild = strstr(s, p)) != NULL) {
-    luaL_addlstring(b, s, wild - s);  /* push prefix */
-    luaL_addstring(b, r);  /* push replacement in place of pattern */
-    s = wild + l;  /* continue after 'p' */
-  }
-  luaL_addstring(b, s);  /* push last suffix */
-}
-
-
-LUALIB_API const char *luaL_gsub (lua_State *L, const char *s,
-                                  const char *p, const char *r) {
-  luaL_Buffer b;
-  luaL_buffinit(L, &b);
-  luaL_addgsub(&b, s, p, r);
-  luaL_pushresult(&b);
-  return lua_tostring(L, -1);
-}
-
-
-static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
-  (void)ud; (void)osize;  /* not used */
-  if (nsize == 0) {
-    free(ptr);
-    return NULL;
-  }
-  else
-    return realloc(ptr, nsize);
-}
-
-
-static int panic (lua_State *L) {
-  const char *msg = lua_tostring(L, -1);
-  if (msg == NULL) msg = "error object is not a string";
-  lua_writestringerror("PANIC: unprotected error in call to Lua API (%s)\n",
-                        msg);
-  return 0;  /* return to Lua to abort */
-}
-
-
-/*
-** Warning functions:
-** warnfoff: warning system is off
-** warnfon: ready to start a new message
-** warnfcont: previous message is to be continued
-*/
-static void warnfoff (void *ud, const char *message, int tocont);
-static void warnfon (void *ud, const char *message, int tocont);
-static void warnfcont (void *ud, const char *message, int tocont);
-
-
-/*
-** Check whether message is a control message. If so, execute the
-** control or ignore it if unknown.
-*/
-static int checkcontrol (lua_State *L, const char *message, int tocont) {
-  if (tocont || *(message++) != '@')  /* not a control message? */
-    return 0;
-  else {
-    if (strcmp(message, "off") == 0)
-      lua_setwarnf(L, warnfoff, L);  /* turn warnings off */
-    else if (strcmp(message, "on") == 0)
-      lua_setwarnf(L, warnfon, L);   /* turn warnings on */
-    return 1;  /* it was a control message */
-  }
-}
-
-
-static void warnfoff (void *ud, const char *message, int tocont) {
-  checkcontrol((lua_State *)ud, message, tocont);
-}
-
-
-/*
-** Writes the message and handle 'tocont', finishing the message
-** if needed and setting the next warn function.
-*/
-static void warnfcont (void *ud, const char *message, int tocont) {
-  lua_State *L = (lua_State *)ud;
-  lua_writestringerror("%s", message);  /* write message */
-  if (tocont)  /* not the last part? */
-    lua_setwarnf(L, warnfcont, L);  /* to be continued */
-  else {  /* last part */
-    lua_writestringerror("%s", "\n");  /* finish message with end-of-line */
-    lua_setwarnf(L, warnfon, L);  /* next call is a new message */
-  }
-}
-
-
-static void warnfon (void *ud, const char *message, int tocont) {
-  if (checkcontrol((lua_State *)ud, message, tocont))  /* control message? */
-    return;  /* nothing else to be done */
-  lua_writestringerror("%s", "Lua warning: ");  /* start a new warning */
-  warnfcont(ud, message, tocont);  /* finish processing */
-}
-
-
-LUALIB_API lua_State *luaL_newstate (void) {
-  lua_State *L = lua_newstate(l_alloc, NULL);
-  if (l_likely(L)) {
-    lua_atpanic(L, &panic);
-    lua_setwarnf(L, warnfoff, L);  /* default is warnings off */
-  }
-  return L;
-}
-
-
-LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver, size_t sz) {
-  lua_Number v = lua_version(L);
-  if (sz != LUAL_NUMSIZES)  /* check numeric types */
-    luaL_error(L, "core and library have incompatible numeric types");
-  else if (v != ver)
-    luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f",
-                  (LUAI_UACNUMBER)ver, (LUAI_UACNUMBER)v);
-}
-
diff --git a/third-party/lua/src/lauxlib.h b/third-party/lua/src/lauxlib.h
deleted file mode 100644
index 5b977e2a3..000000000
--- a/third-party/lua/src/lauxlib.h
+++ /dev/null
@@ -1,301 +0,0 @@
-/*
-** $Id: lauxlib.h $
-** Auxiliary functions for building Lua libraries
-** See Copyright Notice in lua.h
-*/
-
-
-#ifndef lauxlib_h
-#define lauxlib_h
-
-
-#include <stddef.h>
-#include <stdio.h>
-
-#include "luaconf.h"
-#include "lua.h"
-
-
-/* global table */
-#define LUA_GNAME	"_G"
-
-
-typedef struct luaL_Buffer luaL_Buffer;
-
-
-/* extra error code for 'luaL_loadfilex' */
-#define LUA_ERRFILE     (LUA_ERRERR+1)
-
-
-/* key, in the registry, for table of loaded modules */
-#define LUA_LOADED_TABLE	"_LOADED"
-
-
-/* key, in the registry, for table of preloaded loaders */
-#define LUA_PRELOAD_TABLE	"_PRELOAD"
-
-
-typedef struct luaL_Reg {
-  const char *name;
-  lua_CFunction func;
-} luaL_Reg;
-
-
-#define LUAL_NUMSIZES	(sizeof(lua_Integer)*16 + sizeof(lua_Number))
-
-LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz);
-#define luaL_checkversion(L)  \
-	  luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES)
-
-LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
-LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
-LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);
-LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg);
-LUALIB_API int (luaL_typeerror) (lua_State *L, int arg, const char *tname);
-LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg,
-                                                          size_t *l);
-LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg,
-                                          const char *def, size_t *l);
-LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg);
-LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def);
-
-LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg);
-LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg,
-                                          lua_Integer def);
-
-LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
-LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t);
-LUALIB_API void (luaL_checkany) (lua_State *L, int arg);
-
-LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
-LUALIB_API void  (luaL_setmetatable) (lua_State *L, const char *tname);
-LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname);
-LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
-
-LUALIB_API void (luaL_where) (lua_State *L, int lvl);
-LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
-
-LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def,
-                                   const char *const lst[]);
-
-LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);
-LUALIB_API int (luaL_execresult) (lua_State *L, int stat);
-
-
-/* predefined references */
-#define LUA_NOREF       (-2)
-#define LUA_REFNIL      (-1)
-
-LUALIB_API int (luaL_ref) (lua_State *L, int t);
-LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
-
-LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename,
-                                               const char *mode);
-
-#define luaL_loadfile(L,f)	luaL_loadfilex(L,f,NULL)
-
-LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz,
-                                   const char *name, const char *mode);
-LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
-
-LUALIB_API lua_State *(luaL_newstate) (void);
-
-LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx);
-
-LUALIB_API void (luaL_addgsub) (luaL_Buffer *b, const char *s,
-                                     const char *p, const char *r);
-LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s,
-                                    const char *p, const char *r);
-
-LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);
-
-LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname);
-
-LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1,
-                                  const char *msg, int level);
-
-LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,
-                                 lua_CFunction openf, int glb);
-
-/*
-** ===============================================================
-** some useful macros
-** ===============================================================
-*/
-
-
-#define luaL_newlibtable(L,l)	\
-  lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)
-
-#define luaL_newlib(L,l)  \
-  (luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
-
-#define luaL_argcheck(L, cond,arg,extramsg)	\
-	((void)(luai_likely(cond) || luaL_argerror(L, (arg), (extramsg))))
-
-#define luaL_argexpected(L,cond,arg,tname)	\
-	((void)(luai_likely(cond) || luaL_typeerror(L, (arg), (tname))))
-
-#define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))
-#define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))
-
-#define luaL_typename(L,i)	lua_typename(L, lua_type(L,(i)))
-
-#define luaL_dofile(L, fn) \
-	(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
-
-#define luaL_dostring(L, s) \
-	(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
-
-#define luaL_getmetatable(L,n)	(lua_getfield(L, LUA_REGISTRYINDEX, (n)))
-
-#define luaL_opt(L,f,n,d)	(lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
-
-#define luaL_loadbuffer(L,s,sz,n)	luaL_loadbufferx(L,s,sz,n,NULL)
-
-
-/*
-** Perform arithmetic operations on lua_Integer values with wrap-around
-** semantics, as the Lua core does.
-*/
-#define luaL_intop(op,v1,v2)  \
-	((lua_Integer)((lua_Unsigned)(v1) op (lua_Unsigned)(v2)))
-
-
-/* push the value used to represent failure/error */
-#define luaL_pushfail(L)	lua_pushnil(L)
-
-
-/*
-** Internal assertions for in-house debugging
-*/
-#if !defined(lua_assert)
-
-#if defined LUAI_ASSERT
-  #include <assert.h>
-  #define lua_assert(c)		assert(c)
-#else
-  #define lua_assert(c)		((void)0)
-#endif
-
-#endif
-
-
-
-/*
-** {======================================================
-** Generic Buffer manipulation
-** =======================================================
-*/
-
-struct luaL_Buffer {
-  char *b;  /* buffer address */
-  size_t size;  /* buffer size */
-  size_t n;  /* number of characters in buffer */
-  lua_State *L;
-  union {
-    LUAI_MAXALIGN;  /* ensure maximum alignment for buffer */
-    char b[LUAL_BUFFERSIZE];  /* initial buffer */
-  } init;
-};
-
-
-#define luaL_bufflen(bf)	((bf)->n)
-#define luaL_buffaddr(bf)	((bf)->b)
-
-
-#define luaL_addchar(B,c) \
-  ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \
-   ((B)->b[(B)->n++] = (c)))
-
-#define luaL_addsize(B,s)	((B)->n += (s))
-
-#define luaL_buffsub(B,s)	((B)->n -= (s))
-
-LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
-LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);
-LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
-LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
-LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
-LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
-LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz);
-LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz);
-
-#define luaL_prepbuffer(B)	luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
-
-/* }====================================================== */
-
-
-
-/*
-** {======================================================
-** File handles for IO library
-** =======================================================
-*/
-
-/*
-** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and
-** initial structure 'luaL_Stream' (it may contain other fields
-** after that initial structure).
-*/
-
-#define LUA_FILEHANDLE          "FILE*"
-
-
-typedef struct luaL_Stream {
-  FILE *f;  /* stream (NULL for incompletely created streams) */
-  lua_CFunction closef;  /* to close stream (NULL for closed streams) */
-} luaL_Stream;
-
-/* }====================================================== */
-
-/*
-** {==================================================================
-** "Abstraction Layer" for basic report of messages and errors
-** ===================================================================
-*/
-
-/* print a string */
-#if !defined(lua_writestring)
-#define lua_writestring(s,l)   fwrite((s), sizeof(char), (l), stdout)
-#endif
-
-/* print a newline and flush the output */
-#if !defined(lua_writeline)
-#define lua_writeline()        (lua_writestring("\n", 1), fflush(stdout))
-#endif
-
-/* print an error message */
-#if !defined(lua_writestringerror)
-#define lua_writestringerror(s,p) \
-        (fprintf(stderr, (s), (p)), fflush(stderr))
-#endif
-
-/* }================================================================== */
-
-
-/*
-** {============================================================
-** Compatibility with deprecated conversions
-** =============================================================
-*/
-#if defined(LUA_COMPAT_APIINTCASTS)
-
-#define luaL_checkunsigned(L,a)	((lua_Unsigned)luaL_checkinteger(L,a))
-#define luaL_optunsigned(L,a,d)	\
-	((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d)))
-
-#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
-#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
-
-#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
-#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
-
-#endif
-/* }============================================================ */
-
-
-
-#endif
-
-
diff --git a/third-party/lua/src/lbaselib.c b/third-party/lua/src/lbaselib.c
deleted file mode 100644
index 1d60c9ded..000000000
--- a/third-party/lua/src/lbaselib.c
+++ /dev/null
@@ -1,549 +0,0 @@
-/*
-** $Id: lbaselib.c $
-** Basic library
-** See Copyright Notice in lua.h
-*/
-
-#define lbaselib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <ctype.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-static int luaB_print (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
-  int i;
-  for (i = 1; i <= n; i++) {  /* for each argument */
-    size_t l;
-    const char *s = luaL_tolstring(L, i, &l);  /* convert it to string */
-    if (i > 1)  /* not the first element? */
-      lua_writestring("\t", 1);  /* add a tab before it */
-    lua_writestring(s, l);  /* print it */
-    lua_pop(L, 1);  /* pop result */
-  }
-  lua_writeline();
-  return 0;
-}
-
-
-/*
-** Creates a warning with all given arguments.
-** Check first for errors; otherwise an error may interrupt
-** the composition of a warning, leaving it unfinished.
-*/
-static int luaB_warn (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
-  int i;
-  luaL_checkstring(L, 1);  /* at least one argument */
-  for (i = 2; i <= n; i++)
-    luaL_checkstring(L, i);  /* make sure all arguments are strings */
-  for (i = 1; i < n; i++)  /* compose warning */
-    lua_warning(L, lua_tostring(L, i), 1);
-  lua_warning(L, lua_tostring(L, n), 0);  /* close warning */
-  return 0;
-}
-
-
-#define SPACECHARS	" \f\n\r\t\v"
-
-static const char *b_str2int (const char *s, int base, lua_Integer *pn) {
-  lua_Unsigned n = 0;
-  int neg = 0;
-  s += strspn(s, SPACECHARS);  /* skip initial spaces */
-  if (*s == '-') { s++; neg = 1; }  /* handle sign */
-  else if (*s == '+') s++;
-  if (!isalnum((unsigned char)*s))  /* no digit? */
-    return NULL;
-  do {
-    int digit = (isdigit((unsigned char)*s)) ? *s - '0'
-                   : (toupper((unsigned char)*s) - 'A') + 10;
-    if (digit >= base) return NULL;  /* invalid numeral */
-    n = n * base + digit;
-    s++;
-  } while (isalnum((unsigned char)*s));
-  s += strspn(s, SPACECHARS);  /* skip trailing spaces */
-  *pn = (lua_Integer)((neg) ? (0u - n) : n);
-  return s;
-}
-
-
-static int luaB_tonumber (lua_State *L) {
-  if (lua_isnoneornil(L, 2)) {  /* standard conversion? */
-    if (lua_type(L, 1) == LUA_TNUMBER) {  /* already a number? */
-      lua_settop(L, 1);  /* yes; return it */
-      return 1;
-    }
-    else {
-      size_t l;
-      const char *s = lua_tolstring(L, 1, &l);
-      if (s != NULL && lua_stringtonumber(L, s) == l + 1)
-        return 1;  /* successful conversion to number */
-      /* else not a number */
-      luaL_checkany(L, 1);  /* (but there must be some parameter) */
-    }
-  }
-  else {
-    size_t l;
-    const char *s;
-    lua_Integer n = 0;  /* to avoid warnings */
-    lua_Integer base = luaL_checkinteger(L, 2);
-    luaL_checktype(L, 1, LUA_TSTRING);  /* no numbers as strings */
-    s = lua_tolstring(L, 1, &l);
-    luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
-    if (b_str2int(s, (int)base, &n) == s + l) {
-      lua_pushinteger(L, n);
-      return 1;
-    }  /* else not a number */
-  }  /* else not a number */
-  luaL_pushfail(L);  /* not a number */
-  return 1;
-}
-
-
-static int luaB_error (lua_State *L) {
-  int level = (int)luaL_optinteger(L, 2, 1);
-  lua_settop(L, 1);
-  if (lua_type(L, 1) == LUA_TSTRING && level > 0) {
-    luaL_where(L, level);   /* add extra information */
-    lua_pushvalue(L, 1);
-    lua_concat(L, 2);
-  }
-  return lua_error(L);
-}
-
-
-static int luaB_getmetatable (lua_State *L) {
-  luaL_checkany(L, 1);
-  if (!lua_getmetatable(L, 1)) {
-    lua_pushnil(L);
-    return 1;  /* no metatable */
-  }
-  luaL_getmetafield(L, 1, "__metatable");
-  return 1;  /* returns either __metatable field (if present) or metatable */
-}
-
-
-static int luaB_setmetatable (lua_State *L) {
-  int t = lua_type(L, 2);
-  luaL_checktype(L, 1, LUA_TTABLE);
-  luaL_argexpected(L, t == LUA_TNIL || t == LUA_TTABLE, 2, "nil or table");
-  if (l_unlikely(luaL_getmetafield(L, 1, "__metatable") != LUA_TNIL))
-    return luaL_error(L, "cannot change a protected metatable");
-  lua_settop(L, 2);
-  lua_setmetatable(L, 1);
-  return 1;
-}
-
-
-static int luaB_rawequal (lua_State *L) {
-  luaL_checkany(L, 1);
-  luaL_checkany(L, 2);
-  lua_pushboolean(L, lua_rawequal(L, 1, 2));
-  return 1;
-}
-
-
-static int luaB_rawlen (lua_State *L) {
-  int t = lua_type(L, 1);
-  luaL_argexpected(L, t == LUA_TTABLE || t == LUA_TSTRING, 1,
-                      "table or string");
-  lua_pushinteger(L, lua_rawlen(L, 1));
-  return 1;
-}
-
-
-static int luaB_rawget (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-  luaL_checkany(L, 2);
-  lua_settop(L, 2);
-  lua_rawget(L, 1);
-  return 1;
-}
-
-static int luaB_rawset (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-  luaL_checkany(L, 2);
-  luaL_checkany(L, 3);
-  lua_settop(L, 3);
-  lua_rawset(L, 1);
-  return 1;
-}
-
-
-static int pushmode (lua_State *L, int oldmode) {
-  if (oldmode == -1)
-    luaL_pushfail(L);  /* invalid call to 'lua_gc' */
-  else
-    lua_pushstring(L, (oldmode == LUA_GCINC) ? "incremental"
-                                             : "generational");
-  return 1;
-}
-
-
-/*
-** check whether call to 'lua_gc' was valid (not inside a finalizer)
-*/
-#define checkvalres(res) { if (res == -1) break; }
-
-static int luaB_collectgarbage (lua_State *L) {
-  static const char *const opts[] = {"stop", "restart", "collect",
-    "count", "step", "setpause", "setstepmul",
-    "isrunning", "generational", "incremental", NULL};
-  static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
-    LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL,
-    LUA_GCISRUNNING, LUA_GCGEN, LUA_GCINC};
-  int o = optsnum[luaL_checkoption(L, 1, "collect", opts)];
-  switch (o) {
-    case LUA_GCCOUNT: {
-      int k = lua_gc(L, o);
-      int b = lua_gc(L, LUA_GCCOUNTB);
-      checkvalres(k);
-      lua_pushnumber(L, (lua_Number)k + ((lua_Number)b/1024));
-      return 1;
-    }
-    case LUA_GCSTEP: {
-      int step = (int)luaL_optinteger(L, 2, 0);
-      int res = lua_gc(L, o, step);
-      checkvalres(res);
-      lua_pushboolean(L, res);
-      return 1;
-    }
-    case LUA_GCSETPAUSE:
-    case LUA_GCSETSTEPMUL: {
-      int p = (int)luaL_optinteger(L, 2, 0);
-      int previous = lua_gc(L, o, p);
-      checkvalres(previous);
-      lua_pushinteger(L, previous);
-      return 1;
-    }
-    case LUA_GCISRUNNING: {
-      int res = lua_gc(L, o);
-      checkvalres(res);
-      lua_pushboolean(L, res);
-      return 1;
-    }
-    case LUA_GCGEN: {
-      int minormul = (int)luaL_optinteger(L, 2, 0);
-      int majormul = (int)luaL_optinteger(L, 3, 0);
-      return pushmode(L, lua_gc(L, o, minormul, majormul));
-    }
-    case LUA_GCINC: {
-      int pause = (int)luaL_optinteger(L, 2, 0);
-      int stepmul = (int)luaL_optinteger(L, 3, 0);
-      int stepsize = (int)luaL_optinteger(L, 4, 0);
-      return pushmode(L, lua_gc(L, o, pause, stepmul, stepsize));
-    }
-    default: {
-      int res = lua_gc(L, o);
-      checkvalres(res);
-      lua_pushinteger(L, res);
-      return 1;
-    }
-  }
-  luaL_pushfail(L);  /* invalid call (inside a finalizer) */
-  return 1;
-}
-
-
-static int luaB_type (lua_State *L) {
-  int t = lua_type(L, 1);
-  luaL_argcheck(L, t != LUA_TNONE, 1, "value expected");
-  lua_pushstring(L, lua_typename(L, t));
-  return 1;
-}
-
-
-static int luaB_next (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-  lua_settop(L, 2);  /* create a 2nd argument if there isn't one */
-  if (lua_next(L, 1))
-    return 2;
-  else {
-    lua_pushnil(L);
-    return 1;
-  }
-}
-
-
-static int pairscont (lua_State *L, int status, lua_KContext k) {
-  (void)L; (void)status; (void)k;  /* unused */
-  return 3;
-}
-
-static int luaB_pairs (lua_State *L) {
-  luaL_checkany(L, 1);
-  if (luaL_getmetafield(L, 1, "__pairs") == LUA_TNIL) {  /* no metamethod? */
-    lua_pushcfunction(L, luaB_next);  /* will return generator, */
-    lua_pushvalue(L, 1);  /* state, */
-    lua_pushnil(L);  /* and initial value */
-  }
-  else {
-    lua_pushvalue(L, 1);  /* argument 'self' to metamethod */
-    lua_callk(L, 1, 3, 0, pairscont);  /* get 3 values from metamethod */
-  }
-  return 3;
-}
-
-
-/*
-** Traversal function for 'ipairs'
-*/
-static int ipairsaux (lua_State *L) {
-  lua_Integer i = luaL_checkinteger(L, 2);
-  i = luaL_intop(+, i, 1);
-  lua_pushinteger(L, i);
-  return (lua_geti(L, 1, i) == LUA_TNIL) ? 1 : 2;
-}
-
-
-/*
-** 'ipairs' function. Returns 'ipairsaux', given "table", 0.
-** (The given "table" may not be a table.)
-*/
-static int luaB_ipairs (lua_State *L) {
-  luaL_checkany(L, 1);
-  lua_pushcfunction(L, ipairsaux);  /* iteration function */
-  lua_pushvalue(L, 1);  /* state */
-  lua_pushinteger(L, 0);  /* initial value */
-  return 3;
-}
-
-
-static int load_aux (lua_State *L, int status, int envidx) {
-  if (l_likely(status == LUA_OK)) {
-    if (envidx != 0) {  /* 'env' parameter? */
-      lua_pushvalue(L, envidx);  /* environment for loaded function */
-      if (!lua_setupvalue(L, -2, 1))  /* set it as 1st upvalue */
-        lua_pop(L, 1);  /* remove 'env' if not used by previous call */
-    }
-    return 1;
-  }
-  else {  /* error (message is on top of the stack) */
-    luaL_pushfail(L);
-    lua_insert(L, -2);  /* put before error message */
-    return 2;  /* return fail plus error message */
-  }
-}
-
-
-static int luaB_loadfile (lua_State *L) {
-  const char *fname = luaL_optstring(L, 1, NULL);
-  const char *mode = luaL_optstring(L, 2, NULL);
-  int env = (!lua_isnone(L, 3) ? 3 : 0);  /* 'env' index or 0 if no 'env' */
-  int status = luaL_loadfilex(L, fname, mode);
-  return load_aux(L, status, env);
-}
-
-
-/*
-** {======================================================
-** Generic Read function
-** =======================================================
-*/
-
-
-/*
-** reserved slot, above all arguments, to hold a copy of the returned
-** string to avoid it being collected while parsed. 'load' has four
-** optional arguments (chunk, source name, mode, and environment).
-*/
-#define RESERVEDSLOT	5
-
-
-/*
-** Reader for generic 'load' function: 'lua_load' uses the
-** stack for internal stuff, so the reader cannot change the
-** stack top. Instead, it keeps its resulting string in a
-** reserved slot inside the stack.
-*/
-static const char *generic_reader (lua_State *L, void *ud, size_t *size) {
-  (void)(ud);  /* not used */
-  luaL_checkstack(L, 2, "too many nested functions");
-  lua_pushvalue(L, 1);  /* get function */
-  lua_call(L, 0, 1);  /* call it */
-  if (lua_isnil(L, -1)) {
-    lua_pop(L, 1);  /* pop result */
-    *size = 0;
-    return NULL;
-  }
-  else if (l_unlikely(!lua_isstring(L, -1)))
-    luaL_error(L, "reader function must return a string");
-  lua_replace(L, RESERVEDSLOT);  /* save string in reserved slot */
-  return lua_tolstring(L, RESERVEDSLOT, size);
-}
-
-
-static int luaB_load (lua_State *L) {
-  int status;
-  size_t l;
-  const char *s = lua_tolstring(L, 1, &l);
-  const char *mode = luaL_optstring(L, 3, "bt");
-  int env = (!lua_isnone(L, 4) ? 4 : 0);  /* 'env' index or 0 if no 'env' */
-  if (s != NULL) {  /* loading a string? */
-    const char *chunkname = luaL_optstring(L, 2, s);
-    status = luaL_loadbufferx(L, s, l, chunkname, mode);
-  }
-  else {  /* loading from a reader function */
-    const char *chunkname = luaL_optstring(L, 2, "=(load)");
-    luaL_checktype(L, 1, LUA_TFUNCTION);
-    lua_settop(L, RESERVEDSLOT);  /* create reserved slot */
-    status = lua_load(L, generic_reader, NULL, chunkname, mode);
-  }
-  return load_aux(L, status, env);
-}
-
-/* }====================================================== */
-
-
-static int dofilecont (lua_State *L, int d1, lua_KContext d2) {
-  (void)d1;  (void)d2;  /* only to match 'lua_Kfunction' prototype */
-  return lua_gettop(L) - 1;
-}
-
-
-static int luaB_dofile (lua_State *L) {
-  const char *fname = luaL_optstring(L, 1, NULL);
-  lua_settop(L, 1);
-  if (l_unlikely(luaL_loadfile(L, fname) != LUA_OK))
-    return lua_error(L);
-  lua_callk(L, 0, LUA_MULTRET, 0, dofilecont);
-  return dofilecont(L, 0, 0);
-}
-
-
-static int luaB_assert (lua_State *L) {
-  if (l_likely(lua_toboolean(L, 1)))  /* condition is true? */
-    return lua_gettop(L);  /* return all arguments */
-  else {  /* error */
-    luaL_checkany(L, 1);  /* there must be a condition */
-    lua_remove(L, 1);  /* remove it */
-    lua_pushliteral(L, "assertion failed!");  /* default message */
-    lua_settop(L, 1);  /* leave only message (default if no other one) */
-    return luaB_error(L);  /* call 'error' */
-  }
-}
-
-
-static int luaB_select (lua_State *L) {
-  int n = lua_gettop(L);
-  if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') {
-    lua_pushinteger(L, n-1);
-    return 1;
-  }
-  else {
-    lua_Integer i = luaL_checkinteger(L, 1);
-    if (i < 0) i = n + i;
-    else if (i > n) i = n;
-    luaL_argcheck(L, 1 <= i, 1, "index out of range");
-    return n - (int)i;
-  }
-}
-
-
-/*
-** Continuation function for 'pcall' and 'xpcall'. Both functions
-** already pushed a 'true' before doing the call, so in case of success
-** 'finishpcall' only has to return everything in the stack minus
-** 'extra' values (where 'extra' is exactly the number of items to be
-** ignored).
-*/
-static int finishpcall (lua_State *L, int status, lua_KContext extra) {
-  if (l_unlikely(status != LUA_OK && status != LUA_YIELD)) {  /* error? */
-    lua_pushboolean(L, 0);  /* first result (false) */
-    lua_pushvalue(L, -2);  /* error message */
-    return 2;  /* return false, msg */
-  }
-  else
-    return lua_gettop(L) - (int)extra;  /* return all results */
-}
-
-
-static int luaB_pcall (lua_State *L) {
-  int status;
-  luaL_checkany(L, 1);
-  lua_pushboolean(L, 1);  /* first result if no errors */
-  lua_insert(L, 1);  /* put it in place */
-  status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, finishpcall);
-  return finishpcall(L, status, 0);
-}
-
-
-/*
-** Do a protected call with error handling. After 'lua_rotate', the
-** stack will have <f, err, true, f, [args...]>; so, the function passes
-** 2 to 'finishpcall' to skip the 2 first values when returning results.
-*/
-static int luaB_xpcall (lua_State *L) {
-  int status;
-  int n = lua_gettop(L);
-  luaL_checktype(L, 2, LUA_TFUNCTION);  /* check error function */
-  lua_pushboolean(L, 1);  /* first result */
-  lua_pushvalue(L, 1);  /* function */
-  lua_rotate(L, 3, 2);  /* move them below function's arguments */
-  status = lua_pcallk(L, n - 2, LUA_MULTRET, 2, 2, finishpcall);
-  return finishpcall(L, status, 2);
-}
-
-
-static int luaB_tostring (lua_State *L) {
-  luaL_checkany(L, 1);
-  luaL_tolstring(L, 1, NULL);
-  return 1;
-}
-
-
-static const luaL_Reg base_funcs[] = {
-  {"assert", luaB_assert},
-  {"collectgarbage", luaB_collectgarbage},
-  {"dofile", luaB_dofile},
-  {"error", luaB_error},
-  {"getmetatable", luaB_getmetatable},
-  {"ipairs", luaB_ipairs},
-  {"loadfile", luaB_loadfile},
-  {"load", luaB_load},
-  {"next", luaB_next},
-  {"pairs", luaB_pairs},
-  {"pcall", luaB_pcall},
-  {"print", luaB_print},
-  {"warn", luaB_warn},
-  {"rawequal", luaB_rawequal},
-  {"rawlen", luaB_rawlen},
-  {"rawget", luaB_rawget},
-  {"rawset", luaB_rawset},
-  {"select", luaB_select},
-  {"setmetatable", luaB_setmetatable},
-  {"tonumber", luaB_tonumber},
-  {"tostring", luaB_tostring},
-  {"type", luaB_type},
-  {"xpcall", luaB_xpcall},
-  /* placeholders */
-  {LUA_GNAME, NULL},
-  {"_VERSION", NULL},
-  {NULL, NULL}
-};
-
-
-LUAMOD_API int luaopen_base (lua_State *L) {
-  /* open lib into global table */
-  lua_pushglobaltable(L);
-  luaL_setfuncs(L, base_funcs, 0);
-  /* set global _G */
-  lua_pushvalue(L, -1);
-  lua_setfield(L, -2, LUA_GNAME);
-  /* set global _VERSION */
-  lua_pushliteral(L, LUA_VERSION);
-  lua_setfield(L, -2, "_VERSION");
-  return 1;
-}
-
diff --git a/third-party/lua/src/lcode.c b/third-party/lua/src/lcode.c
deleted file mode 100644
index 1a371ca94..000000000
--- a/third-party/lua/src/lcode.c
+++ /dev/null
@@ -1,1871 +0,0 @@
-/*
-** $Id: lcode.c $
-** Code generator for Lua
-** See Copyright Notice in lua.h
-*/
-
-#define lcode_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <float.h>
-#include <limits.h>
-#include <math.h>
-#include <stdlib.h>
-
-#include "lua.h"
-
-#include "lcode.h"
-#include "ldebug.h"
-#include "ldo.h"
-#include "lgc.h"
-#include "llex.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lparser.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "lvm.h"
-
-
-/* Maximum number of registers in a Lua function (must fit in 8 bits) */
-#define MAXREGS		255
-
-
-#define hasjumps(e)	((e)->t != (e)->f)
-
-
-static int codesJ (FuncState *fs, OpCode o, int sj, int k);
-
-
-
-/* semantic error */
-l_noret luaK_semerror (LexState *ls, const char *msg) {
-  ls->t.token = 0;  /* remove "near <token>" from final message */
-  luaX_syntaxerror(ls, msg);
-}
-
-
-/*
-** If expression is a numeric constant, fills 'v' with its value
-** and returns 1. Otherwise, returns 0.
-*/
-static int tonumeral (const expdesc *e, TValue *v) {
-  if (hasjumps(e))
-    return 0;  /* not a numeral */
-  switch (e->k) {
-    case VKINT:
-      if (v) setivalue(v, e->u.ival);
-      return 1;
-    case VKFLT:
-      if (v) setfltvalue(v, e->u.nval);
-      return 1;
-    default: return 0;
-  }
-}
-
-
-/*
-** Get the constant value from a constant expression
-*/
-static TValue *const2val (FuncState *fs, const expdesc *e) {
-  lua_assert(e->k == VCONST);
-  return &fs->ls->dyd->actvar.arr[e->u.info].k;
-}
-
-
-/*
-** If expression is a constant, fills 'v' with its value
-** and returns 1. Otherwise, returns 0.
-*/
-int luaK_exp2const (FuncState *fs, const expdesc *e, TValue *v) {
-  if (hasjumps(e))
-    return 0;  /* not a constant */
-  switch (e->k) {
-    case VFALSE:
-      setbfvalue(v);
-      return 1;
-    case VTRUE:
-      setbtvalue(v);
-      return 1;
-    case VNIL:
-      setnilvalue(v);
-      return 1;
-    case VKSTR: {
-      setsvalue(fs->ls->L, v, e->u.strval);
-      return 1;
-    }
-    case VCONST: {
-      setobj(fs->ls->L, v, const2val(fs, e));
-      return 1;
-    }
-    default: return tonumeral(e, v);
-  }
-}
-
-
-/*
-** Return the previous instruction of the current code. If there
-** may be a jump target between the current instruction and the
-** previous one, return an invalid instruction (to avoid wrong
-** optimizations).
-*/
-static Instruction *previousinstruction (FuncState *fs) {
-  static const Instruction invalidinstruction = ~(Instruction)0;
-  if (fs->pc > fs->lasttarget)
-    return &fs->f->code[fs->pc - 1];  /* previous instruction */
-  else
-    return cast(Instruction*, &invalidinstruction);
-}
-
-
-/*
-** Create a OP_LOADNIL instruction, but try to optimize: if the previous
-** instruction is also OP_LOADNIL and ranges are compatible, adjust
-** range of previous instruction instead of emitting a new one. (For
-** instance, 'local a; local b' will generate a single opcode.)
-*/
-void luaK_nil (FuncState *fs, int from, int n) {
-  int l = from + n - 1;  /* last register to set nil */
-  Instruction *previous = previousinstruction(fs);
-  if (GET_OPCODE(*previous) == OP_LOADNIL) {  /* previous is LOADNIL? */
-    int pfrom = GETARG_A(*previous);  /* get previous range */
-    int pl = pfrom + GETARG_B(*previous);
-    if ((pfrom <= from && from <= pl + 1) ||
-        (from <= pfrom && pfrom <= l + 1)) {  /* can connect both? */
-      if (pfrom < from) from = pfrom;  /* from = min(from, pfrom) */
-      if (pl > l) l = pl;  /* l = max(l, pl) */
-      SETARG_A(*previous, from);
-      SETARG_B(*previous, l - from);
-      return;
-    }  /* else go through */
-  }
-  luaK_codeABC(fs, OP_LOADNIL, from, n - 1, 0);  /* else no optimization */
-}
-
-
-/*
-** Gets the destination address of a jump instruction. Used to traverse
-** a list of jumps.
-*/
-static int getjump (FuncState *fs, int pc) {
-  int offset = GETARG_sJ(fs->f->code[pc]);
-  if (offset == NO_JUMP)  /* point to itself represents end of list */
-    return NO_JUMP;  /* end of list */
-  else
-    return (pc+1)+offset;  /* turn offset into absolute position */
-}
-
-
-/*
-** Fix jump instruction at position 'pc' to jump to 'dest'.
-** (Jump addresses are relative in Lua)
-*/
-static void fixjump (FuncState *fs, int pc, int dest) {
-  Instruction *jmp = &fs->f->code[pc];
-  int offset = dest - (pc + 1);
-  lua_assert(dest != NO_JUMP);
-  if (!(-OFFSET_sJ <= offset && offset <= MAXARG_sJ - OFFSET_sJ))
-    luaX_syntaxerror(fs->ls, "control structure too long");
-  lua_assert(GET_OPCODE(*jmp) == OP_JMP);
-  SETARG_sJ(*jmp, offset);
-}
-
-
-/*
-** Concatenate jump-list 'l2' into jump-list 'l1'
-*/
-void luaK_concat (FuncState *fs, int *l1, int l2) {
-  if (l2 == NO_JUMP) return;  /* nothing to concatenate? */
-  else if (*l1 == NO_JUMP)  /* no original list? */
-    *l1 = l2;  /* 'l1' points to 'l2' */
-  else {
-    int list = *l1;
-    int next;
-    while ((next = getjump(fs, list)) != NO_JUMP)  /* find last element */
-      list = next;
-    fixjump(fs, list, l2);  /* last element links to 'l2' */
-  }
-}
-
-
-/*
-** Create a jump instruction and return its position, so its destination
-** can be fixed later (with 'fixjump').
-*/
-int luaK_jump (FuncState *fs) {
-  return codesJ(fs, OP_JMP, NO_JUMP, 0);
-}
-
-
-/*
-** Code a 'return' instruction
-*/
-void luaK_ret (FuncState *fs, int first, int nret) {
-  OpCode op;
-  switch (nret) {
-    case 0: op = OP_RETURN0; break;
-    case 1: op = OP_RETURN1; break;
-    default: op = OP_RETURN; break;
-  }
-  luaK_codeABC(fs, op, first, nret + 1, 0);
-}
-
-
-/*
-** Code a "conditional jump", that is, a test or comparison opcode
-** followed by a jump. Return jump position.
-*/
-static int condjump (FuncState *fs, OpCode op, int A, int B, int C, int k) {
-  luaK_codeABCk(fs, op, A, B, C, k);
-  return luaK_jump(fs);
-}
-
-
-/*
-** returns current 'pc' and marks it as a jump target (to avoid wrong
-** optimizations with consecutive instructions not in the same basic block).
-*/
-int luaK_getlabel (FuncState *fs) {
-  fs->lasttarget = fs->pc;
-  return fs->pc;
-}
-
-
-/*
-** Returns the position of the instruction "controlling" a given
-** jump (that is, its condition), or the jump itself if it is
-** unconditional.
-*/
-static Instruction *getjumpcontrol (FuncState *fs, int pc) {
-  Instruction *pi = &fs->f->code[pc];
-  if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1))))
-    return pi-1;
-  else
-    return pi;
-}
-
-
-/*
-** Patch destination register for a TESTSET instruction.
-** If instruction in position 'node' is not a TESTSET, return 0 ("fails").
-** Otherwise, if 'reg' is not 'NO_REG', set it as the destination
-** register. Otherwise, change instruction to a simple 'TEST' (produces
-** no register value)
-*/
-static int patchtestreg (FuncState *fs, int node, int reg) {
-  Instruction *i = getjumpcontrol(fs, node);
-  if (GET_OPCODE(*i) != OP_TESTSET)
-    return 0;  /* cannot patch other instructions */
-  if (reg != NO_REG && reg != GETARG_B(*i))
-    SETARG_A(*i, reg);
-  else {
-     /* no register to put value or register already has the value;
-        change instruction to simple test */
-    *i = CREATE_ABCk(OP_TEST, GETARG_B(*i), 0, 0, GETARG_k(*i));
-  }
-  return 1;
-}
-
-
-/*
-** Traverse a list of tests ensuring no one produces a value
-*/
-static void removevalues (FuncState *fs, int list) {
-  for (; list != NO_JUMP; list = getjump(fs, list))
-      patchtestreg(fs, list, NO_REG);
-}
-
-
-/*
-** Traverse a list of tests, patching their destination address and
-** registers: tests producing values jump to 'vtarget' (and put their
-** values in 'reg'), other tests jump to 'dtarget'.
-*/
-static void patchlistaux (FuncState *fs, int list, int vtarget, int reg,
-                          int dtarget) {
-  while (list != NO_JUMP) {
-    int next = getjump(fs, list);
-    if (patchtestreg(fs, list, reg))
-      fixjump(fs, list, vtarget);
-    else
-      fixjump(fs, list, dtarget);  /* jump to default target */
-    list = next;
-  }
-}
-
-
-/*
-** Path all jumps in 'list' to jump to 'target'.
-** (The assert means that we cannot fix a jump to a forward address
-** because we only know addresses once code is generated.)
-*/
-void luaK_patchlist (FuncState *fs, int list, int target) {
-  lua_assert(target <= fs->pc);
-  patchlistaux(fs, list, target, NO_REG, target);
-}
-
-
-void luaK_patchtohere (FuncState *fs, int list) {
-  int hr = luaK_getlabel(fs);  /* mark "here" as a jump target */
-  luaK_patchlist(fs, list, hr);
-}
-
-
-/* limit for difference between lines in relative line info. */
-#define LIMLINEDIFF	0x80
-
-
-/*
-** Save line info for a new instruction. If difference from last line
-** does not fit in a byte, of after that many instructions, save a new
-** absolute line info; (in that case, the special value 'ABSLINEINFO'
-** in 'lineinfo' signals the existence of this absolute information.)
-** Otherwise, store the difference from last line in 'lineinfo'.
-*/
-static void savelineinfo (FuncState *fs, Proto *f, int line) {
-  int linedif = line - fs->previousline;
-  int pc = fs->pc - 1;  /* last instruction coded */
-  if (abs(linedif) >= LIMLINEDIFF || fs->iwthabs++ >= MAXIWTHABS) {
-    luaM_growvector(fs->ls->L, f->abslineinfo, fs->nabslineinfo,
-                    f->sizeabslineinfo, AbsLineInfo, MAX_INT, "lines");
-    f->abslineinfo[fs->nabslineinfo].pc = pc;
-    f->abslineinfo[fs->nabslineinfo++].line = line;
-    linedif = ABSLINEINFO;  /* signal that there is absolute information */
-    fs->iwthabs = 1;  /* restart counter */
-  }
-  luaM_growvector(fs->ls->L, f->lineinfo, pc, f->sizelineinfo, ls_byte,
-                  MAX_INT, "opcodes");
-  f->lineinfo[pc] = linedif;
-  fs->previousline = line;  /* last line saved */
-}
-
-
-/*
-** Remove line information from the last instruction.
-** If line information for that instruction is absolute, set 'iwthabs'
-** above its max to force the new (replacing) instruction to have
-** absolute line info, too.
-*/
-static void removelastlineinfo (FuncState *fs) {
-  Proto *f = fs->f;
-  int pc = fs->pc - 1;  /* last instruction coded */
-  if (f->lineinfo[pc] != ABSLINEINFO) {  /* relative line info? */
-    fs->previousline -= f->lineinfo[pc];  /* correct last line saved */
-    fs->iwthabs--;  /* undo previous increment */
-  }
-  else {  /* absolute line information */
-    lua_assert(f->abslineinfo[fs->nabslineinfo - 1].pc == pc);
-    fs->nabslineinfo--;  /* remove it */
-    fs->iwthabs = MAXIWTHABS + 1;  /* force next line info to be absolute */
-  }
-}
-
-
-/*
-** Remove the last instruction created, correcting line information
-** accordingly.
-*/
-static void removelastinstruction (FuncState *fs) {
-  removelastlineinfo(fs);
-  fs->pc--;
-}
-
-
-/*
-** Emit instruction 'i', checking for array sizes and saving also its
-** line information. Return 'i' position.
-*/
-int luaK_code (FuncState *fs, Instruction i) {
-  Proto *f = fs->f;
-  /* put new instruction in code array */
-  luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction,
-                  MAX_INT, "opcodes");
-  f->code[fs->pc++] = i;
-  savelineinfo(fs, f, fs->ls->lastline);
-  return fs->pc - 1;  /* index of new instruction */
-}
-
-
-/*
-** Format and emit an 'iABC' instruction. (Assertions check consistency
-** of parameters versus opcode.)
-*/
-int luaK_codeABCk (FuncState *fs, OpCode o, int a, int b, int c, int k) {
-  lua_assert(getOpMode(o) == iABC);
-  lua_assert(a <= MAXARG_A && b <= MAXARG_B &&
-             c <= MAXARG_C && (k & ~1) == 0);
-  return luaK_code(fs, CREATE_ABCk(o, a, b, c, k));
-}
-
-
-/*
-** Format and emit an 'iABx' instruction.
-*/
-int luaK_codeABx (FuncState *fs, OpCode o, int a, unsigned int bc) {
-  lua_assert(getOpMode(o) == iABx);
-  lua_assert(a <= MAXARG_A && bc <= MAXARG_Bx);
-  return luaK_code(fs, CREATE_ABx(o, a, bc));
-}
-
-
-/*
-** Format and emit an 'iAsBx' instruction.
-*/
-int luaK_codeAsBx (FuncState *fs, OpCode o, int a, int bc) {
-  unsigned int b = bc + OFFSET_sBx;
-  lua_assert(getOpMode(o) == iAsBx);
-  lua_assert(a <= MAXARG_A && b <= MAXARG_Bx);
-  return luaK_code(fs, CREATE_ABx(o, a, b));
-}
-
-
-/*
-** Format and emit an 'isJ' instruction.
-*/
-static int codesJ (FuncState *fs, OpCode o, int sj, int k) {
-  unsigned int j = sj + OFFSET_sJ;
-  lua_assert(getOpMode(o) == isJ);
-  lua_assert(j <= MAXARG_sJ && (k & ~1) == 0);
-  return luaK_code(fs, CREATE_sJ(o, j, k));
-}
-
-
-/*
-** Emit an "extra argument" instruction (format 'iAx')
-*/
-static int codeextraarg (FuncState *fs, int a) {
-  lua_assert(a <= MAXARG_Ax);
-  return luaK_code(fs, CREATE_Ax(OP_EXTRAARG, a));
-}
-
-
-/*
-** Emit a "load constant" instruction, using either 'OP_LOADK'
-** (if constant index 'k' fits in 18 bits) or an 'OP_LOADKX'
-** instruction with "extra argument".
-*/
-static int luaK_codek (FuncState *fs, int reg, int k) {
-  if (k <= MAXARG_Bx)
-    return luaK_codeABx(fs, OP_LOADK, reg, k);
-  else {
-    int p = luaK_codeABx(fs, OP_LOADKX, reg, 0);
-    codeextraarg(fs, k);
-    return p;
-  }
-}
-
-
-/*
-** Check register-stack level, keeping track of its maximum size
-** in field 'maxstacksize'
-*/
-void luaK_checkstack (FuncState *fs, int n) {
-  int newstack = fs->freereg + n;
-  if (newstack > fs->f->maxstacksize) {
-    if (newstack >= MAXREGS)
-      luaX_syntaxerror(fs->ls,
-        "function or expression needs too many registers");
-    fs->f->maxstacksize = cast_byte(newstack);
-  }
-}
-
-
-/*
-** Reserve 'n' registers in register stack
-*/
-void luaK_reserveregs (FuncState *fs, int n) {
-  luaK_checkstack(fs, n);
-  fs->freereg += n;
-}
-
-
-/*
-** Free register 'reg', if it is neither a constant index nor
-** a local variable.
-)
-*/
-static void freereg (FuncState *fs, int reg) {
-  if (reg >= luaY_nvarstack(fs)) {
-    fs->freereg--;
-    lua_assert(reg == fs->freereg);
-  }
-}
-
-
-/*
-** Free two registers in proper order
-*/
-static void freeregs (FuncState *fs, int r1, int r2) {
-  if (r1 > r2) {
-    freereg(fs, r1);
-    freereg(fs, r2);
-  }
-  else {
-    freereg(fs, r2);
-    freereg(fs, r1);
-  }
-}
-
-
-/*
-** Free register used by expression 'e' (if any)
-*/
-static void freeexp (FuncState *fs, expdesc *e) {
-  if (e->k == VNONRELOC)
-    freereg(fs, e->u.info);
-}
-
-
-/*
-** Free registers used by expressions 'e1' and 'e2' (if any) in proper
-** order.
-*/
-static void freeexps (FuncState *fs, expdesc *e1, expdesc *e2) {
-  int r1 = (e1->k == VNONRELOC) ? e1->u.info : -1;
-  int r2 = (e2->k == VNONRELOC) ? e2->u.info : -1;
-  freeregs(fs, r1, r2);
-}
-
-
-/*
-** Add constant 'v' to prototype's list of constants (field 'k').
-** Use scanner's table to cache position of constants in constant list
-** and try to reuse constants. Because some values should not be used
-** as keys (nil cannot be a key, integer keys can collapse with float
-** keys), the caller must provide a useful 'key' for indexing the cache.
-** Note that all functions share the same table, so entering or exiting
-** a function can make some indices wrong.
-*/
-static int addk (FuncState *fs, TValue *key, TValue *v) {
-  TValue val;
-  lua_State *L = fs->ls->L;
-  Proto *f = fs->f;
-  const TValue *idx = luaH_get(fs->ls->h, key);  /* query scanner table */
-  int k, oldsize;
-  if (ttisinteger(idx)) {  /* is there an index there? */
-    k = cast_int(ivalue(idx));
-    /* correct value? (warning: must distinguish floats from integers!) */
-    if (k < fs->nk && ttypetag(&f->k[k]) == ttypetag(v) &&
-                      luaV_rawequalobj(&f->k[k], v))
-      return k;  /* reuse index */
-  }
-  /* constant not found; create a new entry */
-  oldsize = f->sizek;
-  k = fs->nk;
-  /* numerical value does not need GC barrier;
-     table has no metatable, so it does not need to invalidate cache */
-  setivalue(&val, k);
-  luaH_finishset(L, fs->ls->h, key, idx, &val);
-  luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants");
-  while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
-  setobj(L, &f->k[k], v);
-  fs->nk++;
-  luaC_barrier(L, f, v);
-  return k;
-}
-
-
-/*
-** Add a string to list of constants and return its index.
-*/
-static int stringK (FuncState *fs, TString *s) {
-  TValue o;
-  setsvalue(fs->ls->L, &o, s);
-  return addk(fs, &o, &o);  /* use string itself as key */
-}
-
-
-/*
-** Add an integer to list of constants and return its index.
-*/
-static int luaK_intK (FuncState *fs, lua_Integer n) {
-  TValue o;
-  setivalue(&o, n);
-  return addk(fs, &o, &o);  /* use integer itself as key */
-}
-
-/*
-** Add a float to list of constants and return its index. Floats
-** with integral values need a different key, to avoid collision
-** with actual integers. To that, we add to the number its smaller
-** power-of-two fraction that is still significant in its scale.
-** For doubles, that would be 1/2^52.
-** (This method is not bulletproof: there may be another float
-** with that value, and for floats larger than 2^53 the result is
-** still an integer. At worst, this only wastes an entry with
-** a duplicate.)
-*/
-static int luaK_numberK (FuncState *fs, lua_Number r) {
-  TValue o;
-  lua_Integer ik;
-  setfltvalue(&o, r);
-  if (!luaV_flttointeger(r, &ik, F2Ieq))  /* not an integral value? */
-    return addk(fs, &o, &o);  /* use number itself as key */
-  else {  /* must build an alternative key */
-    const int nbm = l_floatatt(MANT_DIG);
-    const lua_Number q = l_mathop(ldexp)(l_mathop(1.0), -nbm + 1);
-    const lua_Number k = (ik == 0) ? q : r + r*q;  /* new key */
-    TValue kv;
-    setfltvalue(&kv, k);
-    /* result is not an integral value, unless value is too large */
-    lua_assert(!luaV_flttointeger(k, &ik, F2Ieq) ||
-                l_mathop(fabs)(r) >= l_mathop(1e6));
-    return addk(fs, &kv, &o);
-  }
-}
-
-
-/*
-** Add a false to list of constants and return its index.
-*/
-static int boolF (FuncState *fs) {
-  TValue o;
-  setbfvalue(&o);
-  return addk(fs, &o, &o);  /* use boolean itself as key */
-}
-
-
-/*
-** Add a true to list of constants and return its index.
-*/
-static int boolT (FuncState *fs) {
-  TValue o;
-  setbtvalue(&o);
-  return addk(fs, &o, &o);  /* use boolean itself as key */
-}
-
-
-/*
-** Add nil to list of constants and return its index.
-*/
-static int nilK (FuncState *fs) {
-  TValue k, v;
-  setnilvalue(&v);
-  /* cannot use nil as key; instead use table itself to represent nil */
-  sethvalue(fs->ls->L, &k, fs->ls->h);
-  return addk(fs, &k, &v);
-}
-
-
-/*
-** Check whether 'i' can be stored in an 'sC' operand. Equivalent to
-** (0 <= int2sC(i) && int2sC(i) <= MAXARG_C) but without risk of
-** overflows in the hidden addition inside 'int2sC'.
-*/
-static int fitsC (lua_Integer i) {
-  return (l_castS2U(i) + OFFSET_sC <= cast_uint(MAXARG_C));
-}
-
-
-/*
-** Check whether 'i' can be stored in an 'sBx' operand.
-*/
-static int fitsBx (lua_Integer i) {
-  return (-OFFSET_sBx <= i && i <= MAXARG_Bx - OFFSET_sBx);
-}
-
-
-void luaK_int (FuncState *fs, int reg, lua_Integer i) {
-  if (fitsBx(i))
-    luaK_codeAsBx(fs, OP_LOADI, reg, cast_int(i));
-  else
-    luaK_codek(fs, reg, luaK_intK(fs, i));
-}
-
-
-static void luaK_float (FuncState *fs, int reg, lua_Number f) {
-  lua_Integer fi;
-  if (luaV_flttointeger(f, &fi, F2Ieq) && fitsBx(fi))
-    luaK_codeAsBx(fs, OP_LOADF, reg, cast_int(fi));
-  else
-    luaK_codek(fs, reg, luaK_numberK(fs, f));
-}
-
-
-/*
-** Convert a constant in 'v' into an expression description 'e'
-*/
-static void const2exp (TValue *v, expdesc *e) {
-  switch (ttypetag(v)) {
-    case LUA_VNUMINT:
-      e->k = VKINT; e->u.ival = ivalue(v);
-      break;
-    case LUA_VNUMFLT:
-      e->k = VKFLT; e->u.nval = fltvalue(v);
-      break;
-    case LUA_VFALSE:
-      e->k = VFALSE;
-      break;
-    case LUA_VTRUE:
-      e->k = VTRUE;
-      break;
-    case LUA_VNIL:
-      e->k = VNIL;
-      break;
-    case LUA_VSHRSTR:  case LUA_VLNGSTR:
-      e->k = VKSTR; e->u.strval = tsvalue(v);
-      break;
-    default: lua_assert(0);
-  }
-}
-
-
-/*
-** Fix an expression to return the number of results 'nresults'.
-** 'e' must be a multi-ret expression (function call or vararg).
-*/
-void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) {
-  Instruction *pc = &getinstruction(fs, e);
-  if (e->k == VCALL)  /* expression is an open function call? */
-    SETARG_C(*pc, nresults + 1);
-  else {
-    lua_assert(e->k == VVARARG);
-    SETARG_C(*pc, nresults + 1);
-    SETARG_A(*pc, fs->freereg);
-    luaK_reserveregs(fs, 1);
-  }
-}
-
-
-/*
-** Convert a VKSTR to a VK
-*/
-static void str2K (FuncState *fs, expdesc *e) {
-  lua_assert(e->k == VKSTR);
-  e->u.info = stringK(fs, e->u.strval);
-  e->k = VK;
-}
-
-
-/*
-** Fix an expression to return one result.
-** If expression is not a multi-ret expression (function call or
-** vararg), it already returns one result, so nothing needs to be done.
-** Function calls become VNONRELOC expressions (as its result comes
-** fixed in the base register of the call), while vararg expressions
-** become VRELOC (as OP_VARARG puts its results where it wants).
-** (Calls are created returning one result, so that does not need
-** to be fixed.)
-*/
-void luaK_setoneret (FuncState *fs, expdesc *e) {
-  if (e->k == VCALL) {  /* expression is an open function call? */
-    /* already returns 1 value */
-    lua_assert(GETARG_C(getinstruction(fs, e)) == 2);
-    e->k = VNONRELOC;  /* result has fixed position */
-    e->u.info = GETARG_A(getinstruction(fs, e));
-  }
-  else if (e->k == VVARARG) {
-    SETARG_C(getinstruction(fs, e), 2);
-    e->k = VRELOC;  /* can relocate its simple result */
-  }
-}
-
-
-/*
-** Ensure that expression 'e' is not a variable (nor a <const>).
-** (Expression still may have jump lists.)
-*/
-void luaK_dischargevars (FuncState *fs, expdesc *e) {
-  switch (e->k) {
-    case VCONST: {
-      const2exp(const2val(fs, e), e);
-      break;
-    }
-    case VLOCAL: {  /* already in a register */
-      e->u.info = e->u.var.ridx;
-      e->k = VNONRELOC;  /* becomes a non-relocatable value */
-      break;
-    }
-    case VUPVAL: {  /* move value to some (pending) register */
-      e->u.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.info, 0);
-      e->k = VRELOC;
-      break;
-    }
-    case VINDEXUP: {
-      e->u.info = luaK_codeABC(fs, OP_GETTABUP, 0, e->u.ind.t, e->u.ind.idx);
-      e->k = VRELOC;
-      break;
-    }
-    case VINDEXI: {
-      freereg(fs, e->u.ind.t);
-      e->u.info = luaK_codeABC(fs, OP_GETI, 0, e->u.ind.t, e->u.ind.idx);
-      e->k = VRELOC;
-      break;
-    }
-    case VINDEXSTR: {
-      freereg(fs, e->u.ind.t);
-      e->u.info = luaK_codeABC(fs, OP_GETFIELD, 0, e->u.ind.t, e->u.ind.idx);
-      e->k = VRELOC;
-      break;
-    }
-    case VINDEXED: {
-      freeregs(fs, e->u.ind.t, e->u.ind.idx);
-      e->u.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.ind.t, e->u.ind.idx);
-      e->k = VRELOC;
-      break;
-    }
-    case VVARARG: case VCALL: {
-      luaK_setoneret(fs, e);
-      break;
-    }
-    default: break;  /* there is one value available (somewhere) */
-  }
-}
-
-
-/*
-** Ensure expression value is in register 'reg', making 'e' a
-** non-relocatable expression.
-** (Expression still may have jump lists.)
-*/
-static void discharge2reg (FuncState *fs, expdesc *e, int reg) {
-  luaK_dischargevars(fs, e);
-  switch (e->k) {
-    case VNIL: {
-      luaK_nil(fs, reg, 1);
-      break;
-    }
-    case VFALSE: {
-      luaK_codeABC(fs, OP_LOADFALSE, reg, 0, 0);
-      break;
-    }
-    case VTRUE: {
-      luaK_codeABC(fs, OP_LOADTRUE, reg, 0, 0);
-      break;
-    }
-    case VKSTR: {
-      str2K(fs, e);
-    }  /* FALLTHROUGH */
-    case VK: {
-      luaK_codek(fs, reg, e->u.info);
-      break;
-    }
-    case VKFLT: {
-      luaK_float(fs, reg, e->u.nval);
-      break;
-    }
-    case VKINT: {
-      luaK_int(fs, reg, e->u.ival);
-      break;
-    }
-    case VRELOC: {
-      Instruction *pc = &getinstruction(fs, e);
-      SETARG_A(*pc, reg);  /* instruction will put result in 'reg' */
-      break;
-    }
-    case VNONRELOC: {
-      if (reg != e->u.info)
-        luaK_codeABC(fs, OP_MOVE, reg, e->u.info, 0);
-      break;
-    }
-    default: {
-      lua_assert(e->k == VJMP);
-      return;  /* nothing to do... */
-    }
-  }
-  e->u.info = reg;
-  e->k = VNONRELOC;
-}
-
-
-/*
-** Ensure expression value is in a register, making 'e' a
-** non-relocatable expression.
-** (Expression still may have jump lists.)
-*/
-static void discharge2anyreg (FuncState *fs, expdesc *e) {
-  if (e->k != VNONRELOC) {  /* no fixed register yet? */
-    luaK_reserveregs(fs, 1);  /* get a register */
-    discharge2reg(fs, e, fs->freereg-1);  /* put value there */
-  }
-}
-
-
-static int code_loadbool (FuncState *fs, int A, OpCode op) {
-  luaK_getlabel(fs);  /* those instructions may be jump targets */
-  return luaK_codeABC(fs, op, A, 0, 0);
-}
-
-
-/*
-** check whether list has any jump that do not produce a value
-** or produce an inverted value
-*/
-static int need_value (FuncState *fs, int list) {
-  for (; list != NO_JUMP; list = getjump(fs, list)) {
-    Instruction i = *getjumpcontrol(fs, list);
-    if (GET_OPCODE(i) != OP_TESTSET) return 1;
-  }
-  return 0;  /* not found */
-}
-
-
-/*
-** Ensures final expression result (which includes results from its
-** jump lists) is in register 'reg'.
-** If expression has jumps, need to patch these jumps either to
-** its final position or to "load" instructions (for those tests
-** that do not produce values).
-*/
-static void exp2reg (FuncState *fs, expdesc *e, int reg) {
-  discharge2reg(fs, e, reg);
-  if (e->k == VJMP)  /* expression itself is a test? */
-    luaK_concat(fs, &e->t, e->u.info);  /* put this jump in 't' list */
-  if (hasjumps(e)) {
-    int final;  /* position after whole expression */
-    int p_f = NO_JUMP;  /* position of an eventual LOAD false */
-    int p_t = NO_JUMP;  /* position of an eventual LOAD true */
-    if (need_value(fs, e->t) || need_value(fs, e->f)) {
-      int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs);
-      p_f = code_loadbool(fs, reg, OP_LFALSESKIP);  /* skip next inst. */
-      p_t = code_loadbool(fs, reg, OP_LOADTRUE);
-      /* jump around these booleans if 'e' is not a test */
-      luaK_patchtohere(fs, fj);
-    }
-    final = luaK_getlabel(fs);
-    patchlistaux(fs, e->f, final, reg, p_f);
-    patchlistaux(fs, e->t, final, reg, p_t);
-  }
-  e->f = e->t = NO_JUMP;
-  e->u.info = reg;
-  e->k = VNONRELOC;
-}
-
-
-/*
-** Ensures final expression result is in next available register.
-*/
-void luaK_exp2nextreg (FuncState *fs, expdesc *e) {
-  luaK_dischargevars(fs, e);
-  freeexp(fs, e);
-  luaK_reserveregs(fs, 1);
-  exp2reg(fs, e, fs->freereg - 1);
-}
-
-
-/*
-** Ensures final expression result is in some (any) register
-** and return that register.
-*/
-int luaK_exp2anyreg (FuncState *fs, expdesc *e) {
-  luaK_dischargevars(fs, e);
-  if (e->k == VNONRELOC) {  /* expression already has a register? */
-    if (!hasjumps(e))  /* no jumps? */
-      return e->u.info;  /* result is already in a register */
-    if (e->u.info >= luaY_nvarstack(fs)) {  /* reg. is not a local? */
-      exp2reg(fs, e, e->u.info);  /* put final result in it */
-      return e->u.info;
-    }
-    /* else expression has jumps and cannot change its register
-       to hold the jump values, because it is a local variable.
-       Go through to the default case. */
-  }
-  luaK_exp2nextreg(fs, e);  /* default: use next available register */
-  return e->u.info;
-}
-
-
-/*
-** Ensures final expression result is either in a register
-** or in an upvalue.
-*/
-void luaK_exp2anyregup (FuncState *fs, expdesc *e) {
-  if (e->k != VUPVAL || hasjumps(e))
-    luaK_exp2anyreg(fs, e);
-}
-
-
-/*
-** Ensures final expression result is either in a register
-** or it is a constant.
-*/
-void luaK_exp2val (FuncState *fs, expdesc *e) {
-  if (hasjumps(e))
-    luaK_exp2anyreg(fs, e);
-  else
-    luaK_dischargevars(fs, e);
-}
-
-
-/*
-** Try to make 'e' a K expression with an index in the range of R/K
-** indices. Return true iff succeeded.
-*/
-static int luaK_exp2K (FuncState *fs, expdesc *e) {
-  if (!hasjumps(e)) {
-    int info;
-    switch (e->k) {  /* move constants to 'k' */
-      case VTRUE: info = boolT(fs); break;
-      case VFALSE: info = boolF(fs); break;
-      case VNIL: info = nilK(fs); break;
-      case VKINT: info = luaK_intK(fs, e->u.ival); break;
-      case VKFLT: info = luaK_numberK(fs, e->u.nval); break;
-      case VKSTR: info = stringK(fs, e->u.strval); break;
-      case VK: info = e->u.info; break;
-      default: return 0;  /* not a constant */
-    }
-    if (info <= MAXINDEXRK) {  /* does constant fit in 'argC'? */
-      e->k = VK;  /* make expression a 'K' expression */
-      e->u.info = info;
-      return 1;
-    }
-  }
-  /* else, expression doesn't fit; leave it unchanged */
-  return 0;
-}
-
-
-/*
-** Ensures final expression result is in a valid R/K index
-** (that is, it is either in a register or in 'k' with an index
-** in the range of R/K indices).
-** Returns 1 iff expression is K.
-*/
-int luaK_exp2RK (FuncState *fs, expdesc *e) {
-  if (luaK_exp2K(fs, e))
-    return 1;
-  else {  /* not a constant in the right range: put it in a register */
-    luaK_exp2anyreg(fs, e);
-    return 0;
-  }
-}
-
-
-static void codeABRK (FuncState *fs, OpCode o, int a, int b,
-                      expdesc *ec) {
-  int k = luaK_exp2RK(fs, ec);
-  luaK_codeABCk(fs, o, a, b, ec->u.info, k);
-}
-
-
-/*
-** Generate code to store result of expression 'ex' into variable 'var'.
-*/
-void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) {
-  switch (var->k) {
-    case VLOCAL: {
-      freeexp(fs, ex);
-      exp2reg(fs, ex, var->u.var.ridx);  /* compute 'ex' into proper place */
-      return;
-    }
-    case VUPVAL: {
-      int e = luaK_exp2anyreg(fs, ex);
-      luaK_codeABC(fs, OP_SETUPVAL, e, var->u.info, 0);
-      break;
-    }
-    case VINDEXUP: {
-      codeABRK(fs, OP_SETTABUP, var->u.ind.t, var->u.ind.idx, ex);
-      break;
-    }
-    case VINDEXI: {
-      codeABRK(fs, OP_SETI, var->u.ind.t, var->u.ind.idx, ex);
-      break;
-    }
-    case VINDEXSTR: {
-      codeABRK(fs, OP_SETFIELD, var->u.ind.t, var->u.ind.idx, ex);
-      break;
-    }
-    case VINDEXED: {
-      codeABRK(fs, OP_SETTABLE, var->u.ind.t, var->u.ind.idx, ex);
-      break;
-    }
-    default: lua_assert(0);  /* invalid var kind to store */
-  }
-  freeexp(fs, ex);
-}
-
-
-/*
-** Emit SELF instruction (convert expression 'e' into 'e:key(e,').
-*/
-void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
-  int ereg;
-  luaK_exp2anyreg(fs, e);
-  ereg = e->u.info;  /* register where 'e' was placed */
-  freeexp(fs, e);
-  e->u.info = fs->freereg;  /* base register for op_self */
-  e->k = VNONRELOC;  /* self expression has a fixed register */
-  luaK_reserveregs(fs, 2);  /* function and 'self' produced by op_self */
-  codeABRK(fs, OP_SELF, e->u.info, ereg, key);
-  freeexp(fs, key);
-}
-
-
-/*
-** Negate condition 'e' (where 'e' is a comparison).
-*/
-static void negatecondition (FuncState *fs, expdesc *e) {
-  Instruction *pc = getjumpcontrol(fs, e->u.info);
-  lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET &&
-                                           GET_OPCODE(*pc) != OP_TEST);
-  SETARG_k(*pc, (GETARG_k(*pc) ^ 1));
-}
-
-
-/*
-** Emit instruction to jump if 'e' is 'cond' (that is, if 'cond'
-** is true, code will jump if 'e' is true.) Return jump position.
-** Optimize when 'e' is 'not' something, inverting the condition
-** and removing the 'not'.
-*/
-static int jumponcond (FuncState *fs, expdesc *e, int cond) {
-  if (e->k == VRELOC) {
-    Instruction ie = getinstruction(fs, e);
-    if (GET_OPCODE(ie) == OP_NOT) {
-      removelastinstruction(fs);  /* remove previous OP_NOT */
-      return condjump(fs, OP_TEST, GETARG_B(ie), 0, 0, !cond);
-    }
-    /* else go through */
-  }
-  discharge2anyreg(fs, e);
-  freeexp(fs, e);
-  return condjump(fs, OP_TESTSET, NO_REG, e->u.info, 0, cond);
-}
-
-
-/*
-** Emit code to go through if 'e' is true, jump otherwise.
-*/
-void luaK_goiftrue (FuncState *fs, expdesc *e) {
-  int pc;  /* pc of new jump */
-  luaK_dischargevars(fs, e);
-  switch (e->k) {
-    case VJMP: {  /* condition? */
-      negatecondition(fs, e);  /* jump when it is false */
-      pc = e->u.info;  /* save jump position */
-      break;
-    }
-    case VK: case VKFLT: case VKINT: case VKSTR: case VTRUE: {
-      pc = NO_JUMP;  /* always true; do nothing */
-      break;
-    }
-    default: {
-      pc = jumponcond(fs, e, 0);  /* jump when false */
-      break;
-    }
-  }
-  luaK_concat(fs, &e->f, pc);  /* insert new jump in false list */
-  luaK_patchtohere(fs, e->t);  /* true list jumps to here (to go through) */
-  e->t = NO_JUMP;
-}
-
-
-/*
-** Emit code to go through if 'e' is false, jump otherwise.
-*/
-void luaK_goiffalse (FuncState *fs, expdesc *e) {
-  int pc;  /* pc of new jump */
-  luaK_dischargevars(fs, e);
-  switch (e->k) {
-    case VJMP: {
-      pc = e->u.info;  /* already jump if true */
-      break;
-    }
-    case VNIL: case VFALSE: {
-      pc = NO_JUMP;  /* always false; do nothing */
-      break;
-    }
-    default: {
-      pc = jumponcond(fs, e, 1);  /* jump if true */
-      break;
-    }
-  }
-  luaK_concat(fs, &e->t, pc);  /* insert new jump in 't' list */
-  luaK_patchtohere(fs, e->f);  /* false list jumps to here (to go through) */
-  e->f = NO_JUMP;
-}
-
-
-/*
-** Code 'not e', doing constant folding.
-*/
-static void codenot (FuncState *fs, expdesc *e) {
-  switch (e->k) {
-    case VNIL: case VFALSE: {
-      e->k = VTRUE;  /* true == not nil == not false */
-      break;
-    }
-    case VK: case VKFLT: case VKINT: case VKSTR: case VTRUE: {
-      e->k = VFALSE;  /* false == not "x" == not 0.5 == not 1 == not true */
-      break;
-    }
-    case VJMP: {
-      negatecondition(fs, e);
-      break;
-    }
-    case VRELOC:
-    case VNONRELOC: {
-      discharge2anyreg(fs, e);
-      freeexp(fs, e);
-      e->u.info = luaK_codeABC(fs, OP_NOT, 0, e->u.info, 0);
-      e->k = VRELOC;
-      break;
-    }
-    default: lua_assert(0);  /* cannot happen */
-  }
-  /* interchange true and false lists */
-  { int temp = e->f; e->f = e->t; e->t = temp; }
-  removevalues(fs, e->f);  /* values are useless when negated */
-  removevalues(fs, e->t);
-}
-
-
-/*
-** Check whether expression 'e' is a small literal string
-*/
-static int isKstr (FuncState *fs, expdesc *e) {
-  return (e->k == VK && !hasjumps(e) && e->u.info <= MAXARG_B &&
-          ttisshrstring(&fs->f->k[e->u.info]));
-}
-
-/*
-** Check whether expression 'e' is a literal integer.
-*/
-int luaK_isKint (expdesc *e) {
-  return (e->k == VKINT && !hasjumps(e));
-}
-
-
-/*
-** Check whether expression 'e' is a literal integer in
-** proper range to fit in register C
-*/
-static int isCint (expdesc *e) {
-  return luaK_isKint(e) && (l_castS2U(e->u.ival) <= l_castS2U(MAXARG_C));
-}
-
-
-/*
-** Check whether expression 'e' is a literal integer in
-** proper range to fit in register sC
-*/
-static int isSCint (expdesc *e) {
-  return luaK_isKint(e) && fitsC(e->u.ival);
-}
-
-
-/*
-** Check whether expression 'e' is a literal integer or float in
-** proper range to fit in a register (sB or sC).
-*/
-static int isSCnumber (expdesc *e, int *pi, int *isfloat) {
-  lua_Integer i;
-  if (e->k == VKINT)
-    i = e->u.ival;
-  else if (e->k == VKFLT && luaV_flttointeger(e->u.nval, &i, F2Ieq))
-    *isfloat = 1;
-  else
-    return 0;  /* not a number */
-  if (!hasjumps(e) && fitsC(i)) {
-    *pi = int2sC(cast_int(i));
-    return 1;
-  }
-  else
-    return 0;
-}
-
-
-/*
-** Create expression 't[k]'. 't' must have its final result already in a
-** register or upvalue. Upvalues can only be indexed by literal strings.
-** Keys can be literal strings in the constant table or arbitrary
-** values in registers.
-*/
-void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {
-  if (k->k == VKSTR)
-    str2K(fs, k);
-  lua_assert(!hasjumps(t) &&
-             (t->k == VLOCAL || t->k == VNONRELOC || t->k == VUPVAL));
-  if (t->k == VUPVAL && !isKstr(fs, k))  /* upvalue indexed by non 'Kstr'? */
-    luaK_exp2anyreg(fs, t);  /* put it in a register */
-  if (t->k == VUPVAL) {
-    t->u.ind.t = t->u.info;  /* upvalue index */
-    t->u.ind.idx = k->u.info;  /* literal string */
-    t->k = VINDEXUP;
-  }
-  else {
-    /* register index of the table */
-    t->u.ind.t = (t->k == VLOCAL) ? t->u.var.ridx: t->u.info;
-    if (isKstr(fs, k)) {
-      t->u.ind.idx = k->u.info;  /* literal string */
-      t->k = VINDEXSTR;
-    }
-    else if (isCint(k)) {
-      t->u.ind.idx = cast_int(k->u.ival);  /* int. constant in proper range */
-      t->k = VINDEXI;
-    }
-    else {
-      t->u.ind.idx = luaK_exp2anyreg(fs, k);  /* register */
-      t->k = VINDEXED;
-    }
-  }
-}
-
-
-/*
-** Return false if folding can raise an error.
-** Bitwise operations need operands convertible to integers; division
-** operations cannot have 0 as divisor.
-*/
-static int validop (int op, TValue *v1, TValue *v2) {
-  switch (op) {
-    case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR:
-    case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: {  /* conversion errors */
-      lua_Integer i;
-      return (luaV_tointegerns(v1, &i, LUA_FLOORN2I) &&
-              luaV_tointegerns(v2, &i, LUA_FLOORN2I));
-    }
-    case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD:  /* division by 0 */
-      return (nvalue(v2) != 0);
-    default: return 1;  /* everything else is valid */
-  }
-}
-
-
-/*
-** Try to "constant-fold" an operation; return 1 iff successful.
-** (In this case, 'e1' has the final result.)
-*/
-static int constfolding (FuncState *fs, int op, expdesc *e1,
-                                        const expdesc *e2) {
-  TValue v1, v2, res;
-  if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2) || !validop(op, &v1, &v2))
-    return 0;  /* non-numeric operands or not safe to fold */
-  luaO_rawarith(fs->ls->L, op, &v1, &v2, &res);  /* does operation */
-  if (ttisinteger(&res)) {
-    e1->k = VKINT;
-    e1->u.ival = ivalue(&res);
-  }
-  else {  /* folds neither NaN nor 0.0 (to avoid problems with -0.0) */
-    lua_Number n = fltvalue(&res);
-    if (luai_numisnan(n) || n == 0)
-      return 0;
-    e1->k = VKFLT;
-    e1->u.nval = n;
-  }
-  return 1;
-}
-
-
-/*
-** Convert a BinOpr to an OpCode  (ORDER OPR - ORDER OP)
-*/
-l_sinline OpCode binopr2op (BinOpr opr, BinOpr baser, OpCode base) {
-  lua_assert(baser <= opr &&
-            ((baser == OPR_ADD && opr <= OPR_SHR) ||
-             (baser == OPR_LT && opr <= OPR_LE)));
-  return cast(OpCode, (cast_int(opr) - cast_int(baser)) + cast_int(base));
-}
-
-
-/*
-** Convert a UnOpr to an OpCode  (ORDER OPR - ORDER OP)
-*/
-l_sinline OpCode unopr2op (UnOpr opr) {
-  return cast(OpCode, (cast_int(opr) - cast_int(OPR_MINUS)) +
-                                       cast_int(OP_UNM));
-}
-
-
-/*
-** Convert a BinOpr to a tag method  (ORDER OPR - ORDER TM)
-*/
-l_sinline TMS binopr2TM (BinOpr opr) {
-  lua_assert(OPR_ADD <= opr && opr <= OPR_SHR);
-  return cast(TMS, (cast_int(opr) - cast_int(OPR_ADD)) + cast_int(TM_ADD));
-}
-
-
-/*
-** Emit code for unary expressions that "produce values"
-** (everything but 'not').
-** Expression to produce final result will be encoded in 'e'.
-*/
-static void codeunexpval (FuncState *fs, OpCode op, expdesc *e, int line) {
-  int r = luaK_exp2anyreg(fs, e);  /* opcodes operate only on registers */
-  freeexp(fs, e);
-  e->u.info = luaK_codeABC(fs, op, 0, r, 0);  /* generate opcode */
-  e->k = VRELOC;  /* all those operations are relocatable */
-  luaK_fixline(fs, line);
-}
-
-
-/*
-** Emit code for binary expressions that "produce values"
-** (everything but logical operators 'and'/'or' and comparison
-** operators).
-** Expression to produce final result will be encoded in 'e1'.
-*/
-static void finishbinexpval (FuncState *fs, expdesc *e1, expdesc *e2,
-                             OpCode op, int v2, int flip, int line,
-                             OpCode mmop, TMS event) {
-  int v1 = luaK_exp2anyreg(fs, e1);
-  int pc = luaK_codeABCk(fs, op, 0, v1, v2, 0);
-  freeexps(fs, e1, e2);
-  e1->u.info = pc;
-  e1->k = VRELOC;  /* all those operations are relocatable */
-  luaK_fixline(fs, line);
-  luaK_codeABCk(fs, mmop, v1, v2, event, flip);  /* to call metamethod */
-  luaK_fixline(fs, line);
-}
-
-
-/*
-** Emit code for binary expressions that "produce values" over
-** two registers.
-*/
-static void codebinexpval (FuncState *fs, BinOpr opr,
-                           expdesc *e1, expdesc *e2, int line) {
-  OpCode op = binopr2op(opr, OPR_ADD, OP_ADD);
-  int v2 = luaK_exp2anyreg(fs, e2);  /* make sure 'e2' is in a register */
-  /* 'e1' must be already in a register or it is a constant */
-  lua_assert((VNIL <= e1->k && e1->k <= VKSTR) ||
-             e1->k == VNONRELOC || e1->k == VRELOC);
-  lua_assert(OP_ADD <= op && op <= OP_SHR);
-  finishbinexpval(fs, e1, e2, op, v2, 0, line, OP_MMBIN, binopr2TM(opr));
-}
-
-
-/*
-** Code binary operators with immediate operands.
-*/
-static void codebini (FuncState *fs, OpCode op,
-                       expdesc *e1, expdesc *e2, int flip, int line,
-                       TMS event) {
-  int v2 = int2sC(cast_int(e2->u.ival));  /* immediate operand */
-  lua_assert(e2->k == VKINT);
-  finishbinexpval(fs, e1, e2, op, v2, flip, line, OP_MMBINI, event);
-}
-
-
-/*
-** Code binary operators with K operand.
-*/
-static void codebinK (FuncState *fs, BinOpr opr,
-                      expdesc *e1, expdesc *e2, int flip, int line) {
-  TMS event = binopr2TM(opr);
-  int v2 = e2->u.info;  /* K index */
-  OpCode op = binopr2op(opr, OPR_ADD, OP_ADDK);
-  finishbinexpval(fs, e1, e2, op, v2, flip, line, OP_MMBINK, event);
-}
-
-
-/* Try to code a binary operator negating its second operand.
-** For the metamethod, 2nd operand must keep its original value.
-*/
-static int finishbinexpneg (FuncState *fs, expdesc *e1, expdesc *e2,
-                             OpCode op, int line, TMS event) {
-  if (!luaK_isKint(e2))
-    return 0;  /* not an integer constant */
-  else {
-    lua_Integer i2 = e2->u.ival;
-    if (!(fitsC(i2) && fitsC(-i2)))
-      return 0;  /* not in the proper range */
-    else {  /* operating a small integer constant */
-      int v2 = cast_int(i2);
-      finishbinexpval(fs, e1, e2, op, int2sC(-v2), 0, line, OP_MMBINI, event);
-      /* correct metamethod argument */
-      SETARG_B(fs->f->code[fs->pc - 1], int2sC(v2));
-      return 1;  /* successfully coded */
-    }
-  }
-}
-
-
-static void swapexps (expdesc *e1, expdesc *e2) {
-  expdesc temp = *e1; *e1 = *e2; *e2 = temp;  /* swap 'e1' and 'e2' */
-}
-
-
-/*
-** Code binary operators with no constant operand.
-*/
-static void codebinNoK (FuncState *fs, BinOpr opr,
-                        expdesc *e1, expdesc *e2, int flip, int line) {
-  if (flip)
-    swapexps(e1, e2);  /* back to original order */
-  codebinexpval(fs, opr, e1, e2, line);  /* use standard operators */
-}
-
-
-/*
-** Code arithmetic operators ('+', '-', ...). If second operand is a
-** constant in the proper range, use variant opcodes with K operands.
-*/
-static void codearith (FuncState *fs, BinOpr opr,
-                       expdesc *e1, expdesc *e2, int flip, int line) {
-  if (tonumeral(e2, NULL) && luaK_exp2K(fs, e2))  /* K operand? */
-    codebinK(fs, opr, e1, e2, flip, line);
-  else  /* 'e2' is neither an immediate nor a K operand */
-    codebinNoK(fs, opr, e1, e2, flip, line);
-}
-
-
-/*
-** Code commutative operators ('+', '*'). If first operand is a
-** numeric constant, change order of operands to try to use an
-** immediate or K operator.
-*/
-static void codecommutative (FuncState *fs, BinOpr op,
-                             expdesc *e1, expdesc *e2, int line) {
-  int flip = 0;
-  if (tonumeral(e1, NULL)) {  /* is first operand a numeric constant? */
-    swapexps(e1, e2);  /* change order */
-    flip = 1;
-  }
-  if (op == OPR_ADD && isSCint(e2))  /* immediate operand? */
-    codebini(fs, OP_ADDI, e1, e2, flip, line, TM_ADD);
-  else
-    codearith(fs, op, e1, e2, flip, line);
-}
-
-
-/*
-** Code bitwise operations; they are all commutative, so the function
-** tries to put an integer constant as the 2nd operand (a K operand).
-*/
-static void codebitwise (FuncState *fs, BinOpr opr,
-                         expdesc *e1, expdesc *e2, int line) {
-  int flip = 0;
-  if (e1->k == VKINT) {
-    swapexps(e1, e2);  /* 'e2' will be the constant operand */
-    flip = 1;
-  }
-  if (e2->k == VKINT && luaK_exp2K(fs, e2))  /* K operand? */
-    codebinK(fs, opr, e1, e2, flip, line);
-  else  /* no constants */
-    codebinNoK(fs, opr, e1, e2, flip, line);
-}
-
-
-/*
-** Emit code for order comparisons. When using an immediate operand,
-** 'isfloat' tells whether the original value was a float.
-*/
-static void codeorder (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2) {
-  int r1, r2;
-  int im;
-  int isfloat = 0;
-  OpCode op;
-  if (isSCnumber(e2, &im, &isfloat)) {
-    /* use immediate operand */
-    r1 = luaK_exp2anyreg(fs, e1);
-    r2 = im;
-    op = binopr2op(opr, OPR_LT, OP_LTI);
-  }
-  else if (isSCnumber(e1, &im, &isfloat)) {
-    /* transform (A < B) to (B > A) and (A <= B) to (B >= A) */
-    r1 = luaK_exp2anyreg(fs, e2);
-    r2 = im;
-    op = binopr2op(opr, OPR_LT, OP_GTI);
-  }
-  else {  /* regular case, compare two registers */
-    r1 = luaK_exp2anyreg(fs, e1);
-    r2 = luaK_exp2anyreg(fs, e2);
-    op = binopr2op(opr, OPR_LT, OP_LT);
-  }
-  freeexps(fs, e1, e2);
-  e1->u.info = condjump(fs, op, r1, r2, isfloat, 1);
-  e1->k = VJMP;
-}
-
-
-/*
-** Emit code for equality comparisons ('==', '~=').
-** 'e1' was already put as RK by 'luaK_infix'.
-*/
-static void codeeq (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2) {
-  int r1, r2;
-  int im;
-  int isfloat = 0;  /* not needed here, but kept for symmetry */
-  OpCode op;
-  if (e1->k != VNONRELOC) {
-    lua_assert(e1->k == VK || e1->k == VKINT || e1->k == VKFLT);
-    swapexps(e1, e2);
-  }
-  r1 = luaK_exp2anyreg(fs, e1);  /* 1st expression must be in register */
-  if (isSCnumber(e2, &im, &isfloat)) {
-    op = OP_EQI;
-    r2 = im;  /* immediate operand */
-  }
-  else if (luaK_exp2RK(fs, e2)) {  /* 2nd expression is constant? */
-    op = OP_EQK;
-    r2 = e2->u.info;  /* constant index */
-  }
-  else {
-    op = OP_EQ;  /* will compare two registers */
-    r2 = luaK_exp2anyreg(fs, e2);
-  }
-  freeexps(fs, e1, e2);
-  e1->u.info = condjump(fs, op, r1, r2, isfloat, (opr == OPR_EQ));
-  e1->k = VJMP;
-}
-
-
-/*
-** Apply prefix operation 'op' to expression 'e'.
-*/
-void luaK_prefix (FuncState *fs, UnOpr opr, expdesc *e, int line) {
-  static const expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP};
-  luaK_dischargevars(fs, e);
-  switch (opr) {
-    case OPR_MINUS: case OPR_BNOT:  /* use 'ef' as fake 2nd operand */
-      if (constfolding(fs, opr + LUA_OPUNM, e, &ef))
-        break;
-      /* else */ /* FALLTHROUGH */
-    case OPR_LEN:
-      codeunexpval(fs, unopr2op(opr), e, line);
-      break;
-    case OPR_NOT: codenot(fs, e); break;
-    default: lua_assert(0);
-  }
-}
-
-
-/*
-** Process 1st operand 'v' of binary operation 'op' before reading
-** 2nd operand.
-*/
-void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
-  luaK_dischargevars(fs, v);
-  switch (op) {
-    case OPR_AND: {
-      luaK_goiftrue(fs, v);  /* go ahead only if 'v' is true */
-      break;
-    }
-    case OPR_OR: {
-      luaK_goiffalse(fs, v);  /* go ahead only if 'v' is false */
-      break;
-    }
-    case OPR_CONCAT: {
-      luaK_exp2nextreg(fs, v);  /* operand must be on the stack */
-      break;
-    }
-    case OPR_ADD: case OPR_SUB:
-    case OPR_MUL: case OPR_DIV: case OPR_IDIV:
-    case OPR_MOD: case OPR_POW:
-    case OPR_BAND: case OPR_BOR: case OPR_BXOR:
-    case OPR_SHL: case OPR_SHR: {
-      if (!tonumeral(v, NULL))
-        luaK_exp2anyreg(fs, v);
-      /* else keep numeral, which may be folded or used as an immediate
-         operand */
-      break;
-    }
-    case OPR_EQ: case OPR_NE: {
-      if (!tonumeral(v, NULL))
-        luaK_exp2RK(fs, v);
-      /* else keep numeral, which may be an immediate operand */
-      break;
-    }
-    case OPR_LT: case OPR_LE:
-    case OPR_GT: case OPR_GE: {
-      int dummy, dummy2;
-      if (!isSCnumber(v, &dummy, &dummy2))
-        luaK_exp2anyreg(fs, v);
-      /* else keep numeral, which may be an immediate operand */
-      break;
-    }
-    default: lua_assert(0);
-  }
-}
-
-/*
-** Create code for '(e1 .. e2)'.
-** For '(e1 .. e2.1 .. e2.2)' (which is '(e1 .. (e2.1 .. e2.2))',
-** because concatenation is right associative), merge both CONCATs.
-*/
-static void codeconcat (FuncState *fs, expdesc *e1, expdesc *e2, int line) {
-  Instruction *ie2 = previousinstruction(fs);
-  if (GET_OPCODE(*ie2) == OP_CONCAT) {  /* is 'e2' a concatenation? */
-    int n = GETARG_B(*ie2);  /* # of elements concatenated in 'e2' */
-    lua_assert(e1->u.info + 1 == GETARG_A(*ie2));
-    freeexp(fs, e2);
-    SETARG_A(*ie2, e1->u.info);  /* correct first element ('e1') */
-    SETARG_B(*ie2, n + 1);  /* will concatenate one more element */
-  }
-  else {  /* 'e2' is not a concatenation */
-    luaK_codeABC(fs, OP_CONCAT, e1->u.info, 2, 0);  /* new concat opcode */
-    freeexp(fs, e2);
-    luaK_fixline(fs, line);
-  }
-}
-
-
-/*
-** Finalize code for binary operation, after reading 2nd operand.
-*/
-void luaK_posfix (FuncState *fs, BinOpr opr,
-                  expdesc *e1, expdesc *e2, int line) {
-  luaK_dischargevars(fs, e2);
-  if (foldbinop(opr) && constfolding(fs, opr + LUA_OPADD, e1, e2))
-    return;  /* done by folding */
-  switch (opr) {
-    case OPR_AND: {
-      lua_assert(e1->t == NO_JUMP);  /* list closed by 'luaK_infix' */
-      luaK_concat(fs, &e2->f, e1->f);
-      *e1 = *e2;
-      break;
-    }
-    case OPR_OR: {
-      lua_assert(e1->f == NO_JUMP);  /* list closed by 'luaK_infix' */
-      luaK_concat(fs, &e2->t, e1->t);
-      *e1 = *e2;
-      break;
-    }
-    case OPR_CONCAT: {  /* e1 .. e2 */
-      luaK_exp2nextreg(fs, e2);
-      codeconcat(fs, e1, e2, line);
-      break;
-    }
-    case OPR_ADD: case OPR_MUL: {
-      codecommutative(fs, opr, e1, e2, line);
-      break;
-    }
-    case OPR_SUB: {
-      if (finishbinexpneg(fs, e1, e2, OP_ADDI, line, TM_SUB))
-        break; /* coded as (r1 + -I) */
-      /* ELSE */
-    }  /* FALLTHROUGH */
-    case OPR_DIV: case OPR_IDIV: case OPR_MOD: case OPR_POW: {
-      codearith(fs, opr, e1, e2, 0, line);
-      break;
-    }
-    case OPR_BAND: case OPR_BOR: case OPR_BXOR: {
-      codebitwise(fs, opr, e1, e2, line);
-      break;
-    }
-    case OPR_SHL: {
-      if (isSCint(e1)) {
-        swapexps(e1, e2);
-        codebini(fs, OP_SHLI, e1, e2, 1, line, TM_SHL);  /* I << r2 */
-      }
-      else if (finishbinexpneg(fs, e1, e2, OP_SHRI, line, TM_SHL)) {
-        /* coded as (r1 >> -I) */;
-      }
-      else  /* regular case (two registers) */
-       codebinexpval(fs, opr, e1, e2, line);
-      break;
-    }
-    case OPR_SHR: {
-      if (isSCint(e2))
-        codebini(fs, OP_SHRI, e1, e2, 0, line, TM_SHR);  /* r1 >> I */
-      else  /* regular case (two registers) */
-        codebinexpval(fs, opr, e1, e2, line);
-      break;
-    }
-    case OPR_EQ: case OPR_NE: {
-      codeeq(fs, opr, e1, e2);
-      break;
-    }
-    case OPR_GT: case OPR_GE: {
-      /* '(a > b)' <=> '(b < a)';  '(a >= b)' <=> '(b <= a)' */
-      swapexps(e1, e2);
-      opr = cast(BinOpr, (opr - OPR_GT) + OPR_LT);
-    }  /* FALLTHROUGH */
-    case OPR_LT: case OPR_LE: {
-      codeorder(fs, opr, e1, e2);
-      break;
-    }
-    default: lua_assert(0);
-  }
-}
-
-
-/*
-** Change line information associated with current position, by removing
-** previous info and adding it again with new line.
-*/
-void luaK_fixline (FuncState *fs, int line) {
-  removelastlineinfo(fs);
-  savelineinfo(fs, fs->f, line);
-}
-
-
-void luaK_settablesize (FuncState *fs, int pc, int ra, int asize, int hsize) {
-  Instruction *inst = &fs->f->code[pc];
-  int rb = (hsize != 0) ? luaO_ceillog2(hsize) + 1 : 0;  /* hash size */
-  int extra = asize / (MAXARG_C + 1);  /* higher bits of array size */
-  int rc = asize % (MAXARG_C + 1);  /* lower bits of array size */
-  int k = (extra > 0);  /* true iff needs extra argument */
-  *inst = CREATE_ABCk(OP_NEWTABLE, ra, rb, rc, k);
-  *(inst + 1) = CREATE_Ax(OP_EXTRAARG, extra);
-}
-
-
-/*
-** Emit a SETLIST instruction.
-** 'base' is register that keeps table;
-** 'nelems' is #table plus those to be stored now;
-** 'tostore' is number of values (in registers 'base + 1',...) to add to
-** table (or LUA_MULTRET to add up to stack top).
-*/
-void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {
-  lua_assert(tostore != 0 && tostore <= LFIELDS_PER_FLUSH);
-  if (tostore == LUA_MULTRET)
-    tostore = 0;
-  if (nelems <= MAXARG_C)
-    luaK_codeABC(fs, OP_SETLIST, base, tostore, nelems);
-  else {
-    int extra = nelems / (MAXARG_C + 1);
-    nelems %= (MAXARG_C + 1);
-    luaK_codeABCk(fs, OP_SETLIST, base, tostore, nelems, 1);
-    codeextraarg(fs, extra);
-  }
-  fs->freereg = base + 1;  /* free registers with list values */
-}
-
-
-/*
-** return the final target of a jump (skipping jumps to jumps)
-*/
-static int finaltarget (Instruction *code, int i) {
-  int count;
-  for (count = 0; count < 100; count++) {  /* avoid infinite loops */
-    Instruction pc = code[i];
-    if (GET_OPCODE(pc) != OP_JMP)
-      break;
-     else
-       i += GETARG_sJ(pc) + 1;
-  }
-  return i;
-}
-
-
-/*
-** Do a final pass over the code of a function, doing small peephole
-** optimizations and adjustments.
-*/
-void luaK_finish (FuncState *fs) {
-  int i;
-  Proto *p = fs->f;
-  for (i = 0; i < fs->pc; i++) {
-    Instruction *pc = &p->code[i];
-    lua_assert(i == 0 || isOT(*(pc - 1)) == isIT(*pc));
-    switch (GET_OPCODE(*pc)) {
-      case OP_RETURN0: case OP_RETURN1: {
-        if (!(fs->needclose || p->is_vararg))
-          break;  /* no extra work */
-        /* else use OP_RETURN to do the extra work */
-        SET_OPCODE(*pc, OP_RETURN);
-      }  /* FALLTHROUGH */
-      case OP_RETURN: case OP_TAILCALL: {
-        if (fs->needclose)
-          SETARG_k(*pc, 1);  /* signal that it needs to close */
-        if (p->is_vararg)
-          SETARG_C(*pc, p->numparams + 1);  /* signal that it is vararg */
-        break;
-      }
-      case OP_JMP: {
-        int target = finaltarget(p->code, i);
-        fixjump(fs, i, target);
-        break;
-      }
-      default: break;
-    }
-  }
-}
diff --git a/third-party/lua/src/lcode.h b/third-party/lua/src/lcode.h
deleted file mode 100644
index 326582445..000000000
--- a/third-party/lua/src/lcode.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
-** $Id: lcode.h $
-** Code generator for Lua
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lcode_h
-#define lcode_h
-
-#include "llex.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lparser.h"
-
-
-/*
-** Marks the end of a patch list. It is an invalid value both as an absolute
-** address, and as a list link (would link an element to itself).
-*/
-#define NO_JUMP (-1)
-
-
-/*
-** grep "ORDER OPR" if you change these enums  (ORDER OP)
-*/
-typedef enum BinOpr {
-  /* arithmetic operators */
-  OPR_ADD, OPR_SUB, OPR_MUL, OPR_MOD, OPR_POW,
-  OPR_DIV, OPR_IDIV,
-  /* bitwise operators */
-  OPR_BAND, OPR_BOR, OPR_BXOR,
-  OPR_SHL, OPR_SHR,
-  /* string operator */
-  OPR_CONCAT,
-  /* comparison operators */
-  OPR_EQ, OPR_LT, OPR_LE,
-  OPR_NE, OPR_GT, OPR_GE,
-  /* logical operators */
-  OPR_AND, OPR_OR,
-  OPR_NOBINOPR
-} BinOpr;
-
-
-/* true if operation is foldable (that is, it is arithmetic or bitwise) */
-#define foldbinop(op)	((op) <= OPR_SHR)
-
-
-#define luaK_codeABC(fs,o,a,b,c)	luaK_codeABCk(fs,o,a,b,c,0)
-
-
-typedef enum UnOpr { OPR_MINUS, OPR_BNOT, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
-
-
-/* get (pointer to) instruction of given 'expdesc' */
-#define getinstruction(fs,e)	((fs)->f->code[(e)->u.info])
-
-
-#define luaK_setmultret(fs,e)	luaK_setreturns(fs, e, LUA_MULTRET)
-
-#define luaK_jumpto(fs,t)	luaK_patchlist(fs, luaK_jump(fs), t)
-
-LUAI_FUNC int luaK_code (FuncState *fs, Instruction i);
-LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
-LUAI_FUNC int luaK_codeAsBx (FuncState *fs, OpCode o, int A, int Bx);
-LUAI_FUNC int luaK_codeABCk (FuncState *fs, OpCode o, int A,
-                                            int B, int C, int k);
-LUAI_FUNC int luaK_isKint (expdesc *e);
-LUAI_FUNC int luaK_exp2const (FuncState *fs, const expdesc *e, TValue *v);
-LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
-LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
-LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
-LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
-LUAI_FUNC void luaK_int (FuncState *fs, int reg, lua_Integer n);
-LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
-LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
-LUAI_FUNC void luaK_exp2anyregup (FuncState *fs, expdesc *e);
-LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e);
-LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e);
-LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e);
-LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
-LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
-LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);
-LUAI_FUNC void luaK_goiffalse (FuncState *fs, expdesc *e);
-LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
-LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
-LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
-LUAI_FUNC int luaK_jump (FuncState *fs);
-LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
-LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
-LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
-LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
-LUAI_FUNC int luaK_getlabel (FuncState *fs);
-LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v, int line);
-LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
-LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1,
-                            expdesc *v2, int line);
-LUAI_FUNC void luaK_settablesize (FuncState *fs, int pc,
-                                  int ra, int asize, int hsize);
-LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
-LUAI_FUNC void luaK_finish (FuncState *fs);
-LUAI_FUNC l_noret luaK_semerror (LexState *ls, const char *msg);
-
-
-#endif
diff --git a/third-party/lua/src/lcorolib.c b/third-party/lua/src/lcorolib.c
deleted file mode 100644
index c64adf08a..000000000
--- a/third-party/lua/src/lcorolib.c
+++ /dev/null
@@ -1,210 +0,0 @@
-/*
-** $Id: lcorolib.c $
-** Coroutine Library
-** See Copyright Notice in lua.h
-*/
-
-#define lcorolib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <stdlib.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-static lua_State *getco (lua_State *L) {
-  lua_State *co = lua_tothread(L, 1);
-  luaL_argexpected(L, co, 1, "thread");
-  return co;
-}
-
-
-/*
-** Resumes a coroutine. Returns the number of results for non-error
-** cases or -1 for errors.
-*/
-static int auxresume (lua_State *L, lua_State *co, int narg) {
-  int status, nres;
-  if (l_unlikely(!lua_checkstack(co, narg))) {
-    lua_pushliteral(L, "too many arguments to resume");
-    return -1;  /* error flag */
-  }
-  lua_xmove(L, co, narg);
-  status = lua_resume(co, L, narg, &nres);
-  if (l_likely(status == LUA_OK || status == LUA_YIELD)) {
-    if (l_unlikely(!lua_checkstack(L, nres + 1))) {
-      lua_pop(co, nres);  /* remove results anyway */
-      lua_pushliteral(L, "too many results to resume");
-      return -1;  /* error flag */
-    }
-    lua_xmove(co, L, nres);  /* move yielded values */
-    return nres;
-  }
-  else {
-    lua_xmove(co, L, 1);  /* move error message */
-    return -1;  /* error flag */
-  }
-}
-
-
-static int luaB_coresume (lua_State *L) {
-  lua_State *co = getco(L);
-  int r;
-  r = auxresume(L, co, lua_gettop(L) - 1);
-  if (l_unlikely(r < 0)) {
-    lua_pushboolean(L, 0);
-    lua_insert(L, -2);
-    return 2;  /* return false + error message */
-  }
-  else {
-    lua_pushboolean(L, 1);
-    lua_insert(L, -(r + 1));
-    return r + 1;  /* return true + 'resume' returns */
-  }
-}
-
-
-static int luaB_auxwrap (lua_State *L) {
-  lua_State *co = lua_tothread(L, lua_upvalueindex(1));
-  int r = auxresume(L, co, lua_gettop(L));
-  if (l_unlikely(r < 0)) {  /* error? */
-    int stat = lua_status(co);
-    if (stat != LUA_OK && stat != LUA_YIELD) {  /* error in the coroutine? */
-      stat = lua_closethread(co, L);  /* close its tbc variables */
-      lua_assert(stat != LUA_OK);
-      lua_xmove(co, L, 1);  /* move error message to the caller */
-    }
-    if (stat != LUA_ERRMEM &&  /* not a memory error and ... */
-        lua_type(L, -1) == LUA_TSTRING) {  /* ... error object is a string? */
-      luaL_where(L, 1);  /* add extra info, if available */
-      lua_insert(L, -2);
-      lua_concat(L, 2);
-    }
-    return lua_error(L);  /* propagate error */
-  }
-  return r;
-}
-
-
-static int luaB_cocreate (lua_State *L) {
-  lua_State *NL;
-  luaL_checktype(L, 1, LUA_TFUNCTION);
-  NL = lua_newthread(L);
-  lua_pushvalue(L, 1);  /* move function to top */
-  lua_xmove(L, NL, 1);  /* move function from L to NL */
-  return 1;
-}
-
-
-static int luaB_cowrap (lua_State *L) {
-  luaB_cocreate(L);
-  lua_pushcclosure(L, luaB_auxwrap, 1);
-  return 1;
-}
-
-
-static int luaB_yield (lua_State *L) {
-  return lua_yield(L, lua_gettop(L));
-}
-
-
-#define COS_RUN		0
-#define COS_DEAD	1
-#define COS_YIELD	2
-#define COS_NORM	3
-
-
-static const char *const statname[] =
-  {"running", "dead", "suspended", "normal"};
-
-
-static int auxstatus (lua_State *L, lua_State *co) {
-  if (L == co) return COS_RUN;
-  else {
-    switch (lua_status(co)) {
-      case LUA_YIELD:
-        return COS_YIELD;
-      case LUA_OK: {
-        lua_Debug ar;
-        if (lua_getstack(co, 0, &ar))  /* does it have frames? */
-          return COS_NORM;  /* it is running */
-        else if (lua_gettop(co) == 0)
-            return COS_DEAD;
-        else
-          return COS_YIELD;  /* initial state */
-      }
-      default:  /* some error occurred */
-        return COS_DEAD;
-    }
-  }
-}
-
-
-static int luaB_costatus (lua_State *L) {
-  lua_State *co = getco(L);
-  lua_pushstring(L, statname[auxstatus(L, co)]);
-  return 1;
-}
-
-
-static int luaB_yieldable (lua_State *L) {
-  lua_State *co = lua_isnone(L, 1) ? L : getco(L);
-  lua_pushboolean(L, lua_isyieldable(co));
-  return 1;
-}
-
-
-static int luaB_corunning (lua_State *L) {
-  int ismain = lua_pushthread(L);
-  lua_pushboolean(L, ismain);
-  return 2;
-}
-
-
-static int luaB_close (lua_State *L) {
-  lua_State *co = getco(L);
-  int status = auxstatus(L, co);
-  switch (status) {
-    case COS_DEAD: case COS_YIELD: {
-      status = lua_closethread(co, L);
-      if (status == LUA_OK) {
-        lua_pushboolean(L, 1);
-        return 1;
-      }
-      else {
-        lua_pushboolean(L, 0);
-        lua_xmove(co, L, 1);  /* move error message */
-        return 2;
-      }
-    }
-    default:  /* normal or running coroutine */
-      return luaL_error(L, "cannot close a %s coroutine", statname[status]);
-  }
-}
-
-
-static const luaL_Reg co_funcs[] = {
-  {"create", luaB_cocreate},
-  {"resume", luaB_coresume},
-  {"running", luaB_corunning},
-  {"status", luaB_costatus},
-  {"wrap", luaB_cowrap},
-  {"yield", luaB_yield},
-  {"isyieldable", luaB_yieldable},
-  {"close", luaB_close},
-  {NULL, NULL}
-};
-
-
-
-LUAMOD_API int luaopen_coroutine (lua_State *L) {
-  luaL_newlib(L, co_funcs);
-  return 1;
-}
-
diff --git a/third-party/lua/src/lctype.c b/third-party/lua/src/lctype.c
deleted file mode 100644
index 954228094..000000000
--- a/third-party/lua/src/lctype.c
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
-** $Id: lctype.c $
-** 'ctype' functions for Lua
-** See Copyright Notice in lua.h
-*/
-
-#define lctype_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include "lctype.h"
-
-#if !LUA_USE_CTYPE	/* { */
-
-#include <limits.h>
-
-
-#if defined (LUA_UCID)		/* accept UniCode IDentifiers? */
-/* consider all non-ascii codepoints to be alphabetic */
-#define NONA		0x01
-#else
-#define NONA		0x00	/* default */
-#endif
-
-
-LUAI_DDEF const lu_byte luai_ctype_[UCHAR_MAX + 2] = {
-  0x00,  /* EOZ */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 0. */
-  0x00,  0x08,  0x08,  0x08,  0x08,  0x08,  0x00,  0x00,
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 1. */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-  0x0c,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,	/* 2. */
-  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,
-  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,	/* 3. */
-  0x16,  0x16,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,
-  0x04,  0x15,  0x15,  0x15,  0x15,  0x15,  0x15,  0x05,	/* 4. */
-  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,
-  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,	/* 5. */
-  0x05,  0x05,  0x05,  0x04,  0x04,  0x04,  0x04,  0x05,
-  0x04,  0x15,  0x15,  0x15,  0x15,  0x15,  0x15,  0x05,	/* 6. */
-  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,
-  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,	/* 7. */
-  0x05,  0x05,  0x05,  0x04,  0x04,  0x04,  0x04,  0x00,
-  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,	/* 8. */
-  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,
-  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,	/* 9. */
-  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,
-  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,	/* a. */
-  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,
-  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,	/* b. */
-  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,
-  0x00,  0x00,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,	/* c. */
-  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,
-  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,	/* d. */
-  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,
-  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,	/* e. */
-  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,  NONA,
-  NONA,  NONA,  NONA,  NONA,  NONA,  0x00,  0x00,  0x00,	/* f. */
-  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00
-};
-
-#endif			/* } */
diff --git a/third-party/lua/src/lctype.h b/third-party/lua/src/lctype.h
deleted file mode 100644
index 864e19018..000000000
--- a/third-party/lua/src/lctype.h
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
-** $Id: lctype.h $
-** 'ctype' functions for Lua
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lctype_h
-#define lctype_h
-
-#include "lua.h"
-
-
-/*
-** WARNING: the functions defined here do not necessarily correspond
-** to the similar functions in the standard C ctype.h. They are
-** optimized for the specific needs of Lua.
-*/
-
-#if !defined(LUA_USE_CTYPE)
-
-#if 'A' == 65 && '0' == 48
-/* ASCII case: can use its own tables; faster and fixed */
-#define LUA_USE_CTYPE	0
-#else
-/* must use standard C ctype */
-#define LUA_USE_CTYPE	1
-#endif
-
-#endif
-
-
-#if !LUA_USE_CTYPE	/* { */
-
-#include <limits.h>
-
-#include "llimits.h"
-
-
-#define ALPHABIT	0
-#define DIGITBIT	1
-#define PRINTBIT	2
-#define SPACEBIT	3
-#define XDIGITBIT	4
-
-
-#define MASK(B)		(1 << (B))
-
-
-/*
-** add 1 to char to allow index -1 (EOZ)
-*/
-#define testprop(c,p)	(luai_ctype_[(c)+1] & (p))
-
-/*
-** 'lalpha' (Lua alphabetic) and 'lalnum' (Lua alphanumeric) both include '_'
-*/
-#define lislalpha(c)	testprop(c, MASK(ALPHABIT))
-#define lislalnum(c)	testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT)))
-#define lisdigit(c)	testprop(c, MASK(DIGITBIT))
-#define lisspace(c)	testprop(c, MASK(SPACEBIT))
-#define lisprint(c)	testprop(c, MASK(PRINTBIT))
-#define lisxdigit(c)	testprop(c, MASK(XDIGITBIT))
-
-
-/*
-** In ASCII, this 'ltolower' is correct for alphabetic characters and
-** for '.'. That is enough for Lua needs. ('check_exp' ensures that
-** the character either is an upper-case letter or is unchanged by
-** the transformation, which holds for lower-case letters and '.'.)
-*/
-#define ltolower(c)  \
-  check_exp(('A' <= (c) && (c) <= 'Z') || (c) == ((c) | ('A' ^ 'a')),  \
-            (c) | ('A' ^ 'a'))
-
-
-/* one entry for each character and for -1 (EOZ) */
-LUAI_DDEC(const lu_byte luai_ctype_[UCHAR_MAX + 2];)
-
-
-#else			/* }{ */
-
-/*
-** use standard C ctypes
-*/
-
-#include <ctype.h>
-
-
-#define lislalpha(c)	(isalpha(c) || (c) == '_')
-#define lislalnum(c)	(isalnum(c) || (c) == '_')
-#define lisdigit(c)	(isdigit(c))
-#define lisspace(c)	(isspace(c))
-#define lisprint(c)	(isprint(c))
-#define lisxdigit(c)	(isxdigit(c))
-
-#define ltolower(c)	(tolower(c))
-
-#endif			/* } */
-
-#endif
-
diff --git a/third-party/lua/src/ldblib.c b/third-party/lua/src/ldblib.c
deleted file mode 100644
index 6dcbaa982..000000000
--- a/third-party/lua/src/ldblib.c
+++ /dev/null
@@ -1,483 +0,0 @@
-/*
-** $Id: ldblib.c $
-** Interface from Lua to its debug API
-** See Copyright Notice in lua.h
-*/
-
-#define ldblib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-/*
-** The hook table at registry[HOOKKEY] maps threads to their current
-** hook function.
-*/
-static const char *const HOOKKEY = "_HOOKKEY";
-
-
-/*
-** If L1 != L, L1 can be in any state, and therefore there are no
-** guarantees about its stack space; any push in L1 must be
-** checked.
-*/
-static void checkstack (lua_State *L, lua_State *L1, int n) {
-  if (l_unlikely(L != L1 && !lua_checkstack(L1, n)))
-    luaL_error(L, "stack overflow");
-}
-
-
-static int db_getregistry (lua_State *L) {
-  lua_pushvalue(L, LUA_REGISTRYINDEX);
-  return 1;
-}
-
-
-static int db_getmetatable (lua_State *L) {
-  luaL_checkany(L, 1);
-  if (!lua_getmetatable(L, 1)) {
-    lua_pushnil(L);  /* no metatable */
-  }
-  return 1;
-}
-
-
-static int db_setmetatable (lua_State *L) {
-  int t = lua_type(L, 2);
-  luaL_argexpected(L, t == LUA_TNIL || t == LUA_TTABLE, 2, "nil or table");
-  lua_settop(L, 2);
-  lua_setmetatable(L, 1);
-  return 1;  /* return 1st argument */
-}
-
-
-static int db_getuservalue (lua_State *L) {
-  int n = (int)luaL_optinteger(L, 2, 1);
-  if (lua_type(L, 1) != LUA_TUSERDATA)
-    luaL_pushfail(L);
-  else if (lua_getiuservalue(L, 1, n) != LUA_TNONE) {
-    lua_pushboolean(L, 1);
-    return 2;
-  }
-  return 1;
-}
-
-
-static int db_setuservalue (lua_State *L) {
-  int n = (int)luaL_optinteger(L, 3, 1);
-  luaL_checktype(L, 1, LUA_TUSERDATA);
-  luaL_checkany(L, 2);
-  lua_settop(L, 2);
-  if (!lua_setiuservalue(L, 1, n))
-    luaL_pushfail(L);
-  return 1;
-}
-
-
-/*
-** Auxiliary function used by several library functions: check for
-** an optional thread as function's first argument and set 'arg' with
-** 1 if this argument is present (so that functions can skip it to
-** access their other arguments)
-*/
-static lua_State *getthread (lua_State *L, int *arg) {
-  if (lua_isthread(L, 1)) {
-    *arg = 1;
-    return lua_tothread(L, 1);
-  }
-  else {
-    *arg = 0;
-    return L;  /* function will operate over current thread */
-  }
-}
-
-
-/*
-** Variations of 'lua_settable', used by 'db_getinfo' to put results
-** from 'lua_getinfo' into result table. Key is always a string;
-** value can be a string, an int, or a boolean.
-*/
-static void settabss (lua_State *L, const char *k, const char *v) {
-  lua_pushstring(L, v);
-  lua_setfield(L, -2, k);
-}
-
-static void settabsi (lua_State *L, const char *k, int v) {
-  lua_pushinteger(L, v);
-  lua_setfield(L, -2, k);
-}
-
-static void settabsb (lua_State *L, const char *k, int v) {
-  lua_pushboolean(L, v);
-  lua_setfield(L, -2, k);
-}
-
-
-/*
-** In function 'db_getinfo', the call to 'lua_getinfo' may push
-** results on the stack; later it creates the result table to put
-** these objects. Function 'treatstackoption' puts the result from
-** 'lua_getinfo' on top of the result table so that it can call
-** 'lua_setfield'.
-*/
-static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {
-  if (L == L1)
-    lua_rotate(L, -2, 1);  /* exchange object and table */
-  else
-    lua_xmove(L1, L, 1);  /* move object to the "main" stack */
-  lua_setfield(L, -2, fname);  /* put object into table */
-}
-
-
-/*
-** Calls 'lua_getinfo' and collects all results in a new table.
-** L1 needs stack space for an optional input (function) plus
-** two optional outputs (function and line table) from function
-** 'lua_getinfo'.
-*/
-static int db_getinfo (lua_State *L) {
-  lua_Debug ar;
-  int arg;
-  lua_State *L1 = getthread(L, &arg);
-  const char *options = luaL_optstring(L, arg+2, "flnSrtu");
-  checkstack(L, L1, 3);
-  luaL_argcheck(L, options[0] != '>', arg + 2, "invalid option '>'");
-  if (lua_isfunction(L, arg + 1)) {  /* info about a function? */
-    options = lua_pushfstring(L, ">%s", options);  /* add '>' to 'options' */
-    lua_pushvalue(L, arg + 1);  /* move function to 'L1' stack */
-    lua_xmove(L, L1, 1);
-  }
-  else {  /* stack level */
-    if (!lua_getstack(L1, (int)luaL_checkinteger(L, arg + 1), &ar)) {
-      luaL_pushfail(L);  /* level out of range */
-      return 1;
-    }
-  }
-  if (!lua_getinfo(L1, options, &ar))
-    return luaL_argerror(L, arg+2, "invalid option");
-  lua_newtable(L);  /* table to collect results */
-  if (strchr(options, 'S')) {
-    lua_pushlstring(L, ar.source, ar.srclen);
-    lua_setfield(L, -2, "source");
-    settabss(L, "short_src", ar.short_src);
-    settabsi(L, "linedefined", ar.linedefined);
-    settabsi(L, "lastlinedefined", ar.lastlinedefined);
-    settabss(L, "what", ar.what);
-  }
-  if (strchr(options, 'l'))
-    settabsi(L, "currentline", ar.currentline);
-  if (strchr(options, 'u')) {
-    settabsi(L, "nups", ar.nups);
-    settabsi(L, "nparams", ar.nparams);
-    settabsb(L, "isvararg", ar.isvararg);
-  }
-  if (strchr(options, 'n')) {
-    settabss(L, "name", ar.name);
-    settabss(L, "namewhat", ar.namewhat);
-  }
-  if (strchr(options, 'r')) {
-    settabsi(L, "ftransfer", ar.ftransfer);
-    settabsi(L, "ntransfer", ar.ntransfer);
-  }
-  if (strchr(options, 't'))
-    settabsb(L, "istailcall", ar.istailcall);
-  if (strchr(options, 'L'))
-    treatstackoption(L, L1, "activelines");
-  if (strchr(options, 'f'))
-    treatstackoption(L, L1, "func");
-  return 1;  /* return table */
-}
-
-
-static int db_getlocal (lua_State *L) {
-  int arg;
-  lua_State *L1 = getthread(L, &arg);
-  int nvar = (int)luaL_checkinteger(L, arg + 2);  /* local-variable index */
-  if (lua_isfunction(L, arg + 1)) {  /* function argument? */
-    lua_pushvalue(L, arg + 1);  /* push function */
-    lua_pushstring(L, lua_getlocal(L, NULL, nvar));  /* push local name */
-    return 1;  /* return only name (there is no value) */
-  }
-  else {  /* stack-level argument */
-    lua_Debug ar;
-    const char *name;
-    int level = (int)luaL_checkinteger(L, arg + 1);
-    if (l_unlikely(!lua_getstack(L1, level, &ar)))  /* out of range? */
-      return luaL_argerror(L, arg+1, "level out of range");
-    checkstack(L, L1, 1);
-    name = lua_getlocal(L1, &ar, nvar);
-    if (name) {
-      lua_xmove(L1, L, 1);  /* move local value */
-      lua_pushstring(L, name);  /* push name */
-      lua_rotate(L, -2, 1);  /* re-order */
-      return 2;
-    }
-    else {
-      luaL_pushfail(L);  /* no name (nor value) */
-      return 1;
-    }
-  }
-}
-
-
-static int db_setlocal (lua_State *L) {
-  int arg;
-  const char *name;
-  lua_State *L1 = getthread(L, &arg);
-  lua_Debug ar;
-  int level = (int)luaL_checkinteger(L, arg + 1);
-  int nvar = (int)luaL_checkinteger(L, arg + 2);
-  if (l_unlikely(!lua_getstack(L1, level, &ar)))  /* out of range? */
-    return luaL_argerror(L, arg+1, "level out of range");
-  luaL_checkany(L, arg+3);
-  lua_settop(L, arg+3);
-  checkstack(L, L1, 1);
-  lua_xmove(L, L1, 1);
-  name = lua_setlocal(L1, &ar, nvar);
-  if (name == NULL)
-    lua_pop(L1, 1);  /* pop value (if not popped by 'lua_setlocal') */
-  lua_pushstring(L, name);
-  return 1;
-}
-
-
-/*
-** get (if 'get' is true) or set an upvalue from a closure
-*/
-static int auxupvalue (lua_State *L, int get) {
-  const char *name;
-  int n = (int)luaL_checkinteger(L, 2);  /* upvalue index */
-  luaL_checktype(L, 1, LUA_TFUNCTION);  /* closure */
-  name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
-  if (name == NULL) return 0;
-  lua_pushstring(L, name);
-  lua_insert(L, -(get+1));  /* no-op if get is false */
-  return get + 1;
-}
-
-
-static int db_getupvalue (lua_State *L) {
-  return auxupvalue(L, 1);
-}
-
-
-static int db_setupvalue (lua_State *L) {
-  luaL_checkany(L, 3);
-  return auxupvalue(L, 0);
-}
-
-
-/*
-** Check whether a given upvalue from a given closure exists and
-** returns its index
-*/
-static void *checkupval (lua_State *L, int argf, int argnup, int *pnup) {
-  void *id;
-  int nup = (int)luaL_checkinteger(L, argnup);  /* upvalue index */
-  luaL_checktype(L, argf, LUA_TFUNCTION);  /* closure */
-  id = lua_upvalueid(L, argf, nup);
-  if (pnup) {
-    luaL_argcheck(L, id != NULL, argnup, "invalid upvalue index");
-    *pnup = nup;
-  }
-  return id;
-}
-
-
-static int db_upvalueid (lua_State *L) {
-  void *id = checkupval(L, 1, 2, NULL);
-  if (id != NULL)
-    lua_pushlightuserdata(L, id);
-  else
-    luaL_pushfail(L);
-  return 1;
-}
-
-
-static int db_upvaluejoin (lua_State *L) {
-  int n1, n2;
-  checkupval(L, 1, 2, &n1);
-  checkupval(L, 3, 4, &n2);
-  luaL_argcheck(L, !lua_iscfunction(L, 1), 1, "Lua function expected");
-  luaL_argcheck(L, !lua_iscfunction(L, 3), 3, "Lua function expected");
-  lua_upvaluejoin(L, 1, n1, 3, n2);
-  return 0;
-}
-
-
-/*
-** Call hook function registered at hook table for the current
-** thread (if there is one)
-*/
-static void hookf (lua_State *L, lua_Debug *ar) {
-  static const char *const hooknames[] =
-    {"call", "return", "line", "count", "tail call"};
-  lua_getfield(L, LUA_REGISTRYINDEX, HOOKKEY);
-  lua_pushthread(L);
-  if (lua_rawget(L, -2) == LUA_TFUNCTION) {  /* is there a hook function? */
-    lua_pushstring(L, hooknames[(int)ar->event]);  /* push event name */
-    if (ar->currentline >= 0)
-      lua_pushinteger(L, ar->currentline);  /* push current line */
-    else lua_pushnil(L);
-    lua_assert(lua_getinfo(L, "lS", ar));
-    lua_call(L, 2, 0);  /* call hook function */
-  }
-}
-
-
-/*
-** Convert a string mask (for 'sethook') into a bit mask
-*/
-static int makemask (const char *smask, int count) {
-  int mask = 0;
-  if (strchr(smask, 'c')) mask |= LUA_MASKCALL;
-  if (strchr(smask, 'r')) mask |= LUA_MASKRET;
-  if (strchr(smask, 'l')) mask |= LUA_MASKLINE;
-  if (count > 0) mask |= LUA_MASKCOUNT;
-  return mask;
-}
-
-
-/*
-** Convert a bit mask (for 'gethook') into a string mask
-*/
-static char *unmakemask (int mask, char *smask) {
-  int i = 0;
-  if (mask & LUA_MASKCALL) smask[i++] = 'c';
-  if (mask & LUA_MASKRET) smask[i++] = 'r';
-  if (mask & LUA_MASKLINE) smask[i++] = 'l';
-  smask[i] = '\0';
-  return smask;
-}
-
-
-static int db_sethook (lua_State *L) {
-  int arg, mask, count;
-  lua_Hook func;
-  lua_State *L1 = getthread(L, &arg);
-  if (lua_isnoneornil(L, arg+1)) {  /* no hook? */
-    lua_settop(L, arg+1);
-    func = NULL; mask = 0; count = 0;  /* turn off hooks */
-  }
-  else {
-    const char *smask = luaL_checkstring(L, arg+2);
-    luaL_checktype(L, arg+1, LUA_TFUNCTION);
-    count = (int)luaL_optinteger(L, arg + 3, 0);
-    func = hookf; mask = makemask(smask, count);
-  }
-  if (!luaL_getsubtable(L, LUA_REGISTRYINDEX, HOOKKEY)) {
-    /* table just created; initialize it */
-    lua_pushliteral(L, "k");
-    lua_setfield(L, -2, "__mode");  /** hooktable.__mode = "k" */
-    lua_pushvalue(L, -1);
-    lua_setmetatable(L, -2);  /* metatable(hooktable) = hooktable */
-  }
-  checkstack(L, L1, 1);
-  lua_pushthread(L1); lua_xmove(L1, L, 1);  /* key (thread) */
-  lua_pushvalue(L, arg + 1);  /* value (hook function) */
-  lua_rawset(L, -3);  /* hooktable[L1] = new Lua hook */
-  lua_sethook(L1, func, mask, count);
-  return 0;
-}
-
-
-static int db_gethook (lua_State *L) {
-  int arg;
-  lua_State *L1 = getthread(L, &arg);
-  char buff[5];
-  int mask = lua_gethookmask(L1);
-  lua_Hook hook = lua_gethook(L1);
-  if (hook == NULL) {  /* no hook? */
-    luaL_pushfail(L);
-    return 1;
-  }
-  else if (hook != hookf)  /* external hook? */
-    lua_pushliteral(L, "external hook");
-  else {  /* hook table must exist */
-    lua_getfield(L, LUA_REGISTRYINDEX, HOOKKEY);
-    checkstack(L, L1, 1);
-    lua_pushthread(L1); lua_xmove(L1, L, 1);
-    lua_rawget(L, -2);   /* 1st result = hooktable[L1] */
-    lua_remove(L, -2);  /* remove hook table */
-  }
-  lua_pushstring(L, unmakemask(mask, buff));  /* 2nd result = mask */
-  lua_pushinteger(L, lua_gethookcount(L1));  /* 3rd result = count */
-  return 3;
-}
-
-
-static int db_debug (lua_State *L) {
-  for (;;) {
-    char buffer[250];
-    lua_writestringerror("%s", "lua_debug> ");
-    if (fgets(buffer, sizeof(buffer), stdin) == NULL ||
-        strcmp(buffer, "cont\n") == 0)
-      return 0;
-    if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
-        lua_pcall(L, 0, 0, 0))
-      lua_writestringerror("%s\n", luaL_tolstring(L, -1, NULL));
-    lua_settop(L, 0);  /* remove eventual returns */
-  }
-}
-
-
-static int db_traceback (lua_State *L) {
-  int arg;
-  lua_State *L1 = getthread(L, &arg);
-  const char *msg = lua_tostring(L, arg + 1);
-  if (msg == NULL && !lua_isnoneornil(L, arg + 1))  /* non-string 'msg'? */
-    lua_pushvalue(L, arg + 1);  /* return it untouched */
-  else {
-    int level = (int)luaL_optinteger(L, arg + 2, (L == L1) ? 1 : 0);
-    luaL_traceback(L, L1, msg, level);
-  }
-  return 1;
-}
-
-
-static int db_setcstacklimit (lua_State *L) {
-  int limit = (int)luaL_checkinteger(L, 1);
-  int res = lua_setcstacklimit(L, limit);
-  lua_pushinteger(L, res);
-  return 1;
-}
-
-
-static const luaL_Reg dblib[] = {
-  {"debug", db_debug},
-  {"getuservalue", db_getuservalue},
-  {"gethook", db_gethook},
-  {"getinfo", db_getinfo},
-  {"getlocal", db_getlocal},
-  {"getregistry", db_getregistry},
-  {"getmetatable", db_getmetatable},
-  {"getupvalue", db_getupvalue},
-  {"upvaluejoin", db_upvaluejoin},
-  {"upvalueid", db_upvalueid},
-  {"setuservalue", db_setuservalue},
-  {"sethook", db_sethook},
-  {"setlocal", db_setlocal},
-  {"setmetatable", db_setmetatable},
-  {"setupvalue", db_setupvalue},
-  {"traceback", db_traceback},
-  {"setcstacklimit", db_setcstacklimit},
-  {NULL, NULL}
-};
-
-
-LUAMOD_API int luaopen_debug (lua_State *L) {
-  luaL_newlib(L, dblib);
-  return 1;
-}
-
diff --git a/third-party/lua/src/ldebug.c b/third-party/lua/src/ldebug.c
deleted file mode 100644
index 28b1caabf..000000000
--- a/third-party/lua/src/ldebug.c
+++ /dev/null
@@ -1,924 +0,0 @@
-/*
-** $Id: ldebug.c $
-** Debug Interface
-** See Copyright Notice in lua.h
-*/
-
-#define ldebug_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <stdarg.h>
-#include <stddef.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lapi.h"
-#include "lcode.h"
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-#include "lvm.h"
-
-
-
-#define noLuaClosure(f)		((f) == NULL || (f)->c.tt == LUA_VCCL)
-
-
-static const char *funcnamefromcall (lua_State *L, CallInfo *ci,
-                                                   const char **name);
-
-
-static int currentpc (CallInfo *ci) {
-  lua_assert(isLua(ci));
-  return pcRel(ci->u.l.savedpc, ci_func(ci)->p);
-}
-
-
-/*
-** Get a "base line" to find the line corresponding to an instruction.
-** Base lines are regularly placed at MAXIWTHABS intervals, so usually
-** an integer division gets the right place. When the source file has
-** large sequences of empty/comment lines, it may need extra entries,
-** so the original estimate needs a correction.
-** If the original estimate is -1, the initial 'if' ensures that the
-** 'while' will run at least once.
-** The assertion that the estimate is a lower bound for the correct base
-** is valid as long as the debug info has been generated with the same
-** value for MAXIWTHABS or smaller. (Previous releases use a little
-** smaller value.)
-*/
-static int getbaseline (const Proto *f, int pc, int *basepc) {
-  if (f->sizeabslineinfo == 0 || pc < f->abslineinfo[0].pc) {
-    *basepc = -1;  /* start from the beginning */
-    return f->linedefined;
-  }
-  else {
-    int i = cast_uint(pc) / MAXIWTHABS - 1;  /* get an estimate */
-    /* estimate must be a lower bound of the correct base */
-    lua_assert(i < 0 ||
-              (i < f->sizeabslineinfo && f->abslineinfo[i].pc <= pc));
-    while (i + 1 < f->sizeabslineinfo && pc >= f->abslineinfo[i + 1].pc)
-      i++;  /* low estimate; adjust it */
-    *basepc = f->abslineinfo[i].pc;
-    return f->abslineinfo[i].line;
-  }
-}
-
-
-/*
-** Get the line corresponding to instruction 'pc' in function 'f';
-** first gets a base line and from there does the increments until
-** the desired instruction.
-*/
-int luaG_getfuncline (const Proto *f, int pc) {
-  if (f->lineinfo == NULL)  /* no debug information? */
-    return -1;
-  else {
-    int basepc;
-    int baseline = getbaseline(f, pc, &basepc);
-    while (basepc++ < pc) {  /* walk until given instruction */
-      lua_assert(f->lineinfo[basepc] != ABSLINEINFO);
-      baseline += f->lineinfo[basepc];  /* correct line */
-    }
-    return baseline;
-  }
-}
-
-
-static int getcurrentline (CallInfo *ci) {
-  return luaG_getfuncline(ci_func(ci)->p, currentpc(ci));
-}
-
-
-/*
-** Set 'trap' for all active Lua frames.
-** This function can be called during a signal, under "reasonable"
-** assumptions. A new 'ci' is completely linked in the list before it
-** becomes part of the "active" list, and we assume that pointers are
-** atomic; see comment in next function.
-** (A compiler doing interprocedural optimizations could, theoretically,
-** reorder memory writes in such a way that the list could be
-** temporarily broken while inserting a new element. We simply assume it
-** has no good reasons to do that.)
-*/
-static void settraps (CallInfo *ci) {
-  for (; ci != NULL; ci = ci->previous)
-    if (isLua(ci))
-      ci->u.l.trap = 1;
-}
-
-
-/*
-** This function can be called during a signal, under "reasonable"
-** assumptions.
-** Fields 'basehookcount' and 'hookcount' (set by 'resethookcount')
-** are for debug only, and it is no problem if they get arbitrary
-** values (causes at most one wrong hook call). 'hookmask' is an atomic
-** value. We assume that pointers are atomic too (e.g., gcc ensures that
-** for all platforms where it runs). Moreover, 'hook' is always checked
-** before being called (see 'luaD_hook').
-*/
-LUA_API void lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
-  if (func == NULL || mask == 0) {  /* turn off hooks? */
-    mask = 0;
-    func = NULL;
-  }
-  L->hook = func;
-  L->basehookcount = count;
-  resethookcount(L);
-  L->hookmask = cast_byte(mask);
-  if (mask)
-    settraps(L->ci);  /* to trace inside 'luaV_execute' */
-}
-
-
-LUA_API lua_Hook lua_gethook (lua_State *L) {
-  return L->hook;
-}
-
-
-LUA_API int lua_gethookmask (lua_State *L) {
-  return L->hookmask;
-}
-
-
-LUA_API int lua_gethookcount (lua_State *L) {
-  return L->basehookcount;
-}
-
-
-LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) {
-  int status;
-  CallInfo *ci;
-  if (level < 0) return 0;  /* invalid (negative) level */
-  lua_lock(L);
-  for (ci = L->ci; level > 0 && ci != &L->base_ci; ci = ci->previous)
-    level--;
-  if (level == 0 && ci != &L->base_ci) {  /* level found? */
-    status = 1;
-    ar->i_ci = ci;
-  }
-  else status = 0;  /* no such level */
-  lua_unlock(L);
-  return status;
-}
-
-
-static const char *upvalname (const Proto *p, int uv) {
-  TString *s = check_exp(uv < p->sizeupvalues, p->upvalues[uv].name);
-  if (s == NULL) return "?";
-  else return getstr(s);
-}
-
-
-static const char *findvararg (CallInfo *ci, int n, StkId *pos) {
-  if (clLvalue(s2v(ci->func.p))->p->is_vararg) {
-    int nextra = ci->u.l.nextraargs;
-    if (n >= -nextra) {  /* 'n' is negative */
-      *pos = ci->func.p - nextra - (n + 1);
-      return "(vararg)";  /* generic name for any vararg */
-    }
-  }
-  return NULL;  /* no such vararg */
-}
-
-
-const char *luaG_findlocal (lua_State *L, CallInfo *ci, int n, StkId *pos) {
-  StkId base = ci->func.p + 1;
-  const char *name = NULL;
-  if (isLua(ci)) {
-    if (n < 0)  /* access to vararg values? */
-      return findvararg(ci, n, pos);
-    else
-      name = luaF_getlocalname(ci_func(ci)->p, n, currentpc(ci));
-  }
-  if (name == NULL) {  /* no 'standard' name? */
-    StkId limit = (ci == L->ci) ? L->top.p : ci->next->func.p;
-    if (limit - base >= n && n > 0) {  /* is 'n' inside 'ci' stack? */
-      /* generic name for any valid slot */
-      name = isLua(ci) ? "(temporary)" : "(C temporary)";
-    }
-    else
-      return NULL;  /* no name */
-  }
-  if (pos)
-    *pos = base + (n - 1);
-  return name;
-}
-
-
-LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
-  const char *name;
-  lua_lock(L);
-  if (ar == NULL) {  /* information about non-active function? */
-    if (!isLfunction(s2v(L->top.p - 1)))  /* not a Lua function? */
-      name = NULL;
-    else  /* consider live variables at function start (parameters) */
-      name = luaF_getlocalname(clLvalue(s2v(L->top.p - 1))->p, n, 0);
-  }
-  else {  /* active function; get information through 'ar' */
-    StkId pos = NULL;  /* to avoid warnings */
-    name = luaG_findlocal(L, ar->i_ci, n, &pos);
-    if (name) {
-      setobjs2s(L, L->top.p, pos);
-      api_incr_top(L);
-    }
-  }
-  lua_unlock(L);
-  return name;
-}
-
-
-LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
-  StkId pos = NULL;  /* to avoid warnings */
-  const char *name;
-  lua_lock(L);
-  name = luaG_findlocal(L, ar->i_ci, n, &pos);
-  if (name) {
-    setobjs2s(L, pos, L->top.p - 1);
-    L->top.p--;  /* pop value */
-  }
-  lua_unlock(L);
-  return name;
-}
-
-
-static void funcinfo (lua_Debug *ar, Closure *cl) {
-  if (noLuaClosure(cl)) {
-    ar->source = "=[C]";
-    ar->srclen = LL("=[C]");
-    ar->linedefined = -1;
-    ar->lastlinedefined = -1;
-    ar->what = "C";
-  }
-  else {
-    const Proto *p = cl->l.p;
-    if (p->source) {
-      ar->source = getstr(p->source);
-      ar->srclen = tsslen(p->source);
-    }
-    else {
-      ar->source = "=?";
-      ar->srclen = LL("=?");
-    }
-    ar->linedefined = p->linedefined;
-    ar->lastlinedefined = p->lastlinedefined;
-    ar->what = (ar->linedefined == 0) ? "main" : "Lua";
-  }
-  luaO_chunkid(ar->short_src, ar->source, ar->srclen);
-}
-
-
-static int nextline (const Proto *p, int currentline, int pc) {
-  if (p->lineinfo[pc] != ABSLINEINFO)
-    return currentline + p->lineinfo[pc];
-  else
-    return luaG_getfuncline(p, pc);
-}
-
-
-static void collectvalidlines (lua_State *L, Closure *f) {
-  if (noLuaClosure(f)) {
-    setnilvalue(s2v(L->top.p));
-    api_incr_top(L);
-  }
-  else {
-    int i;
-    TValue v;
-    const Proto *p = f->l.p;
-    int currentline = p->linedefined;
-    Table *t = luaH_new(L);  /* new table to store active lines */
-    sethvalue2s(L, L->top.p, t);  /* push it on stack */
-    api_incr_top(L);
-    setbtvalue(&v);  /* boolean 'true' to be the value of all indices */
-    if (!p->is_vararg)  /* regular function? */
-      i = 0;  /* consider all instructions */
-    else {  /* vararg function */
-      lua_assert(GET_OPCODE(p->code[0]) == OP_VARARGPREP);
-      currentline = nextline(p, currentline, 0);
-      i = 1;  /* skip first instruction (OP_VARARGPREP) */
-    }
-    for (; i < p->sizelineinfo; i++) {  /* for each instruction */
-      currentline = nextline(p, currentline, i);  /* get its line */
-      luaH_setint(L, t, currentline, &v);  /* table[line] = true */
-    }
-  }
-}
-
-
-static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
-  /* calling function is a known function? */
-  if (ci != NULL && !(ci->callstatus & CIST_TAIL))
-    return funcnamefromcall(L, ci->previous, name);
-  else return NULL;  /* no way to find a name */
-}
-
-
-static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar,
-                       Closure *f, CallInfo *ci) {
-  int status = 1;
-  for (; *what; what++) {
-    switch (*what) {
-      case 'S': {
-        funcinfo(ar, f);
-        break;
-      }
-      case 'l': {
-        ar->currentline = (ci && isLua(ci)) ? getcurrentline(ci) : -1;
-        break;
-      }
-      case 'u': {
-        ar->nups = (f == NULL) ? 0 : f->c.nupvalues;
-        if (noLuaClosure(f)) {
-          ar->isvararg = 1;
-          ar->nparams = 0;
-        }
-        else {
-          ar->isvararg = f->l.p->is_vararg;
-          ar->nparams = f->l.p->numparams;
-        }
-        break;
-      }
-      case 't': {
-        ar->istailcall = (ci) ? ci->callstatus & CIST_TAIL : 0;
-        break;
-      }
-      case 'n': {
-        ar->namewhat = getfuncname(L, ci, &ar->name);
-        if (ar->namewhat == NULL) {
-          ar->namewhat = "";  /* not found */
-          ar->name = NULL;
-        }
-        break;
-      }
-      case 'r': {
-        if (ci == NULL || !(ci->callstatus & CIST_TRAN))
-          ar->ftransfer = ar->ntransfer = 0;
-        else {
-          ar->ftransfer = ci->u2.transferinfo.ftransfer;
-          ar->ntransfer = ci->u2.transferinfo.ntransfer;
-        }
-        break;
-      }
-      case 'L':
-      case 'f':  /* handled by lua_getinfo */
-        break;
-      default: status = 0;  /* invalid option */
-    }
-  }
-  return status;
-}
-
-
-LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
-  int status;
-  Closure *cl;
-  CallInfo *ci;
-  TValue *func;
-  lua_lock(L);
-  if (*what == '>') {
-    ci = NULL;
-    func = s2v(L->top.p - 1);
-    api_check(L, ttisfunction(func), "function expected");
-    what++;  /* skip the '>' */
-    L->top.p--;  /* pop function */
-  }
-  else {
-    ci = ar->i_ci;
-    func = s2v(ci->func.p);
-    lua_assert(ttisfunction(func));
-  }
-  cl = ttisclosure(func) ? clvalue(func) : NULL;
-  status = auxgetinfo(L, what, ar, cl, ci);
-  if (strchr(what, 'f')) {
-    setobj2s(L, L->top.p, func);
-    api_incr_top(L);
-  }
-  if (strchr(what, 'L'))
-    collectvalidlines(L, cl);
-  lua_unlock(L);
-  return status;
-}
-
-
-/*
-** {======================================================
-** Symbolic Execution
-** =======================================================
-*/
-
-static const char *getobjname (const Proto *p, int lastpc, int reg,
-                               const char **name);
-
-
-/*
-** Find a "name" for the constant 'c'.
-*/
-static void kname (const Proto *p, int c, const char **name) {
-  TValue *kvalue = &p->k[c];
-  *name = (ttisstring(kvalue)) ? svalue(kvalue) : "?";
-}
-
-
-/*
-** Find a "name" for the register 'c'.
-*/
-static void rname (const Proto *p, int pc, int c, const char **name) {
-  const char *what = getobjname(p, pc, c, name); /* search for 'c' */
-  if (!(what && *what == 'c'))  /* did not find a constant name? */
-    *name = "?";
-}
-
-
-/*
-** Find a "name" for a 'C' value in an RK instruction.
-*/
-static void rkname (const Proto *p, int pc, Instruction i, const char **name) {
-  int c = GETARG_C(i);  /* key index */
-  if (GETARG_k(i))  /* is 'c' a constant? */
-    kname(p, c, name);
-  else  /* 'c' is a register */
-    rname(p, pc, c, name);
-}
-
-
-static int filterpc (int pc, int jmptarget) {
-  if (pc < jmptarget)  /* is code conditional (inside a jump)? */
-    return -1;  /* cannot know who sets that register */
-  else return pc;  /* current position sets that register */
-}
-
-
-/*
-** Try to find last instruction before 'lastpc' that modified register 'reg'.
-*/
-static int findsetreg (const Proto *p, int lastpc, int reg) {
-  int pc;
-  int setreg = -1;  /* keep last instruction that changed 'reg' */
-  int jmptarget = 0;  /* any code before this address is conditional */
-  if (testMMMode(GET_OPCODE(p->code[lastpc])))
-    lastpc--;  /* previous instruction was not actually executed */
-  for (pc = 0; pc < lastpc; pc++) {
-    Instruction i = p->code[pc];
-    OpCode op = GET_OPCODE(i);
-    int a = GETARG_A(i);
-    int change;  /* true if current instruction changed 'reg' */
-    switch (op) {
-      case OP_LOADNIL: {  /* set registers from 'a' to 'a+b' */
-        int b = GETARG_B(i);
-        change = (a <= reg && reg <= a + b);
-        break;
-      }
-      case OP_TFORCALL: {  /* affect all regs above its base */
-        change = (reg >= a + 2);
-        break;
-      }
-      case OP_CALL:
-      case OP_TAILCALL: {  /* affect all registers above base */
-        change = (reg >= a);
-        break;
-      }
-      case OP_JMP: {  /* doesn't change registers, but changes 'jmptarget' */
-        int b = GETARG_sJ(i);
-        int dest = pc + 1 + b;
-        /* jump does not skip 'lastpc' and is larger than current one? */
-        if (dest <= lastpc && dest > jmptarget)
-          jmptarget = dest;  /* update 'jmptarget' */
-        change = 0;
-        break;
-      }
-      default:  /* any instruction that sets A */
-        change = (testAMode(op) && reg == a);
-        break;
-    }
-    if (change)
-      setreg = filterpc(pc, jmptarget);
-  }
-  return setreg;
-}
-
-
-/*
-** Check whether table being indexed by instruction 'i' is the
-** environment '_ENV'
-*/
-static const char *gxf (const Proto *p, int pc, Instruction i, int isup) {
-  int t = GETARG_B(i);  /* table index */
-  const char *name;  /* name of indexed variable */
-  if (isup)  /* is an upvalue? */
-    name = upvalname(p, t);
-  else
-    getobjname(p, pc, t, &name);
-  return (name && strcmp(name, LUA_ENV) == 0) ? "global" : "field";
-}
-
-
-static const char *getobjname (const Proto *p, int lastpc, int reg,
-                               const char **name) {
-  int pc;
-  *name = luaF_getlocalname(p, reg + 1, lastpc);
-  if (*name)  /* is a local? */
-    return "local";
-  /* else try symbolic execution */
-  pc = findsetreg(p, lastpc, reg);
-  if (pc != -1) {  /* could find instruction? */
-    Instruction i = p->code[pc];
-    OpCode op = GET_OPCODE(i);
-    switch (op) {
-      case OP_MOVE: {
-        int b = GETARG_B(i);  /* move from 'b' to 'a' */
-        if (b < GETARG_A(i))
-          return getobjname(p, pc, b, name);  /* get name for 'b' */
-        break;
-      }
-      case OP_GETTABUP: {
-        int k = GETARG_C(i);  /* key index */
-        kname(p, k, name);
-        return gxf(p, pc, i, 1);
-      }
-      case OP_GETTABLE: {
-        int k = GETARG_C(i);  /* key index */
-        rname(p, pc, k, name);
-        return gxf(p, pc, i, 0);
-      }
-      case OP_GETI: {
-        *name = "integer index";
-        return "field";
-      }
-      case OP_GETFIELD: {
-        int k = GETARG_C(i);  /* key index */
-        kname(p, k, name);
-        return gxf(p, pc, i, 0);
-      }
-      case OP_GETUPVAL: {
-        *name = upvalname(p, GETARG_B(i));
-        return "upvalue";
-      }
-      case OP_LOADK:
-      case OP_LOADKX: {
-        int b = (op == OP_LOADK) ? GETARG_Bx(i)
-                                 : GETARG_Ax(p->code[pc + 1]);
-        if (ttisstring(&p->k[b])) {
-          *name = svalue(&p->k[b]);
-          return "constant";
-        }
-        break;
-      }
-      case OP_SELF: {
-        rkname(p, pc, i, name);
-        return "method";
-      }
-      default: break;  /* go through to return NULL */
-    }
-  }
-  return NULL;  /* could not find reasonable name */
-}
-
-
-/*
-** Try to find a name for a function based on the code that called it.
-** (Only works when function was called by a Lua function.)
-** Returns what the name is (e.g., "for iterator", "method",
-** "metamethod") and sets '*name' to point to the name.
-*/
-static const char *funcnamefromcode (lua_State *L, const Proto *p,
-                                     int pc, const char **name) {
-  TMS tm = (TMS)0;  /* (initial value avoids warnings) */
-  Instruction i = p->code[pc];  /* calling instruction */
-  switch (GET_OPCODE(i)) {
-    case OP_CALL:
-    case OP_TAILCALL:
-      return getobjname(p, pc, GETARG_A(i), name);  /* get function name */
-    case OP_TFORCALL: {  /* for iterator */
-      *name = "for iterator";
-       return "for iterator";
-    }
-    /* other instructions can do calls through metamethods */
-    case OP_SELF: case OP_GETTABUP: case OP_GETTABLE:
-    case OP_GETI: case OP_GETFIELD:
-      tm = TM_INDEX;
-      break;
-    case OP_SETTABUP: case OP_SETTABLE: case OP_SETI: case OP_SETFIELD:
-      tm = TM_NEWINDEX;
-      break;
-    case OP_MMBIN: case OP_MMBINI: case OP_MMBINK: {
-      tm = cast(TMS, GETARG_C(i));
-      break;
-    }
-    case OP_UNM: tm = TM_UNM; break;
-    case OP_BNOT: tm = TM_BNOT; break;
-    case OP_LEN: tm = TM_LEN; break;
-    case OP_CONCAT: tm = TM_CONCAT; break;
-    case OP_EQ: tm = TM_EQ; break;
-    /* no cases for OP_EQI and OP_EQK, as they don't call metamethods */
-    case OP_LT: case OP_LTI: case OP_GTI: tm = TM_LT; break;
-    case OP_LE: case OP_LEI: case OP_GEI: tm = TM_LE; break;
-    case OP_CLOSE: case OP_RETURN: tm = TM_CLOSE; break;
-    default:
-      return NULL;  /* cannot find a reasonable name */
-  }
-  *name = getstr(G(L)->tmname[tm]) + 2;
-  return "metamethod";
-}
-
-
-/*
-** Try to find a name for a function based on how it was called.
-*/
-static const char *funcnamefromcall (lua_State *L, CallInfo *ci,
-                                                   const char **name) {
-  if (ci->callstatus & CIST_HOOKED) {  /* was it called inside a hook? */
-    *name = "?";
-    return "hook";
-  }
-  else if (ci->callstatus & CIST_FIN) {  /* was it called as a finalizer? */
-    *name = "__gc";
-    return "metamethod";  /* report it as such */
-  }
-  else if (isLua(ci))
-    return funcnamefromcode(L, ci_func(ci)->p, currentpc(ci), name);
-  else
-    return NULL;
-}
-
-/* }====================================================== */
-
-
-
-/*
-** Check whether pointer 'o' points to some value in the stack frame of
-** the current function and, if so, returns its index.  Because 'o' may
-** not point to a value in this stack, we cannot compare it with the
-** region boundaries (undefined behavior in ISO C).
-*/
-static int instack (CallInfo *ci, const TValue *o) {
-  int pos;
-  StkId base = ci->func.p + 1;
-  for (pos = 0; base + pos < ci->top.p; pos++) {
-    if (o == s2v(base + pos))
-      return pos;
-  }
-  return -1;  /* not found */
-}
-
-
-/*
-** Checks whether value 'o' came from an upvalue. (That can only happen
-** with instructions OP_GETTABUP/OP_SETTABUP, which operate directly on
-** upvalues.)
-*/
-static const char *getupvalname (CallInfo *ci, const TValue *o,
-                                 const char **name) {
-  LClosure *c = ci_func(ci);
-  int i;
-  for (i = 0; i < c->nupvalues; i++) {
-    if (c->upvals[i]->v.p == o) {
-      *name = upvalname(c->p, i);
-      return "upvalue";
-    }
-  }
-  return NULL;
-}
-
-
-static const char *formatvarinfo (lua_State *L, const char *kind,
-                                                const char *name) {
-  if (kind == NULL)
-    return "";  /* no information */
-  else
-    return luaO_pushfstring(L, " (%s '%s')", kind, name);
-}
-
-/*
-** Build a string with a "description" for the value 'o', such as
-** "variable 'x'" or "upvalue 'y'".
-*/
-static const char *varinfo (lua_State *L, const TValue *o) {
-  CallInfo *ci = L->ci;
-  const char *name = NULL;  /* to avoid warnings */
-  const char *kind = NULL;
-  if (isLua(ci)) {
-    kind = getupvalname(ci, o, &name);  /* check whether 'o' is an upvalue */
-    if (!kind) {  /* not an upvalue? */
-      int reg = instack(ci, o);  /* try a register */
-      if (reg >= 0)  /* is 'o' a register? */
-        kind = getobjname(ci_func(ci)->p, currentpc(ci), reg, &name);
-    }
-  }
-  return formatvarinfo(L, kind, name);
-}
-
-
-/*
-** Raise a type error
-*/
-static l_noret typeerror (lua_State *L, const TValue *o, const char *op,
-                          const char *extra) {
-  const char *t = luaT_objtypename(L, o);
-  luaG_runerror(L, "attempt to %s a %s value%s", op, t, extra);
-}
-
-
-/*
-** Raise a type error with "standard" information about the faulty
-** object 'o' (using 'varinfo').
-*/
-l_noret luaG_typeerror (lua_State *L, const TValue *o, const char *op) {
-  typeerror(L, o, op, varinfo(L, o));
-}
-
-
-/*
-** Raise an error for calling a non-callable object. Try to find a name
-** for the object based on how it was called ('funcnamefromcall'); if it
-** cannot get a name there, try 'varinfo'.
-*/
-l_noret luaG_callerror (lua_State *L, const TValue *o) {
-  CallInfo *ci = L->ci;
-  const char *name = NULL;  /* to avoid warnings */
-  const char *kind = funcnamefromcall(L, ci, &name);
-  const char *extra = kind ? formatvarinfo(L, kind, name) : varinfo(L, o);
-  typeerror(L, o, "call", extra);
-}
-
-
-l_noret luaG_forerror (lua_State *L, const TValue *o, const char *what) {
-  luaG_runerror(L, "bad 'for' %s (number expected, got %s)",
-                   what, luaT_objtypename(L, o));
-}
-
-
-l_noret luaG_concaterror (lua_State *L, const TValue *p1, const TValue *p2) {
-  if (ttisstring(p1) || cvt2str(p1)) p1 = p2;
-  luaG_typeerror(L, p1, "concatenate");
-}
-
-
-l_noret luaG_opinterror (lua_State *L, const TValue *p1,
-                         const TValue *p2, const char *msg) {
-  if (!ttisnumber(p1))  /* first operand is wrong? */
-    p2 = p1;  /* now second is wrong */
-  luaG_typeerror(L, p2, msg);
-}
-
-
-/*
-** Error when both values are convertible to numbers, but not to integers
-*/
-l_noret luaG_tointerror (lua_State *L, const TValue *p1, const TValue *p2) {
-  lua_Integer temp;
-  if (!luaV_tointegerns(p1, &temp, LUA_FLOORN2I))
-    p2 = p1;
-  luaG_runerror(L, "number%s has no integer representation", varinfo(L, p2));
-}
-
-
-l_noret luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {
-  const char *t1 = luaT_objtypename(L, p1);
-  const char *t2 = luaT_objtypename(L, p2);
-  if (strcmp(t1, t2) == 0)
-    luaG_runerror(L, "attempt to compare two %s values", t1);
-  else
-    luaG_runerror(L, "attempt to compare %s with %s", t1, t2);
-}
-
-
-/* add src:line information to 'msg' */
-const char *luaG_addinfo (lua_State *L, const char *msg, TString *src,
-                                        int line) {
-  char buff[LUA_IDSIZE];
-  if (src)
-    luaO_chunkid(buff, getstr(src), tsslen(src));
-  else {  /* no source available; use "?" instead */
-    buff[0] = '?'; buff[1] = '\0';
-  }
-  return luaO_pushfstring(L, "%s:%d: %s", buff, line, msg);
-}
-
-
-l_noret luaG_errormsg (lua_State *L) {
-  if (L->errfunc != 0) {  /* is there an error handling function? */
-    StkId errfunc = restorestack(L, L->errfunc);
-    lua_assert(ttisfunction(s2v(errfunc)));
-    setobjs2s(L, L->top.p, L->top.p - 1);  /* move argument */
-    setobjs2s(L, L->top.p - 1, errfunc);  /* push function */
-    L->top.p++;  /* assume EXTRA_STACK */
-    luaD_callnoyield(L, L->top.p - 2, 1);  /* call it */
-  }
-  luaD_throw(L, LUA_ERRRUN);
-}
-
-
-l_noret luaG_runerror (lua_State *L, const char *fmt, ...) {
-  CallInfo *ci = L->ci;
-  const char *msg;
-  va_list argp;
-  luaC_checkGC(L);  /* error message uses memory */
-  va_start(argp, fmt);
-  msg = luaO_pushvfstring(L, fmt, argp);  /* format message */
-  va_end(argp);
-  if (isLua(ci)) {  /* if Lua function, add source:line information */
-    luaG_addinfo(L, msg, ci_func(ci)->p->source, getcurrentline(ci));
-    setobjs2s(L, L->top.p - 2, L->top.p - 1);  /* remove 'msg' */
-    L->top.p--;
-  }
-  luaG_errormsg(L);
-}
-
-
-/*
-** Check whether new instruction 'newpc' is in a different line from
-** previous instruction 'oldpc'. More often than not, 'newpc' is only
-** one or a few instructions after 'oldpc' (it must be after, see
-** caller), so try to avoid calling 'luaG_getfuncline'. If they are
-** too far apart, there is a good chance of a ABSLINEINFO in the way,
-** so it goes directly to 'luaG_getfuncline'.
-*/
-static int changedline (const Proto *p, int oldpc, int newpc) {
-  if (p->lineinfo == NULL)  /* no debug information? */
-    return 0;
-  if (newpc - oldpc < MAXIWTHABS / 2) {  /* not too far apart? */
-    int delta = 0;  /* line difference */
-    int pc = oldpc;
-    for (;;) {
-      int lineinfo = p->lineinfo[++pc];
-      if (lineinfo == ABSLINEINFO)
-        break;  /* cannot compute delta; fall through */
-      delta += lineinfo;
-      if (pc == newpc)
-        return (delta != 0);  /* delta computed successfully */
-    }
-  }
-  /* either instructions are too far apart or there is an absolute line
-     info in the way; compute line difference explicitly */
-  return (luaG_getfuncline(p, oldpc) != luaG_getfuncline(p, newpc));
-}
-
-
-/*
-** Traces the execution of a Lua function. Called before the execution
-** of each opcode, when debug is on. 'L->oldpc' stores the last
-** instruction traced, to detect line changes. When entering a new
-** function, 'npci' will be zero and will test as a new line whatever
-** the value of 'oldpc'.  Some exceptional conditions may return to
-** a function without setting 'oldpc'. In that case, 'oldpc' may be
-** invalid; if so, use zero as a valid value. (A wrong but valid 'oldpc'
-** at most causes an extra call to a line hook.)
-** This function is not "Protected" when called, so it should correct
-** 'L->top.p' before calling anything that can run the GC.
-*/
-int luaG_traceexec (lua_State *L, const Instruction *pc) {
-  CallInfo *ci = L->ci;
-  lu_byte mask = L->hookmask;
-  const Proto *p = ci_func(ci)->p;
-  int counthook;
-  if (!(mask & (LUA_MASKLINE | LUA_MASKCOUNT))) {  /* no hooks? */
-    ci->u.l.trap = 0;  /* don't need to stop again */
-    return 0;  /* turn off 'trap' */
-  }
-  pc++;  /* reference is always next instruction */
-  ci->u.l.savedpc = pc;  /* save 'pc' */
-  counthook = (--L->hookcount == 0 && (mask & LUA_MASKCOUNT));
-  if (counthook)
-    resethookcount(L);  /* reset count */
-  else if (!(mask & LUA_MASKLINE))
-    return 1;  /* no line hook and count != 0; nothing to be done now */
-  if (ci->callstatus & CIST_HOOKYIELD) {  /* called hook last time? */
-    ci->callstatus &= ~CIST_HOOKYIELD;  /* erase mark */
-    return 1;  /* do not call hook again (VM yielded, so it did not move) */
-  }
-  if (!isIT(*(ci->u.l.savedpc - 1)))  /* top not being used? */
-    L->top.p = ci->top.p;  /* correct top */
-  if (counthook)
-    luaD_hook(L, LUA_HOOKCOUNT, -1, 0, 0);  /* call count hook */
-  if (mask & LUA_MASKLINE) {
-    /* 'L->oldpc' may be invalid; use zero in this case */
-    int oldpc = (L->oldpc < p->sizecode) ? L->oldpc : 0;
-    int npci = pcRel(pc, p);
-    if (npci <= oldpc ||  /* call hook when jump back (loop), */
-        changedline(p, oldpc, npci)) {  /* or when enter new line */
-      int newline = luaG_getfuncline(p, npci);
-      luaD_hook(L, LUA_HOOKLINE, newline, 0, 0);  /* call line hook */
-    }
-    L->oldpc = npci;  /* 'pc' of last call to line hook */
-  }
-  if (L->status == LUA_YIELD) {  /* did hook yield? */
-    if (counthook)
-      L->hookcount = 1;  /* undo decrement to zero */
-    ci->u.l.savedpc--;  /* undo increment (resume will increment it again) */
-    ci->callstatus |= CIST_HOOKYIELD;  /* mark that it yielded */
-    luaD_throw(L, LUA_YIELD);
-  }
-  return 1;  /* keep 'trap' on */
-}
-
diff --git a/third-party/lua/src/ldebug.h b/third-party/lua/src/ldebug.h
deleted file mode 100644
index 2c3074c61..000000000
--- a/third-party/lua/src/ldebug.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
-** $Id: ldebug.h $
-** Auxiliary functions from Debug Interface module
-** See Copyright Notice in lua.h
-*/
-
-#ifndef ldebug_h
-#define ldebug_h
-
-
-#include "lstate.h"
-
-
-#define pcRel(pc, p)	(cast_int((pc) - (p)->code) - 1)
-
-
-/* Active Lua function (given call info) */
-#define ci_func(ci)		(clLvalue(s2v((ci)->func.p)))
-
-
-#define resethookcount(L)	(L->hookcount = L->basehookcount)
-
-/*
-** mark for entries in 'lineinfo' array that has absolute information in
-** 'abslineinfo' array
-*/
-#define ABSLINEINFO	(-0x80)
-
-
-/*
-** MAXimum number of successive Instructions WiTHout ABSolute line
-** information. (A power of two allows fast divisions.)
-*/
-#if !defined(MAXIWTHABS)
-#define MAXIWTHABS	128
-#endif
-
-
-LUAI_FUNC int luaG_getfuncline (const Proto *f, int pc);
-LUAI_FUNC const char *luaG_findlocal (lua_State *L, CallInfo *ci, int n,
-                                                    StkId *pos);
-LUAI_FUNC l_noret luaG_typeerror (lua_State *L, const TValue *o,
-                                                const char *opname);
-LUAI_FUNC l_noret luaG_callerror (lua_State *L, const TValue *o);
-LUAI_FUNC l_noret luaG_forerror (lua_State *L, const TValue *o,
-                                               const char *what);
-LUAI_FUNC l_noret luaG_concaterror (lua_State *L, const TValue *p1,
-                                                  const TValue *p2);
-LUAI_FUNC l_noret luaG_opinterror (lua_State *L, const TValue *p1,
-                                                 const TValue *p2,
-                                                 const char *msg);
-LUAI_FUNC l_noret luaG_tointerror (lua_State *L, const TValue *p1,
-                                                 const TValue *p2);
-LUAI_FUNC l_noret luaG_ordererror (lua_State *L, const TValue *p1,
-                                                 const TValue *p2);
-LUAI_FUNC l_noret luaG_runerror (lua_State *L, const char *fmt, ...);
-LUAI_FUNC const char *luaG_addinfo (lua_State *L, const char *msg,
-                                                  TString *src, int line);
-LUAI_FUNC l_noret luaG_errormsg (lua_State *L);
-LUAI_FUNC int luaG_traceexec (lua_State *L, const Instruction *pc);
-
-
-#endif
diff --git a/third-party/lua/src/ldo.c b/third-party/lua/src/ldo.c
deleted file mode 100644
index 2a0017ca6..000000000
--- a/third-party/lua/src/ldo.c
+++ /dev/null
@@ -1,1024 +0,0 @@
-/*
-** $Id: ldo.c $
-** Stack and Call structure of Lua
-** See Copyright Notice in lua.h
-*/
-
-#define ldo_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <setjmp.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lapi.h"
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lgc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lparser.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-#include "lundump.h"
-#include "lvm.h"
-#include "lzio.h"
-
-
-
-#define errorstatus(s)	((s) > LUA_YIELD)
-
-
-/*
-** {======================================================
-** Error-recovery functions
-** =======================================================
-*/
-
-/*
-** LUAI_THROW/LUAI_TRY define how Lua does exception handling. By
-** default, Lua handles errors with exceptions when compiling as
-** C++ code, with _longjmp/_setjmp when asked to use them, and with
-** longjmp/setjmp otherwise.
-*/
-#if !defined(LUAI_THROW)				/* { */
-
-#if defined(__cplusplus) && !defined(LUA_USE_LONGJMP)	/* { */
-
-/* C++ exceptions */
-#define LUAI_THROW(L,c)		throw(c)
-#define LUAI_TRY(L,c,a) \
-	try { a } catch(...) { if ((c)->status == 0) (c)->status = -1; }
-#define luai_jmpbuf		int  /* dummy variable */
-
-#elif defined(LUA_USE_POSIX)				/* }{ */
-
-/* in POSIX, try _longjmp/_setjmp (more efficient) */
-#define LUAI_THROW(L,c)		_longjmp((c)->b, 1)
-#define LUAI_TRY(L,c,a)		if (_setjmp((c)->b) == 0) { a }
-#define luai_jmpbuf		jmp_buf
-
-#else							/* }{ */
-
-/* ISO C handling with long jumps */
-#define LUAI_THROW(L,c)		longjmp((c)->b, 1)
-#define LUAI_TRY(L,c,a)		if (setjmp((c)->b) == 0) { a }
-#define luai_jmpbuf		jmp_buf
-
-#endif							/* } */
-
-#endif							/* } */
-
-
-
-/* chain list of long jump buffers */
-struct lua_longjmp {
-  struct lua_longjmp *previous;
-  luai_jmpbuf b;
-  volatile int status;  /* error code */
-};
-
-
-void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop) {
-  switch (errcode) {
-    case LUA_ERRMEM: {  /* memory error? */
-      setsvalue2s(L, oldtop, G(L)->memerrmsg); /* reuse preregistered msg. */
-      break;
-    }
-    case LUA_ERRERR: {
-      setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling"));
-      break;
-    }
-    case LUA_OK: {  /* special case only for closing upvalues */
-      setnilvalue(s2v(oldtop));  /* no error message */
-      break;
-    }
-    default: {
-      lua_assert(errorstatus(errcode));  /* real error */
-      setobjs2s(L, oldtop, L->top.p - 1);  /* error message on current top */
-      break;
-    }
-  }
-  L->top.p = oldtop + 1;
-}
-
-
-l_noret luaD_throw (lua_State *L, int errcode) {
-  if (L->errorJmp) {  /* thread has an error handler? */
-    L->errorJmp->status = errcode;  /* set status */
-    LUAI_THROW(L, L->errorJmp);  /* jump to it */
-  }
-  else {  /* thread has no error handler */
-    global_State *g = G(L);
-    errcode = luaE_resetthread(L, errcode);  /* close all upvalues */
-    if (g->mainthread->errorJmp) {  /* main thread has a handler? */
-      setobjs2s(L, g->mainthread->top.p++, L->top.p - 1);  /* copy error obj. */
-      luaD_throw(g->mainthread, errcode);  /* re-throw in main thread */
-    }
-    else {  /* no handler at all; abort */
-      if (g->panic) {  /* panic function? */
-        lua_unlock(L);
-        g->panic(L);  /* call panic function (last chance to jump out) */
-      }
-      abort();
-    }
-  }
-}
-
-
-int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
-  l_uint32 oldnCcalls = L->nCcalls;
-  struct lua_longjmp lj;
-  lj.status = LUA_OK;
-  lj.previous = L->errorJmp;  /* chain new error handler */
-  L->errorJmp = &lj;
-  LUAI_TRY(L, &lj,
-    (*f)(L, ud);
-  );
-  L->errorJmp = lj.previous;  /* restore old error handler */
-  L->nCcalls = oldnCcalls;
-  return lj.status;
-}
-
-/* }====================================================== */
-
-
-/*
-** {==================================================================
-** Stack reallocation
-** ===================================================================
-*/
-
-
-/*
-** Change all pointers to the stack into offsets.
-*/
-static void relstack (lua_State *L) {
-  CallInfo *ci;
-  UpVal *up;
-  L->top.offset = savestack(L, L->top.p);
-  L->tbclist.offset = savestack(L, L->tbclist.p);
-  for (up = L->openupval; up != NULL; up = up->u.open.next)
-    up->v.offset = savestack(L, uplevel(up));
-  for (ci = L->ci; ci != NULL; ci = ci->previous) {
-    ci->top.offset = savestack(L, ci->top.p);
-    ci->func.offset = savestack(L, ci->func.p);
-  }
-}
-
-
-/*
-** Change back all offsets into pointers.
-*/
-static void correctstack (lua_State *L) {
-  CallInfo *ci;
-  UpVal *up;
-  L->top.p = restorestack(L, L->top.offset);
-  L->tbclist.p = restorestack(L, L->tbclist.offset);
-  for (up = L->openupval; up != NULL; up = up->u.open.next)
-    up->v.p = s2v(restorestack(L, up->v.offset));
-  for (ci = L->ci; ci != NULL; ci = ci->previous) {
-    ci->top.p = restorestack(L, ci->top.offset);
-    ci->func.p = restorestack(L, ci->func.offset);
-    if (isLua(ci))
-      ci->u.l.trap = 1;  /* signal to update 'trap' in 'luaV_execute' */
-  }
-}
-
-
-/* some space for error handling */
-#define ERRORSTACKSIZE	(LUAI_MAXSTACK + 200)
-
-/*
-** Reallocate the stack to a new size, correcting all pointers into it.
-** In ISO C, any pointer use after the pointer has been deallocated is
-** undefined behavior. So, before the reallocation, all pointers are
-** changed to offsets, and after the reallocation they are changed back
-** to pointers. As during the reallocation the pointers are invalid, the
-** reallocation cannot run emergency collections.
-**
-** In case of allocation error, raise an error or return false according
-** to 'raiseerror'.
-*/
-int luaD_reallocstack (lua_State *L, int newsize, int raiseerror) {
-  int oldsize = stacksize(L);
-  int i;
-  StkId newstack;
-  int oldgcstop = G(L)->gcstopem;
-  lua_assert(newsize <= LUAI_MAXSTACK || newsize == ERRORSTACKSIZE);
-  relstack(L);  /* change pointers to offsets */
-  G(L)->gcstopem = 1;  /* stop emergency collection */
-  newstack = luaM_reallocvector(L, L->stack.p, oldsize + EXTRA_STACK,
-                                   newsize + EXTRA_STACK, StackValue);
-  G(L)->gcstopem = oldgcstop;  /* restore emergency collection */
-  if (l_unlikely(newstack == NULL)) {  /* reallocation failed? */
-    correctstack(L);  /* change offsets back to pointers */
-    if (raiseerror)
-      luaM_error(L);
-    else return 0;  /* do not raise an error */
-  }
-  L->stack.p = newstack;
-  correctstack(L);  /* change offsets back to pointers */
-  L->stack_last.p = L->stack.p + newsize;
-  for (i = oldsize + EXTRA_STACK; i < newsize + EXTRA_STACK; i++)
-    setnilvalue(s2v(newstack + i)); /* erase new segment */
-  return 1;
-}
-
-
-/*
-** Try to grow the stack by at least 'n' elements. When 'raiseerror'
-** is true, raises any error; otherwise, return 0 in case of errors.
-*/
-int luaD_growstack (lua_State *L, int n, int raiseerror) {
-  int size = stacksize(L);
-  if (l_unlikely(size > LUAI_MAXSTACK)) {
-    /* if stack is larger than maximum, thread is already using the
-       extra space reserved for errors, that is, thread is handling
-       a stack error; cannot grow further than that. */
-    lua_assert(stacksize(L) == ERRORSTACKSIZE);
-    if (raiseerror)
-      luaD_throw(L, LUA_ERRERR);  /* error inside message handler */
-    return 0;  /* if not 'raiseerror', just signal it */
-  }
-  else if (n < LUAI_MAXSTACK) {  /* avoids arithmetic overflows */
-    int newsize = 2 * size;  /* tentative new size */
-    int needed = cast_int(L->top.p - L->stack.p) + n;
-    if (newsize > LUAI_MAXSTACK)  /* cannot cross the limit */
-      newsize = LUAI_MAXSTACK;
-    if (newsize < needed)  /* but must respect what was asked for */
-      newsize = needed;
-    if (l_likely(newsize <= LUAI_MAXSTACK))
-      return luaD_reallocstack(L, newsize, raiseerror);
-  }
-  /* else stack overflow */
-  /* add extra size to be able to handle the error message */
-  luaD_reallocstack(L, ERRORSTACKSIZE, raiseerror);
-  if (raiseerror)
-    luaG_runerror(L, "stack overflow");
-  return 0;
-}
-
-
-/*
-** Compute how much of the stack is being used, by computing the
-** maximum top of all call frames in the stack and the current top.
-*/
-static int stackinuse (lua_State *L) {
-  CallInfo *ci;
-  int res;
-  StkId lim = L->top.p;
-  for (ci = L->ci; ci != NULL; ci = ci->previous) {
-    if (lim < ci->top.p) lim = ci->top.p;
-  }
-  lua_assert(lim <= L->stack_last.p + EXTRA_STACK);
-  res = cast_int(lim - L->stack.p) + 1;  /* part of stack in use */
-  if (res < LUA_MINSTACK)
-    res = LUA_MINSTACK;  /* ensure a minimum size */
-  return res;
-}
-
-
-/*
-** If stack size is more than 3 times the current use, reduce that size
-** to twice the current use. (So, the final stack size is at most 2/3 the
-** previous size, and half of its entries are empty.)
-** As a particular case, if stack was handling a stack overflow and now
-** it is not, 'max' (limited by LUAI_MAXSTACK) will be smaller than
-** stacksize (equal to ERRORSTACKSIZE in this case), and so the stack
-** will be reduced to a "regular" size.
-*/
-void luaD_shrinkstack (lua_State *L) {
-  int inuse = stackinuse(L);
-  int max = (inuse > LUAI_MAXSTACK / 3) ? LUAI_MAXSTACK : inuse * 3;
-  /* if thread is currently not handling a stack overflow and its
-     size is larger than maximum "reasonable" size, shrink it */
-  if (inuse <= LUAI_MAXSTACK && stacksize(L) > max) {
-    int nsize = (inuse > LUAI_MAXSTACK / 2) ? LUAI_MAXSTACK : inuse * 2;
-    luaD_reallocstack(L, nsize, 0);  /* ok if that fails */
-  }
-  else  /* don't change stack */
-    condmovestack(L,{},{});  /* (change only for debugging) */
-  luaE_shrinkCI(L);  /* shrink CI list */
-}
-
-
-void luaD_inctop (lua_State *L) {
-  luaD_checkstack(L, 1);
-  L->top.p++;
-}
-
-/* }================================================================== */
-
-
-/*
-** Call a hook for the given event. Make sure there is a hook to be
-** called. (Both 'L->hook' and 'L->hookmask', which trigger this
-** function, can be changed asynchronously by signals.)
-*/
-void luaD_hook (lua_State *L, int event, int line,
-                              int ftransfer, int ntransfer) {
-  lua_Hook hook = L->hook;
-  if (hook && L->allowhook) {  /* make sure there is a hook */
-    int mask = CIST_HOOKED;
-    CallInfo *ci = L->ci;
-    ptrdiff_t top = savestack(L, L->top.p);  /* preserve original 'top' */
-    ptrdiff_t ci_top = savestack(L, ci->top.p);  /* idem for 'ci->top' */
-    lua_Debug ar;
-    ar.event = event;
-    ar.currentline = line;
-    ar.i_ci = ci;
-    if (ntransfer != 0) {
-      mask |= CIST_TRAN;  /* 'ci' has transfer information */
-      ci->u2.transferinfo.ftransfer = ftransfer;
-      ci->u2.transferinfo.ntransfer = ntransfer;
-    }
-    if (isLua(ci) && L->top.p < ci->top.p)
-      L->top.p = ci->top.p;  /* protect entire activation register */
-    luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
-    if (ci->top.p < L->top.p + LUA_MINSTACK)
-      ci->top.p = L->top.p + LUA_MINSTACK;
-    L->allowhook = 0;  /* cannot call hooks inside a hook */
-    ci->callstatus |= mask;
-    lua_unlock(L);
-    (*hook)(L, &ar);
-    lua_lock(L);
-    lua_assert(!L->allowhook);
-    L->allowhook = 1;
-    ci->top.p = restorestack(L, ci_top);
-    L->top.p = restorestack(L, top);
-    ci->callstatus &= ~mask;
-  }
-}
-
-
-/*
-** Executes a call hook for Lua functions. This function is called
-** whenever 'hookmask' is not zero, so it checks whether call hooks are
-** active.
-*/
-void luaD_hookcall (lua_State *L, CallInfo *ci) {
-  L->oldpc = 0;  /* set 'oldpc' for new function */
-  if (L->hookmask & LUA_MASKCALL) {  /* is call hook on? */
-    int event = (ci->callstatus & CIST_TAIL) ? LUA_HOOKTAILCALL
-                                             : LUA_HOOKCALL;
-    Proto *p = ci_func(ci)->p;
-    ci->u.l.savedpc++;  /* hooks assume 'pc' is already incremented */
-    luaD_hook(L, event, -1, 1, p->numparams);
-    ci->u.l.savedpc--;  /* correct 'pc' */
-  }
-}
-
-
-/*
-** Executes a return hook for Lua and C functions and sets/corrects
-** 'oldpc'. (Note that this correction is needed by the line hook, so it
-** is done even when return hooks are off.)
-*/
-static void rethook (lua_State *L, CallInfo *ci, int nres) {
-  if (L->hookmask & LUA_MASKRET) {  /* is return hook on? */
-    StkId firstres = L->top.p - nres;  /* index of first result */
-    int delta = 0;  /* correction for vararg functions */
-    int ftransfer;
-    if (isLua(ci)) {
-      Proto *p = ci_func(ci)->p;
-      if (p->is_vararg)
-        delta = ci->u.l.nextraargs + p->numparams + 1;
-    }
-    ci->func.p += delta;  /* if vararg, back to virtual 'func' */
-    ftransfer = cast(unsigned short, firstres - ci->func.p);
-    luaD_hook(L, LUA_HOOKRET, -1, ftransfer, nres);  /* call it */
-    ci->func.p -= delta;
-  }
-  if (isLua(ci = ci->previous))
-    L->oldpc = pcRel(ci->u.l.savedpc, ci_func(ci)->p);  /* set 'oldpc' */
-}
-
-
-/*
-** Check whether 'func' has a '__call' metafield. If so, put it in the
-** stack, below original 'func', so that 'luaD_precall' can call it. Raise
-** an error if there is no '__call' metafield.
-*/
-StkId luaD_tryfuncTM (lua_State *L, StkId func) {
-  const TValue *tm;
-  StkId p;
-  checkstackGCp(L, 1, func);  /* space for metamethod */
-  tm = luaT_gettmbyobj(L, s2v(func), TM_CALL);  /* (after previous GC) */
-  if (l_unlikely(ttisnil(tm)))
-    luaG_callerror(L, s2v(func));  /* nothing to call */
-  for (p = L->top.p; p > func; p--)  /* open space for metamethod */
-    setobjs2s(L, p, p-1);
-  L->top.p++;  /* stack space pre-allocated by the caller */
-  setobj2s(L, func, tm);  /* metamethod is the new function to be called */
-  return func;
-}
-
-
-/*
-** Given 'nres' results at 'firstResult', move 'wanted' of them to 'res'.
-** Handle most typical cases (zero results for commands, one result for
-** expressions, multiple results for tail calls/single parameters)
-** separated.
-*/
-l_sinline void moveresults (lua_State *L, StkId res, int nres, int wanted) {
-  StkId firstresult;
-  int i;
-  switch (wanted) {  /* handle typical cases separately */
-    case 0:  /* no values needed */
-      L->top.p = res;
-      return;
-    case 1:  /* one value needed */
-      if (nres == 0)   /* no results? */
-        setnilvalue(s2v(res));  /* adjust with nil */
-      else  /* at least one result */
-        setobjs2s(L, res, L->top.p - nres);  /* move it to proper place */
-      L->top.p = res + 1;
-      return;
-    case LUA_MULTRET:
-      wanted = nres;  /* we want all results */
-      break;
-    default:  /* two/more results and/or to-be-closed variables */
-      if (hastocloseCfunc(wanted)) {  /* to-be-closed variables? */
-        L->ci->callstatus |= CIST_CLSRET;  /* in case of yields */
-        L->ci->u2.nres = nres;
-        res = luaF_close(L, res, CLOSEKTOP, 1);
-        L->ci->callstatus &= ~CIST_CLSRET;
-        if (L->hookmask) {  /* if needed, call hook after '__close's */
-          ptrdiff_t savedres = savestack(L, res);
-          rethook(L, L->ci, nres);
-          res = restorestack(L, savedres);  /* hook can move stack */
-        }
-        wanted = decodeNresults(wanted);
-        if (wanted == LUA_MULTRET)
-          wanted = nres;  /* we want all results */
-      }
-      break;
-  }
-  /* generic case */
-  firstresult = L->top.p - nres;  /* index of first result */
-  if (nres > wanted)  /* extra results? */
-    nres = wanted;  /* don't need them */
-  for (i = 0; i < nres; i++)  /* move all results to correct place */
-    setobjs2s(L, res + i, firstresult + i);
-  for (; i < wanted; i++)  /* complete wanted number of results */
-    setnilvalue(s2v(res + i));
-  L->top.p = res + wanted;  /* top points after the last result */
-}
-
-
-/*
-** Finishes a function call: calls hook if necessary, moves current
-** number of results to proper place, and returns to previous call
-** info. If function has to close variables, hook must be called after
-** that.
-*/
-void luaD_poscall (lua_State *L, CallInfo *ci, int nres) {
-  int wanted = ci->nresults;
-  if (l_unlikely(L->hookmask && !hastocloseCfunc(wanted)))
-    rethook(L, ci, nres);
-  /* move results to proper place */
-  moveresults(L, ci->func.p, nres, wanted);
-  /* function cannot be in any of these cases when returning */
-  lua_assert(!(ci->callstatus &
-        (CIST_HOOKED | CIST_YPCALL | CIST_FIN | CIST_TRAN | CIST_CLSRET)));
-  L->ci = ci->previous;  /* back to caller (after closing variables) */
-}
-
-
-
-#define next_ci(L)  (L->ci->next ? L->ci->next : luaE_extendCI(L))
-
-
-l_sinline CallInfo *prepCallInfo (lua_State *L, StkId func, int nret,
-                                                int mask, StkId top) {
-  CallInfo *ci = L->ci = next_ci(L);  /* new frame */
-  ci->func.p = func;
-  ci->nresults = nret;
-  ci->callstatus = mask;
-  ci->top.p = top;
-  return ci;
-}
-
-
-/*
-** precall for C functions
-*/
-l_sinline int precallC (lua_State *L, StkId func, int nresults,
-                                            lua_CFunction f) {
-  int n;  /* number of returns */
-  CallInfo *ci;
-  checkstackGCp(L, LUA_MINSTACK, func);  /* ensure minimum stack size */
-  L->ci = ci = prepCallInfo(L, func, nresults, CIST_C,
-                               L->top.p + LUA_MINSTACK);
-  lua_assert(ci->top.p <= L->stack_last.p);
-  if (l_unlikely(L->hookmask & LUA_MASKCALL)) {
-    int narg = cast_int(L->top.p - func) - 1;
-    luaD_hook(L, LUA_HOOKCALL, -1, 1, narg);
-  }
-  lua_unlock(L);
-  n = (*f)(L);  /* do the actual call */
-  lua_lock(L);
-  api_checknelems(L, n);
-  luaD_poscall(L, ci, n);
-  return n;
-}
-
-
-/*
-** Prepare a function for a tail call, building its call info on top
-** of the current call info. 'narg1' is the number of arguments plus 1
-** (so that it includes the function itself). Return the number of
-** results, if it was a C function, or -1 for a Lua function.
-*/
-int luaD_pretailcall (lua_State *L, CallInfo *ci, StkId func,
-                                    int narg1, int delta) {
- retry:
-  switch (ttypetag(s2v(func))) {
-    case LUA_VCCL:  /* C closure */
-      return precallC(L, func, LUA_MULTRET, clCvalue(s2v(func))->f);
-    case LUA_VLCF:  /* light C function */
-      return precallC(L, func, LUA_MULTRET, fvalue(s2v(func)));
-    case LUA_VLCL: {  /* Lua function */
-      Proto *p = clLvalue(s2v(func))->p;
-      int fsize = p->maxstacksize;  /* frame size */
-      int nfixparams = p->numparams;
-      int i;
-      checkstackGCp(L, fsize - delta, func);
-      ci->func.p -= delta;  /* restore 'func' (if vararg) */
-      for (i = 0; i < narg1; i++)  /* move down function and arguments */
-        setobjs2s(L, ci->func.p + i, func + i);
-      func = ci->func.p;  /* moved-down function */
-      for (; narg1 <= nfixparams; narg1++)
-        setnilvalue(s2v(func + narg1));  /* complete missing arguments */
-      ci->top.p = func + 1 + fsize;  /* top for new function */
-      lua_assert(ci->top.p <= L->stack_last.p);
-      ci->u.l.savedpc = p->code;  /* starting point */
-      ci->callstatus |= CIST_TAIL;
-      L->top.p = func + narg1;  /* set top */
-      return -1;
-    }
-    default: {  /* not a function */
-      func = luaD_tryfuncTM(L, func);  /* try to get '__call' metamethod */
-      /* return luaD_pretailcall(L, ci, func, narg1 + 1, delta); */
-      narg1++;
-      goto retry;  /* try again */
-    }
-  }
-}
-
-
-/*
-** Prepares the call to a function (C or Lua). For C functions, also do
-** the call. The function to be called is at '*func'.  The arguments
-** are on the stack, right after the function.  Returns the CallInfo
-** to be executed, if it was a Lua function. Otherwise (a C function)
-** returns NULL, with all the results on the stack, starting at the
-** original function position.
-*/
-CallInfo *luaD_precall (lua_State *L, StkId func, int nresults) {
- retry:
-  switch (ttypetag(s2v(func))) {
-    case LUA_VCCL:  /* C closure */
-      precallC(L, func, nresults, clCvalue(s2v(func))->f);
-      return NULL;
-    case LUA_VLCF:  /* light C function */
-      precallC(L, func, nresults, fvalue(s2v(func)));
-      return NULL;
-    case LUA_VLCL: {  /* Lua function */
-      CallInfo *ci;
-      Proto *p = clLvalue(s2v(func))->p;
-      int narg = cast_int(L->top.p - func) - 1;  /* number of real arguments */
-      int nfixparams = p->numparams;
-      int fsize = p->maxstacksize;  /* frame size */
-      checkstackGCp(L, fsize, func);
-      L->ci = ci = prepCallInfo(L, func, nresults, 0, func + 1 + fsize);
-      ci->u.l.savedpc = p->code;  /* starting point */
-      for (; narg < nfixparams; narg++)
-        setnilvalue(s2v(L->top.p++));  /* complete missing arguments */
-      lua_assert(ci->top.p <= L->stack_last.p);
-      return ci;
-    }
-    default: {  /* not a function */
-      func = luaD_tryfuncTM(L, func);  /* try to get '__call' metamethod */
-      /* return luaD_precall(L, func, nresults); */
-      goto retry;  /* try again with metamethod */
-    }
-  }
-}
-
-
-/*
-** Call a function (C or Lua) through C. 'inc' can be 1 (increment
-** number of recursive invocations in the C stack) or nyci (the same
-** plus increment number of non-yieldable calls).
-** This function can be called with some use of EXTRA_STACK, so it should
-** check the stack before doing anything else. 'luaD_precall' already
-** does that.
-*/
-l_sinline void ccall (lua_State *L, StkId func, int nResults, l_uint32 inc) {
-  CallInfo *ci;
-  L->nCcalls += inc;
-  if (l_unlikely(getCcalls(L) >= LUAI_MAXCCALLS)) {
-    checkstackp(L, 0, func);  /* free any use of EXTRA_STACK */
-    luaE_checkcstack(L);
-  }
-  if ((ci = luaD_precall(L, func, nResults)) != NULL) {  /* Lua function? */
-    ci->callstatus = CIST_FRESH;  /* mark that it is a "fresh" execute */
-    luaV_execute(L, ci);  /* call it */
-  }
-  L->nCcalls -= inc;
-}
-
-
-/*
-** External interface for 'ccall'
-*/
-void luaD_call (lua_State *L, StkId func, int nResults) {
-  ccall(L, func, nResults, 1);
-}
-
-
-/*
-** Similar to 'luaD_call', but does not allow yields during the call.
-*/
-void luaD_callnoyield (lua_State *L, StkId func, int nResults) {
-  ccall(L, func, nResults, nyci);
-}
-
-
-/*
-** Finish the job of 'lua_pcallk' after it was interrupted by an yield.
-** (The caller, 'finishCcall', does the final call to 'adjustresults'.)
-** The main job is to complete the 'luaD_pcall' called by 'lua_pcallk'.
-** If a '__close' method yields here, eventually control will be back
-** to 'finishCcall' (when that '__close' method finally returns) and
-** 'finishpcallk' will run again and close any still pending '__close'
-** methods. Similarly, if a '__close' method errs, 'precover' calls
-** 'unroll' which calls ''finishCcall' and we are back here again, to
-** close any pending '__close' methods.
-** Note that, up to the call to 'luaF_close', the corresponding
-** 'CallInfo' is not modified, so that this repeated run works like the
-** first one (except that it has at least one less '__close' to do). In
-** particular, field CIST_RECST preserves the error status across these
-** multiple runs, changing only if there is a new error.
-*/
-static int finishpcallk (lua_State *L,  CallInfo *ci) {
-  int status = getcistrecst(ci);  /* get original status */
-  if (l_likely(status == LUA_OK))  /* no error? */
-    status = LUA_YIELD;  /* was interrupted by an yield */
-  else {  /* error */
-    StkId func = restorestack(L, ci->u2.funcidx);
-    L->allowhook = getoah(ci->callstatus);  /* restore 'allowhook' */
-    func = luaF_close(L, func, status, 1);  /* can yield or raise an error */
-    luaD_seterrorobj(L, status, func);
-    luaD_shrinkstack(L);   /* restore stack size in case of overflow */
-    setcistrecst(ci, LUA_OK);  /* clear original status */
-  }
-  ci->callstatus &= ~CIST_YPCALL;
-  L->errfunc = ci->u.c.old_errfunc;
-  /* if it is here, there were errors or yields; unlike 'lua_pcallk',
-     do not change status */
-  return status;
-}
-
-
-/*
-** Completes the execution of a C function interrupted by an yield.
-** The interruption must have happened while the function was either
-** closing its tbc variables in 'moveresults' or executing
-** 'lua_callk'/'lua_pcallk'. In the first case, it just redoes
-** 'luaD_poscall'. In the second case, the call to 'finishpcallk'
-** finishes the interrupted execution of 'lua_pcallk'.  After that, it
-** calls the continuation of the interrupted function and finally it
-** completes the job of the 'luaD_call' that called the function.  In
-** the call to 'adjustresults', we do not know the number of results
-** of the function called by 'lua_callk'/'lua_pcallk', so we are
-** conservative and use LUA_MULTRET (always adjust).
-*/
-static void finishCcall (lua_State *L, CallInfo *ci) {
-  int n;  /* actual number of results from C function */
-  if (ci->callstatus & CIST_CLSRET) {  /* was returning? */
-    lua_assert(hastocloseCfunc(ci->nresults));
-    n = ci->u2.nres;  /* just redo 'luaD_poscall' */
-    /* don't need to reset CIST_CLSRET, as it will be set again anyway */
-  }
-  else {
-    int status = LUA_YIELD;  /* default if there were no errors */
-    /* must have a continuation and must be able to call it */
-    lua_assert(ci->u.c.k != NULL && yieldable(L));
-    if (ci->callstatus & CIST_YPCALL)   /* was inside a 'lua_pcallk'? */
-      status = finishpcallk(L, ci);  /* finish it */
-    adjustresults(L, LUA_MULTRET);  /* finish 'lua_callk' */
-    lua_unlock(L);
-    n = (*ci->u.c.k)(L, status, ci->u.c.ctx);  /* call continuation */
-    lua_lock(L);
-    api_checknelems(L, n);
-  }
-  luaD_poscall(L, ci, n);  /* finish 'luaD_call' */
-}
-
-
-/*
-** Executes "full continuation" (everything in the stack) of a
-** previously interrupted coroutine until the stack is empty (or another
-** interruption long-jumps out of the loop).
-*/
-static void unroll (lua_State *L, void *ud) {
-  CallInfo *ci;
-  UNUSED(ud);
-  while ((ci = L->ci) != &L->base_ci) {  /* something in the stack */
-    if (!isLua(ci))  /* C function? */
-      finishCcall(L, ci);  /* complete its execution */
-    else {  /* Lua function */
-      luaV_finishOp(L);  /* finish interrupted instruction */
-      luaV_execute(L, ci);  /* execute down to higher C 'boundary' */
-    }
-  }
-}
-
-
-/*
-** Try to find a suspended protected call (a "recover point") for the
-** given thread.
-*/
-static CallInfo *findpcall (lua_State *L) {
-  CallInfo *ci;
-  for (ci = L->ci; ci != NULL; ci = ci->previous) {  /* search for a pcall */
-    if (ci->callstatus & CIST_YPCALL)
-      return ci;
-  }
-  return NULL;  /* no pending pcall */
-}
-
-
-/*
-** Signal an error in the call to 'lua_resume', not in the execution
-** of the coroutine itself. (Such errors should not be handled by any
-** coroutine error handler and should not kill the coroutine.)
-*/
-static int resume_error (lua_State *L, const char *msg, int narg) {
-  L->top.p -= narg;  /* remove args from the stack */
-  setsvalue2s(L, L->top.p, luaS_new(L, msg));  /* push error message */
-  api_incr_top(L);
-  lua_unlock(L);
-  return LUA_ERRRUN;
-}
-
-
-/*
-** Do the work for 'lua_resume' in protected mode. Most of the work
-** depends on the status of the coroutine: initial state, suspended
-** inside a hook, or regularly suspended (optionally with a continuation
-** function), plus erroneous cases: non-suspended coroutine or dead
-** coroutine.
-*/
-static void resume (lua_State *L, void *ud) {
-  int n = *(cast(int*, ud));  /* number of arguments */
-  StkId firstArg = L->top.p - n;  /* first argument */
-  CallInfo *ci = L->ci;
-  if (L->status == LUA_OK)  /* starting a coroutine? */
-    ccall(L, firstArg - 1, LUA_MULTRET, 0);  /* just call its body */
-  else {  /* resuming from previous yield */
-    lua_assert(L->status == LUA_YIELD);
-    L->status = LUA_OK;  /* mark that it is running (again) */
-    if (isLua(ci)) {  /* yielded inside a hook? */
-      L->top.p = firstArg;  /* discard arguments */
-      luaV_execute(L, ci);  /* just continue running Lua code */
-    }
-    else {  /* 'common' yield */
-      if (ci->u.c.k != NULL) {  /* does it have a continuation function? */
-        lua_unlock(L);
-        n = (*ci->u.c.k)(L, LUA_YIELD, ci->u.c.ctx); /* call continuation */
-        lua_lock(L);
-        api_checknelems(L, n);
-      }
-      luaD_poscall(L, ci, n);  /* finish 'luaD_call' */
-    }
-    unroll(L, NULL);  /* run continuation */
-  }
-}
-
-
-/*
-** Unrolls a coroutine in protected mode while there are recoverable
-** errors, that is, errors inside a protected call. (Any error
-** interrupts 'unroll', and this loop protects it again so it can
-** continue.) Stops with a normal end (status == LUA_OK), an yield
-** (status == LUA_YIELD), or an unprotected error ('findpcall' doesn't
-** find a recover point).
-*/
-static int precover (lua_State *L, int status) {
-  CallInfo *ci;
-  while (errorstatus(status) && (ci = findpcall(L)) != NULL) {
-    L->ci = ci;  /* go down to recovery functions */
-    setcistrecst(ci, status);  /* status to finish 'pcall' */
-    status = luaD_rawrunprotected(L, unroll, NULL);
-  }
-  return status;
-}
-
-
-LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs,
-                                      int *nresults) {
-  int status;
-  lua_lock(L);
-  if (L->status == LUA_OK) {  /* may be starting a coroutine */
-    if (L->ci != &L->base_ci)  /* not in base level? */
-      return resume_error(L, "cannot resume non-suspended coroutine", nargs);
-    else if (L->top.p - (L->ci->func.p + 1) == nargs)  /* no function? */
-      return resume_error(L, "cannot resume dead coroutine", nargs);
-  }
-  else if (L->status != LUA_YIELD)  /* ended with errors? */
-    return resume_error(L, "cannot resume dead coroutine", nargs);
-  L->nCcalls = (from) ? getCcalls(from) : 0;
-  if (getCcalls(L) >= LUAI_MAXCCALLS)
-    return resume_error(L, "C stack overflow", nargs);
-  L->nCcalls++;
-  luai_userstateresume(L, nargs);
-  api_checknelems(L, (L->status == LUA_OK) ? nargs + 1 : nargs);
-  status = luaD_rawrunprotected(L, resume, &nargs);
-   /* continue running after recoverable errors */
-  status = precover(L, status);
-  if (l_likely(!errorstatus(status)))
-    lua_assert(status == L->status);  /* normal end or yield */
-  else {  /* unrecoverable error */
-    L->status = cast_byte(status);  /* mark thread as 'dead' */
-    luaD_seterrorobj(L, status, L->top.p);  /* push error message */
-    L->ci->top.p = L->top.p;
-  }
-  *nresults = (status == LUA_YIELD) ? L->ci->u2.nyield
-                                    : cast_int(L->top.p - (L->ci->func.p + 1));
-  lua_unlock(L);
-  return status;
-}
-
-
-LUA_API int lua_isyieldable (lua_State *L) {
-  return yieldable(L);
-}
-
-
-LUA_API int lua_yieldk (lua_State *L, int nresults, lua_KContext ctx,
-                        lua_KFunction k) {
-  CallInfo *ci;
-  luai_userstateyield(L, nresults);
-  lua_lock(L);
-  ci = L->ci;
-  api_checknelems(L, nresults);
-  if (l_unlikely(!yieldable(L))) {
-    if (L != G(L)->mainthread)
-      luaG_runerror(L, "attempt to yield across a C-call boundary");
-    else
-      luaG_runerror(L, "attempt to yield from outside a coroutine");
-  }
-  L->status = LUA_YIELD;
-  ci->u2.nyield = nresults;  /* save number of results */
-  if (isLua(ci)) {  /* inside a hook? */
-    lua_assert(!isLuacode(ci));
-    api_check(L, nresults == 0, "hooks cannot yield values");
-    api_check(L, k == NULL, "hooks cannot continue after yielding");
-  }
-  else {
-    if ((ci->u.c.k = k) != NULL)  /* is there a continuation? */
-      ci->u.c.ctx = ctx;  /* save context */
-    luaD_throw(L, LUA_YIELD);
-  }
-  lua_assert(ci->callstatus & CIST_HOOKED);  /* must be inside a hook */
-  lua_unlock(L);
-  return 0;  /* return to 'luaD_hook' */
-}
-
-
-/*
-** Auxiliary structure to call 'luaF_close' in protected mode.
-*/
-struct CloseP {
-  StkId level;
-  int status;
-};
-
-
-/*
-** Auxiliary function to call 'luaF_close' in protected mode.
-*/
-static void closepaux (lua_State *L, void *ud) {
-  struct CloseP *pcl = cast(struct CloseP *, ud);
-  luaF_close(L, pcl->level, pcl->status, 0);
-}
-
-
-/*
-** Calls 'luaF_close' in protected mode. Return the original status
-** or, in case of errors, the new status.
-*/
-int luaD_closeprotected (lua_State *L, ptrdiff_t level, int status) {
-  CallInfo *old_ci = L->ci;
-  lu_byte old_allowhooks = L->allowhook;
-  for (;;) {  /* keep closing upvalues until no more errors */
-    struct CloseP pcl;
-    pcl.level = restorestack(L, level); pcl.status = status;
-    status = luaD_rawrunprotected(L, &closepaux, &pcl);
-    if (l_likely(status == LUA_OK))  /* no more errors? */
-      return pcl.status;
-    else {  /* an error occurred; restore saved state and repeat */
-      L->ci = old_ci;
-      L->allowhook = old_allowhooks;
-    }
-  }
-}
-
-
-/*
-** Call the C function 'func' in protected mode, restoring basic
-** thread information ('allowhook', etc.) and in particular
-** its stack level in case of errors.
-*/
-int luaD_pcall (lua_State *L, Pfunc func, void *u,
-                ptrdiff_t old_top, ptrdiff_t ef) {
-  int status;
-  CallInfo *old_ci = L->ci;
-  lu_byte old_allowhooks = L->allowhook;
-  ptrdiff_t old_errfunc = L->errfunc;
-  L->errfunc = ef;
-  status = luaD_rawrunprotected(L, func, u);
-  if (l_unlikely(status != LUA_OK)) {  /* an error occurred? */
-    L->ci = old_ci;
-    L->allowhook = old_allowhooks;
-    status = luaD_closeprotected(L, old_top, status);
-    luaD_seterrorobj(L, status, restorestack(L, old_top));
-    luaD_shrinkstack(L);   /* restore stack size in case of overflow */
-  }
-  L->errfunc = old_errfunc;
-  return status;
-}
-
-
-
-/*
-** Execute a protected parser.
-*/
-struct SParser {  /* data to 'f_parser' */
-  ZIO *z;
-  Mbuffer buff;  /* dynamic structure used by the scanner */
-  Dyndata dyd;  /* dynamic structures used by the parser */
-  const char *mode;
-  const char *name;
-};
-
-
-static void checkmode (lua_State *L, const char *mode, const char *x) {
-  if (mode && strchr(mode, x[0]) == NULL) {
-    luaO_pushfstring(L,
-       "attempt to load a %s chunk (mode is '%s')", x, mode);
-    luaD_throw(L, LUA_ERRSYNTAX);
-  }
-}
-
-
-static void f_parser (lua_State *L, void *ud) {
-  LClosure *cl;
-  struct SParser *p = cast(struct SParser *, ud);
-  int c = zgetc(p->z);  /* read first character */
-  if (c == LUA_SIGNATURE[0]) {
-    checkmode(L, p->mode, "binary");
-    cl = luaU_undump(L, p->z, p->name);
-  }
-  else {
-    checkmode(L, p->mode, "text");
-    cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c);
-  }
-  lua_assert(cl->nupvalues == cl->p->sizeupvalues);
-  luaF_initupvals(L, cl);
-}
-
-
-int luaD_protectedparser (lua_State *L, ZIO *z, const char *name,
-                                        const char *mode) {
-  struct SParser p;
-  int status;
-  incnny(L);  /* cannot yield during parsing */
-  p.z = z; p.name = name; p.mode = mode;
-  p.dyd.actvar.arr = NULL; p.dyd.actvar.size = 0;
-  p.dyd.gt.arr = NULL; p.dyd.gt.size = 0;
-  p.dyd.label.arr = NULL; p.dyd.label.size = 0;
-  luaZ_initbuffer(L, &p.buff);
-  status = luaD_pcall(L, f_parser, &p, savestack(L, L->top.p), L->errfunc);
-  luaZ_freebuffer(L, &p.buff);
-  luaM_freearray(L, p.dyd.actvar.arr, p.dyd.actvar.size);
-  luaM_freearray(L, p.dyd.gt.arr, p.dyd.gt.size);
-  luaM_freearray(L, p.dyd.label.arr, p.dyd.label.size);
-  decnny(L);
-  return status;
-}
-
-
diff --git a/third-party/lua/src/ldo.h b/third-party/lua/src/ldo.h
deleted file mode 100644
index 1aa446ad0..000000000
--- a/third-party/lua/src/ldo.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
-** $Id: ldo.h $
-** Stack and Call structure of Lua
-** See Copyright Notice in lua.h
-*/
-
-#ifndef ldo_h
-#define ldo_h
-
-
-#include "llimits.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lzio.h"
-
-
-/*
-** Macro to check stack size and grow stack if needed.  Parameters
-** 'pre'/'pos' allow the macro to preserve a pointer into the
-** stack across reallocations, doing the work only when needed.
-** It also allows the running of one GC step when the stack is
-** reallocated.
-** 'condmovestack' is used in heavy tests to force a stack reallocation
-** at every check.
-*/
-#define luaD_checkstackaux(L,n,pre,pos)  \
-	if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \
-	  { pre; luaD_growstack(L, n, 1); pos; } \
-        else { condmovestack(L,pre,pos); }
-
-/* In general, 'pre'/'pos' are empty (nothing to save) */
-#define luaD_checkstack(L,n)	luaD_checkstackaux(L,n,(void)0,(void)0)
-
-
-
-#define savestack(L,pt)		(cast_charp(pt) - cast_charp(L->stack.p))
-#define restorestack(L,n)	cast(StkId, cast_charp(L->stack.p) + (n))
-
-
-/* macro to check stack size, preserving 'p' */
-#define checkstackp(L,n,p)  \
-  luaD_checkstackaux(L, n, \
-    ptrdiff_t t__ = savestack(L, p),  /* save 'p' */ \
-    p = restorestack(L, t__))  /* 'pos' part: restore 'p' */
-
-
-/* macro to check stack size and GC, preserving 'p' */
-#define checkstackGCp(L,n,p)  \
-  luaD_checkstackaux(L, n, \
-    ptrdiff_t t__ = savestack(L, p);  /* save 'p' */ \
-    luaC_checkGC(L),  /* stack grow uses memory */ \
-    p = restorestack(L, t__))  /* 'pos' part: restore 'p' */
-
-
-/* macro to check stack size and GC */
-#define checkstackGC(L,fsize)  \
-	luaD_checkstackaux(L, (fsize), luaC_checkGC(L), (void)0)
-
-
-/* type of protected functions, to be ran by 'runprotected' */
-typedef void (*Pfunc) (lua_State *L, void *ud);
-
-LUAI_FUNC void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop);
-LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name,
-                                                  const char *mode);
-LUAI_FUNC void luaD_hook (lua_State *L, int event, int line,
-                                        int fTransfer, int nTransfer);
-LUAI_FUNC void luaD_hookcall (lua_State *L, CallInfo *ci);
-LUAI_FUNC int luaD_pretailcall (lua_State *L, CallInfo *ci, StkId func,
-                                              int narg1, int delta);
-LUAI_FUNC CallInfo *luaD_precall (lua_State *L, StkId func, int nResults);
-LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults);
-LUAI_FUNC void luaD_callnoyield (lua_State *L, StkId func, int nResults);
-LUAI_FUNC StkId luaD_tryfuncTM (lua_State *L, StkId func);
-LUAI_FUNC int luaD_closeprotected (lua_State *L, ptrdiff_t level, int status);
-LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,
-                                        ptrdiff_t oldtop, ptrdiff_t ef);
-LUAI_FUNC void luaD_poscall (lua_State *L, CallInfo *ci, int nres);
-LUAI_FUNC int luaD_reallocstack (lua_State *L, int newsize, int raiseerror);
-LUAI_FUNC int luaD_growstack (lua_State *L, int n, int raiseerror);
-LUAI_FUNC void luaD_shrinkstack (lua_State *L);
-LUAI_FUNC void luaD_inctop (lua_State *L);
-
-LUAI_FUNC l_noret luaD_throw (lua_State *L, int errcode);
-LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);
-
-#endif
-
diff --git a/third-party/lua/src/ldump.c b/third-party/lua/src/ldump.c
deleted file mode 100644
index f231691b7..000000000
--- a/third-party/lua/src/ldump.c
+++ /dev/null
@@ -1,230 +0,0 @@
-/*
-** $Id: ldump.c $
-** save precompiled Lua chunks
-** See Copyright Notice in lua.h
-*/
-
-#define ldump_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <limits.h>
-#include <stddef.h>
-
-#include "lua.h"
-
-#include "lobject.h"
-#include "lstate.h"
-#include "lundump.h"
-
-
-typedef struct {
-  lua_State *L;
-  lua_Writer writer;
-  void *data;
-  int strip;
-  int status;
-} DumpState;
-
-
-/*
-** All high-level dumps go through dumpVector; you can change it to
-** change the endianness of the result
-*/
-#define dumpVector(D,v,n)	dumpBlock(D,v,(n)*sizeof((v)[0]))
-
-#define dumpLiteral(D, s)	dumpBlock(D,s,sizeof(s) - sizeof(char))
-
-
-static void dumpBlock (DumpState *D, const void *b, size_t size) {
-  if (D->status == 0 && size > 0) {
-    lua_unlock(D->L);
-    D->status = (*D->writer)(D->L, b, size, D->data);
-    lua_lock(D->L);
-  }
-}
-
-
-#define dumpVar(D,x)		dumpVector(D,&x,1)
-
-
-static void dumpByte (DumpState *D, int y) {
-  lu_byte x = (lu_byte)y;
-  dumpVar(D, x);
-}
-
-
-/*
-** 'dumpSize' buffer size: each byte can store up to 7 bits. (The "+6"
-** rounds up the division.)
-*/
-#define DIBS    ((sizeof(size_t) * CHAR_BIT + 6) / 7)
-
-static void dumpSize (DumpState *D, size_t x) {
-  lu_byte buff[DIBS];
-  int n = 0;
-  do {
-    buff[DIBS - (++n)] = x & 0x7f;  /* fill buffer in reverse order */
-    x >>= 7;
-  } while (x != 0);
-  buff[DIBS - 1] |= 0x80;  /* mark last byte */
-  dumpVector(D, buff + DIBS - n, n);
-}
-
-
-static void dumpInt (DumpState *D, int x) {
-  dumpSize(D, x);
-}
-
-
-static void dumpNumber (DumpState *D, lua_Number x) {
-  dumpVar(D, x);
-}
-
-
-static void dumpInteger (DumpState *D, lua_Integer x) {
-  dumpVar(D, x);
-}
-
-
-static void dumpString (DumpState *D, const TString *s) {
-  if (s == NULL)
-    dumpSize(D, 0);
-  else {
-    size_t size = tsslen(s);
-    const char *str = getstr(s);
-    dumpSize(D, size + 1);
-    dumpVector(D, str, size);
-  }
-}
-
-
-static void dumpCode (DumpState *D, const Proto *f) {
-  dumpInt(D, f->sizecode);
-  dumpVector(D, f->code, f->sizecode);
-}
-
-
-static void dumpFunction(DumpState *D, const Proto *f, TString *psource);
-
-static void dumpConstants (DumpState *D, const Proto *f) {
-  int i;
-  int n = f->sizek;
-  dumpInt(D, n);
-  for (i = 0; i < n; i++) {
-    const TValue *o = &f->k[i];
-    int tt = ttypetag(o);
-    dumpByte(D, tt);
-    switch (tt) {
-      case LUA_VNUMFLT:
-        dumpNumber(D, fltvalue(o));
-        break;
-      case LUA_VNUMINT:
-        dumpInteger(D, ivalue(o));
-        break;
-      case LUA_VSHRSTR:
-      case LUA_VLNGSTR:
-        dumpString(D, tsvalue(o));
-        break;
-      default:
-        lua_assert(tt == LUA_VNIL || tt == LUA_VFALSE || tt == LUA_VTRUE);
-    }
-  }
-}
-
-
-static void dumpProtos (DumpState *D, const Proto *f) {
-  int i;
-  int n = f->sizep;
-  dumpInt(D, n);
-  for (i = 0; i < n; i++)
-    dumpFunction(D, f->p[i], f->source);
-}
-
-
-static void dumpUpvalues (DumpState *D, const Proto *f) {
-  int i, n = f->sizeupvalues;
-  dumpInt(D, n);
-  for (i = 0; i < n; i++) {
-    dumpByte(D, f->upvalues[i].instack);
-    dumpByte(D, f->upvalues[i].idx);
-    dumpByte(D, f->upvalues[i].kind);
-  }
-}
-
-
-static void dumpDebug (DumpState *D, const Proto *f) {
-  int i, n;
-  n = (D->strip) ? 0 : f->sizelineinfo;
-  dumpInt(D, n);
-  dumpVector(D, f->lineinfo, n);
-  n = (D->strip) ? 0 : f->sizeabslineinfo;
-  dumpInt(D, n);
-  for (i = 0; i < n; i++) {
-    dumpInt(D, f->abslineinfo[i].pc);
-    dumpInt(D, f->abslineinfo[i].line);
-  }
-  n = (D->strip) ? 0 : f->sizelocvars;
-  dumpInt(D, n);
-  for (i = 0; i < n; i++) {
-    dumpString(D, f->locvars[i].varname);
-    dumpInt(D, f->locvars[i].startpc);
-    dumpInt(D, f->locvars[i].endpc);
-  }
-  n = (D->strip) ? 0 : f->sizeupvalues;
-  dumpInt(D, n);
-  for (i = 0; i < n; i++)
-    dumpString(D, f->upvalues[i].name);
-}
-
-
-static void dumpFunction (DumpState *D, const Proto *f, TString *psource) {
-  if (D->strip || f->source == psource)
-    dumpString(D, NULL);  /* no debug info or same source as its parent */
-  else
-    dumpString(D, f->source);
-  dumpInt(D, f->linedefined);
-  dumpInt(D, f->lastlinedefined);
-  dumpByte(D, f->numparams);
-  dumpByte(D, f->is_vararg);
-  dumpByte(D, f->maxstacksize);
-  dumpCode(D, f);
-  dumpConstants(D, f);
-  dumpUpvalues(D, f);
-  dumpProtos(D, f);
-  dumpDebug(D, f);
-}
-
-
-static void dumpHeader (DumpState *D) {
-  dumpLiteral(D, LUA_SIGNATURE);
-  dumpByte(D, LUAC_VERSION);
-  dumpByte(D, LUAC_FORMAT);
-  dumpLiteral(D, LUAC_DATA);
-  dumpByte(D, sizeof(Instruction));
-  dumpByte(D, sizeof(lua_Integer));
-  dumpByte(D, sizeof(lua_Number));
-  dumpInteger(D, LUAC_INT);
-  dumpNumber(D, LUAC_NUM);
-}
-
-
-/*
-** dump Lua function as precompiled chunk
-*/
-int luaU_dump(lua_State *L, const Proto *f, lua_Writer w, void *data,
-              int strip) {
-  DumpState D;
-  D.L = L;
-  D.writer = w;
-  D.data = data;
-  D.strip = strip;
-  D.status = 0;
-  dumpHeader(&D);
-  dumpByte(&D, f->sizeupvalues);
-  dumpFunction(&D, f, NULL);
-  return D.status;
-}
-
diff --git a/third-party/lua/src/lfunc.c b/third-party/lua/src/lfunc.c
deleted file mode 100644
index 0945f241d..000000000
--- a/third-party/lua/src/lfunc.c
+++ /dev/null
@@ -1,294 +0,0 @@
-/*
-** $Id: lfunc.c $
-** Auxiliary functions to manipulate prototypes and closures
-** See Copyright Notice in lua.h
-*/
-
-#define lfunc_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <stddef.h>
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lgc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-
-
-
-CClosure *luaF_newCclosure (lua_State *L, int nupvals) {
-  GCObject *o = luaC_newobj(L, LUA_VCCL, sizeCclosure(nupvals));
-  CClosure *c = gco2ccl(o);
-  c->nupvalues = cast_byte(nupvals);
-  return c;
-}
-
-
-LClosure *luaF_newLclosure (lua_State *L, int nupvals) {
-  GCObject *o = luaC_newobj(L, LUA_VLCL, sizeLclosure(nupvals));
-  LClosure *c = gco2lcl(o);
-  c->p = NULL;
-  c->nupvalues = cast_byte(nupvals);
-  while (nupvals--) c->upvals[nupvals] = NULL;
-  return c;
-}
-
-
-/*
-** fill a closure with new closed upvalues
-*/
-void luaF_initupvals (lua_State *L, LClosure *cl) {
-  int i;
-  for (i = 0; i < cl->nupvalues; i++) {
-    GCObject *o = luaC_newobj(L, LUA_VUPVAL, sizeof(UpVal));
-    UpVal *uv = gco2upv(o);
-    uv->v.p = &uv->u.value;  /* make it closed */
-    setnilvalue(uv->v.p);
-    cl->upvals[i] = uv;
-    luaC_objbarrier(L, cl, uv);
-  }
-}
-
-
-/*
-** Create a new upvalue at the given level, and link it to the list of
-** open upvalues of 'L' after entry 'prev'.
-**/
-static UpVal *newupval (lua_State *L, StkId level, UpVal **prev) {
-  GCObject *o = luaC_newobj(L, LUA_VUPVAL, sizeof(UpVal));
-  UpVal *uv = gco2upv(o);
-  UpVal *next = *prev;
-  uv->v.p = s2v(level);  /* current value lives in the stack */
-  uv->u.open.next = next;  /* link it to list of open upvalues */
-  uv->u.open.previous = prev;
-  if (next)
-    next->u.open.previous = &uv->u.open.next;
-  *prev = uv;
-  if (!isintwups(L)) {  /* thread not in list of threads with upvalues? */
-    L->twups = G(L)->twups;  /* link it to the list */
-    G(L)->twups = L;
-  }
-  return uv;
-}
-
-
-/*
-** Find and reuse, or create if it does not exist, an upvalue
-** at the given level.
-*/
-UpVal *luaF_findupval (lua_State *L, StkId level) {
-  UpVal **pp = &L->openupval;
-  UpVal *p;
-  lua_assert(isintwups(L) || L->openupval == NULL);
-  while ((p = *pp) != NULL && uplevel(p) >= level) {  /* search for it */
-    lua_assert(!isdead(G(L), p));
-    if (uplevel(p) == level)  /* corresponding upvalue? */
-      return p;  /* return it */
-    pp = &p->u.open.next;
-  }
-  /* not found: create a new upvalue after 'pp' */
-  return newupval(L, level, pp);
-}
-
-
-/*
-** Call closing method for object 'obj' with error message 'err'. The
-** boolean 'yy' controls whether the call is yieldable.
-** (This function assumes EXTRA_STACK.)
-*/
-static void callclosemethod (lua_State *L, TValue *obj, TValue *err, int yy) {
-  StkId top = L->top.p;
-  const TValue *tm = luaT_gettmbyobj(L, obj, TM_CLOSE);
-  setobj2s(L, top, tm);  /* will call metamethod... */
-  setobj2s(L, top + 1, obj);  /* with 'self' as the 1st argument */
-  setobj2s(L, top + 2, err);  /* and error msg. as 2nd argument */
-  L->top.p = top + 3;  /* add function and arguments */
-  if (yy)
-    luaD_call(L, top, 0);
-  else
-    luaD_callnoyield(L, top, 0);
-}
-
-
-/*
-** Check whether object at given level has a close metamethod and raise
-** an error if not.
-*/
-static void checkclosemth (lua_State *L, StkId level) {
-  const TValue *tm = luaT_gettmbyobj(L, s2v(level), TM_CLOSE);
-  if (ttisnil(tm)) {  /* no metamethod? */
-    int idx = cast_int(level - L->ci->func.p);  /* variable index */
-    const char *vname = luaG_findlocal(L, L->ci, idx, NULL);
-    if (vname == NULL) vname = "?";
-    luaG_runerror(L, "variable '%s' got a non-closable value", vname);
-  }
-}
-
-
-/*
-** Prepare and call a closing method.
-** If status is CLOSEKTOP, the call to the closing method will be pushed
-** at the top of the stack. Otherwise, values can be pushed right after
-** the 'level' of the upvalue being closed, as everything after that
-** won't be used again.
-*/
-static void prepcallclosemth (lua_State *L, StkId level, int status, int yy) {
-  TValue *uv = s2v(level);  /* value being closed */
-  TValue *errobj;
-  if (status == CLOSEKTOP)
-    errobj = &G(L)->nilvalue;  /* error object is nil */
-  else {  /* 'luaD_seterrorobj' will set top to level + 2 */
-    errobj = s2v(level + 1);  /* error object goes after 'uv' */
-    luaD_seterrorobj(L, status, level + 1);  /* set error object */
-  }
-  callclosemethod(L, uv, errobj, yy);
-}
-
-
-/*
-** Maximum value for deltas in 'tbclist', dependent on the type
-** of delta. (This macro assumes that an 'L' is in scope where it
-** is used.)
-*/
-#define MAXDELTA  \
-	((256ul << ((sizeof(L->stack.p->tbclist.delta) - 1) * 8)) - 1)
-
-
-/*
-** Insert a variable in the list of to-be-closed variables.
-*/
-void luaF_newtbcupval (lua_State *L, StkId level) {
-  lua_assert(level > L->tbclist.p);
-  if (l_isfalse(s2v(level)))
-    return;  /* false doesn't need to be closed */
-  checkclosemth(L, level);  /* value must have a close method */
-  while (cast_uint(level - L->tbclist.p) > MAXDELTA) {
-    L->tbclist.p += MAXDELTA;  /* create a dummy node at maximum delta */
-    L->tbclist.p->tbclist.delta = 0;
-  }
-  level->tbclist.delta = cast(unsigned short, level - L->tbclist.p);
-  L->tbclist.p = level;
-}
-
-
-void luaF_unlinkupval (UpVal *uv) {
-  lua_assert(upisopen(uv));
-  *uv->u.open.previous = uv->u.open.next;
-  if (uv->u.open.next)
-    uv->u.open.next->u.open.previous = uv->u.open.previous;
-}
-
-
-/*
-** Close all upvalues up to the given stack level.
-*/
-void luaF_closeupval (lua_State *L, StkId level) {
-  UpVal *uv;
-  StkId upl;  /* stack index pointed by 'uv' */
-  while ((uv = L->openupval) != NULL && (upl = uplevel(uv)) >= level) {
-    TValue *slot = &uv->u.value;  /* new position for value */
-    lua_assert(uplevel(uv) < L->top.p);
-    luaF_unlinkupval(uv);  /* remove upvalue from 'openupval' list */
-    setobj(L, slot, uv->v.p);  /* move value to upvalue slot */
-    uv->v.p = slot;  /* now current value lives here */
-    if (!iswhite(uv)) {  /* neither white nor dead? */
-      nw2black(uv);  /* closed upvalues cannot be gray */
-      luaC_barrier(L, uv, slot);
-    }
-  }
-}
-
-
-/*
-** Remove first element from the tbclist plus its dummy nodes.
-*/
-static void poptbclist (lua_State *L) {
-  StkId tbc = L->tbclist.p;
-  lua_assert(tbc->tbclist.delta > 0);  /* first element cannot be dummy */
-  tbc -= tbc->tbclist.delta;
-  while (tbc > L->stack.p && tbc->tbclist.delta == 0)
-    tbc -= MAXDELTA;  /* remove dummy nodes */
-  L->tbclist.p = tbc;
-}
-
-
-/*
-** Close all upvalues and to-be-closed variables up to the given stack
-** level. Return restored 'level'.
-*/
-StkId luaF_close (lua_State *L, StkId level, int status, int yy) {
-  ptrdiff_t levelrel = savestack(L, level);
-  luaF_closeupval(L, level);  /* first, close the upvalues */
-  while (L->tbclist.p >= level) {  /* traverse tbc's down to that level */
-    StkId tbc = L->tbclist.p;  /* get variable index */
-    poptbclist(L);  /* remove it from list */
-    prepcallclosemth(L, tbc, status, yy);  /* close variable */
-    level = restorestack(L, levelrel);
-  }
-  return level;
-}
-
-
-Proto *luaF_newproto (lua_State *L) {
-  GCObject *o = luaC_newobj(L, LUA_VPROTO, sizeof(Proto));
-  Proto *f = gco2p(o);
-  f->k = NULL;
-  f->sizek = 0;
-  f->p = NULL;
-  f->sizep = 0;
-  f->code = NULL;
-  f->sizecode = 0;
-  f->lineinfo = NULL;
-  f->sizelineinfo = 0;
-  f->abslineinfo = NULL;
-  f->sizeabslineinfo = 0;
-  f->upvalues = NULL;
-  f->sizeupvalues = 0;
-  f->numparams = 0;
-  f->is_vararg = 0;
-  f->maxstacksize = 0;
-  f->locvars = NULL;
-  f->sizelocvars = 0;
-  f->linedefined = 0;
-  f->lastlinedefined = 0;
-  f->source = NULL;
-  return f;
-}
-
-
-void luaF_freeproto (lua_State *L, Proto *f) {
-  luaM_freearray(L, f->code, f->sizecode);
-  luaM_freearray(L, f->p, f->sizep);
-  luaM_freearray(L, f->k, f->sizek);
-  luaM_freearray(L, f->lineinfo, f->sizelineinfo);
-  luaM_freearray(L, f->abslineinfo, f->sizeabslineinfo);
-  luaM_freearray(L, f->locvars, f->sizelocvars);
-  luaM_freearray(L, f->upvalues, f->sizeupvalues);
-  luaM_free(L, f);
-}
-
-
-/*
-** Look for n-th local variable at line 'line' in function 'func'.
-** Returns NULL if not found.
-*/
-const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
-  int i;
-  for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
-    if (pc < f->locvars[i].endpc) {  /* is variable active? */
-      local_number--;
-      if (local_number == 0)
-        return getstr(f->locvars[i].varname);
-    }
-  }
-  return NULL;  /* not found */
-}
-
diff --git a/third-party/lua/src/lfunc.h b/third-party/lua/src/lfunc.h
deleted file mode 100644
index 3be265efb..000000000
--- a/third-party/lua/src/lfunc.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
-** $Id: lfunc.h $
-** Auxiliary functions to manipulate prototypes and closures
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lfunc_h
-#define lfunc_h
-
-
-#include "lobject.h"
-
-
-#define sizeCclosure(n)	(cast_int(offsetof(CClosure, upvalue)) + \
-                         cast_int(sizeof(TValue)) * (n))
-
-#define sizeLclosure(n)	(cast_int(offsetof(LClosure, upvals)) + \
-                         cast_int(sizeof(TValue *)) * (n))
-
-
-/* test whether thread is in 'twups' list */
-#define isintwups(L)	(L->twups != L)
-
-
-/*
-** maximum number of upvalues in a closure (both C and Lua). (Value
-** must fit in a VM register.)
-*/
-#define MAXUPVAL	255
-
-
-#define upisopen(up)	((up)->v.p != &(up)->u.value)
-
-
-#define uplevel(up)	check_exp(upisopen(up), cast(StkId, (up)->v.p))
-
-
-/*
-** maximum number of misses before giving up the cache of closures
-** in prototypes
-*/
-#define MAXMISS		10
-
-
-
-/* special status to close upvalues preserving the top of the stack */
-#define CLOSEKTOP	(-1)
-
-
-LUAI_FUNC Proto *luaF_newproto (lua_State *L);
-LUAI_FUNC CClosure *luaF_newCclosure (lua_State *L, int nupvals);
-LUAI_FUNC LClosure *luaF_newLclosure (lua_State *L, int nupvals);
-LUAI_FUNC void luaF_initupvals (lua_State *L, LClosure *cl);
-LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level);
-LUAI_FUNC void luaF_newtbcupval (lua_State *L, StkId level);
-LUAI_FUNC void luaF_closeupval (lua_State *L, StkId level);
-LUAI_FUNC StkId luaF_close (lua_State *L, StkId level, int status, int yy);
-LUAI_FUNC void luaF_unlinkupval (UpVal *uv);
-LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f);
-LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number,
-                                         int pc);
-
-
-#endif
diff --git a/third-party/lua/src/lgc.c b/third-party/lua/src/lgc.c
deleted file mode 100644
index a3094ff57..000000000
--- a/third-party/lua/src/lgc.c
+++ /dev/null
@@ -1,1739 +0,0 @@
-/*
-** $Id: lgc.c $
-** Garbage Collector
-** See Copyright Notice in lua.h
-*/
-
-#define lgc_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-#include <stdio.h>
-#include <string.h>
-
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lgc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-
-
-/*
-** Maximum number of elements to sweep in each single step.
-** (Large enough to dissipate fixed overheads but small enough
-** to allow small steps for the collector.)
-*/
-#define GCSWEEPMAX	100
-
-/*
-** Maximum number of finalizers to call in each single step.
-*/
-#define GCFINMAX	10
-
-
-/*
-** Cost of calling one finalizer.
-*/
-#define GCFINALIZECOST	50
-
-
-/*
-** The equivalent, in bytes, of one unit of "work" (visiting a slot,
-** sweeping an object, etc.)
-*/
-#define WORK2MEM	sizeof(TValue)
-
-
-/*
-** macro to adjust 'pause': 'pause' is actually used like
-** 'pause / PAUSEADJ' (value chosen by tests)
-*/
-#define PAUSEADJ		100
-
-
-/* mask with all color bits */
-#define maskcolors	(bitmask(BLACKBIT) | WHITEBITS)
-
-/* mask with all GC bits */
-#define maskgcbits      (maskcolors | AGEBITS)
-
-
-/* macro to erase all color bits then set only the current white bit */
-#define makewhite(g,x)	\
-  (x->marked = cast_byte((x->marked & ~maskcolors) | luaC_white(g)))
-
-/* make an object gray (neither white nor black) */
-#define set2gray(x)	resetbits(x->marked, maskcolors)
-
-
-/* make an object black (coming from any color) */
-#define set2black(x)  \
-  (x->marked = cast_byte((x->marked & ~WHITEBITS) | bitmask(BLACKBIT)))
-
-
-#define valiswhite(x)   (iscollectable(x) && iswhite(gcvalue(x)))
-
-#define keyiswhite(n)   (keyiscollectable(n) && iswhite(gckey(n)))
-
-
-/*
-** Protected access to objects in values
-*/
-#define gcvalueN(o)     (iscollectable(o) ? gcvalue(o) : NULL)
-
-
-#define markvalue(g,o) { checkliveness(g->mainthread,o); \
-  if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); }
-
-#define markkey(g, n)	{ if keyiswhite(n) reallymarkobject(g,gckey(n)); }
-
-#define markobject(g,t)	{ if (iswhite(t)) reallymarkobject(g, obj2gco(t)); }
-
-/*
-** mark an object that can be NULL (either because it is really optional,
-** or it was stripped as debug info, or inside an uncompleted structure)
-*/
-#define markobjectN(g,t)	{ if (t) markobject(g,t); }
-
-static void reallymarkobject (global_State *g, GCObject *o);
-static lu_mem atomic (lua_State *L);
-static void entersweep (lua_State *L);
-
-
-/*
-** {======================================================
-** Generic functions
-** =======================================================
-*/
-
-
-/*
-** one after last element in a hash array
-*/
-#define gnodelast(h)	gnode(h, cast_sizet(sizenode(h)))
-
-
-static GCObject **getgclist (GCObject *o) {
-  switch (o->tt) {
-    case LUA_VTABLE: return &gco2t(o)->gclist;
-    case LUA_VLCL: return &gco2lcl(o)->gclist;
-    case LUA_VCCL: return &gco2ccl(o)->gclist;
-    case LUA_VTHREAD: return &gco2th(o)->gclist;
-    case LUA_VPROTO: return &gco2p(o)->gclist;
-    case LUA_VUSERDATA: {
-      Udata *u = gco2u(o);
-      lua_assert(u->nuvalue > 0);
-      return &u->gclist;
-    }
-    default: lua_assert(0); return 0;
-  }
-}
-
-
-/*
-** Link a collectable object 'o' with a known type into the list 'p'.
-** (Must be a macro to access the 'gclist' field in different types.)
-*/
-#define linkgclist(o,p)	linkgclist_(obj2gco(o), &(o)->gclist, &(p))
-
-static void linkgclist_ (GCObject *o, GCObject **pnext, GCObject **list) {
-  lua_assert(!isgray(o));  /* cannot be in a gray list */
-  *pnext = *list;
-  *list = o;
-  set2gray(o);  /* now it is */
-}
-
-
-/*
-** Link a generic collectable object 'o' into the list 'p'.
-*/
-#define linkobjgclist(o,p) linkgclist_(obj2gco(o), getgclist(o), &(p))
-
-
-
-/*
-** Clear keys for empty entries in tables. If entry is empty, mark its
-** entry as dead. This allows the collection of the key, but keeps its
-** entry in the table: its removal could break a chain and could break
-** a table traversal.  Other places never manipulate dead keys, because
-** its associated empty value is enough to signal that the entry is
-** logically empty.
-*/
-static void clearkey (Node *n) {
-  lua_assert(isempty(gval(n)));
-  if (keyiscollectable(n))
-    setdeadkey(n);  /* unused key; remove it */
-}
-
-
-/*
-** tells whether a key or value can be cleared from a weak
-** table. Non-collectable objects are never removed from weak
-** tables. Strings behave as 'values', so are never removed too. for
-** other objects: if really collected, cannot keep them; for objects
-** being finalized, keep them in keys, but not in values
-*/
-static int iscleared (global_State *g, const GCObject *o) {
-  if (o == NULL) return 0;  /* non-collectable value */
-  else if (novariant(o->tt) == LUA_TSTRING) {
-    markobject(g, o);  /* strings are 'values', so are never weak */
-    return 0;
-  }
-  else return iswhite(o);
-}
-
-
-/*
-** Barrier that moves collector forward, that is, marks the white object
-** 'v' being pointed by the black object 'o'.  In the generational
-** mode, 'v' must also become old, if 'o' is old; however, it cannot
-** be changed directly to OLD, because it may still point to non-old
-** objects. So, it is marked as OLD0. In the next cycle it will become
-** OLD1, and in the next it will finally become OLD (regular old). By
-** then, any object it points to will also be old.  If called in the
-** incremental sweep phase, it clears the black object to white (sweep
-** it) to avoid other barrier calls for this same object. (That cannot
-** be done is generational mode, as its sweep does not distinguish
-** whites from deads.)
-*/
-void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v) {
-  global_State *g = G(L);
-  lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
-  if (keepinvariant(g)) {  /* must keep invariant? */
-    reallymarkobject(g, v);  /* restore invariant */
-    if (isold(o)) {
-      lua_assert(!isold(v));  /* white object could not be old */
-      setage(v, G_OLD0);  /* restore generational invariant */
-    }
-  }
-  else {  /* sweep phase */
-    lua_assert(issweepphase(g));
-    if (g->gckind == KGC_INC)  /* incremental mode? */
-      makewhite(g, o);  /* mark 'o' as white to avoid other barriers */
-  }
-}
-
-
-/*
-** barrier that moves collector backward, that is, mark the black object
-** pointing to a white object as gray again.
-*/
-void luaC_barrierback_ (lua_State *L, GCObject *o) {
-  global_State *g = G(L);
-  lua_assert(isblack(o) && !isdead(g, o));
-  lua_assert((g->gckind == KGC_GEN) == (isold(o) && getage(o) != G_TOUCHED1));
-  if (getage(o) == G_TOUCHED2)  /* already in gray list? */
-    set2gray(o);  /* make it gray to become touched1 */
-  else  /* link it in 'grayagain' and paint it gray */
-    linkobjgclist(o, g->grayagain);
-  if (isold(o))  /* generational mode? */
-    setage(o, G_TOUCHED1);  /* touched in current cycle */
-}
-
-
-void luaC_fix (lua_State *L, GCObject *o) {
-  global_State *g = G(L);
-  lua_assert(g->allgc == o);  /* object must be 1st in 'allgc' list! */
-  set2gray(o);  /* they will be gray forever */
-  setage(o, G_OLD);  /* and old forever */
-  g->allgc = o->next;  /* remove object from 'allgc' list */
-  o->next = g->fixedgc;  /* link it to 'fixedgc' list */
-  g->fixedgc = o;
-}
-
-
-/*
-** create a new collectable object (with given type, size, and offset)
-** and link it to 'allgc' list.
-*/
-GCObject *luaC_newobjdt (lua_State *L, int tt, size_t sz, size_t offset) {
-  global_State *g = G(L);
-  char *p = cast_charp(luaM_newobject(L, novariant(tt), sz));
-  GCObject *o = cast(GCObject *, p + offset);
-  o->marked = luaC_white(g);
-  o->tt = tt;
-  o->next = g->allgc;
-  g->allgc = o;
-  return o;
-}
-
-
-GCObject *luaC_newobj (lua_State *L, int tt, size_t sz) {
-  return luaC_newobjdt(L, tt, sz, 0);
-}
-
-/* }====================================================== */
-
-
-
-/*
-** {======================================================
-** Mark functions
-** =======================================================
-*/
-
-
-/*
-** Mark an object.  Userdata with no user values, strings, and closed
-** upvalues are visited and turned black here.  Open upvalues are
-** already indirectly linked through their respective threads in the
-** 'twups' list, so they don't go to the gray list; nevertheless, they
-** are kept gray to avoid barriers, as their values will be revisited
-** by the thread or by 'remarkupvals'.  Other objects are added to the
-** gray list to be visited (and turned black) later.  Both userdata and
-** upvalues can call this function recursively, but this recursion goes
-** for at most two levels: An upvalue cannot refer to another upvalue
-** (only closures can), and a userdata's metatable must be a table.
-*/
-static void reallymarkobject (global_State *g, GCObject *o) {
-  switch (o->tt) {
-    case LUA_VSHRSTR:
-    case LUA_VLNGSTR: {
-      set2black(o);  /* nothing to visit */
-      break;
-    }
-    case LUA_VUPVAL: {
-      UpVal *uv = gco2upv(o);
-      if (upisopen(uv))
-        set2gray(uv);  /* open upvalues are kept gray */
-      else
-        set2black(uv);  /* closed upvalues are visited here */
-      markvalue(g, uv->v.p);  /* mark its content */
-      break;
-    }
-    case LUA_VUSERDATA: {
-      Udata *u = gco2u(o);
-      if (u->nuvalue == 0) {  /* no user values? */
-        markobjectN(g, u->metatable);  /* mark its metatable */
-        set2black(u);  /* nothing else to mark */
-        break;
-      }
-      /* else... */
-    }  /* FALLTHROUGH */
-    case LUA_VLCL: case LUA_VCCL: case LUA_VTABLE:
-    case LUA_VTHREAD: case LUA_VPROTO: {
-      linkobjgclist(o, g->gray);  /* to be visited later */
-      break;
-    }
-    default: lua_assert(0); break;
-  }
-}
-
-
-/*
-** mark metamethods for basic types
-*/
-static void markmt (global_State *g) {
-  int i;
-  for (i=0; i < LUA_NUMTAGS; i++)
-    markobjectN(g, g->mt[i]);
-}
-
-
-/*
-** mark all objects in list of being-finalized
-*/
-static lu_mem markbeingfnz (global_State *g) {
-  GCObject *o;
-  lu_mem count = 0;
-  for (o = g->tobefnz; o != NULL; o = o->next) {
-    count++;
-    markobject(g, o);
-  }
-  return count;
-}
-
-
-/*
-** For each non-marked thread, simulates a barrier between each open
-** upvalue and its value. (If the thread is collected, the value will be
-** assigned to the upvalue, but then it can be too late for the barrier
-** to act. The "barrier" does not need to check colors: A non-marked
-** thread must be young; upvalues cannot be older than their threads; so
-** any visited upvalue must be young too.) Also removes the thread from
-** the list, as it was already visited. Removes also threads with no
-** upvalues, as they have nothing to be checked. (If the thread gets an
-** upvalue later, it will be linked in the list again.)
-*/
-static int remarkupvals (global_State *g) {
-  lua_State *thread;
-  lua_State **p = &g->twups;
-  int work = 0;  /* estimate of how much work was done here */
-  while ((thread = *p) != NULL) {
-    work++;
-    if (!iswhite(thread) && thread->openupval != NULL)
-      p = &thread->twups;  /* keep marked thread with upvalues in the list */
-    else {  /* thread is not marked or without upvalues */
-      UpVal *uv;
-      lua_assert(!isold(thread) || thread->openupval == NULL);
-      *p = thread->twups;  /* remove thread from the list */
-      thread->twups = thread;  /* mark that it is out of list */
-      for (uv = thread->openupval; uv != NULL; uv = uv->u.open.next) {
-        lua_assert(getage(uv) <= getage(thread));
-        work++;
-        if (!iswhite(uv)) {  /* upvalue already visited? */
-          lua_assert(upisopen(uv) && isgray(uv));
-          markvalue(g, uv->v.p);  /* mark its value */
-        }
-      }
-    }
-  }
-  return work;
-}
-
-
-static void cleargraylists (global_State *g) {
-  g->gray = g->grayagain = NULL;
-  g->weak = g->allweak = g->ephemeron = NULL;
-}
-
-
-/*
-** mark root set and reset all gray lists, to start a new collection
-*/
-static void restartcollection (global_State *g) {
-  cleargraylists(g);
-  markobject(g, g->mainthread);
-  markvalue(g, &g->l_registry);
-  markmt(g);
-  markbeingfnz(g);  /* mark any finalizing object left from previous cycle */
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Traverse functions
-** =======================================================
-*/
-
-
-/*
-** Check whether object 'o' should be kept in the 'grayagain' list for
-** post-processing by 'correctgraylist'. (It could put all old objects
-** in the list and leave all the work to 'correctgraylist', but it is
-** more efficient to avoid adding elements that will be removed.) Only
-** TOUCHED1 objects need to be in the list. TOUCHED2 doesn't need to go
-** back to a gray list, but then it must become OLD. (That is what
-** 'correctgraylist' does when it finds a TOUCHED2 object.)
-*/
-static void genlink (global_State *g, GCObject *o) {
-  lua_assert(isblack(o));
-  if (getage(o) == G_TOUCHED1) {  /* touched in this cycle? */
-    linkobjgclist(o, g->grayagain);  /* link it back in 'grayagain' */
-  }  /* everything else do not need to be linked back */
-  else if (getage(o) == G_TOUCHED2)
-    changeage(o, G_TOUCHED2, G_OLD);  /* advance age */
-}
-
-
-/*
-** Traverse a table with weak values and link it to proper list. During
-** propagate phase, keep it in 'grayagain' list, to be revisited in the
-** atomic phase. In the atomic phase, if table has any white value,
-** put it in 'weak' list, to be cleared.
-*/
-static void traverseweakvalue (global_State *g, Table *h) {
-  Node *n, *limit = gnodelast(h);
-  /* if there is array part, assume it may have white values (it is not
-     worth traversing it now just to check) */
-  int hasclears = (h->alimit > 0);
-  for (n = gnode(h, 0); n < limit; n++) {  /* traverse hash part */
-    if (isempty(gval(n)))  /* entry is empty? */
-      clearkey(n);  /* clear its key */
-    else {
-      lua_assert(!keyisnil(n));
-      markkey(g, n);
-      if (!hasclears && iscleared(g, gcvalueN(gval(n))))  /* a white value? */
-        hasclears = 1;  /* table will have to be cleared */
-    }
-  }
-  if (g->gcstate == GCSatomic && hasclears)
-    linkgclist(h, g->weak);  /* has to be cleared later */
-  else
-    linkgclist(h, g->grayagain);  /* must retraverse it in atomic phase */
-}
-
-
-/*
-** Traverse an ephemeron table and link it to proper list. Returns true
-** iff any object was marked during this traversal (which implies that
-** convergence has to continue). During propagation phase, keep table
-** in 'grayagain' list, to be visited again in the atomic phase. In
-** the atomic phase, if table has any white->white entry, it has to
-** be revisited during ephemeron convergence (as that key may turn
-** black). Otherwise, if it has any white key, table has to be cleared
-** (in the atomic phase). In generational mode, some tables
-** must be kept in some gray list for post-processing; this is done
-** by 'genlink'.
-*/
-static int traverseephemeron (global_State *g, Table *h, int inv) {
-  int marked = 0;  /* true if an object is marked in this traversal */
-  int hasclears = 0;  /* true if table has white keys */
-  int hasww = 0;  /* true if table has entry "white-key -> white-value" */
-  unsigned int i;
-  unsigned int asize = luaH_realasize(h);
-  unsigned int nsize = sizenode(h);
-  /* traverse array part */
-  for (i = 0; i < asize; i++) {
-    if (valiswhite(&h->array[i])) {
-      marked = 1;
-      reallymarkobject(g, gcvalue(&h->array[i]));
-    }
-  }
-  /* traverse hash part; if 'inv', traverse descending
-     (see 'convergeephemerons') */
-  for (i = 0; i < nsize; i++) {
-    Node *n = inv ? gnode(h, nsize - 1 - i) : gnode(h, i);
-    if (isempty(gval(n)))  /* entry is empty? */
-      clearkey(n);  /* clear its key */
-    else if (iscleared(g, gckeyN(n))) {  /* key is not marked (yet)? */
-      hasclears = 1;  /* table must be cleared */
-      if (valiswhite(gval(n)))  /* value not marked yet? */
-        hasww = 1;  /* white-white entry */
-    }
-    else if (valiswhite(gval(n))) {  /* value not marked yet? */
-      marked = 1;
-      reallymarkobject(g, gcvalue(gval(n)));  /* mark it now */
-    }
-  }
-  /* link table into proper list */
-  if (g->gcstate == GCSpropagate)
-    linkgclist(h, g->grayagain);  /* must retraverse it in atomic phase */
-  else if (hasww)  /* table has white->white entries? */
-    linkgclist(h, g->ephemeron);  /* have to propagate again */
-  else if (hasclears)  /* table has white keys? */
-    linkgclist(h, g->allweak);  /* may have to clean white keys */
-  else
-    genlink(g, obj2gco(h));  /* check whether collector still needs to see it */
-  return marked;
-}
-
-
-static void traversestrongtable (global_State *g, Table *h) {
-  Node *n, *limit = gnodelast(h);
-  unsigned int i;
-  unsigned int asize = luaH_realasize(h);
-  for (i = 0; i < asize; i++)  /* traverse array part */
-    markvalue(g, &h->array[i]);
-  for (n = gnode(h, 0); n < limit; n++) {  /* traverse hash part */
-    if (isempty(gval(n)))  /* entry is empty? */
-      clearkey(n);  /* clear its key */
-    else {
-      lua_assert(!keyisnil(n));
-      markkey(g, n);
-      markvalue(g, gval(n));
-    }
-  }
-  genlink(g, obj2gco(h));
-}
-
-
-static lu_mem traversetable (global_State *g, Table *h) {
-  const char *weakkey, *weakvalue;
-  const TValue *mode = gfasttm(g, h->metatable, TM_MODE);
-  markobjectN(g, h->metatable);
-  if (mode && ttisstring(mode) &&  /* is there a weak mode? */
-      (cast_void(weakkey = strchr(svalue(mode), 'k')),
-       cast_void(weakvalue = strchr(svalue(mode), 'v')),
-       (weakkey || weakvalue))) {  /* is really weak? */
-    if (!weakkey)  /* strong keys? */
-      traverseweakvalue(g, h);
-    else if (!weakvalue)  /* strong values? */
-      traverseephemeron(g, h, 0);
-    else  /* all weak */
-      linkgclist(h, g->allweak);  /* nothing to traverse now */
-  }
-  else  /* not weak */
-    traversestrongtable(g, h);
-  return 1 + h->alimit + 2 * allocsizenode(h);
-}
-
-
-static int traverseudata (global_State *g, Udata *u) {
-  int i;
-  markobjectN(g, u->metatable);  /* mark its metatable */
-  for (i = 0; i < u->nuvalue; i++)
-    markvalue(g, &u->uv[i].uv);
-  genlink(g, obj2gco(u));
-  return 1 + u->nuvalue;
-}
-
-
-/*
-** Traverse a prototype. (While a prototype is being build, its
-** arrays can be larger than needed; the extra slots are filled with
-** NULL, so the use of 'markobjectN')
-*/
-static int traverseproto (global_State *g, Proto *f) {
-  int i;
-  markobjectN(g, f->source);
-  for (i = 0; i < f->sizek; i++)  /* mark literals */
-    markvalue(g, &f->k[i]);
-  for (i = 0; i < f->sizeupvalues; i++)  /* mark upvalue names */
-    markobjectN(g, f->upvalues[i].name);
-  for (i = 0; i < f->sizep; i++)  /* mark nested protos */
-    markobjectN(g, f->p[i]);
-  for (i = 0; i < f->sizelocvars; i++)  /* mark local-variable names */
-    markobjectN(g, f->locvars[i].varname);
-  return 1 + f->sizek + f->sizeupvalues + f->sizep + f->sizelocvars;
-}
-
-
-static int traverseCclosure (global_State *g, CClosure *cl) {
-  int i;
-  for (i = 0; i < cl->nupvalues; i++)  /* mark its upvalues */
-    markvalue(g, &cl->upvalue[i]);
-  return 1 + cl->nupvalues;
-}
-
-/*
-** Traverse a Lua closure, marking its prototype and its upvalues.
-** (Both can be NULL while closure is being created.)
-*/
-static int traverseLclosure (global_State *g, LClosure *cl) {
-  int i;
-  markobjectN(g, cl->p);  /* mark its prototype */
-  for (i = 0; i < cl->nupvalues; i++) {  /* visit its upvalues */
-    UpVal *uv = cl->upvals[i];
-    markobjectN(g, uv);  /* mark upvalue */
-  }
-  return 1 + cl->nupvalues;
-}
-
-
-/*
-** Traverse a thread, marking the elements in the stack up to its top
-** and cleaning the rest of the stack in the final traversal. That
-** ensures that the entire stack have valid (non-dead) objects.
-** Threads have no barriers. In gen. mode, old threads must be visited
-** at every cycle, because they might point to young objects.  In inc.
-** mode, the thread can still be modified before the end of the cycle,
-** and therefore it must be visited again in the atomic phase. To ensure
-** these visits, threads must return to a gray list if they are not new
-** (which can only happen in generational mode) or if the traverse is in
-** the propagate phase (which can only happen in incremental mode).
-*/
-static int traversethread (global_State *g, lua_State *th) {
-  UpVal *uv;
-  StkId o = th->stack.p;
-  if (isold(th) || g->gcstate == GCSpropagate)
-    linkgclist(th, g->grayagain);  /* insert into 'grayagain' list */
-  if (o == NULL)
-    return 1;  /* stack not completely built yet */
-  lua_assert(g->gcstate == GCSatomic ||
-             th->openupval == NULL || isintwups(th));
-  for (; o < th->top.p; o++)  /* mark live elements in the stack */
-    markvalue(g, s2v(o));
-  for (uv = th->openupval; uv != NULL; uv = uv->u.open.next)
-    markobject(g, uv);  /* open upvalues cannot be collected */
-  if (g->gcstate == GCSatomic) {  /* final traversal? */
-    for (; o < th->stack_last.p + EXTRA_STACK; o++)
-      setnilvalue(s2v(o));  /* clear dead stack slice */
-    /* 'remarkupvals' may have removed thread from 'twups' list */
-    if (!isintwups(th) && th->openupval != NULL) {
-      th->twups = g->twups;  /* link it back to the list */
-      g->twups = th;
-    }
-  }
-  else if (!g->gcemergency)
-    luaD_shrinkstack(th); /* do not change stack in emergency cycle */
-  return 1 + stacksize(th);
-}
-
-
-/*
-** traverse one gray object, turning it to black.
-*/
-static lu_mem propagatemark (global_State *g) {
-  GCObject *o = g->gray;
-  nw2black(o);
-  g->gray = *getgclist(o);  /* remove from 'gray' list */
-  switch (o->tt) {
-    case LUA_VTABLE: return traversetable(g, gco2t(o));
-    case LUA_VUSERDATA: return traverseudata(g, gco2u(o));
-    case LUA_VLCL: return traverseLclosure(g, gco2lcl(o));
-    case LUA_VCCL: return traverseCclosure(g, gco2ccl(o));
-    case LUA_VPROTO: return traverseproto(g, gco2p(o));
-    case LUA_VTHREAD: return traversethread(g, gco2th(o));
-    default: lua_assert(0); return 0;
-  }
-}
-
-
-static lu_mem propagateall (global_State *g) {
-  lu_mem tot = 0;
-  while (g->gray)
-    tot += propagatemark(g);
-  return tot;
-}
-
-
-/*
-** Traverse all ephemeron tables propagating marks from keys to values.
-** Repeat until it converges, that is, nothing new is marked. 'dir'
-** inverts the direction of the traversals, trying to speed up
-** convergence on chains in the same table.
-**
-*/
-static void convergeephemerons (global_State *g) {
-  int changed;
-  int dir = 0;
-  do {
-    GCObject *w;
-    GCObject *next = g->ephemeron;  /* get ephemeron list */
-    g->ephemeron = NULL;  /* tables may return to this list when traversed */
-    changed = 0;
-    while ((w = next) != NULL) {  /* for each ephemeron table */
-      Table *h = gco2t(w);
-      next = h->gclist;  /* list is rebuilt during loop */
-      nw2black(h);  /* out of the list (for now) */
-      if (traverseephemeron(g, h, dir)) {  /* marked some value? */
-        propagateall(g);  /* propagate changes */
-        changed = 1;  /* will have to revisit all ephemeron tables */
-      }
-    }
-    dir = !dir;  /* invert direction next time */
-  } while (changed);  /* repeat until no more changes */
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Sweep Functions
-** =======================================================
-*/
-
-
-/*
-** clear entries with unmarked keys from all weaktables in list 'l'
-*/
-static void clearbykeys (global_State *g, GCObject *l) {
-  for (; l; l = gco2t(l)->gclist) {
-    Table *h = gco2t(l);
-    Node *limit = gnodelast(h);
-    Node *n;
-    for (n = gnode(h, 0); n < limit; n++) {
-      if (iscleared(g, gckeyN(n)))  /* unmarked key? */
-        setempty(gval(n));  /* remove entry */
-      if (isempty(gval(n)))  /* is entry empty? */
-        clearkey(n);  /* clear its key */
-    }
-  }
-}
-
-
-/*
-** clear entries with unmarked values from all weaktables in list 'l' up
-** to element 'f'
-*/
-static void clearbyvalues (global_State *g, GCObject *l, GCObject *f) {
-  for (; l != f; l = gco2t(l)->gclist) {
-    Table *h = gco2t(l);
-    Node *n, *limit = gnodelast(h);
-    unsigned int i;
-    unsigned int asize = luaH_realasize(h);
-    for (i = 0; i < asize; i++) {
-      TValue *o = &h->array[i];
-      if (iscleared(g, gcvalueN(o)))  /* value was collected? */
-        setempty(o);  /* remove entry */
-    }
-    for (n = gnode(h, 0); n < limit; n++) {
-      if (iscleared(g, gcvalueN(gval(n))))  /* unmarked value? */
-        setempty(gval(n));  /* remove entry */
-      if (isempty(gval(n)))  /* is entry empty? */
-        clearkey(n);  /* clear its key */
-    }
-  }
-}
-
-
-static void freeupval (lua_State *L, UpVal *uv) {
-  if (upisopen(uv))
-    luaF_unlinkupval(uv);
-  luaM_free(L, uv);
-}
-
-
-static void freeobj (lua_State *L, GCObject *o) {
-  switch (o->tt) {
-    case LUA_VPROTO:
-      luaF_freeproto(L, gco2p(o));
-      break;
-    case LUA_VUPVAL:
-      freeupval(L, gco2upv(o));
-      break;
-    case LUA_VLCL: {
-      LClosure *cl = gco2lcl(o);
-      luaM_freemem(L, cl, sizeLclosure(cl->nupvalues));
-      break;
-    }
-    case LUA_VCCL: {
-      CClosure *cl = gco2ccl(o);
-      luaM_freemem(L, cl, sizeCclosure(cl->nupvalues));
-      break;
-    }
-    case LUA_VTABLE:
-      luaH_free(L, gco2t(o));
-      break;
-    case LUA_VTHREAD:
-      luaE_freethread(L, gco2th(o));
-      break;
-    case LUA_VUSERDATA: {
-      Udata *u = gco2u(o);
-      luaM_freemem(L, o, sizeudata(u->nuvalue, u->len));
-      break;
-    }
-    case LUA_VSHRSTR: {
-      TString *ts = gco2ts(o);
-      luaS_remove(L, ts);  /* remove it from hash table */
-      luaM_freemem(L, ts, sizelstring(ts->shrlen));
-      break;
-    }
-    case LUA_VLNGSTR: {
-      TString *ts = gco2ts(o);
-      luaM_freemem(L, ts, sizelstring(ts->u.lnglen));
-      break;
-    }
-    default: lua_assert(0);
-  }
-}
-
-
-/*
-** sweep at most 'countin' elements from a list of GCObjects erasing dead
-** objects, where a dead object is one marked with the old (non current)
-** white; change all non-dead objects back to white, preparing for next
-** collection cycle. Return where to continue the traversal or NULL if
-** list is finished. ('*countout' gets the number of elements traversed.)
-*/
-static GCObject **sweeplist (lua_State *L, GCObject **p, int countin,
-                             int *countout) {
-  global_State *g = G(L);
-  int ow = otherwhite(g);
-  int i;
-  int white = luaC_white(g);  /* current white */
-  for (i = 0; *p != NULL && i < countin; i++) {
-    GCObject *curr = *p;
-    int marked = curr->marked;
-    if (isdeadm(ow, marked)) {  /* is 'curr' dead? */
-      *p = curr->next;  /* remove 'curr' from list */
-      freeobj(L, curr);  /* erase 'curr' */
-    }
-    else {  /* change mark to 'white' */
-      curr->marked = cast_byte((marked & ~maskgcbits) | white);
-      p = &curr->next;  /* go to next element */
-    }
-  }
-  if (countout)
-    *countout = i;  /* number of elements traversed */
-  return (*p == NULL) ? NULL : p;
-}
-
-
-/*
-** sweep a list until a live object (or end of list)
-*/
-static GCObject **sweeptolive (lua_State *L, GCObject **p) {
-  GCObject **old = p;
-  do {
-    p = sweeplist(L, p, 1, NULL);
-  } while (p == old);
-  return p;
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Finalization
-** =======================================================
-*/
-
-/*
-** If possible, shrink string table.
-*/
-static void checkSizes (lua_State *L, global_State *g) {
-  if (!g->gcemergency) {
-    if (g->strt.nuse < g->strt.size / 4) {  /* string table too big? */
-      l_mem olddebt = g->GCdebt;
-      luaS_resize(L, g->strt.size / 2);
-      g->GCestimate += g->GCdebt - olddebt;  /* correct estimate */
-    }
-  }
-}
-
-
-/*
-** Get the next udata to be finalized from the 'tobefnz' list, and
-** link it back into the 'allgc' list.
-*/
-static GCObject *udata2finalize (global_State *g) {
-  GCObject *o = g->tobefnz;  /* get first element */
-  lua_assert(tofinalize(o));
-  g->tobefnz = o->next;  /* remove it from 'tobefnz' list */
-  o->next = g->allgc;  /* return it to 'allgc' list */
-  g->allgc = o;
-  resetbit(o->marked, FINALIZEDBIT);  /* object is "normal" again */
-  if (issweepphase(g))
-    makewhite(g, o);  /* "sweep" object */
-  else if (getage(o) == G_OLD1)
-    g->firstold1 = o;  /* it is the first OLD1 object in the list */
-  return o;
-}
-
-
-static void dothecall (lua_State *L, void *ud) {
-  UNUSED(ud);
-  luaD_callnoyield(L, L->top.p - 2, 0);
-}
-
-
-static void GCTM (lua_State *L) {
-  global_State *g = G(L);
-  const TValue *tm;
-  TValue v;
-  lua_assert(!g->gcemergency);
-  setgcovalue(L, &v, udata2finalize(g));
-  tm = luaT_gettmbyobj(L, &v, TM_GC);
-  if (!notm(tm)) {  /* is there a finalizer? */
-    int status;
-    lu_byte oldah = L->allowhook;
-    int oldgcstp  = g->gcstp;
-    g->gcstp |= GCSTPGC;  /* avoid GC steps */
-    L->allowhook = 0;  /* stop debug hooks during GC metamethod */
-    setobj2s(L, L->top.p++, tm);  /* push finalizer... */
-    setobj2s(L, L->top.p++, &v);  /* ... and its argument */
-    L->ci->callstatus |= CIST_FIN;  /* will run a finalizer */
-    status = luaD_pcall(L, dothecall, NULL, savestack(L, L->top.p - 2), 0);
-    L->ci->callstatus &= ~CIST_FIN;  /* not running a finalizer anymore */
-    L->allowhook = oldah;  /* restore hooks */
-    g->gcstp = oldgcstp;  /* restore state */
-    if (l_unlikely(status != LUA_OK)) {  /* error while running __gc? */
-      luaE_warnerror(L, "__gc");
-      L->top.p--;  /* pops error object */
-    }
-  }
-}
-
-
-/*
-** Call a few finalizers
-*/
-static int runafewfinalizers (lua_State *L, int n) {
-  global_State *g = G(L);
-  int i;
-  for (i = 0; i < n && g->tobefnz; i++)
-    GCTM(L);  /* call one finalizer */
-  return i;
-}
-
-
-/*
-** call all pending finalizers
-*/
-static void callallpendingfinalizers (lua_State *L) {
-  global_State *g = G(L);
-  while (g->tobefnz)
-    GCTM(L);
-}
-
-
-/*
-** find last 'next' field in list 'p' list (to add elements in its end)
-*/
-static GCObject **findlast (GCObject **p) {
-  while (*p != NULL)
-    p = &(*p)->next;
-  return p;
-}
-
-
-/*
-** Move all unreachable objects (or 'all' objects) that need
-** finalization from list 'finobj' to list 'tobefnz' (to be finalized).
-** (Note that objects after 'finobjold1' cannot be white, so they
-** don't need to be traversed. In incremental mode, 'finobjold1' is NULL,
-** so the whole list is traversed.)
-*/
-static void separatetobefnz (global_State *g, int all) {
-  GCObject *curr;
-  GCObject **p = &g->finobj;
-  GCObject **lastnext = findlast(&g->tobefnz);
-  while ((curr = *p) != g->finobjold1) {  /* traverse all finalizable objects */
-    lua_assert(tofinalize(curr));
-    if (!(iswhite(curr) || all))  /* not being collected? */
-      p = &curr->next;  /* don't bother with it */
-    else {
-      if (curr == g->finobjsur)  /* removing 'finobjsur'? */
-        g->finobjsur = curr->next;  /* correct it */
-      *p = curr->next;  /* remove 'curr' from 'finobj' list */
-      curr->next = *lastnext;  /* link at the end of 'tobefnz' list */
-      *lastnext = curr;
-      lastnext = &curr->next;
-    }
-  }
-}
-
-
-/*
-** If pointer 'p' points to 'o', move it to the next element.
-*/
-static void checkpointer (GCObject **p, GCObject *o) {
-  if (o == *p)
-    *p = o->next;
-}
-
-
-/*
-** Correct pointers to objects inside 'allgc' list when
-** object 'o' is being removed from the list.
-*/
-static void correctpointers (global_State *g, GCObject *o) {
-  checkpointer(&g->survival, o);
-  checkpointer(&g->old1, o);
-  checkpointer(&g->reallyold, o);
-  checkpointer(&g->firstold1, o);
-}
-
-
-/*
-** if object 'o' has a finalizer, remove it from 'allgc' list (must
-** search the list to find it) and link it in 'finobj' list.
-*/
-void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) {
-  global_State *g = G(L);
-  if (tofinalize(o) ||                 /* obj. is already marked... */
-      gfasttm(g, mt, TM_GC) == NULL ||    /* or has no finalizer... */
-      (g->gcstp & GCSTPCLS))                   /* or closing state? */
-    return;  /* nothing to be done */
-  else {  /* move 'o' to 'finobj' list */
-    GCObject **p;
-    if (issweepphase(g)) {
-      makewhite(g, o);  /* "sweep" object 'o' */
-      if (g->sweepgc == &o->next)  /* should not remove 'sweepgc' object */
-        g->sweepgc = sweeptolive(L, g->sweepgc);  /* change 'sweepgc' */
-    }
-    else
-      correctpointers(g, o);
-    /* search for pointer pointing to 'o' */
-    for (p = &g->allgc; *p != o; p = &(*p)->next) { /* empty */ }
-    *p = o->next;  /* remove 'o' from 'allgc' list */
-    o->next = g->finobj;  /* link it in 'finobj' list */
-    g->finobj = o;
-    l_setbit(o->marked, FINALIZEDBIT);  /* mark it as such */
-  }
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Generational Collector
-** =======================================================
-*/
-
-
-/*
-** Set the "time" to wait before starting a new GC cycle; cycle will
-** start when memory use hits the threshold of ('estimate' * pause /
-** PAUSEADJ). (Division by 'estimate' should be OK: it cannot be zero,
-** because Lua cannot even start with less than PAUSEADJ bytes).
-*/
-static void setpause (global_State *g) {
-  l_mem threshold, debt;
-  int pause = getgcparam(g->gcpause);
-  l_mem estimate = g->GCestimate / PAUSEADJ;  /* adjust 'estimate' */
-  lua_assert(estimate > 0);
-  threshold = (pause < MAX_LMEM / estimate)  /* overflow? */
-            ? estimate * pause  /* no overflow */
-            : MAX_LMEM;  /* overflow; truncate to maximum */
-  debt = gettotalbytes(g) - threshold;
-  if (debt > 0) debt = 0;
-  luaE_setdebt(g, debt);
-}
-
-
-/*
-** Sweep a list of objects to enter generational mode.  Deletes dead
-** objects and turns the non dead to old. All non-dead threads---which
-** are now old---must be in a gray list. Everything else is not in a
-** gray list. Open upvalues are also kept gray.
-*/
-static void sweep2old (lua_State *L, GCObject **p) {
-  GCObject *curr;
-  global_State *g = G(L);
-  while ((curr = *p) != NULL) {
-    if (iswhite(curr)) {  /* is 'curr' dead? */
-      lua_assert(isdead(g, curr));
-      *p = curr->next;  /* remove 'curr' from list */
-      freeobj(L, curr);  /* erase 'curr' */
-    }
-    else {  /* all surviving objects become old */
-      setage(curr, G_OLD);
-      if (curr->tt == LUA_VTHREAD) {  /* threads must be watched */
-        lua_State *th = gco2th(curr);
-        linkgclist(th, g->grayagain);  /* insert into 'grayagain' list */
-      }
-      else if (curr->tt == LUA_VUPVAL && upisopen(gco2upv(curr)))
-        set2gray(curr);  /* open upvalues are always gray */
-      else  /* everything else is black */
-        nw2black(curr);
-      p = &curr->next;  /* go to next element */
-    }
-  }
-}
-
-
-/*
-** Sweep for generational mode. Delete dead objects. (Because the
-** collection is not incremental, there are no "new white" objects
-** during the sweep. So, any white object must be dead.) For
-** non-dead objects, advance their ages and clear the color of
-** new objects. (Old objects keep their colors.)
-** The ages of G_TOUCHED1 and G_TOUCHED2 objects cannot be advanced
-** here, because these old-generation objects are usually not swept
-** here.  They will all be advanced in 'correctgraylist'. That function
-** will also remove objects turned white here from any gray list.
-*/
-static GCObject **sweepgen (lua_State *L, global_State *g, GCObject **p,
-                            GCObject *limit, GCObject **pfirstold1) {
-  static const lu_byte nextage[] = {
-    G_SURVIVAL,  /* from G_NEW */
-    G_OLD1,      /* from G_SURVIVAL */
-    G_OLD1,      /* from G_OLD0 */
-    G_OLD,       /* from G_OLD1 */
-    G_OLD,       /* from G_OLD (do not change) */
-    G_TOUCHED1,  /* from G_TOUCHED1 (do not change) */
-    G_TOUCHED2   /* from G_TOUCHED2 (do not change) */
-  };
-  int white = luaC_white(g);
-  GCObject *curr;
-  while ((curr = *p) != limit) {
-    if (iswhite(curr)) {  /* is 'curr' dead? */
-      lua_assert(!isold(curr) && isdead(g, curr));
-      *p = curr->next;  /* remove 'curr' from list */
-      freeobj(L, curr);  /* erase 'curr' */
-    }
-    else {  /* correct mark and age */
-      if (getage(curr) == G_NEW) {  /* new objects go back to white */
-        int marked = curr->marked & ~maskgcbits;  /* erase GC bits */
-        curr->marked = cast_byte(marked | G_SURVIVAL | white);
-      }
-      else {  /* all other objects will be old, and so keep their color */
-        setage(curr, nextage[getage(curr)]);
-        if (getage(curr) == G_OLD1 && *pfirstold1 == NULL)
-          *pfirstold1 = curr;  /* first OLD1 object in the list */
-      }
-      p = &curr->next;  /* go to next element */
-    }
-  }
-  return p;
-}
-
-
-/*
-** Traverse a list making all its elements white and clearing their
-** age. In incremental mode, all objects are 'new' all the time,
-** except for fixed strings (which are always old).
-*/
-static void whitelist (global_State *g, GCObject *p) {
-  int white = luaC_white(g);
-  for (; p != NULL; p = p->next)
-    p->marked = cast_byte((p->marked & ~maskgcbits) | white);
-}
-
-
-/*
-** Correct a list of gray objects. Return pointer to where rest of the
-** list should be linked.
-** Because this correction is done after sweeping, young objects might
-** be turned white and still be in the list. They are only removed.
-** 'TOUCHED1' objects are advanced to 'TOUCHED2' and remain on the list;
-** Non-white threads also remain on the list; 'TOUCHED2' objects become
-** regular old; they and anything else are removed from the list.
-*/
-static GCObject **correctgraylist (GCObject **p) {
-  GCObject *curr;
-  while ((curr = *p) != NULL) {
-    GCObject **next = getgclist(curr);
-    if (iswhite(curr))
-      goto remove;  /* remove all white objects */
-    else if (getage(curr) == G_TOUCHED1) {  /* touched in this cycle? */
-      lua_assert(isgray(curr));
-      nw2black(curr);  /* make it black, for next barrier */
-      changeage(curr, G_TOUCHED1, G_TOUCHED2);
-      goto remain;  /* keep it in the list and go to next element */
-    }
-    else if (curr->tt == LUA_VTHREAD) {
-      lua_assert(isgray(curr));
-      goto remain;  /* keep non-white threads on the list */
-    }
-    else {  /* everything else is removed */
-      lua_assert(isold(curr));  /* young objects should be white here */
-      if (getage(curr) == G_TOUCHED2)  /* advance from TOUCHED2... */
-        changeage(curr, G_TOUCHED2, G_OLD);  /* ... to OLD */
-      nw2black(curr);  /* make object black (to be removed) */
-      goto remove;
-    }
-    remove: *p = *next; continue;
-    remain: p = next; continue;
-  }
-  return p;
-}
-
-
-/*
-** Correct all gray lists, coalescing them into 'grayagain'.
-*/
-static void correctgraylists (global_State *g) {
-  GCObject **list = correctgraylist(&g->grayagain);
-  *list = g->weak; g->weak = NULL;
-  list = correctgraylist(list);
-  *list = g->allweak; g->allweak = NULL;
-  list = correctgraylist(list);
-  *list = g->ephemeron; g->ephemeron = NULL;
-  correctgraylist(list);
-}
-
-
-/*
-** Mark black 'OLD1' objects when starting a new young collection.
-** Gray objects are already in some gray list, and so will be visited
-** in the atomic step.
-*/
-static void markold (global_State *g, GCObject *from, GCObject *to) {
-  GCObject *p;
-  for (p = from; p != to; p = p->next) {
-    if (getage(p) == G_OLD1) {
-      lua_assert(!iswhite(p));
-      changeage(p, G_OLD1, G_OLD);  /* now they are old */
-      if (isblack(p))
-        reallymarkobject(g, p);
-    }
-  }
-}
-
-
-/*
-** Finish a young-generation collection.
-*/
-static void finishgencycle (lua_State *L, global_State *g) {
-  correctgraylists(g);
-  checkSizes(L, g);
-  g->gcstate = GCSpropagate;  /* skip restart */
-  if (!g->gcemergency)
-    callallpendingfinalizers(L);
-}
-
-
-/*
-** Does a young collection. First, mark 'OLD1' objects. Then does the
-** atomic step. Then, sweep all lists and advance pointers. Finally,
-** finish the collection.
-*/
-static void youngcollection (lua_State *L, global_State *g) {
-  GCObject **psurvival;  /* to point to first non-dead survival object */
-  GCObject *dummy;  /* dummy out parameter to 'sweepgen' */
-  lua_assert(g->gcstate == GCSpropagate);
-  if (g->firstold1) {  /* are there regular OLD1 objects? */
-    markold(g, g->firstold1, g->reallyold);  /* mark them */
-    g->firstold1 = NULL;  /* no more OLD1 objects (for now) */
-  }
-  markold(g, g->finobj, g->finobjrold);
-  markold(g, g->tobefnz, NULL);
-  atomic(L);
-
-  /* sweep nursery and get a pointer to its last live element */
-  g->gcstate = GCSswpallgc;
-  psurvival = sweepgen(L, g, &g->allgc, g->survival, &g->firstold1);
-  /* sweep 'survival' */
-  sweepgen(L, g, psurvival, g->old1, &g->firstold1);
-  g->reallyold = g->old1;
-  g->old1 = *psurvival;  /* 'survival' survivals are old now */
-  g->survival = g->allgc;  /* all news are survivals */
-
-  /* repeat for 'finobj' lists */
-  dummy = NULL;  /* no 'firstold1' optimization for 'finobj' lists */
-  psurvival = sweepgen(L, g, &g->finobj, g->finobjsur, &dummy);
-  /* sweep 'survival' */
-  sweepgen(L, g, psurvival, g->finobjold1, &dummy);
-  g->finobjrold = g->finobjold1;
-  g->finobjold1 = *psurvival;  /* 'survival' survivals are old now */
-  g->finobjsur = g->finobj;  /* all news are survivals */
-
-  sweepgen(L, g, &g->tobefnz, NULL, &dummy);
-  finishgencycle(L, g);
-}
-
-
-/*
-** Clears all gray lists, sweeps objects, and prepare sublists to enter
-** generational mode. The sweeps remove dead objects and turn all
-** surviving objects to old. Threads go back to 'grayagain'; everything
-** else is turned black (not in any gray list).
-*/
-static void atomic2gen (lua_State *L, global_State *g) {
-  cleargraylists(g);
-  /* sweep all elements making them old */
-  g->gcstate = GCSswpallgc;
-  sweep2old(L, &g->allgc);
-  /* everything alive now is old */
-  g->reallyold = g->old1 = g->survival = g->allgc;
-  g->firstold1 = NULL;  /* there are no OLD1 objects anywhere */
-
-  /* repeat for 'finobj' lists */
-  sweep2old(L, &g->finobj);
-  g->finobjrold = g->finobjold1 = g->finobjsur = g->finobj;
-
-  sweep2old(L, &g->tobefnz);
-
-  g->gckind = KGC_GEN;
-  g->lastatomic = 0;
-  g->GCestimate = gettotalbytes(g);  /* base for memory control */
-  finishgencycle(L, g);
-}
-
-
-/*
-** Set debt for the next minor collection, which will happen when
-** memory grows 'genminormul'%.
-*/
-static void setminordebt (global_State *g) {
-  luaE_setdebt(g, -(cast(l_mem, (gettotalbytes(g) / 100)) * g->genminormul));
-}
-
-
-/*
-** Enter generational mode. Must go until the end of an atomic cycle
-** to ensure that all objects are correctly marked and weak tables
-** are cleared. Then, turn all objects into old and finishes the
-** collection.
-*/
-static lu_mem entergen (lua_State *L, global_State *g) {
-  lu_mem numobjs;
-  luaC_runtilstate(L, bitmask(GCSpause));  /* prepare to start a new cycle */
-  luaC_runtilstate(L, bitmask(GCSpropagate));  /* start new cycle */
-  numobjs = atomic(L);  /* propagates all and then do the atomic stuff */
-  atomic2gen(L, g);
-  setminordebt(g);  /* set debt assuming next cycle will be minor */
-  return numobjs;
-}
-
-
-/*
-** Enter incremental mode. Turn all objects white, make all
-** intermediate lists point to NULL (to avoid invalid pointers),
-** and go to the pause state.
-*/
-static void enterinc (global_State *g) {
-  whitelist(g, g->allgc);
-  g->reallyold = g->old1 = g->survival = NULL;
-  whitelist(g, g->finobj);
-  whitelist(g, g->tobefnz);
-  g->finobjrold = g->finobjold1 = g->finobjsur = NULL;
-  g->gcstate = GCSpause;
-  g->gckind = KGC_INC;
-  g->lastatomic = 0;
-}
-
-
-/*
-** Change collector mode to 'newmode'.
-*/
-void luaC_changemode (lua_State *L, int newmode) {
-  global_State *g = G(L);
-  if (newmode != g->gckind) {
-    if (newmode == KGC_GEN)  /* entering generational mode? */
-      entergen(L, g);
-    else
-      enterinc(g);  /* entering incremental mode */
-  }
-  g->lastatomic = 0;
-}
-
-
-/*
-** Does a full collection in generational mode.
-*/
-static lu_mem fullgen (lua_State *L, global_State *g) {
-  enterinc(g);
-  return entergen(L, g);
-}
-
-
-/*
-** Does a major collection after last collection was a "bad collection".
-**
-** When the program is building a big structure, it allocates lots of
-** memory but generates very little garbage. In those scenarios,
-** the generational mode just wastes time doing small collections, and
-** major collections are frequently what we call a "bad collection", a
-** collection that frees too few objects. To avoid the cost of switching
-** between generational mode and the incremental mode needed for full
-** (major) collections, the collector tries to stay in incremental mode
-** after a bad collection, and to switch back to generational mode only
-** after a "good" collection (one that traverses less than 9/8 objects
-** of the previous one).
-** The collector must choose whether to stay in incremental mode or to
-** switch back to generational mode before sweeping. At this point, it
-** does not know the real memory in use, so it cannot use memory to
-** decide whether to return to generational mode. Instead, it uses the
-** number of objects traversed (returned by 'atomic') as a proxy. The
-** field 'g->lastatomic' keeps this count from the last collection.
-** ('g->lastatomic != 0' also means that the last collection was bad.)
-*/
-static void stepgenfull (lua_State *L, global_State *g) {
-  lu_mem newatomic;  /* count of traversed objects */
-  lu_mem lastatomic = g->lastatomic;  /* count from last collection */
-  if (g->gckind == KGC_GEN)  /* still in generational mode? */
-    enterinc(g);  /* enter incremental mode */
-  luaC_runtilstate(L, bitmask(GCSpropagate));  /* start new cycle */
-  newatomic = atomic(L);  /* mark everybody */
-  if (newatomic < lastatomic + (lastatomic >> 3)) {  /* good collection? */
-    atomic2gen(L, g);  /* return to generational mode */
-    setminordebt(g);
-  }
-  else {  /* another bad collection; stay in incremental mode */
-    g->GCestimate = gettotalbytes(g);  /* first estimate */;
-    entersweep(L);
-    luaC_runtilstate(L, bitmask(GCSpause));  /* finish collection */
-    setpause(g);
-    g->lastatomic = newatomic;
-  }
-}
-
-
-/*
-** Does a generational "step".
-** Usually, this means doing a minor collection and setting the debt to
-** make another collection when memory grows 'genminormul'% larger.
-**
-** However, there are exceptions.  If memory grows 'genmajormul'%
-** larger than it was at the end of the last major collection (kept
-** in 'g->GCestimate'), the function does a major collection. At the
-** end, it checks whether the major collection was able to free a
-** decent amount of memory (at least half the growth in memory since
-** previous major collection). If so, the collector keeps its state,
-** and the next collection will probably be minor again. Otherwise,
-** we have what we call a "bad collection". In that case, set the field
-** 'g->lastatomic' to signal that fact, so that the next collection will
-** go to 'stepgenfull'.
-**
-** 'GCdebt <= 0' means an explicit call to GC step with "size" zero;
-** in that case, do a minor collection.
-*/
-static void genstep (lua_State *L, global_State *g) {
-  if (g->lastatomic != 0)  /* last collection was a bad one? */
-    stepgenfull(L, g);  /* do a full step */
-  else {
-    lu_mem majorbase = g->GCestimate;  /* memory after last major collection */
-    lu_mem majorinc = (majorbase / 100) * getgcparam(g->genmajormul);
-    if (g->GCdebt > 0 && gettotalbytes(g) > majorbase + majorinc) {
-      lu_mem numobjs = fullgen(L, g);  /* do a major collection */
-      if (gettotalbytes(g) < majorbase + (majorinc / 2)) {
-        /* collected at least half of memory growth since last major
-           collection; keep doing minor collections. */
-        lua_assert(g->lastatomic == 0);
-      }
-      else {  /* bad collection */
-        g->lastatomic = numobjs;  /* signal that last collection was bad */
-        setpause(g);  /* do a long wait for next (major) collection */
-      }
-    }
-    else {  /* regular case; do a minor collection */
-      youngcollection(L, g);
-      setminordebt(g);
-      g->GCestimate = majorbase;  /* preserve base value */
-    }
-  }
-  lua_assert(isdecGCmodegen(g));
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** GC control
-** =======================================================
-*/
-
-
-/*
-** Enter first sweep phase.
-** The call to 'sweeptolive' makes the pointer point to an object
-** inside the list (instead of to the header), so that the real sweep do
-** not need to skip objects created between "now" and the start of the
-** real sweep.
-*/
-static void entersweep (lua_State *L) {
-  global_State *g = G(L);
-  g->gcstate = GCSswpallgc;
-  lua_assert(g->sweepgc == NULL);
-  g->sweepgc = sweeptolive(L, &g->allgc);
-}
-
-
-/*
-** Delete all objects in list 'p' until (but not including) object
-** 'limit'.
-*/
-static void deletelist (lua_State *L, GCObject *p, GCObject *limit) {
-  while (p != limit) {
-    GCObject *next = p->next;
-    freeobj(L, p);
-    p = next;
-  }
-}
-
-
-/*
-** Call all finalizers of the objects in the given Lua state, and
-** then free all objects, except for the main thread.
-*/
-void luaC_freeallobjects (lua_State *L) {
-  global_State *g = G(L);
-  g->gcstp = GCSTPCLS;  /* no extra finalizers after here */
-  luaC_changemode(L, KGC_INC);
-  separatetobefnz(g, 1);  /* separate all objects with finalizers */
-  lua_assert(g->finobj == NULL);
-  callallpendingfinalizers(L);
-  deletelist(L, g->allgc, obj2gco(g->mainthread));
-  lua_assert(g->finobj == NULL);  /* no new finalizers */
-  deletelist(L, g->fixedgc, NULL);  /* collect fixed objects */
-  lua_assert(g->strt.nuse == 0);
-}
-
-
-static lu_mem atomic (lua_State *L) {
-  global_State *g = G(L);
-  lu_mem work = 0;
-  GCObject *origweak, *origall;
-  GCObject *grayagain = g->grayagain;  /* save original list */
-  g->grayagain = NULL;
-  lua_assert(g->ephemeron == NULL && g->weak == NULL);
-  lua_assert(!iswhite(g->mainthread));
-  g->gcstate = GCSatomic;
-  markobject(g, L);  /* mark running thread */
-  /* registry and global metatables may be changed by API */
-  markvalue(g, &g->l_registry);
-  markmt(g);  /* mark global metatables */
-  work += propagateall(g);  /* empties 'gray' list */
-  /* remark occasional upvalues of (maybe) dead threads */
-  work += remarkupvals(g);
-  work += propagateall(g);  /* propagate changes */
-  g->gray = grayagain;
-  work += propagateall(g);  /* traverse 'grayagain' list */
-  convergeephemerons(g);
-  /* at this point, all strongly accessible objects are marked. */
-  /* Clear values from weak tables, before checking finalizers */
-  clearbyvalues(g, g->weak, NULL);
-  clearbyvalues(g, g->allweak, NULL);
-  origweak = g->weak; origall = g->allweak;
-  separatetobefnz(g, 0);  /* separate objects to be finalized */
-  work += markbeingfnz(g);  /* mark objects that will be finalized */
-  work += propagateall(g);  /* remark, to propagate 'resurrection' */
-  convergeephemerons(g);
-  /* at this point, all resurrected objects are marked. */
-  /* remove dead objects from weak tables */
-  clearbykeys(g, g->ephemeron);  /* clear keys from all ephemeron tables */
-  clearbykeys(g, g->allweak);  /* clear keys from all 'allweak' tables */
-  /* clear values from resurrected weak tables */
-  clearbyvalues(g, g->weak, origweak);
-  clearbyvalues(g, g->allweak, origall);
-  luaS_clearcache(g);
-  g->currentwhite = cast_byte(otherwhite(g));  /* flip current white */
-  lua_assert(g->gray == NULL);
-  return work;  /* estimate of slots marked by 'atomic' */
-}
-
-
-static int sweepstep (lua_State *L, global_State *g,
-                      int nextstate, GCObject **nextlist) {
-  if (g->sweepgc) {
-    l_mem olddebt = g->GCdebt;
-    int count;
-    g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX, &count);
-    g->GCestimate += g->GCdebt - olddebt;  /* update estimate */
-    return count;
-  }
-  else {  /* enter next state */
-    g->gcstate = nextstate;
-    g->sweepgc = nextlist;
-    return 0;  /* no work done */
-  }
-}
-
-
-static lu_mem singlestep (lua_State *L) {
-  global_State *g = G(L);
-  lu_mem work;
-  lua_assert(!g->gcstopem);  /* collector is not reentrant */
-  g->gcstopem = 1;  /* no emergency collections while collecting */
-  switch (g->gcstate) {
-    case GCSpause: {
-      restartcollection(g);
-      g->gcstate = GCSpropagate;
-      work = 1;
-      break;
-    }
-    case GCSpropagate: {
-      if (g->gray == NULL) {  /* no more gray objects? */
-        g->gcstate = GCSenteratomic;  /* finish propagate phase */
-        work = 0;
-      }
-      else
-        work = propagatemark(g);  /* traverse one gray object */
-      break;
-    }
-    case GCSenteratomic: {
-      work = atomic(L);  /* work is what was traversed by 'atomic' */
-      entersweep(L);
-      g->GCestimate = gettotalbytes(g);  /* first estimate */;
-      break;
-    }
-    case GCSswpallgc: {  /* sweep "regular" objects */
-      work = sweepstep(L, g, GCSswpfinobj, &g->finobj);
-      break;
-    }
-    case GCSswpfinobj: {  /* sweep objects with finalizers */
-      work = sweepstep(L, g, GCSswptobefnz, &g->tobefnz);
-      break;
-    }
-    case GCSswptobefnz: {  /* sweep objects to be finalized */
-      work = sweepstep(L, g, GCSswpend, NULL);
-      break;
-    }
-    case GCSswpend: {  /* finish sweeps */
-      checkSizes(L, g);
-      g->gcstate = GCScallfin;
-      work = 0;
-      break;
-    }
-    case GCScallfin: {  /* call remaining finalizers */
-      if (g->tobefnz && !g->gcemergency) {
-        g->gcstopem = 0;  /* ok collections during finalizers */
-        work = runafewfinalizers(L, GCFINMAX) * GCFINALIZECOST;
-      }
-      else {  /* emergency mode or no more finalizers */
-        g->gcstate = GCSpause;  /* finish collection */
-        work = 0;
-      }
-      break;
-    }
-    default: lua_assert(0); return 0;
-  }
-  g->gcstopem = 0;
-  return work;
-}
-
-
-/*
-** advances the garbage collector until it reaches a state allowed
-** by 'statemask'
-*/
-void luaC_runtilstate (lua_State *L, int statesmask) {
-  global_State *g = G(L);
-  while (!testbit(statesmask, g->gcstate))
-    singlestep(L);
-}
-
-
-
-/*
-** Performs a basic incremental step. The debt and step size are
-** converted from bytes to "units of work"; then the function loops
-** running single steps until adding that many units of work or
-** finishing a cycle (pause state). Finally, it sets the debt that
-** controls when next step will be performed.
-*/
-static void incstep (lua_State *L, global_State *g) {
-  int stepmul = (getgcparam(g->gcstepmul) | 1);  /* avoid division by 0 */
-  l_mem debt = (g->GCdebt / WORK2MEM) * stepmul;
-  l_mem stepsize = (g->gcstepsize <= log2maxs(l_mem))
-                 ? ((cast(l_mem, 1) << g->gcstepsize) / WORK2MEM) * stepmul
-                 : MAX_LMEM;  /* overflow; keep maximum value */
-  do {  /* repeat until pause or enough "credit" (negative debt) */
-    lu_mem work = singlestep(L);  /* perform one single step */
-    debt -= work;
-  } while (debt > -stepsize && g->gcstate != GCSpause);
-  if (g->gcstate == GCSpause)
-    setpause(g);  /* pause until next cycle */
-  else {
-    debt = (debt / stepmul) * WORK2MEM;  /* convert 'work units' to bytes */
-    luaE_setdebt(g, debt);
-  }
-}
-
-/*
-** Performs a basic GC step if collector is running. (If collector is
-** not running, set a reasonable debt to avoid it being called at
-** every single check.)
-*/
-void luaC_step (lua_State *L) {
-  global_State *g = G(L);
-  if (!gcrunning(g))  /* not running? */
-    luaE_setdebt(g, -2000);
-  else {
-    if(isdecGCmodegen(g))
-      genstep(L, g);
-    else
-      incstep(L, g);
-  }
-}
-
-
-/*
-** Perform a full collection in incremental mode.
-** Before running the collection, check 'keepinvariant'; if it is true,
-** there may be some objects marked as black, so the collector has
-** to sweep all objects to turn them back to white (as white has not
-** changed, nothing will be collected).
-*/
-static void fullinc (lua_State *L, global_State *g) {
-  if (keepinvariant(g))  /* black objects? */
-    entersweep(L); /* sweep everything to turn them back to white */
-  /* finish any pending sweep phase to start a new cycle */
-  luaC_runtilstate(L, bitmask(GCSpause));
-  luaC_runtilstate(L, bitmask(GCScallfin));  /* run up to finalizers */
-  /* estimate must be correct after a full GC cycle */
-  lua_assert(g->GCestimate == gettotalbytes(g));
-  luaC_runtilstate(L, bitmask(GCSpause));  /* finish collection */
-  setpause(g);
-}
-
-
-/*
-** Performs a full GC cycle; if 'isemergency', set a flag to avoid
-** some operations which could change the interpreter state in some
-** unexpected ways (running finalizers and shrinking some structures).
-*/
-void luaC_fullgc (lua_State *L, int isemergency) {
-  global_State *g = G(L);
-  lua_assert(!g->gcemergency);
-  g->gcemergency = isemergency;  /* set flag */
-  if (g->gckind == KGC_INC)
-    fullinc(L, g);
-  else
-    fullgen(L, g);
-  g->gcemergency = 0;
-}
-
-/* }====================================================== */
-
-
diff --git a/third-party/lua/src/lgc.h b/third-party/lua/src/lgc.h
deleted file mode 100644
index 538f6edcc..000000000
--- a/third-party/lua/src/lgc.h
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
-** $Id: lgc.h $
-** Garbage Collector
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lgc_h
-#define lgc_h
-
-
-#include "lobject.h"
-#include "lstate.h"
-
-/*
-** Collectable objects may have one of three colors: white, which means
-** the object is not marked; gray, which means the object is marked, but
-** its references may be not marked; and black, which means that the
-** object and all its references are marked.  The main invariant of the
-** garbage collector, while marking objects, is that a black object can
-** never point to a white one. Moreover, any gray object must be in a
-** "gray list" (gray, grayagain, weak, allweak, ephemeron) so that it
-** can be visited again before finishing the collection cycle. (Open
-** upvalues are an exception to this rule.)  These lists have no meaning
-** when the invariant is not being enforced (e.g., sweep phase).
-*/
-
-
-/*
-** Possible states of the Garbage Collector
-*/
-#define GCSpropagate	0
-#define GCSenteratomic	1
-#define GCSatomic	2
-#define GCSswpallgc	3
-#define GCSswpfinobj	4
-#define GCSswptobefnz	5
-#define GCSswpend	6
-#define GCScallfin	7
-#define GCSpause	8
-
-
-#define issweepphase(g)  \
-	(GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend)
-
-
-/*
-** macro to tell when main invariant (white objects cannot point to black
-** ones) must be kept. During a collection, the sweep
-** phase may break the invariant, as objects turned white may point to
-** still-black objects. The invariant is restored when sweep ends and
-** all objects are white again.
-*/
-
-#define keepinvariant(g)	((g)->gcstate <= GCSatomic)
-
-
-/*
-** some useful bit tricks
-*/
-#define resetbits(x,m)		((x) &= cast_byte(~(m)))
-#define setbits(x,m)		((x) |= (m))
-#define testbits(x,m)		((x) & (m))
-#define bitmask(b)		(1<<(b))
-#define bit2mask(b1,b2)		(bitmask(b1) | bitmask(b2))
-#define l_setbit(x,b)		setbits(x, bitmask(b))
-#define resetbit(x,b)		resetbits(x, bitmask(b))
-#define testbit(x,b)		testbits(x, bitmask(b))
-
-
-/*
-** Layout for bit use in 'marked' field. First three bits are
-** used for object "age" in generational mode. Last bit is used
-** by tests.
-*/
-#define WHITE0BIT	3  /* object is white (type 0) */
-#define WHITE1BIT	4  /* object is white (type 1) */
-#define BLACKBIT	5  /* object is black */
-#define FINALIZEDBIT	6  /* object has been marked for finalization */
-
-#define TESTBIT		7
-
-
-
-#define WHITEBITS	bit2mask(WHITE0BIT, WHITE1BIT)
-
-
-#define iswhite(x)      testbits((x)->marked, WHITEBITS)
-#define isblack(x)      testbit((x)->marked, BLACKBIT)
-#define isgray(x)  /* neither white nor black */  \
-	(!testbits((x)->marked, WHITEBITS | bitmask(BLACKBIT)))
-
-#define tofinalize(x)	testbit((x)->marked, FINALIZEDBIT)
-
-#define otherwhite(g)	((g)->currentwhite ^ WHITEBITS)
-#define isdeadm(ow,m)	((m) & (ow))
-#define isdead(g,v)	isdeadm(otherwhite(g), (v)->marked)
-
-#define changewhite(x)	((x)->marked ^= WHITEBITS)
-#define nw2black(x)  \
-	check_exp(!iswhite(x), l_setbit((x)->marked, BLACKBIT))
-
-#define luaC_white(g)	cast_byte((g)->currentwhite & WHITEBITS)
-
-
-/* object age in generational mode */
-#define G_NEW		0	/* created in current cycle */
-#define G_SURVIVAL	1	/* created in previous cycle */
-#define G_OLD0		2	/* marked old by frw. barrier in this cycle */
-#define G_OLD1		3	/* first full cycle as old */
-#define G_OLD		4	/* really old object (not to be visited) */
-#define G_TOUCHED1	5	/* old object touched this cycle */
-#define G_TOUCHED2	6	/* old object touched in previous cycle */
-
-#define AGEBITS		7  /* all age bits (111) */
-
-#define getage(o)	((o)->marked & AGEBITS)
-#define setage(o,a)  ((o)->marked = cast_byte(((o)->marked & (~AGEBITS)) | a))
-#define isold(o)	(getage(o) > G_SURVIVAL)
-
-#define changeage(o,f,t)  \
-	check_exp(getage(o) == (f), (o)->marked ^= ((f)^(t)))
-
-
-/* Default Values for GC parameters */
-#define LUAI_GENMAJORMUL         100
-#define LUAI_GENMINORMUL         20
-
-/* wait memory to double before starting new cycle */
-#define LUAI_GCPAUSE    200
-
-/*
-** some gc parameters are stored divided by 4 to allow a maximum value
-** up to 1023 in a 'lu_byte'.
-*/
-#define getgcparam(p)	((p) * 4)
-#define setgcparam(p,v)	((p) = (v) / 4)
-
-#define LUAI_GCMUL      100
-
-/* how much to allocate before next GC step (log2) */
-#define LUAI_GCSTEPSIZE 13      /* 8 KB */
-
-
-/*
-** Check whether the declared GC mode is generational. While in
-** generational mode, the collector can go temporarily to incremental
-** mode to improve performance. This is signaled by 'g->lastatomic != 0'.
-*/
-#define isdecGCmodegen(g)	(g->gckind == KGC_GEN || g->lastatomic != 0)
-
-
-/*
-** Control when GC is running:
-*/
-#define GCSTPUSR	1  /* bit true when GC stopped by user */
-#define GCSTPGC		2  /* bit true when GC stopped by itself */
-#define GCSTPCLS	4  /* bit true when closing Lua state */
-#define gcrunning(g)	((g)->gcstp == 0)
-
-
-/*
-** Does one step of collection when debt becomes positive. 'pre'/'pos'
-** allows some adjustments to be done only when needed. macro
-** 'condchangemem' is used only for heavy tests (forcing a full
-** GC cycle on every opportunity)
-*/
-#define luaC_condGC(L,pre,pos) \
-	{ if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \
-	  condchangemem(L,pre,pos); }
-
-/* more often than not, 'pre'/'pos' are empty */
-#define luaC_checkGC(L)		luaC_condGC(L,(void)0,(void)0)
-
-
-#define luaC_objbarrier(L,p,o) (  \
-	(isblack(p) && iswhite(o)) ? \
-	luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0))
-
-#define luaC_barrier(L,p,v) (  \
-	iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0))
-
-#define luaC_objbarrierback(L,p,o) (  \
-	(isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0))
-
-#define luaC_barrierback(L,p,v) (  \
-	iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0))
-
-LUAI_FUNC void luaC_fix (lua_State *L, GCObject *o);
-LUAI_FUNC void luaC_freeallobjects (lua_State *L);
-LUAI_FUNC void luaC_step (lua_State *L);
-LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask);
-LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);
-LUAI_FUNC GCObject *luaC_newobj (lua_State *L, int tt, size_t sz);
-LUAI_FUNC GCObject *luaC_newobjdt (lua_State *L, int tt, size_t sz,
-                                                 size_t offset);
-LUAI_FUNC void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v);
-LUAI_FUNC void luaC_barrierback_ (lua_State *L, GCObject *o);
-LUAI_FUNC void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt);
-LUAI_FUNC void luaC_changemode (lua_State *L, int newmode);
-
-
-#endif
diff --git a/third-party/lua/src/linit.c b/third-party/lua/src/linit.c
deleted file mode 100644
index 69808f84f..000000000
--- a/third-party/lua/src/linit.c
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
-** $Id: linit.c $
-** Initialization of libraries for lua.c and other clients
-** See Copyright Notice in lua.h
-*/
-
-
-#define linit_c
-#define LUA_LIB
-
-/*
-** If you embed Lua in your program and need to open the standard
-** libraries, call luaL_openlibs in your program. If you need a
-** different set of libraries, copy this file to your project and edit
-** it to suit your needs.
-**
-** You can also *preload* libraries, so that a later 'require' can
-** open the library, which is already linked to the application.
-** For that, do the following code:
-**
-**  luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
-**  lua_pushcfunction(L, luaopen_modname);
-**  lua_setfield(L, -2, modname);
-**  lua_pop(L, 1);  // remove PRELOAD table
-*/
-
-#include "lprefix.h"
-
-
-#include <stddef.h>
-
-#include "lua.h"
-
-#include "lualib.h"
-#include "lauxlib.h"
-
-
-/*
-** these libs are loaded by lua.c and are readily available to any Lua
-** program
-*/
-static const luaL_Reg loadedlibs[] = {
-  {LUA_GNAME, luaopen_base},
-  {LUA_LOADLIBNAME, luaopen_package},
-  {LUA_COLIBNAME, luaopen_coroutine},
-  {LUA_TABLIBNAME, luaopen_table},
-  {LUA_IOLIBNAME, luaopen_io},
-  {LUA_OSLIBNAME, luaopen_os},
-  {LUA_STRLIBNAME, luaopen_string},
-  {LUA_MATHLIBNAME, luaopen_math},
-  {LUA_UTF8LIBNAME, luaopen_utf8},
-  {LUA_DBLIBNAME, luaopen_debug},
-  {NULL, NULL}
-};
-
-
-LUALIB_API void luaL_openlibs (lua_State *L) {
-  const luaL_Reg *lib;
-  /* "require" functions from 'loadedlibs' and set results to global table */
-  for (lib = loadedlibs; lib->func; lib++) {
-    luaL_requiref(L, lib->name, lib->func, 1);
-    lua_pop(L, 1);  /* remove lib */
-  }
-}
-
diff --git a/third-party/lua/src/liolib.c b/third-party/lua/src/liolib.c
deleted file mode 100644
index b08397da4..000000000
--- a/third-party/lua/src/liolib.c
+++ /dev/null
@@ -1,828 +0,0 @@
-/*
-** $Id: liolib.c $
-** Standard I/O (and system) library
-** See Copyright Notice in lua.h
-*/
-
-#define liolib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <ctype.h>
-#include <errno.h>
-#include <locale.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-
-
-/*
-** Change this macro to accept other modes for 'fopen' besides
-** the standard ones.
-*/
-#if !defined(l_checkmode)
-
-/* accepted extensions to 'mode' in 'fopen' */
-#if !defined(L_MODEEXT)
-#define L_MODEEXT	"b"
-#endif
-
-/* Check whether 'mode' matches '[rwa]%+?[L_MODEEXT]*' */
-static int l_checkmode (const char *mode) {
-  return (*mode != '\0' && strchr("rwa", *(mode++)) != NULL &&
-         (*mode != '+' || ((void)(++mode), 1)) &&  /* skip if char is '+' */
-         (strspn(mode, L_MODEEXT) == strlen(mode)));  /* check extensions */
-}
-
-#endif
-
-/*
-** {======================================================
-** l_popen spawns a new process connected to the current
-** one through the file streams.
-** =======================================================
-*/
-
-#if !defined(l_popen)		/* { */
-
-#if defined(LUA_USE_POSIX)	/* { */
-
-#define l_popen(L,c,m)		(fflush(NULL), popen(c,m))
-#define l_pclose(L,file)	(pclose(file))
-
-#elif defined(LUA_USE_WINDOWS)	/* }{ */
-
-#define l_popen(L,c,m)		(_popen(c,m))
-#define l_pclose(L,file)	(_pclose(file))
-
-#if !defined(l_checkmodep)
-/* Windows accepts "[rw][bt]?" as valid modes */
-#define l_checkmodep(m)	((m[0] == 'r' || m[0] == 'w') && \
-  (m[1] == '\0' || ((m[1] == 'b' || m[1] == 't') && m[2] == '\0')))
-#endif
-
-#else				/* }{ */
-
-/* ISO C definitions */
-#define l_popen(L,c,m)  \
-	  ((void)c, (void)m, \
-	  luaL_error(L, "'popen' not supported"), \
-	  (FILE*)0)
-#define l_pclose(L,file)		((void)L, (void)file, -1)
-
-#endif				/* } */
-
-#endif				/* } */
-
-
-#if !defined(l_checkmodep)
-/* By default, Lua accepts only "r" or "w" as valid modes */
-#define l_checkmodep(m)        ((m[0] == 'r' || m[0] == 'w') && m[1] == '\0')
-#endif
-
-/* }====================================================== */
-
-
-#if !defined(l_getc)		/* { */
-
-#if defined(LUA_USE_POSIX)
-#define l_getc(f)		getc_unlocked(f)
-#define l_lockfile(f)		flockfile(f)
-#define l_unlockfile(f)		funlockfile(f)
-#else
-#define l_getc(f)		getc(f)
-#define l_lockfile(f)		((void)0)
-#define l_unlockfile(f)		((void)0)
-#endif
-
-#endif				/* } */
-
-
-/*
-** {======================================================
-** l_fseek: configuration for longer offsets
-** =======================================================
-*/
-
-#if !defined(l_fseek)		/* { */
-
-#if defined(LUA_USE_POSIX)	/* { */
-
-#include <sys/types.h>
-
-#define l_fseek(f,o,w)		fseeko(f,o,w)
-#define l_ftell(f)		ftello(f)
-#define l_seeknum		off_t
-
-#elif defined(LUA_USE_WINDOWS) && !defined(_CRTIMP_TYPEINFO) \
-   && defined(_MSC_VER) && (_MSC_VER >= 1400)	/* }{ */
-
-/* Windows (but not DDK) and Visual C++ 2005 or higher */
-#define l_fseek(f,o,w)		_fseeki64(f,o,w)
-#define l_ftell(f)		_ftelli64(f)
-#define l_seeknum		__int64
-
-#else				/* }{ */
-
-/* ISO C definitions */
-#define l_fseek(f,o,w)		fseek(f,o,w)
-#define l_ftell(f)		ftell(f)
-#define l_seeknum		long
-
-#endif				/* } */
-
-#endif				/* } */
-
-/* }====================================================== */
-
-
-
-#define IO_PREFIX	"_IO_"
-#define IOPREF_LEN	(sizeof(IO_PREFIX)/sizeof(char) - 1)
-#define IO_INPUT	(IO_PREFIX "input")
-#define IO_OUTPUT	(IO_PREFIX "output")
-
-
-typedef luaL_Stream LStream;
-
-
-#define tolstream(L)	((LStream *)luaL_checkudata(L, 1, LUA_FILEHANDLE))
-
-#define isclosed(p)	((p)->closef == NULL)
-
-
-static int io_type (lua_State *L) {
-  LStream *p;
-  luaL_checkany(L, 1);
-  p = (LStream *)luaL_testudata(L, 1, LUA_FILEHANDLE);
-  if (p == NULL)
-    luaL_pushfail(L);  /* not a file */
-  else if (isclosed(p))
-    lua_pushliteral(L, "closed file");
-  else
-    lua_pushliteral(L, "file");
-  return 1;
-}
-
-
-static int f_tostring (lua_State *L) {
-  LStream *p = tolstream(L);
-  if (isclosed(p))
-    lua_pushliteral(L, "file (closed)");
-  else
-    lua_pushfstring(L, "file (%p)", p->f);
-  return 1;
-}
-
-
-static FILE *tofile (lua_State *L) {
-  LStream *p = tolstream(L);
-  if (l_unlikely(isclosed(p)))
-    luaL_error(L, "attempt to use a closed file");
-  lua_assert(p->f);
-  return p->f;
-}
-
-
-/*
-** When creating file handles, always creates a 'closed' file handle
-** before opening the actual file; so, if there is a memory error, the
-** handle is in a consistent state.
-*/
-static LStream *newprefile (lua_State *L) {
-  LStream *p = (LStream *)lua_newuserdatauv(L, sizeof(LStream), 0);
-  p->closef = NULL;  /* mark file handle as 'closed' */
-  luaL_setmetatable(L, LUA_FILEHANDLE);
-  return p;
-}
-
-
-/*
-** Calls the 'close' function from a file handle. The 'volatile' avoids
-** a bug in some versions of the Clang compiler (e.g., clang 3.0 for
-** 32 bits).
-*/
-static int aux_close (lua_State *L) {
-  LStream *p = tolstream(L);
-  volatile lua_CFunction cf = p->closef;
-  p->closef = NULL;  /* mark stream as closed */
-  return (*cf)(L);  /* close it */
-}
-
-
-static int f_close (lua_State *L) {
-  tofile(L);  /* make sure argument is an open stream */
-  return aux_close(L);
-}
-
-
-static int io_close (lua_State *L) {
-  if (lua_isnone(L, 1))  /* no argument? */
-    lua_getfield(L, LUA_REGISTRYINDEX, IO_OUTPUT);  /* use default output */
-  return f_close(L);
-}
-
-
-static int f_gc (lua_State *L) {
-  LStream *p = tolstream(L);
-  if (!isclosed(p) && p->f != NULL)
-    aux_close(L);  /* ignore closed and incompletely open files */
-  return 0;
-}
-
-
-/*
-** function to close regular files
-*/
-static int io_fclose (lua_State *L) {
-  LStream *p = tolstream(L);
-  int res = fclose(p->f);
-  return luaL_fileresult(L, (res == 0), NULL);
-}
-
-
-static LStream *newfile (lua_State *L) {
-  LStream *p = newprefile(L);
-  p->f = NULL;
-  p->closef = &io_fclose;
-  return p;
-}
-
-
-static void opencheck (lua_State *L, const char *fname, const char *mode) {
-  LStream *p = newfile(L);
-  p->f = fopen(fname, mode);
-  if (l_unlikely(p->f == NULL))
-    luaL_error(L, "cannot open file '%s' (%s)", fname, strerror(errno));
-}
-
-
-static int io_open (lua_State *L) {
-  const char *filename = luaL_checkstring(L, 1);
-  const char *mode = luaL_optstring(L, 2, "r");
-  LStream *p = newfile(L);
-  const char *md = mode;  /* to traverse/check mode */
-  luaL_argcheck(L, l_checkmode(md), 2, "invalid mode");
-  p->f = fopen(filename, mode);
-  return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
-}
-
-
-/*
-** function to close 'popen' files
-*/
-static int io_pclose (lua_State *L) {
-  LStream *p = tolstream(L);
-  errno = 0;
-  return luaL_execresult(L, l_pclose(L, p->f));
-}
-
-
-static int io_popen (lua_State *L) {
-  const char *filename = luaL_checkstring(L, 1);
-  const char *mode = luaL_optstring(L, 2, "r");
-  LStream *p = newprefile(L);
-  luaL_argcheck(L, l_checkmodep(mode), 2, "invalid mode");
-  p->f = l_popen(L, filename, mode);
-  p->closef = &io_pclose;
-  return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
-}
-
-
-static int io_tmpfile (lua_State *L) {
-  LStream *p = newfile(L);
-  p->f = tmpfile();
-  return (p->f == NULL) ? luaL_fileresult(L, 0, NULL) : 1;
-}
-
-
-static FILE *getiofile (lua_State *L, const char *findex) {
-  LStream *p;
-  lua_getfield(L, LUA_REGISTRYINDEX, findex);
-  p = (LStream *)lua_touserdata(L, -1);
-  if (l_unlikely(isclosed(p)))
-    luaL_error(L, "default %s file is closed", findex + IOPREF_LEN);
-  return p->f;
-}
-
-
-static int g_iofile (lua_State *L, const char *f, const char *mode) {
-  if (!lua_isnoneornil(L, 1)) {
-    const char *filename = lua_tostring(L, 1);
-    if (filename)
-      opencheck(L, filename, mode);
-    else {
-      tofile(L);  /* check that it's a valid file handle */
-      lua_pushvalue(L, 1);
-    }
-    lua_setfield(L, LUA_REGISTRYINDEX, f);
-  }
-  /* return current value */
-  lua_getfield(L, LUA_REGISTRYINDEX, f);
-  return 1;
-}
-
-
-static int io_input (lua_State *L) {
-  return g_iofile(L, IO_INPUT, "r");
-}
-
-
-static int io_output (lua_State *L) {
-  return g_iofile(L, IO_OUTPUT, "w");
-}
-
-
-static int io_readline (lua_State *L);
-
-
-/*
-** maximum number of arguments to 'f:lines'/'io.lines' (it + 3 must fit
-** in the limit for upvalues of a closure)
-*/
-#define MAXARGLINE	250
-
-/*
-** Auxiliary function to create the iteration function for 'lines'.
-** The iteration function is a closure over 'io_readline', with
-** the following upvalues:
-** 1) The file being read (first value in the stack)
-** 2) the number of arguments to read
-** 3) a boolean, true iff file has to be closed when finished ('toclose')
-** *) a variable number of format arguments (rest of the stack)
-*/
-static void aux_lines (lua_State *L, int toclose) {
-  int n = lua_gettop(L) - 1;  /* number of arguments to read */
-  luaL_argcheck(L, n <= MAXARGLINE, MAXARGLINE + 2, "too many arguments");
-  lua_pushvalue(L, 1);  /* file */
-  lua_pushinteger(L, n);  /* number of arguments to read */
-  lua_pushboolean(L, toclose);  /* close/not close file when finished */
-  lua_rotate(L, 2, 3);  /* move the three values to their positions */
-  lua_pushcclosure(L, io_readline, 3 + n);
-}
-
-
-static int f_lines (lua_State *L) {
-  tofile(L);  /* check that it's a valid file handle */
-  aux_lines(L, 0);
-  return 1;
-}
-
-
-/*
-** Return an iteration function for 'io.lines'. If file has to be
-** closed, also returns the file itself as a second result (to be
-** closed as the state at the exit of a generic for).
-*/
-static int io_lines (lua_State *L) {
-  int toclose;
-  if (lua_isnone(L, 1)) lua_pushnil(L);  /* at least one argument */
-  if (lua_isnil(L, 1)) {  /* no file name? */
-    lua_getfield(L, LUA_REGISTRYINDEX, IO_INPUT);  /* get default input */
-    lua_replace(L, 1);  /* put it at index 1 */
-    tofile(L);  /* check that it's a valid file handle */
-    toclose = 0;  /* do not close it after iteration */
-  }
-  else {  /* open a new file */
-    const char *filename = luaL_checkstring(L, 1);
-    opencheck(L, filename, "r");
-    lua_replace(L, 1);  /* put file at index 1 */
-    toclose = 1;  /* close it after iteration */
-  }
-  aux_lines(L, toclose);  /* push iteration function */
-  if (toclose) {
-    lua_pushnil(L);  /* state */
-    lua_pushnil(L);  /* control */
-    lua_pushvalue(L, 1);  /* file is the to-be-closed variable (4th result) */
-    return 4;
-  }
-  else
-    return 1;
-}
-
-
-/*
-** {======================================================
-** READ
-** =======================================================
-*/
-
-
-/* maximum length of a numeral */
-#if !defined (L_MAXLENNUM)
-#define L_MAXLENNUM     200
-#endif
-
-
-/* auxiliary structure used by 'read_number' */
-typedef struct {
-  FILE *f;  /* file being read */
-  int c;  /* current character (look ahead) */
-  int n;  /* number of elements in buffer 'buff' */
-  char buff[L_MAXLENNUM + 1];  /* +1 for ending '\0' */
-} RN;
-
-
-/*
-** Add current char to buffer (if not out of space) and read next one
-*/
-static int nextc (RN *rn) {
-  if (l_unlikely(rn->n >= L_MAXLENNUM)) {  /* buffer overflow? */
-    rn->buff[0] = '\0';  /* invalidate result */
-    return 0;  /* fail */
-  }
-  else {
-    rn->buff[rn->n++] = rn->c;  /* save current char */
-    rn->c = l_getc(rn->f);  /* read next one */
-    return 1;
-  }
-}
-
-
-/*
-** Accept current char if it is in 'set' (of size 2)
-*/
-static int test2 (RN *rn, const char *set) {
-  if (rn->c == set[0] || rn->c == set[1])
-    return nextc(rn);
-  else return 0;
-}
-
-
-/*
-** Read a sequence of (hex)digits
-*/
-static int readdigits (RN *rn, int hex) {
-  int count = 0;
-  while ((hex ? isxdigit(rn->c) : isdigit(rn->c)) && nextc(rn))
-    count++;
-  return count;
-}
-
-
-/*
-** Read a number: first reads a valid prefix of a numeral into a buffer.
-** Then it calls 'lua_stringtonumber' to check whether the format is
-** correct and to convert it to a Lua number.
-*/
-static int read_number (lua_State *L, FILE *f) {
-  RN rn;
-  int count = 0;
-  int hex = 0;
-  char decp[2];
-  rn.f = f; rn.n = 0;
-  decp[0] = lua_getlocaledecpoint();  /* get decimal point from locale */
-  decp[1] = '.';  /* always accept a dot */
-  l_lockfile(rn.f);
-  do { rn.c = l_getc(rn.f); } while (isspace(rn.c));  /* skip spaces */
-  test2(&rn, "-+");  /* optional sign */
-  if (test2(&rn, "00")) {
-    if (test2(&rn, "xX")) hex = 1;  /* numeral is hexadecimal */
-    else count = 1;  /* count initial '0' as a valid digit */
-  }
-  count += readdigits(&rn, hex);  /* integral part */
-  if (test2(&rn, decp))  /* decimal point? */
-    count += readdigits(&rn, hex);  /* fractional part */
-  if (count > 0 && test2(&rn, (hex ? "pP" : "eE"))) {  /* exponent mark? */
-    test2(&rn, "-+");  /* exponent sign */
-    readdigits(&rn, 0);  /* exponent digits */
-  }
-  ungetc(rn.c, rn.f);  /* unread look-ahead char */
-  l_unlockfile(rn.f);
-  rn.buff[rn.n] = '\0';  /* finish string */
-  if (l_likely(lua_stringtonumber(L, rn.buff)))
-    return 1;  /* ok, it is a valid number */
-  else {  /* invalid format */
-   lua_pushnil(L);  /* "result" to be removed */
-   return 0;  /* read fails */
-  }
-}
-
-
-static int test_eof (lua_State *L, FILE *f) {
-  int c = getc(f);
-  ungetc(c, f);  /* no-op when c == EOF */
-  lua_pushliteral(L, "");
-  return (c != EOF);
-}
-
-
-static int read_line (lua_State *L, FILE *f, int chop) {
-  luaL_Buffer b;
-  int c;
-  luaL_buffinit(L, &b);
-  do {  /* may need to read several chunks to get whole line */
-    char *buff = luaL_prepbuffer(&b);  /* preallocate buffer space */
-    int i = 0;
-    l_lockfile(f);  /* no memory errors can happen inside the lock */
-    while (i < LUAL_BUFFERSIZE && (c = l_getc(f)) != EOF && c != '\n')
-      buff[i++] = c;  /* read up to end of line or buffer limit */
-    l_unlockfile(f);
-    luaL_addsize(&b, i);
-  } while (c != EOF && c != '\n');  /* repeat until end of line */
-  if (!chop && c == '\n')  /* want a newline and have one? */
-    luaL_addchar(&b, c);  /* add ending newline to result */
-  luaL_pushresult(&b);  /* close buffer */
-  /* return ok if read something (either a newline or something else) */
-  return (c == '\n' || lua_rawlen(L, -1) > 0);
-}
-
-
-static void read_all (lua_State *L, FILE *f) {
-  size_t nr;
-  luaL_Buffer b;
-  luaL_buffinit(L, &b);
-  do {  /* read file in chunks of LUAL_BUFFERSIZE bytes */
-    char *p = luaL_prepbuffer(&b);
-    nr = fread(p, sizeof(char), LUAL_BUFFERSIZE, f);
-    luaL_addsize(&b, nr);
-  } while (nr == LUAL_BUFFERSIZE);
-  luaL_pushresult(&b);  /* close buffer */
-}
-
-
-static int read_chars (lua_State *L, FILE *f, size_t n) {
-  size_t nr;  /* number of chars actually read */
-  char *p;
-  luaL_Buffer b;
-  luaL_buffinit(L, &b);
-  p = luaL_prepbuffsize(&b, n);  /* prepare buffer to read whole block */
-  nr = fread(p, sizeof(char), n, f);  /* try to read 'n' chars */
-  luaL_addsize(&b, nr);
-  luaL_pushresult(&b);  /* close buffer */
-  return (nr > 0);  /* true iff read something */
-}
-
-
-static int g_read (lua_State *L, FILE *f, int first) {
-  int nargs = lua_gettop(L) - 1;
-  int n, success;
-  clearerr(f);
-  if (nargs == 0) {  /* no arguments? */
-    success = read_line(L, f, 1);
-    n = first + 1;  /* to return 1 result */
-  }
-  else {
-    /* ensure stack space for all results and for auxlib's buffer */
-    luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments");
-    success = 1;
-    for (n = first; nargs-- && success; n++) {
-      if (lua_type(L, n) == LUA_TNUMBER) {
-        size_t l = (size_t)luaL_checkinteger(L, n);
-        success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l);
-      }
-      else {
-        const char *p = luaL_checkstring(L, n);
-        if (*p == '*') p++;  /* skip optional '*' (for compatibility) */
-        switch (*p) {
-          case 'n':  /* number */
-            success = read_number(L, f);
-            break;
-          case 'l':  /* line */
-            success = read_line(L, f, 1);
-            break;
-          case 'L':  /* line with end-of-line */
-            success = read_line(L, f, 0);
-            break;
-          case 'a':  /* file */
-            read_all(L, f);  /* read entire file */
-            success = 1; /* always success */
-            break;
-          default:
-            return luaL_argerror(L, n, "invalid format");
-        }
-      }
-    }
-  }
-  if (ferror(f))
-    return luaL_fileresult(L, 0, NULL);
-  if (!success) {
-    lua_pop(L, 1);  /* remove last result */
-    luaL_pushfail(L);  /* push nil instead */
-  }
-  return n - first;
-}
-
-
-static int io_read (lua_State *L) {
-  return g_read(L, getiofile(L, IO_INPUT), 1);
-}
-
-
-static int f_read (lua_State *L) {
-  return g_read(L, tofile(L), 2);
-}
-
-
-/*
-** Iteration function for 'lines'.
-*/
-static int io_readline (lua_State *L) {
-  LStream *p = (LStream *)lua_touserdata(L, lua_upvalueindex(1));
-  int i;
-  int n = (int)lua_tointeger(L, lua_upvalueindex(2));
-  if (isclosed(p))  /* file is already closed? */
-    return luaL_error(L, "file is already closed");
-  lua_settop(L , 1);
-  luaL_checkstack(L, n, "too many arguments");
-  for (i = 1; i <= n; i++)  /* push arguments to 'g_read' */
-    lua_pushvalue(L, lua_upvalueindex(3 + i));
-  n = g_read(L, p->f, 2);  /* 'n' is number of results */
-  lua_assert(n > 0);  /* should return at least a nil */
-  if (lua_toboolean(L, -n))  /* read at least one value? */
-    return n;  /* return them */
-  else {  /* first result is false: EOF or error */
-    if (n > 1) {  /* is there error information? */
-      /* 2nd result is error message */
-      return luaL_error(L, "%s", lua_tostring(L, -n + 1));
-    }
-    if (lua_toboolean(L, lua_upvalueindex(3))) {  /* generator created file? */
-      lua_settop(L, 0);  /* clear stack */
-      lua_pushvalue(L, lua_upvalueindex(1));  /* push file at index 1 */
-      aux_close(L);  /* close it */
-    }
-    return 0;
-  }
-}
-
-/* }====================================================== */
-
-
-static int g_write (lua_State *L, FILE *f, int arg) {
-  int nargs = lua_gettop(L) - arg;
-  int status = 1;
-  for (; nargs--; arg++) {
-    if (lua_type(L, arg) == LUA_TNUMBER) {
-      /* optimization: could be done exactly as for strings */
-      int len = lua_isinteger(L, arg)
-                ? fprintf(f, LUA_INTEGER_FMT,
-                             (LUAI_UACINT)lua_tointeger(L, arg))
-                : fprintf(f, LUA_NUMBER_FMT,
-                             (LUAI_UACNUMBER)lua_tonumber(L, arg));
-      status = status && (len > 0);
-    }
-    else {
-      size_t l;
-      const char *s = luaL_checklstring(L, arg, &l);
-      status = status && (fwrite(s, sizeof(char), l, f) == l);
-    }
-  }
-  if (l_likely(status))
-    return 1;  /* file handle already on stack top */
-  else return luaL_fileresult(L, status, NULL);
-}
-
-
-static int io_write (lua_State *L) {
-  return g_write(L, getiofile(L, IO_OUTPUT), 1);
-}
-
-
-static int f_write (lua_State *L) {
-  FILE *f = tofile(L);
-  lua_pushvalue(L, 1);  /* push file at the stack top (to be returned) */
-  return g_write(L, f, 2);
-}
-
-
-static int f_seek (lua_State *L) {
-  static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};
-  static const char *const modenames[] = {"set", "cur", "end", NULL};
-  FILE *f = tofile(L);
-  int op = luaL_checkoption(L, 2, "cur", modenames);
-  lua_Integer p3 = luaL_optinteger(L, 3, 0);
-  l_seeknum offset = (l_seeknum)p3;
-  luaL_argcheck(L, (lua_Integer)offset == p3, 3,
-                  "not an integer in proper range");
-  op = l_fseek(f, offset, mode[op]);
-  if (l_unlikely(op))
-    return luaL_fileresult(L, 0, NULL);  /* error */
-  else {
-    lua_pushinteger(L, (lua_Integer)l_ftell(f));
-    return 1;
-  }
-}
-
-
-static int f_setvbuf (lua_State *L) {
-  static const int mode[] = {_IONBF, _IOFBF, _IOLBF};
-  static const char *const modenames[] = {"no", "full", "line", NULL};
-  FILE *f = tofile(L);
-  int op = luaL_checkoption(L, 2, NULL, modenames);
-  lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE);
-  int res = setvbuf(f, NULL, mode[op], (size_t)sz);
-  return luaL_fileresult(L, res == 0, NULL);
-}
-
-
-
-static int io_flush (lua_State *L) {
-  return luaL_fileresult(L, fflush(getiofile(L, IO_OUTPUT)) == 0, NULL);
-}
-
-
-static int f_flush (lua_State *L) {
-  return luaL_fileresult(L, fflush(tofile(L)) == 0, NULL);
-}
-
-
-/*
-** functions for 'io' library
-*/
-static const luaL_Reg iolib[] = {
-  {"close", io_close},
-  {"flush", io_flush},
-  {"input", io_input},
-  {"lines", io_lines},
-  {"open", io_open},
-  {"output", io_output},
-  {"popen", io_popen},
-  {"read", io_read},
-  {"tmpfile", io_tmpfile},
-  {"type", io_type},
-  {"write", io_write},
-  {NULL, NULL}
-};
-
-
-/*
-** methods for file handles
-*/
-static const luaL_Reg meth[] = {
-  {"read", f_read},
-  {"write", f_write},
-  {"lines", f_lines},
-  {"flush", f_flush},
-  {"seek", f_seek},
-  {"close", f_close},
-  {"setvbuf", f_setvbuf},
-  {NULL, NULL}
-};
-
-
-/*
-** metamethods for file handles
-*/
-static const luaL_Reg metameth[] = {
-  {"__index", NULL},  /* place holder */
-  {"__gc", f_gc},
-  {"__close", f_gc},
-  {"__tostring", f_tostring},
-  {NULL, NULL}
-};
-
-
-static void createmeta (lua_State *L) {
-  luaL_newmetatable(L, LUA_FILEHANDLE);  /* metatable for file handles */
-  luaL_setfuncs(L, metameth, 0);  /* add metamethods to new metatable */
-  luaL_newlibtable(L, meth);  /* create method table */
-  luaL_setfuncs(L, meth, 0);  /* add file methods to method table */
-  lua_setfield(L, -2, "__index");  /* metatable.__index = method table */
-  lua_pop(L, 1);  /* pop metatable */
-}
-
-
-/*
-** function to (not) close the standard files stdin, stdout, and stderr
-*/
-static int io_noclose (lua_State *L) {
-  LStream *p = tolstream(L);
-  p->closef = &io_noclose;  /* keep file opened */
-  luaL_pushfail(L);
-  lua_pushliteral(L, "cannot close standard file");
-  return 2;
-}
-
-
-static void createstdfile (lua_State *L, FILE *f, const char *k,
-                           const char *fname) {
-  LStream *p = newprefile(L);
-  p->f = f;
-  p->closef = &io_noclose;
-  if (k != NULL) {
-    lua_pushvalue(L, -1);
-    lua_setfield(L, LUA_REGISTRYINDEX, k);  /* add file to registry */
-  }
-  lua_setfield(L, -2, fname);  /* add file to module */
-}
-
-
-LUAMOD_API int luaopen_io (lua_State *L) {
-  luaL_newlib(L, iolib);  /* new module */
-  createmeta(L);
-  /* create (and set) default files */
-  createstdfile(L, stdin, IO_INPUT, "stdin");
-  createstdfile(L, stdout, IO_OUTPUT, "stdout");
-  createstdfile(L, stderr, NULL, "stderr");
-  return 1;
-}
-
diff --git a/third-party/lua/src/ljumptab.h b/third-party/lua/src/ljumptab.h
deleted file mode 100644
index 8306f250c..000000000
--- a/third-party/lua/src/ljumptab.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
-** $Id: ljumptab.h $
-** Jump Table for the Lua interpreter
-** See Copyright Notice in lua.h
-*/
-
-
-#undef vmdispatch
-#undef vmcase
-#undef vmbreak
-
-#define vmdispatch(x)     goto *disptab[x];
-
-#define vmcase(l)     L_##l:
-
-#define vmbreak		vmfetch(); vmdispatch(GET_OPCODE(i));
-
-
-static const void *const disptab[NUM_OPCODES] = {
-
-#if 0
-** you can update the following list with this command:
-**
-**  sed -n '/^OP_/\!d; s/OP_/\&\&L_OP_/ ; s/,.*/,/ ; s/\/.*// ; p'  lopcodes.h
-**
-#endif
-
-&&L_OP_MOVE,
-&&L_OP_LOADI,
-&&L_OP_LOADF,
-&&L_OP_LOADK,
-&&L_OP_LOADKX,
-&&L_OP_LOADFALSE,
-&&L_OP_LFALSESKIP,
-&&L_OP_LOADTRUE,
-&&L_OP_LOADNIL,
-&&L_OP_GETUPVAL,
-&&L_OP_SETUPVAL,
-&&L_OP_GETTABUP,
-&&L_OP_GETTABLE,
-&&L_OP_GETI,
-&&L_OP_GETFIELD,
-&&L_OP_SETTABUP,
-&&L_OP_SETTABLE,
-&&L_OP_SETI,
-&&L_OP_SETFIELD,
-&&L_OP_NEWTABLE,
-&&L_OP_SELF,
-&&L_OP_ADDI,
-&&L_OP_ADDK,
-&&L_OP_SUBK,
-&&L_OP_MULK,
-&&L_OP_MODK,
-&&L_OP_POWK,
-&&L_OP_DIVK,
-&&L_OP_IDIVK,
-&&L_OP_BANDK,
-&&L_OP_BORK,
-&&L_OP_BXORK,
-&&L_OP_SHRI,
-&&L_OP_SHLI,
-&&L_OP_ADD,
-&&L_OP_SUB,
-&&L_OP_MUL,
-&&L_OP_MOD,
-&&L_OP_POW,
-&&L_OP_DIV,
-&&L_OP_IDIV,
-&&L_OP_BAND,
-&&L_OP_BOR,
-&&L_OP_BXOR,
-&&L_OP_SHL,
-&&L_OP_SHR,
-&&L_OP_MMBIN,
-&&L_OP_MMBINI,
-&&L_OP_MMBINK,
-&&L_OP_UNM,
-&&L_OP_BNOT,
-&&L_OP_NOT,
-&&L_OP_LEN,
-&&L_OP_CONCAT,
-&&L_OP_CLOSE,
-&&L_OP_TBC,
-&&L_OP_JMP,
-&&L_OP_EQ,
-&&L_OP_LT,
-&&L_OP_LE,
-&&L_OP_EQK,
-&&L_OP_EQI,
-&&L_OP_LTI,
-&&L_OP_LEI,
-&&L_OP_GTI,
-&&L_OP_GEI,
-&&L_OP_TEST,
-&&L_OP_TESTSET,
-&&L_OP_CALL,
-&&L_OP_TAILCALL,
-&&L_OP_RETURN,
-&&L_OP_RETURN0,
-&&L_OP_RETURN1,
-&&L_OP_FORLOOP,
-&&L_OP_FORPREP,
-&&L_OP_TFORPREP,
-&&L_OP_TFORCALL,
-&&L_OP_TFORLOOP,
-&&L_OP_SETLIST,
-&&L_OP_CLOSURE,
-&&L_OP_VARARG,
-&&L_OP_VARARGPREP,
-&&L_OP_EXTRAARG
-
-};
diff --git a/third-party/lua/src/llex.c b/third-party/lua/src/llex.c
deleted file mode 100644
index 5fc39a5cd..000000000
--- a/third-party/lua/src/llex.c
+++ /dev/null
@@ -1,581 +0,0 @@
-/*
-** $Id: llex.c $
-** Lexical Analyzer
-** See Copyright Notice in lua.h
-*/
-
-#define llex_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <locale.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lctype.h"
-#include "ldebug.h"
-#include "ldo.h"
-#include "lgc.h"
-#include "llex.h"
-#include "lobject.h"
-#include "lparser.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "lzio.h"
-
-
-
-#define next(ls)	(ls->current = zgetc(ls->z))
-
-
-
-#define currIsNewline(ls)	(ls->current == '\n' || ls->current == '\r')
-
-
-/* ORDER RESERVED */
-static const char *const luaX_tokens [] = {
-    "and", "break", "do", "else", "elseif",
-    "end", "false", "for", "function", "goto", "if",
-    "in", "local", "nil", "not", "or", "repeat",
-    "return", "then", "true", "until", "while",
-    "//", "..", "...", "==", ">=", "<=", "~=",
-    "<<", ">>", "::", "<eof>",
-    "<number>", "<integer>", "<name>", "<string>"
-};
-
-
-#define save_and_next(ls) (save(ls, ls->current), next(ls))
-
-
-static l_noret lexerror (LexState *ls, const char *msg, int token);
-
-
-static void save (LexState *ls, int c) {
-  Mbuffer *b = ls->buff;
-  if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) {
-    size_t newsize;
-    if (luaZ_sizebuffer(b) >= MAX_SIZE/2)
-      lexerror(ls, "lexical element too long", 0);
-    newsize = luaZ_sizebuffer(b) * 2;
-    luaZ_resizebuffer(ls->L, b, newsize);
-  }
-  b->buffer[luaZ_bufflen(b)++] = cast_char(c);
-}
-
-
-void luaX_init (lua_State *L) {
-  int i;
-  TString *e = luaS_newliteral(L, LUA_ENV);  /* create env name */
-  luaC_fix(L, obj2gco(e));  /* never collect this name */
-  for (i=0; i<NUM_RESERVED; i++) {
-    TString *ts = luaS_new(L, luaX_tokens[i]);
-    luaC_fix(L, obj2gco(ts));  /* reserved words are never collected */
-    ts->extra = cast_byte(i+1);  /* reserved word */
-  }
-}
-
-
-const char *luaX_token2str (LexState *ls, int token) {
-  if (token < FIRST_RESERVED) {  /* single-byte symbols? */
-    if (lisprint(token))
-      return luaO_pushfstring(ls->L, "'%c'", token);
-    else  /* control character */
-      return luaO_pushfstring(ls->L, "'<\\%d>'", token);
-  }
-  else {
-    const char *s = luaX_tokens[token - FIRST_RESERVED];
-    if (token < TK_EOS)  /* fixed format (symbols and reserved words)? */
-      return luaO_pushfstring(ls->L, "'%s'", s);
-    else  /* names, strings, and numerals */
-      return s;
-  }
-}
-
-
-static const char *txtToken (LexState *ls, int token) {
-  switch (token) {
-    case TK_NAME: case TK_STRING:
-    case TK_FLT: case TK_INT:
-      save(ls, '\0');
-      return luaO_pushfstring(ls->L, "'%s'", luaZ_buffer(ls->buff));
-    default:
-      return luaX_token2str(ls, token);
-  }
-}
-
-
-static l_noret lexerror (LexState *ls, const char *msg, int token) {
-  msg = luaG_addinfo(ls->L, msg, ls->source, ls->linenumber);
-  if (token)
-    luaO_pushfstring(ls->L, "%s near %s", msg, txtToken(ls, token));
-  luaD_throw(ls->L, LUA_ERRSYNTAX);
-}
-
-
-l_noret luaX_syntaxerror (LexState *ls, const char *msg) {
-  lexerror(ls, msg, ls->t.token);
-}
-
-
-/*
-** Creates a new string and anchors it in scanner's table so that it
-** will not be collected until the end of the compilation; by that time
-** it should be anchored somewhere. It also internalizes long strings,
-** ensuring there is only one copy of each unique string.  The table
-** here is used as a set: the string enters as the key, while its value
-** is irrelevant. We use the string itself as the value only because it
-** is a TValue readily available. Later, the code generation can change
-** this value.
-*/
-TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
-  lua_State *L = ls->L;
-  TString *ts = luaS_newlstr(L, str, l);  /* create new string */
-  const TValue *o = luaH_getstr(ls->h, ts);
-  if (!ttisnil(o))  /* string already present? */
-    ts = keystrval(nodefromval(o));  /* get saved copy */
-  else {  /* not in use yet */
-    TValue *stv = s2v(L->top.p++);  /* reserve stack space for string */
-    setsvalue(L, stv, ts);  /* temporarily anchor the string */
-    luaH_finishset(L, ls->h, stv, o, stv);  /* t[string] = string */
-    /* table is not a metatable, so it does not need to invalidate cache */
-    luaC_checkGC(L);
-    L->top.p--;  /* remove string from stack */
-  }
-  return ts;
-}
-
-
-/*
-** increment line number and skips newline sequence (any of
-** \n, \r, \n\r, or \r\n)
-*/
-static void inclinenumber (LexState *ls) {
-  int old = ls->current;
-  lua_assert(currIsNewline(ls));
-  next(ls);  /* skip '\n' or '\r' */
-  if (currIsNewline(ls) && ls->current != old)
-    next(ls);  /* skip '\n\r' or '\r\n' */
-  if (++ls->linenumber >= MAX_INT)
-    lexerror(ls, "chunk has too many lines", 0);
-}
-
-
-void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source,
-                    int firstchar) {
-  ls->t.token = 0;
-  ls->L = L;
-  ls->current = firstchar;
-  ls->lookahead.token = TK_EOS;  /* no look-ahead token */
-  ls->z = z;
-  ls->fs = NULL;
-  ls->linenumber = 1;
-  ls->lastline = 1;
-  ls->source = source;
-  ls->envn = luaS_newliteral(L, LUA_ENV);  /* get env name */
-  luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER);  /* initialize buffer */
-}
-
-
-
-/*
-** =======================================================
-** LEXICAL ANALYZER
-** =======================================================
-*/
-
-
-static int check_next1 (LexState *ls, int c) {
-  if (ls->current == c) {
-    next(ls);
-    return 1;
-  }
-  else return 0;
-}
-
-
-/*
-** Check whether current char is in set 'set' (with two chars) and
-** saves it
-*/
-static int check_next2 (LexState *ls, const char *set) {
-  lua_assert(set[2] == '\0');
-  if (ls->current == set[0] || ls->current == set[1]) {
-    save_and_next(ls);
-    return 1;
-  }
-  else return 0;
-}
-
-
-/* LUA_NUMBER */
-/*
-** This function is quite liberal in what it accepts, as 'luaO_str2num'
-** will reject ill-formed numerals. Roughly, it accepts the following
-** pattern:
-**
-**   %d(%x|%.|([Ee][+-]?))* | 0[Xx](%x|%.|([Pp][+-]?))*
-**
-** The only tricky part is to accept [+-] only after a valid exponent
-** mark, to avoid reading '3-4' or '0xe+1' as a single number.
-**
-** The caller might have already read an initial dot.
-*/
-static int read_numeral (LexState *ls, SemInfo *seminfo) {
-  TValue obj;
-  const char *expo = "Ee";
-  int first = ls->current;
-  lua_assert(lisdigit(ls->current));
-  save_and_next(ls);
-  if (first == '0' && check_next2(ls, "xX"))  /* hexadecimal? */
-    expo = "Pp";
-  for (;;) {
-    if (check_next2(ls, expo))  /* exponent mark? */
-      check_next2(ls, "-+");  /* optional exponent sign */
-    else if (lisxdigit(ls->current) || ls->current == '.')  /* '%x|%.' */
-      save_and_next(ls);
-    else break;
-  }
-  if (lislalpha(ls->current))  /* is numeral touching a letter? */
-    save_and_next(ls);  /* force an error */
-  save(ls, '\0');
-  if (luaO_str2num(luaZ_buffer(ls->buff), &obj) == 0)  /* format error? */
-    lexerror(ls, "malformed number", TK_FLT);
-  if (ttisinteger(&obj)) {
-    seminfo->i = ivalue(&obj);
-    return TK_INT;
-  }
-  else {
-    lua_assert(ttisfloat(&obj));
-    seminfo->r = fltvalue(&obj);
-    return TK_FLT;
-  }
-}
-
-
-/*
-** read a sequence '[=*[' or ']=*]', leaving the last bracket. If
-** sequence is well formed, return its number of '='s + 2; otherwise,
-** return 1 if it is a single bracket (no '='s and no 2nd bracket);
-** otherwise (an unfinished '[==...') return 0.
-*/
-static size_t skip_sep (LexState *ls) {
-  size_t count = 0;
-  int s = ls->current;
-  lua_assert(s == '[' || s == ']');
-  save_and_next(ls);
-  while (ls->current == '=') {
-    save_and_next(ls);
-    count++;
-  }
-  return (ls->current == s) ? count + 2
-         : (count == 0) ? 1
-         : 0;
-}
-
-
-static void read_long_string (LexState *ls, SemInfo *seminfo, size_t sep) {
-  int line = ls->linenumber;  /* initial line (for error message) */
-  save_and_next(ls);  /* skip 2nd '[' */
-  if (currIsNewline(ls))  /* string starts with a newline? */
-    inclinenumber(ls);  /* skip it */
-  for (;;) {
-    switch (ls->current) {
-      case EOZ: {  /* error */
-        const char *what = (seminfo ? "string" : "comment");
-        const char *msg = luaO_pushfstring(ls->L,
-                     "unfinished long %s (starting at line %d)", what, line);
-        lexerror(ls, msg, TK_EOS);
-        break;  /* to avoid warnings */
-      }
-      case ']': {
-        if (skip_sep(ls) == sep) {
-          save_and_next(ls);  /* skip 2nd ']' */
-          goto endloop;
-        }
-        break;
-      }
-      case '\n': case '\r': {
-        save(ls, '\n');
-        inclinenumber(ls);
-        if (!seminfo) luaZ_resetbuffer(ls->buff);  /* avoid wasting space */
-        break;
-      }
-      default: {
-        if (seminfo) save_and_next(ls);
-        else next(ls);
-      }
-    }
-  } endloop:
-  if (seminfo)
-    seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + sep,
-                                     luaZ_bufflen(ls->buff) - 2 * sep);
-}
-
-
-static void esccheck (LexState *ls, int c, const char *msg) {
-  if (!c) {
-    if (ls->current != EOZ)
-      save_and_next(ls);  /* add current to buffer for error message */
-    lexerror(ls, msg, TK_STRING);
-  }
-}
-
-
-static int gethexa (LexState *ls) {
-  save_and_next(ls);
-  esccheck (ls, lisxdigit(ls->current), "hexadecimal digit expected");
-  return luaO_hexavalue(ls->current);
-}
-
-
-static int readhexaesc (LexState *ls) {
-  int r = gethexa(ls);
-  r = (r << 4) + gethexa(ls);
-  luaZ_buffremove(ls->buff, 2);  /* remove saved chars from buffer */
-  return r;
-}
-
-
-static unsigned long readutf8esc (LexState *ls) {
-  unsigned long r;
-  int i = 4;  /* chars to be removed: '\', 'u', '{', and first digit */
-  save_and_next(ls);  /* skip 'u' */
-  esccheck(ls, ls->current == '{', "missing '{'");
-  r = gethexa(ls);  /* must have at least one digit */
-  while (cast_void(save_and_next(ls)), lisxdigit(ls->current)) {
-    i++;
-    esccheck(ls, r <= (0x7FFFFFFFu >> 4), "UTF-8 value too large");
-    r = (r << 4) + luaO_hexavalue(ls->current);
-  }
-  esccheck(ls, ls->current == '}', "missing '}'");
-  next(ls);  /* skip '}' */
-  luaZ_buffremove(ls->buff, i);  /* remove saved chars from buffer */
-  return r;
-}
-
-
-static void utf8esc (LexState *ls) {
-  char buff[UTF8BUFFSZ];
-  int n = luaO_utf8esc(buff, readutf8esc(ls));
-  for (; n > 0; n--)  /* add 'buff' to string */
-    save(ls, buff[UTF8BUFFSZ - n]);
-}
-
-
-static int readdecesc (LexState *ls) {
-  int i;
-  int r = 0;  /* result accumulator */
-  for (i = 0; i < 3 && lisdigit(ls->current); i++) {  /* read up to 3 digits */
-    r = 10*r + ls->current - '0';
-    save_and_next(ls);
-  }
-  esccheck(ls, r <= UCHAR_MAX, "decimal escape too large");
-  luaZ_buffremove(ls->buff, i);  /* remove read digits from buffer */
-  return r;
-}
-
-
-static void read_string (LexState *ls, int del, SemInfo *seminfo) {
-  save_and_next(ls);  /* keep delimiter (for error messages) */
-  while (ls->current != del) {
-    switch (ls->current) {
-      case EOZ:
-        lexerror(ls, "unfinished string", TK_EOS);
-        break;  /* to avoid warnings */
-      case '\n':
-      case '\r':
-        lexerror(ls, "unfinished string", TK_STRING);
-        break;  /* to avoid warnings */
-      case '\\': {  /* escape sequences */
-        int c;  /* final character to be saved */
-        save_and_next(ls);  /* keep '\\' for error messages */
-        switch (ls->current) {
-          case 'a': c = '\a'; goto read_save;
-          case 'b': c = '\b'; goto read_save;
-          case 'f': c = '\f'; goto read_save;
-          case 'n': c = '\n'; goto read_save;
-          case 'r': c = '\r'; goto read_save;
-          case 't': c = '\t'; goto read_save;
-          case 'v': c = '\v'; goto read_save;
-          case 'x': c = readhexaesc(ls); goto read_save;
-          case 'u': utf8esc(ls);  goto no_save;
-          case '\n': case '\r':
-            inclinenumber(ls); c = '\n'; goto only_save;
-          case '\\': case '\"': case '\'':
-            c = ls->current; goto read_save;
-          case EOZ: goto no_save;  /* will raise an error next loop */
-          case 'z': {  /* zap following span of spaces */
-            luaZ_buffremove(ls->buff, 1);  /* remove '\\' */
-            next(ls);  /* skip the 'z' */
-            while (lisspace(ls->current)) {
-              if (currIsNewline(ls)) inclinenumber(ls);
-              else next(ls);
-            }
-            goto no_save;
-          }
-          default: {
-            esccheck(ls, lisdigit(ls->current), "invalid escape sequence");
-            c = readdecesc(ls);  /* digital escape '\ddd' */
-            goto only_save;
-          }
-        }
-       read_save:
-         next(ls);
-         /* go through */
-       only_save:
-         luaZ_buffremove(ls->buff, 1);  /* remove '\\' */
-         save(ls, c);
-         /* go through */
-       no_save: break;
-      }
-      default:
-        save_and_next(ls);
-    }
-  }
-  save_and_next(ls);  /* skip delimiter */
-  seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1,
-                                   luaZ_bufflen(ls->buff) - 2);
-}
-
-
-static int llex (LexState *ls, SemInfo *seminfo) {
-  luaZ_resetbuffer(ls->buff);
-  for (;;) {
-    switch (ls->current) {
-      case '\n': case '\r': {  /* line breaks */
-        inclinenumber(ls);
-        break;
-      }
-      case ' ': case '\f': case '\t': case '\v': {  /* spaces */
-        next(ls);
-        break;
-      }
-      case '-': {  /* '-' or '--' (comment) */
-        next(ls);
-        if (ls->current != '-') return '-';
-        /* else is a comment */
-        next(ls);
-        if (ls->current == '[') {  /* long comment? */
-          size_t sep = skip_sep(ls);
-          luaZ_resetbuffer(ls->buff);  /* 'skip_sep' may dirty the buffer */
-          if (sep >= 2) {
-            read_long_string(ls, NULL, sep);  /* skip long comment */
-            luaZ_resetbuffer(ls->buff);  /* previous call may dirty the buff. */
-            break;
-          }
-        }
-        /* else short comment */
-        while (!currIsNewline(ls) && ls->current != EOZ)
-          next(ls);  /* skip until end of line (or end of file) */
-        break;
-      }
-      case '[': {  /* long string or simply '[' */
-        size_t sep = skip_sep(ls);
-        if (sep >= 2) {
-          read_long_string(ls, seminfo, sep);
-          return TK_STRING;
-        }
-        else if (sep == 0)  /* '[=...' missing second bracket? */
-          lexerror(ls, "invalid long string delimiter", TK_STRING);
-        return '[';
-      }
-      case '=': {
-        next(ls);
-        if (check_next1(ls, '=')) return TK_EQ;  /* '==' */
-        else return '=';
-      }
-      case '<': {
-        next(ls);
-        if (check_next1(ls, '=')) return TK_LE;  /* '<=' */
-        else if (check_next1(ls, '<')) return TK_SHL;  /* '<<' */
-        else return '<';
-      }
-      case '>': {
-        next(ls);
-        if (check_next1(ls, '=')) return TK_GE;  /* '>=' */
-        else if (check_next1(ls, '>')) return TK_SHR;  /* '>>' */
-        else return '>';
-      }
-      case '/': {
-        next(ls);
-        if (check_next1(ls, '/')) return TK_IDIV;  /* '//' */
-        else return '/';
-      }
-      case '~': {
-        next(ls);
-        if (check_next1(ls, '=')) return TK_NE;  /* '~=' */
-        else return '~';
-      }
-      case ':': {
-        next(ls);
-        if (check_next1(ls, ':')) return TK_DBCOLON;  /* '::' */
-        else return ':';
-      }
-      case '"': case '\'': {  /* short literal strings */
-        read_string(ls, ls->current, seminfo);
-        return TK_STRING;
-      }
-      case '.': {  /* '.', '..', '...', or number */
-        save_and_next(ls);
-        if (check_next1(ls, '.')) {
-          if (check_next1(ls, '.'))
-            return TK_DOTS;   /* '...' */
-          else return TK_CONCAT;   /* '..' */
-        }
-        else if (!lisdigit(ls->current)) return '.';
-        else return read_numeral(ls, seminfo);
-      }
-      case '0': case '1': case '2': case '3': case '4':
-      case '5': case '6': case '7': case '8': case '9': {
-        return read_numeral(ls, seminfo);
-      }
-      case EOZ: {
-        return TK_EOS;
-      }
-      default: {
-        if (lislalpha(ls->current)) {  /* identifier or reserved word? */
-          TString *ts;
-          do {
-            save_and_next(ls);
-          } while (lislalnum(ls->current));
-          ts = luaX_newstring(ls, luaZ_buffer(ls->buff),
-                                  luaZ_bufflen(ls->buff));
-          seminfo->ts = ts;
-          if (isreserved(ts))  /* reserved word? */
-            return ts->extra - 1 + FIRST_RESERVED;
-          else {
-            return TK_NAME;
-          }
-        }
-        else {  /* single-char tokens ('+', '*', '%', '{', '}', ...) */
-          int c = ls->current;
-          next(ls);
-          return c;
-        }
-      }
-    }
-  }
-}
-
-
-void luaX_next (LexState *ls) {
-  ls->lastline = ls->linenumber;
-  if (ls->lookahead.token != TK_EOS) {  /* is there a look-ahead token? */
-    ls->t = ls->lookahead;  /* use this one */
-    ls->lookahead.token = TK_EOS;  /* and discharge it */
-  }
-  else
-    ls->t.token = llex(ls, &ls->t.seminfo);  /* read next token */
-}
-
-
-int luaX_lookahead (LexState *ls) {
-  lua_assert(ls->lookahead.token == TK_EOS);
-  ls->lookahead.token = llex(ls, &ls->lookahead.seminfo);
-  return ls->lookahead.token;
-}
-
diff --git a/third-party/lua/src/llex.h b/third-party/lua/src/llex.h
deleted file mode 100644
index 389d2f863..000000000
--- a/third-party/lua/src/llex.h
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
-** $Id: llex.h $
-** Lexical Analyzer
-** See Copyright Notice in lua.h
-*/
-
-#ifndef llex_h
-#define llex_h
-
-#include <limits.h>
-
-#include "lobject.h"
-#include "lzio.h"
-
-
-/*
-** Single-char tokens (terminal symbols) are represented by their own
-** numeric code. Other tokens start at the following value.
-*/
-#define FIRST_RESERVED	(UCHAR_MAX + 1)
-
-
-#if !defined(LUA_ENV)
-#define LUA_ENV		"_ENV"
-#endif
-
-
-/*
-* WARNING: if you change the order of this enumeration,
-* grep "ORDER RESERVED"
-*/
-enum RESERVED {
-  /* terminal symbols denoted by reserved words */
-  TK_AND = FIRST_RESERVED, TK_BREAK,
-  TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FALSE, TK_FOR, TK_FUNCTION,
-  TK_GOTO, TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT,
-  TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE,
-  /* other terminal symbols */
-  TK_IDIV, TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE,
-  TK_SHL, TK_SHR,
-  TK_DBCOLON, TK_EOS,
-  TK_FLT, TK_INT, TK_NAME, TK_STRING
-};
-
-/* number of reserved words */
-#define NUM_RESERVED	(cast_int(TK_WHILE-FIRST_RESERVED + 1))
-
-
-typedef union {
-  lua_Number r;
-  lua_Integer i;
-  TString *ts;
-} SemInfo;  /* semantics information */
-
-
-typedef struct Token {
-  int token;
-  SemInfo seminfo;
-} Token;
-
-
-/* state of the lexer plus state of the parser when shared by all
-   functions */
-typedef struct LexState {
-  int current;  /* current character (charint) */
-  int linenumber;  /* input line counter */
-  int lastline;  /* line of last token 'consumed' */
-  Token t;  /* current token */
-  Token lookahead;  /* look ahead token */
-  struct FuncState *fs;  /* current function (parser) */
-  struct lua_State *L;
-  ZIO *z;  /* input stream */
-  Mbuffer *buff;  /* buffer for tokens */
-  Table *h;  /* to avoid collection/reuse strings */
-  struct Dyndata *dyd;  /* dynamic structures used by the parser */
-  TString *source;  /* current source name */
-  TString *envn;  /* environment variable name */
-} LexState;
-
-
-LUAI_FUNC void luaX_init (lua_State *L);
-LUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z,
-                              TString *source, int firstchar);
-LUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l);
-LUAI_FUNC void luaX_next (LexState *ls);
-LUAI_FUNC int luaX_lookahead (LexState *ls);
-LUAI_FUNC l_noret luaX_syntaxerror (LexState *ls, const char *s);
-LUAI_FUNC const char *luaX_token2str (LexState *ls, int token);
-
-
-#endif
diff --git a/third-party/lua/src/llimits.h b/third-party/lua/src/llimits.h
deleted file mode 100644
index 1c826f7be..000000000
--- a/third-party/lua/src/llimits.h
+++ /dev/null
@@ -1,380 +0,0 @@
-/*
-** $Id: llimits.h $
-** Limits, basic types, and some other 'installation-dependent' definitions
-** See Copyright Notice in lua.h
-*/
-
-#ifndef llimits_h
-#define llimits_h
-
-
-#include <limits.h>
-#include <stddef.h>
-
-
-#include "lua.h"
-
-
-/*
-** 'lu_mem' and 'l_mem' are unsigned/signed integers big enough to count
-** the total memory used by Lua (in bytes). Usually, 'size_t' and
-** 'ptrdiff_t' should work, but we use 'long' for 16-bit machines.
-*/
-#if defined(LUAI_MEM)		/* { external definitions? */
-typedef LUAI_UMEM lu_mem;
-typedef LUAI_MEM l_mem;
-#elif LUAI_IS32INT	/* }{ */
-typedef size_t lu_mem;
-typedef ptrdiff_t l_mem;
-#else  /* 16-bit ints */	/* }{ */
-typedef unsigned long lu_mem;
-typedef long l_mem;
-#endif				/* } */
-
-
-/* chars used as small naturals (so that 'char' is reserved for characters) */
-typedef unsigned char lu_byte;
-typedef signed char ls_byte;
-
-
-/* maximum value for size_t */
-#define MAX_SIZET	((size_t)(~(size_t)0))
-
-/* maximum size visible for Lua (must be representable in a lua_Integer) */
-#define MAX_SIZE	(sizeof(size_t) < sizeof(lua_Integer) ? MAX_SIZET \
-                          : (size_t)(LUA_MAXINTEGER))
-
-
-#define MAX_LUMEM	((lu_mem)(~(lu_mem)0))
-
-#define MAX_LMEM	((l_mem)(MAX_LUMEM >> 1))
-
-
-#define MAX_INT		INT_MAX  /* maximum value of an int */
-
-
-/*
-** floor of the log2 of the maximum signed value for integral type 't'.
-** (That is, maximum 'n' such that '2^n' fits in the given signed type.)
-*/
-#define log2maxs(t)	(sizeof(t) * 8 - 2)
-
-
-/*
-** test whether an unsigned value is a power of 2 (or zero)
-*/
-#define ispow2(x)	(((x) & ((x) - 1)) == 0)
-
-
-/* number of chars of a literal string without the ending \0 */
-#define LL(x)   (sizeof(x)/sizeof(char) - 1)
-
-
-/*
-** conversion of pointer to unsigned integer: this is for hashing only;
-** there is no problem if the integer cannot hold the whole pointer
-** value. (In strict ISO C this may cause undefined behavior, but no
-** actual machine seems to bother.)
-*/
-#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \
-    __STDC_VERSION__ >= 199901L
-#include <stdint.h>
-#if defined(UINTPTR_MAX)  /* even in C99 this type is optional */
-#define L_P2I	uintptr_t
-#else  /* no 'intptr'? */
-#define L_P2I	uintmax_t  /* use the largest available integer */
-#endif
-#else  /* C89 option */
-#define L_P2I	size_t
-#endif
-
-#define point2uint(p)	((unsigned int)((L_P2I)(p) & UINT_MAX))
-
-
-
-/* types of 'usual argument conversions' for lua_Number and lua_Integer */
-typedef LUAI_UACNUMBER l_uacNumber;
-typedef LUAI_UACINT l_uacInt;
-
-
-/*
-** Internal assertions for in-house debugging
-*/
-#if defined LUAI_ASSERT
-#undef NDEBUG
-#include <assert.h>
-#define lua_assert(c)           assert(c)
-#endif
-
-#if defined(lua_assert)
-#define check_exp(c,e)		(lua_assert(c), (e))
-/* to avoid problems with conditions too long */
-#define lua_longassert(c)	((c) ? (void)0 : lua_assert(0))
-#else
-#define lua_assert(c)		((void)0)
-#define check_exp(c,e)		(e)
-#define lua_longassert(c)	((void)0)
-#endif
-
-/*
-** assertion for checking API calls
-*/
-#if !defined(luai_apicheck)
-#define luai_apicheck(l,e)	((void)l, lua_assert(e))
-#endif
-
-#define api_check(l,e,msg)	luai_apicheck(l,(e) && msg)
-
-
-/* macro to avoid warnings about unused variables */
-#if !defined(UNUSED)
-#define UNUSED(x)	((void)(x))
-#endif
-
-
-/* type casts (a macro highlights casts in the code) */
-#define cast(t, exp)	((t)(exp))
-
-#define cast_void(i)	cast(void, (i))
-#define cast_voidp(i)	cast(void *, (i))
-#define cast_num(i)	cast(lua_Number, (i))
-#define cast_int(i)	cast(int, (i))
-#define cast_uint(i)	cast(unsigned int, (i))
-#define cast_byte(i)	cast(lu_byte, (i))
-#define cast_uchar(i)	cast(unsigned char, (i))
-#define cast_char(i)	cast(char, (i))
-#define cast_charp(i)	cast(char *, (i))
-#define cast_sizet(i)	cast(size_t, (i))
-
-
-/* cast a signed lua_Integer to lua_Unsigned */
-#if !defined(l_castS2U)
-#define l_castS2U(i)	((lua_Unsigned)(i))
-#endif
-
-/*
-** cast a lua_Unsigned to a signed lua_Integer; this cast is
-** not strict ISO C, but two-complement architectures should
-** work fine.
-*/
-#if !defined(l_castU2S)
-#define l_castU2S(i)	((lua_Integer)(i))
-#endif
-
-
-/*
-** non-return type
-*/
-#if !defined(l_noret)
-
-#if defined(__GNUC__)
-#define l_noret		void __attribute__((noreturn))
-#elif defined(_MSC_VER) && _MSC_VER >= 1200
-#define l_noret		void __declspec(noreturn)
-#else
-#define l_noret		void
-#endif
-
-#endif
-
-
-/*
-** Inline functions
-*/
-#if !defined(LUA_USE_C89)
-#define l_inline	inline
-#elif defined(__GNUC__)
-#define l_inline	__inline__
-#else
-#define l_inline	/* empty */
-#endif
-
-#define l_sinline	static l_inline
-
-
-/*
-** type for virtual-machine instructions;
-** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)
-*/
-#if LUAI_IS32INT
-typedef unsigned int l_uint32;
-#else
-typedef unsigned long l_uint32;
-#endif
-
-typedef l_uint32 Instruction;
-
-
-
-/*
-** Maximum length for short strings, that is, strings that are
-** internalized. (Cannot be smaller than reserved words or tags for
-** metamethods, as these strings must be internalized;
-** #("function") = 8, #("__newindex") = 10.)
-*/
-#if !defined(LUAI_MAXSHORTLEN)
-#define LUAI_MAXSHORTLEN	40
-#endif
-
-
-/*
-** Initial size for the string table (must be power of 2).
-** The Lua core alone registers ~50 strings (reserved words +
-** metaevent keys + a few others). Libraries would typically add
-** a few dozens more.
-*/
-#if !defined(MINSTRTABSIZE)
-#define MINSTRTABSIZE	128
-#endif
-
-
-/*
-** Size of cache for strings in the API. 'N' is the number of
-** sets (better be a prime) and "M" is the size of each set (M == 1
-** makes a direct cache.)
-*/
-#if !defined(STRCACHE_N)
-#define STRCACHE_N		53
-#define STRCACHE_M		2
-#endif
-
-
-/* minimum size for string buffer */
-#if !defined(LUA_MINBUFFER)
-#define LUA_MINBUFFER	32
-#endif
-
-
-/*
-** Maximum depth for nested C calls, syntactical nested non-terminals,
-** and other features implemented through recursion in C. (Value must
-** fit in a 16-bit unsigned integer. It must also be compatible with
-** the size of the C stack.)
-*/
-#if !defined(LUAI_MAXCCALLS)
-#define LUAI_MAXCCALLS		200
-#endif
-
-
-/*
-** macros that are executed whenever program enters the Lua core
-** ('lua_lock') and leaves the core ('lua_unlock')
-*/
-#if !defined(lua_lock)
-#define lua_lock(L)	((void) 0)
-#define lua_unlock(L)	((void) 0)
-#endif
-
-/*
-** macro executed during Lua functions at points where the
-** function can yield.
-*/
-#if !defined(luai_threadyield)
-#define luai_threadyield(L)	{lua_unlock(L); lua_lock(L);}
-#endif
-
-
-/*
-** these macros allow user-specific actions when a thread is
-** created/deleted/resumed/yielded.
-*/
-#if !defined(luai_userstateopen)
-#define luai_userstateopen(L)		((void)L)
-#endif
-
-#if !defined(luai_userstateclose)
-#define luai_userstateclose(L)		((void)L)
-#endif
-
-#if !defined(luai_userstatethread)
-#define luai_userstatethread(L,L1)	((void)L)
-#endif
-
-#if !defined(luai_userstatefree)
-#define luai_userstatefree(L,L1)	((void)L)
-#endif
-
-#if !defined(luai_userstateresume)
-#define luai_userstateresume(L,n)	((void)L)
-#endif
-
-#if !defined(luai_userstateyield)
-#define luai_userstateyield(L,n)	((void)L)
-#endif
-
-
-
-/*
-** The luai_num* macros define the primitive operations over numbers.
-*/
-
-/* floor division (defined as 'floor(a/b)') */
-#if !defined(luai_numidiv)
-#define luai_numidiv(L,a,b)     ((void)L, l_floor(luai_numdiv(L,a,b)))
-#endif
-
-/* float division */
-#if !defined(luai_numdiv)
-#define luai_numdiv(L,a,b)      ((a)/(b))
-#endif
-
-/*
-** modulo: defined as 'a - floor(a/b)*b'; the direct computation
-** using this definition has several problems with rounding errors,
-** so it is better to use 'fmod'. 'fmod' gives the result of
-** 'a - trunc(a/b)*b', and therefore must be corrected when
-** 'trunc(a/b) ~= floor(a/b)'. That happens when the division has a
-** non-integer negative result: non-integer result is equivalent to
-** a non-zero remainder 'm'; negative result is equivalent to 'a' and
-** 'b' with different signs, or 'm' and 'b' with different signs
-** (as the result 'm' of 'fmod' has the same sign of 'a').
-*/
-#if !defined(luai_nummod)
-#define luai_nummod(L,a,b,m)  \
-  { (void)L; (m) = l_mathop(fmod)(a,b); \
-    if (((m) > 0) ? (b) < 0 : ((m) < 0 && (b) > 0)) (m) += (b); }
-#endif
-
-/* exponentiation */
-#if !defined(luai_numpow)
-#define luai_numpow(L,a,b)  \
-  ((void)L, (b == 2) ? (a)*(a) : l_mathop(pow)(a,b))
-#endif
-
-/* the others are quite standard operations */
-#if !defined(luai_numadd)
-#define luai_numadd(L,a,b)      ((a)+(b))
-#define luai_numsub(L,a,b)      ((a)-(b))
-#define luai_nummul(L,a,b)      ((a)*(b))
-#define luai_numunm(L,a)        (-(a))
-#define luai_numeq(a,b)         ((a)==(b))
-#define luai_numlt(a,b)         ((a)<(b))
-#define luai_numle(a,b)         ((a)<=(b))
-#define luai_numgt(a,b)         ((a)>(b))
-#define luai_numge(a,b)         ((a)>=(b))
-#define luai_numisnan(a)        (!luai_numeq((a), (a)))
-#endif
-
-
-
-
-
-/*
-** macro to control inclusion of some hard tests on stack reallocation
-*/
-#if !defined(HARDSTACKTESTS)
-#define condmovestack(L,pre,pos)	((void)0)
-#else
-/* realloc stack keeping its size */
-#define condmovestack(L,pre,pos)  \
-  { int sz_ = stacksize(L); pre; luaD_reallocstack((L), sz_, 0); pos; }
-#endif
-
-#if !defined(HARDMEMTESTS)
-#define condchangemem(L,pre,pos)	((void)0)
-#else
-#define condchangemem(L,pre,pos)  \
-	{ if (gcrunning(G(L))) { pre; luaC_fullgc(L, 0); pos; } }
-#endif
-
-#endif
diff --git a/third-party/lua/src/lmathlib.c b/third-party/lua/src/lmathlib.c
deleted file mode 100644
index d0b1e1e5d..000000000
--- a/third-party/lua/src/lmathlib.c
+++ /dev/null
@@ -1,764 +0,0 @@
-/*
-** $Id: lmathlib.c $
-** Standard mathematical library
-** See Copyright Notice in lua.h
-*/
-
-#define lmathlib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <float.h>
-#include <limits.h>
-#include <math.h>
-#include <stdlib.h>
-#include <time.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-#undef PI
-#define PI	(l_mathop(3.141592653589793238462643383279502884))
-
-
-static int math_abs (lua_State *L) {
-  if (lua_isinteger(L, 1)) {
-    lua_Integer n = lua_tointeger(L, 1);
-    if (n < 0) n = (lua_Integer)(0u - (lua_Unsigned)n);
-    lua_pushinteger(L, n);
-  }
-  else
-    lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_sin (lua_State *L) {
-  lua_pushnumber(L, l_mathop(sin)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_cos (lua_State *L) {
-  lua_pushnumber(L, l_mathop(cos)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_tan (lua_State *L) {
-  lua_pushnumber(L, l_mathop(tan)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_asin (lua_State *L) {
-  lua_pushnumber(L, l_mathop(asin)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_acos (lua_State *L) {
-  lua_pushnumber(L, l_mathop(acos)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_atan (lua_State *L) {
-  lua_Number y = luaL_checknumber(L, 1);
-  lua_Number x = luaL_optnumber(L, 2, 1);
-  lua_pushnumber(L, l_mathop(atan2)(y, x));
-  return 1;
-}
-
-
-static int math_toint (lua_State *L) {
-  int valid;
-  lua_Integer n = lua_tointegerx(L, 1, &valid);
-  if (l_likely(valid))
-    lua_pushinteger(L, n);
-  else {
-    luaL_checkany(L, 1);
-    luaL_pushfail(L);  /* value is not convertible to integer */
-  }
-  return 1;
-}
-
-
-static void pushnumint (lua_State *L, lua_Number d) {
-  lua_Integer n;
-  if (lua_numbertointeger(d, &n))  /* does 'd' fit in an integer? */
-    lua_pushinteger(L, n);  /* result is integer */
-  else
-    lua_pushnumber(L, d);  /* result is float */
-}
-
-
-static int math_floor (lua_State *L) {
-  if (lua_isinteger(L, 1))
-    lua_settop(L, 1);  /* integer is its own floor */
-  else {
-    lua_Number d = l_mathop(floor)(luaL_checknumber(L, 1));
-    pushnumint(L, d);
-  }
-  return 1;
-}
-
-
-static int math_ceil (lua_State *L) {
-  if (lua_isinteger(L, 1))
-    lua_settop(L, 1);  /* integer is its own ceil */
-  else {
-    lua_Number d = l_mathop(ceil)(luaL_checknumber(L, 1));
-    pushnumint(L, d);
-  }
-  return 1;
-}
-
-
-static int math_fmod (lua_State *L) {
-  if (lua_isinteger(L, 1) && lua_isinteger(L, 2)) {
-    lua_Integer d = lua_tointeger(L, 2);
-    if ((lua_Unsigned)d + 1u <= 1u) {  /* special cases: -1 or 0 */
-      luaL_argcheck(L, d != 0, 2, "zero");
-      lua_pushinteger(L, 0);  /* avoid overflow with 0x80000... / -1 */
-    }
-    else
-      lua_pushinteger(L, lua_tointeger(L, 1) % d);
-  }
-  else
-    lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1),
-                                     luaL_checknumber(L, 2)));
-  return 1;
-}
-
-
-/*
-** next function does not use 'modf', avoiding problems with 'double*'
-** (which is not compatible with 'float*') when lua_Number is not
-** 'double'.
-*/
-static int math_modf (lua_State *L) {
-  if (lua_isinteger(L ,1)) {
-    lua_settop(L, 1);  /* number is its own integer part */
-    lua_pushnumber(L, 0);  /* no fractional part */
-  }
-  else {
-    lua_Number n = luaL_checknumber(L, 1);
-    /* integer part (rounds toward zero) */
-    lua_Number ip = (n < 0) ? l_mathop(ceil)(n) : l_mathop(floor)(n);
-    pushnumint(L, ip);
-    /* fractional part (test needed for inf/-inf) */
-    lua_pushnumber(L, (n == ip) ? l_mathop(0.0) : (n - ip));
-  }
-  return 2;
-}
-
-
-static int math_sqrt (lua_State *L) {
-  lua_pushnumber(L, l_mathop(sqrt)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-
-static int math_ult (lua_State *L) {
-  lua_Integer a = luaL_checkinteger(L, 1);
-  lua_Integer b = luaL_checkinteger(L, 2);
-  lua_pushboolean(L, (lua_Unsigned)a < (lua_Unsigned)b);
-  return 1;
-}
-
-static int math_log (lua_State *L) {
-  lua_Number x = luaL_checknumber(L, 1);
-  lua_Number res;
-  if (lua_isnoneornil(L, 2))
-    res = l_mathop(log)(x);
-  else {
-    lua_Number base = luaL_checknumber(L, 2);
-#if !defined(LUA_USE_C89)
-    if (base == l_mathop(2.0))
-      res = l_mathop(log2)(x);
-    else
-#endif
-    if (base == l_mathop(10.0))
-      res = l_mathop(log10)(x);
-    else
-      res = l_mathop(log)(x)/l_mathop(log)(base);
-  }
-  lua_pushnumber(L, res);
-  return 1;
-}
-
-static int math_exp (lua_State *L) {
-  lua_pushnumber(L, l_mathop(exp)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_deg (lua_State *L) {
-  lua_pushnumber(L, luaL_checknumber(L, 1) * (l_mathop(180.0) / PI));
-  return 1;
-}
-
-static int math_rad (lua_State *L) {
-  lua_pushnumber(L, luaL_checknumber(L, 1) * (PI / l_mathop(180.0)));
-  return 1;
-}
-
-
-static int math_min (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
-  int imin = 1;  /* index of current minimum value */
-  int i;
-  luaL_argcheck(L, n >= 1, 1, "value expected");
-  for (i = 2; i <= n; i++) {
-    if (lua_compare(L, i, imin, LUA_OPLT))
-      imin = i;
-  }
-  lua_pushvalue(L, imin);
-  return 1;
-}
-
-
-static int math_max (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
-  int imax = 1;  /* index of current maximum value */
-  int i;
-  luaL_argcheck(L, n >= 1, 1, "value expected");
-  for (i = 2; i <= n; i++) {
-    if (lua_compare(L, imax, i, LUA_OPLT))
-      imax = i;
-  }
-  lua_pushvalue(L, imax);
-  return 1;
-}
-
-
-static int math_type (lua_State *L) {
-  if (lua_type(L, 1) == LUA_TNUMBER)
-    lua_pushstring(L, (lua_isinteger(L, 1)) ? "integer" : "float");
-  else {
-    luaL_checkany(L, 1);
-    luaL_pushfail(L);
-  }
-  return 1;
-}
-
-
-
-/*
-** {==================================================================
-** Pseudo-Random Number Generator based on 'xoshiro256**'.
-** ===================================================================
-*/
-
-/* number of binary digits in the mantissa of a float */
-#define FIGS	l_floatatt(MANT_DIG)
-
-#if FIGS > 64
-/* there are only 64 random bits; use them all */
-#undef FIGS
-#define FIGS	64
-#endif
-
-
-/*
-** LUA_RAND32 forces the use of 32-bit integers in the implementation
-** of the PRN generator (mainly for testing).
-*/
-#if !defined(LUA_RAND32) && !defined(Rand64)
-
-/* try to find an integer type with at least 64 bits */
-
-#if ((ULONG_MAX >> 31) >> 31) >= 3
-
-/* 'long' has at least 64 bits */
-#define Rand64		unsigned long
-
-#elif !defined(LUA_USE_C89) && defined(LLONG_MAX)
-
-/* there is a 'long long' type (which must have at least 64 bits) */
-#define Rand64		unsigned long long
-
-#elif ((LUA_MAXUNSIGNED >> 31) >> 31) >= 3
-
-/* 'lua_Unsigned' has at least 64 bits */
-#define Rand64		lua_Unsigned
-
-#endif
-
-#endif
-
-
-#if defined(Rand64)  /* { */
-
-/*
-** Standard implementation, using 64-bit integers.
-** If 'Rand64' has more than 64 bits, the extra bits do not interfere
-** with the 64 initial bits, except in a right shift. Moreover, the
-** final result has to discard the extra bits.
-*/
-
-/* avoid using extra bits when needed */
-#define trim64(x)	((x) & 0xffffffffffffffffu)
-
-
-/* rotate left 'x' by 'n' bits */
-static Rand64 rotl (Rand64 x, int n) {
-  return (x << n) | (trim64(x) >> (64 - n));
-}
-
-static Rand64 nextrand (Rand64 *state) {
-  Rand64 state0 = state[0];
-  Rand64 state1 = state[1];
-  Rand64 state2 = state[2] ^ state0;
-  Rand64 state3 = state[3] ^ state1;
-  Rand64 res = rotl(state1 * 5, 7) * 9;
-  state[0] = state0 ^ state3;
-  state[1] = state1 ^ state2;
-  state[2] = state2 ^ (state1 << 17);
-  state[3] = rotl(state3, 45);
-  return res;
-}
-
-
-/* must take care to not shift stuff by more than 63 slots */
-
-
-/*
-** Convert bits from a random integer into a float in the
-** interval [0,1), getting the higher FIG bits from the
-** random unsigned integer and converting that to a float.
-*/
-
-/* must throw out the extra (64 - FIGS) bits */
-#define shift64_FIG	(64 - FIGS)
-
-/* to scale to [0, 1), multiply by scaleFIG = 2^(-FIGS) */
-#define scaleFIG	(l_mathop(0.5) / ((Rand64)1 << (FIGS - 1)))
-
-static lua_Number I2d (Rand64 x) {
-  return (lua_Number)(trim64(x) >> shift64_FIG) * scaleFIG;
-}
-
-/* convert a 'Rand64' to a 'lua_Unsigned' */
-#define I2UInt(x)	((lua_Unsigned)trim64(x))
-
-/* convert a 'lua_Unsigned' to a 'Rand64' */
-#define Int2I(x)	((Rand64)(x))
-
-
-#else	/* no 'Rand64'   }{ */
-
-/* get an integer with at least 32 bits */
-#if LUAI_IS32INT
-typedef unsigned int lu_int32;
-#else
-typedef unsigned long lu_int32;
-#endif
-
-
-/*
-** Use two 32-bit integers to represent a 64-bit quantity.
-*/
-typedef struct Rand64 {
-  lu_int32 h;  /* higher half */
-  lu_int32 l;  /* lower half */
-} Rand64;
-
-
-/*
-** If 'lu_int32' has more than 32 bits, the extra bits do not interfere
-** with the 32 initial bits, except in a right shift and comparisons.
-** Moreover, the final result has to discard the extra bits.
-*/
-
-/* avoid using extra bits when needed */
-#define trim32(x)	((x) & 0xffffffffu)
-
-
-/*
-** basic operations on 'Rand64' values
-*/
-
-/* build a new Rand64 value */
-static Rand64 packI (lu_int32 h, lu_int32 l) {
-  Rand64 result;
-  result.h = h;
-  result.l = l;
-  return result;
-}
-
-/* return i << n */
-static Rand64 Ishl (Rand64 i, int n) {
-  lua_assert(n > 0 && n < 32);
-  return packI((i.h << n) | (trim32(i.l) >> (32 - n)), i.l << n);
-}
-
-/* i1 ^= i2 */
-static void Ixor (Rand64 *i1, Rand64 i2) {
-  i1->h ^= i2.h;
-  i1->l ^= i2.l;
-}
-
-/* return i1 + i2 */
-static Rand64 Iadd (Rand64 i1, Rand64 i2) {
-  Rand64 result = packI(i1.h + i2.h, i1.l + i2.l);
-  if (trim32(result.l) < trim32(i1.l))  /* carry? */
-    result.h++;
-  return result;
-}
-
-/* return i * 5 */
-static Rand64 times5 (Rand64 i) {
-  return Iadd(Ishl(i, 2), i);  /* i * 5 == (i << 2) + i */
-}
-
-/* return i * 9 */
-static Rand64 times9 (Rand64 i) {
-  return Iadd(Ishl(i, 3), i);  /* i * 9 == (i << 3) + i */
-}
-
-/* return 'i' rotated left 'n' bits */
-static Rand64 rotl (Rand64 i, int n) {
-  lua_assert(n > 0 && n < 32);
-  return packI((i.h << n) | (trim32(i.l) >> (32 - n)),
-               (trim32(i.h) >> (32 - n)) | (i.l << n));
-}
-
-/* for offsets larger than 32, rotate right by 64 - offset */
-static Rand64 rotl1 (Rand64 i, int n) {
-  lua_assert(n > 32 && n < 64);
-  n = 64 - n;
-  return packI((trim32(i.h) >> n) | (i.l << (32 - n)),
-               (i.h << (32 - n)) | (trim32(i.l) >> n));
-}
-
-/*
-** implementation of 'xoshiro256**' algorithm on 'Rand64' values
-*/
-static Rand64 nextrand (Rand64 *state) {
-  Rand64 res = times9(rotl(times5(state[1]), 7));
-  Rand64 t = Ishl(state[1], 17);
-  Ixor(&state[2], state[0]);
-  Ixor(&state[3], state[1]);
-  Ixor(&state[1], state[2]);
-  Ixor(&state[0], state[3]);
-  Ixor(&state[2], t);
-  state[3] = rotl1(state[3], 45);
-  return res;
-}
-
-
-/*
-** Converts a 'Rand64' into a float.
-*/
-
-/* an unsigned 1 with proper type */
-#define UONE		((lu_int32)1)
-
-
-#if FIGS <= 32
-
-/* 2^(-FIGS) */
-#define scaleFIG       (l_mathop(0.5) / (UONE << (FIGS - 1)))
-
-/*
-** get up to 32 bits from higher half, shifting right to
-** throw out the extra bits.
-*/
-static lua_Number I2d (Rand64 x) {
-  lua_Number h = (lua_Number)(trim32(x.h) >> (32 - FIGS));
-  return h * scaleFIG;
-}
-
-#else	/* 32 < FIGS <= 64 */
-
-/* must take care to not shift stuff by more than 31 slots */
-
-/* 2^(-FIGS) = 1.0 / 2^30 / 2^3 / 2^(FIGS-33) */
-#define scaleFIG  \
-    (l_mathop(1.0) / (UONE << 30) / l_mathop(8.0) / (UONE << (FIGS - 33)))
-
-/*
-** use FIGS - 32 bits from lower half, throwing out the other
-** (32 - (FIGS - 32)) = (64 - FIGS) bits
-*/
-#define shiftLOW	(64 - FIGS)
-
-/*
-** higher 32 bits go after those (FIGS - 32) bits: shiftHI = 2^(FIGS - 32)
-*/
-#define shiftHI		((lua_Number)(UONE << (FIGS - 33)) * l_mathop(2.0))
-
-
-static lua_Number I2d (Rand64 x) {
-  lua_Number h = (lua_Number)trim32(x.h) * shiftHI;
-  lua_Number l = (lua_Number)(trim32(x.l) >> shiftLOW);
-  return (h + l) * scaleFIG;
-}
-
-#endif
-
-
-/* convert a 'Rand64' to a 'lua_Unsigned' */
-static lua_Unsigned I2UInt (Rand64 x) {
-  return (((lua_Unsigned)trim32(x.h) << 31) << 1) | (lua_Unsigned)trim32(x.l);
-}
-
-/* convert a 'lua_Unsigned' to a 'Rand64' */
-static Rand64 Int2I (lua_Unsigned n) {
-  return packI((lu_int32)((n >> 31) >> 1), (lu_int32)n);
-}
-
-#endif  /* } */
-
-
-/*
-** A state uses four 'Rand64' values.
-*/
-typedef struct {
-  Rand64 s[4];
-} RanState;
-
-
-/*
-** Project the random integer 'ran' into the interval [0, n].
-** Because 'ran' has 2^B possible values, the projection can only be
-** uniform when the size of the interval is a power of 2 (exact
-** division). Otherwise, to get a uniform projection into [0, n], we
-** first compute 'lim', the smallest Mersenne number not smaller than
-** 'n'. We then project 'ran' into the interval [0, lim].  If the result
-** is inside [0, n], we are done. Otherwise, we try with another 'ran',
-** until we have a result inside the interval.
-*/
-static lua_Unsigned project (lua_Unsigned ran, lua_Unsigned n,
-                             RanState *state) {
-  if ((n & (n + 1)) == 0)  /* is 'n + 1' a power of 2? */
-    return ran & n;  /* no bias */
-  else {
-    lua_Unsigned lim = n;
-    /* compute the smallest (2^b - 1) not smaller than 'n' */
-    lim |= (lim >> 1);
-    lim |= (lim >> 2);
-    lim |= (lim >> 4);
-    lim |= (lim >> 8);
-    lim |= (lim >> 16);
-#if (LUA_MAXUNSIGNED >> 31) >= 3
-    lim |= (lim >> 32);  /* integer type has more than 32 bits */
-#endif
-    lua_assert((lim & (lim + 1)) == 0  /* 'lim + 1' is a power of 2, */
-      && lim >= n  /* not smaller than 'n', */
-      && (lim >> 1) < n);  /* and it is the smallest one */
-    while ((ran &= lim) > n)  /* project 'ran' into [0..lim] */
-      ran = I2UInt(nextrand(state->s));  /* not inside [0..n]? try again */
-    return ran;
-  }
-}
-
-
-static int math_random (lua_State *L) {
-  lua_Integer low, up;
-  lua_Unsigned p;
-  RanState *state = (RanState *)lua_touserdata(L, lua_upvalueindex(1));
-  Rand64 rv = nextrand(state->s);  /* next pseudo-random value */
-  switch (lua_gettop(L)) {  /* check number of arguments */
-    case 0: {  /* no arguments */
-      lua_pushnumber(L, I2d(rv));  /* float between 0 and 1 */
-      return 1;
-    }
-    case 1: {  /* only upper limit */
-      low = 1;
-      up = luaL_checkinteger(L, 1);
-      if (up == 0) {  /* single 0 as argument? */
-        lua_pushinteger(L, I2UInt(rv));  /* full random integer */
-        return 1;
-      }
-      break;
-    }
-    case 2: {  /* lower and upper limits */
-      low = luaL_checkinteger(L, 1);
-      up = luaL_checkinteger(L, 2);
-      break;
-    }
-    default: return luaL_error(L, "wrong number of arguments");
-  }
-  /* random integer in the interval [low, up] */
-  luaL_argcheck(L, low <= up, 1, "interval is empty");
-  /* project random integer into the interval [0, up - low] */
-  p = project(I2UInt(rv), (lua_Unsigned)up - (lua_Unsigned)low, state);
-  lua_pushinteger(L, p + (lua_Unsigned)low);
-  return 1;
-}
-
-
-static void setseed (lua_State *L, Rand64 *state,
-                     lua_Unsigned n1, lua_Unsigned n2) {
-  int i;
-  state[0] = Int2I(n1);
-  state[1] = Int2I(0xff);  /* avoid a zero state */
-  state[2] = Int2I(n2);
-  state[3] = Int2I(0);
-  for (i = 0; i < 16; i++)
-    nextrand(state);  /* discard initial values to "spread" seed */
-  lua_pushinteger(L, n1);
-  lua_pushinteger(L, n2);
-}
-
-
-/*
-** Set a "random" seed. To get some randomness, use the current time
-** and the address of 'L' (in case the machine does address space layout
-** randomization).
-*/
-static void randseed (lua_State *L, RanState *state) {
-  lua_Unsigned seed1 = (lua_Unsigned)time(NULL);
-  lua_Unsigned seed2 = (lua_Unsigned)(size_t)L;
-  setseed(L, state->s, seed1, seed2);
-}
-
-
-static int math_randomseed (lua_State *L) {
-  RanState *state = (RanState *)lua_touserdata(L, lua_upvalueindex(1));
-  if (lua_isnone(L, 1)) {
-    randseed(L, state);
-  }
-  else {
-    lua_Integer n1 = luaL_checkinteger(L, 1);
-    lua_Integer n2 = luaL_optinteger(L, 2, 0);
-    setseed(L, state->s, n1, n2);
-  }
-  return 2;  /* return seeds */
-}
-
-
-static const luaL_Reg randfuncs[] = {
-  {"random", math_random},
-  {"randomseed", math_randomseed},
-  {NULL, NULL}
-};
-
-
-/*
-** Register the random functions and initialize their state.
-*/
-static void setrandfunc (lua_State *L) {
-  RanState *state = (RanState *)lua_newuserdatauv(L, sizeof(RanState), 0);
-  randseed(L, state);  /* initialize with a "random" seed */
-  lua_pop(L, 2);  /* remove pushed seeds */
-  luaL_setfuncs(L, randfuncs, 1);
-}
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Deprecated functions (for compatibility only)
-** ===================================================================
-*/
-#if defined(LUA_COMPAT_MATHLIB)
-
-static int math_cosh (lua_State *L) {
-  lua_pushnumber(L, l_mathop(cosh)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_sinh (lua_State *L) {
-  lua_pushnumber(L, l_mathop(sinh)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_tanh (lua_State *L) {
-  lua_pushnumber(L, l_mathop(tanh)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-static int math_pow (lua_State *L) {
-  lua_Number x = luaL_checknumber(L, 1);
-  lua_Number y = luaL_checknumber(L, 2);
-  lua_pushnumber(L, l_mathop(pow)(x, y));
-  return 1;
-}
-
-static int math_frexp (lua_State *L) {
-  int e;
-  lua_pushnumber(L, l_mathop(frexp)(luaL_checknumber(L, 1), &e));
-  lua_pushinteger(L, e);
-  return 2;
-}
-
-static int math_ldexp (lua_State *L) {
-  lua_Number x = luaL_checknumber(L, 1);
-  int ep = (int)luaL_checkinteger(L, 2);
-  lua_pushnumber(L, l_mathop(ldexp)(x, ep));
-  return 1;
-}
-
-static int math_log10 (lua_State *L) {
-  lua_pushnumber(L, l_mathop(log10)(luaL_checknumber(L, 1)));
-  return 1;
-}
-
-#endif
-/* }================================================================== */
-
-
-
-static const luaL_Reg mathlib[] = {
-  {"abs",   math_abs},
-  {"acos",  math_acos},
-  {"asin",  math_asin},
-  {"atan",  math_atan},
-  {"ceil",  math_ceil},
-  {"cos",   math_cos},
-  {"deg",   math_deg},
-  {"exp",   math_exp},
-  {"tointeger", math_toint},
-  {"floor", math_floor},
-  {"fmod",   math_fmod},
-  {"ult",   math_ult},
-  {"log",   math_log},
-  {"max",   math_max},
-  {"min",   math_min},
-  {"modf",   math_modf},
-  {"rad",   math_rad},
-  {"sin",   math_sin},
-  {"sqrt",  math_sqrt},
-  {"tan",   math_tan},
-  {"type", math_type},
-#if defined(LUA_COMPAT_MATHLIB)
-  {"atan2", math_atan},
-  {"cosh",   math_cosh},
-  {"sinh",   math_sinh},
-  {"tanh",   math_tanh},
-  {"pow",   math_pow},
-  {"frexp", math_frexp},
-  {"ldexp", math_ldexp},
-  {"log10", math_log10},
-#endif
-  /* placeholders */
-  {"random", NULL},
-  {"randomseed", NULL},
-  {"pi", NULL},
-  {"huge", NULL},
-  {"maxinteger", NULL},
-  {"mininteger", NULL},
-  {NULL, NULL}
-};
-
-
-/*
-** Open math library
-*/
-LUAMOD_API int luaopen_math (lua_State *L) {
-  luaL_newlib(L, mathlib);
-  lua_pushnumber(L, PI);
-  lua_setfield(L, -2, "pi");
-  lua_pushnumber(L, (lua_Number)HUGE_VAL);
-  lua_setfield(L, -2, "huge");
-  lua_pushinteger(L, LUA_MAXINTEGER);
-  lua_setfield(L, -2, "maxinteger");
-  lua_pushinteger(L, LUA_MININTEGER);
-  lua_setfield(L, -2, "mininteger");
-  setrandfunc(L);
-  return 1;
-}
-
diff --git a/third-party/lua/src/lmem.c b/third-party/lua/src/lmem.c
deleted file mode 100644
index 9800a86fc..000000000
--- a/third-party/lua/src/lmem.c
+++ /dev/null
@@ -1,215 +0,0 @@
-/*
-** $Id: lmem.c $
-** Interface to Memory Manager
-** See Copyright Notice in lua.h
-*/
-
-#define lmem_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <stddef.h>
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lgc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-
-
-
-/*
-** About the realloc function:
-** void *frealloc (void *ud, void *ptr, size_t osize, size_t nsize);
-** ('osize' is the old size, 'nsize' is the new size)
-**
-** - frealloc(ud, p, x, 0) frees the block 'p' and returns NULL.
-** Particularly, frealloc(ud, NULL, 0, 0) does nothing,
-** which is equivalent to free(NULL) in ISO C.
-**
-** - frealloc(ud, NULL, x, s) creates a new block of size 's'
-** (no matter 'x'). Returns NULL if it cannot create the new block.
-**
-** - otherwise, frealloc(ud, b, x, y) reallocates the block 'b' from
-** size 'x' to size 'y'. Returns NULL if it cannot reallocate the
-** block to the new size.
-*/
-
-
-/*
-** Macro to call the allocation function.
-*/
-#define callfrealloc(g,block,os,ns)    ((*g->frealloc)(g->ud, block, os, ns))
-
-
-/*
-** When an allocation fails, it will try again after an emergency
-** collection, except when it cannot run a collection.  The GC should
-** not be called while the state is not fully built, as the collector
-** is not yet fully initialized. Also, it should not be called when
-** 'gcstopem' is true, because then the interpreter is in the middle of
-** a collection step.
-*/
-#define cantryagain(g)	(completestate(g) && !g->gcstopem)
-
-
-
-
-#if defined(EMERGENCYGCTESTS)
-/*
-** First allocation will fail except when freeing a block (frees never
-** fail) and when it cannot try again; this fail will trigger 'tryagain'
-** and a full GC cycle at every allocation.
-*/
-static void *firsttry (global_State *g, void *block, size_t os, size_t ns) {
-  if (ns > 0 && cantryagain(g))
-    return NULL;  /* fail */
-  else  /* normal allocation */
-    return callfrealloc(g, block, os, ns);
-}
-#else
-#define firsttry(g,block,os,ns)    callfrealloc(g, block, os, ns)
-#endif
-
-
-
-
-
-/*
-** {==================================================================
-** Functions to allocate/deallocate arrays for the Parser
-** ===================================================================
-*/
-
-/*
-** Minimum size for arrays during parsing, to avoid overhead of
-** reallocating to size 1, then 2, and then 4. All these arrays
-** will be reallocated to exact sizes or erased when parsing ends.
-*/
-#define MINSIZEARRAY	4
-
-
-void *luaM_growaux_ (lua_State *L, void *block, int nelems, int *psize,
-                     int size_elems, int limit, const char *what) {
-  void *newblock;
-  int size = *psize;
-  if (nelems + 1 <= size)  /* does one extra element still fit? */
-    return block;  /* nothing to be done */
-  if (size >= limit / 2) {  /* cannot double it? */
-    if (l_unlikely(size >= limit))  /* cannot grow even a little? */
-      luaG_runerror(L, "too many %s (limit is %d)", what, limit);
-    size = limit;  /* still have at least one free place */
-  }
-  else {
-    size *= 2;
-    if (size < MINSIZEARRAY)
-      size = MINSIZEARRAY;  /* minimum size */
-  }
-  lua_assert(nelems + 1 <= size && size <= limit);
-  /* 'limit' ensures that multiplication will not overflow */
-  newblock = luaM_saferealloc_(L, block, cast_sizet(*psize) * size_elems,
-                                         cast_sizet(size) * size_elems);
-  *psize = size;  /* update only when everything else is OK */
-  return newblock;
-}
-
-
-/*
-** In prototypes, the size of the array is also its number of
-** elements (to save memory). So, if it cannot shrink an array
-** to its number of elements, the only option is to raise an
-** error.
-*/
-void *luaM_shrinkvector_ (lua_State *L, void *block, int *size,
-                          int final_n, int size_elem) {
-  void *newblock;
-  size_t oldsize = cast_sizet((*size) * size_elem);
-  size_t newsize = cast_sizet(final_n * size_elem);
-  lua_assert(newsize <= oldsize);
-  newblock = luaM_saferealloc_(L, block, oldsize, newsize);
-  *size = final_n;
-  return newblock;
-}
-
-/* }================================================================== */
-
-
-l_noret luaM_toobig (lua_State *L) {
-  luaG_runerror(L, "memory allocation error: block too big");
-}
-
-
-/*
-** Free memory
-*/
-void luaM_free_ (lua_State *L, void *block, size_t osize) {
-  global_State *g = G(L);
-  lua_assert((osize == 0) == (block == NULL));
-  callfrealloc(g, block, osize, 0);
-  g->GCdebt -= osize;
-}
-
-
-/*
-** In case of allocation fail, this function will do an emergency
-** collection to free some memory and then try the allocation again.
-*/
-static void *tryagain (lua_State *L, void *block,
-                       size_t osize, size_t nsize) {
-  global_State *g = G(L);
-  if (cantryagain(g)) {
-    luaC_fullgc(L, 1);  /* try to free some memory... */
-    return callfrealloc(g, block, osize, nsize);  /* try again */
-  }
-  else return NULL;  /* cannot run an emergency collection */
-}
-
-
-/*
-** Generic allocation routine.
-*/
-void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
-  void *newblock;
-  global_State *g = G(L);
-  lua_assert((osize == 0) == (block == NULL));
-  newblock = firsttry(g, block, osize, nsize);
-  if (l_unlikely(newblock == NULL && nsize > 0)) {
-    newblock = tryagain(L, block, osize, nsize);
-    if (newblock == NULL)  /* still no memory? */
-      return NULL;  /* do not update 'GCdebt' */
-  }
-  lua_assert((nsize == 0) == (newblock == NULL));
-  g->GCdebt = (g->GCdebt + nsize) - osize;
-  return newblock;
-}
-
-
-void *luaM_saferealloc_ (lua_State *L, void *block, size_t osize,
-                                                    size_t nsize) {
-  void *newblock = luaM_realloc_(L, block, osize, nsize);
-  if (l_unlikely(newblock == NULL && nsize > 0))  /* allocation failed? */
-    luaM_error(L);
-  return newblock;
-}
-
-
-void *luaM_malloc_ (lua_State *L, size_t size, int tag) {
-  if (size == 0)
-    return NULL;  /* that's all */
-  else {
-    global_State *g = G(L);
-    void *newblock = firsttry(g, NULL, tag, size);
-    if (l_unlikely(newblock == NULL)) {
-      newblock = tryagain(L, NULL, tag, size);
-      if (newblock == NULL)
-        luaM_error(L);
-    }
-    g->GCdebt += size;
-    return newblock;
-  }
-}
diff --git a/third-party/lua/src/lmem.h b/third-party/lua/src/lmem.h
deleted file mode 100644
index 8c75a44be..000000000
--- a/third-party/lua/src/lmem.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
-** $Id: lmem.h $
-** Interface to Memory Manager
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lmem_h
-#define lmem_h
-
-
-#include <stddef.h>
-
-#include "llimits.h"
-#include "lua.h"
-
-
-#define luaM_error(L)	luaD_throw(L, LUA_ERRMEM)
-
-
-/*
-** This macro tests whether it is safe to multiply 'n' by the size of
-** type 't' without overflows. Because 'e' is always constant, it avoids
-** the runtime division MAX_SIZET/(e).
-** (The macro is somewhat complex to avoid warnings:  The 'sizeof'
-** comparison avoids a runtime comparison when overflow cannot occur.
-** The compiler should be able to optimize the real test by itself, but
-** when it does it, it may give a warning about "comparison is always
-** false due to limited range of data type"; the +1 tricks the compiler,
-** avoiding this warning but also this optimization.)
-*/
-#define luaM_testsize(n,e)  \
-	(sizeof(n) >= sizeof(size_t) && cast_sizet((n)) + 1 > MAX_SIZET/(e))
-
-#define luaM_checksize(L,n,e)  \
-	(luaM_testsize(n,e) ? luaM_toobig(L) : cast_void(0))
-
-
-/*
-** Computes the minimum between 'n' and 'MAX_SIZET/sizeof(t)', so that
-** the result is not larger than 'n' and cannot overflow a 'size_t'
-** when multiplied by the size of type 't'. (Assumes that 'n' is an
-** 'int' or 'unsigned int' and that 'int' is not larger than 'size_t'.)
-*/
-#define luaM_limitN(n,t)  \
-  ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) :  \
-     cast_uint((MAX_SIZET/sizeof(t))))
-
-
-/*
-** Arrays of chars do not need any test
-*/
-#define luaM_reallocvchar(L,b,on,n)  \
-  cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char)))
-
-#define luaM_freemem(L, b, s)	luaM_free_(L, (b), (s))
-#define luaM_free(L, b)		luaM_free_(L, (b), sizeof(*(b)))
-#define luaM_freearray(L, b, n)   luaM_free_(L, (b), (n)*sizeof(*(b)))
-
-#define luaM_new(L,t)		cast(t*, luaM_malloc_(L, sizeof(t), 0))
-#define luaM_newvector(L,n,t)	cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0))
-#define luaM_newvectorchecked(L,n,t) \
-  (luaM_checksize(L,n,sizeof(t)), luaM_newvector(L,n,t))
-
-#define luaM_newobject(L,tag,s)	luaM_malloc_(L, (s), tag)
-
-#define luaM_growvector(L,v,nelems,size,t,limit,e) \
-	((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \
-                         luaM_limitN(limit,t),e)))
-
-#define luaM_reallocvector(L, v,oldn,n,t) \
-   (cast(t *, luaM_realloc_(L, v, cast_sizet(oldn) * sizeof(t), \
-                                  cast_sizet(n) * sizeof(t))))
-
-#define luaM_shrinkvector(L,v,size,fs,t) \
-   ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t))))
-
-LUAI_FUNC l_noret luaM_toobig (lua_State *L);
-
-/* not to be called directly */
-LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize,
-                                                          size_t size);
-LUAI_FUNC void *luaM_saferealloc_ (lua_State *L, void *block, size_t oldsize,
-                                                              size_t size);
-LUAI_FUNC void luaM_free_ (lua_State *L, void *block, size_t osize);
-LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int nelems,
-                               int *size, int size_elem, int limit,
-                               const char *what);
-LUAI_FUNC void *luaM_shrinkvector_ (lua_State *L, void *block, int *nelem,
-                                    int final_n, int size_elem);
-LUAI_FUNC void *luaM_malloc_ (lua_State *L, size_t size, int tag);
-
-#endif
-
diff --git a/third-party/lua/src/loadlib.c b/third-party/lua/src/loadlib.c
deleted file mode 100644
index d792dffaa..000000000
--- a/third-party/lua/src/loadlib.c
+++ /dev/null
@@ -1,767 +0,0 @@
-/*
-** $Id: loadlib.c $
-** Dynamic library loader for Lua
-** See Copyright Notice in lua.h
-**
-** This module contains an implementation of loadlib for Unix systems
-** that have dlfcn, an implementation for Windows, and a stub for other
-** systems.
-*/
-
-#define loadlib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-/*
-** LUA_IGMARK is a mark to ignore all before it when building the
-** luaopen_ function name.
-*/
-#if !defined (LUA_IGMARK)
-#define LUA_IGMARK		"-"
-#endif
-
-
-/*
-** LUA_CSUBSEP is the character that replaces dots in submodule names
-** when searching for a C loader.
-** LUA_LSUBSEP is the character that replaces dots in submodule names
-** when searching for a Lua loader.
-*/
-#if !defined(LUA_CSUBSEP)
-#define LUA_CSUBSEP		LUA_DIRSEP
-#endif
-
-#if !defined(LUA_LSUBSEP)
-#define LUA_LSUBSEP		LUA_DIRSEP
-#endif
-
-
-/* prefix for open functions in C libraries */
-#define LUA_POF		"luaopen_"
-
-/* separator for open functions in C libraries */
-#define LUA_OFSEP	"_"
-
-
-/*
-** key for table in the registry that keeps handles
-** for all loaded C libraries
-*/
-static const char *const CLIBS = "_CLIBS";
-
-#define LIB_FAIL	"open"
-
-
-#define setprogdir(L)           ((void)0)
-
-
-/*
-** Special type equivalent to '(void*)' for functions in gcc
-** (to suppress warnings when converting function pointers)
-*/
-typedef void (*voidf)(void);
-
-
-/*
-** system-dependent functions
-*/
-
-/*
-** unload library 'lib'
-*/
-static void lsys_unloadlib (void *lib);
-
-/*
-** load C library in file 'path'. If 'seeglb', load with all names in
-** the library global.
-** Returns the library; in case of error, returns NULL plus an
-** error string in the stack.
-*/
-static void *lsys_load (lua_State *L, const char *path, int seeglb);
-
-/*
-** Try to find a function named 'sym' in library 'lib'.
-** Returns the function; in case of error, returns NULL plus an
-** error string in the stack.
-*/
-static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym);
-
-
-
-
-#if defined(LUA_USE_DLOPEN)	/* { */
-/*
-** {========================================================================
-** This is an implementation of loadlib based on the dlfcn interface.
-** The dlfcn interface is available in Linux, SunOS, Solaris, IRIX, FreeBSD,
-** NetBSD, AIX 4.2, HPUX 11, and  probably most other Unix flavors, at least
-** as an emulation layer on top of native functions.
-** =========================================================================
-*/
-
-#include <dlfcn.h>
-
-/*
-** Macro to convert pointer-to-void* to pointer-to-function. This cast
-** is undefined according to ISO C, but POSIX assumes that it works.
-** (The '__extension__' in gnu compilers is only to avoid warnings.)
-*/
-#if defined(__GNUC__)
-#define cast_func(p) (__extension__ (lua_CFunction)(p))
-#else
-#define cast_func(p) ((lua_CFunction)(p))
-#endif
-
-
-static void lsys_unloadlib (void *lib) {
-  dlclose(lib);
-}
-
-
-static void *lsys_load (lua_State *L, const char *path, int seeglb) {
-  void *lib = dlopen(path, RTLD_NOW | (seeglb ? RTLD_GLOBAL : RTLD_LOCAL));
-  if (l_unlikely(lib == NULL))
-    lua_pushstring(L, dlerror());
-  return lib;
-}
-
-
-static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) {
-  lua_CFunction f = cast_func(dlsym(lib, sym));
-  if (l_unlikely(f == NULL))
-    lua_pushstring(L, dlerror());
-  return f;
-}
-
-/* }====================================================== */
-
-
-
-#elif defined(LUA_DL_DLL)	/* }{ */
-/*
-** {======================================================================
-** This is an implementation of loadlib for Windows using native functions.
-** =======================================================================
-*/
-
-#include <windows.h>
-
-
-/*
-** optional flags for LoadLibraryEx
-*/
-#if !defined(LUA_LLE_FLAGS)
-#define LUA_LLE_FLAGS	0
-#endif
-
-
-#undef setprogdir
-
-
-/*
-** Replace in the path (on the top of the stack) any occurrence
-** of LUA_EXEC_DIR with the executable's path.
-*/
-static void setprogdir (lua_State *L) {
-  char buff[MAX_PATH + 1];
-  char *lb;
-  DWORD nsize = sizeof(buff)/sizeof(char);
-  DWORD n = GetModuleFileNameA(NULL, buff, nsize);  /* get exec. name */
-  if (n == 0 || n == nsize || (lb = strrchr(buff, '\\')) == NULL)
-    luaL_error(L, "unable to get ModuleFileName");
-  else {
-    *lb = '\0';  /* cut name on the last '\\' to get the path */
-    luaL_gsub(L, lua_tostring(L, -1), LUA_EXEC_DIR, buff);
-    lua_remove(L, -2);  /* remove original string */
-  }
-}
-
-
-
-
-static void pusherror (lua_State *L) {
-  int error = GetLastError();
-  char buffer[128];
-  if (FormatMessageA(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
-      NULL, error, 0, buffer, sizeof(buffer)/sizeof(char), NULL))
-    lua_pushstring(L, buffer);
-  else
-    lua_pushfstring(L, "system error %d\n", error);
-}
-
-static void lsys_unloadlib (void *lib) {
-  FreeLibrary((HMODULE)lib);
-}
-
-
-static void *lsys_load (lua_State *L, const char *path, int seeglb) {
-  HMODULE lib = LoadLibraryExA(path, NULL, LUA_LLE_FLAGS);
-  (void)(seeglb);  /* not used: symbols are 'global' by default */
-  if (lib == NULL) pusherror(L);
-  return lib;
-}
-
-
-static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) {
-  lua_CFunction f = (lua_CFunction)(voidf)GetProcAddress((HMODULE)lib, sym);
-  if (f == NULL) pusherror(L);
-  return f;
-}
-
-/* }====================================================== */
-
-
-#else				/* }{ */
-/*
-** {======================================================
-** Fallback for other systems
-** =======================================================
-*/
-
-#undef LIB_FAIL
-#define LIB_FAIL	"absent"
-
-
-#define DLMSG	"dynamic libraries not enabled; check your Lua installation"
-
-
-static void lsys_unloadlib (void *lib) {
-  (void)(lib);  /* not used */
-}
-
-
-static void *lsys_load (lua_State *L, const char *path, int seeglb) {
-  (void)(path); (void)(seeglb);  /* not used */
-  lua_pushliteral(L, DLMSG);
-  return NULL;
-}
-
-
-static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) {
-  (void)(lib); (void)(sym);  /* not used */
-  lua_pushliteral(L, DLMSG);
-  return NULL;
-}
-
-/* }====================================================== */
-#endif				/* } */
-
-
-/*
-** {==================================================================
-** Set Paths
-** ===================================================================
-*/
-
-/*
-** LUA_PATH_VAR and LUA_CPATH_VAR are the names of the environment
-** variables that Lua check to set its paths.
-*/
-#if !defined(LUA_PATH_VAR)
-#define LUA_PATH_VAR    "LUA_PATH"
-#endif
-
-#if !defined(LUA_CPATH_VAR)
-#define LUA_CPATH_VAR   "LUA_CPATH"
-#endif
-
-
-
-/*
-** return registry.LUA_NOENV as a boolean
-*/
-static int noenv (lua_State *L) {
-  int b;
-  lua_getfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");
-  b = lua_toboolean(L, -1);
-  lua_pop(L, 1);  /* remove value */
-  return b;
-}
-
-
-/*
-** Set a path
-*/
-static void setpath (lua_State *L, const char *fieldname,
-                                   const char *envname,
-                                   const char *dft) {
-  const char *dftmark;
-  const char *nver = lua_pushfstring(L, "%s%s", envname, LUA_VERSUFFIX);
-  const char *path = getenv(nver);  /* try versioned name */
-  if (path == NULL)  /* no versioned environment variable? */
-    path = getenv(envname);  /* try unversioned name */
-  if (path == NULL || noenv(L))  /* no environment variable? */
-    lua_pushstring(L, dft);  /* use default */
-  else if ((dftmark = strstr(path, LUA_PATH_SEP LUA_PATH_SEP)) == NULL)
-    lua_pushstring(L, path);  /* nothing to change */
-  else {  /* path contains a ";;": insert default path in its place */
-    size_t len = strlen(path);
-    luaL_Buffer b;
-    luaL_buffinit(L, &b);
-    if (path < dftmark) {  /* is there a prefix before ';;'? */
-      luaL_addlstring(&b, path, dftmark - path);  /* add it */
-      luaL_addchar(&b, *LUA_PATH_SEP);
-    }
-    luaL_addstring(&b, dft);  /* add default */
-    if (dftmark < path + len - 2) {  /* is there a suffix after ';;'? */
-      luaL_addchar(&b, *LUA_PATH_SEP);
-      luaL_addlstring(&b, dftmark + 2, (path + len - 2) - dftmark);
-    }
-    luaL_pushresult(&b);
-  }
-  setprogdir(L);
-  lua_setfield(L, -3, fieldname);  /* package[fieldname] = path value */
-  lua_pop(L, 1);  /* pop versioned variable name ('nver') */
-}
-
-/* }================================================================== */
-
-
-/*
-** return registry.CLIBS[path]
-*/
-static void *checkclib (lua_State *L, const char *path) {
-  void *plib;
-  lua_getfield(L, LUA_REGISTRYINDEX, CLIBS);
-  lua_getfield(L, -1, path);
-  plib = lua_touserdata(L, -1);  /* plib = CLIBS[path] */
-  lua_pop(L, 2);  /* pop CLIBS table and 'plib' */
-  return plib;
-}
-
-
-/*
-** registry.CLIBS[path] = plib        -- for queries
-** registry.CLIBS[#CLIBS + 1] = plib  -- also keep a list of all libraries
-*/
-static void addtoclib (lua_State *L, const char *path, void *plib) {
-  lua_getfield(L, LUA_REGISTRYINDEX, CLIBS);
-  lua_pushlightuserdata(L, plib);
-  lua_pushvalue(L, -1);
-  lua_setfield(L, -3, path);  /* CLIBS[path] = plib */
-  lua_rawseti(L, -2, luaL_len(L, -2) + 1);  /* CLIBS[#CLIBS + 1] = plib */
-  lua_pop(L, 1);  /* pop CLIBS table */
-}
-
-
-/*
-** __gc tag method for CLIBS table: calls 'lsys_unloadlib' for all lib
-** handles in list CLIBS
-*/
-static int gctm (lua_State *L) {
-  lua_Integer n = luaL_len(L, 1);
-  for (; n >= 1; n--) {  /* for each handle, in reverse order */
-    lua_rawgeti(L, 1, n);  /* get handle CLIBS[n] */
-    lsys_unloadlib(lua_touserdata(L, -1));
-    lua_pop(L, 1);  /* pop handle */
-  }
-  return 0;
-}
-
-
-
-/* error codes for 'lookforfunc' */
-#define ERRLIB		1
-#define ERRFUNC		2
-
-/*
-** Look for a C function named 'sym' in a dynamically loaded library
-** 'path'.
-** First, check whether the library is already loaded; if not, try
-** to load it.
-** Then, if 'sym' is '*', return true (as library has been loaded).
-** Otherwise, look for symbol 'sym' in the library and push a
-** C function with that symbol.
-** Return 0 and 'true' or a function in the stack; in case of
-** errors, return an error code and an error message in the stack.
-*/
-static int lookforfunc (lua_State *L, const char *path, const char *sym) {
-  void *reg = checkclib(L, path);  /* check loaded C libraries */
-  if (reg == NULL) {  /* must load library? */
-    reg = lsys_load(L, path, *sym == '*');  /* global symbols if 'sym'=='*' */
-    if (reg == NULL) return ERRLIB;  /* unable to load library */
-    addtoclib(L, path, reg);
-  }
-  if (*sym == '*') {  /* loading only library (no function)? */
-    lua_pushboolean(L, 1);  /* return 'true' */
-    return 0;  /* no errors */
-  }
-  else {
-    lua_CFunction f = lsys_sym(L, reg, sym);
-    if (f == NULL)
-      return ERRFUNC;  /* unable to find function */
-    lua_pushcfunction(L, f);  /* else create new function */
-    return 0;  /* no errors */
-  }
-}
-
-
-static int ll_loadlib (lua_State *L) {
-  const char *path = luaL_checkstring(L, 1);
-  const char *init = luaL_checkstring(L, 2);
-  int stat = lookforfunc(L, path, init);
-  if (l_likely(stat == 0))  /* no errors? */
-    return 1;  /* return the loaded function */
-  else {  /* error; error message is on stack top */
-    luaL_pushfail(L);
-    lua_insert(L, -2);
-    lua_pushstring(L, (stat == ERRLIB) ?  LIB_FAIL : "init");
-    return 3;  /* return fail, error message, and where */
-  }
-}
-
-
-
-/*
-** {======================================================
-** 'require' function
-** =======================================================
-*/
-
-
-static int readable (const char *filename) {
-  FILE *f = fopen(filename, "r");  /* try to open file */
-  if (f == NULL) return 0;  /* open failed */
-  fclose(f);
-  return 1;
-}
-
-
-/*
-** Get the next name in '*path' = 'name1;name2;name3;...', changing
-** the ending ';' to '\0' to create a zero-terminated string. Return
-** NULL when list ends.
-*/
-static const char *getnextfilename (char **path, char *end) {
-  char *sep;
-  char *name = *path;
-  if (name == end)
-    return NULL;  /* no more names */
-  else if (*name == '\0') {  /* from previous iteration? */
-    *name = *LUA_PATH_SEP;  /* restore separator */
-    name++;  /* skip it */
-  }
-  sep = strchr(name, *LUA_PATH_SEP);  /* find next separator */
-  if (sep == NULL)  /* separator not found? */
-    sep = end;  /* name goes until the end */
-  *sep = '\0';  /* finish file name */
-  *path = sep;  /* will start next search from here */
-  return name;
-}
-
-
-/*
-** Given a path such as ";blabla.so;blublu.so", pushes the string
-**
-** no file 'blabla.so'
-**	no file 'blublu.so'
-*/
-static void pusherrornotfound (lua_State *L, const char *path) {
-  luaL_Buffer b;
-  luaL_buffinit(L, &b);
-  luaL_addstring(&b, "no file '");
-  luaL_addgsub(&b, path, LUA_PATH_SEP, "'\n\tno file '");
-  luaL_addstring(&b, "'");
-  luaL_pushresult(&b);
-}
-
-
-static const char *searchpath (lua_State *L, const char *name,
-                                             const char *path,
-                                             const char *sep,
-                                             const char *dirsep) {
-  luaL_Buffer buff;
-  char *pathname;  /* path with name inserted */
-  char *endpathname;  /* its end */
-  const char *filename;
-  /* separator is non-empty and appears in 'name'? */
-  if (*sep != '\0' && strchr(name, *sep) != NULL)
-    name = luaL_gsub(L, name, sep, dirsep);  /* replace it by 'dirsep' */
-  luaL_buffinit(L, &buff);
-  /* add path to the buffer, replacing marks ('?') with the file name */
-  luaL_addgsub(&buff, path, LUA_PATH_MARK, name);
-  luaL_addchar(&buff, '\0');
-  pathname = luaL_buffaddr(&buff);  /* writable list of file names */
-  endpathname = pathname + luaL_bufflen(&buff) - 1;
-  while ((filename = getnextfilename(&pathname, endpathname)) != NULL) {
-    if (readable(filename))  /* does file exist and is readable? */
-      return lua_pushstring(L, filename);  /* save and return name */
-  }
-  luaL_pushresult(&buff);  /* push path to create error message */
-  pusherrornotfound(L, lua_tostring(L, -1));  /* create error message */
-  return NULL;  /* not found */
-}
-
-
-static int ll_searchpath (lua_State *L) {
-  const char *f = searchpath(L, luaL_checkstring(L, 1),
-                                luaL_checkstring(L, 2),
-                                luaL_optstring(L, 3, "."),
-                                luaL_optstring(L, 4, LUA_DIRSEP));
-  if (f != NULL) return 1;
-  else {  /* error message is on top of the stack */
-    luaL_pushfail(L);
-    lua_insert(L, -2);
-    return 2;  /* return fail + error message */
-  }
-}
-
-
-static const char *findfile (lua_State *L, const char *name,
-                                           const char *pname,
-                                           const char *dirsep) {
-  const char *path;
-  lua_getfield(L, lua_upvalueindex(1), pname);
-  path = lua_tostring(L, -1);
-  if (l_unlikely(path == NULL))
-    luaL_error(L, "'package.%s' must be a string", pname);
-  return searchpath(L, name, path, ".", dirsep);
-}
-
-
-static int checkload (lua_State *L, int stat, const char *filename) {
-  if (l_likely(stat)) {  /* module loaded successfully? */
-    lua_pushstring(L, filename);  /* will be 2nd argument to module */
-    return 2;  /* return open function and file name */
-  }
-  else
-    return luaL_error(L, "error loading module '%s' from file '%s':\n\t%s",
-                          lua_tostring(L, 1), filename, lua_tostring(L, -1));
-}
-
-
-static int searcher_Lua (lua_State *L) {
-  const char *filename;
-  const char *name = luaL_checkstring(L, 1);
-  filename = findfile(L, name, "path", LUA_LSUBSEP);
-  if (filename == NULL) return 1;  /* module not found in this path */
-  return checkload(L, (luaL_loadfile(L, filename) == LUA_OK), filename);
-}
-
-
-/*
-** Try to find a load function for module 'modname' at file 'filename'.
-** First, change '.' to '_' in 'modname'; then, if 'modname' has
-** the form X-Y (that is, it has an "ignore mark"), build a function
-** name "luaopen_X" and look for it. (For compatibility, if that
-** fails, it also tries "luaopen_Y".) If there is no ignore mark,
-** look for a function named "luaopen_modname".
-*/
-static int loadfunc (lua_State *L, const char *filename, const char *modname) {
-  const char *openfunc;
-  const char *mark;
-  modname = luaL_gsub(L, modname, ".", LUA_OFSEP);
-  mark = strchr(modname, *LUA_IGMARK);
-  if (mark) {
-    int stat;
-    openfunc = lua_pushlstring(L, modname, mark - modname);
-    openfunc = lua_pushfstring(L, LUA_POF"%s", openfunc);
-    stat = lookforfunc(L, filename, openfunc);
-    if (stat != ERRFUNC) return stat;
-    modname = mark + 1;  /* else go ahead and try old-style name */
-  }
-  openfunc = lua_pushfstring(L, LUA_POF"%s", modname);
-  return lookforfunc(L, filename, openfunc);
-}
-
-
-static int searcher_C (lua_State *L) {
-  const char *name = luaL_checkstring(L, 1);
-  const char *filename = findfile(L, name, "cpath", LUA_CSUBSEP);
-  if (filename == NULL) return 1;  /* module not found in this path */
-  return checkload(L, (loadfunc(L, filename, name) == 0), filename);
-}
-
-
-static int searcher_Croot (lua_State *L) {
-  const char *filename;
-  const char *name = luaL_checkstring(L, 1);
-  const char *p = strchr(name, '.');
-  int stat;
-  if (p == NULL) return 0;  /* is root */
-  lua_pushlstring(L, name, p - name);
-  filename = findfile(L, lua_tostring(L, -1), "cpath", LUA_CSUBSEP);
-  if (filename == NULL) return 1;  /* root not found */
-  if ((stat = loadfunc(L, filename, name)) != 0) {
-    if (stat != ERRFUNC)
-      return checkload(L, 0, filename);  /* real error */
-    else {  /* open function not found */
-      lua_pushfstring(L, "no module '%s' in file '%s'", name, filename);
-      return 1;
-    }
-  }
-  lua_pushstring(L, filename);  /* will be 2nd argument to module */
-  return 2;
-}
-
-
-static int searcher_preload (lua_State *L) {
-  const char *name = luaL_checkstring(L, 1);
-  lua_getfield(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
-  if (lua_getfield(L, -1, name) == LUA_TNIL) {  /* not found? */
-    lua_pushfstring(L, "no field package.preload['%s']", name);
-    return 1;
-  }
-  else {
-    lua_pushliteral(L, ":preload:");
-    return 2;
-  }
-}
-
-
-static void findloader (lua_State *L, const char *name) {
-  int i;
-  luaL_Buffer msg;  /* to build error message */
-  /* push 'package.searchers' to index 3 in the stack */
-  if (l_unlikely(lua_getfield(L, lua_upvalueindex(1), "searchers")
-                 != LUA_TTABLE))
-    luaL_error(L, "'package.searchers' must be a table");
-  luaL_buffinit(L, &msg);
-  /*  iterate over available searchers to find a loader */
-  for (i = 1; ; i++) {
-    luaL_addstring(&msg, "\n\t");  /* error-message prefix */
-    if (l_unlikely(lua_rawgeti(L, 3, i) == LUA_TNIL)) {  /* no more searchers? */
-      lua_pop(L, 1);  /* remove nil */
-      luaL_buffsub(&msg, 2);  /* remove prefix */
-      luaL_pushresult(&msg);  /* create error message */
-      luaL_error(L, "module '%s' not found:%s", name, lua_tostring(L, -1));
-    }
-    lua_pushstring(L, name);
-    lua_call(L, 1, 2);  /* call it */
-    if (lua_isfunction(L, -2))  /* did it find a loader? */
-      return;  /* module loader found */
-    else if (lua_isstring(L, -2)) {  /* searcher returned error message? */
-      lua_pop(L, 1);  /* remove extra return */
-      luaL_addvalue(&msg);  /* concatenate error message */
-    }
-    else {  /* no error message */
-      lua_pop(L, 2);  /* remove both returns */
-      luaL_buffsub(&msg, 2);  /* remove prefix */
-    }
-  }
-}
-
-
-static int ll_require (lua_State *L) {
-  const char *name = luaL_checkstring(L, 1);
-  lua_settop(L, 1);  /* LOADED table will be at index 2 */
-  lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
-  lua_getfield(L, 2, name);  /* LOADED[name] */
-  if (lua_toboolean(L, -1))  /* is it there? */
-    return 1;  /* package is already loaded */
-  /* else must load package */
-  lua_pop(L, 1);  /* remove 'getfield' result */
-  findloader(L, name);
-  lua_rotate(L, -2, 1);  /* function <-> loader data */
-  lua_pushvalue(L, 1);  /* name is 1st argument to module loader */
-  lua_pushvalue(L, -3);  /* loader data is 2nd argument */
-  /* stack: ...; loader data; loader function; mod. name; loader data */
-  lua_call(L, 2, 1);  /* run loader to load module */
-  /* stack: ...; loader data; result from loader */
-  if (!lua_isnil(L, -1))  /* non-nil return? */
-    lua_setfield(L, 2, name);  /* LOADED[name] = returned value */
-  else
-    lua_pop(L, 1);  /* pop nil */
-  if (lua_getfield(L, 2, name) == LUA_TNIL) {   /* module set no value? */
-    lua_pushboolean(L, 1);  /* use true as result */
-    lua_copy(L, -1, -2);  /* replace loader result */
-    lua_setfield(L, 2, name);  /* LOADED[name] = true */
-  }
-  lua_rotate(L, -2, 1);  /* loader data <-> module result  */
-  return 2;  /* return module result and loader data */
-}
-
-/* }====================================================== */
-
-
-
-
-static const luaL_Reg pk_funcs[] = {
-  {"loadlib", ll_loadlib},
-  {"searchpath", ll_searchpath},
-  /* placeholders */
-  {"preload", NULL},
-  {"cpath", NULL},
-  {"path", NULL},
-  {"searchers", NULL},
-  {"loaded", NULL},
-  {NULL, NULL}
-};
-
-
-static const luaL_Reg ll_funcs[] = {
-  {"require", ll_require},
-  {NULL, NULL}
-};
-
-
-static void createsearcherstable (lua_State *L) {
-  static const lua_CFunction searchers[] = {
-    searcher_preload,
-    searcher_Lua,
-    searcher_C,
-    searcher_Croot,
-    NULL
-  };
-  int i;
-  /* create 'searchers' table */
-  lua_createtable(L, sizeof(searchers)/sizeof(searchers[0]) - 1, 0);
-  /* fill it with predefined searchers */
-  for (i=0; searchers[i] != NULL; i++) {
-    lua_pushvalue(L, -2);  /* set 'package' as upvalue for all searchers */
-    lua_pushcclosure(L, searchers[i], 1);
-    lua_rawseti(L, -2, i+1);
-  }
-  lua_setfield(L, -2, "searchers");  /* put it in field 'searchers' */
-}
-
-
-/*
-** create table CLIBS to keep track of loaded C libraries,
-** setting a finalizer to close all libraries when closing state.
-*/
-static void createclibstable (lua_State *L) {
-  luaL_getsubtable(L, LUA_REGISTRYINDEX, CLIBS);  /* create CLIBS table */
-  lua_createtable(L, 0, 1);  /* create metatable for CLIBS */
-  lua_pushcfunction(L, gctm);
-  lua_setfield(L, -2, "__gc");  /* set finalizer for CLIBS table */
-  lua_setmetatable(L, -2);
-}
-
-
-LUAMOD_API int luaopen_package (lua_State *L) {
-  createclibstable(L);
-  luaL_newlib(L, pk_funcs);  /* create 'package' table */
-  createsearcherstable(L);
-  /* set paths */
-  setpath(L, "path", LUA_PATH_VAR, LUA_PATH_DEFAULT);
-  setpath(L, "cpath", LUA_CPATH_VAR, LUA_CPATH_DEFAULT);
-  /* store config information */
-  lua_pushliteral(L, LUA_DIRSEP "\n" LUA_PATH_SEP "\n" LUA_PATH_MARK "\n"
-                     LUA_EXEC_DIR "\n" LUA_IGMARK "\n");
-  lua_setfield(L, -2, "config");
-  /* set field 'loaded' */
-  luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
-  lua_setfield(L, -2, "loaded");
-  /* set field 'preload' */
-  luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
-  lua_setfield(L, -2, "preload");
-  lua_pushglobaltable(L);
-  lua_pushvalue(L, -2);  /* set 'package' as upvalue for next lib */
-  luaL_setfuncs(L, ll_funcs, 1);  /* open lib into global table */
-  lua_pop(L, 1);  /* pop global table */
-  return 1;  /* return 'package' table */
-}
-
diff --git a/third-party/lua/src/lobject.c b/third-party/lua/src/lobject.c
deleted file mode 100644
index f73ffc6d9..000000000
--- a/third-party/lua/src/lobject.c
+++ /dev/null
@@ -1,602 +0,0 @@
-/*
-** $Id: lobject.c $
-** Some generic functions over Lua objects
-** See Copyright Notice in lua.h
-*/
-
-#define lobject_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <locale.h>
-#include <math.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lctype.h"
-#include "ldebug.h"
-#include "ldo.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "lvm.h"
-
-
-/*
-** Computes ceil(log2(x))
-*/
-int luaO_ceillog2 (unsigned int x) {
-  static const lu_byte log_2[256] = {  /* log_2[i] = ceil(log2(i - 1)) */
-    0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-    6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-    7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
-    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
-    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
-    8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
-  };
-  int l = 0;
-  x--;
-  while (x >= 256) { l += 8; x >>= 8; }
-  return l + log_2[x];
-}
-
-
-static lua_Integer intarith (lua_State *L, int op, lua_Integer v1,
-                                                   lua_Integer v2) {
-  switch (op) {
-    case LUA_OPADD: return intop(+, v1, v2);
-    case LUA_OPSUB:return intop(-, v1, v2);
-    case LUA_OPMUL:return intop(*, v1, v2);
-    case LUA_OPMOD: return luaV_mod(L, v1, v2);
-    case LUA_OPIDIV: return luaV_idiv(L, v1, v2);
-    case LUA_OPBAND: return intop(&, v1, v2);
-    case LUA_OPBOR: return intop(|, v1, v2);
-    case LUA_OPBXOR: return intop(^, v1, v2);
-    case LUA_OPSHL: return luaV_shiftl(v1, v2);
-    case LUA_OPSHR: return luaV_shiftr(v1, v2);
-    case LUA_OPUNM: return intop(-, 0, v1);
-    case LUA_OPBNOT: return intop(^, ~l_castS2U(0), v1);
-    default: lua_assert(0); return 0;
-  }
-}
-
-
-static lua_Number numarith (lua_State *L, int op, lua_Number v1,
-                                                  lua_Number v2) {
-  switch (op) {
-    case LUA_OPADD: return luai_numadd(L, v1, v2);
-    case LUA_OPSUB: return luai_numsub(L, v1, v2);
-    case LUA_OPMUL: return luai_nummul(L, v1, v2);
-    case LUA_OPDIV: return luai_numdiv(L, v1, v2);
-    case LUA_OPPOW: return luai_numpow(L, v1, v2);
-    case LUA_OPIDIV: return luai_numidiv(L, v1, v2);
-    case LUA_OPUNM: return luai_numunm(L, v1);
-    case LUA_OPMOD: return luaV_modf(L, v1, v2);
-    default: lua_assert(0); return 0;
-  }
-}
-
-
-int luaO_rawarith (lua_State *L, int op, const TValue *p1, const TValue *p2,
-                   TValue *res) {
-  switch (op) {
-    case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR:
-    case LUA_OPSHL: case LUA_OPSHR:
-    case LUA_OPBNOT: {  /* operate only on integers */
-      lua_Integer i1; lua_Integer i2;
-      if (tointegerns(p1, &i1) && tointegerns(p2, &i2)) {
-        setivalue(res, intarith(L, op, i1, i2));
-        return 1;
-      }
-      else return 0;  /* fail */
-    }
-    case LUA_OPDIV: case LUA_OPPOW: {  /* operate only on floats */
-      lua_Number n1; lua_Number n2;
-      if (tonumberns(p1, n1) && tonumberns(p2, n2)) {
-        setfltvalue(res, numarith(L, op, n1, n2));
-        return 1;
-      }
-      else return 0;  /* fail */
-    }
-    default: {  /* other operations */
-      lua_Number n1; lua_Number n2;
-      if (ttisinteger(p1) && ttisinteger(p2)) {
-        setivalue(res, intarith(L, op, ivalue(p1), ivalue(p2)));
-        return 1;
-      }
-      else if (tonumberns(p1, n1) && tonumberns(p2, n2)) {
-        setfltvalue(res, numarith(L, op, n1, n2));
-        return 1;
-      }
-      else return 0;  /* fail */
-    }
-  }
-}
-
-
-void luaO_arith (lua_State *L, int op, const TValue *p1, const TValue *p2,
-                 StkId res) {
-  if (!luaO_rawarith(L, op, p1, p2, s2v(res))) {
-    /* could not perform raw operation; try metamethod */
-    luaT_trybinTM(L, p1, p2, res, cast(TMS, (op - LUA_OPADD) + TM_ADD));
-  }
-}
-
-
-int luaO_hexavalue (int c) {
-  if (lisdigit(c)) return c - '0';
-  else return (ltolower(c) - 'a') + 10;
-}
-
-
-static int isneg (const char **s) {
-  if (**s == '-') { (*s)++; return 1; }
-  else if (**s == '+') (*s)++;
-  return 0;
-}
-
-
-
-/*
-** {==================================================================
-** Lua's implementation for 'lua_strx2number'
-** ===================================================================
-*/
-
-#if !defined(lua_strx2number)
-
-/* maximum number of significant digits to read (to avoid overflows
-   even with single floats) */
-#define MAXSIGDIG	30
-
-/*
-** convert a hexadecimal numeric string to a number, following
-** C99 specification for 'strtod'
-*/
-static lua_Number lua_strx2number (const char *s, char **endptr) {
-  int dot = lua_getlocaledecpoint();
-  lua_Number r = l_mathop(0.0);  /* result (accumulator) */
-  int sigdig = 0;  /* number of significant digits */
-  int nosigdig = 0;  /* number of non-significant digits */
-  int e = 0;  /* exponent correction */
-  int neg;  /* 1 if number is negative */
-  int hasdot = 0;  /* true after seen a dot */
-  *endptr = cast_charp(s);  /* nothing is valid yet */
-  while (lisspace(cast_uchar(*s))) s++;  /* skip initial spaces */
-  neg = isneg(&s);  /* check sign */
-  if (!(*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X')))  /* check '0x' */
-    return l_mathop(0.0);  /* invalid format (no '0x') */
-  for (s += 2; ; s++) {  /* skip '0x' and read numeral */
-    if (*s == dot) {
-      if (hasdot) break;  /* second dot? stop loop */
-      else hasdot = 1;
-    }
-    else if (lisxdigit(cast_uchar(*s))) {
-      if (sigdig == 0 && *s == '0')  /* non-significant digit (zero)? */
-        nosigdig++;
-      else if (++sigdig <= MAXSIGDIG)  /* can read it without overflow? */
-          r = (r * l_mathop(16.0)) + luaO_hexavalue(*s);
-      else e++; /* too many digits; ignore, but still count for exponent */
-      if (hasdot) e--;  /* decimal digit? correct exponent */
-    }
-    else break;  /* neither a dot nor a digit */
-  }
-  if (nosigdig + sigdig == 0)  /* no digits? */
-    return l_mathop(0.0);  /* invalid format */
-  *endptr = cast_charp(s);  /* valid up to here */
-  e *= 4;  /* each digit multiplies/divides value by 2^4 */
-  if (*s == 'p' || *s == 'P') {  /* exponent part? */
-    int exp1 = 0;  /* exponent value */
-    int neg1;  /* exponent sign */
-    s++;  /* skip 'p' */
-    neg1 = isneg(&s);  /* sign */
-    if (!lisdigit(cast_uchar(*s)))
-      return l_mathop(0.0);  /* invalid; must have at least one digit */
-    while (lisdigit(cast_uchar(*s)))  /* read exponent */
-      exp1 = exp1 * 10 + *(s++) - '0';
-    if (neg1) exp1 = -exp1;
-    e += exp1;
-    *endptr = cast_charp(s);  /* valid up to here */
-  }
-  if (neg) r = -r;
-  return l_mathop(ldexp)(r, e);
-}
-
-#endif
-/* }====================================================== */
-
-
-/* maximum length of a numeral to be converted to a number */
-#if !defined (L_MAXLENNUM)
-#define L_MAXLENNUM	200
-#endif
-
-/*
-** Convert string 's' to a Lua number (put in 'result'). Return NULL on
-** fail or the address of the ending '\0' on success. ('mode' == 'x')
-** means a hexadecimal numeral.
-*/
-static const char *l_str2dloc (const char *s, lua_Number *result, int mode) {
-  char *endptr;
-  *result = (mode == 'x') ? lua_strx2number(s, &endptr)  /* try to convert */
-                          : lua_str2number(s, &endptr);
-  if (endptr == s) return NULL;  /* nothing recognized? */
-  while (lisspace(cast_uchar(*endptr))) endptr++;  /* skip trailing spaces */
-  return (*endptr == '\0') ? endptr : NULL;  /* OK iff no trailing chars */
-}
-
-
-/*
-** Convert string 's' to a Lua number (put in 'result') handling the
-** current locale.
-** This function accepts both the current locale or a dot as the radix
-** mark. If the conversion fails, it may mean number has a dot but
-** locale accepts something else. In that case, the code copies 's'
-** to a buffer (because 's' is read-only), changes the dot to the
-** current locale radix mark, and tries to convert again.
-** The variable 'mode' checks for special characters in the string:
-** - 'n' means 'inf' or 'nan' (which should be rejected)
-** - 'x' means a hexadecimal numeral
-** - '.' just optimizes the search for the common case (no special chars)
-*/
-static const char *l_str2d (const char *s, lua_Number *result) {
-  const char *endptr;
-  const char *pmode = strpbrk(s, ".xXnN");  /* look for special chars */
-  int mode = pmode ? ltolower(cast_uchar(*pmode)) : 0;
-  if (mode == 'n')  /* reject 'inf' and 'nan' */
-    return NULL;
-  endptr = l_str2dloc(s, result, mode);  /* try to convert */
-  if (endptr == NULL) {  /* failed? may be a different locale */
-    char buff[L_MAXLENNUM + 1];
-    const char *pdot = strchr(s, '.');
-    if (pdot == NULL || strlen(s) > L_MAXLENNUM)
-      return NULL;  /* string too long or no dot; fail */
-    strcpy(buff, s);  /* copy string to buffer */
-    buff[pdot - s] = lua_getlocaledecpoint();  /* correct decimal point */
-    endptr = l_str2dloc(buff, result, mode);  /* try again */
-    if (endptr != NULL)
-      endptr = s + (endptr - buff);  /* make relative to 's' */
-  }
-  return endptr;
-}
-
-
-#define MAXBY10		cast(lua_Unsigned, LUA_MAXINTEGER / 10)
-#define MAXLASTD	cast_int(LUA_MAXINTEGER % 10)
-
-static const char *l_str2int (const char *s, lua_Integer *result) {
-  lua_Unsigned a = 0;
-  int empty = 1;
-  int neg;
-  while (lisspace(cast_uchar(*s))) s++;  /* skip initial spaces */
-  neg = isneg(&s);
-  if (s[0] == '0' &&
-      (s[1] == 'x' || s[1] == 'X')) {  /* hex? */
-    s += 2;  /* skip '0x' */
-    for (; lisxdigit(cast_uchar(*s)); s++) {
-      a = a * 16 + luaO_hexavalue(*s);
-      empty = 0;
-    }
-  }
-  else {  /* decimal */
-    for (; lisdigit(cast_uchar(*s)); s++) {
-      int d = *s - '0';
-      if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg))  /* overflow? */
-        return NULL;  /* do not accept it (as integer) */
-      a = a * 10 + d;
-      empty = 0;
-    }
-  }
-  while (lisspace(cast_uchar(*s))) s++;  /* skip trailing spaces */
-  if (empty || *s != '\0') return NULL;  /* something wrong in the numeral */
-  else {
-    *result = l_castU2S((neg) ? 0u - a : a);
-    return s;
-  }
-}
-
-
-size_t luaO_str2num (const char *s, TValue *o) {
-  lua_Integer i; lua_Number n;
-  const char *e;
-  if ((e = l_str2int(s, &i)) != NULL) {  /* try as an integer */
-    setivalue(o, i);
-  }
-  else if ((e = l_str2d(s, &n)) != NULL) {  /* else try as a float */
-    setfltvalue(o, n);
-  }
-  else
-    return 0;  /* conversion failed */
-  return (e - s) + 1;  /* success; return string size */
-}
-
-
-int luaO_utf8esc (char *buff, unsigned long x) {
-  int n = 1;  /* number of bytes put in buffer (backwards) */
-  lua_assert(x <= 0x7FFFFFFFu);
-  if (x < 0x80)  /* ascii? */
-    buff[UTF8BUFFSZ - 1] = cast_char(x);
-  else {  /* need continuation bytes */
-    unsigned int mfb = 0x3f;  /* maximum that fits in first byte */
-    do {  /* add continuation bytes */
-      buff[UTF8BUFFSZ - (n++)] = cast_char(0x80 | (x & 0x3f));
-      x >>= 6;  /* remove added bits */
-      mfb >>= 1;  /* now there is one less bit available in first byte */
-    } while (x > mfb);  /* still needs continuation byte? */
-    buff[UTF8BUFFSZ - n] = cast_char((~mfb << 1) | x);  /* add first byte */
-  }
-  return n;
-}
-
-
-/*
-** Maximum length of the conversion of a number to a string. Must be
-** enough to accommodate both LUA_INTEGER_FMT and LUA_NUMBER_FMT.
-** (For a long long int, this is 19 digits plus a sign and a final '\0',
-** adding to 21. For a long double, it can go to a sign, 33 digits,
-** the dot, an exponent letter, an exponent sign, 5 exponent digits,
-** and a final '\0', adding to 43.)
-*/
-#define MAXNUMBER2STR	44
-
-
-/*
-** Convert a number object to a string, adding it to a buffer
-*/
-static int tostringbuff (TValue *obj, char *buff) {
-  int len;
-  lua_assert(ttisnumber(obj));
-  if (ttisinteger(obj))
-    len = lua_integer2str(buff, MAXNUMBER2STR, ivalue(obj));
-  else {
-    len = lua_number2str(buff, MAXNUMBER2STR, fltvalue(obj));
-    if (buff[strspn(buff, "-0123456789")] == '\0') {  /* looks like an int? */
-      buff[len++] = lua_getlocaledecpoint();
-      buff[len++] = '0';  /* adds '.0' to result */
-    }
-  }
-  return len;
-}
-
-
-/*
-** Convert a number object to a Lua string, replacing the value at 'obj'
-*/
-void luaO_tostring (lua_State *L, TValue *obj) {
-  char buff[MAXNUMBER2STR];
-  int len = tostringbuff(obj, buff);
-  setsvalue(L, obj, luaS_newlstr(L, buff, len));
-}
-
-
-
-
-/*
-** {==================================================================
-** 'luaO_pushvfstring'
-** ===================================================================
-*/
-
-/*
-** Size for buffer space used by 'luaO_pushvfstring'. It should be
-** (LUA_IDSIZE + MAXNUMBER2STR) + a minimal space for basic messages,
-** so that 'luaG_addinfo' can work directly on the buffer.
-*/
-#define BUFVFS		(LUA_IDSIZE + MAXNUMBER2STR + 95)
-
-/* buffer used by 'luaO_pushvfstring' */
-typedef struct BuffFS {
-  lua_State *L;
-  int pushed;  /* true if there is a part of the result on the stack */
-  int blen;  /* length of partial string in 'space' */
-  char space[BUFVFS];  /* holds last part of the result */
-} BuffFS;
-
-
-/*
-** Push given string to the stack, as part of the result, and
-** join it to previous partial result if there is one.
-** It may call 'luaV_concat' while using one slot from EXTRA_STACK.
-** This call cannot invoke metamethods, as both operands must be
-** strings. It can, however, raise an error if the result is too
-** long. In that case, 'luaV_concat' frees the extra slot before
-** raising the error.
-*/
-static void pushstr (BuffFS *buff, const char *str, size_t lstr) {
-  lua_State *L = buff->L;
-  setsvalue2s(L, L->top.p, luaS_newlstr(L, str, lstr));
-  L->top.p++;  /* may use one slot from EXTRA_STACK */
-  if (!buff->pushed)  /* no previous string on the stack? */
-    buff->pushed = 1;  /* now there is one */
-  else  /* join previous string with new one */
-    luaV_concat(L, 2);
-}
-
-
-/*
-** empty the buffer space into the stack
-*/
-static void clearbuff (BuffFS *buff) {
-  pushstr(buff, buff->space, buff->blen);  /* push buffer contents */
-  buff->blen = 0;  /* space now is empty */
-}
-
-
-/*
-** Get a space of size 'sz' in the buffer. If buffer has not enough
-** space, empty it. 'sz' must fit in an empty buffer.
-*/
-static char *getbuff (BuffFS *buff, int sz) {
-  lua_assert(buff->blen <= BUFVFS); lua_assert(sz <= BUFVFS);
-  if (sz > BUFVFS - buff->blen)  /* not enough space? */
-    clearbuff(buff);
-  return buff->space + buff->blen;
-}
-
-
-#define addsize(b,sz)	((b)->blen += (sz))
-
-
-/*
-** Add 'str' to the buffer. If string is larger than the buffer space,
-** push the string directly to the stack.
-*/
-static void addstr2buff (BuffFS *buff, const char *str, size_t slen) {
-  if (slen <= BUFVFS) {  /* does string fit into buffer? */
-    char *bf = getbuff(buff, cast_int(slen));
-    memcpy(bf, str, slen);  /* add string to buffer */
-    addsize(buff, cast_int(slen));
-  }
-  else {  /* string larger than buffer */
-    clearbuff(buff);  /* string comes after buffer's content */
-    pushstr(buff, str, slen);  /* push string */
-  }
-}
-
-
-/*
-** Add a numeral to the buffer.
-*/
-static void addnum2buff (BuffFS *buff, TValue *num) {
-  char *numbuff = getbuff(buff, MAXNUMBER2STR);
-  int len = tostringbuff(num, numbuff);  /* format number into 'numbuff' */
-  addsize(buff, len);
-}
-
-
-/*
-** this function handles only '%d', '%c', '%f', '%p', '%s', and '%%'
-   conventional formats, plus Lua-specific '%I' and '%U'
-*/
-const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
-  BuffFS buff;  /* holds last part of the result */
-  const char *e;  /* points to next '%' */
-  buff.pushed = buff.blen = 0;
-  buff.L = L;
-  while ((e = strchr(fmt, '%')) != NULL) {
-    addstr2buff(&buff, fmt, e - fmt);  /* add 'fmt' up to '%' */
-    switch (*(e + 1)) {  /* conversion specifier */
-      case 's': {  /* zero-terminated string */
-        const char *s = va_arg(argp, char *);
-        if (s == NULL) s = "(null)";
-        addstr2buff(&buff, s, strlen(s));
-        break;
-      }
-      case 'c': {  /* an 'int' as a character */
-        char c = cast_uchar(va_arg(argp, int));
-        addstr2buff(&buff, &c, sizeof(char));
-        break;
-      }
-      case 'd': {  /* an 'int' */
-        TValue num;
-        setivalue(&num, va_arg(argp, int));
-        addnum2buff(&buff, &num);
-        break;
-      }
-      case 'I': {  /* a 'lua_Integer' */
-        TValue num;
-        setivalue(&num, cast(lua_Integer, va_arg(argp, l_uacInt)));
-        addnum2buff(&buff, &num);
-        break;
-      }
-      case 'f': {  /* a 'lua_Number' */
-        TValue num;
-        setfltvalue(&num, cast_num(va_arg(argp, l_uacNumber)));
-        addnum2buff(&buff, &num);
-        break;
-      }
-      case 'p': {  /* a pointer */
-        const int sz = 3 * sizeof(void*) + 8; /* enough space for '%p' */
-        char *bf = getbuff(&buff, sz);
-        void *p = va_arg(argp, void *);
-        int len = lua_pointer2str(bf, sz, p);
-        addsize(&buff, len);
-        break;
-      }
-      case 'U': {  /* a 'long' as a UTF-8 sequence */
-        char bf[UTF8BUFFSZ];
-        int len = luaO_utf8esc(bf, va_arg(argp, long));
-        addstr2buff(&buff, bf + UTF8BUFFSZ - len, len);
-        break;
-      }
-      case '%': {
-        addstr2buff(&buff, "%", 1);
-        break;
-      }
-      default: {
-        luaG_runerror(L, "invalid option '%%%c' to 'lua_pushfstring'",
-                         *(e + 1));
-      }
-    }
-    fmt = e + 2;  /* skip '%' and the specifier */
-  }
-  addstr2buff(&buff, fmt, strlen(fmt));  /* rest of 'fmt' */
-  clearbuff(&buff);  /* empty buffer into the stack */
-  lua_assert(buff.pushed == 1);
-  return svalue(s2v(L->top.p - 1));
-}
-
-
-const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) {
-  const char *msg;
-  va_list argp;
-  va_start(argp, fmt);
-  msg = luaO_pushvfstring(L, fmt, argp);
-  va_end(argp);
-  return msg;
-}
-
-/* }================================================================== */
-
-
-#define RETS	"..."
-#define PRE	"[string \""
-#define POS	"\"]"
-
-#define addstr(a,b,l)	( memcpy(a,b,(l) * sizeof(char)), a += (l) )
-
-void luaO_chunkid (char *out, const char *source, size_t srclen) {
-  size_t bufflen = LUA_IDSIZE;  /* free space in buffer */
-  if (*source == '=') {  /* 'literal' source */
-    if (srclen <= bufflen)  /* small enough? */
-      memcpy(out, source + 1, srclen * sizeof(char));
-    else {  /* truncate it */
-      addstr(out, source + 1, bufflen - 1);
-      *out = '\0';
-    }
-  }
-  else if (*source == '@') {  /* file name */
-    if (srclen <= bufflen)  /* small enough? */
-      memcpy(out, source + 1, srclen * sizeof(char));
-    else {  /* add '...' before rest of name */
-      addstr(out, RETS, LL(RETS));
-      bufflen -= LL(RETS);
-      memcpy(out, source + 1 + srclen - bufflen, bufflen * sizeof(char));
-    }
-  }
-  else {  /* string; format as [string "source"] */
-    const char *nl = strchr(source, '\n');  /* find first new line (if any) */
-    addstr(out, PRE, LL(PRE));  /* add prefix */
-    bufflen -= LL(PRE RETS POS) + 1;  /* save space for prefix+suffix+'\0' */
-    if (srclen < bufflen && nl == NULL) {  /* small one-line source? */
-      addstr(out, source, srclen);  /* keep it */
-    }
-    else {
-      if (nl != NULL) srclen = nl - source;  /* stop at first newline */
-      if (srclen > bufflen) srclen = bufflen;
-      addstr(out, source, srclen);
-      addstr(out, RETS, LL(RETS));
-    }
-    memcpy(out, POS, (LL(POS) + 1) * sizeof(char));
-  }
-}
-
diff --git a/third-party/lua/src/lobject.h b/third-party/lua/src/lobject.h
deleted file mode 100644
index 556608e4a..000000000
--- a/third-party/lua/src/lobject.h
+++ /dev/null
@@ -1,815 +0,0 @@
-/*
-** $Id: lobject.h $
-** Type definitions for Lua objects
-** See Copyright Notice in lua.h
-*/
-
-
-#ifndef lobject_h
-#define lobject_h
-
-
-#include <stdarg.h>
-
-
-#include "llimits.h"
-#include "lua.h"
-
-
-/*
-** Extra types for collectable non-values
-*/
-#define LUA_TUPVAL	LUA_NUMTYPES  /* upvalues */
-#define LUA_TPROTO	(LUA_NUMTYPES+1)  /* function prototypes */
-#define LUA_TDEADKEY	(LUA_NUMTYPES+2)  /* removed keys in tables */
-
-
-
-/*
-** number of all possible types (including LUA_TNONE but excluding DEADKEY)
-*/
-#define LUA_TOTALTYPES		(LUA_TPROTO + 2)
-
-
-/*
-** tags for Tagged Values have the following use of bits:
-** bits 0-3: actual tag (a LUA_T* constant)
-** bits 4-5: variant bits
-** bit 6: whether value is collectable
-*/
-
-/* add variant bits to a type */
-#define makevariant(t,v)	((t) | ((v) << 4))
-
-
-
-/*
-** Union of all Lua values
-*/
-typedef union Value {
-  struct GCObject *gc;    /* collectable objects */
-  void *p;         /* light userdata */
-  lua_CFunction f; /* light C functions */
-  lua_Integer i;   /* integer numbers */
-  lua_Number n;    /* float numbers */
-  /* not used, but may avoid warnings for uninitialized value */
-  lu_byte ub;
-} Value;
-
-
-/*
-** Tagged Values. This is the basic representation of values in Lua:
-** an actual value plus a tag with its type.
-*/
-
-#define TValuefields	Value value_; lu_byte tt_
-
-typedef struct TValue {
-  TValuefields;
-} TValue;
-
-
-#define val_(o)		((o)->value_)
-#define valraw(o)	(val_(o))
-
-
-/* raw type tag of a TValue */
-#define rawtt(o)	((o)->tt_)
-
-/* tag with no variants (bits 0-3) */
-#define novariant(t)	((t) & 0x0F)
-
-/* type tag of a TValue (bits 0-3 for tags + variant bits 4-5) */
-#define withvariant(t)	((t) & 0x3F)
-#define ttypetag(o)	withvariant(rawtt(o))
-
-/* type of a TValue */
-#define ttype(o)	(novariant(rawtt(o)))
-
-
-/* Macros to test type */
-#define checktag(o,t)		(rawtt(o) == (t))
-#define checktype(o,t)		(ttype(o) == (t))
-
-
-/* Macros for internal tests */
-
-/* collectable object has the same tag as the original value */
-#define righttt(obj)		(ttypetag(obj) == gcvalue(obj)->tt)
-
-/*
-** Any value being manipulated by the program either is non
-** collectable, or the collectable object has the right tag
-** and it is not dead. The option 'L == NULL' allows other
-** macros using this one to be used where L is not available.
-*/
-#define checkliveness(L,obj) \
-	((void)L, lua_longassert(!iscollectable(obj) || \
-		(righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj))))))
-
-
-/* Macros to set values */
-
-/* set a value's tag */
-#define settt_(o,t)	((o)->tt_=(t))
-
-
-/* main macro to copy values (from 'obj2' to 'obj1') */
-#define setobj(L,obj1,obj2) \
-	{ TValue *io1=(obj1); const TValue *io2=(obj2); \
-          io1->value_ = io2->value_; settt_(io1, io2->tt_); \
-	  checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); }
-
-/*
-** Different types of assignments, according to source and destination.
-** (They are mostly equal now, but may be different in the future.)
-*/
-
-/* from stack to stack */
-#define setobjs2s(L,o1,o2)	setobj(L,s2v(o1),s2v(o2))
-/* to stack (not from same stack) */
-#define setobj2s(L,o1,o2)	setobj(L,s2v(o1),o2)
-/* from table to same table */
-#define setobjt2t	setobj
-/* to new object */
-#define setobj2n	setobj
-/* to table */
-#define setobj2t	setobj
-
-
-/*
-** Entries in a Lua stack. Field 'tbclist' forms a list of all
-** to-be-closed variables active in this stack. Dummy entries are
-** used when the distance between two tbc variables does not fit
-** in an unsigned short. They are represented by delta==0, and
-** their real delta is always the maximum value that fits in
-** that field.
-*/
-typedef union StackValue {
-  TValue val;
-  struct {
-    TValuefields;
-    unsigned short delta;
-  } tbclist;
-} StackValue;
-
-
-/* index to stack elements */
-typedef StackValue *StkId;
-
-
-/*
-** When reallocating the stack, change all pointers to the stack into
-** proper offsets.
-*/
-typedef union {
-  StkId p;  /* actual pointer */
-  ptrdiff_t offset;  /* used while the stack is being reallocated */
-} StkIdRel;
-
-
-/* convert a 'StackValue' to a 'TValue' */
-#define s2v(o)	(&(o)->val)
-
-
-
-/*
-** {==================================================================
-** Nil
-** ===================================================================
-*/
-
-/* Standard nil */
-#define LUA_VNIL	makevariant(LUA_TNIL, 0)
-
-/* Empty slot (which might be different from a slot containing nil) */
-#define LUA_VEMPTY	makevariant(LUA_TNIL, 1)
-
-/* Value returned for a key not found in a table (absent key) */
-#define LUA_VABSTKEY	makevariant(LUA_TNIL, 2)
-
-
-/* macro to test for (any kind of) nil */
-#define ttisnil(v)		checktype((v), LUA_TNIL)
-
-
-/* macro to test for a standard nil */
-#define ttisstrictnil(o)	checktag((o), LUA_VNIL)
-
-
-#define setnilvalue(obj) settt_(obj, LUA_VNIL)
-
-
-#define isabstkey(v)		checktag((v), LUA_VABSTKEY)
-
-
-/*
-** macro to detect non-standard nils (used only in assertions)
-*/
-#define isnonstrictnil(v)	(ttisnil(v) && !ttisstrictnil(v))
-
-
-/*
-** By default, entries with any kind of nil are considered empty.
-** (In any definition, values associated with absent keys must also
-** be accepted as empty.)
-*/
-#define isempty(v)		ttisnil(v)
-
-
-/* macro defining a value corresponding to an absent key */
-#define ABSTKEYCONSTANT		{NULL}, LUA_VABSTKEY
-
-
-/* mark an entry as empty */
-#define setempty(v)		settt_(v, LUA_VEMPTY)
-
-
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Booleans
-** ===================================================================
-*/
-
-
-#define LUA_VFALSE	makevariant(LUA_TBOOLEAN, 0)
-#define LUA_VTRUE	makevariant(LUA_TBOOLEAN, 1)
-
-#define ttisboolean(o)		checktype((o), LUA_TBOOLEAN)
-#define ttisfalse(o)		checktag((o), LUA_VFALSE)
-#define ttistrue(o)		checktag((o), LUA_VTRUE)
-
-
-#define l_isfalse(o)	(ttisfalse(o) || ttisnil(o))
-
-
-#define setbfvalue(obj)		settt_(obj, LUA_VFALSE)
-#define setbtvalue(obj)		settt_(obj, LUA_VTRUE)
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Threads
-** ===================================================================
-*/
-
-#define LUA_VTHREAD		makevariant(LUA_TTHREAD, 0)
-
-#define ttisthread(o)		checktag((o), ctb(LUA_VTHREAD))
-
-#define thvalue(o)	check_exp(ttisthread(o), gco2th(val_(o).gc))
-
-#define setthvalue(L,obj,x) \
-  { TValue *io = (obj); lua_State *x_ = (x); \
-    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \
-    checkliveness(L,io); }
-
-#define setthvalue2s(L,o,t)	setthvalue(L,s2v(o),t)
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Collectable Objects
-** ===================================================================
-*/
-
-/*
-** Common Header for all collectable objects (in macro form, to be
-** included in other objects)
-*/
-#define CommonHeader	struct GCObject *next; lu_byte tt; lu_byte marked
-
-
-/* Common type for all collectable objects */
-typedef struct GCObject {
-  CommonHeader;
-} GCObject;
-
-
-/* Bit mark for collectable types */
-#define BIT_ISCOLLECTABLE	(1 << 6)
-
-#define iscollectable(o)	(rawtt(o) & BIT_ISCOLLECTABLE)
-
-/* mark a tag as collectable */
-#define ctb(t)			((t) | BIT_ISCOLLECTABLE)
-
-#define gcvalue(o)	check_exp(iscollectable(o), val_(o).gc)
-
-#define gcvalueraw(v)	((v).gc)
-
-#define setgcovalue(L,obj,x) \
-  { TValue *io = (obj); GCObject *i_g=(x); \
-    val_(io).gc = i_g; settt_(io, ctb(i_g->tt)); }
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Numbers
-** ===================================================================
-*/
-
-/* Variant tags for numbers */
-#define LUA_VNUMINT	makevariant(LUA_TNUMBER, 0)  /* integer numbers */
-#define LUA_VNUMFLT	makevariant(LUA_TNUMBER, 1)  /* float numbers */
-
-#define ttisnumber(o)		checktype((o), LUA_TNUMBER)
-#define ttisfloat(o)		checktag((o), LUA_VNUMFLT)
-#define ttisinteger(o)		checktag((o), LUA_VNUMINT)
-
-#define nvalue(o)	check_exp(ttisnumber(o), \
-	(ttisinteger(o) ? cast_num(ivalue(o)) : fltvalue(o)))
-#define fltvalue(o)	check_exp(ttisfloat(o), val_(o).n)
-#define ivalue(o)	check_exp(ttisinteger(o), val_(o).i)
-
-#define fltvalueraw(v)	((v).n)
-#define ivalueraw(v)	((v).i)
-
-#define setfltvalue(obj,x) \
-  { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); }
-
-#define chgfltvalue(obj,x) \
-  { TValue *io=(obj); lua_assert(ttisfloat(io)); val_(io).n=(x); }
-
-#define setivalue(obj,x) \
-  { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); }
-
-#define chgivalue(obj,x) \
-  { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); }
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Strings
-** ===================================================================
-*/
-
-/* Variant tags for strings */
-#define LUA_VSHRSTR	makevariant(LUA_TSTRING, 0)  /* short strings */
-#define LUA_VLNGSTR	makevariant(LUA_TSTRING, 1)  /* long strings */
-
-#define ttisstring(o)		checktype((o), LUA_TSTRING)
-#define ttisshrstring(o)	checktag((o), ctb(LUA_VSHRSTR))
-#define ttislngstring(o)	checktag((o), ctb(LUA_VLNGSTR))
-
-#define tsvalueraw(v)	(gco2ts((v).gc))
-
-#define tsvalue(o)	check_exp(ttisstring(o), gco2ts(val_(o).gc))
-
-#define setsvalue(L,obj,x) \
-  { TValue *io = (obj); TString *x_ = (x); \
-    val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \
-    checkliveness(L,io); }
-
-/* set a string to the stack */
-#define setsvalue2s(L,o,s)	setsvalue(L,s2v(o),s)
-
-/* set a string to a new object */
-#define setsvalue2n	setsvalue
-
-
-/*
-** Header for a string value.
-*/
-typedef struct TString {
-  CommonHeader;
-  lu_byte extra;  /* reserved words for short strings; "has hash" for longs */
-  lu_byte shrlen;  /* length for short strings */
-  unsigned int hash;
-  union {
-    size_t lnglen;  /* length for long strings */
-    struct TString *hnext;  /* linked list for hash table */
-  } u;
-  char contents[1];
-} TString;
-
-
-
-/*
-** Get the actual string (array of bytes) from a 'TString'.
-*/
-#define getstr(ts)  ((ts)->contents)
-
-
-/* get the actual string (array of bytes) from a Lua value */
-#define svalue(o)       getstr(tsvalue(o))
-
-/* get string length from 'TString *s' */
-#define tsslen(s)	((s)->tt == LUA_VSHRSTR ? (s)->shrlen : (s)->u.lnglen)
-
-/* get string length from 'TValue *o' */
-#define vslen(o)	tsslen(tsvalue(o))
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Userdata
-** ===================================================================
-*/
-
-
-/*
-** Light userdata should be a variant of userdata, but for compatibility
-** reasons they are also different types.
-*/
-#define LUA_VLIGHTUSERDATA	makevariant(LUA_TLIGHTUSERDATA, 0)
-
-#define LUA_VUSERDATA		makevariant(LUA_TUSERDATA, 0)
-
-#define ttislightuserdata(o)	checktag((o), LUA_VLIGHTUSERDATA)
-#define ttisfulluserdata(o)	checktag((o), ctb(LUA_VUSERDATA))
-
-#define pvalue(o)	check_exp(ttislightuserdata(o), val_(o).p)
-#define uvalue(o)	check_exp(ttisfulluserdata(o), gco2u(val_(o).gc))
-
-#define pvalueraw(v)	((v).p)
-
-#define setpvalue(obj,x) \
-  { TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_VLIGHTUSERDATA); }
-
-#define setuvalue(L,obj,x) \
-  { TValue *io = (obj); Udata *x_ = (x); \
-    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VUSERDATA)); \
-    checkliveness(L,io); }
-
-
-/* Ensures that addresses after this type are always fully aligned. */
-typedef union UValue {
-  TValue uv;
-  LUAI_MAXALIGN;  /* ensures maximum alignment for udata bytes */
-} UValue;
-
-
-/*
-** Header for userdata with user values;
-** memory area follows the end of this structure.
-*/
-typedef struct Udata {
-  CommonHeader;
-  unsigned short nuvalue;  /* number of user values */
-  size_t len;  /* number of bytes */
-  struct Table *metatable;
-  GCObject *gclist;
-  UValue uv[1];  /* user values */
-} Udata;
-
-
-/*
-** Header for userdata with no user values. These userdata do not need
-** to be gray during GC, and therefore do not need a 'gclist' field.
-** To simplify, the code always use 'Udata' for both kinds of userdata,
-** making sure it never accesses 'gclist' on userdata with no user values.
-** This structure here is used only to compute the correct size for
-** this representation. (The 'bindata' field in its end ensures correct
-** alignment for binary data following this header.)
-*/
-typedef struct Udata0 {
-  CommonHeader;
-  unsigned short nuvalue;  /* number of user values */
-  size_t len;  /* number of bytes */
-  struct Table *metatable;
-  union {LUAI_MAXALIGN;} bindata;
-} Udata0;
-
-
-/* compute the offset of the memory area of a userdata */
-#define udatamemoffset(nuv) \
-	((nuv) == 0 ? offsetof(Udata0, bindata)  \
-                    : offsetof(Udata, uv) + (sizeof(UValue) * (nuv)))
-
-/* get the address of the memory block inside 'Udata' */
-#define getudatamem(u)	(cast_charp(u) + udatamemoffset((u)->nuvalue))
-
-/* compute the size of a userdata */
-#define sizeudata(nuv,nb)	(udatamemoffset(nuv) + (nb))
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Prototypes
-** ===================================================================
-*/
-
-#define LUA_VPROTO	makevariant(LUA_TPROTO, 0)
-
-
-/*
-** Description of an upvalue for function prototypes
-*/
-typedef struct Upvaldesc {
-  TString *name;  /* upvalue name (for debug information) */
-  lu_byte instack;  /* whether it is in stack (register) */
-  lu_byte idx;  /* index of upvalue (in stack or in outer function's list) */
-  lu_byte kind;  /* kind of corresponding variable */
-} Upvaldesc;
-
-
-/*
-** Description of a local variable for function prototypes
-** (used for debug information)
-*/
-typedef struct LocVar {
-  TString *varname;
-  int startpc;  /* first point where variable is active */
-  int endpc;    /* first point where variable is dead */
-} LocVar;
-
-
-/*
-** Associates the absolute line source for a given instruction ('pc').
-** The array 'lineinfo' gives, for each instruction, the difference in
-** lines from the previous instruction. When that difference does not
-** fit into a byte, Lua saves the absolute line for that instruction.
-** (Lua also saves the absolute line periodically, to speed up the
-** computation of a line number: we can use binary search in the
-** absolute-line array, but we must traverse the 'lineinfo' array
-** linearly to compute a line.)
-*/
-typedef struct AbsLineInfo {
-  int pc;
-  int line;
-} AbsLineInfo;
-
-/*
-** Function Prototypes
-*/
-typedef struct Proto {
-  CommonHeader;
-  lu_byte numparams;  /* number of fixed (named) parameters */
-  lu_byte is_vararg;
-  lu_byte maxstacksize;  /* number of registers needed by this function */
-  int sizeupvalues;  /* size of 'upvalues' */
-  int sizek;  /* size of 'k' */
-  int sizecode;
-  int sizelineinfo;
-  int sizep;  /* size of 'p' */
-  int sizelocvars;
-  int sizeabslineinfo;  /* size of 'abslineinfo' */
-  int linedefined;  /* debug information  */
-  int lastlinedefined;  /* debug information  */
-  TValue *k;  /* constants used by the function */
-  Instruction *code;  /* opcodes */
-  struct Proto **p;  /* functions defined inside the function */
-  Upvaldesc *upvalues;  /* upvalue information */
-  ls_byte *lineinfo;  /* information about source lines (debug information) */
-  AbsLineInfo *abslineinfo;  /* idem */
-  LocVar *locvars;  /* information about local variables (debug information) */
-  TString  *source;  /* used for debug information */
-  GCObject *gclist;
-} Proto;
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Functions
-** ===================================================================
-*/
-
-#define LUA_VUPVAL	makevariant(LUA_TUPVAL, 0)
-
-
-/* Variant tags for functions */
-#define LUA_VLCL	makevariant(LUA_TFUNCTION, 0)  /* Lua closure */
-#define LUA_VLCF	makevariant(LUA_TFUNCTION, 1)  /* light C function */
-#define LUA_VCCL	makevariant(LUA_TFUNCTION, 2)  /* C closure */
-
-#define ttisfunction(o)		checktype(o, LUA_TFUNCTION)
-#define ttisLclosure(o)		checktag((o), ctb(LUA_VLCL))
-#define ttislcf(o)		checktag((o), LUA_VLCF)
-#define ttisCclosure(o)		checktag((o), ctb(LUA_VCCL))
-#define ttisclosure(o)         (ttisLclosure(o) || ttisCclosure(o))
-
-
-#define isLfunction(o)	ttisLclosure(o)
-
-#define clvalue(o)	check_exp(ttisclosure(o), gco2cl(val_(o).gc))
-#define clLvalue(o)	check_exp(ttisLclosure(o), gco2lcl(val_(o).gc))
-#define fvalue(o)	check_exp(ttislcf(o), val_(o).f)
-#define clCvalue(o)	check_exp(ttisCclosure(o), gco2ccl(val_(o).gc))
-
-#define fvalueraw(v)	((v).f)
-
-#define setclLvalue(L,obj,x) \
-  { TValue *io = (obj); LClosure *x_ = (x); \
-    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \
-    checkliveness(L,io); }
-
-#define setclLvalue2s(L,o,cl)	setclLvalue(L,s2v(o),cl)
-
-#define setfvalue(obj,x) \
-  { TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_VLCF); }
-
-#define setclCvalue(L,obj,x) \
-  { TValue *io = (obj); CClosure *x_ = (x); \
-    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VCCL)); \
-    checkliveness(L,io); }
-
-
-/*
-** Upvalues for Lua closures
-*/
-typedef struct UpVal {
-  CommonHeader;
-  union {
-    TValue *p;  /* points to stack or to its own value */
-    ptrdiff_t offset;  /* used while the stack is being reallocated */
-  } v;
-  union {
-    struct {  /* (when open) */
-      struct UpVal *next;  /* linked list */
-      struct UpVal **previous;
-    } open;
-    TValue value;  /* the value (when closed) */
-  } u;
-} UpVal;
-
-
-
-#define ClosureHeader \
-	CommonHeader; lu_byte nupvalues; GCObject *gclist
-
-typedef struct CClosure {
-  ClosureHeader;
-  lua_CFunction f;
-  TValue upvalue[1];  /* list of upvalues */
-} CClosure;
-
-
-typedef struct LClosure {
-  ClosureHeader;
-  struct Proto *p;
-  UpVal *upvals[1];  /* list of upvalues */
-} LClosure;
-
-
-typedef union Closure {
-  CClosure c;
-  LClosure l;
-} Closure;
-
-
-#define getproto(o)	(clLvalue(o)->p)
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Tables
-** ===================================================================
-*/
-
-#define LUA_VTABLE	makevariant(LUA_TTABLE, 0)
-
-#define ttistable(o)		checktag((o), ctb(LUA_VTABLE))
-
-#define hvalue(o)	check_exp(ttistable(o), gco2t(val_(o).gc))
-
-#define sethvalue(L,obj,x) \
-  { TValue *io = (obj); Table *x_ = (x); \
-    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \
-    checkliveness(L,io); }
-
-#define sethvalue2s(L,o,h)	sethvalue(L,s2v(o),h)
-
-
-/*
-** Nodes for Hash tables: A pack of two TValue's (key-value pairs)
-** plus a 'next' field to link colliding entries. The distribution
-** of the key's fields ('key_tt' and 'key_val') not forming a proper
-** 'TValue' allows for a smaller size for 'Node' both in 4-byte
-** and 8-byte alignments.
-*/
-typedef union Node {
-  struct NodeKey {
-    TValuefields;  /* fields for value */
-    lu_byte key_tt;  /* key type */
-    int next;  /* for chaining */
-    Value key_val;  /* key value */
-  } u;
-  TValue i_val;  /* direct access to node's value as a proper 'TValue' */
-} Node;
-
-
-/* copy a value into a key */
-#define setnodekey(L,node,obj) \
-	{ Node *n_=(node); const TValue *io_=(obj); \
-	  n_->u.key_val = io_->value_; n_->u.key_tt = io_->tt_; \
-	  checkliveness(L,io_); }
-
-
-/* copy a value from a key */
-#define getnodekey(L,obj,node) \
-	{ TValue *io_=(obj); const Node *n_=(node); \
-	  io_->value_ = n_->u.key_val; io_->tt_ = n_->u.key_tt; \
-	  checkliveness(L,io_); }
-
-
-/*
-** About 'alimit': if 'isrealasize(t)' is true, then 'alimit' is the
-** real size of 'array'. Otherwise, the real size of 'array' is the
-** smallest power of two not smaller than 'alimit' (or zero iff 'alimit'
-** is zero); 'alimit' is then used as a hint for #t.
-*/
-
-#define BITRAS		(1 << 7)
-#define isrealasize(t)		(!((t)->flags & BITRAS))
-#define setrealasize(t)		((t)->flags &= cast_byte(~BITRAS))
-#define setnorealasize(t)	((t)->flags |= BITRAS)
-
-
-typedef struct Table {
-  CommonHeader;
-  lu_byte flags;  /* 1<<p means tagmethod(p) is not present */
-  lu_byte lsizenode;  /* log2 of size of 'node' array */
-  unsigned int alimit;  /* "limit" of 'array' array */
-  TValue *array;  /* array part */
-  Node *node;
-  Node *lastfree;  /* any free position is before this position */
-  struct Table *metatable;
-  GCObject *gclist;
-} Table;
-
-
-/*
-** Macros to manipulate keys inserted in nodes
-*/
-#define keytt(node)		((node)->u.key_tt)
-#define keyval(node)		((node)->u.key_val)
-
-#define keyisnil(node)		(keytt(node) == LUA_TNIL)
-#define keyisinteger(node)	(keytt(node) == LUA_VNUMINT)
-#define keyival(node)		(keyval(node).i)
-#define keyisshrstr(node)	(keytt(node) == ctb(LUA_VSHRSTR))
-#define keystrval(node)		(gco2ts(keyval(node).gc))
-
-#define setnilkey(node)		(keytt(node) = LUA_TNIL)
-
-#define keyiscollectable(n)	(keytt(n) & BIT_ISCOLLECTABLE)
-
-#define gckey(n)	(keyval(n).gc)
-#define gckeyN(n)	(keyiscollectable(n) ? gckey(n) : NULL)
-
-
-/*
-** Dead keys in tables have the tag DEADKEY but keep their original
-** gcvalue. This distinguishes them from regular keys but allows them to
-** be found when searched in a special way. ('next' needs that to find
-** keys removed from a table during a traversal.)
-*/
-#define setdeadkey(node)	(keytt(node) = LUA_TDEADKEY)
-#define keyisdead(node)		(keytt(node) == LUA_TDEADKEY)
-
-/* }================================================================== */
-
-
-
-/*
-** 'module' operation for hashing (size is always a power of 2)
-*/
-#define lmod(s,size) \
-	(check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1)))))
-
-
-#define twoto(x)	(1<<(x))
-#define sizenode(t)	(twoto((t)->lsizenode))
-
-
-/* size of buffer for 'luaO_utf8esc' function */
-#define UTF8BUFFSZ	8
-
-LUAI_FUNC int luaO_utf8esc (char *buff, unsigned long x);
-LUAI_FUNC int luaO_ceillog2 (unsigned int x);
-LUAI_FUNC int luaO_rawarith (lua_State *L, int op, const TValue *p1,
-                             const TValue *p2, TValue *res);
-LUAI_FUNC void luaO_arith (lua_State *L, int op, const TValue *p1,
-                           const TValue *p2, StkId res);
-LUAI_FUNC size_t luaO_str2num (const char *s, TValue *o);
-LUAI_FUNC int luaO_hexavalue (int c);
-LUAI_FUNC void luaO_tostring (lua_State *L, TValue *obj);
-LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt,
-                                                       va_list argp);
-LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...);
-LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t srclen);
-
-
-#endif
-
diff --git a/third-party/lua/src/lopcodes.c b/third-party/lua/src/lopcodes.c
deleted file mode 100644
index c67aa227c..000000000
--- a/third-party/lua/src/lopcodes.c
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
-** $Id: lopcodes.c $
-** Opcodes for Lua virtual machine
-** See Copyright Notice in lua.h
-*/
-
-#define lopcodes_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include "lopcodes.h"
-
-
-/* ORDER OP */
-
-LUAI_DDEF const lu_byte luaP_opmodes[NUM_OPCODES] = {
-/*       MM OT IT T  A  mode		   opcode  */
-  opmode(0, 0, 0, 0, 1, iABC)		/* OP_MOVE */
- ,opmode(0, 0, 0, 0, 1, iAsBx)		/* OP_LOADI */
- ,opmode(0, 0, 0, 0, 1, iAsBx)		/* OP_LOADF */
- ,opmode(0, 0, 0, 0, 1, iABx)		/* OP_LOADK */
- ,opmode(0, 0, 0, 0, 1, iABx)		/* OP_LOADKX */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_LOADFALSE */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_LFALSESKIP */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_LOADTRUE */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_LOADNIL */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_GETUPVAL */
- ,opmode(0, 0, 0, 0, 0, iABC)		/* OP_SETUPVAL */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_GETTABUP */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_GETTABLE */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_GETI */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_GETFIELD */
- ,opmode(0, 0, 0, 0, 0, iABC)		/* OP_SETTABUP */
- ,opmode(0, 0, 0, 0, 0, iABC)		/* OP_SETTABLE */
- ,opmode(0, 0, 0, 0, 0, iABC)		/* OP_SETI */
- ,opmode(0, 0, 0, 0, 0, iABC)		/* OP_SETFIELD */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_NEWTABLE */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_SELF */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_ADDI */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_ADDK */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_SUBK */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_MULK */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_MODK */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_POWK */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_DIVK */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_IDIVK */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_BANDK */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_BORK */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_BXORK */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_SHRI */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_SHLI */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_ADD */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_SUB */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_MUL */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_MOD */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_POW */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_DIV */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_IDIV */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_BAND */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_BOR */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_BXOR */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_SHL */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_SHR */
- ,opmode(1, 0, 0, 0, 0, iABC)		/* OP_MMBIN */
- ,opmode(1, 0, 0, 0, 0, iABC)		/* OP_MMBINI*/
- ,opmode(1, 0, 0, 0, 0, iABC)		/* OP_MMBINK*/
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_UNM */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_BNOT */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_NOT */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_LEN */
- ,opmode(0, 0, 0, 0, 1, iABC)		/* OP_CONCAT */
- ,opmode(0, 0, 0, 0, 0, iABC)		/* OP_CLOSE */
- ,opmode(0, 0, 0, 0, 0, iABC)		/* OP_TBC */
- ,opmode(0, 0, 0, 0, 0, isJ)		/* OP_JMP */
- ,opmode(0, 0, 0, 1, 0, iABC)		/* OP_EQ */
- ,opmode(0, 0, 0, 1, 0, iABC)		/* OP_LT */
- ,opmode(0, 0, 0, 1, 0, iABC)		/* OP_LE */
- ,opmode(0, 0, 0, 1, 0, iABC)		/* OP_EQK */
- ,opmode(0, 0, 0, 1, 0, iABC)		/* OP_EQI */
- ,opmode(0, 0, 0, 1, 0, iABC)		/* OP_LTI */
- ,opmode(0, 0, 0, 1, 0, iABC)		/* OP_LEI */
- ,opmode(0, 0, 0, 1, 0, iABC)		/* OP_GTI */
- ,opmode(0, 0, 0, 1, 0, iABC)		/* OP_GEI */
- ,opmode(0, 0, 0, 1, 0, iABC)		/* OP_TEST */
- ,opmode(0, 0, 0, 1, 1, iABC)		/* OP_TESTSET */
- ,opmode(0, 1, 1, 0, 1, iABC)		/* OP_CALL */
- ,opmode(0, 1, 1, 0, 1, iABC)		/* OP_TAILCALL */
- ,opmode(0, 0, 1, 0, 0, iABC)		/* OP_RETURN */
- ,opmode(0, 0, 0, 0, 0, iABC)		/* OP_RETURN0 */
- ,opmode(0, 0, 0, 0, 0, iABC)		/* OP_RETURN1 */
- ,opmode(0, 0, 0, 0, 1, iABx)		/* OP_FORLOOP */
- ,opmode(0, 0, 0, 0, 1, iABx)		/* OP_FORPREP */
- ,opmode(0, 0, 0, 0, 0, iABx)		/* OP_TFORPREP */
- ,opmode(0, 0, 0, 0, 0, iABC)		/* OP_TFORCALL */
- ,opmode(0, 0, 0, 0, 1, iABx)		/* OP_TFORLOOP */
- ,opmode(0, 0, 1, 0, 0, iABC)		/* OP_SETLIST */
- ,opmode(0, 0, 0, 0, 1, iABx)		/* OP_CLOSURE */
- ,opmode(0, 1, 0, 0, 1, iABC)		/* OP_VARARG */
- ,opmode(0, 0, 1, 0, 1, iABC)		/* OP_VARARGPREP */
- ,opmode(0, 0, 0, 0, 0, iAx)		/* OP_EXTRAARG */
-};
-
diff --git a/third-party/lua/src/lopcodes.h b/third-party/lua/src/lopcodes.h
deleted file mode 100644
index 4c5514539..000000000
--- a/third-party/lua/src/lopcodes.h
+++ /dev/null
@@ -1,405 +0,0 @@
-/*
-** $Id: lopcodes.h $
-** Opcodes for Lua virtual machine
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lopcodes_h
-#define lopcodes_h
-
-#include "llimits.h"
-
-
-/*===========================================================================
-  We assume that instructions are unsigned 32-bit integers.
-  All instructions have an opcode in the first 7 bits.
-  Instructions can have the following formats:
-
-        3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
-        1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
-iABC          C(8)     |      B(8)     |k|     A(8)      |   Op(7)     |
-iABx                Bx(17)               |     A(8)      |   Op(7)     |
-iAsBx              sBx (signed)(17)      |     A(8)      |   Op(7)     |
-iAx                           Ax(25)                     |   Op(7)     |
-isJ                           sJ (signed)(25)            |   Op(7)     |
-
-  A signed argument is represented in excess K: the represented value is
-  the written unsigned value minus K, where K is half the maximum for the
-  corresponding unsigned argument.
-===========================================================================*/
-
-
-enum OpMode {iABC, iABx, iAsBx, iAx, isJ};  /* basic instruction formats */
-
-
-/*
-** size and position of opcode arguments.
-*/
-#define SIZE_C		8
-#define SIZE_B		8
-#define SIZE_Bx		(SIZE_C + SIZE_B + 1)
-#define SIZE_A		8
-#define SIZE_Ax		(SIZE_Bx + SIZE_A)
-#define SIZE_sJ		(SIZE_Bx + SIZE_A)
-
-#define SIZE_OP		7
-
-#define POS_OP		0
-
-#define POS_A		(POS_OP + SIZE_OP)
-#define POS_k		(POS_A + SIZE_A)
-#define POS_B		(POS_k + 1)
-#define POS_C		(POS_B + SIZE_B)
-
-#define POS_Bx		POS_k
-
-#define POS_Ax		POS_A
-
-#define POS_sJ		POS_A
-
-
-/*
-** limits for opcode arguments.
-** we use (signed) 'int' to manipulate most arguments,
-** so they must fit in ints.
-*/
-
-/* Check whether type 'int' has at least 'b' bits ('b' < 32) */
-#define L_INTHASBITS(b)		((UINT_MAX >> ((b) - 1)) >= 1)
-
-
-#if L_INTHASBITS(SIZE_Bx)
-#define MAXARG_Bx	((1<<SIZE_Bx)-1)
-#else
-#define MAXARG_Bx	MAX_INT
-#endif
-
-#define OFFSET_sBx	(MAXARG_Bx>>1)         /* 'sBx' is signed */
-
-
-#if L_INTHASBITS(SIZE_Ax)
-#define MAXARG_Ax	((1<<SIZE_Ax)-1)
-#else
-#define MAXARG_Ax	MAX_INT
-#endif
-
-#if L_INTHASBITS(SIZE_sJ)
-#define MAXARG_sJ	((1 << SIZE_sJ) - 1)
-#else
-#define MAXARG_sJ	MAX_INT
-#endif
-
-#define OFFSET_sJ	(MAXARG_sJ >> 1)
-
-
-#define MAXARG_A	((1<<SIZE_A)-1)
-#define MAXARG_B	((1<<SIZE_B)-1)
-#define MAXARG_C	((1<<SIZE_C)-1)
-#define OFFSET_sC	(MAXARG_C >> 1)
-
-#define int2sC(i)	((i) + OFFSET_sC)
-#define sC2int(i)	((i) - OFFSET_sC)
-
-
-/* creates a mask with 'n' 1 bits at position 'p' */
-#define MASK1(n,p)	((~((~(Instruction)0)<<(n)))<<(p))
-
-/* creates a mask with 'n' 0 bits at position 'p' */
-#define MASK0(n,p)	(~MASK1(n,p))
-
-/*
-** the following macros help to manipulate instructions
-*/
-
-#define GET_OPCODE(i)	(cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0)))
-#define SET_OPCODE(i,o)	((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \
-		((cast(Instruction, o)<<POS_OP)&MASK1(SIZE_OP,POS_OP))))
-
-#define checkopm(i,m)	(getOpMode(GET_OPCODE(i)) == m)
-
-
-#define getarg(i,pos,size)	(cast_int(((i)>>(pos)) & MASK1(size,0)))
-#define setarg(i,v,pos,size)	((i) = (((i)&MASK0(size,pos)) | \
-                ((cast(Instruction, v)<<pos)&MASK1(size,pos))))
-
-#define GETARG_A(i)	getarg(i, POS_A, SIZE_A)
-#define SETARG_A(i,v)	setarg(i, v, POS_A, SIZE_A)
-
-#define GETARG_B(i)	check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B))
-#define GETARG_sB(i)	sC2int(GETARG_B(i))
-#define SETARG_B(i,v)	setarg(i, v, POS_B, SIZE_B)
-
-#define GETARG_C(i)	check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C))
-#define GETARG_sC(i)	sC2int(GETARG_C(i))
-#define SETARG_C(i,v)	setarg(i, v, POS_C, SIZE_C)
-
-#define TESTARG_k(i)	check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k)))))
-#define GETARG_k(i)	check_exp(checkopm(i, iABC), getarg(i, POS_k, 1))
-#define SETARG_k(i,v)	setarg(i, v, POS_k, 1)
-
-#define GETARG_Bx(i)	check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx))
-#define SETARG_Bx(i,v)	setarg(i, v, POS_Bx, SIZE_Bx)
-
-#define GETARG_Ax(i)	check_exp(checkopm(i, iAx), getarg(i, POS_Ax, SIZE_Ax))
-#define SETARG_Ax(i,v)	setarg(i, v, POS_Ax, SIZE_Ax)
-
-#define GETARG_sBx(i)  \
-	check_exp(checkopm(i, iAsBx), getarg(i, POS_Bx, SIZE_Bx) - OFFSET_sBx)
-#define SETARG_sBx(i,b)	SETARG_Bx((i),cast_uint((b)+OFFSET_sBx))
-
-#define GETARG_sJ(i)  \
-	check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ)
-#define SETARG_sJ(i,j) \
-	setarg(i, cast_uint((j)+OFFSET_sJ), POS_sJ, SIZE_sJ)
-
-
-#define CREATE_ABCk(o,a,b,c,k)	((cast(Instruction, o)<<POS_OP) \
-			| (cast(Instruction, a)<<POS_A) \
-			| (cast(Instruction, b)<<POS_B) \
-			| (cast(Instruction, c)<<POS_C) \
-			| (cast(Instruction, k)<<POS_k))
-
-#define CREATE_ABx(o,a,bc)	((cast(Instruction, o)<<POS_OP) \
-			| (cast(Instruction, a)<<POS_A) \
-			| (cast(Instruction, bc)<<POS_Bx))
-
-#define CREATE_Ax(o,a)		((cast(Instruction, o)<<POS_OP) \
-			| (cast(Instruction, a)<<POS_Ax))
-
-#define CREATE_sJ(o,j,k)	((cast(Instruction, o) << POS_OP) \
-			| (cast(Instruction, j) << POS_sJ) \
-			| (cast(Instruction, k) << POS_k))
-
-
-#if !defined(MAXINDEXRK)  /* (for debugging only) */
-#define MAXINDEXRK	MAXARG_B
-#endif
-
-
-/*
-** invalid register that fits in 8 bits
-*/
-#define NO_REG		MAXARG_A
-
-
-/*
-** R[x] - register
-** K[x] - constant (in constant table)
-** RK(x) == if k(i) then K[x] else R[x]
-*/
-
-
-/*
-** Grep "ORDER OP" if you change these enums. Opcodes marked with a (*)
-** has extra descriptions in the notes after the enumeration.
-*/
-
-typedef enum {
-/*----------------------------------------------------------------------
-  name		args	description
-------------------------------------------------------------------------*/
-OP_MOVE,/*	A B	R[A] := R[B]					*/
-OP_LOADI,/*	A sBx	R[A] := sBx					*/
-OP_LOADF,/*	A sBx	R[A] := (lua_Number)sBx				*/
-OP_LOADK,/*	A Bx	R[A] := K[Bx]					*/
-OP_LOADKX,/*	A	R[A] := K[extra arg]				*/
-OP_LOADFALSE,/*	A	R[A] := false					*/
-OP_LFALSESKIP,/*A	R[A] := false; pc++	(*)			*/
-OP_LOADTRUE,/*	A	R[A] := true					*/
-OP_LOADNIL,/*	A B	R[A], R[A+1], ..., R[A+B] := nil		*/
-OP_GETUPVAL,/*	A B	R[A] := UpValue[B]				*/
-OP_SETUPVAL,/*	A B	UpValue[B] := R[A]				*/
-
-OP_GETTABUP,/*	A B C	R[A] := UpValue[B][K[C]:string]			*/
-OP_GETTABLE,/*	A B C	R[A] := R[B][R[C]]				*/
-OP_GETI,/*	A B C	R[A] := R[B][C]					*/
-OP_GETFIELD,/*	A B C	R[A] := R[B][K[C]:string]			*/
-
-OP_SETTABUP,/*	A B C	UpValue[A][K[B]:string] := RK(C)		*/
-OP_SETTABLE,/*	A B C	R[A][R[B]] := RK(C)				*/
-OP_SETI,/*	A B C	R[A][B] := RK(C)				*/
-OP_SETFIELD,/*	A B C	R[A][K[B]:string] := RK(C)			*/
-
-OP_NEWTABLE,/*	A B C k	R[A] := {}					*/
-
-OP_SELF,/*	A B C	R[A+1] := R[B]; R[A] := R[B][RK(C):string]	*/
-
-OP_ADDI,/*	A B sC	R[A] := R[B] + sC				*/
-
-OP_ADDK,/*	A B C	R[A] := R[B] + K[C]:number			*/
-OP_SUBK,/*	A B C	R[A] := R[B] - K[C]:number			*/
-OP_MULK,/*	A B C	R[A] := R[B] * K[C]:number			*/
-OP_MODK,/*	A B C	R[A] := R[B] % K[C]:number			*/
-OP_POWK,/*	A B C	R[A] := R[B] ^ K[C]:number			*/
-OP_DIVK,/*	A B C	R[A] := R[B] / K[C]:number			*/
-OP_IDIVK,/*	A B C	R[A] := R[B] // K[C]:number			*/
-
-OP_BANDK,/*	A B C	R[A] := R[B] & K[C]:integer			*/
-OP_BORK,/*	A B C	R[A] := R[B] | K[C]:integer			*/
-OP_BXORK,/*	A B C	R[A] := R[B] ~ K[C]:integer			*/
-
-OP_SHRI,/*	A B sC	R[A] := R[B] >> sC				*/
-OP_SHLI,/*	A B sC	R[A] := sC << R[B]				*/
-
-OP_ADD,/*	A B C	R[A] := R[B] + R[C]				*/
-OP_SUB,/*	A B C	R[A] := R[B] - R[C]				*/
-OP_MUL,/*	A B C	R[A] := R[B] * R[C]				*/
-OP_MOD,/*	A B C	R[A] := R[B] % R[C]				*/
-OP_POW,/*	A B C	R[A] := R[B] ^ R[C]				*/
-OP_DIV,/*	A B C	R[A] := R[B] / R[C]				*/
-OP_IDIV,/*	A B C	R[A] := R[B] // R[C]				*/
-
-OP_BAND,/*	A B C	R[A] := R[B] & R[C]				*/
-OP_BOR,/*	A B C	R[A] := R[B] | R[C]				*/
-OP_BXOR,/*	A B C	R[A] := R[B] ~ R[C]				*/
-OP_SHL,/*	A B C	R[A] := R[B] << R[C]				*/
-OP_SHR,/*	A B C	R[A] := R[B] >> R[C]				*/
-
-OP_MMBIN,/*	A B C	call C metamethod over R[A] and R[B]	(*)	*/
-OP_MMBINI,/*	A sB C k	call C metamethod over R[A] and sB	*/
-OP_MMBINK,/*	A B C k		call C metamethod over R[A] and K[B]	*/
-
-OP_UNM,/*	A B	R[A] := -R[B]					*/
-OP_BNOT,/*	A B	R[A] := ~R[B]					*/
-OP_NOT,/*	A B	R[A] := not R[B]				*/
-OP_LEN,/*	A B	R[A] := #R[B] (length operator)			*/
-
-OP_CONCAT,/*	A B	R[A] := R[A].. ... ..R[A + B - 1]		*/
-
-OP_CLOSE,/*	A	close all upvalues >= R[A]			*/
-OP_TBC,/*	A	mark variable A "to be closed"			*/
-OP_JMP,/*	sJ	pc += sJ					*/
-OP_EQ,/*	A B k	if ((R[A] == R[B]) ~= k) then pc++		*/
-OP_LT,/*	A B k	if ((R[A] <  R[B]) ~= k) then pc++		*/
-OP_LE,/*	A B k	if ((R[A] <= R[B]) ~= k) then pc++		*/
-
-OP_EQK,/*	A B k	if ((R[A] == K[B]) ~= k) then pc++		*/
-OP_EQI,/*	A sB k	if ((R[A] == sB) ~= k) then pc++		*/
-OP_LTI,/*	A sB k	if ((R[A] < sB) ~= k) then pc++			*/
-OP_LEI,/*	A sB k	if ((R[A] <= sB) ~= k) then pc++		*/
-OP_GTI,/*	A sB k	if ((R[A] > sB) ~= k) then pc++			*/
-OP_GEI,/*	A sB k	if ((R[A] >= sB) ~= k) then pc++		*/
-
-OP_TEST,/*	A k	if (not R[A] == k) then pc++			*/
-OP_TESTSET,/*	A B k	if (not R[B] == k) then pc++ else R[A] := R[B] (*) */
-
-OP_CALL,/*	A B C	R[A], ... ,R[A+C-2] := R[A](R[A+1], ... ,R[A+B-1]) */
-OP_TAILCALL,/*	A B C k	return R[A](R[A+1], ... ,R[A+B-1])		*/
-
-OP_RETURN,/*	A B C k	return R[A], ... ,R[A+B-2]	(see note)	*/
-OP_RETURN0,/*		return						*/
-OP_RETURN1,/*	A	return R[A]					*/
-
-OP_FORLOOP,/*	A Bx	update counters; if loop continues then pc-=Bx; */
-OP_FORPREP,/*	A Bx	<check values and prepare counters>;
-                        if not to run then pc+=Bx+1;			*/
-
-OP_TFORPREP,/*	A Bx	create upvalue for R[A + 3]; pc+=Bx		*/
-OP_TFORCALL,/*	A C	R[A+4], ... ,R[A+3+C] := R[A](R[A+1], R[A+2]);	*/
-OP_TFORLOOP,/*	A Bx	if R[A+2] ~= nil then { R[A]=R[A+2]; pc -= Bx }	*/
-
-OP_SETLIST,/*	A B C k	R[A][C+i] := R[A+i], 1 <= i <= B		*/
-
-OP_CLOSURE,/*	A Bx	R[A] := closure(KPROTO[Bx])			*/
-
-OP_VARARG,/*	A C	R[A], R[A+1], ..., R[A+C-2] = vararg		*/
-
-OP_VARARGPREP,/*A	(adjust vararg parameters)			*/
-
-OP_EXTRAARG/*	Ax	extra (larger) argument for previous opcode	*/
-} OpCode;
-
-
-#define NUM_OPCODES	((int)(OP_EXTRAARG) + 1)
-
-
-
-/*===========================================================================
-  Notes:
-
-  (*) Opcode OP_LFALSESKIP is used to convert a condition to a boolean
-  value, in a code equivalent to (not cond ? false : true).  (It
-  produces false and skips the next instruction producing true.)
-
-  (*) Opcodes OP_MMBIN and variants follow each arithmetic and
-  bitwise opcode. If the operation succeeds, it skips this next
-  opcode. Otherwise, this opcode calls the corresponding metamethod.
-
-  (*) Opcode OP_TESTSET is used in short-circuit expressions that need
-  both to jump and to produce a value, such as (a = b or c).
-
-  (*) In OP_CALL, if (B == 0) then B = top - A. If (C == 0), then
-  'top' is set to last_result+1, so next open instruction (OP_CALL,
-  OP_RETURN*, OP_SETLIST) may use 'top'.
-
-  (*) In OP_VARARG, if (C == 0) then use actual number of varargs and
-  set top (like in OP_CALL with C == 0).
-
-  (*) In OP_RETURN, if (B == 0) then return up to 'top'.
-
-  (*) In OP_LOADKX and OP_NEWTABLE, the next instruction is always
-  OP_EXTRAARG.
-
-  (*) In OP_SETLIST, if (B == 0) then real B = 'top'; if k, then
-  real C = EXTRAARG _ C (the bits of EXTRAARG concatenated with the
-  bits of C).
-
-  (*) In OP_NEWTABLE, B is log2 of the hash size (which is always a
-  power of 2) plus 1, or zero for size zero. If not k, the array size
-  is C. Otherwise, the array size is EXTRAARG _ C.
-
-  (*) For comparisons, k specifies what condition the test should accept
-  (true or false).
-
-  (*) In OP_MMBINI/OP_MMBINK, k means the arguments were flipped
-   (the constant is the first operand).
-
-  (*) All 'skips' (pc++) assume that next instruction is a jump.
-
-  (*) In instructions OP_RETURN/OP_TAILCALL, 'k' specifies that the
-  function builds upvalues, which may need to be closed. C > 0 means
-  the function is vararg, so that its 'func' must be corrected before
-  returning; in this case, (C - 1) is its number of fixed parameters.
-
-  (*) In comparisons with an immediate operand, C signals whether the
-  original operand was a float. (It must be corrected in case of
-  metamethods.)
-
-===========================================================================*/
-
-
-/*
-** masks for instruction properties. The format is:
-** bits 0-2: op mode
-** bit 3: instruction set register A
-** bit 4: operator is a test (next instruction must be a jump)
-** bit 5: instruction uses 'L->top' set by previous instruction (when B == 0)
-** bit 6: instruction sets 'L->top' for next instruction (when C == 0)
-** bit 7: instruction is an MM instruction (call a metamethod)
-*/
-
-LUAI_DDEC(const lu_byte luaP_opmodes[NUM_OPCODES];)
-
-#define getOpMode(m)	(cast(enum OpMode, luaP_opmodes[m] & 7))
-#define testAMode(m)	(luaP_opmodes[m] & (1 << 3))
-#define testTMode(m)	(luaP_opmodes[m] & (1 << 4))
-#define testITMode(m)	(luaP_opmodes[m] & (1 << 5))
-#define testOTMode(m)	(luaP_opmodes[m] & (1 << 6))
-#define testMMMode(m)	(luaP_opmodes[m] & (1 << 7))
-
-/* "out top" (set top for next instruction) */
-#define isOT(i)  \
-	((testOTMode(GET_OPCODE(i)) && GETARG_C(i) == 0) || \
-          GET_OPCODE(i) == OP_TAILCALL)
-
-/* "in top" (uses top from previous instruction) */
-#define isIT(i)		(testITMode(GET_OPCODE(i)) && GETARG_B(i) == 0)
-
-#define opmode(mm,ot,it,t,a,m)  \
-    (((mm) << 7) | ((ot) << 6) | ((it) << 5) | ((t) << 4) | ((a) << 3) | (m))
-
-
-/* number of list items to accumulate before a SETLIST instruction */
-#define LFIELDS_PER_FLUSH	50
-
-#endif
diff --git a/third-party/lua/src/lopnames.h b/third-party/lua/src/lopnames.h
deleted file mode 100644
index 965cec9bf..000000000
--- a/third-party/lua/src/lopnames.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
-** $Id: lopnames.h $
-** Opcode names
-** See Copyright Notice in lua.h
-*/
-
-#if !defined(lopnames_h)
-#define lopnames_h
-
-#include <stddef.h>
-
-
-/* ORDER OP */
-
-static const char *const opnames[] = {
-  "MOVE",
-  "LOADI",
-  "LOADF",
-  "LOADK",
-  "LOADKX",
-  "LOADFALSE",
-  "LFALSESKIP",
-  "LOADTRUE",
-  "LOADNIL",
-  "GETUPVAL",
-  "SETUPVAL",
-  "GETTABUP",
-  "GETTABLE",
-  "GETI",
-  "GETFIELD",
-  "SETTABUP",
-  "SETTABLE",
-  "SETI",
-  "SETFIELD",
-  "NEWTABLE",
-  "SELF",
-  "ADDI",
-  "ADDK",
-  "SUBK",
-  "MULK",
-  "MODK",
-  "POWK",
-  "DIVK",
-  "IDIVK",
-  "BANDK",
-  "BORK",
-  "BXORK",
-  "SHRI",
-  "SHLI",
-  "ADD",
-  "SUB",
-  "MUL",
-  "MOD",
-  "POW",
-  "DIV",
-  "IDIV",
-  "BAND",
-  "BOR",
-  "BXOR",
-  "SHL",
-  "SHR",
-  "MMBIN",
-  "MMBINI",
-  "MMBINK",
-  "UNM",
-  "BNOT",
-  "NOT",
-  "LEN",
-  "CONCAT",
-  "CLOSE",
-  "TBC",
-  "JMP",
-  "EQ",
-  "LT",
-  "LE",
-  "EQK",
-  "EQI",
-  "LTI",
-  "LEI",
-  "GTI",
-  "GEI",
-  "TEST",
-  "TESTSET",
-  "CALL",
-  "TAILCALL",
-  "RETURN",
-  "RETURN0",
-  "RETURN1",
-  "FORLOOP",
-  "FORPREP",
-  "TFORPREP",
-  "TFORCALL",
-  "TFORLOOP",
-  "SETLIST",
-  "CLOSURE",
-  "VARARG",
-  "VARARGPREP",
-  "EXTRAARG",
-  NULL
-};
-
-#endif
-
diff --git a/third-party/lua/src/loslib.c b/third-party/lua/src/loslib.c
deleted file mode 100644
index ad5a92768..000000000
--- a/third-party/lua/src/loslib.c
+++ /dev/null
@@ -1,428 +0,0 @@
-/*
-** $Id: loslib.c $
-** Standard Operating System library
-** See Copyright Notice in lua.h
-*/
-
-#define loslib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <errno.h>
-#include <locale.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-/*
-** {==================================================================
-** List of valid conversion specifiers for the 'strftime' function;
-** options are grouped by length; group of length 2 start with '||'.
-** ===================================================================
-*/
-#if !defined(LUA_STRFTIMEOPTIONS)	/* { */
-
-#if defined(LUA_USE_WINDOWS)
-#define LUA_STRFTIMEOPTIONS  "aAbBcdHIjmMpSUwWxXyYzZ%" \
-    "||" "#c#x#d#H#I#j#m#M#S#U#w#W#y#Y"  /* two-char options */
-#elif defined(LUA_USE_C89)  /* ANSI C 89 (only 1-char options) */
-#define LUA_STRFTIMEOPTIONS  "aAbBcdHIjmMpSUwWxXyYZ%"
-#else  /* C99 specification */
-#define LUA_STRFTIMEOPTIONS  "aAbBcCdDeFgGhHIjmMnprRStTuUVwWxXyYzZ%" \
-    "||" "EcECExEXEyEY" "OdOeOHOIOmOMOSOuOUOVOwOWOy"  /* two-char options */
-#endif
-
-#endif					/* } */
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Configuration for time-related stuff
-** ===================================================================
-*/
-
-/*
-** type to represent time_t in Lua
-*/
-#if !defined(LUA_NUMTIME)	/* { */
-
-#define l_timet			lua_Integer
-#define l_pushtime(L,t)		lua_pushinteger(L,(lua_Integer)(t))
-#define l_gettime(L,arg)	luaL_checkinteger(L, arg)
-
-#else				/* }{ */
-
-#define l_timet			lua_Number
-#define l_pushtime(L,t)		lua_pushnumber(L,(lua_Number)(t))
-#define l_gettime(L,arg)	luaL_checknumber(L, arg)
-
-#endif				/* } */
-
-
-#if !defined(l_gmtime)		/* { */
-/*
-** By default, Lua uses gmtime/localtime, except when POSIX is available,
-** where it uses gmtime_r/localtime_r
-*/
-
-#if defined(LUA_USE_POSIX)	/* { */
-
-#define l_gmtime(t,r)		gmtime_r(t,r)
-#define l_localtime(t,r)	localtime_r(t,r)
-
-#else				/* }{ */
-
-/* ISO C definitions */
-#define l_gmtime(t,r)		((void)(r)->tm_sec, gmtime(t))
-#define l_localtime(t,r)	((void)(r)->tm_sec, localtime(t))
-
-#endif				/* } */
-
-#endif				/* } */
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Configuration for 'tmpnam':
-** By default, Lua uses tmpnam except when POSIX is available, where
-** it uses mkstemp.
-** ===================================================================
-*/
-#if !defined(lua_tmpnam)	/* { */
-
-#if defined(LUA_USE_POSIX)	/* { */
-
-#include <unistd.h>
-
-#define LUA_TMPNAMBUFSIZE	32
-
-#if !defined(LUA_TMPNAMTEMPLATE)
-#define LUA_TMPNAMTEMPLATE	"/tmp/lua_XXXXXX"
-#endif
-
-#define lua_tmpnam(b,e) { \
-        strcpy(b, LUA_TMPNAMTEMPLATE); \
-        e = mkstemp(b); \
-        if (e != -1) close(e); \
-        e = (e == -1); }
-
-#else				/* }{ */
-
-/* ISO C definitions */
-#define LUA_TMPNAMBUFSIZE	L_tmpnam
-#define lua_tmpnam(b,e)		{ e = (tmpnam(b) == NULL); }
-
-#endif				/* } */
-
-#endif				/* } */
-/* }================================================================== */
-
-
-#if !defined(l_system)
-#if defined(LUA_USE_IOS)
-/* Despite claiming to be ISO C, iOS does not implement 'system'. */
-#define l_system(cmd) ((cmd) == NULL ? 0 : -1)
-#else
-#define l_system(cmd)	system(cmd)  /* default definition */
-#endif
-#endif
-
-
-static int os_execute (lua_State *L) {
-  const char *cmd = luaL_optstring(L, 1, NULL);
-  int stat;
-  errno = 0;
-  stat = l_system(cmd);
-  if (cmd != NULL)
-    return luaL_execresult(L, stat);
-  else {
-    lua_pushboolean(L, stat);  /* true if there is a shell */
-    return 1;
-  }
-}
-
-
-static int os_remove (lua_State *L) {
-  const char *filename = luaL_checkstring(L, 1);
-  return luaL_fileresult(L, remove(filename) == 0, filename);
-}
-
-
-static int os_rename (lua_State *L) {
-  const char *fromname = luaL_checkstring(L, 1);
-  const char *toname = luaL_checkstring(L, 2);
-  return luaL_fileresult(L, rename(fromname, toname) == 0, NULL);
-}
-
-
-static int os_tmpname (lua_State *L) {
-  char buff[LUA_TMPNAMBUFSIZE];
-  int err;
-  lua_tmpnam(buff, err);
-  if (l_unlikely(err))
-    return luaL_error(L, "unable to generate a unique filename");
-  lua_pushstring(L, buff);
-  return 1;
-}
-
-
-static int os_getenv (lua_State *L) {
-  lua_pushstring(L, getenv(luaL_checkstring(L, 1)));  /* if NULL push nil */
-  return 1;
-}
-
-
-static int os_clock (lua_State *L) {
-  lua_pushnumber(L, ((lua_Number)clock())/(lua_Number)CLOCKS_PER_SEC);
-  return 1;
-}
-
-
-/*
-** {======================================================
-** Time/Date operations
-** { year=%Y, month=%m, day=%d, hour=%H, min=%M, sec=%S,
-**   wday=%w+1, yday=%j, isdst=? }
-** =======================================================
-*/
-
-/*
-** About the overflow check: an overflow cannot occur when time
-** is represented by a lua_Integer, because either lua_Integer is
-** large enough to represent all int fields or it is not large enough
-** to represent a time that cause a field to overflow.  However, if
-** times are represented as doubles and lua_Integer is int, then the
-** time 0x1.e1853b0d184f6p+55 would cause an overflow when adding 1900
-** to compute the year.
-*/
-static void setfield (lua_State *L, const char *key, int value, int delta) {
-  #if (defined(LUA_NUMTIME) && LUA_MAXINTEGER <= INT_MAX)
-    if (l_unlikely(value > LUA_MAXINTEGER - delta))
-      luaL_error(L, "field '%s' is out-of-bound", key);
-  #endif
-  lua_pushinteger(L, (lua_Integer)value + delta);
-  lua_setfield(L, -2, key);
-}
-
-
-static void setboolfield (lua_State *L, const char *key, int value) {
-  if (value < 0)  /* undefined? */
-    return;  /* does not set field */
-  lua_pushboolean(L, value);
-  lua_setfield(L, -2, key);
-}
-
-
-/*
-** Set all fields from structure 'tm' in the table on top of the stack
-*/
-static void setallfields (lua_State *L, struct tm *stm) {
-  setfield(L, "year", stm->tm_year, 1900);
-  setfield(L, "month", stm->tm_mon, 1);
-  setfield(L, "day", stm->tm_mday, 0);
-  setfield(L, "hour", stm->tm_hour, 0);
-  setfield(L, "min", stm->tm_min, 0);
-  setfield(L, "sec", stm->tm_sec, 0);
-  setfield(L, "yday", stm->tm_yday, 1);
-  setfield(L, "wday", stm->tm_wday, 1);
-  setboolfield(L, "isdst", stm->tm_isdst);
-}
-
-
-static int getboolfield (lua_State *L, const char *key) {
-  int res;
-  res = (lua_getfield(L, -1, key) == LUA_TNIL) ? -1 : lua_toboolean(L, -1);
-  lua_pop(L, 1);
-  return res;
-}
-
-
-static int getfield (lua_State *L, const char *key, int d, int delta) {
-  int isnum;
-  int t = lua_getfield(L, -1, key);  /* get field and its type */
-  lua_Integer res = lua_tointegerx(L, -1, &isnum);
-  if (!isnum) {  /* field is not an integer? */
-    if (l_unlikely(t != LUA_TNIL))  /* some other value? */
-      return luaL_error(L, "field '%s' is not an integer", key);
-    else if (l_unlikely(d < 0))  /* absent field; no default? */
-      return luaL_error(L, "field '%s' missing in date table", key);
-    res = d;
-  }
-  else {
-    if (!(res >= 0 ? res - delta <= INT_MAX : INT_MIN + delta <= res))
-      return luaL_error(L, "field '%s' is out-of-bound", key);
-    res -= delta;
-  }
-  lua_pop(L, 1);
-  return (int)res;
-}
-
-
-static const char *checkoption (lua_State *L, const char *conv,
-                                ptrdiff_t convlen, char *buff) {
-  const char *option = LUA_STRFTIMEOPTIONS;
-  int oplen = 1;  /* length of options being checked */
-  for (; *option != '\0' && oplen <= convlen; option += oplen) {
-    if (*option == '|')  /* next block? */
-      oplen++;  /* will check options with next length (+1) */
-    else if (memcmp(conv, option, oplen) == 0) {  /* match? */
-      memcpy(buff, conv, oplen);  /* copy valid option to buffer */
-      buff[oplen] = '\0';
-      return conv + oplen;  /* return next item */
-    }
-  }
-  luaL_argerror(L, 1,
-    lua_pushfstring(L, "invalid conversion specifier '%%%s'", conv));
-  return conv;  /* to avoid warnings */
-}
-
-
-static time_t l_checktime (lua_State *L, int arg) {
-  l_timet t = l_gettime(L, arg);
-  luaL_argcheck(L, (time_t)t == t, arg, "time out-of-bounds");
-  return (time_t)t;
-}
-
-
-/* maximum size for an individual 'strftime' item */
-#define SIZETIMEFMT	250
-
-
-static int os_date (lua_State *L) {
-  size_t slen;
-  const char *s = luaL_optlstring(L, 1, "%c", &slen);
-  time_t t = luaL_opt(L, l_checktime, 2, time(NULL));
-  const char *se = s + slen;  /* 's' end */
-  struct tm tmr, *stm;
-  if (*s == '!') {  /* UTC? */
-    stm = l_gmtime(&t, &tmr);
-    s++;  /* skip '!' */
-  }
-  else
-    stm = l_localtime(&t, &tmr);
-  if (stm == NULL)  /* invalid date? */
-    return luaL_error(L,
-                 "date result cannot be represented in this installation");
-  if (strcmp(s, "*t") == 0) {
-    lua_createtable(L, 0, 9);  /* 9 = number of fields */
-    setallfields(L, stm);
-  }
-  else {
-    char cc[4];  /* buffer for individual conversion specifiers */
-    luaL_Buffer b;
-    cc[0] = '%';
-    luaL_buffinit(L, &b);
-    while (s < se) {
-      if (*s != '%')  /* not a conversion specifier? */
-        luaL_addchar(&b, *s++);
-      else {
-        size_t reslen;
-        char *buff = luaL_prepbuffsize(&b, SIZETIMEFMT);
-        s++;  /* skip '%' */
-        s = checkoption(L, s, se - s, cc + 1);  /* copy specifier to 'cc' */
-        reslen = strftime(buff, SIZETIMEFMT, cc, stm);
-        luaL_addsize(&b, reslen);
-      }
-    }
-    luaL_pushresult(&b);
-  }
-  return 1;
-}
-
-
-static int os_time (lua_State *L) {
-  time_t t;
-  if (lua_isnoneornil(L, 1))  /* called without args? */
-    t = time(NULL);  /* get current time */
-  else {
-    struct tm ts;
-    luaL_checktype(L, 1, LUA_TTABLE);
-    lua_settop(L, 1);  /* make sure table is at the top */
-    ts.tm_year = getfield(L, "year", -1, 1900);
-    ts.tm_mon = getfield(L, "month", -1, 1);
-    ts.tm_mday = getfield(L, "day", -1, 0);
-    ts.tm_hour = getfield(L, "hour", 12, 0);
-    ts.tm_min = getfield(L, "min", 0, 0);
-    ts.tm_sec = getfield(L, "sec", 0, 0);
-    ts.tm_isdst = getboolfield(L, "isdst");
-    t = mktime(&ts);
-    setallfields(L, &ts);  /* update fields with normalized values */
-  }
-  if (t != (time_t)(l_timet)t || t == (time_t)(-1))
-    return luaL_error(L,
-                  "time result cannot be represented in this installation");
-  l_pushtime(L, t);
-  return 1;
-}
-
-
-static int os_difftime (lua_State *L) {
-  time_t t1 = l_checktime(L, 1);
-  time_t t2 = l_checktime(L, 2);
-  lua_pushnumber(L, (lua_Number)difftime(t1, t2));
-  return 1;
-}
-
-/* }====================================================== */
-
-
-static int os_setlocale (lua_State *L) {
-  static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY,
-                      LC_NUMERIC, LC_TIME};
-  static const char *const catnames[] = {"all", "collate", "ctype", "monetary",
-     "numeric", "time", NULL};
-  const char *l = luaL_optstring(L, 1, NULL);
-  int op = luaL_checkoption(L, 2, "all", catnames);
-  lua_pushstring(L, setlocale(cat[op], l));
-  return 1;
-}
-
-
-static int os_exit (lua_State *L) {
-  int status;
-  if (lua_isboolean(L, 1))
-    status = (lua_toboolean(L, 1) ? EXIT_SUCCESS : EXIT_FAILURE);
-  else
-    status = (int)luaL_optinteger(L, 1, EXIT_SUCCESS);
-  if (lua_toboolean(L, 2))
-    lua_close(L);
-  if (L) exit(status);  /* 'if' to avoid warnings for unreachable 'return' */
-  return 0;
-}
-
-
-static const luaL_Reg syslib[] = {
-  {"clock",     os_clock},
-  {"date",      os_date},
-  {"difftime",  os_difftime},
-  {"execute",   os_execute},
-  {"exit",      os_exit},
-  {"getenv",    os_getenv},
-  {"remove",    os_remove},
-  {"rename",    os_rename},
-  {"setlocale", os_setlocale},
-  {"time",      os_time},
-  {"tmpname",   os_tmpname},
-  {NULL, NULL}
-};
-
-/* }====================================================== */
-
-
-
-LUAMOD_API int luaopen_os (lua_State *L) {
-  luaL_newlib(L, syslib);
-  return 1;
-}
-
diff --git a/third-party/lua/src/lparser.c b/third-party/lua/src/lparser.c
deleted file mode 100644
index b745f236f..000000000
--- a/third-party/lua/src/lparser.c
+++ /dev/null
@@ -1,1967 +0,0 @@
-/*
-** $Id: lparser.c $
-** Lua Parser
-** See Copyright Notice in lua.h
-*/
-
-#define lparser_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <limits.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lcode.h"
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "llex.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lparser.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-
-
-
-/* maximum number of local variables per function (must be smaller
-   than 250, due to the bytecode format) */
-#define MAXVARS		200
-
-
-#define hasmultret(k)		((k) == VCALL || (k) == VVARARG)
-
-
-/* because all strings are unified by the scanner, the parser
-   can use pointer equality for string equality */
-#define eqstr(a,b)	((a) == (b))
-
-
-/*
-** nodes for block list (list of active blocks)
-*/
-typedef struct BlockCnt {
-  struct BlockCnt *previous;  /* chain */
-  int firstlabel;  /* index of first label in this block */
-  int firstgoto;  /* index of first pending goto in this block */
-  lu_byte nactvar;  /* # active locals outside the block */
-  lu_byte upval;  /* true if some variable in the block is an upvalue */
-  lu_byte isloop;  /* true if 'block' is a loop */
-  lu_byte insidetbc;  /* true if inside the scope of a to-be-closed var. */
-} BlockCnt;
-
-
-
-/*
-** prototypes for recursive non-terminal functions
-*/
-static void statement (LexState *ls);
-static void expr (LexState *ls, expdesc *v);
-
-
-static l_noret error_expected (LexState *ls, int token) {
-  luaX_syntaxerror(ls,
-      luaO_pushfstring(ls->L, "%s expected", luaX_token2str(ls, token)));
-}
-
-
-static l_noret errorlimit (FuncState *fs, int limit, const char *what) {
-  lua_State *L = fs->ls->L;
-  const char *msg;
-  int line = fs->f->linedefined;
-  const char *where = (line == 0)
-                      ? "main function"
-                      : luaO_pushfstring(L, "function at line %d", line);
-  msg = luaO_pushfstring(L, "too many %s (limit is %d) in %s",
-                             what, limit, where);
-  luaX_syntaxerror(fs->ls, msg);
-}
-
-
-static void checklimit (FuncState *fs, int v, int l, const char *what) {
-  if (v > l) errorlimit(fs, l, what);
-}
-
-
-/*
-** Test whether next token is 'c'; if so, skip it.
-*/
-static int testnext (LexState *ls, int c) {
-  if (ls->t.token == c) {
-    luaX_next(ls);
-    return 1;
-  }
-  else return 0;
-}
-
-
-/*
-** Check that next token is 'c'.
-*/
-static void check (LexState *ls, int c) {
-  if (ls->t.token != c)
-    error_expected(ls, c);
-}
-
-
-/*
-** Check that next token is 'c' and skip it.
-*/
-static void checknext (LexState *ls, int c) {
-  check(ls, c);
-  luaX_next(ls);
-}
-
-
-#define check_condition(ls,c,msg)	{ if (!(c)) luaX_syntaxerror(ls, msg); }
-
-
-/*
-** Check that next token is 'what' and skip it. In case of error,
-** raise an error that the expected 'what' should match a 'who'
-** in line 'where' (if that is not the current line).
-*/
-static void check_match (LexState *ls, int what, int who, int where) {
-  if (l_unlikely(!testnext(ls, what))) {
-    if (where == ls->linenumber)  /* all in the same line? */
-      error_expected(ls, what);  /* do not need a complex message */
-    else {
-      luaX_syntaxerror(ls, luaO_pushfstring(ls->L,
-             "%s expected (to close %s at line %d)",
-              luaX_token2str(ls, what), luaX_token2str(ls, who), where));
-    }
-  }
-}
-
-
-static TString *str_checkname (LexState *ls) {
-  TString *ts;
-  check(ls, TK_NAME);
-  ts = ls->t.seminfo.ts;
-  luaX_next(ls);
-  return ts;
-}
-
-
-static void init_exp (expdesc *e, expkind k, int i) {
-  e->f = e->t = NO_JUMP;
-  e->k = k;
-  e->u.info = i;
-}
-
-
-static void codestring (expdesc *e, TString *s) {
-  e->f = e->t = NO_JUMP;
-  e->k = VKSTR;
-  e->u.strval = s;
-}
-
-
-static void codename (LexState *ls, expdesc *e) {
-  codestring(e, str_checkname(ls));
-}
-
-
-/*
-** Register a new local variable in the active 'Proto' (for debug
-** information).
-*/
-static int registerlocalvar (LexState *ls, FuncState *fs, TString *varname) {
-  Proto *f = fs->f;
-  int oldsize = f->sizelocvars;
-  luaM_growvector(ls->L, f->locvars, fs->ndebugvars, f->sizelocvars,
-                  LocVar, SHRT_MAX, "local variables");
-  while (oldsize < f->sizelocvars)
-    f->locvars[oldsize++].varname = NULL;
-  f->locvars[fs->ndebugvars].varname = varname;
-  f->locvars[fs->ndebugvars].startpc = fs->pc;
-  luaC_objbarrier(ls->L, f, varname);
-  return fs->ndebugvars++;
-}
-
-
-/*
-** Create a new local variable with the given 'name'. Return its index
-** in the function.
-*/
-static int new_localvar (LexState *ls, TString *name) {
-  lua_State *L = ls->L;
-  FuncState *fs = ls->fs;
-  Dyndata *dyd = ls->dyd;
-  Vardesc *var;
-  checklimit(fs, dyd->actvar.n + 1 - fs->firstlocal,
-                 MAXVARS, "local variables");
-  luaM_growvector(L, dyd->actvar.arr, dyd->actvar.n + 1,
-                  dyd->actvar.size, Vardesc, USHRT_MAX, "local variables");
-  var = &dyd->actvar.arr[dyd->actvar.n++];
-  var->vd.kind = VDKREG;  /* default */
-  var->vd.name = name;
-  return dyd->actvar.n - 1 - fs->firstlocal;
-}
-
-#define new_localvarliteral(ls,v) \
-    new_localvar(ls,  \
-      luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1));
-
-
-
-/*
-** Return the "variable description" (Vardesc) of a given variable.
-** (Unless noted otherwise, all variables are referred to by their
-** compiler indices.)
-*/
-static Vardesc *getlocalvardesc (FuncState *fs, int vidx) {
-  return &fs->ls->dyd->actvar.arr[fs->firstlocal + vidx];
-}
-
-
-/*
-** Convert 'nvar', a compiler index level, to its corresponding
-** register. For that, search for the highest variable below that level
-** that is in a register and uses its register index ('ridx') plus one.
-*/
-static int reglevel (FuncState *fs, int nvar) {
-  while (nvar-- > 0) {
-    Vardesc *vd = getlocalvardesc(fs, nvar);  /* get previous variable */
-    if (vd->vd.kind != RDKCTC)  /* is in a register? */
-      return vd->vd.ridx + 1;
-  }
-  return 0;  /* no variables in registers */
-}
-
-
-/*
-** Return the number of variables in the register stack for the given
-** function.
-*/
-int luaY_nvarstack (FuncState *fs) {
-  return reglevel(fs, fs->nactvar);
-}
-
-
-/*
-** Get the debug-information entry for current variable 'vidx'.
-*/
-static LocVar *localdebuginfo (FuncState *fs, int vidx) {
-  Vardesc *vd = getlocalvardesc(fs,  vidx);
-  if (vd->vd.kind == RDKCTC)
-    return NULL;  /* no debug info. for constants */
-  else {
-    int idx = vd->vd.pidx;
-    lua_assert(idx < fs->ndebugvars);
-    return &fs->f->locvars[idx];
-  }
-}
-
-
-/*
-** Create an expression representing variable 'vidx'
-*/
-static void init_var (FuncState *fs, expdesc *e, int vidx) {
-  e->f = e->t = NO_JUMP;
-  e->k = VLOCAL;
-  e->u.var.vidx = vidx;
-  e->u.var.ridx = getlocalvardesc(fs, vidx)->vd.ridx;
-}
-
-
-/*
-** Raises an error if variable described by 'e' is read only
-*/
-static void check_readonly (LexState *ls, expdesc *e) {
-  FuncState *fs = ls->fs;
-  TString *varname = NULL;  /* to be set if variable is const */
-  switch (e->k) {
-    case VCONST: {
-      varname = ls->dyd->actvar.arr[e->u.info].vd.name;
-      break;
-    }
-    case VLOCAL: {
-      Vardesc *vardesc = getlocalvardesc(fs, e->u.var.vidx);
-      if (vardesc->vd.kind != VDKREG)  /* not a regular variable? */
-        varname = vardesc->vd.name;
-      break;
-    }
-    case VUPVAL: {
-      Upvaldesc *up = &fs->f->upvalues[e->u.info];
-      if (up->kind != VDKREG)
-        varname = up->name;
-      break;
-    }
-    default:
-      return;  /* other cases cannot be read-only */
-  }
-  if (varname) {
-    const char *msg = luaO_pushfstring(ls->L,
-       "attempt to assign to const variable '%s'", getstr(varname));
-    luaK_semerror(ls, msg);  /* error */
-  }
-}
-
-
-/*
-** Start the scope for the last 'nvars' created variables.
-*/
-static void adjustlocalvars (LexState *ls, int nvars) {
-  FuncState *fs = ls->fs;
-  int reglevel = luaY_nvarstack(fs);
-  int i;
-  for (i = 0; i < nvars; i++) {
-    int vidx = fs->nactvar++;
-    Vardesc *var = getlocalvardesc(fs, vidx);
-    var->vd.ridx = reglevel++;
-    var->vd.pidx = registerlocalvar(ls, fs, var->vd.name);
-  }
-}
-
-
-/*
-** Close the scope for all variables up to level 'tolevel'.
-** (debug info.)
-*/
-static void removevars (FuncState *fs, int tolevel) {
-  fs->ls->dyd->actvar.n -= (fs->nactvar - tolevel);
-  while (fs->nactvar > tolevel) {
-    LocVar *var = localdebuginfo(fs, --fs->nactvar);
-    if (var)  /* does it have debug information? */
-      var->endpc = fs->pc;
-  }
-}
-
-
-/*
-** Search the upvalues of the function 'fs' for one
-** with the given 'name'.
-*/
-static int searchupvalue (FuncState *fs, TString *name) {
-  int i;
-  Upvaldesc *up = fs->f->upvalues;
-  for (i = 0; i < fs->nups; i++) {
-    if (eqstr(up[i].name, name)) return i;
-  }
-  return -1;  /* not found */
-}
-
-
-static Upvaldesc *allocupvalue (FuncState *fs) {
-  Proto *f = fs->f;
-  int oldsize = f->sizeupvalues;
-  checklimit(fs, fs->nups + 1, MAXUPVAL, "upvalues");
-  luaM_growvector(fs->ls->L, f->upvalues, fs->nups, f->sizeupvalues,
-                  Upvaldesc, MAXUPVAL, "upvalues");
-  while (oldsize < f->sizeupvalues)
-    f->upvalues[oldsize++].name = NULL;
-  return &f->upvalues[fs->nups++];
-}
-
-
-static int newupvalue (FuncState *fs, TString *name, expdesc *v) {
-  Upvaldesc *up = allocupvalue(fs);
-  FuncState *prev = fs->prev;
-  if (v->k == VLOCAL) {
-    up->instack = 1;
-    up->idx = v->u.var.ridx;
-    up->kind = getlocalvardesc(prev, v->u.var.vidx)->vd.kind;
-    lua_assert(eqstr(name, getlocalvardesc(prev, v->u.var.vidx)->vd.name));
-  }
-  else {
-    up->instack = 0;
-    up->idx = cast_byte(v->u.info);
-    up->kind = prev->f->upvalues[v->u.info].kind;
-    lua_assert(eqstr(name, prev->f->upvalues[v->u.info].name));
-  }
-  up->name = name;
-  luaC_objbarrier(fs->ls->L, fs->f, name);
-  return fs->nups - 1;
-}
-
-
-/*
-** Look for an active local variable with the name 'n' in the
-** function 'fs'. If found, initialize 'var' with it and return
-** its expression kind; otherwise return -1.
-*/
-static int searchvar (FuncState *fs, TString *n, expdesc *var) {
-  int i;
-  for (i = cast_int(fs->nactvar) - 1; i >= 0; i--) {
-    Vardesc *vd = getlocalvardesc(fs, i);
-    if (eqstr(n, vd->vd.name)) {  /* found? */
-      if (vd->vd.kind == RDKCTC)  /* compile-time constant? */
-        init_exp(var, VCONST, fs->firstlocal + i);
-      else  /* real variable */
-        init_var(fs, var, i);
-      return var->k;
-    }
-  }
-  return -1;  /* not found */
-}
-
-
-/*
-** Mark block where variable at given level was defined
-** (to emit close instructions later).
-*/
-static void markupval (FuncState *fs, int level) {
-  BlockCnt *bl = fs->bl;
-  while (bl->nactvar > level)
-    bl = bl->previous;
-  bl->upval = 1;
-  fs->needclose = 1;
-}
-
-
-/*
-** Mark that current block has a to-be-closed variable.
-*/
-static void marktobeclosed (FuncState *fs) {
-  BlockCnt *bl = fs->bl;
-  bl->upval = 1;
-  bl->insidetbc = 1;
-  fs->needclose = 1;
-}
-
-
-/*
-** Find a variable with the given name 'n'. If it is an upvalue, add
-** this upvalue into all intermediate functions. If it is a global, set
-** 'var' as 'void' as a flag.
-*/
-static void singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {
-  if (fs == NULL)  /* no more levels? */
-    init_exp(var, VVOID, 0);  /* default is global */
-  else {
-    int v = searchvar(fs, n, var);  /* look up locals at current level */
-    if (v >= 0) {  /* found? */
-      if (v == VLOCAL && !base)
-        markupval(fs, var->u.var.vidx);  /* local will be used as an upval */
-    }
-    else {  /* not found as local at current level; try upvalues */
-      int idx = searchupvalue(fs, n);  /* try existing upvalues */
-      if (idx < 0) {  /* not found? */
-        singlevaraux(fs->prev, n, var, 0);  /* try upper levels */
-        if (var->k == VLOCAL || var->k == VUPVAL)  /* local or upvalue? */
-          idx  = newupvalue(fs, n, var);  /* will be a new upvalue */
-        else  /* it is a global or a constant */
-          return;  /* don't need to do anything at this level */
-      }
-      init_exp(var, VUPVAL, idx);  /* new or old upvalue */
-    }
-  }
-}
-
-
-/*
-** Find a variable with the given name 'n', handling global variables
-** too.
-*/
-static void singlevar (LexState *ls, expdesc *var) {
-  TString *varname = str_checkname(ls);
-  FuncState *fs = ls->fs;
-  singlevaraux(fs, varname, var, 1);
-  if (var->k == VVOID) {  /* global name? */
-    expdesc key;
-    singlevaraux(fs, ls->envn, var, 1);  /* get environment variable */
-    lua_assert(var->k != VVOID);  /* this one must exist */
-    luaK_exp2anyregup(fs, var);  /* but could be a constant */
-    codestring(&key, varname);  /* key is variable name */
-    luaK_indexed(fs, var, &key);  /* env[varname] */
-  }
-}
-
-
-/*
-** Adjust the number of results from an expression list 'e' with 'nexps'
-** expressions to 'nvars' values.
-*/
-static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
-  FuncState *fs = ls->fs;
-  int needed = nvars - nexps;  /* extra values needed */
-  if (hasmultret(e->k)) {  /* last expression has multiple returns? */
-    int extra = needed + 1;  /* discount last expression itself */
-    if (extra < 0)
-      extra = 0;
-    luaK_setreturns(fs, e, extra);  /* last exp. provides the difference */
-  }
-  else {
-    if (e->k != VVOID)  /* at least one expression? */
-      luaK_exp2nextreg(fs, e);  /* close last expression */
-    if (needed > 0)  /* missing values? */
-      luaK_nil(fs, fs->freereg, needed);  /* complete with nils */
-  }
-  if (needed > 0)
-    luaK_reserveregs(fs, needed);  /* registers for extra values */
-  else  /* adding 'needed' is actually a subtraction */
-    fs->freereg += needed;  /* remove extra values */
-}
-
-
-#define enterlevel(ls)	luaE_incCstack(ls->L)
-
-
-#define leavelevel(ls) ((ls)->L->nCcalls--)
-
-
-/*
-** Generates an error that a goto jumps into the scope of some
-** local variable.
-*/
-static l_noret jumpscopeerror (LexState *ls, Labeldesc *gt) {
-  const char *varname = getstr(getlocalvardesc(ls->fs, gt->nactvar)->vd.name);
-  const char *msg = "<goto %s> at line %d jumps into the scope of local '%s'";
-  msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line, varname);
-  luaK_semerror(ls, msg);  /* raise the error */
-}
-
-
-/*
-** Solves the goto at index 'g' to given 'label' and removes it
-** from the list of pending gotos.
-** If it jumps into the scope of some variable, raises an error.
-*/
-static void solvegoto (LexState *ls, int g, Labeldesc *label) {
-  int i;
-  Labellist *gl = &ls->dyd->gt;  /* list of gotos */
-  Labeldesc *gt = &gl->arr[g];  /* goto to be resolved */
-  lua_assert(eqstr(gt->name, label->name));
-  if (l_unlikely(gt->nactvar < label->nactvar))  /* enter some scope? */
-    jumpscopeerror(ls, gt);
-  luaK_patchlist(ls->fs, gt->pc, label->pc);
-  for (i = g; i < gl->n - 1; i++)  /* remove goto from pending list */
-    gl->arr[i] = gl->arr[i + 1];
-  gl->n--;
-}
-
-
-/*
-** Search for an active label with the given name.
-*/
-static Labeldesc *findlabel (LexState *ls, TString *name) {
-  int i;
-  Dyndata *dyd = ls->dyd;
-  /* check labels in current function for a match */
-  for (i = ls->fs->firstlabel; i < dyd->label.n; i++) {
-    Labeldesc *lb = &dyd->label.arr[i];
-    if (eqstr(lb->name, name))  /* correct label? */
-      return lb;
-  }
-  return NULL;  /* label not found */
-}
-
-
-/*
-** Adds a new label/goto in the corresponding list.
-*/
-static int newlabelentry (LexState *ls, Labellist *l, TString *name,
-                          int line, int pc) {
-  int n = l->n;
-  luaM_growvector(ls->L, l->arr, n, l->size,
-                  Labeldesc, SHRT_MAX, "labels/gotos");
-  l->arr[n].name = name;
-  l->arr[n].line = line;
-  l->arr[n].nactvar = ls->fs->nactvar;
-  l->arr[n].close = 0;
-  l->arr[n].pc = pc;
-  l->n = n + 1;
-  return n;
-}
-
-
-static int newgotoentry (LexState *ls, TString *name, int line, int pc) {
-  return newlabelentry(ls, &ls->dyd->gt, name, line, pc);
-}
-
-
-/*
-** Solves forward jumps. Check whether new label 'lb' matches any
-** pending gotos in current block and solves them. Return true
-** if any of the gotos need to close upvalues.
-*/
-static int solvegotos (LexState *ls, Labeldesc *lb) {
-  Labellist *gl = &ls->dyd->gt;
-  int i = ls->fs->bl->firstgoto;
-  int needsclose = 0;
-  while (i < gl->n) {
-    if (eqstr(gl->arr[i].name, lb->name)) {
-      needsclose |= gl->arr[i].close;
-      solvegoto(ls, i, lb);  /* will remove 'i' from the list */
-    }
-    else
-      i++;
-  }
-  return needsclose;
-}
-
-
-/*
-** Create a new label with the given 'name' at the given 'line'.
-** 'last' tells whether label is the last non-op statement in its
-** block. Solves all pending gotos to this new label and adds
-** a close instruction if necessary.
-** Returns true iff it added a close instruction.
-*/
-static int createlabel (LexState *ls, TString *name, int line,
-                        int last) {
-  FuncState *fs = ls->fs;
-  Labellist *ll = &ls->dyd->label;
-  int l = newlabelentry(ls, ll, name, line, luaK_getlabel(fs));
-  if (last) {  /* label is last no-op statement in the block? */
-    /* assume that locals are already out of scope */
-    ll->arr[l].nactvar = fs->bl->nactvar;
-  }
-  if (solvegotos(ls, &ll->arr[l])) {  /* need close? */
-    luaK_codeABC(fs, OP_CLOSE, luaY_nvarstack(fs), 0, 0);
-    return 1;
-  }
-  return 0;
-}
-
-
-/*
-** Adjust pending gotos to outer level of a block.
-*/
-static void movegotosout (FuncState *fs, BlockCnt *bl) {
-  int i;
-  Labellist *gl = &fs->ls->dyd->gt;
-  /* correct pending gotos to current block */
-  for (i = bl->firstgoto; i < gl->n; i++) {  /* for each pending goto */
-    Labeldesc *gt = &gl->arr[i];
-    /* leaving a variable scope? */
-    if (reglevel(fs, gt->nactvar) > reglevel(fs, bl->nactvar))
-      gt->close |= bl->upval;  /* jump may need a close */
-    gt->nactvar = bl->nactvar;  /* update goto level */
-  }
-}
-
-
-static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) {
-  bl->isloop = isloop;
-  bl->nactvar = fs->nactvar;
-  bl->firstlabel = fs->ls->dyd->label.n;
-  bl->firstgoto = fs->ls->dyd->gt.n;
-  bl->upval = 0;
-  bl->insidetbc = (fs->bl != NULL && fs->bl->insidetbc);
-  bl->previous = fs->bl;
-  fs->bl = bl;
-  lua_assert(fs->freereg == luaY_nvarstack(fs));
-}
-
-
-/*
-** generates an error for an undefined 'goto'.
-*/
-static l_noret undefgoto (LexState *ls, Labeldesc *gt) {
-  const char *msg;
-  if (eqstr(gt->name, luaS_newliteral(ls->L, "break"))) {
-    msg = "break outside loop at line %d";
-    msg = luaO_pushfstring(ls->L, msg, gt->line);
-  }
-  else {
-    msg = "no visible label '%s' for <goto> at line %d";
-    msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line);
-  }
-  luaK_semerror(ls, msg);
-}
-
-
-static void leaveblock (FuncState *fs) {
-  BlockCnt *bl = fs->bl;
-  LexState *ls = fs->ls;
-  int hasclose = 0;
-  int stklevel = reglevel(fs, bl->nactvar);  /* level outside the block */
-  removevars(fs, bl->nactvar);  /* remove block locals */
-  lua_assert(bl->nactvar == fs->nactvar);  /* back to level on entry */
-  if (bl->isloop)  /* has to fix pending breaks? */
-    hasclose = createlabel(ls, luaS_newliteral(ls->L, "break"), 0, 0);
-  if (!hasclose && bl->previous && bl->upval)  /* still need a 'close'? */
-    luaK_codeABC(fs, OP_CLOSE, stklevel, 0, 0);
-  fs->freereg = stklevel;  /* free registers */
-  ls->dyd->label.n = bl->firstlabel;  /* remove local labels */
-  fs->bl = bl->previous;  /* current block now is previous one */
-  if (bl->previous)  /* was it a nested block? */
-    movegotosout(fs, bl);  /* update pending gotos to enclosing block */
-  else {
-    if (bl->firstgoto < ls->dyd->gt.n)  /* still pending gotos? */
-      undefgoto(ls, &ls->dyd->gt.arr[bl->firstgoto]);  /* error */
-  }
-}
-
-
-/*
-** adds a new prototype into list of prototypes
-*/
-static Proto *addprototype (LexState *ls) {
-  Proto *clp;
-  lua_State *L = ls->L;
-  FuncState *fs = ls->fs;
-  Proto *f = fs->f;  /* prototype of current function */
-  if (fs->np >= f->sizep) {
-    int oldsize = f->sizep;
-    luaM_growvector(L, f->p, fs->np, f->sizep, Proto *, MAXARG_Bx, "functions");
-    while (oldsize < f->sizep)
-      f->p[oldsize++] = NULL;
-  }
-  f->p[fs->np++] = clp = luaF_newproto(L);
-  luaC_objbarrier(L, f, clp);
-  return clp;
-}
-
-
-/*
-** codes instruction to create new closure in parent function.
-** The OP_CLOSURE instruction uses the last available register,
-** so that, if it invokes the GC, the GC knows which registers
-** are in use at that time.
-
-*/
-static void codeclosure (LexState *ls, expdesc *v) {
-  FuncState *fs = ls->fs->prev;
-  init_exp(v, VRELOC, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np - 1));
-  luaK_exp2nextreg(fs, v);  /* fix it at the last register */
-}
-
-
-static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) {
-  Proto *f = fs->f;
-  fs->prev = ls->fs;  /* linked list of funcstates */
-  fs->ls = ls;
-  ls->fs = fs;
-  fs->pc = 0;
-  fs->previousline = f->linedefined;
-  fs->iwthabs = 0;
-  fs->lasttarget = 0;
-  fs->freereg = 0;
-  fs->nk = 0;
-  fs->nabslineinfo = 0;
-  fs->np = 0;
-  fs->nups = 0;
-  fs->ndebugvars = 0;
-  fs->nactvar = 0;
-  fs->needclose = 0;
-  fs->firstlocal = ls->dyd->actvar.n;
-  fs->firstlabel = ls->dyd->label.n;
-  fs->bl = NULL;
-  f->source = ls->source;
-  luaC_objbarrier(ls->L, f, f->source);
-  f->maxstacksize = 2;  /* registers 0/1 are always valid */
-  enterblock(fs, bl, 0);
-}
-
-
-static void close_func (LexState *ls) {
-  lua_State *L = ls->L;
-  FuncState *fs = ls->fs;
-  Proto *f = fs->f;
-  luaK_ret(fs, luaY_nvarstack(fs), 0);  /* final return */
-  leaveblock(fs);
-  lua_assert(fs->bl == NULL);
-  luaK_finish(fs);
-  luaM_shrinkvector(L, f->code, f->sizecode, fs->pc, Instruction);
-  luaM_shrinkvector(L, f->lineinfo, f->sizelineinfo, fs->pc, ls_byte);
-  luaM_shrinkvector(L, f->abslineinfo, f->sizeabslineinfo,
-                       fs->nabslineinfo, AbsLineInfo);
-  luaM_shrinkvector(L, f->k, f->sizek, fs->nk, TValue);
-  luaM_shrinkvector(L, f->p, f->sizep, fs->np, Proto *);
-  luaM_shrinkvector(L, f->locvars, f->sizelocvars, fs->ndebugvars, LocVar);
-  luaM_shrinkvector(L, f->upvalues, f->sizeupvalues, fs->nups, Upvaldesc);
-  ls->fs = fs->prev;
-  luaC_checkGC(L);
-}
-
-
-
-/*============================================================*/
-/* GRAMMAR RULES */
-/*============================================================*/
-
-
-/*
-** check whether current token is in the follow set of a block.
-** 'until' closes syntactical blocks, but do not close scope,
-** so it is handled in separate.
-*/
-static int block_follow (LexState *ls, int withuntil) {
-  switch (ls->t.token) {
-    case TK_ELSE: case TK_ELSEIF:
-    case TK_END: case TK_EOS:
-      return 1;
-    case TK_UNTIL: return withuntil;
-    default: return 0;
-  }
-}
-
-
-static void statlist (LexState *ls) {
-  /* statlist -> { stat [';'] } */
-  while (!block_follow(ls, 1)) {
-    if (ls->t.token == TK_RETURN) {
-      statement(ls);
-      return;  /* 'return' must be last statement */
-    }
-    statement(ls);
-  }
-}
-
-
-static void fieldsel (LexState *ls, expdesc *v) {
-  /* fieldsel -> ['.' | ':'] NAME */
-  FuncState *fs = ls->fs;
-  expdesc key;
-  luaK_exp2anyregup(fs, v);
-  luaX_next(ls);  /* skip the dot or colon */
-  codename(ls, &key);
-  luaK_indexed(fs, v, &key);
-}
-
-
-static void yindex (LexState *ls, expdesc *v) {
-  /* index -> '[' expr ']' */
-  luaX_next(ls);  /* skip the '[' */
-  expr(ls, v);
-  luaK_exp2val(ls->fs, v);
-  checknext(ls, ']');
-}
-
-
-/*
-** {======================================================================
-** Rules for Constructors
-** =======================================================================
-*/
-
-
-typedef struct ConsControl {
-  expdesc v;  /* last list item read */
-  expdesc *t;  /* table descriptor */
-  int nh;  /* total number of 'record' elements */
-  int na;  /* number of array elements already stored */
-  int tostore;  /* number of array elements pending to be stored */
-} ConsControl;
-
-
-static void recfield (LexState *ls, ConsControl *cc) {
-  /* recfield -> (NAME | '['exp']') = exp */
-  FuncState *fs = ls->fs;
-  int reg = ls->fs->freereg;
-  expdesc tab, key, val;
-  if (ls->t.token == TK_NAME) {
-    checklimit(fs, cc->nh, MAX_INT, "items in a constructor");
-    codename(ls, &key);
-  }
-  else  /* ls->t.token == '[' */
-    yindex(ls, &key);
-  cc->nh++;
-  checknext(ls, '=');
-  tab = *cc->t;
-  luaK_indexed(fs, &tab, &key);
-  expr(ls, &val);
-  luaK_storevar(fs, &tab, &val);
-  fs->freereg = reg;  /* free registers */
-}
-
-
-static void closelistfield (FuncState *fs, ConsControl *cc) {
-  if (cc->v.k == VVOID) return;  /* there is no list item */
-  luaK_exp2nextreg(fs, &cc->v);
-  cc->v.k = VVOID;
-  if (cc->tostore == LFIELDS_PER_FLUSH) {
-    luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore);  /* flush */
-    cc->na += cc->tostore;
-    cc->tostore = 0;  /* no more items pending */
-  }
-}
-
-
-static void lastlistfield (FuncState *fs, ConsControl *cc) {
-  if (cc->tostore == 0) return;
-  if (hasmultret(cc->v.k)) {
-    luaK_setmultret(fs, &cc->v);
-    luaK_setlist(fs, cc->t->u.info, cc->na, LUA_MULTRET);
-    cc->na--;  /* do not count last expression (unknown number of elements) */
-  }
-  else {
-    if (cc->v.k != VVOID)
-      luaK_exp2nextreg(fs, &cc->v);
-    luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore);
-  }
-  cc->na += cc->tostore;
-}
-
-
-static void listfield (LexState *ls, ConsControl *cc) {
-  /* listfield -> exp */
-  expr(ls, &cc->v);
-  cc->tostore++;
-}
-
-
-static void field (LexState *ls, ConsControl *cc) {
-  /* field -> listfield | recfield */
-  switch(ls->t.token) {
-    case TK_NAME: {  /* may be 'listfield' or 'recfield' */
-      if (luaX_lookahead(ls) != '=')  /* expression? */
-        listfield(ls, cc);
-      else
-        recfield(ls, cc);
-      break;
-    }
-    case '[': {
-      recfield(ls, cc);
-      break;
-    }
-    default: {
-      listfield(ls, cc);
-      break;
-    }
-  }
-}
-
-
-static void constructor (LexState *ls, expdesc *t) {
-  /* constructor -> '{' [ field { sep field } [sep] ] '}'
-     sep -> ',' | ';' */
-  FuncState *fs = ls->fs;
-  int line = ls->linenumber;
-  int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0);
-  ConsControl cc;
-  luaK_code(fs, 0);  /* space for extra arg. */
-  cc.na = cc.nh = cc.tostore = 0;
-  cc.t = t;
-  init_exp(t, VNONRELOC, fs->freereg);  /* table will be at stack top */
-  luaK_reserveregs(fs, 1);
-  init_exp(&cc.v, VVOID, 0);  /* no value (yet) */
-  checknext(ls, '{');
-  do {
-    lua_assert(cc.v.k == VVOID || cc.tostore > 0);
-    if (ls->t.token == '}') break;
-    closelistfield(fs, &cc);
-    field(ls, &cc);
-  } while (testnext(ls, ',') || testnext(ls, ';'));
-  check_match(ls, '}', '{', line);
-  lastlistfield(fs, &cc);
-  luaK_settablesize(fs, pc, t->u.info, cc.na, cc.nh);
-}
-
-/* }====================================================================== */
-
-
-static void setvararg (FuncState *fs, int nparams) {
-  fs->f->is_vararg = 1;
-  luaK_codeABC(fs, OP_VARARGPREP, nparams, 0, 0);
-}
-
-
-static void parlist (LexState *ls) {
-  /* parlist -> [ {NAME ','} (NAME | '...') ] */
-  FuncState *fs = ls->fs;
-  Proto *f = fs->f;
-  int nparams = 0;
-  int isvararg = 0;
-  if (ls->t.token != ')') {  /* is 'parlist' not empty? */
-    do {
-      switch (ls->t.token) {
-        case TK_NAME: {
-          new_localvar(ls, str_checkname(ls));
-          nparams++;
-          break;
-        }
-        case TK_DOTS: {
-          luaX_next(ls);
-          isvararg = 1;
-          break;
-        }
-        default: luaX_syntaxerror(ls, "<name> or '...' expected");
-      }
-    } while (!isvararg && testnext(ls, ','));
-  }
-  adjustlocalvars(ls, nparams);
-  f->numparams = cast_byte(fs->nactvar);
-  if (isvararg)
-    setvararg(fs, f->numparams);  /* declared vararg */
-  luaK_reserveregs(fs, fs->nactvar);  /* reserve registers for parameters */
-}
-
-
-static void body (LexState *ls, expdesc *e, int ismethod, int line) {
-  /* body ->  '(' parlist ')' block END */
-  FuncState new_fs;
-  BlockCnt bl;
-  new_fs.f = addprototype(ls);
-  new_fs.f->linedefined = line;
-  open_func(ls, &new_fs, &bl);
-  checknext(ls, '(');
-  if (ismethod) {
-    new_localvarliteral(ls, "self");  /* create 'self' parameter */
-    adjustlocalvars(ls, 1);
-  }
-  parlist(ls);
-  checknext(ls, ')');
-  statlist(ls);
-  new_fs.f->lastlinedefined = ls->linenumber;
-  check_match(ls, TK_END, TK_FUNCTION, line);
-  codeclosure(ls, e);
-  close_func(ls);
-}
-
-
-static int explist (LexState *ls, expdesc *v) {
-  /* explist -> expr { ',' expr } */
-  int n = 1;  /* at least one expression */
-  expr(ls, v);
-  while (testnext(ls, ',')) {
-    luaK_exp2nextreg(ls->fs, v);
-    expr(ls, v);
-    n++;
-  }
-  return n;
-}
-
-
-static void funcargs (LexState *ls, expdesc *f, int line) {
-  FuncState *fs = ls->fs;
-  expdesc args;
-  int base, nparams;
-  switch (ls->t.token) {
-    case '(': {  /* funcargs -> '(' [ explist ] ')' */
-      luaX_next(ls);
-      if (ls->t.token == ')')  /* arg list is empty? */
-        args.k = VVOID;
-      else {
-        explist(ls, &args);
-        if (hasmultret(args.k))
-          luaK_setmultret(fs, &args);
-      }
-      check_match(ls, ')', '(', line);
-      break;
-    }
-    case '{': {  /* funcargs -> constructor */
-      constructor(ls, &args);
-      break;
-    }
-    case TK_STRING: {  /* funcargs -> STRING */
-      codestring(&args, ls->t.seminfo.ts);
-      luaX_next(ls);  /* must use 'seminfo' before 'next' */
-      break;
-    }
-    default: {
-      luaX_syntaxerror(ls, "function arguments expected");
-    }
-  }
-  lua_assert(f->k == VNONRELOC);
-  base = f->u.info;  /* base register for call */
-  if (hasmultret(args.k))
-    nparams = LUA_MULTRET;  /* open call */
-  else {
-    if (args.k != VVOID)
-      luaK_exp2nextreg(fs, &args);  /* close last argument */
-    nparams = fs->freereg - (base+1);
-  }
-  init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2));
-  luaK_fixline(fs, line);
-  fs->freereg = base+1;  /* call remove function and arguments and leaves
-                            (unless changed) one result */
-}
-
-
-
-
-/*
-** {======================================================================
-** Expression parsing
-** =======================================================================
-*/
-
-
-static void primaryexp (LexState *ls, expdesc *v) {
-  /* primaryexp -> NAME | '(' expr ')' */
-  switch (ls->t.token) {
-    case '(': {
-      int line = ls->linenumber;
-      luaX_next(ls);
-      expr(ls, v);
-      check_match(ls, ')', '(', line);
-      luaK_dischargevars(ls->fs, v);
-      return;
-    }
-    case TK_NAME: {
-      singlevar(ls, v);
-      return;
-    }
-    default: {
-      luaX_syntaxerror(ls, "unexpected symbol");
-    }
-  }
-}
-
-
-static void suffixedexp (LexState *ls, expdesc *v) {
-  /* suffixedexp ->
-       primaryexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs } */
-  FuncState *fs = ls->fs;
-  int line = ls->linenumber;
-  primaryexp(ls, v);
-  for (;;) {
-    switch (ls->t.token) {
-      case '.': {  /* fieldsel */
-        fieldsel(ls, v);
-        break;
-      }
-      case '[': {  /* '[' exp ']' */
-        expdesc key;
-        luaK_exp2anyregup(fs, v);
-        yindex(ls, &key);
-        luaK_indexed(fs, v, &key);
-        break;
-      }
-      case ':': {  /* ':' NAME funcargs */
-        expdesc key;
-        luaX_next(ls);
-        codename(ls, &key);
-        luaK_self(fs, v, &key);
-        funcargs(ls, v, line);
-        break;
-      }
-      case '(': case TK_STRING: case '{': {  /* funcargs */
-        luaK_exp2nextreg(fs, v);
-        funcargs(ls, v, line);
-        break;
-      }
-      default: return;
-    }
-  }
-}
-
-
-static void simpleexp (LexState *ls, expdesc *v) {
-  /* simpleexp -> FLT | INT | STRING | NIL | TRUE | FALSE | ... |
-                  constructor | FUNCTION body | suffixedexp */
-  switch (ls->t.token) {
-    case TK_FLT: {
-      init_exp(v, VKFLT, 0);
-      v->u.nval = ls->t.seminfo.r;
-      break;
-    }
-    case TK_INT: {
-      init_exp(v, VKINT, 0);
-      v->u.ival = ls->t.seminfo.i;
-      break;
-    }
-    case TK_STRING: {
-      codestring(v, ls->t.seminfo.ts);
-      break;
-    }
-    case TK_NIL: {
-      init_exp(v, VNIL, 0);
-      break;
-    }
-    case TK_TRUE: {
-      init_exp(v, VTRUE, 0);
-      break;
-    }
-    case TK_FALSE: {
-      init_exp(v, VFALSE, 0);
-      break;
-    }
-    case TK_DOTS: {  /* vararg */
-      FuncState *fs = ls->fs;
-      check_condition(ls, fs->f->is_vararg,
-                      "cannot use '...' outside a vararg function");
-      init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 0, 1));
-      break;
-    }
-    case '{': {  /* constructor */
-      constructor(ls, v);
-      return;
-    }
-    case TK_FUNCTION: {
-      luaX_next(ls);
-      body(ls, v, 0, ls->linenumber);
-      return;
-    }
-    default: {
-      suffixedexp(ls, v);
-      return;
-    }
-  }
-  luaX_next(ls);
-}
-
-
-static UnOpr getunopr (int op) {
-  switch (op) {
-    case TK_NOT: return OPR_NOT;
-    case '-': return OPR_MINUS;
-    case '~': return OPR_BNOT;
-    case '#': return OPR_LEN;
-    default: return OPR_NOUNOPR;
-  }
-}
-
-
-static BinOpr getbinopr (int op) {
-  switch (op) {
-    case '+': return OPR_ADD;
-    case '-': return OPR_SUB;
-    case '*': return OPR_MUL;
-    case '%': return OPR_MOD;
-    case '^': return OPR_POW;
-    case '/': return OPR_DIV;
-    case TK_IDIV: return OPR_IDIV;
-    case '&': return OPR_BAND;
-    case '|': return OPR_BOR;
-    case '~': return OPR_BXOR;
-    case TK_SHL: return OPR_SHL;
-    case TK_SHR: return OPR_SHR;
-    case TK_CONCAT: return OPR_CONCAT;
-    case TK_NE: return OPR_NE;
-    case TK_EQ: return OPR_EQ;
-    case '<': return OPR_LT;
-    case TK_LE: return OPR_LE;
-    case '>': return OPR_GT;
-    case TK_GE: return OPR_GE;
-    case TK_AND: return OPR_AND;
-    case TK_OR: return OPR_OR;
-    default: return OPR_NOBINOPR;
-  }
-}
-
-
-/*
-** Priority table for binary operators.
-*/
-static const struct {
-  lu_byte left;  /* left priority for each binary operator */
-  lu_byte right; /* right priority */
-} priority[] = {  /* ORDER OPR */
-   {10, 10}, {10, 10},           /* '+' '-' */
-   {11, 11}, {11, 11},           /* '*' '%' */
-   {14, 13},                  /* '^' (right associative) */
-   {11, 11}, {11, 11},           /* '/' '//' */
-   {6, 6}, {4, 4}, {5, 5},   /* '&' '|' '~' */
-   {7, 7}, {7, 7},           /* '<<' '>>' */
-   {9, 8},                   /* '..' (right associative) */
-   {3, 3}, {3, 3}, {3, 3},   /* ==, <, <= */
-   {3, 3}, {3, 3}, {3, 3},   /* ~=, >, >= */
-   {2, 2}, {1, 1}            /* and, or */
-};
-
-#define UNARY_PRIORITY	12  /* priority for unary operators */
-
-
-/*
-** subexpr -> (simpleexp | unop subexpr) { binop subexpr }
-** where 'binop' is any binary operator with a priority higher than 'limit'
-*/
-static BinOpr subexpr (LexState *ls, expdesc *v, int limit) {
-  BinOpr op;
-  UnOpr uop;
-  enterlevel(ls);
-  uop = getunopr(ls->t.token);
-  if (uop != OPR_NOUNOPR) {  /* prefix (unary) operator? */
-    int line = ls->linenumber;
-    luaX_next(ls);  /* skip operator */
-    subexpr(ls, v, UNARY_PRIORITY);
-    luaK_prefix(ls->fs, uop, v, line);
-  }
-  else simpleexp(ls, v);
-  /* expand while operators have priorities higher than 'limit' */
-  op = getbinopr(ls->t.token);
-  while (op != OPR_NOBINOPR && priority[op].left > limit) {
-    expdesc v2;
-    BinOpr nextop;
-    int line = ls->linenumber;
-    luaX_next(ls);  /* skip operator */
-    luaK_infix(ls->fs, op, v);
-    /* read sub-expression with higher priority */
-    nextop = subexpr(ls, &v2, priority[op].right);
-    luaK_posfix(ls->fs, op, v, &v2, line);
-    op = nextop;
-  }
-  leavelevel(ls);
-  return op;  /* return first untreated operator */
-}
-
-
-static void expr (LexState *ls, expdesc *v) {
-  subexpr(ls, v, 0);
-}
-
-/* }==================================================================== */
-
-
-
-/*
-** {======================================================================
-** Rules for Statements
-** =======================================================================
-*/
-
-
-static void block (LexState *ls) {
-  /* block -> statlist */
-  FuncState *fs = ls->fs;
-  BlockCnt bl;
-  enterblock(fs, &bl, 0);
-  statlist(ls);
-  leaveblock(fs);
-}
-
-
-/*
-** structure to chain all variables in the left-hand side of an
-** assignment
-*/
-struct LHS_assign {
-  struct LHS_assign *prev;
-  expdesc v;  /* variable (global, local, upvalue, or indexed) */
-};
-
-
-/*
-** check whether, in an assignment to an upvalue/local variable, the
-** upvalue/local variable is begin used in a previous assignment to a
-** table. If so, save original upvalue/local value in a safe place and
-** use this safe copy in the previous assignment.
-*/
-static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {
-  FuncState *fs = ls->fs;
-  int extra = fs->freereg;  /* eventual position to save local variable */
-  int conflict = 0;
-  for (; lh; lh = lh->prev) {  /* check all previous assignments */
-    if (vkisindexed(lh->v.k)) {  /* assignment to table field? */
-      if (lh->v.k == VINDEXUP) {  /* is table an upvalue? */
-        if (v->k == VUPVAL && lh->v.u.ind.t == v->u.info) {
-          conflict = 1;  /* table is the upvalue being assigned now */
-          lh->v.k = VINDEXSTR;
-          lh->v.u.ind.t = extra;  /* assignment will use safe copy */
-        }
-      }
-      else {  /* table is a register */
-        if (v->k == VLOCAL && lh->v.u.ind.t == v->u.var.ridx) {
-          conflict = 1;  /* table is the local being assigned now */
-          lh->v.u.ind.t = extra;  /* assignment will use safe copy */
-        }
-        /* is index the local being assigned? */
-        if (lh->v.k == VINDEXED && v->k == VLOCAL &&
-            lh->v.u.ind.idx == v->u.var.ridx) {
-          conflict = 1;
-          lh->v.u.ind.idx = extra;  /* previous assignment will use safe copy */
-        }
-      }
-    }
-  }
-  if (conflict) {
-    /* copy upvalue/local value to a temporary (in position 'extra') */
-    if (v->k == VLOCAL)
-      luaK_codeABC(fs, OP_MOVE, extra, v->u.var.ridx, 0);
-    else
-      luaK_codeABC(fs, OP_GETUPVAL, extra, v->u.info, 0);
-    luaK_reserveregs(fs, 1);
-  }
-}
-
-/*
-** Parse and compile a multiple assignment. The first "variable"
-** (a 'suffixedexp') was already read by the caller.
-**
-** assignment -> suffixedexp restassign
-** restassign -> ',' suffixedexp restassign | '=' explist
-*/
-static void restassign (LexState *ls, struct LHS_assign *lh, int nvars) {
-  expdesc e;
-  check_condition(ls, vkisvar(lh->v.k), "syntax error");
-  check_readonly(ls, &lh->v);
-  if (testnext(ls, ',')) {  /* restassign -> ',' suffixedexp restassign */
-    struct LHS_assign nv;
-    nv.prev = lh;
-    suffixedexp(ls, &nv.v);
-    if (!vkisindexed(nv.v.k))
-      check_conflict(ls, lh, &nv.v);
-    enterlevel(ls);  /* control recursion depth */
-    restassign(ls, &nv, nvars+1);
-    leavelevel(ls);
-  }
-  else {  /* restassign -> '=' explist */
-    int nexps;
-    checknext(ls, '=');
-    nexps = explist(ls, &e);
-    if (nexps != nvars)
-      adjust_assign(ls, nvars, nexps, &e);
-    else {
-      luaK_setoneret(ls->fs, &e);  /* close last expression */
-      luaK_storevar(ls->fs, &lh->v, &e);
-      return;  /* avoid default */
-    }
-  }
-  init_exp(&e, VNONRELOC, ls->fs->freereg-1);  /* default assignment */
-  luaK_storevar(ls->fs, &lh->v, &e);
-}
-
-
-static int cond (LexState *ls) {
-  /* cond -> exp */
-  expdesc v;
-  expr(ls, &v);  /* read condition */
-  if (v.k == VNIL) v.k = VFALSE;  /* 'falses' are all equal here */
-  luaK_goiftrue(ls->fs, &v);
-  return v.f;
-}
-
-
-static void gotostat (LexState *ls) {
-  FuncState *fs = ls->fs;
-  int line = ls->linenumber;
-  TString *name = str_checkname(ls);  /* label's name */
-  Labeldesc *lb = findlabel(ls, name);
-  if (lb == NULL)  /* no label? */
-    /* forward jump; will be resolved when the label is declared */
-    newgotoentry(ls, name, line, luaK_jump(fs));
-  else {  /* found a label */
-    /* backward jump; will be resolved here */
-    int lblevel = reglevel(fs, lb->nactvar);  /* label level */
-    if (luaY_nvarstack(fs) > lblevel)  /* leaving the scope of a variable? */
-      luaK_codeABC(fs, OP_CLOSE, lblevel, 0, 0);
-    /* create jump and link it to the label */
-    luaK_patchlist(fs, luaK_jump(fs), lb->pc);
-  }
-}
-
-
-/*
-** Break statement. Semantically equivalent to "goto break".
-*/
-static void breakstat (LexState *ls) {
-  int line = ls->linenumber;
-  luaX_next(ls);  /* skip break */
-  newgotoentry(ls, luaS_newliteral(ls->L, "break"), line, luaK_jump(ls->fs));
-}
-
-
-/*
-** Check whether there is already a label with the given 'name'.
-*/
-static void checkrepeated (LexState *ls, TString *name) {
-  Labeldesc *lb = findlabel(ls, name);
-  if (l_unlikely(lb != NULL)) {  /* already defined? */
-    const char *msg = "label '%s' already defined on line %d";
-    msg = luaO_pushfstring(ls->L, msg, getstr(name), lb->line);
-    luaK_semerror(ls, msg);  /* error */
-  }
-}
-
-
-static void labelstat (LexState *ls, TString *name, int line) {
-  /* label -> '::' NAME '::' */
-  checknext(ls, TK_DBCOLON);  /* skip double colon */
-  while (ls->t.token == ';' || ls->t.token == TK_DBCOLON)
-    statement(ls);  /* skip other no-op statements */
-  checkrepeated(ls, name);  /* check for repeated labels */
-  createlabel(ls, name, line, block_follow(ls, 0));
-}
-
-
-static void whilestat (LexState *ls, int line) {
-  /* whilestat -> WHILE cond DO block END */
-  FuncState *fs = ls->fs;
-  int whileinit;
-  int condexit;
-  BlockCnt bl;
-  luaX_next(ls);  /* skip WHILE */
-  whileinit = luaK_getlabel(fs);
-  condexit = cond(ls);
-  enterblock(fs, &bl, 1);
-  checknext(ls, TK_DO);
-  block(ls);
-  luaK_jumpto(fs, whileinit);
-  check_match(ls, TK_END, TK_WHILE, line);
-  leaveblock(fs);
-  luaK_patchtohere(fs, condexit);  /* false conditions finish the loop */
-}
-
-
-static void repeatstat (LexState *ls, int line) {
-  /* repeatstat -> REPEAT block UNTIL cond */
-  int condexit;
-  FuncState *fs = ls->fs;
-  int repeat_init = luaK_getlabel(fs);
-  BlockCnt bl1, bl2;
-  enterblock(fs, &bl1, 1);  /* loop block */
-  enterblock(fs, &bl2, 0);  /* scope block */
-  luaX_next(ls);  /* skip REPEAT */
-  statlist(ls);
-  check_match(ls, TK_UNTIL, TK_REPEAT, line);
-  condexit = cond(ls);  /* read condition (inside scope block) */
-  leaveblock(fs);  /* finish scope */
-  if (bl2.upval) {  /* upvalues? */
-    int exit = luaK_jump(fs);  /* normal exit must jump over fix */
-    luaK_patchtohere(fs, condexit);  /* repetition must close upvalues */
-    luaK_codeABC(fs, OP_CLOSE, reglevel(fs, bl2.nactvar), 0, 0);
-    condexit = luaK_jump(fs);  /* repeat after closing upvalues */
-    luaK_patchtohere(fs, exit);  /* normal exit comes to here */
-  }
-  luaK_patchlist(fs, condexit, repeat_init);  /* close the loop */
-  leaveblock(fs);  /* finish loop */
-}
-
-
-/*
-** Read an expression and generate code to put its results in next
-** stack slot.
-**
-*/
-static void exp1 (LexState *ls) {
-  expdesc e;
-  expr(ls, &e);
-  luaK_exp2nextreg(ls->fs, &e);
-  lua_assert(e.k == VNONRELOC);
-}
-
-
-/*
-** Fix for instruction at position 'pc' to jump to 'dest'.
-** (Jump addresses are relative in Lua). 'back' true means
-** a back jump.
-*/
-static void fixforjump (FuncState *fs, int pc, int dest, int back) {
-  Instruction *jmp = &fs->f->code[pc];
-  int offset = dest - (pc + 1);
-  if (back)
-    offset = -offset;
-  if (l_unlikely(offset > MAXARG_Bx))
-    luaX_syntaxerror(fs->ls, "control structure too long");
-  SETARG_Bx(*jmp, offset);
-}
-
-
-/*
-** Generate code for a 'for' loop.
-*/
-static void forbody (LexState *ls, int base, int line, int nvars, int isgen) {
-  /* forbody -> DO block */
-  static const OpCode forprep[2] = {OP_FORPREP, OP_TFORPREP};
-  static const OpCode forloop[2] = {OP_FORLOOP, OP_TFORLOOP};
-  BlockCnt bl;
-  FuncState *fs = ls->fs;
-  int prep, endfor;
-  checknext(ls, TK_DO);
-  prep = luaK_codeABx(fs, forprep[isgen], base, 0);
-  enterblock(fs, &bl, 0);  /* scope for declared variables */
-  adjustlocalvars(ls, nvars);
-  luaK_reserveregs(fs, nvars);
-  block(ls);
-  leaveblock(fs);  /* end of scope for declared variables */
-  fixforjump(fs, prep, luaK_getlabel(fs), 0);
-  if (isgen) {  /* generic for? */
-    luaK_codeABC(fs, OP_TFORCALL, base, 0, nvars);
-    luaK_fixline(fs, line);
-  }
-  endfor = luaK_codeABx(fs, forloop[isgen], base, 0);
-  fixforjump(fs, endfor, prep + 1, 1);
-  luaK_fixline(fs, line);
-}
-
-
-static void fornum (LexState *ls, TString *varname, int line) {
-  /* fornum -> NAME = exp,exp[,exp] forbody */
-  FuncState *fs = ls->fs;
-  int base = fs->freereg;
-  new_localvarliteral(ls, "(for state)");
-  new_localvarliteral(ls, "(for state)");
-  new_localvarliteral(ls, "(for state)");
-  new_localvar(ls, varname);
-  checknext(ls, '=');
-  exp1(ls);  /* initial value */
-  checknext(ls, ',');
-  exp1(ls);  /* limit */
-  if (testnext(ls, ','))
-    exp1(ls);  /* optional step */
-  else {  /* default step = 1 */
-    luaK_int(fs, fs->freereg, 1);
-    luaK_reserveregs(fs, 1);
-  }
-  adjustlocalvars(ls, 3);  /* control variables */
-  forbody(ls, base, line, 1, 0);
-}
-
-
-static void forlist (LexState *ls, TString *indexname) {
-  /* forlist -> NAME {,NAME} IN explist forbody */
-  FuncState *fs = ls->fs;
-  expdesc e;
-  int nvars = 5;  /* gen, state, control, toclose, 'indexname' */
-  int line;
-  int base = fs->freereg;
-  /* create control variables */
-  new_localvarliteral(ls, "(for state)");
-  new_localvarliteral(ls, "(for state)");
-  new_localvarliteral(ls, "(for state)");
-  new_localvarliteral(ls, "(for state)");
-  /* create declared variables */
-  new_localvar(ls, indexname);
-  while (testnext(ls, ',')) {
-    new_localvar(ls, str_checkname(ls));
-    nvars++;
-  }
-  checknext(ls, TK_IN);
-  line = ls->linenumber;
-  adjust_assign(ls, 4, explist(ls, &e), &e);
-  adjustlocalvars(ls, 4);  /* control variables */
-  marktobeclosed(fs);  /* last control var. must be closed */
-  luaK_checkstack(fs, 3);  /* extra space to call generator */
-  forbody(ls, base, line, nvars - 4, 1);
-}
-
-
-static void forstat (LexState *ls, int line) {
-  /* forstat -> FOR (fornum | forlist) END */
-  FuncState *fs = ls->fs;
-  TString *varname;
-  BlockCnt bl;
-  enterblock(fs, &bl, 1);  /* scope for loop and control variables */
-  luaX_next(ls);  /* skip 'for' */
-  varname = str_checkname(ls);  /* first variable name */
-  switch (ls->t.token) {
-    case '=': fornum(ls, varname, line); break;
-    case ',': case TK_IN: forlist(ls, varname); break;
-    default: luaX_syntaxerror(ls, "'=' or 'in' expected");
-  }
-  check_match(ls, TK_END, TK_FOR, line);
-  leaveblock(fs);  /* loop scope ('break' jumps to this point) */
-}
-
-
-static void test_then_block (LexState *ls, int *escapelist) {
-  /* test_then_block -> [IF | ELSEIF] cond THEN block */
-  BlockCnt bl;
-  FuncState *fs = ls->fs;
-  expdesc v;
-  int jf;  /* instruction to skip 'then' code (if condition is false) */
-  luaX_next(ls);  /* skip IF or ELSEIF */
-  expr(ls, &v);  /* read condition */
-  checknext(ls, TK_THEN);
-  if (ls->t.token == TK_BREAK) {  /* 'if x then break' ? */
-    int line = ls->linenumber;
-    luaK_goiffalse(ls->fs, &v);  /* will jump if condition is true */
-    luaX_next(ls);  /* skip 'break' */
-    enterblock(fs, &bl, 0);  /* must enter block before 'goto' */
-    newgotoentry(ls, luaS_newliteral(ls->L, "break"), line, v.t);
-    while (testnext(ls, ';')) {}  /* skip semicolons */
-    if (block_follow(ls, 0)) {  /* jump is the entire block? */
-      leaveblock(fs);
-      return;  /* and that is it */
-    }
-    else  /* must skip over 'then' part if condition is false */
-      jf = luaK_jump(fs);
-  }
-  else {  /* regular case (not a break) */
-    luaK_goiftrue(ls->fs, &v);  /* skip over block if condition is false */
-    enterblock(fs, &bl, 0);
-    jf = v.f;
-  }
-  statlist(ls);  /* 'then' part */
-  leaveblock(fs);
-  if (ls->t.token == TK_ELSE ||
-      ls->t.token == TK_ELSEIF)  /* followed by 'else'/'elseif'? */
-    luaK_concat(fs, escapelist, luaK_jump(fs));  /* must jump over it */
-  luaK_patchtohere(fs, jf);
-}
-
-
-static void ifstat (LexState *ls, int line) {
-  /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */
-  FuncState *fs = ls->fs;
-  int escapelist = NO_JUMP;  /* exit list for finished parts */
-  test_then_block(ls, &escapelist);  /* IF cond THEN block */
-  while (ls->t.token == TK_ELSEIF)
-    test_then_block(ls, &escapelist);  /* ELSEIF cond THEN block */
-  if (testnext(ls, TK_ELSE))
-    block(ls);  /* 'else' part */
-  check_match(ls, TK_END, TK_IF, line);
-  luaK_patchtohere(fs, escapelist);  /* patch escape list to 'if' end */
-}
-
-
-static void localfunc (LexState *ls) {
-  expdesc b;
-  FuncState *fs = ls->fs;
-  int fvar = fs->nactvar;  /* function's variable index */
-  new_localvar(ls, str_checkname(ls));  /* new local variable */
-  adjustlocalvars(ls, 1);  /* enter its scope */
-  body(ls, &b, 0, ls->linenumber);  /* function created in next register */
-  /* debug information will only see the variable after this point! */
-  localdebuginfo(fs, fvar)->startpc = fs->pc;
-}
-
-
-static int getlocalattribute (LexState *ls) {
-  /* ATTRIB -> ['<' Name '>'] */
-  if (testnext(ls, '<')) {
-    const char *attr = getstr(str_checkname(ls));
-    checknext(ls, '>');
-    if (strcmp(attr, "const") == 0)
-      return RDKCONST;  /* read-only variable */
-    else if (strcmp(attr, "close") == 0)
-      return RDKTOCLOSE;  /* to-be-closed variable */
-    else
-      luaK_semerror(ls,
-        luaO_pushfstring(ls->L, "unknown attribute '%s'", attr));
-  }
-  return VDKREG;  /* regular variable */
-}
-
-
-static void checktoclose (FuncState *fs, int level) {
-  if (level != -1) {  /* is there a to-be-closed variable? */
-    marktobeclosed(fs);
-    luaK_codeABC(fs, OP_TBC, reglevel(fs, level), 0, 0);
-  }
-}
-
-
-static void localstat (LexState *ls) {
-  /* stat -> LOCAL NAME ATTRIB { ',' NAME ATTRIB } ['=' explist] */
-  FuncState *fs = ls->fs;
-  int toclose = -1;  /* index of to-be-closed variable (if any) */
-  Vardesc *var;  /* last variable */
-  int vidx, kind;  /* index and kind of last variable */
-  int nvars = 0;
-  int nexps;
-  expdesc e;
-  do {
-    vidx = new_localvar(ls, str_checkname(ls));
-    kind = getlocalattribute(ls);
-    getlocalvardesc(fs, vidx)->vd.kind = kind;
-    if (kind == RDKTOCLOSE) {  /* to-be-closed? */
-      if (toclose != -1)  /* one already present? */
-        luaK_semerror(ls, "multiple to-be-closed variables in local list");
-      toclose = fs->nactvar + nvars;
-    }
-    nvars++;
-  } while (testnext(ls, ','));
-  if (testnext(ls, '='))
-    nexps = explist(ls, &e);
-  else {
-    e.k = VVOID;
-    nexps = 0;
-  }
-  var = getlocalvardesc(fs, vidx);  /* get last variable */
-  if (nvars == nexps &&  /* no adjustments? */
-      var->vd.kind == RDKCONST &&  /* last variable is const? */
-      luaK_exp2const(fs, &e, &var->k)) {  /* compile-time constant? */
-    var->vd.kind = RDKCTC;  /* variable is a compile-time constant */
-    adjustlocalvars(ls, nvars - 1);  /* exclude last variable */
-    fs->nactvar++;  /* but count it */
-  }
-  else {
-    adjust_assign(ls, nvars, nexps, &e);
-    adjustlocalvars(ls, nvars);
-  }
-  checktoclose(fs, toclose);
-}
-
-
-static int funcname (LexState *ls, expdesc *v) {
-  /* funcname -> NAME {fieldsel} [':' NAME] */
-  int ismethod = 0;
-  singlevar(ls, v);
-  while (ls->t.token == '.')
-    fieldsel(ls, v);
-  if (ls->t.token == ':') {
-    ismethod = 1;
-    fieldsel(ls, v);
-  }
-  return ismethod;
-}
-
-
-static void funcstat (LexState *ls, int line) {
-  /* funcstat -> FUNCTION funcname body */
-  int ismethod;
-  expdesc v, b;
-  luaX_next(ls);  /* skip FUNCTION */
-  ismethod = funcname(ls, &v);
-  body(ls, &b, ismethod, line);
-  check_readonly(ls, &v);
-  luaK_storevar(ls->fs, &v, &b);
-  luaK_fixline(ls->fs, line);  /* definition "happens" in the first line */
-}
-
-
-static void exprstat (LexState *ls) {
-  /* stat -> func | assignment */
-  FuncState *fs = ls->fs;
-  struct LHS_assign v;
-  suffixedexp(ls, &v.v);
-  if (ls->t.token == '=' || ls->t.token == ',') { /* stat -> assignment ? */
-    v.prev = NULL;
-    restassign(ls, &v, 1);
-  }
-  else {  /* stat -> func */
-    Instruction *inst;
-    check_condition(ls, v.v.k == VCALL, "syntax error");
-    inst = &getinstruction(fs, &v.v);
-    SETARG_C(*inst, 1);  /* call statement uses no results */
-  }
-}
-
-
-static void retstat (LexState *ls) {
-  /* stat -> RETURN [explist] [';'] */
-  FuncState *fs = ls->fs;
-  expdesc e;
-  int nret;  /* number of values being returned */
-  int first = luaY_nvarstack(fs);  /* first slot to be returned */
-  if (block_follow(ls, 1) || ls->t.token == ';')
-    nret = 0;  /* return no values */
-  else {
-    nret = explist(ls, &e);  /* optional return values */
-    if (hasmultret(e.k)) {
-      luaK_setmultret(fs, &e);
-      if (e.k == VCALL && nret == 1 && !fs->bl->insidetbc) {  /* tail call? */
-        SET_OPCODE(getinstruction(fs,&e), OP_TAILCALL);
-        lua_assert(GETARG_A(getinstruction(fs,&e)) == luaY_nvarstack(fs));
-      }
-      nret = LUA_MULTRET;  /* return all values */
-    }
-    else {
-      if (nret == 1)  /* only one single value? */
-        first = luaK_exp2anyreg(fs, &e);  /* can use original slot */
-      else {  /* values must go to the top of the stack */
-        luaK_exp2nextreg(fs, &e);
-        lua_assert(nret == fs->freereg - first);
-      }
-    }
-  }
-  luaK_ret(fs, first, nret);
-  testnext(ls, ';');  /* skip optional semicolon */
-}
-
-
-static void statement (LexState *ls) {
-  int line = ls->linenumber;  /* may be needed for error messages */
-  enterlevel(ls);
-  switch (ls->t.token) {
-    case ';': {  /* stat -> ';' (empty statement) */
-      luaX_next(ls);  /* skip ';' */
-      break;
-    }
-    case TK_IF: {  /* stat -> ifstat */
-      ifstat(ls, line);
-      break;
-    }
-    case TK_WHILE: {  /* stat -> whilestat */
-      whilestat(ls, line);
-      break;
-    }
-    case TK_DO: {  /* stat -> DO block END */
-      luaX_next(ls);  /* skip DO */
-      block(ls);
-      check_match(ls, TK_END, TK_DO, line);
-      break;
-    }
-    case TK_FOR: {  /* stat -> forstat */
-      forstat(ls, line);
-      break;
-    }
-    case TK_REPEAT: {  /* stat -> repeatstat */
-      repeatstat(ls, line);
-      break;
-    }
-    case TK_FUNCTION: {  /* stat -> funcstat */
-      funcstat(ls, line);
-      break;
-    }
-    case TK_LOCAL: {  /* stat -> localstat */
-      luaX_next(ls);  /* skip LOCAL */
-      if (testnext(ls, TK_FUNCTION))  /* local function? */
-        localfunc(ls);
-      else
-        localstat(ls);
-      break;
-    }
-    case TK_DBCOLON: {  /* stat -> label */
-      luaX_next(ls);  /* skip double colon */
-      labelstat(ls, str_checkname(ls), line);
-      break;
-    }
-    case TK_RETURN: {  /* stat -> retstat */
-      luaX_next(ls);  /* skip RETURN */
-      retstat(ls);
-      break;
-    }
-    case TK_BREAK: {  /* stat -> breakstat */
-      breakstat(ls);
-      break;
-    }
-    case TK_GOTO: {  /* stat -> 'goto' NAME */
-      luaX_next(ls);  /* skip 'goto' */
-      gotostat(ls);
-      break;
-    }
-    default: {  /* stat -> func | assignment */
-      exprstat(ls);
-      break;
-    }
-  }
-  lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg &&
-             ls->fs->freereg >= luaY_nvarstack(ls->fs));
-  ls->fs->freereg = luaY_nvarstack(ls->fs);  /* free registers */
-  leavelevel(ls);
-}
-
-/* }====================================================================== */
-
-
-/*
-** compiles the main function, which is a regular vararg function with an
-** upvalue named LUA_ENV
-*/
-static void mainfunc (LexState *ls, FuncState *fs) {
-  BlockCnt bl;
-  Upvaldesc *env;
-  open_func(ls, fs, &bl);
-  setvararg(fs, 0);  /* main function is always declared vararg */
-  env = allocupvalue(fs);  /* ...set environment upvalue */
-  env->instack = 1;
-  env->idx = 0;
-  env->kind = VDKREG;
-  env->name = ls->envn;
-  luaC_objbarrier(ls->L, fs->f, env->name);
-  luaX_next(ls);  /* read first token */
-  statlist(ls);  /* parse main body */
-  check(ls, TK_EOS);
-  close_func(ls);
-}
-
-
-LClosure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
-                       Dyndata *dyd, const char *name, int firstchar) {
-  LexState lexstate;
-  FuncState funcstate;
-  LClosure *cl = luaF_newLclosure(L, 1);  /* create main closure */
-  setclLvalue2s(L, L->top.p, cl);  /* anchor it (to avoid being collected) */
-  luaD_inctop(L);
-  lexstate.h = luaH_new(L);  /* create table for scanner */
-  sethvalue2s(L, L->top.p, lexstate.h);  /* anchor it */
-  luaD_inctop(L);
-  funcstate.f = cl->p = luaF_newproto(L);
-  luaC_objbarrier(L, cl, cl->p);
-  funcstate.f->source = luaS_new(L, name);  /* create and anchor TString */
-  luaC_objbarrier(L, funcstate.f, funcstate.f->source);
-  lexstate.buff = buff;
-  lexstate.dyd = dyd;
-  dyd->actvar.n = dyd->gt.n = dyd->label.n = 0;
-  luaX_setinput(L, &lexstate, z, funcstate.f->source, firstchar);
-  mainfunc(&lexstate, &funcstate);
-  lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs);
-  /* all scopes should be correctly finished */
-  lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0);
-  L->top.p--;  /* remove scanner's table */
-  return cl;  /* closure is on the stack, too */
-}
-
diff --git a/third-party/lua/src/lparser.h b/third-party/lua/src/lparser.h
deleted file mode 100644
index 5e4500f18..000000000
--- a/third-party/lua/src/lparser.h
+++ /dev/null
@@ -1,171 +0,0 @@
-/*
-** $Id: lparser.h $
-** Lua Parser
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lparser_h
-#define lparser_h
-
-#include "llimits.h"
-#include "lobject.h"
-#include "lzio.h"
-
-
-/*
-** Expression and variable descriptor.
-** Code generation for variables and expressions can be delayed to allow
-** optimizations; An 'expdesc' structure describes a potentially-delayed
-** variable/expression. It has a description of its "main" value plus a
-** list of conditional jumps that can also produce its value (generated
-** by short-circuit operators 'and'/'or').
-*/
-
-/* kinds of variables/expressions */
-typedef enum {
-  VVOID,  /* when 'expdesc' describes the last expression of a list,
-             this kind means an empty list (so, no expression) */
-  VNIL,  /* constant nil */
-  VTRUE,  /* constant true */
-  VFALSE,  /* constant false */
-  VK,  /* constant in 'k'; info = index of constant in 'k' */
-  VKFLT,  /* floating constant; nval = numerical float value */
-  VKINT,  /* integer constant; ival = numerical integer value */
-  VKSTR,  /* string constant; strval = TString address;
-             (string is fixed by the lexer) */
-  VNONRELOC,  /* expression has its value in a fixed register;
-                 info = result register */
-  VLOCAL,  /* local variable; var.ridx = register index;
-              var.vidx = relative index in 'actvar.arr'  */
-  VUPVAL,  /* upvalue variable; info = index of upvalue in 'upvalues' */
-  VCONST,  /* compile-time <const> variable;
-              info = absolute index in 'actvar.arr'  */
-  VINDEXED,  /* indexed variable;
-                ind.t = table register;
-                ind.idx = key's R index */
-  VINDEXUP,  /* indexed upvalue;
-                ind.t = table upvalue;
-                ind.idx = key's K index */
-  VINDEXI, /* indexed variable with constant integer;
-                ind.t = table register;
-                ind.idx = key's value */
-  VINDEXSTR, /* indexed variable with literal string;
-                ind.t = table register;
-                ind.idx = key's K index */
-  VJMP,  /* expression is a test/comparison;
-            info = pc of corresponding jump instruction */
-  VRELOC,  /* expression can put result in any register;
-              info = instruction pc */
-  VCALL,  /* expression is a function call; info = instruction pc */
-  VVARARG  /* vararg expression; info = instruction pc */
-} expkind;
-
-
-#define vkisvar(k)	(VLOCAL <= (k) && (k) <= VINDEXSTR)
-#define vkisindexed(k)	(VINDEXED <= (k) && (k) <= VINDEXSTR)
-
-
-typedef struct expdesc {
-  expkind k;
-  union {
-    lua_Integer ival;    /* for VKINT */
-    lua_Number nval;  /* for VKFLT */
-    TString *strval;  /* for VKSTR */
-    int info;  /* for generic use */
-    struct {  /* for indexed variables */
-      short idx;  /* index (R or "long" K) */
-      lu_byte t;  /* table (register or upvalue) */
-    } ind;
-    struct {  /* for local variables */
-      lu_byte ridx;  /* register holding the variable */
-      unsigned short vidx;  /* compiler index (in 'actvar.arr')  */
-    } var;
-  } u;
-  int t;  /* patch list of 'exit when true' */
-  int f;  /* patch list of 'exit when false' */
-} expdesc;
-
-
-/* kinds of variables */
-#define VDKREG		0   /* regular */
-#define RDKCONST	1   /* constant */
-#define RDKTOCLOSE	2   /* to-be-closed */
-#define RDKCTC		3   /* compile-time constant */
-
-/* description of an active local variable */
-typedef union Vardesc {
-  struct {
-    TValuefields;  /* constant value (if it is a compile-time constant) */
-    lu_byte kind;
-    lu_byte ridx;  /* register holding the variable */
-    short pidx;  /* index of the variable in the Proto's 'locvars' array */
-    TString *name;  /* variable name */
-  } vd;
-  TValue k;  /* constant value (if any) */
-} Vardesc;
-
-
-
-/* description of pending goto statements and label statements */
-typedef struct Labeldesc {
-  TString *name;  /* label identifier */
-  int pc;  /* position in code */
-  int line;  /* line where it appeared */
-  lu_byte nactvar;  /* number of active variables in that position */
-  lu_byte close;  /* goto that escapes upvalues */
-} Labeldesc;
-
-
-/* list of labels or gotos */
-typedef struct Labellist {
-  Labeldesc *arr;  /* array */
-  int n;  /* number of entries in use */
-  int size;  /* array size */
-} Labellist;
-
-
-/* dynamic structures used by the parser */
-typedef struct Dyndata {
-  struct {  /* list of all active local variables */
-    Vardesc *arr;
-    int n;
-    int size;
-  } actvar;
-  Labellist gt;  /* list of pending gotos */
-  Labellist label;   /* list of active labels */
-} Dyndata;
-
-
-/* control of blocks */
-struct BlockCnt;  /* defined in lparser.c */
-
-
-/* state needed to generate code for a given function */
-typedef struct FuncState {
-  Proto *f;  /* current function header */
-  struct FuncState *prev;  /* enclosing function */
-  struct LexState *ls;  /* lexical state */
-  struct BlockCnt *bl;  /* chain of current blocks */
-  int pc;  /* next position to code (equivalent to 'ncode') */
-  int lasttarget;   /* 'label' of last 'jump label' */
-  int previousline;  /* last line that was saved in 'lineinfo' */
-  int nk;  /* number of elements in 'k' */
-  int np;  /* number of elements in 'p' */
-  int nabslineinfo;  /* number of elements in 'abslineinfo' */
-  int firstlocal;  /* index of first local var (in Dyndata array) */
-  int firstlabel;  /* index of first label (in 'dyd->label->arr') */
-  short ndebugvars;  /* number of elements in 'f->locvars' */
-  lu_byte nactvar;  /* number of active local variables */
-  lu_byte nups;  /* number of upvalues */
-  lu_byte freereg;  /* first free register */
-  lu_byte iwthabs;  /* instructions issued since last absolute line info */
-  lu_byte needclose;  /* function needs to close upvalues when returning */
-} FuncState;
-
-
-LUAI_FUNC int luaY_nvarstack (FuncState *fs);
-LUAI_FUNC LClosure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
-                                 Dyndata *dyd, const char *name, int firstchar);
-
-
-#endif
diff --git a/third-party/lua/src/lprefix.h b/third-party/lua/src/lprefix.h
deleted file mode 100644
index 484f2ad6f..000000000
--- a/third-party/lua/src/lprefix.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
-** $Id: lprefix.h $
-** Definitions for Lua code that must come before any other header file
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lprefix_h
-#define lprefix_h
-
-
-/*
-** Allows POSIX/XSI stuff
-*/
-#if !defined(LUA_USE_C89)	/* { */
-
-#if !defined(_XOPEN_SOURCE)
-#define _XOPEN_SOURCE           600
-#elif _XOPEN_SOURCE == 0
-#undef _XOPEN_SOURCE  /* use -D_XOPEN_SOURCE=0 to undefine it */
-#endif
-
-/*
-** Allows manipulation of large files in gcc and some other compilers
-*/
-#if !defined(LUA_32BITS) && !defined(_FILE_OFFSET_BITS)
-#define _LARGEFILE_SOURCE       1
-#define _FILE_OFFSET_BITS       64
-#endif
-
-#endif				/* } */
-
-
-/*
-** Windows stuff
-*/
-#if defined(_WIN32)	/* { */
-
-#if !defined(_CRT_SECURE_NO_WARNINGS)
-#define _CRT_SECURE_NO_WARNINGS  /* avoid warnings about ISO C functions */
-#endif
-
-#endif			/* } */
-
-#endif
-
diff --git a/third-party/lua/src/lstate.c b/third-party/lua/src/lstate.c
deleted file mode 100644
index 1e925e5ad..000000000
--- a/third-party/lua/src/lstate.c
+++ /dev/null
@@ -1,445 +0,0 @@
-/*
-** $Id: lstate.c $
-** Global State
-** See Copyright Notice in lua.h
-*/
-
-#define lstate_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <stddef.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lapi.h"
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lgc.h"
-#include "llex.h"
-#include "lmem.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-
-
-
-/*
-** thread state + extra space
-*/
-typedef struct LX {
-  lu_byte extra_[LUA_EXTRASPACE];
-  lua_State l;
-} LX;
-
-
-/*
-** Main thread combines a thread state and the global state
-*/
-typedef struct LG {
-  LX l;
-  global_State g;
-} LG;
-
-
-
-#define fromstate(L)	(cast(LX *, cast(lu_byte *, (L)) - offsetof(LX, l)))
-
-
-/*
-** A macro to create a "random" seed when a state is created;
-** the seed is used to randomize string hashes.
-*/
-#if !defined(luai_makeseed)
-
-#include <time.h>
-
-/*
-** Compute an initial seed with some level of randomness.
-** Rely on Address Space Layout Randomization (if present) and
-** current time.
-*/
-#define addbuff(b,p,e) \
-  { size_t t = cast_sizet(e); \
-    memcpy(b + p, &t, sizeof(t)); p += sizeof(t); }
-
-static unsigned int luai_makeseed (lua_State *L) {
-  char buff[3 * sizeof(size_t)];
-  unsigned int h = cast_uint(time(NULL));
-  int p = 0;
-  addbuff(buff, p, L);  /* heap variable */
-  addbuff(buff, p, &h);  /* local variable */
-  addbuff(buff, p, &lua_newstate);  /* public function */
-  lua_assert(p == sizeof(buff));
-  return luaS_hash(buff, p, h);
-}
-
-#endif
-
-
-/*
-** set GCdebt to a new value keeping the value (totalbytes + GCdebt)
-** invariant (and avoiding underflows in 'totalbytes')
-*/
-void luaE_setdebt (global_State *g, l_mem debt) {
-  l_mem tb = gettotalbytes(g);
-  lua_assert(tb > 0);
-  if (debt < tb - MAX_LMEM)
-    debt = tb - MAX_LMEM;  /* will make 'totalbytes == MAX_LMEM' */
-  g->totalbytes = tb - debt;
-  g->GCdebt = debt;
-}
-
-
-LUA_API int lua_setcstacklimit (lua_State *L, unsigned int limit) {
-  UNUSED(L); UNUSED(limit);
-  return LUAI_MAXCCALLS;  /* warning?? */
-}
-
-
-CallInfo *luaE_extendCI (lua_State *L) {
-  CallInfo *ci;
-  lua_assert(L->ci->next == NULL);
-  ci = luaM_new(L, CallInfo);
-  lua_assert(L->ci->next == NULL);
-  L->ci->next = ci;
-  ci->previous = L->ci;
-  ci->next = NULL;
-  ci->u.l.trap = 0;
-  L->nci++;
-  return ci;
-}
-
-
-/*
-** free all CallInfo structures not in use by a thread
-*/
-void luaE_freeCI (lua_State *L) {
-  CallInfo *ci = L->ci;
-  CallInfo *next = ci->next;
-  ci->next = NULL;
-  while ((ci = next) != NULL) {
-    next = ci->next;
-    luaM_free(L, ci);
-    L->nci--;
-  }
-}
-
-
-/*
-** free half of the CallInfo structures not in use by a thread,
-** keeping the first one.
-*/
-void luaE_shrinkCI (lua_State *L) {
-  CallInfo *ci = L->ci->next;  /* first free CallInfo */
-  CallInfo *next;
-  if (ci == NULL)
-    return;  /* no extra elements */
-  while ((next = ci->next) != NULL) {  /* two extra elements? */
-    CallInfo *next2 = next->next;  /* next's next */
-    ci->next = next2;  /* remove next from the list */
-    L->nci--;
-    luaM_free(L, next);  /* free next */
-    if (next2 == NULL)
-      break;  /* no more elements */
-    else {
-      next2->previous = ci;
-      ci = next2;  /* continue */
-    }
-  }
-}
-
-
-/*
-** Called when 'getCcalls(L)' larger or equal to LUAI_MAXCCALLS.
-** If equal, raises an overflow error. If value is larger than
-** LUAI_MAXCCALLS (which means it is handling an overflow) but
-** not much larger, does not report an error (to allow overflow
-** handling to work).
-*/
-void luaE_checkcstack (lua_State *L) {
-  if (getCcalls(L) == LUAI_MAXCCALLS)
-    luaG_runerror(L, "C stack overflow");
-  else if (getCcalls(L) >= (LUAI_MAXCCALLS / 10 * 11))
-    luaD_throw(L, LUA_ERRERR);  /* error while handling stack error */
-}
-
-
-LUAI_FUNC void luaE_incCstack (lua_State *L) {
-  L->nCcalls++;
-  if (l_unlikely(getCcalls(L) >= LUAI_MAXCCALLS))
-    luaE_checkcstack(L);
-}
-
-
-static void stack_init (lua_State *L1, lua_State *L) {
-  int i; CallInfo *ci;
-  /* initialize stack array */
-  L1->stack.p = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, StackValue);
-  L1->tbclist.p = L1->stack.p;
-  for (i = 0; i < BASIC_STACK_SIZE + EXTRA_STACK; i++)
-    setnilvalue(s2v(L1->stack.p + i));  /* erase new stack */
-  L1->top.p = L1->stack.p;
-  L1->stack_last.p = L1->stack.p + BASIC_STACK_SIZE;
-  /* initialize first ci */
-  ci = &L1->base_ci;
-  ci->next = ci->previous = NULL;
-  ci->callstatus = CIST_C;
-  ci->func.p = L1->top.p;
-  ci->u.c.k = NULL;
-  ci->nresults = 0;
-  setnilvalue(s2v(L1->top.p));  /* 'function' entry for this 'ci' */
-  L1->top.p++;
-  ci->top.p = L1->top.p + LUA_MINSTACK;
-  L1->ci = ci;
-}
-
-
-static void freestack (lua_State *L) {
-  if (L->stack.p == NULL)
-    return;  /* stack not completely built yet */
-  L->ci = &L->base_ci;  /* free the entire 'ci' list */
-  luaE_freeCI(L);
-  lua_assert(L->nci == 0);
-  luaM_freearray(L, L->stack.p, stacksize(L) + EXTRA_STACK);  /* free stack */
-}
-
-
-/*
-** Create registry table and its predefined values
-*/
-static void init_registry (lua_State *L, global_State *g) {
-  /* create registry */
-  Table *registry = luaH_new(L);
-  sethvalue(L, &g->l_registry, registry);
-  luaH_resize(L, registry, LUA_RIDX_LAST, 0);
-  /* registry[LUA_RIDX_MAINTHREAD] = L */
-  setthvalue(L, &registry->array[LUA_RIDX_MAINTHREAD - 1], L);
-  /* registry[LUA_RIDX_GLOBALS] = new table (table of globals) */
-  sethvalue(L, &registry->array[LUA_RIDX_GLOBALS - 1], luaH_new(L));
-}
-
-
-/*
-** open parts of the state that may cause memory-allocation errors.
-*/
-static void f_luaopen (lua_State *L, void *ud) {
-  global_State *g = G(L);
-  UNUSED(ud);
-  stack_init(L, L);  /* init stack */
-  init_registry(L, g);
-  luaS_init(L);
-  luaT_init(L);
-  luaX_init(L);
-  g->gcstp = 0;  /* allow gc */
-  setnilvalue(&g->nilvalue);  /* now state is complete */
-  luai_userstateopen(L);
-}
-
-
-/*
-** preinitialize a thread with consistent values without allocating
-** any memory (to avoid errors)
-*/
-static void preinit_thread (lua_State *L, global_State *g) {
-  G(L) = g;
-  L->stack.p = NULL;
-  L->ci = NULL;
-  L->nci = 0;
-  L->twups = L;  /* thread has no upvalues */
-  L->nCcalls = 0;
-  L->errorJmp = NULL;
-  L->hook = NULL;
-  L->hookmask = 0;
-  L->basehookcount = 0;
-  L->allowhook = 1;
-  resethookcount(L);
-  L->openupval = NULL;
-  L->status = LUA_OK;
-  L->errfunc = 0;
-  L->oldpc = 0;
-}
-
-
-static void close_state (lua_State *L) {
-  global_State *g = G(L);
-  if (!completestate(g))  /* closing a partially built state? */
-    luaC_freeallobjects(L);  /* just collect its objects */
-  else {  /* closing a fully built state */
-    L->ci = &L->base_ci;  /* unwind CallInfo list */
-    luaD_closeprotected(L, 1, LUA_OK);  /* close all upvalues */
-    luaC_freeallobjects(L);  /* collect all objects */
-    luai_userstateclose(L);
-  }
-  luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size);
-  freestack(L);
-  lua_assert(gettotalbytes(g) == sizeof(LG));
-  (*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0);  /* free main block */
-}
-
-
-LUA_API lua_State *lua_newthread (lua_State *L) {
-  global_State *g = G(L);
-  GCObject *o;
-  lua_State *L1;
-  lua_lock(L);
-  luaC_checkGC(L);
-  /* create new thread */
-  o = luaC_newobjdt(L, LUA_TTHREAD, sizeof(LX), offsetof(LX, l));
-  L1 = gco2th(o);
-  /* anchor it on L stack */
-  setthvalue2s(L, L->top.p, L1);
-  api_incr_top(L);
-  preinit_thread(L1, g);
-  L1->hookmask = L->hookmask;
-  L1->basehookcount = L->basehookcount;
-  L1->hook = L->hook;
-  resethookcount(L1);
-  /* initialize L1 extra space */
-  memcpy(lua_getextraspace(L1), lua_getextraspace(g->mainthread),
-         LUA_EXTRASPACE);
-  luai_userstatethread(L, L1);
-  stack_init(L1, L);  /* init stack */
-  lua_unlock(L);
-  return L1;
-}
-
-
-void luaE_freethread (lua_State *L, lua_State *L1) {
-  LX *l = fromstate(L1);
-  luaF_closeupval(L1, L1->stack.p);  /* close all upvalues */
-  lua_assert(L1->openupval == NULL);
-  luai_userstatefree(L, L1);
-  freestack(L1);
-  luaM_free(L, l);
-}
-
-
-int luaE_resetthread (lua_State *L, int status) {
-  CallInfo *ci = L->ci = &L->base_ci;  /* unwind CallInfo list */
-  setnilvalue(s2v(L->stack.p));  /* 'function' entry for basic 'ci' */
-  ci->func.p = L->stack.p;
-  ci->callstatus = CIST_C;
-  if (status == LUA_YIELD)
-    status = LUA_OK;
-  L->status = LUA_OK;  /* so it can run __close metamethods */
-  status = luaD_closeprotected(L, 1, status);
-  if (status != LUA_OK)  /* errors? */
-    luaD_seterrorobj(L, status, L->stack.p + 1);
-  else
-    L->top.p = L->stack.p + 1;
-  ci->top.p = L->top.p + LUA_MINSTACK;
-  luaD_reallocstack(L, cast_int(ci->top.p - L->stack.p), 0);
-  return status;
-}
-
-
-LUA_API int lua_closethread (lua_State *L, lua_State *from) {
-  int status;
-  lua_lock(L);
-  L->nCcalls = (from) ? getCcalls(from) : 0;
-  status = luaE_resetthread(L, L->status);
-  lua_unlock(L);
-  return status;
-}
-
-
-/*
-** Deprecated! Use 'lua_closethread' instead.
-*/
-LUA_API int lua_resetthread (lua_State *L) {
-  return lua_closethread(L, NULL);
-}
-
-
-LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
-  int i;
-  lua_State *L;
-  global_State *g;
-  LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG)));
-  if (l == NULL) return NULL;
-  L = &l->l.l;
-  g = &l->g;
-  L->tt = LUA_VTHREAD;
-  g->currentwhite = bitmask(WHITE0BIT);
-  L->marked = luaC_white(g);
-  preinit_thread(L, g);
-  g->allgc = obj2gco(L);  /* by now, only object is the main thread */
-  L->next = NULL;
-  incnny(L);  /* main thread is always non yieldable */
-  g->frealloc = f;
-  g->ud = ud;
-  g->warnf = NULL;
-  g->ud_warn = NULL;
-  g->mainthread = L;
-  g->seed = luai_makeseed(L);
-  g->gcstp = GCSTPGC;  /* no GC while building state */
-  g->strt.size = g->strt.nuse = 0;
-  g->strt.hash = NULL;
-  setnilvalue(&g->l_registry);
-  g->panic = NULL;
-  g->gcstate = GCSpause;
-  g->gckind = KGC_INC;
-  g->gcstopem = 0;
-  g->gcemergency = 0;
-  g->finobj = g->tobefnz = g->fixedgc = NULL;
-  g->firstold1 = g->survival = g->old1 = g->reallyold = NULL;
-  g->finobjsur = g->finobjold1 = g->finobjrold = NULL;
-  g->sweepgc = NULL;
-  g->gray = g->grayagain = NULL;
-  g->weak = g->ephemeron = g->allweak = NULL;
-  g->twups = NULL;
-  g->totalbytes = sizeof(LG);
-  g->GCdebt = 0;
-  g->lastatomic = 0;
-  setivalue(&g->nilvalue, 0);  /* to signal that state is not yet built */
-  setgcparam(g->gcpause, LUAI_GCPAUSE);
-  setgcparam(g->gcstepmul, LUAI_GCMUL);
-  g->gcstepsize = LUAI_GCSTEPSIZE;
-  setgcparam(g->genmajormul, LUAI_GENMAJORMUL);
-  g->genminormul = LUAI_GENMINORMUL;
-  for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL;
-  if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) {
-    /* memory allocation error: free partial state */
-    close_state(L);
-    L = NULL;
-  }
-  return L;
-}
-
-
-LUA_API void lua_close (lua_State *L) {
-  lua_lock(L);
-  L = G(L)->mainthread;  /* only the main thread can be closed */
-  close_state(L);
-}
-
-
-void luaE_warning (lua_State *L, const char *msg, int tocont) {
-  lua_WarnFunction wf = G(L)->warnf;
-  if (wf != NULL)
-    wf(G(L)->ud_warn, msg, tocont);
-}
-
-
-/*
-** Generate a warning from an error message
-*/
-void luaE_warnerror (lua_State *L, const char *where) {
-  TValue *errobj = s2v(L->top.p - 1);  /* error object */
-  const char *msg = (ttisstring(errobj))
-                  ? svalue(errobj)
-                  : "error object is not a string";
-  /* produce warning "error in %s (%s)" (where, msg) */
-  luaE_warning(L, "error in ", 1);
-  luaE_warning(L, where, 1);
-  luaE_warning(L, " (", 1);
-  luaE_warning(L, msg, 1);
-  luaE_warning(L, ")", 0);
-}
-
diff --git a/third-party/lua/src/lstate.h b/third-party/lua/src/lstate.h
deleted file mode 100644
index 8bf6600e3..000000000
--- a/third-party/lua/src/lstate.h
+++ /dev/null
@@ -1,409 +0,0 @@
-/*
-** $Id: lstate.h $
-** Global State
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lstate_h
-#define lstate_h
-
-#include "lua.h"
-
-
-/* Some header files included here need this definition */
-typedef struct CallInfo CallInfo;
-
-
-#include "lobject.h"
-#include "ltm.h"
-#include "lzio.h"
-
-
-/*
-** Some notes about garbage-collected objects: All objects in Lua must
-** be kept somehow accessible until being freed, so all objects always
-** belong to one (and only one) of these lists, using field 'next' of
-** the 'CommonHeader' for the link:
-**
-** 'allgc': all objects not marked for finalization;
-** 'finobj': all objects marked for finalization;
-** 'tobefnz': all objects ready to be finalized;
-** 'fixedgc': all objects that are not to be collected (currently
-** only small strings, such as reserved words).
-**
-** For the generational collector, some of these lists have marks for
-** generations. Each mark points to the first element in the list for
-** that particular generation; that generation goes until the next mark.
-**
-** 'allgc' -> 'survival': new objects;
-** 'survival' -> 'old': objects that survived one collection;
-** 'old1' -> 'reallyold': objects that became old in last collection;
-** 'reallyold' -> NULL: objects old for more than one cycle.
-**
-** 'finobj' -> 'finobjsur': new objects marked for finalization;
-** 'finobjsur' -> 'finobjold1': survived   """";
-** 'finobjold1' -> 'finobjrold': just old  """";
-** 'finobjrold' -> NULL: really old       """".
-**
-** All lists can contain elements older than their main ages, due
-** to 'luaC_checkfinalizer' and 'udata2finalize', which move
-** objects between the normal lists and the "marked for finalization"
-** lists. Moreover, barriers can age young objects in young lists as
-** OLD0, which then become OLD1. However, a list never contains
-** elements younger than their main ages.
-**
-** The generational collector also uses a pointer 'firstold1', which
-** points to the first OLD1 object in the list. It is used to optimize
-** 'markold'. (Potentially OLD1 objects can be anywhere between 'allgc'
-** and 'reallyold', but often the list has no OLD1 objects or they are
-** after 'old1'.) Note the difference between it and 'old1':
-** 'firstold1': no OLD1 objects before this point; there can be all
-**   ages after it.
-** 'old1': no objects younger than OLD1 after this point.
-*/
-
-/*
-** Moreover, there is another set of lists that control gray objects.
-** These lists are linked by fields 'gclist'. (All objects that
-** can become gray have such a field. The field is not the same
-** in all objects, but it always has this name.)  Any gray object
-** must belong to one of these lists, and all objects in these lists
-** must be gray (with two exceptions explained below):
-**
-** 'gray': regular gray objects, still waiting to be visited.
-** 'grayagain': objects that must be revisited at the atomic phase.
-**   That includes
-**   - black objects got in a write barrier;
-**   - all kinds of weak tables during propagation phase;
-**   - all threads.
-** 'weak': tables with weak values to be cleared;
-** 'ephemeron': ephemeron tables with white->white entries;
-** 'allweak': tables with weak keys and/or weak values to be cleared.
-**
-** The exceptions to that "gray rule" are:
-** - TOUCHED2 objects in generational mode stay in a gray list (because
-** they must be visited again at the end of the cycle), but they are
-** marked black because assignments to them must activate barriers (to
-** move them back to TOUCHED1).
-** - Open upvales are kept gray to avoid barriers, but they stay out
-** of gray lists. (They don't even have a 'gclist' field.)
-*/
-
-
-
-/*
-** About 'nCcalls':  This count has two parts: the lower 16 bits counts
-** the number of recursive invocations in the C stack; the higher
-** 16 bits counts the number of non-yieldable calls in the stack.
-** (They are together so that we can change and save both with one
-** instruction.)
-*/
-
-
-/* true if this thread does not have non-yieldable calls in the stack */
-#define yieldable(L)		(((L)->nCcalls & 0xffff0000) == 0)
-
-/* real number of C calls */
-#define getCcalls(L)	((L)->nCcalls & 0xffff)
-
-
-/* Increment the number of non-yieldable calls */
-#define incnny(L)	((L)->nCcalls += 0x10000)
-
-/* Decrement the number of non-yieldable calls */
-#define decnny(L)	((L)->nCcalls -= 0x10000)
-
-/* Non-yieldable call increment */
-#define nyci	(0x10000 | 1)
-
-
-
-
-struct lua_longjmp;  /* defined in ldo.c */
-
-
-/*
-** Atomic type (relative to signals) to better ensure that 'lua_sethook'
-** is thread safe
-*/
-#if !defined(l_signalT)
-#include <signal.h>
-#define l_signalT	sig_atomic_t
-#endif
-
-
-/*
-** Extra stack space to handle TM calls and some other extras. This
-** space is not included in 'stack_last'. It is used only to avoid stack
-** checks, either because the element will be promptly popped or because
-** there will be a stack check soon after the push. Function frames
-** never use this extra space, so it does not need to be kept clean.
-*/
-#define EXTRA_STACK   5
-
-
-#define BASIC_STACK_SIZE        (2*LUA_MINSTACK)
-
-#define stacksize(th)	cast_int((th)->stack_last.p - (th)->stack.p)
-
-
-/* kinds of Garbage Collection */
-#define KGC_INC		0	/* incremental gc */
-#define KGC_GEN		1	/* generational gc */
-
-
-typedef struct stringtable {
-  TString **hash;
-  int nuse;  /* number of elements */
-  int size;
-} stringtable;
-
-
-/*
-** Information about a call.
-** About union 'u':
-** - field 'l' is used only for Lua functions;
-** - field 'c' is used only for C functions.
-** About union 'u2':
-** - field 'funcidx' is used only by C functions while doing a
-** protected call;
-** - field 'nyield' is used only while a function is "doing" an
-** yield (from the yield until the next resume);
-** - field 'nres' is used only while closing tbc variables when
-** returning from a function;
-** - field 'transferinfo' is used only during call/returnhooks,
-** before the function starts or after it ends.
-*/
-struct CallInfo {
-  StkIdRel func;  /* function index in the stack */
-  StkIdRel	top;  /* top for this function */
-  struct CallInfo *previous, *next;  /* dynamic call link */
-  union {
-    struct {  /* only for Lua functions */
-      const Instruction *savedpc;
-      volatile l_signalT trap;
-      int nextraargs;  /* # of extra arguments in vararg functions */
-    } l;
-    struct {  /* only for C functions */
-      lua_KFunction k;  /* continuation in case of yields */
-      ptrdiff_t old_errfunc;
-      lua_KContext ctx;  /* context info. in case of yields */
-    } c;
-  } u;
-  union {
-    int funcidx;  /* called-function index */
-    int nyield;  /* number of values yielded */
-    int nres;  /* number of values returned */
-    struct {  /* info about transferred values (for call/return hooks) */
-      unsigned short ftransfer;  /* offset of first value transferred */
-      unsigned short ntransfer;  /* number of values transferred */
-    } transferinfo;
-  } u2;
-  short nresults;  /* expected number of results from this function */
-  unsigned short callstatus;
-};
-
-
-/*
-** Bits in CallInfo status
-*/
-#define CIST_OAH	(1<<0)	/* original value of 'allowhook' */
-#define CIST_C		(1<<1)	/* call is running a C function */
-#define CIST_FRESH	(1<<2)	/* call is on a fresh "luaV_execute" frame */
-#define CIST_HOOKED	(1<<3)	/* call is running a debug hook */
-#define CIST_YPCALL	(1<<4)	/* doing a yieldable protected call */
-#define CIST_TAIL	(1<<5)	/* call was tail called */
-#define CIST_HOOKYIELD	(1<<6)	/* last hook called yielded */
-#define CIST_FIN	(1<<7)	/* function "called" a finalizer */
-#define CIST_TRAN	(1<<8)	/* 'ci' has transfer information */
-#define CIST_CLSRET	(1<<9)  /* function is closing tbc variables */
-/* Bits 10-12 are used for CIST_RECST (see below) */
-#define CIST_RECST	10
-#if defined(LUA_COMPAT_LT_LE)
-#define CIST_LEQ	(1<<13)  /* using __lt for __le */
-#endif
-
-
-/*
-** Field CIST_RECST stores the "recover status", used to keep the error
-** status while closing to-be-closed variables in coroutines, so that
-** Lua can correctly resume after an yield from a __close method called
-** because of an error.  (Three bits are enough for error status.)
-*/
-#define getcistrecst(ci)     (((ci)->callstatus >> CIST_RECST) & 7)
-#define setcistrecst(ci,st)  \
-  check_exp(((st) & 7) == (st),   /* status must fit in three bits */  \
-            ((ci)->callstatus = ((ci)->callstatus & ~(7 << CIST_RECST))  \
-                                                  | ((st) << CIST_RECST)))
-
-
-/* active function is a Lua function */
-#define isLua(ci)	(!((ci)->callstatus & CIST_C))
-
-/* call is running Lua code (not a hook) */
-#define isLuacode(ci)	(!((ci)->callstatus & (CIST_C | CIST_HOOKED)))
-
-/* assume that CIST_OAH has offset 0 and that 'v' is strictly 0/1 */
-#define setoah(st,v)	((st) = ((st) & ~CIST_OAH) | (v))
-#define getoah(st)	((st) & CIST_OAH)
-
-
-/*
-** 'global state', shared by all threads of this state
-*/
-typedef struct global_State {
-  lua_Alloc frealloc;  /* function to reallocate memory */
-  void *ud;         /* auxiliary data to 'frealloc' */
-  l_mem totalbytes;  /* number of bytes currently allocated - GCdebt */
-  l_mem GCdebt;  /* bytes allocated not yet compensated by the collector */
-  lu_mem GCestimate;  /* an estimate of the non-garbage memory in use */
-  lu_mem lastatomic;  /* see function 'genstep' in file 'lgc.c' */
-  stringtable strt;  /* hash table for strings */
-  TValue l_registry;
-  TValue nilvalue;  /* a nil value */
-  unsigned int seed;  /* randomized seed for hashes */
-  lu_byte currentwhite;
-  lu_byte gcstate;  /* state of garbage collector */
-  lu_byte gckind;  /* kind of GC running */
-  lu_byte gcstopem;  /* stops emergency collections */
-  lu_byte genminormul;  /* control for minor generational collections */
-  lu_byte genmajormul;  /* control for major generational collections */
-  lu_byte gcstp;  /* control whether GC is running */
-  lu_byte gcemergency;  /* true if this is an emergency collection */
-  lu_byte gcpause;  /* size of pause between successive GCs */
-  lu_byte gcstepmul;  /* GC "speed" */
-  lu_byte gcstepsize;  /* (log2 of) GC granularity */
-  GCObject *allgc;  /* list of all collectable objects */
-  GCObject **sweepgc;  /* current position of sweep in list */
-  GCObject *finobj;  /* list of collectable objects with finalizers */
-  GCObject *gray;  /* list of gray objects */
-  GCObject *grayagain;  /* list of objects to be traversed atomically */
-  GCObject *weak;  /* list of tables with weak values */
-  GCObject *ephemeron;  /* list of ephemeron tables (weak keys) */
-  GCObject *allweak;  /* list of all-weak tables */
-  GCObject *tobefnz;  /* list of userdata to be GC */
-  GCObject *fixedgc;  /* list of objects not to be collected */
-  /* fields for generational collector */
-  GCObject *survival;  /* start of objects that survived one GC cycle */
-  GCObject *old1;  /* start of old1 objects */
-  GCObject *reallyold;  /* objects more than one cycle old ("really old") */
-  GCObject *firstold1;  /* first OLD1 object in the list (if any) */
-  GCObject *finobjsur;  /* list of survival objects with finalizers */
-  GCObject *finobjold1;  /* list of old1 objects with finalizers */
-  GCObject *finobjrold;  /* list of really old objects with finalizers */
-  struct lua_State *twups;  /* list of threads with open upvalues */
-  lua_CFunction panic;  /* to be called in unprotected errors */
-  struct lua_State *mainthread;
-  TString *memerrmsg;  /* message for memory-allocation errors */
-  TString *tmname[TM_N];  /* array with tag-method names */
-  struct Table *mt[LUA_NUMTYPES];  /* metatables for basic types */
-  TString *strcache[STRCACHE_N][STRCACHE_M];  /* cache for strings in API */
-  lua_WarnFunction warnf;  /* warning function */
-  void *ud_warn;         /* auxiliary data to 'warnf' */
-} global_State;
-
-
-/*
-** 'per thread' state
-*/
-struct lua_State {
-  CommonHeader;
-  lu_byte status;
-  lu_byte allowhook;
-  unsigned short nci;  /* number of items in 'ci' list */
-  StkIdRel top;  /* first free slot in the stack */
-  global_State *l_G;
-  CallInfo *ci;  /* call info for current function */
-  StkIdRel stack_last;  /* end of stack (last element + 1) */
-  StkIdRel stack;  /* stack base */
-  UpVal *openupval;  /* list of open upvalues in this stack */
-  StkIdRel tbclist;  /* list of to-be-closed variables */
-  GCObject *gclist;
-  struct lua_State *twups;  /* list of threads with open upvalues */
-  struct lua_longjmp *errorJmp;  /* current error recover point */
-  CallInfo base_ci;  /* CallInfo for first level (C calling Lua) */
-  volatile lua_Hook hook;
-  ptrdiff_t errfunc;  /* current error handling function (stack index) */
-  l_uint32 nCcalls;  /* number of nested (non-yieldable | C)  calls */
-  int oldpc;  /* last pc traced */
-  int basehookcount;
-  int hookcount;
-  volatile l_signalT hookmask;
-};
-
-
-#define G(L)	(L->l_G)
-
-/*
-** 'g->nilvalue' being a nil value flags that the state was completely
-** build.
-*/
-#define completestate(g)	ttisnil(&g->nilvalue)
-
-
-/*
-** Union of all collectable objects (only for conversions)
-** ISO C99, 6.5.2.3 p.5:
-** "if a union contains several structures that share a common initial
-** sequence [...], and if the union object currently contains one
-** of these structures, it is permitted to inspect the common initial
-** part of any of them anywhere that a declaration of the complete type
-** of the union is visible."
-*/
-union GCUnion {
-  GCObject gc;  /* common header */
-  struct TString ts;
-  struct Udata u;
-  union Closure cl;
-  struct Table h;
-  struct Proto p;
-  struct lua_State th;  /* thread */
-  struct UpVal upv;
-};
-
-
-/*
-** ISO C99, 6.7.2.1 p.14:
-** "A pointer to a union object, suitably converted, points to each of
-** its members [...], and vice versa."
-*/
-#define cast_u(o)	cast(union GCUnion *, (o))
-
-/* macros to convert a GCObject into a specific value */
-#define gco2ts(o)  \
-	check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts))
-#define gco2u(o)  check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u))
-#define gco2lcl(o)  check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l))
-#define gco2ccl(o)  check_exp((o)->tt == LUA_VCCL, &((cast_u(o))->cl.c))
-#define gco2cl(o)  \
-	check_exp(novariant((o)->tt) == LUA_TFUNCTION, &((cast_u(o))->cl))
-#define gco2t(o)  check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h))
-#define gco2p(o)  check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p))
-#define gco2th(o)  check_exp((o)->tt == LUA_VTHREAD, &((cast_u(o))->th))
-#define gco2upv(o)	check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv))
-
-
-/*
-** macro to convert a Lua object into a GCObject
-** (The access to 'tt' tries to ensure that 'v' is actually a Lua object.)
-*/
-#define obj2gco(v)	check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc))
-
-
-/* actual number of total bytes allocated */
-#define gettotalbytes(g)	cast(lu_mem, (g)->totalbytes + (g)->GCdebt)
-
-LUAI_FUNC void luaE_setdebt (global_State *g, l_mem debt);
-LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1);
-LUAI_FUNC CallInfo *luaE_extendCI (lua_State *L);
-LUAI_FUNC void luaE_freeCI (lua_State *L);
-LUAI_FUNC void luaE_shrinkCI (lua_State *L);
-LUAI_FUNC void luaE_checkcstack (lua_State *L);
-LUAI_FUNC void luaE_incCstack (lua_State *L);
-LUAI_FUNC void luaE_warning (lua_State *L, const char *msg, int tocont);
-LUAI_FUNC void luaE_warnerror (lua_State *L, const char *where);
-LUAI_FUNC int luaE_resetthread (lua_State *L, int status);
-
-
-#endif
-
diff --git a/third-party/lua/src/lstring.c b/third-party/lua/src/lstring.c
deleted file mode 100644
index 13dcaf425..000000000
--- a/third-party/lua/src/lstring.c
+++ /dev/null
@@ -1,273 +0,0 @@
-/*
-** $Id: lstring.c $
-** String table (keeps all strings handled by Lua)
-** See Copyright Notice in lua.h
-*/
-
-#define lstring_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <string.h>
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-
-
-/*
-** Maximum size for string table.
-*/
-#define MAXSTRTB	cast_int(luaM_limitN(MAX_INT, TString*))
-
-
-/*
-** equality for long strings
-*/
-int luaS_eqlngstr (TString *a, TString *b) {
-  size_t len = a->u.lnglen;
-  lua_assert(a->tt == LUA_VLNGSTR && b->tt == LUA_VLNGSTR);
-  return (a == b) ||  /* same instance or... */
-    ((len == b->u.lnglen) &&  /* equal length and ... */
-     (memcmp(getstr(a), getstr(b), len) == 0));  /* equal contents */
-}
-
-
-unsigned int luaS_hash (const char *str, size_t l, unsigned int seed) {
-  unsigned int h = seed ^ cast_uint(l);
-  for (; l > 0; l--)
-    h ^= ((h<<5) + (h>>2) + cast_byte(str[l - 1]));
-  return h;
-}
-
-
-unsigned int luaS_hashlongstr (TString *ts) {
-  lua_assert(ts->tt == LUA_VLNGSTR);
-  if (ts->extra == 0) {  /* no hash? */
-    size_t len = ts->u.lnglen;
-    ts->hash = luaS_hash(getstr(ts), len, ts->hash);
-    ts->extra = 1;  /* now it has its hash */
-  }
-  return ts->hash;
-}
-
-
-static void tablerehash (TString **vect, int osize, int nsize) {
-  int i;
-  for (i = osize; i < nsize; i++)  /* clear new elements */
-    vect[i] = NULL;
-  for (i = 0; i < osize; i++) {  /* rehash old part of the array */
-    TString *p = vect[i];
-    vect[i] = NULL;
-    while (p) {  /* for each string in the list */
-      TString *hnext = p->u.hnext;  /* save next */
-      unsigned int h = lmod(p->hash, nsize);  /* new position */
-      p->u.hnext = vect[h];  /* chain it into array */
-      vect[h] = p;
-      p = hnext;
-    }
-  }
-}
-
-
-/*
-** Resize the string table. If allocation fails, keep the current size.
-** (This can degrade performance, but any non-zero size should work
-** correctly.)
-*/
-void luaS_resize (lua_State *L, int nsize) {
-  stringtable *tb = &G(L)->strt;
-  int osize = tb->size;
-  TString **newvect;
-  if (nsize < osize)  /* shrinking table? */
-    tablerehash(tb->hash, osize, nsize);  /* depopulate shrinking part */
-  newvect = luaM_reallocvector(L, tb->hash, osize, nsize, TString*);
-  if (l_unlikely(newvect == NULL)) {  /* reallocation failed? */
-    if (nsize < osize)  /* was it shrinking table? */
-      tablerehash(tb->hash, nsize, osize);  /* restore to original size */
-    /* leave table as it was */
-  }
-  else {  /* allocation succeeded */
-    tb->hash = newvect;
-    tb->size = nsize;
-    if (nsize > osize)
-      tablerehash(newvect, osize, nsize);  /* rehash for new size */
-  }
-}
-
-
-/*
-** Clear API string cache. (Entries cannot be empty, so fill them with
-** a non-collectable string.)
-*/
-void luaS_clearcache (global_State *g) {
-  int i, j;
-  for (i = 0; i < STRCACHE_N; i++)
-    for (j = 0; j < STRCACHE_M; j++) {
-      if (iswhite(g->strcache[i][j]))  /* will entry be collected? */
-        g->strcache[i][j] = g->memerrmsg;  /* replace it with something fixed */
-    }
-}
-
-
-/*
-** Initialize the string table and the string cache
-*/
-void luaS_init (lua_State *L) {
-  global_State *g = G(L);
-  int i, j;
-  stringtable *tb = &G(L)->strt;
-  tb->hash = luaM_newvector(L, MINSTRTABSIZE, TString*);
-  tablerehash(tb->hash, 0, MINSTRTABSIZE);  /* clear array */
-  tb->size = MINSTRTABSIZE;
-  /* pre-create memory-error message */
-  g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
-  luaC_fix(L, obj2gco(g->memerrmsg));  /* it should never be collected */
-  for (i = 0; i < STRCACHE_N; i++)  /* fill cache with valid strings */
-    for (j = 0; j < STRCACHE_M; j++)
-      g->strcache[i][j] = g->memerrmsg;
-}
-
-
-
-/*
-** creates a new string object
-*/
-static TString *createstrobj (lua_State *L, size_t l, int tag, unsigned int h) {
-  TString *ts;
-  GCObject *o;
-  size_t totalsize;  /* total size of TString object */
-  totalsize = sizelstring(l);
-  o = luaC_newobj(L, tag, totalsize);
-  ts = gco2ts(o);
-  ts->hash = h;
-  ts->extra = 0;
-  getstr(ts)[l] = '\0';  /* ending 0 */
-  return ts;
-}
-
-
-TString *luaS_createlngstrobj (lua_State *L, size_t l) {
-  TString *ts = createstrobj(L, l, LUA_VLNGSTR, G(L)->seed);
-  ts->u.lnglen = l;
-  return ts;
-}
-
-
-void luaS_remove (lua_State *L, TString *ts) {
-  stringtable *tb = &G(L)->strt;
-  TString **p = &tb->hash[lmod(ts->hash, tb->size)];
-  while (*p != ts)  /* find previous element */
-    p = &(*p)->u.hnext;
-  *p = (*p)->u.hnext;  /* remove element from its list */
-  tb->nuse--;
-}
-
-
-static void growstrtab (lua_State *L, stringtable *tb) {
-  if (l_unlikely(tb->nuse == MAX_INT)) {  /* too many strings? */
-    luaC_fullgc(L, 1);  /* try to free some... */
-    if (tb->nuse == MAX_INT)  /* still too many? */
-      luaM_error(L);  /* cannot even create a message... */
-  }
-  if (tb->size <= MAXSTRTB / 2)  /* can grow string table? */
-    luaS_resize(L, tb->size * 2);
-}
-
-
-/*
-** Checks whether short string exists and reuses it or creates a new one.
-*/
-static TString *internshrstr (lua_State *L, const char *str, size_t l) {
-  TString *ts;
-  global_State *g = G(L);
-  stringtable *tb = &g->strt;
-  unsigned int h = luaS_hash(str, l, g->seed);
-  TString **list = &tb->hash[lmod(h, tb->size)];
-  lua_assert(str != NULL);  /* otherwise 'memcmp'/'memcpy' are undefined */
-  for (ts = *list; ts != NULL; ts = ts->u.hnext) {
-    if (l == ts->shrlen && (memcmp(str, getstr(ts), l * sizeof(char)) == 0)) {
-      /* found! */
-      if (isdead(g, ts))  /* dead (but not collected yet)? */
-        changewhite(ts);  /* resurrect it */
-      return ts;
-    }
-  }
-  /* else must create a new string */
-  if (tb->nuse >= tb->size) {  /* need to grow string table? */
-    growstrtab(L, tb);
-    list = &tb->hash[lmod(h, tb->size)];  /* rehash with new size */
-  }
-  ts = createstrobj(L, l, LUA_VSHRSTR, h);
-  memcpy(getstr(ts), str, l * sizeof(char));
-  ts->shrlen = cast_byte(l);
-  ts->u.hnext = *list;
-  *list = ts;
-  tb->nuse++;
-  return ts;
-}
-
-
-/*
-** new string (with explicit length)
-*/
-TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
-  if (l <= LUAI_MAXSHORTLEN)  /* short string? */
-    return internshrstr(L, str, l);
-  else {
-    TString *ts;
-    if (l_unlikely(l >= (MAX_SIZE - sizeof(TString))/sizeof(char)))
-      luaM_toobig(L);
-    ts = luaS_createlngstrobj(L, l);
-    memcpy(getstr(ts), str, l * sizeof(char));
-    return ts;
-  }
-}
-
-
-/*
-** Create or reuse a zero-terminated string, first checking in the
-** cache (using the string address as a key). The cache can contain
-** only zero-terminated strings, so it is safe to use 'strcmp' to
-** check hits.
-*/
-TString *luaS_new (lua_State *L, const char *str) {
-  unsigned int i = point2uint(str) % STRCACHE_N;  /* hash */
-  int j;
-  TString **p = G(L)->strcache[i];
-  for (j = 0; j < STRCACHE_M; j++) {
-    if (strcmp(str, getstr(p[j])) == 0)  /* hit? */
-      return p[j];  /* that is it */
-  }
-  /* normal route */
-  for (j = STRCACHE_M - 1; j > 0; j--)
-    p[j] = p[j - 1];  /* move out last element */
-  /* new element is first in the list */
-  p[0] = luaS_newlstr(L, str, strlen(str));
-  return p[0];
-}
-
-
-Udata *luaS_newudata (lua_State *L, size_t s, int nuvalue) {
-  Udata *u;
-  int i;
-  GCObject *o;
-  if (l_unlikely(s > MAX_SIZE - udatamemoffset(nuvalue)))
-    luaM_toobig(L);
-  o = luaC_newobj(L, LUA_VUSERDATA, sizeudata(nuvalue, s));
-  u = gco2u(o);
-  u->len = s;
-  u->nuvalue = nuvalue;
-  u->metatable = NULL;
-  for (i = 0; i < nuvalue; i++)
-    setnilvalue(&u->uv[i].uv);
-  return u;
-}
-
diff --git a/third-party/lua/src/lstring.h b/third-party/lua/src/lstring.h
deleted file mode 100644
index 450c2390d..000000000
--- a/third-party/lua/src/lstring.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
-** $Id: lstring.h $
-** String table (keep all strings handled by Lua)
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lstring_h
-#define lstring_h
-
-#include "lgc.h"
-#include "lobject.h"
-#include "lstate.h"
-
-
-/*
-** Memory-allocation error message must be preallocated (it cannot
-** be created after memory is exhausted)
-*/
-#define MEMERRMSG       "not enough memory"
-
-
-/*
-** Size of a TString: Size of the header plus space for the string
-** itself (including final '\0').
-*/
-#define sizelstring(l)  (offsetof(TString, contents) + ((l) + 1) * sizeof(char))
-
-#define luaS_newliteral(L, s)	(luaS_newlstr(L, "" s, \
-                                 (sizeof(s)/sizeof(char))-1))
-
-
-/*
-** test whether a string is a reserved word
-*/
-#define isreserved(s)	((s)->tt == LUA_VSHRSTR && (s)->extra > 0)
-
-
-/*
-** equality for short strings, which are always internalized
-*/
-#define eqshrstr(a,b)	check_exp((a)->tt == LUA_VSHRSTR, (a) == (b))
-
-
-LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed);
-LUAI_FUNC unsigned int luaS_hashlongstr (TString *ts);
-LUAI_FUNC int luaS_eqlngstr (TString *a, TString *b);
-LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
-LUAI_FUNC void luaS_clearcache (global_State *g);
-LUAI_FUNC void luaS_init (lua_State *L);
-LUAI_FUNC void luaS_remove (lua_State *L, TString *ts);
-LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, int nuvalue);
-LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
-LUAI_FUNC TString *luaS_new (lua_State *L, const char *str);
-LUAI_FUNC TString *luaS_createlngstrobj (lua_State *L, size_t l);
-
-
-#endif
diff --git a/third-party/lua/src/lstrlib.c b/third-party/lua/src/lstrlib.c
deleted file mode 100644
index 03167161d..000000000
--- a/third-party/lua/src/lstrlib.c
+++ /dev/null
@@ -1,1874 +0,0 @@
-/*
-** $Id: lstrlib.c $
-** Standard library for string operations and pattern-matching
-** See Copyright Notice in lua.h
-*/
-
-#define lstrlib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <ctype.h>
-#include <float.h>
-#include <limits.h>
-#include <locale.h>
-#include <math.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-/*
-** maximum number of captures that a pattern can do during
-** pattern-matching. This limit is arbitrary, but must fit in
-** an unsigned char.
-*/
-#if !defined(LUA_MAXCAPTURES)
-#define LUA_MAXCAPTURES		32
-#endif
-
-
-/* macro to 'unsign' a character */
-#define uchar(c)	((unsigned char)(c))
-
-
-/*
-** Some sizes are better limited to fit in 'int', but must also fit in
-** 'size_t'. (We assume that 'lua_Integer' cannot be smaller than 'int'.)
-*/
-#define MAX_SIZET	((size_t)(~(size_t)0))
-
-#define MAXSIZE  \
-	(sizeof(size_t) < sizeof(int) ? MAX_SIZET : (size_t)(INT_MAX))
-
-
-
-
-static int str_len (lua_State *L) {
-  size_t l;
-  luaL_checklstring(L, 1, &l);
-  lua_pushinteger(L, (lua_Integer)l);
-  return 1;
-}
-
-
-/*
-** translate a relative initial string position
-** (negative means back from end): clip result to [1, inf).
-** The length of any string in Lua must fit in a lua_Integer,
-** so there are no overflows in the casts.
-** The inverted comparison avoids a possible overflow
-** computing '-pos'.
-*/
-static size_t posrelatI (lua_Integer pos, size_t len) {
-  if (pos > 0)
-    return (size_t)pos;
-  else if (pos == 0)
-    return 1;
-  else if (pos < -(lua_Integer)len)  /* inverted comparison */
-    return 1;  /* clip to 1 */
-  else return len + (size_t)pos + 1;
-}
-
-
-/*
-** Gets an optional ending string position from argument 'arg',
-** with default value 'def'.
-** Negative means back from end: clip result to [0, len]
-*/
-static size_t getendpos (lua_State *L, int arg, lua_Integer def,
-                         size_t len) {
-  lua_Integer pos = luaL_optinteger(L, arg, def);
-  if (pos > (lua_Integer)len)
-    return len;
-  else if (pos >= 0)
-    return (size_t)pos;
-  else if (pos < -(lua_Integer)len)
-    return 0;
-  else return len + (size_t)pos + 1;
-}
-
-
-static int str_sub (lua_State *L) {
-  size_t l;
-  const char *s = luaL_checklstring(L, 1, &l);
-  size_t start = posrelatI(luaL_checkinteger(L, 2), l);
-  size_t end = getendpos(L, 3, -1, l);
-  if (start <= end)
-    lua_pushlstring(L, s + start - 1, (end - start) + 1);
-  else lua_pushliteral(L, "");
-  return 1;
-}
-
-
-static int str_reverse (lua_State *L) {
-  size_t l, i;
-  luaL_Buffer b;
-  const char *s = luaL_checklstring(L, 1, &l);
-  char *p = luaL_buffinitsize(L, &b, l);
-  for (i = 0; i < l; i++)
-    p[i] = s[l - i - 1];
-  luaL_pushresultsize(&b, l);
-  return 1;
-}
-
-
-static int str_lower (lua_State *L) {
-  size_t l;
-  size_t i;
-  luaL_Buffer b;
-  const char *s = luaL_checklstring(L, 1, &l);
-  char *p = luaL_buffinitsize(L, &b, l);
-  for (i=0; i<l; i++)
-    p[i] = tolower(uchar(s[i]));
-  luaL_pushresultsize(&b, l);
-  return 1;
-}
-
-
-static int str_upper (lua_State *L) {
-  size_t l;
-  size_t i;
-  luaL_Buffer b;
-  const char *s = luaL_checklstring(L, 1, &l);
-  char *p = luaL_buffinitsize(L, &b, l);
-  for (i=0; i<l; i++)
-    p[i] = toupper(uchar(s[i]));
-  luaL_pushresultsize(&b, l);
-  return 1;
-}
-
-
-static int str_rep (lua_State *L) {
-  size_t l, lsep;
-  const char *s = luaL_checklstring(L, 1, &l);
-  lua_Integer n = luaL_checkinteger(L, 2);
-  const char *sep = luaL_optlstring(L, 3, "", &lsep);
-  if (n <= 0)
-    lua_pushliteral(L, "");
-  else if (l_unlikely(l + lsep < l || l + lsep > MAXSIZE / n))
-    return luaL_error(L, "resulting string too large");
-  else {
-    size_t totallen = (size_t)n * l + (size_t)(n - 1) * lsep;
-    luaL_Buffer b;
-    char *p = luaL_buffinitsize(L, &b, totallen);
-    while (n-- > 1) {  /* first n-1 copies (followed by separator) */
-      memcpy(p, s, l * sizeof(char)); p += l;
-      if (lsep > 0) {  /* empty 'memcpy' is not that cheap */
-        memcpy(p, sep, lsep * sizeof(char));
-        p += lsep;
-      }
-    }
-    memcpy(p, s, l * sizeof(char));  /* last copy (not followed by separator) */
-    luaL_pushresultsize(&b, totallen);
-  }
-  return 1;
-}
-
-
-static int str_byte (lua_State *L) {
-  size_t l;
-  const char *s = luaL_checklstring(L, 1, &l);
-  lua_Integer pi = luaL_optinteger(L, 2, 1);
-  size_t posi = posrelatI(pi, l);
-  size_t pose = getendpos(L, 3, pi, l);
-  int n, i;
-  if (posi > pose) return 0;  /* empty interval; return no values */
-  if (l_unlikely(pose - posi >= (size_t)INT_MAX))  /* arithmetic overflow? */
-    return luaL_error(L, "string slice too long");
-  n = (int)(pose -  posi) + 1;
-  luaL_checkstack(L, n, "string slice too long");
-  for (i=0; i<n; i++)
-    lua_pushinteger(L, uchar(s[posi+i-1]));
-  return n;
-}
-
-
-static int str_char (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
-  int i;
-  luaL_Buffer b;
-  char *p = luaL_buffinitsize(L, &b, n);
-  for (i=1; i<=n; i++) {
-    lua_Unsigned c = (lua_Unsigned)luaL_checkinteger(L, i);
-    luaL_argcheck(L, c <= (lua_Unsigned)UCHAR_MAX, i, "value out of range");
-    p[i - 1] = uchar(c);
-  }
-  luaL_pushresultsize(&b, n);
-  return 1;
-}
-
-
-/*
-** Buffer to store the result of 'string.dump'. It must be initialized
-** after the call to 'lua_dump', to ensure that the function is on the
-** top of the stack when 'lua_dump' is called. ('luaL_buffinit' might
-** push stuff.)
-*/
-struct str_Writer {
-  int init;  /* true iff buffer has been initialized */
-  luaL_Buffer B;
-};
-
-
-static int writer (lua_State *L, const void *b, size_t size, void *ud) {
-  struct str_Writer *state = (struct str_Writer *)ud;
-  if (!state->init) {
-    state->init = 1;
-    luaL_buffinit(L, &state->B);
-  }
-  luaL_addlstring(&state->B, (const char *)b, size);
-  return 0;
-}
-
-
-static int str_dump (lua_State *L) {
-  struct str_Writer state;
-  int strip = lua_toboolean(L, 2);
-  luaL_checktype(L, 1, LUA_TFUNCTION);
-  lua_settop(L, 1);  /* ensure function is on the top of the stack */
-  state.init = 0;
-  if (l_unlikely(lua_dump(L, writer, &state, strip) != 0))
-    return luaL_error(L, "unable to dump given function");
-  luaL_pushresult(&state.B);
-  return 1;
-}
-
-
-
-/*
-** {======================================================
-** METAMETHODS
-** =======================================================
-*/
-
-#if defined(LUA_NOCVTS2N)	/* { */
-
-/* no coercion from strings to numbers */
-
-static const luaL_Reg stringmetamethods[] = {
-  {"__index", NULL},  /* placeholder */
-  {NULL, NULL}
-};
-
-#else		/* }{ */
-
-static int tonum (lua_State *L, int arg) {
-  if (lua_type(L, arg) == LUA_TNUMBER) {  /* already a number? */
-    lua_pushvalue(L, arg);
-    return 1;
-  }
-  else {  /* check whether it is a numerical string */
-    size_t len;
-    const char *s = lua_tolstring(L, arg, &len);
-    return (s != NULL && lua_stringtonumber(L, s) == len + 1);
-  }
-}
-
-
-static void trymt (lua_State *L, const char *mtname) {
-  lua_settop(L, 2);  /* back to the original arguments */
-  if (l_unlikely(lua_type(L, 2) == LUA_TSTRING ||
-                 !luaL_getmetafield(L, 2, mtname)))
-    luaL_error(L, "attempt to %s a '%s' with a '%s'", mtname + 2,
-                  luaL_typename(L, -2), luaL_typename(L, -1));
-  lua_insert(L, -3);  /* put metamethod before arguments */
-  lua_call(L, 2, 1);  /* call metamethod */
-}
-
-
-static int arith (lua_State *L, int op, const char *mtname) {
-  if (tonum(L, 1) && tonum(L, 2))
-    lua_arith(L, op);  /* result will be on the top */
-  else
-    trymt(L, mtname);
-  return 1;
-}
-
-
-static int arith_add (lua_State *L) {
-  return arith(L, LUA_OPADD, "__add");
-}
-
-static int arith_sub (lua_State *L) {
-  return arith(L, LUA_OPSUB, "__sub");
-}
-
-static int arith_mul (lua_State *L) {
-  return arith(L, LUA_OPMUL, "__mul");
-}
-
-static int arith_mod (lua_State *L) {
-  return arith(L, LUA_OPMOD, "__mod");
-}
-
-static int arith_pow (lua_State *L) {
-  return arith(L, LUA_OPPOW, "__pow");
-}
-
-static int arith_div (lua_State *L) {
-  return arith(L, LUA_OPDIV, "__div");
-}
-
-static int arith_idiv (lua_State *L) {
-  return arith(L, LUA_OPIDIV, "__idiv");
-}
-
-static int arith_unm (lua_State *L) {
-  return arith(L, LUA_OPUNM, "__unm");
-}
-
-
-static const luaL_Reg stringmetamethods[] = {
-  {"__add", arith_add},
-  {"__sub", arith_sub},
-  {"__mul", arith_mul},
-  {"__mod", arith_mod},
-  {"__pow", arith_pow},
-  {"__div", arith_div},
-  {"__idiv", arith_idiv},
-  {"__unm", arith_unm},
-  {"__index", NULL},  /* placeholder */
-  {NULL, NULL}
-};
-
-#endif		/* } */
-
-/* }====================================================== */
-
-/*
-** {======================================================
-** PATTERN MATCHING
-** =======================================================
-*/
-
-
-#define CAP_UNFINISHED	(-1)
-#define CAP_POSITION	(-2)
-
-
-typedef struct MatchState {
-  const char *src_init;  /* init of source string */
-  const char *src_end;  /* end ('\0') of source string */
-  const char *p_end;  /* end ('\0') of pattern */
-  lua_State *L;
-  int matchdepth;  /* control for recursive depth (to avoid C stack overflow) */
-  unsigned char level;  /* total number of captures (finished or unfinished) */
-  struct {
-    const char *init;
-    ptrdiff_t len;
-  } capture[LUA_MAXCAPTURES];
-} MatchState;
-
-
-/* recursive function */
-static const char *match (MatchState *ms, const char *s, const char *p);
-
-
-/* maximum recursion depth for 'match' */
-#if !defined(MAXCCALLS)
-#define MAXCCALLS	200
-#endif
-
-
-#define L_ESC		'%'
-#define SPECIALS	"^$*+?.([%-"
-
-
-static int check_capture (MatchState *ms, int l) {
-  l -= '1';
-  if (l_unlikely(l < 0 || l >= ms->level ||
-                 ms->capture[l].len == CAP_UNFINISHED))
-    return luaL_error(ms->L, "invalid capture index %%%d", l + 1);
-  return l;
-}
-
-
-static int capture_to_close (MatchState *ms) {
-  int level = ms->level;
-  for (level--; level>=0; level--)
-    if (ms->capture[level].len == CAP_UNFINISHED) return level;
-  return luaL_error(ms->L, "invalid pattern capture");
-}
-
-
-static const char *classend (MatchState *ms, const char *p) {
-  switch (*p++) {
-    case L_ESC: {
-      if (l_unlikely(p == ms->p_end))
-        luaL_error(ms->L, "malformed pattern (ends with '%%')");
-      return p+1;
-    }
-    case '[': {
-      if (*p == '^') p++;
-      do {  /* look for a ']' */
-        if (l_unlikely(p == ms->p_end))
-          luaL_error(ms->L, "malformed pattern (missing ']')");
-        if (*(p++) == L_ESC && p < ms->p_end)
-          p++;  /* skip escapes (e.g. '%]') */
-      } while (*p != ']');
-      return p+1;
-    }
-    default: {
-      return p;
-    }
-  }
-}
-
-
-static int match_class (int c, int cl) {
-  int res;
-  switch (tolower(cl)) {
-    case 'a' : res = isalpha(c); break;
-    case 'c' : res = iscntrl(c); break;
-    case 'd' : res = isdigit(c); break;
-    case 'g' : res = isgraph(c); break;
-    case 'l' : res = islower(c); break;
-    case 'p' : res = ispunct(c); break;
-    case 's' : res = isspace(c); break;
-    case 'u' : res = isupper(c); break;
-    case 'w' : res = isalnum(c); break;
-    case 'x' : res = isxdigit(c); break;
-    case 'z' : res = (c == 0); break;  /* deprecated option */
-    default: return (cl == c);
-  }
-  return (islower(cl) ? res : !res);
-}
-
-
-static int matchbracketclass (int c, const char *p, const char *ec) {
-  int sig = 1;
-  if (*(p+1) == '^') {
-    sig = 0;
-    p++;  /* skip the '^' */
-  }
-  while (++p < ec) {
-    if (*p == L_ESC) {
-      p++;
-      if (match_class(c, uchar(*p)))
-        return sig;
-    }
-    else if ((*(p+1) == '-') && (p+2 < ec)) {
-      p+=2;
-      if (uchar(*(p-2)) <= c && c <= uchar(*p))
-        return sig;
-    }
-    else if (uchar(*p) == c) return sig;
-  }
-  return !sig;
-}
-
-
-static int singlematch (MatchState *ms, const char *s, const char *p,
-                        const char *ep) {
-  if (s >= ms->src_end)
-    return 0;
-  else {
-    int c = uchar(*s);
-    switch (*p) {
-      case '.': return 1;  /* matches any char */
-      case L_ESC: return match_class(c, uchar(*(p+1)));
-      case '[': return matchbracketclass(c, p, ep-1);
-      default:  return (uchar(*p) == c);
-    }
-  }
-}
-
-
-static const char *matchbalance (MatchState *ms, const char *s,
-                                   const char *p) {
-  if (l_unlikely(p >= ms->p_end - 1))
-    luaL_error(ms->L, "malformed pattern (missing arguments to '%%b')");
-  if (*s != *p) return NULL;
-  else {
-    int b = *p;
-    int e = *(p+1);
-    int cont = 1;
-    while (++s < ms->src_end) {
-      if (*s == e) {
-        if (--cont == 0) return s+1;
-      }
-      else if (*s == b) cont++;
-    }
-  }
-  return NULL;  /* string ends out of balance */
-}
-
-
-static const char *max_expand (MatchState *ms, const char *s,
-                                 const char *p, const char *ep) {
-  ptrdiff_t i = 0;  /* counts maximum expand for item */
-  while (singlematch(ms, s + i, p, ep))
-    i++;
-  /* keeps trying to match with the maximum repetitions */
-  while (i>=0) {
-    const char *res = match(ms, (s+i), ep+1);
-    if (res) return res;
-    i--;  /* else didn't match; reduce 1 repetition to try again */
-  }
-  return NULL;
-}
-
-
-static const char *min_expand (MatchState *ms, const char *s,
-                                 const char *p, const char *ep) {
-  for (;;) {
-    const char *res = match(ms, s, ep+1);
-    if (res != NULL)
-      return res;
-    else if (singlematch(ms, s, p, ep))
-      s++;  /* try with one more repetition */
-    else return NULL;
-  }
-}
-
-
-static const char *start_capture (MatchState *ms, const char *s,
-                                    const char *p, int what) {
-  const char *res;
-  int level = ms->level;
-  if (level >= LUA_MAXCAPTURES) luaL_error(ms->L, "too many captures");
-  ms->capture[level].init = s;
-  ms->capture[level].len = what;
-  ms->level = level+1;
-  if ((res=match(ms, s, p)) == NULL)  /* match failed? */
-    ms->level--;  /* undo capture */
-  return res;
-}
-
-
-static const char *end_capture (MatchState *ms, const char *s,
-                                  const char *p) {
-  int l = capture_to_close(ms);
-  const char *res;
-  ms->capture[l].len = s - ms->capture[l].init;  /* close capture */
-  if ((res = match(ms, s, p)) == NULL)  /* match failed? */
-    ms->capture[l].len = CAP_UNFINISHED;  /* undo capture */
-  return res;
-}
-
-
-static const char *match_capture (MatchState *ms, const char *s, int l) {
-  size_t len;
-  l = check_capture(ms, l);
-  len = ms->capture[l].len;
-  if ((size_t)(ms->src_end-s) >= len &&
-      memcmp(ms->capture[l].init, s, len) == 0)
-    return s+len;
-  else return NULL;
-}
-
-
-static const char *match (MatchState *ms, const char *s, const char *p) {
-  if (l_unlikely(ms->matchdepth-- == 0))
-    luaL_error(ms->L, "pattern too complex");
-  init: /* using goto to optimize tail recursion */
-  if (p != ms->p_end) {  /* end of pattern? */
-    switch (*p) {
-      case '(': {  /* start capture */
-        if (*(p + 1) == ')')  /* position capture? */
-          s = start_capture(ms, s, p + 2, CAP_POSITION);
-        else
-          s = start_capture(ms, s, p + 1, CAP_UNFINISHED);
-        break;
-      }
-      case ')': {  /* end capture */
-        s = end_capture(ms, s, p + 1);
-        break;
-      }
-      case '$': {
-        if ((p + 1) != ms->p_end)  /* is the '$' the last char in pattern? */
-          goto dflt;  /* no; go to default */
-        s = (s == ms->src_end) ? s : NULL;  /* check end of string */
-        break;
-      }
-      case L_ESC: {  /* escaped sequences not in the format class[*+?-]? */
-        switch (*(p + 1)) {
-          case 'b': {  /* balanced string? */
-            s = matchbalance(ms, s, p + 2);
-            if (s != NULL) {
-              p += 4; goto init;  /* return match(ms, s, p + 4); */
-            }  /* else fail (s == NULL) */
-            break;
-          }
-          case 'f': {  /* frontier? */
-            const char *ep; char previous;
-            p += 2;
-            if (l_unlikely(*p != '['))
-              luaL_error(ms->L, "missing '[' after '%%f' in pattern");
-            ep = classend(ms, p);  /* points to what is next */
-            previous = (s == ms->src_init) ? '\0' : *(s - 1);
-            if (!matchbracketclass(uchar(previous), p, ep - 1) &&
-               matchbracketclass(uchar(*s), p, ep - 1)) {
-              p = ep; goto init;  /* return match(ms, s, ep); */
-            }
-            s = NULL;  /* match failed */
-            break;
-          }
-          case '0': case '1': case '2': case '3':
-          case '4': case '5': case '6': case '7':
-          case '8': case '9': {  /* capture results (%0-%9)? */
-            s = match_capture(ms, s, uchar(*(p + 1)));
-            if (s != NULL) {
-              p += 2; goto init;  /* return match(ms, s, p + 2) */
-            }
-            break;
-          }
-          default: goto dflt;
-        }
-        break;
-      }
-      default: dflt: {  /* pattern class plus optional suffix */
-        const char *ep = classend(ms, p);  /* points to optional suffix */
-        /* does not match at least once? */
-        if (!singlematch(ms, s, p, ep)) {
-          if (*ep == '*' || *ep == '?' || *ep == '-') {  /* accept empty? */
-            p = ep + 1; goto init;  /* return match(ms, s, ep + 1); */
-          }
-          else  /* '+' or no suffix */
-            s = NULL;  /* fail */
-        }
-        else {  /* matched once */
-          switch (*ep) {  /* handle optional suffix */
-            case '?': {  /* optional */
-              const char *res;
-              if ((res = match(ms, s + 1, ep + 1)) != NULL)
-                s = res;
-              else {
-                p = ep + 1; goto init;  /* else return match(ms, s, ep + 1); */
-              }
-              break;
-            }
-            case '+':  /* 1 or more repetitions */
-              s++;  /* 1 match already done */
-              /* FALLTHROUGH */
-            case '*':  /* 0 or more repetitions */
-              s = max_expand(ms, s, p, ep);
-              break;
-            case '-':  /* 0 or more repetitions (minimum) */
-              s = min_expand(ms, s, p, ep);
-              break;
-            default:  /* no suffix */
-              s++; p = ep; goto init;  /* return match(ms, s + 1, ep); */
-          }
-        }
-        break;
-      }
-    }
-  }
-  ms->matchdepth++;
-  return s;
-}
-
-
-
-static const char *lmemfind (const char *s1, size_t l1,
-                               const char *s2, size_t l2) {
-  if (l2 == 0) return s1;  /* empty strings are everywhere */
-  else if (l2 > l1) return NULL;  /* avoids a negative 'l1' */
-  else {
-    const char *init;  /* to search for a '*s2' inside 's1' */
-    l2--;  /* 1st char will be checked by 'memchr' */
-    l1 = l1-l2;  /* 's2' cannot be found after that */
-    while (l1 > 0 && (init = (const char *)memchr(s1, *s2, l1)) != NULL) {
-      init++;   /* 1st char is already checked */
-      if (memcmp(init, s2+1, l2) == 0)
-        return init-1;
-      else {  /* correct 'l1' and 's1' to try again */
-        l1 -= init-s1;
-        s1 = init;
-      }
-    }
-    return NULL;  /* not found */
-  }
-}
-
-
-/*
-** get information about the i-th capture. If there are no captures
-** and 'i==0', return information about the whole match, which
-** is the range 's'..'e'. If the capture is a string, return
-** its length and put its address in '*cap'. If it is an integer
-** (a position), push it on the stack and return CAP_POSITION.
-*/
-static size_t get_onecapture (MatchState *ms, int i, const char *s,
-                              const char *e, const char **cap) {
-  if (i >= ms->level) {
-    if (l_unlikely(i != 0))
-      luaL_error(ms->L, "invalid capture index %%%d", i + 1);
-    *cap = s;
-    return e - s;
-  }
-  else {
-    ptrdiff_t capl = ms->capture[i].len;
-    *cap = ms->capture[i].init;
-    if (l_unlikely(capl == CAP_UNFINISHED))
-      luaL_error(ms->L, "unfinished capture");
-    else if (capl == CAP_POSITION)
-      lua_pushinteger(ms->L, (ms->capture[i].init - ms->src_init) + 1);
-    return capl;
-  }
-}
-
-
-/*
-** Push the i-th capture on the stack.
-*/
-static void push_onecapture (MatchState *ms, int i, const char *s,
-                                                    const char *e) {
-  const char *cap;
-  ptrdiff_t l = get_onecapture(ms, i, s, e, &cap);
-  if (l != CAP_POSITION)
-    lua_pushlstring(ms->L, cap, l);
-  /* else position was already pushed */
-}
-
-
-static int push_captures (MatchState *ms, const char *s, const char *e) {
-  int i;
-  int nlevels = (ms->level == 0 && s) ? 1 : ms->level;
-  luaL_checkstack(ms->L, nlevels, "too many captures");
-  for (i = 0; i < nlevels; i++)
-    push_onecapture(ms, i, s, e);
-  return nlevels;  /* number of strings pushed */
-}
-
-
-/* check whether pattern has no special characters */
-static int nospecials (const char *p, size_t l) {
-  size_t upto = 0;
-  do {
-    if (strpbrk(p + upto, SPECIALS))
-      return 0;  /* pattern has a special character */
-    upto += strlen(p + upto) + 1;  /* may have more after \0 */
-  } while (upto <= l);
-  return 1;  /* no special chars found */
-}
-
-
-static void prepstate (MatchState *ms, lua_State *L,
-                       const char *s, size_t ls, const char *p, size_t lp) {
-  ms->L = L;
-  ms->matchdepth = MAXCCALLS;
-  ms->src_init = s;
-  ms->src_end = s + ls;
-  ms->p_end = p + lp;
-}
-
-
-static void reprepstate (MatchState *ms) {
-  ms->level = 0;
-  lua_assert(ms->matchdepth == MAXCCALLS);
-}
-
-
-static int str_find_aux (lua_State *L, int find) {
-  size_t ls, lp;
-  const char *s = luaL_checklstring(L, 1, &ls);
-  const char *p = luaL_checklstring(L, 2, &lp);
-  size_t init = posrelatI(luaL_optinteger(L, 3, 1), ls) - 1;
-  if (init > ls) {  /* start after string's end? */
-    luaL_pushfail(L);  /* cannot find anything */
-    return 1;
-  }
-  /* explicit request or no special characters? */
-  if (find && (lua_toboolean(L, 4) || nospecials(p, lp))) {
-    /* do a plain search */
-    const char *s2 = lmemfind(s + init, ls - init, p, lp);
-    if (s2) {
-      lua_pushinteger(L, (s2 - s) + 1);
-      lua_pushinteger(L, (s2 - s) + lp);
-      return 2;
-    }
-  }
-  else {
-    MatchState ms;
-    const char *s1 = s + init;
-    int anchor = (*p == '^');
-    if (anchor) {
-      p++; lp--;  /* skip anchor character */
-    }
-    prepstate(&ms, L, s, ls, p, lp);
-    do {
-      const char *res;
-      reprepstate(&ms);
-      if ((res=match(&ms, s1, p)) != NULL) {
-        if (find) {
-          lua_pushinteger(L, (s1 - s) + 1);  /* start */
-          lua_pushinteger(L, res - s);   /* end */
-          return push_captures(&ms, NULL, 0) + 2;
-        }
-        else
-          return push_captures(&ms, s1, res);
-      }
-    } while (s1++ < ms.src_end && !anchor);
-  }
-  luaL_pushfail(L);  /* not found */
-  return 1;
-}
-
-
-static int str_find (lua_State *L) {
-  return str_find_aux(L, 1);
-}
-
-
-static int str_match (lua_State *L) {
-  return str_find_aux(L, 0);
-}
-
-
-/* state for 'gmatch' */
-typedef struct GMatchState {
-  const char *src;  /* current position */
-  const char *p;  /* pattern */
-  const char *lastmatch;  /* end of last match */
-  MatchState ms;  /* match state */
-} GMatchState;
-
-
-static int gmatch_aux (lua_State *L) {
-  GMatchState *gm = (GMatchState *)lua_touserdata(L, lua_upvalueindex(3));
-  const char *src;
-  gm->ms.L = L;
-  for (src = gm->src; src <= gm->ms.src_end; src++) {
-    const char *e;
-    reprepstate(&gm->ms);
-    if ((e = match(&gm->ms, src, gm->p)) != NULL && e != gm->lastmatch) {
-      gm->src = gm->lastmatch = e;
-      return push_captures(&gm->ms, src, e);
-    }
-  }
-  return 0;  /* not found */
-}
-
-
-static int gmatch (lua_State *L) {
-  size_t ls, lp;
-  const char *s = luaL_checklstring(L, 1, &ls);
-  const char *p = luaL_checklstring(L, 2, &lp);
-  size_t init = posrelatI(luaL_optinteger(L, 3, 1), ls) - 1;
-  GMatchState *gm;
-  lua_settop(L, 2);  /* keep strings on closure to avoid being collected */
-  gm = (GMatchState *)lua_newuserdatauv(L, sizeof(GMatchState), 0);
-  if (init > ls)  /* start after string's end? */
-    init = ls + 1;  /* avoid overflows in 's + init' */
-  prepstate(&gm->ms, L, s, ls, p, lp);
-  gm->src = s + init; gm->p = p; gm->lastmatch = NULL;
-  lua_pushcclosure(L, gmatch_aux, 3);
-  return 1;
-}
-
-
-static void add_s (MatchState *ms, luaL_Buffer *b, const char *s,
-                                                   const char *e) {
-  size_t l;
-  lua_State *L = ms->L;
-  const char *news = lua_tolstring(L, 3, &l);
-  const char *p;
-  while ((p = (char *)memchr(news, L_ESC, l)) != NULL) {
-    luaL_addlstring(b, news, p - news);
-    p++;  /* skip ESC */
-    if (*p == L_ESC)  /* '%%' */
-      luaL_addchar(b, *p);
-    else if (*p == '0')  /* '%0' */
-        luaL_addlstring(b, s, e - s);
-    else if (isdigit(uchar(*p))) {  /* '%n' */
-      const char *cap;
-      ptrdiff_t resl = get_onecapture(ms, *p - '1', s, e, &cap);
-      if (resl == CAP_POSITION)
-        luaL_addvalue(b);  /* add position to accumulated result */
-      else
-        luaL_addlstring(b, cap, resl);
-    }
-    else
-      luaL_error(L, "invalid use of '%c' in replacement string", L_ESC);
-    l -= p + 1 - news;
-    news = p + 1;
-  }
-  luaL_addlstring(b, news, l);
-}
-
-
-/*
-** Add the replacement value to the string buffer 'b'.
-** Return true if the original string was changed. (Function calls and
-** table indexing resulting in nil or false do not change the subject.)
-*/
-static int add_value (MatchState *ms, luaL_Buffer *b, const char *s,
-                                      const char *e, int tr) {
-  lua_State *L = ms->L;
-  switch (tr) {
-    case LUA_TFUNCTION: {  /* call the function */
-      int n;
-      lua_pushvalue(L, 3);  /* push the function */
-      n = push_captures(ms, s, e);  /* all captures as arguments */
-      lua_call(L, n, 1);  /* call it */
-      break;
-    }
-    case LUA_TTABLE: {  /* index the table */
-      push_onecapture(ms, 0, s, e);  /* first capture is the index */
-      lua_gettable(L, 3);
-      break;
-    }
-    default: {  /* LUA_TNUMBER or LUA_TSTRING */
-      add_s(ms, b, s, e);  /* add value to the buffer */
-      return 1;  /* something changed */
-    }
-  }
-  if (!lua_toboolean(L, -1)) {  /* nil or false? */
-    lua_pop(L, 1);  /* remove value */
-    luaL_addlstring(b, s, e - s);  /* keep original text */
-    return 0;  /* no changes */
-  }
-  else if (l_unlikely(!lua_isstring(L, -1)))
-    return luaL_error(L, "invalid replacement value (a %s)",
-                         luaL_typename(L, -1));
-  else {
-    luaL_addvalue(b);  /* add result to accumulator */
-    return 1;  /* something changed */
-  }
-}
-
-
-static int str_gsub (lua_State *L) {
-  size_t srcl, lp;
-  const char *src = luaL_checklstring(L, 1, &srcl);  /* subject */
-  const char *p = luaL_checklstring(L, 2, &lp);  /* pattern */
-  const char *lastmatch = NULL;  /* end of last match */
-  int tr = lua_type(L, 3);  /* replacement type */
-  lua_Integer max_s = luaL_optinteger(L, 4, srcl + 1);  /* max replacements */
-  int anchor = (*p == '^');
-  lua_Integer n = 0;  /* replacement count */
-  int changed = 0;  /* change flag */
-  MatchState ms;
-  luaL_Buffer b;
-  luaL_argexpected(L, tr == LUA_TNUMBER || tr == LUA_TSTRING ||
-                   tr == LUA_TFUNCTION || tr == LUA_TTABLE, 3,
-                      "string/function/table");
-  luaL_buffinit(L, &b);
-  if (anchor) {
-    p++; lp--;  /* skip anchor character */
-  }
-  prepstate(&ms, L, src, srcl, p, lp);
-  while (n < max_s) {
-    const char *e;
-    reprepstate(&ms);  /* (re)prepare state for new match */
-    if ((e = match(&ms, src, p)) != NULL && e != lastmatch) {  /* match? */
-      n++;
-      changed = add_value(&ms, &b, src, e, tr) | changed;
-      src = lastmatch = e;
-    }
-    else if (src < ms.src_end)  /* otherwise, skip one character */
-      luaL_addchar(&b, *src++);
-    else break;  /* end of subject */
-    if (anchor) break;
-  }
-  if (!changed)  /* no changes? */
-    lua_pushvalue(L, 1);  /* return original string */
-  else {  /* something changed */
-    luaL_addlstring(&b, src, ms.src_end-src);
-    luaL_pushresult(&b);  /* create and return new string */
-  }
-  lua_pushinteger(L, n);  /* number of substitutions */
-  return 2;
-}
-
-/* }====================================================== */
-
-
-
-/*
-** {======================================================
-** STRING FORMAT
-** =======================================================
-*/
-
-#if !defined(lua_number2strx)	/* { */
-
-/*
-** Hexadecimal floating-point formatter
-*/
-
-#define SIZELENMOD	(sizeof(LUA_NUMBER_FRMLEN)/sizeof(char))
-
-
-/*
-** Number of bits that goes into the first digit. It can be any value
-** between 1 and 4; the following definition tries to align the number
-** to nibble boundaries by making what is left after that first digit a
-** multiple of 4.
-*/
-#define L_NBFD		((l_floatatt(MANT_DIG) - 1)%4 + 1)
-
-
-/*
-** Add integer part of 'x' to buffer and return new 'x'
-*/
-static lua_Number adddigit (char *buff, int n, lua_Number x) {
-  lua_Number dd = l_mathop(floor)(x);  /* get integer part from 'x' */
-  int d = (int)dd;
-  buff[n] = (d < 10 ? d + '0' : d - 10 + 'a');  /* add to buffer */
-  return x - dd;  /* return what is left */
-}
-
-
-static int num2straux (char *buff, int sz, lua_Number x) {
-  /* if 'inf' or 'NaN', format it like '%g' */
-  if (x != x || x == (lua_Number)HUGE_VAL || x == -(lua_Number)HUGE_VAL)
-    return l_sprintf(buff, sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)x);
-  else if (x == 0) {  /* can be -0... */
-    /* create "0" or "-0" followed by exponent */
-    return l_sprintf(buff, sz, LUA_NUMBER_FMT "x0p+0", (LUAI_UACNUMBER)x);
-  }
-  else {
-    int e;
-    lua_Number m = l_mathop(frexp)(x, &e);  /* 'x' fraction and exponent */
-    int n = 0;  /* character count */
-    if (m < 0) {  /* is number negative? */
-      buff[n++] = '-';  /* add sign */
-      m = -m;  /* make it positive */
-    }
-    buff[n++] = '0'; buff[n++] = 'x';  /* add "0x" */
-    m = adddigit(buff, n++, m * (1 << L_NBFD));  /* add first digit */
-    e -= L_NBFD;  /* this digit goes before the radix point */
-    if (m > 0) {  /* more digits? */
-      buff[n++] = lua_getlocaledecpoint();  /* add radix point */
-      do {  /* add as many digits as needed */
-        m = adddigit(buff, n++, m * 16);
-      } while (m > 0);
-    }
-    n += l_sprintf(buff + n, sz - n, "p%+d", e);  /* add exponent */
-    lua_assert(n < sz);
-    return n;
-  }
-}
-
-
-static int lua_number2strx (lua_State *L, char *buff, int sz,
-                            const char *fmt, lua_Number x) {
-  int n = num2straux(buff, sz, x);
-  if (fmt[SIZELENMOD] == 'A') {
-    int i;
-    for (i = 0; i < n; i++)
-      buff[i] = toupper(uchar(buff[i]));
-  }
-  else if (l_unlikely(fmt[SIZELENMOD] != 'a'))
-    return luaL_error(L, "modifiers for format '%%a'/'%%A' not implemented");
-  return n;
-}
-
-#endif				/* } */
-
-
-/*
-** Maximum size for items formatted with '%f'. This size is produced
-** by format('%.99f', -maxfloat), and is equal to 99 + 3 ('-', '.',
-** and '\0') + number of decimal digits to represent maxfloat (which
-** is maximum exponent + 1). (99+3+1, adding some extra, 110)
-*/
-#define MAX_ITEMF	(110 + l_floatatt(MAX_10_EXP))
-
-
-/*
-** All formats except '%f' do not need that large limit.  The other
-** float formats use exponents, so that they fit in the 99 limit for
-** significant digits; 's' for large strings and 'q' add items directly
-** to the buffer; all integer formats also fit in the 99 limit.  The
-** worst case are floats: they may need 99 significant digits, plus
-** '0x', '-', '.', 'e+XXXX', and '\0'. Adding some extra, 120.
-*/
-#define MAX_ITEM	120
-
-
-/* valid flags in a format specification */
-#if !defined(L_FMTFLAGSF)
-
-/* valid flags for a, A, e, E, f, F, g, and G conversions */
-#define L_FMTFLAGSF	"-+#0 "
-
-/* valid flags for o, x, and X conversions */
-#define L_FMTFLAGSX	"-#0"
-
-/* valid flags for d and i conversions */
-#define L_FMTFLAGSI	"-+0 "
-
-/* valid flags for u conversions */
-#define L_FMTFLAGSU	"-0"
-
-/* valid flags for c, p, and s conversions */
-#define L_FMTFLAGSC	"-"
-
-#endif
-
-
-/*
-** Maximum size of each format specification (such as "%-099.99d"):
-** Initial '%', flags (up to 5), width (2), period, precision (2),
-** length modifier (8), conversion specifier, and final '\0', plus some
-** extra.
-*/
-#define MAX_FORMAT	32
-
-
-static void addquoted (luaL_Buffer *b, const char *s, size_t len) {
-  luaL_addchar(b, '"');
-  while (len--) {
-    if (*s == '"' || *s == '\\' || *s == '\n') {
-      luaL_addchar(b, '\\');
-      luaL_addchar(b, *s);
-    }
-    else if (iscntrl(uchar(*s))) {
-      char buff[10];
-      if (!isdigit(uchar(*(s+1))))
-        l_sprintf(buff, sizeof(buff), "\\%d", (int)uchar(*s));
-      else
-        l_sprintf(buff, sizeof(buff), "\\%03d", (int)uchar(*s));
-      luaL_addstring(b, buff);
-    }
-    else
-      luaL_addchar(b, *s);
-    s++;
-  }
-  luaL_addchar(b, '"');
-}
-
-
-/*
-** Serialize a floating-point number in such a way that it can be
-** scanned back by Lua. Use hexadecimal format for "common" numbers
-** (to preserve precision); inf, -inf, and NaN are handled separately.
-** (NaN cannot be expressed as a numeral, so we write '(0/0)' for it.)
-*/
-static int quotefloat (lua_State *L, char *buff, lua_Number n) {
-  const char *s;  /* for the fixed representations */
-  if (n == (lua_Number)HUGE_VAL)  /* inf? */
-    s = "1e9999";
-  else if (n == -(lua_Number)HUGE_VAL)  /* -inf? */
-    s = "-1e9999";
-  else if (n != n)  /* NaN? */
-    s = "(0/0)";
-  else {  /* format number as hexadecimal */
-    int  nb = lua_number2strx(L, buff, MAX_ITEM,
-                                 "%" LUA_NUMBER_FRMLEN "a", n);
-    /* ensures that 'buff' string uses a dot as the radix character */
-    if (memchr(buff, '.', nb) == NULL) {  /* no dot? */
-      char point = lua_getlocaledecpoint();  /* try locale point */
-      char *ppoint = (char *)memchr(buff, point, nb);
-      if (ppoint) *ppoint = '.';  /* change it to a dot */
-    }
-    return nb;
-  }
-  /* for the fixed representations */
-  return l_sprintf(buff, MAX_ITEM, "%s", s);
-}
-
-
-static void addliteral (lua_State *L, luaL_Buffer *b, int arg) {
-  switch (lua_type(L, arg)) {
-    case LUA_TSTRING: {
-      size_t len;
-      const char *s = lua_tolstring(L, arg, &len);
-      addquoted(b, s, len);
-      break;
-    }
-    case LUA_TNUMBER: {
-      char *buff = luaL_prepbuffsize(b, MAX_ITEM);
-      int nb;
-      if (!lua_isinteger(L, arg))  /* float? */
-        nb = quotefloat(L, buff, lua_tonumber(L, arg));
-      else {  /* integers */
-        lua_Integer n = lua_tointeger(L, arg);
-        const char *format = (n == LUA_MININTEGER)  /* corner case? */
-                           ? "0x%" LUA_INTEGER_FRMLEN "x"  /* use hex */
-                           : LUA_INTEGER_FMT;  /* else use default format */
-        nb = l_sprintf(buff, MAX_ITEM, format, (LUAI_UACINT)n);
-      }
-      luaL_addsize(b, nb);
-      break;
-    }
-    case LUA_TNIL: case LUA_TBOOLEAN: {
-      luaL_tolstring(L, arg, NULL);
-      luaL_addvalue(b);
-      break;
-    }
-    default: {
-      luaL_argerror(L, arg, "value has no literal form");
-    }
-  }
-}
-
-
-static const char *get2digits (const char *s) {
-  if (isdigit(uchar(*s))) {
-    s++;
-    if (isdigit(uchar(*s))) s++;  /* (2 digits at most) */
-  }
-  return s;
-}
-
-
-/*
-** Check whether a conversion specification is valid. When called,
-** first character in 'form' must be '%' and last character must
-** be a valid conversion specifier. 'flags' are the accepted flags;
-** 'precision' signals whether to accept a precision.
-*/
-static void checkformat (lua_State *L, const char *form, const char *flags,
-                                       int precision) {
-  const char *spec = form + 1;  /* skip '%' */
-  spec += strspn(spec, flags);  /* skip flags */
-  if (*spec != '0') {  /* a width cannot start with '0' */
-    spec = get2digits(spec);  /* skip width */
-    if (*spec == '.' && precision) {
-      spec++;
-      spec = get2digits(spec);  /* skip precision */
-    }
-  }
-  if (!isalpha(uchar(*spec)))  /* did not go to the end? */
-    luaL_error(L, "invalid conversion specification: '%s'", form);
-}
-
-
-/*
-** Get a conversion specification and copy it to 'form'.
-** Return the address of its last character.
-*/
-static const char *getformat (lua_State *L, const char *strfrmt,
-                                            char *form) {
-  /* spans flags, width, and precision ('0' is included as a flag) */
-  size_t len = strspn(strfrmt, L_FMTFLAGSF "123456789.");
-  len++;  /* adds following character (should be the specifier) */
-  /* still needs space for '%', '\0', plus a length modifier */
-  if (len >= MAX_FORMAT - 10)
-    luaL_error(L, "invalid format (too long)");
-  *(form++) = '%';
-  memcpy(form, strfrmt, len * sizeof(char));
-  *(form + len) = '\0';
-  return strfrmt + len - 1;
-}
-
-
-/*
-** add length modifier into formats
-*/
-static void addlenmod (char *form, const char *lenmod) {
-  size_t l = strlen(form);
-  size_t lm = strlen(lenmod);
-  char spec = form[l - 1];
-  strcpy(form + l - 1, lenmod);
-  form[l + lm - 1] = spec;
-  form[l + lm] = '\0';
-}
-
-
-static int str_format (lua_State *L) {
-  int top = lua_gettop(L);
-  int arg = 1;
-  size_t sfl;
-  const char *strfrmt = luaL_checklstring(L, arg, &sfl);
-  const char *strfrmt_end = strfrmt+sfl;
-  const char *flags;
-  luaL_Buffer b;
-  luaL_buffinit(L, &b);
-  while (strfrmt < strfrmt_end) {
-    if (*strfrmt != L_ESC)
-      luaL_addchar(&b, *strfrmt++);
-    else if (*++strfrmt == L_ESC)
-      luaL_addchar(&b, *strfrmt++);  /* %% */
-    else { /* format item */
-      char form[MAX_FORMAT];  /* to store the format ('%...') */
-      int maxitem = MAX_ITEM;  /* maximum length for the result */
-      char *buff = luaL_prepbuffsize(&b, maxitem);  /* to put result */
-      int nb = 0;  /* number of bytes in result */
-      if (++arg > top)
-        return luaL_argerror(L, arg, "no value");
-      strfrmt = getformat(L, strfrmt, form);
-      switch (*strfrmt++) {
-        case 'c': {
-          checkformat(L, form, L_FMTFLAGSC, 0);
-          nb = l_sprintf(buff, maxitem, form, (int)luaL_checkinteger(L, arg));
-          break;
-        }
-        case 'd': case 'i':
-          flags = L_FMTFLAGSI;
-          goto intcase;
-        case 'u':
-          flags = L_FMTFLAGSU;
-          goto intcase;
-        case 'o': case 'x': case 'X':
-          flags = L_FMTFLAGSX;
-         intcase: {
-          lua_Integer n = luaL_checkinteger(L, arg);
-          checkformat(L, form, flags, 1);
-          addlenmod(form, LUA_INTEGER_FRMLEN);
-          nb = l_sprintf(buff, maxitem, form, (LUAI_UACINT)n);
-          break;
-        }
-        case 'a': case 'A':
-          checkformat(L, form, L_FMTFLAGSF, 1);
-          addlenmod(form, LUA_NUMBER_FRMLEN);
-          nb = lua_number2strx(L, buff, maxitem, form,
-                                  luaL_checknumber(L, arg));
-          break;
-        case 'f':
-          maxitem = MAX_ITEMF;  /* extra space for '%f' */
-          buff = luaL_prepbuffsize(&b, maxitem);
-          /* FALLTHROUGH */
-        case 'e': case 'E': case 'g': case 'G': {
-          lua_Number n = luaL_checknumber(L, arg);
-          checkformat(L, form, L_FMTFLAGSF, 1);
-          addlenmod(form, LUA_NUMBER_FRMLEN);
-          nb = l_sprintf(buff, maxitem, form, (LUAI_UACNUMBER)n);
-          break;
-        }
-        case 'p': {
-          const void *p = lua_topointer(L, arg);
-          checkformat(L, form, L_FMTFLAGSC, 0);
-          if (p == NULL) {  /* avoid calling 'printf' with argument NULL */
-            p = "(null)";  /* result */
-            form[strlen(form) - 1] = 's';  /* format it as a string */
-          }
-          nb = l_sprintf(buff, maxitem, form, p);
-          break;
-        }
-        case 'q': {
-          if (form[2] != '\0')  /* modifiers? */
-            return luaL_error(L, "specifier '%%q' cannot have modifiers");
-          addliteral(L, &b, arg);
-          break;
-        }
-        case 's': {
-          size_t l;
-          const char *s = luaL_tolstring(L, arg, &l);
-          if (form[2] == '\0')  /* no modifiers? */
-            luaL_addvalue(&b);  /* keep entire string */
-          else {
-            luaL_argcheck(L, l == strlen(s), arg, "string contains zeros");
-            checkformat(L, form, L_FMTFLAGSC, 1);
-            if (strchr(form, '.') == NULL && l >= 100) {
-              /* no precision and string is too long to be formatted */
-              luaL_addvalue(&b);  /* keep entire string */
-            }
-            else {  /* format the string into 'buff' */
-              nb = l_sprintf(buff, maxitem, form, s);
-              lua_pop(L, 1);  /* remove result from 'luaL_tolstring' */
-            }
-          }
-          break;
-        }
-        default: {  /* also treat cases 'pnLlh' */
-          return luaL_error(L, "invalid conversion '%s' to 'format'", form);
-        }
-      }
-      lua_assert(nb < maxitem);
-      luaL_addsize(&b, nb);
-    }
-  }
-  luaL_pushresult(&b);
-  return 1;
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** PACK/UNPACK
-** =======================================================
-*/
-
-
-/* value used for padding */
-#if !defined(LUAL_PACKPADBYTE)
-#define LUAL_PACKPADBYTE		0x00
-#endif
-
-/* maximum size for the binary representation of an integer */
-#define MAXINTSIZE	16
-
-/* number of bits in a character */
-#define NB	CHAR_BIT
-
-/* mask for one character (NB 1's) */
-#define MC	((1 << NB) - 1)
-
-/* size of a lua_Integer */
-#define SZINT	((int)sizeof(lua_Integer))
-
-
-/* dummy union to get native endianness */
-static const union {
-  int dummy;
-  char little;  /* true iff machine is little endian */
-} nativeendian = {1};
-
-
-/*
-** information to pack/unpack stuff
-*/
-typedef struct Header {
-  lua_State *L;
-  int islittle;
-  int maxalign;
-} Header;
-
-
-/*
-** options for pack/unpack
-*/
-typedef enum KOption {
-  Kint,		/* signed integers */
-  Kuint,	/* unsigned integers */
-  Kfloat,	/* single-precision floating-point numbers */
-  Knumber,	/* Lua "native" floating-point numbers */
-  Kdouble,	/* double-precision floating-point numbers */
-  Kchar,	/* fixed-length strings */
-  Kstring,	/* strings with prefixed length */
-  Kzstr,	/* zero-terminated strings */
-  Kpadding,	/* padding */
-  Kpaddalign,	/* padding for alignment */
-  Knop		/* no-op (configuration or spaces) */
-} KOption;
-
-
-/*
-** Read an integer numeral from string 'fmt' or return 'df' if
-** there is no numeral
-*/
-static int digit (int c) { return '0' <= c && c <= '9'; }
-
-static int getnum (const char **fmt, int df) {
-  if (!digit(**fmt))  /* no number? */
-    return df;  /* return default value */
-  else {
-    int a = 0;
-    do {
-      a = a*10 + (*((*fmt)++) - '0');
-    } while (digit(**fmt) && a <= ((int)MAXSIZE - 9)/10);
-    return a;
-  }
-}
-
-
-/*
-** Read an integer numeral and raises an error if it is larger
-** than the maximum size for integers.
-*/
-static int getnumlimit (Header *h, const char **fmt, int df) {
-  int sz = getnum(fmt, df);
-  if (l_unlikely(sz > MAXINTSIZE || sz <= 0))
-    return luaL_error(h->L, "integral size (%d) out of limits [1,%d]",
-                            sz, MAXINTSIZE);
-  return sz;
-}
-
-
-/*
-** Initialize Header
-*/
-static void initheader (lua_State *L, Header *h) {
-  h->L = L;
-  h->islittle = nativeendian.little;
-  h->maxalign = 1;
-}
-
-
-/*
-** Read and classify next option. 'size' is filled with option's size.
-*/
-static KOption getoption (Header *h, const char **fmt, int *size) {
-  /* dummy structure to get native alignment requirements */
-  struct cD { char c; union { LUAI_MAXALIGN; } u; };
-  int opt = *((*fmt)++);
-  *size = 0;  /* default */
-  switch (opt) {
-    case 'b': *size = sizeof(char); return Kint;
-    case 'B': *size = sizeof(char); return Kuint;
-    case 'h': *size = sizeof(short); return Kint;
-    case 'H': *size = sizeof(short); return Kuint;
-    case 'l': *size = sizeof(long); return Kint;
-    case 'L': *size = sizeof(long); return Kuint;
-    case 'j': *size = sizeof(lua_Integer); return Kint;
-    case 'J': *size = sizeof(lua_Integer); return Kuint;
-    case 'T': *size = sizeof(size_t); return Kuint;
-    case 'f': *size = sizeof(float); return Kfloat;
-    case 'n': *size = sizeof(lua_Number); return Knumber;
-    case 'd': *size = sizeof(double); return Kdouble;
-    case 'i': *size = getnumlimit(h, fmt, sizeof(int)); return Kint;
-    case 'I': *size = getnumlimit(h, fmt, sizeof(int)); return Kuint;
-    case 's': *size = getnumlimit(h, fmt, sizeof(size_t)); return Kstring;
-    case 'c':
-      *size = getnum(fmt, -1);
-      if (l_unlikely(*size == -1))
-        luaL_error(h->L, "missing size for format option 'c'");
-      return Kchar;
-    case 'z': return Kzstr;
-    case 'x': *size = 1; return Kpadding;
-    case 'X': return Kpaddalign;
-    case ' ': break;
-    case '<': h->islittle = 1; break;
-    case '>': h->islittle = 0; break;
-    case '=': h->islittle = nativeendian.little; break;
-    case '!': {
-      const int maxalign = offsetof(struct cD, u);
-      h->maxalign = getnumlimit(h, fmt, maxalign);
-      break;
-    }
-    default: luaL_error(h->L, "invalid format option '%c'", opt);
-  }
-  return Knop;
-}
-
-
-/*
-** Read, classify, and fill other details about the next option.
-** 'psize' is filled with option's size, 'notoalign' with its
-** alignment requirements.
-** Local variable 'size' gets the size to be aligned. (Kpadal option
-** always gets its full alignment, other options are limited by
-** the maximum alignment ('maxalign'). Kchar option needs no alignment
-** despite its size.
-*/
-static KOption getdetails (Header *h, size_t totalsize,
-                           const char **fmt, int *psize, int *ntoalign) {
-  KOption opt = getoption(h, fmt, psize);
-  int align = *psize;  /* usually, alignment follows size */
-  if (opt == Kpaddalign) {  /* 'X' gets alignment from following option */
-    if (**fmt == '\0' || getoption(h, fmt, &align) == Kchar || align == 0)
-      luaL_argerror(h->L, 1, "invalid next option for option 'X'");
-  }
-  if (align <= 1 || opt == Kchar)  /* need no alignment? */
-    *ntoalign = 0;
-  else {
-    if (align > h->maxalign)  /* enforce maximum alignment */
-      align = h->maxalign;
-    if (l_unlikely((align & (align - 1)) != 0))  /* not a power of 2? */
-      luaL_argerror(h->L, 1, "format asks for alignment not power of 2");
-    *ntoalign = (align - (int)(totalsize & (align - 1))) & (align - 1);
-  }
-  return opt;
-}
-
-
-/*
-** Pack integer 'n' with 'size' bytes and 'islittle' endianness.
-** The final 'if' handles the case when 'size' is larger than
-** the size of a Lua integer, correcting the extra sign-extension
-** bytes if necessary (by default they would be zeros).
-*/
-static void packint (luaL_Buffer *b, lua_Unsigned n,
-                     int islittle, int size, int neg) {
-  char *buff = luaL_prepbuffsize(b, size);
-  int i;
-  buff[islittle ? 0 : size - 1] = (char)(n & MC);  /* first byte */
-  for (i = 1; i < size; i++) {
-    n >>= NB;
-    buff[islittle ? i : size - 1 - i] = (char)(n & MC);
-  }
-  if (neg && size > SZINT) {  /* negative number need sign extension? */
-    for (i = SZINT; i < size; i++)  /* correct extra bytes */
-      buff[islittle ? i : size - 1 - i] = (char)MC;
-  }
-  luaL_addsize(b, size);  /* add result to buffer */
-}
-
-
-/*
-** Copy 'size' bytes from 'src' to 'dest', correcting endianness if
-** given 'islittle' is different from native endianness.
-*/
-static void copywithendian (char *dest, const char *src,
-                            int size, int islittle) {
-  if (islittle == nativeendian.little)
-    memcpy(dest, src, size);
-  else {
-    dest += size - 1;
-    while (size-- != 0)
-      *(dest--) = *(src++);
-  }
-}
-
-
-static int str_pack (lua_State *L) {
-  luaL_Buffer b;
-  Header h;
-  const char *fmt = luaL_checkstring(L, 1);  /* format string */
-  int arg = 1;  /* current argument to pack */
-  size_t totalsize = 0;  /* accumulate total size of result */
-  initheader(L, &h);
-  lua_pushnil(L);  /* mark to separate arguments from string buffer */
-  luaL_buffinit(L, &b);
-  while (*fmt != '\0') {
-    int size, ntoalign;
-    KOption opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign);
-    totalsize += ntoalign + size;
-    while (ntoalign-- > 0)
-     luaL_addchar(&b, LUAL_PACKPADBYTE);  /* fill alignment */
-    arg++;
-    switch (opt) {
-      case Kint: {  /* signed integers */
-        lua_Integer n = luaL_checkinteger(L, arg);
-        if (size < SZINT) {  /* need overflow check? */
-          lua_Integer lim = (lua_Integer)1 << ((size * NB) - 1);
-          luaL_argcheck(L, -lim <= n && n < lim, arg, "integer overflow");
-        }
-        packint(&b, (lua_Unsigned)n, h.islittle, size, (n < 0));
-        break;
-      }
-      case Kuint: {  /* unsigned integers */
-        lua_Integer n = luaL_checkinteger(L, arg);
-        if (size < SZINT)  /* need overflow check? */
-          luaL_argcheck(L, (lua_Unsigned)n < ((lua_Unsigned)1 << (size * NB)),
-                           arg, "unsigned overflow");
-        packint(&b, (lua_Unsigned)n, h.islittle, size, 0);
-        break;
-      }
-      case Kfloat: {  /* C float */
-        float f = (float)luaL_checknumber(L, arg);  /* get argument */
-        char *buff = luaL_prepbuffsize(&b, sizeof(f));
-        /* move 'f' to final result, correcting endianness if needed */
-        copywithendian(buff, (char *)&f, sizeof(f), h.islittle);
-        luaL_addsize(&b, size);
-        break;
-      }
-      case Knumber: {  /* Lua float */
-        lua_Number f = luaL_checknumber(L, arg);  /* get argument */
-        char *buff = luaL_prepbuffsize(&b, sizeof(f));
-        /* move 'f' to final result, correcting endianness if needed */
-        copywithendian(buff, (char *)&f, sizeof(f), h.islittle);
-        luaL_addsize(&b, size);
-        break;
-      }
-      case Kdouble: {  /* C double */
-        double f = (double)luaL_checknumber(L, arg);  /* get argument */
-        char *buff = luaL_prepbuffsize(&b, sizeof(f));
-        /* move 'f' to final result, correcting endianness if needed */
-        copywithendian(buff, (char *)&f, sizeof(f), h.islittle);
-        luaL_addsize(&b, size);
-        break;
-      }
-      case Kchar: {  /* fixed-size string */
-        size_t len;
-        const char *s = luaL_checklstring(L, arg, &len);
-        luaL_argcheck(L, len <= (size_t)size, arg,
-                         "string longer than given size");
-        luaL_addlstring(&b, s, len);  /* add string */
-        while (len++ < (size_t)size)  /* pad extra space */
-          luaL_addchar(&b, LUAL_PACKPADBYTE);
-        break;
-      }
-      case Kstring: {  /* strings with length count */
-        size_t len;
-        const char *s = luaL_checklstring(L, arg, &len);
-        luaL_argcheck(L, size >= (int)sizeof(size_t) ||
-                         len < ((size_t)1 << (size * NB)),
-                         arg, "string length does not fit in given size");
-        packint(&b, (lua_Unsigned)len, h.islittle, size, 0);  /* pack length */
-        luaL_addlstring(&b, s, len);
-        totalsize += len;
-        break;
-      }
-      case Kzstr: {  /* zero-terminated string */
-        size_t len;
-        const char *s = luaL_checklstring(L, arg, &len);
-        luaL_argcheck(L, strlen(s) == len, arg, "string contains zeros");
-        luaL_addlstring(&b, s, len);
-        luaL_addchar(&b, '\0');  /* add zero at the end */
-        totalsize += len + 1;
-        break;
-      }
-      case Kpadding: luaL_addchar(&b, LUAL_PACKPADBYTE);  /* FALLTHROUGH */
-      case Kpaddalign: case Knop:
-        arg--;  /* undo increment */
-        break;
-    }
-  }
-  luaL_pushresult(&b);
-  return 1;
-}
-
-
-static int str_packsize (lua_State *L) {
-  Header h;
-  const char *fmt = luaL_checkstring(L, 1);  /* format string */
-  size_t totalsize = 0;  /* accumulate total size of result */
-  initheader(L, &h);
-  while (*fmt != '\0') {
-    int size, ntoalign;
-    KOption opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign);
-    luaL_argcheck(L, opt != Kstring && opt != Kzstr, 1,
-                     "variable-length format");
-    size += ntoalign;  /* total space used by option */
-    luaL_argcheck(L, totalsize <= MAXSIZE - size, 1,
-                     "format result too large");
-    totalsize += size;
-  }
-  lua_pushinteger(L, (lua_Integer)totalsize);
-  return 1;
-}
-
-
-/*
-** Unpack an integer with 'size' bytes and 'islittle' endianness.
-** If size is smaller than the size of a Lua integer and integer
-** is signed, must do sign extension (propagating the sign to the
-** higher bits); if size is larger than the size of a Lua integer,
-** it must check the unread bytes to see whether they do not cause an
-** overflow.
-*/
-static lua_Integer unpackint (lua_State *L, const char *str,
-                              int islittle, int size, int issigned) {
-  lua_Unsigned res = 0;
-  int i;
-  int limit = (size  <= SZINT) ? size : SZINT;
-  for (i = limit - 1; i >= 0; i--) {
-    res <<= NB;
-    res |= (lua_Unsigned)(unsigned char)str[islittle ? i : size - 1 - i];
-  }
-  if (size < SZINT) {  /* real size smaller than lua_Integer? */
-    if (issigned) {  /* needs sign extension? */
-      lua_Unsigned mask = (lua_Unsigned)1 << (size*NB - 1);
-      res = ((res ^ mask) - mask);  /* do sign extension */
-    }
-  }
-  else if (size > SZINT) {  /* must check unread bytes */
-    int mask = (!issigned || (lua_Integer)res >= 0) ? 0 : MC;
-    for (i = limit; i < size; i++) {
-      if (l_unlikely((unsigned char)str[islittle ? i : size - 1 - i] != mask))
-        luaL_error(L, "%d-byte integer does not fit into Lua Integer", size);
-    }
-  }
-  return (lua_Integer)res;
-}
-
-
-static int str_unpack (lua_State *L) {
-  Header h;
-  const char *fmt = luaL_checkstring(L, 1);
-  size_t ld;
-  const char *data = luaL_checklstring(L, 2, &ld);
-  size_t pos = posrelatI(luaL_optinteger(L, 3, 1), ld) - 1;
-  int n = 0;  /* number of results */
-  luaL_argcheck(L, pos <= ld, 3, "initial position out of string");
-  initheader(L, &h);
-  while (*fmt != '\0') {
-    int size, ntoalign;
-    KOption opt = getdetails(&h, pos, &fmt, &size, &ntoalign);
-    luaL_argcheck(L, (size_t)ntoalign + size <= ld - pos, 2,
-                    "data string too short");
-    pos += ntoalign;  /* skip alignment */
-    /* stack space for item + next position */
-    luaL_checkstack(L, 2, "too many results");
-    n++;
-    switch (opt) {
-      case Kint:
-      case Kuint: {
-        lua_Integer res = unpackint(L, data + pos, h.islittle, size,
-                                       (opt == Kint));
-        lua_pushinteger(L, res);
-        break;
-      }
-      case Kfloat: {
-        float f;
-        copywithendian((char *)&f, data + pos, sizeof(f), h.islittle);
-        lua_pushnumber(L, (lua_Number)f);
-        break;
-      }
-      case Knumber: {
-        lua_Number f;
-        copywithendian((char *)&f, data + pos, sizeof(f), h.islittle);
-        lua_pushnumber(L, f);
-        break;
-      }
-      case Kdouble: {
-        double f;
-        copywithendian((char *)&f, data + pos, sizeof(f), h.islittle);
-        lua_pushnumber(L, (lua_Number)f);
-        break;
-      }
-      case Kchar: {
-        lua_pushlstring(L, data + pos, size);
-        break;
-      }
-      case Kstring: {
-        size_t len = (size_t)unpackint(L, data + pos, h.islittle, size, 0);
-        luaL_argcheck(L, len <= ld - pos - size, 2, "data string too short");
-        lua_pushlstring(L, data + pos + size, len);
-        pos += len;  /* skip string */
-        break;
-      }
-      case Kzstr: {
-        size_t len = strlen(data + pos);
-        luaL_argcheck(L, pos + len < ld, 2,
-                         "unfinished string for format 'z'");
-        lua_pushlstring(L, data + pos, len);
-        pos += len + 1;  /* skip string plus final '\0' */
-        break;
-      }
-      case Kpaddalign: case Kpadding: case Knop:
-        n--;  /* undo increment */
-        break;
-    }
-    pos += size;
-  }
-  lua_pushinteger(L, pos + 1);  /* next position */
-  return n + 1;
-}
-
-/* }====================================================== */
-
-
-static const luaL_Reg strlib[] = {
-  {"byte", str_byte},
-  {"char", str_char},
-  {"dump", str_dump},
-  {"find", str_find},
-  {"format", str_format},
-  {"gmatch", gmatch},
-  {"gsub", str_gsub},
-  {"len", str_len},
-  {"lower", str_lower},
-  {"match", str_match},
-  {"rep", str_rep},
-  {"reverse", str_reverse},
-  {"sub", str_sub},
-  {"upper", str_upper},
-  {"pack", str_pack},
-  {"packsize", str_packsize},
-  {"unpack", str_unpack},
-  {NULL, NULL}
-};
-
-
-static void createmetatable (lua_State *L) {
-  /* table to be metatable for strings */
-  luaL_newlibtable(L, stringmetamethods);
-  luaL_setfuncs(L, stringmetamethods, 0);
-  lua_pushliteral(L, "");  /* dummy string */
-  lua_pushvalue(L, -2);  /* copy table */
-  lua_setmetatable(L, -2);  /* set table as metatable for strings */
-  lua_pop(L, 1);  /* pop dummy string */
-  lua_pushvalue(L, -2);  /* get string library */
-  lua_setfield(L, -2, "__index");  /* metatable.__index = string */
-  lua_pop(L, 1);  /* pop metatable */
-}
-
-
-/*
-** Open string library
-*/
-LUAMOD_API int luaopen_string (lua_State *L) {
-  luaL_newlib(L, strlib);
-  createmetatable(L);
-  return 1;
-}
-
diff --git a/third-party/lua/src/ltable.c b/third-party/lua/src/ltable.c
deleted file mode 100644
index 3c690c5f1..000000000
--- a/third-party/lua/src/ltable.c
+++ /dev/null
@@ -1,980 +0,0 @@
-/*
-** $Id: ltable.c $
-** Lua tables (hash)
-** See Copyright Notice in lua.h
-*/
-
-#define ltable_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-/*
-** Implementation of tables (aka arrays, objects, or hash tables).
-** Tables keep its elements in two parts: an array part and a hash part.
-** Non-negative integer keys are all candidates to be kept in the array
-** part. The actual size of the array is the largest 'n' such that
-** more than half the slots between 1 and n are in use.
-** Hash uses a mix of chained scatter table with Brent's variation.
-** A main invariant of these tables is that, if an element is not
-** in its main position (i.e. the 'original' position that its hash gives
-** to it), then the colliding element is in its own main position.
-** Hence even when the load factor reaches 100%, performance remains good.
-*/
-
-#include <math.h>
-#include <limits.h>
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lgc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "lvm.h"
-
-
-/*
-** MAXABITS is the largest integer such that MAXASIZE fits in an
-** unsigned int.
-*/
-#define MAXABITS	cast_int(sizeof(int) * CHAR_BIT - 1)
-
-
-/*
-** MAXASIZE is the maximum size of the array part. It is the minimum
-** between 2^MAXABITS and the maximum size that, measured in bytes,
-** fits in a 'size_t'.
-*/
-#define MAXASIZE	luaM_limitN(1u << MAXABITS, TValue)
-
-/*
-** MAXHBITS is the largest integer such that 2^MAXHBITS fits in a
-** signed int.
-*/
-#define MAXHBITS	(MAXABITS - 1)
-
-
-/*
-** MAXHSIZE is the maximum size of the hash part. It is the minimum
-** between 2^MAXHBITS and the maximum size such that, measured in bytes,
-** it fits in a 'size_t'.
-*/
-#define MAXHSIZE	luaM_limitN(1u << MAXHBITS, Node)
-
-
-/*
-** When the original hash value is good, hashing by a power of 2
-** avoids the cost of '%'.
-*/
-#define hashpow2(t,n)		(gnode(t, lmod((n), sizenode(t))))
-
-/*
-** for other types, it is better to avoid modulo by power of 2, as
-** they can have many 2 factors.
-*/
-#define hashmod(t,n)	(gnode(t, ((n) % ((sizenode(t)-1)|1))))
-
-
-#define hashstr(t,str)		hashpow2(t, (str)->hash)
-#define hashboolean(t,p)	hashpow2(t, p)
-
-
-#define hashpointer(t,p)	hashmod(t, point2uint(p))
-
-
-#define dummynode		(&dummynode_)
-
-static const Node dummynode_ = {
-  {{NULL}, LUA_VEMPTY,  /* value's value and type */
-   LUA_VNIL, 0, {NULL}}  /* key type, next, and key value */
-};
-
-
-static const TValue absentkey = {ABSTKEYCONSTANT};
-
-
-/*
-** Hash for integers. To allow a good hash, use the remainder operator
-** ('%'). If integer fits as a non-negative int, compute an int
-** remainder, which is faster. Otherwise, use an unsigned-integer
-** remainder, which uses all bits and ensures a non-negative result.
-*/
-static Node *hashint (const Table *t, lua_Integer i) {
-  lua_Unsigned ui = l_castS2U(i);
-  if (ui <= cast_uint(INT_MAX))
-    return hashmod(t, cast_int(ui));
-  else
-    return hashmod(t, ui);
-}
-
-
-/*
-** Hash for floating-point numbers.
-** The main computation should be just
-**     n = frexp(n, &i); return (n * INT_MAX) + i
-** but there are some numerical subtleties.
-** In a two-complement representation, INT_MAX does not has an exact
-** representation as a float, but INT_MIN does; because the absolute
-** value of 'frexp' is smaller than 1 (unless 'n' is inf/NaN), the
-** absolute value of the product 'frexp * -INT_MIN' is smaller or equal
-** to INT_MAX. Next, the use of 'unsigned int' avoids overflows when
-** adding 'i'; the use of '~u' (instead of '-u') avoids problems with
-** INT_MIN.
-*/
-#if !defined(l_hashfloat)
-static int l_hashfloat (lua_Number n) {
-  int i;
-  lua_Integer ni;
-  n = l_mathop(frexp)(n, &i) * -cast_num(INT_MIN);
-  if (!lua_numbertointeger(n, &ni)) {  /* is 'n' inf/-inf/NaN? */
-    lua_assert(luai_numisnan(n) || l_mathop(fabs)(n) == cast_num(HUGE_VAL));
-    return 0;
-  }
-  else {  /* normal case */
-    unsigned int u = cast_uint(i) + cast_uint(ni);
-    return cast_int(u <= cast_uint(INT_MAX) ? u : ~u);
-  }
-}
-#endif
-
-
-/*
-** returns the 'main' position of an element in a table (that is,
-** the index of its hash value).
-*/
-static Node *mainpositionTV (const Table *t, const TValue *key) {
-  switch (ttypetag(key)) {
-    case LUA_VNUMINT: {
-      lua_Integer i = ivalue(key);
-      return hashint(t, i);
-    }
-    case LUA_VNUMFLT: {
-      lua_Number n = fltvalue(key);
-      return hashmod(t, l_hashfloat(n));
-    }
-    case LUA_VSHRSTR: {
-      TString *ts = tsvalue(key);
-      return hashstr(t, ts);
-    }
-    case LUA_VLNGSTR: {
-      TString *ts = tsvalue(key);
-      return hashpow2(t, luaS_hashlongstr(ts));
-    }
-    case LUA_VFALSE:
-      return hashboolean(t, 0);
-    case LUA_VTRUE:
-      return hashboolean(t, 1);
-    case LUA_VLIGHTUSERDATA: {
-      void *p = pvalue(key);
-      return hashpointer(t, p);
-    }
-    case LUA_VLCF: {
-      lua_CFunction f = fvalue(key);
-      return hashpointer(t, f);
-    }
-    default: {
-      GCObject *o = gcvalue(key);
-      return hashpointer(t, o);
-    }
-  }
-}
-
-
-l_sinline Node *mainpositionfromnode (const Table *t, Node *nd) {
-  TValue key;
-  getnodekey(cast(lua_State *, NULL), &key, nd);
-  return mainpositionTV(t, &key);
-}
-
-
-/*
-** Check whether key 'k1' is equal to the key in node 'n2'. This
-** equality is raw, so there are no metamethods. Floats with integer
-** values have been normalized, so integers cannot be equal to
-** floats. It is assumed that 'eqshrstr' is simply pointer equality, so
-** that short strings are handled in the default case.
-** A true 'deadok' means to accept dead keys as equal to their original
-** values. All dead keys are compared in the default case, by pointer
-** identity. (Only collectable objects can produce dead keys.) Note that
-** dead long strings are also compared by identity.
-** Once a key is dead, its corresponding value may be collected, and
-** then another value can be created with the same address. If this
-** other value is given to 'next', 'equalkey' will signal a false
-** positive. In a regular traversal, this situation should never happen,
-** as all keys given to 'next' came from the table itself, and therefore
-** could not have been collected. Outside a regular traversal, we
-** have garbage in, garbage out. What is relevant is that this false
-** positive does not break anything.  (In particular, 'next' will return
-** some other valid item on the table or nil.)
-*/
-static int equalkey (const TValue *k1, const Node *n2, int deadok) {
-  if ((rawtt(k1) != keytt(n2)) &&  /* not the same variants? */
-       !(deadok && keyisdead(n2) && iscollectable(k1)))
-   return 0;  /* cannot be same key */
-  switch (keytt(n2)) {
-    case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE:
-      return 1;
-    case LUA_VNUMINT:
-      return (ivalue(k1) == keyival(n2));
-    case LUA_VNUMFLT:
-      return luai_numeq(fltvalue(k1), fltvalueraw(keyval(n2)));
-    case LUA_VLIGHTUSERDATA:
-      return pvalue(k1) == pvalueraw(keyval(n2));
-    case LUA_VLCF:
-      return fvalue(k1) == fvalueraw(keyval(n2));
-    case ctb(LUA_VLNGSTR):
-      return luaS_eqlngstr(tsvalue(k1), keystrval(n2));
-    default:
-      return gcvalue(k1) == gcvalueraw(keyval(n2));
-  }
-}
-
-
-/*
-** True if value of 'alimit' is equal to the real size of the array
-** part of table 't'. (Otherwise, the array part must be larger than
-** 'alimit'.)
-*/
-#define limitequalsasize(t)	(isrealasize(t) || ispow2((t)->alimit))
-
-
-/*
-** Returns the real size of the 'array' array
-*/
-LUAI_FUNC unsigned int luaH_realasize (const Table *t) {
-  if (limitequalsasize(t))
-    return t->alimit;  /* this is the size */
-  else {
-    unsigned int size = t->alimit;
-    /* compute the smallest power of 2 not smaller than 'n' */
-    size |= (size >> 1);
-    size |= (size >> 2);
-    size |= (size >> 4);
-    size |= (size >> 8);
-#if (UINT_MAX >> 14) > 3  /* unsigned int has more than 16 bits */
-    size |= (size >> 16);
-#if (UINT_MAX >> 30) > 3
-    size |= (size >> 32);  /* unsigned int has more than 32 bits */
-#endif
-#endif
-    size++;
-    lua_assert(ispow2(size) && size/2 < t->alimit && t->alimit < size);
-    return size;
-  }
-}
-
-
-/*
-** Check whether real size of the array is a power of 2.
-** (If it is not, 'alimit' cannot be changed to any other value
-** without changing the real size.)
-*/
-static int ispow2realasize (const Table *t) {
-  return (!isrealasize(t) || ispow2(t->alimit));
-}
-
-
-static unsigned int setlimittosize (Table *t) {
-  t->alimit = luaH_realasize(t);
-  setrealasize(t);
-  return t->alimit;
-}
-
-
-#define limitasasize(t)	check_exp(isrealasize(t), t->alimit)
-
-
-
-/*
-** "Generic" get version. (Not that generic: not valid for integers,
-** which may be in array part, nor for floats with integral values.)
-** See explanation about 'deadok' in function 'equalkey'.
-*/
-static const TValue *getgeneric (Table *t, const TValue *key, int deadok) {
-  Node *n = mainpositionTV(t, key);
-  for (;;) {  /* check whether 'key' is somewhere in the chain */
-    if (equalkey(key, n, deadok))
-      return gval(n);  /* that's it */
-    else {
-      int nx = gnext(n);
-      if (nx == 0)
-        return &absentkey;  /* not found */
-      n += nx;
-    }
-  }
-}
-
-
-/*
-** returns the index for 'k' if 'k' is an appropriate key to live in
-** the array part of a table, 0 otherwise.
-*/
-static unsigned int arrayindex (lua_Integer k) {
-  if (l_castS2U(k) - 1u < MAXASIZE)  /* 'k' in [1, MAXASIZE]? */
-    return cast_uint(k);  /* 'key' is an appropriate array index */
-  else
-    return 0;
-}
-
-
-/*
-** returns the index of a 'key' for table traversals. First goes all
-** elements in the array part, then elements in the hash part. The
-** beginning of a traversal is signaled by 0.
-*/
-static unsigned int findindex (lua_State *L, Table *t, TValue *key,
-                               unsigned int asize) {
-  unsigned int i;
-  if (ttisnil(key)) return 0;  /* first iteration */
-  i = ttisinteger(key) ? arrayindex(ivalue(key)) : 0;
-  if (i - 1u < asize)  /* is 'key' inside array part? */
-    return i;  /* yes; that's the index */
-  else {
-    const TValue *n = getgeneric(t, key, 1);
-    if (l_unlikely(isabstkey(n)))
-      luaG_runerror(L, "invalid key to 'next'");  /* key not found */
-    i = cast_int(nodefromval(n) - gnode(t, 0));  /* key index in hash table */
-    /* hash elements are numbered after array ones */
-    return (i + 1) + asize;
-  }
-}
-
-
-int luaH_next (lua_State *L, Table *t, StkId key) {
-  unsigned int asize = luaH_realasize(t);
-  unsigned int i = findindex(L, t, s2v(key), asize);  /* find original key */
-  for (; i < asize; i++) {  /* try first array part */
-    if (!isempty(&t->array[i])) {  /* a non-empty entry? */
-      setivalue(s2v(key), i + 1);
-      setobj2s(L, key + 1, &t->array[i]);
-      return 1;
-    }
-  }
-  for (i -= asize; cast_int(i) < sizenode(t); i++) {  /* hash part */
-    if (!isempty(gval(gnode(t, i)))) {  /* a non-empty entry? */
-      Node *n = gnode(t, i);
-      getnodekey(L, s2v(key), n);
-      setobj2s(L, key + 1, gval(n));
-      return 1;
-    }
-  }
-  return 0;  /* no more elements */
-}
-
-
-static void freehash (lua_State *L, Table *t) {
-  if (!isdummy(t))
-    luaM_freearray(L, t->node, cast_sizet(sizenode(t)));
-}
-
-
-/*
-** {=============================================================
-** Rehash
-** ==============================================================
-*/
-
-/*
-** Compute the optimal size for the array part of table 't'. 'nums' is a
-** "count array" where 'nums[i]' is the number of integers in the table
-** between 2^(i - 1) + 1 and 2^i. 'pna' enters with the total number of
-** integer keys in the table and leaves with the number of keys that
-** will go to the array part; return the optimal size.  (The condition
-** 'twotoi > 0' in the for loop stops the loop if 'twotoi' overflows.)
-*/
-static unsigned int computesizes (unsigned int nums[], unsigned int *pna) {
-  int i;
-  unsigned int twotoi;  /* 2^i (candidate for optimal size) */
-  unsigned int a = 0;  /* number of elements smaller than 2^i */
-  unsigned int na = 0;  /* number of elements to go to array part */
-  unsigned int optimal = 0;  /* optimal size for array part */
-  /* loop while keys can fill more than half of total size */
-  for (i = 0, twotoi = 1;
-       twotoi > 0 && *pna > twotoi / 2;
-       i++, twotoi *= 2) {
-    a += nums[i];
-    if (a > twotoi/2) {  /* more than half elements present? */
-      optimal = twotoi;  /* optimal size (till now) */
-      na = a;  /* all elements up to 'optimal' will go to array part */
-    }
-  }
-  lua_assert((optimal == 0 || optimal / 2 < na) && na <= optimal);
-  *pna = na;
-  return optimal;
-}
-
-
-static int countint (lua_Integer key, unsigned int *nums) {
-  unsigned int k = arrayindex(key);
-  if (k != 0) {  /* is 'key' an appropriate array index? */
-    nums[luaO_ceillog2(k)]++;  /* count as such */
-    return 1;
-  }
-  else
-    return 0;
-}
-
-
-/*
-** Count keys in array part of table 't': Fill 'nums[i]' with
-** number of keys that will go into corresponding slice and return
-** total number of non-nil keys.
-*/
-static unsigned int numusearray (const Table *t, unsigned int *nums) {
-  int lg;
-  unsigned int ttlg;  /* 2^lg */
-  unsigned int ause = 0;  /* summation of 'nums' */
-  unsigned int i = 1;  /* count to traverse all array keys */
-  unsigned int asize = limitasasize(t);  /* real array size */
-  /* traverse each slice */
-  for (lg = 0, ttlg = 1; lg <= MAXABITS; lg++, ttlg *= 2) {
-    unsigned int lc = 0;  /* counter */
-    unsigned int lim = ttlg;
-    if (lim > asize) {
-      lim = asize;  /* adjust upper limit */
-      if (i > lim)
-        break;  /* no more elements to count */
-    }
-    /* count elements in range (2^(lg - 1), 2^lg] */
-    for (; i <= lim; i++) {
-      if (!isempty(&t->array[i-1]))
-        lc++;
-    }
-    nums[lg] += lc;
-    ause += lc;
-  }
-  return ause;
-}
-
-
-static int numusehash (const Table *t, unsigned int *nums, unsigned int *pna) {
-  int totaluse = 0;  /* total number of elements */
-  int ause = 0;  /* elements added to 'nums' (can go to array part) */
-  int i = sizenode(t);
-  while (i--) {
-    Node *n = &t->node[i];
-    if (!isempty(gval(n))) {
-      if (keyisinteger(n))
-        ause += countint(keyival(n), nums);
-      totaluse++;
-    }
-  }
-  *pna += ause;
-  return totaluse;
-}
-
-
-/*
-** Creates an array for the hash part of a table with the given
-** size, or reuses the dummy node if size is zero.
-** The computation for size overflow is in two steps: the first
-** comparison ensures that the shift in the second one does not
-** overflow.
-*/
-static void setnodevector (lua_State *L, Table *t, unsigned int size) {
-  if (size == 0) {  /* no elements to hash part? */
-    t->node = cast(Node *, dummynode);  /* use common 'dummynode' */
-    t->lsizenode = 0;
-    t->lastfree = NULL;  /* signal that it is using dummy node */
-  }
-  else {
-    int i;
-    int lsize = luaO_ceillog2(size);
-    if (lsize > MAXHBITS || (1u << lsize) > MAXHSIZE)
-      luaG_runerror(L, "table overflow");
-    size = twoto(lsize);
-    t->node = luaM_newvector(L, size, Node);
-    for (i = 0; i < cast_int(size); i++) {
-      Node *n = gnode(t, i);
-      gnext(n) = 0;
-      setnilkey(n);
-      setempty(gval(n));
-    }
-    t->lsizenode = cast_byte(lsize);
-    t->lastfree = gnode(t, size);  /* all positions are free */
-  }
-}
-
-
-/*
-** (Re)insert all elements from the hash part of 'ot' into table 't'.
-*/
-static void reinsert (lua_State *L, Table *ot, Table *t) {
-  int j;
-  int size = sizenode(ot);
-  for (j = 0; j < size; j++) {
-    Node *old = gnode(ot, j);
-    if (!isempty(gval(old))) {
-      /* doesn't need barrier/invalidate cache, as entry was
-         already present in the table */
-      TValue k;
-      getnodekey(L, &k, old);
-      luaH_set(L, t, &k, gval(old));
-    }
-  }
-}
-
-
-/*
-** Exchange the hash part of 't1' and 't2'.
-*/
-static void exchangehashpart (Table *t1, Table *t2) {
-  lu_byte lsizenode = t1->lsizenode;
-  Node *node = t1->node;
-  Node *lastfree = t1->lastfree;
-  t1->lsizenode = t2->lsizenode;
-  t1->node = t2->node;
-  t1->lastfree = t2->lastfree;
-  t2->lsizenode = lsizenode;
-  t2->node = node;
-  t2->lastfree = lastfree;
-}
-
-
-/*
-** Resize table 't' for the new given sizes. Both allocations (for
-** the hash part and for the array part) can fail, which creates some
-** subtleties. If the first allocation, for the hash part, fails, an
-** error is raised and that is it. Otherwise, it copies the elements from
-** the shrinking part of the array (if it is shrinking) into the new
-** hash. Then it reallocates the array part.  If that fails, the table
-** is in its original state; the function frees the new hash part and then
-** raises the allocation error. Otherwise, it sets the new hash part
-** into the table, initializes the new part of the array (if any) with
-** nils and reinserts the elements of the old hash back into the new
-** parts of the table.
-*/
-void luaH_resize (lua_State *L, Table *t, unsigned int newasize,
-                                          unsigned int nhsize) {
-  unsigned int i;
-  Table newt;  /* to keep the new hash part */
-  unsigned int oldasize = setlimittosize(t);
-  TValue *newarray;
-  /* create new hash part with appropriate size into 'newt' */
-  setnodevector(L, &newt, nhsize);
-  if (newasize < oldasize) {  /* will array shrink? */
-    t->alimit = newasize;  /* pretend array has new size... */
-    exchangehashpart(t, &newt);  /* and new hash */
-    /* re-insert into the new hash the elements from vanishing slice */
-    for (i = newasize; i < oldasize; i++) {
-      if (!isempty(&t->array[i]))
-        luaH_setint(L, t, i + 1, &t->array[i]);
-    }
-    t->alimit = oldasize;  /* restore current size... */
-    exchangehashpart(t, &newt);  /* and hash (in case of errors) */
-  }
-  /* allocate new array */
-  newarray = luaM_reallocvector(L, t->array, oldasize, newasize, TValue);
-  if (l_unlikely(newarray == NULL && newasize > 0)) {  /* allocation failed? */
-    freehash(L, &newt);  /* release new hash part */
-    luaM_error(L);  /* raise error (with array unchanged) */
-  }
-  /* allocation ok; initialize new part of the array */
-  exchangehashpart(t, &newt);  /* 't' has the new hash ('newt' has the old) */
-  t->array = newarray;  /* set new array part */
-  t->alimit = newasize;
-  for (i = oldasize; i < newasize; i++)  /* clear new slice of the array */
-     setempty(&t->array[i]);
-  /* re-insert elements from old hash part into new parts */
-  reinsert(L, &newt, t);  /* 'newt' now has the old hash */
-  freehash(L, &newt);  /* free old hash part */
-}
-
-
-void luaH_resizearray (lua_State *L, Table *t, unsigned int nasize) {
-  int nsize = allocsizenode(t);
-  luaH_resize(L, t, nasize, nsize);
-}
-
-/*
-** nums[i] = number of keys 'k' where 2^(i - 1) < k <= 2^i
-*/
-static void rehash (lua_State *L, Table *t, const TValue *ek) {
-  unsigned int asize;  /* optimal size for array part */
-  unsigned int na;  /* number of keys in the array part */
-  unsigned int nums[MAXABITS + 1];
-  int i;
-  int totaluse;
-  for (i = 0; i <= MAXABITS; i++) nums[i] = 0;  /* reset counts */
-  setlimittosize(t);
-  na = numusearray(t, nums);  /* count keys in array part */
-  totaluse = na;  /* all those keys are integer keys */
-  totaluse += numusehash(t, nums, &na);  /* count keys in hash part */
-  /* count extra key */
-  if (ttisinteger(ek))
-    na += countint(ivalue(ek), nums);
-  totaluse++;
-  /* compute new size for array part */
-  asize = computesizes(nums, &na);
-  /* resize the table to new computed sizes */
-  luaH_resize(L, t, asize, totaluse - na);
-}
-
-
-
-/*
-** }=============================================================
-*/
-
-
-Table *luaH_new (lua_State *L) {
-  GCObject *o = luaC_newobj(L, LUA_VTABLE, sizeof(Table));
-  Table *t = gco2t(o);
-  t->metatable = NULL;
-  t->flags = cast_byte(maskflags);  /* table has no metamethod fields */
-  t->array = NULL;
-  t->alimit = 0;
-  setnodevector(L, t, 0);
-  return t;
-}
-
-
-void luaH_free (lua_State *L, Table *t) {
-  freehash(L, t);
-  luaM_freearray(L, t->array, luaH_realasize(t));
-  luaM_free(L, t);
-}
-
-
-static Node *getfreepos (Table *t) {
-  if (!isdummy(t)) {
-    while (t->lastfree > t->node) {
-      t->lastfree--;
-      if (keyisnil(t->lastfree))
-        return t->lastfree;
-    }
-  }
-  return NULL;  /* could not find a free place */
-}
-
-
-
-/*
-** inserts a new key into a hash table; first, check whether key's main
-** position is free. If not, check whether colliding node is in its main
-** position or not: if it is not, move colliding node to an empty place and
-** put new key in its main position; otherwise (colliding node is in its main
-** position), new key goes to an empty position.
-*/
-void luaH_newkey (lua_State *L, Table *t, const TValue *key, TValue *value) {
-  Node *mp;
-  TValue aux;
-  if (l_unlikely(ttisnil(key)))
-    luaG_runerror(L, "table index is nil");
-  else if (ttisfloat(key)) {
-    lua_Number f = fltvalue(key);
-    lua_Integer k;
-    if (luaV_flttointeger(f, &k, F2Ieq)) {  /* does key fit in an integer? */
-      setivalue(&aux, k);
-      key = &aux;  /* insert it as an integer */
-    }
-    else if (l_unlikely(luai_numisnan(f)))
-      luaG_runerror(L, "table index is NaN");
-  }
-  if (ttisnil(value))
-    return;  /* do not insert nil values */
-  mp = mainpositionTV(t, key);
-  if (!isempty(gval(mp)) || isdummy(t)) {  /* main position is taken? */
-    Node *othern;
-    Node *f = getfreepos(t);  /* get a free place */
-    if (f == NULL) {  /* cannot find a free place? */
-      rehash(L, t, key);  /* grow table */
-      /* whatever called 'newkey' takes care of TM cache */
-      luaH_set(L, t, key, value);  /* insert key into grown table */
-      return;
-    }
-    lua_assert(!isdummy(t));
-    othern = mainpositionfromnode(t, mp);
-    if (othern != mp) {  /* is colliding node out of its main position? */
-      /* yes; move colliding node into free position */
-      while (othern + gnext(othern) != mp)  /* find previous */
-        othern += gnext(othern);
-      gnext(othern) = cast_int(f - othern);  /* rechain to point to 'f' */
-      *f = *mp;  /* copy colliding node into free pos. (mp->next also goes) */
-      if (gnext(mp) != 0) {
-        gnext(f) += cast_int(mp - f);  /* correct 'next' */
-        gnext(mp) = 0;  /* now 'mp' is free */
-      }
-      setempty(gval(mp));
-    }
-    else {  /* colliding node is in its own main position */
-      /* new node will go into free position */
-      if (gnext(mp) != 0)
-        gnext(f) = cast_int((mp + gnext(mp)) - f);  /* chain new position */
-      else lua_assert(gnext(f) == 0);
-      gnext(mp) = cast_int(f - mp);
-      mp = f;
-    }
-  }
-  setnodekey(L, mp, key);
-  luaC_barrierback(L, obj2gco(t), key);
-  lua_assert(isempty(gval(mp)));
-  setobj2t(L, gval(mp), value);
-}
-
-
-/*
-** Search function for integers. If integer is inside 'alimit', get it
-** directly from the array part. Otherwise, if 'alimit' is not equal to
-** the real size of the array, key still can be in the array part. In
-** this case, try to avoid a call to 'luaH_realasize' when key is just
-** one more than the limit (so that it can be incremented without
-** changing the real size of the array).
-*/
-const TValue *luaH_getint (Table *t, lua_Integer key) {
-  if (l_castS2U(key) - 1u < t->alimit)  /* 'key' in [1, t->alimit]? */
-    return &t->array[key - 1];
-  else if (!limitequalsasize(t) &&  /* key still may be in the array part? */
-           (l_castS2U(key) == t->alimit + 1 ||
-            l_castS2U(key) - 1u < luaH_realasize(t))) {
-    t->alimit = cast_uint(key);  /* probably '#t' is here now */
-    return &t->array[key - 1];
-  }
-  else {
-    Node *n = hashint(t, key);
-    for (;;) {  /* check whether 'key' is somewhere in the chain */
-      if (keyisinteger(n) && keyival(n) == key)
-        return gval(n);  /* that's it */
-      else {
-        int nx = gnext(n);
-        if (nx == 0) break;
-        n += nx;
-      }
-    }
-    return &absentkey;
-  }
-}
-
-
-/*
-** search function for short strings
-*/
-const TValue *luaH_getshortstr (Table *t, TString *key) {
-  Node *n = hashstr(t, key);
-  lua_assert(key->tt == LUA_VSHRSTR);
-  for (;;) {  /* check whether 'key' is somewhere in the chain */
-    if (keyisshrstr(n) && eqshrstr(keystrval(n), key))
-      return gval(n);  /* that's it */
-    else {
-      int nx = gnext(n);
-      if (nx == 0)
-        return &absentkey;  /* not found */
-      n += nx;
-    }
-  }
-}
-
-
-const TValue *luaH_getstr (Table *t, TString *key) {
-  if (key->tt == LUA_VSHRSTR)
-    return luaH_getshortstr(t, key);
-  else {  /* for long strings, use generic case */
-    TValue ko;
-    setsvalue(cast(lua_State *, NULL), &ko, key);
-    return getgeneric(t, &ko, 0);
-  }
-}
-
-
-/*
-** main search function
-*/
-const TValue *luaH_get (Table *t, const TValue *key) {
-  switch (ttypetag(key)) {
-    case LUA_VSHRSTR: return luaH_getshortstr(t, tsvalue(key));
-    case LUA_VNUMINT: return luaH_getint(t, ivalue(key));
-    case LUA_VNIL: return &absentkey;
-    case LUA_VNUMFLT: {
-      lua_Integer k;
-      if (luaV_flttointeger(fltvalue(key), &k, F2Ieq)) /* integral index? */
-        return luaH_getint(t, k);  /* use specialized version */
-      /* else... */
-    }  /* FALLTHROUGH */
-    default:
-      return getgeneric(t, key, 0);
-  }
-}
-
-
-/*
-** Finish a raw "set table" operation, where 'slot' is where the value
-** should have been (the result of a previous "get table").
-** Beware: when using this function you probably need to check a GC
-** barrier and invalidate the TM cache.
-*/
-void luaH_finishset (lua_State *L, Table *t, const TValue *key,
-                                   const TValue *slot, TValue *value) {
-  if (isabstkey(slot))
-    luaH_newkey(L, t, key, value);
-  else
-    setobj2t(L, cast(TValue *, slot), value);
-}
-
-
-/*
-** beware: when using this function you probably need to check a GC
-** barrier and invalidate the TM cache.
-*/
-void luaH_set (lua_State *L, Table *t, const TValue *key, TValue *value) {
-  const TValue *slot = luaH_get(t, key);
-  luaH_finishset(L, t, key, slot, value);
-}
-
-
-void luaH_setint (lua_State *L, Table *t, lua_Integer key, TValue *value) {
-  const TValue *p = luaH_getint(t, key);
-  if (isabstkey(p)) {
-    TValue k;
-    setivalue(&k, key);
-    luaH_newkey(L, t, &k, value);
-  }
-  else
-    setobj2t(L, cast(TValue *, p), value);
-}
-
-
-/*
-** Try to find a boundary in the hash part of table 't'. From the
-** caller, we know that 'j' is zero or present and that 'j + 1' is
-** present. We want to find a larger key that is absent from the
-** table, so that we can do a binary search between the two keys to
-** find a boundary. We keep doubling 'j' until we get an absent index.
-** If the doubling would overflow, we try LUA_MAXINTEGER. If it is
-** absent, we are ready for the binary search. ('j', being max integer,
-** is larger or equal to 'i', but it cannot be equal because it is
-** absent while 'i' is present; so 'j > i'.) Otherwise, 'j' is a
-** boundary. ('j + 1' cannot be a present integer key because it is
-** not a valid integer in Lua.)
-*/
-static lua_Unsigned hash_search (Table *t, lua_Unsigned j) {
-  lua_Unsigned i;
-  if (j == 0) j++;  /* the caller ensures 'j + 1' is present */
-  do {
-    i = j;  /* 'i' is a present index */
-    if (j <= l_castS2U(LUA_MAXINTEGER) / 2)
-      j *= 2;
-    else {
-      j = LUA_MAXINTEGER;
-      if (isempty(luaH_getint(t, j)))  /* t[j] not present? */
-        break;  /* 'j' now is an absent index */
-      else  /* weird case */
-        return j;  /* well, max integer is a boundary... */
-    }
-  } while (!isempty(luaH_getint(t, j)));  /* repeat until an absent t[j] */
-  /* i < j  &&  t[i] present  &&  t[j] absent */
-  while (j - i > 1u) {  /* do a binary search between them */
-    lua_Unsigned m = (i + j) / 2;
-    if (isempty(luaH_getint(t, m))) j = m;
-    else i = m;
-  }
-  return i;
-}
-
-
-static unsigned int binsearch (const TValue *array, unsigned int i,
-                                                    unsigned int j) {
-  while (j - i > 1u) {  /* binary search */
-    unsigned int m = (i + j) / 2;
-    if (isempty(&array[m - 1])) j = m;
-    else i = m;
-  }
-  return i;
-}
-
-
-/*
-** Try to find a boundary in table 't'. (A 'boundary' is an integer index
-** such that t[i] is present and t[i+1] is absent, or 0 if t[1] is absent
-** and 'maxinteger' if t[maxinteger] is present.)
-** (In the next explanation, we use Lua indices, that is, with base 1.
-** The code itself uses base 0 when indexing the array part of the table.)
-** The code starts with 'limit = t->alimit', a position in the array
-** part that may be a boundary.
-**
-** (1) If 't[limit]' is empty, there must be a boundary before it.
-** As a common case (e.g., after 't[#t]=nil'), check whether 'limit-1'
-** is present. If so, it is a boundary. Otherwise, do a binary search
-** between 0 and limit to find a boundary. In both cases, try to
-** use this boundary as the new 'alimit', as a hint for the next call.
-**
-** (2) If 't[limit]' is not empty and the array has more elements
-** after 'limit', try to find a boundary there. Again, try first
-** the special case (which should be quite frequent) where 'limit+1'
-** is empty, so that 'limit' is a boundary. Otherwise, check the
-** last element of the array part. If it is empty, there must be a
-** boundary between the old limit (present) and the last element
-** (absent), which is found with a binary search. (This boundary always
-** can be a new limit.)
-**
-** (3) The last case is when there are no elements in the array part
-** (limit == 0) or its last element (the new limit) is present.
-** In this case, must check the hash part. If there is no hash part
-** or 'limit+1' is absent, 'limit' is a boundary.  Otherwise, call
-** 'hash_search' to find a boundary in the hash part of the table.
-** (In those cases, the boundary is not inside the array part, and
-** therefore cannot be used as a new limit.)
-*/
-lua_Unsigned luaH_getn (Table *t) {
-  unsigned int limit = t->alimit;
-  if (limit > 0 && isempty(&t->array[limit - 1])) {  /* (1)? */
-    /* there must be a boundary before 'limit' */
-    if (limit >= 2 && !isempty(&t->array[limit - 2])) {
-      /* 'limit - 1' is a boundary; can it be a new limit? */
-      if (ispow2realasize(t) && !ispow2(limit - 1)) {
-        t->alimit = limit - 1;
-        setnorealasize(t);  /* now 'alimit' is not the real size */
-      }
-      return limit - 1;
-    }
-    else {  /* must search for a boundary in [0, limit] */
-      unsigned int boundary = binsearch(t->array, 0, limit);
-      /* can this boundary represent the real size of the array? */
-      if (ispow2realasize(t) && boundary > luaH_realasize(t) / 2) {
-        t->alimit = boundary;  /* use it as the new limit */
-        setnorealasize(t);
-      }
-      return boundary;
-    }
-  }
-  /* 'limit' is zero or present in table */
-  if (!limitequalsasize(t)) {  /* (2)? */
-    /* 'limit' > 0 and array has more elements after 'limit' */
-    if (isempty(&t->array[limit]))  /* 'limit + 1' is empty? */
-      return limit;  /* this is the boundary */
-    /* else, try last element in the array */
-    limit = luaH_realasize(t);
-    if (isempty(&t->array[limit - 1])) {  /* empty? */
-      /* there must be a boundary in the array after old limit,
-         and it must be a valid new limit */
-      unsigned int boundary = binsearch(t->array, t->alimit, limit);
-      t->alimit = boundary;
-      return boundary;
-    }
-    /* else, new limit is present in the table; check the hash part */
-  }
-  /* (3) 'limit' is the last element and either is zero or present in table */
-  lua_assert(limit == luaH_realasize(t) &&
-             (limit == 0 || !isempty(&t->array[limit - 1])));
-  if (isdummy(t) || isempty(luaH_getint(t, cast(lua_Integer, limit + 1))))
-    return limit;  /* 'limit + 1' is absent */
-  else  /* 'limit + 1' is also present */
-    return hash_search(t, limit);
-}
-
-
-
-#if defined(LUA_DEBUG)
-
-/* export these functions for the test library */
-
-Node *luaH_mainposition (const Table *t, const TValue *key) {
-  return mainpositionTV(t, key);
-}
-
-#endif
diff --git a/third-party/lua/src/ltable.h b/third-party/lua/src/ltable.h
deleted file mode 100644
index 75dd9e26e..000000000
--- a/third-party/lua/src/ltable.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
-** $Id: ltable.h $
-** Lua tables (hash)
-** See Copyright Notice in lua.h
-*/
-
-#ifndef ltable_h
-#define ltable_h
-
-#include "lobject.h"
-
-
-#define gnode(t,i)	(&(t)->node[i])
-#define gval(n)		(&(n)->i_val)
-#define gnext(n)	((n)->u.next)
-
-
-/*
-** Clear all bits of fast-access metamethods, which means that the table
-** may have any of these metamethods. (First access that fails after the
-** clearing will set the bit again.)
-*/
-#define invalidateTMcache(t)	((t)->flags &= ~maskflags)
-
-
-/* true when 't' is using 'dummynode' as its hash part */
-#define isdummy(t)		((t)->lastfree == NULL)
-
-
-/* allocated size for hash nodes */
-#define allocsizenode(t)	(isdummy(t) ? 0 : sizenode(t))
-
-
-/* returns the Node, given the value of a table entry */
-#define nodefromval(v)	cast(Node *, (v))
-
-
-LUAI_FUNC const TValue *luaH_getint (Table *t, lua_Integer key);
-LUAI_FUNC void luaH_setint (lua_State *L, Table *t, lua_Integer key,
-                                                    TValue *value);
-LUAI_FUNC const TValue *luaH_getshortstr (Table *t, TString *key);
-LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key);
-LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key);
-LUAI_FUNC void luaH_newkey (lua_State *L, Table *t, const TValue *key,
-                                                    TValue *value);
-LUAI_FUNC void luaH_set (lua_State *L, Table *t, const TValue *key,
-                                                 TValue *value);
-LUAI_FUNC void luaH_finishset (lua_State *L, Table *t, const TValue *key,
-                                       const TValue *slot, TValue *value);
-LUAI_FUNC Table *luaH_new (lua_State *L);
-LUAI_FUNC void luaH_resize (lua_State *L, Table *t, unsigned int nasize,
-                                                    unsigned int nhsize);
-LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, unsigned int nasize);
-LUAI_FUNC void luaH_free (lua_State *L, Table *t);
-LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key);
-LUAI_FUNC lua_Unsigned luaH_getn (Table *t);
-LUAI_FUNC unsigned int luaH_realasize (const Table *t);
-
-
-#if defined(LUA_DEBUG)
-LUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key);
-#endif
-
-
-#endif
diff --git a/third-party/lua/src/ltablib.c b/third-party/lua/src/ltablib.c
deleted file mode 100644
index e6bc4d04a..000000000
--- a/third-party/lua/src/ltablib.c
+++ /dev/null
@@ -1,430 +0,0 @@
-/*
-** $Id: ltablib.c $
-** Library for Table Manipulation
-** See Copyright Notice in lua.h
-*/
-
-#define ltablib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <limits.h>
-#include <stddef.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-/*
-** Operations that an object must define to mimic a table
-** (some functions only need some of them)
-*/
-#define TAB_R	1			/* read */
-#define TAB_W	2			/* write */
-#define TAB_L	4			/* length */
-#define TAB_RW	(TAB_R | TAB_W)		/* read/write */
-
-
-#define aux_getn(L,n,w)	(checktab(L, n, (w) | TAB_L), luaL_len(L, n))
-
-
-static int checkfield (lua_State *L, const char *key, int n) {
-  lua_pushstring(L, key);
-  return (lua_rawget(L, -n) != LUA_TNIL);
-}
-
-
-/*
-** Check that 'arg' either is a table or can behave like one (that is,
-** has a metatable with the required metamethods)
-*/
-static void checktab (lua_State *L, int arg, int what) {
-  if (lua_type(L, arg) != LUA_TTABLE) {  /* is it not a table? */
-    int n = 1;  /* number of elements to pop */
-    if (lua_getmetatable(L, arg) &&  /* must have metatable */
-        (!(what & TAB_R) || checkfield(L, "__index", ++n)) &&
-        (!(what & TAB_W) || checkfield(L, "__newindex", ++n)) &&
-        (!(what & TAB_L) || checkfield(L, "__len", ++n))) {
-      lua_pop(L, n);  /* pop metatable and tested metamethods */
-    }
-    else
-      luaL_checktype(L, arg, LUA_TTABLE);  /* force an error */
-  }
-}
-
-
-static int tinsert (lua_State *L) {
-  lua_Integer pos;  /* where to insert new element */
-  lua_Integer e = aux_getn(L, 1, TAB_RW);
-  e = luaL_intop(+, e, 1);  /* first empty element */
-  switch (lua_gettop(L)) {
-    case 2: {  /* called with only 2 arguments */
-      pos = e;  /* insert new element at the end */
-      break;
-    }
-    case 3: {
-      lua_Integer i;
-      pos = luaL_checkinteger(L, 2);  /* 2nd argument is the position */
-      /* check whether 'pos' is in [1, e] */
-      luaL_argcheck(L, (lua_Unsigned)pos - 1u < (lua_Unsigned)e, 2,
-                       "position out of bounds");
-      for (i = e; i > pos; i--) {  /* move up elements */
-        lua_geti(L, 1, i - 1);
-        lua_seti(L, 1, i);  /* t[i] = t[i - 1] */
-      }
-      break;
-    }
-    default: {
-      return luaL_error(L, "wrong number of arguments to 'insert'");
-    }
-  }
-  lua_seti(L, 1, pos);  /* t[pos] = v */
-  return 0;
-}
-
-
-static int tremove (lua_State *L) {
-  lua_Integer size = aux_getn(L, 1, TAB_RW);
-  lua_Integer pos = luaL_optinteger(L, 2, size);
-  if (pos != size)  /* validate 'pos' if given */
-    /* check whether 'pos' is in [1, size + 1] */
-    luaL_argcheck(L, (lua_Unsigned)pos - 1u <= (lua_Unsigned)size, 2,
-                     "position out of bounds");
-  lua_geti(L, 1, pos);  /* result = t[pos] */
-  for ( ; pos < size; pos++) {
-    lua_geti(L, 1, pos + 1);
-    lua_seti(L, 1, pos);  /* t[pos] = t[pos + 1] */
-  }
-  lua_pushnil(L);
-  lua_seti(L, 1, pos);  /* remove entry t[pos] */
-  return 1;
-}
-
-
-/*
-** Copy elements (1[f], ..., 1[e]) into (tt[t], tt[t+1], ...). Whenever
-** possible, copy in increasing order, which is better for rehashing.
-** "possible" means destination after original range, or smaller
-** than origin, or copying to another table.
-*/
-static int tmove (lua_State *L) {
-  lua_Integer f = luaL_checkinteger(L, 2);
-  lua_Integer e = luaL_checkinteger(L, 3);
-  lua_Integer t = luaL_checkinteger(L, 4);
-  int tt = !lua_isnoneornil(L, 5) ? 5 : 1;  /* destination table */
-  checktab(L, 1, TAB_R);
-  checktab(L, tt, TAB_W);
-  if (e >= f) {  /* otherwise, nothing to move */
-    lua_Integer n, i;
-    luaL_argcheck(L, f > 0 || e < LUA_MAXINTEGER + f, 3,
-                  "too many elements to move");
-    n = e - f + 1;  /* number of elements to move */
-    luaL_argcheck(L, t <= LUA_MAXINTEGER - n + 1, 4,
-                  "destination wrap around");
-    if (t > e || t <= f || (tt != 1 && !lua_compare(L, 1, tt, LUA_OPEQ))) {
-      for (i = 0; i < n; i++) {
-        lua_geti(L, 1, f + i);
-        lua_seti(L, tt, t + i);
-      }
-    }
-    else {
-      for (i = n - 1; i >= 0; i--) {
-        lua_geti(L, 1, f + i);
-        lua_seti(L, tt, t + i);
-      }
-    }
-  }
-  lua_pushvalue(L, tt);  /* return destination table */
-  return 1;
-}
-
-
-static void addfield (lua_State *L, luaL_Buffer *b, lua_Integer i) {
-  lua_geti(L, 1, i);
-  if (l_unlikely(!lua_isstring(L, -1)))
-    luaL_error(L, "invalid value (%s) at index %I in table for 'concat'",
-                  luaL_typename(L, -1), (LUAI_UACINT)i);
-  luaL_addvalue(b);
-}
-
-
-static int tconcat (lua_State *L) {
-  luaL_Buffer b;
-  lua_Integer last = aux_getn(L, 1, TAB_R);
-  size_t lsep;
-  const char *sep = luaL_optlstring(L, 2, "", &lsep);
-  lua_Integer i = luaL_optinteger(L, 3, 1);
-  last = luaL_optinteger(L, 4, last);
-  luaL_buffinit(L, &b);
-  for (; i < last; i++) {
-    addfield(L, &b, i);
-    luaL_addlstring(&b, sep, lsep);
-  }
-  if (i == last)  /* add last value (if interval was not empty) */
-    addfield(L, &b, i);
-  luaL_pushresult(&b);
-  return 1;
-}
-
-
-/*
-** {======================================================
-** Pack/unpack
-** =======================================================
-*/
-
-static int tpack (lua_State *L) {
-  int i;
-  int n = lua_gettop(L);  /* number of elements to pack */
-  lua_createtable(L, n, 1);  /* create result table */
-  lua_insert(L, 1);  /* put it at index 1 */
-  for (i = n; i >= 1; i--)  /* assign elements */
-    lua_seti(L, 1, i);
-  lua_pushinteger(L, n);
-  lua_setfield(L, 1, "n");  /* t.n = number of elements */
-  return 1;  /* return table */
-}
-
-
-static int tunpack (lua_State *L) {
-  lua_Unsigned n;
-  lua_Integer i = luaL_optinteger(L, 2, 1);
-  lua_Integer e = luaL_opt(L, luaL_checkinteger, 3, luaL_len(L, 1));
-  if (i > e) return 0;  /* empty range */
-  n = (lua_Unsigned)e - i;  /* number of elements minus 1 (avoid overflows) */
-  if (l_unlikely(n >= (unsigned int)INT_MAX  ||
-                 !lua_checkstack(L, (int)(++n))))
-    return luaL_error(L, "too many results to unpack");
-  for (; i < e; i++) {  /* push arg[i..e - 1] (to avoid overflows) */
-    lua_geti(L, 1, i);
-  }
-  lua_geti(L, 1, e);  /* push last element */
-  return (int)n;
-}
-
-/* }====================================================== */
-
-
-
-/*
-** {======================================================
-** Quicksort
-** (based on 'Algorithms in MODULA-3', Robert Sedgewick;
-**  Addison-Wesley, 1993.)
-** =======================================================
-*/
-
-
-/* type for array indices */
-typedef unsigned int IdxT;
-
-
-/*
-** Produce a "random" 'unsigned int' to randomize pivot choice. This
-** macro is used only when 'sort' detects a big imbalance in the result
-** of a partition. (If you don't want/need this "randomness", ~0 is a
-** good choice.)
-*/
-#if !defined(l_randomizePivot)		/* { */
-
-#include <time.h>
-
-/* size of 'e' measured in number of 'unsigned int's */
-#define sof(e)		(sizeof(e) / sizeof(unsigned int))
-
-/*
-** Use 'time' and 'clock' as sources of "randomness". Because we don't
-** know the types 'clock_t' and 'time_t', we cannot cast them to
-** anything without risking overflows. A safe way to use their values
-** is to copy them to an array of a known type and use the array values.
-*/
-static unsigned int l_randomizePivot (void) {
-  clock_t c = clock();
-  time_t t = time(NULL);
-  unsigned int buff[sof(c) + sof(t)];
-  unsigned int i, rnd = 0;
-  memcpy(buff, &c, sof(c) * sizeof(unsigned int));
-  memcpy(buff + sof(c), &t, sof(t) * sizeof(unsigned int));
-  for (i = 0; i < sof(buff); i++)
-    rnd += buff[i];
-  return rnd;
-}
-
-#endif					/* } */
-
-
-/* arrays larger than 'RANLIMIT' may use randomized pivots */
-#define RANLIMIT	100u
-
-
-static void set2 (lua_State *L, IdxT i, IdxT j) {
-  lua_seti(L, 1, i);
-  lua_seti(L, 1, j);
-}
-
-
-/*
-** Return true iff value at stack index 'a' is less than the value at
-** index 'b' (according to the order of the sort).
-*/
-static int sort_comp (lua_State *L, int a, int b) {
-  if (lua_isnil(L, 2))  /* no function? */
-    return lua_compare(L, a, b, LUA_OPLT);  /* a < b */
-  else {  /* function */
-    int res;
-    lua_pushvalue(L, 2);    /* push function */
-    lua_pushvalue(L, a-1);  /* -1 to compensate function */
-    lua_pushvalue(L, b-2);  /* -2 to compensate function and 'a' */
-    lua_call(L, 2, 1);      /* call function */
-    res = lua_toboolean(L, -1);  /* get result */
-    lua_pop(L, 1);          /* pop result */
-    return res;
-  }
-}
-
-
-/*
-** Does the partition: Pivot P is at the top of the stack.
-** precondition: a[lo] <= P == a[up-1] <= a[up],
-** so it only needs to do the partition from lo + 1 to up - 2.
-** Pos-condition: a[lo .. i - 1] <= a[i] == P <= a[i + 1 .. up]
-** returns 'i'.
-*/
-static IdxT partition (lua_State *L, IdxT lo, IdxT up) {
-  IdxT i = lo;  /* will be incremented before first use */
-  IdxT j = up - 1;  /* will be decremented before first use */
-  /* loop invariant: a[lo .. i] <= P <= a[j .. up] */
-  for (;;) {
-    /* next loop: repeat ++i while a[i] < P */
-    while ((void)lua_geti(L, 1, ++i), sort_comp(L, -1, -2)) {
-      if (l_unlikely(i == up - 1))  /* a[i] < P  but a[up - 1] == P  ?? */
-        luaL_error(L, "invalid order function for sorting");
-      lua_pop(L, 1);  /* remove a[i] */
-    }
-    /* after the loop, a[i] >= P and a[lo .. i - 1] < P */
-    /* next loop: repeat --j while P < a[j] */
-    while ((void)lua_geti(L, 1, --j), sort_comp(L, -3, -1)) {
-      if (l_unlikely(j < i))  /* j < i  but  a[j] > P ?? */
-        luaL_error(L, "invalid order function for sorting");
-      lua_pop(L, 1);  /* remove a[j] */
-    }
-    /* after the loop, a[j] <= P and a[j + 1 .. up] >= P */
-    if (j < i) {  /* no elements out of place? */
-      /* a[lo .. i - 1] <= P <= a[j + 1 .. i .. up] */
-      lua_pop(L, 1);  /* pop a[j] */
-      /* swap pivot (a[up - 1]) with a[i] to satisfy pos-condition */
-      set2(L, up - 1, i);
-      return i;
-    }
-    /* otherwise, swap a[i] - a[j] to restore invariant and repeat */
-    set2(L, i, j);
-  }
-}
-
-
-/*
-** Choose an element in the middle (2nd-3th quarters) of [lo,up]
-** "randomized" by 'rnd'
-*/
-static IdxT choosePivot (IdxT lo, IdxT up, unsigned int rnd) {
-  IdxT r4 = (up - lo) / 4;  /* range/4 */
-  IdxT p = rnd % (r4 * 2) + (lo + r4);
-  lua_assert(lo + r4 <= p && p <= up - r4);
-  return p;
-}
-
-
-/*
-** Quicksort algorithm (recursive function)
-*/
-static void auxsort (lua_State *L, IdxT lo, IdxT up,
-                                   unsigned int rnd) {
-  while (lo < up) {  /* loop for tail recursion */
-    IdxT p;  /* Pivot index */
-    IdxT n;  /* to be used later */
-    /* sort elements 'lo', 'p', and 'up' */
-    lua_geti(L, 1, lo);
-    lua_geti(L, 1, up);
-    if (sort_comp(L, -1, -2))  /* a[up] < a[lo]? */
-      set2(L, lo, up);  /* swap a[lo] - a[up] */
-    else
-      lua_pop(L, 2);  /* remove both values */
-    if (up - lo == 1)  /* only 2 elements? */
-      return;  /* already sorted */
-    if (up - lo < RANLIMIT || rnd == 0)  /* small interval or no randomize? */
-      p = (lo + up)/2;  /* middle element is a good pivot */
-    else  /* for larger intervals, it is worth a random pivot */
-      p = choosePivot(lo, up, rnd);
-    lua_geti(L, 1, p);
-    lua_geti(L, 1, lo);
-    if (sort_comp(L, -2, -1))  /* a[p] < a[lo]? */
-      set2(L, p, lo);  /* swap a[p] - a[lo] */
-    else {
-      lua_pop(L, 1);  /* remove a[lo] */
-      lua_geti(L, 1, up);
-      if (sort_comp(L, -1, -2))  /* a[up] < a[p]? */
-        set2(L, p, up);  /* swap a[up] - a[p] */
-      else
-        lua_pop(L, 2);
-    }
-    if (up - lo == 2)  /* only 3 elements? */
-      return;  /* already sorted */
-    lua_geti(L, 1, p);  /* get middle element (Pivot) */
-    lua_pushvalue(L, -1);  /* push Pivot */
-    lua_geti(L, 1, up - 1);  /* push a[up - 1] */
-    set2(L, p, up - 1);  /* swap Pivot (a[p]) with a[up - 1] */
-    p = partition(L, lo, up);
-    /* a[lo .. p - 1] <= a[p] == P <= a[p + 1 .. up] */
-    if (p - lo < up - p) {  /* lower interval is smaller? */
-      auxsort(L, lo, p - 1, rnd);  /* call recursively for lower interval */
-      n = p - lo;  /* size of smaller interval */
-      lo = p + 1;  /* tail call for [p + 1 .. up] (upper interval) */
-    }
-    else {
-      auxsort(L, p + 1, up, rnd);  /* call recursively for upper interval */
-      n = up - p;  /* size of smaller interval */
-      up = p - 1;  /* tail call for [lo .. p - 1]  (lower interval) */
-    }
-    if ((up - lo) / 128 > n) /* partition too imbalanced? */
-      rnd = l_randomizePivot();  /* try a new randomization */
-  }  /* tail call auxsort(L, lo, up, rnd) */
-}
-
-
-static int sort (lua_State *L) {
-  lua_Integer n = aux_getn(L, 1, TAB_RW);
-  if (n > 1) {  /* non-trivial interval? */
-    luaL_argcheck(L, n < INT_MAX, 1, "array too big");
-    if (!lua_isnoneornil(L, 2))  /* is there a 2nd argument? */
-      luaL_checktype(L, 2, LUA_TFUNCTION);  /* must be a function */
-    lua_settop(L, 2);  /* make sure there are two arguments */
-    auxsort(L, 1, (IdxT)n, 0);
-  }
-  return 0;
-}
-
-/* }====================================================== */
-
-
-static const luaL_Reg tab_funcs[] = {
-  {"concat", tconcat},
-  {"insert", tinsert},
-  {"pack", tpack},
-  {"unpack", tunpack},
-  {"remove", tremove},
-  {"move", tmove},
-  {"sort", sort},
-  {NULL, NULL}
-};
-
-
-LUAMOD_API int luaopen_table (lua_State *L) {
-  luaL_newlib(L, tab_funcs);
-  return 1;
-}
-
diff --git a/third-party/lua/src/ltm.c b/third-party/lua/src/ltm.c
deleted file mode 100644
index 07a060811..000000000
--- a/third-party/lua/src/ltm.c
+++ /dev/null
@@ -1,271 +0,0 @@
-/*
-** $Id: ltm.c $
-** Tag methods
-** See Copyright Notice in lua.h
-*/
-
-#define ltm_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <string.h>
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lgc.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-#include "lvm.h"
-
-
-static const char udatatypename[] = "userdata";
-
-LUAI_DDEF const char *const luaT_typenames_[LUA_TOTALTYPES] = {
-  "no value",
-  "nil", "boolean", udatatypename, "number",
-  "string", "table", "function", udatatypename, "thread",
-  "upvalue", "proto" /* these last cases are used for tests only */
-};
-
-
-void luaT_init (lua_State *L) {
-  static const char *const luaT_eventname[] = {  /* ORDER TM */
-    "__index", "__newindex",
-    "__gc", "__mode", "__len", "__eq",
-    "__add", "__sub", "__mul", "__mod", "__pow",
-    "__div", "__idiv",
-    "__band", "__bor", "__bxor", "__shl", "__shr",
-    "__unm", "__bnot", "__lt", "__le",
-    "__concat", "__call", "__close"
-  };
-  int i;
-  for (i=0; i<TM_N; i++) {
-    G(L)->tmname[i] = luaS_new(L, luaT_eventname[i]);
-    luaC_fix(L, obj2gco(G(L)->tmname[i]));  /* never collect these names */
-  }
-}
-
-
-/*
-** function to be used with macro "fasttm": optimized for absence of
-** tag methods
-*/
-const TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
-  const TValue *tm = luaH_getshortstr(events, ename);
-  lua_assert(event <= TM_EQ);
-  if (notm(tm)) {  /* no tag method? */
-    events->flags |= cast_byte(1u<<event);  /* cache this fact */
-    return NULL;
-  }
-  else return tm;
-}
-
-
-const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
-  Table *mt;
-  switch (ttype(o)) {
-    case LUA_TTABLE:
-      mt = hvalue(o)->metatable;
-      break;
-    case LUA_TUSERDATA:
-      mt = uvalue(o)->metatable;
-      break;
-    default:
-      mt = G(L)->mt[ttype(o)];
-  }
-  return (mt ? luaH_getshortstr(mt, G(L)->tmname[event]) : &G(L)->nilvalue);
-}
-
-
-/*
-** Return the name of the type of an object. For tables and userdata
-** with metatable, use their '__name' metafield, if present.
-*/
-const char *luaT_objtypename (lua_State *L, const TValue *o) {
-  Table *mt;
-  if ((ttistable(o) && (mt = hvalue(o)->metatable) != NULL) ||
-      (ttisfulluserdata(o) && (mt = uvalue(o)->metatable) != NULL)) {
-    const TValue *name = luaH_getshortstr(mt, luaS_new(L, "__name"));
-    if (ttisstring(name))  /* is '__name' a string? */
-      return getstr(tsvalue(name));  /* use it as type name */
-  }
-  return ttypename(ttype(o));  /* else use standard type name */
-}
-
-
-void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1,
-                  const TValue *p2, const TValue *p3) {
-  StkId func = L->top.p;
-  setobj2s(L, func, f);  /* push function (assume EXTRA_STACK) */
-  setobj2s(L, func + 1, p1);  /* 1st argument */
-  setobj2s(L, func + 2, p2);  /* 2nd argument */
-  setobj2s(L, func + 3, p3);  /* 3rd argument */
-  L->top.p = func + 4;
-  /* metamethod may yield only when called from Lua code */
-  if (isLuacode(L->ci))
-    luaD_call(L, func, 0);
-  else
-    luaD_callnoyield(L, func, 0);
-}
-
-
-void luaT_callTMres (lua_State *L, const TValue *f, const TValue *p1,
-                     const TValue *p2, StkId res) {
-  ptrdiff_t result = savestack(L, res);
-  StkId func = L->top.p;
-  setobj2s(L, func, f);  /* push function (assume EXTRA_STACK) */
-  setobj2s(L, func + 1, p1);  /* 1st argument */
-  setobj2s(L, func + 2, p2);  /* 2nd argument */
-  L->top.p += 3;
-  /* metamethod may yield only when called from Lua code */
-  if (isLuacode(L->ci))
-    luaD_call(L, func, 1);
-  else
-    luaD_callnoyield(L, func, 1);
-  res = restorestack(L, result);
-  setobjs2s(L, res, --L->top.p);  /* move result to its place */
-}
-
-
-static int callbinTM (lua_State *L, const TValue *p1, const TValue *p2,
-                      StkId res, TMS event) {
-  const TValue *tm = luaT_gettmbyobj(L, p1, event);  /* try first operand */
-  if (notm(tm))
-    tm = luaT_gettmbyobj(L, p2, event);  /* try second operand */
-  if (notm(tm)) return 0;
-  luaT_callTMres(L, tm, p1, p2, res);
-  return 1;
-}
-
-
-void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2,
-                    StkId res, TMS event) {
-  if (l_unlikely(!callbinTM(L, p1, p2, res, event))) {
-    switch (event) {
-      case TM_BAND: case TM_BOR: case TM_BXOR:
-      case TM_SHL: case TM_SHR: case TM_BNOT: {
-        if (ttisnumber(p1) && ttisnumber(p2))
-          luaG_tointerror(L, p1, p2);
-        else
-          luaG_opinterror(L, p1, p2, "perform bitwise operation on");
-      }
-      /* calls never return, but to avoid warnings: *//* FALLTHROUGH */
-      default:
-        luaG_opinterror(L, p1, p2, "perform arithmetic on");
-    }
-  }
-}
-
-
-void luaT_tryconcatTM (lua_State *L) {
-  StkId top = L->top.p;
-  if (l_unlikely(!callbinTM(L, s2v(top - 2), s2v(top - 1), top - 2,
-                               TM_CONCAT)))
-    luaG_concaterror(L, s2v(top - 2), s2v(top - 1));
-}
-
-
-void luaT_trybinassocTM (lua_State *L, const TValue *p1, const TValue *p2,
-                                       int flip, StkId res, TMS event) {
-  if (flip)
-    luaT_trybinTM(L, p2, p1, res, event);
-  else
-    luaT_trybinTM(L, p1, p2, res, event);
-}
-
-
-void luaT_trybiniTM (lua_State *L, const TValue *p1, lua_Integer i2,
-                                   int flip, StkId res, TMS event) {
-  TValue aux;
-  setivalue(&aux, i2);
-  luaT_trybinassocTM(L, p1, &aux, flip, res, event);
-}
-
-
-/*
-** Calls an order tag method.
-** For lessequal, LUA_COMPAT_LT_LE keeps compatibility with old
-** behavior: if there is no '__le', try '__lt', based on l <= r iff
-** !(r < l) (assuming a total order). If the metamethod yields during
-** this substitution, the continuation has to know about it (to negate
-** the result of r<l); bit CIST_LEQ in the call status keeps that
-** information.
-*/
-int luaT_callorderTM (lua_State *L, const TValue *p1, const TValue *p2,
-                      TMS event) {
-  if (callbinTM(L, p1, p2, L->top.p, event))  /* try original event */
-    return !l_isfalse(s2v(L->top.p));
-#if defined(LUA_COMPAT_LT_LE)
-  else if (event == TM_LE) {
-      /* try '!(p2 < p1)' for '(p1 <= p2)' */
-      L->ci->callstatus |= CIST_LEQ;  /* mark it is doing 'lt' for 'le' */
-      if (callbinTM(L, p2, p1, L->top.p, TM_LT)) {
-        L->ci->callstatus ^= CIST_LEQ;  /* clear mark */
-        return l_isfalse(s2v(L->top.p));
-      }
-      /* else error will remove this 'ci'; no need to clear mark */
-  }
-#endif
-  luaG_ordererror(L, p1, p2);  /* no metamethod found */
-  return 0;  /* to avoid warnings */
-}
-
-
-int luaT_callorderiTM (lua_State *L, const TValue *p1, int v2,
-                       int flip, int isfloat, TMS event) {
-  TValue aux; const TValue *p2;
-  if (isfloat) {
-    setfltvalue(&aux, cast_num(v2));
-  }
-  else
-    setivalue(&aux, v2);
-  if (flip) {  /* arguments were exchanged? */
-    p2 = p1; p1 = &aux;  /* correct them */
-  }
-  else
-    p2 = &aux;
-  return luaT_callorderTM(L, p1, p2, event);
-}
-
-
-void luaT_adjustvarargs (lua_State *L, int nfixparams, CallInfo *ci,
-                         const Proto *p) {
-  int i;
-  int actual = cast_int(L->top.p - ci->func.p) - 1;  /* number of arguments */
-  int nextra = actual - nfixparams;  /* number of extra arguments */
-  ci->u.l.nextraargs = nextra;
-  luaD_checkstack(L, p->maxstacksize + 1);
-  /* copy function to the top of the stack */
-  setobjs2s(L, L->top.p++, ci->func.p);
-  /* move fixed parameters to the top of the stack */
-  for (i = 1; i <= nfixparams; i++) {
-    setobjs2s(L, L->top.p++, ci->func.p + i);
-    setnilvalue(s2v(ci->func.p + i));  /* erase original parameter (for GC) */
-  }
-  ci->func.p += actual + 1;
-  ci->top.p += actual + 1;
-  lua_assert(L->top.p <= ci->top.p && ci->top.p <= L->stack_last.p);
-}
-
-
-void luaT_getvarargs (lua_State *L, CallInfo *ci, StkId where, int wanted) {
-  int i;
-  int nextra = ci->u.l.nextraargs;
-  if (wanted < 0) {
-    wanted = nextra;  /* get all extra arguments available */
-    checkstackGCp(L, nextra, where);  /* ensure stack space */
-    L->top.p = where + nextra;  /* next instruction will need top */
-  }
-  for (i = 0; i < wanted && i < nextra; i++)
-    setobjs2s(L, where + i, ci->func.p - nextra + i);
-  for (; i < wanted; i++)   /* complete required results with nil */
-    setnilvalue(s2v(where + i));
-}
-
diff --git a/third-party/lua/src/ltm.h b/third-party/lua/src/ltm.h
deleted file mode 100644
index c309e2ae1..000000000
--- a/third-party/lua/src/ltm.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
-** $Id: ltm.h $
-** Tag methods
-** See Copyright Notice in lua.h
-*/
-
-#ifndef ltm_h
-#define ltm_h
-
-
-#include "lobject.h"
-#include "lstate.h"
-
-
-/*
-* WARNING: if you change the order of this enumeration,
-* grep "ORDER TM" and "ORDER OP"
-*/
-typedef enum {
-  TM_INDEX,
-  TM_NEWINDEX,
-  TM_GC,
-  TM_MODE,
-  TM_LEN,
-  TM_EQ,  /* last tag method with fast access */
-  TM_ADD,
-  TM_SUB,
-  TM_MUL,
-  TM_MOD,
-  TM_POW,
-  TM_DIV,
-  TM_IDIV,
-  TM_BAND,
-  TM_BOR,
-  TM_BXOR,
-  TM_SHL,
-  TM_SHR,
-  TM_UNM,
-  TM_BNOT,
-  TM_LT,
-  TM_LE,
-  TM_CONCAT,
-  TM_CALL,
-  TM_CLOSE,
-  TM_N		/* number of elements in the enum */
-} TMS;
-
-
-/*
-** Mask with 1 in all fast-access methods. A 1 in any of these bits
-** in the flag of a (meta)table means the metatable does not have the
-** corresponding metamethod field. (Bit 7 of the flag is used for
-** 'isrealasize'.)
-*/
-#define maskflags	(~(~0u << (TM_EQ + 1)))
-
-
-/*
-** Test whether there is no tagmethod.
-** (Because tagmethods use raw accesses, the result may be an "empty" nil.)
-*/
-#define notm(tm)	ttisnil(tm)
-
-
-#define gfasttm(g,et,e) ((et) == NULL ? NULL : \
-  ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e]))
-
-#define fasttm(l,et,e)	gfasttm(G(l), et, e)
-
-#define ttypename(x)	luaT_typenames_[(x) + 1]
-
-LUAI_DDEC(const char *const luaT_typenames_[LUA_TOTALTYPES];)
-
-
-LUAI_FUNC const char *luaT_objtypename (lua_State *L, const TValue *o);
-
-LUAI_FUNC const TValue *luaT_gettm (Table *events, TMS event, TString *ename);
-LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o,
-                                                       TMS event);
-LUAI_FUNC void luaT_init (lua_State *L);
-
-LUAI_FUNC void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1,
-                            const TValue *p2, const TValue *p3);
-LUAI_FUNC void luaT_callTMres (lua_State *L, const TValue *f,
-                            const TValue *p1, const TValue *p2, StkId p3);
-LUAI_FUNC void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2,
-                              StkId res, TMS event);
-LUAI_FUNC void luaT_tryconcatTM (lua_State *L);
-LUAI_FUNC void luaT_trybinassocTM (lua_State *L, const TValue *p1,
-       const TValue *p2, int inv, StkId res, TMS event);
-LUAI_FUNC void luaT_trybiniTM (lua_State *L, const TValue *p1, lua_Integer i2,
-                               int inv, StkId res, TMS event);
-LUAI_FUNC int luaT_callorderTM (lua_State *L, const TValue *p1,
-                                const TValue *p2, TMS event);
-LUAI_FUNC int luaT_callorderiTM (lua_State *L, const TValue *p1, int v2,
-                                 int inv, int isfloat, TMS event);
-
-LUAI_FUNC void luaT_adjustvarargs (lua_State *L, int nfixparams,
-                                   CallInfo *ci, const Proto *p);
-LUAI_FUNC void luaT_getvarargs (lua_State *L, CallInfo *ci,
-                                              StkId where, int wanted);
-
-
-#endif
diff --git a/third-party/lua/src/lua.c b/third-party/lua/src/lua.c
deleted file mode 100644
index 0ff884545..000000000
--- a/third-party/lua/src/lua.c
+++ /dev/null
@@ -1,679 +0,0 @@
-/*
-** $Id: lua.c $
-** Lua stand-alone interpreter
-** See Copyright Notice in lua.h
-*/
-
-#define lua_c
-
-#include "lprefix.h"
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <signal.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-#if !defined(LUA_PROGNAME)
-#define LUA_PROGNAME		"lua"
-#endif
-
-#if !defined(LUA_INIT_VAR)
-#define LUA_INIT_VAR		"LUA_INIT"
-#endif
-
-#define LUA_INITVARVERSION	LUA_INIT_VAR LUA_VERSUFFIX
-
-
-static lua_State *globalL = NULL;
-
-static const char *progname = LUA_PROGNAME;
-
-
-#if defined(LUA_USE_POSIX)   /* { */
-
-/*
-** Use 'sigaction' when available.
-*/
-static void setsignal (int sig, void (*handler)(int)) {
-  struct sigaction sa;
-  sa.sa_handler = handler;
-  sa.sa_flags = 0;
-  sigemptyset(&sa.sa_mask);  /* do not mask any signal */
-  sigaction(sig, &sa, NULL);
-}
-
-#else           /* }{ */
-
-#define setsignal            signal
-
-#endif                               /* } */
-
-
-/*
-** Hook set by signal function to stop the interpreter.
-*/
-static void lstop (lua_State *L, lua_Debug *ar) {
-  (void)ar;  /* unused arg. */
-  lua_sethook(L, NULL, 0, 0);  /* reset hook */
-  luaL_error(L, "interrupted!");
-}
-
-
-/*
-** Function to be called at a C signal. Because a C signal cannot
-** just change a Lua state (as there is no proper synchronization),
-** this function only sets a hook that, when called, will stop the
-** interpreter.
-*/
-static void laction (int i) {
-  int flag = LUA_MASKCALL | LUA_MASKRET | LUA_MASKLINE | LUA_MASKCOUNT;
-  setsignal(i, SIG_DFL); /* if another SIGINT happens, terminate process */
-  lua_sethook(globalL, lstop, flag, 1);
-}
-
-
-static void print_usage (const char *badoption) {
-  lua_writestringerror("%s: ", progname);
-  if (badoption[1] == 'e' || badoption[1] == 'l')
-    lua_writestringerror("'%s' needs argument\n", badoption);
-  else
-    lua_writestringerror("unrecognized option '%s'\n", badoption);
-  lua_writestringerror(
-  "usage: %s [options] [script [args]]\n"
-  "Available options are:\n"
-  "  -e stat   execute string 'stat'\n"
-  "  -i        enter interactive mode after executing 'script'\n"
-  "  -l mod    require library 'mod' into global 'mod'\n"
-  "  -l g=mod  require library 'mod' into global 'g'\n"
-  "  -v        show version information\n"
-  "  -E        ignore environment variables\n"
-  "  -W        turn warnings on\n"
-  "  --        stop handling options\n"
-  "  -         stop handling options and execute stdin\n"
-  ,
-  progname);
-}
-
-
-/*
-** Prints an error message, adding the program name in front of it
-** (if present)
-*/
-static void l_message (const char *pname, const char *msg) {
-  if (pname) lua_writestringerror("%s: ", pname);
-  lua_writestringerror("%s\n", msg);
-}
-
-
-/*
-** Check whether 'status' is not OK and, if so, prints the error
-** message on the top of the stack. It assumes that the error object
-** is a string, as it was either generated by Lua or by 'msghandler'.
-*/
-static int report (lua_State *L, int status) {
-  if (status != LUA_OK) {
-    const char *msg = lua_tostring(L, -1);
-    l_message(progname, msg);
-    lua_pop(L, 1);  /* remove message */
-  }
-  return status;
-}
-
-
-/*
-** Message handler used to run all chunks
-*/
-static int msghandler (lua_State *L) {
-  const char *msg = lua_tostring(L, 1);
-  if (msg == NULL) {  /* is error object not a string? */
-    if (luaL_callmeta(L, 1, "__tostring") &&  /* does it have a metamethod */
-        lua_type(L, -1) == LUA_TSTRING)  /* that produces a string? */
-      return 1;  /* that is the message */
-    else
-      msg = lua_pushfstring(L, "(error object is a %s value)",
-                               luaL_typename(L, 1));
-  }
-  luaL_traceback(L, L, msg, 1);  /* append a standard traceback */
-  return 1;  /* return the traceback */
-}
-
-
-/*
-** Interface to 'lua_pcall', which sets appropriate message function
-** and C-signal handler. Used to run all chunks.
-*/
-static int docall (lua_State *L, int narg, int nres) {
-  int status;
-  int base = lua_gettop(L) - narg;  /* function index */
-  lua_pushcfunction(L, msghandler);  /* push message handler */
-  lua_insert(L, base);  /* put it under function and args */
-  globalL = L;  /* to be available to 'laction' */
-  setsignal(SIGINT, laction);  /* set C-signal handler */
-  status = lua_pcall(L, narg, nres, base);
-  setsignal(SIGINT, SIG_DFL); /* reset C-signal handler */
-  lua_remove(L, base);  /* remove message handler from the stack */
-  return status;
-}
-
-
-static void print_version (void) {
-  lua_writestring(LUA_COPYRIGHT, strlen(LUA_COPYRIGHT));
-  lua_writeline();
-}
-
-
-/*
-** Create the 'arg' table, which stores all arguments from the
-** command line ('argv'). It should be aligned so that, at index 0,
-** it has 'argv[script]', which is the script name. The arguments
-** to the script (everything after 'script') go to positive indices;
-** other arguments (before the script name) go to negative indices.
-** If there is no script name, assume interpreter's name as base.
-** (If there is no interpreter's name either, 'script' is -1, so
-** table sizes are zero.)
-*/
-static void createargtable (lua_State *L, char **argv, int argc, int script) {
-  int i, narg;
-  narg = argc - (script + 1);  /* number of positive indices */
-  lua_createtable(L, narg, script + 1);
-  for (i = 0; i < argc; i++) {
-    lua_pushstring(L, argv[i]);
-    lua_rawseti(L, -2, i - script);
-  }
-  lua_setglobal(L, "arg");
-}
-
-
-static int dochunk (lua_State *L, int status) {
-  if (status == LUA_OK) status = docall(L, 0, 0);
-  return report(L, status);
-}
-
-
-static int dofile (lua_State *L, const char *name) {
-  return dochunk(L, luaL_loadfile(L, name));
-}
-
-
-static int dostring (lua_State *L, const char *s, const char *name) {
-  return dochunk(L, luaL_loadbuffer(L, s, strlen(s), name));
-}
-
-
-/*
-** Receives 'globname[=modname]' and runs 'globname = require(modname)'.
-*/
-static int dolibrary (lua_State *L, char *globname) {
-  int status;
-  char *modname = strchr(globname, '=');
-  if (modname == NULL)  /* no explicit name? */
-    modname = globname;  /* module name is equal to global name */
-  else {
-    *modname = '\0';  /* global name ends here */
-    modname++;  /* module name starts after the '=' */
-  }
-  lua_getglobal(L, "require");
-  lua_pushstring(L, modname);
-  status = docall(L, 1, 1);  /* call 'require(modname)' */
-  if (status == LUA_OK)
-    lua_setglobal(L, globname);  /* globname = require(modname) */
-  return report(L, status);
-}
-
-
-/*
-** Push on the stack the contents of table 'arg' from 1 to #arg
-*/
-static int pushargs (lua_State *L) {
-  int i, n;
-  if (lua_getglobal(L, "arg") != LUA_TTABLE)
-    luaL_error(L, "'arg' is not a table");
-  n = (int)luaL_len(L, -1);
-  luaL_checkstack(L, n + 3, "too many arguments to script");
-  for (i = 1; i <= n; i++)
-    lua_rawgeti(L, -i, i);
-  lua_remove(L, -i);  /* remove table from the stack */
-  return n;
-}
-
-
-static int handle_script (lua_State *L, char **argv) {
-  int status;
-  const char *fname = argv[0];
-  if (strcmp(fname, "-") == 0 && strcmp(argv[-1], "--") != 0)
-    fname = NULL;  /* stdin */
-  status = luaL_loadfile(L, fname);
-  if (status == LUA_OK) {
-    int n = pushargs(L);  /* push arguments to script */
-    status = docall(L, n, LUA_MULTRET);
-  }
-  return report(L, status);
-}
-
-
-/* bits of various argument indicators in 'args' */
-#define has_error	1	/* bad option */
-#define has_i		2	/* -i */
-#define has_v		4	/* -v */
-#define has_e		8	/* -e */
-#define has_E		16	/* -E */
-
-
-/*
-** Traverses all arguments from 'argv', returning a mask with those
-** needed before running any Lua code or an error code if it finds any
-** invalid argument. In case of error, 'first' is the index of the bad
-** argument.  Otherwise, 'first' is -1 if there is no program name,
-** 0 if there is no script name, or the index of the script name.
-*/
-static int collectargs (char **argv, int *first) {
-  int args = 0;
-  int i;
-  if (argv[0] != NULL) {  /* is there a program name? */
-    if (argv[0][0])  /* not empty? */
-      progname = argv[0];  /* save it */
-  }
-  else {  /* no program name */
-    *first = -1;
-    return 0;
-  }
-  for (i = 1; argv[i] != NULL; i++) {  /* handle arguments */
-    *first = i;
-    if (argv[i][0] != '-')  /* not an option? */
-        return args;  /* stop handling options */
-    switch (argv[i][1]) {  /* else check option */
-      case '-':  /* '--' */
-        if (argv[i][2] != '\0')  /* extra characters after '--'? */
-          return has_error;  /* invalid option */
-        *first = i + 1;
-        return args;
-      case '\0':  /* '-' */
-        return args;  /* script "name" is '-' */
-      case 'E':
-        if (argv[i][2] != '\0')  /* extra characters? */
-          return has_error;  /* invalid option */
-        args |= has_E;
-        break;
-      case 'W':
-        if (argv[i][2] != '\0')  /* extra characters? */
-          return has_error;  /* invalid option */
-        break;
-      case 'i':
-        args |= has_i;  /* (-i implies -v) *//* FALLTHROUGH */
-      case 'v':
-        if (argv[i][2] != '\0')  /* extra characters? */
-          return has_error;  /* invalid option */
-        args |= has_v;
-        break;
-      case 'e':
-        args |= has_e;  /* FALLTHROUGH */
-      case 'l':  /* both options need an argument */
-        if (argv[i][2] == '\0') {  /* no concatenated argument? */
-          i++;  /* try next 'argv' */
-          if (argv[i] == NULL || argv[i][0] == '-')
-            return has_error;  /* no next argument or it is another option */
-        }
-        break;
-      default:  /* invalid option */
-        return has_error;
-    }
-  }
-  *first = 0;  /* no script name */
-  return args;
-}
-
-
-/*
-** Processes options 'e' and 'l', which involve running Lua code, and
-** 'W', which also affects the state.
-** Returns 0 if some code raises an error.
-*/
-static int runargs (lua_State *L, char **argv, int n) {
-  int i;
-  for (i = 1; i < n; i++) {
-    int option = argv[i][1];
-    lua_assert(argv[i][0] == '-');  /* already checked */
-    switch (option) {
-      case 'e':  case 'l': {
-        int status;
-        char *extra = argv[i] + 2;  /* both options need an argument */
-        if (*extra == '\0') extra = argv[++i];
-        lua_assert(extra != NULL);
-        status = (option == 'e')
-                 ? dostring(L, extra, "=(command line)")
-                 : dolibrary(L, extra);
-        if (status != LUA_OK) return 0;
-        break;
-      }
-      case 'W':
-        lua_warning(L, "@on", 0);  /* warnings on */
-        break;
-    }
-  }
-  return 1;
-}
-
-
-static int handle_luainit (lua_State *L) {
-  const char *name = "=" LUA_INITVARVERSION;
-  const char *init = getenv(name + 1);
-  if (init == NULL) {
-    name = "=" LUA_INIT_VAR;
-    init = getenv(name + 1);  /* try alternative name */
-  }
-  if (init == NULL) return LUA_OK;
-  else if (init[0] == '@')
-    return dofile(L, init+1);
-  else
-    return dostring(L, init, name);
-}
-
-
-/*
-** {==================================================================
-** Read-Eval-Print Loop (REPL)
-** ===================================================================
-*/
-
-#if !defined(LUA_PROMPT)
-#define LUA_PROMPT		"> "
-#define LUA_PROMPT2		">> "
-#endif
-
-#if !defined(LUA_MAXINPUT)
-#define LUA_MAXINPUT		512
-#endif
-
-
-/*
-** lua_stdin_is_tty detects whether the standard input is a 'tty' (that
-** is, whether we're running lua interactively).
-*/
-#if !defined(lua_stdin_is_tty)	/* { */
-
-#if defined(LUA_USE_POSIX)	/* { */
-
-#include <unistd.h>
-#define lua_stdin_is_tty()	isatty(0)
-
-#elif defined(LUA_USE_WINDOWS)	/* }{ */
-
-#include <io.h>
-#include <windows.h>
-
-#define lua_stdin_is_tty()	_isatty(_fileno(stdin))
-
-#else				/* }{ */
-
-/* ISO C definition */
-#define lua_stdin_is_tty()	1  /* assume stdin is a tty */
-
-#endif				/* } */
-
-#endif				/* } */
-
-
-/*
-** lua_readline defines how to show a prompt and then read a line from
-** the standard input.
-** lua_saveline defines how to "save" a read line in a "history".
-** lua_freeline defines how to free a line read by lua_readline.
-*/
-#if !defined(lua_readline)	/* { */
-
-#if defined(LUA_USE_READLINE)	/* { */
-
-#include <readline/readline.h>
-#include <readline/history.h>
-#define lua_initreadline(L)	((void)L, rl_readline_name="lua")
-#define lua_readline(L,b,p)	((void)L, ((b)=readline(p)) != NULL)
-#define lua_saveline(L,line)	((void)L, add_history(line))
-#define lua_freeline(L,b)	((void)L, free(b))
-
-#else				/* }{ */
-
-#define lua_initreadline(L)  ((void)L)
-#define lua_readline(L,b,p) \
-        ((void)L, fputs(p, stdout), fflush(stdout),  /* show prompt */ \
-        fgets(b, LUA_MAXINPUT, stdin) != NULL)  /* get line */
-#define lua_saveline(L,line)	{ (void)L; (void)line; }
-#define lua_freeline(L,b)	{ (void)L; (void)b; }
-
-#endif				/* } */
-
-#endif				/* } */
-
-
-/*
-** Return the string to be used as a prompt by the interpreter. Leave
-** the string (or nil, if using the default value) on the stack, to keep
-** it anchored.
-*/
-static const char *get_prompt (lua_State *L, int firstline) {
-  if (lua_getglobal(L, firstline ? "_PROMPT" : "_PROMPT2") == LUA_TNIL)
-    return (firstline ? LUA_PROMPT : LUA_PROMPT2);  /* use the default */
-  else {  /* apply 'tostring' over the value */
-    const char *p = luaL_tolstring(L, -1, NULL);
-    lua_remove(L, -2);  /* remove original value */
-    return p;
-  }
-}
-
-/* mark in error messages for incomplete statements */
-#define EOFMARK		"<eof>"
-#define marklen		(sizeof(EOFMARK)/sizeof(char) - 1)
-
-
-/*
-** Check whether 'status' signals a syntax error and the error
-** message at the top of the stack ends with the above mark for
-** incomplete statements.
-*/
-static int incomplete (lua_State *L, int status) {
-  if (status == LUA_ERRSYNTAX) {
-    size_t lmsg;
-    const char *msg = lua_tolstring(L, -1, &lmsg);
-    if (lmsg >= marklen && strcmp(msg + lmsg - marklen, EOFMARK) == 0) {
-      lua_pop(L, 1);
-      return 1;
-    }
-  }
-  return 0;  /* else... */
-}
-
-
-/*
-** Prompt the user, read a line, and push it into the Lua stack.
-*/
-static int pushline (lua_State *L, int firstline) {
-  char buffer[LUA_MAXINPUT];
-  char *b = buffer;
-  size_t l;
-  const char *prmt = get_prompt(L, firstline);
-  int readstatus = lua_readline(L, b, prmt);
-  if (readstatus == 0)
-    return 0;  /* no input (prompt will be popped by caller) */
-  lua_pop(L, 1);  /* remove prompt */
-  l = strlen(b);
-  if (l > 0 && b[l-1] == '\n')  /* line ends with newline? */
-    b[--l] = '\0';  /* remove it */
-  if (firstline && b[0] == '=')  /* for compatibility with 5.2, ... */
-    lua_pushfstring(L, "return %s", b + 1);  /* change '=' to 'return' */
-  else
-    lua_pushlstring(L, b, l);
-  lua_freeline(L, b);
-  return 1;
-}
-
-
-/*
-** Try to compile line on the stack as 'return <line>;'; on return, stack
-** has either compiled chunk or original line (if compilation failed).
-*/
-static int addreturn (lua_State *L) {
-  const char *line = lua_tostring(L, -1);  /* original line */
-  const char *retline = lua_pushfstring(L, "return %s;", line);
-  int status = luaL_loadbuffer(L, retline, strlen(retline), "=stdin");
-  if (status == LUA_OK) {
-    lua_remove(L, -2);  /* remove modified line */
-    if (line[0] != '\0')  /* non empty? */
-      lua_saveline(L, line);  /* keep history */
-  }
-  else
-    lua_pop(L, 2);  /* pop result from 'luaL_loadbuffer' and modified line */
-  return status;
-}
-
-
-/*
-** Read multiple lines until a complete Lua statement
-*/
-static int multiline (lua_State *L) {
-  for (;;) {  /* repeat until gets a complete statement */
-    size_t len;
-    const char *line = lua_tolstring(L, 1, &len);  /* get what it has */
-    int status = luaL_loadbuffer(L, line, len, "=stdin");  /* try it */
-    if (!incomplete(L, status) || !pushline(L, 0)) {
-      lua_saveline(L, line);  /* keep history */
-      return status;  /* cannot or should not try to add continuation line */
-    }
-    lua_pushliteral(L, "\n");  /* add newline... */
-    lua_insert(L, -2);  /* ...between the two lines */
-    lua_concat(L, 3);  /* join them */
-  }
-}
-
-
-/*
-** Read a line and try to load (compile) it first as an expression (by
-** adding "return " in front of it) and second as a statement. Return
-** the final status of load/call with the resulting function (if any)
-** in the top of the stack.
-*/
-static int loadline (lua_State *L) {
-  int status;
-  lua_settop(L, 0);
-  if (!pushline(L, 1))
-    return -1;  /* no input */
-  if ((status = addreturn(L)) != LUA_OK)  /* 'return ...' did not work? */
-    status = multiline(L);  /* try as command, maybe with continuation lines */
-  lua_remove(L, 1);  /* remove line from the stack */
-  lua_assert(lua_gettop(L) == 1);
-  return status;
-}
-
-
-/*
-** Prints (calling the Lua 'print' function) any values on the stack
-*/
-static void l_print (lua_State *L) {
-  int n = lua_gettop(L);
-  if (n > 0) {  /* any result to be printed? */
-    luaL_checkstack(L, LUA_MINSTACK, "too many results to print");
-    lua_getglobal(L, "print");
-    lua_insert(L, 1);
-    if (lua_pcall(L, n, 0, 0) != LUA_OK)
-      l_message(progname, lua_pushfstring(L, "error calling 'print' (%s)",
-                                             lua_tostring(L, -1)));
-  }
-}
-
-
-/*
-** Do the REPL: repeatedly read (load) a line, evaluate (call) it, and
-** print any results.
-*/
-static void doREPL (lua_State *L) {
-  int status;
-  const char *oldprogname = progname;
-  progname = NULL;  /* no 'progname' on errors in interactive mode */
-  lua_initreadline(L);
-  while ((status = loadline(L)) != -1) {
-    if (status == LUA_OK)
-      status = docall(L, 0, LUA_MULTRET);
-    if (status == LUA_OK) l_print(L);
-    else report(L, status);
-  }
-  lua_settop(L, 0);  /* clear stack */
-  lua_writeline();
-  progname = oldprogname;
-}
-
-/* }================================================================== */
-
-
-/*
-** Main body of stand-alone interpreter (to be called in protected mode).
-** Reads the options and handles them all.
-*/
-static int pmain (lua_State *L) {
-  int argc = (int)lua_tointeger(L, 1);
-  char **argv = (char **)lua_touserdata(L, 2);
-  int script;
-  int args = collectargs(argv, &script);
-  int optlim = (script > 0) ? script : argc; /* first argv not an option */
-  luaL_checkversion(L);  /* check that interpreter has correct version */
-  if (args == has_error) {  /* bad arg? */
-    print_usage(argv[script]);  /* 'script' has index of bad arg. */
-    return 0;
-  }
-  if (args & has_v)  /* option '-v'? */
-    print_version();
-  if (args & has_E) {  /* option '-E'? */
-    lua_pushboolean(L, 1);  /* signal for libraries to ignore env. vars. */
-    lua_setfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");
-  }
-  luaL_openlibs(L);  /* open standard libraries */
-  createargtable(L, argv, argc, script);  /* create table 'arg' */
-  lua_gc(L, LUA_GCRESTART);  /* start GC... */
-  lua_gc(L, LUA_GCGEN, 0, 0);  /* ...in generational mode */
-  if (!(args & has_E)) {  /* no option '-E'? */
-    if (handle_luainit(L) != LUA_OK)  /* run LUA_INIT */
-      return 0;  /* error running LUA_INIT */
-  }
-  if (!runargs(L, argv, optlim))  /* execute arguments -e and -l */
-    return 0;  /* something failed */
-  if (script > 0) {  /* execute main script (if there is one) */
-    if (handle_script(L, argv + script) != LUA_OK)
-      return 0;  /* interrupt in case of error */
-  }
-  if (args & has_i)  /* -i option? */
-    doREPL(L);  /* do read-eval-print loop */
-  else if (script < 1 && !(args & (has_e | has_v))) { /* no active option? */
-    if (lua_stdin_is_tty()) {  /* running in interactive mode? */
-      print_version();
-      doREPL(L);  /* do read-eval-print loop */
-    }
-    else dofile(L, NULL);  /* executes stdin as a file */
-  }
-  lua_pushboolean(L, 1);  /* signal no errors */
-  return 1;
-}
-
-
-int main (int argc, char **argv) {
-  int status, result;
-  lua_State *L = luaL_newstate();  /* create state */
-  if (L == NULL) {
-    l_message(argv[0], "cannot create state: not enough memory");
-    return EXIT_FAILURE;
-  }
-  lua_gc(L, LUA_GCSTOP);  /* stop GC while building state */
-  lua_pushcfunction(L, &pmain);  /* to call 'pmain' in protected mode */
-  lua_pushinteger(L, argc);  /* 1st argument */
-  lua_pushlightuserdata(L, argv); /* 2nd argument */
-  status = lua_pcall(L, 2, 1, 0);  /* do the call */
-  result = lua_toboolean(L, -1);  /* get result */
-  report(L, status);
-  lua_close(L);
-  return (result && status == LUA_OK) ? EXIT_SUCCESS : EXIT_FAILURE;
-}
-
diff --git a/third-party/lua/src/lua.h b/third-party/lua/src/lua.h
deleted file mode 100644
index 1e83589e0..000000000
--- a/third-party/lua/src/lua.h
+++ /dev/null
@@ -1,523 +0,0 @@
-/*
-** $Id: lua.h $
-** Lua - A Scripting Language
-** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
-** See Copyright Notice at the end of this file
-*/
-
-
-#ifndef lua_h
-#define lua_h
-
-#include <stdarg.h>
-#include <stddef.h>
-
-
-#include "luaconf.h"
-
-
-#define LUA_VERSION_MAJOR	"5"
-#define LUA_VERSION_MINOR	"4"
-#define LUA_VERSION_RELEASE	"6"
-
-#define LUA_VERSION_NUM			504
-#define LUA_VERSION_RELEASE_NUM		(LUA_VERSION_NUM * 100 + 6)
-
-#define LUA_VERSION	"Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
-#define LUA_RELEASE	LUA_VERSION "." LUA_VERSION_RELEASE
-#define LUA_COPYRIGHT	LUA_RELEASE "  Copyright (C) 1994-2023 Lua.org, PUC-Rio"
-#define LUA_AUTHORS	"R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
-
-
-/* mark for precompiled code ('<esc>Lua') */
-#define LUA_SIGNATURE	"\x1bLua"
-
-/* option for multiple returns in 'lua_pcall' and 'lua_call' */
-#define LUA_MULTRET	(-1)
-
-
-/*
-** Pseudo-indices
-** (-LUAI_MAXSTACK is the minimum valid index; we keep some free empty
-** space after that to help overflow detection)
-*/
-#define LUA_REGISTRYINDEX	(-LUAI_MAXSTACK - 1000)
-#define lua_upvalueindex(i)	(LUA_REGISTRYINDEX - (i))
-
-
-/* thread status */
-#define LUA_OK		0
-#define LUA_YIELD	1
-#define LUA_ERRRUN	2
-#define LUA_ERRSYNTAX	3
-#define LUA_ERRMEM	4
-#define LUA_ERRERR	5
-
-
-typedef struct lua_State lua_State;
-
-
-/*
-** basic types
-*/
-#define LUA_TNONE		(-1)
-
-#define LUA_TNIL		0
-#define LUA_TBOOLEAN 		1
-#define LUA_TLIGHTUSERDATA	2
-#define LUA_TNUMBER		3
-#define LUA_TSTRING		4
-#define LUA_TTABLE		5
-#define LUA_TFUNCTION		6
-#define LUA_TUSERDATA		7
-#define LUA_TTHREAD		8
-
-#define LUA_NUMTYPES		9
-
-
-
-/* minimum Lua stack available to a C function */
-#define LUA_MINSTACK	20
-
-
-/* predefined values in the registry */
-#define LUA_RIDX_MAINTHREAD	1
-#define LUA_RIDX_GLOBALS	2
-#define LUA_RIDX_LAST		LUA_RIDX_GLOBALS
-
-
-/* type of numbers in Lua */
-typedef LUA_NUMBER lua_Number;
-
-
-/* type for integer functions */
-typedef LUA_INTEGER lua_Integer;
-
-/* unsigned integer type */
-typedef LUA_UNSIGNED lua_Unsigned;
-
-/* type for continuation-function contexts */
-typedef LUA_KCONTEXT lua_KContext;
-
-
-/*
-** Type for C functions registered with Lua
-*/
-typedef int (*lua_CFunction) (lua_State *L);
-
-/*
-** Type for continuation functions
-*/
-typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx);
-
-
-/*
-** Type for functions that read/write blocks when loading/dumping Lua chunks
-*/
-typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
-
-typedef int (*lua_Writer) (lua_State *L, const void *p, size_t sz, void *ud);
-
-
-/*
-** Type for memory-allocation functions
-*/
-typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
-
-
-/*
-** Type for warning functions
-*/
-typedef void (*lua_WarnFunction) (void *ud, const char *msg, int tocont);
-
-
-/*
-** Type used by the debug API to collect debug information
-*/
-typedef struct lua_Debug lua_Debug;
-
-
-/*
-** Functions to be called by the debugger in specific events
-*/
-typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
-
-
-/*
-** generic extra include file
-*/
-#if defined(LUA_USER_H)
-#include LUA_USER_H
-#endif
-
-
-/*
-** RCS ident string
-*/
-extern const char lua_ident[];
-
-
-/*
-** state manipulation
-*/
-LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);
-LUA_API void       (lua_close) (lua_State *L);
-LUA_API lua_State *(lua_newthread) (lua_State *L);
-LUA_API int        (lua_closethread) (lua_State *L, lua_State *from);
-LUA_API int        (lua_resetthread) (lua_State *L);  /* Deprecated! */
-
-LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
-
-
-LUA_API lua_Number (lua_version) (lua_State *L);
-
-
-/*
-** basic stack manipulation
-*/
-LUA_API int   (lua_absindex) (lua_State *L, int idx);
-LUA_API int   (lua_gettop) (lua_State *L);
-LUA_API void  (lua_settop) (lua_State *L, int idx);
-LUA_API void  (lua_pushvalue) (lua_State *L, int idx);
-LUA_API void  (lua_rotate) (lua_State *L, int idx, int n);
-LUA_API void  (lua_copy) (lua_State *L, int fromidx, int toidx);
-LUA_API int   (lua_checkstack) (lua_State *L, int n);
-
-LUA_API void  (lua_xmove) (lua_State *from, lua_State *to, int n);
-
-
-/*
-** access functions (stack -> C)
-*/
-
-LUA_API int             (lua_isnumber) (lua_State *L, int idx);
-LUA_API int             (lua_isstring) (lua_State *L, int idx);
-LUA_API int             (lua_iscfunction) (lua_State *L, int idx);
-LUA_API int             (lua_isinteger) (lua_State *L, int idx);
-LUA_API int             (lua_isuserdata) (lua_State *L, int idx);
-LUA_API int             (lua_type) (lua_State *L, int idx);
-LUA_API const char     *(lua_typename) (lua_State *L, int tp);
-
-LUA_API lua_Number      (lua_tonumberx) (lua_State *L, int idx, int *isnum);
-LUA_API lua_Integer     (lua_tointegerx) (lua_State *L, int idx, int *isnum);
-LUA_API int             (lua_toboolean) (lua_State *L, int idx);
-LUA_API const char     *(lua_tolstring) (lua_State *L, int idx, size_t *len);
-LUA_API lua_Unsigned    (lua_rawlen) (lua_State *L, int idx);
-LUA_API lua_CFunction   (lua_tocfunction) (lua_State *L, int idx);
-LUA_API void	       *(lua_touserdata) (lua_State *L, int idx);
-LUA_API lua_State      *(lua_tothread) (lua_State *L, int idx);
-LUA_API const void     *(lua_topointer) (lua_State *L, int idx);
-
-
-/*
-** Comparison and arithmetic functions
-*/
-
-#define LUA_OPADD	0	/* ORDER TM, ORDER OP */
-#define LUA_OPSUB	1
-#define LUA_OPMUL	2
-#define LUA_OPMOD	3
-#define LUA_OPPOW	4
-#define LUA_OPDIV	5
-#define LUA_OPIDIV	6
-#define LUA_OPBAND	7
-#define LUA_OPBOR	8
-#define LUA_OPBXOR	9
-#define LUA_OPSHL	10
-#define LUA_OPSHR	11
-#define LUA_OPUNM	12
-#define LUA_OPBNOT	13
-
-LUA_API void  (lua_arith) (lua_State *L, int op);
-
-#define LUA_OPEQ	0
-#define LUA_OPLT	1
-#define LUA_OPLE	2
-
-LUA_API int   (lua_rawequal) (lua_State *L, int idx1, int idx2);
-LUA_API int   (lua_compare) (lua_State *L, int idx1, int idx2, int op);
-
-
-/*
-** push functions (C -> stack)
-*/
-LUA_API void        (lua_pushnil) (lua_State *L);
-LUA_API void        (lua_pushnumber) (lua_State *L, lua_Number n);
-LUA_API void        (lua_pushinteger) (lua_State *L, lua_Integer n);
-LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t len);
-LUA_API const char *(lua_pushstring) (lua_State *L, const char *s);
-LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,
-                                                      va_list argp);
-LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);
-LUA_API void  (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);
-LUA_API void  (lua_pushboolean) (lua_State *L, int b);
-LUA_API void  (lua_pushlightuserdata) (lua_State *L, void *p);
-LUA_API int   (lua_pushthread) (lua_State *L);
-
-
-/*
-** get functions (Lua -> stack)
-*/
-LUA_API int (lua_getglobal) (lua_State *L, const char *name);
-LUA_API int (lua_gettable) (lua_State *L, int idx);
-LUA_API int (lua_getfield) (lua_State *L, int idx, const char *k);
-LUA_API int (lua_geti) (lua_State *L, int idx, lua_Integer n);
-LUA_API int (lua_rawget) (lua_State *L, int idx);
-LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n);
-LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p);
-
-LUA_API void  (lua_createtable) (lua_State *L, int narr, int nrec);
-LUA_API void *(lua_newuserdatauv) (lua_State *L, size_t sz, int nuvalue);
-LUA_API int   (lua_getmetatable) (lua_State *L, int objindex);
-LUA_API int  (lua_getiuservalue) (lua_State *L, int idx, int n);
-
-
-/*
-** set functions (stack -> Lua)
-*/
-LUA_API void  (lua_setglobal) (lua_State *L, const char *name);
-LUA_API void  (lua_settable) (lua_State *L, int idx);
-LUA_API void  (lua_setfield) (lua_State *L, int idx, const char *k);
-LUA_API void  (lua_seti) (lua_State *L, int idx, lua_Integer n);
-LUA_API void  (lua_rawset) (lua_State *L, int idx);
-LUA_API void  (lua_rawseti) (lua_State *L, int idx, lua_Integer n);
-LUA_API void  (lua_rawsetp) (lua_State *L, int idx, const void *p);
-LUA_API int   (lua_setmetatable) (lua_State *L, int objindex);
-LUA_API int   (lua_setiuservalue) (lua_State *L, int idx, int n);
-
-
-/*
-** 'load' and 'call' functions (load and run Lua code)
-*/
-LUA_API void  (lua_callk) (lua_State *L, int nargs, int nresults,
-                           lua_KContext ctx, lua_KFunction k);
-#define lua_call(L,n,r)		lua_callk(L, (n), (r), 0, NULL)
-
-LUA_API int   (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc,
-                            lua_KContext ctx, lua_KFunction k);
-#define lua_pcall(L,n,r,f)	lua_pcallk(L, (n), (r), (f), 0, NULL)
-
-LUA_API int   (lua_load) (lua_State *L, lua_Reader reader, void *dt,
-                          const char *chunkname, const char *mode);
-
-LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip);
-
-
-/*
-** coroutine functions
-*/
-LUA_API int  (lua_yieldk)     (lua_State *L, int nresults, lua_KContext ctx,
-                               lua_KFunction k);
-LUA_API int  (lua_resume)     (lua_State *L, lua_State *from, int narg,
-                               int *nres);
-LUA_API int  (lua_status)     (lua_State *L);
-LUA_API int (lua_isyieldable) (lua_State *L);
-
-#define lua_yield(L,n)		lua_yieldk(L, (n), 0, NULL)
-
-
-/*
-** Warning-related functions
-*/
-LUA_API void (lua_setwarnf) (lua_State *L, lua_WarnFunction f, void *ud);
-LUA_API void (lua_warning)  (lua_State *L, const char *msg, int tocont);
-
-
-/*
-** garbage-collection function and options
-*/
-
-#define LUA_GCSTOP		0
-#define LUA_GCRESTART		1
-#define LUA_GCCOLLECT		2
-#define LUA_GCCOUNT		3
-#define LUA_GCCOUNTB		4
-#define LUA_GCSTEP		5
-#define LUA_GCSETPAUSE		6
-#define LUA_GCSETSTEPMUL	7
-#define LUA_GCISRUNNING		9
-#define LUA_GCGEN		10
-#define LUA_GCINC		11
-
-LUA_API int (lua_gc) (lua_State *L, int what, ...);
-
-
-/*
-** miscellaneous functions
-*/
-
-LUA_API int   (lua_error) (lua_State *L);
-
-LUA_API int   (lua_next) (lua_State *L, int idx);
-
-LUA_API void  (lua_concat) (lua_State *L, int n);
-LUA_API void  (lua_len)    (lua_State *L, int idx);
-
-LUA_API size_t   (lua_stringtonumber) (lua_State *L, const char *s);
-
-LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
-LUA_API void      (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);
-
-LUA_API void (lua_toclose) (lua_State *L, int idx);
-LUA_API void (lua_closeslot) (lua_State *L, int idx);
-
-
-/*
-** {==============================================================
-** some useful macros
-** ===============================================================
-*/
-
-#define lua_getextraspace(L)	((void *)((char *)(L) - LUA_EXTRASPACE))
-
-#define lua_tonumber(L,i)	lua_tonumberx(L,(i),NULL)
-#define lua_tointeger(L,i)	lua_tointegerx(L,(i),NULL)
-
-#define lua_pop(L,n)		lua_settop(L, -(n)-1)
-
-#define lua_newtable(L)		lua_createtable(L, 0, 0)
-
-#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
-
-#define lua_pushcfunction(L,f)	lua_pushcclosure(L, (f), 0)
-
-#define lua_isfunction(L,n)	(lua_type(L, (n)) == LUA_TFUNCTION)
-#define lua_istable(L,n)	(lua_type(L, (n)) == LUA_TTABLE)
-#define lua_islightuserdata(L,n)	(lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
-#define lua_isnil(L,n)		(lua_type(L, (n)) == LUA_TNIL)
-#define lua_isboolean(L,n)	(lua_type(L, (n)) == LUA_TBOOLEAN)
-#define lua_isthread(L,n)	(lua_type(L, (n)) == LUA_TTHREAD)
-#define lua_isnone(L,n)		(lua_type(L, (n)) == LUA_TNONE)
-#define lua_isnoneornil(L, n)	(lua_type(L, (n)) <= 0)
-
-#define lua_pushliteral(L, s)	lua_pushstring(L, "" s)
-
-#define lua_pushglobaltable(L)  \
-	((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS))
-
-#define lua_tostring(L,i)	lua_tolstring(L, (i), NULL)
-
-
-#define lua_insert(L,idx)	lua_rotate(L, (idx), 1)
-
-#define lua_remove(L,idx)	(lua_rotate(L, (idx), -1), lua_pop(L, 1))
-
-#define lua_replace(L,idx)	(lua_copy(L, -1, (idx)), lua_pop(L, 1))
-
-/* }============================================================== */
-
-
-/*
-** {==============================================================
-** compatibility macros
-** ===============================================================
-*/
-#if defined(LUA_COMPAT_APIINTCASTS)
-
-#define lua_pushunsigned(L,n)	lua_pushinteger(L, (lua_Integer)(n))
-#define lua_tounsignedx(L,i,is)	((lua_Unsigned)lua_tointegerx(L,i,is))
-#define lua_tounsigned(L,i)	lua_tounsignedx(L,(i),NULL)
-
-#endif
-
-#define lua_newuserdata(L,s)	lua_newuserdatauv(L,s,1)
-#define lua_getuservalue(L,idx)	lua_getiuservalue(L,idx,1)
-#define lua_setuservalue(L,idx)	lua_setiuservalue(L,idx,1)
-
-#define LUA_NUMTAGS		LUA_NUMTYPES
-
-/* }============================================================== */
-
-/*
-** {======================================================================
-** Debug API
-** =======================================================================
-*/
-
-
-/*
-** Event codes
-*/
-#define LUA_HOOKCALL	0
-#define LUA_HOOKRET	1
-#define LUA_HOOKLINE	2
-#define LUA_HOOKCOUNT	3
-#define LUA_HOOKTAILCALL 4
-
-
-/*
-** Event masks
-*/
-#define LUA_MASKCALL	(1 << LUA_HOOKCALL)
-#define LUA_MASKRET	(1 << LUA_HOOKRET)
-#define LUA_MASKLINE	(1 << LUA_HOOKLINE)
-#define LUA_MASKCOUNT	(1 << LUA_HOOKCOUNT)
-
-
-LUA_API int (lua_getstack) (lua_State *L, int level, lua_Debug *ar);
-LUA_API int (lua_getinfo) (lua_State *L, const char *what, lua_Debug *ar);
-LUA_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n);
-LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n);
-LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n);
-LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n);
-
-LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n);
-LUA_API void  (lua_upvaluejoin) (lua_State *L, int fidx1, int n1,
-                                               int fidx2, int n2);
-
-LUA_API void (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count);
-LUA_API lua_Hook (lua_gethook) (lua_State *L);
-LUA_API int (lua_gethookmask) (lua_State *L);
-LUA_API int (lua_gethookcount) (lua_State *L);
-
-LUA_API int (lua_setcstacklimit) (lua_State *L, unsigned int limit);
-
-struct lua_Debug {
-  int event;
-  const char *name;	/* (n) */
-  const char *namewhat;	/* (n) 'global', 'local', 'field', 'method' */
-  const char *what;	/* (S) 'Lua', 'C', 'main', 'tail' */
-  const char *source;	/* (S) */
-  size_t srclen;	/* (S) */
-  int currentline;	/* (l) */
-  int linedefined;	/* (S) */
-  int lastlinedefined;	/* (S) */
-  unsigned char nups;	/* (u) number of upvalues */
-  unsigned char nparams;/* (u) number of parameters */
-  char isvararg;        /* (u) */
-  char istailcall;	/* (t) */
-  unsigned short ftransfer;   /* (r) index of first value transferred */
-  unsigned short ntransfer;   /* (r) number of transferred values */
-  char short_src[LUA_IDSIZE]; /* (S) */
-  /* private part */
-  struct CallInfo *i_ci;  /* active function */
-};
-
-/* }====================================================================== */
-
-
-/******************************************************************************
-* Copyright (C) 1994-2023 Lua.org, PUC-Rio.
-*
-* Permission is hereby granted, free of charge, to any person obtaining
-* a copy of this software and associated documentation files (the
-* "Software"), to deal in the Software without restriction, including
-* without limitation the rights to use, copy, modify, merge, publish,
-* distribute, sublicense, and/or sell copies of the Software, and to
-* permit persons to whom the Software is furnished to do so, subject to
-* the following conditions:
-*
-* The above copyright notice and this permission notice shall be
-* included in all copies or substantial portions of the Software.
-*
-* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-******************************************************************************/
-
-
-#endif
diff --git a/third-party/lua/src/lua.hpp b/third-party/lua/src/lua.hpp
deleted file mode 100644
index ec417f594..000000000
--- a/third-party/lua/src/lua.hpp
+++ /dev/null
@@ -1,9 +0,0 @@
-// lua.hpp
-// Lua header files for C++
-// <<extern "C">> not supplied automatically because Lua also compiles as C++
-
-extern "C" {
-#include "lua.h"
-#include "lualib.h"
-#include "lauxlib.h"
-}
diff --git a/third-party/lua/src/luac.c b/third-party/lua/src/luac.c
deleted file mode 100644
index 5f4a141bd..000000000
--- a/third-party/lua/src/luac.c
+++ /dev/null
@@ -1,723 +0,0 @@
-/*
-** $Id: luac.c $
-** Lua compiler (saves bytecodes to files; also lists bytecodes)
-** See Copyright Notice in lua.h
-*/
-
-#define luac_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-#include <ctype.h>
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lua.h"
-#include "lauxlib.h"
-
-#include "ldebug.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lopnames.h"
-#include "lstate.h"
-#include "lundump.h"
-
-static void PrintFunction(const Proto* f, int full);
-#define luaU_print	PrintFunction
-
-#define PROGNAME	"luac"		/* default program name */
-#define OUTPUT		PROGNAME ".out"	/* default output file */
-
-static int listing=0;			/* list bytecodes? */
-static int dumping=1;			/* dump bytecodes? */
-static int stripping=0;			/* strip debug information? */
-static char Output[]={ OUTPUT };	/* default output file name */
-static const char* output=Output;	/* actual output file name */
-static const char* progname=PROGNAME;	/* actual program name */
-static TString **tmname;
-
-static void fatal(const char* message)
-{
- fprintf(stderr,"%s: %s\n",progname,message);
- exit(EXIT_FAILURE);
-}
-
-static void cannot(const char* what)
-{
- fprintf(stderr,"%s: cannot %s %s: %s\n",progname,what,output,strerror(errno));
- exit(EXIT_FAILURE);
-}
-
-static void usage(const char* message)
-{
- if (*message=='-')
-  fprintf(stderr,"%s: unrecognized option '%s'\n",progname,message);
- else
-  fprintf(stderr,"%s: %s\n",progname,message);
- fprintf(stderr,
-  "usage: %s [options] [filenames]\n"
-  "Available options are:\n"
-  "  -l       list (use -l -l for full listing)\n"
-  "  -o name  output to file 'name' (default is \"%s\")\n"
-  "  -p       parse only\n"
-  "  -s       strip debug information\n"
-  "  -v       show version information\n"
-  "  --       stop handling options\n"
-  "  -        stop handling options and process stdin\n"
-  ,progname,Output);
- exit(EXIT_FAILURE);
-}
-
-#define IS(s)	(strcmp(argv[i],s)==0)
-
-static int doargs(int argc, char* argv[])
-{
- int i;
- int version=0;
- if (argv[0]!=NULL && *argv[0]!=0) progname=argv[0];
- for (i=1; i<argc; i++)
- {
-  if (*argv[i]!='-')			/* end of options; keep it */
-   break;
-  else if (IS("--"))			/* end of options; skip it */
-  {
-   ++i;
-   if (version) ++version;
-   break;
-  }
-  else if (IS("-"))			/* end of options; use stdin */
-   break;
-  else if (IS("-l"))			/* list */
-   ++listing;
-  else if (IS("-o"))			/* output file */
-  {
-   output=argv[++i];
-   if (output==NULL || *output==0 || (*output=='-' && output[1]!=0))
-    usage("'-o' needs argument");
-   if (IS("-")) output=NULL;
-  }
-  else if (IS("-p"))			/* parse only */
-   dumping=0;
-  else if (IS("-s"))			/* strip debug information */
-   stripping=1;
-  else if (IS("-v"))			/* show version */
-   ++version;
-  else					/* unknown option */
-   usage(argv[i]);
- }
- if (i==argc && (listing || !dumping))
- {
-  dumping=0;
-  argv[--i]=Output;
- }
- if (version)
- {
-  printf("%s\n",LUA_COPYRIGHT);
-  if (version==argc-1) exit(EXIT_SUCCESS);
- }
- return i;
-}
-
-#define FUNCTION "(function()end)();\n"
-
-static const char* reader(lua_State* L, void* ud, size_t* size)
-{
- UNUSED(L);
- if ((*(int*)ud)--)
- {
-  *size=sizeof(FUNCTION)-1;
-  return FUNCTION;
- }
- else
- {
-  *size=0;
-  return NULL;
- }
-}
-
-#define toproto(L,i) getproto(s2v(L->top.p+(i)))
-
-static const Proto* combine(lua_State* L, int n)
-{
- if (n==1)
-  return toproto(L,-1);
- else
- {
-  Proto* f;
-  int i=n;
-  if (lua_load(L,reader,&i,"=(" PROGNAME ")",NULL)!=LUA_OK) fatal(lua_tostring(L,-1));
-  f=toproto(L,-1);
-  for (i=0; i<n; i++)
-  {
-   f->p[i]=toproto(L,i-n-1);
-   if (f->p[i]->sizeupvalues>0) f->p[i]->upvalues[0].instack=0;
-  }
-  return f;
- }
-}
-
-static int writer(lua_State* L, const void* p, size_t size, void* u)
-{
- UNUSED(L);
- return (fwrite(p,size,1,(FILE*)u)!=1) && (size!=0);
-}
-
-static int pmain(lua_State* L)
-{
- int argc=(int)lua_tointeger(L,1);
- char** argv=(char**)lua_touserdata(L,2);
- const Proto* f;
- int i;
- tmname=G(L)->tmname;
- if (!lua_checkstack(L,argc)) fatal("too many input files");
- for (i=0; i<argc; i++)
- {
-  const char* filename=IS("-") ? NULL : argv[i];
-  if (luaL_loadfile(L,filename)!=LUA_OK) fatal(lua_tostring(L,-1));
- }
- f=combine(L,argc);
- if (listing) luaU_print(f,listing>1);
- if (dumping)
- {
-  FILE* D= (output==NULL) ? stdout : fopen(output,"wb");
-  if (D==NULL) cannot("open");
-  lua_lock(L);
-  luaU_dump(L,f,writer,D,stripping);
-  lua_unlock(L);
-  if (ferror(D)) cannot("write");
-  if (fclose(D)) cannot("close");
- }
- return 0;
-}
-
-int main(int argc, char* argv[])
-{
- lua_State* L;
- int i=doargs(argc,argv);
- argc-=i; argv+=i;
- if (argc<=0) usage("no input files given");
- L=luaL_newstate();
- if (L==NULL) fatal("cannot create state: not enough memory");
- lua_pushcfunction(L,&pmain);
- lua_pushinteger(L,argc);
- lua_pushlightuserdata(L,argv);
- if (lua_pcall(L,2,0,0)!=LUA_OK) fatal(lua_tostring(L,-1));
- lua_close(L);
- return EXIT_SUCCESS;
-}
-
-/*
-** print bytecodes
-*/
-
-#define UPVALNAME(x) ((f->upvalues[x].name) ? getstr(f->upvalues[x].name) : "-")
-#define VOID(p) ((const void*)(p))
-#define eventname(i) (getstr(tmname[i]))
-
-static void PrintString(const TString* ts)
-{
- const char* s=getstr(ts);
- size_t i,n=tsslen(ts);
- printf("\"");
- for (i=0; i<n; i++)
- {
-  int c=(int)(unsigned char)s[i];
-  switch (c)
-  {
-   case '"':
-	printf("\\\"");
-	break;
-   case '\\':
-	printf("\\\\");
-	break;
-   case '\a':
-	printf("\\a");
-	break;
-   case '\b':
-	printf("\\b");
-	break;
-   case '\f':
-	printf("\\f");
-	break;
-   case '\n':
-	printf("\\n");
-	break;
-   case '\r':
-	printf("\\r");
-	break;
-   case '\t':
-	printf("\\t");
-	break;
-   case '\v':
-	printf("\\v");
-	break;
-   default:
-	if (isprint(c)) printf("%c",c); else printf("\\%03d",c);
-	break;
-  }
- }
- printf("\"");
-}
-
-static void PrintType(const Proto* f, int i)
-{
- const TValue* o=&f->k[i];
- switch (ttypetag(o))
- {
-  case LUA_VNIL:
-	printf("N");
-	break;
-  case LUA_VFALSE:
-  case LUA_VTRUE:
-	printf("B");
-	break;
-  case LUA_VNUMFLT:
-	printf("F");
-	break;
-  case LUA_VNUMINT:
-	printf("I");
-	break;
-  case LUA_VSHRSTR:
-  case LUA_VLNGSTR:
-	printf("S");
-	break;
-  default:				/* cannot happen */
-	printf("?%d",ttypetag(o));
-	break;
- }
- printf("\t");
-}
-
-static void PrintConstant(const Proto* f, int i)
-{
- const TValue* o=&f->k[i];
- switch (ttypetag(o))
- {
-  case LUA_VNIL:
-	printf("nil");
-	break;
-  case LUA_VFALSE:
-	printf("false");
-	break;
-  case LUA_VTRUE:
-	printf("true");
-	break;
-  case LUA_VNUMFLT:
-	{
-	char buff[100];
-	sprintf(buff,LUA_NUMBER_FMT,fltvalue(o));
-	printf("%s",buff);
-	if (buff[strspn(buff,"-0123456789")]=='\0') printf(".0");
-	break;
-	}
-  case LUA_VNUMINT:
-	printf(LUA_INTEGER_FMT,ivalue(o));
-	break;
-  case LUA_VSHRSTR:
-  case LUA_VLNGSTR:
-	PrintString(tsvalue(o));
-	break;
-  default:				/* cannot happen */
-	printf("?%d",ttypetag(o));
-	break;
- }
-}
-
-#define COMMENT		"\t; "
-#define EXTRAARG	GETARG_Ax(code[pc+1])
-#define EXTRAARGC	(EXTRAARG*(MAXARG_C+1))
-#define ISK		(isk ? "k" : "")
-
-static void PrintCode(const Proto* f)
-{
- const Instruction* code=f->code;
- int pc,n=f->sizecode;
- for (pc=0; pc<n; pc++)
- {
-  Instruction i=code[pc];
-  OpCode o=GET_OPCODE(i);
-  int a=GETARG_A(i);
-  int b=GETARG_B(i);
-  int c=GETARG_C(i);
-  int ax=GETARG_Ax(i);
-  int bx=GETARG_Bx(i);
-  int sb=GETARG_sB(i);
-  int sc=GETARG_sC(i);
-  int sbx=GETARG_sBx(i);
-  int isk=GETARG_k(i);
-  int line=luaG_getfuncline(f,pc);
-  printf("\t%d\t",pc+1);
-  if (line>0) printf("[%d]\t",line); else printf("[-]\t");
-  printf("%-9s\t",opnames[o]);
-  switch (o)
-  {
-   case OP_MOVE:
-	printf("%d %d",a,b);
-	break;
-   case OP_LOADI:
-	printf("%d %d",a,sbx);
-	break;
-   case OP_LOADF:
-	printf("%d %d",a,sbx);
-	break;
-   case OP_LOADK:
-	printf("%d %d",a,bx);
-	printf(COMMENT); PrintConstant(f,bx);
-	break;
-   case OP_LOADKX:
-	printf("%d",a);
-	printf(COMMENT); PrintConstant(f,EXTRAARG);
-	break;
-   case OP_LOADFALSE:
-	printf("%d",a);
-	break;
-   case OP_LFALSESKIP:
-	printf("%d",a);
-	break;
-   case OP_LOADTRUE:
-	printf("%d",a);
-	break;
-   case OP_LOADNIL:
-	printf("%d %d",a,b);
-	printf(COMMENT "%d out",b+1);
-	break;
-   case OP_GETUPVAL:
-	printf("%d %d",a,b);
-	printf(COMMENT "%s",UPVALNAME(b));
-	break;
-   case OP_SETUPVAL:
-	printf("%d %d",a,b);
-	printf(COMMENT "%s",UPVALNAME(b));
-	break;
-   case OP_GETTABUP:
-	printf("%d %d %d",a,b,c);
-	printf(COMMENT "%s",UPVALNAME(b));
-	printf(" "); PrintConstant(f,c);
-	break;
-   case OP_GETTABLE:
-	printf("%d %d %d",a,b,c);
-	break;
-   case OP_GETI:
-	printf("%d %d %d",a,b,c);
-	break;
-   case OP_GETFIELD:
-	printf("%d %d %d",a,b,c);
-	printf(COMMENT); PrintConstant(f,c);
-	break;
-   case OP_SETTABUP:
-	printf("%d %d %d%s",a,b,c,ISK);
-	printf(COMMENT "%s",UPVALNAME(a));
-	printf(" "); PrintConstant(f,b);
-	if (isk) { printf(" "); PrintConstant(f,c); }
-	break;
-   case OP_SETTABLE:
-	printf("%d %d %d%s",a,b,c,ISK);
-	if (isk) { printf(COMMENT); PrintConstant(f,c); }
-	break;
-   case OP_SETI:
-	printf("%d %d %d%s",a,b,c,ISK);
-	if (isk) { printf(COMMENT); PrintConstant(f,c); }
-	break;
-   case OP_SETFIELD:
-	printf("%d %d %d%s",a,b,c,ISK);
-	printf(COMMENT); PrintConstant(f,b);
-	if (isk) { printf(" "); PrintConstant(f,c); }
-	break;
-   case OP_NEWTABLE:
-	printf("%d %d %d",a,b,c);
-	printf(COMMENT "%d",c+EXTRAARGC);
-	break;
-   case OP_SELF:
-	printf("%d %d %d%s",a,b,c,ISK);
-	if (isk) { printf(COMMENT); PrintConstant(f,c); }
-	break;
-   case OP_ADDI:
-	printf("%d %d %d",a,b,sc);
-	break;
-   case OP_ADDK:
-	printf("%d %d %d",a,b,c);
-	printf(COMMENT); PrintConstant(f,c);
-	break;
-   case OP_SUBK:
-	printf("%d %d %d",a,b,c);
-	printf(COMMENT); PrintConstant(f,c);
-	break;
-   case OP_MULK:
-	printf("%d %d %d",a,b,c);
-	printf(COMMENT); PrintConstant(f,c);
-	break;
-   case OP_MODK:
-	printf("%d %d %d",a,b,c);
-	printf(COMMENT); PrintConstant(f,c);
-	break;
-   case OP_POWK:
-	printf("%d %d %d",a,b,c);
-	printf(COMMENT); PrintConstant(f,c);
-	break;
-   case OP_DIVK:
-	printf("%d %d %d",a,b,c);
-	printf(COMMENT); PrintConstant(f,c);
-	break;
-   case OP_IDIVK:
-	printf("%d %d %d",a,b,c);
-	printf(COMMENT); PrintConstant(f,c);
-	break;
-   case OP_BANDK:
-	printf("%d %d %d",a,b,c);
-	printf(COMMENT); PrintConstant(f,c);
-	break;
-   case OP_BORK:
-	printf("%d %d %d",a,b,c);
-	printf(COMMENT); PrintConstant(f,c);
-	break;
-   case OP_BXORK:
-	printf("%d %d %d",a,b,c);
-	printf(COMMENT); PrintConstant(f,c);
-	break;
-   case OP_SHRI:
-	printf("%d %d %d",a,b,sc);
-	break;
-   case OP_SHLI:
-	printf("%d %d %d",a,b,sc);
-	break;
-   case OP_ADD:
-	printf("%d %d %d",a,b,c);
-	break;
-   case OP_SUB:
-	printf("%d %d %d",a,b,c);
-	break;
-   case OP_MUL:
-	printf("%d %d %d",a,b,c);
-	break;
-   case OP_MOD:
-	printf("%d %d %d",a,b,c);
-	break;
-   case OP_POW:
-	printf("%d %d %d",a,b,c);
-	break;
-   case OP_DIV:
-	printf("%d %d %d",a,b,c);
-	break;
-   case OP_IDIV:
-	printf("%d %d %d",a,b,c);
-	break;
-   case OP_BAND:
-	printf("%d %d %d",a,b,c);
-	break;
-   case OP_BOR:
-	printf("%d %d %d",a,b,c);
-	break;
-   case OP_BXOR:
-	printf("%d %d %d",a,b,c);
-	break;
-   case OP_SHL:
-	printf("%d %d %d",a,b,c);
-	break;
-   case OP_SHR:
-	printf("%d %d %d",a,b,c);
-	break;
-   case OP_MMBIN:
-	printf("%d %d %d",a,b,c);
-	printf(COMMENT "%s",eventname(c));
-	break;
-   case OP_MMBINI:
-	printf("%d %d %d %d",a,sb,c,isk);
-	printf(COMMENT "%s",eventname(c));
-	if (isk) printf(" flip");
-	break;
-   case OP_MMBINK:
-	printf("%d %d %d %d",a,b,c,isk);
-	printf(COMMENT "%s ",eventname(c)); PrintConstant(f,b);
-	if (isk) printf(" flip");
-	break;
-   case OP_UNM:
-	printf("%d %d",a,b);
-	break;
-   case OP_BNOT:
-	printf("%d %d",a,b);
-	break;
-   case OP_NOT:
-	printf("%d %d",a,b);
-	break;
-   case OP_LEN:
-	printf("%d %d",a,b);
-	break;
-   case OP_CONCAT:
-	printf("%d %d",a,b);
-	break;
-   case OP_CLOSE:
-	printf("%d",a);
-	break;
-   case OP_TBC:
-	printf("%d",a);
-	break;
-   case OP_JMP:
-	printf("%d",GETARG_sJ(i));
-	printf(COMMENT "to %d",GETARG_sJ(i)+pc+2);
-	break;
-   case OP_EQ:
-	printf("%d %d %d",a,b,isk);
-	break;
-   case OP_LT:
-	printf("%d %d %d",a,b,isk);
-	break;
-   case OP_LE:
-	printf("%d %d %d",a,b,isk);
-	break;
-   case OP_EQK:
-	printf("%d %d %d",a,b,isk);
-	printf(COMMENT); PrintConstant(f,b);
-	break;
-   case OP_EQI:
-	printf("%d %d %d",a,sb,isk);
-	break;
-   case OP_LTI:
-	printf("%d %d %d",a,sb,isk);
-	break;
-   case OP_LEI:
-	printf("%d %d %d",a,sb,isk);
-	break;
-   case OP_GTI:
-	printf("%d %d %d",a,sb,isk);
-	break;
-   case OP_GEI:
-	printf("%d %d %d",a,sb,isk);
-	break;
-   case OP_TEST:
-	printf("%d %d",a,isk);
-	break;
-   case OP_TESTSET:
-	printf("%d %d %d",a,b,isk);
-	break;
-   case OP_CALL:
-	printf("%d %d %d",a,b,c);
-	printf(COMMENT);
-	if (b==0) printf("all in "); else printf("%d in ",b-1);
-	if (c==0) printf("all out"); else printf("%d out",c-1);
-	break;
-   case OP_TAILCALL:
-	printf("%d %d %d%s",a,b,c,ISK);
-	printf(COMMENT "%d in",b-1);
-	break;
-   case OP_RETURN:
-	printf("%d %d %d%s",a,b,c,ISK);
-	printf(COMMENT);
-	if (b==0) printf("all out"); else printf("%d out",b-1);
-	break;
-   case OP_RETURN0:
-	break;
-   case OP_RETURN1:
-	printf("%d",a);
-	break;
-   case OP_FORLOOP:
-	printf("%d %d",a,bx);
-	printf(COMMENT "to %d",pc-bx+2);
-	break;
-   case OP_FORPREP:
-	printf("%d %d",a,bx);
-	printf(COMMENT "exit to %d",pc+bx+3);
-	break;
-   case OP_TFORPREP:
-	printf("%d %d",a,bx);
-	printf(COMMENT "to %d",pc+bx+2);
-	break;
-   case OP_TFORCALL:
-	printf("%d %d",a,c);
-	break;
-   case OP_TFORLOOP:
-	printf("%d %d",a,bx);
-	printf(COMMENT "to %d",pc-bx+2);
-	break;
-   case OP_SETLIST:
-	printf("%d %d %d",a,b,c);
-	if (isk) printf(COMMENT "%d",c+EXTRAARGC);
-	break;
-   case OP_CLOSURE:
-	printf("%d %d",a,bx);
-	printf(COMMENT "%p",VOID(f->p[bx]));
-	break;
-   case OP_VARARG:
-	printf("%d %d",a,c);
-	printf(COMMENT);
-	if (c==0) printf("all out"); else printf("%d out",c-1);
-	break;
-   case OP_VARARGPREP:
-	printf("%d",a);
-	break;
-   case OP_EXTRAARG:
-	printf("%d",ax);
-	break;
-#if 0
-   default:
-	printf("%d %d %d",a,b,c);
-	printf(COMMENT "not handled");
-	break;
-#endif
-  }
-  printf("\n");
- }
-}
-
-
-#define SS(x)	((x==1)?"":"s")
-#define S(x)	(int)(x),SS(x)
-
-static void PrintHeader(const Proto* f)
-{
- const char* s=f->source ? getstr(f->source) : "=?";
- if (*s=='@' || *s=='=')
-  s++;
- else if (*s==LUA_SIGNATURE[0])
-  s="(bstring)";
- else
-  s="(string)";
- printf("\n%s <%s:%d,%d> (%d instruction%s at %p)\n",
-	(f->linedefined==0)?"main":"function",s,
-	f->linedefined,f->lastlinedefined,
-	S(f->sizecode),VOID(f));
- printf("%d%s param%s, %d slot%s, %d upvalue%s, ",
-	(int)(f->numparams),f->is_vararg?"+":"",SS(f->numparams),
-	S(f->maxstacksize),S(f->sizeupvalues));
- printf("%d local%s, %d constant%s, %d function%s\n",
-	S(f->sizelocvars),S(f->sizek),S(f->sizep));
-}
-
-static void PrintDebug(const Proto* f)
-{
- int i,n;
- n=f->sizek;
- printf("constants (%d) for %p:\n",n,VOID(f));
- for (i=0; i<n; i++)
- {
-  printf("\t%d\t",i);
-  PrintType(f,i);
-  PrintConstant(f,i);
-  printf("\n");
- }
- n=f->sizelocvars;
- printf("locals (%d) for %p:\n",n,VOID(f));
- for (i=0; i<n; i++)
- {
-  printf("\t%d\t%s\t%d\t%d\n",
-  i,getstr(f->locvars[i].varname),f->locvars[i].startpc+1,f->locvars[i].endpc+1);
- }
- n=f->sizeupvalues;
- printf("upvalues (%d) for %p:\n",n,VOID(f));
- for (i=0; i<n; i++)
- {
-  printf("\t%d\t%s\t%d\t%d\n",
-  i,UPVALNAME(i),f->upvalues[i].instack,f->upvalues[i].idx);
- }
-}
-
-static void PrintFunction(const Proto* f, int full)
-{
- int i,n=f->sizep;
- PrintHeader(f);
- PrintCode(f);
- if (full) PrintDebug(f);
- for (i=0; i<n; i++) PrintFunction(f->p[i],full);
-}
diff --git a/third-party/lua/src/luaconf.h b/third-party/lua/src/luaconf.h
deleted file mode 100644
index 137103ede..000000000
--- a/third-party/lua/src/luaconf.h
+++ /dev/null
@@ -1,793 +0,0 @@
-/*
-** $Id: luaconf.h $
-** Configuration file for Lua
-** See Copyright Notice in lua.h
-*/
-
-
-#ifndef luaconf_h
-#define luaconf_h
-
-#include <limits.h>
-#include <stddef.h>
-
-
-/*
-** ===================================================================
-** General Configuration File for Lua
-**
-** Some definitions here can be changed externally, through the compiler
-** (e.g., with '-D' options): They are commented out or protected
-** by '#if !defined' guards. However, several other definitions
-** should be changed directly here, either because they affect the
-** Lua ABI (by making the changes here, you ensure that all software
-** connected to Lua, such as C libraries, will be compiled with the same
-** configuration); or because they are seldom changed.
-**
-** Search for "@@" to find all configurable definitions.
-** ===================================================================
-*/
-
-
-/*
-** {====================================================================
-** System Configuration: macros to adapt (if needed) Lua to some
-** particular platform, for instance restricting it to C89.
-** =====================================================================
-*/
-
-/*
-@@ LUA_USE_C89 controls the use of non-ISO-C89 features.
-** Define it if you want Lua to avoid the use of a few C99 features
-** or Windows-specific features on Windows.
-*/
-/* #define LUA_USE_C89 */
-
-
-/*
-** By default, Lua on Windows use (some) specific Windows features
-*/
-#if !defined(LUA_USE_C89) && defined(_WIN32) && !defined(_WIN32_WCE)
-#define LUA_USE_WINDOWS  /* enable goodies for regular Windows */
-#endif
-
-
-#if defined(LUA_USE_WINDOWS)
-#define LUA_DL_DLL	/* enable support for DLL */
-#define LUA_USE_C89	/* broadly, Windows is C89 */
-#endif
-
-
-#if defined(LUA_USE_LINUX)
-#define LUA_USE_POSIX
-#define LUA_USE_DLOPEN		/* needs an extra library: -ldl */
-#endif
-
-
-#if defined(LUA_USE_MACOSX)
-#define LUA_USE_POSIX
-#define LUA_USE_DLOPEN		/* MacOS does not need -ldl */
-#endif
-
-
-#if defined(LUA_USE_IOS)
-#define LUA_USE_POSIX
-#define LUA_USE_DLOPEN
-#endif
-
-
-/*
-@@ LUAI_IS32INT is true iff 'int' has (at least) 32 bits.
-*/
-#define LUAI_IS32INT	((UINT_MAX >> 30) >= 3)
-
-/* }================================================================== */
-
-
-
-/*
-** {==================================================================
-** Configuration for Number types. These options should not be
-** set externally, because any other code connected to Lua must
-** use the same configuration.
-** ===================================================================
-*/
-
-/*
-@@ LUA_INT_TYPE defines the type for Lua integers.
-@@ LUA_FLOAT_TYPE defines the type for Lua floats.
-** Lua should work fine with any mix of these options supported
-** by your C compiler. The usual configurations are 64-bit integers
-** and 'double' (the default), 32-bit integers and 'float' (for
-** restricted platforms), and 'long'/'double' (for C compilers not
-** compliant with C99, which may not have support for 'long long').
-*/
-
-/* predefined options for LUA_INT_TYPE */
-#define LUA_INT_INT		1
-#define LUA_INT_LONG		2
-#define LUA_INT_LONGLONG	3
-
-/* predefined options for LUA_FLOAT_TYPE */
-#define LUA_FLOAT_FLOAT		1
-#define LUA_FLOAT_DOUBLE	2
-#define LUA_FLOAT_LONGDOUBLE	3
-
-
-/* Default configuration ('long long' and 'double', for 64-bit Lua) */
-#define LUA_INT_DEFAULT		LUA_INT_LONGLONG
-#define LUA_FLOAT_DEFAULT	LUA_FLOAT_DOUBLE
-
-
-/*
-@@ LUA_32BITS enables Lua with 32-bit integers and 32-bit floats.
-*/
-#define LUA_32BITS	0
-
-
-/*
-@@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for
-** C89 ('long' and 'double'); Windows always has '__int64', so it does
-** not need to use this case.
-*/
-#if defined(LUA_USE_C89) && !defined(LUA_USE_WINDOWS)
-#define LUA_C89_NUMBERS		1
-#else
-#define LUA_C89_NUMBERS		0
-#endif
-
-
-#if LUA_32BITS		/* { */
-/*
-** 32-bit integers and 'float'
-*/
-#if LUAI_IS32INT  /* use 'int' if big enough */
-#define LUA_INT_TYPE	LUA_INT_INT
-#else  /* otherwise use 'long' */
-#define LUA_INT_TYPE	LUA_INT_LONG
-#endif
-#define LUA_FLOAT_TYPE	LUA_FLOAT_FLOAT
-
-#elif LUA_C89_NUMBERS	/* }{ */
-/*
-** largest types available for C89 ('long' and 'double')
-*/
-#define LUA_INT_TYPE	LUA_INT_LONG
-#define LUA_FLOAT_TYPE	LUA_FLOAT_DOUBLE
-
-#else		/* }{ */
-/* use defaults */
-
-#define LUA_INT_TYPE	LUA_INT_DEFAULT
-#define LUA_FLOAT_TYPE	LUA_FLOAT_DEFAULT
-
-#endif				/* } */
-
-
-/* }================================================================== */
-
-
-
-/*
-** {==================================================================
-** Configuration for Paths.
-** ===================================================================
-*/
-
-/*
-** LUA_PATH_SEP is the character that separates templates in a path.
-** LUA_PATH_MARK is the string that marks the substitution points in a
-** template.
-** LUA_EXEC_DIR in a Windows path is replaced by the executable's
-** directory.
-*/
-#define LUA_PATH_SEP            ";"
-#define LUA_PATH_MARK           "?"
-#define LUA_EXEC_DIR            "!"
-
-
-/*
-@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
-** Lua libraries.
-@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for
-** C libraries.
-** CHANGE them if your machine has a non-conventional directory
-** hierarchy or if you want to install your libraries in
-** non-conventional directories.
-*/
-
-#define LUA_VDIR	LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
-#if defined(_WIN32)	/* { */
-/*
-** In Windows, any exclamation mark ('!') in the path is replaced by the
-** path of the directory of the executable file of the current process.
-*/
-#define LUA_LDIR	"!\\lua\\"
-#define LUA_CDIR	"!\\"
-#define LUA_SHRDIR	"!\\..\\share\\lua\\" LUA_VDIR "\\"
-
-#if !defined(LUA_PATH_DEFAULT)
-#define LUA_PATH_DEFAULT  \
-		LUA_LDIR"?.lua;"  LUA_LDIR"?\\init.lua;" \
-		LUA_CDIR"?.lua;"  LUA_CDIR"?\\init.lua;" \
-		LUA_SHRDIR"?.lua;" LUA_SHRDIR"?\\init.lua;" \
-		".\\?.lua;" ".\\?\\init.lua"
-#endif
-
-#if !defined(LUA_CPATH_DEFAULT)
-#define LUA_CPATH_DEFAULT \
-		LUA_CDIR"?.dll;" \
-		LUA_CDIR"..\\lib\\lua\\" LUA_VDIR "\\?.dll;" \
-		LUA_CDIR"loadall.dll;" ".\\?.dll"
-#endif
-
-#else			/* }{ */
-
-#define LUA_ROOT	"/usr/local/"
-#define LUA_LDIR	LUA_ROOT "share/lua/" LUA_VDIR "/"
-#define LUA_CDIR	LUA_ROOT "lib/lua/" LUA_VDIR "/"
-
-#if !defined(LUA_PATH_DEFAULT)
-#define LUA_PATH_DEFAULT  \
-		LUA_LDIR"?.lua;"  LUA_LDIR"?/init.lua;" \
-		LUA_CDIR"?.lua;"  LUA_CDIR"?/init.lua;" \
-		"./?.lua;" "./?/init.lua"
-#endif
-
-#if !defined(LUA_CPATH_DEFAULT)
-#define LUA_CPATH_DEFAULT \
-		LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so"
-#endif
-
-#endif			/* } */
-
-
-/*
-@@ LUA_DIRSEP is the directory separator (for submodules).
-** CHANGE it if your machine does not use "/" as the directory separator
-** and is not Windows. (On Windows Lua automatically uses "\".)
-*/
-#if !defined(LUA_DIRSEP)
-
-#if defined(_WIN32)
-#define LUA_DIRSEP	"\\"
-#else
-#define LUA_DIRSEP	"/"
-#endif
-
-#endif
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Marks for exported symbols in the C code
-** ===================================================================
-*/
-
-/*
-@@ LUA_API is a mark for all core API functions.
-@@ LUALIB_API is a mark for all auxiliary library functions.
-@@ LUAMOD_API is a mark for all standard library opening functions.
-** CHANGE them if you need to define those functions in some special way.
-** For instance, if you want to create one Windows DLL with the core and
-** the libraries, you may want to use the following definition (define
-** LUA_BUILD_AS_DLL to get it).
-*/
-#if defined(LUA_BUILD_AS_DLL)	/* { */
-
-#if defined(LUA_CORE) || defined(LUA_LIB)	/* { */
-#define LUA_API __declspec(dllexport)
-#else						/* }{ */
-#define LUA_API __declspec(dllimport)
-#endif						/* } */
-
-#else				/* }{ */
-
-#define LUA_API		extern
-
-#endif				/* } */
-
-
-/*
-** More often than not the libs go together with the core.
-*/
-#define LUALIB_API	LUA_API
-#define LUAMOD_API	LUA_API
-
-
-/*
-@@ LUAI_FUNC is a mark for all extern functions that are not to be
-** exported to outside modules.
-@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables,
-** none of which to be exported to outside modules (LUAI_DDEF for
-** definitions and LUAI_DDEC for declarations).
-** CHANGE them if you need to mark them in some special way. Elf/gcc
-** (versions 3.2 and later) mark them as "hidden" to optimize access
-** when Lua is compiled as a shared library. Not all elf targets support
-** this attribute. Unfortunately, gcc does not offer a way to check
-** whether the target offers that support, and those without support
-** give a warning about it. To avoid these warnings, change to the
-** default definition.
-*/
-#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
-    defined(__ELF__)		/* { */
-#define LUAI_FUNC	__attribute__((visibility("internal"))) extern
-#else				/* }{ */
-#define LUAI_FUNC	extern
-#endif				/* } */
-
-#define LUAI_DDEC(dec)	LUAI_FUNC dec
-#define LUAI_DDEF	/* empty */
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Compatibility with previous versions
-** ===================================================================
-*/
-
-/*
-@@ LUA_COMPAT_5_3 controls other macros for compatibility with Lua 5.3.
-** You can define it to get all options, or change specific options
-** to fit your specific needs.
-*/
-#if defined(LUA_COMPAT_5_3)	/* { */
-
-/*
-@@ LUA_COMPAT_MATHLIB controls the presence of several deprecated
-** functions in the mathematical library.
-** (These functions were already officially removed in 5.3;
-** nevertheless they are still available here.)
-*/
-#define LUA_COMPAT_MATHLIB
-
-/*
-@@ LUA_COMPAT_APIINTCASTS controls the presence of macros for
-** manipulating other integer types (lua_pushunsigned, lua_tounsigned,
-** luaL_checkint, luaL_checklong, etc.)
-** (These macros were also officially removed in 5.3, but they are still
-** available here.)
-*/
-#define LUA_COMPAT_APIINTCASTS
-
-
-/*
-@@ LUA_COMPAT_LT_LE controls the emulation of the '__le' metamethod
-** using '__lt'.
-*/
-#define LUA_COMPAT_LT_LE
-
-
-/*
-@@ The following macros supply trivial compatibility for some
-** changes in the API. The macros themselves document how to
-** change your code to avoid using them.
-** (Once more, these macros were officially removed in 5.3, but they are
-** still available here.)
-*/
-#define lua_strlen(L,i)		lua_rawlen(L, (i))
-
-#define lua_objlen(L,i)		lua_rawlen(L, (i))
-
-#define lua_equal(L,idx1,idx2)		lua_compare(L,(idx1),(idx2),LUA_OPEQ)
-#define lua_lessthan(L,idx1,idx2)	lua_compare(L,(idx1),(idx2),LUA_OPLT)
-
-#endif				/* } */
-
-/* }================================================================== */
-
-
-
-/*
-** {==================================================================
-** Configuration for Numbers (low-level part).
-** Change these definitions if no predefined LUA_FLOAT_* / LUA_INT_*
-** satisfy your needs.
-** ===================================================================
-*/
-
-/*
-@@ LUAI_UACNUMBER is the result of a 'default argument promotion'
-@@ over a floating number.
-@@ l_floatatt(x) corrects float attribute 'x' to the proper float type
-** by prefixing it with one of FLT/DBL/LDBL.
-@@ LUA_NUMBER_FRMLEN is the length modifier for writing floats.
-@@ LUA_NUMBER_FMT is the format for writing floats.
-@@ lua_number2str converts a float to a string.
-@@ l_mathop allows the addition of an 'l' or 'f' to all math operations.
-@@ l_floor takes the floor of a float.
-@@ lua_str2number converts a decimal numeral to a number.
-*/
-
-
-/* The following definitions are good for most cases here */
-
-#define l_floor(x)		(l_mathop(floor)(x))
-
-#define lua_number2str(s,sz,n)  \
-	l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n))
-
-/*
-@@ lua_numbertointeger converts a float number with an integral value
-** to an integer, or returns 0 if float is not within the range of
-** a lua_Integer.  (The range comparisons are tricky because of
-** rounding. The tests here assume a two-complement representation,
-** where MININTEGER always has an exact representation as a float;
-** MAXINTEGER may not have one, and therefore its conversion to float
-** may have an ill-defined value.)
-*/
-#define lua_numbertointeger(n,p) \
-  ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \
-   (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \
-      (*(p) = (LUA_INTEGER)(n), 1))
-
-
-/* now the variable definitions */
-
-#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT		/* { single float */
-
-#define LUA_NUMBER	float
-
-#define l_floatatt(n)		(FLT_##n)
-
-#define LUAI_UACNUMBER	double
-
-#define LUA_NUMBER_FRMLEN	""
-#define LUA_NUMBER_FMT		"%.7g"
-
-#define l_mathop(op)		op##f
-
-#define lua_str2number(s,p)	strtof((s), (p))
-
-
-#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE	/* }{ long double */
-
-#define LUA_NUMBER	long double
-
-#define l_floatatt(n)		(LDBL_##n)
-
-#define LUAI_UACNUMBER	long double
-
-#define LUA_NUMBER_FRMLEN	"L"
-#define LUA_NUMBER_FMT		"%.19Lg"
-
-#define l_mathop(op)		op##l
-
-#define lua_str2number(s,p)	strtold((s), (p))
-
-#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE	/* }{ double */
-
-#define LUA_NUMBER	double
-
-#define l_floatatt(n)		(DBL_##n)
-
-#define LUAI_UACNUMBER	double
-
-#define LUA_NUMBER_FRMLEN	""
-#define LUA_NUMBER_FMT		"%.14g"
-
-#define l_mathop(op)		op
-
-#define lua_str2number(s,p)	strtod((s), (p))
-
-#else						/* }{ */
-
-#error "numeric float type not defined"
-
-#endif					/* } */
-
-
-
-/*
-@@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER.
-@@ LUAI_UACINT is the result of a 'default argument promotion'
-@@ over a LUA_INTEGER.
-@@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers.
-@@ LUA_INTEGER_FMT is the format for writing integers.
-@@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER.
-@@ LUA_MININTEGER is the minimum value for a LUA_INTEGER.
-@@ LUA_MAXUNSIGNED is the maximum value for a LUA_UNSIGNED.
-@@ lua_integer2str converts an integer to a string.
-*/
-
-
-/* The following definitions are good for most cases here */
-
-#define LUA_INTEGER_FMT		"%" LUA_INTEGER_FRMLEN "d"
-
-#define LUAI_UACINT		LUA_INTEGER
-
-#define lua_integer2str(s,sz,n)  \
-	l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n))
-
-/*
-** use LUAI_UACINT here to avoid problems with promotions (which
-** can turn a comparison between unsigneds into a signed comparison)
-*/
-#define LUA_UNSIGNED		unsigned LUAI_UACINT
-
-
-/* now the variable definitions */
-
-#if LUA_INT_TYPE == LUA_INT_INT		/* { int */
-
-#define LUA_INTEGER		int
-#define LUA_INTEGER_FRMLEN	""
-
-#define LUA_MAXINTEGER		INT_MAX
-#define LUA_MININTEGER		INT_MIN
-
-#define LUA_MAXUNSIGNED		UINT_MAX
-
-#elif LUA_INT_TYPE == LUA_INT_LONG	/* }{ long */
-
-#define LUA_INTEGER		long
-#define LUA_INTEGER_FRMLEN	"l"
-
-#define LUA_MAXINTEGER		LONG_MAX
-#define LUA_MININTEGER		LONG_MIN
-
-#define LUA_MAXUNSIGNED		ULONG_MAX
-
-#elif LUA_INT_TYPE == LUA_INT_LONGLONG	/* }{ long long */
-
-/* use presence of macro LLONG_MAX as proxy for C99 compliance */
-#if defined(LLONG_MAX)		/* { */
-/* use ISO C99 stuff */
-
-#define LUA_INTEGER		long long
-#define LUA_INTEGER_FRMLEN	"ll"
-
-#define LUA_MAXINTEGER		LLONG_MAX
-#define LUA_MININTEGER		LLONG_MIN
-
-#define LUA_MAXUNSIGNED		ULLONG_MAX
-
-#elif defined(LUA_USE_WINDOWS) /* }{ */
-/* in Windows, can use specific Windows types */
-
-#define LUA_INTEGER		__int64
-#define LUA_INTEGER_FRMLEN	"I64"
-
-#define LUA_MAXINTEGER		_I64_MAX
-#define LUA_MININTEGER		_I64_MIN
-
-#define LUA_MAXUNSIGNED		_UI64_MAX
-
-#else				/* }{ */
-
-#error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \
-  or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)"
-
-#endif				/* } */
-
-#else				/* }{ */
-
-#error "numeric integer type not defined"
-
-#endif				/* } */
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Dependencies with C99 and other C details
-** ===================================================================
-*/
-
-/*
-@@ l_sprintf is equivalent to 'snprintf' or 'sprintf' in C89.
-** (All uses in Lua have only one format item.)
-*/
-#if !defined(LUA_USE_C89)
-#define l_sprintf(s,sz,f,i)	snprintf(s,sz,f,i)
-#else
-#define l_sprintf(s,sz,f,i)	((void)(sz), sprintf(s,f,i))
-#endif
-
-
-/*
-@@ lua_strx2number converts a hexadecimal numeral to a number.
-** In C99, 'strtod' does that conversion. Otherwise, you can
-** leave 'lua_strx2number' undefined and Lua will provide its own
-** implementation.
-*/
-#if !defined(LUA_USE_C89)
-#define lua_strx2number(s,p)		lua_str2number(s,p)
-#endif
-
-
-/*
-@@ lua_pointer2str converts a pointer to a readable string in a
-** non-specified way.
-*/
-#define lua_pointer2str(buff,sz,p)	l_sprintf(buff,sz,"%p",p)
-
-
-/*
-@@ lua_number2strx converts a float to a hexadecimal numeral.
-** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that.
-** Otherwise, you can leave 'lua_number2strx' undefined and Lua will
-** provide its own implementation.
-*/
-#if !defined(LUA_USE_C89)
-#define lua_number2strx(L,b,sz,f,n)  \
-	((void)L, l_sprintf(b,sz,f,(LUAI_UACNUMBER)(n)))
-#endif
-
-
-/*
-** 'strtof' and 'opf' variants for math functions are not valid in
-** C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the
-** availability of these variants. ('math.h' is already included in
-** all files that use these macros.)
-*/
-#if defined(LUA_USE_C89) || (defined(HUGE_VAL) && !defined(HUGE_VALF))
-#undef l_mathop  /* variants not available */
-#undef lua_str2number
-#define l_mathop(op)		(lua_Number)op  /* no variant */
-#define lua_str2number(s,p)	((lua_Number)strtod((s), (p)))
-#endif
-
-
-/*
-@@ LUA_KCONTEXT is the type of the context ('ctx') for continuation
-** functions.  It must be a numerical type; Lua will use 'intptr_t' if
-** available, otherwise it will use 'ptrdiff_t' (the nearest thing to
-** 'intptr_t' in C89)
-*/
-#define LUA_KCONTEXT	ptrdiff_t
-
-#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \
-    __STDC_VERSION__ >= 199901L
-#include <stdint.h>
-#if defined(INTPTR_MAX)  /* even in C99 this type is optional */
-#undef LUA_KCONTEXT
-#define LUA_KCONTEXT	intptr_t
-#endif
-#endif
-
-
-/*
-@@ lua_getlocaledecpoint gets the locale "radix character" (decimal point).
-** Change that if you do not want to use C locales. (Code using this
-** macro must include the header 'locale.h'.)
-*/
-#if !defined(lua_getlocaledecpoint)
-#define lua_getlocaledecpoint()		(localeconv()->decimal_point[0])
-#endif
-
-
-/*
-** macros to improve jump prediction, used mostly for error handling
-** and debug facilities. (Some macros in the Lua API use these macros.
-** Define LUA_NOBUILTIN if you do not want '__builtin_expect' in your
-** code.)
-*/
-#if !defined(luai_likely)
-
-#if defined(__GNUC__) && !defined(LUA_NOBUILTIN)
-#define luai_likely(x)		(__builtin_expect(((x) != 0), 1))
-#define luai_unlikely(x)	(__builtin_expect(((x) != 0), 0))
-#else
-#define luai_likely(x)		(x)
-#define luai_unlikely(x)	(x)
-#endif
-
-#endif
-
-
-#if defined(LUA_CORE) || defined(LUA_LIB)
-/* shorter names for Lua's own use */
-#define l_likely(x)	luai_likely(x)
-#define l_unlikely(x)	luai_unlikely(x)
-#endif
-
-
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Language Variations
-** =====================================================================
-*/
-
-/*
-@@ LUA_NOCVTN2S/LUA_NOCVTS2N control how Lua performs some
-** coercions. Define LUA_NOCVTN2S to turn off automatic coercion from
-** numbers to strings. Define LUA_NOCVTS2N to turn off automatic
-** coercion from strings to numbers.
-*/
-/* #define LUA_NOCVTN2S */
-/* #define LUA_NOCVTS2N */
-
-
-/*
-@@ LUA_USE_APICHECK turns on several consistency checks on the C API.
-** Define it as a help when debugging C code.
-*/
-#if defined(LUA_USE_APICHECK)
-#include <assert.h>
-#define luai_apicheck(l,e)	assert(e)
-#endif
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Macros that affect the API and must be stable (that is, must be the
-** same when you compile Lua and when you compile code that links to
-** Lua).
-** =====================================================================
-*/
-
-/*
-@@ LUAI_MAXSTACK limits the size of the Lua stack.
-** CHANGE it if you need a different limit. This limit is arbitrary;
-** its only purpose is to stop Lua from consuming unlimited stack
-** space (and to reserve some numbers for pseudo-indices).
-** (It must fit into max(size_t)/32 and max(int)/2.)
-*/
-#if LUAI_IS32INT
-#define LUAI_MAXSTACK		1000000
-#else
-#define LUAI_MAXSTACK		15000
-#endif
-
-
-/*
-@@ LUA_EXTRASPACE defines the size of a raw memory area associated with
-** a Lua state with very fast access.
-** CHANGE it if you need a different size.
-*/
-#define LUA_EXTRASPACE		(sizeof(void *))
-
-
-/*
-@@ LUA_IDSIZE gives the maximum size for the description of the source
-** of a function in debug information.
-** CHANGE it if you want a different size.
-*/
-#define LUA_IDSIZE	60
-
-
-/*
-@@ LUAL_BUFFERSIZE is the initial buffer size used by the lauxlib
-** buffer system.
-*/
-#define LUAL_BUFFERSIZE   ((int)(16 * sizeof(void*) * sizeof(lua_Number)))
-
-
-/*
-@@ LUAI_MAXALIGN defines fields that, when used in a union, ensure
-** maximum alignment for the other items in that union.
-*/
-#define LUAI_MAXALIGN  lua_Number n; double u; void *s; lua_Integer i; long l
-
-/* }================================================================== */
-
-
-
-
-
-/* =================================================================== */
-
-/*
-** Local configuration. You can use this space to add your redefinitions
-** without modifying the main part of the file.
-*/
-
-
-
-
-
-#endif
-
diff --git a/third-party/lua/src/lualib.h b/third-party/lua/src/lualib.h
deleted file mode 100644
index 262552907..000000000
--- a/third-party/lua/src/lualib.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-** $Id: lualib.h $
-** Lua standard libraries
-** See Copyright Notice in lua.h
-*/
-
-
-#ifndef lualib_h
-#define lualib_h
-
-#include "lua.h"
-
-
-/* version suffix for environment variable names */
-#define LUA_VERSUFFIX          "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR
-
-
-LUAMOD_API int (luaopen_base) (lua_State *L);
-
-#define LUA_COLIBNAME	"coroutine"
-LUAMOD_API int (luaopen_coroutine) (lua_State *L);
-
-#define LUA_TABLIBNAME	"table"
-LUAMOD_API int (luaopen_table) (lua_State *L);
-
-#define LUA_IOLIBNAME	"io"
-LUAMOD_API int (luaopen_io) (lua_State *L);
-
-#define LUA_OSLIBNAME	"os"
-LUAMOD_API int (luaopen_os) (lua_State *L);
-
-#define LUA_STRLIBNAME	"string"
-LUAMOD_API int (luaopen_string) (lua_State *L);
-
-#define LUA_UTF8LIBNAME	"utf8"
-LUAMOD_API int (luaopen_utf8) (lua_State *L);
-
-#define LUA_MATHLIBNAME	"math"
-LUAMOD_API int (luaopen_math) (lua_State *L);
-
-#define LUA_DBLIBNAME	"debug"
-LUAMOD_API int (luaopen_debug) (lua_State *L);
-
-#define LUA_LOADLIBNAME	"package"
-LUAMOD_API int (luaopen_package) (lua_State *L);
-
-
-/* open all previous libraries */
-LUALIB_API void (luaL_openlibs) (lua_State *L);
-
-
-#endif
diff --git a/third-party/lua/src/lundump.c b/third-party/lua/src/lundump.c
deleted file mode 100644
index 02aed64fb..000000000
--- a/third-party/lua/src/lundump.c
+++ /dev/null
@@ -1,335 +0,0 @@
-/*
-** $Id: lundump.c $
-** load precompiled Lua chunks
-** See Copyright Notice in lua.h
-*/
-
-#define lundump_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <limits.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstring.h"
-#include "lundump.h"
-#include "lzio.h"
-
-
-#if !defined(luai_verifycode)
-#define luai_verifycode(L,f)  /* empty */
-#endif
-
-
-typedef struct {
-  lua_State *L;
-  ZIO *Z;
-  const char *name;
-} LoadState;
-
-
-static l_noret error (LoadState *S, const char *why) {
-  luaO_pushfstring(S->L, "%s: bad binary format (%s)", S->name, why);
-  luaD_throw(S->L, LUA_ERRSYNTAX);
-}
-
-
-/*
-** All high-level loads go through loadVector; you can change it to
-** adapt to the endianness of the input
-*/
-#define loadVector(S,b,n)	loadBlock(S,b,(n)*sizeof((b)[0]))
-
-static void loadBlock (LoadState *S, void *b, size_t size) {
-  if (luaZ_read(S->Z, b, size) != 0)
-    error(S, "truncated chunk");
-}
-
-
-#define loadVar(S,x)		loadVector(S,&x,1)
-
-
-static lu_byte loadByte (LoadState *S) {
-  int b = zgetc(S->Z);
-  if (b == EOZ)
-    error(S, "truncated chunk");
-  return cast_byte(b);
-}
-
-
-static size_t loadUnsigned (LoadState *S, size_t limit) {
-  size_t x = 0;
-  int b;
-  limit >>= 7;
-  do {
-    b = loadByte(S);
-    if (x >= limit)
-      error(S, "integer overflow");
-    x = (x << 7) | (b & 0x7f);
-  } while ((b & 0x80) == 0);
-  return x;
-}
-
-
-static size_t loadSize (LoadState *S) {
-  return loadUnsigned(S, ~(size_t)0);
-}
-
-
-static int loadInt (LoadState *S) {
-  return cast_int(loadUnsigned(S, INT_MAX));
-}
-
-
-static lua_Number loadNumber (LoadState *S) {
-  lua_Number x;
-  loadVar(S, x);
-  return x;
-}
-
-
-static lua_Integer loadInteger (LoadState *S) {
-  lua_Integer x;
-  loadVar(S, x);
-  return x;
-}
-
-
-/*
-** Load a nullable string into prototype 'p'.
-*/
-static TString *loadStringN (LoadState *S, Proto *p) {
-  lua_State *L = S->L;
-  TString *ts;
-  size_t size = loadSize(S);
-  if (size == 0)  /* no string? */
-    return NULL;
-  else if (--size <= LUAI_MAXSHORTLEN) {  /* short string? */
-    char buff[LUAI_MAXSHORTLEN];
-    loadVector(S, buff, size);  /* load string into buffer */
-    ts = luaS_newlstr(L, buff, size);  /* create string */
-  }
-  else {  /* long string */
-    ts = luaS_createlngstrobj(L, size);  /* create string */
-    setsvalue2s(L, L->top.p, ts);  /* anchor it ('loadVector' can GC) */
-    luaD_inctop(L);
-    loadVector(S, getstr(ts), size);  /* load directly in final place */
-    L->top.p--;  /* pop string */
-  }
-  luaC_objbarrier(L, p, ts);
-  return ts;
-}
-
-
-/*
-** Load a non-nullable string into prototype 'p'.
-*/
-static TString *loadString (LoadState *S, Proto *p) {
-  TString *st = loadStringN(S, p);
-  if (st == NULL)
-    error(S, "bad format for constant string");
-  return st;
-}
-
-
-static void loadCode (LoadState *S, Proto *f) {
-  int n = loadInt(S);
-  f->code = luaM_newvectorchecked(S->L, n, Instruction);
-  f->sizecode = n;
-  loadVector(S, f->code, n);
-}
-
-
-static void loadFunction(LoadState *S, Proto *f, TString *psource);
-
-
-static void loadConstants (LoadState *S, Proto *f) {
-  int i;
-  int n = loadInt(S);
-  f->k = luaM_newvectorchecked(S->L, n, TValue);
-  f->sizek = n;
-  for (i = 0; i < n; i++)
-    setnilvalue(&f->k[i]);
-  for (i = 0; i < n; i++) {
-    TValue *o = &f->k[i];
-    int t = loadByte(S);
-    switch (t) {
-      case LUA_VNIL:
-        setnilvalue(o);
-        break;
-      case LUA_VFALSE:
-        setbfvalue(o);
-        break;
-      case LUA_VTRUE:
-        setbtvalue(o);
-        break;
-      case LUA_VNUMFLT:
-        setfltvalue(o, loadNumber(S));
-        break;
-      case LUA_VNUMINT:
-        setivalue(o, loadInteger(S));
-        break;
-      case LUA_VSHRSTR:
-      case LUA_VLNGSTR:
-        setsvalue2n(S->L, o, loadString(S, f));
-        break;
-      default: lua_assert(0);
-    }
-  }
-}
-
-
-static void loadProtos (LoadState *S, Proto *f) {
-  int i;
-  int n = loadInt(S);
-  f->p = luaM_newvectorchecked(S->L, n, Proto *);
-  f->sizep = n;
-  for (i = 0; i < n; i++)
-    f->p[i] = NULL;
-  for (i = 0; i < n; i++) {
-    f->p[i] = luaF_newproto(S->L);
-    luaC_objbarrier(S->L, f, f->p[i]);
-    loadFunction(S, f->p[i], f->source);
-  }
-}
-
-
-/*
-** Load the upvalues for a function. The names must be filled first,
-** because the filling of the other fields can raise read errors and
-** the creation of the error message can call an emergency collection;
-** in that case all prototypes must be consistent for the GC.
-*/
-static void loadUpvalues (LoadState *S, Proto *f) {
-  int i, n;
-  n = loadInt(S);
-  f->upvalues = luaM_newvectorchecked(S->L, n, Upvaldesc);
-  f->sizeupvalues = n;
-  for (i = 0; i < n; i++)  /* make array valid for GC */
-    f->upvalues[i].name = NULL;
-  for (i = 0; i < n; i++) {  /* following calls can raise errors */
-    f->upvalues[i].instack = loadByte(S);
-    f->upvalues[i].idx = loadByte(S);
-    f->upvalues[i].kind = loadByte(S);
-  }
-}
-
-
-static void loadDebug (LoadState *S, Proto *f) {
-  int i, n;
-  n = loadInt(S);
-  f->lineinfo = luaM_newvectorchecked(S->L, n, ls_byte);
-  f->sizelineinfo = n;
-  loadVector(S, f->lineinfo, n);
-  n = loadInt(S);
-  f->abslineinfo = luaM_newvectorchecked(S->L, n, AbsLineInfo);
-  f->sizeabslineinfo = n;
-  for (i = 0; i < n; i++) {
-    f->abslineinfo[i].pc = loadInt(S);
-    f->abslineinfo[i].line = loadInt(S);
-  }
-  n = loadInt(S);
-  f->locvars = luaM_newvectorchecked(S->L, n, LocVar);
-  f->sizelocvars = n;
-  for (i = 0; i < n; i++)
-    f->locvars[i].varname = NULL;
-  for (i = 0; i < n; i++) {
-    f->locvars[i].varname = loadStringN(S, f);
-    f->locvars[i].startpc = loadInt(S);
-    f->locvars[i].endpc = loadInt(S);
-  }
-  n = loadInt(S);
-  if (n != 0)  /* does it have debug information? */
-    n = f->sizeupvalues;  /* must be this many */
-  for (i = 0; i < n; i++)
-    f->upvalues[i].name = loadStringN(S, f);
-}
-
-
-static void loadFunction (LoadState *S, Proto *f, TString *psource) {
-  f->source = loadStringN(S, f);
-  if (f->source == NULL)  /* no source in dump? */
-    f->source = psource;  /* reuse parent's source */
-  f->linedefined = loadInt(S);
-  f->lastlinedefined = loadInt(S);
-  f->numparams = loadByte(S);
-  f->is_vararg = loadByte(S);
-  f->maxstacksize = loadByte(S);
-  loadCode(S, f);
-  loadConstants(S, f);
-  loadUpvalues(S, f);
-  loadProtos(S, f);
-  loadDebug(S, f);
-}
-
-
-static void checkliteral (LoadState *S, const char *s, const char *msg) {
-  char buff[sizeof(LUA_SIGNATURE) + sizeof(LUAC_DATA)]; /* larger than both */
-  size_t len = strlen(s);
-  loadVector(S, buff, len);
-  if (memcmp(s, buff, len) != 0)
-    error(S, msg);
-}
-
-
-static void fchecksize (LoadState *S, size_t size, const char *tname) {
-  if (loadByte(S) != size)
-    error(S, luaO_pushfstring(S->L, "%s size mismatch", tname));
-}
-
-
-#define checksize(S,t)	fchecksize(S,sizeof(t),#t)
-
-static void checkHeader (LoadState *S) {
-  /* skip 1st char (already read and checked) */
-  checkliteral(S, &LUA_SIGNATURE[1], "not a binary chunk");
-  if (loadByte(S) != LUAC_VERSION)
-    error(S, "version mismatch");
-  if (loadByte(S) != LUAC_FORMAT)
-    error(S, "format mismatch");
-  checkliteral(S, LUAC_DATA, "corrupted chunk");
-  checksize(S, Instruction);
-  checksize(S, lua_Integer);
-  checksize(S, lua_Number);
-  if (loadInteger(S) != LUAC_INT)
-    error(S, "integer format mismatch");
-  if (loadNumber(S) != LUAC_NUM)
-    error(S, "float format mismatch");
-}
-
-
-/*
-** Load precompiled chunk.
-*/
-LClosure *luaU_undump(lua_State *L, ZIO *Z, const char *name) {
-  LoadState S;
-  LClosure *cl;
-  if (*name == '@' || *name == '=')
-    S.name = name + 1;
-  else if (*name == LUA_SIGNATURE[0])
-    S.name = "binary string";
-  else
-    S.name = name;
-  S.L = L;
-  S.Z = Z;
-  checkHeader(&S);
-  cl = luaF_newLclosure(L, loadByte(&S));
-  setclLvalue2s(L, L->top.p, cl);
-  luaD_inctop(L);
-  cl->p = luaF_newproto(L);
-  luaC_objbarrier(L, cl, cl->p);
-  loadFunction(&S, cl->p, NULL);
-  lua_assert(cl->nupvalues == cl->p->sizeupvalues);
-  luai_verifycode(L, cl->p);
-  return cl;
-}
-
diff --git a/third-party/lua/src/lundump.h b/third-party/lua/src/lundump.h
deleted file mode 100644
index f3748a998..000000000
--- a/third-party/lua/src/lundump.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
-** $Id: lundump.h $
-** load precompiled Lua chunks
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lundump_h
-#define lundump_h
-
-#include "llimits.h"
-#include "lobject.h"
-#include "lzio.h"
-
-
-/* data to catch conversion errors */
-#define LUAC_DATA	"\x19\x93\r\n\x1a\n"
-
-#define LUAC_INT	0x5678
-#define LUAC_NUM	cast_num(370.5)
-
-/*
-** Encode major-minor version in one byte, one nibble for each
-*/
-#define MYINT(s)	(s[0]-'0')  /* assume one-digit numerals */
-#define LUAC_VERSION	(MYINT(LUA_VERSION_MAJOR)*16+MYINT(LUA_VERSION_MINOR))
-
-#define LUAC_FORMAT	0	/* this is the official format */
-
-/* load one chunk; from lundump.c */
-LUAI_FUNC LClosure* luaU_undump (lua_State* L, ZIO* Z, const char* name);
-
-/* dump one chunk; from ldump.c */
-LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w,
-                         void* data, int strip);
-
-#endif
diff --git a/third-party/lua/src/lutf8lib.c b/third-party/lua/src/lutf8lib.c
deleted file mode 100644
index 3a5b9bc38..000000000
--- a/third-party/lua/src/lutf8lib.c
+++ /dev/null
@@ -1,291 +0,0 @@
-/*
-** $Id: lutf8lib.c $
-** Standard library for UTF-8 manipulation
-** See Copyright Notice in lua.h
-*/
-
-#define lutf8lib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include <assert.h>
-#include <limits.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-#define MAXUNICODE	0x10FFFFu
-
-#define MAXUTF		0x7FFFFFFFu
-
-
-#define MSGInvalid	"invalid UTF-8 code"
-
-/*
-** Integer type for decoded UTF-8 values; MAXUTF needs 31 bits.
-*/
-#if (UINT_MAX >> 30) >= 1
-typedef unsigned int utfint;
-#else
-typedef unsigned long utfint;
-#endif
-
-
-#define iscont(c)	(((c) & 0xC0) == 0x80)
-#define iscontp(p)	iscont(*(p))
-
-
-/* from strlib */
-/* translate a relative string position: negative means back from end */
-static lua_Integer u_posrelat (lua_Integer pos, size_t len) {
-  if (pos >= 0) return pos;
-  else if (0u - (size_t)pos > len) return 0;
-  else return (lua_Integer)len + pos + 1;
-}
-
-
-/*
-** Decode one UTF-8 sequence, returning NULL if byte sequence is
-** invalid.  The array 'limits' stores the minimum value for each
-** sequence length, to check for overlong representations. Its first
-** entry forces an error for non-ascii bytes with no continuation
-** bytes (count == 0).
-*/
-static const char *utf8_decode (const char *s, utfint *val, int strict) {
-  static const utfint limits[] =
-        {~(utfint)0, 0x80, 0x800, 0x10000u, 0x200000u, 0x4000000u};
-  unsigned int c = (unsigned char)s[0];
-  utfint res = 0;  /* final result */
-  if (c < 0x80)  /* ascii? */
-    res = c;
-  else {
-    int count = 0;  /* to count number of continuation bytes */
-    for (; c & 0x40; c <<= 1) {  /* while it needs continuation bytes... */
-      unsigned int cc = (unsigned char)s[++count];  /* read next byte */
-      if (!iscont(cc))  /* not a continuation byte? */
-        return NULL;  /* invalid byte sequence */
-      res = (res << 6) | (cc & 0x3F);  /* add lower 6 bits from cont. byte */
-    }
-    res |= ((utfint)(c & 0x7F) << (count * 5));  /* add first byte */
-    if (count > 5 || res > MAXUTF || res < limits[count])
-      return NULL;  /* invalid byte sequence */
-    s += count;  /* skip continuation bytes read */
-  }
-  if (strict) {
-    /* check for invalid code points; too large or surrogates */
-    if (res > MAXUNICODE || (0xD800u <= res && res <= 0xDFFFu))
-      return NULL;
-  }
-  if (val) *val = res;
-  return s + 1;  /* +1 to include first byte */
-}
-
-
-/*
-** utf8len(s [, i [, j [, lax]]]) --> number of characters that
-** start in the range [i,j], or nil + current position if 's' is not
-** well formed in that interval
-*/
-static int utflen (lua_State *L) {
-  lua_Integer n = 0;  /* counter for the number of characters */
-  size_t len;  /* string length in bytes */
-  const char *s = luaL_checklstring(L, 1, &len);
-  lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), len);
-  lua_Integer posj = u_posrelat(luaL_optinteger(L, 3, -1), len);
-  int lax = lua_toboolean(L, 4);
-  luaL_argcheck(L, 1 <= posi && --posi <= (lua_Integer)len, 2,
-                   "initial position out of bounds");
-  luaL_argcheck(L, --posj < (lua_Integer)len, 3,
-                   "final position out of bounds");
-  while (posi <= posj) {
-    const char *s1 = utf8_decode(s + posi, NULL, !lax);
-    if (s1 == NULL) {  /* conversion error? */
-      luaL_pushfail(L);  /* return fail ... */
-      lua_pushinteger(L, posi + 1);  /* ... and current position */
-      return 2;
-    }
-    posi = s1 - s;
-    n++;
-  }
-  lua_pushinteger(L, n);
-  return 1;
-}
-
-
-/*
-** codepoint(s, [i, [j [, lax]]]) -> returns codepoints for all
-** characters that start in the range [i,j]
-*/
-static int codepoint (lua_State *L) {
-  size_t len;
-  const char *s = luaL_checklstring(L, 1, &len);
-  lua_Integer posi = u_posrelat(luaL_optinteger(L, 2, 1), len);
-  lua_Integer pose = u_posrelat(luaL_optinteger(L, 3, posi), len);
-  int lax = lua_toboolean(L, 4);
-  int n;
-  const char *se;
-  luaL_argcheck(L, posi >= 1, 2, "out of bounds");
-  luaL_argcheck(L, pose <= (lua_Integer)len, 3, "out of bounds");
-  if (posi > pose) return 0;  /* empty interval; return no values */
-  if (pose - posi >= INT_MAX)  /* (lua_Integer -> int) overflow? */
-    return luaL_error(L, "string slice too long");
-  n = (int)(pose -  posi) + 1;  /* upper bound for number of returns */
-  luaL_checkstack(L, n, "string slice too long");
-  n = 0;  /* count the number of returns */
-  se = s + pose;  /* string end */
-  for (s += posi - 1; s < se;) {
-    utfint code;
-    s = utf8_decode(s, &code, !lax);
-    if (s == NULL)
-      return luaL_error(L, MSGInvalid);
-    lua_pushinteger(L, code);
-    n++;
-  }
-  return n;
-}
-
-
-static void pushutfchar (lua_State *L, int arg) {
-  lua_Unsigned code = (lua_Unsigned)luaL_checkinteger(L, arg);
-  luaL_argcheck(L, code <= MAXUTF, arg, "value out of range");
-  lua_pushfstring(L, "%U", (long)code);
-}
-
-
-/*
-** utfchar(n1, n2, ...)  -> char(n1)..char(n2)...
-*/
-static int utfchar (lua_State *L) {
-  int n = lua_gettop(L);  /* number of arguments */
-  if (n == 1)  /* optimize common case of single char */
-    pushutfchar(L, 1);
-  else {
-    int i;
-    luaL_Buffer b;
-    luaL_buffinit(L, &b);
-    for (i = 1; i <= n; i++) {
-      pushutfchar(L, i);
-      luaL_addvalue(&b);
-    }
-    luaL_pushresult(&b);
-  }
-  return 1;
-}
-
-
-/*
-** offset(s, n, [i])  -> index where n-th character counting from
-**   position 'i' starts; 0 means character at 'i'.
-*/
-static int byteoffset (lua_State *L) {
-  size_t len;
-  const char *s = luaL_checklstring(L, 1, &len);
-  lua_Integer n  = luaL_checkinteger(L, 2);
-  lua_Integer posi = (n >= 0) ? 1 : len + 1;
-  posi = u_posrelat(luaL_optinteger(L, 3, posi), len);
-  luaL_argcheck(L, 1 <= posi && --posi <= (lua_Integer)len, 3,
-                   "position out of bounds");
-  if (n == 0) {
-    /* find beginning of current byte sequence */
-    while (posi > 0 && iscontp(s + posi)) posi--;
-  }
-  else {
-    if (iscontp(s + posi))
-      return luaL_error(L, "initial position is a continuation byte");
-    if (n < 0) {
-       while (n < 0 && posi > 0) {  /* move back */
-         do {  /* find beginning of previous character */
-           posi--;
-         } while (posi > 0 && iscontp(s + posi));
-         n++;
-       }
-     }
-     else {
-       n--;  /* do not move for 1st character */
-       while (n > 0 && posi < (lua_Integer)len) {
-         do {  /* find beginning of next character */
-           posi++;
-         } while (iscontp(s + posi));  /* (cannot pass final '\0') */
-         n--;
-       }
-     }
-  }
-  if (n == 0)  /* did it find given character? */
-    lua_pushinteger(L, posi + 1);
-  else  /* no such character */
-    luaL_pushfail(L);
-  return 1;
-}
-
-
-static int iter_aux (lua_State *L, int strict) {
-  size_t len;
-  const char *s = luaL_checklstring(L, 1, &len);
-  lua_Unsigned n = (lua_Unsigned)lua_tointeger(L, 2);
-  if (n < len) {
-    while (iscontp(s + n)) n++;  /* go to next character */
-  }
-  if (n >= len)  /* (also handles original 'n' being negative) */
-    return 0;  /* no more codepoints */
-  else {
-    utfint code;
-    const char *next = utf8_decode(s + n, &code, strict);
-    if (next == NULL || iscontp(next))
-      return luaL_error(L, MSGInvalid);
-    lua_pushinteger(L, n + 1);
-    lua_pushinteger(L, code);
-    return 2;
-  }
-}
-
-
-static int iter_auxstrict (lua_State *L) {
-  return iter_aux(L, 1);
-}
-
-static int iter_auxlax (lua_State *L) {
-  return iter_aux(L, 0);
-}
-
-
-static int iter_codes (lua_State *L) {
-  int lax = lua_toboolean(L, 2);
-  const char *s = luaL_checkstring(L, 1);
-  luaL_argcheck(L, !iscontp(s), 1, MSGInvalid);
-  lua_pushcfunction(L, lax ? iter_auxlax : iter_auxstrict);
-  lua_pushvalue(L, 1);
-  lua_pushinteger(L, 0);
-  return 3;
-}
-
-
-/* pattern to match a single UTF-8 character */
-#define UTF8PATT	"[\0-\x7F\xC2-\xFD][\x80-\xBF]*"
-
-
-static const luaL_Reg funcs[] = {
-  {"offset", byteoffset},
-  {"codepoint", codepoint},
-  {"char", utfchar},
-  {"len", utflen},
-  {"codes", iter_codes},
-  /* placeholders */
-  {"charpattern", NULL},
-  {NULL, NULL}
-};
-
-
-LUAMOD_API int luaopen_utf8 (lua_State *L) {
-  luaL_newlib(L, funcs);
-  lua_pushlstring(L, UTF8PATT, sizeof(UTF8PATT)/sizeof(char) - 1);
-  lua_setfield(L, -2, "charpattern");
-  return 1;
-}
-
diff --git a/third-party/lua/src/lvm.c b/third-party/lua/src/lvm.c
deleted file mode 100644
index 8493a770c..000000000
--- a/third-party/lua/src/lvm.c
+++ /dev/null
@@ -1,1901 +0,0 @@
-/*
-** $Id: lvm.c $
-** Lua virtual machine
-** See Copyright Notice in lua.h
-*/
-
-#define lvm_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-#include <float.h>
-#include <limits.h>
-#include <math.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lua.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lgc.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-#include "lvm.h"
-
-
-/*
-** By default, use jump tables in the main interpreter loop on gcc
-** and compatible compilers.
-*/
-#if !defined(LUA_USE_JUMPTABLE)
-#if defined(__GNUC__)
-#define LUA_USE_JUMPTABLE	1
-#else
-#define LUA_USE_JUMPTABLE	0
-#endif
-#endif
-
-
-
-/* limit for table tag-method chains (to avoid infinite loops) */
-#define MAXTAGLOOP	2000
-
-
-/*
-** 'l_intfitsf' checks whether a given integer is in the range that
-** can be converted to a float without rounding. Used in comparisons.
-*/
-
-/* number of bits in the mantissa of a float */
-#define NBM		(l_floatatt(MANT_DIG))
-
-/*
-** Check whether some integers may not fit in a float, testing whether
-** (maxinteger >> NBM) > 0. (That implies (1 << NBM) <= maxinteger.)
-** (The shifts are done in parts, to avoid shifting by more than the size
-** of an integer. In a worst case, NBM == 113 for long double and
-** sizeof(long) == 32.)
-*/
-#if ((((LUA_MAXINTEGER >> (NBM / 4)) >> (NBM / 4)) >> (NBM / 4)) \
-	>> (NBM - (3 * (NBM / 4))))  >  0
-
-/* limit for integers that fit in a float */
-#define MAXINTFITSF	((lua_Unsigned)1 << NBM)
-
-/* check whether 'i' is in the interval [-MAXINTFITSF, MAXINTFITSF] */
-#define l_intfitsf(i)	((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF))
-
-#else  /* all integers fit in a float precisely */
-
-#define l_intfitsf(i)	1
-
-#endif
-
-
-/*
-** Try to convert a value from string to a number value.
-** If the value is not a string or is a string not representing
-** a valid numeral (or if coercions from strings to numbers
-** are disabled via macro 'cvt2num'), do not modify 'result'
-** and return 0.
-*/
-static int l_strton (const TValue *obj, TValue *result) {
-  lua_assert(obj != result);
-  if (!cvt2num(obj))  /* is object not a string? */
-    return 0;
-  else
-    return (luaO_str2num(svalue(obj), result) == vslen(obj) + 1);
-}
-
-
-/*
-** Try to convert a value to a float. The float case is already handled
-** by the macro 'tonumber'.
-*/
-int luaV_tonumber_ (const TValue *obj, lua_Number *n) {
-  TValue v;
-  if (ttisinteger(obj)) {
-    *n = cast_num(ivalue(obj));
-    return 1;
-  }
-  else if (l_strton(obj, &v)) {  /* string coercible to number? */
-    *n = nvalue(&v);  /* convert result of 'luaO_str2num' to a float */
-    return 1;
-  }
-  else
-    return 0;  /* conversion failed */
-}
-
-
-/*
-** try to convert a float to an integer, rounding according to 'mode'.
-*/
-int luaV_flttointeger (lua_Number n, lua_Integer *p, F2Imod mode) {
-  lua_Number f = l_floor(n);
-  if (n != f) {  /* not an integral value? */
-    if (mode == F2Ieq) return 0;  /* fails if mode demands integral value */
-    else if (mode == F2Iceil)  /* needs ceil? */
-      f += 1;  /* convert floor to ceil (remember: n != f) */
-  }
-  return lua_numbertointeger(f, p);
-}
-
-
-/*
-** try to convert a value to an integer, rounding according to 'mode',
-** without string coercion.
-** ("Fast track" handled by macro 'tointegerns'.)
-*/
-int luaV_tointegerns (const TValue *obj, lua_Integer *p, F2Imod mode) {
-  if (ttisfloat(obj))
-    return luaV_flttointeger(fltvalue(obj), p, mode);
-  else if (ttisinteger(obj)) {
-    *p = ivalue(obj);
-    return 1;
-  }
-  else
-    return 0;
-}
-
-
-/*
-** try to convert a value to an integer.
-*/
-int luaV_tointeger (const TValue *obj, lua_Integer *p, F2Imod mode) {
-  TValue v;
-  if (l_strton(obj, &v))  /* does 'obj' point to a numerical string? */
-    obj = &v;  /* change it to point to its corresponding number */
-  return luaV_tointegerns(obj, p, mode);
-}
-
-
-/*
-** Try to convert a 'for' limit to an integer, preserving the semantics
-** of the loop. Return true if the loop must not run; otherwise, '*p'
-** gets the integer limit.
-** (The following explanation assumes a positive step; it is valid for
-** negative steps mutatis mutandis.)
-** If the limit is an integer or can be converted to an integer,
-** rounding down, that is the limit.
-** Otherwise, check whether the limit can be converted to a float. If
-** the float is too large, clip it to LUA_MAXINTEGER.  If the float
-** is too negative, the loop should not run, because any initial
-** integer value is greater than such limit; so, the function returns
-** true to signal that. (For this latter case, no integer limit would be
-** correct; even a limit of LUA_MININTEGER would run the loop once for
-** an initial value equal to LUA_MININTEGER.)
-*/
-static int forlimit (lua_State *L, lua_Integer init, const TValue *lim,
-                                   lua_Integer *p, lua_Integer step) {
-  if (!luaV_tointeger(lim, p, (step < 0 ? F2Iceil : F2Ifloor))) {
-    /* not coercible to in integer */
-    lua_Number flim;  /* try to convert to float */
-    if (!tonumber(lim, &flim)) /* cannot convert to float? */
-      luaG_forerror(L, lim, "limit");
-    /* else 'flim' is a float out of integer bounds */
-    if (luai_numlt(0, flim)) {  /* if it is positive, it is too large */
-      if (step < 0) return 1;  /* initial value must be less than it */
-      *p = LUA_MAXINTEGER;  /* truncate */
-    }
-    else {  /* it is less than min integer */
-      if (step > 0) return 1;  /* initial value must be greater than it */
-      *p = LUA_MININTEGER;  /* truncate */
-    }
-  }
-  return (step > 0 ? init > *p : init < *p);  /* not to run? */
-}
-
-
-/*
-** Prepare a numerical for loop (opcode OP_FORPREP).
-** Return true to skip the loop. Otherwise,
-** after preparation, stack will be as follows:
-**   ra : internal index (safe copy of the control variable)
-**   ra + 1 : loop counter (integer loops) or limit (float loops)
-**   ra + 2 : step
-**   ra + 3 : control variable
-*/
-static int forprep (lua_State *L, StkId ra) {
-  TValue *pinit = s2v(ra);
-  TValue *plimit = s2v(ra + 1);
-  TValue *pstep = s2v(ra + 2);
-  if (ttisinteger(pinit) && ttisinteger(pstep)) { /* integer loop? */
-    lua_Integer init = ivalue(pinit);
-    lua_Integer step = ivalue(pstep);
-    lua_Integer limit;
-    if (step == 0)
-      luaG_runerror(L, "'for' step is zero");
-    setivalue(s2v(ra + 3), init);  /* control variable */
-    if (forlimit(L, init, plimit, &limit, step))
-      return 1;  /* skip the loop */
-    else {  /* prepare loop counter */
-      lua_Unsigned count;
-      if (step > 0) {  /* ascending loop? */
-        count = l_castS2U(limit) - l_castS2U(init);
-        if (step != 1)  /* avoid division in the too common case */
-          count /= l_castS2U(step);
-      }
-      else {  /* step < 0; descending loop */
-        count = l_castS2U(init) - l_castS2U(limit);
-        /* 'step+1' avoids negating 'mininteger' */
-        count /= l_castS2U(-(step + 1)) + 1u;
-      }
-      /* store the counter in place of the limit (which won't be
-         needed anymore) */
-      setivalue(plimit, l_castU2S(count));
-    }
-  }
-  else {  /* try making all values floats */
-    lua_Number init; lua_Number limit; lua_Number step;
-    if (l_unlikely(!tonumber(plimit, &limit)))
-      luaG_forerror(L, plimit, "limit");
-    if (l_unlikely(!tonumber(pstep, &step)))
-      luaG_forerror(L, pstep, "step");
-    if (l_unlikely(!tonumber(pinit, &init)))
-      luaG_forerror(L, pinit, "initial value");
-    if (step == 0)
-      luaG_runerror(L, "'for' step is zero");
-    if (luai_numlt(0, step) ? luai_numlt(limit, init)
-                            : luai_numlt(init, limit))
-      return 1;  /* skip the loop */
-    else {
-      /* make sure internal values are all floats */
-      setfltvalue(plimit, limit);
-      setfltvalue(pstep, step);
-      setfltvalue(s2v(ra), init);  /* internal index */
-      setfltvalue(s2v(ra + 3), init);  /* control variable */
-    }
-  }
-  return 0;
-}
-
-
-/*
-** Execute a step of a float numerical for loop, returning
-** true iff the loop must continue. (The integer case is
-** written online with opcode OP_FORLOOP, for performance.)
-*/
-static int floatforloop (StkId ra) {
-  lua_Number step = fltvalue(s2v(ra + 2));
-  lua_Number limit = fltvalue(s2v(ra + 1));
-  lua_Number idx = fltvalue(s2v(ra));  /* internal index */
-  idx = luai_numadd(L, idx, step);  /* increment index */
-  if (luai_numlt(0, step) ? luai_numle(idx, limit)
-                          : luai_numle(limit, idx)) {
-    chgfltvalue(s2v(ra), idx);  /* update internal index */
-    setfltvalue(s2v(ra + 3), idx);  /* and control variable */
-    return 1;  /* jump back */
-  }
-  else
-    return 0;  /* finish the loop */
-}
-
-
-/*
-** Finish the table access 'val = t[key]'.
-** if 'slot' is NULL, 't' is not a table; otherwise, 'slot' points to
-** t[k] entry (which must be empty).
-*/
-void luaV_finishget (lua_State *L, const TValue *t, TValue *key, StkId val,
-                      const TValue *slot) {
-  int loop;  /* counter to avoid infinite loops */
-  const TValue *tm;  /* metamethod */
-  for (loop = 0; loop < MAXTAGLOOP; loop++) {
-    if (slot == NULL) {  /* 't' is not a table? */
-      lua_assert(!ttistable(t));
-      tm = luaT_gettmbyobj(L, t, TM_INDEX);
-      if (l_unlikely(notm(tm)))
-        luaG_typeerror(L, t, "index");  /* no metamethod */
-      /* else will try the metamethod */
-    }
-    else {  /* 't' is a table */
-      lua_assert(isempty(slot));
-      tm = fasttm(L, hvalue(t)->metatable, TM_INDEX);  /* table's metamethod */
-      if (tm == NULL) {  /* no metamethod? */
-        setnilvalue(s2v(val));  /* result is nil */
-        return;
-      }
-      /* else will try the metamethod */
-    }
-    if (ttisfunction(tm)) {  /* is metamethod a function? */
-      luaT_callTMres(L, tm, t, key, val);  /* call it */
-      return;
-    }
-    t = tm;  /* else try to access 'tm[key]' */
-    if (luaV_fastget(L, t, key, slot, luaH_get)) {  /* fast track? */
-      setobj2s(L, val, slot);  /* done */
-      return;
-    }
-    /* else repeat (tail call 'luaV_finishget') */
-  }
-  luaG_runerror(L, "'__index' chain too long; possible loop");
-}
-
-
-/*
-** Finish a table assignment 't[key] = val'.
-** If 'slot' is NULL, 't' is not a table.  Otherwise, 'slot' points
-** to the entry 't[key]', or to a value with an absent key if there
-** is no such entry.  (The value at 'slot' must be empty, otherwise
-** 'luaV_fastget' would have done the job.)
-*/
-void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
-                     TValue *val, const TValue *slot) {
-  int loop;  /* counter to avoid infinite loops */
-  for (loop = 0; loop < MAXTAGLOOP; loop++) {
-    const TValue *tm;  /* '__newindex' metamethod */
-    if (slot != NULL) {  /* is 't' a table? */
-      Table *h = hvalue(t);  /* save 't' table */
-      lua_assert(isempty(slot));  /* slot must be empty */
-      tm = fasttm(L, h->metatable, TM_NEWINDEX);  /* get metamethod */
-      if (tm == NULL) {  /* no metamethod? */
-        luaH_finishset(L, h, key, slot, val);  /* set new value */
-        invalidateTMcache(h);
-        luaC_barrierback(L, obj2gco(h), val);
-        return;
-      }
-      /* else will try the metamethod */
-    }
-    else {  /* not a table; check metamethod */
-      tm = luaT_gettmbyobj(L, t, TM_NEWINDEX);
-      if (l_unlikely(notm(tm)))
-        luaG_typeerror(L, t, "index");
-    }
-    /* try the metamethod */
-    if (ttisfunction(tm)) {
-      luaT_callTM(L, tm, t, key, val);
-      return;
-    }
-    t = tm;  /* else repeat assignment over 'tm' */
-    if (luaV_fastget(L, t, key, slot, luaH_get)) {
-      luaV_finishfastset(L, t, slot, val);
-      return;  /* done */
-    }
-    /* else 'return luaV_finishset(L, t, key, val, slot)' (loop) */
-  }
-  luaG_runerror(L, "'__newindex' chain too long; possible loop");
-}
-
-
-/*
-** Compare two strings 'ls' x 'rs', returning an integer less-equal-
-** -greater than zero if 'ls' is less-equal-greater than 'rs'.
-** The code is a little tricky because it allows '\0' in the strings
-** and it uses 'strcoll' (to respect locales) for each segments
-** of the strings.
-*/
-static int l_strcmp (const TString *ls, const TString *rs) {
-  const char *l = getstr(ls);
-  size_t ll = tsslen(ls);
-  const char *r = getstr(rs);
-  size_t lr = tsslen(rs);
-  for (;;) {  /* for each segment */
-    int temp = strcoll(l, r);
-    if (temp != 0)  /* not equal? */
-      return temp;  /* done */
-    else {  /* strings are equal up to a '\0' */
-      size_t len = strlen(l);  /* index of first '\0' in both strings */
-      if (len == lr)  /* 'rs' is finished? */
-        return (len == ll) ? 0 : 1;  /* check 'ls' */
-      else if (len == ll)  /* 'ls' is finished? */
-        return -1;  /* 'ls' is less than 'rs' ('rs' is not finished) */
-      /* both strings longer than 'len'; go on comparing after the '\0' */
-      len++;
-      l += len; ll -= len; r += len; lr -= len;
-    }
-  }
-}
-
-
-/*
-** Check whether integer 'i' is less than float 'f'. If 'i' has an
-** exact representation as a float ('l_intfitsf'), compare numbers as
-** floats. Otherwise, use the equivalence 'i < f <=> i < ceil(f)'.
-** If 'ceil(f)' is out of integer range, either 'f' is greater than
-** all integers or less than all integers.
-** (The test with 'l_intfitsf' is only for performance; the else
-** case is correct for all values, but it is slow due to the conversion
-** from float to int.)
-** When 'f' is NaN, comparisons must result in false.
-*/
-l_sinline int LTintfloat (lua_Integer i, lua_Number f) {
-  if (l_intfitsf(i))
-    return luai_numlt(cast_num(i), f);  /* compare them as floats */
-  else {  /* i < f <=> i < ceil(f) */
-    lua_Integer fi;
-    if (luaV_flttointeger(f, &fi, F2Iceil))  /* fi = ceil(f) */
-      return i < fi;   /* compare them as integers */
-    else  /* 'f' is either greater or less than all integers */
-      return f > 0;  /* greater? */
-  }
-}
-
-
-/*
-** Check whether integer 'i' is less than or equal to float 'f'.
-** See comments on previous function.
-*/
-l_sinline int LEintfloat (lua_Integer i, lua_Number f) {
-  if (l_intfitsf(i))
-    return luai_numle(cast_num(i), f);  /* compare them as floats */
-  else {  /* i <= f <=> i <= floor(f) */
-    lua_Integer fi;
-    if (luaV_flttointeger(f, &fi, F2Ifloor))  /* fi = floor(f) */
-      return i <= fi;   /* compare them as integers */
-    else  /* 'f' is either greater or less than all integers */
-      return f > 0;  /* greater? */
-  }
-}
-
-
-/*
-** Check whether float 'f' is less than integer 'i'.
-** See comments on previous function.
-*/
-l_sinline int LTfloatint (lua_Number f, lua_Integer i) {
-  if (l_intfitsf(i))
-    return luai_numlt(f, cast_num(i));  /* compare them as floats */
-  else {  /* f < i <=> floor(f) < i */
-    lua_Integer fi;
-    if (luaV_flttointeger(f, &fi, F2Ifloor))  /* fi = floor(f) */
-      return fi < i;   /* compare them as integers */
-    else  /* 'f' is either greater or less than all integers */
-      return f < 0;  /* less? */
-  }
-}
-
-
-/*
-** Check whether float 'f' is less than or equal to integer 'i'.
-** See comments on previous function.
-*/
-l_sinline int LEfloatint (lua_Number f, lua_Integer i) {
-  if (l_intfitsf(i))
-    return luai_numle(f, cast_num(i));  /* compare them as floats */
-  else {  /* f <= i <=> ceil(f) <= i */
-    lua_Integer fi;
-    if (luaV_flttointeger(f, &fi, F2Iceil))  /* fi = ceil(f) */
-      return fi <= i;   /* compare them as integers */
-    else  /* 'f' is either greater or less than all integers */
-      return f < 0;  /* less? */
-  }
-}
-
-
-/*
-** Return 'l < r', for numbers.
-*/
-l_sinline int LTnum (const TValue *l, const TValue *r) {
-  lua_assert(ttisnumber(l) && ttisnumber(r));
-  if (ttisinteger(l)) {
-    lua_Integer li = ivalue(l);
-    if (ttisinteger(r))
-      return li < ivalue(r);  /* both are integers */
-    else  /* 'l' is int and 'r' is float */
-      return LTintfloat(li, fltvalue(r));  /* l < r ? */
-  }
-  else {
-    lua_Number lf = fltvalue(l);  /* 'l' must be float */
-    if (ttisfloat(r))
-      return luai_numlt(lf, fltvalue(r));  /* both are float */
-    else  /* 'l' is float and 'r' is int */
-      return LTfloatint(lf, ivalue(r));
-  }
-}
-
-
-/*
-** Return 'l <= r', for numbers.
-*/
-l_sinline int LEnum (const TValue *l, const TValue *r) {
-  lua_assert(ttisnumber(l) && ttisnumber(r));
-  if (ttisinteger(l)) {
-    lua_Integer li = ivalue(l);
-    if (ttisinteger(r))
-      return li <= ivalue(r);  /* both are integers */
-    else  /* 'l' is int and 'r' is float */
-      return LEintfloat(li, fltvalue(r));  /* l <= r ? */
-  }
-  else {
-    lua_Number lf = fltvalue(l);  /* 'l' must be float */
-    if (ttisfloat(r))
-      return luai_numle(lf, fltvalue(r));  /* both are float */
-    else  /* 'l' is float and 'r' is int */
-      return LEfloatint(lf, ivalue(r));
-  }
-}
-
-
-/*
-** return 'l < r' for non-numbers.
-*/
-static int lessthanothers (lua_State *L, const TValue *l, const TValue *r) {
-  lua_assert(!ttisnumber(l) || !ttisnumber(r));
-  if (ttisstring(l) && ttisstring(r))  /* both are strings? */
-    return l_strcmp(tsvalue(l), tsvalue(r)) < 0;
-  else
-    return luaT_callorderTM(L, l, r, TM_LT);
-}
-
-
-/*
-** Main operation less than; return 'l < r'.
-*/
-int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) {
-  if (ttisnumber(l) && ttisnumber(r))  /* both operands are numbers? */
-    return LTnum(l, r);
-  else return lessthanothers(L, l, r);
-}
-
-
-/*
-** return 'l <= r' for non-numbers.
-*/
-static int lessequalothers (lua_State *L, const TValue *l, const TValue *r) {
-  lua_assert(!ttisnumber(l) || !ttisnumber(r));
-  if (ttisstring(l) && ttisstring(r))  /* both are strings? */
-    return l_strcmp(tsvalue(l), tsvalue(r)) <= 0;
-  else
-    return luaT_callorderTM(L, l, r, TM_LE);
-}
-
-
-/*
-** Main operation less than or equal to; return 'l <= r'.
-*/
-int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r) {
-  if (ttisnumber(l) && ttisnumber(r))  /* both operands are numbers? */
-    return LEnum(l, r);
-  else return lessequalothers(L, l, r);
-}
-
-
-/*
-** Main operation for equality of Lua values; return 't1 == t2'.
-** L == NULL means raw equality (no metamethods)
-*/
-int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2) {
-  const TValue *tm;
-  if (ttypetag(t1) != ttypetag(t2)) {  /* not the same variant? */
-    if (ttype(t1) != ttype(t2) || ttype(t1) != LUA_TNUMBER)
-      return 0;  /* only numbers can be equal with different variants */
-    else {  /* two numbers with different variants */
-      /* One of them is an integer. If the other does not have an
-         integer value, they cannot be equal; otherwise, compare their
-         integer values. */
-      lua_Integer i1, i2;
-      return (luaV_tointegerns(t1, &i1, F2Ieq) &&
-              luaV_tointegerns(t2, &i2, F2Ieq) &&
-              i1 == i2);
-    }
-  }
-  /* values have same type and same variant */
-  switch (ttypetag(t1)) {
-    case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: return 1;
-    case LUA_VNUMINT: return (ivalue(t1) == ivalue(t2));
-    case LUA_VNUMFLT: return luai_numeq(fltvalue(t1), fltvalue(t2));
-    case LUA_VLIGHTUSERDATA: return pvalue(t1) == pvalue(t2);
-    case LUA_VLCF: return fvalue(t1) == fvalue(t2);
-    case LUA_VSHRSTR: return eqshrstr(tsvalue(t1), tsvalue(t2));
-    case LUA_VLNGSTR: return luaS_eqlngstr(tsvalue(t1), tsvalue(t2));
-    case LUA_VUSERDATA: {
-      if (uvalue(t1) == uvalue(t2)) return 1;
-      else if (L == NULL) return 0;
-      tm = fasttm(L, uvalue(t1)->metatable, TM_EQ);
-      if (tm == NULL)
-        tm = fasttm(L, uvalue(t2)->metatable, TM_EQ);
-      break;  /* will try TM */
-    }
-    case LUA_VTABLE: {
-      if (hvalue(t1) == hvalue(t2)) return 1;
-      else if (L == NULL) return 0;
-      tm = fasttm(L, hvalue(t1)->metatable, TM_EQ);
-      if (tm == NULL)
-        tm = fasttm(L, hvalue(t2)->metatable, TM_EQ);
-      break;  /* will try TM */
-    }
-    default:
-      return gcvalue(t1) == gcvalue(t2);
-  }
-  if (tm == NULL)  /* no TM? */
-    return 0;  /* objects are different */
-  else {
-    luaT_callTMres(L, tm, t1, t2, L->top.p);  /* call TM */
-    return !l_isfalse(s2v(L->top.p));
-  }
-}
-
-
-/* macro used by 'luaV_concat' to ensure that element at 'o' is a string */
-#define tostring(L,o)  \
-	(ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1)))
-
-#define isemptystr(o)	(ttisshrstring(o) && tsvalue(o)->shrlen == 0)
-
-/* copy strings in stack from top - n up to top - 1 to buffer */
-static void copy2buff (StkId top, int n, char *buff) {
-  size_t tl = 0;  /* size already copied */
-  do {
-    size_t l = vslen(s2v(top - n));  /* length of string being copied */
-    memcpy(buff + tl, svalue(s2v(top - n)), l * sizeof(char));
-    tl += l;
-  } while (--n > 0);
-}
-
-
-/*
-** Main operation for concatenation: concat 'total' values in the stack,
-** from 'L->top.p - total' up to 'L->top.p - 1'.
-*/
-void luaV_concat (lua_State *L, int total) {
-  if (total == 1)
-    return;  /* "all" values already concatenated */
-  do {
-    StkId top = L->top.p;
-    int n = 2;  /* number of elements handled in this pass (at least 2) */
-    if (!(ttisstring(s2v(top - 2)) || cvt2str(s2v(top - 2))) ||
-        !tostring(L, s2v(top - 1)))
-      luaT_tryconcatTM(L);  /* may invalidate 'top' */
-    else if (isemptystr(s2v(top - 1)))  /* second operand is empty? */
-      cast_void(tostring(L, s2v(top - 2)));  /* result is first operand */
-    else if (isemptystr(s2v(top - 2))) {  /* first operand is empty string? */
-      setobjs2s(L, top - 2, top - 1);  /* result is second op. */
-    }
-    else {
-      /* at least two non-empty string values; get as many as possible */
-      size_t tl = vslen(s2v(top - 1));
-      TString *ts;
-      /* collect total length and number of strings */
-      for (n = 1; n < total && tostring(L, s2v(top - n - 1)); n++) {
-        size_t l = vslen(s2v(top - n - 1));
-        if (l_unlikely(l >= (MAX_SIZE/sizeof(char)) - tl)) {
-          L->top.p = top - total;  /* pop strings to avoid wasting stack */
-          luaG_runerror(L, "string length overflow");
-        }
-        tl += l;
-      }
-      if (tl <= LUAI_MAXSHORTLEN) {  /* is result a short string? */
-        char buff[LUAI_MAXSHORTLEN];
-        copy2buff(top, n, buff);  /* copy strings to buffer */
-        ts = luaS_newlstr(L, buff, tl);
-      }
-      else {  /* long string; copy strings directly to final result */
-        ts = luaS_createlngstrobj(L, tl);
-        copy2buff(top, n, getstr(ts));
-      }
-      setsvalue2s(L, top - n, ts);  /* create result */
-    }
-    total -= n - 1;  /* got 'n' strings to create one new */
-    L->top.p -= n - 1;  /* popped 'n' strings and pushed one */
-  } while (total > 1);  /* repeat until only 1 result left */
-}
-
-
-/*
-** Main operation 'ra = #rb'.
-*/
-void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) {
-  const TValue *tm;
-  switch (ttypetag(rb)) {
-    case LUA_VTABLE: {
-      Table *h = hvalue(rb);
-      tm = fasttm(L, h->metatable, TM_LEN);
-      if (tm) break;  /* metamethod? break switch to call it */
-      setivalue(s2v(ra), luaH_getn(h));  /* else primitive len */
-      return;
-    }
-    case LUA_VSHRSTR: {
-      setivalue(s2v(ra), tsvalue(rb)->shrlen);
-      return;
-    }
-    case LUA_VLNGSTR: {
-      setivalue(s2v(ra), tsvalue(rb)->u.lnglen);
-      return;
-    }
-    default: {  /* try metamethod */
-      tm = luaT_gettmbyobj(L, rb, TM_LEN);
-      if (l_unlikely(notm(tm)))  /* no metamethod? */
-        luaG_typeerror(L, rb, "get length of");
-      break;
-    }
-  }
-  luaT_callTMres(L, tm, rb, rb, ra);
-}
-
-
-/*
-** Integer division; return 'm // n', that is, floor(m/n).
-** C division truncates its result (rounds towards zero).
-** 'floor(q) == trunc(q)' when 'q >= 0' or when 'q' is integer,
-** otherwise 'floor(q) == trunc(q) - 1'.
-*/
-lua_Integer luaV_idiv (lua_State *L, lua_Integer m, lua_Integer n) {
-  if (l_unlikely(l_castS2U(n) + 1u <= 1u)) {  /* special cases: -1 or 0 */
-    if (n == 0)
-      luaG_runerror(L, "attempt to divide by zero");
-    return intop(-, 0, m);   /* n==-1; avoid overflow with 0x80000...//-1 */
-  }
-  else {
-    lua_Integer q = m / n;  /* perform C division */
-    if ((m ^ n) < 0 && m % n != 0)  /* 'm/n' would be negative non-integer? */
-      q -= 1;  /* correct result for different rounding */
-    return q;
-  }
-}
-
-
-/*
-** Integer modulus; return 'm % n'. (Assume that C '%' with
-** negative operands follows C99 behavior. See previous comment
-** about luaV_idiv.)
-*/
-lua_Integer luaV_mod (lua_State *L, lua_Integer m, lua_Integer n) {
-  if (l_unlikely(l_castS2U(n) + 1u <= 1u)) {  /* special cases: -1 or 0 */
-    if (n == 0)
-      luaG_runerror(L, "attempt to perform 'n%%0'");
-    return 0;   /* m % -1 == 0; avoid overflow with 0x80000...%-1 */
-  }
-  else {
-    lua_Integer r = m % n;
-    if (r != 0 && (r ^ n) < 0)  /* 'm/n' would be non-integer negative? */
-      r += n;  /* correct result for different rounding */
-    return r;
-  }
-}
-
-
-/*
-** Float modulus
-*/
-lua_Number luaV_modf (lua_State *L, lua_Number m, lua_Number n) {
-  lua_Number r;
-  luai_nummod(L, m, n, r);
-  return r;
-}
-
-
-/* number of bits in an integer */
-#define NBITS	cast_int(sizeof(lua_Integer) * CHAR_BIT)
-
-
-/*
-** Shift left operation. (Shift right just negates 'y'.)
-*/
-lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y) {
-  if (y < 0) {  /* shift right? */
-    if (y <= -NBITS) return 0;
-    else return intop(>>, x, -y);
-  }
-  else {  /* shift left */
-    if (y >= NBITS) return 0;
-    else return intop(<<, x, y);
-  }
-}
-
-
-/*
-** create a new Lua closure, push it in the stack, and initialize
-** its upvalues.
-*/
-static void pushclosure (lua_State *L, Proto *p, UpVal **encup, StkId base,
-                         StkId ra) {
-  int nup = p->sizeupvalues;
-  Upvaldesc *uv = p->upvalues;
-  int i;
-  LClosure *ncl = luaF_newLclosure(L, nup);
-  ncl->p = p;
-  setclLvalue2s(L, ra, ncl);  /* anchor new closure in stack */
-  for (i = 0; i < nup; i++) {  /* fill in its upvalues */
-    if (uv[i].instack)  /* upvalue refers to local variable? */
-      ncl->upvals[i] = luaF_findupval(L, base + uv[i].idx);
-    else  /* get upvalue from enclosing function */
-      ncl->upvals[i] = encup[uv[i].idx];
-    luaC_objbarrier(L, ncl, ncl->upvals[i]);
-  }
-}
-
-
-/*
-** finish execution of an opcode interrupted by a yield
-*/
-void luaV_finishOp (lua_State *L) {
-  CallInfo *ci = L->ci;
-  StkId base = ci->func.p + 1;
-  Instruction inst = *(ci->u.l.savedpc - 1);  /* interrupted instruction */
-  OpCode op = GET_OPCODE(inst);
-  switch (op) {  /* finish its execution */
-    case OP_MMBIN: case OP_MMBINI: case OP_MMBINK: {
-      setobjs2s(L, base + GETARG_A(*(ci->u.l.savedpc - 2)), --L->top.p);
-      break;
-    }
-    case OP_UNM: case OP_BNOT: case OP_LEN:
-    case OP_GETTABUP: case OP_GETTABLE: case OP_GETI:
-    case OP_GETFIELD: case OP_SELF: {
-      setobjs2s(L, base + GETARG_A(inst), --L->top.p);
-      break;
-    }
-    case OP_LT: case OP_LE:
-    case OP_LTI: case OP_LEI:
-    case OP_GTI: case OP_GEI:
-    case OP_EQ: {  /* note that 'OP_EQI'/'OP_EQK' cannot yield */
-      int res = !l_isfalse(s2v(L->top.p - 1));
-      L->top.p--;
-#if defined(LUA_COMPAT_LT_LE)
-      if (ci->callstatus & CIST_LEQ) {  /* "<=" using "<" instead? */
-        ci->callstatus ^= CIST_LEQ;  /* clear mark */
-        res = !res;  /* negate result */
-      }
-#endif
-      lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_JMP);
-      if (res != GETARG_k(inst))  /* condition failed? */
-        ci->u.l.savedpc++;  /* skip jump instruction */
-      break;
-    }
-    case OP_CONCAT: {
-      StkId top = L->top.p - 1;  /* top when 'luaT_tryconcatTM' was called */
-      int a = GETARG_A(inst);      /* first element to concatenate */
-      int total = cast_int(top - 1 - (base + a));  /* yet to concatenate */
-      setobjs2s(L, top - 2, top);  /* put TM result in proper position */
-      L->top.p = top - 1;  /* top is one after last element (at top-2) */
-      luaV_concat(L, total);  /* concat them (may yield again) */
-      break;
-    }
-    case OP_CLOSE: {  /* yielded closing variables */
-      ci->u.l.savedpc--;  /* repeat instruction to close other vars. */
-      break;
-    }
-    case OP_RETURN: {  /* yielded closing variables */
-      StkId ra = base + GETARG_A(inst);
-      /* adjust top to signal correct number of returns, in case the
-         return is "up to top" ('isIT') */
-      L->top.p = ra + ci->u2.nres;
-      /* repeat instruction to close other vars. and complete the return */
-      ci->u.l.savedpc--;
-      break;
-    }
-    default: {
-      /* only these other opcodes can yield */
-      lua_assert(op == OP_TFORCALL || op == OP_CALL ||
-           op == OP_TAILCALL || op == OP_SETTABUP || op == OP_SETTABLE ||
-           op == OP_SETI || op == OP_SETFIELD);
-      break;
-    }
-  }
-}
-
-
-
-
-/*
-** {==================================================================
-** Macros for arithmetic/bitwise/comparison opcodes in 'luaV_execute'
-** ===================================================================
-*/
-
-#define l_addi(L,a,b)	intop(+, a, b)
-#define l_subi(L,a,b)	intop(-, a, b)
-#define l_muli(L,a,b)	intop(*, a, b)
-#define l_band(a,b)	intop(&, a, b)
-#define l_bor(a,b)	intop(|, a, b)
-#define l_bxor(a,b)	intop(^, a, b)
-
-#define l_lti(a,b)	(a < b)
-#define l_lei(a,b)	(a <= b)
-#define l_gti(a,b)	(a > b)
-#define l_gei(a,b)	(a >= b)
-
-
-/*
-** Arithmetic operations with immediate operands. 'iop' is the integer
-** operation, 'fop' is the float operation.
-*/
-#define op_arithI(L,iop,fop) {  \
-  StkId ra = RA(i); \
-  TValue *v1 = vRB(i);  \
-  int imm = GETARG_sC(i);  \
-  if (ttisinteger(v1)) {  \
-    lua_Integer iv1 = ivalue(v1);  \
-    pc++; setivalue(s2v(ra), iop(L, iv1, imm));  \
-  }  \
-  else if (ttisfloat(v1)) {  \
-    lua_Number nb = fltvalue(v1);  \
-    lua_Number fimm = cast_num(imm);  \
-    pc++; setfltvalue(s2v(ra), fop(L, nb, fimm)); \
-  }}
-
-
-/*
-** Auxiliary function for arithmetic operations over floats and others
-** with two register operands.
-*/
-#define op_arithf_aux(L,v1,v2,fop) {  \
-  lua_Number n1; lua_Number n2;  \
-  if (tonumberns(v1, n1) && tonumberns(v2, n2)) {  \
-    pc++; setfltvalue(s2v(ra), fop(L, n1, n2));  \
-  }}
-
-
-/*
-** Arithmetic operations over floats and others with register operands.
-*/
-#define op_arithf(L,fop) {  \
-  StkId ra = RA(i); \
-  TValue *v1 = vRB(i);  \
-  TValue *v2 = vRC(i);  \
-  op_arithf_aux(L, v1, v2, fop); }
-
-
-/*
-** Arithmetic operations with K operands for floats.
-*/
-#define op_arithfK(L,fop) {  \
-  StkId ra = RA(i); \
-  TValue *v1 = vRB(i);  \
-  TValue *v2 = KC(i); lua_assert(ttisnumber(v2));  \
-  op_arithf_aux(L, v1, v2, fop); }
-
-
-/*
-** Arithmetic operations over integers and floats.
-*/
-#define op_arith_aux(L,v1,v2,iop,fop) {  \
-  StkId ra = RA(i); \
-  if (ttisinteger(v1) && ttisinteger(v2)) {  \
-    lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2);  \
-    pc++; setivalue(s2v(ra), iop(L, i1, i2));  \
-  }  \
-  else op_arithf_aux(L, v1, v2, fop); }
-
-
-/*
-** Arithmetic operations with register operands.
-*/
-#define op_arith(L,iop,fop) {  \
-  TValue *v1 = vRB(i);  \
-  TValue *v2 = vRC(i);  \
-  op_arith_aux(L, v1, v2, iop, fop); }
-
-
-/*
-** Arithmetic operations with K operands.
-*/
-#define op_arithK(L,iop,fop) {  \
-  TValue *v1 = vRB(i);  \
-  TValue *v2 = KC(i); lua_assert(ttisnumber(v2));  \
-  op_arith_aux(L, v1, v2, iop, fop); }
-
-
-/*
-** Bitwise operations with constant operand.
-*/
-#define op_bitwiseK(L,op) {  \
-  StkId ra = RA(i); \
-  TValue *v1 = vRB(i);  \
-  TValue *v2 = KC(i);  \
-  lua_Integer i1;  \
-  lua_Integer i2 = ivalue(v2);  \
-  if (tointegerns(v1, &i1)) {  \
-    pc++; setivalue(s2v(ra), op(i1, i2));  \
-  }}
-
-
-/*
-** Bitwise operations with register operands.
-*/
-#define op_bitwise(L,op) {  \
-  StkId ra = RA(i); \
-  TValue *v1 = vRB(i);  \
-  TValue *v2 = vRC(i);  \
-  lua_Integer i1; lua_Integer i2;  \
-  if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) {  \
-    pc++; setivalue(s2v(ra), op(i1, i2));  \
-  }}
-
-
-/*
-** Order operations with register operands. 'opn' actually works
-** for all numbers, but the fast track improves performance for
-** integers.
-*/
-#define op_order(L,opi,opn,other) {  \
-  StkId ra = RA(i); \
-  int cond;  \
-  TValue *rb = vRB(i);  \
-  if (ttisinteger(s2v(ra)) && ttisinteger(rb)) {  \
-    lua_Integer ia = ivalue(s2v(ra));  \
-    lua_Integer ib = ivalue(rb);  \
-    cond = opi(ia, ib);  \
-  }  \
-  else if (ttisnumber(s2v(ra)) && ttisnumber(rb))  \
-    cond = opn(s2v(ra), rb);  \
-  else  \
-    Protect(cond = other(L, s2v(ra), rb));  \
-  docondjump(); }
-
-
-/*
-** Order operations with immediate operand. (Immediate operand is
-** always small enough to have an exact representation as a float.)
-*/
-#define op_orderI(L,opi,opf,inv,tm) {  \
-  StkId ra = RA(i); \
-  int cond;  \
-  int im = GETARG_sB(i);  \
-  if (ttisinteger(s2v(ra)))  \
-    cond = opi(ivalue(s2v(ra)), im);  \
-  else if (ttisfloat(s2v(ra))) {  \
-    lua_Number fa = fltvalue(s2v(ra));  \
-    lua_Number fim = cast_num(im);  \
-    cond = opf(fa, fim);  \
-  }  \
-  else {  \
-    int isf = GETARG_C(i);  \
-    Protect(cond = luaT_callorderiTM(L, s2v(ra), im, inv, isf, tm));  \
-  }  \
-  docondjump(); }
-
-/* }================================================================== */
-
-
-/*
-** {==================================================================
-** Function 'luaV_execute': main interpreter loop
-** ===================================================================
-*/
-
-/*
-** some macros for common tasks in 'luaV_execute'
-*/
-
-
-#define RA(i)	(base+GETARG_A(i))
-#define RB(i)	(base+GETARG_B(i))
-#define vRB(i)	s2v(RB(i))
-#define KB(i)	(k+GETARG_B(i))
-#define RC(i)	(base+GETARG_C(i))
-#define vRC(i)	s2v(RC(i))
-#define KC(i)	(k+GETARG_C(i))
-#define RKC(i)	((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i)))
-
-
-
-#define updatetrap(ci)  (trap = ci->u.l.trap)
-
-#define updatebase(ci)	(base = ci->func.p + 1)
-
-
-#define updatestack(ci)  \
-	{ if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } }
-
-
-/*
-** Execute a jump instruction. The 'updatetrap' allows signals to stop
-** tight loops. (Without it, the local copy of 'trap' could never change.)
-*/
-#define dojump(ci,i,e)	{ pc += GETARG_sJ(i) + e; updatetrap(ci); }
-
-
-/* for test instructions, execute the jump instruction that follows it */
-#define donextjump(ci)	{ Instruction ni = *pc; dojump(ci, ni, 1); }
-
-/*
-** do a conditional jump: skip next instruction if 'cond' is not what
-** was expected (parameter 'k'), else do next instruction, which must
-** be a jump.
-*/
-#define docondjump()	if (cond != GETARG_k(i)) pc++; else donextjump(ci);
-
-
-/*
-** Correct global 'pc'.
-*/
-#define savepc(L)	(ci->u.l.savedpc = pc)
-
-
-/*
-** Whenever code can raise errors, the global 'pc' and the global
-** 'top' must be correct to report occasional errors.
-*/
-#define savestate(L,ci)		(savepc(L), L->top.p = ci->top.p)
-
-
-/*
-** Protect code that, in general, can raise errors, reallocate the
-** stack, and change the hooks.
-*/
-#define Protect(exp)  (savestate(L,ci), (exp), updatetrap(ci))
-
-/* special version that does not change the top */
-#define ProtectNT(exp)  (savepc(L), (exp), updatetrap(ci))
-
-/*
-** Protect code that can only raise errors. (That is, it cannot change
-** the stack or hooks.)
-*/
-#define halfProtect(exp)  (savestate(L,ci), (exp))
-
-/* 'c' is the limit of live values in the stack */
-#define checkGC(L,c)  \
-	{ luaC_condGC(L, (savepc(L), L->top.p = (c)), \
-                         updatetrap(ci)); \
-           luai_threadyield(L); }
-
-
-/* fetch an instruction and prepare its execution */
-#define vmfetch()	{ \
-  if (l_unlikely(trap)) {  /* stack reallocation or hooks? */ \
-    trap = luaG_traceexec(L, pc);  /* handle hooks */ \
-    updatebase(ci);  /* correct stack */ \
-  } \
-  i = *(pc++); \
-}
-
-#define vmdispatch(o)	switch(o)
-#define vmcase(l)	case l:
-#define vmbreak		break
-
-
-void luaV_execute (lua_State *L, CallInfo *ci) {
-  LClosure *cl;
-  TValue *k;
-  StkId base;
-  const Instruction *pc;
-  int trap;
-#if LUA_USE_JUMPTABLE
-#include "ljumptab.h"
-#endif
- startfunc:
-  trap = L->hookmask;
- returning:  /* trap already set */
-  cl = clLvalue(s2v(ci->func.p));
-  k = cl->p->k;
-  pc = ci->u.l.savedpc;
-  if (l_unlikely(trap)) {
-    if (pc == cl->p->code) {  /* first instruction (not resuming)? */
-      if (cl->p->is_vararg)
-        trap = 0;  /* hooks will start after VARARGPREP instruction */
-      else  /* check 'call' hook */
-        luaD_hookcall(L, ci);
-    }
-    ci->u.l.trap = 1;  /* assume trap is on, for now */
-  }
-  base = ci->func.p + 1;
-  /* main loop of interpreter */
-  for (;;) {
-    Instruction i;  /* instruction being executed */
-    vmfetch();
-    #if 0
-      /* low-level line tracing for debugging Lua */
-      printf("line: %d\n", luaG_getfuncline(cl->p, pcRel(pc, cl->p)));
-    #endif
-    lua_assert(base == ci->func.p + 1);
-    lua_assert(base <= L->top.p && L->top.p <= L->stack_last.p);
-    /* invalidate top for instructions not expecting it */
-    lua_assert(isIT(i) || (cast_void(L->top.p = base), 1));
-    vmdispatch (GET_OPCODE(i)) {
-      vmcase(OP_MOVE) {
-        StkId ra = RA(i);
-        setobjs2s(L, ra, RB(i));
-        vmbreak;
-      }
-      vmcase(OP_LOADI) {
-        StkId ra = RA(i);
-        lua_Integer b = GETARG_sBx(i);
-        setivalue(s2v(ra), b);
-        vmbreak;
-      }
-      vmcase(OP_LOADF) {
-        StkId ra = RA(i);
-        int b = GETARG_sBx(i);
-        setfltvalue(s2v(ra), cast_num(b));
-        vmbreak;
-      }
-      vmcase(OP_LOADK) {
-        StkId ra = RA(i);
-        TValue *rb = k + GETARG_Bx(i);
-        setobj2s(L, ra, rb);
-        vmbreak;
-      }
-      vmcase(OP_LOADKX) {
-        StkId ra = RA(i);
-        TValue *rb;
-        rb = k + GETARG_Ax(*pc); pc++;
-        setobj2s(L, ra, rb);
-        vmbreak;
-      }
-      vmcase(OP_LOADFALSE) {
-        StkId ra = RA(i);
-        setbfvalue(s2v(ra));
-        vmbreak;
-      }
-      vmcase(OP_LFALSESKIP) {
-        StkId ra = RA(i);
-        setbfvalue(s2v(ra));
-        pc++;  /* skip next instruction */
-        vmbreak;
-      }
-      vmcase(OP_LOADTRUE) {
-        StkId ra = RA(i);
-        setbtvalue(s2v(ra));
-        vmbreak;
-      }
-      vmcase(OP_LOADNIL) {
-        StkId ra = RA(i);
-        int b = GETARG_B(i);
-        do {
-          setnilvalue(s2v(ra++));
-        } while (b--);
-        vmbreak;
-      }
-      vmcase(OP_GETUPVAL) {
-        StkId ra = RA(i);
-        int b = GETARG_B(i);
-        setobj2s(L, ra, cl->upvals[b]->v.p);
-        vmbreak;
-      }
-      vmcase(OP_SETUPVAL) {
-        StkId ra = RA(i);
-        UpVal *uv = cl->upvals[GETARG_B(i)];
-        setobj(L, uv->v.p, s2v(ra));
-        luaC_barrier(L, uv, s2v(ra));
-        vmbreak;
-      }
-      vmcase(OP_GETTABUP) {
-        StkId ra = RA(i);
-        const TValue *slot;
-        TValue *upval = cl->upvals[GETARG_B(i)]->v.p;
-        TValue *rc = KC(i);
-        TString *key = tsvalue(rc);  /* key must be a string */
-        if (luaV_fastget(L, upval, key, slot, luaH_getshortstr)) {
-          setobj2s(L, ra, slot);
-        }
-        else
-          Protect(luaV_finishget(L, upval, rc, ra, slot));
-        vmbreak;
-      }
-      vmcase(OP_GETTABLE) {
-        StkId ra = RA(i);
-        const TValue *slot;
-        TValue *rb = vRB(i);
-        TValue *rc = vRC(i);
-        lua_Unsigned n;
-        if (ttisinteger(rc)  /* fast track for integers? */
-            ? (cast_void(n = ivalue(rc)), luaV_fastgeti(L, rb, n, slot))
-            : luaV_fastget(L, rb, rc, slot, luaH_get)) {
-          setobj2s(L, ra, slot);
-        }
-        else
-          Protect(luaV_finishget(L, rb, rc, ra, slot));
-        vmbreak;
-      }
-      vmcase(OP_GETI) {
-        StkId ra = RA(i);
-        const TValue *slot;
-        TValue *rb = vRB(i);
-        int c = GETARG_C(i);
-        if (luaV_fastgeti(L, rb, c, slot)) {
-          setobj2s(L, ra, slot);
-        }
-        else {
-          TValue key;
-          setivalue(&key, c);
-          Protect(luaV_finishget(L, rb, &key, ra, slot));
-        }
-        vmbreak;
-      }
-      vmcase(OP_GETFIELD) {
-        StkId ra = RA(i);
-        const TValue *slot;
-        TValue *rb = vRB(i);
-        TValue *rc = KC(i);
-        TString *key = tsvalue(rc);  /* key must be a string */
-        if (luaV_fastget(L, rb, key, slot, luaH_getshortstr)) {
-          setobj2s(L, ra, slot);
-        }
-        else
-          Protect(luaV_finishget(L, rb, rc, ra, slot));
-        vmbreak;
-      }
-      vmcase(OP_SETTABUP) {
-        const TValue *slot;
-        TValue *upval = cl->upvals[GETARG_A(i)]->v.p;
-        TValue *rb = KB(i);
-        TValue *rc = RKC(i);
-        TString *key = tsvalue(rb);  /* key must be a string */
-        if (luaV_fastget(L, upval, key, slot, luaH_getshortstr)) {
-          luaV_finishfastset(L, upval, slot, rc);
-        }
-        else
-          Protect(luaV_finishset(L, upval, rb, rc, slot));
-        vmbreak;
-      }
-      vmcase(OP_SETTABLE) {
-        StkId ra = RA(i);
-        const TValue *slot;
-        TValue *rb = vRB(i);  /* key (table is in 'ra') */
-        TValue *rc = RKC(i);  /* value */
-        lua_Unsigned n;
-        if (ttisinteger(rb)  /* fast track for integers? */
-            ? (cast_void(n = ivalue(rb)), luaV_fastgeti(L, s2v(ra), n, slot))
-            : luaV_fastget(L, s2v(ra), rb, slot, luaH_get)) {
-          luaV_finishfastset(L, s2v(ra), slot, rc);
-        }
-        else
-          Protect(luaV_finishset(L, s2v(ra), rb, rc, slot));
-        vmbreak;
-      }
-      vmcase(OP_SETI) {
-        StkId ra = RA(i);
-        const TValue *slot;
-        int c = GETARG_B(i);
-        TValue *rc = RKC(i);
-        if (luaV_fastgeti(L, s2v(ra), c, slot)) {
-          luaV_finishfastset(L, s2v(ra), slot, rc);
-        }
-        else {
-          TValue key;
-          setivalue(&key, c);
-          Protect(luaV_finishset(L, s2v(ra), &key, rc, slot));
-        }
-        vmbreak;
-      }
-      vmcase(OP_SETFIELD) {
-        StkId ra = RA(i);
-        const TValue *slot;
-        TValue *rb = KB(i);
-        TValue *rc = RKC(i);
-        TString *key = tsvalue(rb);  /* key must be a string */
-        if (luaV_fastget(L, s2v(ra), key, slot, luaH_getshortstr)) {
-          luaV_finishfastset(L, s2v(ra), slot, rc);
-        }
-        else
-          Protect(luaV_finishset(L, s2v(ra), rb, rc, slot));
-        vmbreak;
-      }
-      vmcase(OP_NEWTABLE) {
-        StkId ra = RA(i);
-        int b = GETARG_B(i);  /* log2(hash size) + 1 */
-        int c = GETARG_C(i);  /* array size */
-        Table *t;
-        if (b > 0)
-          b = 1 << (b - 1);  /* size is 2^(b - 1) */
-        lua_assert((!TESTARG_k(i)) == (GETARG_Ax(*pc) == 0));
-        if (TESTARG_k(i))  /* non-zero extra argument? */
-          c += GETARG_Ax(*pc) * (MAXARG_C + 1);  /* add it to size */
-        pc++;  /* skip extra argument */
-        L->top.p = ra + 1;  /* correct top in case of emergency GC */
-        t = luaH_new(L);  /* memory allocation */
-        sethvalue2s(L, ra, t);
-        if (b != 0 || c != 0)
-          luaH_resize(L, t, c, b);  /* idem */
-        checkGC(L, ra + 1);
-        vmbreak;
-      }
-      vmcase(OP_SELF) {
-        StkId ra = RA(i);
-        const TValue *slot;
-        TValue *rb = vRB(i);
-        TValue *rc = RKC(i);
-        TString *key = tsvalue(rc);  /* key must be a string */
-        setobj2s(L, ra + 1, rb);
-        if (luaV_fastget(L, rb, key, slot, luaH_getstr)) {
-          setobj2s(L, ra, slot);
-        }
-        else
-          Protect(luaV_finishget(L, rb, rc, ra, slot));
-        vmbreak;
-      }
-      vmcase(OP_ADDI) {
-        op_arithI(L, l_addi, luai_numadd);
-        vmbreak;
-      }
-      vmcase(OP_ADDK) {
-        op_arithK(L, l_addi, luai_numadd);
-        vmbreak;
-      }
-      vmcase(OP_SUBK) {
-        op_arithK(L, l_subi, luai_numsub);
-        vmbreak;
-      }
-      vmcase(OP_MULK) {
-        op_arithK(L, l_muli, luai_nummul);
-        vmbreak;
-      }
-      vmcase(OP_MODK) {
-        savestate(L, ci);  /* in case of division by 0 */
-        op_arithK(L, luaV_mod, luaV_modf);
-        vmbreak;
-      }
-      vmcase(OP_POWK) {
-        op_arithfK(L, luai_numpow);
-        vmbreak;
-      }
-      vmcase(OP_DIVK) {
-        op_arithfK(L, luai_numdiv);
-        vmbreak;
-      }
-      vmcase(OP_IDIVK) {
-        savestate(L, ci);  /* in case of division by 0 */
-        op_arithK(L, luaV_idiv, luai_numidiv);
-        vmbreak;
-      }
-      vmcase(OP_BANDK) {
-        op_bitwiseK(L, l_band);
-        vmbreak;
-      }
-      vmcase(OP_BORK) {
-        op_bitwiseK(L, l_bor);
-        vmbreak;
-      }
-      vmcase(OP_BXORK) {
-        op_bitwiseK(L, l_bxor);
-        vmbreak;
-      }
-      vmcase(OP_SHRI) {
-        StkId ra = RA(i);
-        TValue *rb = vRB(i);
-        int ic = GETARG_sC(i);
-        lua_Integer ib;
-        if (tointegerns(rb, &ib)) {
-          pc++; setivalue(s2v(ra), luaV_shiftl(ib, -ic));
-        }
-        vmbreak;
-      }
-      vmcase(OP_SHLI) {
-        StkId ra = RA(i);
-        TValue *rb = vRB(i);
-        int ic = GETARG_sC(i);
-        lua_Integer ib;
-        if (tointegerns(rb, &ib)) {
-          pc++; setivalue(s2v(ra), luaV_shiftl(ic, ib));
-        }
-        vmbreak;
-      }
-      vmcase(OP_ADD) {
-        op_arith(L, l_addi, luai_numadd);
-        vmbreak;
-      }
-      vmcase(OP_SUB) {
-        op_arith(L, l_subi, luai_numsub);
-        vmbreak;
-      }
-      vmcase(OP_MUL) {
-        op_arith(L, l_muli, luai_nummul);
-        vmbreak;
-      }
-      vmcase(OP_MOD) {
-        savestate(L, ci);  /* in case of division by 0 */
-        op_arith(L, luaV_mod, luaV_modf);
-        vmbreak;
-      }
-      vmcase(OP_POW) {
-        op_arithf(L, luai_numpow);
-        vmbreak;
-      }
-      vmcase(OP_DIV) {  /* float division (always with floats) */
-        op_arithf(L, luai_numdiv);
-        vmbreak;
-      }
-      vmcase(OP_IDIV) {  /* floor division */
-        savestate(L, ci);  /* in case of division by 0 */
-        op_arith(L, luaV_idiv, luai_numidiv);
-        vmbreak;
-      }
-      vmcase(OP_BAND) {
-        op_bitwise(L, l_band);
-        vmbreak;
-      }
-      vmcase(OP_BOR) {
-        op_bitwise(L, l_bor);
-        vmbreak;
-      }
-      vmcase(OP_BXOR) {
-        op_bitwise(L, l_bxor);
-        vmbreak;
-      }
-      vmcase(OP_SHR) {
-        op_bitwise(L, luaV_shiftr);
-        vmbreak;
-      }
-      vmcase(OP_SHL) {
-        op_bitwise(L, luaV_shiftl);
-        vmbreak;
-      }
-      vmcase(OP_MMBIN) {
-        StkId ra = RA(i);
-        Instruction pi = *(pc - 2);  /* original arith. expression */
-        TValue *rb = vRB(i);
-        TMS tm = (TMS)GETARG_C(i);
-        StkId result = RA(pi);
-        lua_assert(OP_ADD <= GET_OPCODE(pi) && GET_OPCODE(pi) <= OP_SHR);
-        Protect(luaT_trybinTM(L, s2v(ra), rb, result, tm));
-        vmbreak;
-      }
-      vmcase(OP_MMBINI) {
-        StkId ra = RA(i);
-        Instruction pi = *(pc - 2);  /* original arith. expression */
-        int imm = GETARG_sB(i);
-        TMS tm = (TMS)GETARG_C(i);
-        int flip = GETARG_k(i);
-        StkId result = RA(pi);
-        Protect(luaT_trybiniTM(L, s2v(ra), imm, flip, result, tm));
-        vmbreak;
-      }
-      vmcase(OP_MMBINK) {
-        StkId ra = RA(i);
-        Instruction pi = *(pc - 2);  /* original arith. expression */
-        TValue *imm = KB(i);
-        TMS tm = (TMS)GETARG_C(i);
-        int flip = GETARG_k(i);
-        StkId result = RA(pi);
-        Protect(luaT_trybinassocTM(L, s2v(ra), imm, flip, result, tm));
-        vmbreak;
-      }
-      vmcase(OP_UNM) {
-        StkId ra = RA(i);
-        TValue *rb = vRB(i);
-        lua_Number nb;
-        if (ttisinteger(rb)) {
-          lua_Integer ib = ivalue(rb);
-          setivalue(s2v(ra), intop(-, 0, ib));
-        }
-        else if (tonumberns(rb, nb)) {
-          setfltvalue(s2v(ra), luai_numunm(L, nb));
-        }
-        else
-          Protect(luaT_trybinTM(L, rb, rb, ra, TM_UNM));
-        vmbreak;
-      }
-      vmcase(OP_BNOT) {
-        StkId ra = RA(i);
-        TValue *rb = vRB(i);
-        lua_Integer ib;
-        if (tointegerns(rb, &ib)) {
-          setivalue(s2v(ra), intop(^, ~l_castS2U(0), ib));
-        }
-        else
-          Protect(luaT_trybinTM(L, rb, rb, ra, TM_BNOT));
-        vmbreak;
-      }
-      vmcase(OP_NOT) {
-        StkId ra = RA(i);
-        TValue *rb = vRB(i);
-        if (l_isfalse(rb))
-          setbtvalue(s2v(ra));
-        else
-          setbfvalue(s2v(ra));
-        vmbreak;
-      }
-      vmcase(OP_LEN) {
-        StkId ra = RA(i);
-        Protect(luaV_objlen(L, ra, vRB(i)));
-        vmbreak;
-      }
-      vmcase(OP_CONCAT) {
-        StkId ra = RA(i);
-        int n = GETARG_B(i);  /* number of elements to concatenate */
-        L->top.p = ra + n;  /* mark the end of concat operands */
-        ProtectNT(luaV_concat(L, n));
-        checkGC(L, L->top.p); /* 'luaV_concat' ensures correct top */
-        vmbreak;
-      }
-      vmcase(OP_CLOSE) {
-        StkId ra = RA(i);
-        Protect(luaF_close(L, ra, LUA_OK, 1));
-        vmbreak;
-      }
-      vmcase(OP_TBC) {
-        StkId ra = RA(i);
-        /* create new to-be-closed upvalue */
-        halfProtect(luaF_newtbcupval(L, ra));
-        vmbreak;
-      }
-      vmcase(OP_JMP) {
-        dojump(ci, i, 0);
-        vmbreak;
-      }
-      vmcase(OP_EQ) {
-        StkId ra = RA(i);
-        int cond;
-        TValue *rb = vRB(i);
-        Protect(cond = luaV_equalobj(L, s2v(ra), rb));
-        docondjump();
-        vmbreak;
-      }
-      vmcase(OP_LT) {
-        op_order(L, l_lti, LTnum, lessthanothers);
-        vmbreak;
-      }
-      vmcase(OP_LE) {
-        op_order(L, l_lei, LEnum, lessequalothers);
-        vmbreak;
-      }
-      vmcase(OP_EQK) {
-        StkId ra = RA(i);
-        TValue *rb = KB(i);
-        /* basic types do not use '__eq'; we can use raw equality */
-        int cond = luaV_rawequalobj(s2v(ra), rb);
-        docondjump();
-        vmbreak;
-      }
-      vmcase(OP_EQI) {
-        StkId ra = RA(i);
-        int cond;
-        int im = GETARG_sB(i);
-        if (ttisinteger(s2v(ra)))
-          cond = (ivalue(s2v(ra)) == im);
-        else if (ttisfloat(s2v(ra)))
-          cond = luai_numeq(fltvalue(s2v(ra)), cast_num(im));
-        else
-          cond = 0;  /* other types cannot be equal to a number */
-        docondjump();
-        vmbreak;
-      }
-      vmcase(OP_LTI) {
-        op_orderI(L, l_lti, luai_numlt, 0, TM_LT);
-        vmbreak;
-      }
-      vmcase(OP_LEI) {
-        op_orderI(L, l_lei, luai_numle, 0, TM_LE);
-        vmbreak;
-      }
-      vmcase(OP_GTI) {
-        op_orderI(L, l_gti, luai_numgt, 1, TM_LT);
-        vmbreak;
-      }
-      vmcase(OP_GEI) {
-        op_orderI(L, l_gei, luai_numge, 1, TM_LE);
-        vmbreak;
-      }
-      vmcase(OP_TEST) {
-        StkId ra = RA(i);
-        int cond = !l_isfalse(s2v(ra));
-        docondjump();
-        vmbreak;
-      }
-      vmcase(OP_TESTSET) {
-        StkId ra = RA(i);
-        TValue *rb = vRB(i);
-        if (l_isfalse(rb) == GETARG_k(i))
-          pc++;
-        else {
-          setobj2s(L, ra, rb);
-          donextjump(ci);
-        }
-        vmbreak;
-      }
-      vmcase(OP_CALL) {
-        StkId ra = RA(i);
-        CallInfo *newci;
-        int b = GETARG_B(i);
-        int nresults = GETARG_C(i) - 1;
-        if (b != 0)  /* fixed number of arguments? */
-          L->top.p = ra + b;  /* top signals number of arguments */
-        /* else previous instruction set top */
-        savepc(L);  /* in case of errors */
-        if ((newci = luaD_precall(L, ra, nresults)) == NULL)
-          updatetrap(ci);  /* C call; nothing else to be done */
-        else {  /* Lua call: run function in this same C frame */
-          ci = newci;
-          goto startfunc;
-        }
-        vmbreak;
-      }
-      vmcase(OP_TAILCALL) {
-        StkId ra = RA(i);
-        int b = GETARG_B(i);  /* number of arguments + 1 (function) */
-        int n;  /* number of results when calling a C function */
-        int nparams1 = GETARG_C(i);
-        /* delta is virtual 'func' - real 'func' (vararg functions) */
-        int delta = (nparams1) ? ci->u.l.nextraargs + nparams1 : 0;
-        if (b != 0)
-          L->top.p = ra + b;
-        else  /* previous instruction set top */
-          b = cast_int(L->top.p - ra);
-        savepc(ci);  /* several calls here can raise errors */
-        if (TESTARG_k(i)) {
-          luaF_closeupval(L, base);  /* close upvalues from current call */
-          lua_assert(L->tbclist.p < base);  /* no pending tbc variables */
-          lua_assert(base == ci->func.p + 1);
-        }
-        if ((n = luaD_pretailcall(L, ci, ra, b, delta)) < 0)  /* Lua function? */
-          goto startfunc;  /* execute the callee */
-        else {  /* C function? */
-          ci->func.p -= delta;  /* restore 'func' (if vararg) */
-          luaD_poscall(L, ci, n);  /* finish caller */
-          updatetrap(ci);  /* 'luaD_poscall' can change hooks */
-          goto ret;  /* caller returns after the tail call */
-        }
-      }
-      vmcase(OP_RETURN) {
-        StkId ra = RA(i);
-        int n = GETARG_B(i) - 1;  /* number of results */
-        int nparams1 = GETARG_C(i);
-        if (n < 0)  /* not fixed? */
-          n = cast_int(L->top.p - ra);  /* get what is available */
-        savepc(ci);
-        if (TESTARG_k(i)) {  /* may there be open upvalues? */
-          ci->u2.nres = n;  /* save number of returns */
-          if (L->top.p < ci->top.p)
-            L->top.p = ci->top.p;
-          luaF_close(L, base, CLOSEKTOP, 1);
-          updatetrap(ci);
-          updatestack(ci);
-        }
-        if (nparams1)  /* vararg function? */
-          ci->func.p -= ci->u.l.nextraargs + nparams1;
-        L->top.p = ra + n;  /* set call for 'luaD_poscall' */
-        luaD_poscall(L, ci, n);
-        updatetrap(ci);  /* 'luaD_poscall' can change hooks */
-        goto ret;
-      }
-      vmcase(OP_RETURN0) {
-        if (l_unlikely(L->hookmask)) {
-          StkId ra = RA(i);
-          L->top.p = ra;
-          savepc(ci);
-          luaD_poscall(L, ci, 0);  /* no hurry... */
-          trap = 1;
-        }
-        else {  /* do the 'poscall' here */
-          int nres;
-          L->ci = ci->previous;  /* back to caller */
-          L->top.p = base - 1;
-          for (nres = ci->nresults; l_unlikely(nres > 0); nres--)
-            setnilvalue(s2v(L->top.p++));  /* all results are nil */
-        }
-        goto ret;
-      }
-      vmcase(OP_RETURN1) {
-        if (l_unlikely(L->hookmask)) {
-          StkId ra = RA(i);
-          L->top.p = ra + 1;
-          savepc(ci);
-          luaD_poscall(L, ci, 1);  /* no hurry... */
-          trap = 1;
-        }
-        else {  /* do the 'poscall' here */
-          int nres = ci->nresults;
-          L->ci = ci->previous;  /* back to caller */
-          if (nres == 0)
-            L->top.p = base - 1;  /* asked for no results */
-          else {
-            StkId ra = RA(i);
-            setobjs2s(L, base - 1, ra);  /* at least this result */
-            L->top.p = base;
-            for (; l_unlikely(nres > 1); nres--)
-              setnilvalue(s2v(L->top.p++));  /* complete missing results */
-          }
-        }
-       ret:  /* return from a Lua function */
-        if (ci->callstatus & CIST_FRESH)
-          return;  /* end this frame */
-        else {
-          ci = ci->previous;
-          goto returning;  /* continue running caller in this frame */
-        }
-      }
-      vmcase(OP_FORLOOP) {
-        StkId ra = RA(i);
-        if (ttisinteger(s2v(ra + 2))) {  /* integer loop? */
-          lua_Unsigned count = l_castS2U(ivalue(s2v(ra + 1)));
-          if (count > 0) {  /* still more iterations? */
-            lua_Integer step = ivalue(s2v(ra + 2));
-            lua_Integer idx = ivalue(s2v(ra));  /* internal index */
-            chgivalue(s2v(ra + 1), count - 1);  /* update counter */
-            idx = intop(+, idx, step);  /* add step to index */
-            chgivalue(s2v(ra), idx);  /* update internal index */
-            setivalue(s2v(ra + 3), idx);  /* and control variable */
-            pc -= GETARG_Bx(i);  /* jump back */
-          }
-        }
-        else if (floatforloop(ra))  /* float loop */
-          pc -= GETARG_Bx(i);  /* jump back */
-        updatetrap(ci);  /* allows a signal to break the loop */
-        vmbreak;
-      }
-      vmcase(OP_FORPREP) {
-        StkId ra = RA(i);
-        savestate(L, ci);  /* in case of errors */
-        if (forprep(L, ra))
-          pc += GETARG_Bx(i) + 1;  /* skip the loop */
-        vmbreak;
-      }
-      vmcase(OP_TFORPREP) {
-       StkId ra = RA(i);
-        /* create to-be-closed upvalue (if needed) */
-        halfProtect(luaF_newtbcupval(L, ra + 3));
-        pc += GETARG_Bx(i);
-        i = *(pc++);  /* go to next instruction */
-        lua_assert(GET_OPCODE(i) == OP_TFORCALL && ra == RA(i));
-        goto l_tforcall;
-      }
-      vmcase(OP_TFORCALL) {
-       l_tforcall: {
-        StkId ra = RA(i);
-        /* 'ra' has the iterator function, 'ra + 1' has the state,
-           'ra + 2' has the control variable, and 'ra + 3' has the
-           to-be-closed variable. The call will use the stack after
-           these values (starting at 'ra + 4')
-        */
-        /* push function, state, and control variable */
-        memcpy(ra + 4, ra, 3 * sizeof(*ra));
-        L->top.p = ra + 4 + 3;
-        ProtectNT(luaD_call(L, ra + 4, GETARG_C(i)));  /* do the call */
-        updatestack(ci);  /* stack may have changed */
-        i = *(pc++);  /* go to next instruction */
-        lua_assert(GET_OPCODE(i) == OP_TFORLOOP && ra == RA(i));
-        goto l_tforloop;
-      }}
-      vmcase(OP_TFORLOOP) {
-       l_tforloop: {
-        StkId ra = RA(i);
-        if (!ttisnil(s2v(ra + 4))) {  /* continue loop? */
-          setobjs2s(L, ra + 2, ra + 4);  /* save control variable */
-          pc -= GETARG_Bx(i);  /* jump back */
-        }
-        vmbreak;
-      }}
-      vmcase(OP_SETLIST) {
-        StkId ra = RA(i);
-        int n = GETARG_B(i);
-        unsigned int last = GETARG_C(i);
-        Table *h = hvalue(s2v(ra));
-        if (n == 0)
-          n = cast_int(L->top.p - ra) - 1;  /* get up to the top */
-        else
-          L->top.p = ci->top.p;  /* correct top in case of emergency GC */
-        last += n;
-        if (TESTARG_k(i)) {
-          last += GETARG_Ax(*pc) * (MAXARG_C + 1);
-          pc++;
-        }
-        if (last > luaH_realasize(h))  /* needs more space? */
-          luaH_resizearray(L, h, last);  /* preallocate it at once */
-        for (; n > 0; n--) {
-          TValue *val = s2v(ra + n);
-          setobj2t(L, &h->array[last - 1], val);
-          last--;
-          luaC_barrierback(L, obj2gco(h), val);
-        }
-        vmbreak;
-      }
-      vmcase(OP_CLOSURE) {
-        StkId ra = RA(i);
-        Proto *p = cl->p->p[GETARG_Bx(i)];
-        halfProtect(pushclosure(L, p, cl->upvals, base, ra));
-        checkGC(L, ra + 1);
-        vmbreak;
-      }
-      vmcase(OP_VARARG) {
-        StkId ra = RA(i);
-        int n = GETARG_C(i) - 1;  /* required results */
-        Protect(luaT_getvarargs(L, ci, ra, n));
-        vmbreak;
-      }
-      vmcase(OP_VARARGPREP) {
-        ProtectNT(luaT_adjustvarargs(L, GETARG_A(i), ci, cl->p));
-        if (l_unlikely(trap)) {  /* previous "Protect" updated trap */
-          luaD_hookcall(L, ci);
-          L->oldpc = 1;  /* next opcode will be seen as a "new" line */
-        }
-        updatebase(ci);  /* function has new base after adjustment */
-        vmbreak;
-      }
-      vmcase(OP_EXTRAARG) {
-        lua_assert(0);
-        vmbreak;
-      }
-    }
-  }
-}
-
-/* }================================================================== */
diff --git a/third-party/lua/src/lvm.h b/third-party/lua/src/lvm.h
deleted file mode 100644
index dba1ad277..000000000
--- a/third-party/lua/src/lvm.h
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
-** $Id: lvm.h $
-** Lua virtual machine
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lvm_h
-#define lvm_h
-
-
-#include "ldo.h"
-#include "lobject.h"
-#include "ltm.h"
-
-
-#if !defined(LUA_NOCVTN2S)
-#define cvt2str(o)	ttisnumber(o)
-#else
-#define cvt2str(o)	0	/* no conversion from numbers to strings */
-#endif
-
-
-#if !defined(LUA_NOCVTS2N)
-#define cvt2num(o)	ttisstring(o)
-#else
-#define cvt2num(o)	0	/* no conversion from strings to numbers */
-#endif
-
-
-/*
-** You can define LUA_FLOORN2I if you want to convert floats to integers
-** by flooring them (instead of raising an error if they are not
-** integral values)
-*/
-#if !defined(LUA_FLOORN2I)
-#define LUA_FLOORN2I		F2Ieq
-#endif
-
-
-/*
-** Rounding modes for float->integer coercion
- */
-typedef enum {
-  F2Ieq,     /* no rounding; accepts only integral values */
-  F2Ifloor,  /* takes the floor of the number */
-  F2Iceil    /* takes the ceil of the number */
-} F2Imod;
-
-
-/* convert an object to a float (including string coercion) */
-#define tonumber(o,n) \
-	(ttisfloat(o) ? (*(n) = fltvalue(o), 1) : luaV_tonumber_(o,n))
-
-
-/* convert an object to a float (without string coercion) */
-#define tonumberns(o,n) \
-	(ttisfloat(o) ? ((n) = fltvalue(o), 1) : \
-	(ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0))
-
-
-/* convert an object to an integer (including string coercion) */
-#define tointeger(o,i) \
-  (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \
-                          : luaV_tointeger(o,i,LUA_FLOORN2I))
-
-
-/* convert an object to an integer (without string coercion) */
-#define tointegerns(o,i) \
-  (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \
-                          : luaV_tointegerns(o,i,LUA_FLOORN2I))
-
-
-#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2))
-
-#define luaV_rawequalobj(t1,t2)		luaV_equalobj(NULL,t1,t2)
-
-
-/*
-** fast track for 'gettable': if 't' is a table and 't[k]' is present,
-** return 1 with 'slot' pointing to 't[k]' (position of final result).
-** Otherwise, return 0 (meaning it will have to check metamethod)
-** with 'slot' pointing to an empty 't[k]' (if 't' is a table) or NULL
-** (otherwise). 'f' is the raw get function to use.
-*/
-#define luaV_fastget(L,t,k,slot,f) \
-  (!ttistable(t)  \
-   ? (slot = NULL, 0)  /* not a table; 'slot' is NULL and result is 0 */  \
-   : (slot = f(hvalue(t), k),  /* else, do raw access */  \
-      !isempty(slot)))  /* result not empty? */
-
-
-/*
-** Special case of 'luaV_fastget' for integers, inlining the fast case
-** of 'luaH_getint'.
-*/
-#define luaV_fastgeti(L,t,k,slot) \
-  (!ttistable(t)  \
-   ? (slot = NULL, 0)  /* not a table; 'slot' is NULL and result is 0 */  \
-   : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \
-              ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \
-      !isempty(slot)))  /* result not empty? */
-
-
-/*
-** Finish a fast set operation (when fast get succeeds). In that case,
-** 'slot' points to the place to put the value.
-*/
-#define luaV_finishfastset(L,t,slot,v) \
-    { setobj2t(L, cast(TValue *,slot), v); \
-      luaC_barrierback(L, gcvalue(t), v); }
-
-
-/*
-** Shift right is the same as shift left with a negative 'y'
-*/
-#define luaV_shiftr(x,y)	luaV_shiftl(x,intop(-, 0, y))
-
-
-
-LUAI_FUNC int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2);
-LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r);
-LUAI_FUNC int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r);
-LUAI_FUNC int luaV_tonumber_ (const TValue *obj, lua_Number *n);
-LUAI_FUNC int luaV_tointeger (const TValue *obj, lua_Integer *p, F2Imod mode);
-LUAI_FUNC int luaV_tointegerns (const TValue *obj, lua_Integer *p,
-                                F2Imod mode);
-LUAI_FUNC int luaV_flttointeger (lua_Number n, lua_Integer *p, F2Imod mode);
-LUAI_FUNC void luaV_finishget (lua_State *L, const TValue *t, TValue *key,
-                               StkId val, const TValue *slot);
-LUAI_FUNC void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
-                               TValue *val, const TValue *slot);
-LUAI_FUNC void luaV_finishOp (lua_State *L);
-LUAI_FUNC void luaV_execute (lua_State *L, CallInfo *ci);
-LUAI_FUNC void luaV_concat (lua_State *L, int total);
-LUAI_FUNC lua_Integer luaV_idiv (lua_State *L, lua_Integer x, lua_Integer y);
-LUAI_FUNC lua_Integer luaV_mod (lua_State *L, lua_Integer x, lua_Integer y);
-LUAI_FUNC lua_Number luaV_modf (lua_State *L, lua_Number x, lua_Number y);
-LUAI_FUNC lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y);
-LUAI_FUNC void luaV_objlen (lua_State *L, StkId ra, const TValue *rb);
-
-#endif
diff --git a/third-party/lua/src/lzio.c b/third-party/lua/src/lzio.c
deleted file mode 100644
index cd0a02d5f..000000000
--- a/third-party/lua/src/lzio.c
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
-** $Id: lzio.c $
-** Buffered streams
-** See Copyright Notice in lua.h
-*/
-
-#define lzio_c
-#define LUA_CORE
-
-#include "lprefix.h"
-
-
-#include <string.h>
-
-#include "lua.h"
-
-#include "llimits.h"
-#include "lmem.h"
-#include "lstate.h"
-#include "lzio.h"
-
-
-int luaZ_fill (ZIO *z) {
-  size_t size;
-  lua_State *L = z->L;
-  const char *buff;
-  lua_unlock(L);
-  buff = z->reader(L, z->data, &size);
-  lua_lock(L);
-  if (buff == NULL || size == 0)
-    return EOZ;
-  z->n = size - 1;  /* discount char being returned */
-  z->p = buff;
-  return cast_uchar(*(z->p++));
-}
-
-
-void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) {
-  z->L = L;
-  z->reader = reader;
-  z->data = data;
-  z->n = 0;
-  z->p = NULL;
-}
-
-
-/* --------------------------------------------------------------- read --- */
-size_t luaZ_read (ZIO *z, void *b, size_t n) {
-  while (n) {
-    size_t m;
-    if (z->n == 0) {  /* no bytes in buffer? */
-      if (luaZ_fill(z) == EOZ)  /* try to read more */
-        return n;  /* no more input; return number of missing bytes */
-      else {
-        z->n++;  /* luaZ_fill consumed first byte; put it back */
-        z->p--;
-      }
-    }
-    m = (n <= z->n) ? n : z->n;  /* min. between n and z->n */
-    memcpy(b, z->p, m);
-    z->n -= m;
-    z->p += m;
-    b = (char *)b + m;
-    n -= m;
-  }
-  return 0;
-}
-
diff --git a/third-party/lua/src/lzio.h b/third-party/lua/src/lzio.h
deleted file mode 100644
index 38f397fd2..000000000
--- a/third-party/lua/src/lzio.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
-** $Id: lzio.h $
-** Buffered streams
-** See Copyright Notice in lua.h
-*/
-
-
-#ifndef lzio_h
-#define lzio_h
-
-#include "lua.h"
-
-#include "lmem.h"
-
-
-#define EOZ	(-1)			/* end of stream */
-
-typedef struct Zio ZIO;
-
-#define zgetc(z)  (((z)->n--)>0 ?  cast_uchar(*(z)->p++) : luaZ_fill(z))
-
-
-typedef struct Mbuffer {
-  char *buffer;
-  size_t n;
-  size_t buffsize;
-} Mbuffer;
-
-#define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0)
-
-#define luaZ_buffer(buff)	((buff)->buffer)
-#define luaZ_sizebuffer(buff)	((buff)->buffsize)
-#define luaZ_bufflen(buff)	((buff)->n)
-
-#define luaZ_buffremove(buff,i)	((buff)->n -= (i))
-#define luaZ_resetbuffer(buff) ((buff)->n = 0)
-
-
-#define luaZ_resizebuffer(L, buff, size) \
-	((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \
-				(buff)->buffsize, size), \
-	(buff)->buffsize = size)
-
-#define luaZ_freebuffer(L, buff)	luaZ_resizebuffer(L, buff, 0)
-
-
-LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader,
-                                        void *data);
-LUAI_FUNC size_t luaZ_read (ZIO* z, void *b, size_t n);	/* read next n bytes */
-
-
-
-/* --------- Private Part ------------------ */
-
-struct Zio {
-  size_t n;			/* bytes still unread */
-  const char *p;		/* current position in buffer */
-  lua_Reader reader;		/* reader function */
-  void *data;			/* additional data */
-  lua_State *L;			/* Lua state (for reader) */
-};
-
-
-LUAI_FUNC int luaZ_fill (ZIO *z);
-
-#endif