src: fixed some clang tidy warnings

* implemented CxxDeclName constructors that just move the members
* removed empty destructors because they disable default move constructors
* removed some unnecessary code
* replaced ".size() == 0" with ".empty()" because it's more explicit

src/lib_cxx/data/indexer/IndexerCommandCxx.cpp

@@ -15,10 +15,6 @@ IndexerCommandCxx::IndexerCommandCxx(
 {
 }
 
-IndexerCommandCxx::~IndexerCommandCxx()
-{
-}
-
 size_t IndexerCommandCxx::getByteSize(size_t stringSize) const
 {
 	size_t size = IndexerCommand::getByteSize(stringSize);

src/lib_cxx/data/indexer/IndexerCommandCxx.h

@@ -20,7 +20,6 @@ public:
 		const std::vector<FilePath>& frameworkSearchPaths,
 		const std::vector<std::string>& compilerFlags);
 
-	virtual ~IndexerCommandCxx();
 	virtual size_t getByteSize(size_t stringSize) const override;
 
 	std::vector<FilePath> getSystemHeaderSearchPaths() const;

src/lib_cxx/data/indexer/IndexerCommandCxxCdb.cpp

@@ -53,10 +53,6 @@ IndexerCommandCxxCdb::IndexerCommandCxxCdb(
 {
 }
 
-IndexerCommandCxxCdb::~IndexerCommandCxxCdb()
-{
-}
-
 IndexerCommandType IndexerCommandCxxCdb::getIndexerCommandType() const
 {
 	return getStaticIndexerCommandType();

src/lib_cxx/data/indexer/IndexerCommandCxxCdb.h

@@ -29,8 +29,6 @@ public:
 		const std::vector<FilePath>& systemHeaderSearchPaths,
 		const std::vector<FilePath>& frameworkSearchPaths);
 
-	virtual ~IndexerCommandCxxCdb();
-
 	virtual IndexerCommandType getIndexerCommandType() const override;
 	virtual size_t getByteSize(size_t stringSize) const override;
 

src/lib_cxx/data/indexer/IndexerCommandCxxManual.cpp

@@ -19,10 +19,6 @@ IndexerCommandCxxManual::IndexerCommandCxxManual(
 {
 }
 
-IndexerCommandCxxManual::~IndexerCommandCxxManual()
-{
-}
-
 IndexerCommandType IndexerCommandCxxManual::getIndexerCommandType() const
 {
 	return getStaticIndexerCommandType();

src/lib_cxx/data/indexer/IndexerCommandCxxManual.h

@@ -20,8 +20,6 @@ public:
 		const std::vector<FilePath>& frameworkSearchPaths,
 		const std::vector<std::string>& compilerFlags);
 
-	virtual ~IndexerCommandCxxManual();
-
 	virtual IndexerCommandType getIndexerCommandType() const override;
 	virtual size_t getByteSize(size_t stringSize) const override;
 

src/lib_cxx/data/indexer/IndexerCxx.h

@@ -11,18 +11,13 @@ template <typename IndexerCommandType, typename ParserType>
 class IndexerCxx: public Indexer<IndexerCommandType>
 {
 public:
-	virtual ~IndexerCxx();
+	virtual ~IndexerCxx() = default;
 
 	virtual std::shared_ptr<IntermediateStorage> doIndex(
 		std::shared_ptr<IndexerCommandType> indexerCommand,
 		std::shared_ptr<FileRegister> fileRegister);
 };
 
-template <typename IndexerCommandType, typename ParserType>
-IndexerCxx<IndexerCommandType, ParserType>::~IndexerCxx()
-{
-}
-
 template <typename IndexerCommandType, typename ParserType>
 std::shared_ptr<IntermediateStorage> IndexerCxx<IndexerCommandType, ParserType>::doIndex(
 	std::shared_ptr<IndexerCommandType> indexerCommand,

src/lib_cxx/data/indexer/IndexerFactoryModuleCxxCdb.cpp

@@ -4,10 +4,6 @@
 #include "data/indexer/IndexerCommandCxxCdb.h"
 #include "data/parser/cxx/CxxParser.h"
 
-IndexerFactoryModuleCxxCdb::~IndexerFactoryModuleCxxCdb()
-{
-}
-
 std::shared_ptr<IndexerBase> IndexerFactoryModuleCxxCdb::createIndexer()
 {
 	return std::make_shared<IndexerCxx<IndexerCommandCxxCdb, CxxParser>>();

src/lib_cxx/data/indexer/IndexerFactoryModuleCxxCdb.h

@@ -6,7 +6,6 @@
 class IndexerFactoryModuleCxxCdb: public IndexerFactoryModule
 {
 public:
-	virtual ~IndexerFactoryModuleCxxCdb();
 	virtual std::shared_ptr<IndexerBase> createIndexer();
 };
 

src/lib_cxx/data/indexer/IndexerFactoryModuleCxxManual.cpp

@@ -4,10 +4,6 @@
 #include "data/indexer/IndexerCommandCxxManual.h"
 #include "data/parser/cxx/CxxParser.h"
 
-IndexerFactoryModuleCxxManual::~IndexerFactoryModuleCxxManual()
-{
-}
-
 std::shared_ptr<IndexerBase> IndexerFactoryModuleCxxManual::createIndexer()
 {
 	return std::make_shared<IndexerCxx<IndexerCommandCxxManual, CxxParser>>();

src/lib_cxx/data/indexer/IndexerFactoryModuleCxxManual.h

@@ -6,7 +6,6 @@
 class IndexerFactoryModuleCxxManual: public IndexerFactoryModule
 {
 public:
-	virtual ~IndexerFactoryModuleCxxManual();
 	virtual std::shared_ptr<IndexerBase> createIndexer();
 };
 

src/lib_cxx/data/parser/cxx/name/CxxDeclName.cpp

@@ -1,23 +1,36 @@
 #include "data/parser/cxx/name/CxxDeclName.h"
 
-CxxDeclName::CxxDeclName(std::string name, std::vector<std::string> templateParameterNames)
-	: m_name(name)
-	, m_templateParameterNames(templateParameterNames)
+//CxxDeclName::CxxDeclName(const std::string& name, const std::vector<std::string>& templateParameterNames)
+//	: m_name(name)
+//	, m_templateParameterNames(templateParameterNames)
+//{
+//}
+
+CxxDeclName::CxxDeclName(std::string&& name, std::vector<std::string>&& templateParameterNames)
+	: m_name(std::move(name))
+	, m_templateParameterNames(std::move(templateParameterNames))
 {
 }
 
+//CxxDeclName::CxxDeclName(
+//	const std::string& name,
+//	const std::vector<std::string>& templateParameterNames,
+//	std::shared_ptr<CxxName> parent
+//)
+//	: CxxName(parent)
+//	, m_name(name)
+//	, m_templateParameterNames(templateParameterNames)
+//{
+//}
+
 CxxDeclName::CxxDeclName(
-	std::string name,
-	std::vector<std::string> templateParameterNames,
+	std::string&& name,
+	std::vector<std::string>&& templateParameterNames,
 	std::shared_ptr<CxxName> parent
 )
 	: CxxName(parent)
-	, m_name(name)
-	, m_templateParameterNames(templateParameterNames)
-{
-}
-
-CxxDeclName::~CxxDeclName()
+	, m_name(std::move(name))
+	, m_templateParameterNames(std::move(templateParameterNames))
 {
 }
 

src/lib_cxx/data/parser/cxx/name/CxxDeclName.h

@@ -11,18 +11,30 @@
 class CxxDeclName: public CxxName
 {
 public:
-	CxxDeclName(
-		std::string name,
-		std::vector<std::string> templateParameterNames
-	);
+	// uncomment this constructor if required, but try to use the one using move constructors for the members
+	//CxxDeclName(
+	//	const std::string& name,
+	//	const std::vector<std::string>& templateParameterNames
+	//);
 
 	CxxDeclName(
-		std::string name,
-		std::vector<std::string> templateParameterNames,
+		std::string&& name,
+		std::vector<std::string>&& templateParameterNames
+	);
+
+	// uncomment this constructor if required, but try to use the one using move constructors for the members
+	//CxxDeclName(
+	//	const std::string& name,
+	//	const std::vector<std::string>& templateParameterNames,
+	//	std::shared_ptr<CxxName> parent
+	//);
+
+	CxxDeclName(
+		std::string&& name,
+		std::vector<std::string>&& templateParameterNames,
 		std::shared_ptr<CxxName> parent
 	);
 
-	virtual ~CxxDeclName();
 	virtual NameHierarchy toNameHierarchy() const;
 
 	std::string getName() const;

src/lib_cxx/data/parser/cxx/name/CxxFunctionDeclName.cpp

@@ -1,42 +1,71 @@
 #include "data/parser/cxx/name/CxxFunctionDeclName.h"
 
+//CxxFunctionDeclName::CxxFunctionDeclName(
+//	const std::string& name,
+//	const std::vector<std::string>& templateParameterNames,
+//	std::shared_ptr<CxxTypeName> returnTypeName,
+//	const std::vector<std::shared_ptr<CxxTypeName>>& parameterTypeNames,
+//	const bool isConst,
+//	const bool isStatic
+//)
+//	: CxxDeclName(name, templateParameterNames)
+//	, m_returnTypeName(returnTypeName)
+//	, m_parameterTypeNames(parameterTypeNames)
+//	, m_isConst(isConst)
+//	, m_isStatic(isStatic)
+//{
+//}
+
 CxxFunctionDeclName::CxxFunctionDeclName(
-	const std::string& name,
-	const std::vector<std::string>& templateParameterNames,
+	std::string&& name,
+	std::vector<std::string>&& templateParameterNames,
 	std::shared_ptr<CxxTypeName> returnTypeName,
-	const std::vector<std::shared_ptr<CxxTypeName>>& parameterTypeNames,
+	std::vector<std::shared_ptr<CxxTypeName>>&& parameterTypeNames,
 	const bool isConst,
 	const bool isStatic
 )
-	: CxxDeclName(name, templateParameterNames)
+	: CxxDeclName(std::move(name), std::move(templateParameterNames))
 	, m_returnTypeName(returnTypeName)
-	, m_parameterTypeNames(parameterTypeNames)
+	, m_parameterTypeNames(std::move(parameterTypeNames))
 	, m_isConst(isConst)
 	, m_isStatic(isStatic)
 {
 }
 
+//CxxFunctionDeclName::CxxFunctionDeclName(
+//	const std::string& name,
+//	const std::vector<std::string>& templateParameterNames,
+//	std::shared_ptr<CxxTypeName> returnTypeName,
+//	const std::vector<std::shared_ptr<CxxTypeName>>& parameterTypeNames,
+//	const bool isConst,
+//	const bool isStatic,
+//	std::shared_ptr<CxxName> parent
+//)
+//	: CxxDeclName(name, templateParameterNames, parent)
+//	, m_returnTypeName(returnTypeName)
+//	, m_parameterTypeNames(parameterTypeNames)
+//	, m_isConst(isConst)
+//	, m_isStatic(isStatic)
+//{
+//}
+
 CxxFunctionDeclName::CxxFunctionDeclName(
-	const std::string& name,
-	const std::vector<std::string>& templateParameterNames,
+	std::string&& name,
+	std::vector<std::string>&& templateParameterNames,
 	std::shared_ptr<CxxTypeName> returnTypeName,
-	const std::vector<std::shared_ptr<CxxTypeName>>& parameterTypeNames,
+	std::vector<std::shared_ptr<CxxTypeName>>&& parameterTypeNames,
 	const bool isConst,
 	const bool isStatic,
 	std::shared_ptr<CxxName> parent
 )
-	: CxxDeclName(name, templateParameterNames, parent)
+	: CxxDeclName(std::move(name), std::move(templateParameterNames), parent)
 	, m_returnTypeName(returnTypeName)
-	, m_parameterTypeNames(parameterTypeNames)
+	, m_parameterTypeNames(std::move(parameterTypeNames))
 	, m_isConst(isConst)
 	, m_isStatic(isStatic)
 {
 }
 
-CxxFunctionDeclName::~CxxFunctionDeclName()
-{
-}
-
 NameHierarchy CxxFunctionDeclName::toNameHierarchy() const
 {
 	std::string signaturePrefix;

src/lib_cxx/data/parser/cxx/name/CxxFunctionDeclName.h

@@ -10,27 +10,46 @@
 class CxxFunctionDeclName: public CxxDeclName
 {
 public:
+	// uncomment this constructor if required, but try to use the one using move constructors for the members
+	//CxxFunctionDeclName(
+	//	const std::string& name,
+	//	const std::vector<std::string>& templateParameterNames,
+	//	std::shared_ptr<CxxTypeName> returnTypeName,
+	//	const std::vector<std::shared_ptr<CxxTypeName>>& parameterTypeNames,
+	//	const bool isConst,
+	//	const bool isStatic
+	//);
+
 	CxxFunctionDeclName(
-		const std::string& name,
-		const std::vector<std::string>& templateParameterNames,
+		std::string&& name,
+		std::vector<std::string>&& templateParameterNames,
 		std::shared_ptr<CxxTypeName> returnTypeName,
-		const std::vector<std::shared_ptr<CxxTypeName>>& parameterTypeNames,
+		std::vector<std::shared_ptr<CxxTypeName>>&& parameterTypeNames,
 		const bool isConst,
 		const bool isStatic
 	);
 
+	// uncomment this constructor if required, but try to use the one using move constructors for the members
+	//CxxFunctionDeclName(
+	//	const std::string& name,
+	//	const std::vector<std::string>& templateParameterNames,
+	//	std::shared_ptr<CxxTypeName> returnTypeName,
+	//	const std::vector<std::shared_ptr<CxxTypeName>>& parameterTypeNames,
+	//	const bool isConst,
+	//	const bool isStatic,
+	//	std::shared_ptr<CxxName> parent
+	//);
+
 	CxxFunctionDeclName(
-		const std::string& name,
-		const std::vector<std::string>& templateParameterNames,
+		std::string&& name,
+		std::vector<std::string>&& templateParameterNames,
 		std::shared_ptr<CxxTypeName> returnTypeName,
-		const std::vector<std::shared_ptr<CxxTypeName>>& parameterTypeNames,
+		std::vector<std::shared_ptr<CxxTypeName>>&& parameterTypeNames,
 		const bool isConst,
 		const bool isStatic,
 		std::shared_ptr<CxxName> parent
 	);
 
-	virtual ~CxxFunctionDeclName();
-
 	virtual NameHierarchy toNameHierarchy() const;
 
 private:

src/lib_cxx/data/parser/cxx/name/CxxName.cpp

@@ -9,10 +9,6 @@ CxxName::CxxName(std::shared_ptr<CxxName> parent)
 {
 }
 
-CxxName::~CxxName()
-{
-}
-
 void CxxName::setParent(std::shared_ptr<CxxName> parent)
 {
 	m_parent = parent;

src/lib_cxx/data/parser/cxx/name/CxxName.h

@@ -13,7 +13,7 @@ public:
 	CxxName();
 	CxxName(std::shared_ptr<CxxName> parent);
 
-	virtual ~CxxName();
+	virtual ~CxxName() = default;
 
 	void setParent(std::shared_ptr<CxxName> parent);
 	std::shared_ptr<CxxName> getParent() const;

src/lib_cxx/data/parser/cxx/name/CxxStaticFunctionDeclName.cpp

@@ -1,31 +1,52 @@
 #include "data/parser/cxx/name/CxxStaticFunctionDeclName.h"
 
+//CxxStaticFunctionDeclName::CxxStaticFunctionDeclName(
+//	const std::string& name,
+//	const std::vector<std::string>& templateParameterNames,
+//	std::shared_ptr<CxxTypeName> returnTypeName,
+//	const std::vector<std::shared_ptr<CxxTypeName>>& parameterTypeNames,
+//	const std::string& translationUnitFileName
+//)
+//	: CxxFunctionDeclName(name, templateParameterNames, returnTypeName, parameterTypeNames, false, true)
+//	, m_translationUnitFileName(translationUnitFileName)
+//{
+//}
+
 CxxStaticFunctionDeclName::CxxStaticFunctionDeclName(
-	const std::string& name,
-	const std::vector<std::string>& templateParameterNames,
+	std::string&& name,
+	std::vector<std::string>&& templateParameterNames,
 	std::shared_ptr<CxxTypeName> returnTypeName,
-	const std::vector<std::shared_ptr<CxxTypeName>>& parameterTypeNames,
-	const std::string& translationUnitFileName
+	std::vector<std::shared_ptr<CxxTypeName>>&& parameterTypeNames,
+	std::string&& translationUnitFileName
 )
-	: CxxFunctionDeclName(name, templateParameterNames, returnTypeName, parameterTypeNames, false, true)
-	, m_translationUnitFileName(translationUnitFileName)
+	: CxxFunctionDeclName(std::move(name), std::move(templateParameterNames), returnTypeName, std::move(parameterTypeNames), false, true)
+	, m_translationUnitFileName(std::move(translationUnitFileName))
 {
 }
 
+//CxxStaticFunctionDeclName::CxxStaticFunctionDeclName(
+//	const std::string& name,
+//	const std::vector<std::string>& templateParameterNames,
+//	std::shared_ptr<CxxTypeName> returnTypeName,
+//	const std::vector<std::shared_ptr<CxxTypeName>>& parameterTypeNames,
+//	const std::string& translationUnitFileName,
+//	std::shared_ptr<CxxName> parent
+//)
+//	: CxxFunctionDeclName(name, templateParameterNames, returnTypeName, parameterTypeNames, false, true, parent)
+//	, m_translationUnitFileName(translationUnitFileName)
+//{
+//}
+
 CxxStaticFunctionDeclName::CxxStaticFunctionDeclName(
-	const std::string& name,
-	const std::vector<std::string>& templateParameterNames,
+	std::string&& name,
+	std::vector<std::string>&& templateParameterNames,
 	std::shared_ptr<CxxTypeName> returnTypeName,
-	const std::vector<std::shared_ptr<CxxTypeName>>& parameterTypeNames,
-	const std::string& translationUnitFileName,
+	std::vector<std::shared_ptr<CxxTypeName>>&& parameterTypeNames,
+	std::string&& translationUnitFileName,
 	std::shared_ptr<CxxName> parent
 )
-	: CxxFunctionDeclName(name, templateParameterNames, returnTypeName, parameterTypeNames, false, true, parent)
-	, m_translationUnitFileName(translationUnitFileName)
-{
-}
-
-CxxStaticFunctionDeclName::~CxxStaticFunctionDeclName()
+	: CxxFunctionDeclName(std::move(name), std::move(templateParameterNames), returnTypeName, std::move(parameterTypeNames), false, true, parent)
+	, m_translationUnitFileName(std::move(translationUnitFileName))
 {
 }
 

src/lib_cxx/data/parser/cxx/name/CxxStaticFunctionDeclName.h

@@ -6,25 +6,42 @@
 class CxxStaticFunctionDeclName: public CxxFunctionDeclName
 {
 public:
-	CxxStaticFunctionDeclName(
-		const std::string& name,
-		const std::vector<std::string>& templateParameterNames,
-		std::shared_ptr<CxxTypeName> returnTypeName,
-		const std::vector<std::shared_ptr<CxxTypeName>>& parameterTypeNames,
-		const std::string& translationUnitFileName
-	);
+	// uncomment this constructor if required, but try to use the one using move constructors for the members
+	//CxxStaticFunctionDeclName(
+	//	const std::string& name,
+	//	const std::vector<std::string>& templateParameterNames,
+	//	std::shared_ptr<CxxTypeName> returnTypeName,
+	//	const std::vector<std::shared_ptr<CxxTypeName>>& parameterTypeNames,
+	//	const std::string& translationUnitFileName
+	//);
 
 	CxxStaticFunctionDeclName(
-		const std::string& name,
-		const std::vector<std::string>& templateParameterNames,
+		std::string&& name,
+		std::vector<std::string>&& templateParameterNames,
 		std::shared_ptr<CxxTypeName> returnTypeName,
-		const std::vector<std::shared_ptr<CxxTypeName>>& parameterTypeNames,
-		const std::string& translationUnitFileName,
+		std::vector<std::shared_ptr<CxxTypeName>>&& parameterTypeNames,
+		std::string&& translationUnitFileName
+	);
+
+	// uncomment this constructor if required, but try to use the one using move constructors for the members
+	//CxxStaticFunctionDeclName(
+	//	const std::string& name,
+	//	const std::vector<std::string>& templateParameterNames,
+	//	std::shared_ptr<CxxTypeName> returnTypeName,
+	//	const std::vector<std::shared_ptr<CxxTypeName>>& parameterTypeNames,
+	//	const std::string& translationUnitFileName,
+	//	std::shared_ptr<CxxName> parent
+	//);
+
+	CxxStaticFunctionDeclName(
+		std::string&& name,
+		std::vector<std::string>&& templateParameterNames,
+		std::shared_ptr<CxxTypeName> returnTypeName,
+		std::vector<std::shared_ptr<CxxTypeName>>&& parameterTypeNames,
+		std::string&& translationUnitFileName,
 		std::shared_ptr<CxxName> parent
 	);
 
-	virtual ~CxxStaticFunctionDeclName();
-
 	virtual NameHierarchy toNameHierarchy() const;
 
 private:

src/lib_cxx/data/parser/cxx/name/CxxTypeName.cpp

@@ -11,29 +11,42 @@ std::shared_ptr<CxxTypeName> CxxTypeName::makeUnsolvedIfNull(std::shared_ptr<Cxx
 	);
 }
 
-CxxTypeName::Modifier::Modifier(std::string symbol)
-	: symbol(symbol)
+CxxTypeName::Modifier::Modifier(std::string&& symbol)
+	: symbol(std::move(symbol))
 {
 }
 
-CxxTypeName::CxxTypeName(std::string name, std::vector<std::string> templateArguments)
-	: m_name(name)
-	, m_templateArguments(templateArguments)
+//CxxTypeName::CxxTypeName(const std::string& name, const std::vector<std::string>& templateArguments)
+//	: m_name(name)
+//	, m_templateArguments(templateArguments)
+//{
+//}
+
+CxxTypeName::CxxTypeName(std::string&& name, std::vector<std::string>&& templateArguments)
+	: m_name(std::move(name))
+	, m_templateArguments(std::move(templateArguments))
 {
 }
 
+//CxxTypeName::CxxTypeName(
+//	const std::string& name,
+//	const std::vector<std::string>& templateArguments,
+//	std::shared_ptr<CxxName> parent
+//)
+//	: CxxName(parent)
+//	, m_name(name)
+//	, m_templateArguments(templateArguments)
+//{
+//}
+
 CxxTypeName::CxxTypeName(
-	std::string name,
-	std::vector<std::string> templateArguments,
+	std::string&& name,
+	std::vector<std::string>&& templateArguments,
 	std::shared_ptr<CxxName> parent
 )
 	: CxxName(parent)
-	, m_name(name)
-	, m_templateArguments(templateArguments)
-{
-}
-
-CxxTypeName::~CxxTypeName()
+	, m_name(std::move(name))
+	, m_templateArguments(std::move(templateArguments))
 {
 }
 

src/lib_cxx/data/parser/cxx/name/CxxTypeName.h

@@ -16,23 +16,35 @@ public:
 
 	struct Modifier
 	{
-		Modifier(std::string symbol);
+		Modifier(std::string&& symbol);
 		std::string symbol;
 		CxxQualifierFlags qualifierFlags;
 	};
 
-	CxxTypeName(
-		std::string name,
-		std::vector<std::string> templateArguments
-	);
+	// uncomment this constructor if required, but try to use the one using move constructors for the members
+	//CxxTypeName(
+	//	const std::string& name,
+	//	const std::vector<std::string>& templateArguments
+	//);
 
 	CxxTypeName(
-		std::string name,
-		std::vector<std::string> templateArguments,
+		std::string&& name,
+		std::vector<std::string>&& templateArguments
+	);
+
+	// uncomment this constructor if required, but try to use the one using move constructors for the members
+	//CxxTypeName(
+	//	const std::string& name,
+	//	const std::vector<std::string>& templateArguments,
+	//	std::shared_ptr<CxxName> parent
+	//);
+
+	CxxTypeName(
+		std::string&& name,
+		std::vector<std::string>&& templateArguments,
 		std::shared_ptr<CxxName> parent
 	);
 
-	virtual ~CxxTypeName();
 	virtual NameHierarchy toNameHierarchy() const;
 
 	void addQualifier(const CxxQualifierFlags::QualifierType qualifier);

src/lib_cxx/data/parser/cxx/name/CxxVariableDeclName.cpp

@@ -1,34 +1,55 @@
 #include "data/parser/cxx/name/CxxVariableDeclName.h"
 
+//CxxVariableDeclName::CxxVariableDeclName(
+//	const std::string& name,
+//	const std::vector<std::string>& templateParameterNames,
+//	std::shared_ptr<CxxTypeName> typeName,
+//	bool isStatic
+//)
+//	: CxxDeclName(name, templateParameterNames)
+//	, m_typeName(typeName)
+//	, m_isStatic(isStatic)
+//{
+//}
+
 CxxVariableDeclName::CxxVariableDeclName(
-	std::string name,
-	std::vector<std::string> templateParameterNames,
+	std::string&& name,
+	std::vector<std::string>&& templateParameterNames,
 	std::shared_ptr<CxxTypeName> typeName,
 	bool isStatic
 )
-	: CxxDeclName(name, templateParameterNames)
+	: CxxDeclName(std::move(name), std::move(templateParameterNames))
 	, m_typeName(typeName)
 	, m_isStatic(isStatic)
 {
 }
 
+//CxxVariableDeclName::CxxVariableDeclName(
+//	const std::string& name,
+//	const std::vector<std::string>& templateParameterNames,
+//	std::shared_ptr<CxxTypeName> typeName,
+//	bool isStatic,
+//	std::shared_ptr<CxxName> parent
+//)
+//	: CxxDeclName(name, templateParameterNames, parent)
+//	, m_typeName(typeName)
+//	, m_isStatic(isStatic)
+//{
+//}
+
 CxxVariableDeclName::CxxVariableDeclName(
-	std::string name,
-	std::vector<std::string> templateParameterNames,
+	std::string&& name,
+	std::vector<std::string>&& templateParameterNames,
 	std::shared_ptr<CxxTypeName> typeName,
 	bool isStatic,
 	std::shared_ptr<CxxName> parent
 )
-	: CxxDeclName(name, templateParameterNames, parent)
+	: CxxDeclName(std::move(name), std::move(templateParameterNames), parent)
 	, m_typeName(typeName)
 	, m_isStatic(isStatic)
 {
 }
 
-CxxVariableDeclName::~CxxVariableDeclName()
-{
-}
-
 NameHierarchy CxxVariableDeclName::toNameHierarchy() const
 {
 	std::string signaturePrefix;

src/lib_cxx/data/parser/cxx/name/CxxVariableDeclName.h

@@ -10,23 +10,38 @@
 class CxxVariableDeclName: public CxxDeclName
 {
 public:
+	// uncomment this constructor if required, but try to use the one using move constructors for the members
+	//CxxVariableDeclName(
+	//	const std::string& name,
+	//	const std::vector<std::string>& templateParameterNames,
+	//	std::shared_ptr<CxxTypeName> typeName,
+	//	bool isStatic
+	//);
+
 	CxxVariableDeclName(
-		std::string name,
-		std::vector<std::string> templateParameterNames,
+		std::string&& name,
+		std::vector<std::string>&& templateParameterNames,
 		std::shared_ptr<CxxTypeName> typeName,
 		bool isStatic
 	);
 
+	// uncomment this constructor if required, but try to use the one using move constructors for the members
+	//CxxVariableDeclName(
+	//	const std::string& name,
+	//	const std::vector<std::string>& templateParameterNames,
+	//	std::shared_ptr<CxxTypeName> typeName,
+	//	bool isStatic,
+	//	std::shared_ptr<CxxName> parent
+	//);
+
 	CxxVariableDeclName(
-		std::string name,
-		std::vector<std::string> templateParameterNames,
+		std::string&& name,
+		std::vector<std::string>&& templateParameterNames,
 		std::shared_ptr<CxxTypeName> typeName,
 		bool isStatic,
 		std::shared_ptr<CxxName> parent
 	);
 
-	virtual ~CxxVariableDeclName();
-
 	virtual NameHierarchy toNameHierarchy() const;
 
 private:

src/lib_cxx/data/parser/cxx/name_resolver/CxxDeclNameResolver.cpp

@@ -217,10 +217,12 @@ std::shared_ptr<CxxDeclName> CxxDeclNameResolver::getDeclName(const clang::Named
 				}
 				else if (clang::isa<clang::ClassTemplatePartialSpecializationDecl>(declaration))
 				{
-					const std::vector<std::string> templateParameterNames = getTemplateParameterStringsOfPatrialSpecialitarion(
-						clang::dyn_cast<clang::ClassTemplatePartialSpecializationDecl>(declaration)
+					return std::make_shared<CxxDeclName>(
+						std::move(declNameString), 
+						getTemplateParameterStringsOfPatrialSpecialitarion(
+							clang::dyn_cast<clang::ClassTemplatePartialSpecializationDecl>(declaration)
+						)
 					);
-					return std::make_shared<CxxDeclName>(declNameString, templateParameterNames);
 				}
 				else if (clang::isa<clang::ClassTemplateSpecializationDecl>(declaration))
 				{
@@ -230,7 +232,7 @@ std::shared_ptr<CxxDeclName> CxxDeclNameResolver::getDeclName(const clang::Named
 					{
 						templateArguments.push_back(getTemplateArgumentName(templateArgumentList.get(i)));
 					}
-					return std::make_shared<CxxDeclName>(declNameString, templateArguments);
+					return std::make_shared<CxxDeclName>(std::move(declNameString), std::move(templateArguments));
 				}
 			}
 		}
@@ -289,19 +291,19 @@ std::shared_ptr<CxxDeclName> CxxDeclNameResolver::getDeclName(const clang::Named
 			if (!clang::isa<clang::CXXMethodDecl>(declaration) && isStatic)
 			{
 				return std::make_shared<CxxStaticFunctionDeclName>(
-					functionName,
-					templateArguments,
+					std::move(functionName),
+					std::move(templateArguments),
 					returnTypeName,
-					parameterTypeNames,
+					std::move(parameterTypeNames),
 					getTranslationUnitMainFileName(declaration)
 				);
 			}
 
 			return std::make_shared<CxxFunctionDeclName>(
-				functionName,
-				templateArguments,
+				std::move(functionName),
+				std::move(templateArguments),
 				returnTypeName,
-				parameterTypeNames,
+				std::move(parameterTypeNames),
 				isConst,
 				isStatic
 			);
@@ -317,7 +319,7 @@ std::shared_ptr<CxxDeclName> CxxDeclNameResolver::getDeclName(const clang::Named
 			CxxTypeNameResolver typenNameResolver(getCanonicalFilePathCache(), getIgnoredContextDecls());
 			typenNameResolver.ignoreContextDecl(fieldDecl);
 			std::shared_ptr<CxxTypeName> typeName = CxxTypeName::makeUnsolvedIfNull(typenNameResolver.getName(fieldDecl->getType()));
-			return std::make_shared<CxxVariableDeclName>(declNameString, std::vector<std::string>(), typeName, false);
+			return std::make_shared<CxxVariableDeclName>(std::move(declNameString), std::vector<std::string>(), typeName, false);
 		}
 		else if (clang::isa<clang::NamespaceDecl>(declaration) && clang::dyn_cast<clang::NamespaceDecl>(declaration)->isAnonymousNamespace())
 		{
@@ -406,7 +408,7 @@ std::shared_ptr<CxxDeclName> CxxDeclNameResolver::getDeclName(const clang::Named
 					}
 				}
 
-				return std::make_shared<CxxVariableDeclName>(varName, templateParameterNames, typeName, isStatic);
+				return std::make_shared<CxxVariableDeclName>(std::move(varName), std::move(templateParameterNames), typeName, isStatic);
 			}
 		}
 		else if (clang::isa<clang::VarTemplateDecl>(declaration))
@@ -416,12 +418,12 @@ std::shared_ptr<CxxDeclName> CxxDeclNameResolver::getDeclName(const clang::Named
 		}
 		else if (clang::isa<clang::TemplateDecl>(declaration)) // also triggers on TemplateTemplateParmDecl
 		{
-			return std::make_shared<CxxDeclName>(declNameString, getTemplateParameterStrings(clang::dyn_cast<clang::TemplateDecl>(declaration)));
+			return std::make_shared<CxxDeclName>(std::move(declNameString), getTemplateParameterStrings(clang::dyn_cast<clang::TemplateDecl>(declaration)));
 		}
 
 		if (!declNameString.empty())
 		{
-			return std::make_shared<CxxDeclName>(declNameString, std::vector<std::string>(), std::shared_ptr<CxxName>());
+			return std::make_shared<CxxDeclName>(std::move(declNameString), std::vector<std::string>(), std::shared_ptr<CxxName>());
 		}
 	}
 

src/lib_cxx/data/parser/cxx/name_resolver/CxxTypeNameResolver.cpp

@@ -178,7 +178,7 @@ std::shared_ptr<CxxTypeName> CxxTypeNameResolver::getName(const clang::Type* typ
 
 						typeName = std::make_shared<CxxTypeName>(
 							declName->getName(),
-							templateArguments,
+							std::move(templateArguments),
 							declName->getParent()
 						);
 					}
@@ -235,7 +235,7 @@ std::shared_ptr<CxxTypeName> CxxTypeNameResolver::getName(const clang::Type* typ
 				}
 
 				typeName = std::make_shared<CxxTypeName>(
-					dependentType->getIdentifier()->getName().str(), templateArguments, specifierName
+					dependentType->getIdentifier()->getName().str(), std::move(templateArguments), specifierName
 				);
 				break;
 			}
@@ -280,7 +280,7 @@ std::shared_ptr<CxxTypeName> CxxTypeNameResolver::getName(const clang::Type* typ
 				nameString += ")";
 
 				typeName = std::make_shared<CxxTypeName>(
-					nameString, std::vector<std::string>()
+					std::move(nameString), std::vector<std::string>()
 				);
 				break;
 			}
@@ -304,7 +304,7 @@ std::shared_ptr<CxxTypeName> CxxTypeNameResolver::getName(const clang::Type* typ
 				std::string nameString = StrOS.str();
 
 				typeName = std::make_shared<CxxTypeName>(
-					nameString, std::vector<std::string>()
+					std::move(nameString), std::vector<std::string>()
 				);
 				break;
 			}