data: save undefined in database field instead of using different node types

* expand toggle also for undefined classes
* changed direction of some template edges
* save same access component to specialized template functions and classes

bin/app/data/color_schemes/bright.xml

@@ -111,6 +111,10 @@
 		<hatching>white</hatching>
 
 		<node>
+			<type>
+				<normal>#ededed</normal>
+				<hover>#ededed</hover>
+			</type>
 			<class>
 				<normal>#ededed</normal>
 				<hover>#ededed</hover>
@@ -123,10 +127,6 @@
 				<normal>#ededed</normal>
 				<hover>#ededed</hover>
 			</enum>
-			<undefined_type>
-				<normal>#ededed</normal>
-				<hover>#ededed</hover>
-			</undefined_type>
 			<typedef>
 				<normal>#ededed</normal>
 				<hover>#ededed</hover>
@@ -144,10 +144,6 @@
 				<normal>#F4D07D</normal>
 				<hover>#F4BC3D</hover>
 			</method>
-			<undefined_function>
-				<normal>#F4D07D</normal>
-				<hover>#F4BC3D</hover>
-			</undefined_function>
 
 			<field>
 				<normal>#7BB5D4</normal>
@@ -157,10 +153,6 @@
 				<normal>#7BB5D4</normal>
 				<hover>#42A1D4</hover>
 			</global_variable>
-			<undefined_variable>
-				<normal>#7BB5D4</normal>
-				<hover>#42A1D4</hover>
-			</undefined_variable>
 			<enum_constant>
 				<normal>#7BB5D4</normal>
 				<hover>#42A1D4</hover>
@@ -180,10 +172,6 @@
 				<hover>#CCC</hover>
 			</file>
 
-			<undefined_macro>
-				<normal>#DDD</normal>
-				<hover>#CCC</hover>
-			</undefined_macro>
 			<macro>
 				<normal>#DDD</normal>
 				<hover>#CCC</hover>

bin/app/data/color_schemes/dark.xml

@@ -111,6 +111,10 @@
 		<hatching>#272728</hatching>
 
 		<node>
+			<type>
+				<normal>#4D4D4D</normal>
+				<hover>#4D4D4D</hover>
+			</type>
 			<class>
 				<normal>#4D4D4D</normal>
 				<hover>#4D4D4D</hover>
@@ -123,10 +127,6 @@
 				<normal>#4D4D4D</normal>
 				<hover>#4D4D4D</hover>
 			</enum>
-			<undefined_type>
-				<normal>#4D4D4D</normal>
-				<hover>#4D4D4D</hover>
-			</undefined_type>
 			<typedef>
 				<normal>#4D4D4D</normal>
 				<hover>#4D4D4D</hover>
@@ -144,10 +144,6 @@
 				<normal>#7A681F</normal>
 				<hover>#9C8528</hover>
 			</method>
-			<undefined_function>
-				<normal>#7A681F</normal>
-				<hover>#9C8528</hover>
-			</undefined_function>
 
 			<field>
 				<normal>#21516B</normal>
@@ -157,10 +153,6 @@
 				<normal>#21516B</normal>
 				<hover>#2A6484</hover>
 			</global_variable>
-			<undefined_variable>
-				<normal>#21516B</normal>
-				<hover>#2A6484</hover>
-			</undefined_variable>
 			<enum_constant>
 				<normal>#21516B</normal>
 				<hover>#2A6484</hover>
@@ -180,10 +172,6 @@
 				<hover>#247368</hover>
 			</file>
 
-			<undefined_macro>
-				<normal>#1B564E</normal>
-				<hover>#247368</hover>
-			</undefined_macro>
 			<macro>
 				<normal>#1B564E</normal>
 				<hover>#247368</hover>

src/app/qt/element/QtAutocompletionList.cpp

@@ -104,7 +104,7 @@ void QtAutocompletionDelegate::paint(QPainter* painter, const QStyleOptionViewIt
 	QColor color("#FFFFFF");
 
 	Node::NodeType nodeType = static_cast<Node::NodeType>(index.sibling(index.row(), index.column() + 3).data().toInt());
-	if (type.size() && nodeType)
+	if (type.size())
 	{
 		color = QColor(scheme->getNodeTypeColor(nodeType).c_str());
 	}

src/app/qt/view/graphElements/QtGraphNodeData.cpp

@@ -20,7 +20,13 @@ QtGraphNodeData::QtGraphNodeData(const Node* data, bool hasParent, bool childVis
 		this->setName(data->getName());
 	}
 
-	this->setToolTip(QString::fromStdString(data->getTypeString()));
+	std::string toolTip = data->getTypeString();
+	if (!data->isDefined() && !data->isType(Node::NODE_UNDEFINED))
+	{
+		toolTip = "undefined " + toolTip;
+	}
+
+	this->setToolTip(QString::fromStdString(toolTip));
 }
 
 QtGraphNodeData::~QtGraphNodeData()
@@ -59,7 +65,7 @@ void QtGraphNodeData::moved(const Vec2i& oldPosition)
 void QtGraphNodeData::updateStyle()
 {
 	GraphViewStyle::NodeStyle style =
-		GraphViewStyle::getStyleForNodeType(m_data->getType(), m_isActive, m_isHovering, m_childVisible);
+		GraphViewStyle::getStyleForNodeType(m_data->getType(), m_data->isDefined(), m_isActive, m_isHovering, m_childVisible);
 	setStyle(style);
 }
 

src/lib/Project.cpp

@@ -7,6 +7,7 @@
 #include "data/access/StorageAccessProxy.h"
 #include "data/graph/Token.h"
 #include "data/parser/cxx/TaskParseCxx.h"
+#include "data/Storage.h"
 #include "data/TaskCleanStorage.h"
 #include "settings/ApplicationSettings.h"
 #include "settings/ProjectSettings.h"

src/lib/Project.h

@@ -6,8 +6,8 @@
 #include "utility/file/FileManager.h"
 
 #include "data/parser/Parser.h"
-#include "data/Storage.h"
 
+class Storage;
 class StorageAccessProxy;
 
 class Project

src/lib/component/controller/GraphController.cpp

