blob: 50843d24b96ca5e918b1ceecb777d61a5430f778 [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.skyframe;
import com.google.common.base.Objects;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Interner;
import com.google.devtools.build.lib.actions.BasicActionLookupValue;
import com.google.devtools.build.lib.analysis.ConfiguredAspect;
import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
import com.google.devtools.build.lib.cmdline.Label;
import com.google.devtools.build.lib.collect.nestedset.NestedSet;
import com.google.devtools.build.lib.concurrent.BlazeInterners;
import com.google.devtools.build.lib.events.Location;
import com.google.devtools.build.lib.packages.Aspect;
import com.google.devtools.build.lib.packages.AspectClass;
import com.google.devtools.build.lib.packages.AspectDescriptor;
import com.google.devtools.build.lib.packages.AspectParameters;
import com.google.devtools.build.lib.packages.Package;
import com.google.devtools.build.lib.skyframe.BuildConfigurationValue.Key;
import com.google.devtools.build.lib.skyframe.ConfiguredTargetKey.KeyAndHost;
import com.google.devtools.build.lib.skyframe.serialization.autocodec.AutoCodec;
import com.google.devtools.build.lib.syntax.SkylarkImport;
import com.google.devtools.build.skyframe.SkyFunctionName;
import java.math.BigInteger;
import javax.annotation.Nullable;
/** An aspect in the context of the Skyframe graph. */
public final class AspectValue extends BasicActionLookupValue {
/**
* A base class for keys that have AspectValue as a Sky value.
*/
public abstract static class AspectValueKey extends ActionLookupKey {
public abstract String getDescription();
@Override
public abstract Label getLabel();
}
/** A base class for a key representing an aspect applied to a particular target. */
@AutoCodec
public static class AspectKey extends AspectValueKey {
private final Label label;
private final ImmutableList<AspectKey> baseKeys;
private final BuildConfigurationValue.Key aspectConfigurationKey;
private final ConfiguredTargetKey baseConfiguredTargetKey;
private final AspectDescriptor aspectDescriptor;
private int hashCode;
private AspectKey(
Label label,
BuildConfigurationValue.Key aspectConfigurationKey,
ConfiguredTargetKey baseConfiguredTargetKey,
ImmutableList<AspectKey> baseKeys,
AspectDescriptor aspectDescriptor) {
this.baseKeys = baseKeys;
this.label = label;
this.aspectConfigurationKey = aspectConfigurationKey;
this.baseConfiguredTargetKey = baseConfiguredTargetKey;
this.aspectDescriptor = aspectDescriptor;
}
@AutoCodec.VisibleForSerialization
@AutoCodec.Instantiator
static AspectKey createAspectKey(
Label label,
ConfiguredTargetKey baseConfiguredTargetKey,
ImmutableList<AspectKey> baseKeys,
AspectDescriptor aspectDescriptor,
BuildConfigurationValue.Key aspectConfigurationKey,
boolean aspectConfigurationIsHost) {
return aspectKeyInterner.intern(
aspectConfigurationIsHost
? new HostAspectKey(
label,
aspectConfigurationKey,
baseConfiguredTargetKey,
baseKeys,
aspectDescriptor)
: new AspectKey(
label,
aspectConfigurationKey,
baseConfiguredTargetKey,
baseKeys,
aspectDescriptor));
}
@Override
public SkyFunctionName functionName() {
return SkyFunctions.ASPECT;
}
@Override
public Label getLabel() {
return label;
}
public AspectClass getAspectClass() {
return aspectDescriptor.getAspectClass();
}
@Nullable
public AspectParameters getParameters() {
return aspectDescriptor.getParameters();
}
public AspectDescriptor getAspectDescriptor() {
return aspectDescriptor;
}
@Nullable
ImmutableList<AspectKey> getBaseKeys() {
return baseKeys;
}
@Override
public String getDescription() {
if (baseKeys.isEmpty()) {
return String.format("%s of %s",
aspectDescriptor.getAspectClass().getName(), getLabel());
} else {
return String.format("%s on top of %s",
aspectDescriptor.getAspectClass().getName(), baseKeys.toString());
}
}
// Note that this does not factor into equality/hash-code computations because its value is
// already encoded in the aspectConfigurationKey, albeit in an opaque way.
protected boolean aspectConfigurationIsHost() {
return false;
}
/**
* Returns the key of the configured target of the aspect; that is, the configuration in which
* the aspect will be evaluated.
*
* <p>In trimmed configuration mode, the aspect may require more fragments than the target on
* which it is being evaluated; in addition to configuration fragments required by the target
* and its dependencies, an aspect has configuration fragment requirements of its own, as well
* as dependencies of its own with their own configuration fragment requirements.
*
* <p>The aspect configuration contains all of these fragments, and is used to create the
* aspect's RuleContext and to retrieve the dependencies. Note that dependencies will have their
* configurations trimmed from this one as normal.
*
* <p>Because of these properties, this configuration is always a superset of the base target's
* configuration. In untrimmed configuration mode, this configuration will be equivalent to the
* base target's configuration.
*/
BuildConfigurationValue.Key getAspectConfigurationKey() {
return aspectConfigurationKey;
}
/** Returns the key for the base configured target for this aspect. */
ConfiguredTargetKey getBaseConfiguredTargetKey() {
return baseConfiguredTargetKey;
}
@Override
public int hashCode() {
// We use the hash code caching strategy employed by java.lang.String. There are three subtle
// things going on here:
//
// (1) We use a value of 0 to indicate that the hash code hasn't been computed and cached yet.
// Yes, this means that if the hash code is really 0 then we will "recompute" it each time.
// But this isn't a problem in practice since a hash code of 0 should be rare.
//
// (2) Since we have no synchronization, multiple threads can race here thinking there are the
// first one to compute and cache the hash code.
//
// (3) Moreover, since 'hashCode' is non-volatile, the cached hash code value written from one
// thread may not be visible by another.
//
// All three of these issues are benign from a correctness perspective; in the end we have no
// overhead from synchronization, at the cost of potentially computing the hash code more than
// once.
int h = hashCode;
if (h == 0) {
h = computeHashCode();
hashCode = h;
}
return h;
}
private int computeHashCode() {
return Objects.hashCode(
label, baseKeys, aspectConfigurationKey, baseConfiguredTargetKey, aspectDescriptor);
}
@Override
public boolean equals(Object other) {
if (this == other) {
return true;
}
if (!(other instanceof AspectKey)) {
return false;
}
AspectKey that = (AspectKey) other;
return Objects.equal(label, that.label)
&& Objects.equal(baseKeys, that.baseKeys)
&& Objects.equal(aspectConfigurationKey, that.aspectConfigurationKey)
&& Objects.equal(baseConfiguredTargetKey, that.baseConfiguredTargetKey)
&& Objects.equal(aspectDescriptor, that.aspectDescriptor);
}
public String prettyPrint() {
if (label == null) {
return "null";
}
String baseKeysString =
baseKeys.isEmpty()
? ""
: String.format(" (over %s)", baseKeys.toString());
return String.format(
"%s with aspect %s%s%s",
label.toString(),
aspectDescriptor.getAspectClass().getName(),
(aspectConfigurationKey != null && aspectConfigurationIsHost()) ? "(host) " : "",
baseKeysString);
}
@Override
public String toString() {
return (baseKeys == null ? label : baseKeys.toString())
+ "#"
+ aspectDescriptor
+ " "
+ aspectConfigurationKey
+ " "
+ baseConfiguredTargetKey
+ " "
+ aspectDescriptor.getParameters()
+ (aspectConfigurationIsHost() ? " (host)" : "");
}
AspectKey withLabel(Label label) {
ImmutableList.Builder<AspectKey> newBaseKeys = ImmutableList.builder();
for (AspectKey baseKey : baseKeys) {
newBaseKeys.add(baseKey.withLabel(label));
}
return createAspectKey(
label,
ConfiguredTargetKey.of(
label,
baseConfiguredTargetKey.getConfigurationKey(),
baseConfiguredTargetKey.isHostConfiguration()),
newBaseKeys.build(),
aspectDescriptor,
aspectConfigurationKey,
aspectConfigurationIsHost());
}
}
/** An {@link AspectKey} for an aspect in the host configuration. */
static class HostAspectKey extends AspectKey {
private HostAspectKey(
Label label,
Key aspectConfigurationKey,
ConfiguredTargetKey baseConfiguredTargetKey,
ImmutableList<AspectKey> baseKeys,
AspectDescriptor aspectDescriptor) {
super(label, aspectConfigurationKey, baseConfiguredTargetKey, baseKeys, aspectDescriptor);
}
@Override
protected boolean aspectConfigurationIsHost() {
return true;
}
}
/**
* The key for a skylark aspect.
*/
public static class SkylarkAspectLoadingKey extends AspectValueKey {
private final Label targetLabel;
private final BuildConfigurationValue.Key aspectConfigurationKey;
private final ConfiguredTargetKey baseConfiguredTargetKey;
private final SkylarkImport skylarkImport;
private final String skylarkValueName;
private int hashCode;
private SkylarkAspectLoadingKey(
Label targetLabel,
BuildConfigurationValue.Key aspectConfigurationKey,
ConfiguredTargetKey baseConfiguredTargetKey,
SkylarkImport skylarkImport,
String skylarkFunctionName) {
this.targetLabel = targetLabel;
this.aspectConfigurationKey = aspectConfigurationKey;
this.baseConfiguredTargetKey = baseConfiguredTargetKey;
this.skylarkImport = skylarkImport;
this.skylarkValueName = skylarkFunctionName;
}
@Override
public SkyFunctionName functionName() {
return SkyFunctions.LOAD_SKYLARK_ASPECT;
}
String getSkylarkValueName() {
return skylarkValueName;
}
SkylarkImport getSkylarkImport() {
return skylarkImport;
}
protected boolean isAspectConfigurationHost() {
return false;
}
@Override
public Label getLabel() {
return targetLabel;
}
@Override
public String getDescription() {
// Skylark aspects are referred to on command line with <file>%<value ame>
return String.format("%s%%%s of %s", skylarkImport.getImportString(),
skylarkValueName, targetLabel);
}
@Override
public int hashCode() {
// We use the hash code caching strategy employed by java.lang.String. There are three subtle
// things going on here:
//
// (1) We use a value of 0 to indicate that the hash code hasn't been computed and cached yet.
// Yes, this means that if the hash code is really 0 then we will "recompute" it each time.
// But this isn't a problem in practice since a hash code of 0 should be rare.
//
// (2) Since we have no synchronization, multiple threads can race here thinking there are the
// first one to compute and cache the hash code.
//
// (3) Moreover, since 'hashCode' is non-volatile, the cached hash code value written from one
// thread may not be visible by another.
//
// All three of these issues are benign from a correctness perspective; in the end we have no
// overhead from synchronization, at the cost of potentially computing the hash code more than
// once.
int h = hashCode;
if (h == 0) {
h = computeHashCode();
hashCode = h;
}
return h;
}
private int computeHashCode() {
return Objects.hashCode(
targetLabel,
aspectConfigurationKey,
baseConfiguredTargetKey,
skylarkImport,
skylarkValueName);
}
@Override
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof SkylarkAspectLoadingKey)) {
return false;
}
SkylarkAspectLoadingKey that = (SkylarkAspectLoadingKey) o;
return Objects.equal(targetLabel, that.targetLabel)
&& Objects.equal(aspectConfigurationKey, that.aspectConfigurationKey)
&& Objects.equal(baseConfiguredTargetKey, that.baseConfiguredTargetKey)
&& Objects.equal(skylarkImport, that.skylarkImport)
&& Objects.equal(skylarkValueName, that.skylarkValueName);
}
AspectKey toAspectKey(AspectClass aspectClass) {
return AspectKey.createAspectKey(
targetLabel,
baseConfiguredTargetKey,
ImmutableList.of(),
new AspectDescriptor(aspectClass, AspectParameters.EMPTY),
aspectConfigurationKey,
isAspectConfigurationHost());
}
}
/** A {@link SkylarkAspectLoadingKey} for an aspect in the host configuration. */
private static class HostSkylarkAspectLoadingKey extends SkylarkAspectLoadingKey {
private HostSkylarkAspectLoadingKey(
Label targetLabel,
Key aspectConfigurationKey,
ConfiguredTargetKey baseConfiguredTargetKey,
SkylarkImport skylarkImport,
String skylarkFunctionName) {
super(
targetLabel,
aspectConfigurationKey,
baseConfiguredTargetKey,
skylarkImport,
skylarkFunctionName);
}
@Override
protected boolean isAspectConfigurationHost() {
return true;
}
}
// These variables are only non-final because they may be clear()ed to save memory. They are null
// only after they are cleared except for transitivePackagesForPackageRootResolution.
@Nullable private Label label;
@Nullable private Aspect aspect;
@Nullable private Location location;
@Nullable private AspectKey key;
@Nullable private ConfiguredAspect configuredAspect;
// May be null either after clearing or because transitive packages are not tracked.
@Nullable private transient NestedSet<Package> transitivePackagesForPackageRootResolution;
public AspectValue(
AspectKey key,
Aspect aspect,
Label label,
Location location,
ConfiguredAspect configuredAspect,
NestedSet<Package> transitivePackagesForPackageRootResolution,
BigInteger nonceVersion) {
super(configuredAspect.getActions(), nonceVersion);
this.label = Preconditions.checkNotNull(label, actions);
this.aspect = Preconditions.checkNotNull(aspect, label);
this.location = Preconditions.checkNotNull(location, label);
this.key = Preconditions.checkNotNull(key, label);
this.configuredAspect = Preconditions.checkNotNull(configuredAspect, label);
this.transitivePackagesForPackageRootResolution = transitivePackagesForPackageRootResolution;
}
public ConfiguredAspect getConfiguredAspect() {
return Preconditions.checkNotNull(configuredAspect);
}
public Label getLabel() {
return Preconditions.checkNotNull(label);
}
public Location getLocation() {
return Preconditions.checkNotNull(location);
}
public AspectKey getKey() {
return Preconditions.checkNotNull(key);
}
public Aspect getAspect() {
return Preconditions.checkNotNull(aspect);
}
void clear(boolean clearEverything) {
Preconditions.checkNotNull(label, this);
Preconditions.checkNotNull(aspect, this);
Preconditions.checkNotNull(location, this);
Preconditions.checkNotNull(key, this);
Preconditions.checkNotNull(configuredAspect, this);
if (clearEverything) {
label = null;
aspect = null;
location = null;
key = null;
configuredAspect = null;
}
transitivePackagesForPackageRootResolution = null;
}
@Override
public final boolean mustBeReferenceComparedOnRecomputation() {
return true;
}
/**
* Returns the set of packages transitively loaded by this value. Must only be used for
* constructing the package -> source root map needed for some builds. If the caller has not
* specified that this map needs to be constructed (via the constructor argument in {@link
* AspectFunction#AspectFunction}), calling this will crash.
*/
public NestedSet<Package> getTransitivePackagesForPackageRootResolution() {
return Preconditions.checkNotNull(transitivePackagesForPackageRootResolution);
}
@Override
public String toString() {
return getStringHelper()
.add("label", label)
.add("key", key)
.add("location", location)
.add("aspect", aspect)
.add("configuredAspect", configuredAspect)
.toString();
}
public static AspectKey createAspectKey(
Label label,
BuildConfiguration baseConfiguration,
ImmutableList<AspectKey> baseKeys,
AspectDescriptor aspectDescriptor,
BuildConfiguration aspectConfiguration) {
KeyAndHost aspectKeyAndHost = ConfiguredTargetKey.keyFromConfiguration(aspectConfiguration);
return AspectKey.createAspectKey(
label,
ConfiguredTargetKey.of(label, baseConfiguration),
baseKeys,
aspectDescriptor,
aspectKeyAndHost.key,
aspectKeyAndHost.isHost);
}
private static final Interner<AspectKey> aspectKeyInterner = BlazeInterners.newWeakInterner();
public static AspectKey createAspectKey(
Label label,
BuildConfiguration baseConfiguration,
AspectDescriptor aspectDescriptor,
BuildConfiguration aspectConfiguration) {
KeyAndHost aspectKeyAndHost = ConfiguredTargetKey.keyFromConfiguration(aspectConfiguration);
return AspectKey.createAspectKey(
label,
ConfiguredTargetKey.of(label, baseConfiguration),
ImmutableList.of(),
aspectDescriptor,
aspectKeyAndHost.key,
aspectKeyAndHost.isHost);
}
private static final Interner<SkylarkAspectLoadingKey> skylarkAspectKeyInterner =
BlazeInterners.newWeakInterner();
public static SkylarkAspectLoadingKey createSkylarkAspectKey(
Label targetLabel,
BuildConfiguration aspectConfiguration,
BuildConfiguration targetConfiguration,
SkylarkImport skylarkImport,
String skylarkExportName) {
KeyAndHost keyAndHost = ConfiguredTargetKey.keyFromConfiguration(aspectConfiguration);
SkylarkAspectLoadingKey key =
keyAndHost.isHost
? new HostSkylarkAspectLoadingKey(
targetLabel,
keyAndHost.key,
ConfiguredTargetKey.of(targetLabel, targetConfiguration),
skylarkImport,
skylarkExportName)
: new SkylarkAspectLoadingKey(
targetLabel,
keyAndHost.key,
ConfiguredTargetKey.of(targetLabel, targetConfiguration),
skylarkImport,
skylarkExportName);
return skylarkAspectKeyInterner.intern(key);
}
}