1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
// Copyright 2014 Google Inc. 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 com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Joiner;
import com.google.common.base.Preconditions;
import com.google.common.base.Verify;
import com.google.common.collect.ImmutableMap;
import com.google.devtools.build.lib.analysis.config.ConfigMatchingProvider;
import com.google.devtools.build.lib.cmdline.Label;
import com.google.devtools.build.lib.packages.AbstractAttributeMapper;
import com.google.devtools.build.lib.packages.AttributeMap;
import com.google.devtools.build.lib.packages.BuildType;
import com.google.devtools.build.lib.packages.BuildType.Selector;
import com.google.devtools.build.lib.packages.BuildType.SelectorList;
import com.google.devtools.build.lib.packages.Rule;
import com.google.devtools.build.lib.syntax.EvalException;
import com.google.devtools.build.lib.syntax.Type;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* {@link AttributeMap} implementation that binds a rule's attribute as follows:
*
* <ol>
* <li>If the attribute is selectable (i.e. its BUILD declaration is of the form
* "attr = { config1: "value1", "config2: "value2", ... }", returns the subset of values
* chosen by the current configuration in accordance with Bazel's documented policy on
* configurable attribute selection.
* <li>If the attribute is not selectable (i.e. its value is static), returns that value with
* no additional processing.
* </ol>
*
* <p>Example usage:
* <pre>
* Label fooLabel = ConfiguredAttributeMapper.of(ruleConfiguredTarget).get("foo", Type.LABEL);
* </pre>
*/
public class ConfiguredAttributeMapper extends AbstractAttributeMapper {
private final Map<Label, ConfigMatchingProvider> configConditions;
private Rule rule;
private ConfiguredAttributeMapper(Rule rule, Set<ConfigMatchingProvider> configConditions) {
super(Preconditions.checkNotNull(rule).getPackage(), rule.getRuleClassObject(), rule.getLabel(),
rule.getAttributeContainer());
ImmutableMap.Builder<Label, ConfigMatchingProvider> builder = ImmutableMap.builder();
for (ConfigMatchingProvider configCondition : configConditions) {
builder.put(configCondition.label(), configCondition);
}
this.configConditions = builder.build();
this.rule = rule;
}
/**
* "Do-it-all" constructor that just needs a {@link RuleConfiguredTarget}.
*/
public static ConfiguredAttributeMapper of(RuleConfiguredTarget ct) {
return new ConfiguredAttributeMapper(ct.getTarget(), ct.getConfigConditions());
}
/**
* "Manual" constructor that requires the caller to pass the set of configurability conditions
* that trigger this rule's configurable attributes.
*
* <p>If you don't know how to do this, you really want to use one of the "do-it-all"
* constructors.
*/
@VisibleForTesting
public static ConfiguredAttributeMapper of(
Rule rule, Set<ConfigMatchingProvider> configConditions) {
return new ConfiguredAttributeMapper(rule, configConditions);
}
/**
* Checks that all attributes can be mapped to their configured values. This is
* useful for checking that the configuration space in a configured attribute doesn't
* contain unresolvable contradictions.
*
* @throws EvalException if any attribute's value can't be resolved under this mapper
*/
public void validateAttributes() throws EvalException {
for (String attrName : getAttributeNames()) {
getAndValidate(attrName, getAttributeType(attrName));
}
}
/**
* Variation of {@link #get} that throws an informative exception if the attribute
* can't be resolved due to intrinsic contradictions in the configuration.
*/
private <T> T getAndValidate(String attributeName, Type<T> type) throws EvalException {
SelectorList<T> selectorList = getSelectorList(attributeName, type);
if (selectorList == null) {
// This is a normal attribute.
return super.get(attributeName, type);
}
List<T> resolvedList = new ArrayList<>();
for (Selector<T> selector : selectorList.getSelectors()) {
resolvedList.add(resolveSelector(attributeName, selector));
}
return resolvedList.size() == 1 ? resolvedList.get(0) : type.concat(resolvedList);
}
private <T> T resolveSelector(String attributeName, Selector<T> selector)
throws EvalException {
ConfigMatchingProvider matchingCondition = null;
Set<Label> conditionLabels = new LinkedHashSet<>();
T matchingValue = null;
// Find the matching condition and record its value (checking for duplicates).
for (Map.Entry<Label, T> entry : selector.getEntries().entrySet()) {
Label selectorKey = entry.getKey();
if (BuildType.Selector.isReservedLabel(selectorKey)) {
continue;
}
ConfigMatchingProvider curCondition = Verify.verifyNotNull(configConditions.get(selectorKey));
conditionLabels.add(curCondition.label());
if (curCondition.matches()) {
if (matchingCondition == null || curCondition.refines(matchingCondition)) {
// A match is valid if either this is the *only* condition that matches or this is a
// more "precise" specification of another matching condition (in which case we choose
// the most precise one).
matchingCondition = curCondition;
matchingValue = entry.getValue();
} else if (matchingCondition.refines(curCondition)) {
// The originally matching conditions is more precise, so keep that one.
} else {
throw new EvalException(rule.getAttributeLocation(attributeName),
"Both " + matchingCondition.label() + " and " + curCondition.label()
+ " match configurable attribute \"" + attributeName + "\" in " + getLabel()
+ ". Multiple matches are not allowed unless one is a specialization of the other");
}
}
}
// If nothing matched, choose the default condition.
if (matchingCondition == null) {
if (!selector.hasDefault()) {
throw new EvalException(rule.getAttributeLocation(attributeName),
"Configurable attribute \"" + attributeName + "\" doesn't match this "
+ "configuration (would a default condition help?).\nConditions checked:\n "
+ Joiner.on("\n ").join(conditionLabels));
}
matchingValue = selector.getDefault();
}
return matchingValue;
}
@Override
public <T> T get(String attributeName, Type<T> type) {
try {
return getAndValidate(attributeName, type);
} catch (EvalException e) {
// Callers that reach this branch should explicitly validate the attribute through an
// appropriate call and handle the exception directly. This method assumes
// pre-validated attributes.
throw new IllegalStateException(
"lookup failed on attribute " + attributeName + ": " + e.getMessage());
}
}
}
|
