Detailed Description

This namespace provides common interfaces for all kinds of diagrams.

The core diagram functionality is divided into 3 groups: visitor, model and generators.

Namespaces
namespace	generators

namespace	jinja

namespace	model

namespace	visitor

Classes
class	compilation_database
	Custom compilation database class. More...

class	eid_t
	Universal class for representing all kinds of Id's in the diagram model. More...

class	optional_ref
	Simple optional reference type. More...

struct	or_regex
	Convenience class for configuration options with regex support. More...

struct	path_or_regex

struct	regex
	Wrapper around std::regex, which contains original pattern. More...

Typedefs
using	compilation_database_ptr = std::unique_ptr< compilation_database >

template<typename T >
using	opt_ref = optional_ref< T >

template<typename T >
using	reference_vector = std::vector< std::reference_wrapper< T > >

template<typename T >
using	reference_set = std::unordered_set< std::reference_wrapper< T > >

using	string_or_regex = or_regex< std::string >

using	namespace_or_regex = common::or_regex< common::model::namespace_ >

Enumerations
enum class	generator_type_t { plantuml , json , mermaid , graphml }

Functions
model::access_t	access_specifier_to_access_t (clang::AccessSpecifier access_specifier)
	Convert `clang::AccessSpecifier` to.

model::access_t	access_specifier_to_access_t (clang::ObjCIvarDecl::AccessControl access_specifier)

model::namespace_	get_tag_namespace (const clang::TagDecl &declaration)

model::namespace_	get_template_namespace (const clang::TemplateDecl &declaration)

std::string	get_tag_name (const clang::TagDecl &declaration)
	Generate full qualified name for clang::TagDecl instance.

std::string	to_string (const clang::ArrayType &array_type, const clang::ASTContext &ctx, bool try_canonical, std::vector< std::string > &dimensions)

std::string	to_string (const clang::TemplateArgumentLoc &argLoc, const clang::ASTContext &context)

std::string	to_string (const clang::QualType &type, const clang::ASTContext &ctx, bool try_canonical)

std::string	to_string (const clang::RecordType &type, const clang::ASTContext &ctx, bool try_canonical)

std::string	to_string (const clang::TemplateArgument &arg, const clang::ASTContext *ctx)

std::string	to_string (const clang::TemplateName &templ)

std::string	to_string (const clang::Expr *expr)

std::string	to_string (const clang::ValueDecl *val)

std::string	to_string (const clang::Stmt *stmt)

std::string	to_string (const clang::FunctionTemplateDecl *decl)

std::string	to_string (const clang::TypeConstraint *tc)

std::string	get_source_text_raw (clang::SourceRange range, const clang::SourceManager &sm)
	Get raw text of specific source range.

std::string	get_source_text (clang::SourceRange range, const clang::SourceManager &sm)
	Get printable range of text of specific source range.

std::tuple< unsigned int, unsigned int, std::string >	extract_template_parameter_index (const std::string &type_parameter)
	Extract template depth and index.

void	ensure_lambda_type_is_relative (const config::diagram &config, std::string &parameter_type)

bool	is_subexpr_of (const clang::Stmt parent_stmt, const clang::Stmt sub_stmt)
	Check if an expression is contained in another expression.

template<>
eid_t	to_id (const std::string &full_name)

eid_t	to_id (const clang::QualType &type, const clang::ASTContext &ctx)

template<>
eid_t	to_id (const clang::NamespaceDecl &declaration)

template<>
eid_t	to_id (const clang::RecordDecl &declaration)

template<>
eid_t	to_id (const clang::ObjCCategoryDecl &type)

template<>
eid_t	to_id (const clang::ObjCInterfaceDecl &type)

template<>
eid_t	to_id (const clang::ObjCProtocolDecl &type)

template<>
eid_t	to_id (const clang::EnumDecl &declaration)

template<>
eid_t	to_id (const clang::TagDecl &declaration)

template<>
eid_t	to_id (const clang::CXXRecordDecl &declaration)

template<>
eid_t	to_id (const clang::EnumType &t)

template<>
eid_t	to_id (const std::filesystem::path &file)

template<>
eid_t	to_id (const clang::TemplateArgument &template_argument)

std::pair< common::model::namespace_, std::string >	split_ns (const std::string &full_name)
	Split qualified name to namespace and name.

std::vector< common::model::template_parameter >	parse_unexposed_template_params (const std::string &params, const std::function< std::string(const std::string &)> &ns_resolve, int depth=0)
	Parse unexposed (available as string) template params.

bool	is_type_parameter (const std::string &t)

bool	is_qualifier (const std::string &q)

bool	is_bracket (const std::string &b)

bool	is_identifier_character (char c)

bool	is_identifier (const std::string &t)

bool	is_keyword (const std::string &t)

bool	is_qualified_identifier (const std::string &t)

bool	is_type_token (const std::string &t)

std::string	format_condition_text (const std::string &condition_text)

std::string	get_condition_text (clang::SourceManager &sm, clang::IfStmt *stmt)

std::string	get_condition_text (clang::SourceManager &sm, clang::WhileStmt *stmt)

std::string	get_condition_text (clang::SourceManager &sm, clang::CXXForRangeStmt *stmt)

std::string	get_condition_text (clang::SourceManager &sm, clang::ForStmt *stmt)

std::string	get_condition_text (clang::SourceManager &sm, clang::DoStmt *stmt)

std::string	get_condition_text (clang::SourceManager &sm, clang::ConditionalOperator *stmt)

clang::QualType	dereference (clang::QualType type)

std::pair< clang::QualType, std::deque< common::model::context > >	consume_type_context (clang::QualType type)
	Extract type context and return raw type.

std::vector< std::string >	tokenize_unexposed_template_parameter (const std::string &t)

bool	parse_source_location (const std::string &location_str, std::string &file, unsigned &line, unsigned &column)

clang::RawComment *	get_expression_raw_comment (const clang::SourceManager &sm, const clang::ASTContext &context, const clang::Stmt *stmt)
	Extract a comment before or next to a statement.

clang::RawComment *	get_declaration_raw_comment (const clang::SourceManager &sm, const clang::ASTContext &context, const clang::Decl *decl)

clang::RawComment *	get_raw_comment (const clang::SourceManager &sm, const clang::ASTContext &context, const clang::SourceRange &source_range)

bool	is_coroutine (const clang::FunctionDecl &decl)

bool	is_struct (const clang::NamedDecl *decl)

bool	has_attr (const clang::FunctionDecl *decl, clang::attr::Kind function_attr)

std::optional< size_t >	get_array_size (const clang::ArrayType &type)

void	set_source_location (clang::SourceManager &source_manager, const clang::SourceLocation &location, clanguml::common::model::source_location &element, std::filesystem::path tu_path, std::filesystem::path relative_to_path_)

const clang::Type *	get_unqualified_type (const clang::TypedefDecl *decl)

const clang::EnumDecl *	get_typedef_enum_decl (const clang::TypedefDecl *decl)

const clang::ConceptDecl *	get_template_parameter_concept_constraint (const clang::TemplateTypeParmType type_parameter, const clang::TemplateDecl template_decl)

bool	is_lambda_call (const clang::Expr *expr)

bool	is_lambda_method (const clang::FunctionDecl *decl)

template<typename T >
std::string	get_qualified_name (const T &declaration)
	Get qualified name of some Clang declaration.

template<typename T >
eid_t	to_id (const T &declaration)

template<>
eid_t	to_id (const std::string &full_name)

template<>
eid_t	to_id (const clang::NamespaceDecl &declaration)

template<>
eid_t	to_id (const clang::CXXRecordDecl &declaration)

template<>
eid_t	to_id (const clang::RecordDecl &declaration)

template<>
eid_t	to_id (const clang::ObjCCategoryDecl &type)

