[NFC] Clean up analyzer version info getter

The version of analyzer binaries can be fetched by `get_binary_version()` function.
ClangSA plugin had an extra `version_info()` that returned the version number among some further info in another format. This function is now eliminated.

In `log_parser` module it is checked whether the same clang version is used for analysis and the original build. The compiler path was checked by `clang --version` that contains this info. Now we use the clang binary path itself.

Author: bruntib

analyzer/codechecker_analyzer/analyzer.py

@@ -282,7 +282,7 @@ def perform_analysis(args, skip_handlers, filter_handlers,
 
         version = analyzer_types.supported_analyzers[analyzer] \
             .get_binary_version()
-        metadata_info['analyzer_statistics']['version'] = version
+        metadata_info['analyzer_statistics']['version'] = str(version)
 
         metadata_tool['analyzers'][analyzer] = metadata_info
     LOG.info("Enabled checker list can be found in %s",

analyzer/codechecker_analyzer/analyzers/analyzer_base.py

@@ -12,6 +12,7 @@
 
 from abc import ABCMeta, abstractmethod
 import os
+from semver.version import Version
 import signal
 import subprocess
 import sys
@@ -72,12 +73,10 @@ def resolve_missing_binary(cls, configured_binary, environ):
 
     @classmethod
     @abstractmethod
-    def get_binary_version(cls, details=False) -> str:
+    def get_binary_version(cls) -> Optional[Version]:
         """
         Return the version number of the binary that CodeChecker found, even
-        if its incompatible. If details is true, additional version information
-        is provided. If details is false, the return value should be
-        convertible to a distutils.version.StrictVersion type.
+        if it's incompatible.
         """
         raise NotImplementedError("Subclasses should implement this!")
 

analyzer/codechecker_analyzer/analyzers/clangsa/analyzer.py

@@ -15,7 +15,9 @@
 import re
 import subprocess
 import sys
-from typing import List, Tuple
+from typing import List, Optional, Tuple
+
+from semver.version import Version
 
 from codechecker_common import util
 from codechecker_common.logger import get_logger
@@ -33,7 +35,6 @@
 
 from . import config_handler
 from . import ctu_triple_arch
-from . import version
 from .result_handler import ClangSAResultHandler
 
 LOG = get_logger('analyzer')
@@ -186,36 +187,30 @@ def __add_plugin_load_flags(cls, analyzer_cmd: List[str]):
             analyzer_cmd.extend(["-load", plugin])
 
     @classmethod
-    def get_binary_version(cls, details=False) -> str:
+    def get_binary_version(cls) -> Optional[Version]:
         # No need to LOG here, we will emit a warning later anyway.
         if not cls.analyzer_binary():
             return None
 
         environ = analyzer_context.get_context().get_env_for_bin(
             cls.analyzer_binary())
 
-        if details:
-            ver = [cls.analyzer_binary(), '--version']
-        else:
-            ver = [cls.analyzer_binary(), '-dumpversion']
+        version = [cls.analyzer_binary(), '-dumpversion']
+
         try:
-            output = subprocess.check_output(ver,
+            output = subprocess.check_output(version,
                                              env=environ,
                                              universal_newlines=True,
                                              encoding="utf-8",
                                              errors="ignore")
-            return output.strip()
+            return Version.parse(output.strip())
         except (subprocess.CalledProcessError, OSError) as oerr:
             LOG.warning("Failed to get analyzer version: %s",
-                        ' '.join(ver))
+                        ' '.join(version))
             LOG.warning(oerr)
 
         return None
 
-    @classmethod
-    def version_info(cls):
-        return version.get(cls.analyzer_binary())
-
     @classmethod
     def ctu_mapping(cls):
         """Clang version dependent ctu mapping tool path and mapping file name.
@@ -227,8 +222,8 @@ def ctu_mapping(cls):
         default the shorter name is looked up, then if it is not found the
         postfixed.
         """
-        clang_version_info = cls.version_info()
-        if not clang_version_info:
+        clang_version = cls.get_binary_version()
+        if not clang_version:
             LOG.debug(
                 "No clang version information. "
                 "Can not detect ctu mapping tool.")
@@ -240,9 +235,7 @@ def ctu_mapping(cls):
         new_mapping_tool_name = 'clang-extdef-mapping'
         new_mapping_file_name = 'externalDefMap.txt'
 
-        major_version = clang_version_info.major_version
-
-        if major_version > 7:
+        if clang_version.major > 7:
             tool_name = new_mapping_tool_name
             mapping_file = new_mapping_file_name
         else:
@@ -261,7 +254,7 @@ def ctu_mapping(cls):
             "filename...", tool_path, installed_dir)
 
         postfixed_tool_path = ''.join(
-            [str(tool_path), '-', str(major_version)])
+            [str(tool_path), '-', str(clang_version.major)])
 
         if os.path.isfile(postfixed_tool_path):
             return postfixed_tool_path, mapping_file
