[scan-build-py] Set of small fixes

[xazax.hun]

Summary

This patch fix some small errors in scan-build-py, including:

• When invoking clang with -### and parsing error add -fno-color-diagnostics to the invocation to avoid problems parsing potential errors. This might be sub-optimal for users expecting to see the results in the command line and expecting to have colors. If we really want this to work I can either make the regex more forgiving or try to restore the -fcolor-diagnosticsflag to its original state after the -### invocation.
• If a file was missing from a compilation database the whole analysis was stopped due to an unhandled exception.
• Fix two typos: analyzis -> analysis

[xazax.hun]

Sorry, there was a brain hiccup on my side. We just do not generate HTMLs for every translation units (which is the case for plists).

[phosek]

LGTM

clang/tools/scan-build-py/libscanbuild/clang.py

47

Alternative would be to set TERM=dumb environment variable which disables color support as well, but this also works.

[xazax.hun]

clang/tools/scan-build-py/libscanbuild/clang.py

47

Thanks! I'd love to have another solution, but it looks like the command line takes precedence over the environment variables and if -fcolor-diagnostics is specified in the command line it will always turn the colors on.

[xazax.hun]

So after investigating the effects of this patch, the result is the following:

Verbose mode (-v) that also prints findings to the command line will no longer be colored after the patch. If we do not want this regression there are two easy ways around it:

1. Make the parsing of error more forgiving
2. Make two -### invocation, one for parsing the potential error and the other for actually getting the arguments.

Any preferences?

[NoQ]

In D70693#1762137, @xazax.hun wrote:

So after investigating the effects of this patch, the result is the following:

Verbose mode (-v) that also prints findings to the command line will no longer be colored after the patch.

These warning printouts are fairly useless anyway, users still need to read the html reports, so I don't care all that much. Thanks for cleaning this up!

clang/tools/scan-build-py/libscanbuild/analyze.py

 from libscanbuild import command_entry_point, compiler_wrapper, \
     wrapper_environment, run_build, run_command, CtuConfig
 from libscanbuild.arguments import parse_args_for_scan_build, \
     parse_args_for_analyze_build
 from libscanbuild.intercept import capture
 from libscanbuild.report import document
 from libscanbuild.compilation import split_command, classify_source, \
     compiler_language
-from libscanbuild.clang import get_version, get_arguments, get_triple_arch
+from libscanbuild.clang import get_version, get_arguments, get_triple_arch, \
+    ClangErrorException
 from libscanbuild.shell import decode
 
 __all__ = ['scan_build', 'analyze_build', 'analyze_compiler_wrapper']
 
 COMPILER_WRAPPER_CC = 'analyze-cc'
 COMPILER_WRAPPER_CXX = 'analyze-c++'
 
 CTU_EXTDEF_MAP_FILENAME = 'externalDefMap.txt'
@require(['command',  # entry from compilation database
           'output_format',  # it's 'plist', 'html', both or plist-multi-file
           'output_failures',  # generate crash reports or not
           'ctu'])  # ctu control options
 def run(opts):
     """ Entry point to run (or not) static analyzer against a single entry
     of the compilation database.
 
     This complex task is decomposed into smaller methods which are calling
-    each other in chain. If the analyzis is not possible the given method
+    each other in chain. If the analysis is not possible the given method
     just return and break the chain.
 
     The passed parameter is a python dictionary. Each method first check
     that the needed parameters received. (This is done by the 'require'
     decorator. It's like an 'assert' to check the contract between the
     caller and the called method.) """
 
     try:
         command = opts.pop('command')
         command = command if isinstance(command, list) else decode(command)
         logging.debug("Run analyzer against '%s'", command)
         opts.update(classify_parameters(command))
 
         return arch_check(opts)
     except Exception:
-        logging.error("Problem occurred during analyzis.", exc_info=1)
+        logging.error("Problem occurred during analysis.", exc_info=1)
         return None
 
 
 @require(['clang', 'directory', 'flags', 'file', 'output_dir', 'language',
           'error_output', 'exit_code'])
 def report_failure(opts):
     """ Create report when analyzer failed.
 
def report_failure(opts):
     # Create preprocessor output file name. (This is blindly following the
     # Perl implementation.)
     (handle, name) = tempfile.mkstemp(suffix=extension(),
                                       prefix='clang_' + error + '_',
                                       dir=destination())
     os.close(handle)
     # Execute Clang again, but run the syntax check only.
     cwd = opts['directory']
-    cmd = get_arguments(
-        [opts['clang'], '-fsyntax-only', '-E'
-         ] + opts['flags'] + [opts['file'], '-o', name], cwd)
+    cmd = [opts['clang'], '-fsyntax-only', '-E'] + opts['flags'] + \
+        [opts['file'], '-o', name]
+    try:
+        cmd = get_arguments(cmd, cwd)
         run_command(cmd, cwd=cwd)
+    except subprocess.CalledProcessError:
+        pass
+    except ClangErrorException:
+        pass
     # write general information about the crash
     with open(name + '.info.txt', 'w') as handle:
         handle.write(opts['file'] + os.linesep)
         handle.write(error.title().replace('_', ' ') + os.linesep)
         handle.write(' '.join(cmd) + os.linesep)
         handle.write(' '.join(os.uname()) + os.linesep)
         handle.write(get_version(opts['clang']))
         handle.close()
try:
         output = run_command(cmd, cwd=cwd)
         return {'error_output': output, 'exit_code': 0}
     except subprocess.CalledProcessError as ex:
         result = {'error_output': ex.output, 'exit_code': ex.returncode}
         if opts.get('output_failures', False):
             opts.update(result)
             continuation(opts)
         return result
+    except ClangErrorException as ex:
+        result = {'error_output': ex.error, 'exit_code': 0}
+        if opts.get('output_failures', False):
+            opts.update(result)
+            continuation(opts)
+        return result
 
 
 def extdef_map_list_src_to_ast(extdef_src_list):
     """ Turns textual external definition map list with source files into an
     external definition map list with ast files. """
 
     extdef_ast_list = []
     for extdef_src_txt in extdef_src_list:

clang/tools/scan-build-py/libscanbuild/clang.py

 
 __all__ = ['get_version', 'get_arguments', 'get_checkers', 'is_ctu_capable',
            'get_triple_arch']
 
 # regex for activated checker
 ACTIVE_CHECKER_PATTERN = re.compile(r'^-analyzer-checker=(.*)$')
 
 
+class ClangErrorException(Exception):
+    def __init__(self, error):
+        self.error = error
+
+
 def get_version(clang):
     """ Returns the compiler version as string.
 
     :param clang:   the compiler we are using
     :return:        the version string printed to stderr """
 
     output = run_command([clang, '-v'])
     # the relevant version info is in the first line
     return output[0]
 
 
 def get_arguments(command, cwd):
     """ Capture Clang invocation.
 
     :param command: the compilation command
     :param cwd:     the current working directory
     :return:        the detailed front-end invocation command """
 
     cmd = command[:]
     cmd.insert(1, '-###')
+    cmd.append('-fno-color-diagnostics')
 
     output = run_command(cmd, cwd=cwd)
     # The relevant information is in the last line of the output.
     # Don't check if finding last line fails, would throw exception anyway.
     last_line = output[-1]
     if re.search(r'clang(.*): error:', last_line):
-        raise Exception(last_line)
+        raise ClangErrorException(last_line)
     return decode(last_line)
 
 
 def get_active_checkers(clang, plugins):
     """ Get the active checker list.
 
     :param clang:   the compiler we are using
     :param plugins: list of plugins which was requested by the user