template<>
eid_t	to_id (const clang::ObjCInterfaceDecl &type)

template<>
eid_t	to_id (const clang::ObjCProtocolDecl &type)

template<>
eid_t	to_id (const clang::EnumDecl &declaration)

template<>
eid_t	to_id (const clang::TagDecl &declaration)

template<>
eid_t	to_id (const clang::EnumType &type)

template<>
eid_t	to_id (const clang::TemplateSpecializationType &type)

template<>
eid_t	to_id (const std::filesystem::path &type)

template<typename T , typename P , typename F >
void	if_dyn_cast (P pointer, F &&func)

bool	operator== (const eid_t &lhs, const eid_t &rhs)

bool	operator== (const eid_t &lhs, const uint64_t &v)

bool	operator!= (const eid_t &lhs, const uint64_t &v)

bool	operator!= (const eid_t &lhs, const eid_t &rhs)

bool	operator< (const eid_t &lhs, const eid_t &rhs)

std::string	to_string (const bool v)

std::string	to_string (const std::string &s)

std::string	to_string (const string_or_regex &sr)

std::string	to_string (const std::filesystem::path &p)

std::string	to_string (const generator_type_t type)

YAML::Emitter &	operator<< (YAML::Emitter &out, const string_or_regex &m)

Typedef Documentation

◆ compilation_database_ptr

using clanguml::common::compilation_database_ptr = typedef std::unique_ptr<compilation_database>

Definition at line 143 of file compilation_database.h.

◆ namespace_or_regex

using clanguml::common::namespace_or_regex = typedef common::or_regex<common::model::namespace_>

Definition at line 347 of file types.h.

◆ opt_ref

template<typename T >

using clanguml::common::opt_ref = typedef optional_ref<T>

Definition at line 229 of file types.h.

◆ reference_set

template<typename T >

using clanguml::common::reference_set = typedef std::unordered_set<std::reference_wrapper<T> >

Definition at line 235 of file types.h.

◆ reference_vector

template<typename T >

using clanguml::common::reference_vector = typedef std::vector<std::reference_wrapper<T> >

Definition at line 232 of file types.h.

◆ string_or_regex

using clanguml::common::string_or_regex = typedef or_regex<std::string>

Definition at line 343 of file types.h.

Enumeration Type Documentation

◆ generator_type_t

enum class clanguml::common::generator_type_t

strong

Type of output diagram format generator.

Enumerator
plantuml	Diagrams will be generated in PlantUML format
json	Diagrams will be generated in JSON format
mermaid	Diagrams will be generated in MermaidJS format
graphml	Diagrams will be generated in GraphML format

Definition at line 86 of file types.h.

                            {
    plantuml, /*!< Diagrams will be generated in PlantUML format */
    json,     /*!< Diagrams will be generated in JSON format */
    mermaid,  /*!< Diagrams will be generated in MermaidJS format */
    graphml   /*!< Diagrams will be generated in GraphML format */
};

Function Documentation

◆ access_specifier_to_access_t() [1/2]

model::access_t clanguml::common::access_specifier_to_access_t ( clang::AccessSpecifier access_specifier )

Convert clang::AccessSpecifier to.

See also: clanguml::model::access_t

Parameters

access_specifier Clang member access specifier

Returns: Enum value of

See also: clanguml::model::access_t

Definition at line 25 of file clang_utils.cc.

{
    auto access = model::access_t::kPublic;
    switch (access_specifier) {
    case clang::AccessSpecifier::AS_public:
        access = model::access_t::kPublic;
        break;
    case clang::AccessSpecifier::AS_private:
        access = model::access_t::kPrivate;
        break;
    case clang::AccessSpecifier::AS_protected:
        access = model::access_t::kProtected;
        break;
    default:
        break;
    }
 
    return access;
}

◆ access_specifier_to_access_t() [2/2]

model::access_t clanguml::common::access_specifier_to_access_t ( clang::ObjCIvarDecl::AccessControl access_specifier )

Definition at line 46 of file clang_utils.cc.

{
    auto access = model::access_t::kPublic;
    switch (access_specifier) {
    case clang::ObjCIvarDecl::AccessControl::Public:
        access = model::access_t::kPublic;
        break;
    case clang::ObjCIvarDecl::AccessControl::Private:
        access = model::access_t::kPrivate;
        break;
    case clang::ObjCIvarDecl::AccessControl::Protected:
        access = model::access_t::kProtected;
        break;
    default:
        break;
    }
 
    return access;
}

◆ consume_type_context()

std::pair< clang::QualType, std::deque< common::model::context > > clanguml::common::consume_type_context ( clang::QualType type )

Extract type context and return raw type.

This function removes the context for a type, for example for: std::string const& it will return (std::string, [const&])

Parameters

type	Type to process

Returns: (type, [qualifiers])

Definition at line 794 of file clang_utils.cc.

{
    std::deque<common::model::context> res;
 
    while (true) {
        bool try_again{false};
        common::model::context ctx;
 
        if (type.isConstQualified()) {
            ctx.is_const = true;
            try_again = true;
        }
 
        if (type.isVolatileQualified()) {
            ctx.is_volatile = true;
            try_again = true;
        }
 
        if (type->isPointerType() || type->isReferenceType()) {
            if (type.isConstQualified() || type.isVolatileQualified()) {
                ctx.is_ref_const = type.isConstQualified();
                ctx.is_ref_volatile = type.isVolatileQualified();
 
                try_again = true;
            }
        }
 
        if (type->isLValueReferenceType()) {
            ctx.pr = common::model::rpqualifier::kLValueReference;
            try_again = true;
        }
        else if (type->isRValueReferenceType()) {
            ctx.pr = common::model::rpqualifier::kRValueReference;
            try_again = true;
        }
        else if (type->isMemberFunctionPointerType() &&
            type->getPointeeType()->getAs<clang::FunctionProtoType>() !=
                nullptr) {
            const auto ref_qualifier =
                type->getPointeeType()                  // NOLINT
                    ->getAs<clang::FunctionProtoType>() // NOLINT
                    ->getRefQualifier();
 
            if (ref_qualifier == clang::RefQualifierKind::RQ_RValue) {
                ctx.pr = common::model::rpqualifier::kRValueReference;
                try_again = true;
            }
            else if (ref_qualifier == clang::RefQualifierKind::RQ_LValue) {
                ctx.pr = common::model::rpqualifier::kLValueReference;
                try_again = true;
            }
        }
        else if (type->isPointerType()) {
            ctx.pr = common::model::rpqualifier::kPointer;
            try_again = true;
        }
 
        if (try_again) {
            if (type->isPointerType()) {
                if (type->getPointeeType().isConstQualified())
                    ctx.is_const = true;
                if (type->getPointeeType().isVolatileQualified())
                    ctx.is_volatile = true;
 
                type = type->getPointeeType().getUnqualifiedType();
            }
            else if (type->isReferenceType()) {
                if (type.getNonReferenceType().isConstQualified())
                    ctx.is_const = true;
                if (type.getNonReferenceType().isVolatileQualified())
                    ctx.is_volatile = true;
 
                type = type.getNonReferenceType().getUnqualifiedType();
            }
            else if (type.isConstQualified() || type.isVolatileQualified()) {
                ctx.is_const = type.isConstQualified();
                ctx.is_volatile = type.isVolatileQualified();
                type = type.getUnqualifiedType();
            }
 
            res.push_front(ctx);
 
            if (type->isMemberFunctionPointerType())
                return std::make_pair(type, res);
        }
        else
            return std::make_pair(type, res);
    }
}

◆ dereference()

clang::QualType clanguml::common::dereference ( clang::QualType type )

Definition at line 777 of file clang_utils.cc.

