Hm, it's not exactly the same, since when combines constraints, while default_args overrides.

What's expected here:

with default_args(type="build"), default_args(type=("link", "run")):
    depends_on("x")

is that equivalent to

depends_on("x", type=("build", "link", "run"))

or

depends_on("x", type=("link", "run"))

@tgamblin when deals with a single specific argument, that is known to be a spec literal:

1. It combines constraints using Spec.constrain
2. It can be nested (though we don't recommend that in general), and
3. The when= argument can be in the directive too.

This:

with when("+foo"):
    with when("+bar"):
        depends_on("xxx", when="+baz")

is equivalent to:

depends_on("xxx", when="+foo+bar+baz")

Ok, I agree with @alalazo and that's a great reason why when should have its own directive.

Are there any other default args worth having special semantics for? I can't think of any off the top of my head that I'd justify implementing semantics other than override for.

but RE: @haampie, this is awful:

with default_args(type="build"), default_args(type=("link", "run")):
    depends_on("x")

I think most people would expect that to be equivalent to depends_on("x", type=("build", "link", "run")) as written, but then you should just write that. Sigh. I guess we could try to catch that in audit or review.

I could see you wanting an override if the second context manager were in the middle of some statements like:

with default_args(when="@2.0:", type="build"):
    depends_on("x")
    with default_args(type=("link", "run")):
        depends_on("y")
        depends_on("z")

but I think we should just encourage people not to do this. I worry about people composing with when() and with default_args() as it's going to be surprising if they use the latter for when. e.g. what should these do and what do they do right now?

with default_args(when="@2.0:", type="build"):
    depends_on("x")
    with when("@3.0:"):
        depends_on("y")
        depends_on("z")

or:

with default_args(when="@2.0:", type="build"):
    depends_on("x")
    with when("@3.0:"):
        depends_on("y")
        depends_on("z")

Should this be disallowed? I kind of think we should just raise and recommend using with when if you try to stick when in default_args.

Finally, I think regardless of what we settle on, the semantics need to be documented with a note saying how they're different from with when.

Are there any other default args worth having special semantics for?

Would love to be able to use with type(...) but I imagine that's not desirable for the same reasons that with args(...) isn't 😆

@tgamblin should be good to go? For documentation see https://spack--39964.org.readthedocs.build/en/39964/packaging_guide.html#common-default-arguments

And this one too @tgamblin :D