refactor: restructure makefile and compiler detect and more

Samat Gaynutdinov · Samat Gaynutdinov · commit b6570d363b4e · 2022-06-09T20:21:48.000+03:00
diff --git a/server/src/Paths.cpp b/server/src/Paths.cpp
@@ -388,15 +388,21 @@ namespace Paths {
         return fs::relative(source.parent_path(), projectContext.projectPath);
     }
 
-    std::optional<fs::path> getRelativePathWithShellVariable(const fs::path &shellVariableForBase,
-                                                 const fs::path &base,
-                                                 const fs::path &source) {
-
-        auto relative = fs::relative(source, base).string();
-        if (relative.empty() || StringUtils::contains(relative, "..")) {
-            return std::nullopt;
+    std::optional<std::string> getRelativePathWithShellVariable(const fs::path &shellVariableForBase,
+                                                 const std::string &base,
+                                                 const std::string &source) {
+
+//        auto relative = fs::relative(source, base).string();
+//        if (relative.empty() || StringUtils::contains(relative, "..")) {
+//            return std::nullopt;
+//        }
+//        return std::make_optional(shellVariableForBase / fs::relative(source, base));
+        std::string returnPath = source;
+        if (StringUtils::startsWith(source, base)) {
+            StringUtils::replaceFirst(returnPath, base, shellVariableForBase.string());
+            return returnPath;
         }
-        return std::make_optional(shellVariableForBase / fs::relative(source, base));
+        return std::nullopt;
     }
 
 
diff --git a/server/src/Paths.h b/server/src/Paths.h
@@ -160,7 +160,7 @@ namespace Paths {
         if (utbotBuildDir.string().empty()) {
             return tmpPath / "tmp" / RequestEnvironment::getClientId();
         }
-        return utbotBuildDir / "tmp";
+        return utbotBuildDir;
     }
 
     static inline fs::path getTmpPath() {
@@ -355,9 +355,9 @@ namespace Paths {
 
     fs::path getRelativeDirPath(const utbot::ProjectContext &projectContext, const fs::path &source);
 
-    std::optional<fs::path> getRelativePathWithShellVariable(const fs::path &shellVariableForBase,
-                                                                const fs::path &base,
-                                                                const fs::path &source);
+    std::optional<std::string> getRelativePathWithShellVariable(const fs::path &shellVariableForBase,
+                                                             const std::string &base,
+                                                             const std::string &source);
 
     fs::path
     getMakefilePathFromSourceFilePath(const utbot::ProjectContext &projectContext, const fs::path &sourceFilePath,
diff --git a/server/src/environment/EnvironmentPaths.cpp b/server/src/environment/EnvironmentPaths.cpp
@@ -34,11 +34,11 @@ namespace Paths {
 
 
     fs::path getBear() {
-        return getUTBotRootDir() / "bear/bin/bear";
+        return getUTBotRootDir() / "bear" / "bin" / "bear";
     }
 
     fs::path getCMake() {
-        return getUTBotInstallDir() / "bin/cmake";
+        return getUTBotInstallDir() / "bin" / "cmake";
     }
 
     fs::path getMake() {
@@ -62,27 +62,27 @@ namespace Paths {
     }
 
     fs::path getLLVMnm() {
-        return getUTBotInstallDir() / "bin/llvm-nm";
+        return getUTBotInstallDir() / "bin" / "llvm-nm";
     }
 
     fs::path getGtestLibPath() {
         return getUTBotRootDir() / "gtest";
     }
 
     fs::path getAccessPrivateLibPath() {
-        return getUTBotRootDir() / "access_private/include";
+        return getUTBotRootDir() / "access_private" / "include";
     }
 
     fs::path getLLVMprofdata() {
-        return getUTBotInstallDir() / "bin/llvm-profdata";
+        return getUTBotInstallDir() / "bin" / "llvm-profdata";
     }
 
     fs::path getLLVMcov() {
-        return getUTBotInstallDir() / "bin/llvm-cov";
+        return getUTBotInstallDir() / "bin" / "llvm-cov";
     }
 
     fs::path getLLVMgold() {
-        return getUTBotInstallDir() / "lib/LLVMgold.so";
+        return getUTBotInstallDir() / "lib" / "LLVMgold.so";
     }
 
     fs::path getAr() {
@@ -98,6 +98,6 @@ namespace Paths {
     }
 
     fs::path getAsanLibraryPath() {
-        return Paths::getUTBotDebsInstallDir() / "usr/lib/gcc/x86_64-linux-gnu/9/libasan.so";
+        return Paths::getUTBotDebsInstallDir() / "usr" / "lib" / "gcc" / "x86_64-linux-gnu" / "9" / "libasan.so";
     }
 }
diff --git a/server/src/printers/DefaultMakefilePrinter.cpp b/server/src/printers/DefaultMakefilePrinter.cpp
@@ -16,10 +16,14 @@ void DefaultMakefilePrinter::declareVariable(std::string const &name, std::strin
     ss << stringFormat("%s = %s\n", name, value);
 }
 
+void DefaultMakefilePrinter::Tab() {
+    ss << "    ";
+}
+
 void DefaultMakefilePrinter::declareVariableIfNotDefined(std::string const &variableName, std::string const &ifNotDefinedValue) {
     ss << stringFormat("ifndef %s\n", variableName);
 //    ss << TAB_N();
-    ss << "    ";
+    Tab();
     declareVariable(variableName, ifNotDefinedValue);
     ss << "endif\n";
 }
diff --git a/server/src/printers/DefaultMakefilePrinter.h b/server/src/printers/DefaultMakefilePrinter.h
@@ -21,6 +21,8 @@ class DefaultMakefilePrinter : public Printer {
 
     void declareVariableIfNotDefined(std::string const &variableName, std::string const &ifNotDefinedValue);
 
+    void Tab();
+
     template<class ContainerD = std::initializer_list<std::string>,
             class ContainerA = std::initializer_list<std::string>>
     void declareTarget(std::string const &name,
diff --git a/server/src/printers/NativeMakefilePrinter.cpp b/server/src/printers/NativeMakefilePrinter.cpp
@@ -110,33 +110,49 @@ namespace printer {
           dependencyDirectory(buildDirectory / "dependencies"),
           pathToShellVariable{{buildDirectory, "$(build_dir)"},
                               {projectContext.projectPath, "$(project_dir)"},
-                              {buildDirectoryRelative, "$(build_relative)"},
-                              {Paths::getUTBotRootDir(), "$(UTBOT_ALL)"},
-                              {Paths::getGtestLibPath(), "$(gtest)"},
-                              {Paths::getAccessPrivateLibPath(), "$(access_privateLib)"},
-                              {Paths::getAsanLibraryPath(), "$(asanLib)"}
+                              {buildDirectoryRelative, "$(build_relative)"}
                               },
-          artifacts({getRelativePath(buildDirectory), getRelativePath(dependencyDirectory) }), stubSources(stubSources) {
+          priorityObjectNameByAbsolutePath{{Paths::getUTBotClangPP(), "clang++"},
+                                           {Paths::getUTBotClang(),   "clang"},
+                                           {Paths::getGcc(),          "gcc"},
+                                           {Paths::getGpp(),          "g++"},
+                                           {Paths::getGtestLibPath(), "gtest"}
+                       },
+          stubSources(stubSources) {
+
+        artifacts = {getRelativePath(buildDirectory), getRelativePath(dependencyDirectory)};
         init();
     }
 
     void NativeMakefilePrinter::init() {
-        declareVariableIfNotDefined("UTBOT_ALL", Paths::getUTBotRootDir());
+        const auto declareVariableFunc = &NativeMakefilePrinter::declareVariable;
+        const auto declareVariableIfNotDefinedFunc = &NativeMakefilePrinter::declareVariableIfNotDefined;
+        const auto declareVariableWithPriorityFunc = &NativeMakefilePrinter::declareVariableWithPriority;
 
-        declareVariable("access_privateLib", Paths::getAccessPrivateLibPath());
-        declareVariable("asanLib", Paths::getAsanLibraryPath());
+        declareShellVariable("UTBOT_ALL", Paths::getUTBotRootDir(), declareVariableFunc);
 
-        declareVariableIfNotDefined("clang", Paths::getUTBotClang());
-        declareVariableIfNotDefined("clangpp", Paths::getUTBotClangPP());
-        declareVariableIfNotDefined("gcc", Paths::getGcc());
-        declareVariableIfNotDefined("gpp", Paths::getGpp());
+        declareShellVariable("UTBOT_INSTALL", Paths::getUTBotInstallDir(), declareVariableFunc);
 
-        declareVariableIfNotDefined("ar", Paths::getAr());
-        declareVariableIfNotDefined("ld", Paths::getLd());
-        declareVariableIfNotDefined("ldGold", Paths::getLdGold());
+        declareShellVariable("access_privateLib", Paths::getAccessPrivateLibPath(), declareVariableFunc);
 
+        declareShellVariable("utbotDebsInstallDir", Paths::getUTBotDebsInstallDir(), declareVariableFunc);
 
-        declareVariableIfNotDefined("gtest", Paths::getGtestLibPath());
+        declareShellVariable("asanLib", Paths::getAsanLibraryPath(), declareVariableFunc);
+
+        declareShellVariable("clang", Paths::getUTBotClang(), declareVariableWithPriorityFunc, true);
+
+        declareShellVariable("clangPlusPlus", Paths::getUTBotClangPP(), declareVariableWithPriorityFunc, true);
+
+        declareShellVariable("gcc", Paths::getGcc(), declareVariableWithPriorityFunc, true);
+        declareShellVariable("gpp", Paths::getGpp(), declareVariableWithPriorityFunc, true);
+
+        declareShellVariable("ar", Paths::getAr(), declareVariableIfNotDefinedFunc);
+
+        declareShellVariable("ldGold", Paths::getLdGold(), declareVariableIfNotDefinedFunc);
+
+        declareShellVariable("ld", Paths::getLd(), declareVariableIfNotDefinedFunc);
+
+        declareShellVariable("gtest", Paths::getGtestLibPath(), declareVariableWithPriorityFunc, true);
 
         declareVariable("project_dir", stringFormat("%s/%s", "$(makefile_dir)", "$(project_dir_relative_to_makefile)"));
         declareVariable("build_relative", buildDirectoryRelative);
@@ -153,7 +169,7 @@ namespace printer {
 
         fs::path gtestBuildDirectory = getRelativePath(buildDirectory / "googletest");
         fs::path defaultPath = "default.c";
-        std::vector<std::string> defaultGtestCompileCommandLine{ getShellByCompiler(primaryCxxCompiler), "-c", "-std=c++11",
+        std::vector<std::string> defaultGtestCompileCommandLine{ getRelativePath(primaryCxxCompiler), "-c", "-std=c++11",
                                                             FPIC_FLAG, defaultPath };
         utbot::CompileCommand defaultGtestCompileCommand{defaultGtestCompileCommandLine,
                                                          getRelativePath(buildDirectory), defaultPath };
@@ -233,7 +249,7 @@ namespace printer {
                 CompilationUtils::getCompilerName(compileCommand.getCompiler()));
         fs::path cxxCompiler = CompilationUtils::toCppCompiler(compiler);
         auto compilerName = CompilationUtils::getCompilerName(compiler);
-        compileCommand.setCompiler(getShellByCompiler(compiler));
+        compileCommand.setCompiler(getRelativePath(compiler));
         compileCommand.setSourcePath(getRelativePath(sourcePath));
         compileCommand.setOutput(getRelativePath(output));
 
@@ -306,7 +322,7 @@ namespace printer {
     void NativeMakefilePrinter::addTestTarget(const fs::path &sourcePath) {
         auto compilationUnitInfo = buildDatabase->getClientCompilationUnitInfo(sourcePath);
         auto testCompilationCommand = compilationUnitInfo->command;
-        testCompilationCommand.setCompiler(getShellByCompiler(primaryCxxCompiler));
+        testCompilationCommand.setCompiler(getRelativePath(primaryCxxCompiler));
         testCompilationCommand.setOptimizationLevel(OPTIMIZATION_FLAG);
         testCompilationCommand.filterCFlags();
         testCompilationCommand.removeIncludeFlags();
@@ -343,7 +359,7 @@ namespace printer {
                                              getRelativePath(
                                                      sharedOutput.value()) };
         if (rootLinkUnitInfo->commands.front().isArchiveCommand()) {
-            std::vector<std::string> dynamicLinkCommandLine{getShellByLinker(cxxLinker), "$(LDFLAGS)",
+            std::vector<std::string> dynamicLinkCommandLine{getRelativePath(getLinker(cxxLinker)), "$(LDFLAGS)",
                                                             pthreadFlag, coverageLinkFlags,
                                                             sanitizerLinkFlags, "-o",
                                                             getRelativePath(
@@ -357,7 +373,7 @@ namespace printer {
                           { dynamicLinkCommand.toStringWithChangingDirectory() });
         } else {
             utbot::LinkCommand dynamicLinkCommand = rootLinkUnitInfo->commands.front();
-            dynamicLinkCommand.setLinker(cxxLinker);
+            dynamicLinkCommand.setLinker(getLinker(cxxLinker));
             dynamicLinkCommand.setOutput(testExecutablePath);
             dynamicLinkCommand.erase_if([&](std::string const &argument) {
                 return CollectionUtils::contains(rootLinkUnitInfo->files, argument) ||
@@ -390,7 +406,7 @@ namespace printer {
                             sharedOutput.value().parent_path())));
             dynamicLinkCommand.addFlagToBegin("$(LDFLAGS)");
 
-            auto linker = getShellByLinker(cxxLinker);
+            auto linker = getRelativePath(getLinker(cxxLinker));
             dynamicLinkCommand.setLinker(linker);
             dynamicLinkCommand.setOutput(
                     getRelativePath(testExecutablePath));
@@ -424,7 +440,9 @@ namespace printer {
           artifacts(baseMakefilePrinter.artifacts),
           buildResults(baseMakefilePrinter.buildResults),
           sharedOutput(baseMakefilePrinter.sharedOutput),
-          pathToShellVariable(baseMakefilePrinter.pathToShellVariable) {
+          pathToShellVariable(baseMakefilePrinter.pathToShellVariable),
+          priorityObjectNameByAbsolutePath(baseMakefilePrinter.priorityObjectNameByAbsolutePath),
+          priorityObjectByRelativePath(baseMakefilePrinter.priorityObjectByRelativePath) {
         resetStream();
         DefaultMakefilePrinter::writeCopyrightHeader();
 
@@ -565,7 +583,7 @@ namespace printer {
                 }
 
                 fs::path linker = linkCommand.getLinker();
-                linkCommand.setLinker(getShellByLinker(linker));
+                linkCommand.setLinker(getRelativePath(getLinker(linker)));
 
 
                 for (std::string& argument : linkCommand.getCommandLine()) {
@@ -597,7 +615,7 @@ namespace printer {
             auto sharedOutputRelative = getRelativePath(
                     sharedOutput.value());
             std::vector<std::string> sharedLinkCommandLine{
-                getShellByCompiler(primaryCompiler),      "$(LDFLAGS)",
+                getRelativePath(primaryCompiler),      "$(LDFLAGS)",
                 SHARED_FLAG,          coverageLinkFlags,
                 sanitizerLinkFlags,   "-o",
                 sharedOutputRelative, "-Wl,--whole-archive",
@@ -669,8 +687,16 @@ namespace printer {
     }
 
     fs::path NativeMakefilePrinter::getRelativePath(const fs::path& source) const {
-        const std::vector basePaths = {buildDirectory, projectContext.projectPath,
-                                       Paths::getGtestLibPath(), Paths::getUTBotRootDir()};
+        std::vector<std::string> basePaths = CollectionUtils::transformTo<std::vector<std::string>>(pathToShellVariable,
+                [](auto const& item) {
+            return item.first;
+        });
+        std::sort(basePaths.begin(), basePaths.end(), [](const std::string& first, const std::string& second) {
+            if (second == Paths::getUTBotRootDir().string()) {
+                return true;
+            }
+            return std::greater<>()(first, second);
+        });
 
         for (const auto& path : basePaths) {
             std::optional<fs::path> relative = Paths::getRelativePathWithShellVariable(
@@ -685,67 +711,32 @@ namespace printer {
         return source;
     }
 
-    fs::path NativeMakefilePrinter::getLinker(const fs::path& pathToLinker) const {
-        if (StringUtils::contains(pathToLinker.filename().c_str(), "clang++")) {
-            return Paths::getUTBotClangPP();
-        }
-        if (StringUtils::contains(pathToLinker.filename().c_str(), "clang")) {
-            return Paths::getUTBotClang();
-        }
-        if (StringUtils::contains(pathToLinker.filename().c_str(), "ar")) {
-            return Paths::getAr();
-        }
-        if (StringUtils::contains(pathToLinker.filename().c_str(), "ld.gold")) {
-            return Paths::getLdGold();
-        }
-        if (StringUtils::contains(pathToLinker.filename().c_str(), "ld")) {
-            return Paths::getLd();
-        }
-        if (StringUtils::contains(pathToLinker.filename().c_str(), "gcc")) {
-            return Paths::getGcc();
-        }
-        if (StringUtils::contains(pathToLinker.filename().c_str(), "g++")) {
-            return Paths::getGpp();
-        }
-    }
-
-    std::string NativeMakefilePrinter::getShellByCompiler(const fs::path& pathToCompiler) const {
-        if (StringUtils::contains(pathToCompiler.filename().c_str(), "clang++")) {
-            return "$(clangpp)";
-        }
-        if (StringUtils::contains(pathToCompiler.filename().c_str(), "clang")) {
-            return "$(clang)";
-        }
-        if (StringUtils::contains(pathToCompiler.filename().c_str(), "gcc")) {
-            return "$(gcc)";
-        }
-        if (StringUtils::contains(pathToCompiler.filename().c_str(), "g++")) {
-            return "$(gpp)";
+    void NativeMakefilePrinter::declareShellVariable(const std::string& variableName, fs::path path,
+                              void (NativeMakefilePrinter::*declareFunc) (const std::string&, const std::string&),
+                              bool isPriorityObjectDeclaration) {
+        const fs::path relativePath = getRelativePath(path);
+        if (isPriorityObjectDeclaration) {
+            priorityObjectByRelativePath[relativePath] = priorityObjectNameByAbsolutePath[path];
         }
+        (*this.*declareFunc)(variableName, relativePath.string());
+        pathToShellVariable[path] = StringUtils::stringFormat("$(%s)", variableName);
     }
 
-    std::string NativeMakefilePrinter::getShellByLinker(const fs::path& pathToLinker) const {
-        if (StringUtils::contains(pathToLinker.filename().c_str(), "clang++")) {
-            return "$(clangpp)";
-        }
-        if (StringUtils::contains(pathToLinker.filename().c_str(), "clang")) {
-            return "$(clang)";
-        }
+    fs::path NativeMakefilePrinter::getLinker(const fs::path& pathToLinker) const {
         if (StringUtils::contains(pathToLinker.filename().c_str(), "ar")) {
-            return "$(ar)";
-        }
-        if (StringUtils::contains(pathToLinker.filename().c_str(), "ld.gold")) {
-            return "$(ldGold)";
-        }
-        if (StringUtils::contains(pathToLinker.filename().c_str(), "ld")) {
-            return "$(ld)";
-        }
-        if (StringUtils::contains(pathToLinker.filename().c_str(), "gcc")) {
-            return "$(gcc)";
-        }
-        if (StringUtils::contains(pathToLinker.filename().c_str(), "g++")) {
-            return "$(gpp)";
+            return Paths::getAr();
         }
+        return pathToLinker;
     }
 
+    void NativeMakefilePrinter::declareVariableWithPriority(std::string const &variableName,
+                                                            std::string const &variablePath) {
+        ss << stringFormat("ifneq (\"$(wildcard %s)\",\"\")\n", variablePath);
+        Tab();
+        declareVariable(variableName, variablePath);
+        ss << "else\n";
+        Tab();
+        declareVariable(variableName, priorityObjectByRelativePath.at(variablePath));
+        ss << "endif\n";
+    }
 }
diff --git a/server/src/printers/NativeMakefilePrinter.h b/server/src/printers/NativeMakefilePrinter.h
diff --git a/server/src/utils/StringUtils.cpp b/server/src/utils/StringUtils.cpp
diff --git a/server/src/utils/StringUtils.h b/server/src/utils/StringUtils.h

Original file line number	Diff line number	Diff line change
`@@ -34,11 +34,11 @@ namespace Paths {`
`34`	`34`
`35`	`35`
`36`	`36`	`fs::path getBear() {`
`37`		`- return getUTBotRootDir() / "bear/bin/bear";`
	`37`	`+ return getUTBotRootDir() / "bear" / "bin" / "bear";`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`fs::path getCMake() {`
`41`		`- return getUTBotInstallDir() / "bin/cmake";`
	`41`	`+ return getUTBotInstallDir() / "bin" / "cmake";`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`fs::path getMake() {`
`@@ -62,27 +62,27 @@ namespace Paths {`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`fs::path getLLVMnm() {`
`65`		`- return getUTBotInstallDir() / "bin/llvm-nm";`
	`65`	`+ return getUTBotInstallDir() / "bin" / "llvm-nm";`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`fs::path getGtestLibPath() {`
`69`	`69`	`return getUTBotRootDir() / "gtest";`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`fs::path getAccessPrivateLibPath() {`
`73`		`- return getUTBotRootDir() / "access_private/include";`
	`73`	`+ return getUTBotRootDir() / "access_private" / "include";`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`fs::path getLLVMprofdata() {`
`77`		`- return getUTBotInstallDir() / "bin/llvm-profdata";`
	`77`	`+ return getUTBotInstallDir() / "bin" / "llvm-profdata";`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`fs::path getLLVMcov() {`
`81`		`- return getUTBotInstallDir() / "bin/llvm-cov";`
	`81`	`+ return getUTBotInstallDir() / "bin" / "llvm-cov";`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`fs::path getLLVMgold() {`
`85`		`- return getUTBotInstallDir() / "lib/LLVMgold.so";`
	`85`	`+ return getUTBotInstallDir() / "lib" / "LLVMgold.so";`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`fs::path getAr() {`
`@@ -98,6 +98,6 @@ namespace Paths {`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`fs::path getAsanLibraryPath() {`
`101`		`- return Paths::getUTBotDebsInstallDir() / "usr/lib/gcc/x86_64-linux-gnu/9/libasan.so";`
	`101`	`+ return Paths::getUTBotDebsInstallDir() / "usr" / "lib" / "gcc" / "x86_64-linux-gnu" / "9" / "libasan.so";`
`102`	`102`	`}`
`103`	`103`	`}`