{
    auto res = type;
 
    while (true) {
        if (res->isReferenceType())
            res = res.getNonReferenceType();
        else if (res->isPointerType())
            res = res->getPointeeType();
        else
            break;
    }
 
    return res;
}

◆ ensure_lambda_type_is_relative()

void clanguml::common::ensure_lambda_type_is_relative	(	const config::diagram &	config,
		std::string &	parameter_type
	)

Definition at line 420 of file clang_utils.cc.

{
#ifdef _MSC_VER
    auto root_name =
        fmt::format("{}", std::filesystem::current_path().root_name().string());
#else
    auto root_name = std::string{"/"};
#endif
 
    std::string lambda_prefix{fmt::format("(lambda at {}", root_name)};
 
    while (parameter_type.find(lambda_prefix) != std::string::npos) {
        auto lambda_begin = parameter_type.find(lambda_prefix);
        auto lambda_prefix_size = lambda_prefix.size();
#ifdef _MSC_VER
        // Skip the `\` or `/` after drive letter and semicolon
        lambda_prefix_size++;
#endif
        auto absolute_lambda_path_end =
            parameter_type.find(':', lambda_begin + lambda_prefix_size);
        auto absolute_lambda_path = parameter_type.substr(
            lambda_begin + lambda_prefix_size - 1,
            absolute_lambda_path_end - (lambda_begin + lambda_prefix_size - 1));
 
        auto relative_lambda_path = util::path_to_url(
            config.make_path_relative(absolute_lambda_path).string());
 
        parameter_type = fmt::format("{}(lambda at {}{}",
            parameter_type.substr(0, lambda_begin), relative_lambda_path,
            parameter_type.substr(absolute_lambda_path_end));
    }
}

◆ extract_template_parameter_index()

std::tuple< unsigned int, unsigned int, std::string > clanguml::common::extract_template_parameter_index ( const std::string & type_parameter )

Extract template depth and index.

This function extracts template depth and index values from Clang's type-parameter- names.

Parameters

type_parameter Clang's type parameter string

Returns: (depth, index, qualifier)

Definition at line 401 of file clang_utils.cc.

{
    assert(type_parameter.find("type-parameter-") == 0);
 
    auto type_parameter_and_suffix = util::split(type_parameter, " ");
 
    auto toks = util::split(
        type_parameter_and_suffix.front().substr(strlen("type-parameter-")),
        "-");
 
    std::string qualifier;
 
    if (type_parameter_and_suffix.size() > 1) {
        qualifier = type_parameter_and_suffix.at(1);
    }
 
    return {std::stoi(toks.at(0)), std::stoi(toks.at(1)), std::move(qualifier)};
}

◆ format_condition_text()

std::string clanguml::common::format_condition_text ( const std::string & condition_text )

Definition at line 708 of file clang_utils.cc.

{
    std::string result{condition_text};
 
    if (result.size() < 2)
        return {};
 
    std::vector<std::string> text_lines = util::split(result, "\n", true);
 
    // Trim each line
    for (auto &line : text_lines) {
        line = util::trim(line);
    }
 
    result = util::join(" ", text_lines);
 
    if (result.at(0) == '(' && result.back() == ')')
        return result.substr(1, result.size() - 2);
 
    return result;
}

◆ get_array_size()

std::optional< size_t > clanguml::common::get_array_size ( const clang::ArrayType & type )

If type is a constant array, return it's number of elements. Otherwise nothing.

Parameters

type

Returns: Number of elements in the array.

Definition at line 1072 of file clang_utils.cc.

{
    if (const auto *constant_array =
            clang::dyn_cast<clang::ConstantArrayType>(&type);
        constant_array != nullptr) {
        return {constant_array->getSize().getZExtValue()};
    }
 
    return {};
}

◆ get_condition_text() [1/6]

std::string clanguml::common::get_condition_text	(	clang::SourceManager &	sm,
		clang::ConditionalOperator *	stmt
	)

Definition at line 769 of file clang_utils.cc.

{
    auto condition_range = stmt->getCond()->getSourceRange();
 
    return format_condition_text(get_source_text(condition_range, sm));
}

◆ get_condition_text() [2/6]

std::string clanguml::common::get_condition_text	(	clang::SourceManager &	sm,
		clang::CXXForRangeStmt *	stmt
	)

Definition at line 746 of file clang_utils.cc.

{
    auto condition_range = stmt->getRangeStmt()->getSourceRange();
 
    return format_condition_text(get_source_text(condition_range, sm));
}

◆ get_condition_text() [3/6]

std::string clanguml::common::get_condition_text	(	clang::SourceManager &	sm,
		clang::DoStmt *	stmt
	)

Definition at line 762 of file clang_utils.cc.

{
    auto condition_range = stmt->getCond()->getSourceRange();
 
    return format_condition_text(get_source_text(condition_range, sm));
}

◆ get_condition_text() [4/6]

std::string clanguml::common::get_condition_text	(	clang::SourceManager &	sm,
		clang::ForStmt *	stmt
	)

Definition at line 754 of file clang_utils.cc.

{
    auto condition_range =
        clang::SourceRange(stmt->getLParenLoc(), stmt->getRParenLoc());
 
    return format_condition_text(get_source_text(condition_range, sm));
}

◆ get_condition_text() [5/6]

std::string clanguml::common::get_condition_text	(	clang::SourceManager &	sm,
		clang::IfStmt *	stmt
	)

Definition at line 730 of file clang_utils.cc.

{
    auto condition_range =
        clang::SourceRange(stmt->getLParenLoc(), stmt->getRParenLoc());
 
    return format_condition_text(get_source_text(condition_range, sm));
}

◆ get_condition_text() [6/6]

std::string clanguml::common::get_condition_text	(	clang::SourceManager &	sm,
		clang::WhileStmt *	stmt
	)

Definition at line 738 of file clang_utils.cc.

{
    auto condition_range =
        clang::SourceRange(stmt->getLParenLoc(), stmt->getRParenLoc());
 
    return format_condition_text(get_source_text(condition_range, sm));
}

◆ get_declaration_raw_comment()

clang::RawComment * clanguml::common::get_declaration_raw_comment	(	const clang::SourceManager &	sm,
		const clang::ASTContext &	context,
		const clang::Decl *	decl
	)

Definition at line 1010 of file clang_utils.cc.

{
    return get_raw_comment(sm, context, decl->getSourceRange());
}

◆ get_expression_raw_comment()

clang::RawComment * clanguml::common::get_expression_raw_comment	(	const clang::SourceManager &	sm,
		const clang::ASTContext &	context,
		const clang::Stmt *	stmt
	)

Extract a comment before or next to a statement.

Parameters

sm	clang::SourceManager reference
context	clang::ASTContext reference
stmt	Pointer to the current clang::Stmt

Returns: Pointer to a clang::RawComment* or nullptr

Definition at line 1004 of file clang_utils.cc.

{
    return get_raw_comment(sm, context, stmt->getSourceRange());
}

◆ get_qualified_name()

template<typename T >

std::string clanguml::common::get_qualified_name ( const T & declaration )

Get qualified name of some Clang declaration.

This template is convenient for getting qualified name of various types of clang declarations.

Template Parameters

T	Type of Clang's declaration, e.g. `clang::TagDecl`

Parameters

declaration Reference to a clang declaration

Returns: Fully qualified name

Definition at line 71 of file clang_utils.h.

{
    auto qualified_name = declaration.getQualifiedNameAsString();
    util::replace_all(qualified_name, "(anonymous namespace)", "");
    util::replace_all(qualified_name, "::::", "::");
 
    if constexpr (std::is_base_of_v<clang::TagDecl, T>) {
        auto base_name = get_tag_name(declaration);
        model::namespace_ ns{qualified_name};
        ns.pop_back();
        ns = ns | base_name;
 
        return ns.to_string();
    }
 
    return qualified_name;
}

