infer_clone/infer/lib/python/infer

#!/usr/bin/env python2.7

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals

import argparse
import imp
import json
import logging
import os
import platform
import sys

import inferlib
from inferlib import analyze, config, utils


CAPTURE_PACKAGE = 'capture'

# token that identifies the end of the options for infer and the beginning
# of the compilation command
CMD_MARKER = '--'

# insert here the correspondence between module name and the list of
# compiler/build-systems it handles.
# All supported commands should be listed here
MODULE_TO_COMMAND = {
    'ant': ['ant'],
    'analyze': ['analyze'],
    'buck': ['buck'],
    'gradle': ['gradle', 'gradlew'],
    'javac': ['javac'],
    'make': ['make', 'clang', 'clang++', 'cc', 'gcc', 'g++'],
    'xcodebuild': ['xcodebuild'],
    'mvn': ['mvn']
}

def get_commands():
    """Return all commands that are supported."""
    #flatten and dedup the list of commands
    return set(sum(MODULE_TO_COMMAND.values(), []))


def get_module_name(command):
    """ Return module that is able to handle the command. None if
    there is no such module."""
    for module, commands in MODULE_TO_COMMAND.iteritems():
        if command in commands:
            return module
    return None


def load_module(mod_name):
    pkg_info = imp.find_module(CAPTURE_PACKAGE, inferlib.__path__)
    imported_pkg = imp.load_module(CAPTURE_PACKAGE, *pkg_info)
    # load the requested module (e.g. make)
    mod_file, mod_path, mod_descr = \
        imp.find_module(mod_name, imported_pkg.__path__)
    try:
        return imp.load_module(
            '{pkg}.{mod}'.format(pkg=imported_pkg.__name__, mod=mod_name),
            mod_file, mod_path, mod_descr)
    finally:
        if mod_file:
            mod_file.close()


def split_args_to_parse():
    dd_index = \
        sys.argv.index(CMD_MARKER) if CMD_MARKER in sys.argv else len(sys.argv)
    cmd_raw = sys.argv[dd_index + 1:]
    return (map(utils.decode, sys.argv[1:dd_index]),
            map(utils.decode, cmd_raw))


def create_argparser(parents=[]):
    parser = argparse.ArgumentParser(
        parents=[analyze.infer_parser] + parents,
        add_help=False,
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    group = parser.add_argument_group(
        'supported compiler/build-system commands')

    supported_commands = ', '.join(get_commands())
    group.add_argument(
        CMD_MARKER,
        metavar='<cmd>',
        dest='nullarg',
        default=None,
        help=('Command to run the compiler/build-system. '
              'Supported build commands (run `infer --help -- <cmd_name>` for '
              'extra help, e.g. `infer --help -- javac`): ' + supported_commands),
    )
    return parser


def main():
    to_parse, cmd = split_args_to_parse()
    # get the module name (if any), then load it
    capture_module_name = os.path.basename(cmd[0]) if len(cmd) > 0 else None
    mod_name = get_module_name(capture_module_name)
    imported_module = None
    if mod_name:
        # There is module that supports the command
        imported_module = load_module(mod_name)

    # get the module's argparser and merge it with the global argparser
    module_argparser = []
    if imported_module:
        module_argparser.append(
            imported_module.create_argparser(capture_module_name)
        )
    global_argparser = create_argparser(module_argparser)

    args = global_argparser.parse_args(to_parse)

    remove_infer_out = (imported_module
                        and not args.reactive
                        and capture_module_name != 'analyze'
                        and not args.buck)
    if remove_infer_out:
        analyze.remove_infer_out(args.infer_out)

    if imported_module:
        analyze.create_results_dir(args.infer_out)
        if not args.continue_capture:
            analyze.reset_start_file(args.infer_out)

        utils.configure_logging(args)
        logging.info('Running command %s', ' '.join(sys.argv))
        logging.info('Path to infer script %s (%s)', __file__,
                 os.path.realpath(__file__))
        logging.info(analyze.get_infer_version())
        logging.info('Platform: %s', platform.platform())
        logging.info('PATH=%s', os.getenv('PATH'))
        logging.info('SHELL=%s', os.getenv('SHELL'))
        logging.info('PWD=%s', os.getenv('PWD'))

        capture_exitcode = imported_module.gen_instance(args, cmd).capture()
        if capture_exitcode != os.EX_OK:
            logging.error('Error during capture phase, exiting')
            exit(capture_exitcode)
        logging.info('Capture phase was successful')
    elif capture_module_name is not None:
        # There was a command, but it's not supported
        utils.stdout('Command "{cmd}" not recognised'
                     .format(cmd='' if capture_module_name is None
                             else capture_module_name))
        global_argparser.print_help()
        sys.exit(1)
    else:
        global_argparser.print_help()
        sys.exit(os.EX_OK)

    if not (mod_name == 'buck' or mod_name == 'javac'):
        # Something should be already captured, otherwise analysis would fail
        if not os.path.exists(os.path.join(args.infer_out, 'captured')):
            print('There was nothing to analyze, exiting')
            exit(os.EX_USAGE)
        analysis = analyze.AnalyzerWrapper(args)
        analysis.analyze_and_report()
        analysis.save_stats()

    if args.fail_on_bug:
        bugs_filename = os.path.join(args.infer_out,
                                     config.JSON_REPORT_FILENAME)
        try:
            bugs = utils.load_json_from_path(bugs_filename)
            if len(bugs) > 0:
                sys.exit(config.BUG_FOUND_ERROR_CODE)
        except OSError:
            pass

if __name__ == '__main__':
    main()