From bdbd266a679db13cdae7fba89912fa8da8083222 Mon Sep 17 00:00:00 2001 From: malte_langkabel Date: Sat, 28 Mar 2015 16:57:30 +0100 Subject: [PATCH] data: NameHierarchy class * replaced vector of strings as name hierarchy by a new NameHierarchy class. * Adjusted code in ASTVisitor, Storage and various test cases. --- src/lib/CMakeLists.txt | 5 ++ src/lib/data/Storage.cpp | 87 ++++++++++--------- src/lib/data/Storage.h | 46 +++++----- src/lib/data/name/NameElement.cpp | 15 ++++ src/lib/data/name/NameElement.h | 18 ++++ src/lib/data/name/NameHierarchy.cpp | 48 +++++++++++ src/lib/data/name/NameHierarchy.h | 28 ++++++ src/lib/data/parser/ParseFunction.cpp | 4 +- src/lib/data/parser/ParseFunction.h | 7 +- src/lib/data/parser/ParseVariable.cpp | 6 +- src/lib/data/parser/ParseVariable.h | 5 +- src/lib/data/parser/ParserClient.h | 43 +++++----- src/lib/data/parser/cxx/ASTVisitor.cpp | 18 ++-- src/lib/data/parser/cxx/utilityCxx.cpp | 63 ++++++++------ src/lib/data/parser/cxx/utilityCxx.h | 9 +- src/lib/data/search/SearchIndex.cpp | 6 +- src/lib/data/search/SearchIndex.h | 3 +- src/lib/data/type/DataType.h | 5 +- src/lib/data/type/ModifiedDataType.cpp | 2 +- src/lib/data/type/ModifiedDataType.h | 2 +- src/lib/data/type/NamedDataType.cpp | 6 +- src/lib/data/type/NamedDataType.h | 8 +- src/test/CxxParserTestSuite.h | 103 +++++++++++++--------- src/test/DataTypeTestSuite.h | 27 ++++-- src/test/SearchIndexTestSuite.h | 73 +++++++++------- src/test/StorageGraphTestSuite.h | 17 +++- src/test/StorageTestSuite.h | 114 ++++++++++++++----------- 27 files changed, 485 insertions(+), 283 deletions(-) create mode 100644 src/lib/data/name/NameElement.cpp create mode 100644 src/lib/data/name/NameElement.h create mode 100644 src/lib/data/name/NameHierarchy.cpp create mode 100644 src/lib/data/name/NameHierarchy.h diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt index ec27d072..53c9896e 100644 --- a/src/lib/CMakeLists.txt +++ b/src/lib/CMakeLists.txt @@ -137,6 +137,11 @@ add_files( data/location/TokenLocationLine.cpp 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.h data/parser/ParseLocation.cpp diff --git a/src/lib/data/Storage.cpp b/src/lib/data/Storage.cpp index 6e7cd03c..09351955 100644 --- a/src/lib/data/Storage.cpp +++ b/src/lib/data/Storage.cpp @@ -26,7 +26,9 @@ Storage::Storage() { for (const std::pair& p : QueryCommand::getCommandTypeMap()) { - m_filterIndex.addNode(std::vector(1, p.first)); + NameHierarchy commandNameHierarchy; + commandNameHierarchy.push(std::make_shared(p.first)); + m_filterIndex.addNode(commandNameHierarchy); } } @@ -197,10 +199,10 @@ void Storage::onError(const ParseLocation& location, const std::string& message) } Id Storage::onTypedefParsed( - const ParseLocation& location, const std::vector& nameHierarchy, const ParseTypeUsage& underlyingType, + const ParseLocation& location, const NameHierarchy& nameHierarchy, const ParseTypeUsage& underlyingType, 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); addAccess(node, access); @@ -211,10 +213,10 @@ Id Storage::onTypedefParsed( } Id Storage::onClassParsed( - const ParseLocation& location, const std::vector& nameHierarchy, AccessType access, + const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access, const ParseLocation& scopeLocation ){ - log("class", utility::join(nameHierarchy, "::"), location); + log("class", nameHierarchy.getFullName(), location); Node* node = addNodeHierarchy(Node::NODE_CLASS, nameHierarchy); addAccess(node, access); @@ -225,10 +227,10 @@ Id Storage::onClassParsed( } Id Storage::onStructParsed( - const ParseLocation& location, const std::vector& nameHierarchy, AccessType access, + const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access, const ParseLocation& scopeLocation ){ - log("struct", utility::join(nameHierarchy, "::"), location); + log("struct", nameHierarchy.getFullName(), location); Node* node = addNodeHierarchy(Node::NODE_STRUCT, nameHierarchy); addAccess(node, access); @@ -345,9 +347,9 @@ Id Storage::onMethodParsed( } Id Storage::onNamespaceParsed( - const ParseLocation& location, const std::vector& 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); if (location.isValid()) @@ -360,10 +362,10 @@ Id Storage::onNamespaceParsed( } Id Storage::onEnumParsed( - const ParseLocation& location, const std::vector& nameHierarchy, AccessType access, + const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access, const ParseLocation& scopeLocation ){ - log("enum", utility::join(nameHierarchy, "::"), location); + log("enum", nameHierarchy.getFullName(), location); Node* node = addNodeHierarchy(Node::NODE_ENUM, nameHierarchy); addAccess(node, access); @@ -373,9 +375,9 @@ Id Storage::onEnumParsed( return node->getId(); } -Id Storage::onEnumConstantParsed(const ParseLocation& location, const std::vector& 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); addTokenLocation(node, location); @@ -384,10 +386,10 @@ Id Storage::onEnumConstantParsed(const ParseLocation& location, const std::vecto } Id Storage::onInheritanceParsed( - const ParseLocation& location, const std::vector& nameHierarchy, - const std::vector& baseNameHierarchy, AccessType access + const ParseLocation& location, const NameHierarchy& nameHierarchy, + 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* baseNode = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, baseNameHierarchy); @@ -442,9 +444,9 @@ Id Storage::onCallParsed(const ParseLocation& location, const ParseVariable& cal Id Storage::onVariableUsageParsed( const std::string kind, const ParseLocation& location, const ParseFunction& user, - const std::vector& 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* usedNode = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, usedNameHierarchy); @@ -456,21 +458,21 @@ Id Storage::onVariableUsageParsed( } Id Storage::onFieldUsageParsed( - const ParseLocation& location, const ParseFunction& user, const std::vector& usedNameHierarchy + const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy ){ return onVariableUsageParsed("field usage", location, user, usedNameHierarchy); } Id Storage::onGlobalVariableUsageParsed( // or static variable used - const ParseLocation& location, const ParseFunction& user, const std::vector& usedNameHierarchy + const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy ){ return onVariableUsageParsed("global usage", location, user, usedNameHierarchy); } Id Storage::onGlobalVariableUsageParsed( - const ParseLocation& location, const ParseVariable& user, const std::vector& 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* usedNode = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, usedNameHierarchy); @@ -482,15 +484,15 @@ Id Storage::onGlobalVariableUsageParsed( } Id Storage::onEnumConstantUsageParsed( - const ParseLocation& location, const ParseFunction& user, const std::vector& usedNameHierarchy + const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy ){ return onVariableUsageParsed("enum constant usage", location, user, usedNameHierarchy); } Id Storage::onEnumConstantUsageParsed( - const ParseLocation& location, const ParseVariable& user, const std::vector& 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* usedNode = addNodeHierarchy(Node::NODE_UNDEFINED_VARIABLE, usedNameHierarchy); @@ -534,12 +536,12 @@ Id Storage::onTypeUsageParsed(const ParseTypeUsage& type, const ParseVariable& v } Id Storage::onTemplateArgumentTypeParsed( - const ParseLocation& location, const std::vector& argumentNameHierarchy, - const std::vector& templateNameHierarchy) + const ParseLocation& location, const NameHierarchy& argumentNameHierarchy, + const NameHierarchy& templateNameHierarchy) { log( "template argument type", - utility::join(argumentNameHierarchy, "::") + " -> " + utility::join(templateNameHierarchy, "::"), + argumentNameHierarchy.getFullName() + " -> " + templateNameHierarchy.getFullName(), location ); @@ -556,12 +558,11 @@ Id Storage::onTemplateArgumentTypeParsed( } Id Storage::onTemplateDefaultArgumentTypeParsed( - const ParseTypeUsage& defaultArgumentType, const std::vector& templateArgumentTypeNameHierarchy + const ParseTypeUsage& defaultArgumentType, const NameHierarchy& templateArgumentTypeNameHierarchy ){ log( "template default argument", - utility::join(defaultArgumentType.dataType->getTypeNameHierarchy(), "::") + - " -> " + utility::join(templateArgumentTypeNameHierarchy, "::"), + defaultArgumentType.dataType->getTypeNameHierarchy().getFullName() + " -> " + templateArgumentTypeNameHierarchy.getFullName(), defaultArgumentType.location ); @@ -577,10 +578,10 @@ Id Storage::onTemplateDefaultArgumentTypeParsed( } Id Storage::onTemplateRecordParameterTypeParsed( - const ParseLocation& location, const std::vector& templateParameterTypeNameHierarchy, - const std::vector& templateRecordNameHierarchy + const ParseLocation& location, const NameHierarchy& templateParameterTypeNameHierarchy, + 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); addTokenLocation(templateParameterNode, location); @@ -592,12 +593,12 @@ Id Storage::onTemplateRecordParameterTypeParsed( } Id Storage::onTemplateRecordSpecializationParsed( - const ParseLocation& location, const std::vector& specializedRecordNameHierarchy, - const RecordType specializedRecordType, const std::vector& specializedFromNameHierarchy + const ParseLocation& location, const NameHierarchy& specializedRecordNameHierarchy, + const RecordType specializedRecordType, const NameHierarchy& specializedFromNameHierarchy ){ log( "template record specialization", - utility::join(specializedRecordNameHierarchy, "::") + " -> " + utility::join(specializedFromNameHierarchy, "::"), + specializedRecordNameHierarchy.getFullName() + " -> " + specializedFromNameHierarchy.getFullName(), location ); @@ -617,9 +618,9 @@ Id Storage::onTemplateRecordSpecializationParsed( } Id Storage::onTemplateFunctionParameterTypeParsed( - const ParseLocation& location, const std::vector& 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); addTokenLocation(templateParameterNode, location); @@ -1069,7 +1070,7 @@ const SearchIndex& Storage::getSearchIndex() const return m_tokenIndex; } -Node* Storage::addNodeHierarchy(Node::NodeType type, std::vector nameHierarchy) +Node* Storage::addNodeHierarchy(Node::NodeType type, NameHierarchy nameHierarchy) { SearchNode* searchNode = m_tokenIndex.addNode(nameHierarchy); if (!searchNode) @@ -1099,7 +1100,9 @@ Node* Storage::addNodeHierarchyWithDistinctSignature(Node::NodeType type, const Node* Storage::addFileNode(const FilePath& filePath) { - Node* fileNode = addNodeHierarchy(Node::NODE_FILE, std::vector(1, filePath.fileName())); + NameHierarchy fileNameHierarchy; + fileNameHierarchy.push(std::make_shared(filePath.fileName())); + Node* fileNode = addNodeHierarchy(Node::NODE_FILE, fileNameHierarchy); if (!fileNode->getComponent()) { @@ -1175,7 +1178,7 @@ Edge* Storage::addTypeEdge(Node* node, Edge::EdgeType edgeType, const ParseTypeU return nullptr; } - std::vector nameHierarchy = typeUsage.dataType->getTypeNameHierarchy(); + NameHierarchy nameHierarchy = typeUsage.dataType->getTypeNameHierarchy(); Node* typeNode = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, nameHierarchy); if (!typeNode) diff --git a/src/lib/data/Storage.h b/src/lib/data/Storage.h index d6c09f39..92f65efc 100644 --- a/src/lib/data/Storage.h +++ b/src/lib/data/Storage.h @@ -35,13 +35,13 @@ public: virtual void onError(const ParseLocation& location, const std::string& message); virtual Id onTypedefParsed( - const ParseLocation& location, const std::vector& nameHierarchy, + const ParseLocation& location, const NameHierarchy& nameHierarchy, const ParseTypeUsage& underlyingType, AccessType access); virtual Id onClassParsed( - const ParseLocation& location, const std::vector& nameHierarchy, AccessType access, + const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access, const ParseLocation& scopeLocation); virtual Id onStructParsed( - const ParseLocation& location, const std::vector& nameHierarchy, AccessType access, + const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access, const ParseLocation& scopeLocation); virtual Id onGlobalVariableParsed(const ParseLocation& location, const ParseVariable& variable); @@ -54,16 +54,16 @@ public: const ParseLocation& scopeLocation); virtual Id onNamespaceParsed( - const ParseLocation& location, const std::vector& nameHierarchy, const ParseLocation& scopeLocation); + const ParseLocation& location, const NameHierarchy& nameHierarchy, const ParseLocation& scopeLocation); virtual Id onEnumParsed( - const ParseLocation& location, const std::vector& nameHierarchy, AccessType access, + const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access, const ParseLocation& scopeLocation); - virtual Id onEnumConstantParsed(const ParseLocation& location, const std::vector& nameHierarchy); + virtual Id onEnumConstantParsed(const ParseLocation& location, const NameHierarchy& nameHierarchy); virtual Id onInheritanceParsed( - const ParseLocation& location, const std::vector& nameHierarchy, - const std::vector& baseNameHierarchy, AccessType access); + const ParseLocation& location, const NameHierarchy& nameHierarchy, + const NameHierarchy& baseNameHierarchy, AccessType access); virtual Id onMethodOverrideParsed(const ParseFunction& base, const ParseFunction& overrider); virtual Id onCallParsed( const ParseLocation& location, const ParseFunction& caller, const ParseFunction& callee); @@ -71,33 +71,33 @@ public: const ParseLocation& location, const ParseVariable& caller, const ParseFunction& callee); Id onVariableUsageParsed( const std::string kind, const ParseLocation& location, const ParseFunction& user, - const std::vector& usedNameHierarchy); // helper + const NameHierarchy& usedNameHierarchy); // helper virtual Id onFieldUsageParsed( - const ParseLocation& location, const ParseFunction& user, const std::vector& usedNameHierarchy); + const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy); virtual Id onGlobalVariableUsageParsed( - const ParseLocation& location, const ParseFunction& user, const std::vector& usedNameHierarchy); + const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy); virtual Id onGlobalVariableUsageParsed( - const ParseLocation& location, const ParseVariable& user, const std::vector& usedNameHierarchy); + const ParseLocation& location, const ParseVariable& user, const NameHierarchy& usedNameHierarchy); virtual Id onEnumConstantUsageParsed( - const ParseLocation& location, const ParseFunction& user, const std::vector& usedNameHierarchy); + const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy); virtual Id onEnumConstantUsageParsed( - const ParseLocation& location, const ParseVariable& user, const std::vector& 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 ParseVariable& variable); virtual Id onTemplateArgumentTypeParsed( - const ParseLocation& location, const std::vector& argumentNameHierarchy, - const std::vector& templateNameHierarchy); + const ParseLocation& location, const NameHierarchy& argumentNameHierarchy, + const NameHierarchy& templateNameHierarchy); virtual Id onTemplateDefaultArgumentTypeParsed( - const ParseTypeUsage& type, const std::vector& templateArgumentTypeNameHierarchy); + const ParseTypeUsage& type, const NameHierarchy& templateArgumentTypeNameHierarchy); virtual Id onTemplateRecordParameterTypeParsed( - const ParseLocation& location, const std::vector& templateParameterTypeNameHierarchy, - const std::vector& templateRecordNameHierarchy); + const ParseLocation& location, const NameHierarchy& templateParameterTypeNameHierarchy, + const NameHierarchy& templateRecordNameHierarchy); virtual Id onTemplateRecordSpecializationParsed( - const ParseLocation& location, const std::vector& specializedRecordNameHierarchy, - const RecordType specializedRecordType, const std::vector& specializedFromNameHierarchy); + const ParseLocation& location, const NameHierarchy& specializedRecordNameHierarchy, + const RecordType specializedRecordType, const NameHierarchy& specializedFromNameHierarchy); virtual Id onTemplateFunctionParameterTypeParsed( - const ParseLocation& location, const std::vector& templateParameterTypeNameHierarchy, const ParseFunction function); + const ParseLocation& location, const NameHierarchy& templateParameterTypeNameHierarchy, const ParseFunction function); virtual Id onTemplateFunctionSpecializationParsed( const ParseLocation& location, const ParseFunction specializedFunction, const ParseFunction templateFunction); @@ -133,7 +133,7 @@ protected: const SearchIndex& getSearchIndex() const; private: - Node* addNodeHierarchy(Node::NodeType type, std::vector nameHierarchy); + Node* addNodeHierarchy(Node::NodeType type, NameHierarchy nameHierarchy); Node* addNodeHierarchyWithDistinctSignature(Node::NodeType type, const ParseFunction& function); Node* addFileNode(const FilePath& filePath); diff --git a/src/lib/data/name/NameElement.cpp b/src/lib/data/name/NameElement.cpp new file mode 100644 index 00000000..d37fa833 --- /dev/null +++ b/src/lib/data/name/NameElement.cpp @@ -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; +} diff --git a/src/lib/data/name/NameElement.h b/src/lib/data/name/NameElement.h new file mode 100644 index 00000000..a633dded --- /dev/null +++ b/src/lib/data/name/NameElement.h @@ -0,0 +1,18 @@ +#ifndef NAME_ELEMENT_H +#define NAME_ELEMENT_H + +#include + +class NameElement +{ +public: + NameElement(std::string name); + ~NameElement(); + + std::string getFullName() const; + +private: + std::string m_name; +}; + +#endif // NAME_ELEMENT_H diff --git a/src/lib/data/name/NameHierarchy.cpp b/src/lib/data/name/NameHierarchy.cpp new file mode 100644 index 00000000..256fe6ea --- /dev/null +++ b/src/lib/data/name/NameHierarchy.cpp @@ -0,0 +1,48 @@ +#include "data/name/NameHierarchy.h" + +NameHierarchy::NameHierarchy() +{ +} + +NameHierarchy::~NameHierarchy() +{ +} + +void NameHierarchy::push(std::shared_ptr element) +{ + m_elements.push_back(element); +} + +void NameHierarchy::pop() +{ + m_elements.pop_back(); +} + +std::shared_ptr NameHierarchy::back() +{ + return m_elements.back(); +} + +std::shared_ptr 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; +} diff --git a/src/lib/data/name/NameHierarchy.h b/src/lib/data/name/NameHierarchy.h new file mode 100644 index 00000000..f3d77a09 --- /dev/null +++ b/src/lib/data/name/NameHierarchy.h @@ -0,0 +1,28 @@ +#ifndef NAME_HIERARCHY_H +#define NAME_HIERARCHY_H + +#include +#include +#include + +#include "data/name/NameElement.h" + +class NameHierarchy +{ +public: + NameHierarchy(); + ~NameHierarchy(); + + void push(std::shared_ptr element); + void pop(); + std::shared_ptr back(); + std::shared_ptr operator[](size_t pos) const; + size_t size() const; + + std::string getFullName() const; + +private: + std::vector> m_elements; +}; + +#endif // NAME_ELEMENT_H diff --git a/src/lib/data/parser/ParseFunction.cpp b/src/lib/data/parser/ParseFunction.cpp index 1e812b37..ad3dd9e3 100644 --- a/src/lib/data/parser/ParseFunction.cpp +++ b/src/lib/data/parser/ParseFunction.cpp @@ -4,7 +4,7 @@ ParseFunction::ParseFunction( const ParseTypeUsage& returnType, - const std::vector& nameHierarchy, + const NameHierarchy& nameHierarchy, const std::vector& parameters, bool isStatic, bool isConst @@ -19,5 +19,5 @@ ParseFunction::ParseFunction( std::string ParseFunction::getFullName() const { - return utility::join(nameHierarchy, "::"); + return nameHierarchy.getFullName(); } diff --git a/src/lib/data/parser/ParseFunction.h b/src/lib/data/parser/ParseFunction.h index b58bd81e..2efa185e 100644 --- a/src/lib/data/parser/ParseFunction.h +++ b/src/lib/data/parser/ParseFunction.h @@ -1,15 +1,14 @@ #ifndef PARSE_FUNCTION_H #define PARSE_FUNCTION_H -#include - +#include "data/name/NameHierarchy.h" #include "data/parser/ParseTypeUsage.h" struct ParseFunction { ParseFunction( const ParseTypeUsage& returnType, - const std::vector& nameHierarchy, + const NameHierarchy& nameHierarchy, const std::vector& parameters, bool isStatic = false, bool isConst = false @@ -18,7 +17,7 @@ struct ParseFunction std::string getFullName() const; const ParseTypeUsage returnType; - const std::vector nameHierarchy; + const NameHierarchy nameHierarchy; const std::vector parameters; const bool isStatic; const bool isConst; diff --git a/src/lib/data/parser/ParseVariable.cpp b/src/lib/data/parser/ParseVariable.cpp index 0595b05c..2ba5b03e 100644 --- a/src/lib/data/parser/ParseVariable.cpp +++ b/src/lib/data/parser/ParseVariable.cpp @@ -2,7 +2,7 @@ #include "utility/utilityString.h" -ParseVariable::ParseVariable(const ParseTypeUsage& type, const std::vector& nameHierarchy, bool isStatic) +ParseVariable::ParseVariable(const ParseTypeUsage& type, const NameHierarchy& nameHierarchy, bool isStatic) : type(type) , nameHierarchy(nameHierarchy) , isStatic(isStatic) @@ -11,5 +11,5 @@ ParseVariable::ParseVariable(const ParseTypeUsage& type, const std::vector +#include "data/name/NameHierarchy.h" #include "data/parser/ParseTypeUsage.h" struct ParseVariable { - ParseVariable(const ParseTypeUsage& type, const std::vector& nameHierarchy, bool isStatic); + ParseVariable(const ParseTypeUsage& type, const NameHierarchy& nameHierarchy, bool isStatic); std::string getFullName() const; const ParseTypeUsage type; - const std::vector nameHierarchy; + const NameHierarchy nameHierarchy; const bool isStatic; }; diff --git a/src/lib/data/parser/ParserClient.h b/src/lib/data/parser/ParserClient.h index e546d1da..2c961c17 100644 --- a/src/lib/data/parser/ParserClient.h +++ b/src/lib/data/parser/ParserClient.h @@ -5,6 +5,7 @@ #include #include "utility/types.h" +#include "data/name/NameHierarchy.h" struct ParseFunction; struct ParseLocation; @@ -52,13 +53,13 @@ public: virtual void onError(const ParseLocation& location, const std::string& message) = 0; virtual Id onTypedefParsed( - const ParseLocation& location, const std::vector& nameHierarchy, + const ParseLocation& location, const NameHierarchy& nameHierarchy, const ParseTypeUsage& underlyingType, AccessType access) = 0; virtual Id onClassParsed( - const ParseLocation& location, const std::vector& nameHierarchy, AccessType access, + const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access, const ParseLocation& scopeLocation) = 0; virtual Id onStructParsed( - const ParseLocation& location, const std::vector& nameHierarchy, AccessType access, + const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access, const ParseLocation& scopeLocation) = 0; virtual Id onGlobalVariableParsed(const ParseLocation& location, const ParseVariable& variable) = 0; @@ -71,48 +72,48 @@ public: const ParseLocation& scopeLocation) = 0; virtual Id onNamespaceParsed( - const ParseLocation& location, const std::vector& nameHierarchy, + const ParseLocation& location, const NameHierarchy& nameHierarchy, const ParseLocation& scopeLocation) = 0; virtual Id onEnumParsed( - const ParseLocation& location, const std::vector& nameHierarchy, AccessType access, + const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access, const ParseLocation& scopeLocation) = 0; - virtual Id onEnumConstantParsed(const ParseLocation& location, const std::vector& nameHierarchy) = 0; + virtual Id onEnumConstantParsed(const ParseLocation& location, const NameHierarchy& nameHierarchy) = 0; virtual Id onInheritanceParsed( - const ParseLocation& location, const std::vector& nameHierarchy, - const std::vector& baseNameHierarchy, AccessType access) = 0; + const ParseLocation& location, const NameHierarchy& nameHierarchy, + const NameHierarchy& baseNameHierarchy, AccessType access) = 0; virtual Id onMethodOverrideParsed(const ParseFunction& base, const ParseFunction& overrider) = 0; virtual Id onCallParsed( const ParseLocation& location, const ParseFunction& caller, const ParseFunction& callee) = 0; virtual Id onCallParsed( const ParseLocation& location, const ParseVariable& caller, const ParseFunction& callee) = 0; virtual Id onFieldUsageParsed( - const ParseLocation& location, const ParseFunction& user, const std::vector& usedNameHierarchy) = 0; + const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy) = 0; virtual Id onGlobalVariableUsageParsed( - const ParseLocation& location, const ParseFunction& user, const std::vector& usedNameHierarchy) = 0; + const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy) = 0; virtual Id onGlobalVariableUsageParsed( - const ParseLocation& location, const ParseVariable& user, const std::vector& usedNameHierarchy) = 0; + const ParseLocation& location, const ParseVariable& user, const NameHierarchy& usedNameHierarchy) = 0; virtual Id onEnumConstantUsageParsed( - const ParseLocation& location, const ParseFunction& user, const std::vector& usedNameHierarchy) = 0; + const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy) = 0; virtual Id onEnumConstantUsageParsed( - const ParseLocation& location, const ParseVariable& user, const std::vector& 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 ParseVariable& variable) = 0; virtual Id onTemplateArgumentTypeParsed( - const ParseLocation& location, const std::vector& argumentNameHierarchy, - const std::vector& templateNameHierarchy) = 0; + const ParseLocation& location, const NameHierarchy& argumentNameHierarchy, + const NameHierarchy& templateNameHierarchy) = 0; virtual Id onTemplateDefaultArgumentTypeParsed( - const ParseTypeUsage& type, const std::vector& templateArgumentTypeNameHierarchy) = 0; + const ParseTypeUsage& type, const NameHierarchy& templateArgumentTypeNameHierarchy) = 0; virtual Id onTemplateRecordParameterTypeParsed( - const ParseLocation& location, const std::vector& templateParameterTypeNameHierarchy, - const std::vector& templateRecordNameHierarchy) = 0; + const ParseLocation& location, const NameHierarchy& templateParameterTypeNameHierarchy, + const NameHierarchy& templateRecordNameHierarchy) = 0; virtual Id onTemplateRecordSpecializationParsed( - const ParseLocation& location, const std::vector& specializedRecordNameHierarchy, - const RecordType specializedRecordType, const std::vector& specializedFromNameHierarchy) = 0; + const ParseLocation& location, const NameHierarchy& specializedRecordNameHierarchy, + const RecordType specializedRecordType, const NameHierarchy& specializedFromNameHierarchy) = 0; virtual Id onTemplateFunctionParameterTypeParsed( - const ParseLocation& location, const std::vector& templateParameterTypeNameHierarchy, + const ParseLocation& location, const NameHierarchy& templateParameterTypeNameHierarchy, const ParseFunction function) = 0; virtual Id onTemplateFunctionSpecializationParsed( const ParseLocation& location, const ParseFunction specializedFunction, const ParseFunction templateFunction) = 0; diff --git a/src/lib/data/parser/cxx/ASTVisitor.cpp b/src/lib/data/parser/cxx/ASTVisitor.cpp index 783086ee..62b39c8f 100644 --- a/src/lib/data/parser/cxx/ASTVisitor.cpp +++ b/src/lib/data/parser/cxx/ASTVisitor.cpp @@ -311,10 +311,10 @@ bool ASTVisitor::VisitTemplateTemplateParmDecl(clang::TemplateTemplateParmDecl * bool ASTVisitor::VisitClassTemplateDecl(clang::ClassTemplateDecl* declaration) { - std::vector rarchy = utility::getDeclNameHierarchy(declaration); + NameHierarchy rarchy = utility::getDeclNameHierarchy(declaration); if (isLocatedInUnparsedProjectFile(declaration)) { - std::vector templateRecordNameHierarchy = utility::getDeclNameHierarchy(declaration); + NameHierarchy templateRecordNameHierarchy = utility::getDeclNameHierarchy(declaration); clang::TemplateParameterList* parameterList = declaration->getTemplateParameters(); for (size_t i = 0; i < parameterList->size(); i++) { @@ -341,10 +341,10 @@ bool ASTVisitor::VisitClassTemplateDecl(clang::ClassTemplateDecl* declaration) clang::ClassTemplateSpecializationDecl* specializationDecl = *it; // The specializationParent can be an indirect specialization of the ClassTemplate (by specializing a partial specialization). - std::vector specializationParentNameHierarchy = utility::getTemplateSpecializationParentNameHierarchy(specializationDecl); + NameHierarchy specializationParentNameHierarchy = utility::getTemplateSpecializationParentNameHierarchy(specializationDecl); ParserClient::RecordType specializedRecordType = specializationDecl->isStruct() ? ParserClient::RECORD_STRUCT : ParserClient::RECORD_CLASS; - std::vector specializedRecordNameHierarchy = utility::getDeclNameHierarchy(specializationDecl); + NameHierarchy specializedRecordNameHierarchy = utility::getDeclNameHierarchy(specializationDecl); m_client->onTemplateRecordSpecializationParsed( getParseLocationForNamedDecl(*it), specializedRecordNameHierarchy, specializedRecordType, specializationParentNameHierarchy ); @@ -354,7 +354,7 @@ bool ASTVisitor::VisitClassTemplateDecl(clang::ClassTemplateDecl* declaration) const clang::TemplateArgumentList &argList = specializationDecl->getTemplateArgs(); for (size_t i = 0; i < argList.size(); i++) { - std::vector 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. { @@ -374,8 +374,8 @@ bool ASTVisitor::VisitClassTemplatePartialSpecializationDecl(clang::ClassTemplat { if (isLocatedInUnparsedProjectFile(declaration)) { - std::vector specializedRecordNameHierarchy = utility::getDeclNameHierarchy(declaration); - std::vector specializationParentNameHierarchy = utility::getTemplateSpecializationParentNameHierarchy(declaration); + NameHierarchy specializedRecordNameHierarchy = utility::getDeclNameHierarchy(declaration); + NameHierarchy specializationParentNameHierarchy = utility::getTemplateSpecializationParentNameHierarchy(declaration); ParserClient::RecordType specializedRecordType = declaration->isStruct() ? ParserClient::RECORD_STRUCT : ParserClient::RECORD_CLASS; m_client->onTemplateRecordSpecializationParsed( @@ -423,7 +423,7 @@ bool ASTVisitor::VisitFunctionTemplateDecl(clang::FunctionTemplateDecl *declarat if (isLocatedInUnparsedProjectFile(namedDecl)) { - std::vector templateParameterTypeNameHierarchy = utility::getDeclNameHierarchy(namedDecl); + NameHierarchy templateParameterTypeNameHierarchy = utility::getDeclNameHierarchy(namedDecl); m_client->onTemplateFunctionParameterTypeParsed( getParseLocationForNamedDecl(namedDecl), @@ -873,7 +873,7 @@ std::vector ASTVisitor::getParameters(const clang::FunctionDecl* ParseVariable ASTVisitor::getParseVariable(const clang::DeclaratorDecl* declaration) const { bool isStatic = false; - std::vector hameHierarchy = utility::getDeclNameHierarchy(declaration); + NameHierarchy hameHierarchy = utility::getDeclNameHierarchy(declaration); if (clang::isa(declaration)) { const clang::VarDecl* varDecl = clang::dyn_cast(declaration); diff --git a/src/lib/data/parser/cxx/utilityCxx.cpp b/src/lib/data/parser/cxx/utilityCxx.cpp index 4619a0b7..6fa97d44 100644 --- a/src/lib/data/parser/cxx/utilityCxx.cpp +++ b/src/lib/data/parser/cxx/utilityCxx.cpp @@ -41,6 +41,10 @@ namespace utility dataType = std::make_shared(getDeclNameHierarchy(type->getAs()->getDecl())); break; } + case clang::Type::MemberPointer: + { + int ogogo = 0; // test this case! + } case clang::Type::Pointer: { std::shared_ptr innerType = qualTypeToDataType(type->getPointeeType()); @@ -85,15 +89,15 @@ namespace utility clang::QualType::print(type, clang::Qualifiers(), StrOS, pp, clang::Twine()); std::string typeName = StrOS.str(); - std::vector typeNameHerarchy; - typeNameHerarchy.push_back(typeName); + NameHierarchy typeNameHerarchy; + typeNameHerarchy.push(std::make_shared(typeName)); dataType = std::make_shared(typeNameHerarchy); break; } case clang::Type::TemplateSpecialization: { - std::vector typeNameHerarchy; + NameHierarchy typeNameHerarchy; const clang::TagType* tagType = type->getAs(); // remove this case when NameHierarchy is split into namepart and parameter part if (tagType) @@ -116,9 +120,11 @@ namespace utility } templateArgumentPart += ">"; - std::string& declName = typeNameHerarchy.back(); - declName = declName.substr(0, declName.rfind("<")); // remove template parameters + std::string declName = typeNameHerarchy.back()->getFullName(); + declName = declName.substr(0, declName.rfind("<")); // remove template parameters - does not work for A> declName += templateArgumentPart; // add template arguments + typeNameHerarchy.pop(); + typeNameHerarchy.push(std::make_shared(declName)); } } dataType = std::make_shared(typeNameHerarchy); @@ -129,16 +135,18 @@ namespace utility clang::TemplateTypeParmDecl* templateTypeParmDecl = clang::dyn_cast(type)->getDecl(); std::string typeName = getDeclName(templateTypeParmDecl); - std::vector typeNameHerarchy = getContextNameHierarchyOfTemplateParameter(templateTypeParmDecl); + NameHierarchy typeNameHerarchy = getContextNameHierarchyOfTemplateParameter(templateTypeParmDecl); if (typeNameHerarchy.size() == 0) { LOG_ERROR("Unable to resolve type name hierarchy for template parameter \"" + typeName + "\""); - typeNameHerarchy.push_back(typeName); + typeNameHerarchy.push(std::make_shared(typeName)); } else { - typeNameHerarchy.back() += "::" + typeName; + std::string lastContextElementName = typeNameHerarchy.back()->getFullName(); + typeNameHerarchy.pop(); + typeNameHerarchy.push(std::make_shared(lastContextElementName + "::" + typeName)); } dataType = std::make_shared(typeNameHerarchy); break; @@ -153,11 +161,11 @@ namespace utility const clang::DependentNameType* dependentNameType = clang::dyn_cast(type); clang::NestedNameSpecifier* nns = dependentNameType->getQualifier(); clang::NestedNameSpecifier::SpecifierKind nnsKind = nns->getKind(); - std::vector typeNameHerarchy; + NameHierarchy typeNameHerarchy; switch (nnsKind) { case clang::NestedNameSpecifier::Identifier: - typeNameHerarchy.push_back(nns->getAsIdentifier()->getName()); + typeNameHerarchy.push(std::make_shared(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. break; case clang::NestedNameSpecifier::Namespace: @@ -178,7 +186,7 @@ namespace utility break; } - typeNameHerarchy.push_back(dependentNameType->getIdentifier()->getName().str()); + typeNameHerarchy.push(std::make_shared(dependentNameType->getIdentifier()->getName().str())); dataType = std::make_shared(typeNameHerarchy); break; @@ -195,8 +203,8 @@ namespace utility clang::QualType::print(type, clang::Qualifiers(), StrOS, pp, clang::Twine()); std::string typeName = StrOS.str(); - std::vector typeNameHerarchy; - typeNameHerarchy.push_back(typeName); + NameHierarchy typeNameHerarchy; + typeNameHerarchy.push(std::make_shared(typeName)); dataType = std::make_shared(typeNameHerarchy); break; @@ -205,9 +213,9 @@ namespace utility return dataType; } - std::vector getDeclNameHierarchy(const clang::Decl* declaration) + NameHierarchy getDeclNameHierarchy(const clang::Decl* declaration) { - std::vector contextNameHierarchy; + NameHierarchy contextNameHierarchy; if (declaration) { std::string declName = ""; @@ -225,19 +233,22 @@ namespace utility clang::isa(declaration) || clang::isa(declaration)) { - contextNameHierarchy.back() += "::" + declName; + std::string lastContextElementName = contextNameHierarchy.back()->getFullName(); + contextNameHierarchy.pop(); + contextNameHierarchy.push(std::make_shared(lastContextElementName + "::" + declName)); + } else { - contextNameHierarchy.push_back(declName); + contextNameHierarchy.push(std::make_shared(declName)); } } return contextNameHierarchy; } - std::vector getContextNameHierarchy(const clang::DeclContext* declContext) + NameHierarchy getContextNameHierarchy(const clang::DeclContext* declContext) { - std::vector contextNameHierarchy; + NameHierarchy contextNameHierarchy; const clang::DeclContext* parentContext = declContext->getParent(); if (parentContext) @@ -247,18 +258,18 @@ namespace utility if (clang::isa(declContext)) { - std::string declName = getDeclName(clang::dyn_cast(declContext)); + std::string declName = getDeclName(clang::dyn_cast(declContext)); if (declName != "") { - contextNameHierarchy.push_back(declName); + contextNameHierarchy.push(std::make_shared(declName)); } } return contextNameHierarchy; } - std::vector getContextNameHierarchyOfTemplateParameter(const clang::NamedDecl* templateParmDecl) + NameHierarchy getContextNameHierarchyOfTemplateParameter(const clang::NamedDecl* templateParmDecl) // why do we need this?? { - std::vector contextNameHierarchy; + NameHierarchy contextNameHierarchy; const clang::Decl* parentNode = getAstParentDecl(templateParmDecl); if (parentNode && clang::isa(parentNode)) @@ -364,9 +375,9 @@ namespace utility return declName; } - std::vector getTemplateSpecializationParentNameHierarchy(clang::ClassTemplateSpecializationDecl* declaration) + NameHierarchy getTemplateSpecializationParentNameHierarchy(clang::ClassTemplateSpecializationDecl* declaration) { - std::vector specializationParentNameHierarchy; + NameHierarchy specializationParentNameHierarchy; llvm::PointerUnion pu = declaration->getSpecializedTemplateOrPartial(); if (pu.is()) { @@ -424,7 +435,7 @@ namespace utility LOG_ERROR("Type of template argument not handled." + argument.getKind()); break; } - return std::make_shared(std::vector()); + return std::make_shared(NameHierarchy()); } std::string getTemplateParameterString(const clang::NamedDecl* parameter) diff --git a/src/lib/data/parser/cxx/utilityCxx.h b/src/lib/data/parser/cxx/utilityCxx.h index cdfcec70..0d607714 100644 --- a/src/lib/data/parser/cxx/utilityCxx.h +++ b/src/lib/data/parser/cxx/utilityCxx.h @@ -10,17 +10,18 @@ #include "clang/AST/DeclTemplate.h" class DataType; +class NameHierarchy; namespace utility { std::shared_ptr qualTypeToDataType(clang::QualType qualType); std::shared_ptr typeToDataType(const clang::Type* type); - std::vector getDeclNameHierarchy(const clang::Decl* declaration); - std::vector getContextNameHierarchy(const clang::DeclContext* declaration); - std::vector getContextNameHierarchyOfTemplateParameter(const clang::NamedDecl* templateParmDecl); + NameHierarchy getDeclNameHierarchy(const clang::Decl* declaration); + NameHierarchy getContextNameHierarchy(const clang::DeclContext* declaration); + NameHierarchy getContextNameHierarchyOfTemplateParameter(const clang::NamedDecl* templateParmDecl); std::string getDeclName(const clang::NamedDecl* declaration); - std::vector getTemplateSpecializationParentNameHierarchy(clang::ClassTemplateSpecializationDecl* declaration); + NameHierarchy getTemplateSpecializationParentNameHierarchy(clang::ClassTemplateSpecializationDecl* declaration); std::shared_ptr templateArgumentToDataType(const clang::TemplateArgument& argument); std::string getTemplateParameterString(const clang::NamedDecl* parameter); std::string getTemplateParameterTypeString(const clang::NonTypeTemplateParmDecl* parameter); diff --git a/src/lib/data/search/SearchIndex.cpp b/src/lib/data/search/SearchIndex.cpp index 8d79d2b7..58ab7842 100644 --- a/src/lib/data/search/SearchIndex.cpp +++ b/src/lib/data/search/SearchIndex.cpp @@ -51,12 +51,12 @@ const std::string& SearchIndex::getWord(Id wordId) const return m_dictionary.getWord(wordId); } -SearchNode* SearchIndex::addNode(std::vector nameHierarchy) +SearchNode* SearchIndex::addNode(NameHierarchy nameHierarchy) { std::deque 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()) { diff --git a/src/lib/data/search/SearchIndex.h b/src/lib/data/search/SearchIndex.h index 79526d9e..c099e68f 100644 --- a/src/lib/data/search/SearchIndex.h +++ b/src/lib/data/search/SearchIndex.h @@ -8,6 +8,7 @@ #include "utility/text/Dictionary.h" #include "utility/types.h" +#include "data/name/NameHierarchy.h" #include "data/search/SearchNode.h" class SearchIndex @@ -25,7 +26,7 @@ public: Id getWordId(const std::string& word); const std::string& getWord(Id wordId) const; - SearchNode* addNode(std::vector nameHierarchy); + SearchNode* addNode(NameHierarchy nameHierarchy); SearchNode* getNode(const std::string& fullName) const; SearchNode* getNode(const SearchNode* searchNode) const; diff --git a/src/lib/data/type/DataType.h b/src/lib/data/type/DataType.h index 9b765d22..1223d040 100644 --- a/src/lib/data/type/DataType.h +++ b/src/lib/data/type/DataType.h @@ -2,7 +2,8 @@ #define DATA_TYPE_H #include -#include + +#include "data/name/NameHierarchy.h" class DataType { @@ -18,7 +19,7 @@ public: virtual std::string getFullTypeName() const = 0; virtual std::string getRawTypeName() const = 0; - virtual const std::vector& getTypeNameHierarchy() const = 0; + virtual const NameHierarchy& getTypeNameHierarchy() const = 0; void addQualifier(QualifierType qualifier); void removeQualifier(QualifierType qualifier); diff --git a/src/lib/data/type/ModifiedDataType.cpp b/src/lib/data/type/ModifiedDataType.cpp index d721474b..8ddb8f64 100644 --- a/src/lib/data/type/ModifiedDataType.cpp +++ b/src/lib/data/type/ModifiedDataType.cpp @@ -22,7 +22,7 @@ std::string ModifiedDataType::getRawTypeName() const return m_dataType->getRawTypeName(); } -const std::vector& ModifiedDataType::getTypeNameHierarchy() const +const NameHierarchy& ModifiedDataType::getTypeNameHierarchy() const { return m_dataType->getTypeNameHierarchy(); } diff --git a/src/lib/data/type/ModifiedDataType.h b/src/lib/data/type/ModifiedDataType.h index ed4d495c..e29496db 100644 --- a/src/lib/data/type/ModifiedDataType.h +++ b/src/lib/data/type/ModifiedDataType.h @@ -13,7 +13,7 @@ public: virtual std::string getFullTypeName() const; virtual std::string getRawTypeName() const; - virtual const std::vector& getTypeNameHierarchy() const; + virtual const NameHierarchy& getTypeNameHierarchy() const; protected: virtual void applyModifier(std::string& typeName) const = 0; diff --git a/src/lib/data/type/NamedDataType.cpp b/src/lib/data/type/NamedDataType.cpp index cdc763ec..ae869ec9 100644 --- a/src/lib/data/type/NamedDataType.cpp +++ b/src/lib/data/type/NamedDataType.cpp @@ -2,7 +2,7 @@ #include "utility/utilityString.h" -NamedDataType::NamedDataType(const std::vector& nameHierarchy) +NamedDataType::NamedDataType(const NameHierarchy& nameHierarchy) : m_nameHierarchy(nameHierarchy) { } @@ -20,10 +20,10 @@ std::string NamedDataType::getFullTypeName() const std::string NamedDataType::getRawTypeName() const { - return utility::join(m_nameHierarchy, "::"); + return m_nameHierarchy.getFullName(); } -const std::vector& NamedDataType::getTypeNameHierarchy() const +const NameHierarchy& NamedDataType::getTypeNameHierarchy() const { return m_nameHierarchy; } diff --git a/src/lib/data/type/NamedDataType.h b/src/lib/data/type/NamedDataType.h index 4b75e92f..366e97d6 100644 --- a/src/lib/data/type/NamedDataType.h +++ b/src/lib/data/type/NamedDataType.h @@ -1,20 +1,20 @@ #ifndef NAMED_DATA_TYPE_H #define NAMED_DATA_TYPE_H -#include "DataType.h" +#include "data/type/DataType.h" class NamedDataType: public DataType { public: - NamedDataType(const std::vector& nameHierarchy); + NamedDataType(const NameHierarchy& nameHierarchy); virtual ~NamedDataType(); virtual std::string getFullTypeName() const; virtual std::string getRawTypeName() const; - virtual const std::vector& getTypeNameHierarchy() const; + virtual const NameHierarchy& getTypeNameHierarchy() const; private: - const std::vector m_nameHierarchy; + const NameHierarchy m_nameHierarchy; }; #endif // NAMED_DATA_TYPE_H diff --git a/src/test/CxxParserTestSuite.h b/src/test/CxxParserTestSuite.h index e094f21a..a757a990 100644 --- a/src/test/CxxParserTestSuite.h +++ b/src/test/CxxParserTestSuite.h @@ -13,6 +13,7 @@ #include "helper/TestFileManager.h" + class CxxParserTestSuite: public CxxTest::TestSuite { public: @@ -2329,7 +2330,7 @@ public: TS_ASSERT_EQUALS(client->templateArgumentTypes[0], "test->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 client = parseCode( "template \n" @@ -2347,7 +2348,33 @@ public: TS_ASSERT_EQUALS(client->templateDefaultArgumentTypes[0], "int -> test::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 client = parseCode( + "template \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 client = parseCode( + "template \n" + "class A\n" + "{};\n" + "template class T = A>\n" + "void test()\n" + "{\n" + "};\n" + ); + + TS_ASSERT_EQUALS(client->templateDefaultArgumentTypes.size(), 1); + TS_ASSERT_EQUALS(client->templateDefaultArgumentTypes[0], "A -> test typename T>::T <4:40 4:40>"); + } void test_cxx_parser_parses_multiple_files() { @@ -2403,28 +2430,28 @@ private: } virtual Id onTypedefParsed( - const ParseLocation& location, const std::vector& nameHierarchy, const ParseTypeUsage& underlyingType, + const ParseLocation& location, const NameHierarchy& nameHierarchy, const ParseTypeUsage& underlyingType, 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)); return 0; } virtual Id onClassParsed( - const ParseLocation& location, const std::vector& nameHierarchy, AccessType access, + const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access, 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; } virtual Id onStructParsed( - const ParseLocation& location, const std::vector& nameHierarchy, AccessType access, + const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access, 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; } @@ -2472,30 +2499,30 @@ private: } virtual Id onNamespaceParsed( - const ParseLocation& location, const std::vector& 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; } virtual Id onEnumParsed( - const ParseLocation& location, const std::vector& nameHierarchy, AccessType access, + const ParseLocation& location, const NameHierarchy& nameHierarchy, AccessType access, 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; } - virtual Id onEnumConstantParsed(const ParseLocation& location, const std::vector& 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; } virtual Id onInheritanceParsed( - const ParseLocation& location, const std::vector& nameHierarchy, const std::vector& 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)); return 0; } @@ -2521,37 +2548,37 @@ private: } virtual Id onFieldUsageParsed( - const ParseLocation& location, const ParseFunction& user, const std::vector& 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; } virtual Id onGlobalVariableUsageParsed( - const ParseLocation& location, const ParseFunction& user, const std::vector& 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; } virtual Id onGlobalVariableUsageParsed( - const ParseLocation& location, const ParseVariable& user, const std::vector& 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; } virtual Id onEnumConstantUsageParsed( - const ParseLocation& location, const ParseFunction& user, const std::vector& 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; } virtual Id onEnumConstantUsageParsed( - const ParseLocation& location, const ParseVariable& user, const std::vector& 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; } @@ -2568,51 +2595,51 @@ private: } virtual Id onTemplateArgumentTypeParsed( - const ParseLocation& location, const std::vector& templateArgumentTypeNameHierarchy, - const std::vector& templateRecordNameHierarchy) + const ParseLocation& location, const NameHierarchy& templateArgumentTypeNameHierarchy, + const NameHierarchy& templateRecordNameHierarchy) { templateArgumentTypes.push_back( - addLocationSuffix(utility::join(templateRecordNameHierarchy, "::") + "->" + utility::join(templateArgumentTypeNameHierarchy, "::"), location) + addLocationSuffix(templateRecordNameHierarchy.getFullName() + "->" + templateArgumentTypeNameHierarchy.getFullName(), location) ); return 0; } virtual Id onTemplateDefaultArgumentTypeParsed( - const ParseTypeUsage& defaultArgumentType, const std::vector& templateArgumentTypeNameHierarchy) + const ParseTypeUsage& defaultArgumentType, const NameHierarchy& templateArgumentTypeNameHierarchy) { 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; } virtual Id onTemplateRecordParameterTypeParsed( - const ParseLocation& location, const std::vector& templateParameterTypeNameHierarchy, - const std::vector& templateRecordNameHierarchy) + const ParseLocation& location, const NameHierarchy& templateParameterTypeNameHierarchy, + const NameHierarchy& templateRecordNameHierarchy) { templateParameterTypes.push_back( - addLocationSuffix(utility::join(templateParameterTypeNameHierarchy, "::"), location) + addLocationSuffix(templateParameterTypeNameHierarchy.getFullName(), location) ); return 0; } virtual Id onTemplateRecordSpecializationParsed( - const ParseLocation& location, const std::vector& specializedRecordNameHierarchy, - const RecordType specializedRecordType, const std::vector& specializedFromNameHierarchy) + const ParseLocation& location, const NameHierarchy& specializedRecordNameHierarchy, + const RecordType specializedRecordType, const NameHierarchy& specializedFromNameHierarchy) { templateSpecializations.push_back( addLocationSuffix(std::string(specializedRecordType == ParserClient::RECORD_CLASS ? "class" : "struct") + " " + - utility::join(specializedRecordNameHierarchy, "::") + " -> " + utility::join(specializedFromNameHierarchy, "::"), location) + specializedRecordNameHierarchy.getFullName() + " -> " + specializedFromNameHierarchy.getFullName(), location) ); return 0; } virtual Id onTemplateFunctionParameterTypeParsed( - const ParseLocation& location, const std::vector& templateParameterTypeNameHierarchy, + const ParseLocation& location, const NameHierarchy& templateParameterTypeNameHierarchy, const ParseFunction function) { templateParameterTypes.push_back( - addLocationSuffix(utility::join(templateParameterTypeNameHierarchy, "::"), location) + addLocationSuffix(templateParameterTypeNameHierarchy.getFullName(), location) ); return 0; } diff --git a/src/test/DataTypeTestSuite.h b/src/test/DataTypeTestSuite.h index 112569c0..fd032608 100644 --- a/src/test/DataTypeTestSuite.h +++ b/src/test/DataTypeTestSuite.h @@ -13,13 +13,13 @@ class DataTypeTestSuite: public CxxTest::TestSuite public: 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()); } 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); TS_ASSERT_EQUALS("int const", dataType.getFullTypeName()); } @@ -28,34 +28,34 @@ public: //{ // DataTypeQualifierList qualifierList; // DataTypeModifierStack modifierStack; - // DataType dataType(utility::splitToVector("int", "::"), qualifierList, modifierStack); + // DataType dataType(createNameHierarchy("int"), qualifierList, modifierStack); // TS_ASSERT_EQUALS("int", dataType.getFullTypeName()); //} void test_datatype_created_with_name_and_array_modifier_has_array_modifier() { - std::shared_ptr dataType1 = std::make_shared(utility::splitToVector("int", "::")); + std::shared_ptr dataType1 = std::make_shared(createNameHierarchy("int")); std::shared_ptr dataType2 = std::make_shared(dataType1); TS_ASSERT_EQUALS("int []", dataType2->getFullTypeName()); } void test_datatype_created_with_name_and_pointer_modifier_has_pointer_modifier() { - std::shared_ptr dataType1 = std::make_shared(utility::splitToVector("int", "::")); + std::shared_ptr dataType1 = std::make_shared(createNameHierarchy("int")); std::shared_ptr dataType2 = std::make_shared(dataType1); TS_ASSERT_EQUALS("int *", dataType2->getFullTypeName()); } void test_datatype_created_with_name_and_reference_modifier_has_reference_modifier() { - std::shared_ptr dataType1 = std::make_shared(utility::splitToVector("int", "::")); + std::shared_ptr dataType1 = std::make_shared(createNameHierarchy("int")); std::shared_ptr dataType2 = std::make_shared(dataType1); TS_ASSERT_EQUALS("int &", dataType2->getFullTypeName()); } void test_datatype_created_with_name_and_const_pointer_modifier_has_const_pointer_modifier() { - std::shared_ptr dataType1 = std::make_shared(utility::splitToVector("int", "::")); + std::shared_ptr dataType1 = std::make_shared(createNameHierarchy("int")); std::shared_ptr dataType2 = std::make_shared(dataType1); dataType2->addQualifier(DataType::QUALIFIER_CONST); 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() { - std::shared_ptr dataType1 = std::make_shared(utility::splitToVector("int", "::")); + std::shared_ptr dataType1 = std::make_shared(createNameHierarchy("int")); std::shared_ptr dataType2 = std::make_shared(dataType1); std::shared_ptr dataType3 = std::make_shared(dataType2); 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(element)); + } + return nameHierarchy; + } }; diff --git a/src/test/SearchIndexTestSuite.h b/src/test/SearchIndexTestSuite.h index a98d1137..94f0c372 100644 --- a/src/test/SearchIndexTestSuite.h +++ b/src/test/SearchIndexTestSuite.h @@ -11,7 +11,7 @@ public: void test_add_node() { SearchIndex index; - SearchNode* node = index.addNode(utility::splitToVector("util", "::")); + SearchNode* node = index.addNode(createNameHierarchy("util")); TS_ASSERT(node); TS_ASSERT_EQUALS("util", node->getName()); @@ -26,7 +26,7 @@ public: void test_get_node() { SearchIndex index; - index.addNode(utility::splitToVector("util", "::")); + index.addNode(createNameHierarchy("util")); SearchNode* node = index.getNode("util"); TS_ASSERT(node); @@ -45,7 +45,7 @@ public: void test_add_hierarchy_node() { SearchIndex index; - SearchNode* node = index.addNode(utility::splitToVector("util::math::pow", "::")); + SearchNode* node = index.addNode(createNameHierarchy("util::math::pow")); TS_ASSERT(node); TS_ASSERT_EQUALS("pow", node->getName()); @@ -64,8 +64,8 @@ public: void test_reuse_hierarchy_node() { SearchIndex index; - SearchNode* node1 = index.addNode(utility::splitToVector("math::pow", "::")); - SearchNode* node2 = index.addNode(utility::splitToVector("math::floor", "::")); + SearchNode* node1 = index.addNode(createNameHierarchy("math::pow")); + SearchNode* node2 = index.addNode(createNameHierarchy("math::floor")); TS_ASSERT(node1); TS_ASSERT(node2); @@ -79,8 +79,8 @@ public: void test_remove_nodes() { SearchIndex index; - index.addNode(utility::splitToVector("util::math::pow", "::")); - index.addNode(utility::splitToVector("util::math::floor", "::")); + index.addNode(createNameHierarchy("util::math::pow")); + index.addNode(createNameHierarchy("util::math::floor")); index.removeNode(index.getNode("util::math::pow")); @@ -98,8 +98,8 @@ public: void test_remove_unreferenced_nodes() { SearchIndex index; - SearchNode* node1 = index.addNode(utility::splitToVector("util::math::pow", "::")); - SearchNode* node2 = index.addNode(utility::splitToVector("util::math::floor", "::")); + SearchNode* node1 = index.addNode(createNameHierarchy("util::math::pow")); + SearchNode* node2 = index.addNode(createNameHierarchy("util::math::floor")); node1->addTokenId(1); node2->addTokenId(2); @@ -128,8 +128,8 @@ public: void test_clear() { SearchIndex index; - index.addNode(utility::splitToVector("math", "::")); - index.addNode(utility::splitToVector("string", "::")); + index.addNode(createNameHierarchy("math")); + index.addNode(createNameHierarchy("string")); TS_ASSERT(index.getNode("math")); @@ -142,9 +142,9 @@ public: void test_fuzzy_matching() { SearchIndex index; - index.addNode(utility::splitToVector("util", "::")); - index.addNode(utility::splitToVector("math", "::")); - index.addNode(utility::splitToVector("string", "::")); + index.addNode(createNameHierarchy("util")); + index.addNode(createNameHierarchy("math")); + index.addNode(createNameHierarchy("string")); std::vector matches = index.runFuzzySearchAndGetMatches("u"); @@ -168,8 +168,8 @@ public: void test_fuzzy_matching_is_case_insensitive() { SearchIndex index; - index.addNode(utility::splitToVector("util", "::")); - index.addNode(utility::splitToVector("MATH", "::")); + index.addNode(createNameHierarchy("util")); + index.addNode(createNameHierarchy("MATH")); std::vector matches = index.runFuzzySearchAndGetMatches("t"); @@ -187,9 +187,9 @@ public: void test_fuzzy_matching_wheighs_by_distance_and_alphabet() { SearchIndex index; - index.addNode(utility::splitToVector("util", "::")); - index.addNode(utility::splitToVector("math", "::")); - index.addNode(utility::splitToVector("string", "::")); + index.addNode(createNameHierarchy("util")); + index.addNode(createNameHierarchy("math")); + index.addNode(createNameHierarchy("string")); std::vector matches = index.runFuzzySearchAndGetMatches("t"); @@ -211,8 +211,8 @@ public: void test_fuzzy_matching_wheighs_higher_by_uppercase() { SearchIndex index; - index.addNode(utility::splitToVector("uTil", "::")); - index.addNode(utility::splitToVector("string", "::")); + index.addNode(createNameHierarchy("uTil")); + index.addNode(createNameHierarchy("string")); std::vector matches = index.runFuzzySearchAndGetMatches("t"); @@ -224,8 +224,8 @@ public: void test_fuzzy_matching_wheighs_higher_on_consecutive_letters() { SearchIndex index; - index.addNode(utility::splitToVector("oaabbcc", "::")); - index.addNode(utility::splitToVector("ocbcabc", "::")); + index.addNode(createNameHierarchy("oaabbcc")); + index.addNode(createNameHierarchy("ocbcabc")); std::vector matches = index.runFuzzySearchAndGetMatches("abc"); @@ -237,9 +237,9 @@ public: void test_fuzzy_matching_in_hierarchy() { SearchIndex index; - index.addNode(utility::splitToVector("util::math::ceil", "::")); - index.addNode(utility::splitToVector("util::math::floor", "::")); - index.addNode(utility::splitToVector("util::string::concat", "::")); + index.addNode(createNameHierarchy("util::math::ceil")); + index.addNode(createNameHierarchy("util::math::floor")); + index.addNode(createNameHierarchy("util::string::concat")); std::vector matches = index.runFuzzySearchAndGetMatches("t"); @@ -261,9 +261,9 @@ public: void test_fuzzy_matching_in_hierarchy_respects_collin() { SearchIndex index; - index.addNode(utility::splitToVector("util::math::ceil", "::")); - index.addNode(utility::splitToVector("util::math::floor", "::")); - index.addNode(utility::splitToVector("util::string::concat", "::")); + index.addNode(createNameHierarchy("util::math::ceil")); + index.addNode(createNameHierarchy("util::math::floor")); + index.addNode(createNameHierarchy("util::string::concat")); std::vector matches = index.runFuzzySearchAndGetMatches("u:i"); @@ -281,8 +281,8 @@ public: void test_fuzzy_matching_in_hierarchy_weighs_front_letters_higher() { SearchIndex index; - index.addNode(utility::splitToVector("abc::dfe::ghi", "::")); - index.addNode(utility::splitToVector("abc::hgi", "::")); + index.addNode(createNameHierarchy("abc::dfe::ghi")); + index.addNode(createNameHierarchy("abc::hgi")); std::vector matches = index.runFuzzySearchAndGetMatches("g"); @@ -290,4 +290,15 @@ public: TS_ASSERT_EQUALS("abc::dfe::ghi", matches[0].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(element)); + } + return nameHierarchy; + } }; diff --git a/src/test/StorageGraphTestSuite.h b/src/test/StorageGraphTestSuite.h index ed908586..d9d302ee 100644 --- a/src/test/StorageGraphTestSuite.h +++ b/src/test/StorageGraphTestSuite.h @@ -324,14 +324,25 @@ private: public: 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(element)); + } + SearchNode* searchNode = m_index.addNode(nameHierarchy); return StorageGraph::createNodeHierarchy(type, searchNode); } Node* createNodeHierarchyWithDistinctSignature( 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(element)); + } + SearchNode* searchNode = m_index.addNode(nameHierarchy); std::shared_ptr signature = std::make_shared(signatureId); return StorageGraph::createNodeHierarchyWithDistinctSignature(type, searchNode, signature); } diff --git a/src/test/StorageTestSuite.h b/src/test/StorageTestSuite.h index 33669cf8..0e3d0c19 100644 --- a/src/test/StorageTestSuite.h +++ b/src/test/StorageTestSuite.h @@ -25,7 +25,7 @@ public: void test_storage_saves_typedef() { 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); TS_ASSERT(node); @@ -44,7 +44,7 @@ public: void test_storage_saves_class() { 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); TS_ASSERT(node); @@ -61,7 +61,7 @@ public: void test_storage_saves_struct() { 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); TS_ASSERT(node); @@ -78,7 +78,7 @@ public: void test_storage_saves_global_variable() { 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); TS_ASSERT(node); @@ -98,7 +98,7 @@ public: void test_storage_saves_global_variable_static() { 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); TS_ASSERT(node); @@ -115,7 +115,7 @@ public: { TestStorage storage; 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); @@ -136,7 +136,7 @@ public: { TestStorage storage; 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); @@ -170,7 +170,7 @@ public: { TestStorage storage; 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); @@ -201,7 +201,7 @@ public: TestStorage storage; Id id = storage.onMethodParsed( validLocation(9), - ParseFunction(typeUsage("void"), utility::splitToVector("isMethod", "::"), parameters("bool")), + ParseFunction(typeUsage("void"), createNameHierarchy("isMethod"), parameters("bool")), ParserClient::ACCESS_NONE, ParserClient::ABSTRACTION_NONE, validLocation(4) @@ -235,7 +235,7 @@ public: TestStorage storage; Id id = storage.onMethodParsed( validLocation(1), - ParseFunction(typeUsage("void"), utility::splitToVector("isMethod", "::"), parameters("bool"), true), + ParseFunction(typeUsage("void"), createNameHierarchy("isMethod"), parameters("bool"), true), ParserClient::ACCESS_NONE, ParserClient::ABSTRACTION_NONE, validLocation(4) @@ -253,7 +253,7 @@ public: TestStorage storage; Id id = storage.onMethodParsed( validLocation(1), - ParseFunction(typeUsage("void"), utility::splitToVector("Class::isMethod", "::"), parameters("bool")), + ParseFunction(typeUsage("void"), createNameHierarchy("Class::isMethod"), parameters("bool")), ParserClient::ACCESS_PROTECTED, ParserClient::ABSTRACTION_VIRTUAL, validLocation(4) @@ -287,7 +287,7 @@ public: void test_storage_saves_namespace() { 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); TS_ASSERT(node); @@ -304,7 +304,7 @@ public: void test_storage_saves_enum() { 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); TS_ASSERT(node); @@ -322,7 +322,7 @@ public: { TestStorage storage; Id id = - storage.onEnumParsed(validLocation(1), utility::splitToVector("Class::Category", "::"), + storage.onEnumParsed(validLocation(1), createNameHierarchy("Class::Category"), ParserClient::ACCESS_PRIVATE, validLocation(2) ); @@ -347,7 +347,7 @@ public: void test_storage_saves_enum_constant() { TestStorage storage; - Id id = storage.onEnumConstantParsed(validLocation(1), utility::splitToVector("VALUE", "::")); + Id id = storage.onEnumConstantParsed(validLocation(1), createNameHierarchy("VALUE")); Node* node = storage.getNodeWithId(id); TS_ASSERT(node); @@ -362,11 +362,11 @@ public: void test_storage_saves_class_inheritance() { TestStorage storage; - storage.onClassParsed(validLocation(), utility::splitToVector("ClassA", "::"), ParserClient::ACCESS_NONE, validLocation()); - storage.onClassParsed(validLocation(), utility::splitToVector("ClassB", "::"), ParserClient::ACCESS_NONE, validLocation()); + storage.onClassParsed(validLocation(), createNameHierarchy("ClassA"), ParserClient::ACCESS_NONE, validLocation()); + storage.onClassParsed(validLocation(), createNameHierarchy("ClassB"), ParserClient::ACCESS_NONE, validLocation()); Id id = - storage.onInheritanceParsed(validLocation(5), utility::splitToVector("ClassB", "::"), - utility::splitToVector("ClassA", "::"), ParserClient::ACCESS_PUBLIC + storage.onInheritanceParsed(validLocation(5), createNameHierarchy("ClassB"), + createNameHierarchy("ClassA"), ParserClient::ACCESS_PUBLIC ); Edge* edge = storage.getEdgeWithId(id); @@ -387,11 +387,11 @@ public: void test_storage_saves_struct_inheritance() { TestStorage storage; - storage.onStructParsed(validLocation(), utility::splitToVector("StructA", "::"), ParserClient::ACCESS_NONE, validLocation()); - storage.onStructParsed(validLocation(), utility::splitToVector("StructB", "::"), ParserClient::ACCESS_NONE, validLocation()); + storage.onStructParsed(validLocation(), createNameHierarchy("StructA"), ParserClient::ACCESS_NONE, validLocation()); + storage.onStructParsed(validLocation(), createNameHierarchy("StructB"), ParserClient::ACCESS_NONE, validLocation()); Id id = - storage.onInheritanceParsed(validLocation(5), utility::splitToVector("StructB", "::"), - utility::splitToVector("StructA", "::"), ParserClient::ACCESS_PUBLIC + storage.onInheritanceParsed(validLocation(5), createNameHierarchy("StructB"), + createNameHierarchy("StructA"), ParserClient::ACCESS_PUBLIC ); Edge* edge = storage.getEdgeWithId(id); @@ -413,8 +413,8 @@ public: { TestStorage storage; - ParseFunction a(typeUsage("void"), utility::splitToVector("A::isMethod", "::"), parameters("bool")); - ParseFunction b(typeUsage("void"), utility::splitToVector("B::isMethod", "::"), parameters("bool")); + ParseFunction a(typeUsage("void"), createNameHierarchy("A::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(7), b, ParserClient::ACCESS_PRIVATE, ParserClient::ABSTRACTION_NONE, validLocation(3)); @@ -432,15 +432,15 @@ public: { TestStorage storage; storage.onFunctionParsed( - validLocation(), ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("char")), validLocation() + validLocation(), ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char")), validLocation() ); 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( validLocation(9), - ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("char")), - ParseFunction(typeUsage("void"), utility::splitToVector("func", "::"), parameters("bool")) + ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char")), + ParseFunction(typeUsage("void"), createNameHierarchy("func"), parameters("bool")) ); Edge* edge = storage.getEdgeWithId(id); @@ -458,15 +458,15 @@ public: void test_storage_saves_call_in_global_variable_declaration() { TestStorage storage; - storage.onGlobalVariableParsed(validLocation(), ParseVariable(typeUsage("bool"), utility::splitToVector("global", "::"), false)); + storage.onGlobalVariableParsed(validLocation(), ParseVariable(typeUsage("bool"), createNameHierarchy("global"), false)); 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( validLocation(7), - ParseVariable(typeUsage("bool"), utility::splitToVector("global", "::"), false), - ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("char")) + ParseVariable(typeUsage("bool"), createNameHierarchy("global"), false), + ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char")) ); Edge* edge = storage.getEdgeWithId(id); @@ -485,16 +485,16 @@ public: { TestStorage storage; storage.onFunctionParsed( - validLocation(), ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("char")), validLocation() + validLocation(), ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char")), validLocation() ); 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( validLocation(7), - ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("char")), - utility::splitToVector("Foo::m_field", "::") + ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char")), + createNameHierarchy("Foo::m_field") ); Edge* edge = storage.getEdgeWithId(id); @@ -513,14 +513,14 @@ public: { TestStorage storage; 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( validLocation(7), - ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("char")), - utility::splitToVector("global", "::") + ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char")), + createNameHierarchy("global") ); Edge* edge = storage.getEdgeWithId(id); @@ -539,15 +539,15 @@ public: { TestStorage storage; storage.onFunctionParsed( - validLocation(), ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), + validLocation(), ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char")), validLocation() ); storage.onStructParsed( - validLocation(), utility::splitToVector("Struct", "::"), ParserClient::ACCESS_NONE, validLocation()); + validLocation(), createNameHierarchy("Struct"), ParserClient::ACCESS_NONE, validLocation()); Id id = storage.onTypeUsageParsed( typeUsage("Struct"), - ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), parameters("char")) + ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char")) ); Edge* edge = storage.getEdgeWithId(id); @@ -566,7 +566,7 @@ public: { TestStorage storage; storage.onFunctionParsed( - validLocation(), ParseFunction(typeUsage("bool"), utility::splitToVector("isTrue", "::"), + validLocation(), ParseFunction(typeUsage("bool"), createNameHierarchy("isTrue"), parameters("char")), validLocation() ); @@ -591,12 +591,12 @@ public: 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()); 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.onCallParsed(validLocation(), main, isTrue); @@ -622,12 +622,12 @@ public: 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()); 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.onCallParsed(validLocation(), main, isTrue); @@ -653,12 +653,12 @@ public: 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()); 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.onCallParsed(validLocation(), main, isTrue); @@ -800,9 +800,19 @@ private: location->getColumnNumber() == locationId; } + NameHierarchy createNameHierarchy(std::string s) const + { + NameHierarchy nameHierarchy; + for (std::string element: utility::splitToVector(s, "::")) + { + nameHierarchy.push(std::make_shared(element)); + } + return nameHierarchy; + } + ParseTypeUsage typeUsage(const std::string& typeName) const { - return ParseTypeUsage(validLocation(), std::make_shared(utility::splitToVector(typeName, "::"))); + return ParseTypeUsage(validLocation(), std::make_shared(createNameHierarchy(typeName))); } std::vector parameters(const std::string& param) const