@@ -240,7 +240,7 @@ DummyNode GraphController::createDummyNodeTopDown(Node* node)
 			}
 			else
 			{
-				if (node->isType(Node::NODE_CLASS | Node::NODE_STRUCT))
+				if (node->isType(Node::NODE_TYPE | Node::NODE_CLASS | Node::NODE_STRUCT))
 				{
 					accessType = TokenComponentAccess::ACCESS_PUBLIC;
 				}
@@ -448,11 +448,7 @@ void GraphController::bundleNodes()
 	bundleNodesMatching(
 		[](const DummyNode& node)
 		{
-			const Node::NodeTypeMask undefinedMask =
-				Node::NODE_UNDEFINED | Node::NODE_UNDEFINED_TYPE |
-				Node::NODE_UNDEFINED_VARIABLE | Node::NODE_UNDEFINED_FUNCTION;
-
-			if (node.visible && node.isGraphNode() && !node.hasActiveSubNode() && node.data->isType(undefinedMask))
+			if (node.visible && node.isGraphNode() && !node.hasActiveSubNode() && !node.data->isDefined())
 			{
 				return true;
 			}
@@ -671,7 +667,7 @@ void GraphController::layoutNestingRecursive(DummyNode& node) const
 			width = margins.charWidth * node.data->getName().size();
 		}
 
-		if (node.data->isType(Node::NODE_CLASS | Node::NODE_STRUCT | Node::NODE_ENUM) && node.subNodes.size())
+		if (node.data->isType(Node::NODE_TYPE | Node::NODE_CLASS | Node::NODE_STRUCT | Node::NODE_ENUM) && node.subNodes.size())
 		{
 			addExpandToggleNode(node);
 		}

src/lib/component/view/GraphViewStyle.cpp

@@ -105,19 +105,16 @@ size_t GraphViewStyle::getFontSizeForNodeType(Node::NodeType type)
 	case Node::NODE_NAMESPACE:
 		return s_fontSize - 2;
 
-	case Node::NODE_UNDEFINED_TYPE:
+	case Node::NODE_TYPE:
 	case Node::NODE_STRUCT:
 	case Node::NODE_CLASS:
 	case Node::NODE_ENUM:
 	case Node::NODE_TYPEDEF:
 	case Node::NODE_TEMPLATE_PARAMETER_TYPE:
 	case Node::NODE_FILE:
-	case Node::NODE_UNDEFINED_MACRO:
 	case Node::NODE_MACRO:
 		return s_fontSize;
 
-	case Node::NODE_UNDEFINED_FUNCTION:
-	case Node::NODE_UNDEFINED_VARIABLE:
 	case Node::NODE_FUNCTION:
 	case Node::NODE_METHOD:
 	case Node::NODE_GLOBAL_VARIABLE:
@@ -175,10 +172,9 @@ GraphViewStyle::NodeMargins GraphViewStyle::getMarginsForNodeType(Node::NodeType
 	case Node::NODE_FILE:
 	case Node::NODE_ENUM:
 	case Node::NODE_TYPEDEF:
-	case Node::NODE_UNDEFINED_MACRO:
 	case Node::NODE_MACRO:
 		margins.iconWidth = s_fontSize + 11;
-	case Node::NODE_UNDEFINED_TYPE:
+	case Node::NODE_TYPE:
 	case Node::NODE_STRUCT:
 	case Node::NODE_CLASS:
 	case Node::NODE_TEMPLATE_PARAMETER_TYPE:
@@ -195,10 +191,8 @@ GraphViewStyle::NodeMargins GraphViewStyle::getMarginsForNodeType(Node::NodeType
 		}
 		break;
 
-	case Node::NODE_UNDEFINED_FUNCTION:
 	case Node::NODE_FUNCTION:
 	case Node::NODE_METHOD:
-	case Node::NODE_UNDEFINED_VARIABLE:
 	case Node::NODE_GLOBAL_VARIABLE:
 	case Node::NODE_FIELD:
 	case Node::NODE_ENUM_CONSTANT:
@@ -257,7 +251,7 @@ GraphViewStyle::NodeMargins GraphViewStyle::getMarginsOfBundleNode()
 }
 
 GraphViewStyle::NodeStyle GraphViewStyle::getStyleForNodeType(
-	Node::NodeType type, bool isActive, bool isFocused, bool hasChildren
+	Node::NodeType type, bool defined, bool isActive, bool isFocused, bool hasChildren
 ){
 	NodeStyle style;
 
@@ -294,10 +288,7 @@ GraphViewStyle::NodeStyle GraphViewStyle::getStyleForNodeType(
 		style.textOffset.y = 6;
 		break;
 
-	case Node::NODE_UNDEFINED_TYPE:
-	case Node::NODE_UNDEFINED_MACRO:
-		style.hatchingColor = scheme->getColor("graph/hatching");
-
+	case Node::NODE_TYPE:
 	case Node::NODE_STRUCT:
 	case Node::NODE_CLASS:
 	case Node::NODE_ENUM:
@@ -338,10 +329,6 @@ GraphViewStyle::NodeStyle GraphViewStyle::getStyleForNodeType(
 		style.textOffset.y = 9;
 		break;
 
-	case Node::NODE_UNDEFINED_FUNCTION:
-	case Node::NODE_UNDEFINED_VARIABLE:
-		style.hatchingColor = scheme->getColor("graph/hatching");
-
 	case Node::NODE_FUNCTION:
 	case Node::NODE_METHOD:
 	case Node::NODE_GLOBAL_VARIABLE:
@@ -363,6 +350,11 @@ GraphViewStyle::NodeStyle GraphViewStyle::getStyleForNodeType(
 		style.fontBold = true;
 	}
 
+	if (!defined)
+	{
+		style.hatchingColor = scheme->getColor("graph/hatching");
+	}
+
 	addIcon(type, hasChildren, &style);
 
 	return style;
@@ -412,7 +404,7 @@ GraphViewStyle::NodeStyle GraphViewStyle::getStyleOfExpandToggleNode()
 
 GraphViewStyle::NodeStyle GraphViewStyle::getStyleOfBundleNode(bool isFocused)
 {
-	NodeStyle style = getStyleForNodeType(Node::NODE_CLASS, false, isFocused, false);
+	NodeStyle style = getStyleForNodeType(Node::NODE_CLASS, true, false, isFocused, false);
 
 	addIcon(Node::NODE_ENUM, false, &style);
 	style.iconPath = "data/gui/graph_view/images/bundle.png";
@@ -530,7 +522,6 @@ void GraphViewStyle::addIcon(Node::NodeType type, bool hasChildren, NodeStyle* s
 	case Node::NODE_TYPEDEF:
 		style->iconPath = "data/gui/graph_view/images/typedef_2.png";
 		break;
-	case Node::NODE_UNDEFINED_MACRO:
 	case Node::NODE_MACRO:
 		style->iconPath = "data/gui/graph_view/images/macro_3.png";
 		break;

src/lib/component/view/GraphViewStyle.h

@@ -105,7 +105,7 @@ public:
 	static NodeMargins getMarginsOfExpandToggleNode();
 	static NodeMargins getMarginsOfBundleNode();
 
-	static NodeStyle getStyleForNodeType(Node::NodeType type, bool isActive, bool isFocused, bool hasChildren);
+	static NodeStyle getStyleForNodeType(Node::NodeType type, bool defined, bool isActive, bool isFocused, bool hasChildren);
 	static NodeStyle getStyleOfAccessNode();
 	static NodeStyle getStyleOfExpandToggleNode();
 	static NodeStyle getStyleOfBundleNode(bool isFocused);

src/lib/data/SqliteStorage.cpp

@@ -63,7 +63,7 @@ Id SqliteStorage::addEdge(int type, Id sourceNodeId, Id targetNodeId)
 	return id;
 }
 
-Id SqliteStorage::addNode(int type, Id nameId)
+Id SqliteStorage::addNode(int type, Id nameId, bool defined)
 {
 	m_database.execDML(
 		"INSERT INTO element(id) VALUES(NULL);"
@@ -71,8 +71,8 @@ Id SqliteStorage::addNode(int type, Id nameId)
 	Id id = m_database.lastRowId();
 
 	m_database.execDML((
-		"INSERT INTO node(id, type, name_id) VALUES("
-		+ std::to_string(id) + ", " + std::to_string(type) + ", " + std::to_string(nameId) + ");"
+		"INSERT INTO node(id, type, name_id, defined) VALUES("
+		+ std::to_string(id) + ", " + std::to_string(type) + ", " + std::to_string(nameId) + ", " + std::to_string(defined) + ");"
 	).c_str());
 
 	return id;
@@ -80,7 +80,7 @@ Id SqliteStorage::addNode(int type, Id nameId)
 
 Id SqliteStorage::addFile(Id nameId, const std::string& filePath, const std::string& modificationTime)
 {
-	Id id = addNode(Node::NODE_FILE, nameId);
+	Id id = addNode(Node::NODE_FILE, nameId, true);
 	std::shared_ptr<TextAccess> content = TextAccess::createFromFile(filePath);
 
 	CppSQLite3Statement stmt = m_database.compileStatement((
@@ -196,32 +196,12 @@ StorageNode SqliteStorage::getFirstNode() const
 		return nodes[0];
 	}
 
-	return StorageNode(0, 0, 0);
+	return StorageNode(0, 0, 0, false);
 }
 
 std::vector<StorageNode> SqliteStorage::getAllNodes() const
 {
-	std::vector<StorageNode> nodes;
-
-	CppSQLite3Query q = m_database.execQuery(
-		"SELECT id, type, name_id FROM node;"
-	);
-
-	while (!q.eof())
-	{
-		const Id id = q.getIntField(0, 0);
-		const int type = q.getIntField(1, -1);
-		const Id nameId = q.getIntField(2, 0);
-
-		if (id != 0 && type != -1 && nameId != 0)
-		{
-			nodes.push_back(StorageNode(id, type, nameId));
-		}
-
-		q.nextRow();
-	}
-
-	return nodes;
+	return getAllNodes("");
 }
 
 bool SqliteStorage::isEdge(Id elementId) const
@@ -364,60 +344,24 @@ std::vector<StorageEdge> SqliteStorage::getEdgesByTargetType(Id targetId, int ty
 
 StorageNode SqliteStorage::getNodeById(Id id) const
 {
-	CppSQLite3Query q = m_database.execQuery((
-		"SELECT type, name_id FROM node WHERE id == " + std::to_string(id) + ";"
-	).c_str());
-
-	if (!q.eof())
+	std::vector<StorageNode> nodes = getAllNodes("WHERE id == " + std::to_string(id));
+	if (nodes.size())
 	{
-		const int type = q.getIntField(0, -1);
-		const Id nameId = q.getIntField(1, 0);
-
-		if (type != -1 && nameId != 0 )
-		{
-			return StorageNode(id, type, nameId);
-		}
+		return nodes[0];
 	}
-	return StorageNode(0, -1, 0);
+
+	return StorageNode(0, 0, 0, false);
 }
 
 StorageNode SqliteStorage::getNodeByNameId(Id nameId) const
 {
-	CppSQLite3Query q = m_database.execQuery((
-		"SELECT id, type FROM node WHERE name_id == " + std::to_string(nameId) + ";"
-	).c_str());
-
-	if (!q.eof())
+	std::vector<StorageNode> nodes = getAllNodes("WHERE name_id == " + std::to_string(nameId));
+	if (nodes.size())
 	{
-		const Id id = q.getIntField(0, 0);
-		const int type = q.getIntField(1, -1);
-
-		if (id != 0 && type != -1)
-		{
-			return StorageNode(id, type, nameId);
-		}
+		return nodes[0];
 	}
-	return StorageNode(0, -1, 0);
-}
 
-StorageNode SqliteStorage::getNodeByName(const std::string& nodeName) const
-{
-	CppSQLite3Query q = m_database.execQuery((
-		"SELECT node.id, node.type, node.name_id FROM node INNER JOIN name_hierarchy_element ON node.name_id = name_hierarchy_element.id WHERE name_hierarchy_element.name = '" + nodeName + "';"
-	).c_str());
-
-	if (!q.eof())
-	{
-		const Id id = q.getIntField(0, 0);
-		const int type = q.getIntField(1, -1);
-		const Id nameId = q.getIntField(2, 0);
-
-		if (id != 0 && type != -1 && nameId != 0)
-		{
-			return StorageNode(id, type, nameId);
-		}
-	}
-	return StorageNode(0, -1, 0);
+	return StorageNode(0, 0, 0, false);
 }
 
 std::vector<StorageNode> SqliteStorage::getNodesByIds(const std::vector<Id>& nodeIds) const
@@ -486,6 +430,13 @@ void SqliteStorage::setNodeType(int type, Id nodeId)
 	).c_str());
 }
 
+void SqliteStorage::setNodeDefined(bool defined, Id nodeId)
+{
+	m_database.execDML((
+		"UPDATE node SET defined = " + std::to_string(defined) + " WHERE id == " + std::to_string(nodeId) + ";"
+	).c_str());
+}
+
 Id SqliteStorage::getNameHierarchyElementIdByName(const std::string& name, Id parentId) const
 {
 	if (parentId)
@@ -579,7 +530,7 @@ std::shared_ptr<TokenLocationFile> SqliteStorage::getTokenLocationsForFile(const
 {
 	std::shared_ptr<TokenLocationFile> ret = std::make_shared<TokenLocationFile>(filePath);
 
-	const Id fileNodeId = getNodeByName(filePath.fileName()).id;
+	const Id fileNodeId = getFileByPath(filePath.str()).id;
 	if (fileNodeId == 0) // early out
 	{
 		return ret;
@@ -759,6 +710,7 @@ void SqliteStorage::setupTables()
 			"id INTEGER NOT NULL, "
 			"type INTEGER NOT NULL, "
 			"name_id INTEGER NOT NULL, "
+			"defined INTEGER NOT NULL, "
 			"PRIMARY KEY(id), "
 			"FOREIGN KEY(id) REFERENCES element(id) ON DELETE CASCADE, "
 			"FOREIGN KEY(name_id) REFERENCES name_hierarchy_element(id) ON DELETE CASCADE);" // maybe use restrict here
@@ -941,7 +893,7 @@ std::vector<StorageEdge> SqliteStorage::getAllEdges(const std::string& query) co
 std::vector<StorageNode> SqliteStorage::getAllNodes(const std::string& query) const
 {
 	CppSQLite3Query q = m_database.execQuery((
-		"SELECT id, type, name_id FROM node " + query + ";"
+		"SELECT id, type, name_id, defined FROM node " + query + ";"
 	).c_str());
 
 	std::vector<StorageNode> nodes;
@@ -950,10 +902,11 @@ std::vector<StorageNode> SqliteStorage::getAllNodes(const std::string& query) co
 		const Id id = q.getIntField(0, 0);
 		const int type = q.getIntField(1, -1);
 		const Id nameId = q.getIntField(2, 0);
+		const bool defined = q.getIntField(3, 0);
 
 		if (id != 0 && type != -1)
 		{
-			nodes.push_back(StorageNode(id, type, nameId));
+			nodes.push_back(StorageNode(id, type, nameId, defined));
 		}
 
 		q.nextRow();

src/lib/data/SqliteStorage.h

@@ -30,7 +30,7 @@ public:
 	void rollbackTransaction();
 
 	Id addEdge(int type, Id sourceNodeId, Id targetNodeId);
-	Id addNode(int type, Id nameId);
+	Id addNode(int type, Id nameId, bool defined);
 	Id addFile(Id nameId, const std::string& filePath, const std::string& modificationTime);
 	int addSourceLocation(Id elementId, Id fileNodeId, uint startLine, uint startCol, uint endLine, uint endCol, bool isScope);
 	Id addNameHierarchyElement(const std::string& name, Id parentId = 0);
@@ -67,7 +67,6 @@ public:
 
 	StorageNode getNodeById(Id id) const;
 	StorageNode getNodeByNameId(Id nameId) const;
-	StorageNode getNodeByName(const std::string& nodeName) const; // hmm... we need to use name hierarchy here...??
 	std::vector<StorageNode> getNodesByIds(const std::vector<Id>& nodeIds) const;
 
 	StorageFile getFileById(const Id id) const;
@@ -77,6 +76,7 @@ public:
 	std::shared_ptr<TextAccess> getFileContentByPath(const std::string& filePath) const;
 
 	void setNodeType(int type, Id nodeId);
+	void setNodeDefined(bool defined, Id nodeId);
 
 	Id getNameHierarchyElementIdByName(const std::string& name, Id parentId = 0) const;
 	Id getNameHierarchyElementIdByNodeId(const Id nodeId) const;

src/lib/data/Storage.cpp

@@ -217,11 +217,11 @@ Id Storage::onTypedefParsed(
 ){
 	log("typedef", nameHierarchy.getFullName() + " -> " + underlyingType.dataType->getFullTypeName(), location);
 
-	Id typedefNodeId = addNodeHierarchy(Node::NODE_TYPEDEF, nameHierarchy);
+	Id typedefNodeId = addNodeHierarchy(Node::NODE_TYPEDEF, nameHierarchy, true);
 	addSourceLocation(typedefNodeId, location);
 	addAccess(typedefNodeId, access);
 
-	Id underlyingTypeNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, underlyingType.dataType->getTypeNameHierarchy());
+	Id underlyingTypeNodeId = addNodeHierarchy(Node::NODE_TYPE, underlyingType.dataType->getTypeNameHierarchy(), false);
 	addEdge(typedefNodeId, underlyingTypeNodeId, Edge::EDGE_TYPEDEF_OF, location);
 
 	return typedefNodeId;
@@ -233,7 +233,7 @@ Id Storage::onClassParsed(
 ){
 	log("class", nameHierarchy.getFullName(), location);
 
-	Id nodeId = addNodeHierarchy(scopeLocation.isValid() ? Node::NODE_CLASS : Node::NODE_UNDEFINED_TYPE, nameHierarchy);
+	Id nodeId = addNodeHierarchy(Node::NODE_CLASS, nameHierarchy, scopeLocation.isValid());
 
 	addSourceLocation(nodeId, location);
 	addSourceLocation(nodeId, scopeLocation, true);
@@ -249,7 +249,7 @@ Id Storage::onStructParsed(
 ){
 	log("struct", nameHierarchy.getFullName(), location);
 
-	Id nodeId = addNodeHierarchy(Node::NODE_STRUCT, nameHierarchy);
+	Id nodeId = addNodeHierarchy(Node::NODE_STRUCT, nameHierarchy, true);
 
 	addSourceLocation(nodeId, location);
 	addSourceLocation(nodeId, scopeLocation, true);
@@ -263,10 +263,10 @@ Id Storage::onGlobalVariableParsed(const ParseLocation& location, const ParseVar
 {
 	log("global", variable.getFullName(), location);
 
-	Id nodeId = addNodeHierarchy(Node::NODE_GLOBAL_VARIABLE, variable.nameHierarchy);
+	Id nodeId = addNodeHierarchy(Node::NODE_GLOBAL_VARIABLE, variable.nameHierarchy, true);
 	addSourceLocation(nodeId, location);
 
-	Id typeNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, variable.type.dataType->getTypeNameHierarchy());
+	Id typeNodeId = addNodeHierarchy(Node::NODE_TYPE, variable.type.dataType->getTypeNameHierarchy(), false);
 	addEdge(nodeId, typeNodeId, Edge::EDGE_TYPE_OF, location);
 
 	return nodeId;
@@ -276,11 +276,11 @@ Id Storage::onFieldParsed(const ParseLocation& location, const ParseVariable& va
 {
 	log("field", variable.getFullName(), location);
 
-	Id nodeId = addNodeHierarchy(Node::NODE_FIELD, variable.nameHierarchy);
+	Id nodeId = addNodeHierarchy(Node::NODE_FIELD, variable.nameHierarchy, true);
 	addSourceLocation(nodeId, location);
 	addAccess(nodeId, access);
 
-	Id typeNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, variable.type.dataType->getTypeNameHierarchy());
+	Id typeNodeId = addNodeHierarchy(Node::NODE_TYPE, variable.type.dataType->getTypeNameHierarchy(), false);
 	addEdge(nodeId, typeNodeId, Edge::EDGE_TYPE_OF, variable.type.location);
 
 	return nodeId;
@@ -291,15 +291,15 @@ Id Storage::onFunctionParsed(
 ){
 	log("function", function.getFullName(), location);
 
-	Id nodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_FUNCTION, function);
+	Id nodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_FUNCTION, function, true);
 
-	Id returnTypeNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, function.returnType.dataType->getTypeNameHierarchy());
+	Id returnTypeNodeId = addNodeHierarchy(Node::NODE_TYPE, function.returnType.dataType->getTypeNameHierarchy(), false);
 	addEdge(nodeId, returnTypeNodeId, Edge::EDGE_TYPE_USAGE, function.returnType.location);
 	// addEdge(nodeId, returnTypeNodeId, Edge::EDGE_RETURN_TYPE_OF, function.returnType.location);
 
 	for (size_t i = 0; i < function.parameters.size(); i++)
 	{
-		Id parameternTypeNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, function.parameters[i].dataType->getTypeNameHierarchy());
+		Id parameternTypeNodeId = addNodeHierarchy(Node::NODE_TYPE, function.parameters[i].dataType->getTypeNameHierarchy(), false);
 		addEdge(nodeId, parameternTypeNodeId, Edge::EDGE_TYPE_USAGE, function.parameters[i].location);
 		// addEdge(nodeId, parameternTypeNodeId, Edge::EDGE_PARAMETER_TYPE_OF, function.parameters[i].location);
 	}
@@ -316,18 +316,18 @@ Id Storage::onMethodParsed(
 ){
 	log("method", method.getFullName(), location);
 
-	Id nodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_METHOD, method);
+	Id nodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_METHOD, method, true);
 	addSourceLocation(nodeId, location);
 	addSourceLocation(nodeId, scopeLocation, true);
 	addAccess(nodeId, access);
 
-	Id returnTypeNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, method.returnType.dataType->getTypeNameHierarchy());
+	Id returnTypeNodeId = addNodeHierarchy(Node::NODE_TYPE, method.returnType.dataType->getTypeNameHierarchy(), false);
 	addEdge(nodeId, returnTypeNodeId, Edge::EDGE_TYPE_USAGE, method.returnType.location);
 	// addEdge(nodeId, returnTypeNodeId, Edge::EDGE_RETURN_TYPE_OF, method.returnType.location);
 
 	for (size_t i = 0; i < method.parameters.size(); i++)
 	{
-		Id parameternTypeNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, method.parameters[i].dataType->getTypeNameHierarchy());
+		Id parameternTypeNodeId = addNodeHierarchy(Node::NODE_TYPE, method.parameters[i].dataType->getTypeNameHierarchy(), false);
 		addEdge(nodeId, parameternTypeNodeId, Edge::EDGE_TYPE_USAGE, method.parameters[i].location);
 		// addEdge(nodeId, parameternTypeNodeId, Edge::EDGE_PARAMETER_TYPE_OF, method.parameters[i].location);
 	}
@@ -340,7 +340,7 @@ Id Storage::onNamespaceParsed(
 ){
 	log("namespace", nameHierarchy.getFullName(), location);
 
-	Id nodeId = addNodeHierarchy(Node::NODE_NAMESPACE, nameHierarchy);
+	Id nodeId = addNodeHierarchy(Node::NODE_NAMESPACE, nameHierarchy, true);
 
 	addSourceLocation(nodeId, location);
 	addSourceLocation(nodeId, scopeLocation, true);
@@ -354,7 +354,7 @@ Id Storage::onEnumParsed(
 ){
 	log("enum", nameHierarchy.getFullName(), location);
 
-	Id nodeId = addNodeHierarchy(Node::NODE_ENUM, nameHierarchy);
+	Id nodeId = addNodeHierarchy(Node::NODE_ENUM, nameHierarchy, true);
 
 	addSourceLocation(nodeId, location);
 	addSourceLocation(nodeId, scopeLocation, true);
@@ -367,7 +367,7 @@ Id Storage::onEnumConstantParsed(const ParseLocation& location, const NameHierar
 {
 	log("enum constant", nameHierarchy.getFullName(), location);
 
-	Id nodeId = addNodeHierarchy(Node::NODE_ENUM_CONSTANT, nameHierarchy);
+	Id nodeId = addNodeHierarchy(Node::NODE_ENUM_CONSTANT, nameHierarchy, true);
 
 	addSourceLocation(nodeId, location);
 
@@ -380,8 +380,8 @@ Id Storage::onInheritanceParsed(
 ){
 	log("inheritance", childNameHierarchy.getFullName() + " : " + parentNameHierarchy.getFullName(), location);
 
-	Id childNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, childNameHierarchy);
-	Id parentNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, parentNameHierarchy);
+	Id childNodeId = addNodeHierarchy(Node::NODE_TYPE, childNameHierarchy, false);
+	Id parentNodeId = addNodeHierarchy(Node::NODE_TYPE, parentNameHierarchy, false);
 
 	Id edgeId = addEdge(childNodeId, parentNodeId, Edge::EDGE_INHERITANCE, location);
 
@@ -393,8 +393,8 @@ Id Storage::onMethodOverrideParsed(
 {
 	log("override", base.getFullName() + " -> " + overrider.getFullName(), location);
 
-	Id baseNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_UNDEFINED_FUNCTION, base); // TODO: call this overridden
-	Id overriderNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_UNDEFINED_FUNCTION, overrider);
+	Id baseNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_FUNCTION, base, false); // TODO: call this overridden
+	Id overriderNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_FUNCTION, overrider, false);
 
 	Id edgeId = addEdge(overriderNodeId, baseNodeId, Edge::EDGE_OVERRIDE, location);
 
@@ -405,8 +405,8 @@ Id Storage::onCallParsed(const ParseLocation& location, const ParseFunction& cal
 {
 	log("call", caller.getFullName() + " -> " + callee.getFullName(), location);
 
-	Id callerNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_UNDEFINED_FUNCTION, caller);
-	Id calleeNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_UNDEFINED_FUNCTION, callee);
+	Id callerNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_FUNCTION, caller, false);
+	Id calleeNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_FUNCTION, callee, false);
 
 	Id edgeId = addEdge(callerNodeId, calleeNodeId, Edge::EDGE_CALL, location);
 
@@ -417,8 +417,8 @@ Id Storage::onCallParsed(const ParseLocation& location, const ParseVariable& cal
 {
 	log("call", caller.getFullName() + " -> " + callee.getFullName(), location);
 
-	Id callerNodeId = addNodeHierarchy(Node::NODE_UNDEFINED, caller.nameHierarchy);
-	Id calleeNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_UNDEFINED_FUNCTION, callee);
+	Id callerNodeId = addNodeHierarchy(Node::NODE_UNDEFINED, caller.nameHierarchy, false);
+	Id calleeNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_FUNCTION, callee, false);
 
 	Id edgeId = addEdge(callerNodeId, calleeNodeId, Edge::EDGE_CALL, location);
 
@@ -430,8 +430,8 @@ Id Storage::onFieldUsageParsed(
 ){
 	log("field usage", user.getFullName() + " -> " + usedNameHierarchy.getFullName(), location);
 
-	Id userNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_UNDEFINED_FUNCTION, user);
-	Id usedNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, usedNameHierarchy);
+	Id userNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_FUNCTION, user, false);
+	Id usedNodeId = addNodeHierarchy(Node::NODE_GLOBAL_VARIABLE, usedNameHierarchy, false);
 
 	Id edgeId = addEdge(userNodeId, usedNodeId, Edge::EDGE_USAGE, location);
 
@@ -443,8 +443,8 @@ Id Storage::onFieldUsageParsed(
 ){
 	log("global usage", user.getFullName() + " -> " + usedNameHierarchy.getFullName(), location);
 
-	Id userNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_FUNCTION, user.nameHierarchy);
-	Id usedNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, usedNameHierarchy);
+	Id userNodeId = addNodeHierarchy(Node::NODE_FUNCTION, user.nameHierarchy, false);
+	Id usedNodeId = addNodeHierarchy(Node::NODE_GLOBAL_VARIABLE, usedNameHierarchy, false);
 
 	Id edgeId = addEdge(userNodeId, usedNodeId, Edge::EDGE_USAGE, location);
 
@@ -456,8 +456,8 @@ Id Storage::onGlobalVariableUsageParsed( // or static variable used
 ){
 	log("global usage", user.getFullName() + " -> " + usedNameHierarchy.getFullName(), location);
 
-	Id userNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_UNDEFINED_FUNCTION, user);
-	Id usedNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, usedNameHierarchy);
+	Id userNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_FUNCTION, user, false);
+	Id usedNodeId = addNodeHierarchy(Node::NODE_GLOBAL_VARIABLE, usedNameHierarchy, false);
 
 	Id edgeId = addEdge(userNodeId, usedNodeId, Edge::EDGE_USAGE, location);
 
@@ -469,8 +469,8 @@ Id Storage::onGlobalVariableUsageParsed(
 {
 	log("global usage", user.getFullName() + " -> " + usedNameHierarchy.getFullName(), location);
 
-	Id userNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, user.nameHierarchy);
-	Id usedNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, usedNameHierarchy);
+	Id userNodeId = addNodeHierarchy(Node::NODE_GLOBAL_VARIABLE, user.nameHierarchy, false);
+	Id usedNodeId = addNodeHierarchy(Node::NODE_GLOBAL_VARIABLE, usedNameHierarchy, false);
 
 	Id edgeId = addEdge(userNodeId, usedNodeId, Edge::EDGE_USAGE, location);
 
@@ -482,8 +482,8 @@ Id Storage::onEnumConstantUsageParsed(
 ){
 	log("enum constant usage", user.getFullName() + " -> " + usedNameHierarchy.getFullName(), location);
 
-	Id userNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_UNDEFINED_FUNCTION, user);
-	Id usedNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, usedNameHierarchy);
+	Id userNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_FUNCTION, user, false);
+	Id usedNodeId = addNodeHierarchy(Node::NODE_GLOBAL_VARIABLE, usedNameHierarchy, false);
 
 	Id edgeId = addEdge(userNodeId, usedNodeId, Edge::EDGE_USAGE, location);
 
@@ -495,8 +495,8 @@ Id Storage::onEnumConstantUsageParsed(
 ){
 	log("enum constant usage", user.getFullName() + " -> " + usedNameHierarchy.getFullName(), location);
 
-	Id userNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_FUNCTION, user.nameHierarchy);
-	Id usedNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, usedNameHierarchy);
+	Id userNodeId = addNodeHierarchy(Node::NODE_FUNCTION, user.nameHierarchy, false);
+	Id usedNodeId = addNodeHierarchy(Node::NODE_GLOBAL_VARIABLE, usedNameHierarchy, false);
 
 	Id edgeId = addEdge(userNodeId, usedNodeId, Edge::EDGE_USAGE, location);
 
@@ -512,8 +512,8 @@ Id Storage::onTypeUsageParsed(const ParseTypeUsage& typeUsage, const ParseFuncti
 		return 0;
 	}
 
-	Id functionNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_UNDEFINED_FUNCTION, function);
-	Id typeNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, typeUsage.dataType->getTypeNameHierarchy());
+	Id functionNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_FUNCTION, function, false);
+	Id typeNodeId = addNodeHierarchy(Node::NODE_TYPE, typeUsage.dataType->getTypeNameHierarchy(), false);
 
 	Id edgeId = addEdge(functionNodeId, typeNodeId, Edge::EDGE_TYPE_USAGE, typeUsage.location);
 
