Initial refactor to cppast

.gitmodules

@@ -1,3 +1,4 @@
 [submodule "thirdparty/cppast"]
 	path = thirdparty/cppast
-	url = https://github.com/foonathan/cppast
+	url = https://github.com/bkryza/cppast
+	branch = handle-exposed-template-arguments

CMakeLists.txt

@@ -15,6 +15,8 @@ set(CLANG_UML_INSTALL_BIN_DIR ${PROJECT_SOURCE_DIR}/bin)
 
 set(UML_HEADERS_DIR ${PROJECT_SOURCE_DIR}/src/uml)
 
+set(LLVM_PREFERRED_VERSION 11.0.0)
+
 message(STATUS "Checking for spdlog...")
 find_package(spdlog REQUIRED)
 
@@ -28,6 +30,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 ${LIBCLANG_CXXFLAGS}")
 
 # Thirdparty sources
 set(THIRDPARTY_HEADERS_DIR ${PROJECT_SOURCE_DIR}/thirdparty/)
+add_subdirectory(thirdparty/cppast)
 
 find_package(LLVM REQUIRED CONFIG)
 set(CLANG_INCLUDE_DIRS "llvm/clang/include")
@@ -37,6 +40,9 @@ include_directories(${CLANG_UML_INSTALL_INCLUDE_DIR})
 include_directories(${YAML_CPP_INCLUDE_DIR})
 include_directories(${UML_HEADERS_DIR})
 include_directories(${THIRDPARTY_HEADERS_DIR})
+include_directories(${THIRDPARTY_HEADERS_DIR}/cppast/include)
+include_directories(${THIRDPARTY_HEADERS_DIR}/cppast/external/type_safe/include)
+include_directories(${THIRDPARTY_HEADERS_DIR}/cppast/external/type_safe/external/debug_assert)
 include_directories(${PROJECT_SOURCE_DIR}/src/)
 
 file(GLOB_RECURSE SOURCES src/*.cc include/*.h)
@@ -47,7 +53,7 @@ add_library(clang-umllib OBJECT ${SOURCES})
 
 add_executable(clang-uml ${MAIN_SOURCE_FILE})
 install(TARGETS clang-uml DESTINATION ${CLANG_UML_INSTALL_BIN_DIR})
-target_link_libraries(clang-uml ${LIBCLANG_LIBRARIES} ${YAML_CPP_LIBRARIES} spdlog::spdlog clang-umllib)
+target_link_libraries(clang-uml ${LIBCLANG_LIBRARIES} ${YAML_CPP_LIBRARIES} spdlog::spdlog cppast clang-umllib)
 
 install(
         FILES

Makefile

@@ -21,7 +21,7 @@
 # Specify preferred LLVM version for CMake
 LLVM_VERSION ?= 11
 
-.DEFAULT_GOAL := test
+.DEFAULT_GOAL := debug
 
 .PHONY: clean
 clean:

src/cx/util.cc

@@ -18,6 +18,8 @@
 
 #include "cx/util.h"
 
+#include <cppast/cpp_class.hpp>
+#include <cppast/cpp_entity_kind.hpp>
 #include <spdlog/spdlog.h>
 
 namespace clanguml {
@@ -30,6 +32,65 @@ std::string to_string(CXString &&cxs)
     clang_disposeString(cxs);
     return r;
 }
+
+std::string full_name(const cppast::cpp_entity &e)
+{
+    if (e.name().empty())
+        return "";
+    else if (cppast::is_parameter(e.kind()))
+        // parameters don't have a full name
+        return e.name();
+
+    std::string scopes;
+
+    for (auto cur = e.parent(); cur; cur = cur.value().parent())
+        // prepend each scope, if there is any
+        if (cur.value().kind() == cppast::cpp_entity_kind::namespace_t)
+            type_safe::with(cur.value().scope_name(),
+                [&](const cppast::cpp_scope_name &cur_scope) {
+                    scopes = cur_scope.name() + "::" + scopes;
+                });
+
+    if (e.kind() == cppast::cpp_entity_kind::class_t) {
+        auto &c = static_cast<const cppast::cpp_class &>(e);
+        return scopes /*+ c.semantic_scope()*/ + c.name();
+    }
+    else if (e.kind() == cppast::cpp_entity_kind::class_template_t) {
+        return scopes;
+    }
+    else
+        return scopes + e.name();
+}
+
+std::string ns(const cppast::cpp_entity &e)
+{
+    std::vector<std::string> res{};
+
+    auto it = e.parent();
+    while (it) {
+        if (it.value().kind() == cppast::cpp_entity_kind::namespace_t) {
+            res.push_back(it.value().name());
+        }
+        it = it.value().parent();
+    }
+
+    return fmt::format("{}", fmt::join(res.rbegin(), res.rend(), "::"));
+}
+
+std::string fully_prefixed(const cppast::cpp_entity &e)
+{
+    std::vector<std::string> res{e.name()};
+
+    auto it = e.parent();
+    while (it) {
+        if (it.value().kind() == cppast::cpp_entity_kind::namespace_t) {
+            res.push_back(it.value().name());
+        }
+        it = it.value().parent();
+    }
+
+    return fmt::format("{}", fmt::join(res.rbegin(), res.rend(), "::"));
+}
 } // namespace util
 } // namespace cx
 } // namespace clanguml

