TypeInfo identifies fundamental types

#feat

Author: alandefreitas

include/mrdocs/Metadata/Type.hpp

@@ -208,11 +208,185 @@ struct TypeInfoCommonBase : TypeInfo
     }
 };
 
+/** 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.
+
+    @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::optional<FundamentalTypeKind> FundamentalType;
+
     std::strong_ordering
     operator<=>(NamedTypeInfo const& other) const;
 };

src/lib/AST/ClangHelpers.hpp

@@ -500,7 +500,7 @@ toFunctionClass(Decl::Kind const kind)
  */
 inline
 AutoKind
-convertToAutoKind(AutoTypeKeyword const kind)
+toAutoKind(AutoTypeKeyword const kind)
 {
     switch(kind)
     {
@@ -514,6 +514,63 @@ convertToAutoKind(AutoTypeKeyword const kind)
     }
 }
 
+/** Convert a Clang AutoTypeKeyword into a MrDocs AutoKind
+ */
+inline
+std::optional<FundamentalTypeKind>
+toFundamentalTypeKind(BuiltinType::Kind const kind)
+{
+    switch(kind)
+    {
+    case BuiltinType::Kind::Void:
+        return FundamentalTypeKind::Void;
+    case BuiltinType::Kind::NullPtr:
+        return FundamentalTypeKind::Nullptr;
+    case BuiltinType::Kind::Bool:
+        return FundamentalTypeKind::Bool;
+    case BuiltinType::Kind::Char_U:
+    case BuiltinType::Kind::Char_S:
+        return FundamentalTypeKind::Char;
+    case BuiltinType::Kind::SChar:
+        return FundamentalTypeKind::SignedChar;
+    case BuiltinType::Kind::UChar:
+        return FundamentalTypeKind::UnsignedChar;
+    case BuiltinType::Kind::Char8:
+        return FundamentalTypeKind::Char8;
+    case BuiltinType::Kind::Char16:
+        return FundamentalTypeKind::Char16;
+    case BuiltinType::Kind::Char32:
+        return FundamentalTypeKind::Char32;
+    case BuiltinType::Kind::WChar_S:
+    case BuiltinType::Kind::WChar_U:
+        return FundamentalTypeKind::WChar;
+    case BuiltinType::Kind::Short:
+        return FundamentalTypeKind::Short;
+    case BuiltinType::Kind::UShort:
+        return FundamentalTypeKind::UnsignedShort;
+    case BuiltinType::Kind::Int:
+        return FundamentalTypeKind::Int;
+    case BuiltinType::Kind::UInt:
+        return FundamentalTypeKind::UnsignedInt;
+    case BuiltinType::Kind::Long:
+        return FundamentalTypeKind::Long;
+    case BuiltinType::Kind::ULong:
+        return FundamentalTypeKind::UnsignedLong;
+    case BuiltinType::Kind::LongLong:
+        return FundamentalTypeKind::LongLong;
+    case BuiltinType::Kind::ULongLong:
+        return FundamentalTypeKind::UnsignedLongLong;
+    case BuiltinType::Kind::Float:
+        return FundamentalTypeKind::Float;
+    case BuiltinType::Kind::Double:
+        return FundamentalTypeKind::Double;
+    case BuiltinType::Kind::LongDouble:
+        return FundamentalTypeKind::LongDouble;
+    default:
+        return std::nullopt;
+    }
+}
+
 // ----------------------------------------------------------------
 
 /** Visit a Decl and call the appropriate visitor function.

src/lib/AST/TypeInfoBuilder.cpp

@@ -126,7 +126,7 @@ buildAuto(
     AutoTypeInfo I;
     I.IsConst = quals & Qualifiers::Const;
     I.IsVolatile = quals & Qualifiers::Volatile;
-    I.Keyword = convertToAutoKind(T->getKeyword());
+    I.Keyword = toAutoKind(T->getKeyword());
     if(T->isConstrained())
     {
         std::optional<ArrayRef<TemplateArgument>> TArgs;
@@ -153,12 +153,18 @@ buildTerminal(
     unsigned quals,
     bool pack)
 {
+    MRDOCS_SYMBOL_TRACE(T, getASTVisitor().context_);
     NamedTypeInfo TI;
     TI.IsConst = quals & Qualifiers::Const;
     TI.IsVolatile = quals & Qualifiers::Volatile;
     TI.Name = MakePolymorphic<NameInfo>();
     TI.Name->Name = getASTVisitor().toString(T);
     TI.Name->Prefix = getASTVisitor().toNameInfo(NNS);
+    if (isa<BuiltinType>(T))
+    {
+        auto const* FT = cast<BuiltinType>(T);
+        TI.FundamentalType = toFundamentalTypeKind(FT->getKind());
+    }
     TI.Constraints = this->Constraints;
     *Inner = std::move(TI);
     Result->Constraints = this->Constraints;