change InfoType to InfoKind

Author: sdkrystian

include/mrdox/Corpus.hpp

@@ -161,19 +161,19 @@ get(
     assert(I != nullptr);
     auto const t = static_cast<T const*>(I);
     if constexpr(std::is_same_v<T, NamespaceInfo>)
-        assert(t->IT == InfoType::IT_namespace);
+        assert(t->Kind == InfoKind::Namespace);
     else if constexpr(std::is_same_v<T, RecordInfo>)
-        assert(t->IT == InfoType::IT_record);
+        assert(t->Kind == InfoKind::Record);
     else if constexpr(std::is_same_v<T, FunctionInfo>)
-        assert(t->IT == InfoType::IT_function);
+        assert(t->Kind == InfoKind::Function);
     else if constexpr(std::is_same_v<T, TypedefInfo>)
-        assert(t->IT == InfoType::IT_typedef);
+        assert(t->Kind == InfoKind::Typedef);
     else if constexpr(std::is_same_v<T, EnumInfo>)
-        assert(t->IT == InfoType::IT_enum);
+        assert(t->Kind == InfoKind::Enum);
     else if constexpr(std::is_same_v<T, VarInfo>)
-        assert(t->IT == InfoType::IT_variable);
+        assert(t->Kind == InfoKind::Variable);
     else if constexpr(std::is_same_v<T, FieldInfo>)
-        assert(t->IT == InfoType::IT_field);
+        assert(t->Kind == InfoKind::Field);
     return *t;
 }
 

include/mrdox/Metadata/Enum.hpp

@@ -82,12 +82,12 @@ struct EnumInfo
 
     //--------------------------------------------
 
-    static constexpr InfoType type_id = InfoType::IT_enum;
+    static constexpr InfoKind kind_id = InfoKind::Enum;
 
     explicit
     EnumInfo(
         SymbolID ID = SymbolID::zero)
-        : SymbolInfo(InfoType::IT_enum, ID)
+        : SymbolInfo(InfoKind::Enum, ID)
     {
     }
 };

include/mrdox/Metadata/Field.hpp

@@ -56,11 +56,11 @@ struct FieldInfo
 
     //--------------------------------------------
 
-    static constexpr InfoType type_id = InfoType::IT_field;
+    static constexpr InfoKind kind_id = InfoKind::Field;
 
     FieldInfo(
         SymbolID ID = SymbolID::zero)
-        : SymbolInfo(InfoType::IT_field, ID)
+        : SymbolInfo(InfoKind::Field, ID)
     {
     }
 };

include/mrdox/Metadata/Function.hpp

@@ -190,20 +190,20 @@ struct FunctionInfo
 
     //--------------------------------------------
 
-    static constexpr InfoType type_id = InfoType::IT_function;
+    static constexpr InfoKind kind_id = InfoKind::Function;
 
     explicit
     FunctionInfo(
         SymbolID ID = SymbolID::zero)
-        : SymbolInfo(InfoType::IT_function, ID)
+        : SymbolInfo(InfoKind::Function, ID)
     {
     }
 
 private:
     explicit
     FunctionInfo(
         std::unique_ptr<TemplateInfo>&& T)
-        : SymbolInfo(InfoType::IT_function)
+        : SymbolInfo(InfoKind::Function)
         , Template(std::move(T))
     {
     }

include/mrdox/Metadata/Info.hpp

@@ -34,7 +34,7 @@ struct Info
 
     /** Kind of declaration.
     */
-    InfoType IT = InfoType::IT_default;
+    InfoKind Kind = InfoKind::Default;
 
     /** The unqualified name.
     */
@@ -56,10 +56,10 @@ struct Info
 
     explicit
     Info(
-        InfoType IT = InfoType::IT_default,
+        InfoKind kind = InfoKind::Default,
         SymbolID ID = SymbolID::zero)
         : id(ID)
-        , IT(IT)
+        , Kind(kind)
     {
     }
 

include/mrdox/Metadata/Namespace.hpp

@@ -28,7 +28,7 @@ struct NamespaceInfo
 
     //--------------------------------------------
 
-    static constexpr InfoType type_id = InfoType::IT_namespace;
+    static constexpr InfoKind kind_id = InfoKind::Namespace;
 
     NamespaceInfo();
 

include/mrdox/Metadata/Record.hpp

@@ -160,20 +160,20 @@ struct RecordInfo
 
     //--------------------------------------------
 
-    static constexpr InfoType type_id = InfoType::IT_record;
+    static constexpr InfoKind kind_id = InfoKind::Record;
 
     explicit
     RecordInfo(
         SymbolID ID = SymbolID::zero)
-        : SymbolInfo(InfoType::IT_record, ID)
+        : SymbolInfo(InfoKind::Record, ID)
     {
     }
 
 private:
     explicit
     RecordInfo(
         std::unique_ptr<TemplateInfo>&& T)
-        : SymbolInfo(InfoType::IT_record)
+        : SymbolInfo(InfoKind::Record)
         , Template(std::move(T))
     {
     }

include/mrdox/Metadata/Reference.hpp

@@ -34,7 +34,7 @@ struct Reference
 
     /** The type of the referenced symbol.
     */
-    InfoType RefType = InfoType::IT_default;
+    InfoKind RefKind = InfoKind::Default;
 
     //--------------------------------------------
 
@@ -46,10 +46,10 @@ struct Reference
     Reference(
         SymbolID ID = SymbolID::zero,
         std::string_view Name = "",
-        InfoType IT = InfoType::IT_default)
+        InfoKind kind = InfoKind::Default)
         : id(ID)
         , Name(Name)
-        , RefType(IT)
+        , RefKind(kind)
     {
     }
 
@@ -62,8 +62,8 @@ struct Reference
         // VFALCO Is this function only needed
         //        for the old unit tests?
         return
-            std::tie(id, Name, RefType) ==
-            std::tie(Other.id, Other.Name, Other.RefType);
+            std::tie(id, Name, RefKind) ==
+            std::tie(Other.id, Other.Name, Other.RefKind);
     }
 #endif
 };

include/mrdox/Metadata/Symbol.hpp

@@ -45,9 +45,9 @@ struct SymbolInfo
 
     explicit
     SymbolInfo(
-        InfoType IT,
+        InfoKind kind,
         SymbolID ID = SymbolID::zero)
-        : Info(IT, ID)
+        : Info(kind, ID)
     {
     }
 };

include/mrdox/Metadata/Symbols.hpp

@@ -107,17 +107,17 @@ using OptionalSymbolID = Optional<SymbolID>;
 
 /** Info variant discriminator
 */
-enum class InfoType
+enum class InfoKind
 {
-    IT_default,
-    IT_namespace,
-    IT_record,
-    IT_function,
-    IT_enum,
-    IT_typedef,
-    IT_variable,
-    IT_field,
-    IT_specialization
+    Default,
+    Namespace,
+    Record,
+    Function,
+    Enum,
+    Typedef,
+    Variable,
+    Field,
+    Specialization
 };
 
 /** Return the result of comparing s0 to s1.