[fix] Compiler path can be relative in compile_commands.json

When a compiler is given by relative path in compile_commands.json
then it should be considered as relative to the "directory" component
of the build action.

Fixes #4340

Author: bruntib

analyzer/codechecker_analyzer/buildlog/log_parser.py

@@ -646,7 +646,7 @@ def get_language(extension):
     return mapping.get(extension)
 
 
-def determine_compiler(gcc_command, is_executable_compiler_fun):
+def determine_compiler(gcc_command, cwd, is_executable_compiler_fun):
     """
     This function determines the compiler from the given compilation command.
     If the first part of the gcc_command is ccache invocation then the rest
@@ -672,12 +672,39 @@ def determine_compiler(gcc_command, is_executable_compiler_fun):
     TODO: The second case could be handled if there was a way for querying the
     used compiler from ccache. This can be configured for ccache in config
     files or environment variables.
+
+    In a compilation database the relative paths in "command" section are
+    relative to the "directory" section. This is supposed to apply to the
+    compiler itself, too:
+
+    {
+        "directory": "/my/path",
+        "command": "../compiler/gcc main.c",
+        "file": "main.c"
+    }
+
+    However, if the compiler name is provided only, then the intuition is that
+    it should be searched in PATH instead of /my/path/gcc:
+
+    {
+        "directory": "/my/path",
+        "command": "gcc main.c",
+        "file": "main.c"
+    }
+
+    If in the future we decide to consider this relative path applied to
+    "directory" section, then it can be fixed here.
     """
+    compiler = gcc_command[0]
+
     if gcc_command[0].endswith('ccache'):
         if is_executable_compiler_fun(gcc_command[1]):
-            return gcc_command[1]
+            compiler = gcc_command[1]
+
+    if not Path(compiler).is_absolute() and os.sep in compiler:
+        compiler = str((Path(cwd) / compiler).resolve())
 
-    return gcc_command[0]
+    return compiler
 
 
 def __is_not_include_fixed(dirname):
@@ -989,6 +1016,7 @@ def parse_options(compilation_db_entry,
     details['action_type'] = None
     details['compiler'] =\
         determine_compiler(gcc_command,
+                           details['directory'],
                            ImplicitCompilerInfo.is_executable_compiler)
     if '++' in os.path.basename(details['compiler']):
         details['lang'] = 'c++'

analyzer/tests/unit/test_option_parser.py

@@ -464,28 +464,59 @@ def test_compiler_toolchain(self):
     def test_ccache_compiler(self):
         compiler_action = shlex.split('ccache g++ main.cpp')
         res = log_parser.determine_compiler(compiler_action,
+                                            "",
                                             self.is_compiler_executable_fun)
         self.assertEqual(res, 'g++')
 
         compiler_action = shlex.split('ccache main.cpp')
         res = log_parser.determine_compiler(
             compiler_action,
+            "",
             self.is_compiler_executable_fun_false)
         self.assertEqual(res, 'ccache')
 
         compiler_action = shlex.split('ccache -Ihello main.cpp')
         res = log_parser.determine_compiler(
             compiler_action,
+            "",
             self.is_compiler_executable_fun_false)
         self.assertEqual(res, 'ccache')
 
         compiler_action = shlex.split('/usr/lib/ccache/g++ -Ihello main.cpp')
         res = log_parser.determine_compiler(
             compiler_action,
+            "",
             self.is_compiler_executable_fun_false)
         self.assertEqual(res,
                          '/usr/lib/ccache/g++')
 
+    def test_relative_compiler_path(self):
+        # When the compiler is provided by absolute path, it should be used
+        # directly.
+        compiler_action = shlex.split('/absolute/path/gcc main.c')
+        res = log_parser.determine_compiler(compiler_action,
+                                            '/path/to/project',
+                                            self.is_compiler_executable_fun)
+        self.assertEqual(res, '/absolute/path/gcc')
+
+        # When the compiler is provided by relative path, it should be relative
+        # to the directory section.
+        compiler_action = shlex.split('../gcc main.c')
+        res = log_parser.determine_compiler(compiler_action,
+                                            '/path/to/project',
+                                            self.is_compiler_executable_fun)
+        self.assertEqual(res, '/path/to/gcc')
+
+        # When the compiler is relative, but only the compiler name is provided
+        # then we searh it in the PATH.
+        # !!!WARNING!!! Probably this is not the official interpretation of
+        # the compilation database format.
+        compiler_action = shlex.split('gcc main.c')
+        res = log_parser.determine_compiler(compiler_action,
+                                            '/path/to/project',
+                                            self.is_compiler_executable_fun)
+        self.assertEqual(res, 'gcc')
+
     @unittest.skipUnless(
         'clang' in pathlib.Path(shutil.which('g++')).resolve().name,
         "If gcc or g++ is a symlink to clang this test should be "