In practice, a ({@link Label} and post-transition {@link BuildConfigurationKey}) pair plus a * possible execution platform override {@link Label} with special constraints described as follows. * *
A build should not request keys with equal ({@link Label}, {@link BuildConfigurationValue}) * pairs but different execution platform override {@link Label} if the invoked rule will register * actions. (This is potentially OK if all outputs of all registered actions incorporate the * execution platform in their name unless the build also requests keys without an override that * happen to resolve to the same execution platform.) In practice, this issue has not been seen in * any 'real' builds; however, pathologically failure could lead to multiple (potentially different) * ConfiguredTarget that have the same ({@link Label}, {@link BuildConfigurationValue}) pair. * *
Note that this key may be used to look up the generating action of an artifact. * *
TODO(blaze-configurability-team): Consider just using BuildOptions over a
* BuildConfigurationKey.
*/
public class ConfiguredTargetKey implements ActionLookupKey {
/**
* Cache so that the number of ConfiguredTargetKey instances is {@code O(configured targets)} and
* not {@code O(edges between configured targets)}.
*/
private static final SkyKey.SkyKeyInterner True by default but set false when a non-idempotent rule transition is detected. It prevents
* over-application of such transitions.
*/
public boolean shouldApplyRuleTransition() {
return true;
}
public final String prettyPrint() {
if (getLabel() == null) {
return "null";
}
return String.format("%s (%s)", getLabel(), formatConfigurationKey(configurationKey));
}
@Override
public final int hashCode() {
return hashCode;
}
@Override
public final boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof ConfiguredTargetKey)) {
return false;
}
ConfiguredTargetKey other = (ConfiguredTargetKey) obj;
return hashCode == other.hashCode
&& getLabel().equals(other.getLabel())
&& Objects.equals(configurationKey, other.configurationKey)
&& Objects.equals(getExecutionPlatformLabel(), other.getExecutionPlatformLabel())
&& shouldApplyRuleTransition() == other.shouldApplyRuleTransition();
}
@Override
public final String toString() {
// TODO(b/162809183): consider reverting to less verbose toString when bug is resolved.
MoreObjects.ToStringHelper helper =
MoreObjects.toStringHelper(this).add("label", getLabel()).add("config", configurationKey);
if (getExecutionPlatformLabel() != null) {
helper.add("executionPlatformLabel", getExecutionPlatformLabel());
}
return helper.toString();
}
/**
* Key indicating that no rule transition should be applied to the configuration.
*
* NOTE: although it's true that no rule transition is applied when there is a null
* configuration, this key type is used to handle a special edge case described below. It should
* only be used with a non-null configuration.
*
* When a non-noop rule transition occurs, it creates a new delegation {@link
* ConfiguredTargetKey} with the resulting configuration. This is so if different starting
* configurations result in the same configuration after transition, they converge on the same
* key-value entry in Skyframe.
*
* This can be problematic when transitions are not idempotent because evaluation of the
* delegate repeats the transition, resulting in a another delegate. In cases of
* non-convergent transitions, this may lead to infinite expansion.
*
* To ensure that transitions are effectively only applied once, prior to delegation, the
* {@link ConfiguredTargetFunction} applies the transition a second time to check it for
* idempotency. It sets {@link ConfiguredTargetKey#shouldApplyRuleTransition} false when it is not
* idempotent.
*/
private static final class ConfiguredTargetKeyWithFinalConfiguration extends ConfiguredTargetKey {
// This is implemented using subtypes instead of adding a boolean field to `ConfiguredTargetKey`
// to reduce memory cost.
private ConfiguredTargetKeyWithFinalConfiguration(
Label label, BuildConfigurationKey configurationKey, int hashCode) {
super(label, checkNotNull(configurationKey), hashCode);
}
@Override
public boolean shouldApplyRuleTransition() {
return false;
}
}
private static class ToolchainDependencyConfiguredTargetKey extends ConfiguredTargetKey {
private final Label executionPlatformLabel;
private ToolchainDependencyConfiguredTargetKey(
Label label,
@Nullable BuildConfigurationKey configurationKey,
int hashCode,
Label executionPlatformLabel) {
super(label, configurationKey, hashCode);
this.executionPlatformLabel = checkNotNull(executionPlatformLabel);
}
@Override
public Label getExecutionPlatformLabel() {
return executionPlatformLabel;
}
}
private static final class ToolchainDependencyConfiguredTargetKeyWithFinalConfiguration
extends ToolchainDependencyConfiguredTargetKey {
private ToolchainDependencyConfiguredTargetKeyWithFinalConfiguration(
Label label,
BuildConfigurationKey configurationKey,
int hashCode,
Label executionPlatformLabel) {
super(label, checkNotNull(configurationKey), hashCode, executionPlatformLabel);
}
@Override
public boolean shouldApplyRuleTransition() {
return false;
}
}
public Builder toBuilder() {
return builder()
.setConfigurationKey(configurationKey)
.setLabel(getLabel())
.setExecutionPlatformLabel(getExecutionPlatformLabel())
.setShouldApplyRuleTransition(shouldApplyRuleTransition());
}
/** Returns a new {@link Builder} to create instances of {@link ConfiguredTargetKey}. */
public static Builder builder() {
return new Builder();
}
/** Returns the {@link ConfiguredTargetKey} that owns {@code configuredTarget}. */
public static ConfiguredTargetKey fromConfiguredTarget(ConfiguredTarget configuredTarget) {
// If configuredTarget is a MergedConfiguredTarget unwraps it first. MergedConfiguredTarget is
// ephemeral and does not have a directly corresponding entry in Skyframe.
//
// The cast exists because the key passes through parts of analysis that work on both aspects
// and configured targets. This process discards the key's specific type information.
return (ConfiguredTargetKey) configuredTarget.unwrapIfMerged().getLookupKey();
}
/** A helper class to create instances of {@link ConfiguredTargetKey}. */
public static final class Builder {
private Label label = null;
private BuildConfigurationKey configurationKey = null;
private Label executionPlatformLabel = null;
private boolean shouldApplyRuleTransition = true;
private Builder() {}
/** Sets the label for the target. */
@CanIgnoreReturnValue
public Builder setLabel(Label label) {
this.label = label;
return this;
}
/** Sets the {@link BuildConfigurationValue} for the configured target. */
@CanIgnoreReturnValue
public Builder setConfiguration(@Nullable BuildConfigurationValue buildConfiguration) {
return setConfigurationKey(buildConfiguration == null ? null : buildConfiguration.getKey());
}
/** Sets the configuration key for the configured target. */
@CanIgnoreReturnValue
public Builder setConfigurationKey(@Nullable BuildConfigurationKey configurationKey) {
this.configurationKey = configurationKey;
return this;
}
/**
* Sets the execution platform {@link Label} this configured target should use for toolchain
* resolution. When present, this overrides the normally determined execution platform.
*/
@CanIgnoreReturnValue
public Builder setExecutionPlatformLabel(@Nullable Label executionPlatformLabel) {
this.executionPlatformLabel = executionPlatformLabel;
return this;
}
@CanIgnoreReturnValue
public Builder setShouldApplyRuleTransition(boolean shouldApplyRuleTransition) {
this.shouldApplyRuleTransition = shouldApplyRuleTransition;
return this;
}
/** Builds a new {@link ConfiguredTargetKey} based on the supplied data. */
public ConfiguredTargetKey build() {
int hashCode =
computeHashCode(
label, configurationKey, executionPlatformLabel, shouldApplyRuleTransition);
ConfiguredTargetKey newKey;
if (executionPlatformLabel == null) {
newKey =
shouldApplyRuleTransition
? new ConfiguredTargetKey(label, configurationKey, hashCode)
: new ConfiguredTargetKeyWithFinalConfiguration(label, configurationKey, hashCode);
} else {
newKey =
shouldApplyRuleTransition
? new ToolchainDependencyConfiguredTargetKey(
label, configurationKey, hashCode, executionPlatformLabel)
: new ToolchainDependencyConfiguredTargetKeyWithFinalConfiguration(
label, configurationKey, hashCode, executionPlatformLabel);
}
return interner.intern(newKey);
}
}
private static int computeHashCode(
Label label,
@Nullable BuildConfigurationKey configurationKey,
@Nullable Label executionPlatformLabel,
boolean shouldApplyRuleTransition) {
int hashCode = hashObjects(label, configurationKey, executionPlatformLabel);
if (!shouldApplyRuleTransition) {
hashCode = ~hashCode;
}
return hashCode;
}
private static String formatConfigurationKey(@Nullable BuildConfigurationKey key) {
if (key == null) {
return "null";
}
return key.getOptions().checksum();
}
/** Codec for all {@link ConfiguredTargetKey} subtypes. */
@Keep
private static class ConfiguredTargetKeyCodec implements ObjectCodec