temp commit

Vladislav Kalugin · Vladislav Kalugin · commit 96aaf90d72df · 2022-06-30T12:25:11.000+03:00
diff --git a/server/src/Server.cpp b/server/src/Server.cpp
@@ -568,7 +568,8 @@ Status Server::TestsGenServiceImpl::PrintModulesContent(ServerContext *context,
 
     fs::path serverBuildDir = Paths::getTmpDir(request->projectname());
     utbot::ProjectContext projectContext{ *request };
-    std::shared_ptr<BuildDatabase> buildDatabase = BuildDatabase::create(projectContext);
+    std::shared_ptr<BuildDatabase> buildDatabase = BuildDatabase::create(projectContext,
+                                                                         GrpcUtils::UTBOT_AUTO_TARGET_PATH);
     StubSourcesFinder(buildDatabase).printAllModules();
     return Status::OK;
 }
@@ -643,7 +644,7 @@ Status Server::TestsGenServiceImpl::GetProjectTargets(ServerContext *context,
 
     try {
         utbot::ProjectContext projectContext{ request->projectcontext() };
-        auto buildDatabase = BuildDatabase::create(projectContext);
+        auto buildDatabase = BuildDatabase::create(projectContext, GrpcUtils::UTBOT_AUTO_TARGET_PATH);
         auto targets = buildDatabase->getAllTargets();
         ProjectTargetsWriter targetsWriter{ response };
         targetsWriter.writeResponse(projectContext, targets);
@@ -665,7 +666,7 @@ Status Server::TestsGenServiceImpl::GetFileTargets(ServerContext *context,
 
     try {
         utbot::ProjectContext projectContext{ request->projectcontext() };
-        auto buildDatabase = BuildDatabase::create(projectContext);
+        auto buildDatabase = BuildDatabase::create(projectContext, GrpcUtils::UTBOT_AUTO_TARGET_PATH);
         fs::path path = request->path();
         auto targets = buildDatabase->getTargetsForSourceFile(path);
         FileTargetsWriter targetsWriter{ response };
diff --git a/server/src/building/BuildDatabase.cpp b/server/src/building/BuildDatabase.cpp
@@ -15,6 +15,7 @@
 #include <queue>
 #include <set>
 #include <unordered_map>
+#include <utils/GrpcUtils.h>
 
 static std::string tryConvertOptionToPath(const std::string &possibleFilePath,
                                           const fs::path &dirPath) {
@@ -32,7 +33,8 @@ static std::string tryConvertOptionToPath(const std::string &possibleFilePath,
 
 BuildDatabase::BuildDatabase(const fs::path& buildCommandsJsonPath,
                              fs::path serverBuildDir,
-                             utbot::ProjectContext projectContext)
+                             utbot::ProjectContext projectContext,
+                             const std::string &target)
     : serverBuildDir(std::move(serverBuildDir)), projectContext(std::move(projectContext)) {
     linkCommandsJsonPath = fs::canonical(buildCommandsJsonPath / "link_commands.json");
     compileCommandsJsonPath = fs::canonical(buildCommandsJsonPath / "compile_commands.json");
@@ -42,20 +44,23 @@ BuildDatabase::BuildDatabase(const fs::path& buildCommandsJsonPath,
     auto linkCommandsJson = JsonUtils::getJsonFromFile(linkCommandsJsonPath);
     auto compileCommandsJson = JsonUtils::getJsonFromFile(compileCommandsJsonPath);
 
-    createClangCompileCommandsJson(buildCommandsJsonPath, compileCommandsJson);
+    initObjects(compileCommandsJson);
     initInfo(linkCommandsJson);
     filterInstalledFiles();
     addLocalSharedLibraries();
     fillTargetInfoParents();
+    createClangCompileCommandsJson(target, buildCommandsJsonPath);
+    //filter
 }
 
-std::shared_ptr<BuildDatabase> BuildDatabase::create(const utbot::ProjectContext &projectContext) {
+std::shared_ptr<BuildDatabase> BuildDatabase::create(const utbot::ProjectContext &projectContext,
+                                                     const std::string &target) {
     fs::path compileCommandsJsonPath =
-        CompilationUtils::substituteRemotePathToCompileCommandsJsonPath(
-            projectContext.projectPath, projectContext.buildDirRelativePath);
+            CompilationUtils::substituteRemotePathToCompileCommandsJsonPath(
+                    projectContext.projectPath, projectContext.buildDirRelativePath);
     fs::path serverBuildDir = Paths::getTmpDir(projectContext.projectName);
     std::shared_ptr<BuildDatabase> buildDatabase =
-        std::make_shared<BuildDatabase>(compileCommandsJsonPath, serverBuildDir, projectContext);
+            std::make_shared<BuildDatabase>(compileCommandsJsonPath, serverBuildDir, projectContext, target);
     return buildDatabase;
 }
 
@@ -78,10 +83,8 @@ fs::path BuildDatabase::createExplicitObjectFileCompilationCommand(const std::sh
     }
 }
 
-void BuildDatabase::createClangCompileCommandsJson(const fs::path &buildCommandsJsonPath,
-                                                   const nlohmann::json &compileCommandsJson) {
-    CollectionUtils::MapFileTo<std::pair<nlohmann::json, std::shared_ptr<ObjectFileInfo>>> fileCompileCommands;
-    for (auto const& compileCommand: compileCommandsJson) {
+void BuildDatabase::initObjects(const nlohmann::json &compileCommandsJson) {
+    for (const nlohmann::json &compileCommand: compileCommandsJson) {
         auto objectInfo = std::make_shared<ObjectFileInfo>();
 
         fs::path directory = compileCommand.at("directory").get<std::string>();
@@ -103,11 +106,12 @@ void BuildDatabase::createClangCompileCommandsJson(const fs::path &buildCommands
         objectInfo->command.removeWerror();
         fs::path outputFile = objectInfo->getOutputFile();
         fs::path kleeFilePathTemplate =
-            Paths::createNewDirForFile(sourceFile, projectContext.buildDir, serverBuildDir);
+                Paths::createNewDirForFile(sourceFile, projectContext.buildDir, serverBuildDir);
         fs::path kleeFile = Paths::addSuffix(kleeFilePathTemplate, "_klee");
         objectInfo->kleeFilesInfo = std::make_shared<KleeFilesInfo>(kleeFile);
 
-        if (CollectionUtils::containsKey(objectFileInfos, outputFile) || CollectionUtils::containsKey(targetInfos, outputFile)) {
+        if (CollectionUtils::containsKey(objectFileInfos, outputFile) ||
+            CollectionUtils::containsKey(targetInfos, outputFile)) {
             /*
              * If the condition above is true, that means that the output file
              * is built from multiple sources. Hence, it is not an object file,
@@ -129,9 +133,9 @@ void BuildDatabase::createClangCompileCommandsJson(const fs::path &buildCommands
                 //create targetInfo
                 targetInfo = targetInfos[outputFile] = std::make_shared<TargetInfo>();
                 targetInfo->commands.emplace_back(
-                    std::initializer_list<std::string>{ targetObjectInfo->command.getCompiler(),
-                                                        "-o", outputFile, tmpObjectFileName },
-                    directory);
+                        std::initializer_list<std::string>{targetObjectInfo->command.getCompiler(),
+                                                           "-o", outputFile, tmpObjectFileName},
+                        directory);
                 targetInfo->addFile(tmpObjectFileName);
             }
             //redirect new compilation command to temporary file
@@ -143,22 +147,13 @@ void BuildDatabase::createClangCompileCommandsJson(const fs::path &buildCommands
         } else {
             objectFileInfos[outputFile] = objectInfo;
         }
+        compileCommands_temp.emplace_back(compileCommand, objectInfo);
         const fs::path &sourcePath = objectInfo->getSourcePath();
-        if (!CollectionUtils::containsKey(sourceFileInfos, sourcePath) ||
-            conflictPriorityMore(objectInfo, fileCompileCommands[sourcePath].second)) {
-            fileCompileCommands[sourcePath] = { compileCommand, objectInfo };
-        }
         sourceFileInfos[sourcePath].emplace_back(objectInfo);
     }
     for (auto &[sourceFile, objectInfos]: sourceFileInfos) {
         std::sort(objectInfos.begin(), objectInfos.end(), conflictPriorityMore);
     }
-    nlohmann::json compileCommandsSingleFilesJson;
-    for (const auto &compileCommand: fileCompileCommands) {
-        compileCommandsSingleFilesJson.push_back(compileCommand.second.first);
-    }
-    fs::path clangCompileCommandsJsonPath = CompilationUtils::getClangCompileCommandsJsonPath(buildCommandsJsonPath);
-    JsonUtils::writeJsonToFile(clangCompileCommandsJsonPath, compileCommandsSingleFilesJson);
 }
 
 void BuildDatabase::initInfo(const nlohmann::json &linkCommandsJson) {
@@ -204,6 +199,27 @@ void BuildDatabase::initInfo(const nlohmann::json &linkCommandsJson) {
     }
 }
 
+void BuildDatabase::createClangCompileCommandsJson(const fs::path &target, const fs::path &buildCommandsJsonPath) {
+    CollectionUtils::MapFileTo<std::pair<nlohmann::json, std::shared_ptr<ObjectFileInfo>>> fileCompileCommands;
+    for (const auto &[compileCommand, objectInfo]: compileCommands_temp) {
+        const fs::path &sourcePath = objectInfo->getSourcePath();
+        if ((targetInfos[target]->files.contains(objectInfo->getOutputFile()) ||
+             target == GrpcUtils::UTBOT_AUTO_TARGET_PATH) &&
+            (!CollectionUtils::containsKey(fileCompileCommands, sourcePath) ||
+             conflictPriorityMore(objectInfo, fileCompileCommands[sourcePath].second))) {
+            fileCompileCommands[sourcePath] = {compileCommand, objectInfo};
+        }
+    }
+
+    nlohmann::json compileCommandsSingleFilesJson;
+    for (const auto &compileCommand: fileCompileCommands) {
+        compileCommandsSingleFilesJson.push_back(compileCommand.second.first);
+    }
+
+    fs::path clangCompileCommandsJsonPath = CompilationUtils::getClangCompileCommandsJsonPath(buildCommandsJsonPath);
+    JsonUtils::writeJsonToFile(clangCompileCommandsJsonPath, compileCommandsSingleFilesJson);
+}
+
 void BuildDatabase::mergeLibraryOptions(std::vector<std::string> &jsonArguments) const {
     for (auto it = jsonArguments.begin(); it != jsonArguments.end(); it++) {
         if (*it == DynamicLibraryUtils::libraryDirOption || *it == DynamicLibraryUtils::linkFlag) {
@@ -468,7 +484,8 @@ BuildDatabase::getClientCompilationUnitInfo(const fs::path &filepath) const {
             throw CompilationDatabaseException("File not found in compilation_commands.json: " + filepath.string());
         }
         return sourceFileInfos.at(filepath)[0];
-    } if (Paths::isObjectFile(filepath)) {
+    }
+    if (Paths::isObjectFile(filepath)) {
         if (!CollectionUtils::contains(objectFileInfos, filepath)) {
             throw CompilationDatabaseException("File not found in compilation_commands.json: " + filepath.string());
         }
@@ -477,8 +494,7 @@ BuildDatabase::getClientCompilationUnitInfo(const fs::path &filepath) const {
     throw CompilationDatabaseException("File is not a compilation unit or an object file: " + filepath.string());
 }
 
-std::shared_ptr<const BuildDatabase::TargetInfo>
-BuildDatabase::getClientLinkUnitInfo(const fs::path &filepath) const {
+std::shared_ptr<const BuildDatabase::TargetInfo> BuildDatabase::getClientLinkUnitInfo(const fs::path &filepath) const {
     if (Paths::isSourceFile(filepath)) {
         auto compilationInfo = getClientCompilationUnitInfo(filepath);
         return targetInfos.at(compilationInfo->linkUnit);
@@ -491,8 +507,8 @@ BuildDatabase::getClientLinkUnitInfo(const fs::path &filepath) const {
 }
 
 bool BuildDatabase::conflictPriorityMore(
-    const std::shared_ptr<BuildDatabase::ObjectFileInfo> &left,
-    const std::shared_ptr<BuildDatabase::ObjectFileInfo> &right) {
+        const std::shared_ptr<BuildDatabase::ObjectFileInfo> &left,
+        const std::shared_ptr<BuildDatabase::ObjectFileInfo> &right) {
     if (StringUtils::contains(left->getOutputFile().string(), "64")) {
         return true;
     }
@@ -675,6 +691,7 @@ std::shared_ptr<BuildDatabase::TargetInfo> BuildDatabase::getPriorityTarget() co
                                });
     return *it;
 }
+
 fs::path BuildDatabase::newDirForFile(const fs::path &file) const {
     fs::path base = Paths::longestCommonPrefixPath(this->projectContext.buildDir,
                                                    this->projectContext.projectPath);
diff --git a/server/src/building/BuildDatabase.h b/server/src/building/BuildDatabase.h
@@ -15,6 +15,7 @@
 #include <unordered_set>
 #include <variant>
 #include <vector>
+#include <vector>
 
 class BuildDatabase {
 public:
@@ -101,9 +102,11 @@ class BuildDatabase {
 public:
     BuildDatabase(const fs::path &buildCommandsJsonPath,
                   fs::path serverBuildDir,
-                  utbot::ProjectContext projectContext);
+                  utbot::ProjectContext projectContext,
+                  const std::string &target);
 
-    static std::shared_ptr<BuildDatabase> create(const utbot::ProjectContext &projectContext);
+    static std::shared_ptr<BuildDatabase> create(const utbot::ProjectContext &projectContext,
+                                                 const std::string &target);
 
     const fs::path &getCompileCommandsJson();
     const fs::path &getLinkCommandsJson();
@@ -212,20 +215,22 @@ class BuildDatabase {
     std::unordered_map<std::shared_ptr<const BuildDatabase::TargetInfo>, CollectionUtils::FileSet>
         linkUnitToStubFiles;
 
+    std::vector<std::pair<nlohmann::json, std::shared_ptr<ObjectFileInfo>>> compileCommands_temp;
+    std::vector<std::pair<nlohmann::json, std::shared_ptr<ObjectFileInfo>>> linkCommands_temp;
+
     static bool conflictPriorityMore(const std::shared_ptr<ObjectFileInfo> &left,
                                      const std::shared_ptr<ObjectFileInfo> &right);
 
     void filterInstalledFiles();
     void addLocalSharedLibraries();
     void fillTargetInfoParents();
     static fs::path getCorrespondingBitcodeFile(const fs::path &filepath);
-    void createClangCompileCommandsJson(const fs::path &buildCommandsJsonPath,
-                                        const nlohmann::json &compileCommandsJson);
+    void initObjects(const nlohmann::json &compileCommandsJson);
     void initInfo(const nlohmann::json &linkCommandsJson);
+    void createClangCompileCommandsJson(const fs::path &target, const fs::path &buildCommandsJsonPath);
     void mergeLibraryOptions(std::vector<std::string> &jsonArguments) const;
     fs::path newDirForFile(fs::path const& file) const;
-    fs::path
-    createExplicitObjectFileCompilationCommand(const std::shared_ptr<ObjectFileInfo> &objectInfo);
+    fs::path createExplicitObjectFileCompilationCommand(const std::shared_ptr<ObjectFileInfo> &objectInfo);
 
     using sharedLibrariesMap = std::unordered_map<std::string, CollectionUtils::MapFileTo<fs::path>>;
 
diff --git a/server/src/testgens/ProjectTestGen.cpp b/server/src/testgens/ProjectTestGen.cpp
@@ -15,9 +15,9 @@ ProjectTestGen::ProjectTestGen(const testsgen::ProjectRequest &request,
                   testMode), request(&request) {
     fs::create_directories(projectContext.testDirPath);
     compileCommandsJsonPath = CompilationUtils::substituteRemotePathToCompileCommandsJsonPath(
-        projectContext.projectPath, projectContext.buildDirRelativePath);
-    buildDatabase =
-        std::make_shared<BuildDatabase>(compileCommandsJsonPath, serverBuildDir, projectContext);
+            projectContext.projectPath, projectContext.buildDirRelativePath);
+    buildDatabase = std::make_shared<BuildDatabase>(compileCommandsJsonPath, serverBuildDir, projectContext,
+                                                    request.targetpath());
     compilationDatabase = CompilationUtils::getCompilationDatabase(compileCommandsJsonPath);
     if (autoDetect) {
         autoDetectSourcePathsIfNotEmpty();
diff --git a/server/src/testgens/SnippetTestGen.cpp b/server/src/testgens/SnippetTestGen.cpp
@@ -11,13 +11,14 @@ SnippetTestGen::SnippetTestGen(const testsgen::SnippetRequest &request,
                   progressWriter,
                   testMode) {
     filePath = fs::weakly_canonical(request.filepath());
-    sourcePaths = { filePath };
+    sourcePaths = {filePath};
     testingMethodsSourcePaths = sourcePaths;
     printer::CCJsonPrinter::createDummyBuildDB(sourcePaths, serverBuildDir);
     compileCommandsJsonPath = serverBuildDir;
-    utbot::ProjectContext projectContext{ request, serverBuildDir };
+    utbot::ProjectContext projectContext{request, serverBuildDir};
     buildDatabase =
-        std::make_shared<BuildDatabase>(compileCommandsJsonPath, serverBuildDir, projectContext);
+            std::make_shared<BuildDatabase>(compileCommandsJsonPath, serverBuildDir, projectContext,
+                                            GrpcUtils::UTBOT_AUTO_TARGET_PATH);
     compilationDatabase = CompilationUtils::getCompilationDatabase(serverBuildDir);
     setTargetForSource(filePath);
     setInitializedTestsMap();