@@ -529,8 +529,8 @@ Id Storage::onTypeUsageParsed(const ParseTypeUsage& typeUsage, const ParseVariab
 		return 0;
 	}
 
-	Id functionNodeId = addNodeHierarchy(Node::NODE_UNDEFINED, variable.nameHierarchy);
-	Id typeNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, typeUsage.dataType->getTypeNameHierarchy());
+	Id functionNodeId = addNodeHierarchy(Node::NODE_UNDEFINED, variable.nameHierarchy, false);
+	Id typeNodeId = addNodeHierarchy(Node::NODE_TYPE, typeUsage.dataType->getTypeNameHierarchy(), false);
 
 	Id edgeId = addEdge(functionNodeId, typeNodeId, Edge::EDGE_TYPE_USAGE, typeUsage.location);
 
@@ -547,12 +547,12 @@ Id Storage::onTemplateArgumentTypeParsed(
 		location
 	);
 
-	Id argumentNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, argumentNameHierarchy);
+	Id argumentNodeId = addNodeHierarchy(Node::NODE_TYPE, argumentNameHierarchy, false);
 	// does not need a source location because this type that is already defined (and therefore has a location).
 
-	Id templateNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, templateNameHierarchy);
+	Id templateNodeId = addNodeHierarchy(Node::NODE_TYPE, templateNameHierarchy, false);
 
