logic: expanded indexer to cover more template argument related elements

* recording of usages of FunctionProtoTypes (e.g. "int(void)" can be used as a template argument)
* implemented solving names of dependent template specialization types (these are not as bad as it sounds ;) )
* implemented correct solving or decayed types
* fixed: qualified type usages are recorded in the correct context
* changed cxx indexer tests not to crash anymore when something is not found

src/lib/data/parser/ParserClientImpl.cpp

@@ -33,7 +33,6 @@ void ParserClientImpl::finishParsingFile()
 {
 }
 
-
 Id ParserClientImpl::recordSymbol(
 	const NameHierarchy& symbolName, SymbolKind symbolType,
 	AccessKind access, bool isImplicit

src/lib/utility/utility.h

@@ -58,6 +58,19 @@ namespace utility
 		);
 	}
 
+	template<typename T>
+	bool containsElement(const std::vector<T>& v, const T& e)
+	{
+		for (const T& ve: v)
+		{
+			if (ve == e)
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+
 	bool intersectionPoint(Vec2f a1, Vec2f b1, Vec2f a2, Vec2f b2, Vec2f* i);
 
 	size_t digits(size_t n);

src/lib_cxx/data/parser/cxx/CxxAstVisitor.cpp

@@ -97,6 +97,12 @@ bool CxxAstVisitor::TraverseType(clang::QualType t)
 	return base::TraverseType(t);
 }
 
+// same as base::TraverseQualifiedTypeLoc(..) but we need to make sure to call this.TraverseTypeLoc(..)
+bool CxxAstVisitor::TraverseQualifiedTypeLoc(clang::QualifiedTypeLoc tl)
+{
+	return TraverseTypeLoc(tl.getUnqualifiedLoc());
+}
+
 bool CxxAstVisitor::TraverseTypeLoc(clang::TypeLoc tl)
 {
 	std::shared_ptr<ScopedFunctor> removeContextFunctor;
@@ -1210,6 +1216,7 @@ bool CxxAstVisitor::checkIgnoresTypeLoc(const clang::TypeLoc& tl)
 		(!tl.getAs<clang::TemplateTypeParmTypeLoc>().isNull()) ||
 		(!tl.getAs<clang::TemplateSpecializationTypeLoc>().isNull()) ||
 		(!tl.getAs<clang::DependentNameTypeLoc>().isNull()) ||
+		(!tl.getAs<clang::DependentTemplateSpecializationTypeLoc>().isNull()) ||
 		(!tl.getAs<clang::BuiltinTypeLoc>().isNull()) ||
 		(!tl.getAs<clang::AutoTypeLoc>().isNull())
 	){

src/lib_cxx/data/parser/cxx/CxxAstVisitor.h

@@ -61,6 +61,7 @@ public:
 
 	// Traversal methods. These specify how to traverse the AST and record context info.
 	virtual bool TraverseDecl(clang::Decl *d);
+	virtual bool TraverseQualifiedTypeLoc(clang::QualifiedTypeLoc tl);
 	virtual bool TraverseTypeLoc(clang::TypeLoc tl);
 	virtual bool TraverseType(clang::QualType t);
 	virtual bool TraverseStmt(clang::Stmt *stmt);

src/lib_cxx/data/parser/cxx/name_resolver/CxxTypeNameResolver.cpp

@@ -59,9 +59,6 @@ std::shared_ptr<CxxTypeName> CxxTypeNameResolver::getName(const clang::Type* typ
 		break;
 	}
 	case clang::Type::MemberPointer:
-	{
-		// test this case!
-	}
 	case clang::Type::Pointer:
 	{
 		typeName = getName(type->getPointeeType());
@@ -126,7 +123,7 @@ std::shared_ptr<CxxTypeName> CxxTypeNameResolver::getName(const clang::Type* typ
 			{
 				typeName = std::make_shared<CxxTypeName>(
 					declName->getName(),
-					declName->getTemplateParameterNames(), 
+					declName->getTemplateParameterNames(),
 					declName->getParent()
 				);
 			}
@@ -147,8 +144,8 @@ std::shared_ptr<CxxTypeName> CxxTypeNameResolver::getName(const clang::Type* typ
 				}
 
 				typeName = std::make_shared<CxxTypeName>(
-					declName->getName(), 
-					templateArguments, 
+					declName->getName(),
+					templateArguments,
 					declName->getParent()
 				);
 			}
@@ -166,8 +163,8 @@ std::shared_ptr<CxxTypeName> CxxTypeNameResolver::getName(const clang::Type* typ
 		if (declName)
 		{
 			typeName = std::make_shared<CxxTypeName>(
-				declName->getName(), 
-				declName->getTemplateParameterNames(), 
+				declName->getName(),
+				declName->getTemplateParameterNames(),
 				declName->getParent()
 			);
 		}
@@ -180,14 +177,32 @@ std::shared_ptr<CxxTypeName> CxxTypeNameResolver::getName(const clang::Type* typ
 	}
 	case clang::Type::DependentName:
 	{
-		const clang::DependentNameType* dependentNameType = clang::dyn_cast<clang::DependentNameType>(type);
+		const clang::DependentNameType* dependentType = clang::dyn_cast<clang::DependentNameType>(type);
 
 		CxxSpecifierNameResolver specifierNameResolver(getIgnoredContextDecls());
-		std::shared_ptr<CxxName> specifierName = specifierNameResolver.getName(dependentNameType->getQualifier());
+		std::shared_ptr<CxxName> specifierName = specifierNameResolver.getName(dependentType->getQualifier());
 
-		// TODO: TEst what if this one has template args?
 		typeName = std::make_shared<CxxTypeName>(
-			dependentNameType->getIdentifier()->getName().str(), std::vector<std::string>(), specifierName
+			dependentType->getIdentifier()->getName().str(), std::vector<std::string>(), specifierName
+		);
+		break;
+	}
+	case clang::Type::DependentTemplateSpecialization:
+	{
+		const clang::DependentTemplateSpecializationType* dependentType = clang::dyn_cast<clang::DependentTemplateSpecializationType>(type);
+
+		CxxSpecifierNameResolver specifierNameResolver(getIgnoredContextDecls());
+		std::shared_ptr<CxxName> specifierName = specifierNameResolver.getName(dependentType->getQualifier());
+
+		std::vector<std::string> templateArguments;
+		CxxTemplateArgumentNameResolver resolver(getIgnoredContextDecls());
+		for (size_t i = 0; i < dependentType->getNumArgs(); i++)
+		{
+			templateArguments.push_back(resolver.getTemplateArgumentName(dependentType->getArg(i)));
+		}
+
+		typeName = std::make_shared<CxxTypeName>(
+			dependentType->getIdentifier()->getName().str(), templateArguments, specifierName
 		);
 		break;
 	}
@@ -216,6 +231,32 @@ std::shared_ptr<CxxTypeName> CxxTypeNameResolver::getName(const clang::Type* typ
 		typeName = getName(clang::dyn_cast<clang::DecltypeType>(type)->getUnderlyingType());
 		break;
 	}
+	case clang::Type::FunctionProto:
+	{
+		const clang::FunctionProtoType* protoType = clang::dyn_cast<clang::FunctionProtoType>(type);
+		std::string nameString = getName(protoType->getReturnType())->toString();
+		nameString += "(";
+		for (size_t i = 0; i < protoType->getNumParams(); i++)
+		{
+			if (i != 0)
+			{
+				nameString += ", ";
+			}
+			nameString += getName(protoType->getParamType(i))->toString();
+		}
+		nameString += ")";
+
+		typeName = std::make_shared<CxxTypeName>(
+			nameString, std::vector<std::string>()
+		);
+		break;
+	}
+	case clang::Type::Adjusted:
+	case clang::Type::Decayed:
+	{
+		typeName = getName(type->getAs<clang::AdjustedType>()->getOriginalType());
+		break;
+	}
 	default:
 	{
 		std::string typeClassName = type->getTypeClassName();