ynkmr/Sourcetrail
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

data: NameHierarchy class

Browse Source 
* replaced vector of strings as name hierarchy by a new NameHierarchy class.
* Adjusted code in ASTVisitor, Storage and various test cases.
This commit is contained in:
malte_langkabel
2015-03-28 16:57:30 +01:00
parent 07ca387326
commit bdbd266a67
27 changed files with 485 additions and 283 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/lib/CMakeLists.txt
+5
View File
@@ -137,6 +137,11 @@ add_files(
data/location/TokenLocationLine.cpp data/location/TokenLocationLine.cpp
data/location/TokenLocationLine.h data/location/TokenLocationLine.h
data/name/NameElement.cpp
data/name/NameElement.h
data/name/NameHierarchy.cpp
data/name/NameHierarchy.h
data/parser/ParseFunction.cpp data/parser/ParseFunction.cpp
data/parser/ParseFunction.h data/parser/ParseFunction.h
data/parser/ParseLocation.cpp data/parser/ParseLocation.cpp
src/lib/data/Storage.cpp
+45 -42
View File
@@ -26,7 +26,9 @@ Storage::Storage()
{ {
for (const std::pair<std::string, QueryCommand::CommandType>& p : QueryCommand::getCommandTypeMap()) for (const std::pair<std::string, QueryCommand::CommandType>& p : QueryCommand::getCommandTypeMap())
{ {
m_filterIndex.addNode(std::vector<std::string>(1, p.first)); NameHierarchy commandNameHierarchy;
commandNameHierarchy.push(std::make_shared<NameElement>(p.first));
m_filterIndex.addNode(commandNameHierarchy);
} }
} }
@@ -197,10 +199,10 @@ void Storage::onError(const ParseLocation& location, const std::string& message)
} }
Id Storage::onTypedefParsed( Id Storage::onTypedefParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, const ParseTypeUsage& underlyingType, const ParseLocation& location, const NameHierarchy& nameHierarchy, const ParseTypeUsage& underlyingType,
AccessType access AccessType access
){ ){
log("typedef", utility::join(nameHierarchy, "::") + " -> " + underlyingType.dataType->getFullTypeName(), location); log("typedef", nameHierarchy.getFullName() + " -> " + underlyingType.dataType->getFullTypeName(), location);
Node* node = addNodeHierarchy(Node::NODE_TYPEDEF, nameHierarchy); Node* node = addNodeHierarchy(Node::NODE_TYPEDEF, nameHierarchy);
addAccess(node, access); addAccess(node, access);
@@ -211,10 +213,10 @@ Id Storage::onTypedefParsed(
} }
Id Storage::onClassParsed( Id Storage::onClassParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, AccessType access, const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access,
const ParseLocation& scopeLocation const ParseLocation& scopeLocation
){ ){
log("class", utility::join(nameHierarchy, "::"), location); log("class", nameHierarchy.getFullName(), location);
Node* node = addNodeHierarchy(Node::NODE_CLASS, nameHierarchy); Node* node = addNodeHierarchy(Node::NODE_CLASS, nameHierarchy);
addAccess(node, access); addAccess(node, access);
@@ -225,10 +227,10 @@ Id Storage::onClassParsed(
} }
Id Storage::onStructParsed( Id Storage::onStructParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, AccessType access, const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access,
const ParseLocation& scopeLocation const ParseLocation& scopeLocation
){ ){
log("struct", utility::join(nameHierarchy, "::"), location); log("struct", nameHierarchy.getFullName(), location);
Node* node = addNodeHierarchy(Node::NODE_STRUCT, nameHierarchy); Node* node = addNodeHierarchy(Node::NODE_STRUCT, nameHierarchy);
addAccess(node, access); addAccess(node, access);
@@ -345,9 +347,9 @@ Id Storage::onMethodParsed(
} }
Id Storage::onNamespaceParsed( Id Storage::onNamespaceParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, const ParseLocation& scopeLocation const ParseLocation& location, const NameHierarchy& nameHierarchy, const ParseLocation& scopeLocation
){ ){
log("namespace", utility::join(nameHierarchy, "::"), location); log("namespace", nameHierarchy.getFullName(), location);
Node* node = addNodeHierarchy(Node::NODE_NAMESPACE, nameHierarchy); Node* node = addNodeHierarchy(Node::NODE_NAMESPACE, nameHierarchy);
if (location.isValid()) if (location.isValid())
@@ -360,10 +362,10 @@ Id Storage::onNamespaceParsed(
} }
Id Storage::onEnumParsed( Id Storage::onEnumParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, AccessType access, const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access,
const ParseLocation& scopeLocation const ParseLocation& scopeLocation
){ ){
log("enum", utility::join(nameHierarchy, "::"), location); log("enum", nameHierarchy.getFullName(), location);
Node* node = addNodeHierarchy(Node::NODE_ENUM, nameHierarchy); Node* node = addNodeHierarchy(Node::NODE_ENUM, nameHierarchy);
addAccess(node, access); addAccess(node, access);
@@ -373,9 +375,9 @@ Id Storage::onEnumParsed(
return node->getId(); return node->getId();
} }
Id Storage::onEnumConstantParsed(const ParseLocation& location, const std::vector<std::string>& nameHierarchy) Id Storage::onEnumConstantParsed(const ParseLocation& location, const NameHierarchy& nameHierarchy)
{ {
log("enum constant", utility::join(nameHierarchy, "::"), location); log("enum constant", nameHierarchy.getFullName(), location);
Node* node = addNodeHierarchy(Node::NODE_ENUM_CONSTANT, nameHierarchy); Node* node = addNodeHierarchy(Node::NODE_ENUM_CONSTANT, nameHierarchy);
addTokenLocation(node, location); addTokenLocation(node, location);
@@ -384,10 +386,10 @@ Id Storage::onEnumConstantParsed(const ParseLocation& location, const std::vecto
} }
Id Storage::onInheritanceParsed( Id Storage::onInheritanceParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, const ParseLocation& location, const NameHierarchy& nameHierarchy,
const std::vector<std::string>& baseNameHierarchy, AccessType access const NameHierarchy& baseNameHierarchy, AccessType access
){ ){
log("inheritance", utility::join(nameHierarchy, "::") + " : " + utility::join(baseNameHierarchy, "::"), location); log("inheritance", nameHierarchy.getFullName() + " : " + baseNameHierarchy.getFullName(), location);
Node* node = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, nameHierarchy); Node* node = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, nameHierarchy);
Node* baseNode = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, baseNameHierarchy); Node* baseNode = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, baseNameHierarchy);
@@ -442,9 +444,9 @@ Id Storage::onCallParsed(const ParseLocation& location, const ParseVariable& cal
Id Storage::onVariableUsageParsed( Id Storage::onVariableUsageParsed(
const std::string kind, const ParseLocation& location, const ParseFunction& user, const std::string kind, const ParseLocation& location, const ParseFunction& user,
const std::vector<std::string>& usedNameHierarchy const NameHierarchy& usedNameHierarchy
){ ){
log(kind, user.getFullName() + " -> " + utility::join(usedNameHierarchy, "::"), location); log(kind, user.getFullName() + " -> " + usedNameHierarchy.getFullName(), location);
Node* userNode = addNodeHierarchyWithDistinctSignature(Node::NODE_UNDEFINED_FUNCTION, user); Node* userNode = addNodeHierarchyWithDistinctSignature(Node::NODE_UNDEFINED_FUNCTION, user);
Node* usedNode = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, usedNameHierarchy); Node* usedNode = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, usedNameHierarchy);
@@ -456,21 +458,21 @@ Id Storage::onVariableUsageParsed(
} }
Id Storage::onFieldUsageParsed( Id Storage::onFieldUsageParsed(
const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy
){ ){
return onVariableUsageParsed("field usage", location, user, usedNameHierarchy); return onVariableUsageParsed("field usage", location, user, usedNameHierarchy);
} }
Id Storage::onGlobalVariableUsageParsed( // or static variable used Id Storage::onGlobalVariableUsageParsed( // or static variable used
const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy
){ ){
return onVariableUsageParsed("global usage", location, user, usedNameHierarchy); return onVariableUsageParsed("global usage", location, user, usedNameHierarchy);
} }
Id Storage::onGlobalVariableUsageParsed( Id Storage::onGlobalVariableUsageParsed(
const ParseLocation& location, const ParseVariable& user, const std::vector<std::string>& usedNameHierarchy) const ParseLocation& location, const ParseVariable& user, const NameHierarchy& usedNameHierarchy)
{ {
log("global usage", user.getFullName() + " -> " + utility::join(usedNameHierarchy, "::"), location); log("global usage", user.getFullName() + " -> " + usedNameHierarchy.getFullName(), location);
Node* userNode = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, user.nameHierarchy); Node* userNode = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, user.nameHierarchy);
Node* usedNode = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, usedNameHierarchy); Node* usedNode = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, usedNameHierarchy);
@@ -482,15 +484,15 @@ Id Storage::onGlobalVariableUsageParsed(
} }
Id Storage::onEnumConstantUsageParsed( Id Storage::onEnumConstantUsageParsed(
const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy
){ ){
return onVariableUsageParsed("enum constant usage", location, user, usedNameHierarchy); return onVariableUsageParsed("enum constant usage", location, user, usedNameHierarchy);
} }
Id Storage::onEnumConstantUsageParsed( Id Storage::onEnumConstantUsageParsed(
const ParseLocation& location, const ParseVariable& user, const std::vector<std::string>& usedNameHierarchy const ParseLocation& location, const ParseVariable& user, const NameHierarchy& usedNameHierarchy
){ ){
log("enum constant usage", user.getFullName() + " -> " + utility::join(usedNameHierarchy, "::"), location); log("enum constant usage", user.getFullName() + " -> " + usedNameHierarchy.getFullName(), location);
Node* userNode = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, user.nameHierarchy); Node* userNode = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, user.nameHierarchy);
Node* usedNode = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, usedNameHierarchy); Node* usedNode = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, usedNameHierarchy);
@@ -534,12 +536,12 @@ Id Storage::onTypeUsageParsed(const ParseTypeUsage& type, const ParseVariable& v
} }
Id Storage::onTemplateArgumentTypeParsed( Id Storage::onTemplateArgumentTypeParsed(
const ParseLocation& location, const std::vector<std::string>& argumentNameHierarchy, const ParseLocation& location, const NameHierarchy& argumentNameHierarchy,
const std::vector<std::string>& templateNameHierarchy) const NameHierarchy& templateNameHierarchy)
{ {
log( log(
"template argument type", "template argument type",
utility::join(argumentNameHierarchy, "::") + " -> " + utility::join(templateNameHierarchy, "::"), argumentNameHierarchy.getFullName() + " -> " + templateNameHierarchy.getFullName(),
location location
); );
@@ -556,12 +558,11 @@ Id Storage::onTemplateArgumentTypeParsed(
} }
Id Storage::onTemplateDefaultArgumentTypeParsed( Id Storage::onTemplateDefaultArgumentTypeParsed(
const ParseTypeUsage& defaultArgumentType, const std::vector<std::string>& templateArgumentTypeNameHierarchy const ParseTypeUsage& defaultArgumentType, const NameHierarchy& templateArgumentTypeNameHierarchy
){ ){
log( log(
"template default argument", "template default argument",
utility::join(defaultArgumentType.dataType->getTypeNameHierarchy(), "::") + defaultArgumentType.dataType->getTypeNameHierarchy().getFullName() + " -> " + templateArgumentTypeNameHierarchy.getFullName(),
" -> " + utility::join(templateArgumentTypeNameHierarchy, "::"),
defaultArgumentType.location defaultArgumentType.location
); );
@@ -577,10 +578,10 @@ Id Storage::onTemplateDefaultArgumentTypeParsed(
} }
Id Storage::onTemplateRecordParameterTypeParsed( Id Storage::onTemplateRecordParameterTypeParsed(
const ParseLocation& location, const std::vector<std::string>& templateParameterTypeNameHierarchy, const ParseLocation& location, const NameHierarchy& templateParameterTypeNameHierarchy,
const std::vector<std::string>& templateRecordNameHierarchy const NameHierarchy& templateRecordNameHierarchy
){ ){
log("template record type parameter", utility::join(templateParameterTypeNameHierarchy, "::"), location); log("template record type parameter", templateParameterTypeNameHierarchy.getFullName(), location);
Node* templateParameterNode = addNodeHierarchy(Node::NODE_TEMPLATE_PARAMETER_TYPE, templateParameterTypeNameHierarchy); Node* templateParameterNode = addNodeHierarchy(Node::NODE_TEMPLATE_PARAMETER_TYPE, templateParameterTypeNameHierarchy);
addTokenLocation(templateParameterNode, location); addTokenLocation(templateParameterNode, location);
@@ -592,12 +593,12 @@ Id Storage::onTemplateRecordParameterTypeParsed(
} }
Id Storage::onTemplateRecordSpecializationParsed( Id Storage::onTemplateRecordSpecializationParsed(
const ParseLocation& location, const std::vector<std::string>& specializedRecordNameHierarchy, const ParseLocation& location, const NameHierarchy& specializedRecordNameHierarchy,
const RecordType specializedRecordType, const std::vector<std::string>& specializedFromNameHierarchy const RecordType specializedRecordType, const NameHierarchy& specializedFromNameHierarchy
){ ){
log( log(
"template record specialization", "template record specialization",
utility::join(specializedRecordNameHierarchy, "::") + " -> " + utility::join(specializedFromNameHierarchy, "::"), specializedRecordNameHierarchy.getFullName() + " -> " + specializedFromNameHierarchy.getFullName(),
location location
); );
@@ -617,9 +618,9 @@ Id Storage::onTemplateRecordSpecializationParsed(
} }
Id Storage::onTemplateFunctionParameterTypeParsed( Id Storage::onTemplateFunctionParameterTypeParsed(
const ParseLocation& location, const std::vector<std::string>& templateParameterTypeNameHierarchy, const ParseFunction function const ParseLocation& location, const NameHierarchy& templateParameterTypeNameHierarchy, const ParseFunction function
){ ){
log("template function type parameter", utility::join(templateParameterTypeNameHierarchy, "::"), location); log("template function type parameter", templateParameterTypeNameHierarchy.getFullName(), location);
Node* templateParameterNode = addNodeHierarchy(Node::NODE_TEMPLATE_PARAMETER_TYPE, templateParameterTypeNameHierarchy); Node* templateParameterNode = addNodeHierarchy(Node::NODE_TEMPLATE_PARAMETER_TYPE, templateParameterTypeNameHierarchy);
addTokenLocation(templateParameterNode, location); addTokenLocation(templateParameterNode, location);
@@ -1069,7 +1070,7 @@ const SearchIndex& Storage::getSearchIndex() const
return m_tokenIndex; return m_tokenIndex;
} }
Node* Storage::addNodeHierarchy(Node::NodeType type, std::vector<std::string> nameHierarchy) Node* Storage::addNodeHierarchy(Node::NodeType type, NameHierarchy nameHierarchy)
{ {
SearchNode* searchNode = m_tokenIndex.addNode(nameHierarchy); SearchNode* searchNode = m_tokenIndex.addNode(nameHierarchy);
if (!searchNode) if (!searchNode)
@@ -1099,7 +1100,9 @@ Node* Storage::addNodeHierarchyWithDistinctSignature(Node::NodeType type, const
Node* Storage::addFileNode(const FilePath& filePath) Node* Storage::addFileNode(const FilePath& filePath)
{ {
Node* fileNode = addNodeHierarchy(Node::NODE_FILE, std::vector<std::string>(1, filePath.fileName())); NameHierarchy fileNameHierarchy;
fileNameHierarchy.push(std::make_shared<NameElement>(filePath.fileName()));
Node* fileNode = addNodeHierarchy(Node::NODE_FILE, fileNameHierarchy);
if (!fileNode->getComponent<TokenComponentFilePath>()) if (!fileNode->getComponent<TokenComponentFilePath>())
{ {
@@ -1175,7 +1178,7 @@ Edge* Storage::addTypeEdge(Node* node, Edge::EdgeType edgeType, const ParseTypeU
return nullptr; return nullptr;
} }
std::vector<std::string> nameHierarchy = typeUsage.dataType->getTypeNameHierarchy(); NameHierarchy nameHierarchy = typeUsage.dataType->getTypeNameHierarchy();
Node* typeNode = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, nameHierarchy); Node* typeNode = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, nameHierarchy);
if (!typeNode) if (!typeNode)
src/lib/data/Storage.h
+23 -23
View File
@@ -35,13 +35,13 @@ public:
virtual void onError(const ParseLocation& location, const std::string& message); virtual void onError(const ParseLocation& location, const std::string& message);
virtual Id onTypedefParsed( virtual Id onTypedefParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, const ParseLocation& location, const NameHierarchy& nameHierarchy,
const ParseTypeUsage& underlyingType, AccessType access); const ParseTypeUsage& underlyingType, AccessType access);
virtual Id onClassParsed( virtual Id onClassParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, AccessType access, const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access,
const ParseLocation& scopeLocation); const ParseLocation& scopeLocation);
virtual Id onStructParsed( virtual Id onStructParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, AccessType access, const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access,
const ParseLocation& scopeLocation); const ParseLocation& scopeLocation);
virtual Id onGlobalVariableParsed(const ParseLocation& location, const ParseVariable& variable); virtual Id onGlobalVariableParsed(const ParseLocation& location, const ParseVariable& variable);
@@ -54,16 +54,16 @@ public:
const ParseLocation& scopeLocation); const ParseLocation& scopeLocation);
virtual Id onNamespaceParsed( virtual Id onNamespaceParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, const ParseLocation& scopeLocation); const ParseLocation& location, const NameHierarchy& nameHierarchy, const ParseLocation& scopeLocation);
virtual Id onEnumParsed( virtual Id onEnumParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, AccessType access, const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access,
const ParseLocation& scopeLocation); const ParseLocation& scopeLocation);
virtual Id onEnumConstantParsed(const ParseLocation& location, const std::vector<std::string>& nameHierarchy); virtual Id onEnumConstantParsed(const ParseLocation& location, const NameHierarchy& nameHierarchy);
virtual Id onInheritanceParsed( virtual Id onInheritanceParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, const ParseLocation& location, const NameHierarchy& nameHierarchy,
const std::vector<std::string>& baseNameHierarchy, AccessType access); const NameHierarchy& baseNameHierarchy, AccessType access);
virtual Id onMethodOverrideParsed(const ParseFunction& base, const ParseFunction& overrider); virtual Id onMethodOverrideParsed(const ParseFunction& base, const ParseFunction& overrider);
virtual Id onCallParsed( virtual Id onCallParsed(
const ParseLocation& location, const ParseFunction& caller, const ParseFunction& callee); const ParseLocation& location, const ParseFunction& caller, const ParseFunction& callee);
@@ -71,33 +71,33 @@ public:
const ParseLocation& location, const ParseVariable& caller, const ParseFunction& callee); const ParseLocation& location, const ParseVariable& caller, const ParseFunction& callee);
Id onVariableUsageParsed( Id onVariableUsageParsed(
const std::string kind, const ParseLocation& location, const ParseFunction& user, const std::string kind, const ParseLocation& location, const ParseFunction& user,
const std::vector<std::string>& usedNameHierarchy); // helper const NameHierarchy& usedNameHierarchy); // helper
virtual Id onFieldUsageParsed( virtual Id onFieldUsageParsed(
const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy); const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy);
virtual Id onGlobalVariableUsageParsed( virtual Id onGlobalVariableUsageParsed(
const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy); const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy);
virtual Id onGlobalVariableUsageParsed( virtual Id onGlobalVariableUsageParsed(
const ParseLocation& location, const ParseVariable& user, const std::vector<std::string>& usedNameHierarchy); const ParseLocation& location, const ParseVariable& user, const NameHierarchy& usedNameHierarchy);
virtual Id onEnumConstantUsageParsed( virtual Id onEnumConstantUsageParsed(
const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy); const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy);
virtual Id onEnumConstantUsageParsed( virtual Id onEnumConstantUsageParsed(
const ParseLocation& location, const ParseVariable& user, const std::vector<std::string>& usedNameHierarchy); const ParseLocation& location, const ParseVariable& user, const NameHierarchy& usedNameHierarchy);
virtual Id onTypeUsageParsed(const ParseTypeUsage& type, const ParseFunction& function); virtual Id onTypeUsageParsed(const ParseTypeUsage& type, const ParseFunction& function);
virtual Id onTypeUsageParsed(const ParseTypeUsage& type, const ParseVariable& variable); virtual Id onTypeUsageParsed(const ParseTypeUsage& type, const ParseVariable& variable);
virtual Id onTemplateArgumentTypeParsed( virtual Id onTemplateArgumentTypeParsed(
const ParseLocation& location, const std::vector<std::string>& argumentNameHierarchy, const ParseLocation& location, const NameHierarchy& argumentNameHierarchy,
const std::vector<std::string>& templateNameHierarchy); const NameHierarchy& templateNameHierarchy);
virtual Id onTemplateDefaultArgumentTypeParsed( virtual Id onTemplateDefaultArgumentTypeParsed(
const ParseTypeUsage& type, const std::vector<std::string>& templateArgumentTypeNameHierarchy); const ParseTypeUsage& type, const NameHierarchy& templateArgumentTypeNameHierarchy);
virtual Id onTemplateRecordParameterTypeParsed( virtual Id onTemplateRecordParameterTypeParsed(
const ParseLocation& location, const std::vector<std::string>& templateParameterTypeNameHierarchy, const ParseLocation& location, const NameHierarchy& templateParameterTypeNameHierarchy,
const std::vector<std::string>& templateRecordNameHierarchy); const NameHierarchy& templateRecordNameHierarchy);
virtual Id onTemplateRecordSpecializationParsed( virtual Id onTemplateRecordSpecializationParsed(
const ParseLocation& location, const std::vector<std::string>& specializedRecordNameHierarchy, const ParseLocation& location, const NameHierarchy& specializedRecordNameHierarchy,
const RecordType specializedRecordType, const std::vector<std::string>& specializedFromNameHierarchy); const RecordType specializedRecordType, const NameHierarchy& specializedFromNameHierarchy);
virtual Id onTemplateFunctionParameterTypeParsed( virtual Id onTemplateFunctionParameterTypeParsed(
const ParseLocation& location, const std::vector<std::string>& templateParameterTypeNameHierarchy, const ParseFunction function); const ParseLocation& location, const NameHierarchy& templateParameterTypeNameHierarchy, const ParseFunction function);
virtual Id onTemplateFunctionSpecializationParsed( virtual Id onTemplateFunctionSpecializationParsed(
const ParseLocation& location, const ParseFunction specializedFunction, const ParseFunction templateFunction); const ParseLocation& location, const ParseFunction specializedFunction, const ParseFunction templateFunction);
@@ -133,7 +133,7 @@ protected:
const SearchIndex& getSearchIndex() const; const SearchIndex& getSearchIndex() const;
private: private:
Node* addNodeHierarchy(Node::NodeType type, std::vector<std::string> nameHierarchy); Node* addNodeHierarchy(Node::NodeType type, NameHierarchy nameHierarchy);
Node* addNodeHierarchyWithDistinctSignature(Node::NodeType type, const ParseFunction& function); Node* addNodeHierarchyWithDistinctSignature(Node::NodeType type, const ParseFunction& function);
Node* addFileNode(const FilePath& filePath); Node* addFileNode(const FilePath& filePath);
src/lib/data/name/NameElement.cpp
+15
View File
@@ -0,0 +1,15 @@
#include "data/name/NameElement.h"
NameElement::NameElement(std::string name)
: m_name(name)
{
}
NameElement::~NameElement()
{
}
std::string NameElement::getFullName() const
{
return m_name;
}
src/lib/data/name/NameElement.h
+18
View File
@@ -0,0 +1,18 @@
#ifndef NAME_ELEMENT_H
#define NAME_ELEMENT_H
#include <string>
class NameElement
{
public:
NameElement(std::string name);
~NameElement();
std::string getFullName() const;
private:
std::string m_name;
};
#endif // NAME_ELEMENT_H
src/lib/data/name/NameHierarchy.cpp
+48
View File
@@ -0,0 +1,48 @@
#include "data/name/NameHierarchy.h"
NameHierarchy::NameHierarchy()
{
}
NameHierarchy::~NameHierarchy()
{
}
void NameHierarchy::push(std::shared_ptr<NameElement> element)
{
m_elements.push_back(element);
}
void NameHierarchy::pop()
{
m_elements.pop_back();
}
std::shared_ptr<NameElement> NameHierarchy::back()
{
return m_elements.back();
}
std::shared_ptr<NameElement> NameHierarchy::operator[](size_t pos) const
{
return m_elements[pos];
}
size_t NameHierarchy::size() const
{
return m_elements.size();
}
std::string NameHierarchy::getFullName() const
{
std::string name;
for (int i = 0; i < m_elements.size(); i++)
{
name += m_elements[i]->getFullName();
if (i < m_elements.size() - 1)
{
name += "::";
}
}
return name;
}
src/lib/data/name/NameHierarchy.h
+28
View File
@@ -0,0 +1,28 @@
#ifndef NAME_HIERARCHY_H
#define NAME_HIERARCHY_H
#include <memory>
#include <string>
#include <vector>
#include "data/name/NameElement.h"
class NameHierarchy
{
public:
NameHierarchy();
~NameHierarchy();
void push(std::shared_ptr<NameElement> element);
void pop();
std::shared_ptr<NameElement> back();
std::shared_ptr<NameElement> operator[](size_t pos) const;
size_t size() const;
std::string getFullName() const;
private:
std::vector<std::shared_ptr<NameElement>> m_elements;
};
#endif // NAME_ELEMENT_H
src/lib/data/parser/ParseFunction.cpp
+2 -2
View File
@@ -4,7 +4,7 @@
ParseFunction::ParseFunction( ParseFunction::ParseFunction(
const ParseTypeUsage& returnType, const ParseTypeUsage& returnType,
const std::vector<std::string>& nameHierarchy, const NameHierarchy& nameHierarchy,
const std::vector<ParseTypeUsage>& parameters, const std::vector<ParseTypeUsage>& parameters,
bool isStatic, bool isStatic,
bool isConst bool isConst
@@ -19,5 +19,5 @@ ParseFunction::ParseFunction(
std::string ParseFunction::getFullName() const std::string ParseFunction::getFullName() const
{ {
return utility::join(nameHierarchy, "::"); return nameHierarchy.getFullName();
} }
src/lib/data/parser/ParseFunction.h
+3 -4
View File
@@ -1,15 +1,14 @@
#ifndef PARSE_FUNCTION_H #ifndef PARSE_FUNCTION_H
#define PARSE_FUNCTION_H #define PARSE_FUNCTION_H
#include <string> #include "data/name/NameHierarchy.h"
#include "data/parser/ParseTypeUsage.h" #include "data/parser/ParseTypeUsage.h"
struct ParseFunction struct ParseFunction
{ {
ParseFunction( ParseFunction(
const ParseTypeUsage& returnType, const ParseTypeUsage& returnType,
const std::vector<std::string>& nameHierarchy, const NameHierarchy& nameHierarchy,
const std::vector<ParseTypeUsage>& parameters, const std::vector<ParseTypeUsage>& parameters,
bool isStatic = false, bool isStatic = false,
bool isConst = false bool isConst = false
@@ -18,7 +17,7 @@ struct ParseFunction
std::string getFullName() const; std::string getFullName() const;
const ParseTypeUsage returnType; const ParseTypeUsage returnType;
const std::vector<std::string> nameHierarchy; const NameHierarchy nameHierarchy;
const std::vector<ParseTypeUsage> parameters; const std::vector<ParseTypeUsage> parameters;
const bool isStatic; const bool isStatic;
const bool isConst; const bool isConst;
src/lib/data/parser/ParseVariable.cpp
+3 -3
View File
@@ -2,7 +2,7 @@
#include "utility/utilityString.h" #include "utility/utilityString.h"
ParseVariable::ParseVariable(const ParseTypeUsage& type, const std::vector<std::string>& nameHierarchy, bool isStatic) ParseVariable::ParseVariable(const ParseTypeUsage& type, const NameHierarchy& nameHierarchy, bool isStatic)
: type(type) : type(type)
, nameHierarchy(nameHierarchy) , nameHierarchy(nameHierarchy)
, isStatic(isStatic) , isStatic(isStatic)
@@ -11,5 +11,5 @@ ParseVariable::ParseVariable(const ParseTypeUsage& type, const std::vector<std::
std::string ParseVariable::getFullName() const std::string ParseVariable::getFullName() const
{ {
return utility::join(nameHierarchy, "::"); return nameHierarchy.getFullName();
} }
src/lib/data/parser/ParseVariable.h
+3 -2
View File
@@ -3,16 +3,17 @@
#include <string> #include <string>
#include "data/name/NameHierarchy.h"
#include "data/parser/ParseTypeUsage.h" #include "data/parser/ParseTypeUsage.h"
struct ParseVariable struct ParseVariable
{ {
ParseVariable(const ParseTypeUsage& type, const std::vector<std::string>& nameHierarchy, bool isStatic); ParseVariable(const ParseTypeUsage& type, const NameHierarchy& nameHierarchy, bool isStatic);
std::string getFullName() const; std::string getFullName() const;
const ParseTypeUsage type; const ParseTypeUsage type;
const std::vector<std::string> nameHierarchy; const NameHierarchy nameHierarchy;
const bool isStatic; const bool isStatic;
}; };
src/lib/data/parser/ParserClient.h
+22 -21
View File
@@ -5,6 +5,7 @@
#include <vector> #include <vector>
#include "utility/types.h" #include "utility/types.h"
#include "data/name/NameHierarchy.h"
struct ParseFunction; struct ParseFunction;
struct ParseLocation; struct ParseLocation;
@@ -52,13 +53,13 @@ public:
virtual void onError(const ParseLocation& location, const std::string& message) = 0; virtual void onError(const ParseLocation& location, const std::string& message) = 0;
virtual Id onTypedefParsed( virtual Id onTypedefParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, const ParseLocation& location, const NameHierarchy& nameHierarchy,
const ParseTypeUsage& underlyingType, AccessType access) = 0; const ParseTypeUsage& underlyingType, AccessType access) = 0;
virtual Id onClassParsed( virtual Id onClassParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, AccessType access, const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access,
const ParseLocation& scopeLocation) = 0; const ParseLocation& scopeLocation) = 0;
virtual Id onStructParsed( virtual Id onStructParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, AccessType access, const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access,
const ParseLocation& scopeLocation) = 0; const ParseLocation& scopeLocation) = 0;
virtual Id onGlobalVariableParsed(const ParseLocation& location, const ParseVariable& variable) = 0; virtual Id onGlobalVariableParsed(const ParseLocation& location, const ParseVariable& variable) = 0;
@@ -71,48 +72,48 @@ public:
const ParseLocation& scopeLocation) = 0; const ParseLocation& scopeLocation) = 0;
virtual Id onNamespaceParsed( virtual Id onNamespaceParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, const ParseLocation& location, const NameHierarchy& nameHierarchy,
const ParseLocation& scopeLocation) = 0; const ParseLocation& scopeLocation) = 0;
virtual Id onEnumParsed( virtual Id onEnumParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, AccessType access, const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access,
const ParseLocation& scopeLocation) = 0; const ParseLocation& scopeLocation) = 0;
virtual Id onEnumConstantParsed(const ParseLocation& location, const std::vector<std::string>& nameHierarchy) = 0; virtual Id onEnumConstantParsed(const ParseLocation& location, const NameHierarchy& nameHierarchy) = 0;
virtual Id onInheritanceParsed( virtual Id onInheritanceParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, const ParseLocation& location, const NameHierarchy& nameHierarchy,
const std::vector<std::string>& baseNameHierarchy, AccessType access) = 0; const NameHierarchy& baseNameHierarchy, AccessType access) = 0;
virtual Id onMethodOverrideParsed(const ParseFunction& base, const ParseFunction& overrider) = 0; virtual Id onMethodOverrideParsed(const ParseFunction& base, const ParseFunction& overrider) = 0;
virtual Id onCallParsed( virtual Id onCallParsed(
const ParseLocation& location, const ParseFunction& caller, const ParseFunction& callee) = 0; const ParseLocation& location, const ParseFunction& caller, const ParseFunction& callee) = 0;
virtual Id onCallParsed( virtual Id onCallParsed(
const ParseLocation& location, const ParseVariable& caller, const ParseFunction& callee) = 0; const ParseLocation& location, const ParseVariable& caller, const ParseFunction& callee) = 0;
virtual Id onFieldUsageParsed( virtual Id onFieldUsageParsed(
const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy) = 0; const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy) = 0;
virtual Id onGlobalVariableUsageParsed( virtual Id onGlobalVariableUsageParsed(
const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy) = 0; const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy) = 0;
virtual Id onGlobalVariableUsageParsed( virtual Id onGlobalVariableUsageParsed(
const ParseLocation& location, const ParseVariable& user, const std::vector<std::string>& usedNameHierarchy) = 0; const ParseLocation& location, const ParseVariable& user, const NameHierarchy& usedNameHierarchy) = 0;
virtual Id onEnumConstantUsageParsed( virtual Id onEnumConstantUsageParsed(
const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy) = 0; const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy) = 0;
virtual Id onEnumConstantUsageParsed( virtual Id onEnumConstantUsageParsed(
const ParseLocation& location, const ParseVariable& user, const std::vector<std::string>& usedNameHierarchy) = 0; const ParseLocation& location, const ParseVariable& user, const NameHierarchy& usedNameHierarchy) = 0;
virtual Id onTypeUsageParsed(const ParseTypeUsage& type, const ParseFunction& function) = 0; virtual Id onTypeUsageParsed(const ParseTypeUsage& type, const ParseFunction& function) = 0;
virtual Id onTypeUsageParsed(const ParseTypeUsage& type, const ParseVariable& variable) = 0; virtual Id onTypeUsageParsed(const ParseTypeUsage& type, const ParseVariable& variable) = 0;
virtual Id onTemplateArgumentTypeParsed( virtual Id onTemplateArgumentTypeParsed(
const ParseLocation& location, const std::vector<std::string>& argumentNameHierarchy, const ParseLocation& location, const NameHierarchy& argumentNameHierarchy,
const std::vector<std::string>& templateNameHierarchy) = 0; const NameHierarchy& templateNameHierarchy) = 0;
virtual Id onTemplateDefaultArgumentTypeParsed( virtual Id onTemplateDefaultArgumentTypeParsed(
const ParseTypeUsage& type, const std::vector<std::string>& templateArgumentTypeNameHierarchy) = 0; const ParseTypeUsage& type, const NameHierarchy& templateArgumentTypeNameHierarchy) = 0;
virtual Id onTemplateRecordParameterTypeParsed( virtual Id onTemplateRecordParameterTypeParsed(
const ParseLocation& location, const std::vector<std::string>& templateParameterTypeNameHierarchy, const ParseLocation& location, const NameHierarchy& templateParameterTypeNameHierarchy,
const std::vector<std::string>& templateRecordNameHierarchy) = 0; const NameHierarchy& templateRecordNameHierarchy) = 0;
virtual Id onTemplateRecordSpecializationParsed( virtual Id onTemplateRecordSpecializationParsed(
const ParseLocation& location, const std::vector<std::string>& specializedRecordNameHierarchy, const ParseLocation& location, const NameHierarchy& specializedRecordNameHierarchy,
const RecordType specializedRecordType, const std::vector<std::string>& specializedFromNameHierarchy) = 0; const RecordType specializedRecordType, const NameHierarchy& specializedFromNameHierarchy) = 0;
virtual Id onTemplateFunctionParameterTypeParsed( virtual Id onTemplateFunctionParameterTypeParsed(
const ParseLocation& location, const std::vector<std::string>& templateParameterTypeNameHierarchy, const ParseLocation& location, const NameHierarchy& templateParameterTypeNameHierarchy,
const ParseFunction function) = 0; const ParseFunction function) = 0;
virtual Id onTemplateFunctionSpecializationParsed( virtual Id onTemplateFunctionSpecializationParsed(
const ParseLocation& location, const ParseFunction specializedFunction, const ParseFunction templateFunction) = 0; const ParseLocation& location, const ParseFunction specializedFunction, const ParseFunction templateFunction) = 0;
src/lib/data/parser/cxx/ASTVisitor.cpp
+9 -9
View File
@@ -311,10 +311,10 @@ bool ASTVisitor::VisitTemplateTemplateParmDecl(clang::TemplateTemplateParmDecl *
bool ASTVisitor::VisitClassTemplateDecl(clang::ClassTemplateDecl* declaration) bool ASTVisitor::VisitClassTemplateDecl(clang::ClassTemplateDecl* declaration)
{ {
std::vector<std::string> rarchy = utility::getDeclNameHierarchy(declaration); NameHierarchy rarchy = utility::getDeclNameHierarchy(declaration);
if (isLocatedInUnparsedProjectFile(declaration)) if (isLocatedInUnparsedProjectFile(declaration))
{ {
std::vector<std::string> templateRecordNameHierarchy = utility::getDeclNameHierarchy(declaration); NameHierarchy templateRecordNameHierarchy = utility::getDeclNameHierarchy(declaration);
clang::TemplateParameterList* parameterList = declaration->getTemplateParameters(); clang::TemplateParameterList* parameterList = declaration->getTemplateParameters();
for (size_t i = 0; i < parameterList->size(); i++) for (size_t i = 0; i < parameterList->size(); i++)
{ {
@@ -341,10 +341,10 @@ bool ASTVisitor::VisitClassTemplateDecl(clang::ClassTemplateDecl* declaration)
clang::ClassTemplateSpecializationDecl* specializationDecl = *it; clang::ClassTemplateSpecializationDecl* specializationDecl = *it;
// The specializationParent can be an indirect specialization of the ClassTemplate (by specializing a partial specialization). // The specializationParent can be an indirect specialization of the ClassTemplate (by specializing a partial specialization).
std::vector<std::string> specializationParentNameHierarchy = utility::getTemplateSpecializationParentNameHierarchy(specializationDecl); NameHierarchy specializationParentNameHierarchy = utility::getTemplateSpecializationParentNameHierarchy(specializationDecl);
ParserClient::RecordType specializedRecordType = specializationDecl->isStruct() ? ParserClient::RECORD_STRUCT : ParserClient::RECORD_CLASS; ParserClient::RecordType specializedRecordType = specializationDecl->isStruct() ? ParserClient::RECORD_STRUCT : ParserClient::RECORD_CLASS;
std::vector<std::string> specializedRecordNameHierarchy = utility::getDeclNameHierarchy(specializationDecl); NameHierarchy specializedRecordNameHierarchy = utility::getDeclNameHierarchy(specializationDecl);
m_client->onTemplateRecordSpecializationParsed( m_client->onTemplateRecordSpecializationParsed(
getParseLocationForNamedDecl(*it), specializedRecordNameHierarchy, specializedRecordType, specializationParentNameHierarchy getParseLocationForNamedDecl(*it), specializedRecordNameHierarchy, specializedRecordType, specializationParentNameHierarchy
); );
@@ -354,7 +354,7 @@ bool ASTVisitor::VisitClassTemplateDecl(clang::ClassTemplateDecl* declaration)
const clang::TemplateArgumentList &argList = specializationDecl->getTemplateArgs(); const clang::TemplateArgumentList &argList = specializationDecl->getTemplateArgs();
for (size_t i = 0; i < argList.size(); i++) for (size_t i = 0; i < argList.size(); i++)
{ {
std::vector<std::string> argumentNameHierarchy = utility::templateArgumentToDataType(argList.get(i))->getTypeNameHierarchy(); NameHierarchy argumentNameHierarchy = utility::templateArgumentToDataType(argList.get(i))->getTypeNameHierarchy();
if (argumentNameHierarchy.size()) // FIXME: Some TemplateArgument kinds are not handled yet. if (argumentNameHierarchy.size()) // FIXME: Some TemplateArgument kinds are not handled yet.
{ {
@@ -374,8 +374,8 @@ bool ASTVisitor::VisitClassTemplatePartialSpecializationDecl(clang::ClassTemplat
{ {
if (isLocatedInUnparsedProjectFile(declaration)) if (isLocatedInUnparsedProjectFile(declaration))
{ {
std::vector<std::string> specializedRecordNameHierarchy = utility::getDeclNameHierarchy(declaration); NameHierarchy specializedRecordNameHierarchy = utility::getDeclNameHierarchy(declaration);
std::vector<std::string> specializationParentNameHierarchy = utility::getTemplateSpecializationParentNameHierarchy(declaration); NameHierarchy specializationParentNameHierarchy = utility::getTemplateSpecializationParentNameHierarchy(declaration);
ParserClient::RecordType specializedRecordType = declaration->isStruct() ? ParserClient::RECORD_STRUCT : ParserClient::RECORD_CLASS; ParserClient::RecordType specializedRecordType = declaration->isStruct() ? ParserClient::RECORD_STRUCT : ParserClient::RECORD_CLASS;
m_client->onTemplateRecordSpecializationParsed( m_client->onTemplateRecordSpecializationParsed(
@@ -423,7 +423,7 @@ bool ASTVisitor::VisitFunctionTemplateDecl(clang::FunctionTemplateDecl *declarat
if (isLocatedInUnparsedProjectFile(namedDecl)) if (isLocatedInUnparsedProjectFile(namedDecl))
{ {
std::vector<std::string> templateParameterTypeNameHierarchy = utility::getDeclNameHierarchy(namedDecl); NameHierarchy templateParameterTypeNameHierarchy = utility::getDeclNameHierarchy(namedDecl);
m_client->onTemplateFunctionParameterTypeParsed( m_client->onTemplateFunctionParameterTypeParsed(
getParseLocationForNamedDecl(namedDecl), getParseLocationForNamedDecl(namedDecl),
@@ -873,7 +873,7 @@ std::vector<ParseTypeUsage> ASTVisitor::getParameters(const clang::FunctionDecl*
ParseVariable ASTVisitor::getParseVariable(const clang::DeclaratorDecl* declaration) const ParseVariable ASTVisitor::getParseVariable(const clang::DeclaratorDecl* declaration) const
{ {
bool isStatic = false; bool isStatic = false;
std::vector<std::string> hameHierarchy = utility::getDeclNameHierarchy(declaration); NameHierarchy hameHierarchy = utility::getDeclNameHierarchy(declaration);
if (clang::isa<clang::VarDecl>(declaration)) if (clang::isa<clang::VarDecl>(declaration))
{ {
const clang::VarDecl* varDecl = clang::dyn_cast<const clang::VarDecl>(declaration); const clang::VarDecl* varDecl = clang::dyn_cast<const clang::VarDecl>(declaration);
src/lib/data/parser/cxx/utilityCxx.cpp
+37 -26
View File
@@ -41,6 +41,10 @@ namespace utility
dataType = std::make_shared<NamedDataType>(getDeclNameHierarchy(type->getAs<clang::TypedefType>()->getDecl())); dataType = std::make_shared<NamedDataType>(getDeclNameHierarchy(type->getAs<clang::TypedefType>()->getDecl()));
break; break;
} }
case clang::Type::MemberPointer:
{
int ogogo = 0; // test this case!
}
case clang::Type::Pointer: case clang::Type::Pointer:
{ {
std::shared_ptr<DataType> innerType = qualTypeToDataType(type->getPointeeType()); std::shared_ptr<DataType> innerType = qualTypeToDataType(type->getPointeeType());
@@ -85,15 +89,15 @@ namespace utility
clang::QualType::print(type, clang::Qualifiers(), StrOS, pp, clang::Twine()); clang::QualType::print(type, clang::Qualifiers(), StrOS, pp, clang::Twine());
std::string typeName = StrOS.str(); std::string typeName = StrOS.str();
std::vector<std::string> typeNameHerarchy; NameHierarchy typeNameHerarchy;
typeNameHerarchy.push_back(typeName); typeNameHerarchy.push(std::make_shared<NameElement>(typeName));
dataType = std::make_shared<NamedDataType>(typeNameHerarchy); dataType = std::make_shared<NamedDataType>(typeNameHerarchy);
break; break;
} }
case clang::Type::TemplateSpecialization: case clang::Type::TemplateSpecialization:
{ {
std::vector<std::string> typeNameHerarchy; NameHierarchy typeNameHerarchy;
const clang::TagType* tagType = type->getAs<clang::TagType>(); // remove this case when NameHierarchy is split into namepart and parameter part const clang::TagType* tagType = type->getAs<clang::TagType>(); // remove this case when NameHierarchy is split into namepart and parameter part
if (tagType) if (tagType)
@@ -116,9 +120,11 @@ namespace utility
} }
templateArgumentPart += ">"; templateArgumentPart += ">";
std::string& declName = typeNameHerarchy.back(); std::string declName = typeNameHerarchy.back()->getFullName();
declName = declName.substr(0, declName.rfind("<")); // remove template parameters declName = declName.substr(0, declName.rfind("<")); // remove template parameters - does not work for A<ajaj<ajsj>>
declName += templateArgumentPart; // add template arguments declName += templateArgumentPart; // add template arguments
typeNameHerarchy.pop();
typeNameHerarchy.push(std::make_shared<NameElement>(declName));
} }
} }
dataType = std::make_shared<NamedDataType>(typeNameHerarchy); dataType = std::make_shared<NamedDataType>(typeNameHerarchy);
@@ -129,16 +135,18 @@ namespace utility
clang::TemplateTypeParmDecl* templateTypeParmDecl = clang::dyn_cast<clang::TemplateTypeParmType>(type)->getDecl(); clang::TemplateTypeParmDecl* templateTypeParmDecl = clang::dyn_cast<clang::TemplateTypeParmType>(type)->getDecl();
std::string typeName = getDeclName(templateTypeParmDecl); std::string typeName = getDeclName(templateTypeParmDecl);
std::vector<std::string> typeNameHerarchy = getContextNameHierarchyOfTemplateParameter(templateTypeParmDecl); NameHierarchy typeNameHerarchy = getContextNameHierarchyOfTemplateParameter(templateTypeParmDecl);
if (typeNameHerarchy.size() == 0) if (typeNameHerarchy.size() == 0)
{ {
LOG_ERROR("Unable to resolve type name hierarchy for template parameter \"" + typeName + "\""); LOG_ERROR("Unable to resolve type name hierarchy for template parameter \"" + typeName + "\"");
typeNameHerarchy.push_back(typeName); typeNameHerarchy.push(std::make_shared<NameElement>(typeName));
} }
else else
{ {
typeNameHerarchy.back() += "::" + typeName; std::string lastContextElementName = typeNameHerarchy.back()->getFullName();
typeNameHerarchy.pop();
typeNameHerarchy.push(std::make_shared<NameElement>(lastContextElementName + "::" + typeName));
} }
dataType = std::make_shared<NamedDataType>(typeNameHerarchy); dataType = std::make_shared<NamedDataType>(typeNameHerarchy);
break; break;
@@ -153,11 +161,11 @@ namespace utility
const clang::DependentNameType* dependentNameType = clang::dyn_cast<clang::DependentNameType>(type); const clang::DependentNameType* dependentNameType = clang::dyn_cast<clang::DependentNameType>(type);
clang::NestedNameSpecifier* nns = dependentNameType->getQualifier(); clang::NestedNameSpecifier* nns = dependentNameType->getQualifier();
clang::NestedNameSpecifier::SpecifierKind nnsKind = nns->getKind(); clang::NestedNameSpecifier::SpecifierKind nnsKind = nns->getKind();
std::vector<std::string> typeNameHerarchy; NameHierarchy typeNameHerarchy;
switch (nnsKind) switch (nnsKind)
{ {
case clang::NestedNameSpecifier::Identifier: case clang::NestedNameSpecifier::Identifier:
typeNameHerarchy.push_back(nns->getAsIdentifier()->getName()); typeNameHerarchy.push(std::make_shared<NameElement>(nns->getAsIdentifier()->getName()));
LOG_ERROR("Unable to resolve name of nested name specifier of kind: Identifier"); // this one is not tested yet. tell malte if you get this log error. LOG_ERROR("Unable to resolve name of nested name specifier of kind: Identifier"); // this one is not tested yet. tell malte if you get this log error.
break; break;
case clang::NestedNameSpecifier::Namespace: case clang::NestedNameSpecifier::Namespace:
@@ -178,7 +186,7 @@ namespace utility
break; break;
} }
typeNameHerarchy.push_back(dependentNameType->getIdentifier()->getName().str()); typeNameHerarchy.push(std::make_shared<NameElement>(dependentNameType->getIdentifier()->getName().str()));
dataType = std::make_shared<NamedDataType>(typeNameHerarchy); dataType = std::make_shared<NamedDataType>(typeNameHerarchy);
break; break;
@@ -195,8 +203,8 @@ namespace utility
clang::QualType::print(type, clang::Qualifiers(), StrOS, pp, clang::Twine()); clang::QualType::print(type, clang::Qualifiers(), StrOS, pp, clang::Twine());
std::string typeName = StrOS.str(); std::string typeName = StrOS.str();
std::vector<std::string> typeNameHerarchy; NameHierarchy typeNameHerarchy;
typeNameHerarchy.push_back(typeName); typeNameHerarchy.push(std::make_shared<NameElement>(typeName));
dataType = std::make_shared<NamedDataType>(typeNameHerarchy); dataType = std::make_shared<NamedDataType>(typeNameHerarchy);
break; break;
@@ -205,9 +213,9 @@ namespace utility
return dataType; return dataType;
} }
std::vector<std::string> getDeclNameHierarchy(const clang::Decl* declaration) NameHierarchy getDeclNameHierarchy(const clang::Decl* declaration)
{ {
std::vector<std::string> contextNameHierarchy; NameHierarchy contextNameHierarchy;
if (declaration) if (declaration)
{ {
std::string declName = ""; std::string declName = "";
@@ -225,19 +233,22 @@ namespace utility
clang::isa<clang::TemplateTypeParmDecl>(declaration) || clang::isa<clang::TemplateTypeParmDecl>(declaration) ||
clang::isa<clang::TemplateTemplateParmDecl>(declaration)) clang::isa<clang::TemplateTemplateParmDecl>(declaration))
{ {
contextNameHierarchy.back() += "::" + declName; std::string lastContextElementName = contextNameHierarchy.back()->getFullName();
contextNameHierarchy.pop();
contextNameHierarchy.push(std::make_shared<NameElement>(lastContextElementName + "::" + declName));
} }
else else
{ {
contextNameHierarchy.push_back(declName); contextNameHierarchy.push(std::make_shared<NameElement>(declName));
} }
} }
return contextNameHierarchy; return contextNameHierarchy;
} }
std::vector<std::string> getContextNameHierarchy(const clang::DeclContext* declContext) NameHierarchy getContextNameHierarchy(const clang::DeclContext* declContext)
{ {
std::vector<std::string> contextNameHierarchy; NameHierarchy contextNameHierarchy;
const clang::DeclContext* parentContext = declContext->getParent(); const clang::DeclContext* parentContext = declContext->getParent();
if (parentContext) if (parentContext)
@@ -247,18 +258,18 @@ namespace utility
if (clang::isa<clang::NamedDecl>(declContext)) if (clang::isa<clang::NamedDecl>(declContext))
{ {
std::string declName = getDeclName(clang::dyn_cast<const clang::NamedDecl>(declContext)); std::string declName = getDeclName(clang::dyn_cast<clang::NamedDecl>(declContext));
if (declName != "") if (declName != "")
{ {
contextNameHierarchy.push_back(declName); contextNameHierarchy.push(std::make_shared<NameElement>(declName));
} }
} }
return contextNameHierarchy; return contextNameHierarchy;
} }
std::vector<std::string> getContextNameHierarchyOfTemplateParameter(const clang::NamedDecl* templateParmDecl) NameHierarchy getContextNameHierarchyOfTemplateParameter(const clang::NamedDecl* templateParmDecl) // why do we need this??
{ {
std::vector<std::string> contextNameHierarchy; NameHierarchy contextNameHierarchy;
const clang::Decl* parentNode = getAstParentDecl(templateParmDecl); const clang::Decl* parentNode = getAstParentDecl(templateParmDecl);
if (parentNode && clang::isa<clang::NamedDecl>(parentNode)) if (parentNode && clang::isa<clang::NamedDecl>(parentNode))
@@ -364,9 +375,9 @@ namespace utility
return declName; return declName;
} }
std::vector<std::string> getTemplateSpecializationParentNameHierarchy(clang::ClassTemplateSpecializationDecl* declaration) NameHierarchy getTemplateSpecializationParentNameHierarchy(clang::ClassTemplateSpecializationDecl* declaration)
{ {
std::vector<std::string> specializationParentNameHierarchy; NameHierarchy specializationParentNameHierarchy;
llvm::PointerUnion<clang::ClassTemplateDecl*, clang::ClassTemplatePartialSpecializationDecl*> pu = declaration->getSpecializedTemplateOrPartial(); llvm::PointerUnion<clang::ClassTemplateDecl*, clang::ClassTemplatePartialSpecializationDecl*> pu = declaration->getSpecializedTemplateOrPartial();
if (pu.is<clang::ClassTemplateDecl*>()) if (pu.is<clang::ClassTemplateDecl*>())
{ {
@@ -424,7 +435,7 @@ namespace utility
LOG_ERROR("Type of template argument not handled." + argument.getKind()); LOG_ERROR("Type of template argument not handled." + argument.getKind());
break; break;
} }
return std::make_shared<NamedDataType>(std::vector<std::string>()); return std::make_shared<NamedDataType>(NameHierarchy());
} }
std::string getTemplateParameterString(const clang::NamedDecl* parameter) std::string getTemplateParameterString(const clang::NamedDecl* parameter)
src/lib/data/parser/cxx/utilityCxx.h
+5 -4
View File
@@ -10,17 +10,18 @@
#include "clang/AST/DeclTemplate.h" #include "clang/AST/DeclTemplate.h"
class DataType; class DataType;
class NameHierarchy;
namespace utility namespace utility
{ {
std::shared_ptr<DataType> qualTypeToDataType(clang::QualType qualType); std::shared_ptr<DataType> qualTypeToDataType(clang::QualType qualType);
std::shared_ptr<DataType> typeToDataType(const clang::Type* type); std::shared_ptr<DataType> typeToDataType(const clang::Type* type);
std::vector<std::string> getDeclNameHierarchy(const clang::Decl* declaration); NameHierarchy getDeclNameHierarchy(const clang::Decl* declaration);
std::vector<std::string> getContextNameHierarchy(const clang::DeclContext* declaration); NameHierarchy getContextNameHierarchy(const clang::DeclContext* declaration);
std::vector<std::string> getContextNameHierarchyOfTemplateParameter(const clang::NamedDecl* templateParmDecl); NameHierarchy getContextNameHierarchyOfTemplateParameter(const clang::NamedDecl* templateParmDecl);
std::string getDeclName(const clang::NamedDecl* declaration); std::string getDeclName(const clang::NamedDecl* declaration);
std::vector<std::string> getTemplateSpecializationParentNameHierarchy(clang::ClassTemplateSpecializationDecl* declaration); NameHierarchy getTemplateSpecializationParentNameHierarchy(clang::ClassTemplateSpecializationDecl* declaration);
std::shared_ptr<DataType> templateArgumentToDataType(const clang::TemplateArgument& argument); std::shared_ptr<DataType> templateArgumentToDataType(const clang::TemplateArgument& argument);
std::string getTemplateParameterString(const clang::NamedDecl* parameter); std::string getTemplateParameterString(const clang::NamedDecl* parameter);
std::string getTemplateParameterTypeString(const clang::NonTypeTemplateParmDecl* parameter); std::string getTemplateParameterTypeString(const clang::NonTypeTemplateParmDecl* parameter);
src/lib/data/search/SearchIndex.cpp
+3 -3
View File
@@ -51,12 +51,12 @@ const std::string& SearchIndex::getWord(Id wordId) const
return m_dictionary.getWord(wordId); return m_dictionary.getWord(wordId);
} }
SearchNode* SearchIndex::addNode(std::vector<std::string> nameHierarchy) SearchNode* SearchIndex::addNode(NameHierarchy nameHierarchy)
{ {
std::deque<Id> nameIds; std::deque<Id> nameIds;
for (const std::string& name: nameHierarchy) for (int i = 0; i < nameHierarchy.size(); i++)
{ {
nameIds.push_back(m_dictionary.getWordId(name)); nameIds.push_back(m_dictionary.getWordId(nameHierarchy[i]->getFullName()));
} }
if (nameIds.size()) if (nameIds.size())
{ {
src/lib/data/search/SearchIndex.h
+2 -1
View File
@@ -8,6 +8,7 @@
#include "utility/text/Dictionary.h" #include "utility/text/Dictionary.h"
#include "utility/types.h" #include "utility/types.h"
#include "data/name/NameHierarchy.h"
#include "data/search/SearchNode.h" #include "data/search/SearchNode.h"
class SearchIndex class SearchIndex
@@ -25,7 +26,7 @@ public:
Id getWordId(const std::string& word); Id getWordId(const std::string& word);
const std::string& getWord(Id wordId) const; const std::string& getWord(Id wordId) const;
SearchNode* addNode(std::vector<std::string> nameHierarchy); SearchNode* addNode(NameHierarchy nameHierarchy);
SearchNode* getNode(const std::string& fullName) const; SearchNode* getNode(const std::string& fullName) const;
SearchNode* getNode(const SearchNode* searchNode) const; SearchNode* getNode(const SearchNode* searchNode) const;
src/lib/data/type/DataType.h
+3 -2
View File
@@ -2,7 +2,8 @@
#define DATA_TYPE_H #define DATA_TYPE_H
#include <string> #include <string>
#include <vector>
#include "data/name/NameHierarchy.h"
class DataType class DataType
{ {
@@ -18,7 +19,7 @@ public:
virtual std::string getFullTypeName() const = 0; virtual std::string getFullTypeName() const = 0;
virtual std::string getRawTypeName() const = 0; virtual std::string getRawTypeName() const = 0;
virtual const std::vector<std::string>& getTypeNameHierarchy() const = 0; virtual const NameHierarchy& getTypeNameHierarchy() const = 0;
void addQualifier(QualifierType qualifier); void addQualifier(QualifierType qualifier);
void removeQualifier(QualifierType qualifier); void removeQualifier(QualifierType qualifier);
src/lib/data/type/ModifiedDataType.cpp
+1 -1
View File
@@ -22,7 +22,7 @@ std::string ModifiedDataType::getRawTypeName() const
return m_dataType->getRawTypeName(); return m_dataType->getRawTypeName();
} }
const std::vector<std::string>& ModifiedDataType::getTypeNameHierarchy() const const NameHierarchy& ModifiedDataType::getTypeNameHierarchy() const
{ {
return m_dataType->getTypeNameHierarchy(); return m_dataType->getTypeNameHierarchy();
} }
src/lib/data/type/ModifiedDataType.h
+1 -1
View File
@@ -13,7 +13,7 @@ public:
virtual std::string getFullTypeName() const; virtual std::string getFullTypeName() const;
virtual std::string getRawTypeName() const; virtual std::string getRawTypeName() const;
virtual const std::vector<std::string>& getTypeNameHierarchy() const; virtual const NameHierarchy& getTypeNameHierarchy() const;
protected: protected:
virtual void applyModifier(std::string& typeName) const = 0; virtual void applyModifier(std::string& typeName) const = 0;
src/lib/data/type/NamedDataType.cpp
+3 -3
View File
@@ -2,7 +2,7 @@
#include "utility/utilityString.h" #include "utility/utilityString.h"
NamedDataType::NamedDataType(const std::vector<std::string>& nameHierarchy) NamedDataType::NamedDataType(const NameHierarchy& nameHierarchy)
: m_nameHierarchy(nameHierarchy) : m_nameHierarchy(nameHierarchy)
{ {
} }
@@ -20,10 +20,10 @@ std::string NamedDataType::getFullTypeName() const
std::string NamedDataType::getRawTypeName() const std::string NamedDataType::getRawTypeName() const
{ {
return utility::join(m_nameHierarchy, "::"); return m_nameHierarchy.getFullName();
} }
const std::vector<std::string>& NamedDataType::getTypeNameHierarchy() const const NameHierarchy& NamedDataType::getTypeNameHierarchy() const
{ {
return m_nameHierarchy; return m_nameHierarchy;
} }
src/lib/data/type/NamedDataType.h
+4 -4
View File
@@ -1,20 +1,20 @@
#ifndef NAMED_DATA_TYPE_H #ifndef NAMED_DATA_TYPE_H
#define NAMED_DATA_TYPE_H #define NAMED_DATA_TYPE_H
#include "DataType.h" #include "data/type/DataType.h"
class NamedDataType: public DataType class NamedDataType: public DataType
{ {
public: public:
NamedDataType(const std::vector<std::string>& nameHierarchy); NamedDataType(const NameHierarchy& nameHierarchy);
virtual ~NamedDataType(); virtual ~NamedDataType();
virtual std::string getFullTypeName() const; virtual std::string getFullTypeName() const;
virtual std::string getRawTypeName() const; virtual std::string getRawTypeName() const;
virtual const std::vector<std::string>& getTypeNameHierarchy() const; virtual const NameHierarchy& getTypeNameHierarchy() const;
private: private:
const std::vector<std::string> m_nameHierarchy; const NameHierarchy m_nameHierarchy;
}; };
#endif // NAMED_DATA_TYPE_H #endif // NAMED_DATA_TYPE_H
src/test/CxxParserTestSuite.h
+65 -38
View File
@@ -13,6 +13,7 @@
#include "helper/TestFileManager.h" #include "helper/TestFileManager.h"
class CxxParserTestSuite: public CxxTest::TestSuite class CxxParserTestSuite: public CxxTest::TestSuite
{ {
public: public:
@@ -2329,7 +2330,7 @@ public:
TS_ASSERT_EQUALS(client->templateArgumentTypes[0], "test<int>->int <0:0 0:0>"); TS_ASSERT_EQUALS(client->templateArgumentTypes[0], "test<int>->int <0:0 0:0>");
} }
void test_cxx_parser_finds_template_default_argument_type_of_template_function() void test_cxx_parser_finds_type_template_default_argument_type_of_template_function()
{ {
std::shared_ptr<TestParserClient> client = parseCode( std::shared_ptr<TestParserClient> client = parseCode(
"template <typename T = int>\n" "template <typename T = int>\n"
@@ -2347,7 +2348,33 @@ public:
TS_ASSERT_EQUALS(client->templateDefaultArgumentTypes[0], "int -> test<typename T>::T <1:24 1:26>"); TS_ASSERT_EQUALS(client->templateDefaultArgumentTypes[0], "int -> test<typename T>::T <1:24 1:26>");
} }
void test_cxx_parser_does_not_find_default_argument_type_for_non_type_bool_template_parameter_of_template_function()
{
std::shared_ptr<TestParserClient> client = parseCode(
"template <bool T = true>\n"
"void test()\n"
"{\n"
"};\n"
);
TS_ASSERT_EQUALS(client->templateDefaultArgumentTypes.size(), 0);
}
void test_cxx_parser_finds_template_template_default_argument_type_of_template_function()
{
std::shared_ptr<TestParserClient> client = parseCode(
"template <typename T>\n"
"class A\n"
"{};\n"
"template <template<typename> class T = A>\n"
"void test()\n"
"{\n"
"};\n"
);
TS_ASSERT_EQUALS(client->templateDefaultArgumentTypes.size(), 1);
TS_ASSERT_EQUALS(client->templateDefaultArgumentTypes[0], "A<typename T> -> test<template<typename> typename T>::T<typename> <4:40 4:40>");
}
void test_cxx_parser_parses_multiple_files() void test_cxx_parser_parses_multiple_files()
{ {
@@ -2403,28 +2430,28 @@ private:
} }
virtual Id onTypedefParsed( virtual Id onTypedefParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, const ParseTypeUsage& underlyingType, const ParseLocation& location, const NameHierarchy& nameHierarchy, const ParseTypeUsage& underlyingType,
AccessType access AccessType access
) )
{ {
std::string str = addAccessPrefix(underlyingType.dataType->getFullTypeName() + " -> " + utility::join(nameHierarchy, "::"), access); std::string str = addAccessPrefix(underlyingType.dataType->getFullTypeName() + " -> " + nameHierarchy.getFullName(), access);
typedefs.push_back(addLocationSuffix(str, location)); typedefs.push_back(addLocationSuffix(str, location));
return 0; return 0;
} }
virtual Id onClassParsed( virtual Id onClassParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, AccessType access, const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access,
const ParseLocation& scopeLocation) const ParseLocation& scopeLocation)
{ {
classes.push_back(addLocationSuffix(addAccessPrefix(utility::join(nameHierarchy, "::"), access), location, scopeLocation)); classes.push_back(addLocationSuffix(addAccessPrefix(nameHierarchy.getFullName(), access), location, scopeLocation));
return 0; return 0;
} }
virtual Id onStructParsed( virtual Id onStructParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, AccessType access, const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access,
const ParseLocation& scopeLocation) const ParseLocation& scopeLocation)
{ {
structs.push_back(addLocationSuffix(addAccessPrefix(utility::join(nameHierarchy, "::"), access), location, scopeLocation)); structs.push_back(addLocationSuffix(addAccessPrefix(nameHierarchy.getFullName(), access), location, scopeLocation));
return 0; return 0;
} }
@@ -2472,30 +2499,30 @@ private:
} }
virtual Id onNamespaceParsed( virtual Id onNamespaceParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, const ParseLocation& scopeLocation) const ParseLocation& location, const NameHierarchy& nameHierarchy, const ParseLocation& scopeLocation)
{ {
namespaces.push_back(addLocationSuffix(utility::join(nameHierarchy, "::"), location, scopeLocation)); namespaces.push_back(addLocationSuffix(nameHierarchy.getFullName(), location, scopeLocation));
return 0; return 0;
} }
virtual Id onEnumParsed( virtual Id onEnumParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, AccessType access, const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access,
const ParseLocation& scopeLocation) const ParseLocation& scopeLocation)
{ {
enums.push_back(addLocationSuffix(addAccessPrefix(utility::join(nameHierarchy, "::"), access), location, scopeLocation)); enums.push_back(addLocationSuffix(addAccessPrefix(nameHierarchy.getFullName(), access), location, scopeLocation));
return 0; return 0;
} }
virtual Id onEnumConstantParsed(const ParseLocation& location, const std::vector<std::string>& nameHierarchy) virtual Id onEnumConstantParsed(const ParseLocation& location, const NameHierarchy& nameHierarchy)
{ {
enumConstants.push_back(addLocationSuffix(utility::join(nameHierarchy, "::"), location)); enumConstants.push_back(addLocationSuffix(nameHierarchy.getFullName(), location));
return 0; return 0;
} }
virtual Id onInheritanceParsed( virtual Id onInheritanceParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy, const std::vector<std::string>& baseNameHierarchy, AccessType access) const ParseLocation& location, const NameHierarchy& nameHierarchy, const NameHierarchy& baseNameHierarchy, AccessType access)
{ {
std::string str = utility::join(nameHierarchy, "::") + " : " + addAccessPrefix(utility::join(baseNameHierarchy, "::"), access); std::string str = nameHierarchy.getFullName() + " : " + addAccessPrefix(baseNameHierarchy.getFullName(), access);
inheritances.push_back(addLocationSuffix(str, location)); inheritances.push_back(addLocationSuffix(str, location));
return 0; return 0;
} }
@@ -2521,37 +2548,37 @@ private:
} }
virtual Id onFieldUsageParsed( virtual Id onFieldUsageParsed(
const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy) const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy)
{ {
usages.push_back(addLocationSuffix(functionStr(user) + " -> " + utility::join(usedNameHierarchy, "::"), location)); usages.push_back(addLocationSuffix(functionStr(user) + " -> " + usedNameHierarchy.getFullName(), location));
return 0; return 0;
} }
virtual Id onGlobalVariableUsageParsed( virtual Id onGlobalVariableUsageParsed(
const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy) const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy)
{ {
usages.push_back(addLocationSuffix(functionStr(user) + " -> " + utility::join(usedNameHierarchy, "::"), location)); usages.push_back(addLocationSuffix(functionStr(user) + " -> " + usedNameHierarchy.getFullName(), location));
return 0; return 0;
} }
virtual Id onGlobalVariableUsageParsed( virtual Id onGlobalVariableUsageParsed(
const ParseLocation& location, const ParseVariable& user, const std::vector<std::string>& usedNameHierarchy) const ParseLocation& location, const ParseVariable& user, const NameHierarchy& usedNameHierarchy)
{ {
usages.push_back(addLocationSuffix(variableStr(user) + " -> " + utility::join(usedNameHierarchy, "::"), location)); usages.push_back(addLocationSuffix(variableStr(user) + " -> " + usedNameHierarchy.getFullName(), location));
return 0; return 0;
} }
virtual Id onEnumConstantUsageParsed( virtual Id onEnumConstantUsageParsed(
const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy) const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy)
{ {
usages.push_back(addLocationSuffix(functionStr(user) + " -> " + utility::join(usedNameHierarchy, "::"), location)); usages.push_back(addLocationSuffix(functionStr(user) + " -> " + usedNameHierarchy.getFullName(), location));
return 0; return 0;
} }
virtual Id onEnumConstantUsageParsed( virtual Id onEnumConstantUsageParsed(
const ParseLocation& location, const ParseVariable& user, const std::vector<std::string>& usedNameHierarchy) const ParseLocation& location, const ParseVariable& user, const NameHierarchy& usedNameHierarchy)
{ {
usages.push_back(addLocationSuffix(variableStr(user) + " -> " + utility::join(usedNameHierarchy, "::"), location)); usages.push_back(addLocationSuffix(variableStr(user) + " -> " + usedNameHierarchy.getFullName(), location));
return 0; return 0;
} }
@@ -2568,51 +2595,51 @@ private:
} }
virtual Id onTemplateArgumentTypeParsed( virtual Id onTemplateArgumentTypeParsed(
const ParseLocation& location, const std::vector<std::string>& templateArgumentTypeNameHierarchy, const ParseLocation& location, const NameHierarchy& templateArgumentTypeNameHierarchy,
const std::vector<std::string>& templateRecordNameHierarchy) const NameHierarchy& templateRecordNameHierarchy)
{ {
templateArgumentTypes.push_back( templateArgumentTypes.push_back(
addLocationSuffix(utility::join(templateRecordNameHierarchy, "::") + "->" + utility::join(templateArgumentTypeNameHierarchy, "::"), location) addLocationSuffix(templateRecordNameHierarchy.getFullName() + "->" + templateArgumentTypeNameHierarchy.getFullName(), location)
); );
return 0; return 0;
} }
virtual Id onTemplateDefaultArgumentTypeParsed( virtual Id onTemplateDefaultArgumentTypeParsed(
const ParseTypeUsage& defaultArgumentType, const std::vector<std::string>& templateArgumentTypeNameHierarchy) const ParseTypeUsage& defaultArgumentType, const NameHierarchy& templateArgumentTypeNameHierarchy)
{ {
templateDefaultArgumentTypes.push_back( templateDefaultArgumentTypes.push_back(
addLocationSuffix(utility::join(defaultArgumentType.dataType->getTypeNameHierarchy(), "::") + " -> " + utility::join(templateArgumentTypeNameHierarchy, "::"), defaultArgumentType.location) addLocationSuffix(defaultArgumentType.dataType->getTypeNameHierarchy().getFullName() + " -> " + templateArgumentTypeNameHierarchy.getFullName(), defaultArgumentType.location)
); );
return 0; return 0;
} }
virtual Id onTemplateRecordParameterTypeParsed( virtual Id onTemplateRecordParameterTypeParsed(
const ParseLocation& location, const std::vector<std::string>& templateParameterTypeNameHierarchy, const ParseLocation& location, const NameHierarchy& templateParameterTypeNameHierarchy,
const std::vector<std::string>& templateRecordNameHierarchy) const NameHierarchy& templateRecordNameHierarchy)
{ {
templateParameterTypes.push_back( templateParameterTypes.push_back(
addLocationSuffix(utility::join(templateParameterTypeNameHierarchy, "::"), location) addLocationSuffix(templateParameterTypeNameHierarchy.getFullName(), location)
); );
return 0; return 0;
} }
virtual Id onTemplateRecordSpecializationParsed( virtual Id onTemplateRecordSpecializationParsed(
const ParseLocation& location, const std::vector<std::string>& specializedRecordNameHierarchy, const ParseLocation& location, const NameHierarchy& specializedRecordNameHierarchy,
const RecordType specializedRecordType, const std::vector<std::string>& specializedFromNameHierarchy) const RecordType specializedRecordType, const NameHierarchy& specializedFromNameHierarchy)
{ {
templateSpecializations.push_back( templateSpecializations.push_back(
addLocationSuffix(std::string(specializedRecordType == ParserClient::RECORD_CLASS ? "class" : "struct") + " " + addLocationSuffix(std::string(specializedRecordType == ParserClient::RECORD_CLASS ? "class" : "struct") + " " +
utility::join(specializedRecordNameHierarchy, "::") + " -> " + utility::join(specializedFromNameHierarchy, "::"), location) specializedRecordNameHierarchy.getFullName() + " -> " + specializedFromNameHierarchy.getFullName(), location)
); );
return 0; return 0;
} }
virtual Id onTemplateFunctionParameterTypeParsed( virtual Id onTemplateFunctionParameterTypeParsed(
const ParseLocation& location, const std::vector<std::string>& templateParameterTypeNameHierarchy, const ParseLocation& location, const NameHierarchy& templateParameterTypeNameHierarchy,
const ParseFunction function) const ParseFunction function)
{ {
templateParameterTypes.push_back( templateParameterTypes.push_back(
addLocationSuffix(utility::join(templateParameterTypeNameHierarchy, "::"), location) addLocationSuffix(templateParameterTypeNameHierarchy.getFullName(), location)
); );
return 0; return 0;
} }
src/test/DataTypeTestSuite.h
+19 -8
View File
@@ -13,13 +13,13 @@ class DataTypeTestSuite: public CxxTest::TestSuite
public: public:
void test_datatype_created_with_name_has_no_qualifiers_or_modifiers() void test_datatype_created_with_name_has_no_qualifiers_or_modifiers()
{ {
NamedDataType dataType(utility::splitToVector("int", "::")); NamedDataType dataType(createNameHierarchy("int"));
TS_ASSERT_EQUALS("int", dataType.getFullTypeName()); TS_ASSERT_EQUALS("int", dataType.getFullTypeName());
} }
void test_datatype_created_with_name_and_const_qualifier_has_no_modifiers() void test_datatype_created_with_name_and_const_qualifier_has_no_modifiers()
{ {
NamedDataType dataType(utility::splitToVector("int", "::")); NamedDataType dataType(createNameHierarchy("int"));
dataType.addQualifier(DataType::QUALIFIER_CONST); dataType.addQualifier(DataType::QUALIFIER_CONST);
TS_ASSERT_EQUALS("int const", dataType.getFullTypeName()); TS_ASSERT_EQUALS("int const", dataType.getFullTypeName());
} }
@@ -28,34 +28,34 @@ public:
//{ //{
// DataTypeQualifierList qualifierList; // DataTypeQualifierList qualifierList;
// DataTypeModifierStack modifierStack; // DataTypeModifierStack modifierStack;
// DataType dataType(utility::splitToVector("int", "::"), qualifierList, modifierStack); // DataType dataType(createNameHierarchy("int"), qualifierList, modifierStack);
// TS_ASSERT_EQUALS("int", dataType.getFullTypeName()); // TS_ASSERT_EQUALS("int", dataType.getFullTypeName());
//} //}
void test_datatype_created_with_name_and_array_modifier_has_array_modifier() void test_datatype_created_with_name_and_array_modifier_has_array_modifier()
{ {
std::shared_ptr<DataType> dataType1 = std::make_shared<NamedDataType>(utility::splitToVector("int", "::")); std::shared_ptr<DataType> dataType1 = std::make_shared<NamedDataType>(createNameHierarchy("int"));
std::shared_ptr<DataType> dataType2 = std::make_shared<ArrayModifiedDataType>(dataType1); std::shared_ptr<DataType> dataType2 = std::make_shared<ArrayModifiedDataType>(dataType1);
TS_ASSERT_EQUALS("int []", dataType2->getFullTypeName()); TS_ASSERT_EQUALS("int []", dataType2->getFullTypeName());
} }
void test_datatype_created_with_name_and_pointer_modifier_has_pointer_modifier() void test_datatype_created_with_name_and_pointer_modifier_has_pointer_modifier()
{ {
std::shared_ptr<DataType> dataType1 = std::make_shared<NamedDataType>(utility::splitToVector("int", "::")); std::shared_ptr<DataType> dataType1 = std::make_shared<NamedDataType>(createNameHierarchy("int"));
std::shared_ptr<DataType> dataType2 = std::make_shared<PointerModifiedDataType>(dataType1); std::shared_ptr<DataType> dataType2 = std::make_shared<PointerModifiedDataType>(dataType1);
TS_ASSERT_EQUALS("int *", dataType2->getFullTypeName()); TS_ASSERT_EQUALS("int *", dataType2->getFullTypeName());
} }
void test_datatype_created_with_name_and_reference_modifier_has_reference_modifier() void test_datatype_created_with_name_and_reference_modifier_has_reference_modifier()
{ {
std::shared_ptr<DataType> dataType1 = std::make_shared<NamedDataType>(utility::splitToVector("int", "::")); std::shared_ptr<DataType> dataType1 = std::make_shared<NamedDataType>(createNameHierarchy("int"));
std::shared_ptr<DataType> dataType2 = std::make_shared<ReferenceModifiedDataType>(dataType1); std::shared_ptr<DataType> dataType2 = std::make_shared<ReferenceModifiedDataType>(dataType1);
TS_ASSERT_EQUALS("int &", dataType2->getFullTypeName()); TS_ASSERT_EQUALS("int &", dataType2->getFullTypeName());
} }
void test_datatype_created_with_name_and_const_pointer_modifier_has_const_pointer_modifier() void test_datatype_created_with_name_and_const_pointer_modifier_has_const_pointer_modifier()
{ {
std::shared_ptr<DataType> dataType1 = std::make_shared<NamedDataType>(utility::splitToVector("int", "::")); std::shared_ptr<DataType> dataType1 = std::make_shared<NamedDataType>(createNameHierarchy("int"));
std::shared_ptr<DataType> dataType2 = std::make_shared<PointerModifiedDataType>(dataType1); std::shared_ptr<DataType> dataType2 = std::make_shared<PointerModifiedDataType>(dataType1);
dataType2->addQualifier(DataType::QUALIFIER_CONST); dataType2->addQualifier(DataType::QUALIFIER_CONST);
TS_ASSERT_EQUALS("int * const", dataType2->getFullTypeName()); TS_ASSERT_EQUALS("int * const", dataType2->getFullTypeName());
@@ -63,9 +63,20 @@ public:
void test_datatype_created_with_name_and_pointer_pointer_modifier_has_pointer_pointer_modifier() void test_datatype_created_with_name_and_pointer_pointer_modifier_has_pointer_pointer_modifier()
{ {
std::shared_ptr<DataType> dataType1 = std::make_shared<NamedDataType>(utility::splitToVector("int", "::")); std::shared_ptr<DataType> dataType1 = std::make_shared<NamedDataType>(createNameHierarchy("int"));
std::shared_ptr<DataType> dataType2 = std::make_shared<PointerModifiedDataType>(dataType1); std::shared_ptr<DataType> dataType2 = std::make_shared<PointerModifiedDataType>(dataType1);
std::shared_ptr<DataType> dataType3 = std::make_shared<PointerModifiedDataType>(dataType2); std::shared_ptr<DataType> dataType3 = std::make_shared<PointerModifiedDataType>(dataType2);
TS_ASSERT_EQUALS("int * *", dataType3->getFullTypeName()); TS_ASSERT_EQUALS("int * *", dataType3->getFullTypeName());
} }
private:
NameHierarchy createNameHierarchy(std::string s) const
{
NameHierarchy nameHierarchy;
for (std::string element: utility::splitToVector(s, "::"))
{
nameHierarchy.push(std::make_shared<NameElement>(element));
}
return nameHierarchy;
}
}; };
src/test/SearchIndexTestSuite.h
+42 -31
View File
@@ -11,7 +11,7 @@ public:
void test_add_node() void test_add_node()
{ {
SearchIndex index; SearchIndex index;
SearchNode* node = index.addNode(utility::splitToVector("util", "::")); SearchNode* node = index.addNode(createNameHierarchy("util"));
TS_ASSERT(node); TS_ASSERT(node);
TS_ASSERT_EQUALS("util", node->getName()); TS_ASSERT_EQUALS("util", node->getName());
@@ -26,7 +26,7 @@ public:
void test_get_node() void test_get_node()
{ {
SearchIndex index; SearchIndex index;
index.addNode(utility::splitToVector("util", "::")); index.addNode(createNameHierarchy("util"));
SearchNode* node = index.getNode("util"); SearchNode* node = index.getNode("util");
TS_ASSERT(node); TS_ASSERT(node);
@@ -45,7 +45,7 @@ public:
void test_add_hierarchy_node() void test_add_hierarchy_node()
{ {
SearchIndex index; SearchIndex index;
SearchNode* node = index.addNode(utility::splitToVector("util::math::pow", "::")); SearchNode* node = index.addNode(createNameHierarchy("util::math::pow"));
TS_ASSERT(node); TS_ASSERT(node);
TS_ASSERT_EQUALS("pow", node->getName()); TS_ASSERT_EQUALS("pow", node->getName());
@@ -64,8 +64,8 @@ public:
void test_reuse_hierarchy_node() void test_reuse_hierarchy_node()
{ {
SearchIndex index; SearchIndex index;
SearchNode* node1 = index.addNode(utility::splitToVector("math::pow", "::")); SearchNode* node1 = index.addNode(createNameHierarchy("math::pow"));
SearchNode* node2 = index.addNode(utility::splitToVector("math::floor", "::")); SearchNode* node2 = index.addNode(createNameHierarchy("math::floor"));
TS_ASSERT(node1); TS_ASSERT(node1);
TS_ASSERT(node2); TS_ASSERT(node2);
@@ -79,8 +79,8 @@ public:
void test_remove_nodes() void test_remove_nodes()
{ {
SearchIndex index; SearchIndex index;
index.addNode(utility::splitToVector("util::math::pow", "::")); index.addNode(createNameHierarchy("util::math::pow"));
index.addNode(utility::splitToVector("util::math::floor", "::")); index.addNode(createNameHierarchy("util::math::floor"));
index.removeNode(index.getNode("util::math::pow")); index.removeNode(index.getNode("util::math::pow"));
@@ -98,8 +98,8 @@ public:
void test_remove_unreferenced_nodes() void test_remove_unreferenced_nodes()
{ {
SearchIndex index; SearchIndex index;
SearchNode* node1 = index.addNode(utility::splitToVector("util::math::pow", "::")); SearchNode* node1 = index.addNode(createNameHierarchy("util::math::pow"));
SearchNode* node2 = index.addNode(utility::splitToVector("util::math::floor", "::")); SearchNode* node2 = index.addNode(createNameHierarchy("util::math::floor"));
node1->addTokenId(1); node1->addTokenId(1);
node2->addTokenId(2); node2->addTokenId(2);
@@ -128,8 +128,8 @@ public:
void test_clear() void test_clear()
{ {
SearchIndex index; SearchIndex index;
index.addNode(utility::splitToVector("math", "::")); index.addNode(createNameHierarchy("math"));
index.addNode(utility::splitToVector("string", "::")); index.addNode(createNameHierarchy("string"));
TS_ASSERT(index.getNode("math")); TS_ASSERT(index.getNode("math"));
@@ -142,9 +142,9 @@ public:
void test_fuzzy_matching() void test_fuzzy_matching()
{ {
SearchIndex index; SearchIndex index;
index.addNode(utility::splitToVector("util", "::")); index.addNode(createNameHierarchy("util"));
index.addNode(utility::splitToVector("math", "::")); index.addNode(createNameHierarchy("math"));
index.addNode(utility::splitToVector("string", "::")); index.addNode(createNameHierarchy("string"));
std::vector<SearchMatch> matches = index.runFuzzySearchAndGetMatches("u"); std::vector<SearchMatch> matches = index.runFuzzySearchAndGetMatches("u");
@@ -168,8 +168,8 @@ public:
void test_fuzzy_matching_is_case_insensitive() void test_fuzzy_matching_is_case_insensitive()
{ {
SearchIndex index; SearchIndex index;
index.addNode(utility::splitToVector("util", "::")); index.addNode(createNameHierarchy("util"));
index.addNode(utility::splitToVector("MATH", "::")); index.addNode(createNameHierarchy("MATH"));
std::vector<SearchMatch> matches = index.runFuzzySearchAndGetMatches("t"); std::vector<SearchMatch> matches = index.runFuzzySearchAndGetMatches("t");
@@ -187,9 +187,9 @@ public:
void test_fuzzy_matching_wheighs_by_distance_and_alphabet() void test_fuzzy_matching_wheighs_by_distance_and_alphabet()
{ {
SearchIndex index; SearchIndex index;
index.addNode(utility::splitToVector("util", "::")); index.addNode(createNameHierarchy("util"));
index.addNode(utility::splitToVector("math", "::")); index.addNode(createNameHierarchy("math"));
index.addNode(utility::splitToVector("string", "::")); index.addNode(createNameHierarchy("string"));
std::vector<SearchMatch> matches = index.runFuzzySearchAndGetMatches("t"); std::vector<SearchMatch> matches = index.runFuzzySearchAndGetMatches("t");
@@ -211,8 +211,8 @@ public:
void test_fuzzy_matching_wheighs_higher_by_uppercase() void test_fuzzy_matching_wheighs_higher_by_uppercase()
{ {
SearchIndex index; SearchIndex index;
index.addNode(utility::splitToVector("uTil", "::")); index.addNode(createNameHierarchy("uTil"));
index.addNode(utility::splitToVector("string", "::")); index.addNode(createNameHierarchy("string"));
std::vector<SearchMatch> matches = index.runFuzzySearchAndGetMatches("t"); std::vector<SearchMatch> matches = index.runFuzzySearchAndGetMatches("t");
@@ -224,8 +224,8 @@ public:
void test_fuzzy_matching_wheighs_higher_on_consecutive_letters() void test_fuzzy_matching_wheighs_higher_on_consecutive_letters()
{ {
SearchIndex index; SearchIndex index;
index.addNode(utility::splitToVector("oaabbcc", "::")); index.addNode(createNameHierarchy("oaabbcc"));
index.addNode(utility::splitToVector("ocbcabc", "::")); index.addNode(createNameHierarchy("ocbcabc"));
std::vector<SearchMatch> matches = index.runFuzzySearchAndGetMatches("abc"); std::vector<SearchMatch> matches = index.runFuzzySearchAndGetMatches("abc");
@@ -237,9 +237,9 @@ public:
void test_fuzzy_matching_in_hierarchy() void test_fuzzy_matching_in_hierarchy()
{ {
SearchIndex index; SearchIndex index;
index.addNode(utility::splitToVector("util::math::ceil", "::")); index.addNode(createNameHierarchy("util::math::ceil"));
index.addNode(utility::splitToVector("util::math::floor", "::")); index.addNode(createNameHierarchy("util::math::floor"));
index.addNode(utility::splitToVector("util::string::concat", "::")); index.addNode(createNameHierarchy("util::string::concat"));
std::vector<SearchMatch> matches = index.runFuzzySearchAndGetMatches("t"); std::vector<SearchMatch> matches = index.runFuzzySearchAndGetMatches("t");
@@ -261,9 +261,9 @@ public:
void test_fuzzy_matching_in_hierarchy_respects_collin() void test_fuzzy_matching_in_hierarchy_respects_collin()
{ {
SearchIndex index; SearchIndex index;
index.addNode(utility::splitToVector("util::math::ceil", "::")); index.addNode(createNameHierarchy("util::math::ceil"));
index.addNode(utility::splitToVector("util::math::floor", "::")); index.addNode(createNameHierarchy("util::math::floor"));
index.addNode(utility::splitToVector("util::string::concat", "::")); index.addNode(createNameHierarchy("util::string::concat"));
std::vector<SearchMatch> matches = index.runFuzzySearchAndGetMatches("u:i"); std::vector<SearchMatch> matches = index.runFuzzySearchAndGetMatches("u:i");
@@ -281,8 +281,8 @@ public:
void test_fuzzy_matching_in_hierarchy_weighs_front_letters_higher() void test_fuzzy_matching_in_hierarchy_weighs_front_letters_higher()
{ {
SearchIndex index; SearchIndex index;
index.addNode(utility::splitToVector("abc::dfe::ghi", "::")); index.addNode(createNameHierarchy("abc::dfe::ghi"));
index.addNode(utility::splitToVector("abc::hgi", "::")); index.addNode(createNameHierarchy("abc::hgi"));
std::vector<SearchMatch> matches = index.runFuzzySearchAndGetMatches("g"); std::vector<SearchMatch> matches = index.runFuzzySearchAndGetMatches("g");
@@ -290,4 +290,15 @@ public:
TS_ASSERT_EQUALS("abc::dfe::ghi", matches[0].fullName); TS_ASSERT_EQUALS("abc::dfe::ghi", matches[0].fullName);
TS_ASSERT_EQUALS("abc::hgi", matches[1].fullName); TS_ASSERT_EQUALS("abc::hgi", matches[1].fullName);
} }
private:
NameHierarchy createNameHierarchy(std::string s) const
{
NameHierarchy nameHierarchy;
for (std::string element: utility::splitToVector(s, "::"))
{
nameHierarchy.push(std::make_shared<NameElement>(element));
}
return nameHierarchy;
}
}; };
src/test/StorageGraphTestSuite.h
+14 -3
View File
@@ -324,14 +324,25 @@ private:
public: public:
Node* createNodeHierarchy(Node::NodeType type, const std::string& name) Node* createNodeHierarchy(Node::NodeType type, const std::string& name)
{ {
SearchNode* searchNode = m_index.addNode(utility::splitToVector(name, "::")); NameHierarchy nameHierarchy;
for (std::string element: utility::splitToVector(name, "::"))
{
nameHierarchy.push(std::make_shared<NameElement>(element));
}
SearchNode* searchNode = m_index.addNode(nameHierarchy);
return StorageGraph::createNodeHierarchy(type, searchNode); return StorageGraph::createNodeHierarchy(type, searchNode);
} }
Node* createNodeHierarchyWithDistinctSignature( Node* createNodeHierarchyWithDistinctSignature(
Node::NodeType type, const std::string& name, Id signatureId Node::NodeType type, const std::string& name, Id signatureId
){ )
SearchNode* searchNode = m_index.addNode(utility::splitToVector(name, "::")); {
NameHierarchy nameHierarchy;
for (std::string element: utility::splitToVector(name, "::"))
{
nameHierarchy.push(std::make_shared<NameElement>(element));
}
SearchNode* searchNode = m_index.addNode(nameHierarchy);
std::shared_ptr<TokenComponentSignature> signature = std::make_shared<TokenComponentSignature>(signatureId); std::shared_ptr<TokenComponentSignature> signature = std::make_shared<TokenComponentSignature>(signatureId);
return StorageGraph::createNodeHierarchyWithDistinctSignature(type, searchNode, signature); return StorageGraph::createNodeHierarchyWithDistinctSignature(type, searchNode, signature);
} }
src/test/StorageTestSuite.h
+62 -52
View File
@@ -25,7 +25,7 @@ public:
void test_storage_saves_typedef() void test_storage_saves_typedef()
{ {
TestStorage storage; TestStorage storage;
Id id = storage.onTypedefParsed(validLocation(1), utility::splitToVector("type", "::"), typeUsage("int"), ParserClient::ACCESS_NONE); Id id = storage.onTypedefParsed(validLocation(1), createNameHierarchy("type"), typeUsage("int"), ParserClient::ACCESS_NONE);
Node* node = storage.getNodeWithId(id); Node* node = storage.getNodeWithId(id);
TS_ASSERT(node); TS_ASSERT(node);
@@ -44,7 +44,7 @@ public:
void test_storage_saves_class() void test_storage_saves_class()
{ {
TestStorage storage; TestStorage storage;
Id id = storage.onClassParsed(validLocation(1), utility::splitToVector("Class", "::"), ParserClient::ACCESS_NONE, validLocation(2)); Id id = storage.onClassParsed(validLocation(1), createNameHierarchy("Class"), ParserClient::ACCESS_NONE, validLocation(2));
Node* node = storage.getNodeWithId(id); Node* node = storage.getNodeWithId(id);
TS_ASSERT(node); TS_ASSERT(node);
@@ -61,7 +61,7 @@ public:
void test_storage_saves_struct() void test_storage_saves_struct()
{ {
TestStorage storage; TestStorage storage;
Id id = storage.onStructParsed(validLocation(1), utility::splitToVector("Struct", "::"), ParserClient::ACCESS_NONE, validLocation(2)); Id id = storage.onStructParsed(validLocation(1), createNameHierarchy("Struct"), ParserClient::ACCESS_NONE, validLocation(2));
Node* node = storage.getNodeWithId(id); Node* node = storage.getNodeWithId(id);
TS_ASSERT(node); TS_ASSERT(node);
@@ -78,7 +78,7 @@ public:
void test_storage_saves_global_variable() void test_storage_saves_global_variable()
{ {
TestStorage storage; TestStorage storage;
Id id = storage.onGlobalVariableParsed(validLocation(42), ParseVariable(typeUsage("char"), utility::splitToVector("Global", "::"), false)); Id id = storage.onGlobalVariableParsed(validLocation(42), ParseVariable(typeUsage("char"), createNameHierarchy("Global"), false));
Node* node = storage.getNodeWithId(id); Node* node = storage.getNodeWithId(id);
TS_ASSERT(node); TS_ASSERT(node);
@@ -98,7 +98,7 @@ public:
void test_storage_saves_global_variable_static() void test_storage_saves_global_variable_static()
{ {
TestStorage storage; TestStorage storage;
Id id = storage.onGlobalVariableParsed(validLocation(7), ParseVariable(typeUsage("char"), utility::splitToVector("Global", "::"), true)); Id id = storage.onGlobalVariableParsed(validLocation(7), ParseVariable(typeUsage("char"), createNameHierarchy("Global"), true));
Node* node = storage.getNodeWithId(id); Node* node = storage.getNodeWithId(id);
TS_ASSERT(node); TS_ASSERT(node);
@@ -115,7 +115,7 @@ public:
{ {
TestStorage storage; TestStorage storage;
Id id = storage.onFieldParsed( Id id = storage.onFieldParsed(
validLocation(3), ParseVariable(typeUsage("bool"), utility::splitToVector("m_field", "::"), false), ParserClient::ACCESS_NONE validLocation(3), ParseVariable(typeUsage("bool"), createNameHierarchy("m_field"), false), ParserClient::ACCESS_NONE
); );
Node* node = storage.getNodeWithId(id); Node* node = storage.getNodeWithId(id);
@@ -136,7 +136,7 @@ public:
{ {
TestStorage storage; TestStorage storage;
Id id = storage.onFieldParsed( Id id = storage.onFieldParsed(
validLocation(11), ParseVariable(typeUsage("bool"), utility::splitToVector("Struct::m_field", "::"), false), ParserClient::ACCESS_PUBLIC validLocation(11), ParseVariable(typeUsage("bool"), createNameHierarchy("Struct::m_field"), false), ParserClient::ACCESS_PUBLIC
); );
Node* node = storage.getNodeWithId(id); Node* node = storage.getNodeWithId(id);
@@ -170,7 +170,7 @@ public:
{ {
TestStorage storage; TestStorage storage;
Id id = storage.onFunctionParsed( Id id = storage.onFunctionParsed(
validLocation(14), ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("char")), validLocation(41) validLocation(14), ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char")), validLocation(41)
); );
Node* node = storage.getNodeWithId(id); Node* node = storage.getNodeWithId(id);
@@ -201,7 +201,7 @@ public:
TestStorage storage; TestStorage storage;
Id id = storage.onMethodParsed( Id id = storage.onMethodParsed(
validLocation(9), validLocation(9),
ParseFunction(typeUsage("void"), utility::splitToVector("isMethod", "::"), parameters("bool")), ParseFunction(typeUsage("void"), createNameHierarchy("isMethod"), parameters("bool")),
ParserClient::ACCESS_NONE, ParserClient::ACCESS_NONE,
ParserClient::ABSTRACTION_NONE, ParserClient::ABSTRACTION_NONE,
validLocation(4) validLocation(4)
@@ -235,7 +235,7 @@ public:
TestStorage storage; TestStorage storage;
Id id = storage.onMethodParsed( Id id = storage.onMethodParsed(
validLocation(1), validLocation(1),
ParseFunction(typeUsage("void"), utility::splitToVector("isMethod", "::"), parameters("bool"), true), ParseFunction(typeUsage("void"), createNameHierarchy("isMethod"), parameters("bool"), true),
ParserClient::ACCESS_NONE, ParserClient::ACCESS_NONE,
ParserClient::ABSTRACTION_NONE, ParserClient::ABSTRACTION_NONE,
validLocation(4) validLocation(4)
@@ -253,7 +253,7 @@ public:
TestStorage storage; TestStorage storage;
Id id = storage.onMethodParsed( Id id = storage.onMethodParsed(
validLocation(1), validLocation(1),
ParseFunction(typeUsage("void"), utility::splitToVector("Class::isMethod", "::"), parameters("bool")), ParseFunction(typeUsage("void"), createNameHierarchy("Class::isMethod"), parameters("bool")),
ParserClient::ACCESS_PROTECTED, ParserClient::ACCESS_PROTECTED,
ParserClient::ABSTRACTION_VIRTUAL, ParserClient::ABSTRACTION_VIRTUAL,
validLocation(4) validLocation(4)
@@ -287,7 +287,7 @@ public:
void test_storage_saves_namespace() void test_storage_saves_namespace()
{ {
TestStorage storage; TestStorage storage;
Id id = storage.onNamespaceParsed(validLocation(1), utility::splitToVector("utility", "::"), validLocation(2)); Id id = storage.onNamespaceParsed(validLocation(1), createNameHierarchy("utility"), validLocation(2));
Node* node = storage.getNodeWithId(id); Node* node = storage.getNodeWithId(id);
TS_ASSERT(node); TS_ASSERT(node);
@@ -304,7 +304,7 @@ public:
void test_storage_saves_enum() void test_storage_saves_enum()
{ {
TestStorage storage; TestStorage storage;
Id id = storage.onEnumParsed(validLocation(17), utility::splitToVector("Category", "::"), ParserClient::ACCESS_NONE, validLocation(23)); Id id = storage.onEnumParsed(validLocation(17), createNameHierarchy("Category"), ParserClient::ACCESS_NONE, validLocation(23));
Node* node = storage.getNodeWithId(id); Node* node = storage.getNodeWithId(id);
TS_ASSERT(node); TS_ASSERT(node);
@@ -322,7 +322,7 @@ public:
{ {
TestStorage storage; TestStorage storage;
Id id = Id id =
storage.onEnumParsed(validLocation(1), utility::splitToVector("Class::Category", "::"), storage.onEnumParsed(validLocation(1), createNameHierarchy("Class::Category"),
ParserClient::ACCESS_PRIVATE, validLocation(2) ParserClient::ACCESS_PRIVATE, validLocation(2)
); );
@@ -347,7 +347,7 @@ public:
void test_storage_saves_enum_constant() void test_storage_saves_enum_constant()
{ {
TestStorage storage; TestStorage storage;
Id id = storage.onEnumConstantParsed(validLocation(1), utility::splitToVector("VALUE", "::")); Id id = storage.onEnumConstantParsed(validLocation(1), createNameHierarchy("VALUE"));
Node* node = storage.getNodeWithId(id); Node* node = storage.getNodeWithId(id);
TS_ASSERT(node); TS_ASSERT(node);
@@ -362,11 +362,11 @@ public:
void test_storage_saves_class_inheritance() void test_storage_saves_class_inheritance()
{ {
TestStorage storage; TestStorage storage;
storage.onClassParsed(validLocation(), utility::splitToVector("ClassA", "::"), ParserClient::ACCESS_NONE, validLocation()); storage.onClassParsed(validLocation(), createNameHierarchy("ClassA"), ParserClient::ACCESS_NONE, validLocation());
storage.onClassParsed(validLocation(), utility::splitToVector("ClassB", "::"), ParserClient::ACCESS_NONE, validLocation()); storage.onClassParsed(validLocation(), createNameHierarchy("ClassB"), ParserClient::ACCESS_NONE, validLocation());
Id id = Id id =
storage.onInheritanceParsed(validLocation(5), utility::splitToVector("ClassB", "::"), storage.onInheritanceParsed(validLocation(5), createNameHierarchy("ClassB"),
utility::splitToVector("ClassA", "::"), ParserClient::ACCESS_PUBLIC createNameHierarchy("ClassA"), ParserClient::ACCESS_PUBLIC
); );
Edge* edge = storage.getEdgeWithId(id); Edge* edge = storage.getEdgeWithId(id);
@@ -387,11 +387,11 @@ public:
void test_storage_saves_struct_inheritance() void test_storage_saves_struct_inheritance()
{ {
TestStorage storage; TestStorage storage;
storage.onStructParsed(validLocation(), utility::splitToVector("StructA", "::"), ParserClient::ACCESS_NONE, validLocation()); storage.onStructParsed(validLocation(), createNameHierarchy("StructA"), ParserClient::ACCESS_NONE, validLocation());
storage.onStructParsed(validLocation(), utility::splitToVector("StructB", "::"), ParserClient::ACCESS_NONE, validLocation()); storage.onStructParsed(validLocation(), createNameHierarchy("StructB"), ParserClient::ACCESS_NONE, validLocation());
Id id = Id id =
storage.onInheritanceParsed(validLocation(5), utility::splitToVector("StructB", "::"), storage.onInheritanceParsed(validLocation(5), createNameHierarchy("StructB"),
utility::splitToVector("StructA", "::"), ParserClient::ACCESS_PUBLIC createNameHierarchy("StructA"), ParserClient::ACCESS_PUBLIC
); );
Edge* edge = storage.getEdgeWithId(id); Edge* edge = storage.getEdgeWithId(id);
@@ -413,8 +413,8 @@ public:
{ {
TestStorage storage; TestStorage storage;
ParseFunction a(typeUsage("void"), utility::splitToVector("A::isMethod", "::"), parameters("bool")); ParseFunction a(typeUsage("void"), createNameHierarchy("A::isMethod"), parameters("bool"));
ParseFunction b(typeUsage("void"), utility::splitToVector("B::isMethod", "::"), parameters("bool")); ParseFunction b(typeUsage("void"), createNameHierarchy("B::isMethod"), parameters("bool"));
storage.onMethodParsed(validLocation(9), a, ParserClient::ACCESS_PRIVATE, ParserClient::ABSTRACTION_VIRTUAL, validLocation(4)); storage.onMethodParsed(validLocation(9), a, ParserClient::ACCESS_PRIVATE, ParserClient::ABSTRACTION_VIRTUAL, validLocation(4));
storage.onMethodParsed(validLocation(7), b, ParserClient::ACCESS_PRIVATE, ParserClient::ABSTRACTION_NONE, validLocation(3)); storage.onMethodParsed(validLocation(7), b, ParserClient::ACCESS_PRIVATE, ParserClient::ABSTRACTION_NONE, validLocation(3));
@@ -432,15 +432,15 @@ public:
{ {
TestStorage storage; TestStorage storage;
storage.onFunctionParsed( storage.onFunctionParsed(
validLocation(), ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("char")), validLocation() validLocation(), ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char")), validLocation()
); );
storage.onFunctionParsed( storage.onFunctionParsed(
validLocation(), ParseFunction(typeUsage("void"), utility::splitToVector("func", "::"), parameters("bool")), validLocation() validLocation(), ParseFunction(typeUsage("void"), createNameHierarchy("func"), parameters("bool")), validLocation()
); );
Id id = storage.onCallParsed( Id id = storage.onCallParsed(
validLocation(9), validLocation(9),
ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("char")), ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char")),
ParseFunction(typeUsage("void"), utility::splitToVector("func", "::"), parameters("bool")) ParseFunction(typeUsage("void"), createNameHierarchy("func"), parameters("bool"))
); );
Edge* edge = storage.getEdgeWithId(id); Edge* edge = storage.getEdgeWithId(id);
@@ -458,15 +458,15 @@ public:
void test_storage_saves_call_in_global_variable_declaration() void test_storage_saves_call_in_global_variable_declaration()
{ {
TestStorage storage; TestStorage storage;
storage.onGlobalVariableParsed(validLocation(), ParseVariable(typeUsage("bool"), utility::splitToVector("global", "::"), false)); storage.onGlobalVariableParsed(validLocation(), ParseVariable(typeUsage("bool"), createNameHierarchy("global"), false));
storage.onFunctionParsed( storage.onFunctionParsed(
validLocation(), ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("char")), validLocation() validLocation(), ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char")), validLocation()
); );
Id id = storage.onCallParsed( Id id = storage.onCallParsed(
validLocation(7), validLocation(7),
ParseVariable(typeUsage("bool"), utility::splitToVector("global", "::"), false), ParseVariable(typeUsage("bool"), createNameHierarchy("global"), false),
ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("char")) ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char"))
); );
Edge* edge = storage.getEdgeWithId(id); Edge* edge = storage.getEdgeWithId(id);
@@ -485,16 +485,16 @@ public:
{ {
TestStorage storage; TestStorage storage;
storage.onFunctionParsed( storage.onFunctionParsed(
validLocation(), ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("char")), validLocation() validLocation(), ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char")), validLocation()
); );
storage.onFieldParsed( storage.onFieldParsed(
validLocation(), ParseVariable(typeUsage("bool"), utility::splitToVector("Foo::m_field", "::"), false), ParserClient::ACCESS_PRIVATE validLocation(), ParseVariable(typeUsage("bool"), createNameHierarchy("Foo::m_field"), false), ParserClient::ACCESS_PRIVATE
); );
Id id = storage.onFieldUsageParsed( Id id = storage.onFieldUsageParsed(
validLocation(7), validLocation(7),
ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("char")), ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char")),
utility::splitToVector("Foo::m_field", "::") createNameHierarchy("Foo::m_field")
); );
Edge* edge = storage.getEdgeWithId(id); Edge* edge = storage.getEdgeWithId(id);
@@ -513,14 +513,14 @@ public:
{ {
TestStorage storage; TestStorage storage;
storage.onFunctionParsed( storage.onFunctionParsed(
validLocation(), ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("char")), validLocation() validLocation(), ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char")), validLocation()
); );
storage.onGlobalVariableParsed(validLocation(), ParseVariable(typeUsage("bool"), utility::splitToVector("global", "::"), false)); storage.onGlobalVariableParsed(validLocation(), ParseVariable(typeUsage("bool"), createNameHierarchy("global"), false));
Id id = storage.onGlobalVariableUsageParsed( Id id = storage.onGlobalVariableUsageParsed(
validLocation(7), validLocation(7),
ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("char")), ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char")),
utility::splitToVector("global", "::") createNameHierarchy("global")
); );
Edge* edge = storage.getEdgeWithId(id); Edge* edge = storage.getEdgeWithId(id);
@@ -539,15 +539,15 @@ public:
{ {
TestStorage storage; TestStorage storage;
storage.onFunctionParsed( storage.onFunctionParsed(
validLocation(), ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), validLocation(), ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"),
parameters("char")), validLocation() parameters("char")), validLocation()
); );
storage.onStructParsed( storage.onStructParsed(
validLocation(), utility::splitToVector("Struct", "::"), ParserClient::ACCESS_NONE, validLocation()); validLocation(), createNameHierarchy("Struct"), ParserClient::ACCESS_NONE, validLocation());
Id id = storage.onTypeUsageParsed( Id id = storage.onTypeUsageParsed(
typeUsage("Struct"), typeUsage("Struct"),
ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("char")) ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char"))
); );
Edge* edge = storage.getEdgeWithId(id); Edge* edge = storage.getEdgeWithId(id);
@@ -566,7 +566,7 @@ public:
{ {
TestStorage storage; TestStorage storage;
storage.onFunctionParsed( storage.onFunctionParsed(
validLocation(), ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), validLocation(), ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"),
parameters("char")), validLocation() parameters("char")), validLocation()
); );
@@ -591,12 +591,12 @@ public:
TestStorage storage; TestStorage storage;
ParseFunction isTrue = ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("char")); ParseFunction isTrue = ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char"));
storage.onFunctionParsed(validLocation(), isTrue, validLocation()); storage.onFunctionParsed(validLocation(), isTrue, validLocation());
m_filePath = "file.cpp"; m_filePath = "file.cpp";
ParseFunction main = ParseFunction(typeUsage("int"), utility::splitToVector("main", "::"), parameters("void")); ParseFunction main = ParseFunction(typeUsage("int"), createNameHierarchy("main"), parameters("void"));
storage.onFunctionParsed(validLocation(), main, validLocation()); storage.onFunctionParsed(validLocation(), main, validLocation());
storage.onCallParsed(validLocation(), main, isTrue); storage.onCallParsed(validLocation(), main, isTrue);
@@ -622,12 +622,12 @@ public:
TestStorage storage; TestStorage storage;
ParseFunction isTrue = ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("void")); ParseFunction isTrue = ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("void"));
storage.onFunctionParsed(validLocation(), isTrue, validLocation()); storage.onFunctionParsed(validLocation(), isTrue, validLocation());
m_filePath = "file.cpp"; m_filePath = "file.cpp";
ParseFunction main = ParseFunction(typeUsage("int"), utility::splitToVector("main", "::"), parameters("void")); ParseFunction main = ParseFunction(typeUsage("int"), createNameHierarchy("main"), parameters("void"));
storage.onFunctionParsed(validLocation(), main, validLocation()); storage.onFunctionParsed(validLocation(), main, validLocation());
storage.onCallParsed(validLocation(), main, isTrue); storage.onCallParsed(validLocation(), main, isTrue);
@@ -653,12 +653,12 @@ public:
TestStorage storage; TestStorage storage;
ParseFunction isTrue = ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("void")); ParseFunction isTrue = ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("void"));
storage.onFunctionParsed(validLocation(), isTrue, validLocation()); storage.onFunctionParsed(validLocation(), isTrue, validLocation());
m_filePath = "file.cpp"; m_filePath = "file.cpp";
ParseFunction main = ParseFunction(typeUsage("int"), utility::splitToVector("main", "::"), parameters("void")); ParseFunction main = ParseFunction(typeUsage("int"), createNameHierarchy("main"), parameters("void"));
storage.onFunctionParsed(validLocation(), main, validLocation()); storage.onFunctionParsed(validLocation(), main, validLocation());
storage.onCallParsed(validLocation(), main, isTrue); storage.onCallParsed(validLocation(), main, isTrue);
@@ -800,9 +800,19 @@ private:
location->getColumnNumber() == locationId; location->getColumnNumber() == locationId;
} }
NameHierarchy createNameHierarchy(std::string s) const
{
NameHierarchy nameHierarchy;
for (std::string element: utility::splitToVector(s, "::"))
{
nameHierarchy.push(std::make_shared<NameElement>(element));
}
return nameHierarchy;
}
ParseTypeUsage typeUsage(const std::string& typeName) const ParseTypeUsage typeUsage(const std::string& typeName) const
{ {
return ParseTypeUsage(validLocation(), std::make_shared<NamedDataType>(utility::splitToVector(typeName, "::"))); return ParseTypeUsage(validLocation(), std::make_shared<NamedDataType>(createNameHierarchy(typeName)));
} }
std::vector<ParseTypeUsage> parameters(const std::string& param) const std::vector<ParseTypeUsage> parameters(const std::string& param) const