refactor: drop Symbol's isXxx booleans

`Symbol`'s `tag_invoke` overload added four convenience booleans --
`isRegular`, `isSeeBelow`, `isImplementationDefined`, `isDependency` --
outside the described struct. Because reflection couldn't see them, the
JSON schema writer had to mirror the same hardcoded list.

This removes those booleans and lets templates compare the described
enum directly; e.g.:

  {{#if isRegular}}   ->   {{#if (eq extraction "regular")}}

For the two `filter_by` / `any_of_by` sites that previously keyed on the
booleans, the helper family gains variadic siblings `filter_by_eq` and
`any_of_by_eq` -- signature `(container, key, value1, value2, ...)`.

This addresses review feedback on PR #1178.

Author: gennaroprota

include/mrdocs/Metadata/Symbol/SymbolBase.hpp

@@ -180,7 +180,15 @@ MRDOCS_DESCRIBE_STRUCT(
      Extraction, IsCopyFromInherited, Parent, doc)
 )
 
-/** Map a Symbol to a dom::Object with computed extraction properties.
+/** Map a Symbol to a dom::Object plus a `class` discriminator.
+
+    The `class` field is the only synthesized member here: templates
+    that consume a mixed array of DOM objects use it to tell Symbol
+    entries apart from Type or Name entries. Everything else comes
+    from reflection over the described struct, including the
+    `extraction` enum that templates compare with `(eq extraction
+    "regular")` etc.
+
     @param io The IO object to map into.
     @param I The Symbol to map.
     @param domCorpus The DomCorpus context.
@@ -196,10 +204,6 @@ tag_invoke(
     MRDOCS_ASSERT(domCorpus);
     mapReflectedType<false>(io, I, domCorpus);
     io.map("class", std::string("symbol"));
-    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);
 }
 
 //------------------------------------------------

share/mrdocs/addons/generator/adoc/partials/symbol.adoc.hbs

@@ -249,7 +249,7 @@
 {{! 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}}
+{{#if (eq extraction "regular")}}
 {{#> markup/dynamic-level-h id=null }}{{> symbol/qualified-name . }} namespace{{/markup/dynamic-level-h~}}
 {{> symbol symbol=. id=null traversing-global-namespace=true }}
 {{/if}}

share/mrdocs/addons/generator/common/partials/symbol/detail/members-table-impl.hbs

@@ -10,7 +10,7 @@
 {{> symbol/detail/members-table-row . includeBrief=false isName=true}}
 {{/each}}
 {{ else }}
-{{#each (filter_by members "isRegular" "isSeeBelow")}}
+{{#each (filter_by_eq members "extraction" "regular" "see-below")}}
 {{> symbol/detail/members-table-row . includeBrief=../includeBrief isName=false}}
 {{/each}}
 {{/if}}

share/mrdocs/addons/generator/common/partials/symbol/members-table.hbs

@@ -15,7 +15,7 @@
     See: https://mrdocs.com/docs/mrdocs/develop/generators.html#dom_reference
 --}}
 {{#if members}}
-{{#if (or (eq members.[0].$meta.type "Name") (any_of_by members "isRegular" "isSeeBelow"))}}
+{{#if (or (eq members.[0].$meta.type "Name") (any_of_by_eq members "extraction" "regular" "see-below"))}}
 {{#>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].$meta.type "Name") includeBrief=(select (any_of_by members "doc.brief") true false) title=title}}
 

share/mrdocs/addons/generator/common/partials/symbol/signature/record.hbs

@@ -24,5 +24,5 @@
       final;` is ill-formed (`final` can't be used on a non-defining
       declaration). Similarly, don't show a semicolon if there are base
       classes. --}}
-{{~#isSeeBelow}} { /* see-below */ }{{/isSeeBelow~}}
-{{#if (or isSeeBelow (and (not isFinal) (eq (len bases) 0)))}};{{/if}}
+{{~#if (eq extraction "see-below")}} { /* see-below */ }{{/if~}}
+{{#if (or (eq extraction "see-below") (and (not isFinal) (eq (len bases) 0)))}};{{/if}}

share/mrdocs/addons/generator/common/partials/type/name-infos.hbs

@@ -12,7 +12,7 @@
 
     See: https://mrdocs.com/docs/mrdocs/develop/generators.html#dom_reference
 --}}
-{{#if id.isImplementationDefined~}}
+{{#if (eq id.extraction "implementation-defined")~}}
     {{! The name refers to a symbol that's implementation defined. These are special names that should not be linked. ~}}
     {{ str '/* '}}implementation-defined{{ str ' */'~}}
 {{else~}}

share/mrdocs/addons/generator/html/partials/symbol.html.hbs

@@ -348,7 +348,7 @@
 {{! 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}}
+{{#if (eq extraction "regular")}}
 {{#> markup/dynamic-level-h id=null }}{{> symbol/qualified-name . }} namespace{{/markup/dynamic-level-h~}}
 {{> symbol symbol=. id=null traversing-global-namespace=true }}
 {{/if}}

src/lib/Schemas/DomDescriptions.hpp

@@ -22,8 +22,7 @@
     automatically by reflection, but the *meaning* of each field
     cannot be inferred from the C++ types alone (e.g. the C++ doc
     comment describes the C++ class, not the DOM projection;
-    synthesized fields like `class` or `isSeeBelow` have no C++
-    counterpart at all).
+    the synthesized `class` field has no C++ counterpart at all).
 
     This header carries a small lookup table indexed by
     `(typeName, memberName)`. The schema writer consults it when
@@ -109,18 +108,6 @@ inline constexpr DomDescription kDomDescriptions[] = {
      "Tag set to the literal `\"symbol\"`. Lets templates "
      "discriminate symbol DOM objects from auxiliary types "
      "(`type`, `name`, etc.) without inspecting `kind`."},
-    {"Symbol", "isRegular",
-     "Convenience boolean equivalent to "
-     "`extraction === \"regular\"`."},
-    {"Symbol", "isSeeBelow",
-     "Convenience boolean equivalent to "
-     "`extraction === \"see-below\"`."},
-    {"Symbol", "isImplementationDefined",
-     "Convenience boolean equivalent to "
-     "`extraction === \"implementation-defined\"`."},
-    {"Symbol", "isDependency",
-     "Convenience boolean equivalent to "
-     "`extraction === \"dependency\"`."},
 
     // ----- FunctionSymbol ------------------------------------------
     {"FunctionSymbol", "",

src/lib/Schemas/DomSchemaWriter.hpp

@@ -276,45 +276,22 @@ objectSchema()
             });
     }
 
-    // Custom tag_invoke extensions for Symbol (see SymbolBase.hpp).
-    // These fields are added by the Symbol tag_invoke overload
-    // beyond what reflection provides. Descriptions live on the
-    // base `Symbol` entry in DomDescriptions.hpp.
+    // `class` is the only field Symbol's tag_invoke adds beyond
+    // what reflection provides; see SymbolBase.hpp. It acts as a
+    // discriminator so templates can tell Symbol DOM entries apart
+    // from Type or Name entries in mixed arrays.
     if constexpr (std::is_base_of_v<Symbol, T>)
     {
-        auto withDesc =
-            [](dom::Object schema, std::string_view const member)
-            {
-                if (auto const desc =
-                        findDomDescription("Symbol", member);
-                    !desc.empty())
-                {
-                    schema.set("description", std::string(desc));
-                }
-                return schema;
-            };
-
         dom::Object classSchema;
         classSchema.set("type", "string");
         classSchema.set("const", "symbol");
-        properties.set("class", withDesc(std::move(classSchema), "class"));
-
-        dom::Object boolSchema;
-        boolSchema.set("type", "boolean");
-        properties.set("isRegular",
-            withDesc(boolSchema, "isRegular"));
-        properties.set("isSeeBelow",
-            withDesc(boolSchema, "isSeeBelow"));
-        properties.set("isImplementationDefined",
-            withDesc(boolSchema, "isImplementationDefined"));
-        properties.set("isDependency",
-            withDesc(boolSchema, "isDependency"));
-
+        if (auto const desc = findDomDescription("Symbol", "class");
+            !desc.empty())
+        {
+            classSchema.set("description", std::string(desc));
+        }
+        properties.set("class", std::move(classSchema));
         required.push_back("class");
-        required.push_back("isRegular");
-        required.push_back("isSeeBelow");
-        required.push_back("isImplementationDefined");
-        required.push_back("isDependency");
     }
 
     // $meta object (added by addMetaObject in MapReflectedType.hpp).

src/lib/Support/Handlebars.cpp

@@ -6535,6 +6535,98 @@ registerContainerHelpers(Handlebars& hbs)
 
     hbs.registerHelper("any_of_by", any_of_by_fn);
 
+    static auto filter_by_eq_fn = dom::makeVariadicInvocable([](
+        dom::Array const& arguments) -> dom::Value
+    {
+        // (filter_by_eq container key value1 value2 ...)
+        //
+        // Filter elements of `container` keeping those whose value
+        // at `key` equals any of the listed values. The terminal
+        // argument is the Handlebars options object and is dropped.
+        if (arguments.size() < 4)
+        {
+            return arguments.at(0);
+        }
+        dom::Value container = arguments.at(0);
+        dom::Value key = arguments.at(1);
+        std::vector<dom::Value> values;
+        for (std::size_t i = 2; i < arguments.size() - 1; ++i)
+        {
+            values.push_back(arguments.at(i));
+        }
+
+        if (!container.isArray())
+        {
+            return container;
+        }
+        dom::Array const& arr = container.getArray();
+
+        std::vector<dom::Value> res;
+        std::size_t const n = arr.size();
+        for (std::size_t i = 0; i < n; ++i)
+        {
+            dom::Value el = arr.at(i);
+            if (!el.isObject())
+            {
+                continue;
+            }
+            dom::Value const fieldValue = el.lookup(key.getString());
+            auto const matchIt = std::ranges::find(values, fieldValue);
+            if (matchIt == values.end())
+            {
+                continue;
+            }
+            res.emplace_back(el);
+        }
+        return dom::Array(res);
+    });
+
+    hbs.registerHelper("filter_by_eq", filter_by_eq_fn);
+
+    static auto any_of_by_eq_fn = dom::makeVariadicInvocable([](
+        dom::Array const& arguments) -> dom::Value
+    {
+        // (any_of_by_eq container key value1 value2 ...)
+        //
+        // True if any element of `container` has its value at `key`
+        // equal to any of the listed values.
+        if (arguments.size() < 4)
+        {
+            return false;
+        }
+        dom::Value container = arguments.at(0);
+        dom::Value key = arguments.at(1);
+        std::vector<dom::Value> values;
+        for (std::size_t i = 2; i < arguments.size() - 1; ++i)
+        {
+            values.push_back(arguments.at(i));
+        }
+
+        if (!container.isArray())
+        {
+            return false;
+        }
+        dom::Array const& arr = container.getArray();
+
+        std::size_t const n = arr.size();
+        for (std::size_t i = 0; i < n; ++i)
+        {
+            dom::Value el = arr.at(i);
+            if (!el.isObject())
+            {
+                continue;
+            }
+            dom::Value const fieldValue = el.lookup(key.getString());
+            if (std::ranges::find(values, fieldValue) != values.end())
+            {
+                return true;
+            }
+        }
+        return false;
+    });
+
+    hbs.registerHelper("any_of_by_eq", any_of_by_eq_fn);
+
     hbs.registerHelper("at", dom::makeInvocable(at_fn));
 
     static auto fill_fn = dom::makeInvocable([](