def main(argv):
argv = build_utils.ExpandFileArgs(argv[1:])
parser = argparse.ArgumentParser()
parser.add_argument('--target-name',
help='Fully qualified GN target name.')
parser.add_argument('--script',
required=True,
help='Path to the java binary wrapper script.')
parser.add_argument('--gn-target', required=True)
parser.add_argument('--input-jar', required=True)
parser.add_argument('--direct-classpath-jars')
parser.add_argument('--sdk-classpath-jars')
parser.add_argument('--full-classpath-jars')
parser.add_argument('--full-classpath-gn-targets')
parser.add_argument('--stamp')
parser.add_argument('-v', '--verbose', action='store_true')
parser.add_argument('--missing-classes-allowlist')
parser.add_argument('--warnings-as-errors',
action='store_true',
help='Treat all warnings as errors.')
_AddSwitch(parser, '--is-prebuilt')
args = parser.parse_args(argv)
if server_utils.MaybeRunCommand(name=args.target_name,
argv=sys.argv,
stamp_file=args.stamp):
return
args.sdk_classpath_jars = build_utils.ParseGnList(args.sdk_classpath_jars)
args.direct_classpath_jars = build_utils.ParseGnList(
args.direct_classpath_jars)
args.full_classpath_jars = build_utils.ParseGnList(
args.full_classpath_jars)
args.full_classpath_gn_targets = build_utils.ParseGnList(
args.full_classpath_gn_targets)
args.missing_classes_allowlist = build_utils.ParseGnList(
args.missing_classes_allowlist)
verbose = '--verbose' if args.verbose else '--not-verbose'
cmd = [
args.script, args.gn_target, args.input_jar, verbose, args.is_prebuilt
]
cmd += [str(len(args.missing_classes_allowlist))]
cmd += args.missing_classes_allowlist
cmd += [str(len(args.sdk_classpath_jars))]
cmd += args.sdk_classpath_jars
cmd += [str(len(args.direct_classpath_jars))]
cmd += args.direct_classpath_jars
cmd += [str(len(args.full_classpath_jars))]
cmd += args.full_classpath_jars
cmd += [str(len(args.full_classpath_gn_targets))]
cmd += args.full_classpath_gn_targets
build_utils.CheckOutput(cmd,
print_stdout=True,
fail_func=None,
fail_on_output=args.warnings_as_errors)
if args.stamp:
build_utils.Touch(args.stamp)
def main():
build_utils.InitLogging('LINT_DEBUG')
args = _ParseArgs(sys.argv[1:])
# TODO(wnwen): Consider removing lint cache now that there are only two lint
# invocations.
# Avoid parallelizing cache creation since lint runs without the cache defeat
# the purpose of creating the cache in the first place.
if (not args.create_cache and not args.skip_build_server
and server_utils.MaybeRunCommand(name=args.target_name,
argv=sys.argv,
stamp_file=args.stamp,
force=args.use_build_server)):
return
sources = []
for java_sources_file in args.java_sources:
sources.extend(build_utils.ReadSourcesList(java_sources_file))
resource_sources = []
for resource_sources_file in args.resource_sources:
resource_sources.extend(build_utils.ReadSourcesList(resource_sources_file))
possible_depfile_deps = (args.srcjars + args.resource_zips + sources +
resource_sources + [
args.baseline,
args.manifest_path,
])
depfile_deps = [p for p in possible_depfile_deps if p]
_RunLint(args.create_cache,
args.lint_binary_path,
args.backported_methods,
args.config_path,
args.manifest_path,
args.extra_manifest_paths,
sources,
args.classpath,
args.cache_dir,
args.android_sdk_version,
args.aars,
args.srcjars,
args.min_sdk_version,
resource_sources,
args.resource_zips,
args.android_sdk_root,
args.lint_gen_dir,
args.baseline,
testonly_target=args.testonly,
warnings_as_errors=args.warnings_as_errors)
logging.info('Creating stamp file')
build_utils.Touch(args.stamp)
if args.depfile:
build_utils.WriteDepfile(args.depfile, args.stamp, depfile_deps)
def main(argv):
build_utils.InitLogging('JAVAC_DEBUG')
argv = build_utils.ExpandFileArgs(argv)
options, java_files = _ParseOptions(argv)
# Only use the build server for errorprone runs.
if (options.enable_errorprone and not options.skip_build_server
and server_utils.MaybeRunCommand(name=options.target_name,
argv=sys.argv,
stamp_file=options.jar_path)):
return
javac_cmd = []
if options.gomacc_path:
javac_cmd.append(options.gomacc_path)
javac_cmd.append(build_utils.JAVAC_PATH)
javac_args = [
'-g',
# Chromium only allows UTF8 source files. Being explicit avoids
# javac pulling a default encoding from the user's environment.
'-encoding',
'UTF-8',
# Prevent compiler from compiling .java files not listed as inputs.
# See: http://blog.ltgt.net/most-build-tools-misuse-javac/
'-sourcepath',
':',
]
if options.enable_errorprone:
# All errorprone args are passed space-separated in a single arg.
errorprone_flags = ['-Xplugin:ErrorProne']
# Make everything a warning so that when treat_warnings_as_errors is false,
# they do not fail the build.
errorprone_flags += ['-XepAllErrorsAsWarnings']
# Don't check generated files.
errorprone_flags += ['-XepDisableWarningsInGeneratedCode']
errorprone_flags.extend('-Xep:{}:OFF'.format(x)
for x in ERRORPRONE_WARNINGS_TO_DISABLE)
errorprone_flags.extend('-Xep:{}:WARN'.format(x)
for x in ERRORPRONE_WARNINGS_TO_ENABLE)
if ERRORPRONE_CHECKS_TO_APPLY:
errorprone_flags += [
'-XepPatchLocation:IN_PLACE',
'-XepPatchChecks:,' + ','.join(ERRORPRONE_CHECKS_TO_APPLY)
]
javac_args += ['-XDcompilePolicy=simple', ' '.join(errorprone_flags)]
# This flag quits errorprone after checks and before code generation, since
# we do not need errorprone outputs, this speeds up errorprone by 4 seconds
# for chrome_java.
if not ERRORPRONE_CHECKS_TO_APPLY:
javac_args += ['-XDshould-stop.ifNoError=FLOW']
if options.java_version:
javac_args.extend([
'-source',
options.java_version,
'-target',
options.java_version,
])
if options.java_version == '1.8':
# Android's boot jar doesn't contain all java 8 classes.
options.bootclasspath.append(build_utils.RT_JAR_PATH)
# This effectively disables all annotation processors, even including
# annotation processors in service provider configuration files named
# META-INF/. See the following link for reference:
# https://docs.oracle.com/en/java/javase/11/tools/javac.html
javac_args.extend(['-proc:none'])
if options.bootclasspath:
javac_args.extend(['-bootclasspath', ':'.join(options.bootclasspath)])
if options.processorpath:
javac_args.extend(['-processorpath', ':'.join(options.processorpath)])
if options.processor_args:
for arg in options.processor_args:
javac_args.extend(['-A%s' % arg])
javac_args.extend(options.javac_arg)
classpath_inputs = (options.bootclasspath + options.classpath +
options.processorpath)
depfile_deps = classpath_inputs
# Files that are already inputs in GN should go in input_paths.
input_paths = depfile_deps + options.java_srcjars + java_files
if options.header_jar:
input_paths.append(options.header_jar)
input_paths += [x[0] for x in options.additional_jar_files]
output_paths = [options.jar_path]
if not options.enable_errorprone:
output_paths += [options.jar_path + '.info']
input_strings = javac_cmd + javac_args + options.classpath + java_files + [
options.warnings_as_errors, options.jar_info_exclude_globs
]
# Use md5_check for |pass_changes| feature.
md5_check.CallAndWriteDepfileIfStale(lambda changes: _OnStaleMd5(
changes, options, javac_cmd, javac_args, java_files),
options,
depfile_deps=depfile_deps,
input_paths=input_paths,
input_strings=input_strings,
output_paths=output_paths,
pass_changes=True)