# Copyright 2023 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Methods for managing deps based on build_config.json files."""
from __future__ import annotations
import collections
import dataclasses
import json
import logging
import os
import pathlib
import subprocess
import sys
from typing import Dict, Iterator, List, Set
from util import jar_utils
_SRC_PATH = pathlib.Path(__file__).resolve().parents[4]
sys.path.append(str(_SRC_PATH / 'build/android'))
# Import list_java_targets so that the dependency is found by print_python_deps.
import list_java_targets
@dataclasses.dataclass(frozen=True)
class ClassEntry:
"""An assignment of a Java class to a build target."""
full_class_name: str
target: str
preferred_dep: bool
def __lt__(self, other: 'ClassEntry'):
# Prefer canonical targets first.
if self.preferred_dep and not other.preferred_dep:
return True
# Prefer targets without __ in the name. Usually double underscores are used
# for internal subtargets and not top level targets.
if '__' not in self.target and '__' in other.target:
return True
# Prefer shorter target names first since they are usually the correct ones.
if len(self.target) < len(other.target):
return True
if len(self.target) > len(other.target):
return False
# Use string comparison to get a stable ordering of equal-length names.
return self.target < other.target
@dataclasses.dataclass
class BuildConfig:
"""Container for information from a build config."""
target_name: str
relpath: str
is_group: bool
preferred_dep: bool
dependent_config_paths: List[str]
full_class_names: Set[str]
def all_dependent_configs(
self,
path_to_configs: Dict[str, 'BuildConfig'],
) -> Iterator['BuildConfig']:
for path in self.dependent_config_paths:
dep_build_config = path_to_configs.get(path)
# This can happen when a java group depends on non-java targets.
if dep_build_config is None:
continue
yield dep_build_config
if dep_build_config.is_group:
yield from dep_build_config.all_dependent_configs(path_to_configs)
class ClassLookupIndex:
"""A map from full Java class to its build targets.
A class might be in multiple targets if it's bytecode rewritten."""
def __init__(self, build_output_dir: pathlib.Path, should_build: bool):
self._abs_build_output_dir = build_output_dir.resolve().absolute()
self._should_build = should_build
self._class_index = self._index_root()
def match(self, search_string: str) -> List[ClassEntry]:
"""Get class/target entries where the class matches search_string"""
# Priority 1: Exact full matches
if search_string in self._class_index:
return self._entries_for(search_string)
# Priority 2: Match full class name (any case), if it's a class name
matches = []
lower_search_string = search_string.lower()
if '.' not in lower_search_string:
for full_class_name in self._class_index:
package_and_class = full_class_name.rsplit('.', 1)
if len(package_and_class) < 2:
continue
class_name = package_and_class[1]
class_lower = class_name.lower()
if class_lower == lower_search_string:
matches.extend(self._entries_for(full_class_name))
if matches:
return matches
# Priority 3: Match anything
for full_class_name in self._class_index:
if lower_search_string in full_class_name.lower():
matches.extend(self._entries_for(full_class_name))
# Priority 4: Match parent class when no matches and it's an inner class.
if not matches:
components = search_string.rsplit('.', 2)
if len(components) == 3:
package, outer_class, inner_class = components
if outer_class[0].isupper() and inner_class[0].isupper():
matches.extend(self.match(f'{package}.{outer_class}'))
return matches
def _entries_for(self, class_name) -> List[ClassEntry]:
return sorted(self._class_index[class_name])
def _index_root(self) -> Dict[str, Set[ClassEntry]]:
"""Create the class to target index."""
logging.debug('Running list_java_targets.py...')
list_java_targets_command = [
'build/android/list_java_targets.py', '--gn-labels',
'--print-build-config-paths',
f'--output-directory={self._abs_build_output_dir}'
]
if self._should_build:
list_java_targets_command += ['--build']
list_java_targets_run = subprocess.run(list_java_targets_command,
cwd=_SRC_PATH,
capture_output=True,
text=True,
check=True)
logging.debug('... done.')
# Parse output of list_java_targets.py into BuildConfig objects.
path_to_build_config: Dict[str, BuildConfig] = {}
target_lines = list_java_targets_run.stdout.splitlines()
for target_line in target_lines:
# Skip empty lines
if not target_line:
continue
target_line_parts = target_line.split(': ')
assert len(target_line_parts) == 2, target_line_parts
target_name, build_config_path = target_line_parts
if not os.path.exists(build_config_path):
assert not self._should_build
continue
with open(build_config_path) as build_config_contents:
build_config_json: Dict = json.load(build_config_contents)
deps_info = build_config_json['deps_info']
# Checking the library type here instead of in list_java_targets.py avoids
# reading each .build_config file twice.
if deps_info['type'] not in ('java_library', 'group'):
continue
relpath = os.path.relpath(build_config_path, self._abs_build_output_dir)
preferred_dep = bool(deps_info.get('preferred_dep'))
is_group = bool(deps_info.get('type') == 'group')
dependent_config_paths = deps_info.get('deps_configs', [])
full_class_names = self._compute_full_class_names_for_build_config(
deps_info)
build_config = BuildConfig(relpath=relpath,
target_name=target_name,
is_group=is_group,
preferred_dep=preferred_dep,
dependent_config_paths=dependent_config_paths,
full_class_names=full_class_names)
path_to_build_config[relpath] = build_config
# From GN's perspective, depending on a java group is the same as depending
# on all of its deps directly, since groups are collapsed in
# write_build_config.py. Thus, collect all the java files in a java group's
# deps (recursing into other java groups) and set that as the java group's
# list of classes.
for build_config in path_to_build_config.values():
if build_config.is_group:
for dep_build_config in build_config.all_dependent_configs(
path_to_build_config):
build_config.full_class_names.update(
dep_build_config.full_class_names)
class_index = collections.defaultdict(set)
for build_config in path_to_build_config.values():
for full_class_name in build_config.full_class_names:
class_index[full_class_name].add(
ClassEntry(full_class_name=full_class_name,
target=build_config.target_name,
preferred_dep=build_config.preferred_dep))
return class_index
def _compute_full_class_names_for_build_config(self,
deps_info: Dict) -> Set[str]:
"""Returns set of fully qualified class names for build config."""
full_class_names = set()
# Read the location of the target_sources_file from the build_config
sources_path = deps_info.get('target_sources_file')
if sources_path:
# Read the target_sources_file, indexing the classes found
with open(self._abs_build_output_dir / sources_path) as sources_contents:
for source_line in sources_contents:
source_path = pathlib.Path(source_line.strip())
java_class = jar_utils.parse_full_java_class(source_path)
if java_class:
full_class_names.add(java_class)
# |unprocessed_jar_path| is set for prebuilt targets. (ex:
# android_aar_prebuilt())
# |unprocessed_jar_path| might be set but not exist if not all targets have
# been built.
unprocessed_jar_path = deps_info.get('unprocessed_jar_path')
if unprocessed_jar_path:
abs_unprocessed_jar_path = (self._abs_build_output_dir /
unprocessed_jar_path)
if abs_unprocessed_jar_path.exists():
# Normalize path but do not follow symlink if .jar is symlink.
abs_unprocessed_jar_path = (abs_unprocessed_jar_path.parent.resolve() /
abs_unprocessed_jar_path.name)
full_class_names.update(
jar_utils.extract_full_class_names_from_jar(
abs_unprocessed_jar_path))
return full_class_names
def GnTargetToBuildFilePath(gn_target: str):
"""Returns the relative BUILD.gn file path for this target from src root."""
assert gn_target.startswith('//'), f'Relative {gn_target} name not supported.'
ninja_target_name = gn_target[2:]
# Remove the colon at the end
colon_index = ninja_target_name.find(':')
if colon_index != -1:
ninja_target_name = ninja_target_name[:colon_index]
return os.path.join(ninja_target_name, 'BUILD.gn')
def CreateAddDepsCommand(gn_target: str, missing_deps: List[str]) -> List[str]:
# Normalize chrome_public_apk__java to chrome_public_apk.
gn_target = gn_target.split('__', 1)[0]
build_file_path = GnTargetToBuildFilePath(gn_target)
return [
'build/gn_editor', 'add', '--quiet', '--file', build_file_path,
'--target', gn_target, '--deps'
] + missing_deps
def ReplaceGmsPackageIfNeeded(target_name: str) -> str:
if target_name.startswith(
('//third_party/android_deps:google_play_services_',
'//clank/third_party/google3:google_play_services_')):
return f'$google_play_services_package:{target_name.split(":")[1]}'
return target_name
def DisambiguateDeps(class_entries: List[ClassEntry]):
def filter_if_not_empty(entries, filter_func):
filtered_entries = [e for e in entries if filter_func(e)]
return filtered_entries or entries
# When some deps are preferred, ignore all other potential deps.
class_entries = filter_if_not_empty(class_entries, lambda e: e.preferred_dep)
# E.g. javax_annotation_jsr250_api_java.
class_entries = filter_if_not_empty(class_entries,
lambda e: 'jsr' in e.target)
# Avoid suggesting subtargets when regular targets exist.
class_entries = filter_if_not_empty(class_entries,
lambda e: '__' not in e.target)
# Swap out GMS package names if needed.
class_entries = [
dataclasses.replace(e, target=ReplaceGmsPackageIfNeeded(e.target))
for e in class_entries
]
# Convert to dict and then use list to get the keys back to remove dups and
# keep order the same as before.
class_entries = list({e: True for e in class_entries})
return class_entries
Codebase Browser
chromium