◆ get_raw_comment()

clang::RawComment * clanguml::common::get_raw_comment	(	const clang::SourceManager &	sm,
		const clang::ASTContext &	context,
		const clang::SourceRange &	source_range
	)

Definition at line 1016 of file clang_utils.cc.

{
    auto expr_begin = sm.getExpansionLoc(source_range.getBegin());
    const auto expr_begin_line = sm.getExpansionLineNumber(expr_begin);
 
    auto file_id = sm.getFileID(expr_begin);
 
    const auto has_comments = !context.Comments.empty();
    const auto *comments = context.Comments.getCommentsInFile(file_id);
 
    if (has_comments && comments != nullptr) {
        for (const auto [offset, raw_comment] :
            *context.Comments.getCommentsInFile(sm.getFileID(expr_begin))) {
            const auto comment_end_line = sm.getExpansionLineNumber(
                raw_comment->getSourceRange().getEnd());
 
            if (expr_begin_line == comment_end_line ||
                expr_begin_line == comment_end_line + 1)
                return raw_comment;
        }
    }
 
    return {};
}

◆ get_source_text()

std::string clanguml::common::get_source_text	(	clang::SourceRange	range,
		const clang::SourceManager &	sm
	)

Get printable range of text of specific source range.

Parameters

range	Source range
sm	Source manager reference

Returns: Printable source text

Definition at line 388 of file clang_utils.cc.

{
    const clang::LangOptions lo;
 
    auto start_loc = sm.getSpellingLoc(range.getBegin());
    auto last_token_loc = sm.getSpellingLoc(range.getEnd());
    auto end_loc = clang::Lexer::getLocForEndOfToken(last_token_loc, 0, sm, lo);
    auto printable_range = clang::SourceRange{start_loc, end_loc};
    return get_source_text_raw(printable_range, sm);
}

◆ get_source_text_raw()

std::string clanguml::common::get_source_text_raw	(	clang::SourceRange	range,
		const clang::SourceManager &	sm
	)

Get raw text of specific source range.

Parameters

range	Source range
sm	Source manager reference

Returns: Raw source text

Definition at line 380 of file clang_utils.cc.

{
    return clang::Lexer::getSourceText(
        clang::CharSourceRange::getCharRange(range), sm, clang::LangOptions())
        .str();
}

◆ get_tag_name()

std::string clanguml::common::get_tag_name ( const clang::TagDecl & declaration )

Generate full qualified name for clang::TagDecl instance.

Parameters

declaration Input declaration

Returns: String representation including any templates, parameters and attribtues

Definition at line 105 of file clang_utils.cc.

{
    auto base_name = declaration.getNameAsString();
 
    if (base_name.empty()) {
        base_name =
            fmt::format("(anonymous_{})", std::to_string(declaration.getID()));
    }
 
    if ((declaration.getParent() != nullptr) &&
        declaration.getParent()->isRecord()) {
        // If the record is nested within another record (e.g. class or struct)
        // we have to maintain a containment namespace in order to ensure
        // unique names within the diagram
        std::deque<std::string> record_parent_names;
        record_parent_names.push_front(base_name);
 
        const auto *cls_parent{declaration.getParent()};
        while (cls_parent->isRecord()) {
            if (const auto *record_decl =
                    clang::dyn_cast<clang::RecordDecl>(cls_parent);
                record_decl != nullptr) {
                record_parent_names.push_front(record_decl->getNameAsString());
            }
            cls_parent = cls_parent->getParent();
        }
        return fmt::format("{}", fmt::join(record_parent_names, "##"));
    }
 
    return base_name;
}

◆ get_tag_namespace()

model::namespace_ clanguml::common::get_tag_namespace ( const clang::TagDecl & declaration )

Get namespace of a specific clang::TagDecl

Parameters

declaration Reference to clang::TagDecl

Returns: Namespace instance

Definition at line 67 of file clang_utils.cc.

{
    model::namespace_ ns;
 
    const auto *parent{declaration.getParent()};
 
    // First walk up to the nearest namespace, e.g. from nested class or enum
    while ((parent != nullptr) && !parent->isNamespace()) {
        parent = parent->getParent();
    }
 
    // Now build up the namespace
    std::deque<std::string> namespace_tokens;
    while ((parent != nullptr) && parent->isNamespace()) {
        if (const auto *ns_decl = clang::dyn_cast<clang::NamespaceDecl>(parent);
            ns_decl != nullptr) {
            if (!ns_decl->isInline() && !ns_decl->isAnonymousNamespace())
                namespace_tokens.push_front(ns_decl->getNameAsString());
        }
 
        parent = parent->getParent();
    }
 
    for (const auto &ns_token : namespace_tokens) {
        ns |= ns_token;
    }
 
    return ns;
}

◆ get_template_namespace()

model::namespace_ clanguml::common::get_template_namespace ( const clang::TemplateDecl & declaration )

Get namespace of a specific clang::TemplateDecl

Parameters

declaration Reference to clang::TemplateDecl

Returns: Namespace instance

Definition at line 97 of file clang_utils.cc.

{
    model::namespace_ ns{declaration.getQualifiedNameAsString()};
    ns.pop_back();
 
    return ns;
}

◆ get_template_parameter_concept_constraint()

const clang::ConceptDecl * clanguml::common::get_template_parameter_concept_constraint	(	const clang::TemplateTypeParmType *	type_parameter,
		const clang::TemplateDecl *	template_decl
	)

Definition at line 1190 of file clang_utils.cc.

{
    clang::TemplateTypeParmDecl *template_type_parameter{nullptr};
 
#if LLVM_VERSION_MAJOR >= 22
    // In LLVM 22+, getDecl() on a TemplateTypeParmType used in a base class
    // may return the outer template's parameter (carrying an inherited concept
    // constraint) instead of the base template's own parameter. Prefer the
    // template_decl's own parameter at the matching index to avoid spuriously
    // inheriting constraints (e.g. HList<T...> becoming HList<IsArithmetic
    // T...> when used as base of Arithmetic<IsArithmetic T...>).
    if (template_decl->getTemplateParameters()->size() >
        type_parameter->getIndex()) {
        template_type_parameter = clang::dyn_cast<clang::TemplateTypeParmDecl>(
            template_decl->getTemplateParameters()->getParam(
                type_parameter->getIndex()));
    }
    if (template_type_parameter == nullptr &&
        type_parameter->getDecl() != nullptr) {
        template_type_parameter = type_parameter->getDecl();
    }
#else
    if (type_parameter->getDecl() != nullptr) {
        template_type_parameter = type_parameter->getDecl();
    }
    else if (template_decl->getTemplateParameters()->size() >
        type_parameter->getIndex()) {
        template_type_parameter = clang::dyn_cast<clang::TemplateTypeParmDecl>(
            template_decl->getTemplateParameters()->getParam(
                type_parameter->getIndex()));
    }
#endif
 
    if (template_type_parameter == nullptr ||
        template_type_parameter->getTypeConstraint() == nullptr)
        return nullptr;
 
#if LLVM_VERSION_MAJOR < 22
    return template_type_parameter->getTypeConstraint()->getNamedConcept();
#else
    return clang::cast<clang::ConceptDecl>(
        template_type_parameter->getTypeConstraint()->getNamedConcept());
#endif
}

◆ get_typedef_enum_decl()

const clang::EnumDecl * clanguml::common::get_typedef_enum_decl ( const clang::TypedefDecl * decl )

Get pointer to enum decl in typedef decl

Parameters

decl	typedef decl

Returns: Pointer to enum decl inside typedef

Definition at line 1153 of file clang_utils.cc.

