jyapayne/cppast
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Parse cpp_class_template

Browse source
This commit is contained in:
Jonathan Müller 2017-03-27 11:34:51 +02:00
commit 22fd582756
12 changed files with 289 additions and 56 deletions
Download patch file Download diff file Expand all files Collapse all files

36
include/cppast/cpp_class.hpp
View file

@ -74,17 +74,19 @@ namespace cppast
/// \returns A newly created base class specifier.
/// \notes It is not meant to be registered at the [cppast::cpp_entity_index](),
/// as nothing can refer to the specifier itself.
static std::unique_ptr<cpp_base_class> build(const cpp_type_ref& base,
static std::unique_ptr<cpp_base_class> build(std::string name,
std::unique_ptr<cpp_type> base,
cpp_access_specifier_kind access,
bool is_virtual)
{
return std::unique_ptr<cpp_base_class>(new cpp_base_class(base, access, is_virtual));
return std::unique_ptr<cpp_base_class>(
new cpp_base_class(std::move(name), std::move(base), access, is_virtual));
}
/// \returns An entity reference to the base class.
cpp_type_ref entity() const
/// \returns The type of the base class.
const cpp_type& type() const
{
return cpp_type_ref(base_id_, name());
return *type_;
}
/// \returns The access specifier of the base class.
@ -100,15 +102,15 @@ namespace cppast
}
private:
cpp_base_class(const cpp_type_ref& base, cpp_access_specifier_kind access, bool is_virtual)
: cpp_entity(base.name()), base_id_(base.id()[0u]), access_(access), virtual_(is_virtual)
cpp_base_class(std::string name, std::unique_ptr<cpp_type> base,
cpp_access_specifier_kind access, bool is_virtual)
: cpp_entity(std::move(name)), type_(std::move(base)), access_(access), virtual_(is_virtual)
{
DEBUG_ASSERT(!base.is_overloaded(), detail::precondition_error_handler{});
}
cpp_entity_kind do_get_entity_kind() const noexcept override;
cpp_entity_id base_id_;
std::unique_ptr<cpp_type> type_;
cpp_access_specifier_kind access_;
bool virtual_;
};
@ -142,10 +144,11 @@ namespace cppast
}
/// \effects Builds a [cppast::cpp_base_class]() and adds it.
void base_class(const cpp_type_ref& base, cpp_access_specifier_kind access,
bool is_virtual)
void base_class(std::string name, std::unique_ptr<cpp_type> type,
cpp_access_specifier_kind access, bool is_virtual)
{
add_base_class(cpp_base_class::build(base, access, is_virtual));
add_base_class(
cpp_base_class::build(std::move(name), std::move(type), access, is_virtual));
}
/// \effects Adds a new base class.
@ -179,10 +182,17 @@ namespace cppast
/// \effects Marks the class as forward declaration.
/// \returns The finished class.
/// \notes It will not be registered, as it is not the main definition.
std::unique_ptr<cpp_class> finish_declaration(const cpp_entity_index& idx,
cpp_entity_id definition_id);
/// \effects Returns the finished class without registering it.
/// \notes This is intended for templated classes only.
std::unique_ptr<cpp_class> finish();
/// \effects Returns the finish class without registering it and marks it as forward declaration.
/// \notes This is intended for templated classes only.
std::unique_ptr<cpp_class> finish_declaration(cpp_entity_id definition_id);
private:
std::unique_ptr<cpp_class> class_;
};

2
include/cppast/cpp_class_template.hpp
View file

