rustdoc: support #![cfg(feature)] that disables doc tests

[kornelski]

Code in doc comments may require specific Cargo features or platforms, but currently the syntax for disabling doctests is non-obvious, verbose, and by mixing languages and syntaxes, it doesn't play well with Markdown syntax highlighting:

#![cfg_attr(feature = "alloc", doc = " ```")]
#![cfg_attr(not(feature = "alloc"), doc = " ```ignore")]
//! code
//! ```

I suggest supporting #![cfg(…)] inside doctests, injected into the test code in a way that disables a block of code containing the test. Currently #![cfg(feature = …)] doesn't work at all in doctests, because it gets hoisted to be a real crate attribute, and ends up disabling entire the test module.

//! ```rust
//! #![cfg(feature = "alloc")] // proposed syntax
//! code
//! ```

In the implementation I think it would require wrapping "everything_else" code in extra { }, and keeping #![cfg(feature = …)] attrs in the code, instead of extracting them and hoisting them to the top level of the doctest crate.

[Nemo157]

It would be good if however this is handled could retain the ignore marker rather than just executing an empty doctest. Even better would be to show the cfg in the docs if it's disabled so you know what to enable if you want to use code from the example.

Given we have more complex info-strings like custom,{class=language-c} already, maybe this should be an explicit feature:

//! ```rust,{ignore-cfg=not(feature = "alloc")}
//! code
//! ```

(I'm not sure of the exact syntax these braced info-strings target, and there are many possible options for how to structure it within them, this is just the first I thought of).

In the past I've played around with using macros that actually completely remove lines from the docs, rather than just enabling/disabling examples (the whole item needs to be wrapped in a macro invocation to support this syntax):

/// Change the alphabet that will be used for encoding.
///
#[doc_cfg(feature = "alloc")]
/// # Examples
///
/// ```rust
/// let input = [0x60, 0x65, 0xe7, 0x9b, 0xba, 0x2f, 0x78];
/// assert_eq!(
///     "he11owor1d",
///     bs58::encode(input)
///         .with_alphabet(bs58::alphabet::RIPPLE)
///         .into_string());
/// ```
#[/doc_cfg]

[kornelski]

//! ```rust,{ignore-cfg=not(feature = "alloc")}

This seems to me like unnecessarily inventing yet another microsyntax, only to parse the same thing one line earlier. Rustdoc already parses the Rust code and extracts all #![…] from the body of the code, and already moves these attributes to a custom location under Rustdoc's control. It already has all the information to act on the normal cfg in the code, without having to invent a new microsyntax for it. Everything that can be done with {ignore-cfg=not(feature = "alloc")} can also be done with #![cfg(not(feature = "alloc"))].