{
    if (decl == nullptr)
        return nullptr;
 
    const clang::Type *unqualified_type = get_unqualified_type(decl);
 
#if LLVM_VERSION_MAJOR < 22
    if (unqualified_type->getTypeClass() == clang::Type::Elaborated) {
        const auto *tag_decl =
            clang::cast<clang::ElaboratedType>(unqualified_type)
                ->getNamedType()
                ->getAsTagDecl();
 
        if (tag_decl == nullptr)
            return nullptr;
 
        const auto *enum_decl = clang::dyn_cast<clang::EnumDecl>(tag_decl);
        if (enum_decl != nullptr && enum_decl->getIdentifier() == nullptr)
            return enum_decl;
    }
#else
    {
        const auto *tag_decl = unqualified_type->getAsTagDecl();
 
        if (tag_decl == nullptr)
            return nullptr;
 
        const auto *enum_decl = clang::dyn_cast<clang::EnumDecl>(tag_decl);
        if (enum_decl != nullptr && enum_decl->getIdentifier() == nullptr)
            return enum_decl;
    }
#endif
 
    return nullptr;
}

◆ get_unqualified_type()

const clang::Type * clanguml::common::get_unqualified_type ( const clang::TypedefDecl * decl )

Get the unqualified type of typedef decl

Parameters

decl	typedef decl

Returns: Pointer to underlying type or nullptr

Definition at line 1143 of file clang_utils.cc.

{
    const auto *type_source_info = decl->getTypeSourceInfo();
 
    if (type_source_info == nullptr)
        return nullptr;
 
    return type_source_info->getType().split().Ty;
}

◆ has_attr()

bool clanguml::common::has_attr	(	const clang::FunctionDecl *	decl,
		clang::attr::Kind	function_attr
	)

Check if function declaration contains specified attributed

Parameters

decl	Function declaration
function_attr	Clang function attribute

Returns: True, if decl contains specified function attribute

Definition at line 1065 of file clang_utils.cc.

{
    return std::any_of(decl->attrs().begin(), decl->attrs().end(),
        [function_attr](
            auto &&attr) { return attr->getKind() == function_attr; });
}

◆ if_dyn_cast()

template<typename T , typename P , typename F >

void clanguml::common::if_dyn_cast	(	P	pointer,
		F &&	func
	)

Definition at line 241 of file clang_utils.h.

{
    if (pointer == nullptr)
        return;
 
    if (const auto *dyn_cast_value = clang::dyn_cast<T>(pointer);
        dyn_cast_value) {
        std::forward<F>(func)(dyn_cast_value);
    }
}

◆ is_bracket()

bool clanguml::common::is_bracket ( const std::string & b )

Definition at line 659 of file clang_utils.cc.

{
    return b == "(" || b == ")" || b == "[" || b == "]";
}

◆ is_coroutine()

bool clanguml::common::is_coroutine ( const clang::FunctionDecl & decl )

Check if function or method declaration is a C++20 coroutine.

Parameters

decl	Function declaration

Returns: True, if the function is a C++20 coroutine.

Definition at line 1042 of file clang_utils.cc.

{
    const auto *body = decl.getBody();
    return clang::isa_and_nonnull<clang::CoroutineBodyStmt>(body);
}

◆ is_identifier()

bool clanguml::common::is_identifier ( const std::string & t )

Definition at line 669 of file clang_utils.cc.

{
    return std::all_of(t.begin(), t.end(),
        [](const char c) { return is_identifier_character(c); });
}

◆ is_identifier_character()

bool clanguml::common::is_identifier_character ( char c )

Definition at line 664 of file clang_utils.cc.

{
    return std::isalnum(c) != 0 || c == '_';
}

◆ is_keyword()

bool clanguml::common::is_keyword ( const std::string & t )

Definition at line 675 of file clang_utils.cc.

{
    static std::vector<std::string> keywords{"alignas", "alignof", "asm",
        "auto", "bool", "break", "case", "catch", "char", "char16_t",
        "char32_t", "class", "concept", "const", "constexpr", "const_cast",
        "continue", "decltype", "default", "delete", "do", "double",
        "dynamic_cast", "else", "enum", "explicit", "export", "extern", "false",
        "float", "for", "friend", "goto", "if", "inline", "int", "long",
        "mutable", "namespace", "new", "noexcept", "nullptr", "operator",
        "private", "protected", "public", "register", "reinterpret_cast",
        "return", "requires", "short", "signed", "sizeof", "static",
        "static_assert", "static_cast", "struct", "switch", "template", "this",
        "thread_local", "throw", "true", "try", "typedef", "typeid", "typename",
        "union", "unsigned", "using", "virtual", "void", "volatile", "wchar_t",
        "while"};
 
    return util::contains(keywords, t);
}

◆ is_lambda_call()

bool clanguml::common::is_lambda_call ( const clang::Expr * callExpr )

Check if clang::Expr is a call on lambda operator()

Parameters

callExpr

Returns: True, if the expression points to lambda invocation

Definition at line 1237 of file clang_utils.cc.

{
    const auto *call_expr = clang::dyn_cast<clang::CallExpr>(expr);
 
    if (call_expr == nullptr)
        return false;
 
    if (clang::dyn_cast_or_null<clang::LambdaExpr>(call_expr->getCallee()) !=
        nullptr) {
        return true;
    }
 
    const auto *function_callee = call_expr->getDirectCallee();
    if (function_callee != nullptr) {
 
        const auto *method_decl =
            clang::dyn_cast<clang::CXXMethodDecl>(function_callee);
        if (method_decl == nullptr)
            return false;
 
        if (method_decl->getParent()->isLambda() &&
            method_decl->getOverloadedOperator() == clang::OO_Call) {
            return true;
        }
    }
 
    return false;
}

◆ is_lambda_method()

bool clanguml::common::is_lambda_method ( const clang::FunctionDecl * decl )

Definition at line 1266 of file clang_utils.cc.

{
    if (decl == nullptr)
        return false;
 
    if (const auto *method = clang::dyn_cast<clang::CXXMethodDecl>(decl);
        method != nullptr) {
        if (method->getParent() != nullptr && method->getParent()->isLambda())
            return true;
    }
 
    return false;
}

◆ is_qualified_identifier()

bool clanguml::common::is_qualified_identifier ( const std::string & t )

Definition at line 694 of file clang_utils.cc.

{
    return std::isalpha(t.at(0)) != 0 &&
        std::all_of(t.begin(), t.end(), [](const char c) {
            return is_identifier_character(c) || c == ':';
        });
}

◆ is_qualifier()

bool clanguml::common::is_qualifier ( const std::string & q )

Definition at line 654 of file clang_utils.cc.

{
    return q == "&" || q == "&&" || q == "const&";
}

◆ is_struct()

bool clanguml::common::is_struct ( const clang::NamedDecl * decl )

Check if named declaration is a C++ struct.

Parameters

decl	Declaration to check

Returns: True, if declaration represents a struct.

Definition at line 1048 of file clang_utils.cc.

{
    if (decl == nullptr)
        return false;
 
    if (const auto *record = clang::dyn_cast<clang::CXXRecordDecl>(decl);
        record) {
        return record->isStruct();
    }
 
    if (const auto *tag = clang::dyn_cast<clang::TagDecl>(decl); tag) {
        return tag->isStruct();
    }
 
    return false;
}

◆ is_subexpr_of()

bool clanguml::common::is_subexpr_of	(	const clang::Stmt *	parent_stmt,
		const clang::Stmt *	sub_stmt
	)

Check if an expression is contained in another expression.

This method returns true if sub_stmt is equal to or is contained in the AST subtree of parent_stmt

Parameters

parent_stmt	Parent statement
sub_stmt	Sub statement

Returns

Definition at line 454 of file clang_utils.cc.

