#!/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:]))
Codebase Browser
chromium