Add detecting real compiler type from symlink like cc (#592)

Author: ladisgin

server/CMakeLists.txt

@@ -114,6 +114,7 @@ file(GLOB ALL_SOURCES
         "${PROJECT_SOURCE_DIR}/src/streams/tests/*"
         "${PROJECT_SOURCE_DIR}/src/testgens/*"
         "${PROJECT_SOURCE_DIR}/src/utils/*"
+        "${PROJECT_SOURCE_DIR}/src/utils/path/*"
         "${PROJECT_SOURCE_DIR}/src/utils/stats/*"
         "${PROJECT_SOURCE_DIR}/src/stubs/*"
         "${PROJECT_SOURCE_DIR}/src/visitors/*"

server/src/Paths.cpp

@@ -416,12 +416,12 @@ namespace Paths {
         return removeSuffix(sourceFilePath, STUB_SUFFIX);
     }
 
+    //endregion
+
     bool isHeadersEqual(const fs::path &srcPath, const fs::path &headerPath) {
         return removeSuffix(srcPath, STUB_SUFFIX).stem() == headerPath.stem();
     }
 
-    //endregion
-
     const std::vector<std::string> CXXFileExtensions({".cc", ".cp", ".cpp", ".c++", ".cxx"});
     const std::vector<std::string> HPPFileExtensions({".hh", ".hpp", ".hxx"});
     const std::vector<std::string> CFileSourceExtensions({".c"});

server/src/utils/CompilationUtils.cpp

@@ -25,21 +25,33 @@ namespace CompilationUtils {
         return compilationDatabase;
     }
 
-    CompilerName getCompilerName(const fs::path &compilerPath) {
-        auto compiler = compilerPath.filename().string();
-        if (StringUtils::contains(compiler, CLANGXX_PATH)) {
-            return CompilerName::CLANGXX;
-        }
-        if (StringUtils::contains(compiler, CLANG_PATH)) {
-            return CompilerName::CLANG;
-        }
-        if (StringUtils::contains(compiler, GXX_PATH_PATTERN)) {
-            return CompilerName::GXX;
-        }
-        if (StringUtils::contains(compiler, GCC_PATH_PATTERN)) {
-            return CompilerName::GCC;
+    CompilerName getCompilerName(fs::path compilerPath) {
+        CompilerName compilerName = CompilerName::UNKNOWN;
+        while (compilerName == CompilerName::UNKNOWN) {
+            std::string compiler = compilerPath.filename().string();
+            if (StringUtils::contains(compiler, CLANGXX_PATH)) {
+                return CompilerName::CLANGXX;
+            }
+            if (StringUtils::contains(compiler, CLANG_PATH)) {
+                return CompilerName::CLANG;
+            }
+            if (StringUtils::contains(compiler, GXX_PATH_PATTERN)) {
+                return CompilerName::GXX;
+            }
+            if (StringUtils::contains(compiler, GCC_PATH_PATTERN)) {
+                return CompilerName::GCC;
+            }
+            compilerPath = fs::findInPATH(compilerPath);
+            if (fs::is_symlink(compilerPath)) {
+                std::error_code ec;
+                compilerPath = fs::read_symlink(compilerPath, ec);
+                if (!ec) {
+                    continue;
+                }
+            }
+            break;
         }
-        return CompilerName::UNKNOWN;
+        return compilerName;
     }
 
     std::string getBuildDirectoryName(CompilerName compilerName) {

server/src/utils/CompilationUtils.h

@@ -38,7 +38,7 @@ namespace CompilationUtils {
     std::shared_ptr<CompilationDatabase>
     getCompilationDatabase(const fs::path &buildCommandsJsonPath);
 
-    CompilerName getCompilerName(fs::path const &compilerPath);
+    CompilerName getCompilerName(fs::path compilerPath);
 
     fs::path substituteRemotePathToCompileCommandsJsonPath(const utbot::ProjectContext &projectContext);
 

server/src/utils/path/FileSystemPath.cpp

@@ -0,0 +1,18 @@
+#include "FileSystemPath.h"
+#include "utils/StringUtils.h"
+
+namespace fs {
+    path findInPATH(const path &p) {
+        if (is_absolute(p)) {
+            return p;
+        }
+        std::vector<std::string> pathENV = StringUtils::split(std::getenv("PATH"), ':');
+        for (const std::string &pathFind: pathENV) {
+            path fullPath = path(pathFind) / p;
+            if (exists(fullPath)) {
+                return fullPath;
+            }
+        }
+        return p;
+    }
+}

server/src/utils/path/FileSystemPath.h

@@ -152,6 +152,9 @@ namespace fs {
         friend bool exists( const path& p );
         friend bool is_empty( const path& p );
         friend bool is_directory( const path& p );
+        friend bool is_symlink( const path& p );
+        friend bool is_absolute( const path& p );
+        friend path read_symlink( const path& p, std::error_code& ec);
         friend path relative( const path& p, const path& base);
         friend path canonical( const path& p );
         friend path weakly_canonical( const path& p );
@@ -258,6 +261,20 @@ namespace fs {
         return is_directory(p.path_);
     }
 
+    inline bool is_symlink(const path &p) {
+        return is_symlink(p.path_);
+    }
+
+    inline bool is_absolute(const path &p) {
+        return p.path_.is_absolute();
+    }
+
+    inline path read_symlink(const path &p, std::error_code &ec) {
+        return read_symlink(p.path_, ec);
+    }
+
+    path findInPATH(const path &p);
+
     inline path relative( const path& p, const path& base) {
         return path(relative(p.path_, base.path_));
     }