blob: d6166d2de81bcdb9d00f71e74f2ce56746bb4e0b [file] [log] [blame]
Colin Cross6362e272015-10-29 15:25:03 -07001// Copyright 2015 Google Inc. All rights reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
Colin Cross635c3b02016-05-18 15:37:25 -070015package android
Colin Cross6362e272015-10-29 15:25:03 -070016
Colin Cross795c3772017-03-16 16:50:10 -070017import (
Colin Cross984223f2024-02-01 17:10:23 -080018 "sync"
19
Colin Cross795c3772017-03-16 16:50:10 -070020 "github.com/google/blueprint"
21)
Colin Cross6362e272015-10-29 15:25:03 -070022
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -070023// Phases:
24// run Pre-arch mutators
25// run archMutator
26// run Pre-deps mutators
27// run depsMutator
28// run PostDeps mutators
Colin Cross1e954b62024-09-13 13:50:00 -070029// run FinalDeps mutators (TransitionMutators disallowed in this phase)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -070030// continue on to GenerateAndroidBuildActions
Colin Cross1e676be2016-10-12 14:38:15 -070031
Paul Duffinc05b0342021-03-06 13:28:13 +000032// collateGloballyRegisteredMutators constructs the list of mutators that have been registered
33// with the InitRegistrationContext and will be used at runtime.
34func collateGloballyRegisteredMutators() sortableComponents {
Colin Crossf22fe412024-10-01 14:02:12 -070035 return collateRegisteredMutators(preArch, preDeps, postDeps, postApex, finalDeps)
Paul Duffinc05b0342021-03-06 13:28:13 +000036}
37
38// collateRegisteredMutators constructs a single list of mutators from the separate lists.
Colin Crossf22fe412024-10-01 14:02:12 -070039func collateRegisteredMutators(preArch, preDeps, postDeps, postApex, finalDeps []RegisterMutatorFunc) sortableComponents {
Colin Crosscec81712017-07-13 14:43:27 -070040 mctx := &registerMutatorsContext{}
Nan Zhangdb0b9a32017-02-27 10:12:13 -080041
42 register := func(funcs []RegisterMutatorFunc) {
43 for _, f := range funcs {
Colin Crosscec81712017-07-13 14:43:27 -070044 f(mctx)
Nan Zhangdb0b9a32017-02-27 10:12:13 -080045 }
46 }
47
Colin Crosscec81712017-07-13 14:43:27 -070048 register(preArch)
Nan Zhangdb0b9a32017-02-27 10:12:13 -080049
Colin Crosscec81712017-07-13 14:43:27 -070050 register(preDeps)
51
Liz Kammer356f7d42021-01-26 09:18:53 -050052 register([]RegisterMutatorFunc{registerDepsMutator})
Colin Crosscec81712017-07-13 14:43:27 -070053
54 register(postDeps)
55
Colin Crossf22fe412024-10-01 14:02:12 -070056 register(postApex)
57
Martin Stjernholm710ec3a2020-01-16 15:12:04 +000058 mctx.finalPhase = true
59 register(finalDeps)
60
Paul Duffinc05b0342021-03-06 13:28:13 +000061 return mctx.mutators
Colin Cross795c3772017-03-16 16:50:10 -070062}
63
64type registerMutatorsContext struct {
Colin Crossb63d7b32023-12-07 16:54:51 -080065 mutators sortableComponents
66 finalPhase bool
Colin Cross795c3772017-03-16 16:50:10 -070067}
Colin Cross1e676be2016-10-12 14:38:15 -070068
69type RegisterMutatorsContext interface {
Colin Cross25de6c32019-06-06 14:29:25 -070070 BottomUp(name string, m BottomUpMutator) MutatorHandle
Colin Cross617b88a2020-08-24 18:04:09 -070071 BottomUpBlueprint(name string, m blueprint.BottomUpMutator) MutatorHandle
Colin Cross90d7df92025-01-31 11:29:33 -080072 Transition(name string, m VariationTransitionMutator) TransitionMutatorHandle
73 InfoBasedTransition(name string, m androidTransitionMutator) TransitionMutatorHandle
Colin Cross1e676be2016-10-12 14:38:15 -070074}
75
76type RegisterMutatorFunc func(RegisterMutatorsContext)
77
Colin Crosscec81712017-07-13 14:43:27 -070078var preArch = []RegisterMutatorFunc{
Dan Willemsen6e72ef72018-01-26 18:27:02 -080079 RegisterNamespaceMutator,
Paul Duffinaa4162e2020-05-05 11:35:43 +010080
Paul Duffinaa4162e2020-05-05 11:35:43 +010081 // Check the visibility rules are valid.
82 //
83 // This must run after the package renamer mutators so that any issues found during
84 // validation of the package's default_visibility property are reported using the
85 // correct package name and not the synthetic name.
86 //
87 // This must also be run before defaults mutators as the rules for validation are
88 // different before checking the rules than they are afterwards. e.g.
89 // visibility: ["//visibility:private", "//visibility:public"]
90 // would be invalid if specified in a module definition but is valid if it results
91 // from something like this:
92 //
93 // defaults {
94 // name: "defaults",
95 // // Be inaccessible outside a package by default.
96 // visibility: ["//visibility:private"]
97 // }
98 //
99 // defaultable_module {
100 // name: "defaultable_module",
101 // defaults: ["defaults"],
102 // // Override the default.
103 // visibility: ["//visibility:public"]
104 // }
105 //
Paul Duffin593b3c92019-12-05 14:31:48 +0000106 RegisterVisibilityRuleChecker,
Paul Duffinaa4162e2020-05-05 11:35:43 +0100107
Bob Badour37af0462021-01-07 03:34:31 +0000108 // Record the default_applicable_licenses for each package.
109 //
110 // This must run before the defaults so that defaults modules can pick up the package default.
111 RegisterLicensesPackageMapper,
112
Paul Duffinaa4162e2020-05-05 11:35:43 +0100113 // Apply properties from defaults modules to the referencing modules.
Paul Duffinafa9fa12020-04-29 16:47:28 +0100114 //
115 // Any mutators that are added before this will not see any modules created by
116 // a DefaultableHook.
Colin Cross89536d42017-07-07 14:35:50 -0700117 RegisterDefaultsPreArchMutators,
Paul Duffinaa4162e2020-05-05 11:35:43 +0100118
Paul Duffin44f1d842020-06-26 20:17:02 +0100119 // Add dependencies on any components so that any component references can be
120 // resolved within the deps mutator.
121 //
122 // Must be run after defaults so it can be used to create dependencies on the
123 // component modules that are creating in a DefaultableHook.
124 //
125 // Must be run before RegisterPrebuiltsPreArchMutators, i.e. before prebuilts are
126 // renamed. That is so that if a module creates components using a prebuilt module
127 // type that any dependencies (which must use prebuilt_ prefixes) are resolved to
128 // the prebuilt module and not the source module.
129 RegisterComponentsMutator,
130
Paul Duffinc988c8e2020-04-29 18:27:14 +0100131 // Create an association between prebuilt modules and their corresponding source
132 // modules (if any).
Paul Duffinafa9fa12020-04-29 16:47:28 +0100133 //
134 // Must be run after defaults mutators to ensure that any modules created by
135 // a DefaultableHook can be either a prebuilt or a source module with a matching
136 // prebuilt.
Paul Duffinc988c8e2020-04-29 18:27:14 +0100137 RegisterPrebuiltsPreArchMutators,
138
Bob Badour37af0462021-01-07 03:34:31 +0000139 // Gather the licenses properties for all modules for use during expansion and enforcement.
140 //
141 // This must come after the defaults mutators to ensure that any licenses supplied
142 // in a defaults module has been successfully applied before the rules are gathered.
143 RegisterLicensesPropertyGatherer,
144
Paul Duffinaa4162e2020-05-05 11:35:43 +0100145 // Gather the visibility rules for all modules for us during visibility enforcement.
146 //
147 // This must come after the defaults mutators to ensure that any visibility supplied
148 // in a defaults module has been successfully applied before the rules are gathered.
Paul Duffin593b3c92019-12-05 14:31:48 +0000149 RegisterVisibilityRuleGatherer,
Colin Crosscec81712017-07-13 14:43:27 -0700150}
151
Colin Crossae4c6182017-09-15 17:33:55 -0700152func registerArchMutator(ctx RegisterMutatorsContext) {
Colin Cross8bbc3d52024-09-11 15:33:54 -0700153 ctx.Transition("os", &osTransitionMutator{})
Cole Faust5b7635d2024-10-28 13:01:12 -0700154 ctx.BottomUp("image_begin", imageMutatorBeginMutator)
Jihoon Kang5402bbd2024-07-31 18:37:49 +0000155 ctx.Transition("image", &imageTransitionMutator{})
Colin Cross8bbc3d52024-09-11 15:33:54 -0700156 ctx.Transition("arch", &archTransitionMutator{})
Colin Crossae4c6182017-09-15 17:33:55 -0700157}
158
Colin Crosscec81712017-07-13 14:43:27 -0700159var preDeps = []RegisterMutatorFunc{
Colin Crossae4c6182017-09-15 17:33:55 -0700160 registerArchMutator,
Colin Crossd8d8b852024-12-20 16:32:37 -0800161 RegisterPrebuiltsPreDepsMutators,
Colin Crosscec81712017-07-13 14:43:27 -0700162}
163
164var postDeps = []RegisterMutatorFunc{
Colin Cross1b488422019-03-04 22:33:56 -0800165 registerPathDepsMutator,
Colin Cross5ea9bcc2017-07-27 15:41:32 -0700166 RegisterPrebuiltsPostDepsMutators,
Paul Duffin593b3c92019-12-05 14:31:48 +0000167 RegisterVisibilityRuleEnforcer,
Bob Badour37af0462021-01-07 03:34:31 +0000168 RegisterLicensesDependencyChecker,
Paul Duffin45338f02021-03-30 23:07:52 +0100169 registerNeverallowMutator,
Jaewoong Jungb639a6a2019-05-10 15:16:29 -0700170 RegisterOverridePostDepsMutators,
Colin Crosscec81712017-07-13 14:43:27 -0700171}
Colin Cross1e676be2016-10-12 14:38:15 -0700172
Colin Crossf22fe412024-10-01 14:02:12 -0700173var postApex = []RegisterMutatorFunc{}
174
Martin Stjernholm710ec3a2020-01-16 15:12:04 +0000175var finalDeps = []RegisterMutatorFunc{}
176
Colin Cross1e676be2016-10-12 14:38:15 -0700177func PreArchMutators(f RegisterMutatorFunc) {
178 preArch = append(preArch, f)
179}
180
181func PreDepsMutators(f RegisterMutatorFunc) {
182 preDeps = append(preDeps, f)
183}
184
185func PostDepsMutators(f RegisterMutatorFunc) {
186 postDeps = append(postDeps, f)
187}
188
Colin Crossf22fe412024-10-01 14:02:12 -0700189func PostApexMutators(f RegisterMutatorFunc) {
190 postApex = append(postApex, f)
191}
192
Martin Stjernholm710ec3a2020-01-16 15:12:04 +0000193func FinalDepsMutators(f RegisterMutatorFunc) {
194 finalDeps = append(finalDeps, f)
195}
196
Colin Cross25de6c32019-06-06 14:29:25 -0700197type BottomUpMutator func(BottomUpMutatorContext)
Colin Cross6362e272015-10-29 15:25:03 -0700198
Colin Cross635c3b02016-05-18 15:37:25 -0700199type BottomUpMutatorContext interface {
Colin Crossb2388e32024-10-07 15:05:23 -0700200 BaseModuleContext
Colin Crossb63d7b32023-12-07 16:54:51 -0800201
202 // AddDependency adds a dependency to the given module. It returns a slice of modules for each
203 // dependency (some entries may be nil).
204 //
Colin Cross8a962802024-10-09 15:29:27 -0700205 // This method will pause until the new dependencies have had the current mutator called on them.
Colin Crossd5c64312024-12-18 16:04:52 -0800206 AddDependency(module blueprint.Module, tag blueprint.DependencyTag, name ...string) []Module
Colin Crossaabf6792017-11-29 00:27:14 -0800207
Colin Cross9f35c3d2020-09-16 19:04:41 -0700208 // AddReverseDependency adds a dependency from the destination to the given module.
209 // Does not affect the ordering of the current mutator pass, but will be ordered
210 // correctly for all future mutator passes. All reverse dependencies for a destination module are
211 // collected until the end of the mutator pass, sorted by name, and then appended to the destination
Colin Crossb8533a82024-10-05 15:25:09 -0700212 // module's dependency list. May only be called by mutators that were marked with
213 // UsesReverseDependencies during registration.
Colin Crossaabf6792017-11-29 00:27:14 -0800214 AddReverseDependency(module blueprint.Module, tag blueprint.DependencyTag, name string)
Colin Cross9f35c3d2020-09-16 19:04:41 -0700215
Colin Cross9f35c3d2020-09-16 19:04:41 -0700216 // AddVariationDependencies adds deps as dependencies of the current module, but uses the variations
Colin Cross4f1dcb02020-09-16 18:45:04 -0700217 // argument to select which variant of the dependency to use. It returns a slice of modules for
218 // each dependency (some entries may be nil). A variant of the dependency must exist that matches
Usta Shresthac725f472022-01-11 02:44:21 -0500219 // all the non-local variations of the current module, plus the variations argument.
Colin Cross4f1dcb02020-09-16 18:45:04 -0700220 //
Colin Cross8a962802024-10-09 15:29:27 -0700221 // This method will pause until the new dependencies have had the current mutator called on them.
Colin Crossd5c64312024-12-18 16:04:52 -0800222 AddVariationDependencies(variations []blueprint.Variation, tag blueprint.DependencyTag, names ...string) []Module
Colin Cross9f35c3d2020-09-16 19:04:41 -0700223
Colin Crossb8533a82024-10-05 15:25:09 -0700224 // AddReverseVariationDependency adds a dependency from the named module to the current
Cole Faustf4992e82024-09-30 15:16:18 -0700225 // module. The given variations will be added to the current module's varations, and then the
226 // result will be used to find the correct variation of the depending module, which must exist.
227 //
228 // Does not affect the ordering of the current mutator pass, but will be ordered
229 // correctly for all future mutator passes. All reverse dependencies for a destination module are
230 // collected until the end of the mutator pass, sorted by name, and then appended to the destination
Colin Crossb8533a82024-10-05 15:25:09 -0700231 // module's dependency list. May only be called by mutators that were marked with
232 // UsesReverseDependencies during registration.
Cole Faustf4992e82024-09-30 15:16:18 -0700233 AddReverseVariationDependency([]blueprint.Variation, blueprint.DependencyTag, string)
234
Colin Cross9f35c3d2020-09-16 19:04:41 -0700235 // AddFarVariationDependencies adds deps as dependencies of the current module, but uses the
Colin Cross4f1dcb02020-09-16 18:45:04 -0700236 // variations argument to select which variant of the dependency to use. It returns a slice of
237 // modules for each dependency (some entries may be nil). A variant of the dependency must
238 // exist that matches the variations argument, but may also have other variations.
Colin Cross9f35c3d2020-09-16 19:04:41 -0700239 // For any unspecified variation the first variant will be used.
240 //
241 // Unlike AddVariationDependencies, the variations of the current module are ignored - the
242 // dependency only needs to match the supplied variations.
Colin Cross4f1dcb02020-09-16 18:45:04 -0700243 //
Colin Cross8a962802024-10-09 15:29:27 -0700244 // This method will pause until the new dependencies have had the current mutator called on them.
Colin Crossd5c64312024-12-18 16:04:52 -0800245 AddFarVariationDependencies([]blueprint.Variation, blueprint.DependencyTag, ...string) []Module
Colin Cross9f35c3d2020-09-16 19:04:41 -0700246
Colin Cross86771322024-05-01 14:19:51 -0700247 // ReplaceDependencies finds all the variants of the module with the specified name, then
248 // replaces all dependencies onto those variants with the current variant of this module.
Colin Crossb8533a82024-10-05 15:25:09 -0700249 // Replacements don't take effect until after the mutator pass is finished. May only
250 // be called by mutators that were marked with UsesReplaceDependencies during registration.
Colin Crossaabf6792017-11-29 00:27:14 -0800251 ReplaceDependencies(string)
Colin Cross9f35c3d2020-09-16 19:04:41 -0700252
Colin Cross86771322024-05-01 14:19:51 -0700253 // ReplaceDependenciesIf finds all the variants of the module with the specified name, then
254 // replaces all dependencies onto those variants with the current variant of this module
255 // as long as the supplied predicate returns true.
Colin Crossb8533a82024-10-05 15:25:09 -0700256 // Replacements don't take effect until after the mutator pass is finished. May only
257 // be called by mutators that were marked with UsesReplaceDependencies during registration.
Paul Duffin80342d72020-06-26 22:08:43 +0100258 ReplaceDependenciesIf(string, blueprint.ReplaceDependencyPredicate)
Colin Crossb2388e32024-10-07 15:05:23 -0700259
260 // Rename all variants of a module. The new name is not visible to calls to ModuleName,
Colin Crossb8533a82024-10-05 15:25:09 -0700261 // AddDependency or OtherModuleName until after this mutator pass is complete. May only be called
262 // by mutators that were marked with UsesRename during registration.
Colin Crossb2388e32024-10-07 15:05:23 -0700263 Rename(name string)
264
265 // CreateModule creates a new module by calling the factory method for the specified moduleType, and applies
Colin Crossb8533a82024-10-05 15:25:09 -0700266 // the specified property structs to it as if the properties were set in a blueprint file. May only
267 // be called by mutators that were marked with UsesCreateModule during registration.
Colin Crossb2388e32024-10-07 15:05:23 -0700268 CreateModule(ModuleFactory, ...interface{}) Module
Colin Cross6362e272015-10-29 15:25:03 -0700269}
270
Colin Cross984223f2024-02-01 17:10:23 -0800271// An outgoingTransitionContextImpl and incomingTransitionContextImpl is created for every dependency of every module
Colin Crossa6792772025-02-11 12:03:24 -0800272// for each transition mutator. bottomUpMutatorContext is created once for every module for every BottomUp mutator.
273// Use a global pool for each to avoid reallocating every time.
Colin Cross984223f2024-02-01 17:10:23 -0800274var (
275 outgoingTransitionContextPool = sync.Pool{
276 New: func() any { return &outgoingTransitionContextImpl{} },
277 }
278 incomingTransitionContextPool = sync.Pool{
279 New: func() any { return &incomingTransitionContextImpl{} },
280 }
281 bottomUpMutatorContextPool = sync.Pool{
282 New: func() any { return &bottomUpMutatorContext{} },
283 }
Colin Cross984223f2024-02-01 17:10:23 -0800284)
285
Colin Cross25de6c32019-06-06 14:29:25 -0700286type bottomUpMutatorContext struct {
Colin Crossdc35e212019-06-06 16:13:11 -0700287 bp blueprint.BottomUpMutatorContext
Colin Cross0ea8ba82019-06-06 14:33:29 -0700288 baseModuleContext
Chris Parsons5a34ffb2021-07-21 14:34:58 -0400289 finalPhase bool
Colin Cross6362e272015-10-29 15:25:03 -0700290}
291
Colin Cross984223f2024-02-01 17:10:23 -0800292// callers must immediately follow the call to this function with defer bottomUpMutatorContextPool.Put(mctx).
Colin Cross617b88a2020-08-24 18:04:09 -0700293func bottomUpMutatorContextFactory(ctx blueprint.BottomUpMutatorContext, a Module,
Colin Crossb63d7b32023-12-07 16:54:51 -0800294 finalPhase bool) BottomUpMutatorContext {
Colin Cross617b88a2020-08-24 18:04:09 -0700295
Chris Parsons5a34ffb2021-07-21 14:34:58 -0400296 moduleContext := a.base().baseModuleContextFactory(ctx)
Colin Cross984223f2024-02-01 17:10:23 -0800297 mctx := bottomUpMutatorContextPool.Get().(*bottomUpMutatorContext)
298 *mctx = bottomUpMutatorContext{
Chris Parsons5a34ffb2021-07-21 14:34:58 -0400299 bp: ctx,
Cole Faust0abd4b42023-01-10 10:49:18 -0800300 baseModuleContext: moduleContext,
Chris Parsons5a34ffb2021-07-21 14:34:58 -0400301 finalPhase: finalPhase,
Colin Cross617b88a2020-08-24 18:04:09 -0700302 }
Colin Cross984223f2024-02-01 17:10:23 -0800303 return mctx
Colin Cross617b88a2020-08-24 18:04:09 -0700304}
305
Colin Cross25de6c32019-06-06 14:29:25 -0700306func (x *registerMutatorsContext) BottomUp(name string, m BottomUpMutator) MutatorHandle {
Martin Stjernholm710ec3a2020-01-16 15:12:04 +0000307 finalPhase := x.finalPhase
Colin Cross798bfce2016-10-12 14:28:16 -0700308 f := func(ctx blueprint.BottomUpMutatorContext) {
Colin Cross635c3b02016-05-18 15:37:25 -0700309 if a, ok := ctx.Module().(Module); ok {
Colin Cross984223f2024-02-01 17:10:23 -0800310 mctx := bottomUpMutatorContextFactory(ctx, a, finalPhase)
311 defer bottomUpMutatorContextPool.Put(mctx)
312 m(mctx)
Colin Cross6362e272015-10-29 15:25:03 -0700313 }
Colin Cross798bfce2016-10-12 14:28:16 -0700314 }
Liz Kammer356f7d42021-01-26 09:18:53 -0500315 mutator := &mutator{name: x.mutatorName(name), bottomUpMutator: f}
Colin Cross795c3772017-03-16 16:50:10 -0700316 x.mutators = append(x.mutators, mutator)
Colin Cross798bfce2016-10-12 14:28:16 -0700317 return mutator
Colin Cross6362e272015-10-29 15:25:03 -0700318}
319
Colin Cross617b88a2020-08-24 18:04:09 -0700320func (x *registerMutatorsContext) BottomUpBlueprint(name string, m blueprint.BottomUpMutator) MutatorHandle {
321 mutator := &mutator{name: name, bottomUpMutator: m}
322 x.mutators = append(x.mutators, mutator)
323 return mutator
324}
325
Colin Cross90d7df92025-01-31 11:29:33 -0800326func (x *registerMutatorsContext) Transition(name string, m VariationTransitionMutator) TransitionMutatorHandle {
Colin Crossc6f3f022025-01-31 11:16:26 -0800327 atm := &androidTransitionMutatorAdapter{
Colin Crossb63d7b32023-12-07 16:54:51 -0800328 finalPhase: x.finalPhase,
Colin Crossc6f3f022025-01-31 11:16:26 -0800329 mutator: variationTransitionMutatorAdapter{m},
Colin Crossd67425d2024-04-15 15:17:05 -0700330 name: name,
Lukacs T. Berki6c716762022-06-13 20:50:39 +0200331 }
332 mutator := &mutator{
333 name: name,
Cole Faustfc7a4112024-11-04 15:07:12 -0800334 transitionMutator: atm,
335 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +0200336 x.mutators = append(x.mutators, mutator)
Cole Faustfc7a4112024-11-04 15:07:12 -0800337 return mutator
Lukacs T. Berki6c716762022-06-13 20:50:39 +0200338}
339
Colin Cross90d7df92025-01-31 11:29:33 -0800340func (x *registerMutatorsContext) InfoBasedTransition(name string, m androidTransitionMutator) TransitionMutatorHandle {
341 atm := &androidTransitionMutatorAdapter{
342 finalPhase: x.finalPhase,
343 mutator: m,
344 name: name,
345 }
346 mutator := &mutator{
347 name: name,
348 transitionMutator: atm,
349 }
350 x.mutators = append(x.mutators, mutator)
351 return mutator
352}
353
Liz Kammer356f7d42021-01-26 09:18:53 -0500354func (x *registerMutatorsContext) mutatorName(name string) string {
Liz Kammer356f7d42021-01-26 09:18:53 -0500355 return name
356}
357
Paul Duffin1d2d42f2021-03-06 20:08:12 +0000358func (mutator *mutator) componentName() string {
359 return mutator.name
360}
361
362func (mutator *mutator) register(ctx *Context) {
363 blueprintCtx := ctx.Context
364 var handle blueprint.MutatorHandle
365 if mutator.bottomUpMutator != nil {
366 handle = blueprintCtx.RegisterBottomUpMutator(mutator.name, mutator.bottomUpMutator)
Lukacs T. Berki6c716762022-06-13 20:50:39 +0200367 } else if mutator.transitionMutator != nil {
Cole Faustfc7a4112024-11-04 15:07:12 -0800368 handle := blueprintCtx.RegisterTransitionMutator(mutator.name, mutator.transitionMutator)
369 if mutator.neverFar {
370 handle.NeverFar()
371 }
Paul Duffin1d2d42f2021-03-06 20:08:12 +0000372 }
Colin Crossb8533a82024-10-05 15:25:09 -0700373
374 // Forward booleans set on the MutatorHandle to the blueprint.MutatorHandle.
Colin Crossb8533a82024-10-05 15:25:09 -0700375 if mutator.usesRename {
376 handle.UsesRename()
377 }
378 if mutator.usesReverseDependencies {
379 handle.UsesReverseDependencies()
380 }
381 if mutator.usesReplaceDependencies {
382 handle.UsesReplaceDependencies()
383 }
384 if mutator.usesCreateModule {
385 handle.UsesCreateModule()
386 }
387 if mutator.mutatesDependencies {
388 handle.MutatesDependencies()
389 }
390 if mutator.mutatesGlobalState {
391 handle.MutatesGlobalState()
392 }
Paul Duffin1d2d42f2021-03-06 20:08:12 +0000393}
394
Colin Cross798bfce2016-10-12 14:28:16 -0700395type MutatorHandle interface {
Colin Crossb8533a82024-10-05 15:25:09 -0700396 // Parallel sets the mutator to visit modules in parallel while maintaining ordering. Calling any
397 // method on the mutator context is thread-safe, but the mutator must handle synchronization
398 // for any modifications to global state or any modules outside the one it was invoked on.
Colin Cross8a962802024-10-09 15:29:27 -0700399 // Deprecated: all Mutators are parallel by default.
Colin Cross798bfce2016-10-12 14:28:16 -0700400 Parallel() MutatorHandle
Colin Crossb8533a82024-10-05 15:25:09 -0700401
402 // UsesRename marks the mutator as using the BottomUpMutatorContext.Rename method, which prevents
403 // coalescing adjacent mutators into a single mutator pass.
404 UsesRename() MutatorHandle
405
406 // UsesReverseDependencies marks the mutator as using the BottomUpMutatorContext.AddReverseDependency
407 // method, which prevents coalescing adjacent mutators into a single mutator pass.
408 UsesReverseDependencies() MutatorHandle
409
410 // UsesReplaceDependencies marks the mutator as using the BottomUpMutatorContext.ReplaceDependencies
411 // method, which prevents coalescing adjacent mutators into a single mutator pass.
412 UsesReplaceDependencies() MutatorHandle
413
414 // UsesCreateModule marks the mutator as using the BottomUpMutatorContext.CreateModule method,
415 // which prevents coalescing adjacent mutators into a single mutator pass.
416 UsesCreateModule() MutatorHandle
417
418 // MutatesDependencies marks the mutator as modifying properties in dependencies, which prevents
419 // coalescing adjacent mutators into a single mutator pass.
420 MutatesDependencies() MutatorHandle
421
422 // MutatesGlobalState marks the mutator as modifying global state, which prevents coalescing
423 // adjacent mutators into a single mutator pass.
424 MutatesGlobalState() MutatorHandle
Colin Cross798bfce2016-10-12 14:28:16 -0700425}
426
Cole Faustfc7a4112024-11-04 15:07:12 -0800427type TransitionMutatorHandle interface {
428 // NeverFar causes the variations created by this mutator to never be ignored when adding
429 // far variation dependencies. Normally, far variation dependencies ignore all the variants
430 // of the source module, and only use the variants explicitly requested by the
431 // AddFarVariationDependencies call.
432 NeverFar() MutatorHandle
433}
434
Colin Cross798bfce2016-10-12 14:28:16 -0700435func (mutator *mutator) Parallel() MutatorHandle {
Colin Cross798bfce2016-10-12 14:28:16 -0700436 return mutator
Colin Cross6362e272015-10-29 15:25:03 -0700437}
Colin Cross1e676be2016-10-12 14:38:15 -0700438
Colin Crossb8533a82024-10-05 15:25:09 -0700439func (mutator *mutator) UsesRename() MutatorHandle {
440 mutator.usesRename = true
441 return mutator
442}
443
444func (mutator *mutator) UsesReverseDependencies() MutatorHandle {
445 mutator.usesReverseDependencies = true
446 return mutator
447}
448
449func (mutator *mutator) UsesReplaceDependencies() MutatorHandle {
450 mutator.usesReplaceDependencies = true
451 return mutator
452}
453
454func (mutator *mutator) UsesCreateModule() MutatorHandle {
455 mutator.usesCreateModule = true
456 return mutator
457}
458
459func (mutator *mutator) MutatesDependencies() MutatorHandle {
460 mutator.mutatesDependencies = true
461 return mutator
462}
463
464func (mutator *mutator) MutatesGlobalState() MutatorHandle {
465 mutator.mutatesGlobalState = true
466 return mutator
467}
468
Cole Faustfc7a4112024-11-04 15:07:12 -0800469func (mutator *mutator) NeverFar() MutatorHandle {
470 mutator.neverFar = true
471 return mutator
472}
473
Paul Duffin44f1d842020-06-26 20:17:02 +0100474func RegisterComponentsMutator(ctx RegisterMutatorsContext) {
Colin Cross8a962802024-10-09 15:29:27 -0700475 ctx.BottomUp("component-deps", componentDepsMutator)
Paul Duffin44f1d842020-06-26 20:17:02 +0100476}
477
478// A special mutator that runs just prior to the deps mutator to allow the dependencies
479// on component modules to be added so that they can depend directly on a prebuilt
480// module.
481func componentDepsMutator(ctx BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -0700482 ctx.Module().ComponentDepsMutator(ctx)
Paul Duffin44f1d842020-06-26 20:17:02 +0100483}
484
Colin Cross1e676be2016-10-12 14:38:15 -0700485func depsMutator(ctx BottomUpMutatorContext) {
Cole Fausta963b942024-04-11 17:43:00 -0700486 if m := ctx.Module(); m.Enabled(ctx) {
Ronald Braunstein73b08ff2023-12-19 10:24:47 -0800487 m.base().baseDepsMutator(ctx)
Colin Cross1e676be2016-10-12 14:38:15 -0700488 m.DepsMutator(ctx)
489 }
490}
Colin Crossd11fcda2017-10-23 17:59:01 -0700491
Liz Kammer356f7d42021-01-26 09:18:53 -0500492func registerDepsMutator(ctx RegisterMutatorsContext) {
Colin Cross8a962802024-10-09 15:29:27 -0700493 ctx.BottomUp("deps", depsMutator).UsesReverseDependencies()
Liz Kammer356f7d42021-01-26 09:18:53 -0500494}
495
Colin Crossa6792772025-02-11 12:03:24 -0800496// android.bottomUpMutatorContext either has to embed blueprint.BottomUpMutatorContext, in which case every method that
Colin Crossdc35e212019-06-06 16:13:11 -0700497// has an overridden version in android.BaseModuleContext has to be manually forwarded to BaseModuleContext to avoid
Colin Crossa6792772025-02-11 12:03:24 -0800498// ambiguous method errors, or it has to store a blueprint.BottomUpMutatorContext non-embedded, in which case every
Colin Crossdc35e212019-06-06 16:13:11 -0700499// non-overridden method has to be forwarded. There are fewer non-overridden methods, so use the latter. The following
Colin Crossa6792772025-02-11 12:03:24 -0800500// methods forward to the identical blueprint versions for bottomUpMutatorContext.
Colin Crossdc35e212019-06-06 16:13:11 -0700501
Colin Crossdc35e212019-06-06 16:13:11 -0700502func (b *bottomUpMutatorContext) Rename(name string) {
503 b.bp.Rename(name)
Colin Cross9a362232019-07-01 15:32:45 -0700504 b.Module().base().commonProperties.DebugName = name
Colin Crossdc35e212019-06-06 16:13:11 -0700505}
506
Colin Crossd5c64312024-12-18 16:04:52 -0800507func (b *bottomUpMutatorContext) createModule(factory blueprint.ModuleFactory, name string, props ...interface{}) Module {
508 return bpModuleToModule(b.bp.CreateModule(factory, name, props...))
Colin Crossda279cf2024-09-17 14:25:45 -0700509}
510
Colin Crossd5c64312024-12-18 16:04:52 -0800511func (b *bottomUpMutatorContext) createModuleInDirectory(factory blueprint.ModuleFactory, name string, _ string, props ...interface{}) Module {
Jihoon Kang222874d2024-10-23 23:38:05 +0000512 panic("createModuleInDirectory is not implemented for bottomUpMutatorContext")
513}
514
Colin Crossda279cf2024-09-17 14:25:45 -0700515func (b *bottomUpMutatorContext) CreateModule(factory ModuleFactory, props ...interface{}) Module {
Jihoon Kang222874d2024-10-23 23:38:05 +0000516 return createModule(b, factory, "_bottomUpMutatorModule", doesNotSpecifyDirectory(), props...)
Colin Crossda279cf2024-09-17 14:25:45 -0700517}
518
Colin Crossd5c64312024-12-18 16:04:52 -0800519func (b *bottomUpMutatorContext) AddDependency(module blueprint.Module, tag blueprint.DependencyTag, name ...string) []Module {
Liz Kammerc13f7852023-05-17 13:01:48 -0400520 if b.baseModuleContext.checkedMissingDeps() {
521 panic("Adding deps not allowed after checking for missing deps")
522 }
Colin Crossd5c64312024-12-18 16:04:52 -0800523 return bpModulesToModules(b.bp.AddDependency(module, tag, name...))
Colin Crossdc35e212019-06-06 16:13:11 -0700524}
525
526func (b *bottomUpMutatorContext) AddReverseDependency(module blueprint.Module, tag blueprint.DependencyTag, name string) {
Liz Kammerc13f7852023-05-17 13:01:48 -0400527 if b.baseModuleContext.checkedMissingDeps() {
528 panic("Adding deps not allowed after checking for missing deps")
529 }
Colin Crossdc35e212019-06-06 16:13:11 -0700530 b.bp.AddReverseDependency(module, tag, name)
531}
Cole Faustf4992e82024-09-30 15:16:18 -0700532
533func (b *bottomUpMutatorContext) AddReverseVariationDependency(variations []blueprint.Variation, tag blueprint.DependencyTag, name string) {
534 if b.baseModuleContext.checkedMissingDeps() {
535 panic("Adding deps not allowed after checking for missing deps")
536 }
537 b.bp.AddReverseVariationDependency(variations, tag, name)
538}
539
Colin Crossdc35e212019-06-06 16:13:11 -0700540func (b *bottomUpMutatorContext) AddVariationDependencies(variations []blueprint.Variation, tag blueprint.DependencyTag,
Colin Crossd5c64312024-12-18 16:04:52 -0800541 names ...string) []Module {
Liz Kammerc13f7852023-05-17 13:01:48 -0400542 if b.baseModuleContext.checkedMissingDeps() {
543 panic("Adding deps not allowed after checking for missing deps")
544 }
Colin Crossd5c64312024-12-18 16:04:52 -0800545 return bpModulesToModules(b.bp.AddVariationDependencies(variations, tag, names...))
Colin Crossdc35e212019-06-06 16:13:11 -0700546}
547
548func (b *bottomUpMutatorContext) AddFarVariationDependencies(variations []blueprint.Variation,
Colin Crossd5c64312024-12-18 16:04:52 -0800549 tag blueprint.DependencyTag, names ...string) []Module {
Liz Kammerc13f7852023-05-17 13:01:48 -0400550 if b.baseModuleContext.checkedMissingDeps() {
551 panic("Adding deps not allowed after checking for missing deps")
552 }
Colin Crossdc35e212019-06-06 16:13:11 -0700553
Colin Crossd5c64312024-12-18 16:04:52 -0800554 return bpModulesToModules(b.bp.AddFarVariationDependencies(variations, tag, names...))
Colin Crossdc35e212019-06-06 16:13:11 -0700555}
556
Colin Crossdc35e212019-06-06 16:13:11 -0700557func (b *bottomUpMutatorContext) ReplaceDependencies(name string) {
Liz Kammerc13f7852023-05-17 13:01:48 -0400558 if b.baseModuleContext.checkedMissingDeps() {
559 panic("Adding deps not allowed after checking for missing deps")
560 }
Colin Crossdc35e212019-06-06 16:13:11 -0700561 b.bp.ReplaceDependencies(name)
562}
Jaewoong Jung9f88ce22019-11-15 10:57:34 -0800563
Paul Duffin80342d72020-06-26 22:08:43 +0100564func (b *bottomUpMutatorContext) ReplaceDependenciesIf(name string, predicate blueprint.ReplaceDependencyPredicate) {
Liz Kammerc13f7852023-05-17 13:01:48 -0400565 if b.baseModuleContext.checkedMissingDeps() {
566 panic("Adding deps not allowed after checking for missing deps")
567 }
Paul Duffin80342d72020-06-26 22:08:43 +0100568 b.bp.ReplaceDependenciesIf(name, predicate)
569}
Colin Crossd5c64312024-12-18 16:04:52 -0800570
571func bpModulesToModules(bpModules []blueprint.Module) []Module {
572 modules := make([]Module, len(bpModules))
573 for i, bpModule := range bpModules {
574 modules[i] = bpModuleToModule(bpModule)
575 }
576 return modules
577}
578
579func bpModuleToModule(bpModule blueprint.Module) Module {
580 if bpModule != nil {
581 return bpModule.(Module)
582 }
583 return nil
584}