// 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.collect.ImmutableCollection;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMultimap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSetMultimap;
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.concurrent.ThreadSafety.Immutable;
import com.google.devtools.build.lib.packages.ConfigurationFragmentPolicy.MissingFragmentPolicy;
import com.google.devtools.build.lib.syntax.Type;
import com.google.devtools.build.lib.util.Preconditions;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nullable;
/**
* The definition of an aspect (see {@link Aspect} for moreinformation.)
*
*
Contains enough information to build up the configured target graph except for the actual way
* to build the Skyframe node (that is the territory of
* {@link com.google.devtools.build.lib.view AspectFactory}). In particular:
*
*
The condition that must be fulfilled for an aspect to be able to operate on a configured
* target
*
The (implicit or late-bound) attributes of the aspect that denote dependencies the aspect
* itself needs (e.g. runtime libraries for a new language for protocol buffers)
*
The aspects this aspect requires from its direct dependencies
*
*
*
The way to build the Skyframe node is not here because this data needs to be accessible from
* the {@code .packages} package and that one requires references to the {@code .view} package.
*/
@Immutable
public final class AspectDefinition {
private final AspectClass aspectClass;
private final ImmutableList>> requiredProviderSets;
private final ImmutableList> requiredProviderNameSets;
private final ImmutableMap attributes;
private final PropagationFunction attributeAspects;
@Nullable private final ConfigurationFragmentPolicy configurationFragmentPolicy;
private interface PropagationFunction {
ImmutableCollection propagate(Attribute attribute);
}
private AspectDefinition(
AspectClass aspectClass,
ImmutableList>> requiredProviderSets,
ImmutableMap attributes,
PropagationFunction attributeAspects,
@Nullable ConfigurationFragmentPolicy configurationFragmentPolicy) {
this.aspectClass = aspectClass;
this.requiredProviderSets = requiredProviderSets;
this.attributes = attributes;
this.attributeAspects = attributeAspects;
this.configurationFragmentPolicy = configurationFragmentPolicy;
ImmutableList.Builder> requiredProviderNameSetsBuilder =
new ImmutableList.Builder<>();
for (ImmutableSet> requiredProviderSet : requiredProviderSets) {
requiredProviderNameSetsBuilder.add(toStringSet(requiredProviderSet));
}
this.requiredProviderNameSets = requiredProviderNameSetsBuilder.build();
}
public String getName() {
return aspectClass.getName();
}
public AspectClass getAspectClass() {
return aspectClass;
}
/**
* Returns the attributes of the aspect in the form of a String -> {@link Attribute} map.
*
*
All attributes are either implicit or late-bound.
*/
public ImmutableMap getAttributes() {
return attributes;
}
/**
* Returns the list of {@link com.google.devtools.build.lib.analysis.TransitiveInfoProvider}
* sets. All required providers from at least one set must be present on a configured target so
* that this aspect can be applied to it.
*
*
We cannot refer to that class here due to our dependency structure, so this returns a set
* of unconstrained class objects.
*
*
If a configured target does not have a required provider, the aspect is silently not created
* for it.
*/
public ImmutableList>> getRequiredProviders() {
return requiredProviderSets;
}
/**
* Returns the list of class name sets of
* {@link com.google.devtools.build.lib.analysis.TransitiveInfoProvider}. All required providers
* from at least one set must be present on a configured target so that this aspect can be applied
* to it.
*
*
This set is a mirror of the set returned by {@link #getRequiredProviders}, but contains the
* names of the classes rather than the class objects themselves.
*
*
If a configured target does not have a required provider, the aspect is silently not created
* for it.
*/
public ImmutableList> getRequiredProviderNames() {
return requiredProviderNameSets;
}
/**
* Returns the set of required aspects for a given atribute.
*/
public ImmutableCollection getAttributeAspects(Attribute attribute) {
return attributeAspects.propagate(attribute);
}
/**
* Returns the set of configuration fragments required by this Aspect.
*/
public ConfigurationFragmentPolicy getConfigurationFragmentPolicy() {
return configurationFragmentPolicy;
}
/**
* Returns the attribute -> set of labels that are provided by aspects of attribute.
*/
public static ImmutableMultimap visitAspectsIfRequired(
Target from, Attribute attribute, Target to,
DependencyFilter dependencyFilter) {
// Aspect can be declared only for Rules.
if (!(from instanceof Rule) || !(to instanceof Rule)) {
return ImmutableMultimap.of();
}
RuleClass ruleClass = ((Rule) to).getRuleClassObject();
ImmutableSet> providers = ruleClass.getAdvertisedProviders();
return visitAspectsIfRequired((Rule) from, attribute, ruleClass.canHaveAnyProvider(),
toStringSet(providers), dependencyFilter);
}
/**
* Returns the attribute -> set of labels that are provided by aspects of attribute.
*/
public static ImmutableMultimap visitAspectsIfRequired(
Rule from, Attribute attribute, boolean canHaveAnyProvider, Set advertisedProviders,
DependencyFilter dependencyFilter) {
SetMultimap result = LinkedHashMultimap.create();
for (Aspect candidateClass : attribute.getAspects(from)) {
// Check if target satisfies condition for this aspect (has to provide all required
// TransitiveInfoProviders)
if (!canHaveAnyProvider) {
ImmutableList> providerNamesList =
candidateClass.getDefinition().getRequiredProviderNames();
for (ImmutableSet providerNames : providerNamesList) {
if (advertisedProviders.containsAll(providerNames)) {
addAllAttributesOfAspect(from, result, candidateClass, dependencyFilter);
break;
}
}
} else {
addAllAttributesOfAspect(from, result, candidateClass, dependencyFilter);
}
}
return ImmutableMultimap.copyOf(result);
}
private static ImmutableSet toStringSet(ImmutableSet> classes) {
ImmutableSet.Builder classStrings = new ImmutableSet.Builder<>();
for (Class> clazz : classes) {
classStrings.add(clazz.getName());
}
return classStrings.build();
}
@Nullable
private static Label maybeGetRepositoryRelativeLabel(Rule from, @Nullable Label label) {
return label == null ? null : from.getLabel().resolveRepositoryRelative(label);
}
/**
* Collects all attribute labels from the specified aspectDefinition.
*/
public static void addAllAttributesOfAspect(
Rule from,
Multimap labelBuilder,
Aspect aspect,
DependencyFilter dependencyFilter) {
ImmutableMap attributes = aspect.getDefinition().getAttributes();
for (Attribute aspectAttribute : attributes.values()) {
if (!dependencyFilter.apply(aspect, aspectAttribute)) {
continue;
}
if (aspectAttribute.getType() == BuildType.LABEL) {
Label label = maybeGetRepositoryRelativeLabel(
from, BuildType.LABEL.cast(aspectAttribute.getDefaultValue(from)));
if (label != null) {
labelBuilder.put(aspectAttribute, label);
}
} else if (aspectAttribute.getType() == BuildType.LABEL_LIST) {
List