@ -14,6 +14,8 @@ namespace cppast
class cpp_class_template final : public cpp_template
{
public:
static cpp_entity_kind kind() noexcept;
/// Builder for [cppast::cpp_class_template]().
class builder : public basic_builder<cpp_class_template, cpp_class>
{

9
include/cppast/cpp_template.hpp
View file

@ -58,9 +58,14 @@ namespace cppast
/// \effects Registers the template.
/// \returns The finished template.
std::unique_ptr<T> finish(const cpp_entity_index& idx, cpp_entity_id id)
std::unique_ptr<T> finish(const cpp_entity_index& idx, cpp_entity_id id,
bool is_definition)
{
idx.register_definition(std::move(id), type_safe::cref(*template_entity));
if (is_definition)
idx.register_definition(std::move(id), type_safe::cref(*template_entity));
else
idx.register_forward_declaration(std::move(id),
type_safe::cref(*template_entity));
return std::move(template_entity);
}

11
src/cpp_class.cpp
View file

@ -23,6 +23,17 @@ std::unique_ptr<cpp_class> cpp_class::builder::finish_declaration(const cpp_enti
return std::move(class_);
}
std::unique_ptr<cpp_class> cpp_class::builder::finish()
{
return std::move(class_);
}
std::unique_ptr<cpp_class> cpp_class::builder::finish_declaration(cpp_entity_id definition_id)
{
class_->set_definition(definition_id);
return std::move(class_);
}
const char* cppast::to_string(cpp_class_kind kind) noexcept
{
switch (kind)

7
src/cpp_class_template.cpp
View file

@ -8,11 +8,16 @@
using namespace cppast;
cpp_entity_kind cpp_class_template::do_get_entity_kind() const noexcept
cpp_entity_kind cpp_class_template::kind() noexcept
{
return cpp_entity_kind::class_template_t;
}
cpp_entity_kind cpp_class_template::do_get_entity_kind() const noexcept
{
return kind();
}
cpp_entity_kind cpp_class_template_specialization::do_get_entity_kind() const noexcept
{
return cpp_entity_kind::class_template_specialization_t;

23
src/libclang/class_parser.cpp
View file

@ -14,7 +14,10 @@ namespace
{
cpp_class_kind parse_class_kind(const CXCursor& cur)
{
switch (clang_getCursorKind(cur))
auto kind = clang_getTemplateCursorKind(cur);
if (kind == CXCursor_NoDeclFound)
kind = clang_getCursorKind(cur);
switch (kind)
{
case CXCursor_ClassDecl:
return cpp_class_kind::class_t;
@ -62,7 +65,7 @@ namespace
}
void add_base_class(cpp_class::builder& builder, const detail::parse_context& context,
const CXCursor& cur)
const CXCursor& cur, const CXCursor& class_cur)
{
DEBUG_ASSERT(cur.kind == CXCursor_CXXBaseSpecifier, detail::assert_handler{});
auto access = convert_access(cur);
@ -82,9 +85,8 @@ namespace
while (!stream.done())
name += stream.get().c_str();
auto type =
cpp_type_ref(detail::get_entity_id(clang_getCursorReferenced(cur)), std::move(name));
builder.base_class(type, access, is_virtual);
auto type = detail::parse_type(context, class_cur, clang_getCursorType(cur));
builder.base_class(std::move(name), std::move(type), access, is_virtual);
}
}
@ -98,14 +100,19 @@ std::unique_ptr<cpp_entity> detail::parse_cpp_class(const detail::parse_context&
if (kind == CXCursor_CXXAccessSpecifier)
add_access_specifier(builder, child);
else if (kind == CXCursor_CXXBaseSpecifier)
add_base_class(builder, context, child);
add_base_class(builder, context, child, cur);
else if (kind == CXCursor_CXXFinalAttr)
builder.is_final();
else if (kind == CXCursor_TemplateTypeParameter || kind == CXCursor_NonTypeTemplateParameter
|| kind == CXCursor_TemplateTemplateParameter)
return;
else if (auto entity = parse_entity(context, child))
builder.add_child(std::move(entity));
});
auto is_templated = clang_getTemplateCursorKind(cur) != CXCursor_NoDeclFound;
if (clang_isCursorDefinition(cur))
return builder.finish(*context.idx, get_entity_id(cur));
return is_templated ? builder.finish() : builder.finish(*context.idx, get_entity_id(cur));
else
return builder.finish_declaration(*context.idx, get_entity_id(cur));
return is_templated ? builder.finish_declaration(detail::get_entity_id(cur)) :
builder.finish_declaration(*context.idx, get_entity_id(cur));
}

2
src/libclang/parse_functions.cpp
View file

@ -132,6 +132,8 @@ std::unique_ptr<cpp_entity> detail::parse_entity(const detail::parse_context& co
return parse_cpp_alias_template(context, cur);
case CXCursor_FunctionTemplate:
return parse_cpp_function_template(context, cur);
case CXCursor_ClassTemplate:
return parse_cpp_class_template(context, cur);
default:
break;

2
src/libclang/parse_functions.hpp
View file

@ -133,6 +133,8 @@ namespace cppast
const CXCursor& cur);
std::unique_ptr<cpp_entity> parse_cpp_function_template(const parse_context& context,
const CXCursor& cur);
std::unique_ptr<cpp_entity> parse_cpp_class_template(const parse_context& context,
const CXCursor& cur);
// as_template: true, iff currently parsing a template
std::unique_ptr<cpp_entity> parse_entity(

40
src/libclang/template_parser.cpp
View file

@ -3,6 +3,7 @@
// found in the top-level directory of this distribution.
#include <cppast/cpp_alias_template.hpp>
#include <cppast/cpp_class_template.hpp>
#include <cppast/cpp_function_template.hpp>
#include <cppast/cpp_entity_kind.hpp>
@ -217,7 +218,7 @@ std::unique_ptr<cpp_entity> detail::parse_cpp_alias_template(const detail::parse
return nullptr;
context.comments.match(builder.value().get(), cur);
parse_parameters(builder.value(), context, cur);
return builder.value().finish(*context.idx, detail::get_entity_id(cur));
return builder.value().finish(*context.idx, detail::get_entity_id(cur), true);
}
std::unique_ptr<cpp_entity> detail::parse_cpp_function_template(
@ -259,13 +260,14 @@ std::unique_ptr<cpp_entity> detail::parse_cpp_function_template(
std::unique_ptr<cpp_function_base>(static_cast<cpp_function_base*>(func.release())));
builder.get().set_comment(std::move(comment));
parse_parameters(builder, context, cur);
return builder.finish(*context.idx, detail::get_entity_id(cur));
return builder.finish(*context.idx, detail::get_entity_id(cur),
builder.get().function().is_definition());
}
namespace
{
template <class Builder>
void add_arguments(Builder& b, const detail::parse_context& context, const CXCursor& cur)
void parse_arguments(Builder& b, const detail::parse_context& context, const CXCursor& cur)
{
detail::tokenizer tokenizer(context.tu, context.file, cur);
detail::token_stream stream(tokenizer, cur);
@ -320,10 +322,36 @@ std::unique_ptr<cpp_entity> detail::try_parse_cpp_function_template_specializati
if (!func)
return nullptr;
// steal comment
auto comment = type_safe::copy(func->comment());
func->set_comment(type_safe::nullopt);
cpp_function_template_specialization::builder
builder(std::unique_ptr<cpp_function_base>(static_cast<cpp_function_base*>(func.release())),
cpp_template_ref(detail::get_entity_id(templ), ""));
add_arguments(builder, context, cur);
return builder.finish(*context.idx, detail::get_entity_id(cur));
builder.get().set_comment(std::move(comment));
parse_arguments(builder, context, cur);
return builder.finish(*context.idx, detail::get_entity_id(cur),
builder.get().function().is_definition());
}
std::unique_ptr<cpp_entity> detail::parse_cpp_class_template(const detail::parse_context& context,
const CXCursor& cur)
{
DEBUG_ASSERT(clang_getCursorKind(cur) == CXCursor_ClassTemplate, detail::assert_handler{});
auto c = detail::parse_cpp_class(context, cur);
if (!c)
return nullptr;
// steal comment
auto comment = type_safe::copy(c->comment());
c->set_comment(type_safe::nullopt);
cpp_class_template::builder builder(
std::unique_ptr<cpp_class>(static_cast<cpp_class*>(c.release())));
builder.get().set_comment(std::move(comment));
parse_parameters(builder, context, cur);
return builder.finish(*context.idx, detail::get_entity_id(cur),
builder.get().class_().is_definition());
}

5
src/libclang/type_parser.cpp
View file

@ -451,6 +451,7 @@ namespace
case CXType_Vector:
case CXType_ObjCInterface:
case CXType_ObjCObjectPointer:
case CXType_Dependent:
{
auto msg = detail::format("unexpected type of kind '",
detail::get_type_kind_spelling(type).c_str(), "'");
@ -543,10 +544,6 @@ namespace
case CXType_MemberPointer:
return cpp_pointer_type::build(parse_member_pointee_type(context, cur, type));
// TODO: everything template related
case CXType_Dependent:
break;
// TODO: auto/decltype
case CXType_Auto:
break;

37
test/cpp_class.cpp
View file

@ -179,20 +179,18 @@ struct g
REQUIRE(base.access_specifier() == cpp_private);
REQUIRE(!base.is_virtual());
REQUIRE(!base.entity().is_overloaded());
auto entities = base.entity().get(idx);
REQUIRE(entities.size() == 1u);
REQUIRE(entities[0u]->name() == "a");
REQUIRE(
equal_types(idx, base.type(), *cpp_user_defined_type::build(
cpp_type_ref(cpp_entity_id(""), "a"))));
}
else if (base.name() == "d")
{
REQUIRE(base.access_specifier() == cpp_private);
REQUIRE(!base.is_virtual());
REQUIRE(!base.entity().is_overloaded());
auto entities = base.entity().get(idx);
REQUIRE(entities.size() == 1u);
REQUIRE(entities[0u]->name() == "d");
REQUIRE(
equal_types(idx, base.type(), *cpp_user_defined_type::build(
cpp_type_ref(cpp_entity_id(""), "d"))));
}
else
REQUIRE(false);
@ -216,21 +214,18 @@ struct g
REQUIRE(base.access_specifier() == cpp_public);
REQUIRE(!base.is_virtual());
REQUIRE(!base.entity().is_overloaded());
auto entities = base.entity().get(idx);
REQUIRE(entities.size() == 1u);
REQUIRE(entities[0u]->name() == "base");
REQUIRE(full_name(*entities[0u]) == "ns::base");
REQUIRE(equal_types(idx, base.type(),
*cpp_user_defined_type::build(
cpp_type_ref(cpp_entity_id(""), "ns::base"))));
}
else if (base.name() == "e")
{
REQUIRE(base.access_specifier() == cpp_protected);
REQUIRE(base.is_virtual());
REQUIRE(!base.entity().is_overloaded());
auto entities = base.entity().get(idx);
REQUIRE(entities.size() == 1u);
REQUIRE(entities[0u]->name() == "e");
REQUIRE(
equal_types(idx, base.type(), *cpp_user_defined_type::build(
cpp_type_ref(cpp_entity_id(""), "e"))));
}
else
REQUIRE(false);
@ -254,11 +249,9 @@ struct g
REQUIRE(base.access_specifier() == cpp_public);
REQUIRE(!base.is_virtual());
REQUIRE(!base.entity().is_overloaded());
auto entities = base.entity().get(idx);
REQUIRE(entities.size() == 1u);
REQUIRE(entities[0u]->name() == "base");
REQUIRE(full_name(*entities[0u]) == "ns::base");
REQUIRE(equal_types(idx, base.type(),
*cpp_user_defined_type::build(
cpp_type_ref(cpp_entity_id(""), "ns::base"))));
}
else
REQUIRE(false);

171
test/cpp_class_template.cpp Normal file
View file

@ -0,0 +1,171 @@
// Copyright (C) 2017 Jonathan Müller <jonathanmueller.dev@gmail.com>
// This file is subject to the license terms in the LICENSE file
// found in the top-level directory of this distribution.
#include <cppast/cpp_class_template.hpp>
#include <cppast/cpp_function_template.hpp>
#include <cppast/cpp_member_function.hpp>
#include <cppast/cpp_member_variable.hpp>
#include "test_parser.hpp"
using namespace cppast;
TEST_CASE("cpp_class_template")
{
auto code = R"(
// check everything not related to members first
template <typename T>
class a {};
template <int I, typename T>
struct b {};
template <template <typename> class T>
union c;
// bases
template <typename T>
struct d : T, a<T>, T::type, a<T>::type {};
// members
template <typename T>
struct e
{
T var_a;
a<T> var_b;
typename T::type var_c;
typename a<T>::type var_d;
template <typename U>
T func(U);
};
)";
cpp_entity_index idx;
auto file = parse(idx, "cpp_class_template.cpp", code);
auto count = test_visit<cpp_class_template>(*file, [&](const cpp_class_template& templ) {
auto& c = templ.class_();
REQUIRE(!c.is_final());
if (templ.name() == "a")
{
check_template_parameters(templ, {{cpp_entity_kind::template_type_parameter_t, "T"}});
REQUIRE(c.class_kind() == cpp_class_kind::class_t);
REQUIRE(c.is_definition());
}
else if (templ.name() == "b")
{
check_template_parameters(templ, {{cpp_entity_kind::non_type_template_parameter_t, "I"},
{cpp_entity_kind::template_type_parameter_t, "T"}});
REQUIRE(c.class_kind() == cpp_class_kind::struct_t);
REQUIRE(c.is_definition());
}
else if (templ.name() == "c")
{
check_template_parameters(templ,
{{cpp_entity_kind::template_template_parameter_t, "T"}});
REQUIRE(c.class_kind() == cpp_class_kind::union_t);
REQUIRE(c.is_declaration());
}
else
{
check_template_parameters(templ, {{cpp_entity_kind::template_type_parameter_t, "T"}});
REQUIRE(c.class_kind() == cpp_class_kind::struct_t);
REQUIRE(c.is_definition());
if (templ.name() == "d")
{
auto no = 0u;
for (auto& base : c.bases())
{
++no;
REQUIRE(base.access_specifier() == cpp_public);
REQUIRE(!base.is_virtual());
if (base.name() == "T")
REQUIRE(equal_types(idx, base.type(),
*cpp_template_parameter_type::build(
cpp_template_type_parameter_ref(cpp_entity_id(""),
"T"))));
else if (base.name() == "a<T>")
{
cpp_template_instantiation_type::builder builder(
cpp_template_ref(cpp_entity_id(""), "a"));
builder.add_unexposed_arguments("T");
REQUIRE(equal_types(idx, base.type(), *builder.finish()));
}
else if (base.name() == "T::type")
REQUIRE(
equal_types(idx, base.type(), *cpp_unexposed_type::build("T::type")));
else if (base.name() == "a<T>::type")
REQUIRE(equal_types(idx, base.type(),
*cpp_unexposed_type::build("a<T>::type")));
else
REQUIRE(false);
}
REQUIRE(no == 4u);
}
else if (templ.name() == "e")
{
auto no = 0u;
for (auto& child : c)
{
++no;
if (child.name().length() == 5u && child.name().substr(0, 3u) == "var")
{
REQUIRE(child.kind() == cpp_entity_kind::member_variable_t);
auto& var = static_cast<const cpp_member_variable&>(child);
if (child.name() == "var_a")
REQUIRE(
equal_types(idx, var.type(),
*cpp_template_parameter_type::build(
cpp_template_type_parameter_ref(cpp_entity_id(""),
"T"))));
else if (child.name() == "var_b")
{
cpp_template_instantiation_type::builder builder(
cpp_template_ref(cpp_entity_id(""), "a"));
builder.add_unexposed_arguments("T");
REQUIRE(equal_types(idx, var.type(), *builder.finish()));
}
else if (child.name() == "var_c")
REQUIRE(equal_types(idx, var.type(),
*cpp_unexposed_type::build("typename T::type")));
else if (child.name() == "var_d")
REQUIRE(equal_types(idx, var.type(),
*cpp_unexposed_type::build("typename a<T>::type")));
else
REQUIRE(false);
}
else if (child.name() == "func")
{
REQUIRE(child.kind() == cpp_entity_kind::function_template_t);
auto& templ = static_cast<const cpp_function_template&>(child);
REQUIRE(templ.function().kind() == cpp_entity_kind::member_function_t);
auto& mfunc = static_cast<const cpp_member_function&>(templ.function());
REQUIRE(equal_types(idx, mfunc.return_type(),
*cpp_template_parameter_type::build(
cpp_template_type_parameter_ref(cpp_entity_id(""),
"T"))));
for (auto& param : mfunc)
REQUIRE(
equal_types(idx, param.type(),
*cpp_template_parameter_type::build(
cpp_template_type_parameter_ref(cpp_entity_id(""),
"U"))));
}
else
REQUIRE(false);
}
REQUIRE(no == 5u);
}
}
});
REQUIRE(count == 5u);
}