{
    if (parent_stmt == nullptr || sub_stmt == nullptr)
        return false;
 
    if (parent_stmt == sub_stmt)
        return true;
 
    return std::any_of(parent_stmt->child_begin(), parent_stmt->child_end(),
        [sub_stmt](const auto *e) { return is_subexpr_of(e, sub_stmt); });
}

◆ is_type_parameter()

bool clanguml::common::is_type_parameter ( const std::string & t )

Definition at line 649 of file clang_utils.cc.

{
    return t.find("type-parameter-") == 0;
}

◆ is_type_token()

bool clanguml::common::is_type_token ( const std::string & t )

Definition at line 702 of file clang_utils.cc.

{
    return is_type_parameter(t) ||
        (is_identifier(t) && !is_qualifier(t) && !is_bracket(t));
}

◆ operator!=() [1/2]

bool clanguml::common::operator!=	(	const eid_t &	lhs,
		const eid_t &	rhs
	)

Definition at line 66 of file types.cc.

66{ return !(lhs == rhs); }

◆ operator!=() [2/2]

bool clanguml::common::operator!=	(	const eid_t &	lhs,
		const uint64_t &	v
	)

Definition at line 59 of file types.cc.

{
    assert(v != 0);
 
    return lhs.value_ != v;
}

◆ operator<()

bool clanguml::common::operator<	(	const eid_t &	lhs,
		const eid_t &	rhs
	)

Definition at line 68 of file types.cc.

{
    if (lhs.is_global_ != rhs.is_global_) {
        return lhs.value_ < rhs.value_ + 1;
    }
 
    return lhs.value_ < rhs.value_; // Compare values if is_global_ are the same
}

◆ operator<<()

YAML::Emitter & clanguml::common::operator<<	(	YAML::Emitter &	out,
		const string_or_regex &	m
	)

Definition at line 23 of file yaml_emitters.cc.

{
    if (std::holds_alternative<std::string>(m.value())) {
        out << std::get<std::string>(m.value());
    }
    else {
        out << YAML::BeginMap;
        out << YAML::Key << "r" << YAML::Value
            << std::get<regex>(m.value()).pattern;
        out << YAML::EndMap;
    }
 
    return out;
}

◆ operator==() [1/2]

bool clanguml::common::operator==	(	const eid_t &	lhs,
		const eid_t &	rhs
	)

Definition at line 52 of file types.cc.

{
    return (lhs.is_global_ == rhs.is_global_) && (lhs.value_ == rhs.value_);
}

◆ operator==() [2/2]

bool clanguml::common::operator==	(	const eid_t &	lhs,
		const uint64_t &	v
	)

Definition at line 57 of file types.cc.

57{ return lhs.value_ == v; }

◆ parse_source_location()

bool clanguml::common::parse_source_location	(	const std::string &	location_str,
		std::string &	file,
		unsigned &	line,
		unsigned &	column
	)

Definition at line 967 of file clang_utils.cc.

{
    auto tokens = util::split(location_str, ":");
 
    if (tokens.size() < 3)
        return false;
 
    if (tokens.size() == 4) {
        // Handle Windows paths
        decltype(tokens) tmp_tokens{};
        tmp_tokens.emplace_back(
            fmt::format("{}:{}", tokens.at(0), tokens.at(1)));
        tmp_tokens.emplace_back(tokens.at(2));
        tmp_tokens.emplace_back(tokens.at(3));
 
        tokens = std::move(tmp_tokens);
    }
 
    file = tokens.at(0);
    try {
        line = std::stoi(tokens.at(1));
    }
    catch (std::invalid_argument &e) {
        return false;
    }
 
    try {
        column = std::stoi(tokens.at(2));
    }
    catch (std::invalid_argument &e) {
        column = 0;
    }
 
    return true;
}

◆ parse_unexposed_template_params()

std::vector< common::model::template_parameter > clanguml::common::parse_unexposed_template_params	(	const std::string &	params,
		const std::function< std::string(const std::string &)> &	ns_resolve,
		int	depth = `0`
	)

Parse unexposed (available as string) template params.

Parameters

params	String parameters as provided by Clang
ns_resolve	Namespace resolver function
depth	Current depth in the template specification

Returns: Parsed template parameter

Definition at line 557 of file clang_utils.cc.

{
    using common::model::template_parameter;
 
    std::vector<template_parameter> res;
 
    auto it = params.begin();
    while (std::isspace(*it) != 0)
        ++it;
 
    std::string type{};
    std::vector<template_parameter> nested_params;
    bool complete_class_template_argument{false};
 
    while (it != params.end()) {
        if (*it == '<') {
            int nested_level{0};
            auto bracket_match_begin = it + 1;
            auto bracket_match_end = bracket_match_begin;
            while (bracket_match_end != params.end()) {
                if (*bracket_match_end == '<') {
                    nested_level++;
                }
                else if (*bracket_match_end == '>') {
                    if (nested_level > 0)
                        nested_level--;
                    else
                        break;
                }
                else {
                }
                bracket_match_end++;
            }
 
            std::string nested_params_str(
                bracket_match_begin, bracket_match_end);
 
            nested_params = parse_unexposed_template_params(
                nested_params_str, ns_resolve, depth + 1);
 
            if (nested_params.empty()) {
                // We couldn't extract any nested template parameters from
                // `nested_params_str` so just add it as type of template
                // argument as is
                nested_params.emplace_back(
                    template_parameter::make_unexposed_argument(
                        nested_params_str));
            }
 
            it = bracket_match_end - 1;
        }
        else if (*it == '>') {
            complete_class_template_argument = true;
            if (depth == 0) {
                break;
            }
        }
        else if (*it == ',') {
            complete_class_template_argument = true;
        }
        else {
            type += *it;
        }
        if (complete_class_template_argument) {
            auto t = template_parameter::make_unexposed_argument(
                ns_resolve(clanguml::util::trim_typename(type)));
            type = "";
            for (auto &&param : nested_params)
                t.add_template_param(std::move(param));
 
            res.emplace_back(std::move(t));
            complete_class_template_argument = false;
        }
        it++;
    }
 
    if (!type.empty()) {
        auto t = template_parameter::make_unexposed_argument(
            ns_resolve(clanguml::util::trim_typename(type)));
        type = "";
        for (auto &&param : nested_params)
            t.add_template_param(std::move(param));
 
        res.emplace_back(std::move(t));
    }
 
    return res;
}

◆ set_source_location()

void clanguml::common::set_source_location	(	clang::SourceManager &	source_manager,
		const clang::SourceLocation &	location,
		clanguml::common::model::source_location &	element,
		std::filesystem::path	tu_path,
		std::filesystem::path	relative_to_path_
	)

Definition at line 1083 of file clang_utils.cc.

{
    namespace fs = std::filesystem;
 
    std::string file;
    unsigned line{};
    unsigned column{};
 
    if (location.isValid()) {
        file =
            source_manager.getFilename(source_manager.getSpellingLoc(location))
                .str();
        line = source_manager.getSpellingLineNumber(location);
        column = source_manager.getSpellingColumnNumber(location);
 
        if (file.empty()) {
            // Why do I have to do this?
            parse_source_location(
                location.printToString(source_manager), file, line, column);
        }
    }
    else {
        auto success = parse_source_location(
            location.printToString(source_manager), file, line, column);
        if (!success) {
            LOG_DBG("Failed to extract source location for element from {}",
                location.printToString(source_manager));
            return;
        }
    }
 
    // ensure the path is absolute
    fs::path file_path{file};
    if (!file_path.is_absolute()) {
        file_path = fs::absolute(file_path);
    }
 
    file_path = weakly_canonical(file_path);
 
    file = file_path.string();
 
    element.set_file(file);
 
    if (util::is_relative_to(file_path, relative_to_path_)) {
        element.set_file_relative(util::path_to_url(
            fs::path{element.file()}.lexically_relative(relative_to_path_)));
    }
    else {
        element.set_file_relative("");
    }
 
    element.set_translation_unit(tu_path.string());
    element.set_line(line);
    element.set_column(column);
    element.set_location_id(location.getHashValue());
}

