Vital fixes: clang-12 compilation, destructors, deleted constructors …

…and stuff (17.10 11:45)

.gitignore

@@ -34,3 +34,7 @@ Builds/
 *.out
 *.app
 *.ps1
+
+.idea
+cmake-build-debug
+cmake-build-release

CMake/MetaPrebuild.cmake

@@ -54,12 +54,18 @@ macro(meta_generate PROJECT_NAME IN_SOURCE OUT_HEADER OUT_SOURCE ADDITIONAL_FLAG
 	set(CMD "${META_CPP_EXE} \"${IN_SOURCE_PATH}\" -out-header \"${OUT_HEADER_PATH}\" -out-source \"${OUT_SOURCE_PATH}\" ${FLAGS}")
 	separate_arguments(CMD)
 
+
 	add_custom_command(
-		TARGET ${PROJECT_NAME}
-		PRE_BUILD
+    	OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/MetaCPP"
 		COMMAND ${CMD}
 		WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
 	)
+
+	add_custom_target(
+		ProduceMetaCPP ALL
+		DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/MetaCPP"
+		)
+
 	set_source_files_properties(${OUT_HEADER_PATH} ${OUT_SOURCE_PATH} PROPERTIES GENERATED TRUE)
 
 endmacro()

Example/CMakeLists.txt

@@ -1,6 +1,8 @@
 cmake_minimum_required (VERSION 2.8)
 project(MetaCPP-Example)
 
+set (CMAKE_CXX_STANDARD 17)
+
 add_subdirectory(../MetaCPP-CLI MetaCPP-CLI)
 
 add_executable(Example main.cpp objects.hpp)

MetaCPP-CLI/ASTScraper.cpp

@@ -77,6 +77,7 @@ namespace metacpp {
 
 			type->SetAccess(TransformAccess(cxxRecordDecl->getAccess()));
 			type->SetHasDefaultConstructor(!typeCxxRecordDecl->hasUserProvidedDefaultConstructor() && typeCxxRecordDecl->needsImplicitDefaultConstructor());
+            type->SetHasDefaultDestructor(typeCxxRecordDecl->needsImplicitDestructor());
 
 			// methods
 			for (auto it = cxxRecordDecl->method_begin(); it != cxxRecordDecl->method_end(); it++) {
@@ -87,7 +88,10 @@ namespace metacpp {
 			}
 
 			if (typeCxxRecordDecl->isAbstract())
-				type->SetHasDefaultConstructor(false);
+            {
+                type->SetHasDefaultConstructor(false);
+                type->SetHasDefaultDestructor(false);
+            }
 		}
 
 		return type;
@@ -149,7 +153,7 @@ namespace metacpp {
 			static clang::PrintingPolicy printing_policy(lang_opts);
 
 			auto builtin = cType->getAs<clang::BuiltinType>();
-			std::string name = builtin->getName(printing_policy);
+			std::string name = builtin->getName(printing_policy).str();
 			if (name == "_Bool")
 				name = "bool";
 			qualifiedName = QualifiedName({}, name);
@@ -183,7 +187,8 @@ namespace metacpp {
 
 		type->SetSize(m_Context->getTypeSize(cType) / 8);
 		type->SetKind(kind);
-		type->SetHasDefaultConstructor(cType->getTypeClass() == clang::Type::TypeClass::Builtin && qualifiedName.GetName() != "void");
+        type->SetHasDefaultConstructor(cType->getTypeClass() == clang::Type::TypeClass::Builtin && qualifiedName.GetName() != "void");
+        type->SetHasDefaultDestructor(cType->getTypeClass() == clang::Type::TypeClass::Builtin && qualifiedName.GetName() != "void");
 		type->SetPolymorphic(false);
 
 		if (auto cxxRecordDecl = cType->getAsCXXRecordDecl()) {
@@ -237,9 +242,12 @@ namespace metacpp {
 		auto constructor = clang::dyn_cast<clang::CXXConstructorDecl>(cxxMethodDecl);
 		auto destructor = clang::dyn_cast<clang::CXXDestructorDecl>(cxxMethodDecl);
 
-		if (constructor && constructor->isDefaultConstructor() && constructor->getAccess() == clang::AccessSpecifier::AS_public) {
-			parent->SetHasDefaultConstructor(true);
-		}
+        if (constructor && !constructor->isDeleted() && constructor->isDefaultConstructor() && constructor->getAccess() == clang::AccessSpecifier::AS_public) {
+            parent->SetHasDefaultConstructor(true);
+        }
+        if (destructor && !destructor->isDeleted() && destructor->getAccess() == clang::AccessSpecifier::AS_public) {
+            parent->SetHasDefaultDestructor(true);
+        }
 
 		metacpp::QualifiedName qualifiedName = ResolveQualifiedName(cxxMethodDecl->getQualifiedNameAsString());
 

MetaCPP-CLI/CMakeLists.txt

@@ -1,8 +1,6 @@
 cmake_minimum_required (VERSION 3.1)
 project(MetaCPP-CLI)
 
-set (CMAKE_CXX_STANDARD 11)
-
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/../CMake")
 
 add_subdirectory(../MetaCPP MetaCPP)

MetaCPP-CLI/MetaExporter.cpp

@@ -85,7 +85,8 @@ namespace metacpp {
 		data["access"] = std::to_string(type->m_Access);
 		data["valid"] = std::to_string(type->IsValid());
 		data["polymorphic"] = std::to_string(type->m_Polymorphic);
-		data["hasDefaultConstructor"] = std::to_string(type->m_HasDefaultConstructor);
+        data["hasDefaultConstructor"] = std::to_string(type->m_HasDefaultConstructor);
+        data["hasDefaultDestructor"] = std::to_string(type->m_HasDefaultDestructor);
 
 		bool seqContainer = type->IsSequentialContainer();
 		bool assocContainer = type->IsAssociativeContainer();

MetaCPP-CLI/ScraperTool.cpp

@@ -8,13 +8,17 @@
 
 #include "ASTScraper.hpp"
 
+using namespace clang;
+using namespace clang::tooling;
+
 namespace metacpp {
 	ScraperTool::ScraperTool(std::string source, std::vector<std::string> flags)
 	{
 #if _DEBUG
 		// For now
 		flags.push_back("-D_DEBUG");
 #endif
+        flags.push_back("-I/usr/local/lib/clang/12.0.0/include");
 
 		m_CompilationDatabase = new clang::tooling::FixedCompilationDatabase(".", flags);
 		m_ClangTool = new clang::tooling::ClangTool(*m_CompilationDatabase, source);
@@ -55,12 +59,12 @@ namespace metacpp {
 		class ActionFactory : public clang::tooling::FrontendActionFactory {
 		public:
 			ActionFactory(ASTScraper* scraper) : scraper(scraper) {};
-			clang::FrontendAction *create() override { return new ASTScraperAction(scraper); }
+            std::unique_ptr<FrontendAction> create() override { return std::make_unique<ASTScraperAction>(scraper); }
 		private:
 			ASTScraper* scraper;
 		};
-		auto scraperAction = std::unique_ptr<ActionFactory>(new ActionFactory(scraper));
+		auto scraperActionFactory = std::unique_ptr<ActionFactory>(new ActionFactory(scraper));
 
-		m_ClangTool->run(scraperAction.get());
+		m_ClangTool->run(scraperActionFactory.get());
 	}
 }

MetaCPP-CLI/ScraperTool.hpp

@@ -5,6 +5,7 @@
 #include <string>
 
 #include <clang/Tooling/Tooling.h>
+#include <clang/Tooling/CompilationDatabase.h>
 
 namespace metacpp {
 	class ASTScraper;

MetaCPP-CLI/templates/source.template

@@ -89,6 +89,12 @@ namespace metacpp { namespace generated {
 				return new (ptr) {{qualifiedName}};
 			});
 #endif
+            // Destructor
+#if ({{hasDefaultDestructor}} == 1) // hasDefaultDestructor
+			type->SetDestructor([](void* ptr) -> void {
+                std::destroy_at(std::launder(reinterpret_cast<{{qualifiedName}}*>(ptr)));
+			});
+#endif
 
 #if ({{isSequentialContainer}} == 1) // isSequentialContainer
 			// SequentialContainer

MetaCPP/CMakeLists.txt

@@ -1,8 +1,6 @@
 cmake_minimum_required (VERSION 3.1)
 project(MetaCPP)
 
-set (CMAKE_CXX_STANDARD 11)
-
 set(MetaCPP_INC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
 set(MetaCPP_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src)
 

MetaCPP/include/MetaCPP/Type.hpp

@@ -3,6 +3,8 @@
 
 #include <vector>
 #include <functional>
+#include <cstring>
+#include <algorithm>
 
 #include "TypeID.hpp"
 #include "QualifiedName.hpp"
@@ -30,7 +32,8 @@ namespace metacpp {
 
 	class Type {
 	public:
-		typedef std::function<void*(void*)> Constructor;
+        typedef std::function<void*(void*)> Constructor;
+        typedef std::function<void(void*)> Destructor;
 
 		Type(const TypeID id, const QualifiedName& qName);
 
@@ -54,14 +57,17 @@ namespace metacpp {
 		const std::vector<TypeID>& GetDerivedTypes() const;
 		Container* GetContainer() const;
 
-		void* Allocate(void* ptr = 0) const;
+        void* Allocate(void* ptr = 0) const;
+        void Delete(void* ptr = 0) const;
 
 		void SetKind(const TypeKind kind);
 		void SetAccess(const AccessSpecifier access);
 		void SetSize(const size_t bytes);
 		void SetPolymorphic(const bool polymorphic);
-		void SetHasDefaultConstructor(const bool hasDefaultConstructor);
-		void SetConstructor(const Constructor constructor);
+        void SetHasDefaultConstructor(const bool hasDefaultConstructor);
+        void SetHasDefaultDestructor(const bool hasDefaultDestructor);
+        void SetConstructor(const Constructor constructor);
+        void SetDestructor(const Destructor destructor);
 		void SetContainer(Container* container);
 
 		void AddBaseType(const QualifiedType& baseType, const AccessSpecifier access);
@@ -78,8 +84,10 @@ namespace metacpp {
 		AccessSpecifier m_Access;
 		bool m_Polymorphic;
 		bool m_HasDefaultConstructor;
+        bool m_HasDefaultDestructor;
 		Container* m_Container;
-		Constructor m_Constructor;
+        Constructor m_Constructor;
+        Destructor m_Destructor;
 
 		std::vector<BaseType> m_BaseTypes;
 		std::vector<TypeID> m_DerivedTypes;

MetaCPP/src/MetaCPP/JsonSerializer.cpp

@@ -50,7 +50,8 @@ namespace metacpp {
 		FIELD_SET(SetDouble, double)
 		else if(id == TypeInfo<std::string>::ID) {
 			const std::string* str = reinterpret_cast<const std::string*>(ptr);
-			value.Swap(Value((*str).c_str(), context.document->GetAllocator()));
+			auto newValue = Value((*str).c_str(), context.document->GetAllocator());
+			value.Swap(newValue);
 		}
 		else {
 			// Unhandled basic type
@@ -147,7 +148,7 @@ namespace metacpp {
 			object.AddMember("reflection_class", rc, context.document->GetAllocator());
 		}
 
-		std::vector<Field>& fields = context.serializer->GetStorage()->GetAllFields(type);
+		const std::vector<Field>& fields = context.serializer->GetStorage()->GetAllFields(type);
 
 		for (const Field& field : fields) {
 			const QualifiedType& field_qtype = field.GetType();
@@ -184,7 +185,8 @@ namespace metacpp {
 			SerializeObject(type, obj, true, 0, context);
 		}
 		else {
-			document.Swap(SerializeObject(type, obj, false, 0, context));
+		    auto serializedDocument = SerializeObject(type, obj, false, 0, context);
+			document.Swap(serializedDocument);
 		}
 
 		StringBuffer sb;
@@ -304,23 +306,30 @@ namespace metacpp {
 
 				for (const Value& item : value.GetArray()) {
 					switch (item_qtype.GetQualifierOperator()) {
-					case QualifierOperator::VALUE:
-					{
-						void* temp_item_ptr = item_type->Allocate();
-
-						DeSerializeType(item_qtype, item, temp_item_ptr, context);
-
-						sc->PushBack(obj, temp_item_ptr);
-
-						delete temp_item_ptr;
-						break;
-					}
-					case QualifierOperator::POINTER:
-						void* holder = 0;
-						DeSerializePointer(item_type, item, &holder, context);
-
-						sc->PushBack(obj, &holder);
-						break;
+                        case QualifierOperator::VALUE:
+                        {
+                            void* temp_item_ptr = item_type->Allocate();
+
+                            DeSerializeType(item_qtype, item, temp_item_ptr, context);
+
+                            sc->PushBack(obj, temp_item_ptr);
+
+                            item_type->Delete(temp_item_ptr);
+                            break;
+                        }
+                        case QualifierOperator::POINTER:
+                            {
+                            void *holder = 0;
+                            DeSerializePointer(item_type, item, &holder, context);
+
+                            sc->PushBack(obj, &holder);
+                            break;
+                        }
+                        case QualifierOperator::REFERENCE:
+                            {
+                            assert(false);
+                            break;
+                        }
 					}
 				}
 			}

MetaCPP/src/MetaCPP/QualifiedType.cpp

@@ -3,6 +3,8 @@
 #include "MetaCPP/Storage.hpp"
 #include "MetaCPP/Type.hpp"
 
+#include <cassert>
+
 namespace metacpp {
 	QualifiedType::QualifiedType()
 		: m_Type(0), m_Operator(QualifierOperator::VALUE), m_Const(false)
@@ -29,6 +31,8 @@ namespace metacpp {
 		case QualifierOperator::REFERENCE:
 			result += "&";
 			break;
+        case QualifierOperator::VALUE:
+            break;
 		}
 
 		return result;

MetaCPP/src/MetaCPP/Type.cpp

@@ -76,7 +76,7 @@ namespace metacpp {
 
 	bool Type::IsSequentialContainer() const
 	{
-		std::string& name = m_QualifiedName.GetName();
+		const std::string& name = m_QualifiedName.GetName();
 		return name == "vector" || name == "deque" || name == "array" || name == "list" || name == "forward_list";
 	}
 
@@ -115,18 +115,27 @@ namespace metacpp {
 		return m_Container;
 	}
 
-	void* Type::Allocate(void* ptr) const
-	{
-		if(ptr == 0)
-			ptr = malloc(m_SizeInBytes);
-		memset(ptr, 0, m_SizeInBytes);
+    void* Type::Allocate(void* ptr) const
+    {
+        if(ptr == 0)
+            ptr = malloc(m_SizeInBytes);
+        memset(ptr, 0, m_SizeInBytes);
 
-		if (m_Constructor)
-			//new (ptr) T;
-			ptr = m_Constructor(ptr);
+        if (m_Constructor)
+            //new (ptr) T;
+            ptr = m_Constructor(ptr);
 
-		return ptr;
-	}
+        return ptr;
+    }
+
+    void Type::Delete(void* ptr) const
+    {
+        if (m_Destructor && ptr)
+            //ptr->~T();
+            m_Destructor(ptr);
+
+        free(ptr);
+    }
 
 	void Type::SetKind(const TypeKind kind)
 	{
@@ -153,10 +162,20 @@ namespace metacpp {
 		m_HasDefaultConstructor = hasDefaultConstructor;
 	}
 
-	void Type::SetConstructor(const Constructor constructor)
-	{
-		m_Constructor = constructor;
-	}
+    void Type::SetHasDefaultDestructor(const bool hasDefaultDestructor)
+    {
+        m_HasDefaultDestructor = hasDefaultDestructor;
+    }
+
+    void Type::SetConstructor(const Constructor constructor)
+    {
+        m_Constructor = constructor;
+    }
+
+    void Type::SetDestructor(const Destructor destructor)
+    {
+        m_Destructor = destructor;
+    }
 
 	void Type::SetContainer(Container* container)
 	{