temp

Author: ladisgin

integration-tests/cpp-example/cxx_lib/multiple_classes.cpp

@@ -0,0 +1,20 @@
+#include "multiple_classes.h"
+
+int first_class::get1() {
+    return 1;
+}
+
+int second_class::get2() {
+    return 2;
+}
+
+int second_class::third_class::get3() {
+    return 3;
+}
+
+first_class::first_class() {}
+
+second_class::second_class() {}
+
+second_class::third_class::third_class() {}
+

integration-tests/cpp-example/cxx_lib/multiple_classes.h

@@ -0,0 +1,27 @@
+#ifndef UNITTESTBOT_MULTIPLE_CLASSES_H
+#define UNITTESTBOT_MULTIPLE_CLASSES_H
+
+
+class first_class {
+public:
+    first_class();
+
+    int get1();
+};
+
+struct second_class {
+public:
+    second_class();
+
+    struct third_class {
+        third_class();
+
+    public:
+        int get3();
+    };
+
+    int get2();
+};
+
+
+#endif //UNITTESTBOT_MULTIPLE_CLASSES_H

server/src/BordersFinder.cpp

@@ -83,7 +83,16 @@ void BordersFinder::run(const MatchFinder::MatchResult &Result) {
         } else {
             lineInfo.scopeName = path.stem().string();
         }
-        lineInfo.methodName = FS->getNameAsString();
+
+        std::string QualName = "";
+
+        llvm::raw_string_ostream OS(QualName);
+        auto qua = FS->getQualifier();
+        if (qua) {
+            qua->print(OS, FS->getASTContext().getPrintingPolicy());
+        }
+
+        lineInfo.methodName = QualName + FS->getNameAsString();
         clang::QualType realReturnType = ClangUtils::getReturnType(FS, Result);
         lineInfo.functionReturnType = ParamsHandler::getType(realReturnType, realReturnType, sourceManager);
         lineInfo.initialized = true;

server/src/clang-utils/ClangUtils.cpp

@@ -36,12 +36,27 @@ namespace ClangUtils {
         return FS;
     }
 
-
-    clang::QualType getReturnType(const clang::FunctionDecl *FS, const clang::ast_matchers::MatchFinder::MatchResult &Result) {
+    clang::QualType
+    getReturnType(const clang::FunctionDecl *FS, const clang::ast_matchers::MatchFinder::MatchResult &Result) {
         clang::QualType realReturnType = FS->getReturnType().getCanonicalType();
         if (const auto *CS = getConstructor(Result)) {
             realReturnType = CS->getThisObjectType();
         }
         return realReturnType;
     }
+
+    std::string getQualName(const clang::FunctionDecl *FS) {
+        std::string QualName = "";
+        llvm::raw_string_ostream OS(QualName);
+        auto qualifier = FS->getQualifier();
+        if (qualifier) {
+            switch (FS->getCanonicalDecl()) {
+                
+            }
+            qualifier->print(OS, FS->getASTContext().getPrintingPolicy());
+            OS.flush();
+
+            LOG_S(ERROR) << "qualname: '" << QualName << "'    '" << FS->getQualifiedNameAsString() << "'";
+        }
+    }
 }

server/src/fetchers/FunctionDeclsMatchCallback.cpp

@@ -16,8 +16,8 @@ FunctionDeclsMatchCallback::FunctionDeclsMatchCallback(const Fetcher *parent,
                                                        bool onlyNames,
                                                        bool toResolveReturnTypes,
                                                        bool onlyReturnTypes)
-    : parent(parent), typesResolver(parent), onlyNames(onlyNames),
-      toResolveReturnTypes(toResolveReturnTypes), onlyReturnTypes(onlyReturnTypes) {
+        : parent(parent), typesResolver(parent), onlyNames(onlyNames),
+          toResolveReturnTypes(toResolveReturnTypes), onlyReturnTypes(onlyReturnTypes) {
 }
 
 void FunctionDeclsMatchCallback::run(const MatchFinder::MatchResult &Result) {
@@ -29,15 +29,14 @@ void FunctionDeclsMatchCallback::run(const MatchFinder::MatchResult &Result) {
                 ->tryGetRealPathName()
                 .str();
 
-        std::string methodName = FS->getNameAsString();
         Tests::MethodDescription methodDescription;
-        methodDescription.name = methodName;
         if (const CXXConstructorDecl *CS = ClangUtils::getConstructor(Result)) {
-            methodDescription.constructorInfo = Tests::ConstructorInfo::CONSTRUCTOR;
-            if (CS->isMoveConstructor()) {
-                methodDescription.constructorInfo = Tests::ConstructorInfo::MOVE_CONSTRUCTOR;
-            }
+            methodDescription.constructorInfo = CS->isMoveConstructor() ? Tests::ConstructorInfo::MOVE_CONSTRUCTOR
+                                                                        : Tests::ConstructorInfo::CONSTRUCTOR;
         }
+
+        std::string methodName = QualName + FS->getNameAsString();
+        methodDescription.name = methodName;
         methodDescription.sourceFilePath = sourceFilePath;
         if (onlyNames) {
             addMethod(sourceFilePath, methodDescription);
@@ -156,18 +155,18 @@ void FunctionDeclsMatchCallback::logFunction(const Tests::MethodDescription &des
 }
 
 void FunctionDeclsMatchCallback::addFunctionPointer(
-    tests::Tests::MethodDescription::FPointerMap &functionPointers,
-    const clang::FunctionType *functionType,
-    const clang::QualType &qualType,
-    const std::string &name,
-    const clang::SourceManager &sourceManager,
-    const types::Type &type) {
+        tests::Tests::MethodDescription::FPointerMap &functionPointers,
+        const clang::FunctionType *functionType,
+        const clang::QualType &qualType,
+        const std::string &name,
+        const clang::SourceManager &sourceManager,
+        const types::Type &type) {
     if (type.isPointerToFunction()) {
         functionPointers[name] = ParamsHandler::getFunctionPointerDeclaration(functionType, name, sourceManager,
-                                                            false);
+                                                                              false);
     } else if (type.isArrayOfPointersToFunction()) {
         functionPointers[name] = ParamsHandler::getFunctionPointerDeclaration(
-            qualType->getPointeeType()->getPointeeType()->getAs<clang::FunctionType>(), name,
-            sourceManager, true);
+                qualType->getPointeeType()->getPointeeType()->getAs<clang::FunctionType>(), name,
+                sourceManager, true);
     }
 }

server/src/utils/KleeUtils.cpp

@@ -83,7 +83,10 @@ namespace KleeUtils {
                                    const std::string &methodName,
                                    bool needToMangle,
                                    bool isWrapped) {
-        std::string methodNewName = getRenamedOperator(methodName);
+
+        std::string methodNewName = methodName;
+        StringUtils::replaceAll(methodNewName, ':', '_');
+        methodNewName = getRenamedOperator(methodNewName);
         if (isWrapped) {
             methodNewName += PrinterUtils::WRAPPED_SUFFIX;
         }