-	addEdge(argumentNodeId, templateNodeId, Edge::EDGE_TEMPLATE_ARGUMENT_OF, location);
+	addEdge(templateNodeId, argumentNodeId, Edge::EDGE_TEMPLATE_ARGUMENT, location);
 
 	return argumentNodeId;
 }
@@ -567,12 +567,12 @@ Id Storage::onTemplateDefaultArgumentTypeParsed(
 		defaultArgumentTypeUsage.location
 	);
 
-	Id defaultArgumentNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, defaultArgumentTypeUsage.dataType->getTypeNameHierarchy());
+	Id defaultArgumentNodeId = addNodeHierarchy(Node::NODE_TYPE, defaultArgumentTypeUsage.dataType->getTypeNameHierarchy(), false);
 	// does not need a source location because this type that is already defined (and therefore has a location).
 
-	Id argumentNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, templateArgumentTypeNameHierarchy);
+	Id argumentNodeId = addNodeHierarchy(Node::NODE_TYPE, templateArgumentTypeNameHierarchy, false);
 
-	addEdge(defaultArgumentNodeId, argumentNodeId, Edge::EDGE_TEMPLATE_DEFAULT_ARGUMENT_OF, defaultArgumentTypeUsage.location);
+	addEdge(argumentNodeId, defaultArgumentNodeId, Edge::EDGE_TEMPLATE_DEFAULT_ARGUMENT, defaultArgumentTypeUsage.location);
 
 	return defaultArgumentNodeId;
 }
