fix: don't map "class" to "functionClass"

gennaroprota · gennaroprota · commit cbc0c8813e96 · 2025-12-10T16:41:23.000+01:00
diff --git a/include/mrdocs/Metadata/Symbol/Function.hpp b/include/mrdocs/Metadata/Symbol/Function.hpp
@@ -50,7 +50,7 @@ struct FunctionSymbol final
     Optional<TemplateInfo> Template;
 
     /// The class of function this is
-    FunctionClass Class = FunctionClass::Normal;
+    FunctionClass FuncClass = FunctionClass::Normal;
 
     /** Exception specification for the function.
     */
@@ -148,7 +148,7 @@ struct FunctionSymbol final
 BOOST_DESCRIBE_STRUCT(
     FunctionSymbol,
     (SymbolCommonBase<SymbolKind::Function>),
-    (ReturnType, Params, Template, Class, Noexcept, Requires,
+    (ReturnType, Params, Template, FuncClass, Noexcept, Requires,
      IsVariadic, IsDefaulted, IsExplicitlyDefaulted, IsDeleted,
      IsDeletedAsWritten, IsNoReturn, HasOverrideAttr, HasTrailingReturn,
      IsNodiscard, IsExplicitObjectMemberFunction, Constexpr,
diff --git a/include/mrdocs/Metadata/Symbol/Overloads.hpp b/include/mrdocs/Metadata/Symbol/Overloads.hpp
@@ -26,7 +26,7 @@ struct OverloadsSymbol final
     : SymbolCommonBase<SymbolKind::Overloads>
 {
     /// The class of the functions.
-    FunctionClass Class = FunctionClass::Normal;
+    FunctionClass FuncClass = FunctionClass::Normal;
 
     /// The overloaded operator, if any.
     OperatorKind OverloadedOperator = OperatorKind::None;
@@ -64,7 +64,7 @@ struct OverloadsSymbol final
 BOOST_DESCRIBE_STRUCT(
     OverloadsSymbol,
     (SymbolCommonBase<SymbolKind::Overloads>),
-    (Class, OverloadedOperator, Members) // ReturnType intentionally omitted.
+    (FuncClass, OverloadedOperator, Members) // ReturnType intentionally omitted.
 )
 
 /** Merge overload sets, preserving ordering in `Members`.
diff --git a/include/mrdocs/Metadata/Symbol/SymbolDescribeMapper.hpp b/include/mrdocs/Metadata/Symbol/SymbolDescribeMapper.hpp
@@ -75,10 +75,6 @@ normalizeMemberName(std::string_view name)
     {
         return "constexprKind";
     }
-    else if (name == "Class")
-    {
-        return "functionClass";
-    }
     else if (name == "ReturnType")
     {
         return "return";
diff --git a/share/mrdocs/addons/generator/common/partials/symbol/name-text.hbs b/share/mrdocs/addons/generator/common/partials/symbol/name-text.hbs
@@ -11,7 +11,7 @@
 
     See: https://mrdocs.com/docs/mrdocs/develop/generators.html#dom_reference
 --}}
-{{~#if (and (eq kind "function") (eq functionClass "conversion"))~}}
+{{~#if (and (eq kind "function") (eq funcClass "conversion"))~}}
     {{! Conversion operator: "operator" and the type declarator ~}}
     operator {{>type/declarator-text return ~}}
 {{~else if (eq kind "guide")~}}
diff --git a/src/lib/AST/ASTVisitor.cpp b/src/lib/AST/ASTVisitor.cpp
@@ -920,7 +920,7 @@ populate(
         }
     }
 
-    I.Class = toFunctionClass(D->getDeclKind());
+    I.FuncClass = toFunctionClass(D->getDeclKind());
 
     // extract the return type in direct dependency mode
     // if it contains a placeholder type which is
diff --git a/src/lib/CorpusImpl.cpp b/src/lib/CorpusImpl.cpp
@@ -583,7 +583,7 @@ lookupImpl(
                 }
                 else if (component.isConversion())
                 {
-                    MRDOCS_CHECK_OR(M.Class == FunctionClass::Conversion, matchRes);
+                    MRDOCS_CHECK_OR(M.FuncClass == FunctionClass::Conversion, matchRes);
                     MRDOCS_CHECK_OR(component.ConversionType == M.ReturnType, matchRes);
                 }
                 else
diff --git a/src/lib/Gen/xml/XMLWriter.cpp b/src/lib/Gen/xml/XMLWriter.cpp
@@ -187,8 +187,8 @@ writeFunction(
 
     constexpr std::string_view functionTagName = "function";
     tags_.open(functionTagName, {
-        { "class", toString(I.Class),
-            I.Class != FunctionClass::Normal },
+        { "class", toString(I.FuncClass),
+            I.FuncClass != FunctionClass::Normal },
         { "name", I.Name },
         { I.Access },
         { "exception-spec", except_spec,
diff --git a/src/lib/Metadata/Finalizers/BaseMembersFinalizer.cpp b/src/lib/Metadata/Finalizers/BaseMembersFinalizer.cpp
@@ -119,8 +119,8 @@ inheritBaseMembers(
         // Check if we're not attempt to copy a special member function
         if (auto const *funcPtr = otherInfoPtr->asFunctionPtr()) {
           MRDOCS_CHECK_OR_CONTINUE(
-              !is_one_of(funcPtr->Class, {FunctionClass::Constructor,
-                                          FunctionClass::Destructor}));
+              !is_one_of(funcPtr->FuncClass, {FunctionClass::Constructor,
+                                              FunctionClass::Destructor}));
         }
 
         // Check if derived class has a member that shadows the base member
diff --git a/src/lib/Metadata/Finalizers/DocComment/Function.hpp b/src/lib/Metadata/Finalizers/DocComment/Function.hpp
@@ -25,14 +25,14 @@ bool
 isSpecialFunction(FunctionSymbol const& I)
 {
     return
-        I.Class != FunctionClass::Normal ||
+        I.FuncClass != FunctionClass::Normal ||
         I.OverloadedOperator != OperatorKind::None;
 }
 
 bool
 isDefaultConstructor(FunctionSymbol const& I)
 {
-    return I.Class == FunctionClass::Constructor && I.Params.empty();
+    return I.FuncClass == FunctionClass::Constructor && I.Params.empty();
 }
 
 template <bool move, bool assignment>
@@ -41,7 +41,7 @@ isCopyOrMoveConstructorOrAssignment(FunctionSymbol const& I)
 {
     if constexpr (!assignment)
     {
-        MRDOCS_CHECK_OR(I.Class == FunctionClass::Constructor, false);
+        MRDOCS_CHECK_OR(I.FuncClass == FunctionClass::Constructor, false);
     }
     else
     {
@@ -122,7 +122,7 @@ innermostTypenameString(Polymorphic<Type> const& T)
 bool
 populateFunctionBriefFromClass(FunctionSymbol& I, CorpusImpl const& corpus)
 {
-    switch (I.Class)
+    switch (I.FuncClass)
     {
         case FunctionClass::Normal:
             return false;
@@ -315,7 +315,7 @@ populateFunctionReturnsForSpecial(
     Polymorphic<Type> const& innerR,
     CorpusImpl const& corpus)
 {
-    if (I.Class == FunctionClass::Conversion)
+    if (I.FuncClass == FunctionClass::Conversion)
     {
         if (auto* brief = getInfoBrief(innerR, corpus))
         {
@@ -529,7 +529,7 @@ setCntrOrAssignParamName(
     MRDOCS_CHECK_OR(I.Params.size() == 1, false);
     MRDOCS_CHECK_OR(I.IsRecordMethod, false);
     MRDOCS_CHECK_OR(
-        I.Class == FunctionClass::Constructor ||
+        I.FuncClass == FunctionClass::Constructor ||
         I.OverloadedOperator == OperatorKind::Equal,
         false);
     auto paramNames =
@@ -645,7 +645,7 @@ setCntrOrAssignParamDoc(
     MRDOCS_CHECK_OR(index == 0, false);
     MRDOCS_CHECK_OR(I.IsRecordMethod, false);
     MRDOCS_CHECK_OR(
-        I.Class == FunctionClass::Constructor ||
+        I.FuncClass == FunctionClass::Constructor ||
         I.OverloadedOperator == OperatorKind::Equal,
         false);
 
diff --git a/src/lib/Metadata/Finalizers/DocComment/Overloads.hpp b/src/lib/Metadata/Finalizers/DocComment/Overloads.hpp
@@ -63,7 +63,7 @@ populateOverloadsBriefIfAllSameBrief(OverloadsSymbol& I, Range&& functionsWithBr
 bool
 populateOverloadsFromClass(OverloadsSymbol& I)
 {
-    switch (I.Class)
+    switch (I.FuncClass)
     {
     case FunctionClass::Normal:
         return false;
diff --git a/src/lib/Metadata/Finalizers/DocCommentFinalizer.cpp b/src/lib/Metadata/Finalizers/DocCommentFinalizer.cpp
@@ -832,7 +832,7 @@ generateAutoFunctionMetadata(FunctionSymbol& I) const
             return;
         }
 
-        if (!is_one_of(I.Class, {
+        if (!is_one_of(I.FuncClass, {
             FunctionClass::Constructor,
             FunctionClass::Destructor }) &&
             I.doc->returns.empty())
diff --git a/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp b/src/lib/Metadata/Finalizers/SortMembersFinalizer.cpp
@@ -37,7 +37,7 @@ struct SymbolIDCompareFn
             std::same_as<FunctionSymbol, InfoTy> ||
             std::same_as<OverloadsSymbol, InfoTy>)
         {
-            return I.Class;
+            return I.FuncClass;
         }
         return std::nullopt;
     }
diff --git a/src/lib/Metadata/Symbol/Function.cpp b/src/lib/Metadata/Symbol/Function.cpp
@@ -369,9 +369,9 @@ merge(FunctionSymbol& I, FunctionSymbol&& Other)
 {
     MRDOCS_ASSERT(canMerge(I, Other));
     merge(I.asInfo(), std::move(Other.asInfo()));
-    if (I.Class == FunctionClass::Normal)
+    if (I.FuncClass == FunctionClass::Normal)
     {
-        I.Class = Other.Class;
+        I.FuncClass = Other.FuncClass;
     }
     I.ReturnType = std::move(Other.ReturnType);
     std::size_t const n = std::min(I.Params.size(), Other.Params.size());
diff --git a/src/lib/Metadata/Symbol/Overloads.cpp b/src/lib/Metadata/Symbol/Overloads.cpp
@@ -48,7 +48,7 @@ addMember(OverloadsSymbol& I, FunctionSymbol const& Member)
         I.Name = Member.Name;
         I.Access = Member.Access;
         I.Extraction = Member.Extraction;
-        I.Class = Member.Class;
+        I.FuncClass = Member.FuncClass;
         I.OverloadedOperator = Member.OverloadedOperator;
         I.ReturnType = Member.ReturnType;
     }
diff --git a/src/lib/Support/LegibleNames.cpp b/src/lib/Support/LegibleNames.cpp
@@ -49,24 +49,24 @@ getUnnamedInfoName(Symbol const& I)
         if (auto const* FI = I.asFunctionPtr())
         {
             // don't use the reserved prefix for overloaded operators
-            if(FI->Class == FunctionClass::Normal &&
+            if(FI->FuncClass == FunctionClass::Normal &&
                 FI->OverloadedOperator != OperatorKind::None)
             {
                 return std::string(getSafeOperatorName(
                     FI->OverloadedOperator, true));
             }
-            func_idx = to_underlying(FI->Class);
+            func_idx = to_underlying(FI->FuncClass);
         }
         if (auto const* FI = I.asOverloadsPtr())
         {
             // don't use the reserved prefix for overloaded operators
-            if(FI->Class == FunctionClass::Normal &&
+            if(FI->FuncClass == FunctionClass::Normal &&
                 FI->OverloadedOperator != OperatorKind::None)
             {
                 return std::string(getSafeOperatorName(
                     FI->OverloadedOperator, true));
             }
-            func_idx = to_underlying(FI->Class);
+            func_idx = to_underlying(FI->FuncClass);
         }
         MRDOCS_ASSERT(func_idx < std::size(func_reserved));
         return std::string(func_reserved[func_idx]);
@@ -219,7 +219,7 @@ class LegibleNames::Impl
                 {
                     // functions can be explicitly specialized,
                     // and can be overloaded
-                    if (t.Class != FunctionClass::Normal ||
+                    if (t.FuncClass != FunctionClass::Normal ||
                         t.OverloadedOperator != OperatorKind::None)
                     {
                         return getUnnamedInfoName(t);

Original file line number	Diff line number	Diff line change
`@@ -75,10 +75,6 @@ normalizeMemberName(std::string_view name)`
`75`	`75`	`{`
`76`	`76`	`return "constexprKind";`
`77`	`77`	`}`
`78`		`- else if (name == "Class")`
`79`		`- {`
`80`		`- return "functionClass";`
`81`		`- }`
`82`	`78`	`else if (name == "ReturnType")`
`83`	`79`	`{`
`84`	`80`	`return "return";`
Original file line number	Diff line number	Diff line change
`@@ -920,7 +920,7 @@ populate(`
`920`	`920`	`}`
`921`	`921`	`}`
`922`	`922`
`923`		`- I.Class = toFunctionClass(D->getDeclKind());`
	`923`	`+ I.FuncClass = toFunctionClass(D->getDeclKind());`
`924`	`924`
`925`	`925`	`// extract the return type in direct dependency mode`
`926`	`926`	`// if it contains a placeholder type which is`
Original file line number	Diff line number	Diff line change
`@@ -583,7 +583,7 @@ lookupImpl(`
`583`	`583`	`}`
`584`	`584`	`else if (component.isConversion())`
`585`	`585`	`{`
`586`		`- MRDOCS_CHECK_OR(M.Class == FunctionClass::Conversion, matchRes);`
	`586`	`+ MRDOCS_CHECK_OR(M.FuncClass == FunctionClass::Conversion, matchRes);`
`587`	`587`	`MRDOCS_CHECK_OR(component.ConversionType == M.ReturnType, matchRes);`
`588`	`588`	`}`
`589`	`589`	`else`
Original file line number	Diff line number	Diff line change
`@@ -25,14 +25,14 @@ bool`
`25`	`25`	`isSpecialFunction(FunctionSymbol const& I)`
`26`	`26`	`{`
`27`	`27`	`return`
`28`		`- I.Class != FunctionClass::Normal \|\|`
	`28`	`+ I.FuncClass != FunctionClass::Normal \|\|`
`29`	`29`	`I.OverloadedOperator != OperatorKind::None;`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`bool`
`33`	`33`	`isDefaultConstructor(FunctionSymbol const& I)`
`34`	`34`	`{`
`35`		`- return I.Class == FunctionClass::Constructor && I.Params.empty();`
	`35`	`+ return I.FuncClass == FunctionClass::Constructor && I.Params.empty();`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`template <bool move, bool assignment>`
`@@ -41,7 +41,7 @@ isCopyOrMoveConstructorOrAssignment(FunctionSymbol const& I)`
`41`	`41`	`{`
`42`	`42`	`if constexpr (!assignment)`
`43`	`43`	`{`
`44`		`- MRDOCS_CHECK_OR(I.Class == FunctionClass::Constructor, false);`
	`44`	`+ MRDOCS_CHECK_OR(I.FuncClass == FunctionClass::Constructor, false);`
`45`	`45`	`}`
`46`	`46`	`else`
`47`	`47`	`{`
`@@ -122,7 +122,7 @@ innermostTypenameString(Polymorphic<Type> const& T)`
`122`	`122`	`bool`
`123`	`123`	`populateFunctionBriefFromClass(FunctionSymbol& I, CorpusImpl const& corpus)`
`124`	`124`	`{`
`125`		`- switch (I.Class)`
	`125`	`+ switch (I.FuncClass)`
`126`	`126`	`{`
`127`	`127`	`case FunctionClass::Normal:`
`128`	`128`	`return false;`
`@@ -315,7 +315,7 @@ populateFunctionReturnsForSpecial(`
`315`	`315`	`Polymorphic<Type> const& innerR,`
`316`	`316`	`CorpusImpl const& corpus)`
`317`	`317`	`{`
`318`		`- if (I.Class == FunctionClass::Conversion)`
	`318`	`+ if (I.FuncClass == FunctionClass::Conversion)`
`319`	`319`	`{`
`320`	`320`	`if (auto* brief = getInfoBrief(innerR, corpus))`
`321`	`321`	`{`
`@@ -529,7 +529,7 @@ setCntrOrAssignParamName(`
`529`	`529`	`MRDOCS_CHECK_OR(I.Params.size() == 1, false);`
`530`	`530`	`MRDOCS_CHECK_OR(I.IsRecordMethod, false);`
`531`	`531`	`MRDOCS_CHECK_OR(`
`532`		`- I.Class == FunctionClass::Constructor \|\|`
	`532`	`+ I.FuncClass == FunctionClass::Constructor \|\|`
`533`	`533`	`I.OverloadedOperator == OperatorKind::Equal,`
`534`	`534`	`false);`
`535`	`535`	`auto paramNames =`
`@@ -645,7 +645,7 @@ setCntrOrAssignParamDoc(`
`645`	`645`	`MRDOCS_CHECK_OR(index == 0, false);`
`646`	`646`	`MRDOCS_CHECK_OR(I.IsRecordMethod, false);`
`647`	`647`	`MRDOCS_CHECK_OR(`
`648`		`- I.Class == FunctionClass::Constructor \|\|`
	`648`	`+ I.FuncClass == FunctionClass::Constructor \|\|`
`649`	`649`	`I.OverloadedOperator == OperatorKind::Equal,`
`650`	`650`	`false);`
`651`	`651`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ populateOverloadsBriefIfAllSameBrief(OverloadsSymbol& I, Range&& functionsWithBr`
`63`	`63`	`bool`
`64`	`64`	`populateOverloadsFromClass(OverloadsSymbol& I)`
`65`	`65`	`{`
`66`		`- switch (I.Class)`
	`66`	`+ switch (I.FuncClass)`
`67`	`67`	`{`
`68`	`68`	`case FunctionClass::Normal:`
`69`	`69`	`return false;`