Honour #[mutants::skip] on block expressions

[sandersaares]

What

Honor #[mutants::skip] on plain block expressions { ... } inside function bodies.

The visitor already checks #[mutants::skip] at most scopes — fn, impl, trait, mod, file, and several expression kinds (call, method-call, match, struct literal, unary). Block expressions were omitted, so writing #[mutants::skip] { ... } inside a function body silently mutated the contents anyway.

This PR adds a visit_expr_block override that short-circuits when attrs_excluded matches, mirroring the existing per-expression handlers. It works in:

• statement position: #[mutants::skip] { ... }
• expression position: let x = #[mutants::skip] { ... };
• labeled blocks: #[mutants::skip] 'outer: { ... }

…because syn attaches the outer attribute to ExprBlock.attrs in all three forms.

Stable Rust workaround: cfg_attr(any(), mutants::skip)

Stable Rust gates custom proc-macro attributes on expression positions behind the unstable stmt_expr_attributes and proc_macro_hygiene features, so the direct form #[mutants::skip] { ... } only compiles on nightly.

To make the feature actually usable on stable, this PR also extends attr_is_mutants_skip to recognise mutants::skip inside cfg_attr when the cfg predicate is a function-style form (any(...), all(...), not(...)) or a name = "value" form. Previously parse_nested_meta errored out on those, silently dropping the skip directive.

The recommended workaround is:

fn frobnicate(x: i32) -> i32 {
    #[cfg_attr(any(), mutants::skip)]
    {
        x + 1
    }
}

any() is built into rustc and evaluates to false at compile time, so the inner attribute is never expanded — and unlike a made-up cfg name (mutants, never, etc.) it does not trigger the unexpected_cfgs lint. cargo-mutants still sees the inner mutants::skip and applies the suppression.

This caveat applies to the existing expression-level skip attrs too; book/src/attrs.md is updated with a short note and inline example documenting the workaround.

Tests

• Unit tests (src/visit/test/skip_attr_expr_block.rs) covering all four forms (statement-position, expression-position, all-genres-within, labeled) and verifying that nested mutants of every supported genre (binary, unary, match arms, match guards) are suppressed inside an annotated block while sibling code outside it is still mutated.
• cfg_attr predicate tests (src/visit/test/skip_attr_cfg_attr.rs) covering any(), not(all()), and target_os = "linux" predicates inside cfg_attr(...).
• Integration testdata (testdata/skip_attr_block/) exercising the visitor end-to-end with cargo mutants --check. Asserts the expected 22 mutants are produced, all pass cargo check, and the ones inside annotated blocks are suppressed. Uses #[cfg_attr(any(), mutants::skip)] so the tree compiles on stable.

Docs

• book/src/attrs.md: block expressions added to the Scope list; stable-Rust caveat + inline example using cfg_attr(any(), ...).
• NEWS.md: Unreleased entry.

🤖 Generated with the help of GitHub Copilot CLI.

[sandersaares]

Side-finding: the #[cfg_attr(any(), mutants::skip)] form does not actually require even a dev-dependency on the mutants crate because the macro is never invoked at compile time. This might be an interesting opportunity for people who like to keep a low dependency count.