@@ -378,12 +371,18 @@ def get_analyzer_checkers(
         # The new checker help printig flags are not available there yet.
         # If the OSX clang will be updated to based on clang v8
         # this early return can be removed.
-        version_info = cls.version_info()
-        if version_info and version_info.vendor == "clang":
-            if alpha and version_info.major_version >= 9:
+        version_info = cls.get_binary_version()
+        if version_info:
+            try:
+                help_page = clang_command_output([
+                    cls.analyzer_binary(), "-cc1", "--help"])
+            except (subprocess.CalledProcessError, OSError):
+                help_page = ""
+
+            if alpha and "-analyzer-checker-help-alpha" in help_page:
                 command.append("-analyzer-checker-help-alpha")
 
-            if debug and version_info.major_version >= 9:
+            if debug and "-analyzer-checker-help-developer" in help_page:
                 command.append("-analyzer-checker-help-developer")
 
         return parse_clang_help_page(command, 'CHECKERS:')
@@ -402,12 +401,18 @@ def get_checker_config(cls) -> List[analyzer_base.CheckerConfig]:
 
         command.append("-analyzer-checker-option-help")
 
-        version_info = ClangSA.version_info()
-        if version_info.vendor == "clang":
-            if version_info.major_version >= 9:
+        version_info = cls.get_binary_version()
+        if version_info:
+            try:
+                help_page = clang_command_output([
+                    cls.analyzer_binary(), "-cc1", "--help"])
+            except (subprocess.CalledProcessError, OSError):
+                help_page = ""
+
+            if "-analyzer-checker-option-help-alpha" in help_page:
                 command.append("-analyzer-checker-option-help-alpha")
 
-            if version_info.major_version >= 9:
+            if "-analyzer-checker-option-help-developer" in help_page:
                 command.append("-analyzer-checker-option-help-developer")
 
         result = []
@@ -534,8 +539,8 @@ def construct_analyzer_cmd(self, result_handler):
                                      '-analyzer-checker=' +
                                      ','.join(enabled_checkers)])
             # Enable aggressive-binary-operation-simplification option.