@@ -583,12 +583,12 @@ Id Storage::onTemplateRecordParameterTypeParsed(
 ){
 	log("template record type parameter", templateParameterTypeNameHierarchy.getFullName(), location);
 
-	Id parameterNodeId = addNodeHierarchy(Node::NODE_TEMPLATE_PARAMETER_TYPE, templateParameterTypeNameHierarchy);
+	Id parameterNodeId = addNodeHierarchy(Node::NODE_TEMPLATE_PARAMETER_TYPE, templateParameterTypeNameHierarchy, true);
 	addSourceLocation(parameterNodeId, location, false);
 
-	Id recordNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, templateRecordNameHierarchy);
+	Id recordNodeId = addNodeHierarchy(Node::NODE_TYPE, templateRecordNameHierarchy, false);
 
-	addEdge(parameterNodeId, recordNodeId, Edge::EDGE_TEMPLATE_PARAMETER_OF, location);
+	addEdge(recordNodeId, parameterNodeId, Edge::EDGE_TEMPLATE_PARAMETER, location);
 
 	return parameterNodeId;
 }
@@ -609,10 +609,11 @@ Id Storage::onTemplateRecordSpecializationParsed(
 		specializedRecordNodeType = Node::NODE_STRUCT;
 	}
 
-	Id specializedNodeId = addNodeHierarchy(specializedRecordNodeType, specializedRecordNameHierarchy);
+	Id specializedNodeId = addNodeHierarchy(specializedRecordNodeType, specializedRecordNameHierarchy, true);
 	addSourceLocation(specializedNodeId, location, false);
 
