def parse_override(override):
try:
coordinate, rev = override.split('=', 1)
try:
# overrides imply semantic versioning
rev = Semver.parse(rev)
except ValueError as e:
raise TaskError('Invalid version {}: {}'.format(rev, e))
return parse_jarcoordinate(coordinate), rev
except ValueError:
raise TaskError('Invalid override: {}'.format(override))
def parse_override(override):
try:
coordinate, rev = override.split('=', 1)
try:
# overrides imply semantic versioning
rev = Semver.parse(rev)
except ValueError as e:
raise TaskError('Invalid version {}: {}'.format(rev, e))
return parse_jarcoordinate(coordinate), rev
except ValueError:
raise TaskError('Invalid override: {}'.format(override))
def parse_override(override):
try:
coordinate, rev = override.split("=", 1)
try:
# overrides imply semantic versioning
rev = Semver.parse(rev)
except ValueError as e:
raise TaskError(f"Invalid version {rev}: {e!r}")
return parse_jarcoordinate(coordinate), rev
except ValueError:
raise TaskError(f"Invalid override: {override}")
def get_entry(self, target):
"""Given an internal target, return a PushDb.Entry, which might contain defaults."""
db_get, _ = self._accessors_for_target(target)
major = int(db_get('revision.major', '0'))
minor = int(db_get('revision.minor', '0'))
patch = int(db_get('revision.patch', '0'))
snapshot = str(db_get('revision.snapshot', 'false')).lower() == 'true'
named_version = db_get('revision.named_version', None)
named_is_latest = str(db_get('revision.named_is_latest', 'false')).lower() == 'true'
sha = db_get('revision.sha', None)
fingerprint = db_get('revision.fingerprint', None)
sem_ver = Semver(major, minor, patch, snapshot=snapshot)
named_ver = Namedver(named_version) if named_version else None
return self.Entry(sem_ver, named_ver, named_is_latest, sha, fingerprint)
def work_for_vts_rsc(vts, ctx):
target = ctx.target
(tgt, ) = vts.targets
rsc_cc = compile_contexts[target].rsc_cc
use_youtline = rsc_cc.workflow == self.JvmCompileWorkflowType.outline_and_zinc
outliner = "scalac-outliner" if use_youtline else "rsc"
if use_youtline and Semver.parse(
self._scala_library_version) < Semver.parse("2.12.9"):
raise RuntimeError(
f"To use scalac's built-in outlining, scala version must be at least 2.12.9, but got {self._scala_library_version}"
)
# If we didn't hit the cache in the cache job, run rsc.
if not vts.valid:
counter_val = str(counter()).rjust(counter.format_length(),
" ")
counter_str = f"[{counter_val}/{counter.size}] "
action_str = "Outlining " if use_youtline else "Rsc-ing "
self.context.log.info(
counter_str,
action_str,
items_to_report_element(ctx.sources,
f"{self.name()} source"),
" in ",
items_to_report_element(
[t.address.reference() for t in vts.targets],
"target"),
" (",
ctx.target.address.spec,
").",
)
# This does the following
# - Collect the rsc classpath elements, including zinc compiles of rsc incompatible targets
# and rsc compiles of rsc compatible targets.
# - Run Rsc on the current target with those as dependencies.
dependencies_for_target = list(
DependencyContext.global_instance(
).dependencies_respecting_strict_deps(target))
classpath_paths = []
classpath_digests = []
classpath_product = self.context.products.get_data(
"rsc_mixed_compile_classpath")
classpath_entries = classpath_product.get_classpath_entries_for_targets(
dependencies_for_target)
hermetic = self.execution_strategy == self.ExecutionStrategy.hermetic
for _conf, classpath_entry in classpath_entries:
classpath_paths.append(
fast_relpath(classpath_entry.path, get_buildroot()))
if hermetic and not classpath_entry.directory_digest:
raise AssertionError(
"ClasspathEntry {} didn't have a Digest, so won't be present for hermetic "
"execution of {}".format(classpath_entry,
outliner))
classpath_digests.append(classpath_entry.directory_digest)
ctx.ensure_output_dirs_exist()
with Timer() as timer:
# Outline Scala sources into SemanticDB / scalac compatible header jars.
# ---------------------------------------------
rsc_jar_file_relative_path = fast_relpath(
ctx.rsc_jar_file.path, get_buildroot())
sources_snapshot = ctx.target.sources_snapshot(
scheduler=self.context._scheduler)
distribution = self._get_jvm_distribution()
def hermetic_digest_classpath():
jdk_libs_rel, jdk_libs_digest = self._jdk_libs_paths_and_digest(
distribution)
merged_sources_and_jdk_digest = self.context._scheduler.merge_directories(
(jdk_libs_digest, sources_snapshot.digest) +
tuple(classpath_digests))
classpath_rel_jdk = classpath_paths + jdk_libs_rel
return (merged_sources_and_jdk_digest,
classpath_rel_jdk)
def nonhermetic_digest_classpath():
classpath_abs_jdk = classpath_paths + self._jdk_libs_abs(
distribution)
return ((EMPTY_DIGEST), classpath_abs_jdk)
(input_digest, classpath_entry_paths) = match(
self.execution_strategy,
{
self.ExecutionStrategy.hermetic:
hermetic_digest_classpath,
self.ExecutionStrategy.subprocess:
nonhermetic_digest_classpath,
self.ExecutionStrategy.nailgun:
nonhermetic_digest_classpath,
},
)()
youtline_args = []
if use_youtline:
youtline_args = [
"-Youtline",
"-Ystop-after:pickler",
"-Ypickle-write",
rsc_jar_file_relative_path,
]
target_sources = ctx.sources
# TODO: m.jar digests aren't found, so hermetic will fail.
if use_youtline and not hermetic and self.get_options(
).zinc_outline:
self._zinc_outline(ctx, classpath_paths,
target_sources, youtline_args)
else:
args = ([
"-cp",
os.pathsep.join(classpath_entry_paths),
"-d",
rsc_jar_file_relative_path,
] + self.get_options().extra_rsc_args + youtline_args +
target_sources)
self.write_argsfile(ctx, args)
self._runtool(distribution, input_digest, ctx,
use_youtline)
self._record_target_stats(
tgt,
len(classpath_entry_paths),
len(target_sources),
timer.elapsed,
False,
outliner,
)
# Update the products with the latest classes.
self.register_extra_products_from_contexts([ctx.target],
compile_contexts)
def work_for_vts_rsc(vts, ctx):
target = ctx.target
tgt, = vts.targets
rsc_cc = compile_contexts[target].rsc_cc
use_youtline = rsc_cc.workflow == self.JvmCompileWorkflowType.outline_and_zinc
outliner = 'scalac-outliner' if use_youtline else 'rsc'
if use_youtline and Semver.parse(
self._scala_library_version) < Semver.parse("2.12.9"):
raise RuntimeError(
f"To use scalac's built-in outlining, scala version must be at least 2.12.9, but got {self._scala_library_version}"
)
# If we didn't hit the cache in the cache job, run rsc.
if not vts.valid:
counter_val = str(counter()).rjust(counter.format_length(),
' ')
counter_str = '[{}/{}] '.format(counter_val, counter.size)
action_str = 'Outlining ' if use_youtline else 'Rsc-ing '
self.context.log.info(
counter_str, action_str,
items_to_report_element(ctx.sources,
'{} source'.format(self.name())),
' in ',
items_to_report_element(
[t.address.reference() for t in vts.targets],
'target'), ' (', ctx.target.address.spec, ').')
# This does the following
# - Collect the rsc classpath elements, including zinc compiles of rsc incompatible targets
# and rsc compiles of rsc compatible targets.
# - Run Rsc on the current target with those as dependencies.
dependencies_for_target = list(
DependencyContext.global_instance(
).dependencies_respecting_strict_deps(target))
classpath_paths = []
classpath_directory_digests = []
classpath_product = self.context.products.get_data(
'rsc_mixed_compile_classpath')
classpath_entries = classpath_product.get_classpath_entries_for_targets(
dependencies_for_target)
for _conf, classpath_entry in classpath_entries:
classpath_paths.append(
fast_relpath(classpath_entry.path, get_buildroot()))
if self.execution_strategy == self.ExecutionStrategy.hermetic and not classpath_entry.directory_digest:
raise AssertionError(
"ClasspathEntry {} didn't have a Digest, so won't be present for hermetic "
"execution of {}".format(classpath_entry,
outliner))
classpath_directory_digests.append(
classpath_entry.directory_digest)
ctx.ensure_output_dirs_exist()
with Timer() as timer:
# Outline Scala sources into SemanticDB / scalac compatible header jars.
# ---------------------------------------------
rsc_jar_file_relative_path = fast_relpath(
ctx.rsc_jar_file.path, get_buildroot())
sources_snapshot = ctx.target.sources_snapshot(
scheduler=self.context._scheduler)
distribution = self._get_jvm_distribution()
def hermetic_digest_classpath():
jdk_libs_rel, jdk_libs_digest = self._jdk_libs_paths_and_digest(
distribution)
merged_sources_and_jdk_digest = self.context._scheduler.merge_directories(
(jdk_libs_digest,
sources_snapshot.directory_digest) +
tuple(classpath_directory_digests))
classpath_rel_jdk = classpath_paths + jdk_libs_rel
return (merged_sources_and_jdk_digest,
classpath_rel_jdk)
def nonhermetic_digest_classpath():
classpath_abs_jdk = classpath_paths + self._jdk_libs_abs(
distribution)
return ((EMPTY_DIRECTORY_DIGEST), classpath_abs_jdk)
(input_digest,
classpath_entry_paths) = self.execution_strategy.match({
self.ExecutionStrategy.hermetic:
hermetic_digest_classpath,
self.ExecutionStrategy.subprocess:
nonhermetic_digest_classpath,
self.ExecutionStrategy.nailgun:
nonhermetic_digest_classpath,
})()
youtline_args = []
if use_youtline:
youtline_args = [
"-Youtline",
"-Ystop-after:pickler",
"-Ypickle-write",
rsc_jar_file_relative_path,
]
if not self.get_options().allow_public_inference:
wartremover_args = [
f"-Xplugin:{self._wartremover_classpath[0]}",
"-P:wartremover:traverser:org.wartremover.warts.PublicInference",
"-Ycache-plugin-class-loader:last-modified",
]
youtline_args = wartremover_args + youtline_args
target_sources = ctx.sources
args = [
'-cp',
os.pathsep.join(classpath_entry_paths),
'-d',
rsc_jar_file_relative_path,
] + self.get_options(
).extra_rsc_args + youtline_args + target_sources
self.write_argsfile(ctx, args)
self._runtool(distribution, input_digest, ctx,
use_youtline)
self._record_target_stats(tgt, len(classpath_entry_paths),
len(target_sources), timer.elapsed,
False, outliner)
# Update the products with the latest classes.
self.register_extra_products_from_contexts([ctx.target],
compile_contexts)