| #!/usr/bin/env python3 |
| # Copyright 2022 The Chromium Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """ |
| Updates BUILD.gn files to add missing direct dependencies when the |
| transitive dependency already exists. |
| The script is intentionally conservative and will not work in many |
| scenarios (e.g it does not handle target names with variables). These |
| cases will require manual roll (as today). |
| """ |
| |
| import argparse |
| from collections import defaultdict |
| import os |
| import re |
| import subprocess |
| import sys |
| |
| # The output of gn check when some direct dependencies are missing is expected |
| # to contain these lines. |
| TRANSITIVE_PATTERNS = [ |
| (3, "The target:"), (5, "is including a file from the target:"), |
| (8, "It's usually best to depend directly on the destination target."), |
| (9, "In some cases, the destination target is considered a subcomponent"), |
| (10, "of an intermediate target. In this case, the intermediate target"), |
| (11, "should depend publicly on the destination to forward the ability"), |
| (12, "to include headers."), |
| (14, "Dependency chain (there may also be others):") |
| ] |
| # The line containing the target in the error message. |
| TRANSITIVE_DEPENDENT_LINE_NUMBER = 4 |
| # The line containing the dependence in the error message. |
| TRANSITIVE_DEPENDEE_LINE_NUMBER = 6 |
| |
| MISSING_PATTERNS = [ |
| (3, "It is not in any dependency of"), |
| (5, "The include file is in the target(s):"), |
| ] |
| MISSING_DEPENDENT_LINE_NUMBER = 4 |
| MISSING_DEPENDEE_LINE_NUMBER = 6 |
| |
| # Character to set colors in terminal. |
| TERMINAL_ERROR_COLOR = "\033[91m" |
| TERMINAL_WARNING_COLOR = "\033[93m" |
| TERMINAL_RESET_COLOR = "\033[0m" |
| |
| # Separator between GN errors. |
| GN_ERROR_SEPARATOR = "___________________\n" |
| |
| # The error message to be used when the include file is in multiple GN targets. |
| MULTIPLE_DEPENDEES_ERROR = "Cannot handle includes in multiple targets:" |
| # The error message to be used when several "deps" are present for the target. |
| MULTIPLE_DEPS_ERROR = "Multiple deps variables in:" |
| # Warning message when automatically removing a target ending with |
| # "_strings_grit". |
| GRIT_TARGET_MESSAGE = "Grit target found!" |
| GRIT_TARGET_MESSAGE_DETAILS = "Automatically replacing:\n %s\nby:\n %s\n" |
| |
| # Array to handle special cases for canonical public target. This avoids having |
| # dependencies on internal target when there is a canonical target with public |
| # deps on those internal targets. |
| CANONICAL_PUBLIC_TARGETS = { |
| "//ios/chrome/app/strings:ios_strings_grit": |
| "//ios/chrome/app/strings:strings", |
| "//ios/chrome/app/strings:ios_branded_strings_grit": |
| "//ios/chrome/app/strings:strings", |
| "//components/strings:components_strings_grit": |
| "//components/strings:strings", |
| "//components/sessions:shared": |
| "//components/sessions:sessions", |
| "//base/numerics:base_numerics": |
| "//base:base", |
| "//third_party/abseil-cpp/absl/types:optional": |
| "//base:base", |
| } |
| |
| |
| def gn_format(gn_files): |
| """Format the file `gn_files`.""" |
| subprocess.check_call(["gn", "format"] + gn_files) |
| |
| |
| def remove_redundant_target_name(dependant, target_name): |
| """Canonicalize target_name to be used as a dep of dependant.""" |
| if target_name in CANONICAL_PUBLIC_TARGETS: |
| target_name = CANONICAL_PUBLIC_TARGETS[target_name] |
| (dependant_folder, dependant_target) = dependant.split(":") |
| (folder, target) = target_name.split(":") |
| if dependant_folder == folder: |
| return ":%s" % target |
| last_folder = os.path.basename(folder) |
| if last_folder == target: |
| return folder |
| if target.endswith("_strings_grit"): |
| warning_message = GRIT_TARGET_MESSAGE_DETAILS % (target_name, folder) |
| print_warning(GRIT_TARGET_MESSAGE, warning_message) |
| return folder |
| return target_name |
| |
| |
| def cleanup_redundant_deps(deps): |
| """If the list of `deps` contains only targets redundant with each |
| others, this method will return only one of them. Otherwise, return |
| all targets. |
| """ |
| if len(deps) != 2: |
| """Currently only handle the string grit case where gn finds the |
| the string header in <path>:<target>_strings and |
| <path>:<target>_string_grit, so don't check if there is not |
| exactly two targets. |
| """ |
| return deps |
| if (deps[1].endswith("_strings") and |
| deps[0] == deps[1] + "_grit"): |
| return [deps[0]] |
| if (deps[0].endswith("_strings") and |
| deps[1] == deps[0] + "_grit"): |
| return [deps[1]] |
| return deps |
| |
| |
| def extract_missing_dependency(error, prefix, patterns, dependant_line, |
| dependee_line): |
| """Parse gn error message for missing direct dependency.""" |
| lines = error.splitlines() |
| |
| if len(lines) <= patterns[-1][0]: |
| return False, None |
| for line_number, pattern in patterns: |
| if lines[line_number] != pattern: |
| return False, None |
| dependant = lines[dependant_line].strip() |
| if prefix and not dependant.startswith(prefix): |
| return False, None |
| |
| dependees_with_target = [] |
| index = dependee_line |
| while lines[dependee_line].strip().startswith("//"): |
| dependees_with_target.append(lines[dependee_line].strip()) |
| dependee_line += 1 |
| dependees_with_target = cleanup_redundant_deps(dependees_with_target) |
| |
| dependees = [] |
| for dependee in dependees_with_target: |
| dependees.append(remove_redundant_target_name(dependant, dependee)) |
| |
| return True, (dependant, dependees) |
| |
| |
| def get_missing_deps(builddir, prefix): |
| """Extracts missing direct dependencies from gn.""" |
| missing_deps = defaultdict(set) |
| process = subprocess.Popen(["gn", "check", builddir], |
| stdout=subprocess.PIPE) |
| lines, errs = process.communicate() |
| errors = lines.decode("ascii").split(GN_ERROR_SEPARATOR) |
| for error in errors: |
| has_missing_dep, info = extract_missing_dependency( |
| error, prefix, TRANSITIVE_PATTERNS, |
| TRANSITIVE_DEPENDENT_LINE_NUMBER, TRANSITIVE_DEPENDEE_LINE_NUMBER) |
| if not has_missing_dep: |
| has_missing_dep, info = extract_missing_dependency( |
| error, prefix, MISSING_PATTERNS, MISSING_DEPENDENT_LINE_NUMBER, |
| MISSING_DEPENDEE_LINE_NUMBER) |
| if has_missing_dep: |
| dependant, dependees = info |
| if len(dependees) == 1: |
| missing_deps[dependant].add(dependees[0]) |
| else: |
| print_error(MULTIPLE_DEPENDEES_ERROR, error) |
| return missing_deps |
| |
| |
| def add_missing_deps(srcdir, target, deps): |
| """Adds the missing deps to the BUILD.gn file and run gn format on it.""" |
| (dir, target_name) = target.split(":") |
| build_gn_file = os.path.join(srcdir, dir[2:], "BUILD.gn") |
| content = [] |
| in_target = False |
| changed = False |
| first_deps_variable_line_index = -1 |
| target_name = target_name.replace("+", "\\+") |
| |
| # Handles the internal targets from ios_app_bundle and |
| # ios_framework_bundle templates. |
| for suffix in ('_executable', '_shared_library'): |
| if target_name.endswith(suffix): |
| target_name = target_name[:-len(suffix)] |
| break |
| |
| target_rule = re.compile(r"\s*[a-z_]*\(\"%s\"\) {" % target_name) |
| with open(build_gn_file, "r") as build_gn: |
| all_lines = build_gn.readlines() |
| for line_index, line in enumerate(all_lines): |
| content += [line] |
| if target_rule.search(line): |
| indent = len(line) - len(line.lstrip(" ")) |
| in_target = True |
| if in_target and line == (" " * indent + "}\n"): |
| in_target = False |
| if (in_target and first_deps_variable_line_index != -1 and |
| line.strip().startswith("deps ")): |
| error_detail = (f"At lines:\n" |
| f"* {build_gn_file}:{first_deps_variable_line_index}:\n" |
| f" {all_lines[first_deps_variable_line_index]}\n" |
| f"* {build_gn_file}:{line_index}:\n" |
| f" {line}\n") |
| error_detail = f"{target}\n{error_detail}" |
| print_error(MULTIPLE_DEPS_ERROR, error_detail) |
| # Multiple deps, abort |
| return False, None |
| if (in_target and first_deps_variable_line_index == -1 and |
| line.strip().startswith("deps ")): |
| first_deps_variable_line_index = line_index |
| onelinedeps = False |
| if "[" in line and line[-2] == "]": |
| onelinedeps = True |
| content[-1] = line.replace("]", ",") |
| for dep in deps: |
| content += ["\"%s\",\n" % dep] |
| changed = True |
| if onelinedeps: |
| content += ["]\n"] |
| if changed: |
| with open(build_gn_file, "w") as build_gn: |
| build_gn.write("".join(content)) |
| return True, build_gn_file |
| return False, None |
| |
| |
| def main(args): |
| parser = argparse.ArgumentParser( |
| description=__doc__, formatter_class=argparse.RawTextHelpFormatter) |
| parser.add_argument("--prefix", |
| help="Only fix subtargets of prefix", |
| default="") |
| parser.add_argument("builddir", help="The build dir") |
| parser.add_argument("srcdir", help="The src dir") |
| args = parser.parse_args() |
| deps = get_missing_deps(args.builddir, args.prefix) |
| changed_build_gn_files = [] |
| for target in deps: |
| changed, build_gn_file = add_missing_deps(args.srcdir, target, |
| deps[target]) |
| if changed: |
| changed_build_gn_files.append(build_gn_file) |
| if changed_build_gn_files: |
| gn_format(changed_build_gn_files) |
| |
| |
| def print_error(error_message, error_info): |
| """ Print the `error_message` with additional `error_info` """ |
| color_start, color_end = adapted_color_for_output(TERMINAL_ERROR_COLOR, |
| TERMINAL_RESET_COLOR) |
| |
| error_message = color_start + "ERROR: " + error_message + color_end |
| if len(error_info) > 0: |
| error_message = error_message + "\n" + error_info |
| print(error_message + "\n" + GN_ERROR_SEPARATOR) |
| |
| |
| def print_warning(warning_message, warning_info): |
| """ Print the `warning_message` with additional `warning_info` """ |
| color_start, color_end = adapted_color_for_output(TERMINAL_WARNING_COLOR, |
| TERMINAL_RESET_COLOR) |
| |
| warning_message = color_start + "WARNING: " + warning_message + color_end |
| if len(warning_info) > 0: |
| warning_message = warning_message + "\n" + warning_info |
| print(warning_message + "\n" + GN_ERROR_SEPARATOR) |
| |
| |
| def adapted_color_for_output(color_start, color_end): |
| """ Returns a the `color_start`, `color_end` tuple if the output is a |
| terminal, or empty strings otherwise """ |
| if not sys.stdout.isatty(): |
| return "", "" |
| return color_start, color_end |
| |
| |
| if __name__ == "__main__": |
| sys.exit(main(sys.argv[1:])) |