◆ split_ns()

std::pair< common::model::namespace_, std::string > clanguml::common::split_ns ( const std::string & full_name )

Split qualified name to namespace and name.

Parameters

full_name Fully qualified element name

Returns: (namespace, name)

Definition at line 544 of file clang_utils.cc.

{
    assert(!full_name.empty());
 
    auto name_before_template = ::clanguml::util::split(full_name, "<")[0];
    auto ns = common::model::namespace_{
        ::clanguml::util::split(name_before_template, "::")};
    auto name = ns.name();
    ns.pop_back();
    return {ns, name};
}

◆ to_id()

template<>

eid_t clanguml::common::to_id ( const clang::TemplateArgument & template_argument )

Definition at line 527 of file clang_utils.cc.

{
    if (template_argument.getKind() == clang::TemplateArgument::Type) {
        if (const auto *enum_type =
                template_argument.getAsType()->getAs<clang::EnumType>();
            enum_type != nullptr)
            return to_id(*enum_type->getAsTagDecl());
 
        if (const auto *record_type =
                template_argument.getAsType()->getAs<clang::RecordType>();
            record_type != nullptr)
            return to_id(*record_type->getAsRecordDecl());
    }
 
    throw std::runtime_error("Cannot generate id for template argument");
}

◆ to_string() [1/16]

std::string clanguml::common::to_string ( const bool v )

Definition at line 86 of file types.cc.

86{ return v ? "true" : "false"; }

◆ to_string() [2/16]

std::string clanguml::common::to_string	(	const clang::ArrayType &	array_type,
		const clang::ASTContext &	ctx,
		bool	try_canonical,
		std::vector< std::string > &	dimensions
	)

Definition at line 137 of file clang_utils.cc.

{
    auto maybe_size = get_array_size(array_type);
    std::string array_size =
        maybe_size.has_value() ? std::to_string(maybe_size.value()) : "";
    dimensions.emplace_back(std::move(array_size));
 
    const auto underlying_type = array_type.getElementType();
 
    if (underlying_type->isArrayType())
        return to_string(*underlying_type->getAsArrayTypeUnsafe(), ctx,
            try_canonical, dimensions);
 
    std::string dimensions_str;
    for (const auto &d : dimensions) {
        dimensions_str += fmt::format("[{}]", d);
    }
    return fmt::format(
        "{}{}", to_string(underlying_type, ctx, try_canonical), dimensions_str);
}

◆ to_string() [3/16]

std::string clanguml::common::to_string ( const clang::Expr * expr )

Definition at line 314 of file clang_utils.cc.

{
    const clang::LangOptions lang_options;
    std::string result;
    llvm::raw_string_ostream ostream(result);
    expr->printPretty(ostream, nullptr, clang::PrintingPolicy(lang_options));
 
    return result;
}

◆ to_string() [4/16]

std::string clanguml::common::to_string ( const clang::FunctionTemplateDecl * decl )

Definition at line 339 of file clang_utils.cc.

{
    std::vector<std::string> template_parameters;
    // Handle template function
    for (const auto *parameter : *decl->getTemplateParameters()) {
        if (clang::dyn_cast_or_null<clang::TemplateTypeParmDecl>(parameter) !=
            nullptr) {
            const auto *template_type_parameter =
                clang::dyn_cast_or_null<clang::TemplateTypeParmDecl>(parameter);
 
            std::string template_parameter{
                template_type_parameter->getNameAsString()};
 
            if (template_type_parameter->isParameterPack())
                template_parameter += "...";
 
            template_parameters.emplace_back(std::move(template_parameter));
        }
        else {
            // TODO
        }
    }
    return fmt::format("{}<{}>({})", decl->getQualifiedNameAsString(),
        fmt::join(template_parameters, ","), "");
}

◆ to_string() [5/16]

std::string clanguml::common::to_string	(	const clang::QualType &	type,
		const clang::ASTContext &	ctx,
		bool	try_canonical
	)

Definition at line 181 of file clang_utils.cc.

{
    if (type->isArrayType()) {
        std::vector<std::string> dimensions;
        return to_string(
            *type->getAsArrayTypeUnsafe(), ctx, try_canonical, dimensions);
    }
 
    clang::PrintingPolicy print_policy(ctx.getLangOpts());
    print_policy.SuppressScope = 0;
#if LLVM_VERSION_MAJOR < 21
    print_policy.PrintCanonicalTypes = 0;
#else
    print_policy.PrintAsCanonical = 0;
#endif
 
    std::string result;
 
    result = type.getAsString(print_policy);
 
    if (try_canonical && result.find('<') != std::string::npos) {
        auto canonical_type_name =
            type.getCanonicalType().getAsString(print_policy);
 
        auto result_qualified_template_name =
            result.substr(0, result.find('<'));
        auto result_template_arguments = result.substr(result.find('<'));
 
        auto canonical_qualified_template_name =
            canonical_type_name.substr(0, canonical_type_name.find('<'));
 
        // Choose the longer name (why do I have to do this?)
        if (result_qualified_template_name.size() <
            canonical_qualified_template_name.size()) {
 
            result =
                canonical_qualified_template_name + result_template_arguments;
        }
    }
 
    // If for any reason clang reports the type as empty string, make sure
    // it has some default name
    if (result.empty())
        result = "(anonymous)";
    else if (util::contains(result, "unnamed struct") ||
        util::contains(result, "unnamed union") ||
        util::contains(result, "struct (unnamed") ||
        util::contains(result, "union (unnamed")) {
        const auto *declarationTag = type->getAsTagDecl();
        if (declarationTag == nullptr) {
            result = "(unnamed undeclared)";
        }
        else {
            result = common::get_tag_name(*declarationTag);
        }
    }
    else if (util::contains(result, "anonymous struct") ||
        util::contains(result, "anonymous union")) {
        result = common::get_tag_name(*type->getAsTagDecl());
    }
 
    // Remove trailing spaces after commas in template arguments
    clanguml::util::replace_all(result, ", ", ",");
    clanguml::util::replace_all(result, "> >", ">>");
 
    // Try to get rid of 'type-parameter-X-Y' ugliness
    if (result.find("type-parameter-") != std::string::npos) {
        util::if_not_null(
            common::dereference(type)->getAs<clang::TypedefType>(),
            [&result, &type](auto *p) {
                auto [unqualified_type, context] =
                    common::consume_type_context(type);
                result = p->getDecl()->getNameAsString();
                if (!context.empty()) {
                    std::vector<std::string> deduced_contexts;
 
                    for (const auto &c : context) {
                        deduced_contexts.push_back(c.to_string());
                    }
 
                    result = fmt::format(
                        "{} {}", result, fmt::join(deduced_contexts, " "));
                }
            });
    }
 
    return result;
}

◆ to_string() [6/16]

std::string clanguml::common::to_string	(	const clang::RecordType &	type,
		const clang::ASTContext &	ctx,
		bool	try_canonical
	)

Definition at line 271 of file clang_utils.cc.

{
    return to_string(type.desugar(), ctx, try_canonical);
}

◆ to_string() [7/16]

std::string clanguml::common::to_string ( const clang::Stmt * stmt )

Definition at line 329 of file clang_utils.cc.

{
    const clang::LangOptions lang_options;
    std::string result;
    llvm::raw_string_ostream ostream(result);
    stmt->printPretty(ostream, nullptr, clang::PrintingPolicy(lang_options));
 
    return result;
}

◆ to_string() [8/16]

std::string clanguml::common::to_string	(	const clang::TemplateArgument &	arg,
		const clang::ASTContext *	ctx
	)

Definition at line 277 of file clang_utils.cc.

