Register declarations as well

Will be overriden by definitions.

src/cpp_class.cpp

@@ -9,10 +9,17 @@
 
 using namespace cppast;
 
-std::unique_ptr<cpp_class> cpp_class::builder::finish(const cpp_entity_index& idx,
-                                                      cpp_entity_id           id) noexcept
+std::unique_ptr<cpp_class> cpp_class::builder::finish(const cpp_entity_index& idx, cpp_entity_id id)
 {
-    idx.register_entity(std::move(id), type_safe::ref(*class_));
+    idx.register_definition(std::move(id), type_safe::ref(*class_));
+    return std::move(class_);
+}
+
+std::unique_ptr<cpp_class> cpp_class::builder::finish_declaration(const cpp_entity_index& idx,
+                                                                  cpp_entity_id definition_id)
+{
+    class_->set_definition(definition_id);
+    idx.register_forward_declaration(std::move(definition_id), type_safe::ref(*class_));
     return std::move(class_);
 }
 

src/cpp_enum.cpp

@@ -19,7 +19,7 @@ std::unique_ptr<cpp_enum_value> cpp_enum_value::build(const cpp_entity_index& id
 {
     auto result =
         std::unique_ptr<cpp_enum_value>(new cpp_enum_value(std::move(name), std::move(value)));
-    idx.register_entity(std::move(id), type_safe::ref(*result));
+    idx.register_definition(std::move(id), type_safe::ref(*result));
     return result;
 }
 

src/cpp_function.cpp

@@ -19,7 +19,7 @@ std::unique_ptr<cpp_function_parameter> cpp_function_parameter::build(
 {
     auto result = std::unique_ptr<cpp_function_parameter>(
         new cpp_function_parameter(std::move(name), std::move(type), std::move(def)));
-    idx.register_entity(std::move(id), type_safe::cref(*result));
+    idx.register_definition(std::move(id), type_safe::cref(*result));
     return result;
 }
 

src/cpp_member_variable.cpp

@@ -21,7 +21,7 @@ std::unique_ptr<cpp_member_variable> cpp_member_variable::build(const cpp_entity
 {
     auto result = std::unique_ptr<cpp_member_variable>(
         new cpp_member_variable(std::move(name), std::move(type), std::move(def), is_mutable));
-    idx.register_entity(std::move(id), type_safe::cref(*result));
+    idx.register_definition(std::move(id), type_safe::cref(*result));
     return result;
 }
 
@@ -41,7 +41,7 @@ std::unique_ptr<cpp_bitfield> cpp_bitfield::build(const cpp_entity_index& idx, c
 {
     auto result = std::unique_ptr<cpp_bitfield>(
         new cpp_bitfield(std::move(name), std::move(type), no_bits, is_mutable));
-    idx.register_entity(std::move(id), type_safe::cref(*result));
+    idx.register_definition(std::move(id), type_safe::cref(*result));
     return result;
 }
 

src/cpp_namespace.cpp

@@ -29,7 +29,7 @@ std::unique_ptr<cpp_namespace_alias> cpp_namespace_alias::build(const cpp_entity
 {
     auto ptr = std::unique_ptr<cpp_namespace_alias>(
         new cpp_namespace_alias(std::move(name), std::move(target)));
-    idx.register_entity(std::move(id), type_safe::ref(*ptr));
+    idx.register_definition(std::move(id), type_safe::ref(*ptr));
     return ptr;
 }
 

src/cpp_template_parameter.cpp

@@ -27,7 +27,7 @@ std::unique_ptr<cpp_template_type_parameter> cpp_template_type_parameter::build(
 {
     std::unique_ptr<cpp_template_type_parameter> result(
         new cpp_template_type_parameter(std::move(name), kw, variadic, std::move(default_type)));
-    idx.register_entity(std::move(id), type_safe::cref(*result));
+    idx.register_definition(std::move(id), type_safe::cref(*result));
     return result;
 }
 
@@ -48,7 +48,7 @@ std::unique_ptr<cpp_non_type_template_parameter> cpp_non_type_template_parameter
     std::unique_ptr<cpp_non_type_template_parameter> result(
         new cpp_non_type_template_parameter(std::move(name), std::move(type), is_variadic,
                                             std::move(default_value)));
-    idx.register_entity(std::move(id), type_safe::cref(*result));
+    idx.register_definition(std::move(id), type_safe::cref(*result));
     return result;
 }
 

src/cpp_type_alias.cpp

@@ -18,7 +18,7 @@ std::unique_ptr<cpp_type_alias> cpp_type_alias::build(const cpp_entity_index& id
                                                       std::unique_ptr<cpp_type> type)
 {
     auto result = build(std::move(name), std::move(type));
-    idx.register_entity(std::move(id), type_safe::cref(*result));
+    idx.register_definition(std::move(id), type_safe::cref(*result));
     return result;
 }
 

src/cpp_variable.cpp

@@ -21,7 +21,7 @@ std::unique_ptr<cpp_variable> cpp_variable::build(const cpp_entity_index& idx, c
 {
     auto result = std::unique_ptr<cpp_variable>(
         new cpp_variable(std::move(name), std::move(type), std::move(def), spec, is_constexpr));
-    idx.register_entity(std::move(id), type_safe::cref(*result));
+    idx.register_definition(std::move(id), type_safe::cref(*result));
     return result;
 }
 

src/libclang/class_parser.cpp

@@ -107,5 +107,5 @@ std::unique_ptr<cpp_entity> detail::parse_cpp_class(const detail::parse_context&
     if (clang_isCursorDefinition(cur))
         return builder.finish(*context.idx, get_entity_id(cur));
     else
-        return builder.finish_declaration(get_entity_id(cur));
+        return builder.finish_declaration(*context.idx, get_entity_id(cur));
 }

src/libclang/debug_helper.cpp

@@ -34,8 +34,9 @@ namespace
 void detail::print_cursor_info(const CXCursor& cur) noexcept
 {
     std::lock_guard<std::mutex> lock(mtx);
-    std::printf("[debug] cursor '%s' (%s)\n", get_display_name(cur).c_str(),
-                cxstring(clang_getCursorKindSpelling(cur.kind)).c_str());
+    std::printf("[debug] cursor '%s' (%s): %s\n", get_display_name(cur).c_str(),
+                cxstring(clang_getCursorKindSpelling(cur.kind)).c_str(),
+                cxstring(clang_getCursorUSR(cur)).c_str());
 }
 
 void detail::print_tokens(const CXTranslationUnit& tu, const CXFile& file,

src/libclang/enum_parser.cpp

@@ -85,5 +85,5 @@ std::unique_ptr<cpp_entity> detail::parse_cpp_enum(const detail::parse_context&
     if (clang_isCursorDefinition(cur))
         return builder.finish(*context.idx, get_entity_id(cur));
     else
-        return builder.finish_declaration(get_entity_id(cur));
+        return builder.finish_declaration(*context.idx, get_entity_id(cur));
 }

src/libclang/function_parser.cpp

@@ -176,7 +176,7 @@ namespace
             DEBUG_ASSERT(allow_virtual, detail::parse_error_handler{}, stream.cursor(),
                          "unexpected token");
             if (result.virtual_keywords)
-                result.virtual_keywords.value() &= cpp_virtual_flags::pure;
+                result.virtual_keywords.value() |= cpp_virtual_flags::pure;
             else
                 result.virtual_keywords = cpp_virtual_flags::pure;
         }