-	Id recordNodeId = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, specializedFromNameHierarchy);
+	Id recordNodeId = addNodeHierarchy(Node::NODE_TYPE, specializedFromNameHierarchy, false);
+	addAccess(specializedNodeId, getAccess(recordNodeId));
 
 	addEdge(specializedNodeId, recordNodeId, Edge::EDGE_TEMPLATE_SPECIALIZATION_OF, location);
 
@@ -624,12 +625,11 @@ Id Storage::onTemplateFunctionParameterTypeParsed(
 ){
 	log("template function type parameter", templateParameterTypeNameHierarchy.getFullName(), location);
 
-	Id parameterNodeId = addNodeHierarchy(Node::NODE_TEMPLATE_PARAMETER_TYPE, templateParameterTypeNameHierarchy);
+	Id parameterNodeId = addNodeHierarchy(Node::NODE_TEMPLATE_PARAMETER_TYPE, templateParameterTypeNameHierarchy, true);
 	addSourceLocation(parameterNodeId, location, false);
 
-	Id functionNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_UNDEFINED_FUNCTION, function);
-
-	addEdge(parameterNodeId, functionNodeId, Edge::EDGE_TEMPLATE_PARAMETER_OF, location);
+	Id functionNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_FUNCTION, function, false);
+	addEdge(functionNodeId, parameterNodeId, Edge::EDGE_TEMPLATE_PARAMETER, location);
 
 	return parameterNodeId;
 }
@@ -639,10 +639,11 @@ Id Storage::onTemplateFunctionSpecializationParsed(
 ){
 	log("function template specialization", specializedFunction.getFullName(), location);
 
-	Id specializedNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_FUNCTION, specializedFunction);
+	Id specializedNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_FUNCTION, specializedFunction, true);
 	addSourceLocation(specializedNodeId, location, false);
 
-	Id functionNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_UNDEFINED_FUNCTION, templateFunction);
+	Id functionNodeId = addNodeHierarchyWithDistinctSignature(Node::NODE_FUNCTION, templateFunction, false);
+	addAccess(specializedNodeId, getAccess(functionNodeId));
 
 	addEdge(specializedNodeId, functionNodeId, Edge::EDGE_TEMPLATE_SPECIALIZATION_OF, location);
 
