Tools/Scripts/generate-dirty-files

#!/usr/bin/env python3
# Copyright (C) 2024 Apple Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1.  Redistributions of source code must retain the above copyright
#     notice, this list of conditions and the following disclaimer.
# 2.  Redistributions in binary form must reproduce the above copyright
#     notice, this list of conditions and the following disclaimer in the
#     documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

import os
import subprocess
import argparse
import json
import sys
import re

from webkitpy.safer_cpp.checkers import Checker

DERIVED_SOURCES_RE = r'(^|.*\/)DerivedSources\/WebCore\/JS.*'


def parser():
    parser = argparse.ArgumentParser(description='Generates files listing new regressions and files per checker type')
    parser.add_argument(
        'results_dir',
        help='Path to directory of results to parse'
    )
    parser.add_argument(
        '--output-dir',
        dest='output_dir',
        help='Path to output directory for generated files',
        default='smart-pointer-result-archive'
    )
    parser.add_argument(
        '--build-dir',
        dest='build_dir',
        help='Path to build directory, used to standardize file paths',
        required=True
    )

    return parser.parse_args()


def parse_results_file(args, file_path):
    bug_type, bug_file, issue_hash, bug_line = None, None, None, None
    with open(file_path, 'r') as f:
        while True:
            lines = f.readlines(250)
            if not lines:
                break
            for line in lines:
                if 'BUGFILE' in line:
                    bug_file = line.removeprefix('<!-- BUGFILE ')
                    bug_file = bug_file.removesuffix(' -->\n')
                    bug_file = bug_file.removeprefix(f'{args.build_dir}/')
                    bug_file = bug_file.removeprefix('WebKitBuild/Release/')
                    bug_file = bug_file.removeprefix('WebKitBuild/Release-iphonesimulator/')
                if 'ISSUEHASHCONTENTOFLINEINCONTEXT' in line:
                    issue_hash = line.removeprefix('<!-- ISSUEHASHCONTENTOFLINEINCONTEXT ')
                    issue_hash = issue_hash.removesuffix(' -->\n')
                if 'BUGTYPE' in line:
                    bug_type = line.removeprefix('<!-- BUGTYPE ')
                    bug_type = bug_type.removesuffix(' -->\n')
                if 'BUGLINE' in line:
                    bug_line = line.removeprefix('<!-- BUGLINE ')
                    bug_line = bug_line.removesuffix(' -->\n')
                if bug_file and issue_hash and bug_type and bug_line:
                    return bug_file, issue_hash, bug_type, bug_line
    return None, None, None, None


def find_project_results(args, project, file_list, results_data, issue_to_report):
    bug_counts = {}
    files_per_project = {checker.name(): set() for checker in Checker.enumerate()}

    for result_file in file_list:
        file_name, issue_hash, bug_type, _ = parse_results_file(args, result_file)
        if not file_name:
            continue

        if bug_type not in bug_counts:
            bug_counts[bug_type] = 0
        bug_counts[bug_type] += 1

        if f'{project.lower()}/' not in file_name.lower():
            # Ignore WebKitBuild/Debug files that are included from other projects
            continue
        elif not re.match(DERIVED_SOURCES_RE, file_name):
            # Truncate path after project name to match the expectations file
            file_name = file_name.split(f'{project}/')[-1]
            file_name = file_name.removeprefix('./')

        # Map filename to issues for each bug type
        checker = Checker.find_checker_by_description(bug_type)
        checker_name = checker.name()
        file_dict = results_data.get(checker_name, {})
        if not file_name in file_dict:
            file_dict[file_name] = {}

        # Map issue to its report path
        if not issue_hash in file_dict[file_name]:
            file_dict[file_name][issue_hash] = result_file
        results_data[checker_name] = file_dict

        # Add direct mapping from issue hash to report path
        if not checker_name in issue_to_report.keys():
            issue_to_report[checker_name] = {}
        issue_to_report[checker_name][issue_hash] = result_file

        output_file_name = os.path.abspath(f'{args.output_dir}/{project}/{checker_name}Issues')
        with open(output_file_name, 'a') as f:
            f.write(f'{issue_hash}\n')

        # Map checker to all files with bugs of that type
        files_per_project[checker_name].add(file_name)

    for checker in Checker.enumerate():
        checker_name = checker.name()
        output_file_name_2 = os.path.abspath(f'{args.output_dir}/{project}/{checker_name}Files')
        with open(output_file_name_2, 'a') as f:
            f.write('\n'.join(sorted(files_per_project[checker_name])))

    for type, count in bug_counts.items():
        print(f'    {type}: {count}')
    return results_data


def find_all_results(args):
    file_list = []
    results_data = {}
    result_counts = {}
    issue_to_report = {}

    for project in Checker.projects():
        print('\n')
        subprocess.run(['mkdir', os.path.abspath(f'{args.output_dir}/{project}')])
        path = os.path.abspath(os.path.join(args.results_dir, 'StaticAnalyzer', project))
        command = 'find {} -name report\\*.html -print'.format(path)
        try:
            result_files = subprocess.check_output(command, shell=True, text=True)
        except subprocess.CalledProcessError as e:
            sys.stderr.write(f'{e.output}')
            sys.stderr.write(f'No results for {project}\n')
            continue
        project_files = result_files.splitlines()
        file_list.extend(project_files)
        result_counts[project] = len(project_files)

        print(f'\n------ {project} ------\n')
        print(f'TOTAL ISSUES: {len(project_files)}')
        find_project_results(args, project, project_files, results_data, issue_to_report)

    print("\nWriting results files...")
    # Checker -> File -> Issue -> Report
    results_data_file = os.path.abspath(f'{args.output_dir}/issues_per_file.json')
    with open(results_data_file, "w") as f:
        results_data_obj = json.dumps(results_data, indent=4)
        f.write(results_data_obj)
    # Checker -> Issue -> Report
    issue_to_report_file = os.path.abspath(f'{args.output_dir}/issue_to_report.json')
    with open(issue_to_report_file, "w") as f:
        f.write(json.dumps(issue_to_report, indent=4))
    print(f'Done! Find them in {os.path.abspath(args.output_dir)}\n')

    results_msg = f'Total ({sum([c for c in result_counts.values()])}) '
    for proj, count in result_counts.items():
        results_msg += f'{proj} ({count}) '
    print(results_msg)


def main():
    args = parser()
    try:
        subprocess.run(['mkdir', '-p', args.output_dir])
    except subprocess.CalledProcessError as e:
        sys.stderr.write(f'{e.output}\n')

    if args.results_dir:
        find_all_results(args)


if __name__ == '__main__':
    main()