Improved parsing of templates

closes #167

Author: sdkrystian

include/mrdox/Metadata/Symbols.hpp

@@ -80,6 +80,13 @@ class OptionalSymbolID
     {
         return ID_ != EmptySID;
     }
+
+    template<typename... Args>
+    constexpr value_type& emplace(Args&&... args)
+    {
+        return *::new (&ID_) SymbolID(
+            std::forward<Args>(args)...);
+    }
 };
 
 /** The ID of the global namespace.

include/mrdox/Metadata/Template.hpp

@@ -5,6 +5,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 // Copyright (c) 2023 Vinnie Falco ([email protected])
+// Copyright (c) 2023 Krystian Stasiowski ([email protected])
 //
 // Official repository: https://github.com/cppalliance/mrdox
 //
@@ -13,30 +14,49 @@
 #define MRDOX_METADATA_TEMPLATE_HPP
 
 #include <mrdox/Platform.hpp>
+#include <mrdox/Metadata/TemplateArg.hpp>
 #include <mrdox/Metadata/TemplateParam.hpp>
-#include <llvm/ADT/Optional.h>
 
 namespace clang {
 namespace mrdox {
 
-struct TemplateSpecializationInfo
+enum class TemplateSpecKind
 {
-    // Indicates the declaration that this specializes.
-    SymbolID SpecializationOf;
-
-    // Template parameters applying to the specialized record/function.
-    std::vector<TemplateParamInfo> Params;
+    Primary = 0, // for bitstream
+    Explicit,
+    Partial
 };
 
-// Records the template information for a struct or function that is a template
-// or an explicit template specialization.
+// stores information pertaining to primary template and
+// partial/explicit specialization declarations
 struct TemplateInfo
 {
-    // May be empty for non-partial specializations.
-    std::vector<TemplateParamInfo> Params;
+    // for primary templates:
+    //     - Params will be non-empty
+    //     - Args will be empty
+    // for explicit specializations:
+    //     - Params will be empty
+    // for partial specializations:
+    //     - Params will be non-empty
+    //     - each template parameter will appear at least
+    //       once in Args outside of a non-deduced context 
+    std::vector<TParam> Params;
+    std::vector<TArg> Args;
+
+    // stores the ID of the corresponding primary template
+    // for partial and explicit specializations
+    OptionalSymbolID Primary;
 
-    // Set when this is a specialization of another record/function.
-    llvm::Optional<TemplateSpecializationInfo> Specialization;
+    // KRYSTIAN NOTE: using the presence of args/params
+    // to determine the specialization kind *should* work.
+    // emphasis on should.
+    TemplateSpecKind specializationKind() const noexcept
+    {
+        if(Params.empty())
+            return TemplateSpecKind::Explicit;
+        return Args.empty() ? TemplateSpecKind::Primary :
+            TemplateSpecKind::Partial;
+    }
 };
 
 } // mrdox

include/mrdox/Metadata/TemplateArg.hpp

@@ -0,0 +1,33 @@
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Copyright (c) 2023 Krystian Stasiowski ([email protected])
+//
+// Official repository: https://github.com/cppalliance/mrdox
+//
+
+#ifndef MRDOX_METADATA_TEMPLATEARG_HPP
+#define MRDOX_METADATA_TEMPLATEARG_HPP
+
+#include <mrdox/Platform.hpp>
+#include <string>
+
+namespace clang {
+namespace mrdox {
+
+struct TArg
+{
+    std::string Value;
+
+    TArg() = default;
+
+    MRDOX_DECL 
+    TArg(std::string&& value);
+};
+
+} // mrdox
+} // clang
+
+#endif

include/mrdox/Metadata/TemplateParam.hpp

@@ -5,6 +5,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 // Copyright (c) 2023 Vinnie Falco ([email protected])
+// Copyright (c) 2023 Krystian Stasiowski ([email protected])
 //
 // Official repository: https://github.com/cppalliance/mrdox
 //
@@ -13,45 +14,164 @@
 #define MRDOX_METADATA_TEMPLATEPARAM_HPP
 
 #include <mrdox/Platform.hpp>
-#include <clang/AST/Decl.h>
-#include <clang/AST/Type.h>
-#include <llvm/ADT/SmallString.h>
-#include <llvm/ADT/StringRef.h>
+#include <mrdox/Metadata/Type.hpp>
 
 namespace clang {
 namespace mrdox {
 
-// Represents one template parameter.
-//
-// This is a very simple serialization of the text of the source code of the
-// template parameter. It is saved in a struct so there is a place to add the
-// name and default values in the future if needed.
-//
-/** A template parameter.
-*/
-struct TemplateParamInfo
+enum class TemplateParamKind : int
+{
+    None = 0, // for bitstream
+    // template type parameter, e.g. "typename T" or "class T"
+    Type,
+    // template non-type parameter, e.g. "int N" or "auto N"
+    NonType,
+    // template template parameter, e.g. "template<typename> typename T"
+    Template,
+};
+
+struct TParam;
+
+struct TypeTParam
+{
+    // default type for the type template parameter
+    std::optional<TypeInfo> Default;
+};
+
+struct NonTypeTParam
+{
+    // type of the non-type template parameter
+    TypeInfo Type;
+    // non-type template parameter default value (if any)
+    std::optional<std::string> Default;
+};
+
+struct TemplateTParam
+{
+    // template parameters for the template template parameter
+    std::vector<TParam> Params;
+    // non-type template parameter default value (if any)
+    std::optional<std::string> Default;
+};
+
+
+struct TParam
 {
-    // The literal contents of the code for that specifies this template parameter
-    // for this declaration. Typical values will be "class T" and
-    // "typename T = int".
-    llvm::SmallString<16> Contents;
+private:
+    union Variant
+    {
+        Variant() { }
+        ~Variant() { }
+
+        TypeTParam Type;
+        NonTypeTParam NonType;
+        TemplateTParam Template;
+    } Variant_;
+
+    void destroy() const noexcept;
+
+    template<typename T>
+    void 
+    construct(T&& other)
+    {
+        switch(other.Kind)
+        {
+        case TemplateParamKind::Type:
+            emplace<TypeTParam>(
+                std::forward<T>(other).Variant_.Type);
+            break;
+        case TemplateParamKind::NonType:
+            emplace<NonTypeTParam>(
+                std::forward<T>(other).Variant_.NonType);
+            break;
+        case TemplateParamKind::Template:
+            emplace<TemplateTParam>(
+                std::forward<T>(other).Variant_.Template);
+            break;
+        default:
+            break;
+        }
+    }
+
+public:
+    // The kind of template parameter this is.
+    TemplateParamKind Kind = TemplateParamKind::None;
+    // The template parameters name, if any
+    std::string Name;
+    // Whether this template parameter is a parameter pack.
+    bool IsParameterPack = false;
+
 
-    //--------------------------------------------
+    TParam() = default;
 
-    TemplateParamInfo() = default;
+    MRDOX_DECL 
+    TParam(
+        TParam&& other) noexcept;
+    
+    MRDOX_DECL
+    TParam(
+        const TParam& other);
 
-    explicit
-    TemplateParamInfo(
-        NamedDecl const& ND);
+    MRDOX_DECL
+    TParam(
+        std::string&& name,
+        bool is_pack);
 
-    TemplateParamInfo(
-        Decl const& D,
-        TemplateArgument const &Arg);
+    MRDOX_DECL ~TParam();
+
+    MRDOX_DECL
+    TParam& 
+    operator=(
+        const TParam& other);
+
+    MRDOX_DECL
+    TParam& 
+    operator=(
+        TParam&& other) noexcept;
+
+    template<typename T, typename... Args>
+    auto&
+    emplace(Args&&... args)
+    {
+        using U = std::remove_cvref_t<T>;
+        if constexpr(std::is_same_v<U, TypeTParam>)
+            Kind = TemplateParamKind::Type;
+        else if constexpr(std::is_same_v<U, NonTypeTParam>)
+            Kind = TemplateParamKind::NonType;
+        else if constexpr(std::is_same_v<U, TemplateTParam>)
+            Kind = TemplateParamKind::Template;
+        else
+            assert(! "invalid template parameter kind");
+        return *::new (static_cast<void*>(&Variant_)) T(
+            std::forward<Args>(args)...);
+    }
+
+    template<typename T>
+    auto& get() noexcept
+    {
+        using U = std::remove_cvref_t<T>;
+        if constexpr(std::is_same_v<U, TypeTParam>)
+            return Variant_.Type;
+        else if constexpr(std::is_same_v<U, NonTypeTParam>)
+            return Variant_.NonType;
+        else if constexpr(std::is_same_v<U, TemplateTParam>)
+            return Variant_.Template;
+        else
+            assert(! "invalid template parameter kind");
+    }
 
-    TemplateParamInfo(
-        llvm::StringRef Contents)
-        : Contents(Contents)
+    template<typename T>
+    const auto& get() const noexcept
     {
+        using U = std::remove_cvref_t<T>;
+        if constexpr(std::is_same_v<U, TypeTParam>)
+            return Variant_.Type;
+        else if constexpr(std::is_same_v<U, NonTypeTParam>)
+            return Variant_.NonType;
+        else if constexpr(std::is_same_v<U, TemplateTParam>)
+            return Variant_.Template;
+        else
+            assert(! "invalid template parameter kind");
     }
 };
 

include/mrdox/MetadataFwd.hpp

@@ -41,14 +41,18 @@ struct RefWithAccess;
 struct Reference;
 struct Scope;
 struct SymbolInfo;
-struct TemplateInfo;
-struct TemplateParamInfo;
-struct TemplateSpecializationInfo;
 struct TypeInfo;
 struct TypedefInfo;
 struct VarInfo;
 struct VerbatimBlock;
 
+struct TemplateInfo;
+struct TArg;
+struct TParam;
+struct TypeTParam;
+struct NonTypeTParam;
+struct TemplateTParam;
+
 struct DataMember;
 struct MemberEnum;
 struct MemberFunction;