-            version_info = ClangSA.version_info()
-            if version_info and version_info.major_version >= 8:
+            version_info = ClangSA.get_binary_version()
+            if version_info and version_info.major >= 8:
                 analyzer_cmd.extend([
                     '-Xclang',
                     '-analyzer-config',

analyzer/codechecker_analyzer/analyzers/clangsa/version.py

@@ -15,10 +15,11 @@
 import os
 from pathlib import Path
 import re
+from semver.version import Version
 import shutil
 import subprocess
 import sys
-from typing import Iterable, List, Set, Tuple
+from typing import Iterable, List, Optional, Set, Tuple
 
 import yaml
 
@@ -155,12 +156,9 @@ def get_diagtool_bin():
 
     # Sometimes diagtool binary has a version number in its name: diagtool-14.
     version = ClangTidy.get_binary_version()
-    if version:
-        version = version.split('.')[0]
 
-    diagtool_bin = diagtool_bin.with_name(f'diagtool-{version}')
-
-    if diagtool_bin.exists():
+    if version and \
+            diagtool_bin.with_name(f'diagtool-{version.major}').exists():
         return diagtool_bin
 
     LOG.warning(
@@ -238,17 +236,6 @@ def need_asterisk(checker: str) -> bool:
     return result
 
 
-def parse_version(tidy_output):
-    """
-    Parse clang-tidy version output and return the version number.
-    """
-    version_re = re.compile(r'.*version (?P<version>[\d\.]+)', re.S)
-    match = version_re.match(tidy_output)
-    if match:
-        return match.group('version')
-    return None
-
-
 class ClangTidy(analyzer_base.SourceAnalyzer):
     """
     Constructs the clang tidy analyzer commands.
@@ -279,7 +266,7 @@ def analyzer_binary(cls):
             .analyzer_binaries[cls.ANALYZER_NAME]
 
     @classmethod
-    def get_binary_version(cls, details=False) -> str:
+    def get_binary_version(cls) -> Optional[Version]:
         if not cls.analyzer_binary():
             return None
         # No need to LOG here, we will emit a warning later anyway.
@@ -293,9 +280,10 @@ def get_binary_version(cls, details=False) -> str:
                                              universal_newlines=True,
                                              encoding="utf-8",
                                              errors="ignore")
-            if details:
-                return output.strip()
-            return parse_version(output)
+            version_re = re.compile(r'.*version (?P<version>[\d\.]+)', re.S)
+            match = version_re.match(output)
+            if match:
+                return Version.parse(match.group('version'))
         except (subprocess.CalledProcessError, OSError) as oerr:
             LOG.warning("Failed to get analyzer version: %s",
                         ' '.join(version))

analyzer/codechecker_analyzer/analyzers/clangtidy/analyzer.py

@@ -11,11 +11,11 @@
 
 from collections import defaultdict
 import sys
-from typing import List
-from packaging.version import Version
+from typing import List, Optional
 from pathlib import Path
 import os
 import re
+from semver.version import Version
 import shutil
 import subprocess
 import xml.etree.ElementTree as ET
@@ -60,14 +60,14 @@ def parse_checkers(cppcheck_output):
     return checkers
 
 
-def parse_version(cppcheck_output):
+def parse_version(cppcheck_output) -> Optional[Version]:
     """
     Parse cppcheck version output and return the version number.
     """
     version_re = re.compile(r'^Cppcheck(.*?)(?P<version>[\d\.]+)')
     match = version_re.match(cppcheck_output)
     if match:
-        return match.group('version')
+        return Version.parse(match.group('version'))
     return None
 
 
@@ -84,7 +84,7 @@ def analyzer_binary(cls):
             .analyzer_binaries[cls.ANALYZER_NAME]
 
     @classmethod
-    def get_binary_version(cls, details=False) -> str:
+    def get_binary_version(cls) -> Optional[Version]:
         """ Get analyzer version information. """
         # No need to LOG here, we will emit a warning later anyway.
         if not cls.analyzer_binary():
@@ -98,8 +98,6 @@ def get_binary_version(cls, details=False) -> str:
                                              universal_newlines=True,
                                              encoding="utf-8",
                                              errors="ignore")
-            if details:
-                return output.strip()
             return parse_version(output)
         except (subprocess.CalledProcessError, OSError) as oerr:
             LOG.warning("Failed to get analyzer version: %s",
@@ -390,7 +388,7 @@ def is_binary_version_incompatible(cls):
 
         # The analyzer version should be above 1.80 because '--plist-output'
         # argument was introduced in this release.
-        if Version(analyzer_version) >= Version("1.80"):
+        if analyzer_version and analyzer_version >= Version(1, 80):
             return None
 
         return "CppCheck binary found is too old at " \