ui/data: cleaned up UI and parsing

* HOT FIX: typename not always correctly split to name hierarchy
* show node main if available as first active token after parsing
* show all contents of namespaces if searched for
* added missing enum type and enum value usages
* added inheritance for structs
* removed MessageActivateToken and replaced it with MessageActivateTokens
* activating correct nodes for clicks in GraphView and CodeView
* no graph change when clicking an edge, but highlighting the edge instead
* only show active nodes without connections when multiple are activated
* fixed snippet sorting to put file that contains declarations on top
* set sizeHints on CodeView and SearchView to increase their initial size

fortune cookie message = Das Leben wird eine positive Wendung nehmen.

src/lib/data/Storage.cpp

@@ -278,10 +278,11 @@ Id Storage::onCallParsed(const ParseLocation& location, const ParseVariable& cal
 	return edge->getId();
 }
 
-Id Storage::onFieldUsageParsed(
-	const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy)
-{
-	log("field usage", user.getFullName() + " -> " + utility::join(usedNameHierarchy, "::"), location);
+Id Storage::onVariableUsageParsed(
+	const std::string kind, const ParseLocation& location, const ParseFunction& user,
+	const std::vector<std::string>& usedNameHierarchy
+){
+	log(kind, user.getFullName() + " -> " + utility::join(usedNameHierarchy, "::"), location);
 
 	Node* userNode = addNodeHierarchyWithDistinctSignature(Node::NODE_UNDEFINED_FUNCTION, user);
 	Node* usedNode = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, usedNameHierarchy);
@@ -292,12 +293,30 @@ Id Storage::onFieldUsageParsed(
 	return edge->getId();
 }
 
+Id Storage::onFieldUsageParsed(
+	const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy
+){
+	return onVariableUsageParsed("field usage", location, user, usedNameHierarchy);
+}
+
 Id Storage::onGlobalVariableUsageParsed( // or static variable used
+	const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy
+){
+	return onVariableUsageParsed("global usage", location, user, usedNameHierarchy);
+}
+
+Id Storage::onEnumFieldUsageParsed(
 		const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy
 ){
-	log("global usage", user.getFullName() + " -> " + utility::join(usedNameHierarchy, "::"), location);
+	return onVariableUsageParsed("enum field usage", location, user, usedNameHierarchy);
+}
 
-	Node* userNode = addNodeHierarchyWithDistinctSignature(Node::NODE_UNDEFINED_FUNCTION, user);
+Id Storage::onEnumFieldUsageParsed(
+		const ParseLocation& location, const ParseVariable& user, const std::vector<std::string>& usedNameHierarchy
+){
+	log("enum field usage", user.getFullName() + " -> " + utility::join(usedNameHierarchy, "::"), location);
+
+	Node* userNode = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, user.nameHierarchy);
 	Node* usedNode = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, usedNameHierarchy);
 
 	Edge* edge = m_graph.createEdge(Edge::EDGE_USAGE, userNode, usedNode);
@@ -322,6 +341,22 @@ Id Storage::onTypeUsageParsed(const ParseTypeUsage& type, const ParseFunction& f
 	return edge->getId();
 }
 
