Bazel -- get arguments to another target macro - bazel

Question

I have two macros/targets: component and bundle (which packages several components). I would like to extend the bundle macro to accept a list of bundles in addition to a list of components and package all of the components directly-included or included in one of its included bundles.
For example, if I have the following BUILD file:
component(name = 'a')
component(name = 'b')
component(name = 'c')
component(name = 'd')
bundle(name = 'x', components = ['a'])
bundle(name = 'y', components = ['b', 'c'], bundles = ['x'])
bundle(name = 'z', components = ['d'], bundles = ['y'])
Bundle z should include components a, b, c, and d
The .bzl file right now is like this:
def component(name):
# implementation (it uses other args but they aren't relevant)
def bundle(name, components = []):
# complex logic on components
What I want is:
def bundle(name, components = [], bundles = []):
for bundle in bundles:
for component in TODO_get_components_in_bundle(bundle):
if component not in components:
components.append(component)
# complex logic on components
How can I implement TODO_get_components_in_bundle or achieve the same effect?

Answer 1

You cannot do that with a macro (alone):
A macro is a function called from the BUILD file that can instantiate rules. Macros don’t give additional power, they are just used for encapsulation and code reuse. By the end of the loading phase, macros don’t exist anymore, and Bazel sees only the set of rules they created.
In other words you'll need (custom) rule(s) that you can pass the inputs to and work with as you'll need to establish their relations during analysis phase and for execution phase. That is something macros cannot help with.
I've put this example together, providing necessary load is in place, it works with the BUILD file you've used in the question (these rules are written to that interface):
ComponentInfo = provider(fields = ["files", "name"])
BundleInfo = provider(fields = ["files", "name", "components"])
def _component_impl(ctx):
ctx.actions.write(
output = ctx.outputs.out,
content = "NAME: {}\n".format(ctx.attr.name),
)
return ComponentInfo(
files = depset([ctx.outputs.out]),
name = ctx.attr.name,
)
component = rule(
implementation = _component_impl,
outputs = {"out": "%{name}.txt"},
)
def _bundle_impl(ctx):
deps = depset(
[c[ComponentInfo] for c in ctx.attr.components] +
[c for b in ctx.attr.bundles for c in b[BundleInfo].components.to_list()],
)
content = "NAME: {}\n".format(ctx.attr.name)
for comp in deps.to_list():
content += "CONTAINS: {}\n".format(comp.name)
ctx.actions.write(
output = ctx.outputs.out,
content = content,
)
return BundleInfo(
files = depset([ctx.outputs.out]),
name = ctx.attr.name,
components = deps,
)
bundle = rule(
implementation = _bundle_impl,
attrs = {
"components": attr.label_list(),
"bundles": attr.label_list(),
},
outputs = {"out": "%{name}.txt"},
)
It doesn't do anything useful. It just creates a text file with component name for all component targets the same for bundle targets in which case it also lists all components bundled.
I've used custom providers to pass information such as component info around (assuming it's important) without having to resort to some magic divining it from file generated or label name.