Allow filtering of expanded targets according to the available exec configuration (like target_compatible_with but for exec)

[sitaktif]

Description of the feature request:

The target_compatible_with attribute allows skipping targets (and targets that transitively depend on it) when using target pattern expansion (e.g. //...), which is great.

Now, it appears that exec_compatible_with does not work that way: it adds constraints, but still includes the target (and targets that transitively depend on it) during target pattern expansion. In other words, if we don't have any way to satisfy these exec constraints, the build will fail (No matching toolchains) instead of skipping the target.

The suggested feature is to achieve the equivalent of target_compatible_with but for the exec config.

What underlying problem are you trying to solve with this feature?

As a user, I want bazel build //... to be successful both locally on macos and on Linux for my repository, even if that means skipping some targets that I would otherwise not be able to build on a given platform. Note that this is a goal stated in https://bazel.build/community/roadmaps-configurability#goal.

One of the targets in my repository builds a docker image and depends on a binary in a "Linux OS" configuration; unfortunately we do not support cross-compiling this binary from macos to Linux. So I would like this target to be skipped when running it on a Mac.

In summary, I would like to be able to say "when running bazel build //..., don't build this target (nor its dependents) if you can't find executors that satisfy the Linux OS constraint".

(another problem that might be worth solving is the fact that target_compatible_with and exec_compatible_with are not doing equivalent things with target and exec configurations despite having having equivalent option names)

Which operating system are you running Bazel on?

Mac, Linux

What is the output of bazel info release?

release 5.1.1

Have you found anything relevant by searching the web?

Related to #10945 (target_compatible_with implementation).

[katre]

target_compatible_with and exec_compatible_with have similar names but actually do different things, which I agree is unfortunate.

It's a bit tricky to figure out how to change from "no toolchains found" errors to skipping targets, since the skipping logic is at a much earlier and higher level in the code. Also, given that toolchains can be optional, this may not be detected at all.

I'm going to close this for now, but if you have a concrete proposal or further ideas feel free to reply further.

[rosds]

I was also recently surprised with this behavior. In my case, I have a code generator that only runs in x86, but the generated code can be compiled and run in many targets. If I understand correctly, this means that my code generator is exec_compatible_with = [ "@platforms//cpu:x86_64" ]. I would expect that running bazel build //... in a aarch64 host would just skip the generation of the code and also the target that depends on the generated code.

[jesses-canva]

@rosds I think your code generator needs target_compatible_with = ["@platforms//cpu:x86_64"] and depended on via cfg = "exec" (or via tools of a genrule).

exec_compatible_with would be for the platforms where the code generator can be built, not the platforms it can run on.