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.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
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())
{
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(
const ParseLocation& location, const std::vector<std::string>& 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<std::string>& 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<std::string>& 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<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);
if (location.isValid())
@@ -360,10 +362,10 @@ Id Storage::onNamespaceParsed(
}
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
){
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<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);
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<std::string>& nameHierarchy,
const std::vector<std::string>& 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<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* 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<std::string>& 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<std::string>& 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<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* 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<std::string>& 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<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* 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<std::string>& argumentNameHierarchy,
const std::vector<std::string>& 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<std::string>& 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<std::string>& templateParameterTypeNameHierarchy,
const std::vector<std::string>& 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<std::string>& specializedRecordNameHierarchy,
const RecordType specializedRecordType, const std::vector<std::string>& 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<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);
addTokenLocation(templateParameterNode, location);
@@ -1069,7 +1070,7 @@ const SearchIndex& Storage::getSearchIndex() const
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);
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<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>())
{
@@ -1175,7 +1178,7 @@ Edge* Storage::addTypeEdge(Node* node, Edge::EdgeType edgeType, const ParseTypeU
return nullptr;
}
std::vector<std::string> nameHierarchy = typeUsage.dataType->getTypeNameHierarchy();
NameHierarchy nameHierarchy = typeUsage.dataType->getTypeNameHierarchy();
Node* typeNode = addNodeHierarchy(Node::NODE_UNDEFINED_TYPE, nameHierarchy);
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 Id onTypedefParsed(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy,
const ParseLocation& location, const NameHierarchy& nameHierarchy,
const ParseTypeUsage& underlyingType, AccessType access);
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);
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);
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<std::string>& nameHierarchy, const ParseLocation& scopeLocation);
const ParseLocation& location, const NameHierarchy& nameHierarchy, const ParseLocation& scopeLocation);
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);
virtual Id onEnumConstantParsed(const ParseLocation& location, const std::vector<std::string>& nameHierarchy);
virtual Id onEnumConstantParsed(const ParseLocation& location, const NameHierarchy& nameHierarchy);
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);
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<std::string>& usedNameHierarchy); // helper
const NameHierarchy& usedNameHierarchy); // helper
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(
const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy);
const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy);
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(
const ParseLocation& location, const ParseFunction& user, const std::vector<std::string>& usedNameHierarchy);
const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy);
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 ParseVariable& variable);
virtual Id onTemplateArgumentTypeParsed(
const ParseLocation& location, const std::vector<std::string>& argumentNameHierarchy,
const std::vector<std::string>& templateNameHierarchy);
const ParseLocation& location, const NameHierarchy& argumentNameHierarchy,
const NameHierarchy& templateNameHierarchy);
virtual Id onTemplateDefaultArgumentTypeParsed(
const ParseTypeUsage& type, const std::vector<std::string>& templateArgumentTypeNameHierarchy);
const ParseTypeUsage& type, const NameHierarchy& templateArgumentTypeNameHierarchy);
virtual Id onTemplateRecordParameterTypeParsed(
const ParseLocation& location, const std::vector<std::string>& templateParameterTypeNameHierarchy,
const std::vector<std::string>& templateRecordNameHierarchy);
const ParseLocation& location, const NameHierarchy& templateParameterTypeNameHierarchy,
const NameHierarchy& templateRecordNameHierarchy);
virtual Id onTemplateRecordSpecializationParsed(
const ParseLocation& location, const std::vector<std::string>& specializedRecordNameHierarchy,
const RecordType specializedRecordType, const std::vector<std::string>& specializedFromNameHierarchy);
const ParseLocation& location, const NameHierarchy& specializedRecordNameHierarchy,
const RecordType specializedRecordType, const NameHierarchy& specializedFromNameHierarchy);
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(
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<std::string> nameHierarchy);
Node* addNodeHierarchy(Node::NodeType type, NameHierarchy nameHierarchy);
Node* addNodeHierarchyWithDistinctSignature(Node::NodeType type, const ParseFunction& function);
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(
const ParseTypeUsage& returnType,
const std::vector<std::string>& nameHierarchy,
const NameHierarchy& nameHierarchy,
const std::vector<ParseTypeUsage>& parameters,
bool isStatic,
bool isConst
@@ -19,5 +19,5 @@ ParseFunction::ParseFunction(
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
#define PARSE_FUNCTION_H
#include <string>
#include "data/name/NameHierarchy.h"
#include "data/parser/ParseTypeUsage.h"
struct ParseFunction
{
ParseFunction(
const ParseTypeUsage& returnType,
const std::vector<std::string>& nameHierarchy,
const NameHierarchy& nameHierarchy,
const std::vector<ParseTypeUsage>& parameters,
bool isStatic = false,
bool isConst = false
@@ -18,7 +17,7 @@ struct ParseFunction
std::string getFullName() const;
const ParseTypeUsage returnType;
const std::vector<std::string> nameHierarchy;
const NameHierarchy nameHierarchy;
const std::vector<ParseTypeUsage> parameters;
const bool isStatic;
const bool isConst;
src/lib/data/parser/ParseVariable.cpp
+3 -3
View File
@@ -2,7 +2,7 @@
#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)
, nameHierarchy(nameHierarchy)
, isStatic(isStatic)
@@ -11,5 +11,5 @@ ParseVariable::ParseVariable(const ParseTypeUsage& type, const std::vector<std::
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 "data/name/NameHierarchy.h"
#include "data/parser/ParseTypeUsage.h"
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;
const ParseTypeUsage type;
const std::vector<std::string> nameHierarchy;
const NameHierarchy nameHierarchy;
const bool isStatic;
};
src/lib/data/parser/ParserClient.h
+22 -21
View File
@@ -5,6 +5,7 @@
#include <vector>
#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<std::string>& nameHierarchy,
const ParseLocation& location, const NameHierarchy& nameHierarchy,
const ParseTypeUsage& underlyingType, AccessType access) = 0;
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;
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;
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<std::string>& nameHierarchy,
const ParseLocation& location, const NameHierarchy& nameHierarchy,
const ParseLocation& scopeLocation) = 0;
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;
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(
const ParseLocation& location, const std::vector<std::string>& nameHierarchy,
const std::vector<std::string>& 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<std::string>& usedNameHierarchy) = 0;
const ParseLocation& location, const ParseFunction& user, const NameHierarchy& usedNameHierarchy) = 0;
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(
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(
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(
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 ParseVariable& variable) = 0;
virtual Id onTemplateArgumentTypeParsed(
const ParseLocation& location, const std::vector<std::string>& argumentNameHierarchy,
const std::vector<std::string>& templateNameHierarchy) = 0;
const ParseLocation& location, const NameHierarchy& argumentNameHierarchy,
const NameHierarchy& templateNameHierarchy) = 0;
virtual Id onTemplateDefaultArgumentTypeParsed(
const ParseTypeUsage& type, const std::vector<std::string>& templateArgumentTypeNameHierarchy) = 0;
const ParseTypeUsage& type, const NameHierarchy& templateArgumentTypeNameHierarchy) = 0;
virtual Id onTemplateRecordParameterTypeParsed(
const ParseLocation& location, const std::vector<std::string>& templateParameterTypeNameHierarchy,
const std::vector<std::string>& templateRecordNameHierarchy) = 0;
const ParseLocation& location, const NameHierarchy& templateParameterTypeNameHierarchy,
const NameHierarchy& templateRecordNameHierarchy) = 0;
virtual Id onTemplateRecordSpecializationParsed(
const ParseLocation& location, const std::vector<std::string>& specializedRecordNameHierarchy,
const RecordType specializedRecordType, const std::vector<std::string>& specializedFromNameHierarchy) = 0;
const ParseLocation& location, const NameHierarchy& specializedRecordNameHierarchy,
const RecordType specializedRecordType, const NameHierarchy& specializedFromNameHierarchy) = 0;
virtual Id onTemplateFunctionParameterTypeParsed(
const ParseLocation& location, const std::vector<std::string>& templateParameterTypeNameHierarchy,
const ParseLocation& location, const NameHierarchy& templateParameterTypeNameHierarchy,
const ParseFunction function) = 0;
virtual Id onTemplateFunctionSpecializationParsed(
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)
{
std::vector<std::string> rarchy = utility::getDeclNameHierarchy(declaration);
NameHierarchy rarchy = utility::getDeclNameHierarchy(declaration);
if (isLocatedInUnparsedProjectFile(declaration))
{
std::vector<std::string> 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<std::string> specializationParentNameHierarchy = utility::getTemplateSpecializationParentNameHierarchy(specializationDecl);
NameHierarchy specializationParentNameHierarchy = utility::getTemplateSpecializationParentNameHierarchy(specializationDecl);
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(
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<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.
{
@@ -374,8 +374,8 @@ bool ASTVisitor::VisitClassTemplatePartialSpecializationDecl(clang::ClassTemplat
{
if (isLocatedInUnparsedProjectFile(declaration))
{
std::vector<std::string> specializedRecordNameHierarchy = utility::getDeclNameHierarchy(declaration);
std::vector<std::string> 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<std::string> templateParameterTypeNameHierarchy = utility::getDeclNameHierarchy(namedDecl);
NameHierarchy templateParameterTypeNameHierarchy = utility::getDeclNameHierarchy(namedDecl);
m_client->onTemplateFunctionParameterTypeParsed(
getParseLocationForNamedDecl(namedDecl),
@@ -873,7 +873,7 @@ std::vector<ParseTypeUsage> ASTVisitor::getParameters(const clang::FunctionDecl*
ParseVariable ASTVisitor::getParseVariable(const clang::DeclaratorDecl* declaration) const
{
bool isStatic = false;
std::vector<std::string> hameHierarchy = utility::getDeclNameHierarchy(declaration);
NameHierarchy hameHierarchy = utility::getDeclNameHierarchy(declaration);
if (clang::isa<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()));
break;
}
case clang::Type::MemberPointer:
{
int ogogo = 0; // test this case!
}
case clang::Type::Pointer:
{
std::shared_ptr<DataType> 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<std::string> typeNameHerarchy;
typeNameHerarchy.push_back(typeName);
NameHierarchy typeNameHerarchy;
typeNameHerarchy.push(std::make_shared<NameElement>(typeName));
dataType = std::make_shared<NamedDataType>(typeNameHerarchy);
break;
}
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
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<ajaj<ajsj>>
declName += templateArgumentPart; // add template arguments
typeNameHerarchy.pop();
typeNameHerarchy.push(std::make_shared<NameElement>(declName));
}
}
dataType = std::make_shared<NamedDataType>(typeNameHerarchy);
@@ -129,16 +135,18 @@ namespace utility
clang::TemplateTypeParmDecl* templateTypeParmDecl = clang::dyn_cast<clang::TemplateTypeParmType>(type)->getDecl();
std::string typeName = getDeclName(templateTypeParmDecl);
std::vector<std::string> 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<NameElement>(typeName));
}
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);
break;
@@ -153,11 +161,11 @@ namespace utility
const clang::DependentNameType* dependentNameType = clang::dyn_cast<clang::DependentNameType>(type);
clang::NestedNameSpecifier* nns = dependentNameType->getQualifier();
clang::NestedNameSpecifier::SpecifierKind nnsKind = nns->getKind();
std::vector<std::string> typeNameHerarchy;
NameHierarchy typeNameHerarchy;
switch (nnsKind)
{
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.
break;
case clang::NestedNameSpecifier::Namespace:
@@ -178,7 +186,7 @@ namespace utility
break;
}
typeNameHerarchy.push_back(dependentNameType->getIdentifier()->getName().str());
typeNameHerarchy.push(std::make_shared<NameElement>(dependentNameType->getIdentifier()->getName().str()));
dataType = std::make_shared<NamedDataType>(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<std::string> typeNameHerarchy;
typeNameHerarchy.push_back(typeName);
NameHierarchy typeNameHerarchy;
typeNameHerarchy.push(std::make_shared<NameElement>(typeName));
dataType = std::make_shared<NamedDataType>(typeNameHerarchy);
break;
@@ -205,9 +213,9 @@ namespace utility
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)
{
std::string declName = "";
@@ -225,19 +233,22 @@ namespace utility
clang::isa<clang::TemplateTypeParmDecl>(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
{
contextNameHierarchy.push_back(declName);
contextNameHierarchy.push(std::make_shared<NameElement>(declName));
}
}
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();
if (parentContext)
@@ -247,18 +258,18 @@ namespace utility
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 != "")
{
contextNameHierarchy.push_back(declName);
contextNameHierarchy.push(std::make_shared<NameElement>(declName));
}
}
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);
if (parentNode && clang::isa<clang::NamedDecl>(parentNode))
@@ -364,9 +375,9 @@ namespace utility
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();
if (pu.is<clang::ClassTemplateDecl*>())
{
@@ -424,7 +435,7 @@ namespace utility
LOG_ERROR("Type of template argument not handled." + argument.getKind());
break;
}
return std::make_shared<NamedDataType>(std::vector<std::string>());
return std::make_shared<NamedDataType>(NameHierarchy());
}
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"
class DataType;
class NameHierarchy;
namespace utility
{
std::shared_ptr<DataType> qualTypeToDataType(clang::QualType qualType);
std::shared_ptr<DataType> typeToDataType(const clang::Type* type);
std::vector<std::string> getDeclNameHierarchy(const clang::Decl* declaration);
std::vector<std::string> getContextNameHierarchy(const clang::DeclContext* declaration);
std::vector<std::string> 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<std::string> getTemplateSpecializationParentNameHierarchy(clang::ClassTemplateSpecializationDecl* declaration);
NameHierarchy getTemplateSpecializationParentNameHierarchy(clang::ClassTemplateSpecializationDecl* declaration);
std::shared_ptr<DataType> templateArgumentToDataType(const clang::TemplateArgument& argument);
std::string getTemplateParameterString(const clang::NamedDecl* 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);
}
SearchNode* SearchIndex::addNode(std::vector<std::string> nameHierarchy)
SearchNode* SearchIndex::addNode(NameHierarchy nameHierarchy)
{
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())
{
src/lib/data/search/SearchIndex.h
+2 -1
View File
@@ -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<std::string> nameHierarchy);
SearchNode* addNode(NameHierarchy nameHierarchy);
SearchNode* getNode(const std::string& fullName) 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
#include <string>
#include <vector>
#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<std::string>& getTypeNameHierarchy() const = 0;
virtual const NameHierarchy& getTypeNameHierarchy() const = 0;
void addQualifier(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();
}
const std::vector<std::string>& ModifiedDataType::getTypeNameHierarchy() const
const NameHierarchy& ModifiedDataType::getTypeNameHierarchy() const
{
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 getRawTypeName() const;
virtual const std::vector<std::string>& getTypeNameHierarchy() const;
virtual const NameHierarchy& getTypeNameHierarchy() const;
protected:
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"
NamedDataType::NamedDataType(const std::vector<std::string>& 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<std::string>& NamedDataType::getTypeNameHierarchy() const
const NameHierarchy& NamedDataType::getTypeNameHierarchy() const
{
return m_nameHierarchy;
}
src/lib/data/type/NamedDataType.h
+4 -4
View File
@@ -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<std::string>& nameHierarchy);
NamedDataType(const NameHierarchy& nameHierarchy);
virtual ~NamedDataType();
virtual std::string getFullTypeName() const;
virtual std::string getRawTypeName() const;
virtual const std::vector<std::string>& getTypeNameHierarchy() const;
virtual const NameHierarchy& getTypeNameHierarchy() const;
private:
const std::vector<std::string> m_nameHierarchy;
const NameHierarchy m_nameHierarchy;
};
#endif // NAMED_DATA_TYPE_H
src/test/CxxParserTestSuite.h
+65 -38
View File
@@ -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>->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(
"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>");
}
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()
{
@@ -2403,28 +2430,28 @@ private:
}
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
)
{
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<std::string>& 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<std::string>& 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<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;
}
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)
{
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<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;
}
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));
return 0;
}
@@ -2521,37 +2548,37 @@ private:
}
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;
}
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;
}
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;
}
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;
}
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;
}
@@ -2568,51 +2595,51 @@ private:
}
virtual Id onTemplateArgumentTypeParsed(
const ParseLocation& location, const std::vector<std::string>& templateArgumentTypeNameHierarchy,
const std::vector<std::string>& 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<std::string>& 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<std::string>& templateParameterTypeNameHierarchy,
const std::vector<std::string>& 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<std::string>& specializedRecordNameHierarchy,
const RecordType specializedRecordType, const std::vector<std::string>& 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<std::string>& templateParameterTypeNameHierarchy,
const ParseLocation& location, const NameHierarchy& templateParameterTypeNameHierarchy,
const ParseFunction function)
{
templateParameterTypes.push_back(
addLocationSuffix(utility::join(templateParameterTypeNameHierarchy, "::"), location)
addLocationSuffix(templateParameterTypeNameHierarchy.getFullName(), location)
);
return 0;
}
src/test/DataTypeTestSuite.h
+19 -8
View File
@@ -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<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);
TS_ASSERT_EQUALS("int []", dataType2->getFullTypeName());
}
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);
TS_ASSERT_EQUALS("int *", dataType2->getFullTypeName());
}
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);
TS_ASSERT_EQUALS("int &", dataType2->getFullTypeName());
}
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);
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<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> dataType3 = std::make_shared<PointerModifiedDataType>(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<NameElement>(element));
}
return nameHierarchy;
}
};
src/test/SearchIndexTestSuite.h
+42 -31
View File
@@ -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<SearchMatch> 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<SearchMatch> 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<SearchMatch> 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<SearchMatch> 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<SearchMatch> 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<SearchMatch> 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<SearchMatch> 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<SearchMatch> 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<NameElement>(element));
}
return nameHierarchy;
}
};
src/test/StorageGraphTestSuite.h
+14 -3
View File
@@ -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<NameElement>(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<NameElement>(element));
}
SearchNode* searchNode = m_index.addNode(nameHierarchy);
std::shared_ptr<TokenComponentSignature> signature = std::make_shared<TokenComponentSignature>(signatureId);
return StorageGraph::createNodeHierarchyWithDistinctSignature(type, searchNode, signature);
}
src/test/StorageTestSuite.h
+62 -52
View File
@@ -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<NameElement>(element));
}
return nameHierarchy;
}
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