+Id Storage::onTypeUsageParsed(const ParseTypeUsage& type, const ParseVariable& variable)
+{
+	log("type usage", variable.getFullName() + " -> " + type.dataType.getRawTypeName(), type.location);
+
+	Node* variableNode = addNodeHierarchy(Node::NODE_UNDEFINED, variable.nameHierarchy);
+	Edge* edge = addTypeEdge(variableNode, Edge::EDGE_TYPE_USAGE, type);
+
+	if (!edge)
+	{
+		LOG_ERROR("Could not create type usage edge.");
+		return 0;
+	}
+
+	return edge->getId();
+}
+
 Id Storage::onTemplateRecordParameterTypeParsed(
 	const ParseLocation& location, const std::string& templateParameterTypeName,
 	const std::vector<std::string>& templateRecordNameHierarchy
@@ -466,13 +501,41 @@ std::shared_ptr<Graph> Storage::getGraphForActiveTokenIds(const std::vector<Id>&
 {
 	std::shared_ptr<Graph> graph = std::make_shared<Graph>();
 
-	for (Id tokenId : tokenIds)
+	if (!tokenIds.size())
 	{
-		Token* token = m_graph.getTokenById(tokenId);
+		return graph;
+	}
+
+	if (tokenIds.size() > 1)
+	{
+		for (Id tokenId : tokenIds)
+		{
+			Token* token = m_graph.getTokenById(tokenId);
+			if (!token)
+			{
+				LOG_ERROR_STREAM(<< "Token with id " << tokenId << " was not found");
+				continue;
+			}
+
+			if (token->isNode())
+			{
+				Node* node = dynamic_cast<Node*>(token);
+				graph->addNodeAndAllChildrenAsPlainCopy(node->getLastParentNode());
+			}
+			else
+			{
+				Edge* edge = dynamic_cast<Edge*>(token);
+				graph->addEdgeAndAllChildrenAsPlainCopy(edge);
+			}
+		}
+	}
+	else if (tokenIds.size() == 1)
+	{
+		Token* token = m_graph.getTokenById(tokenIds[0]);
 		if (!token)
 		{
-			LOG_ERROR_STREAM(<< "Token with id " << tokenId << " was not found");
-			continue;
+			LOG_ERROR_STREAM(<< "Token with id " << tokenIds[0] << " was not found");
+			return graph;
 		}
 
 		if (token->isNode())
@@ -504,9 +567,10 @@ std::shared_ptr<Graph> Storage::getGraphForActiveTokenIds(const std::vector<Id>&
 	return graph;
 }
 
-std::vector<Id> Storage::getActiveTokenIdsForId(Id tokenId, Id& declarationId) const
+std::vector<Id> Storage::getActiveTokenIdsForId(Id tokenId, Id* declarationId) const
 {
 	std::vector<Id> ret;
+
 	Token* token = m_graph.getTokenById(tokenId);
 	if (!token)
 	{
@@ -516,30 +580,52 @@ std::vector<Id> Storage::getActiveTokenIdsForId(Id tokenId, Id& declarationId) c
 	ret.push_back(token->getId());
 
 	Node* node;
-	if (token->isEdge())
+	if (token->isNode())
 	{
-		node = dynamic_cast<Edge*>(token)->getTo();
-		declarationId = node->getId();
+		Node* node = dynamic_cast<Node*>(token);
+		*declarationId = node->getId();
+
+		node->forEachEdge(
+			[&node, &ret](Edge* edge)
+			{
+				if (edge->getTo() == node)
+				{
+					ret.push_back(edge->getId());
+				}
+			}
+		);
+	}
+
+	return ret;
+}
+
+std::vector<Id> Storage::getActiveTokenIdsForLocationId(Id locationId) const
+{
+	std::vector<Id> ret;
+
+	TokenLocation* location = m_locationCollection.findTokenLocationById(locationId);
+	if (!location)
+	{
+		return ret;
+	}
+
+	Token* token = m_graph.getTokenById(location->getTokenId());
+	if (!token)
+	{
+		return ret;
+	}
+
+	if (token->isNode())
+	{
+		Node* node = dynamic_cast<Node*>(token);
 		ret.push_back(node->getId());
 	}
 	else
 	{
-		node = dynamic_cast<Node*>(token);
-		declarationId = node->getId();
+		Edge* edge = dynamic_cast<Edge*>(token);
+		ret.push_back(edge->getTo()->getId());
 	}
 
-	//ret.push_back(node->getId());
-
-	node->forEachEdge(
-		[&node, &ret](Edge* e)
-		{
-			if (e->getTo() == node)
-			{
-				ret.push_back(e->getId());
-			}
-		}
-	);
-
 	return ret;
 }
 
@@ -770,7 +856,15 @@ Edge* Storage::addTypeEdge(Node* node, Edge::EdgeType edgeType, const ParseTypeU
 		return nullptr;
 	}
 
-	Node* typeNode = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, typeUsage.dataType.getTypeNameHierarchy());
+	// FIXME: For some reason the TypeNameHierarchy is not always split up properly by the Parser. This might happen
+	// when a Type declaration is in a different file than it's usage, but this oberservation is not reliable.
+	std::vector<std::string> nameHierarchy = typeUsage.dataType.getTypeNameHierarchy();
+	if (nameHierarchy.size() == 1 && nameHierarchy[0].find('<') == std::string::npos)
+	{
+		nameHierarchy = utility::splitToVector(nameHierarchy[0], "::");
+	}
+
+	Node* typeNode = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, nameHierarchy);
 	if (!typeNode)
 	{
 		return nullptr;

src/lib/data/Storage.h

@@ -62,11 +62,19 @@ public:
 		const ParseLocation& location, const ParseFunction& caller, const ParseFunction& callee);
 	virtual Id onCallParsed(
 		const ParseLocation& location, const ParseVariable& caller, const ParseFunction& callee);
+	Id onVariableUsageParsed(
+		const std::string kind, const ParseLocation& location, const ParseFunction& user,
+		const std::vector<std::string>& usedNameHierarchy); // helper
 	virtual Id onFieldUsageParsed(
 		const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy);
 	virtual Id onGlobalVariableUsageParsed(
 		const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy);
+	virtual Id onEnumFieldUsageParsed(
+		const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy);
+	virtual Id onEnumFieldUsageParsed(
+		const ParseLocation& location, const ParseVariable& user, const std::vector<std::string>& usedNameHierarchy);
 	virtual Id onTypeUsageParsed(const ParseTypeUsage& type, const ParseFunction& function);
+	virtual Id onTypeUsageParsed(const ParseTypeUsage& type, const ParseVariable& variable);
 
 	virtual Id onTemplateRecordParameterTypeParsed(
 		const ParseLocation& location, const std::string& templateParameterTypeName,
@@ -87,7 +95,8 @@ public:
 
 	virtual std::shared_ptr<Graph> getGraphForActiveTokenIds(const std::vector<Id>& tokenIds) const;
 
-	virtual std::vector<Id> getActiveTokenIdsForId(Id tokenId, Id& declarationId) const;
+	virtual std::vector<Id> getActiveTokenIdsForId(Id tokenId, Id* declarationId) const;
+	virtual std::vector<Id> getActiveTokenIdsForLocationId(Id locationId) const;
 	virtual std::vector<Id> getLocationIdsForTokenIds(const std::vector<Id>& tokenIds) const;
 
 	virtual std::vector<Id> getTokenIdsForQuery(std::string query) const;
@@ -105,8 +114,8 @@ protected:
 	const SearchIndex& getSearchIndex() const;
 
 private:
-	Node* addNodeHierarchy(Node::NodeType type, std::vector<std::string> nameHierarchy);
 
+	Node* addNodeHierarchy(Node::NodeType type, std::vector<std::string> nameHierarchy);
 	Node* addNodeHierarchyWithDistinctSignature(Node::NodeType type, const ParseFunction& function);
 
 	TokenComponentAccess::AccessType convertAccessType(ParserClient::AccessType access) const;

src/lib/data/access/GraphAccess.h

@@ -21,7 +21,8 @@ public:
 
 	virtual std::shared_ptr<Graph> getGraphForActiveTokenIds(const std::vector<Id>& tokenIds) const = 0;
 
-	virtual std::vector<Id> getActiveTokenIdsForId(Id tokenId, Id& declarationId) const = 0;
+	virtual std::vector<Id> getActiveTokenIdsForId(Id tokenId, Id* declarationId) const = 0;
+	virtual std::vector<Id> getActiveTokenIdsForLocationId(Id locationId) const = 0;
 	virtual std::vector<Id> getLocationIdsForTokenIds(const std::vector<Id>& tokenIds) const = 0;
 
 	virtual std::vector<Id> getTokenIdsForQuery(std::string query) const = 0;

src/lib/data/access/GraphAccessProxy.cpp

@@ -69,7 +69,7 @@ std::shared_ptr<Graph> GraphAccessProxy::getGraphForActiveTokenIds(const std::ve
 	return std::make_shared<Graph>();
 }
 
-std::vector<Id> GraphAccessProxy::getActiveTokenIdsForId(Id tokenId, Id& delcarationId) const
+std::vector<Id> GraphAccessProxy::getActiveTokenIdsForId(Id tokenId, Id* delcarationId) const
 {
 	if (hasSubject())
 	{
@@ -79,6 +79,16 @@ std::vector<Id> GraphAccessProxy::getActiveTokenIdsForId(Id tokenId, Id& delcara
 	return std::vector<Id>();
 }
 
+std::vector<Id> GraphAccessProxy::getActiveTokenIdsForLocationId(Id locationId) const
+{
+	if (hasSubject())
+	{
+		return m_subject->getActiveTokenIdsForLocationId(locationId);
+	}
+
+	return std::vector<Id>();
+}
+
 std::vector<Id> GraphAccessProxy::getLocationIdsForTokenIds(const std::vector<Id>& tokenIds) const
 {
 	if (hasSubject())

src/lib/data/access/GraphAccessProxy.h

@@ -20,7 +20,8 @@ public:
 
 	virtual std::shared_ptr<Graph> getGraphForActiveTokenIds(const std::vector<Id>& tokenIds) const;
 
-	virtual std::vector<Id> getActiveTokenIdsForId(Id tokenId, Id& declarationId) const;
+	virtual std::vector<Id> getActiveTokenIdsForId(Id tokenId, Id* declarationId) const;
+	virtual std::vector<Id> getActiveTokenIdsForLocationId(Id locationId) const;
 	virtual std::vector<Id> getLocationIdsForTokenIds(const std::vector<Id>& tokenIds) const;
 
 	virtual std::vector<Id> getTokenIdsForQuery(std::string query) const;

src/lib/data/parser/ParserClient.h

@@ -88,7 +88,12 @@ public:
 		const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy) = 0;
 	virtual Id onGlobalVariableUsageParsed(
 		const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy) = 0;
+	virtual Id onEnumFieldUsageParsed(
+		const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy) = 0;
+	virtual Id onEnumFieldUsageParsed(
+		const ParseLocation& location, const ParseVariable& user, const std::vector<std::string>& usedNameHierarchy) = 0;
 	virtual Id onTypeUsageParsed(const ParseTypeUsage& type, const ParseFunction& function) = 0;
+	virtual Id onTypeUsageParsed(const ParseTypeUsage& type, const ParseVariable& variable) = 0;
 
 	virtual Id onTemplateRecordParameterTypeParsed(
 		const ParseLocation& location, const std::string& templateParameterTypeName,

src/lib/data/parser/cxx/ASTBodyVisitor.cpp

@@ -62,6 +62,20 @@ void ASTBodyVisitor::VisitCXXConstructExpr(clang::CXXConstructExpr* expr)
 	VisitStmt(expr);
 }
 
+void ASTBodyVisitor::VisitCXXNewExpr(clang::CXXNewExpr* expr)
+{
+	if (m_functionDecl)
+	{
+		m_client->VisitCXXNewExprInDeclBody(m_functionDecl, expr);
+	}
+	else
+	{
+		m_client->VisitCXXNewExprInDeclBody(m_varDecl, expr);
+	}
+
+	VisitStmt(expr);
+}
+
 void ASTBodyVisitor::VisitMemberExpr(clang::make_ptr<clang::MemberExpr>::type expr)
 {
 	if (expr->getMemberDecl()->getKind() == clang::Decl::Kind::Field)
@@ -75,7 +89,18 @@ void ASTBodyVisitor::VisitDeclRefExpr(clang::make_ptr<clang::DeclRefExpr>::type
 {
 	if (expr->getDecl()->getKind() == clang::Decl::Var && expr->getDecl()->isDefinedOutsideFunctionOrMethod())
 	{
-		m_client->VisitDeclRefExprInDeclBody(m_functionDecl, expr);
+		m_client->VisitGlobalVariableExprInDeclBody(m_functionDecl, expr);
+	}
+	else if (expr->getDecl()->getKind() == clang::Decl::EnumConstant)
+	{
+		if (m_functionDecl)
+		{
+			m_client->VisitEnumExprInDeclBody(m_functionDecl, expr);
+		}
+		else
+		{
+			m_client->VisitEnumExprInDeclBody(m_varDecl, expr);
+		}
 	}
 	VisitStmt(expr);
 }

src/lib/data/parser/cxx/ASTBodyVisitor.h

@@ -15,6 +15,7 @@ public:
 	void VisitChildren(clang::Stmt* stmt);
 	void VisitCallExpr(clang::CallExpr* expr);
 	void VisitCXXConstructExpr(clang::CXXConstructExpr* expr);
+	void VisitCXXNewExpr(clang::CXXNewExpr* expr);
 	void VisitMemberExpr(clang::make_ptr<clang::MemberExpr>::type expr);
 	void VisitDeclRefExpr(clang::make_ptr<clang::DeclRefExpr>::type expr);
 	void VisitDeclStmt(clang::DeclStmt* stmt);

src/lib/data/parser/cxx/ASTBodyVisitorClient.h

@@ -15,8 +15,12 @@ public:
 	virtual void VisitCallExprInDeclBody(clang::VarDecl* decl, clang::CallExpr* expr) = 0;
 	virtual void VisitCXXConstructExprInDeclBody(clang::FunctionDecl* decl, clang::CXXConstructExpr* expr) = 0;
 	virtual void VisitCXXConstructExprInDeclBody(clang::VarDecl* decl, clang::CXXConstructExpr* expr) = 0;
+	virtual void VisitCXXNewExprInDeclBody(clang::FunctionDecl* decl, clang::CXXNewExpr* expr) = 0;
+	virtual void VisitCXXNewExprInDeclBody(clang::VarDecl* decl, clang::CXXNewExpr* expr) = 0;
 	virtual void VisitMemberExprInDeclBody(clang::FunctionDecl* decl, clang::MemberExpr* expr) = 0;
-	virtual void VisitDeclRefExprInDeclBody(clang::FunctionDecl* decl, clang::DeclRefExpr* expr) = 0;
+	virtual void VisitGlobalVariableExprInDeclBody(clang::FunctionDecl* decl, clang::DeclRefExpr* expr) = 0;
+	virtual void VisitEnumExprInDeclBody(clang::FunctionDecl* decl, clang::DeclRefExpr* expr) = 0;
+	virtual void VisitEnumExprInDeclBody(clang::VarDecl* decl, clang::DeclRefExpr* expr) = 0;
 	virtual void VisitVarDeclInDeclBody(clang::FunctionDecl* decl, clang::VarDecl* varDecl) = 0;
 };
 

src/lib/data/parser/cxx/ASTVisitor.cpp

@@ -54,7 +54,19 @@ bool ASTVisitor::VisitCXXRecordDecl(clang::CXXRecordDecl* declaration)
 				convertAccessType(declaration->getAccess()),
 				getParseLocationOfRecordBody(declaration)
 			);
+		}
+		else if (declaration->isStruct())
+		{
+			m_client->onStructParsed(
+				getParseLocationForNamedDecl(declaration),
+				utility::getDeclNameHierarchy(declaration),
+				convertAccessType(declaration->getAccess()),
+				getParseLocationOfRecordBody(declaration)
+			);
+		}
 
+		if (declaration->isClass() || declaration->isStruct())
+		{
 			if (declaration->hasDefinition() && declaration->getNumBases())
 			{
 				for (const clang::CXXBaseSpecifier& it : declaration->bases())
@@ -68,16 +80,6 @@ bool ASTVisitor::VisitCXXRecordDecl(clang::CXXRecordDecl* declaration)
 				}
 			}
 		}
-		else if (declaration->isStruct())
-		{
-			m_client->onStructParsed(
-				getParseLocationForNamedDecl(declaration),
-				utility::getDeclNameHierarchy(declaration),
-				convertAccessType(declaration->getAccess()),
-				getParseLocationOfRecordBody(declaration)
-			);
-			// TODO: what about struct inheritance?
-		}
 	}
 
 	return true;
@@ -438,6 +440,22 @@ void ASTVisitor::VisitCXXConstructExprInDeclBody(clang::VarDecl* decl, clang::CX
 	);
 }
 
+void ASTVisitor::VisitCXXNewExprInDeclBody(clang::FunctionDecl* decl, clang::CXXNewExpr* expr)
+{
+	m_client->onTypeUsageParsed(
+		getParseTypeUsage(expr->getAllocatedTypeSourceInfo()->getTypeLoc(), expr->getAllocatedType()),
+		getParseFunction(decl)
+	);
+}
+
+void ASTVisitor::VisitCXXNewExprInDeclBody(clang::VarDecl* decl, clang::CXXNewExpr* expr)
+{
+	m_client->onTypeUsageParsed(
+		getParseTypeUsage(expr->getAllocatedTypeSourceInfo()->getTypeLoc(), expr->getAllocatedType()),
+		getParseVariable(decl)
+	);
+}
+
 void ASTVisitor::VisitMemberExprInDeclBody(clang::FunctionDecl* decl, clang::MemberExpr* expr)
 {
 	ParseLocation parseLocation = getParseLocation(expr->getSourceRange());
@@ -452,7 +470,7 @@ void ASTVisitor::VisitMemberExprInDeclBody(clang::FunctionDecl* decl, clang::Mem
 	);
 }
 
-void ASTVisitor::VisitDeclRefExprInDeclBody(clang::FunctionDecl* decl, clang::DeclRefExpr* expr)
+void ASTVisitor::VisitGlobalVariableExprInDeclBody(clang::FunctionDecl* decl, clang::DeclRefExpr* expr)
 {
 	ParseLocation parseLocation = getParseLocation(expr->getSourceRange());
 
@@ -466,6 +484,34 @@ void ASTVisitor::VisitDeclRefExprInDeclBody(clang::FunctionDecl* decl, clang::De
 	);
 }
 
+void ASTVisitor::VisitEnumExprInDeclBody(clang::FunctionDecl* decl, clang::DeclRefExpr* expr)
+{
+	ParseLocation parseLocation = getParseLocation(expr->getSourceRange());
+
+	const std::string exprName = expr->getNameInfo().getAsString();
+	parseLocation.endColumnNumber += exprName.size() - 1;
+
+	m_client->onEnumFieldUsageParsed(
+		parseLocation,
+		getParseFunction(decl),
+		utility::getDeclNameHierarchy(expr->getDecl())
+	);
+}
+
+void ASTVisitor::VisitEnumExprInDeclBody(clang::VarDecl* decl, clang::DeclRefExpr* expr)
+{
+	ParseLocation parseLocation = getParseLocation(expr->getSourceRange());
+
+	const std::string exprName = expr->getNameInfo().getAsString();
+	parseLocation.endColumnNumber += exprName.size() - 1;
+
+	m_client->onEnumFieldUsageParsed(
+		parseLocation,
+		getParseVariable(decl),
+		utility::getDeclNameHierarchy(expr->getDecl())
+	);
+}
+
 void ASTVisitor::VisitVarDeclInDeclBody(clang::FunctionDecl* decl, clang::VarDecl* varDecl)
 {
 	m_client->onTypeUsageParsed(
@@ -480,12 +526,6 @@ bool ASTVisitor::hasValidLocation(const clang::Decl* declaration) const
 	return location.isValid() && m_context->getSourceManager().isWrittenInMainFile(location);
 }
 
-std::string ASTVisitor::getTypeName(const clang::QualType& qualType) const
-{
-	DataType dataType = utility::qualTypeToDataType(qualType);
-	return dataType.getRawTypeName();
-}
-
 ParserClient::AccessType ASTVisitor::convertAccessType(clang::AccessSpecifier access) const
 {
 	switch (access)

src/lib/data/parser/cxx/ASTVisitor.h

@@ -16,11 +16,11 @@ public:
 	virtual ~ASTVisitor();
 
 	// Left for debugging purposes. Uncomment to see a colored ast-dump of the parsed file.
-	 //virtual bool VisitTranslationUnitDecl(clang::TranslationUnitDecl* decl)
-	 //{
-	 //	decl->dump();
-	 //	return true;
-	 //}
+	// virtual bool VisitTranslationUnitDecl(clang::TranslationUnitDecl* decl)
+	// {
+	// 	decl->dump();
+	// 	return true;
+	// }
 
 	// RecursiveASTVisitor implementation
 	virtual bool VisitStmt(const clang::Stmt* statement); // avoid visiting
@@ -45,13 +45,16 @@ public:
 	virtual void VisitCallExprInDeclBody(clang::VarDecl* decl, clang::CallExpr* expr); // calls in initialization of global variables
 	virtual void VisitCXXConstructExprInDeclBody(clang::FunctionDecl* decl, clang::CXXConstructExpr* expr); // constructor calls
 	virtual void VisitCXXConstructExprInDeclBody(clang::VarDecl* decl, clang::CXXConstructExpr* expr); // constructor calls of global variables
+	virtual void VisitCXXNewExprInDeclBody(clang::FunctionDecl* decl, clang::CXXNewExpr* expr); // type use of new operator
+	virtual void VisitCXXNewExprInDeclBody(clang::VarDecl* decl, clang::CXXNewExpr* expr); // type use of new operator in global space
 	virtual void VisitMemberExprInDeclBody(clang::FunctionDecl* decl, clang::MemberExpr* expr); // field usages
-	virtual void VisitDeclRefExprInDeclBody(clang::FunctionDecl* decl, clang::DeclRefExpr* expr); // global variable usage
+	virtual void VisitGlobalVariableExprInDeclBody(clang::FunctionDecl* decl, clang::DeclRefExpr* expr); // global variable usage
+	virtual void VisitEnumExprInDeclBody(clang::FunctionDecl* decl, clang::DeclRefExpr* expr); // enum field usage
+	virtual void VisitEnumExprInDeclBody(clang::VarDecl* decl, clang::DeclRefExpr* expr); // enum field usage in global variable
 	virtual void VisitVarDeclInDeclBody(clang::FunctionDecl* decl, clang::VarDecl* varDecl); // type usages
 
 private:
 	bool hasValidLocation(const clang::Decl* declaration) const;
-	std::string getTypeName(const clang::QualType& qualType) const;
 	ParserClient::AccessType convertAccessType(clang::AccessSpecifier) const;
 
 	ParseLocation getParseLocation(const clang::SourceRange& sourceRange) const;

src/lib/data/type/DataType.cpp

@@ -47,7 +47,7 @@ std::string DataType::getRawTypeName() const
 	return utility::join(m_typeNameHierarchy, "::");
 }
 
-std::vector<std::string> DataType::getTypeNameHierarchy() const
+const std::vector<std::string>& DataType::getTypeNameHierarchy() const
 {
 	return m_typeNameHierarchy;
 }

src/lib/data/type/DataType.h

@@ -23,7 +23,7 @@ public:
 
 	std::string getFullTypeName() const;
 	std::string getRawTypeName() const;
-	std::vector<std::string> getTypeNameHierarchy() const;
+	const std::vector<std::string>& getTypeNameHierarchy() const;
 
 private:
 	const std::vector<std::string> m_typeNameHierarchy;