| #!/usr/bin/env python3 |
| # |
| # Copyright 2021 The Chromium Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| """Contains helper class for processing javac output.""" |
| |
| import functools |
| import os |
| import pathlib |
| import posixpath |
| import re |
| import shlex |
| import sys |
| import traceback |
| |
| from util import dep_utils |
| |
| |
| _PACKAGE_RE = re.compile(r'^package\s+(.*?)(;|\s*$)', flags=re.MULTILINE) |
| |
| |
| @functools.cache |
| def _running_locally(): |
| return os.path.exists('build.ninja') |
| |
| |
| @functools.cache # pylint: disable=method-cache-max-size-none |
| def _extract_package_name(path): |
| data = pathlib.Path(path).read_text('utf-8') |
| if m := _PACKAGE_RE.search(data): |
| return m.group(1) |
| return None |
| |
| |
| class JavacOutputProcessor: |
| def __init__(self, target_name): |
| self._target_name = self._RemoveSuffixesIfPresent( |
| ["__compile_java", "__errorprone", "__header"], target_name) |
| self._missing_classes_short = set() |
| self._missing_classes_full = set() |
| self._suggested_targets = set() |
| self._unresolvable_classes = set() |
| |
| # Examples: |
| # ../../path/to/Foo.java:54: error: cannot find symbol |
| # ClangProfiler.writeClangProfilingProfile(); |
| # ^ |
| # symbol: variable ClangProfiler |
| # |
| # ../../path/to/Foo.java:69: error: could not resolve Linker.LibInfo |
| # static Linker.LibInfo anyLibInfo() { |
| # ^ |
| self._resolution_re = re.compile( |
| # ../../ui/android/java/src/org/chromium/ui/base/Clipboard.java:45: |
| r'^(?P<path>[-.\w/\\]+.java):(?:[0-9]+):' |
| # error: package org.chromium.components.url_formatter does not exist |
| r'(?: error: package [\w.]+ does not exist|' |
| # error: cannot find symbol |
| r' error: cannot find symbol|' |
| # error: could not resolve Linker.LibInfo |
| r' error: could not resolve (?P<unresolved>[A-Z]\w*).*|' |
| # error: symbol not found org.chromium.url.GURL |
| r' error: symbol not found [\w.]+)$' |
| r'\s*(?:' |
| # import org.chromium.url.GURL; |
| r'import (?P<import>[\w\.]+);|' |
| # import static org.chromium.url.GURL.method; |
| r'import static (?P<static_import>[\w\.]+)\.\S+;|' |
| r'.*)$' |
| r'\s*\^*$' |
| # symbol: variable ClangProfiler |
| r'\s*(symbol:\s+variable (?P<variable>[A-Z]\w+))?', |
| re.MULTILINE) |
| |
| self._class_lookup_index = None |
| |
| def Process(self, output): |
| self._LookForUnknownSymbols(output) |
| |
| if not self._missing_classes_full: |
| return output |
| |
| sb = [] |
| sb.append('💡 One or more errors due to missing GN deps 💡') |
| if self._unresolvable_classes: |
| sb.append('Failed to find targets for the following classes:') |
| for class_name in sorted(self._unresolvable_classes): |
| sb.append(f'* {class_name}') |
| if self._suggested_targets: |
| sb.append('Hint: Try adding the following to ' + self._target_name) |
| |
| for targets in sorted(self._suggested_targets): |
| if len(targets) > 1: |
| suggested_targets_str = 'one of: ' + ', '.join(targets) |
| else: |
| suggested_targets_str = targets[0] |
| # Show them in quotes so they can be copy/pasted into BUILD.gn files. |
| sb.append(f' "{suggested_targets_str}",') |
| |
| sb.append('') |
| sb.append('Hint: Run the following command to add the missing deps:') |
| missing_targets = {targets[0] for targets in self._suggested_targets} |
| cmd = dep_utils.CreateAddDepsCommand(self._target_name, |
| sorted(missing_targets)) |
| sb.append(f' {shlex.join(cmd)}') |
| sb.append('') |
| sb.append('Use tools/android/auto_fix_missing_java_deps.py' |
| ' to auto-apply suggestions.') |
| elif not self._unresolvable_classes: |
| sb.append( |
| 'Hint: Rebuild with -config no-remote-javac to show missing deps.') |
| |
| sb.append('') |
| return output + '\n'.join(sb) |
| |
| def _LookForUnknownSymbols(self, output): |
| for m in self._resolution_re.finditer(output): |
| full_class_name = m.group('import') or m.group('static_import') |
| if not full_class_name: |
| short_class_name = m.group('unresolved') or m.group('variable') |
| if not short_class_name: |
| continue |
| if short_class_name in self._missing_classes_short: |
| continue |
| path = m.group('path') |
| if os.path.exists(path): |
| package_name = _extract_package_name(path) |
| if not package_name: |
| continue |
| else: |
| # This can happen for .srcjars in turbine.py (which directly supports |
| # .srcjar files). |
| # E.g.: "org/chromium/network/mojom/ParsedHeaders.java" |
| package_name = posixpath.dirname(path).replace('/', '.') |
| full_class_name = f'{package_name}.{short_class_name}' |
| |
| if full_class_name not in self._missing_classes_full: |
| short_class_name = full_class_name.split('.')[-1] |
| self._missing_classes_short.add(short_class_name) |
| self._missing_classes_full.add(full_class_name) |
| if _running_locally(): |
| try: |
| self._AnalyzeMissingClass(full_class_name) |
| except Exception: |
| sys.stderr.write('Error in _AnalyzeMissingClass---\n' + |
| traceback.format_exc()) |
| return |
| |
| def _AnalyzeMissingClass(self, class_name): |
| if self._class_lookup_index is None: |
| self._class_lookup_index = dep_utils.ClassLookupIndex( |
| pathlib.Path(os.getcwd()), |
| should_build=False, |
| ) |
| |
| suggested_deps = self._class_lookup_index.match(class_name) |
| |
| if not suggested_deps: |
| self._unresolvable_classes.add(class_name) |
| return |
| |
| suggested_deps = dep_utils.DisambiguateDeps(suggested_deps) |
| self._suggested_targets.add(tuple(d.target for d in suggested_deps)) |
| |
| @staticmethod |
| def _RemoveSuffixesIfPresent(suffixes, text): |
| for suffix in suffixes: |
| if text.endswith(suffix): |
| return text[:-len(suffix)] |
| return text |
| |
| |
| def Process(target_name, output): |
| processor = JavacOutputProcessor(target_name) |
| return processor.Process(output) |
