rebase

Author: Vladislav Kalugin

server/src/KleeGenerator.cpp

@@ -253,8 +253,8 @@ std::vector<fs::path> KleeGenerator::buildKleeFiles(const tests::TestsMap &tests
                 return;
             }
             kleePrinter.srcLanguage = Paths::getSourceLanguage(filename);
-            auto includeFlags = { StringUtils::stringFormat("-I%s",
-                                                            Paths::getFlagsDir(projectContext)) };
+            std::vector<std::string> includeFlags = {
+                    StringUtils::stringFormat("-I%s", Paths::getFlagsDir(projectContext))};
             auto buildDirPath =
                 buildDatabase->getClientCompilationUnitInfo(filename)->getDirectory();
 

server/src/Paths.cpp

@@ -27,7 +27,7 @@ namespace Paths {
         CollectionUtils::FileSet filtered =
             CollectionUtils::filterOut(paths, [&dirPaths, &filter](const fs::path &path) {
                 return !std::any_of(dirPaths.begin(), dirPaths.end(), [&](const fs::path &dirPath) {
-                    return path.parent_path() == dirPath && fs::exists(path) && filter(path);
+                    return isSubPathOf(dirPath, path) && fs::exists(path) && filter(path);
                 });
             });
         return filtered;

server/src/Server.cpp

@@ -568,7 +568,8 @@ Status Server::TestsGenServiceImpl::PrintModulesContent(ServerContext *context,
 
     utbot::ProjectContext projectContext{ *request };
     fs::path serverBuildDir = Paths::getUtbotBuildDir(projectContext);
-    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 };

server/src/building/BaseCommand.cpp

@@ -7,11 +7,11 @@
 #include "tasks/ShellExecTask.h"
 #include "utils/CollectionUtils.h"
 #include "utils/StringUtils.h"
+#include "utils/path/FileSystemPath.h"
 
 #include "loguru.h"
 
 #include <algorithm>
-#include "utils/path/FileSystemPath.h"
 #include <iterator>
 #include <set>
 #include <utility>
@@ -20,26 +20,36 @@ namespace utbot {
     BaseCommand::BaseCommand(std::list<std::string> commandLine, fs::path directory, bool shouldChangeDirectory)
         : commandLine(std::move(commandLine)), directory(std::move(directory)), shouldChangeDirectory{shouldChangeDirectory} {
         initOptimizationLevel();
+        initCompiler();
+        initOutput();
     }
     BaseCommand::BaseCommand(std::vector<std::string> commandLine, fs::path directory, bool shouldChangeDirectory)
         : commandLine(commandLine.begin(), commandLine.end()), directory(std::move(directory)), shouldChangeDirectory{shouldChangeDirectory} {
         initOptimizationLevel();
+        initCompiler();
+        initOutput();
     }
 
     BaseCommand::BaseCommand(BaseCommand const &other)
-        : directory(other.directory), commandLine(other.commandLine),
-          environmentVariables(other.environmentVariables), shouldChangeDirectory(other.shouldChangeDirectory) {
+            : directory(other.directory), commandLine(other.commandLine),
+              environmentVariables(other.environmentVariables), shouldChangeDirectory(other.shouldChangeDirectory),
+              compiler(other.compiler),
+              output(other.output) {
         if (other.optimizationLevel.has_value()) {
             optimizationLevel =
-                std::next(commandLine.begin(),
-                          std::distance<const_iterator>(other.commandLine.begin(),
-                                                        other.optimizationLevel.value()));
+                    std::next(commandLine.begin(),
+                              std::distance<const_iterator>(other.commandLine.begin(),
+                                                            other.optimizationLevel.value()));
         }
     }
+
     BaseCommand::BaseCommand(BaseCommand &&other) noexcept
         : directory(std::move(other.directory)), commandLine(std::move(other.commandLine)),
           environmentVariables(std::move(other.environmentVariables)),
-          optimizationLevel(other.optimizationLevel), shouldChangeDirectory(other.shouldChangeDirectory) {
+          optimizationLevel(other.optimizationLevel),
+          compiler(other.compiler),
+          output(other.output),
+          shouldChangeDirectory(other.shouldChangeDirectory) {
     }
 
     void BaseCommand::initOptimizationLevel() {
@@ -48,6 +58,19 @@ namespace utbot {
             optimizationLevel = it;
         }
     }
+
+    void BaseCommand::initCompiler() {
+        auto it = commandLine.begin();
+        compiler = it;
+    }
+
+    void BaseCommand::initOutput() {
+        auto it = findOutput();
+        if (it != commandLine.end()) {
+            output = it;
+        }
+    }
+
     BaseCommand::iterator BaseCommand::findOutput() {
         auto it = std::find(commandLine.begin(), commandLine.end(), "-o");
         if (it != commandLine.end()) {
@@ -127,4 +150,20 @@ namespace utbot {
             optimizationLevel = addFlagToBegin(flag);
         }
     }
+
+    fs::path BaseCommand::getCompiler() const {
+        return *compiler;
+    }
+
+    void BaseCommand::setCompiler(fs::path compiler) {
+        *(this->compiler) = std::move(compiler);
+    }
+
+    fs::path BaseCommand::getOutput() const {
+        return *output;
+    }
+
+    void BaseCommand::setOutput(fs::path output) {
+        *(this->output) = std::move(output);
+    }
 }

server/src/building/BaseCommand.h

@@ -23,15 +23,22 @@ namespace utbot {
         using iterator = decltype(commandLine)::iterator;
         using const_iterator = decltype(commandLine)::const_iterator;
 
+        iterator compiler;
+        iterator output;
+
         std::optional<iterator> optimizationLevel;
 
         void initOptimizationLevel();
 
+        void initCompiler();
+
+        void initOutput();
+
         [[nodiscard]] iterator findOutput();
 
         iterator findOptimizationLevelFlag();
 
-    public:
+
         BaseCommand() = default;
 
         BaseCommand(std::list<std::string> commandLine, fs::path directory, bool shouldChangeDirectory = false);
@@ -42,13 +49,17 @@ namespace utbot {
 
         BaseCommand(BaseCommand &&other) noexcept;
 
+    public:
+
         [[nodiscard]] std::list<std::string> &getCommandLine();
 
         [[nodiscard]] const std::list<std::string> &getCommandLine() const;
 
         [[nodiscard]] const fs::path &getDirectory() const;
 
-        [[nodiscard]] virtual fs::path getOutput() const = 0;
+        [[nodiscard]] fs::path getOutput() const;
+
+        void setOutput(fs::path output);
 
         [[nodiscard]] virtual bool isArchiveCommand() const = 0;
 
@@ -89,6 +100,10 @@ namespace utbot {
         size_t erase_if(std::function<bool(std::string)> f);
 
         void setOptimizationLevel(const std::string &flag);
+
+        [[nodiscard]] fs::path getCompiler() const;
+
+        void setCompiler(fs::path compiler);
     };
 }