InfoTypeFor trait

#refactor

Author: alandefreitas

src/lib/AST/ASTVisitor.cpp

@@ -348,22 +348,20 @@ defaultTraverseImpl(DeclTy* D, TemplateDeclTy* TD)
 
     // If D is also a template declaration, we extract
     // the template information from the declaration itself
-    if constexpr (!PopulateFromTD && std::derived_from<DeclTy, TemplateDecl>)
-    {
-        defaultTraverseImpl<true>(D, D);
-        return;
-    }
-
-    using InfoT = MrDocsType_t<DeclTy>;
-    static constexpr bool HasMrDocsInfoType = !std::same_as<InfoT, Info>;
-    if constexpr (!HasMrDocsInfoType)
+    if constexpr (!HasInfoTypeFor<DeclTy>)
     {
         // Traverse the members of the declaration even if
         // the declaration does not have a corresponding Info type
         traverseMembers(D);
     }
     else
     {
+        if constexpr (!PopulateFromTD && std::derived_from<DeclTy, TemplateDecl>)
+        {
+            defaultTraverseImpl<true>(D, D);
+            return;
+        }
+
         // If the declaration has a corresponding Info type,
         // we build the Info object and populate it with the
         // necessary information.
@@ -2805,7 +2803,7 @@ upsert(SymbolID const& id)
 }
 
 template <std::derived_from<Decl> DeclType>
-Expected<ASTVisitor::upsertResult<MrDocsType_t<DeclType>>>
+Expected<ASTVisitor::upsertResult<InfoTypeFor_t<DeclType>>>
 ASTVisitor::
 upsert(DeclType* D)
 {
@@ -2817,10 +2815,10 @@ upsert(DeclType* D)
     SymbolID const id = generateID(D);
     MRDOCS_CHECK_MSG(id, "Failed to extract symbol ID");
 
-    auto [I, isNew] = upsert<MrDocsType_t<DeclType>>(id);
+    auto [I, isNew] = upsert<InfoTypeFor_t<DeclType>>(id);
     I.Access = convertToAccessKind(access);
 
-    using R = upsertResult<MrDocsType_t<DeclType>>;
+    using R = upsertResult<InfoTypeFor_t<DeclType>>;
     return R{std::ref(I), isNew};
 }
 

src/lib/AST/ASTVisitor.hpp

@@ -879,7 +879,7 @@ class ASTVisitor
         @param D The declaration to extract
      */
     template <std::derived_from<Decl> DeclType>
-    Expected<upsertResult<MrDocsType_t<DeclType>>>
+    Expected<upsertResult<InfoTypeFor_t<DeclType>>>
     upsert(DeclType* D);
 
     /* Get or construct an empty Info for a dependency declaration.

src/lib/AST/ClangHelpers.hpp

@@ -63,53 +63,85 @@ SubstituteConstraintExpressionWithoutSatisfaction(
 
     When there's no direct correspondence, this trait returns
     the base Info type.
-
  */
-template <class DeclType>
-struct MrDocsType : std::type_identity<Info> {};
+template <class>
+struct InfoTypeFor {};
 
-template <std::derived_from<CXXRecordDecl> DeclType>
-struct MrDocsType<DeclType> : std::type_identity<RecordInfo> {};
+// Extract NamespaceInfo from NamespaceDecl
+template <>
+struct InfoTypeFor<NamespaceDecl>
+    : std::type_identity<NamespaceInfo> {};
 
-template <std::derived_from<VarDecl> VarTy>
-struct MrDocsType<VarTy> : std::type_identity<VariableInfo> {};
+// Extract RecordInfo from anything derived from CXXRecordDecl
+template <std::derived_from<CXXRecordDecl> DeclType>
+struct InfoTypeFor<DeclType>
+    : std::type_identity<RecordInfo> {};
 
+// Extract FunctionInfo from anything derived from FunctionDecl
 template <std::derived_from<FunctionDecl> FunctionTy>
-struct MrDocsType<FunctionTy> : std::type_identity<FunctionInfo> {};
-
-template <std::derived_from<TypedefNameDecl> TypedefNameTy>
-struct MrDocsType<TypedefNameTy> : std::type_identity<TypedefInfo> {};
+struct InfoTypeFor<FunctionTy>
+    : std::type_identity<FunctionInfo> {};
 
+// Extract EnumInfo from EnumDecl
 template <>
-struct MrDocsType<EnumDecl> : std::type_identity<EnumInfo> {};
+struct InfoTypeFor<EnumDecl>
+    : std::type_identity<EnumInfo> {};
 
+// Extract EnumConstantInfo from EnumConstantDecl
 template <>
-struct MrDocsType<FieldDecl> : std::type_identity<FieldInfo> {};
+struct InfoTypeFor<EnumConstantDecl>
+    : std::type_identity<EnumConstantInfo> {};
 
-template <>
-struct MrDocsType<EnumConstantDecl> : std::type_identity<EnumConstantInfo> {};
+// Extract TypedefInfo from anything derived from TypedefNameDecl
+template <std::derived_from<TypedefNameDecl> TypedefNameTy>
+struct InfoTypeFor<TypedefNameTy>
+    : std::type_identity<TypedefInfo> {};
 
+// Extract VariableInfo from anything derived from VarDecl
+template <std::derived_from<VarDecl> VarTy>
+struct InfoTypeFor<VarTy>
+    : std::type_identity<VariableInfo> {};
+
+// Extract FieldInfo from FieldDecl
 template <>
-struct MrDocsType<FriendDecl> : std::type_identity<FriendInfo> {};
+struct InfoTypeFor<FieldDecl>
+    : std::type_identity<FieldInfo> {};
 
+// Extract FriendInfo from FriendDecl
 template <>
-struct MrDocsType<CXXDeductionGuideDecl> : std::type_identity<GuideInfo> {};
+struct InfoTypeFor<FriendDecl>
+    : std::type_identity<FriendInfo> {};
 
+// Extract GuideInfo from CXXDeductionGuideDecl
 template <>
-struct MrDocsType<NamespaceAliasDecl> : std::type_identity<NamespaceAliasInfo> {};
+struct InfoTypeFor<CXXDeductionGuideDecl>
+    : std::type_identity<GuideInfo> {};
 
+// Extract NamespaceAliasInfo from NamespaceAliasDecl
 template <>
-struct MrDocsType<UsingDecl> : std::type_identity<UsingInfo> {};
+struct InfoTypeFor<NamespaceAliasDecl>
+    : std::type_identity<NamespaceAliasInfo> {};
 
+// Extract UsingInfo from UsingDecl
 template <>
-struct MrDocsType<NamespaceDecl> : std::type_identity<NamespaceInfo>{};
+struct InfoTypeFor<UsingDecl>
+    : std::type_identity<UsingInfo> {};
 
+// Extract ConceptInfo from ConceptDecl
 template <>
-struct MrDocsType<ConceptDecl> : std::type_identity<ConceptInfo>{};
+struct InfoTypeFor<ConceptDecl>
+    : std::type_identity<ConceptInfo> {};
+
+/// Determine if there's a MrDocs Info type for a Clang DeclType
+template <class T>
+concept HasInfoTypeFor = requires
+{
+    typename InfoTypeFor<T>::type;
+};
 
-/// @copydoc MrDocsType
+/// @copydoc InfoTypeFor
 template <class DeclType>
-using MrDocsType_t = typename MrDocsType<DeclType>::type;
+using InfoTypeFor_t = typename InfoTypeFor<DeclType>::type;
 
 /** Convert a Clang AccessSpecifier into a MrDocs AccessKind
  */