@@ -693,7 +694,7 @@ Id Storage::onMacroDefineParsed(const ParseLocation& location, const NameHierarc
 {
 	log("macro", macroNameHierarchy.getFullName(), location);
 
-	Id macroId = addNodeHierarchy(Node::NODE_MACRO, macroNameHierarchy);
+	Id macroId = addNodeHierarchy(Node::NODE_MACRO, macroNameHierarchy, true);
 	addSourceLocation(macroId, location);
 
 	Id fileNodeId = getFileNodeId(location.filePath);
@@ -706,7 +707,7 @@ Id Storage::onMacroExpandParsed(const ParseLocation &location, const NameHierarc
 {
 	log("macro use", macroNameHierarchy.getFullName(), location);
 
-	Id macroExpandId = addNodeHierarchy(Node::NODE_UNDEFINED_MACRO, macroNameHierarchy);
+	Id macroExpandId = addNodeHierarchy(Node::NODE_MACRO, macroNameHierarchy, false);
 	Id fileNodeId = getFileNodeId(location.filePath);
 	Id edgeId = addEdge(fileNodeId, macroExpandId, Edge::EDGE_MACRO_USAGE, location);
 
@@ -768,8 +769,14 @@ std::vector<SearchMatch> Storage::getAutocompletionMatches(const std::string& qu
 		Id elementId = *(match.tokenIds.cbegin());
 		if (m_sqliteStorage.isNode(elementId))
 		{
-			match.nodeType = Node::intToType(m_sqliteStorage.getNodeById(elementId).type);
+			StorageNode node = m_sqliteStorage.getNodeById(elementId);
+			match.nodeType = Node::intToType(node.type);
 			match.typeName = Node::getTypeString(match.nodeType);
+
+			if (!node.defined && match.nodeType != Node::NODE_UNDEFINED)
+			{
+				match.typeName = "undefined " + match.typeName;
+			}
 		}
 		else
 		{
@@ -1169,7 +1176,7 @@ std::shared_ptr<TextAccess> Storage::getFileContent(const FilePath& filePath) co
 	return m_sqliteStorage.getFileContentByPath(filePath.str());
 }
 
-Id Storage::addNodeHierarchy(Node::NodeType nodeType, NameHierarchy nameHierarchy, bool distinct)
+Id Storage::addNodeHierarchy(Node::NodeType nodeType, NameHierarchy nameHierarchy, bool defined, bool distinct)
 {
 	std::vector<Id> nameIds = addNameHierarchyElements(nameHierarchy);
 
@@ -1184,9 +1191,14 @@ Id Storage::addNodeHierarchy(Node::NodeType nodeType, NameHierarchy nameHierarch
 		const StorageNode node = m_sqliteStorage.getNodeByNameId(nameId);
 		Id nodeId = node.id;
 
+		if (nodeId && !node.defined && lastName && defined)
+		{
+			m_sqliteStorage.setNodeDefined(true, nodeId);
+		}
+
 		if (nodeId == 0 || (lastName && distinct))
 		{
-			nodeId = m_sqliteStorage.addNode(Node::typeToInt(type), nameId);
+			nodeId = m_sqliteStorage.addNode(Node::typeToInt(type), nameId, lastName & defined);
 
 			if (parentNodeId != 0)
 			{
@@ -1208,16 +1220,20 @@ Id Storage::addNodeHierarchy(Node::NodeType nodeType, NameHierarchy nameHierarch
 	return parentNodeId;
 }
 
-Id Storage::addNodeHierarchyWithDistinctSignature(Node::NodeType type, const ParseFunction& function)
+Id Storage::addNodeHierarchyWithDistinctSignature(Node::NodeType type, const ParseFunction& function, bool defined)
 {
 	std::string signature = ParserClient::functionSignatureStr(function);
 	Id nodeId = m_sqliteStorage.getNodeIdBySignature(signature);
 
 	if (!nodeId)
 	{
-		nodeId = addNodeHierarchy(type, function.nameHierarchy, true);
+		nodeId = addNodeHierarchy(type, function.nameHierarchy, defined, true);
 		m_sqliteStorage.addSignature(nodeId, signature);
 	}
+	else if (defined)
+	{
+		m_sqliteStorage.setNodeDefined(true, nodeId);
+	}
 
 	return nodeId;
 }
@@ -1486,7 +1502,8 @@ void Storage::addNodesToGraph(const std::vector<Id> nodeIds, Graph* graph) const
 		graph->createNode(
 			storageNode.id,
 			Node::intToType(storageNode.type),
-			m_tokenIndex.getNameHierarchyForTokenId(storageNode.id)
+			m_tokenIndex.getNameHierarchyForTokenId(storageNode.id),
+			storageNode.defined
 		);
 	}
 }
@@ -1525,9 +1542,9 @@ TokenComponentAccess::AccessType Storage::convertAccessType(ParserClient::Access
 	}
 }
 
-void Storage::addAccess(const Id nodeId, ParserClient::AccessType access)
+void Storage::addAccess(Id nodeId, TokenComponentAccess::AccessType access)
 {
-	if (access == ACCESS_NONE)
+	if (access == TokenComponentAccess::ACCESS_NONE)
 	{
 		return;
 	}
@@ -1539,7 +1556,23 @@ void Storage::addAccess(const Id nodeId, ParserClient::AccessType access)
 		return;
 	}
 
-	m_sqliteStorage.addComponentAccess(memberEdges[0].id, convertAccessType(access));
+	m_sqliteStorage.addComponentAccess(memberEdges[0].id, access);
+}
+
+void Storage::addAccess(Id nodeId, ParserClient::AccessType access)
+{
+	addAccess(nodeId, convertAccessType(access));
+}
+
+TokenComponentAccess::AccessType Storage::getAccess(Id nodeId) const
+{
+	std::vector<StorageEdge> memberEdges = m_sqliteStorage.getEdgesByTargetType(nodeId, Edge::EDGE_MEMBER);
+	if (memberEdges.size() == 1)
+	{
+		return TokenComponentAccess::intToType(m_sqliteStorage.getComponentAccessByMemberEdgeId(memberEdges[0].id).type);
+	}
+
+	return TokenComponentAccess::ACCESS_NONE;
 }
 
 void Storage::addComponentAccessToGraph(Graph* graph) const

src/lib/data/Storage.h

@@ -161,8 +161,8 @@ public:
 
 
 private:
-	Id addNodeHierarchy(Node::NodeType nodeType, NameHierarchy nameHierarchy, bool distinct = false);
-	Id addNodeHierarchyWithDistinctSignature(Node::NodeType type, const ParseFunction& function);
+	Id addNodeHierarchy(Node::NodeType nodeType, NameHierarchy nameHierarchy, bool defined, bool distinct = false);
+	Id addNodeHierarchyWithDistinctSignature(Node::NodeType type, const ParseFunction& function, bool defined);
 	std::vector<Id> addNameHierarchyElements(NameHierarchy nameHierarchy);
 	int addSourceLocation(int elementNodeId, const ParseLocation& location, bool isScope = false);
 
@@ -183,7 +183,9 @@ private:
 	void addEdgesToGraph(const std::vector<Id> edgeIds, Graph* graph) const;
 
 	TokenComponentAccess::AccessType convertAccessType(ParserClient::AccessType access) const;
-	void addAccess(const Id nodeId, ParserClient::AccessType access);
+	void addAccess(Id nodeId, TokenComponentAccess::AccessType access);
+	void addAccess(Id nodeId, ParserClient::AccessType access);
+	TokenComponentAccess::AccessType getAccess(Id nodeId) const;
 
 	void addComponentAccessToGraph(Graph* graph) const;
 

src/lib/data/StorageTypes.h

@@ -19,13 +19,14 @@ struct StorageEdge
 
 struct StorageNode
 {
-	StorageNode(Id id, int type, Id nameId)
-		: id(id), type(type), nameId(nameId)
+	StorageNode(Id id, int type, Id nameId, bool defined)
+		: id(id), type(type), nameId(nameId), defined(defined)
 	{}
 
 	Id id;
 	int type;
 	Id nameId;
+	bool defined;
 };
 
 struct StorageFile

src/lib/data/graph/Edge.cpp

@@ -38,11 +38,11 @@ Edge::EdgeType Edge::intToType(int value)
 	case 0x200:
 		return EDGE_TYPEDEF_OF;
 	case 0x400:
-		return EDGE_TEMPLATE_PARAMETER_OF;
+		return EDGE_TEMPLATE_PARAMETER;
 	case 0x800:
-		return EDGE_TEMPLATE_ARGUMENT_OF;
+		return EDGE_TEMPLATE_ARGUMENT;
 	case 0x1000:
-		return EDGE_TEMPLATE_DEFAULT_ARGUMENT_OF;
+		return EDGE_TEMPLATE_DEFAULT_ARGUMENT;
 	case 0x2000:
 		return EDGE_TEMPLATE_SPECIALIZATION_OF;
 	case 0x4000:
@@ -186,11 +186,11 @@ std::string Edge::getTypeString(EdgeType type)
 		return "use";
 	case EDGE_TYPEDEF_OF:
 		return "typedef";
-	case EDGE_TEMPLATE_PARAMETER_OF:
+	case EDGE_TEMPLATE_PARAMETER:
 		return "template_parameter";
-	case EDGE_TEMPLATE_ARGUMENT_OF:
+	case EDGE_TEMPLATE_ARGUMENT:
 		return "template_argument";
-	case EDGE_TEMPLATE_DEFAULT_ARGUMENT_OF:
+	case EDGE_TEMPLATE_DEFAULT_ARGUMENT:
 		return "template_default_argument";
 	case EDGE_TEMPLATE_SPECIALIZATION_OF:
 		return "template_specialization";
@@ -238,10 +238,10 @@ std::ostream& operator<<(std::ostream& ostream, const Edge& edge)
 
 bool Edge::checkType() const
 {
-	Node::NodeTypeMask complexTypeMask = Node::NODE_UNDEFINED_TYPE | Node::NODE_CLASS | Node::NODE_STRUCT | Node:: NODE_TEMPLATE_PARAMETER_TYPE;
-	Node::NodeTypeMask typeMask = Node::NODE_UNDEFINED | Node::NODE_ENUM | Node::NODE_TYPEDEF | complexTypeMask;
-	Node::NodeTypeMask variableMask = Node::NODE_UNDEFINED | Node::NODE_UNDEFINED_VARIABLE | Node::NODE_GLOBAL_VARIABLE | Node::NODE_FIELD;
-	Node::NodeTypeMask functionMask = Node::NODE_UNDEFINED_FUNCTION | Node::NODE_FUNCTION | Node::NODE_METHOD;
+	Node::NodeTypeMask complexTypeMask = Node::NODE_CLASS | Node::NODE_STRUCT | Node:: NODE_TEMPLATE_PARAMETER_TYPE;
+	Node::NodeTypeMask typeMask = Node::NODE_ENUM | Node::NODE_TYPEDEF | complexTypeMask;
+	Node::NodeTypeMask variableMask = Node::NODE_GLOBAL_VARIABLE | Node::NODE_FIELD;
+	Node::NodeTypeMask functionMask = Node::NODE_FUNCTION | Node::NODE_METHOD;
 
 	switch (m_type)
 	{
@@ -282,8 +282,8 @@ bool Edge::checkType() const
 		return true;
 
 	case EDGE_OVERRIDE:
-		if (!m_from->isType(Node::NODE_UNDEFINED_FUNCTION | Node::NODE_METHOD) ||
-			!m_to->isType(Node::NODE_UNDEFINED_FUNCTION | Node::NODE_METHOD))
+		if (!m_from->isType(Node::NODE_METHOD) ||
+			!m_to->isType(Node::NODE_METHOD))
 		{
 			break;
 		}
@@ -310,15 +310,15 @@ bool Edge::checkType() const
 		}
 		return true;
 
-	case EDGE_TEMPLATE_PARAMETER_OF:
+	case EDGE_TEMPLATE_PARAMETER:
 		if (!m_from->isType(Node::NODE_TEMPLATE_PARAMETER_TYPE) || !m_to->isType(typeMask | functionMask))
 		{
 			break;
 		}
 		return true;
 
-	case EDGE_TEMPLATE_ARGUMENT_OF:
-	case EDGE_TEMPLATE_DEFAULT_ARGUMENT_OF:
+	case EDGE_TEMPLATE_ARGUMENT:
+	case EDGE_TEMPLATE_DEFAULT_ARGUMENT:
 		if (!m_from->isType(typeMask) || !m_to->isType(typeMask | functionMask))
 		{
 			break;
@@ -346,7 +346,7 @@ bool Edge::checkType() const
 		}
 		return true;
 	case EDGE_MACRO_USAGE:
-		if(!m_to->isType(Node::NODE_MACRO | Node::NODE_UNDEFINED_MACRO) || !m_from->isType(Node::NODE_FILE))
+		if (!m_to->isType(Node::NODE_MACRO) || !m_from->isType(Node::NODE_FILE))
 		{
 			break;
 		}

src/lib/data/graph/Edge.h

@@ -29,9 +29,9 @@ public:
 		EDGE_INHERITANCE					= 0x80,
 		EDGE_OVERRIDE						= 0x100,
 		EDGE_TYPEDEF_OF						= 0x200,
-		EDGE_TEMPLATE_PARAMETER_OF			= 0x400,
-		EDGE_TEMPLATE_ARGUMENT_OF			= 0x800,
-		EDGE_TEMPLATE_DEFAULT_ARGUMENT_OF	= 0x1000,
+		EDGE_TEMPLATE_PARAMETER				= 0x400,
+		EDGE_TEMPLATE_ARGUMENT				= 0x800,
+		EDGE_TEMPLATE_DEFAULT_ARGUMENT		= 0x1000,
 		EDGE_TEMPLATE_SPECIALIZATION_OF		= 0x2000,
 
 		EDGE_INCLUDE						= 0x4000,

src/lib/data/graph/Graph.cpp

@@ -40,7 +40,7 @@ void Graph::forEachToken(std::function<void(Token*)> func) const
 	forEachEdge(func);
 }
 
-Node* Graph::createNode(Id id, Node::NodeType type, NameHierarchy nameHierarchy)
+Node* Graph::createNode(Id id, Node::NodeType type, NameHierarchy nameHierarchy, bool defined)
 {
 	Node* n = getNodeById(id);
 	if (n)
@@ -48,7 +48,7 @@ Node* Graph::createNode(Id id, Node::NodeType type, NameHierarchy nameHierarchy)
 		return n;
 	}
 
-	std::shared_ptr<Node> node = std::make_shared<Node>(id, type, nameHierarchy);
+	std::shared_ptr<Node> node = std::make_shared<Node>(id, type, nameHierarchy, defined);
 	m_nodes.emplace(node->getId(), node);
 	return node.get();
 }

src/lib/data/graph/Graph.h

@@ -20,7 +20,7 @@ public:
 	void forEachEdge(std::function<void(Edge*)> func) const;
 	void forEachToken(std::function<void(Token*)> func) const;
 
-	Node* createNode(Id id, Node::NodeType type, NameHierarchy nameHierarchy);
+	Node* createNode(Id id, Node::NodeType type, NameHierarchy nameHierarchy, bool defined);
 	Edge* createEdge(Id id, Edge::EdgeType type, Node* from, Node* to);
 
 	size_t getNodeCount() const;

src/lib/data/graph/Node.cpp

@@ -17,12 +17,10 @@ std::string Node::getTypeString(NodeType type)
 	{
 	case NODE_UNDEFINED:
 		return "undefined";
-	case NODE_UNDEFINED_FUNCTION:
-		return "undefined_function";
-	case NODE_UNDEFINED_VARIABLE:
-		return "undefined_variable";
-	case NODE_UNDEFINED_TYPE:
-		return "undefined_type";
+	case NODE_TYPE:
+		return "type";
+	case NODE_NAMESPACE:
+		return "namespace";
 	case NODE_CLASS:
 		return "class";
 	case NODE_STRUCT:
@@ -35,8 +33,6 @@ std::string Node::getTypeString(NodeType type)
 		return "function";
 	case NODE_METHOD:
 		return "method";
-	case NODE_NAMESPACE:
-		return "namespace";
 	case NODE_ENUM:
 		return "enum";
 	case NODE_ENUM_CONSTANT:
@@ -47,8 +43,6 @@ std::string Node::getTypeString(NodeType type)
 		return "template_parameter_type";
 	case NODE_FILE:
 		return "file";
-	case NODE_UNDEFINED_MACRO:
-		return "undefined_macro";
 	case NODE_MACRO:
 		return "macro";
 	}
@@ -65,58 +59,44 @@ Node::NodeType Node::intToType(int value)
 {
 	switch (value)
 	{
-	case 0x1:
-		return NODE_UNDEFINED;
 	case 0x2:
-		return NODE_UNDEFINED_TYPE;
+		return NODE_TYPE;
 	case 0x4:
-		return NODE_UNDEFINED_VARIABLE;
-	case 0x8:
-		return NODE_UNDEFINED_FUNCTION;
-	case 0x10:
-		return NODE_STRUCT;
-	case 0x20:
-		return NODE_CLASS;
-	case 0x40:
-		return NODE_GLOBAL_VARIABLE;
-	case 0x80:
-		return NODE_FIELD;
-	case 0x100:
-		return NODE_FUNCTION;
-	case 0x200:
-		return NODE_METHOD;
-	case 0x400:
 		return NODE_NAMESPACE;
-	case 0x800:
+	case 0x8:
+		return NODE_STRUCT;
+	case 0x10:
+		return NODE_CLASS;
+	case 0x20:
+		return NODE_GLOBAL_VARIABLE;
+	case 0x40:
+		return NODE_FIELD;
+	case 0x80:
+		return NODE_FUNCTION;
+	case 0x100:
+		return NODE_METHOD;
+	case 0x200:
 		return NODE_ENUM;
-	case 0x1000:
+	case 0x400:
 		return NODE_ENUM_CONSTANT;
-	case 0x2000:
+	case 0x800:
 		return NODE_TYPEDEF;
-	case 0x4000:
+	case 0x1000:
 		return NODE_TEMPLATE_PARAMETER_TYPE;
-	case 0x8000:
+	case 0x2000:
 		return NODE_FILE;
-	case 0x10000:
-		return NODE_UNDEFINED_MACRO;
-	case 0x20000:
+	case 0x4000:
 		return NODE_MACRO;
 	}
 
 	return NODE_UNDEFINED;
 }
 
-Node::Node(Id id, NodeType type, NameHierarchy nameHierarchy)
+Node::Node(Id id, NodeType type, NameHierarchy nameHierarchy, bool defined)
 	: Token(id)
 	, m_type(type)
 	, m_nameHierarchy(nameHierarchy)
-{
-}
-
-Node::Node(const Node& other)
-	: Token(other)
-	, m_type(other.m_type)
-	, m_nameHierarchy(other.m_nameHierarchy)
+	, m_defined(defined)
 {
 }
 
@@ -131,7 +111,7 @@ Node::NodeType Node::getType() const
 
 void Node::setType(NodeType type)
 {
-	if (!isType(type | NODE_UNDEFINED | NODE_UNDEFINED_FUNCTION | NODE_UNDEFINED_VARIABLE | NODE_UNDEFINED_TYPE))
+	if (!isType(type | NODE_UNDEFINED))
 	{
 		LOG_WARNING(
 			"Cannot change NodeType after it was already set from " + getTypeString() + " to " + getTypeString(type)
@@ -161,6 +141,16 @@ NameHierarchy Node::getNameHierarchy() const
 	return m_nameHierarchy;
 }
 
+bool Node::isDefined() const
+{
+	return m_defined;
+}
+
+void Node::setDefined(bool defined)
+{
+	m_defined = defined;
+}
+
 const std::vector<Edge*>& Node::getEdges() const
 {
 	return m_edges;

src/lib/data/graph/Node.h

@@ -20,30 +20,26 @@ class Node
 {
 public:
 	typedef int NodeTypeMask;
-	// list undefined types first to ensure that they get replaced by their defined counterparts when it is parsed.
 	enum NodeType : NodeTypeMask
 	{
 		NODE_UNDEFINED					= 0x1,
-		NODE_UNDEFINED_TYPE				= 0x2,
-		NODE_UNDEFINED_VARIABLE			= 0x4,
-		NODE_UNDEFINED_FUNCTION			= 0x8,
+		NODE_TYPE						= 0x2,
 
-		NODE_STRUCT						= 0x10,
-		NODE_CLASS						= 0x20,
-		NODE_GLOBAL_VARIABLE			= 0x40,
-		NODE_FIELD						= 0x80,
-		NODE_FUNCTION					= 0x100,
-		NODE_METHOD						= 0x200,
-		NODE_NAMESPACE					= 0x400,
-		NODE_ENUM						= 0x800,
-		NODE_ENUM_CONSTANT				= 0x1000,
-		NODE_TYPEDEF					= 0x2000,
-		NODE_TEMPLATE_PARAMETER_TYPE	= 0x4000,
+		NODE_NAMESPACE					= 0x4,
+		NODE_STRUCT						= 0x8,
+		NODE_CLASS						= 0x10,
+		NODE_GLOBAL_VARIABLE			= 0x20,
+		NODE_FIELD						= 0x40,
+		NODE_FUNCTION					= 0x80,
+		NODE_METHOD						= 0x100,
 
-		NODE_FILE						= 0x8000,
+		NODE_ENUM						= 0x200,
+		NODE_ENUM_CONSTANT				= 0x400,
+		NODE_TYPEDEF					= 0x800,
+		NODE_TEMPLATE_PARAMETER_TYPE	= 0x1000,
 
-		NODE_UNDEFINED_MACRO			= 0x10000,
-		NODE_MACRO						= 0x20000,
+		NODE_FILE						= 0x2000,
+		NODE_MACRO						= 0x4000
 	};
 
 	static std::string getTypeString(NodeType type);
@@ -52,8 +48,7 @@ public:
 
 	static const NodeTypeMask NODE_NOT_VISIBLE;
 
-	Node(Id id, NodeType type, NameHierarchy nameHierarchy);
-	Node(const Node& other);
+	Node(Id id, NodeType type, NameHierarchy nameHierarchy, bool defined);
 	virtual ~Node();
 
 	NodeType getType() const;
@@ -64,6 +59,9 @@ public:
 	std::string getFullName() const;
 	NameHierarchy getNameHierarchy() const;
 
+	bool isDefined() const;
+	void setDefined(bool defined);
+
 	const std::vector<Edge*>& getEdges() const;
 
 	void addEdge(Edge* edge);
@@ -105,6 +103,7 @@ private:
 
 	NodeType m_type;
 	NameHierarchy m_nameHierarchy;
+	bool m_defined;
 };
 
 std::ostream& operator<<(std::ostream& ostream, const Node& node);