src/cx/util.h

@@ -19,6 +19,7 @@
 
 #include <clang-c/CXCompilationDatabase.h>
 #include <clang-c/Index.h>
+#include <cppast/cpp_entity.hpp>
 
 #include <string>
 
@@ -38,6 +39,10 @@ namespace util {
  */
 std::string to_string(CXString &&cxs);
 
+std::string full_name(const cppast::cpp_entity &e);
+
+std::string fully_prefixed(const cppast::cpp_entity &e);
+
 } // namespace util
 } // namespace cx
 } // namespace clanguml

src/main.cc

@@ -25,6 +25,7 @@
 #include "uml/sequence_diagram_visitor.h"
 
 #include <cli11/CLI11.hpp>
+#include <cppast/libclang_parser.hpp>
 #include <glob/glob.hpp>
 #include <spdlog/spdlog.h>
 
@@ -73,6 +74,8 @@ int main(int argc, const char *argv[])
     auto db =
         compilation_database::from_directory(config.compilation_database_dir);
 
+    cppast::libclang_compilation_database db2(config.compilation_database_dir);
+
     for (const auto &[name, diagram] : config.diagrams) {
         using clanguml::config::class_diagram;
         using clanguml::config::sequence_diagram;
@@ -83,7 +86,7 @@ int main(int argc, const char *argv[])
 
         if (std::dynamic_pointer_cast<class_diagram>(diagram)) {
             auto model = generators::class_diagram::generate(
-                db, name, dynamic_cast<class_diagram &>(*diagram));
+                db2, name, dynamic_cast<class_diagram &>(*diagram));
 
             ofs << clanguml::generators::class_diagram::puml::generator(
                 dynamic_cast<clanguml::config::class_diagram &>(*diagram),

src/puml/class_diagram_generator.h

@@ -23,6 +23,8 @@
 #include "uml/class_diagram_visitor.h"
 #include "util/util.h"
 
+#include <cppast/libclang_parser.hpp>
+#include <cppast/cpp_entity_index.hpp>
 #include <glob/glob.hpp>
 
 #include <filesystem>
@@ -267,7 +269,7 @@ std::ostream &operator<<(std::ostream &os, const generator &g)
 }
 
 clanguml::model::class_diagram::diagram generate(
-    clanguml::cx::compilation_database &db, const std::string &name,
+    cppast::libclang_compilation_database &db, const std::string &name,
     clanguml::config::class_diagram &diagram)
 {
     spdlog::info("Generating diagram {}.puml", name);
@@ -276,7 +278,7 @@ clanguml::model::class_diagram::diagram generate(
 
     // Get all translation units matching the glob from diagram
     // configuration
-    std::vector<std::filesystem::path> translation_units{};
+    std::vector<std::string> translation_units{};
     for (const auto &g : diagram.glob) {
         spdlog::debug("Processing glob: {}", g);
         const auto matches = glob::glob(g);
@@ -284,13 +286,20 @@ clanguml::model::class_diagram::diagram generate(
             std::back_inserter(translation_units));
     }
 
+    cppast::cpp_entity_index idx;
+    cppast::simple_file_parser<cppast::libclang_parser> parser{type_safe::ref(idx)};
+
     // Process all matching translation units
+    clanguml::visitor::class_diagram::tu_visitor ctx(d, diagram);
+    cppast::parse_files(parser, translation_units, db);
+    for (auto &file : parser.files())
+        ctx(file);
+
+    /*
     for (const auto &tu_path : translation_units) {
         spdlog::debug("Processing translation unit: {}",
             std::filesystem::canonical(tu_path).c_str());
 
-        auto tu = db.parse_translation_unit(tu_path);
-
         auto cursor = clang_getTranslationUnitCursor(tu);
 
         if (clang_Cursor_isNull(cursor)) {
@@ -309,6 +318,7 @@ clanguml::model::class_diagram::diagram generate(
 
         clang_suspendTranslationUnit(tu);
     }
+    */
 
     return d;
 }

src/uml/class_diagram_visitor.cc

@@ -17,6 +17,12 @@
  */
 #include "class_diagram_visitor.h"
 
+#include <cppast/cpp_array_type.hpp>
+#include <cppast/cpp_entity_kind.hpp>
+#include <cppast/cpp_member_function.hpp>
+#include <cppast/cpp_member_variable.hpp>
+#include <cppast/cpp_template.hpp>
+#include <cppast/cpp_variable.hpp>
 #include <spdlog/spdlog.h>
 
 namespace clanguml {
@@ -35,6 +41,405 @@ using clanguml::model::class_diagram::method_parameter;
 using clanguml::model::class_diagram::relationship_t;
 using clanguml::model::class_diagram::scope_t;
 
+namespace detail {
+scope_t cpp_access_specifier_to_scope(cppast::cpp_access_specifier_kind as)
+{
+    scope_t res = scope_t::kPublic;
+    switch (as) {
+        case cppast::cpp_access_specifier_kind::cpp_public:
+            res = scope_t::kPublic;
+            break;
+        case cppast::cpp_access_specifier_kind::cpp_private:
+            res = scope_t::kPrivate;
+            break;
+        case cppast::cpp_access_specifier_kind::cpp_protected:
+            res = scope_t::kProtected;
+            break;
+        default:
+            break;
+    }
+
+    return res;
+}
+}
+
+void tu_visitor::operator()(const cppast::cpp_entity &file)
+{
+    std::string prefix;
+    // visit each entity in the file
+    cppast::visit(file,
+        [&, this](const cppast::cpp_entity &e, cppast::visitor_info info) {
+            if (e.kind() == cppast::cpp_entity_kind::class_t) {
+                spdlog::debug("{}'{}' - {}", prefix,
+                    cx::util::fully_prefixed(e), cppast::to_string(e.kind()));
+
+                auto &cls = static_cast<const cppast::cpp_class &>(e);
+
+                if (ctx.config.should_include(cx::util::fully_prefixed(cls)))
+                    process_class_declaration(cls);
+            }
+        });
+}
+
+void tu_visitor::process_class_declaration(const cppast::cpp_class &cls)
+{
+    class_ c;
+    c.usr = cx::util::full_name(cls);
+    c.is_struct = cls.class_kind() == cppast::cpp_class_kind::struct_t;
+    c.name = cx::util::full_name(cls);
+
+    cppast::cpp_access_specifier_kind last_access_specifier =
+        cppast::cpp_access_specifier_kind::cpp_private;
+
+    // Process class child entities
+    if (c.is_struct)
+        last_access_specifier = cppast::cpp_access_specifier_kind::cpp_public;
+
+    for (auto &child : cls) {
+        if (child.kind() == cppast::cpp_entity_kind::access_specifier_t) {
+            auto &as = static_cast<const cppast::cpp_access_specifier &>(child);
+            last_access_specifier = as.access_specifier();
+        }
+        else if (child.kind() == cppast::cpp_entity_kind::member_variable_t) {
+            auto &mv = static_cast<const cppast::cpp_member_variable &>(child);
+            process_field(mv, c, last_access_specifier);
+        }
+        else if (child.kind() == cppast::cpp_entity_kind::variable_t) {
+            auto &mv = static_cast<const cppast::cpp_variable &>(child);
+            process_static_field(mv, c, last_access_specifier);
+        }
+        else if (child.kind() == cppast::cpp_entity_kind::member_function_t) {
+            auto &mf = static_cast<const cppast::cpp_member_function &>(child);
+            process_method(mf, c, last_access_specifier);
+        }
+        else if (child.kind() == cppast::cpp_entity_kind::function_t) {
+            auto &mf = static_cast<const cppast::cpp_function &>(child);
+            process_static_method(mf, c, last_access_specifier);
+        }
+        else if (child.kind() == cppast::cpp_entity_kind::constructor_t) {
+            auto &mc = static_cast<const cppast::cpp_constructor &>(child);
+            process_constructor(mc, c, last_access_specifier);
+        }
+        else if (child.kind() == cppast::cpp_entity_kind::destructor_t) {
+            auto &mc = static_cast<const cppast::cpp_destructor &>(child);
+            process_destructor(mc, c, last_access_specifier);
+        }
+    }
+
+    // Process class bases
+    for (auto &base : cls.bases()) {
+        class_parent cp;
+        cp.name = clanguml::cx::util::fully_prefixed(base);
+        cp.is_virtual = base.is_virtual();
+        switch (base.access_specifier()) {
+            case cppast::cpp_access_specifier_kind::cpp_private:
+                cp.access = class_parent::access_t::kPrivate;
+                break;
+            case cppast::cpp_access_specifier_kind::cpp_public:
+                cp.access = class_parent::access_t::kPublic;
+                break;
+            case cppast::cpp_access_specifier_kind::cpp_protected:
+                cp.access = class_parent::access_t::kProtected;
+                break;
+            default:
+                cp.access = class_parent::access_t::kPublic;
+        }
+
+        c.bases.emplace_back(std::move(cp));
+    }
+
+    // Process class template arguments
+    if (cppast::is_templated(cls)) {
+        auto scope = cppast::cpp_scope_name(type_safe::ref(cls));
+        for (const auto &tp : scope.template_parameters()) {
+            if (tp.kind() ==
+                cppast::cpp_entity_kind::template_type_parameter_t) {
+                process_template_type_parameter(
+                    static_cast<const cppast::cpp_template_type_parameter &>(
+                        tp),
+                    c);
+            }
+            else if (tp.kind() ==
+                cppast::cpp_entity_kind::non_type_template_parameter_t) {
+                process_template_nontype_parameter(
+                    static_cast<
+                        const cppast::cpp_non_type_template_parameter &>(tp),
+                    c);
+            }
+            else if (tp.kind() ==
+                cppast::cpp_entity_kind::template_template_parameter_t) {
+                process_template_template_parameter(
+                    static_cast<
+                        const cppast::cpp_template_template_parameter &>(tp),
+                    c);
+            }
+        }
+    }
+
+    ctx.d.add_class(std::move(c));
+}
+
+void tu_visitor::process_field(const cppast::cpp_member_variable &mv, class_ &c,
+    cppast::cpp_access_specifier_kind as)
+{
+    class_member m;
+    m.name = mv.name();
+    m.type = cppast::to_string(mv.type());
+    m.scope = detail::cpp_access_specifier_to_scope(as);
+    m.is_static = false;
+
+    if (mv.type().kind() != cppast::cpp_type_kind::builtin_t) {
+        std::vector<std::pair<std::string, relationship_t>> relationships;
+
+        find_relationships(mv.type(), relationships);
+
+        for (const auto &[type, relationship_type] : relationships) {
+            if (relationship_type != relationship_t::kNone) {
+                class_relationship r;
+                r.destination = type;
+                r.type = relationship_type;
+                r.label = m.name;
+                c.relationships.emplace_back(std::move(r));
+
+                spdlog::debug("Added relationship to: {}", r.destination);
+            }
+        }
+    }
+
+    c.members.emplace_back(std::move(m));
+}
+
+void tu_visitor::process_static_field(const cppast::cpp_variable &mv, class_ &c,
+    cppast::cpp_access_specifier_kind as)
+{
+    class_member m;
+    m.name = mv.name();
+    m.type = cppast::to_string(mv.type());
+    m.scope = detail::cpp_access_specifier_to_scope(as);
+    m.is_static = true;
+
+    c.members.emplace_back(std::move(m));
+}
+
+void tu_visitor::process_method(const cppast::cpp_member_function &mf,
+    class_ &c, cppast::cpp_access_specifier_kind as)
+{
+    class_method m;
+    m.name = util::trim(mf.name());
+    m.type = cppast::to_string(mf.return_type());
+    m.is_pure_virtual = cppast::is_pure(mf.virtual_info());
+    m.is_virtual = cppast::is_virtual(mf.virtual_info());
+    m.is_const = cppast::is_const(mf.cv_qualifier());
+    m.is_defaulted = false; // cursor.is_method_defaulted();
+    m.is_static = false;    // cppast::is_static(mf.storage_class());
+    m.scope = detail::cpp_access_specifier_to_scope(as);
+
+    for (auto &param : mf.parameters())
+        process_function_parameter(param, m);
+
+    c.methods.emplace_back(std::move(m));
+}
+
+void tu_visitor::process_static_method(const cppast::cpp_function &mf,
+    class_ &c, cppast::cpp_access_specifier_kind as)
+{
+    class_method m;
+    m.name = util::trim(mf.name());
+    m.type = cppast::to_string(mf.return_type());
+    m.is_pure_virtual = false;
+    m.is_virtual = false;
+    m.is_const = false;
+    m.is_defaulted = false;
+    m.is_static = true;
+    m.scope = detail::cpp_access_specifier_to_scope(as);
+
+    for (auto &param : mf.parameters())
+        process_function_parameter(param, m);
+
+    c.methods.emplace_back(std::move(m));
+}
+
+void tu_visitor::process_constructor(const cppast::cpp_constructor &mf,
+    class_ &c, cppast::cpp_access_specifier_kind as)
+{
+    class_method m;
+    m.name = util::trim(mf.name());
+    m.type = "void";
+    m.is_pure_virtual = false;
+    m.is_virtual = false;
+    m.is_const = false;
+    m.is_defaulted = false;
+    m.is_static = false;
+    m.scope = detail::cpp_access_specifier_to_scope(as);
+
+    for (auto &param : mf.parameters())
+        process_function_parameter(param, m);
+
+    c.methods.emplace_back(std::move(m));
+}
+
+void tu_visitor::process_destructor(const cppast::cpp_destructor &mf, class_ &c,
+    cppast::cpp_access_specifier_kind as)
+{
+    class_method m;
+    m.name = util::trim(mf.name());
+    m.type = "void";
+    m.is_pure_virtual = false;
+    m.is_virtual = cppast::is_virtual(mf.virtual_info());
+    m.is_const = false;
+    m.is_defaulted = false;
+    m.is_static = false;
+    m.scope = detail::cpp_access_specifier_to_scope(as);
+
+    c.methods.emplace_back(std::move(m));
+}
+
+void tu_visitor::process_function_parameter(
+    const cppast::cpp_function_parameter &param, class_method &m)
+{
+    method_parameter mp;
+    mp.name = param.name();
+    mp.type = cppast::to_string(param.type());
+
+    auto dv = param.default_value();
+    if (dv)
+        switch (dv.value().kind()) {
+            case cppast::cpp_expression_kind::literal_t:
+                mp.default_value =
+                    static_cast<const cppast::cpp_literal_expression &>(
+                        dv.value())
+                        .value();
+                break;
+            case cppast::cpp_expression_kind::unexposed_t:
+                mp.default_value =
+                    static_cast<const cppast::cpp_unexposed_expression &>(
+                        dv.value())
+                        .expression()
+                        .as_string();
+                break;
+            default:
+                mp.default_value = "{}";
+        }
+
+    m.parameters.emplace_back(std::move(mp));
+}
+
+void tu_visitor::process_template_type_parameter(
+    const cppast::cpp_template_type_parameter &t, class_ &parent)
+{
+    class_template ct;
+    ct.type = "";
+    ct.default_value = "";
+    ct.is_variadic = t.is_variadic();
+    ct.name = t.name();
+    if (ct.is_variadic)
+        ct.name += "...";
+    parent.templates.emplace_back(std::move(ct));
+}
+
+void tu_visitor::process_template_nontype_parameter(
+    const cppast::cpp_non_type_template_parameter &t, class_ &parent)
+{
+    class_template ct;
+    ct.type = cppast::to_string(t.type());
+    ct.name = t.name();
+    ct.default_value = "";
+    ct.is_variadic = t.is_variadic();
+    if (ct.is_variadic)
+        ct.name += "...";
+    parent.templates.emplace_back(std::move(ct));
+}
+
+void tu_visitor::process_template_template_parameter(
+    const cppast::cpp_template_template_parameter &t, class_ &parent)
+{
+    class_template ct;
+    ct.type = "";
+    ct.name = t.name() + "<>";
+    ct.default_value = "";
+    parent.templates.emplace_back(std::move(ct));
+}
+
+void tu_visitor::find_relationships(const cppast::cpp_type &t_,
+    std::vector<std::pair<std::string, relationship_t>> &relationships,
+    relationship_t relationship_hint)
+{
+    relationship_t relationship_type = relationship_hint;
+    const auto &t = cppast::remove_cv(t_);
+
+    if (t.kind() == cppast::cpp_type_kind::array_t) {
+        auto &a = static_cast<const cppast::cpp_array_type &>(t);
+        find_relationships(
+            a.value_type(), relationships, relationship_t::kComposition);
+        return;
+    }
+
+    auto name = cppast::to_string(t);
+
+    if (t.kind() == cppast::cpp_type_kind::template_instantiation_t) {
+        class_relationship r;
+
+        auto &tinst =
+            static_cast<const cppast::cpp_template_instantiation_type &>(t);
+
+        if (!tinst.arguments_exposed()) {
+            spdlog::debug(
+                "Template instantiation {} has no exposed arguments", name);
+
+            return;
+        }
+
+        const auto &args = tinst.arguments().value();
+
+        if (name.find("std::unique_ptr") == 0) {
+            find_relationships(args[0u].type().value(), relationships,
+                relationship_t::kComposition);
+        }
+        else if (name.find("std::shared_ptr") == 0) {
+            find_relationships(args[0u].type().value(), relationships,
+                relationship_t::kAssociation);
+        }
+        else if (name.find("std::weak_ptr") == 0) {
+            find_relationships(args[0u].type().value(), relationships,
+                relationship_t::kAssociation);
+        }
+        else if (name.find("std::vector") == 0) {
+            find_relationships(args[0u].type().value(), relationships,
+                relationship_t::kAggregation);
+        }
+        else {
+            for (const auto &arg : args) {
+                find_relationships(
+                    arg.type().value(), relationships, relationship_type);
+            }
+        }
+    }
+    else if (t.kind() == cppast::cpp_type_kind::user_defined_t) {
+        if (relationship_type != relationship_t::kNone)
+            relationships.emplace_back(cppast::to_string(t), relationship_hint);
+        else
+            relationships.emplace_back(
+                cppast::to_string(t), relationship_t::kComposition);
+    }
+    else if (t.kind() == cppast::cpp_type_kind::pointer_t) {
+        auto &p = static_cast<const cppast::cpp_pointer_type &>(t);
+        find_relationships(
+            p.pointee(), relationships, relationship_t::kAssociation);
+    }
+    else if (t.kind() == cppast::cpp_type_kind::reference_t) {
+        auto &r = static_cast<const cppast::cpp_reference_type &>(t);
+        auto rt = relationship_t::kAssociation;
+        if (r.reference_kind() == cppast::cpp_reference::cpp_ref_rvalue) {
+            rt = relationship_t::kComposition;
+        }
+        find_relationships(r.referee(), relationships, rt);
+    }
+}
+
+//
+// ============== OLD CODE =======================
+//
+
 enum CXChildVisitResult visit_if_cursor_valid(
     cx::cursor cursor, std::function<enum CXChildVisitResult(cx::cursor)> f)
 {

src/uml/class_diagram_visitor.h

@@ -23,6 +23,11 @@
 
 #include <clang-c/CXCompilationDatabase.h>
 #include <clang-c/Index.h>
+#include <cppast/cpp_member_function.hpp>
+#include <cppast/cpp_member_variable.hpp>
+#include <cppast/cpp_template_parameter.hpp>
+#include <cppast/cpp_type.hpp>
+#include <cppast/visitor.hpp>
 
 #include <functional>
 #include <memory>
@@ -58,6 +63,67 @@ template <typename T> struct element_visitor_context {
     clanguml::model::class_diagram::diagram &d;
 };
 
+class tu_visitor {
+public:
+    tu_visitor(clanguml::model::class_diagram::diagram &d_,
+        const clanguml::config::class_diagram &config_)
+        : ctx{d_, config_}
+    {
+    }
+
+    void operator()(const cppast::cpp_entity &file);
+
+    void process_class_declaration(const cppast::cpp_class &cls);
+
+    void process_field(const cppast::cpp_member_variable &mv,
+        clanguml::model::class_diagram::class_ &c,
+        cppast::cpp_access_specifier_kind as);
+
+    void process_static_field(const cppast::cpp_variable &mv,
+        clanguml::model::class_diagram::class_ &c,
+        cppast::cpp_access_specifier_kind as);
+
+    void process_method(const cppast::cpp_member_function &mf,
+        clanguml::model::class_diagram::class_ &c,
+        cppast::cpp_access_specifier_kind as);
+
+    void process_static_method(const cppast::cpp_function &mf,
+        clanguml::model::class_diagram::class_ &c,
+        cppast::cpp_access_specifier_kind as);
+
+    void process_constructor(const cppast::cpp_constructor &mf,
+        clanguml::model::class_diagram::class_ &c,
+        cppast::cpp_access_specifier_kind as);
+
+    void process_destructor(const cppast::cpp_destructor &mf,
+        clanguml::model::class_diagram::class_ &c,
+        cppast::cpp_access_specifier_kind as);
+
+    void process_function_parameter(const cppast::cpp_function_parameter &param,
+        clanguml::model::class_diagram::class_method &m);
+
+    void find_relationships(const cppast::cpp_type &t,
+        std::vector<std::pair<std::string,
+            clanguml::model::class_diagram::relationship_t>> &relationships,
+        clanguml::model::class_diagram::relationship_t relationship_hint =
+            clanguml::model::class_diagram::relationship_t::kNone);
+
+    void process_template_type_parameter(
+        const cppast::cpp_template_type_parameter &t,
+        clanguml::model::class_diagram::class_ &parent);
+
+    void process_template_nontype_parameter(
+        const cppast::cpp_non_type_template_parameter &t,
+        clanguml::model::class_diagram::class_ &parent);
+
+    void process_template_template_parameter(
+        const cppast::cpp_template_template_parameter &t,
+        clanguml::model::class_diagram::class_ &parent);
+
+private:
+    tu_context ctx;
+};
+
 // Visitors
 
 enum CXChildVisitResult visit_if_cursor_valid(

tests/CMakeLists.txt

@@ -31,7 +31,7 @@ target_link_libraries(test_util
     PRIVATE
     ${LIBCLANG_LIBRARIES}
     ${YAML_CPP_LIBRARIES}
-    spdlog::spdlog clang-umllib)
+    spdlog::spdlog clang-umllib cppast)
 
 
 add_executable(test_cases
@@ -42,7 +42,7 @@ target_link_libraries(test_cases
     PRIVATE
     ${LIBCLANG_LIBRARIES}
     ${YAML_CPP_LIBRARIES}
-    spdlog::spdlog clang-umllib)
+    spdlog::spdlog clang-umllib cppast)
 
 foreach(TEST_CASE_CONFIG ${TEST_CASE_CONFIGS})
     file(RELATIVE_PATH

tests/t00003/test_case.h

@@ -56,7 +56,7 @@ TEST_CASE("t00003", "[test-case][class]")
     REQUIRE_THAT(puml, IsField(Public("int public_member")));
     REQUIRE_THAT(puml, IsField(Protected("int protected_member")));
     REQUIRE_THAT(puml, IsField(Private("int private_member")));
-    REQUIRE_THAT(puml, IsField(Static(Public("unsigned long auto_member"))));
+    REQUIRE_THAT(puml, IsField(Static(Public("unsigned long const auto_member"))));
 
     REQUIRE_THAT(puml, IsField(Private("int a")));
     REQUIRE_THAT(puml, IsField(Private("int b")));

tests/t00005/test_case.h

@@ -58,8 +58,8 @@ TEST_CASE("t00005", "[test-case][class]")
     REQUIRE_THAT(puml, IsClass(_A("R")));
 
     REQUIRE_THAT(puml, IsField(Public("int some_int")));
-    REQUIRE_THAT(puml, IsField(Public("int * some_int_pointer")));
+    REQUIRE_THAT(puml, IsField(Public("int* some_int_pointer")));
-    REQUIRE_THAT(puml, IsField(Public("int ** some_int_pointer_pointer")));
+    REQUIRE_THAT(puml, IsField(Public("int** some_int_pointer_pointer")));
 
     REQUIRE_THAT(puml, IsComposition(_A("R"), _A("A"), "a"));
     REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("B"), "b"));

tests/test_cases.cc

@@ -19,7 +19,20 @@
 
 #include <spdlog/spdlog.h>
 
-std::pair<clanguml::config::config, compilation_database> load_config(
+std::pair<clanguml::config::config, cppast::libclang_compilation_database>
+load_config(const std::string &test_name)
+{
+    auto config = clanguml::config::load(test_name + "/.clanguml");
+
+    // auto db = clanguml::cx::compilation_database::from_directory(
+    // config.compilation_database_dir);
+
+    cppast::libclang_compilation_database db(config.compilation_database_dir);
+
+    return std::make_pair(std::move(config), std::move(db));
+}
+
+std::pair<clanguml::config::config, compilation_database> load_config2(
     const std::string &test_name)
 {
     auto config = clanguml::config::load(test_name + "/.clanguml");
@@ -42,7 +55,7 @@ clanguml::model::sequence_diagram::diagram generate_sequence_diagram(
 }
 
 clanguml::model::class_diagram::diagram generate_class_diagram(
-    compilation_database &db,
+    cppast::libclang_compilation_database &db,
     std::shared_ptr<clanguml::config::diagram> diagram)
 {
     auto diagram_model =
@@ -134,7 +147,7 @@ using clanguml::test::matchers::Static;
 //
 // Sequence diagram tests
 //
-#include "t20001/test_case.h"
+//#include "t20001/test_case.h"
 
 //
 // Other tests (e.g. configuration file)

tests/test_cases.h

@@ -43,7 +43,9 @@ using Catch::Matchers::VectorContains;
 using clanguml::cx::compilation_database;
 using namespace clanguml::util;
 
-std::pair<clanguml::config::config, compilation_database> load_config(
+std::pair<clanguml::config::config, cppast::libclang_compilation_database>
+load_config(const std::string &test_name);
+std::pair<clanguml::config::config, compilation_database> load_config2(
     const std::string &test_name);
 
 clanguml::model::sequence_diagram::diagram generate_sequence_diagram(