blob: 1c9ba345b376193c20bbf5941765c669ee9b033b [file] [log] [blame]
// 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.packages;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableListMultimap;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSortedSet;
import com.google.common.collect.LinkedHashMultimap;
import com.google.common.collect.Multimap;
import com.google.common.collect.SetMultimap;
import com.google.devtools.build.lib.cmdline.Label;
import com.google.devtools.build.lib.cmdline.LabelSyntaxException;
import com.google.devtools.build.lib.cmdline.PackageIdentifier;
import com.google.devtools.build.lib.cmdline.RepositoryName;
import com.google.devtools.build.lib.events.Event;
import com.google.devtools.build.lib.events.EventHandler;
import com.google.devtools.build.lib.events.NullEventHandler;
import com.google.devtools.build.lib.packages.ImplicitOutputsFunction.StarlarkImplicitOutputsFunction;
import com.google.devtools.build.lib.packages.License.DistributionType;
import com.google.devtools.build.lib.packages.Package.ConfigSettingVisibilityPolicy;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nullable;
import net.starlark.java.eval.EvalException;
import net.starlark.java.syntax.Location;
/**
* An instance of a build rule in the build language. A rule has a name, a package to which it
* belongs, a class such as <code>cc_library</code>, and set of typed attributes. The set of
* attribute names and types is a property of the rule's class. The use of the term "class" here has
* nothing to do with Java classes. All rules are implemented by the same Java classes, Rule and
* RuleClass.
*
* <p>Here is a typical rule as it appears in a BUILD file:
*
* <pre>
* cc_library(name = 'foo',
* defines = ['-Dkey=value'],
* srcs = ['foo.cc'],
* deps = ['bar'])
* </pre>
*/
// Non-final only for mocking in tests. Do not subclass!
public class Rule implements Target, DependencyFilter.AttributeInfoProvider {
/** Label predicate that allows every label. */
public static final Predicate<Label> ALL_LABELS = Predicates.alwaysTrue();
private static final String GENERATOR_FUNCTION = "generator_function";
private static final String GENERATOR_LOCATION = "generator_location";
private final Label label;
private final Package pkg;
private final RuleClass ruleClass;
private AttributeContainer attributes;
private RuleVisibility visibility;
private boolean containsErrors;
private final Location location;
private final CallStack callstack;
private final ImplicitOutputsFunction implicitOutputsFunction;
/**
* A compact representation of a multimap from "output keys" to output files.
*
* <p>An output key is an identifier used to access the output in {@code ctx.outputs}, or the
* empty string in the case of an output that's not exposed there. For explicit outputs, the
* output key is the name of the attribute under which that output appears. For Starlark-defined
* implicit outputs, the output key is determined by the dict returned from the Starlark function.
* Native-defined implicit outputs are not named in this manner, and so are invisible to {@code
* ctx.outputs} and use the empty string key. (It'd be pathological for the empty string to be
* used as a key in the other two cases, but this class makes no attempt to prohibit that.)
*
* <p>Rather than naively store an ImmutableListMultimap, we save space by compressing it as an
* ImmutableList, where each key is followed by all the values having that key. We distinguish
* keys (Strings) from values (OutputFiles) by the fact that they have different types. The
* accessor methods traverse the list and create a more user-friendly view.
*
* <p>To distinguish implicit outputs from explicit outputs, we store all the implicit outputs in
* the list first, and record how many implicit output keys there are in a separate field.
*
* <p>The order of the implicit outputs is the same as returned by the implicit output function.
* This allows a native rule implementation and native implicit outputs function to agree on the
* index of a given kind of output. The order of explicit outputs preserves the attribute
* iteration order and the order of values in a list attribute; the latter is important so that
* {@code ctx.outputs.some_list} has a well-defined order.
*/
// Both of these fields are initialized by populateOutputFiles().
private ImmutableList<Object> flattenedOutputFileMap;
private int numImplicitOutputKeys;
Rule(
Package pkg,
Label label,
RuleClass ruleClass,
Location location,
CallStack callstack,
AttributeContainer attributeContainer) {
this(
pkg,
label,
ruleClass,
location,
callstack,
attributeContainer,
ruleClass.getDefaultImplicitOutputsFunction());
}
Rule(
Package pkg,
Label label,
RuleClass ruleClass,
Location location,
CallStack callstack,
AttributeContainer attributeContainer,
ImplicitOutputsFunction implicitOutputsFunction) {
this.pkg = Preconditions.checkNotNull(pkg);
this.label = label;
this.ruleClass = Preconditions.checkNotNull(ruleClass);
this.location = Preconditions.checkNotNull(location);
this.callstack = Preconditions.checkNotNull(callstack);
this.attributes = attributeContainer;
this.implicitOutputsFunction = implicitOutputsFunction;
this.containsErrors = false;
}
void setVisibility(RuleVisibility visibility) {
this.visibility = visibility;
}
void setAttributeValue(Attribute attribute, Object value, boolean explicit) {
Integer attrIndex = ruleClass.getAttributeIndex(attribute.getName());
Preconditions.checkArgument(
attrIndex != null, "attribute %s is not valid for this rule", attribute.getName());
attributes.setAttributeValue(attrIndex, value, explicit);
}
void setContainsErrors() {
this.containsErrors = true;
}
@Override
public Label getLabel() {
return label;
}
@Override
public String getName() {
return label.getName();
}
@Override
public Package getPackage() {
return pkg;
}
public RuleClass getRuleClassObject() {
return ruleClass;
}
@Override
public String getTargetKind() {
return ruleClass.getTargetKind();
}
/**
* Returns the class of this rule. (e.g. "cc_library")
*/
public String getRuleClass() {
return ruleClass.getName();
}
/**
* Returns true iff the outputs of this rule should be created beneath the bin directory, false if
* beneath genfiles. For most rule classes, this is constant, but for genrule, it is a property of
* the individual target, derived from the 'output_to_bindir' attribute.
*/
public boolean outputsToBindir() {
return ruleClass.getName().equals("genrule") // this is unfortunate...
? NonconfigurableAttributeMapper.of(this).get("output_to_bindir", Type.BOOLEAN)
: ruleClass.outputsToBindir();
}
/** Returns true if this rule is an analysis test (set by analysis_test = true). */
public boolean isAnalysisTest() {
return ruleClass.isAnalysisTest();
}
/**
* Returns true if this rule has at least one attribute with an analysis test transition. (A
* starlark-defined transition using analysis_test_transition()).
*/
public boolean hasAnalysisTestTransition() {
return ruleClass.hasAnalysisTestTransition();
}
public boolean isBuildSetting() {
return ruleClass.getBuildSetting() != null;
}
/**
* Returns true iff there were errors while constructing this rule, such as
* attributes with missing values or values of the wrong type.
*/
public boolean containsErrors() {
return containsErrors;
}
public boolean hasAspects() {
return ruleClass.hasAspects();
}
/**
* Returns an (unmodifiable, unordered) collection containing all the
* Attribute definitions for this kind of rule. (Note, this doesn't include
* the <i>values</i> of the attributes, merely the schema. Call
* get[Type]Attr() methods to access the actual values.)
*/
public Collection<Attribute> getAttributes() {
return ruleClass.getAttributes();
}
/**
* Returns true if the given attribute is configurable.
*/
public boolean isConfigurableAttribute(String attributeName) {
Attribute attribute = ruleClass.getAttributeByNameMaybe(attributeName);
// TODO(murali): This method should be property of ruleclass not rule instance.
// Further, this call to AbstractAttributeMapper.isConfigurable is delegated right back
// to this instance!
return attribute != null
&& AbstractAttributeMapper.isConfigurable(this, attributeName, attribute.getType());
}
/**
* Returns the attribute definition whose name is {@code attrName}, or null
* if not found. (Use get[X]Attr for the actual value.)
*
* @deprecated use {@link AbstractAttributeMapper#getAttributeDefinition} instead
*/
@Deprecated
public Attribute getAttributeDefinition(String attrName) {
return ruleClass.getAttributeByNameMaybe(attrName);
}
/**
* Constructs and returns an immutable list containing all the declared output files of this rule.
*
* <p>There are two kinds of outputs. Explicit outputs are declared in attributes of type OUTPUT
* or OUTPUT_LABEL. Implicit outputs are determined by custom rule logic in an "implicit outputs
* function" (either defined natively or in Starlark), and are named following a template pattern
* based on the target's attributes.
*
* <p>All implicit output files (declared in the {@link RuleClass}) are listed first, followed by
* any explicit files (declared via output attributes). Additionally, both implicit and explicit
* outputs will retain the relative order in which they were declared.
*/
public ImmutableList<OutputFile> getOutputFiles() {
// Discard the String keys, taking only the OutputFile values.
ImmutableList.Builder<OutputFile> result = ImmutableList.builder();
for (Object o : flattenedOutputFileMap) {
if (o instanceof OutputFile) {
result.add((OutputFile) o);
}
}
return result.build();
}
/**
* Constructs and returns an immutable list of all the implicit output files of this rule, in the
* order they were declared.
*/
public ImmutableList<OutputFile> getImplicitOutputFiles() {
ImmutableList.Builder<OutputFile> result = ImmutableList.builder();
int seenKeys = 0;
for (Object o : flattenedOutputFileMap) {
if (o instanceof String) {
if (++seenKeys > numImplicitOutputKeys) {
break;
}
} else {
result.add((OutputFile) o);
}
}
return result.build();
}
/**
* Constructs and returns an immutable multimap of the explicit outputs, from attribute name to
* associated value.
*
* <p>Keys are listed in the same order as attributes. Order of attribute values (outputs in an
* output list) is preserved.
*
* <p>Since this is a multimap, attributes that have no associated outputs are omitted from the
* result.
*/
public ImmutableListMultimap<String, OutputFile> getExplicitOutputFileMap() {
ImmutableListMultimap.Builder<String, OutputFile> result = ImmutableListMultimap.builder();
int seenKeys = 0;
String key = null;
for (Object o : flattenedOutputFileMap) {
if (o instanceof String) {
seenKeys++;
key = (String) o;
} else if (seenKeys > numImplicitOutputKeys) {
result.put(key, (OutputFile) o);
}
}
return result.build();
}
/**
* Returns a map of the Starlark-defined implicit outputs, from dict key to output file.
*
* <p>If there is no implicit outputs function, or it is a native one, an empty map is returned.
*
* <p>This is not a multimap because Starlark-defined implicit output functions return exactly one
* output per key.
*/
public ImmutableMap<String, OutputFile> getStarlarkImplicitOutputFileMap() {
if (!(implicitOutputsFunction instanceof StarlarkImplicitOutputsFunction)) {
return ImmutableMap.of();
}
ImmutableMap.Builder<String, OutputFile> result = ImmutableMap.builder();
int seenKeys = 0;
String key = null;
for (Object o : flattenedOutputFileMap) {
if (o instanceof String) {
if (++seenKeys > numImplicitOutputKeys) {
break;
}
key = (String) o;
} else {
result.put(key, (OutputFile) o);
}
}
return result.build();
}
@Override
public Location getLocation() {
return location;
}
/** Returns the stack of function calls active when this rule was instantiated. */
public CallStack getCallStack() {
return callstack;
}
public ImplicitOutputsFunction getImplicitOutputsFunction() {
return implicitOutputsFunction;
}
@Override
public Rule getAssociatedRule() {
return this;
}
/**
* Returns this rule's raw attribute info, suitable for being fed into an {@link AttributeMap} for
* user-level attribute access. Don't use this method for direct attribute access.
*/
AttributeContainer getAttributeContainer() {
return attributes;
}
/*
*******************************************************************
* Attribute accessor functions.
*
* The below provide access to attribute definitions and other generic
* metadata.
*
* For access to attribute *values* (e.g. "What's the value of attribute
* X for Rule Y?"), go through {@link RuleContext#attributes}. If no
* RuleContext is available, create a localized {@link AbstractAttributeMapper}
* instance instead.
*******************************************************************
*/
/**
* Returns the default value for the attribute {@code attrName}, which may be of any type, but
* must exist (an exception is thrown otherwise).
*/
public Object getAttrDefaultValue(String attrName) {
Object defaultValue = ruleClass.getAttributeByName(attrName).getDefaultValue(this);
// Computed defaults not expected here.
Preconditions.checkState(!(defaultValue instanceof Attribute.ComputedDefault));
return defaultValue;
}
/**
* Returns true iff the rule class has an attribute with the given name and type.
*
* <p>Note: RuleContext also has isAttrDefined(), which takes Aspects into account. Whenever
* possible, use RuleContext.isAttrDefined() instead of this method.
*/
public boolean isAttrDefined(String attrName, Type<?> type) {
return ruleClass.hasAttr(attrName, type);
}
/**
* Returns the value of the attribute with the given index. Returns null, if no such attribute
* exists OR no value was set.
*/
@Nullable
private Object getAttrWithIndex(int attrIndex) {
Object value = attributes.getAttributeValue(attrIndex);
if (value != null) {
return value;
}
Attribute attr = ruleClass.getAttribute(attrIndex);
if (attr.hasComputedDefault()) {
// Attributes with computed defaults are explicitly populated during rule creation.
// However, computing those defaults could trigger reads of other attributes
// which have not yet been populated. In such a case control comes here, and we return null.
// NOTE: In this situation returning null does not result in a correctness issue, since
// the value for the attribute is actually a function to compute the value.
return null;
}
switch (attr.getName()) {
case GENERATOR_FUNCTION:
return callstack.size() > 1 ? callstack.getFrame(1).name : "";
case GENERATOR_LOCATION:
return callstack.size() > 1 ? relativeLocation(callstack.getFrame(0).location) : "";
default:
return attr.getDefaultValue(null);
}
}
@Nullable
private String relativeLocation(Location location) {
// Determining the workspace root only works reliably if both location and label point to files
// in the same package.
// It would be preferable to construct the path from the label itself, but this doesn't work for
// rules created from function calls in a subincluded file, even if both files share a path
// prefix (for example, when //a/package:BUILD subincludes //a/package/with/a/subpackage:BUILD).
// We can revert to that approach once subincludes aren't supported anymore.
//
// TODO(b/151165647): this logic has always been wrong:
// it spuriously matches occurrences of the package name earlier in the path.
String absolutePath = location.toString();
int pos = absolutePath.indexOf(label.getPackageName());
return (pos < 0) ? null : absolutePath.substring(pos);
}
/**
* Returns the value of the given attribute for this rule. Returns null for invalid attributes and
* default value if attribute was not set.
*
* @param attrName the name of the attribute to lookup.
*/
@Nullable
public Object getAttr(String attrName) {
Integer attrIndex = ruleClass.getAttributeIndex(attrName);
return attrIndex == null ? null : getAttrWithIndex(attrIndex);
}
/**
* Returns the value of the given attribute if it has the right type.
*
* @throws IllegalArgumentException if the attribute does not have the expected type.
*/
@Nullable
public <T> Object getAttr(String attrName, Type<T> type) {
Integer index = ruleClass.getAttributeIndex(attrName);
if (index == null) {
throw new IllegalArgumentException(
"No such attribute " + attrName + " in " + ruleClass + " rule " + label);
}
Attribute attr = ruleClass.getAttribute(index);
if (attr.getType() != type) {
throw new IllegalArgumentException(
"Attribute "
+ attrName
+ " is of type "
+ attr.getType()
+ " and not of type "
+ type
+ " in "
+ ruleClass
+ " rule "
+ label);
}
return getAttrWithIndex(index);
}
/**
* Returns a {@link BuildType.SelectorList} for the given attribute if the attribute is
* configurable for this rule, null otherwise.
*/
@Nullable
@SuppressWarnings("unchecked")
public <T> BuildType.SelectorList<T> getSelectorList(String attributeName, Type<T> type) {
Integer index = ruleClass.getAttributeIndex(attributeName);
if (index == null) {
return null;
}
Object attrValue = attributes.getAttributeValue(index);
if (!(attrValue instanceof BuildType.SelectorList)) {
return null;
}
if (((BuildType.SelectorList<?>) attrValue).getOriginalType() != type) {
throw new IllegalArgumentException(
"Attribute "
+ attributeName
+ " is not of type "
+ type
+ " in "
+ ruleClass
+ " rule "
+ label);
}
return (BuildType.SelectorList<T>) attrValue;
}
/**
* See {@link #isAttributeValueExplicitlySpecified(String)}
*/
@Override
public boolean isAttributeValueExplicitlySpecified(Attribute attribute) {
return isAttributeValueExplicitlySpecified(attribute.getName());
}
/**
* Returns true iff the value of the specified attribute is explicitly set in the BUILD file. This
* returns true also if the value explicitly specified in the BUILD file is the same as the
* attribute's default value. In addition, this method return false if the rule has no attribute
* with the given name.
*/
public boolean isAttributeValueExplicitlySpecified(String attrName) {
if (attrName.equals(GENERATOR_FUNCTION) || attrName.equals(GENERATOR_LOCATION)) {
return wasCreatedByMacro();
}
Integer attrIndex = ruleClass.getAttributeIndex(attrName);
return attrIndex != null && attributes.isAttributeValueExplicitlySpecified(attrIndex);
}
/**
* Returns whether this rule was created by a macro.
*/
public boolean wasCreatedByMacro() {
return hasStringAttribute("generator_name") || hasStringAttribute(GENERATOR_FUNCTION);
}
/** Returns the macro that generated this rule, or an empty string. */
public String getGeneratorFunction() {
Object value = getAttr(GENERATOR_FUNCTION);
if (value instanceof String) {
return (String) value;
}
return "";
}
private boolean hasStringAttribute(String attrName) {
Object value = getAttr(attrName);
if (value instanceof String) {
return !((String) value).isEmpty();
}
return false;
}
/** Returns a new list containing all direct dependencies (all types). */
public List<Label> getLabels() {
List<Label> labels = new ArrayList<>();
AggregatingAttributeMapper.of(this).visitAllLabels((attribute, label) -> labels.add(label));
return labels;
}
/**
* Returns a sorted set containing all labels that match a given {@link DependencyFilter}, not
* including outputs.
*
* @param filter A dependency filter that determines whether a label should be included in the
* result. {@link DependencyFilter#test} is called with this rule and the attribute that
* contains the label. The label will be contained in the result iff the predicate returns
* {@code true} <em>and</em> the label is not an output.
*/
public ImmutableSortedSet<Label> getSortedLabels(DependencyFilter filter) {
ImmutableSortedSet.Builder<Label> labels = ImmutableSortedSet.naturalOrder();
AggregatingAttributeMapper.of(this)
.visitLabels(filter, (attribute, label) -> labels.add(label));
return labels.build();
}
/**
* Returns a {@link Multimap} containing all non-output labels matching a given {@link
* DependencyFilter}, keyed by the corresponding attribute.
*
* <p>Labels that appear in multiple attributes will be mapped from each of their corresponding
* attributes, provided they pass the {@link DependencyFilter}.
*
* @param filter A dependency filter that determines whether a label should be included in the
* result. {@link DependencyFilter#test} is called with this rule and the attribute that
* contains the label. The label will be contained in the result iff the predicate returns
* {@code true} <em>and</em> the label is not an output.
*/
public Multimap<Attribute, Label> getTransitions(DependencyFilter filter) {
Multimap<Attribute, Label> transitions = HashMultimap.create();
AggregatingAttributeMapper.of(this).visitLabels(filter, transitions::put);
return transitions;
}
void freeze() {
attributes = attributes.freeze();
}
/**
* Check if this rule is valid according to the validityPredicate of its RuleClass.
*/
void checkValidityPredicate(EventHandler eventHandler) {
PredicateWithMessage<Rule> predicate = ruleClass.getValidityPredicate();
if (!predicate.apply(this)) {
reportError(predicate.getErrorReason(this), eventHandler);
}
}
/**
* Collects the output files (both implicit and explicit). Must be called before the output
* accessors methods can be used, and must be called only once.
*/
void populateOutputFiles(EventHandler eventHandler, Package.Builder pkgBuilder)
throws LabelSyntaxException, InterruptedException {
populateOutputFilesInternal(
eventHandler, pkgBuilder.getPackageIdentifier(), /*checkLabels=*/ true);
}
void populateOutputFilesUnchecked(Package.Builder pkgBuilder) throws InterruptedException {
try {
populateOutputFilesInternal(
NullEventHandler.INSTANCE, pkgBuilder.getPackageIdentifier(), /*checkLabels=*/ false);
} catch (LabelSyntaxException e) {
throw new IllegalStateException(e);
}
}
@FunctionalInterface
private interface ExplicitOutputHandler {
void accept(Attribute attribute, Label outputLabel) throws LabelSyntaxException;
}
@FunctionalInterface
private interface ImplicitOutputHandler {
void accept(String outputKey, String outputName);
}
private void populateOutputFilesInternal(
EventHandler eventHandler, PackageIdentifier pkgId, boolean checkLabels)
throws LabelSyntaxException, InterruptedException {
Preconditions.checkState(flattenedOutputFileMap == null);
// We associate each output with its String key (or empty string if there's no key) as we go,
// and compress it down to a flat list afterwards. We use ImmutableListMultimap because it's
// more efficient than LinkedListMultimap and provides ordering guarantees among keys (whereas
// ArrayListMultimap doesn't).
ImmutableListMultimap.Builder<String, OutputFile> outputFileMap =
ImmutableListMultimap.builder();
// Detects collisions where the same output key is used for both an explicit and implicit entry.
HashSet<String> implicitOutputKeys = new HashSet<>();
// We need the implicits to appear before the explicits in the final data structure, so we
// process them first. We check for duplicates while handling the explicits.
//
// Each of these cases has two subcases, so we factor their bodies out into lambdas.
ImplicitOutputHandler implicitOutputHandler =
// outputKey: associated dict key if Starlark-defined, empty string otherwise
// outputName: package-relative path fragment
(outputKey, outputName) -> {
Label label;
if (checkLabels) { // controls label syntax validation only
try {
label = Label.create(pkgId, outputName);
} catch (LabelSyntaxException e) {
reportError(
String.format(
"illegal output file name '%s' in rule %s due to: %s",
outputName, this.label, e.getMessage()),
eventHandler);
return;
}
} else {
label = Label.createUnvalidated(pkgId, outputName);
}
validateOutputLabel(label, eventHandler);
OutputFile file = new OutputFile(label, this);
outputFileMap.put(outputKey, file);
implicitOutputKeys.add(outputKey);
};
// Populate the implicit outputs.
try {
RawAttributeMapper attributeMap = RawAttributeMapper.of(this);
// TODO(bazel-team): Reconsider the ImplicitOutputsFunction abstraction. It doesn't seem to be
// a good fit if it forces us to downcast in situations like this. It also causes
// getImplicitOutputs() to declare that it throws EvalException (which then has to be
// explicitly disclaimed by the subclass SafeImplicitOutputsFunction).
if (implicitOutputsFunction instanceof StarlarkImplicitOutputsFunction) {
for (Map.Entry<String, String> e :
((StarlarkImplicitOutputsFunction) implicitOutputsFunction)
.calculateOutputs(eventHandler, attributeMap)
.entrySet()) {
implicitOutputHandler.accept(e.getKey(), e.getValue());
}
} else {
for (String out : implicitOutputsFunction.getImplicitOutputs(eventHandler, attributeMap)) {
implicitOutputHandler.accept(/*outputKey=*/ "", out);
}
}
} catch (EvalException e) {
reportError(String.format("In rule %s: %s", label, e.getMessageWithStack()), eventHandler);
}
ExplicitOutputHandler explicitOutputHandler =
(attribute, outputLabel) -> {
String attrName = attribute.getName();
if (implicitOutputKeys.contains(attrName)) {
reportError(
String.format(
"Implicit output key '%s' collides with output attribute name", attrName),
eventHandler);
}
if (checkLabels) {
if (!outputLabel.getPackageIdentifier().equals(pkg.getPackageIdentifier())) {
throw new IllegalStateException(
String.format(
"Label for attribute %s should refer to '%s' but instead refers to '%s'"
+ " (label '%s')",
attribute,
pkg.getName(),
outputLabel.getPackageFragment(),
outputLabel.getName()));
}
if (outputLabel.getName().equals(".")) {
throw new LabelSyntaxException("output file name can't be equal '.'");
}
}
validateOutputLabel(outputLabel, eventHandler);
OutputFile outputFile = new OutputFile(outputLabel, this);
outputFileMap.put(attrName, outputFile);
};
// Populate the explicit outputs.
NonconfigurableAttributeMapper nonConfigurableAttributes =
NonconfigurableAttributeMapper.of(this);
for (Attribute attribute : ruleClass.getAttributes()) {
String name = attribute.getName();
Type<?> type = attribute.getType();
if (type == BuildType.OUTPUT) {
Label label = nonConfigurableAttributes.get(name, BuildType.OUTPUT);
if (label != null) {
explicitOutputHandler.accept(attribute, label);
}
} else if (type == BuildType.OUTPUT_LIST) {
for (Label label : nonConfigurableAttributes.get(name, BuildType.OUTPUT_LIST)) {
explicitOutputHandler.accept(attribute, label);
}
}
}
// Flatten the result into the final list.
ImmutableList.Builder<Object> builder = ImmutableList.builder();
for (Map.Entry<String, Collection<OutputFile>> e : outputFileMap.build().asMap().entrySet()) {
builder.add(e.getKey());
for (OutputFile out : e.getValue()) {
builder.add(out);
}
}
flattenedOutputFileMap = builder.build();
numImplicitOutputKeys = implicitOutputKeys.size();
}
private void validateOutputLabel(Label label, EventHandler eventHandler) {
if (label.getName().equals(getName())) {
// TODO(bazel-team): for now (23 Apr 2008) this is just a warning. After
// June 1st we should make it an error.
reportWarning("target '" + getName() + "' is both a rule and a file; please choose "
+ "another name for the rule", eventHandler);
}
}
void reportError(String message, EventHandler eventHandler) {
eventHandler.handle(Event.error(location, message));
this.containsErrors = true;
}
private void reportWarning(String message, EventHandler eventHandler) {
eventHandler.handle(Event.warn(location, message));
}
/** Returns a string of the form "cc_binary rule //foo:foo" */
@Override
public String toString() {
return getRuleClass() + " rule " + label;
}
/**
* Returns the effective visibility of this Rule. Visibility is computed from
* these sources in this order of preference:
* - 'visibility' attribute
* - 'default_visibility;' attribute of package() declaration
* - public.
*/
@Override
public RuleVisibility getVisibility() {
// Temporary logic to relax config_setting's visibility enforcement while depot migrations set
// visibility settings properly (legacy code may have visibility settings that would break if
// enforced). See https://github.com/bazelbuild/bazel/issues/12669. Ultimately this entire
// conditional should be removed.
if (ruleClass.getName().equals("config_setting")) {
ConfigSettingVisibilityPolicy policy = pkg.getConfigSettingVisibilityPolicy();
if (visibility != null) {
return visibility; // Use explicitly set visibility
} else if (policy == ConfigSettingVisibilityPolicy.DEFAULT_PUBLIC) {
return ConstantRuleVisibility.PUBLIC; // Default: //visibility:public.
} else {
return pkg.getDefaultVisibility(); // Default: same as all other rules.
}
}
// All other rules.
if (visibility != null) {
return visibility;
}
return pkg.getDefaultVisibility();
}
public boolean isVisibilitySpecified() {
return visibility != null;
}
@Override
public boolean isConfigurable() {
return true;
}
@Override
public Set<DistributionType> getDistributions() {
if (isAttrDefined("distribs", BuildType.DISTRIBUTIONS)
&& isAttributeValueExplicitlySpecified("distribs")) {
return NonconfigurableAttributeMapper.of(this).get("distribs", BuildType.DISTRIBUTIONS);
} else {
return pkg.getDefaultDistribs();
}
}
@Override
public License getLicense() {
// New style licenses defined by Starlark rules don't
// have old-style licenses. This is hardcoding the representation
// of new-style rules, but it's in the old-style licensing code path
// and will ultimately be removed.
if (ruleClass.isBazelLicense()) {
return License.NO_LICENSE;
} else if (isAttrDefined("licenses", BuildType.LICENSE)
&& isAttributeValueExplicitlySpecified("licenses")) {
return NonconfigurableAttributeMapper.of(this).get("licenses", BuildType.LICENSE);
} else if (ruleClass.ignoreLicenses()) {
return License.NO_LICENSE;
} else {
return pkg.getDefaultLicense();
}
}
/**
* Returns the license of the output of the binary created by this rule, or
* null if it is not specified.
*/
public License getToolOutputLicense(AttributeMap attributes) {
if (isAttrDefined("output_licenses", BuildType.LICENSE)
&& attributes.isAttributeValueExplicitlySpecified("output_licenses")) {
return attributes.get("output_licenses", BuildType.LICENSE);
} else {
return null;
}
}
/**
* Returns the Set of all tags exhibited by this target. May be empty.
*/
public Set<String> getRuleTags() {
Set<String> ruleTags = new LinkedHashSet<>();
for (Attribute attribute : ruleClass.getAttributes()) {
if (attribute.isTaggable()) {
Type<?> attrType = attribute.getType();
String name = attribute.getName();
// This enforces the expectation that taggable attributes are non-configurable.
Object value = NonconfigurableAttributeMapper.of(this).get(name, attrType);
Set<String> tags = attrType.toTagSet(value, name);
ruleTags.addAll(tags);
}
}
return ruleTags;
}
/**
* Computes labels of additional dependencies that can be provided by aspects that this rule can
* require from its direct dependencies.
*/
public Collection<Label> getAspectLabelsSuperset(DependencyFilter predicate) {
if (!hasAspects()) {
return ImmutableList.of();
}
SetMultimap<Attribute, Label> labels = LinkedHashMultimap.create();
for (Attribute attribute : this.getAttributes()) {
for (Aspect candidateClass : attribute.getAspects(this)) {
AspectDefinition.addAllAttributesOfAspect(Rule.this, labels, candidateClass, predicate);
}
}
return labels.values();
}
/**
* @return The repository name.
*/
public RepositoryName getRepository() {
return label.getPackageIdentifier().getRepository();
}
/** Returns the suffix of target kind for all rules. */
public static String targetKindSuffix() {
return " rule";
}
}