// Copyright 2014 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.devtools.build.lib.analysis;
import static com.google.common.collect.ImmutableList.toImmutableList;
import static com.google.devtools.build.lib.analysis.constraints.ConstraintConstants.OS_TO_CONSTRAINTS;
import static com.google.devtools.build.lib.analysis.test.ExecutionInfo.DEFAULT_TEST_RUNNER_EXEC_GROUP;
import static com.google.devtools.build.lib.packages.ExecGroup.DEFAULT_EXEC_GROUP_NAME;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Joiner;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableListMultimap;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimaps;
import com.google.common.collect.Streams;
import com.google.devtools.build.lib.actions.ActionAnalysisMetadata;
import com.google.devtools.build.lib.actions.ActionLookupKey;
import com.google.devtools.build.lib.actions.ActionOwner;
import com.google.devtools.build.lib.actions.ActionRegistry;
import com.google.devtools.build.lib.actions.Artifact;
import com.google.devtools.build.lib.actions.Artifact.SpecialArtifact;
import com.google.devtools.build.lib.actions.ArtifactRoot;
import com.google.devtools.build.lib.analysis.AliasProvider.TargetMode;
import com.google.devtools.build.lib.analysis.ExecGroupCollection.InvalidExecGroupException;
import com.google.devtools.build.lib.analysis.actions.ActionConstructionContext;
import com.google.devtools.build.lib.analysis.buildinfo.BuildInfoKey;
import com.google.devtools.build.lib.analysis.config.BuildConfigurationValue;
import com.google.devtools.build.lib.analysis.config.ConfigConditions;
import com.google.devtools.build.lib.analysis.config.ConfigMatchingProvider;
import com.google.devtools.build.lib.analysis.config.FeatureSet;
import com.google.devtools.build.lib.analysis.config.Fragment;
import com.google.devtools.build.lib.analysis.platform.ConstraintValueInfo;
import com.google.devtools.build.lib.analysis.platform.PlatformInfo;
import com.google.devtools.build.lib.analysis.platform.ToolchainInfo;
import com.google.devtools.build.lib.analysis.starlark.StarlarkRuleContext;
import com.google.devtools.build.lib.analysis.stringtemplate.TemplateContext;
import com.google.devtools.build.lib.cmdline.Label;
import com.google.devtools.build.lib.cmdline.RepositoryName;
import com.google.devtools.build.lib.collect.ImmutableSortedKeyListMultimap;
import com.google.devtools.build.lib.collect.nestedset.NestedSet;
import com.google.devtools.build.lib.events.Event;
import com.google.devtools.build.lib.packages.Aspect;
import com.google.devtools.build.lib.packages.AspectDescriptor;
import com.google.devtools.build.lib.packages.Attribute;
import com.google.devtools.build.lib.packages.AttributeMap;
import com.google.devtools.build.lib.packages.BazelStarlarkContext;
import com.google.devtools.build.lib.packages.BuildType;
import com.google.devtools.build.lib.packages.BuiltinProvider;
import com.google.devtools.build.lib.packages.ConfigurationFragmentPolicy;
import com.google.devtools.build.lib.packages.ConfiguredAttributeMapper;
import com.google.devtools.build.lib.packages.ImplicitOutputsFunction;
import com.google.devtools.build.lib.packages.Info;
import com.google.devtools.build.lib.packages.OutputFile;
import com.google.devtools.build.lib.packages.Package;
import com.google.devtools.build.lib.packages.Package.ConfigSettingVisibilityPolicy;
import com.google.devtools.build.lib.packages.PackageSpecification.PackageGroupContents;
import com.google.devtools.build.lib.packages.RawAttributeMapper;
import com.google.devtools.build.lib.packages.RequiredProviders;
import com.google.devtools.build.lib.packages.Rule;
import com.google.devtools.build.lib.packages.RuleClass;
import com.google.devtools.build.lib.packages.RuleClass.ConfiguredTargetFactory.RuleErrorException;
import com.google.devtools.build.lib.packages.StarlarkProviderWrapper;
import com.google.devtools.build.lib.packages.SymbolGenerator;
import com.google.devtools.build.lib.packages.Target;
import com.google.devtools.build.lib.packages.TargetUtils;
import com.google.devtools.build.lib.packages.Type;
import com.google.devtools.build.lib.packages.Type.LabelClass;
import com.google.devtools.build.lib.packages.semantics.BuildLanguageOptions;
import com.google.devtools.build.lib.skyframe.ConfiguredTargetAndData;
import com.google.devtools.build.lib.util.FileTypeSet;
import com.google.devtools.build.lib.util.OS;
import com.google.devtools.build.lib.util.OrderedSetMultimap;
import com.google.devtools.build.lib.util.StringUtil;
import com.google.devtools.build.lib.vfs.FileSystemUtils;
import com.google.devtools.build.lib.vfs.PathFragment;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import javax.annotation.Nullable;
import net.starlark.java.eval.EvalException;
import net.starlark.java.eval.Mutability;
import net.starlark.java.eval.Starlark;
import net.starlark.java.eval.StarlarkSemantics;
import net.starlark.java.eval.StarlarkThread;
import net.starlark.java.syntax.Identifier;
import net.starlark.java.syntax.Location;
/**
* The totality of data available during the analysis of a rule.
*
*
These objects should not outlast the analysis phase. Do not pass them to {@link
* com.google.devtools.build.lib.actions.Action} objects or other persistent objects. There are
* internal tests to ensure that RuleContext objects are not persisted that check the name of this
* class, so update those tests if you change this class's name.
*
* @see com.google.devtools.build.lib.analysis.RuleConfiguredTargetFactory
*/
public final class RuleContext extends TargetContext
implements ActionConstructionContext, ActionRegistry, RuleErrorConsumer, AutoCloseable {
/** Custom dependency validation logic. */
public interface PrerequisiteValidator {
/**
* Checks whether the rule in {@code contextBuilder} is allowed to depend on {@code
* prerequisite} through the attribute {@code attribute}.
*
*
Can be used for enforcing any organization-specific policies about the layout of the
* workspace.
*/
void validate(
Builder contextBuilder, ConfiguredTargetAndData prerequisite, Attribute attribute);
}
public static final String TOOLCHAIN_ATTR_NAME = "$toolchain";
/** A fake attribute to use for toolchain-related validation errors. */
private static final Attribute TOOLCHAIN_ATTRIBUTE =
new Attribute.Builder<>(TOOLCHAIN_ATTR_NAME, BuildType.LABEL_LIST).build();
private final Rule rule;
/**
* A list of all aspects applied to the target. If this {@code RuleContext} is for a rule
* implementation, {@code aspects} is an empty list.
*
*
Otherwise, the last aspect in the list is the one that this {@code RuleContext} is for.
*/
private final ImmutableList aspects;
private final ImmutableList aspectDescriptors;
private final ListMultimap targetMap;
private final ImmutableMap configConditions;
private final AspectAwareAttributeMapper attributes;
private final FeatureSet features;
private final String ruleClassNameForLogging;
private final ConfigurationFragmentPolicy configurationFragmentPolicy;
private final ConfiguredRuleClassProvider ruleClassProvider;
private final RuleErrorConsumer reporter;
@Nullable private final ToolchainCollection toolchainContexts;
private final ExecGroupCollection execGroupCollection;
@Nullable private final RequiredConfigFragmentsProvider requiredConfigFragments;
@Nullable private final NestedSet transitivePackagesForRunfileRepoMappingManifest;
private final List makeVariableExpanders = new ArrayList<>();
/** Map of exec group names to ActionOwners. */
private final Map actionOwners = new HashMap<>();
private final SymbolGenerator actionOwnerSymbolGenerator;
/* lazily computed cache for Make variables, computed from the above. See get... method */
private transient ConfigurationMakeVariableContext configurationMakeVariableContext = null;
/**
* Thread used for any Starlark evaluation during analysis, e.g. rule implementation function for
* a Starlark-defined rule, or Starlarkified helper logic for native rules that have been
* partially migrated to {@code @_builtins}.
*/
private final StarlarkThread starlarkThread;
/**
* The {@code ctx} object passed to a Starlark-defined rule's or aspect's implementation function.
* This object may outlive the analysis phase, e.g. if it is returned in a provider.
*
*
Initialized explicitly by calling {@link #initStarlarkRuleContext}. Native rules that do not
* pass this object to {@code @_builtins} might avoid the cost of initializing this object, but
* for everyone else it's mandatory.
*/
@Nullable private StarlarkRuleContext starlarkRuleContext;
private RuleContext(
Builder builder,
AttributeMap attributes,
ListMultimap targetMap,
ExecGroupCollection execGroupCollection) {
super(
builder.env,
builder.target.getAssociatedRule(),
builder.configuration,
builder.prerequisiteMap.get(null),
builder.visibility);
this.rule = builder.target.getAssociatedRule();
this.aspects = builder.aspects;
this.aspectDescriptors = aspects.stream().map(Aspect::getDescriptor).collect(toImmutableList());
this.configurationFragmentPolicy = builder.configurationFragmentPolicy;
this.ruleClassProvider = builder.ruleClassProvider;
this.targetMap = targetMap;
this.configConditions = builder.configConditions.asProviders();
this.attributes = new AspectAwareAttributeMapper(attributes, builder.aspectAttributes);
this.features = computeFeatures();
this.ruleClassNameForLogging = builder.getRuleClassNameForLogging();
this.actionOwnerSymbolGenerator = new SymbolGenerator<>(builder.actionOwnerSymbol);
this.reporter = builder.reporter;
this.toolchainContexts = builder.toolchainContexts;
this.execGroupCollection = execGroupCollection;
this.requiredConfigFragments = builder.requiredConfigFragments;
this.transitivePackagesForRunfileRepoMappingManifest =
builder.transitivePackagesForRunfileRepoMappingManifest;
this.starlarkThread = createStarlarkThread(builder.mutability); // uses above state
}
private FeatureSet computeFeatures() {
FeatureSet pkg = rule.getPackage().getPackageArgs().features();
FeatureSet rule =
attributes().has("features", Type.STRING_LIST)
? FeatureSet.parse(attributes().get("features", Type.STRING_LIST))
: FeatureSet.EMPTY;
return FeatureSet.mergeWithGlobalFeatures(
FeatureSet.merge(pkg, rule), getConfiguration().getDefaultFeatures());
}
public boolean isAllowTagsPropagation() {
return getAnalysisEnvironment()
.getStarlarkSemantics()
.getBool(BuildLanguageOptions.INCOMPATIBLE_ALLOW_TAGS_PROPAGATION);
}
public RepositoryName getRepository() {
return rule.getRepository();
}
@Override
public ArtifactRoot getBinDirectory() {
return getConfiguration().getBinDirectory(getLabel().getRepository());
}
@SuppressWarnings("Unused") // Goal is to migrate here.
public ArtifactRoot getBuildInfoDirectory() {
return getConfiguration().getBuildInfoDirectory(getLabel().getRepository());
}
public ArtifactRoot getGenfilesDirectory() {
return getConfiguration().getGenfilesDirectory(getLabel().getRepository());
}
public ArtifactRoot getCoverageMetadataDirectory() {
return getConfiguration().getCoverageMetadataDirectory(getLabel().getRepository());
}
public ArtifactRoot getTestLogsDirectory() {
return getConfiguration().getTestLogsDirectory(getLabel().getRepository());
}
public PathFragment getBinFragment() {
return getConfiguration().getBinFragment(getLabel().getRepository());
}
public PathFragment getGenfilesFragment() {
return getConfiguration().getGenfilesFragment(getLabel().getRepository());
}
@Override
public ArtifactRoot getMiddlemanDirectory() {
return getConfiguration().getMiddlemanDirectory(getLabel().getRepository());
}
public Rule getRule() {
return rule;
}
public ImmutableList getAspects() {
return aspects;
}
/**
* If this target's configuration suppresses analysis failures, this returns a list of strings,
* where each string corresponds to a description of an error that occurred during processing this
* target.
*
* @throws IllegalStateException if this target's configuration does not suppress analysis
* failures (if {@code getConfiguration().allowAnalysisFailures()} is false)
*/
public List getSuppressedErrorMessages() {
Preconditions.checkState(
getConfiguration().allowAnalysisFailures(),
"Error messages can only be retrieved via RuleContext if allow_analysis_failures is true");
Preconditions.checkState(
reporter instanceof SuppressingErrorReporter, "Unexpected error reporter");
return ((SuppressingErrorReporter) reporter).getErrorMessages();
}
/**
* If this RuleContext is for an aspect implementation, returns that aspect. (it is
* the last aspect in the list of aspects applied to a target; all other aspects are the ones main
* aspect sees as specified by its "required_aspect_providers") Otherwise returns null
* .
*/
@Nullable
public Aspect getMainAspect() {
return Streams.findLast(aspects.stream()).orElse(null);
}
/**
* Returns a rule class name suitable for log messages, including an aspect name if applicable.
*/
public String getRuleClassNameForLogging() {
return ruleClassNameForLogging;
}
/** Returns the workspace name for the rule. */
public String getWorkspaceName() {
return rule.getPackage().getWorkspaceName();
}
/** The configuration conditions that trigger this rule's configurable attributes. */
public ImmutableMap getConfigConditions() {
return configConditions;
}
/** All aspects applied to the rule. */
public ImmutableList getAspectDescriptors() {
return aspectDescriptors;
}
/**
* Accessor for the attributes of the rule and its aspects.
*
*
The rule's native attributes can be queried both on their structure / existence and values
* Aspect attributes can only be queried on their structure.
*
*
This should be the sole interface for reading rule/aspect attributes in {@link RuleContext}.
* Don't expose other access points through new public methods.
*/
public AttributeMap attributes() {
return attributes;
}
@Override
public boolean hasErrors() {
return reporter.hasErrors();
}
/**
* Returns an immutable map from attribute name to list of configured targets for that attribute.
*/
public ListMultimap getConfiguredTargetMap() {
return Multimaps.transformValues(targetMap, ConfiguredTargetAndData::getConfiguredTarget);
}
/**
* Returns an immutable map from attribute name to list of {@link ConfiguredTargetAndData} objects
* for that attribute.
*/
public ListMultimap getConfiguredTargetAndDataMap() {
return targetMap;
}
/** Returns the {@link ConfiguredTargetAndData} the given attribute. */
public List getPrerequisiteConfiguredTargets(String attributeName) {
return targetMap.get(attributeName);
}
@Override
public ActionOwner getActionOwner() {
return getActionOwner(DEFAULT_EXEC_GROUP_NAME);
}
/**
* Returns a special action owner for test actions. Test actions should run on the target platform
* rather than the host platform. Note that the value is not cached (on the assumption that this
* method is only called once).
*/
public ActionOwner getTestActionOwner() {
PlatformInfo testExecutionPlatform;
ImmutableMap testExecProperties;
// If we have a toolchain, pull the target platform out of it.
if (toolchainContexts != null) {
// TODO(https://github.com/bazelbuild/bazel/issues/17466): This doesn't respect execution
// properties coming from the target's `exec_properties` attribute.
// src/test/java/com/google/devtools/build/lib/analysis/test/TestActionBuilderTest.java has a
// test to test for it when it gets figured out.
testExecutionPlatform = toolchainContexts.getTargetPlatform();
testExecProperties = testExecutionPlatform.execProperties();
} else {
testExecutionPlatform = null;
testExecProperties = getExecGroups().getExecProperties(DEFAULT_TEST_RUNNER_EXEC_GROUP);
}
ActionOwner actionOwner =
createActionOwner(
rule, aspectDescriptors, getConfiguration(), testExecProperties, testExecutionPlatform);
if (actionOwner == null) {
actionOwner = getActionOwner();
}
return actionOwner;
}
@Override
@Nullable
public ActionOwner getActionOwner(String execGroup) {
if (actionOwners.containsKey(execGroup)) {
return actionOwners.get(execGroup);
}
if (toolchainContexts != null && !toolchainContexts.hasToolchainContext(execGroup)) {
return null;
}
ActionOwner actionOwner =
createActionOwner(
rule,
aspectDescriptors,
getConfiguration(),
execGroupCollection.getExecProperties(execGroup),
getExecutionPlatform(execGroup));
actionOwners.put(execGroup, actionOwner);
return actionOwner;
}
/**
* An opaque symbol generator to be used when identifying objects by their action owner/index of
* creation. Only needed if an object needs to know whether it was created by the same action
* owner in the same order as another object. Each symbol must call {@link
* SymbolGenerator#generate} separately to obtain a unique object.
*/
public SymbolGenerator getSymbolGenerator() {
return actionOwnerSymbolGenerator;
}
/** Returns a configuration fragment for this this target. */
@Nullable
public T getFragment(Class fragment) {
return getFragment(fragment, fragment.getSimpleName(), "");
}
@Nullable
private T getFragment(
Class fragment, String name, String additionalErrorMessage) {
// TODO(bazel-team): The fragments can also be accessed directly through
// BuildConfigurationValue. Can we lock that down somehow?
Preconditions.checkArgument(
isLegalFragment(fragment),
"%s has to declare '%s' as a required fragment in order to access it.%s",
ruleClassNameForLogging,
name,
additionalErrorMessage);
return getConfiguration().getFragment(fragment);
}
@Nullable
public Fragment getStarlarkFragment(String name) throws EvalException {
Class fragmentClass = getConfiguration().getStarlarkFragmentByName(name);
if (fragmentClass == null) {
return null;
}
try {
Preconditions.checkArgument(
isLegalFragment(fragmentClass),
"%s has to declare '%s' as a required fragment in order to access it."
+ " Please update the 'fragments' argument of the rule definition "
+ "(for example: fragments = [\"%s\"])",
ruleClassNameForLogging,
name,
name);
return getConfiguration().getFragment(fragmentClass);
} catch (IllegalArgumentException ex) { // fishy
throw new EvalException(ex.getMessage());
}
}
public ImmutableCollection getStarlarkFragmentNames() {
return getConfiguration().getStarlarkFragmentNames();
}
public boolean isLegalFragment(Class fragment) {
return ruleClassProvider.getFragmentRegistry().getUniversalFragments().contains(fragment)
|| configurationFragmentPolicy.isLegalConfigurationFragment(fragment);
}
@Override
public ActionLookupKey getOwner() {
return getAnalysisEnvironment().getOwner();
}
public ImmutableList getBuildInfo(BuildInfoKey key) throws InterruptedException {
return getAnalysisEnvironment()
.getBuildInfo(
AnalysisUtils.isStampingEnabled(this, getConfiguration()), key, getConfiguration());
}
@VisibleForTesting
public static ActionOwner createActionOwner(
Rule rule,
ImmutableList aspectDescriptors,
BuildConfigurationValue buildConfigurationValue,
ImmutableMap execProperties,
@Nullable PlatformInfo executionPlatform) {
return ActionOwner.create(
rule.getLabel(),
rule.getLocation(),
rule.getTargetKind(),
buildConfigurationValue,
executionPlatform,
aspectDescriptors,
execProperties);
}
@Override
public void registerAction(ActionAnalysisMetadata action) {
getAnalysisEnvironment().registerAction(action);
}
/**
* Convenience function for subclasses to report non-attribute-specific errors in the current
* rule.
*/
@Override
public void ruleError(String message) {
reporter.ruleError(message);
}
/**
* Convenience function for subclasses to report non-attribute-specific warnings in the current
* rule.
*/
@Override
public void ruleWarning(String message) {
reporter.ruleWarning(message);
}
/**
* Convenience function for subclasses to report attribute-specific errors in the current rule.
*
*
If the name of the attribute starts with $ it is replaced with a string
* (an implicit dependency).
*/
@Override
public void attributeError(String attrName, String message) {
reporter.attributeError(attrName, message);
}
/**
* Like attributeError, but does not mark the configured target as errored.
*
*
If the name of the attribute starts with $ it is replaced with a string
* (an implicit dependency).
*/
@Override
public void attributeWarning(String attrName, String message) {
reporter.attributeWarning(attrName, message);
}
/**
* Returns an artifact beneath the root of either the "bin" or "genfiles" tree, whose path is
* based on the name of this target and the current configuration. The choice of which tree to use
* is based on the rule with which this target (which must be an OutputFile or a Rule) is
* associated.
*/
public Artifact createOutputArtifact() {
Target target = getTarget();
PathFragment rootRelativePath =
getPackageDirectory().getRelative(PathFragment.create(target.getName()));
return internalCreateOutputArtifact(rootRelativePath, target, OutputFile.Kind.FILE);
}
/**
* Returns the output artifact of an {@link OutputFile} of this target.
*
* @see #createOutputArtifact()
*/
public Artifact createOutputArtifact(OutputFile out) {
PathFragment packageRelativePath =
getPackageDirectory().getRelative(PathFragment.create(out.getName()));
return internalCreateOutputArtifact(packageRelativePath, out, out.getKind());
}
/**
* Returns an artifact beneath the root of either the "bin" or "genfiles" tree, whose path is
* based on the name of this target and the current configuration, with a script suffix
* appropriate for the current host platform. ({@code .cmd} for Windows, otherwise {@code .sh}).
* The choice of which tree to use is based on the rule with which this target (which must be an
* OutputFile or a Rule) is associated.
*/
public Artifact createOutputArtifactScript() {
Target target = getTarget();
String fileExtension = isExecutedOnWindows() ? ".cmd" : ".sh";
PathFragment rootRelativePath =
getPackageDirectory().getRelative(PathFragment.create(target.getName() + fileExtension));
return internalCreateOutputArtifact(rootRelativePath, target, OutputFile.Kind.FILE);
}
/**
* Implementation for {@link #createOutputArtifact()} and {@link
* #createOutputArtifact(OutputFile)}. This is private so that {@link
* #createOutputArtifact(OutputFile)} can have a more specific signature.
*/
private Artifact internalCreateOutputArtifact(
PathFragment rootRelativePath, Target target, OutputFile.Kind outputFileKind) {
Preconditions.checkState(
target.getLabel().getPackageIdentifier().equals(getLabel().getPackageIdentifier()),
"Creating output artifact for target '%s' in different package than the rule '%s' "
+ "being analyzed",
target.getLabel(),
getLabel());
ArtifactRoot root = getBinOrGenfilesDirectory();
switch (outputFileKind) {
case FILE:
return getDerivedArtifact(rootRelativePath, root);
case FILESET:
return getAnalysisEnvironment().getFilesetArtifact(rootRelativePath, root);
default:
throw new IllegalStateException();
}
}
/**
* Returns the root of either the "bin" or "genfiles" tree, based on this target and the current
* configuration. The choice of which tree to use is based on the rule with which this target
* (which must be an OutputFile or a Rule) is associated.
*/
@Override
public ArtifactRoot getBinOrGenfilesDirectory() {
return rule.outputsToBindir()
? getConfiguration().getBinDirectory(getLabel().getRepository())
: getConfiguration().getGenfilesDirectory(getLabel().getRepository());
}
/**
* Creates an artifact in a directory that is unique to the package that contains the rule, thus
* guaranteeing that it never clashes with artifacts created by rules in other packages.
*/
public Artifact getBinArtifact(String relative) {
return getBinArtifact(PathFragment.create(relative));
}
public Artifact getBinArtifact(PathFragment relative) {
return getPackageRelativeArtifact(
relative, getConfiguration().getBinDirectory(getLabel().getRepository()));
}
/**
* Creates an artifact in a directory that is unique to the package that contains the rule, thus
* guaranteeing that it never clashes with artifacts created by rules in other packages.
*/
public Artifact getGenfilesArtifact(String relative) {
return getGenfilesArtifact(PathFragment.create(relative));
}
public Artifact getGenfilesArtifact(PathFragment relative) {
return getPackageRelativeArtifact(
relative, getConfiguration().getGenfilesDirectory(getLabel().getRepository()));
}
@Override
public Artifact getShareableArtifact(PathFragment rootRelativePath, ArtifactRoot root) {
return getAnalysisEnvironment().getDerivedArtifact(rootRelativePath, root);
}
@Override
public Artifact.DerivedArtifact getPackageRelativeArtifact(
PathFragment relative, ArtifactRoot root) {
return getPackageRelativeArtifact(relative, root, /* contentBasedPath= */ false);
}
/**
* Same as {@link #getPackageRelativeArtifact(PathFragment, ArtifactRoot)} but includes the option
* option to use a content-based path for this artifact (see {@link
* BuildConfigurationValue#useContentBasedOutputPaths()}).
*/
private Artifact.DerivedArtifact getPackageRelativeArtifact(
PathFragment relative, ArtifactRoot root, boolean contentBasedPath) {
return getDerivedArtifact(getPackageDirectory().getRelative(relative), root, contentBasedPath);
}
/**
* Creates an artifact in a directory that is unique to the package that contains the rule, thus
* guaranteeing that it never clashes with artifacts created by rules in other packages.
*/
public Artifact getPackageRelativeArtifact(String relative, ArtifactRoot root) {
return getPackageRelativeArtifact(relative, root, /* contentBasedPath= */ false);
}
/**
* Same as {@link #getPackageRelativeArtifact(String, ArtifactRoot)} but includes the option to
* use a content-based path for this artifact (see {@link
* BuildConfigurationValue#useContentBasedOutputPaths()}).
*/
private Artifact getPackageRelativeArtifact(
String relative, ArtifactRoot root, boolean contentBasedPath) {
return getPackageRelativeArtifact(PathFragment.create(relative), root, contentBasedPath);
}
@Override
public PathFragment getPackageDirectory() {
return getLabel()
.getPackageIdentifier()
.getPackagePath(getConfiguration().isSiblingRepositoryLayout());
}
/**
* Creates an artifact under a given root with the given root-relative path.
*
*
Verifies that it is in the root-relative directory corresponding to the package of the rule,
* thus ensuring that it doesn't clash with other artifacts generated by other rules using this
* method.
*/
@Override
public Artifact.DerivedArtifact getDerivedArtifact(
PathFragment rootRelativePath, ArtifactRoot root) {
return getDerivedArtifact(rootRelativePath, root, /* contentBasedPath= */ false);
}
/**
* Same as {@link #getDerivedArtifact(PathFragment, ArtifactRoot)} but includes the option to use
* a content-based path for this artifact (see {@link
* BuildConfigurationValue#useContentBasedOutputPaths()}).
*/
public Artifact.DerivedArtifact getDerivedArtifact(
PathFragment rootRelativePath, ArtifactRoot root, boolean contentBasedPath) {
Preconditions.checkState(
rootRelativePath.startsWith(getPackageDirectory()),
"Output artifact '%s' not under package directory '%s' for target '%s'",
rootRelativePath,
getPackageDirectory(),
getLabel());
return getAnalysisEnvironment().getDerivedArtifact(rootRelativePath, root, contentBasedPath);
}
@Override
public SpecialArtifact getTreeArtifact(PathFragment rootRelativePath, ArtifactRoot root) {
Preconditions.checkState(
rootRelativePath.startsWith(getPackageDirectory()),
"Output artifact '%s' not under package directory '%s' for target '%s'",
rootRelativePath,
getPackageDirectory(),
getLabel());
return getAnalysisEnvironment().getTreeArtifact(rootRelativePath, root);
}
/**
* Creates a tree artifact in a directory that is unique to the package that contains the rule,
* thus guaranteeing that it never clashes with artifacts created by rules in other packages.
*/
public Artifact getPackageRelativeTreeArtifact(PathFragment relative, ArtifactRoot root) {
return getTreeArtifact(getPackageDirectory().getRelative(relative), root);
}
public Artifact getPackageRelativeTreeArtifact(String relative, ArtifactRoot root) {
return getPackageRelativeTreeArtifact(PathFragment.create(relative), root);
}
/**
* Creates an artifact in a directory that is unique to the rule, thus guaranteeing that it never
* clashes with artifacts created by other rules.
*/
public Artifact getUniqueDirectoryArtifact(
String uniqueDirectory, String relative, ArtifactRoot root) {
return getUniqueDirectoryArtifact(uniqueDirectory, PathFragment.create(relative), root);
}
@Override
public Artifact getUniqueDirectoryArtifact(String uniqueDirectorySuffix, String relative) {
return getUniqueDirectoryArtifact(uniqueDirectorySuffix, relative, getBinOrGenfilesDirectory());
}
@Override
public Artifact getUniqueDirectoryArtifact(String uniqueDirectorySuffix, PathFragment relative) {
return getUniqueDirectoryArtifact(uniqueDirectorySuffix, relative, getBinOrGenfilesDirectory());
}
@Override
public Artifact getUniqueDirectoryArtifact(
String uniqueDirectory, PathFragment relative, ArtifactRoot root) {
return getDerivedArtifact(getUniqueDirectory(uniqueDirectory).getRelative(relative), root);
}
/**
* Returns true iff the rule, or any attached aspect, has an attribute with the given name and
* type.
*/
public boolean isAttrDefined(String attrName, Type type) {
return attributes().has(attrName, type);
}
/**
* Returns the dependencies through a {@code LABEL_DICT_UNARY} attribute as a map from a string to
* a {@link TransitiveInfoCollection}.
*/
public Map getPrerequisiteMap(String attributeName) {
Preconditions.checkState(attributes().has(attributeName, BuildType.LABEL_DICT_UNARY));
ImmutableMap.Builder result = ImmutableMap.builder();
Map dict = attributes().get(attributeName, BuildType.LABEL_DICT_UNARY);
Map labelToDep = new HashMap<>();
for (ConfiguredTargetAndData dep : targetMap.get(attributeName)) {
labelToDep.put(dep.getTargetLabel(), dep.getConfiguredTarget());
}
for (Map.Entry entry : dict.entrySet()) {
result.put(entry.getKey(), Preconditions.checkNotNull(labelToDep.get(entry.getValue())));
}
return result.buildOrThrow();
}
/**
* Returns the prerequisites keyed by their configuration transition keys. If the split transition
* is not active (e.g. split() returned an empty list), the key is an empty Optional.
*/
public Map, ? extends List>
getSplitPrerequisites(String attributeName) {
return Maps.transformValues(
getSplitPrerequisiteConfiguredTargetAndTargets(attributeName),
(ctatList) -> Lists.transform(ctatList, ConfiguredTargetAndData::getConfiguredTarget));
}
/**
* Returns the prerequisites keyed by their transition keys. If the split transition is not active
* (e.g. split() returned an empty list), the key is an empty Optional.
*/
public Map, List>
getSplitPrerequisiteConfiguredTargetAndTargets(String attributeName) {
checkAttributeIsDependency(attributeName);
// Use an ImmutableListMultimap.Builder here to preserve ordering.
ImmutableListMultimap.Builder, ConfiguredTargetAndData> result =
ImmutableListMultimap.builder();
List deps = getPrerequisiteConfiguredTargets(attributeName);
for (ConfiguredTargetAndData t : deps) {
ImmutableList transitionKeys = t.getTransitionKeys();
if (transitionKeys.isEmpty()) {
// The split transition is not active, i.e. does not change build configurations.
// TODO(jungjw): Investigate if we need to do a check here.
return ImmutableMap.of(Optional.absent(), deps);
}
for (String key : transitionKeys) {
result.put(Optional.of(key), t);
}
}
return Multimaps.asMap(result.build());
}
/**
* Returns the specified provider of the prerequisite referenced by the attribute in the argument.
* If the attribute is empty or it does not support the specified provider, returns null.
*/
@Nullable
public C getPrerequisite(
String attributeName, Class provider) {
TransitiveInfoCollection prerequisite = getPrerequisite(attributeName);
return prerequisite == null ? null : prerequisite.getProvider(provider);
}
/**
* Returns the transitive info collection that feeds into this target through the specified
* attribute. Returns null if the attribute is empty.
*/
@Nullable
public TransitiveInfoCollection getPrerequisite(String attributeName) {
ConfiguredTargetAndData result = getPrerequisiteConfiguredTargetAndData(attributeName);
return result == null ? null : result.getConfiguredTarget();
}
/**
* Returns the declared provider (native and Starlark) for the specified constructor under the
* specified attribute of this target in the BUILD file. May return null if there is no
* TransitiveInfoCollection under the specified attribute.
*/
@Nullable
public T getPrerequisite(String attributeName, BuiltinProvider starlarkKey) {
TransitiveInfoCollection prerequisite = getPrerequisite(attributeName);
return prerequisite == null ? null : prerequisite.get(starlarkKey);
}
/**
* Returns the {@link ConfiguredTargetAndData} that feeds ino this target through the specified
* attribute. Returns null if the attribute is empty.
*/
@Nullable
public ConfiguredTargetAndData getPrerequisiteConfiguredTargetAndData(String attributeName) {
checkAttributeIsDependency(attributeName);
List elements = getPrerequisiteConfiguredTargets(attributeName);
Preconditions.checkState(
elements.size() <= 1,
"%s attribute %s produces more than one prerequisite",
ruleClassNameForLogging,
attributeName);
return elements.isEmpty() ? null : elements.get(0);
}
/**
* For a given attribute, returns all declared provider provided by targets of that attribute.
* Each declared provider is keyed by the {@link BuildConfigurationValue} under which the provider
* was created.
*/
public
ImmutableListMultimap getPrerequisitesByConfiguration(
String attributeName, BuiltinProvider provider) {
checkAttributeIsDependency(attributeName);
List ctatCollection = getPrerequisiteConfiguredTargets(attributeName);
ImmutableListMultimap.Builder result =
ImmutableListMultimap.builder();
for (ConfiguredTargetAndData prerequisite : ctatCollection) {
C prerequisiteProvider = prerequisite.getConfiguredTarget().get(provider);
if (prerequisiteProvider != null) {
result.put(prerequisite.getConfiguration(), prerequisiteProvider);
}
}
return result.build();
}
/**
* Returns the list of transitive info collections that feed into this target through the
* specified attribute.
*/
public List getPrerequisites(String attributeName) {
if (!attributes().has(attributeName)) {
return ImmutableList.of();
}
List prerequisiteConfiguredTargets;
// android_binary, android_test, and android_binary_internal override deps to use a split
// transition.
if ((rule.getRuleClass().equals("android_binary")
|| rule.getRuleClass().equals("android_test")
|| rule.getRuleClass().equals("android_binary_internal"))
&& attributeName.equals("deps")
&& attributes().getAttributeDefinition(attributeName).getTransitionFactory().isSplit()) {
// TODO(b/168038145): Restore legacy behavior of returning the prerequisites from the first
// portion of the split transition.
// Callers should be identified, cleaned up, and this check removed.
Map, List> map =
getSplitPrerequisiteConfiguredTargetAndTargets(attributeName);
prerequisiteConfiguredTargets =
map.isEmpty() ? ImmutableList.of() : map.entrySet().iterator().next().getValue();
} else {
prerequisiteConfiguredTargets = getPrerequisiteConfiguredTargets(attributeName);
}
return Lists.transform(
prerequisiteConfiguredTargets, ConfiguredTargetAndData::getConfiguredTarget);
}
/**
* Returns all the providers of the specified type that are listed under the specified attribute
* of this target in the BUILD file.
*/
public List getPrerequisites(
String attributeName, Class classType) {
AnalysisUtils.checkProvider(classType);
return AnalysisUtils.getProviders(getPrerequisites(attributeName), classType);
}
/**
* Returns all the declared Starlark wrapped providers for the specified constructor under the
* specified attribute of this target in the BUILD file.
*/
public ImmutableList getPrerequisites(
String attributeName, StarlarkProviderWrapper starlarkKey) throws RuleErrorException {
return AnalysisUtils.getProviders(getPrerequisites(attributeName), starlarkKey);
}
/**
* Returns all the declared providers (native and Starlark) for the specified constructor under
* the specified attribute of this target in the BUILD file.
*/
public List getPrerequisites(
String attributeName, BuiltinProvider starlarkKey) {
return AnalysisUtils.getProviders(getPrerequisites(attributeName), starlarkKey);
}
/**
* Returns all the providers of the specified type that are listed under the specified attribute
* of this target in the BUILD file, and that contain the specified provider.
*/
public
Iterable getPrerequisitesIf(
String attributeName, Class classType) {
AnalysisUtils.checkProvider(classType);
return AnalysisUtils.filterByProvider(getPrerequisites(attributeName), classType);
}
/**
* Returns all the providers of the specified type that are listed under the specified attribute
* of this target in the BUILD file, and that contain the specified provider.
*/
public Iterable getPrerequisitesIf(
String attributeName, BuiltinProvider classType) {
return AnalysisUtils.filterByProvider(getPrerequisites(attributeName), classType);
}
/**
* Returns the prerequisite referred to by the specified attribute. Also checks whether the
* attribute is marked as executable and that the target referred to can actually be executed.
*
* @param attributeName the name of the attribute
* @return the {@link FilesToRunProvider} interface of the prerequisite.
*/
@Nullable
public FilesToRunProvider getExecutablePrerequisite(String attributeName) {
Attribute ruleDefinition = attributes().getAttributeDefinition(attributeName);
Preconditions.checkNotNull(
ruleDefinition, "%s attribute %s is not defined", ruleClassNameForLogging, attributeName);
Preconditions.checkState(
ruleDefinition.isExecutable(),
"%s attribute %s is not configured to be executable",
ruleClassNameForLogging,
attributeName);
TransitiveInfoCollection prerequisite = getPrerequisite(attributeName);
if (prerequisite == null) {
return null;
}
FilesToRunProvider result = prerequisite.getProvider(FilesToRunProvider.class);
if (result == null || result.getExecutable() == null) {
attributeError(
attributeName, prerequisite.getLabel() + " does not refer to a valid executable target");
}
return result;
}
public void initConfigurationMakeVariableContext(
Iterable makeVariableSuppliers) {
Preconditions.checkState(
configurationMakeVariableContext == null,
"Attempted to init an already initialized Make var context (did you call"
+ " initConfigurationMakeVariableContext() after accessing ctx.var?)");
configurationMakeVariableContext =
new ConfigurationMakeVariableContext(
this, rule.getPackage(), getConfiguration(), makeVariableSuppliers);
}
public Expander getExpander(TemplateContext templateContext) {
Expander expander = new Expander(this, templateContext);
makeVariableExpanders.add(expander);
return expander;
}
public Expander getExpander() {
Expander expander = new Expander(this, getConfigurationMakeVariableContext());
makeVariableExpanders.add(expander);
return expander;
}
public Expander getExpander(ImmutableMap> labelMap) {
Expander expander = new Expander(this, getConfigurationMakeVariableContext(), labelMap);
makeVariableExpanders.add(expander);
return expander;
}
/**
* Returns a cached context that maps Make variable names (string) to values (string) without any
* extra {@link MakeVariableSupplier}.
*
*
CAUTION: If there's no context, this will initialize the context with no
* MakeVariableSuppliers. Call {@link #initConfigurationMakeVariableContext} first if you want to
* register suppliers.
*/
public ConfigurationMakeVariableContext getConfigurationMakeVariableContext() {
if (configurationMakeVariableContext == null) {
initConfigurationMakeVariableContext(ImmutableList.of());
}
return configurationMakeVariableContext;
}
private StarlarkThread createStarlarkThread(Mutability mutability) {
AnalysisEnvironment env = getAnalysisEnvironment();
StarlarkThread thread = new StarlarkThread(mutability, env.getStarlarkSemantics());
thread.setPrintHandler(Event.makeDebugPrintHandler(env.getEventHandler()));
new BazelStarlarkContext(
BazelStarlarkContext.Phase.ANALYSIS,
getSymbolGenerator(),
/* analysisRuleLabel= */ getLabel())
.storeInThread(thread);
return thread;
}
public StarlarkThread getStarlarkThread() {
return starlarkThread;
}
/**
* Initializes the StarlarkRuleContext for use and returns it. No-op if already initialized.
*
*
Throws RuleErrorException on failure.
*/
public StarlarkRuleContext initStarlarkRuleContext() throws RuleErrorException {
if (starlarkRuleContext == null) {
AspectDescriptor descriptor =
aspects.isEmpty() ? null : Iterables.getLast(aspects).getDescriptor();
this.starlarkRuleContext = new StarlarkRuleContext(this, descriptor);
}
return starlarkRuleContext;
}
public StarlarkRuleContext getStarlarkRuleContext() {
Preconditions.checkNotNull(starlarkRuleContext, "Must call initStarlarkRuleContext() first");
return starlarkRuleContext;
}
/**
* Retrieves the {@code @_builtins}-defined Starlark object registered in the {@code
* exported_to_java} mapping under the given name.
*
*
Reports and raises a rule error if no symbol by that name is defined.
*/
public Object getStarlarkDefinedBuiltin(String name)
throws RuleErrorException, InterruptedException {
Object result = getAnalysisEnvironment().getStarlarkDefinedBuiltins().get(name);
if (result == null) {
throwWithRuleError(
String.format(
"(Internal error) No symbol named '%s' defined in the @_builtins exported_to_java"
+ " dict",
name));
}
return result;
}
/**
* Calls a Starlark function in this rule's Starlark thread with the given positional and keyword
* arguments. On failure, calls {@link #throwWithRuleError} with the Starlark stack trace.
*
*
This convenience method avoids the need to catch EvalException when the failure would just
* immediately terminate rule analysis anyway.
*/
public Object callStarlarkOrThrowRuleError(
Object func, List