{
    switch (arg.getKind()) {
    case clang::TemplateArgument::Expression:
        return to_string(arg.getAsExpr());
    case clang::TemplateArgument::Type:
        return to_string(arg.getAsType(), *ctx, false);
    case clang::TemplateArgument::Null:
        return "";
    case clang::TemplateArgument::NullPtr:
        return "nullptr";
    case clang::TemplateArgument::Integral:
        return std::to_string(arg.getAsIntegral().getExtValue());
    case clang::TemplateArgument::Template:
        return to_string(arg.getAsTemplate());
    case clang::TemplateArgument::TemplateExpansion:
        return to_string(arg.getAsTemplateOrTemplatePattern());
    default:
        return "";
    }
}

◆ to_string() [9/16]

std::string clanguml::common::to_string	(	const clang::TemplateArgumentLoc &	argLoc,
		const clang::ASTContext &	context
	)

Definition at line 160 of file clang_utils.cc.

{
    std::string result;
    llvm::raw_string_ostream stream(result);
 
    clang::PrintingPolicy policy(context.getLangOpts());
 
    const clang::TemplateArgument &arg = argLoc.getArgument();
 
#if LLVM_VERSION_MAJOR > 18
    arg.print(policy, stream, false);
#else
    arg.dump(stream);
#endif
 
    stream.flush();
 
    return result;
}

◆ to_string() [10/16]

std::string clanguml::common::to_string ( const clang::TemplateName & templ )

Definition at line 300 of file clang_utils.cc.

{
    if (templ.getAsTemplateDecl() != nullptr) {
        return templ.getAsTemplateDecl()->getQualifiedNameAsString();
    }
 
    std::string result;
    const clang::LangOptions lang_options;
    llvm::raw_string_ostream ostream(result);
    templ.print(ostream, clang::PrintingPolicy(lang_options));
 
    return result;
}

◆ to_string() [11/16]

std::string clanguml::common::to_string ( const clang::TypeConstraint * tc )

Definition at line 365 of file clang_utils.cc.

{
    if (tc == nullptr)
        return {};
 
    const clang::PrintingPolicy print_policy(
        tc->getNamedConcept()->getASTContext().getLangOpts());
 
    std::string ostream_buf;
    llvm::raw_string_ostream ostream{ostream_buf};
    tc->print(ostream, print_policy);
 
    return ostream.str();
}

◆ to_string() [12/16]

std::string clanguml::common::to_string ( const clang::ValueDecl * val )

Definition at line 324 of file clang_utils.cc.

{
    return val->getQualifiedNameAsString();
}

◆ to_string() [13/16]

std::string clanguml::common::to_string ( const generator_type_t type )

Definition at line 94 of file types.cc.

{
    switch (type) {
    case generator_type_t::plantuml:
        return "plantuml";
    case generator_type_t::mermaid:
        return "mermaid";
    case generator_type_t::json:
        return "json";
    case generator_type_t::graphml:
        return "graphml";
    default:
        return "<unknown>";
    }
}

◆ to_string() [14/16]

std::string clanguml::common::to_string ( const std::filesystem::path & p )

Definition at line 92 of file types.cc.

92{ return p.string(); }

◆ to_string() [15/16]

std::string clanguml::common::to_string ( const std::string & s )

Definition at line 88 of file types.cc.

88{ return s; }

◆ to_string() [16/16]

std::string clanguml::common::to_string ( const string_or_regex & sr )

Definition at line 90 of file types.cc.

90{ return sr.to_string(); }

◆ tokenize_unexposed_template_parameter()

std::vector< std::string > clanguml::common::tokenize_unexposed_template_parameter ( const std::string & t )

Definition at line 884 of file clang_utils.cc.

{
    std::vector<std::string> result;
 
    auto spaced_out = util::split(t, " ");
 
    for (const auto &word : spaced_out) {
        if (is_qualified_identifier(word)) {
            if (word != "class" && word != "templated" && word != "struct")
                result.emplace_back(word);
            continue;
        }
 
        std::string tok;
 
        for (const char c : word) {
            if (c == '(' || c == ')' || c == '[' || c == ']' || c == '<' ||
                c == '>') {
                if (!tok.empty())
                    result.emplace_back(tok);
                result.emplace_back(std::string{c});
                tok.clear();
            }
            else if (c == ':') {
                if (!tok.empty() && tok != ":") {
                    result.emplace_back(tok);
                    tok = ":";
                }
                else if (tok == ":") {
                    result.emplace_back("::");
                    tok = "";
                }
                else {
                    tok += ':';
                }
            }
            else if (c == ',') {
                if (!tok.empty()) {
                    result.emplace_back(tok);
                }
                result.emplace_back(",");
                tok.clear();
            }
            else if (c == '*') {
                if (!tok.empty()) {
                    result.emplace_back(tok);
                }
                result.emplace_back("*");
                tok.clear();
            }
            else if (c == '.') {
                // This can only be the case if we have a variadic template,
                // right?
                if (tok == "..") {
                    result.emplace_back("...");
                    tok.clear();
                }
                else if (tok == ".") {
                    tok = "..";
                }
                else if (!tok.empty()) {
                    result.emplace_back(tok);
                    tok = ".";
                }
            }
            else {
                tok += c;
            }
        }
 
        tok = util::trim(tok);
 
        if (!tok.empty()) {
            if (tok != "class" && tok != "typename" && word != "struct")
                result.emplace_back(tok);
            tok.clear();
        }
    }
 
    return result;
}

Detailed Description

Namespaces

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

◆ compilation_database_ptr

◆ namespace_or_regex

◆ opt_ref

◆ reference_set

◆ reference_vector

◆ string_or_regex

Enumeration Type Documentation

◆ generator_type_t

Function Documentation

◆ access_specifier_to_access_t() [1/2]

◆ access_specifier_to_access_t() [2/2]

◆ consume_type_context()

◆ dereference()

◆ ensure_lambda_type_is_relative()

◆ extract_template_parameter_index()

◆ format_condition_text()

◆ get_array_size()

◆ get_condition_text() [1/6]

◆ get_condition_text() [2/6]

◆ get_condition_text() [3/6]

◆ get_condition_text() [4/6]

◆ get_condition_text() [5/6]

◆ get_condition_text() [6/6]

◆ get_declaration_raw_comment()

◆ get_expression_raw_comment()

◆ get_qualified_name()

◆ get_raw_comment()

◆ get_source_text()

◆ get_source_text_raw()

◆ get_tag_name()

◆ get_tag_namespace()

◆ get_template_namespace()

◆ get_template_parameter_concept_constraint()

◆ get_typedef_enum_decl()

◆ get_unqualified_type()

◆ has_attr()

◆ if_dyn_cast()

◆ is_bracket()

◆ is_coroutine()

◆ is_identifier()

◆ is_identifier_character()

◆ is_keyword()

◆ is_lambda_call()

◆ is_lambda_method()

◆ is_qualified_identifier()

◆ is_qualifier()

◆ is_struct()

◆ is_subexpr_of()

◆ is_type_parameter()

◆ is_type_token()

◆ operator!=() [1/2]

◆ operator!=() [2/2]

◆ operator<()

◆ operator<<()

◆ operator==() [1/2]

◆ operator==() [2/2]

◆ parse_source_location()

◆ parse_unexposed_template_params()

◆ set_source_location()

◆ split_ns()

◆ to_id()

◆ to_string() [1/16]

◆ to_string() [2/16]

◆ to_string() [3/16]

◆ to_string() [4/16]

◆ to_string() [5/16]

◆ to_string() [6/16]

◆ to_string() [7/16]

◆ to_string() [8/16]

◆ to_string() [9/16]

◆ to_string() [10/16]

◆ to_string() [11/16]

◆ to_string() [12/16]