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
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
// Copyright 2017 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.analysis.config;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.devtools.build.lib.analysis.TargetAndConfiguration;
import com.google.devtools.build.lib.analysis.config.transitions.ComposingSplitTransition;
import com.google.devtools.build.lib.analysis.config.transitions.NoTransition;
import com.google.devtools.build.lib.analysis.config.transitions.NullTransition;
import com.google.devtools.build.lib.analysis.config.transitions.PatchTransition;
import com.google.devtools.build.lib.analysis.config.transitions.SplitTransition;
import com.google.devtools.build.lib.analysis.config.transitions.Transition;
import com.google.devtools.build.lib.packages.Attribute;
import com.google.devtools.build.lib.packages.ConfiguredAttributeMapper;
import com.google.devtools.build.lib.packages.InputFile;
import com.google.devtools.build.lib.packages.PackageGroup;
import com.google.devtools.build.lib.packages.Rule;
import com.google.devtools.build.lib.packages.RuleTransitionFactory;
import com.google.devtools.build.lib.packages.Target;
/**
* Tool for evaluating which {@link Transition}(s) should be applied to given targets.
*
* <p>For the work of turning these transitions into actual configurations, see {@link
* ConfigurationResolver}.
*
* <p>This is the "generic engine" for configuration selection. It doesn't know anything about
* specific rules or their requirements. Rule writers decide those with appropriately placed {@link
* PatchTransition} declarations. This class then processes those declarations to determine final
* transitions.
*/
public final class TransitionResolver {
/**
* Given a parent rule and configuration depending on a child through an attribute, determines
* the configuration the child should take.
*
* @param fromConfig the parent rule's configuration
* @param fromRule the parent rule
* @param attribute the attribute creating the dependency (e.g. "srcs")
* @param toTarget the child target (which may or may not be a rule)
*
* @return the child's configuration, expressed as a diff from the parent's configuration. This
* is either a {@link PatchTransition} or {@link SplitTransition}.
*/
public static Transition evaluateTransition(BuildConfiguration fromConfig, final Rule fromRule,
final Attribute attribute, final Target toTarget, ConfiguredAttributeMapper attributeMap) {
// I. Input files and package groups have no configurations. We don't want to duplicate them.
if (usesNullConfiguration(toTarget)) {
return NullTransition.INSTANCE;
}
// II. Host configurations never switch to another. All prerequisites of host targets have the
// same host configuration.
if (fromConfig.isHostConfiguration()) {
return NoTransition.INSTANCE;
}
// Make sure config_setting dependencies are resolved in the referencing rule's configuration,
// unconditionally. For example, given:
//
// genrule(
// name = 'myrule',
// tools = select({ '//a:condition': [':sometool'] })
//
// all labels in "tools" get resolved in the host configuration (since the "tools" attribute
// declares a host configuration transition). We want to explicitly exclude configuration labels
// from these transitions, since their *purpose* is to do computation on the owning
// rule's configuration.
// TODO(bazel-team): don't require special casing here. This is far too hackish.
if (toTarget instanceof Rule && ((Rule) toTarget).getRuleClassObject().isConfigMatcher()) {
// TODO(gregce): see if this actually gets called
return NoTransition.INSTANCE;
}
// The current transition to apply. When multiple transitions are requested, this is a
// ComposingSplitTransition, which encapsulates them into a single object so calling code
// doesn't need special logic for combinations.
Transition currentTransition = NoTransition.INSTANCE;
// Apply the parent rule's outgoing transition if it has one.
RuleTransitionFactory transitionFactory =
fromRule.getRuleClassObject().getOutgoingTransitionFactory();
if (transitionFactory != null) {
Transition transition = transitionFactory.buildTransitionFor(toTarget.getAssociatedRule());
if (transition != null) {
currentTransition = composeTransitions(currentTransition, transition);
}
}
// TODO(gregce): make the below transitions composable (i.e. take away the "else" clauses).
// The "else" is a legacy restriction from static configurations.
if (attribute.hasSplitConfigurationTransition()) {
currentTransition = split(currentTransition, attribute.getSplitTransition(attributeMap));
} else {
// III. Attributes determine configurations. The configuration of a prerequisite is determined
// by the attribute.
currentTransition = composeTransitions(currentTransition,
attribute.getConfigurationTransition());
}
// IV. Applies any rule transitions associated with the dep target, composes their transitions
// with a passed-in existing transition, and returns the composed result.
return applyRuleTransition(currentTransition, toTarget);
}
/**
* Same as evaluateTransition except does not check for transitions coming from parents and
* enables support for rule-triggered top-level configuration hooks.
*/
public static Transition evaluateTopLevelTransition(TargetAndConfiguration targetAndConfig) {
Target target = targetAndConfig.getTarget();
BuildConfiguration fromConfig = targetAndConfig.getConfiguration();
// Top-level transitions (chosen by configuration fragments):
Transition topLevelTransition = fromConfig.topLevelConfigurationHook(target);
if (topLevelTransition == null) {
topLevelTransition = NoTransition.INSTANCE;
}
// Rule class transitions (chosen by rule class definitions):
if (target.getAssociatedRule() == null) {
return topLevelTransition;
}
return applyRuleTransition(topLevelTransition, target);
}
/**
* Returns true if the given target should have a null configuration. This method is the
* "source of truth" for this determination.
*/
public static boolean usesNullConfiguration(Target target) {
return target instanceof InputFile || target instanceof PackageGroup;
}
/**
* Composes two transitions together efficiently.
*/
@VisibleForTesting
public static Transition composeTransitions(Transition transition1, Transition transition2) {
if (isFinal(transition1) || transition2 == NoTransition.INSTANCE) {
return transition1;
} else if (isFinal(transition2) || transition1 == NoTransition.INSTANCE) {
// When the second transition is a HOST transition, there's no need to compose. But this also
// improves performance: host transitions are common, and ConfiguredTargetFunction has special
// optimized logic to handle them. If they were buried in the last segment of a
// ComposingSplitTransition, those optimizations wouldn't trigger.
return transition2;
} else {
return new ComposingSplitTransition(transition1, transition2);
}
}
/**
* Returns true if once the given transition is applied to a dep no followup transitions should
* be composed after it.
*/
private static boolean isFinal(Transition transition) {
return (transition == NullTransition.INSTANCE
|| transition == HostTransition.INSTANCE);
}
/**
* Applies the given split and composes it after an existing transition.
*/
private static Transition split(Transition currentTransition, SplitTransition split) {
Preconditions.checkState(currentTransition != NullTransition.INSTANCE,
"cannot apply splits after null transitions (null transitions are expected to be final)");
Preconditions.checkState(currentTransition != HostTransition.INSTANCE,
"cannot apply splits after host transitions (host transitions are expected to be final)");
return currentTransition == NoTransition.INSTANCE
? split
: new ComposingSplitTransition(currentTransition, split);
}
/**
* @param currentTransition a pre-existing transition to be composed with
* @param toTarget rule to examine for transitions
*/
private static Transition applyRuleTransition(Transition currentTransition, Target toTarget) {
if (isFinal(currentTransition)) {
return currentTransition;
}
Rule associatedRule = toTarget.getAssociatedRule();
RuleTransitionFactory transitionFactory =
associatedRule.getRuleClassObject().getTransitionFactory();
if (transitionFactory != null) {
PatchTransition ruleClassTransition =
(PatchTransition) transitionFactory.buildTransitionFor(associatedRule);
if (ruleClassTransition != null) {
if (currentTransition == NoTransition.INSTANCE) {
return ruleClassTransition;
} else {
return new ComposingSplitTransition(currentTransition, ruleClassTransition);
}
}
}
return currentTransition;
}
}
|
