Greatly speed up doctests by compiling compatible doctests in one file

library/std/src/keyword_docs.rs

@@ -236,7 +236,7 @@ mod continue_keyword {}
 /// fundamental compilation unit of Rust code, and can be seen as libraries or projects. More can
 /// be read about crates in the [Reference].
 ///
-/// ```rust ignore
+/// ```rust,ignore (code sample)
 /// extern crate rand;
 /// extern crate my_crate as thing;
 /// extern crate std; // implicitly added to the root of every Rust project

src/doc/rustdoc/src/write-documentation/documentation-tests.md

@@ -376,6 +376,58 @@ that the code sample should be compiled using the respective edition of Rust.
 # fn foo() {}
 ```
 
+Starting the 2024 edition[^edition-note], compatible doctests will be merged as one before being
+run. It means that they will share the process, so any change global/static variables will now
+impact the other doctests.
+
+[^edition-note]: This is based on the edition of the whole crate, not the edition of the individual
+test case that may be specified in its code attribute.
+
+For example, if you have:
+
+```rust
+//! ```
+//! foo::init();
+//! ```
+
+/// ```
+/// foo::init();
+/// ```
+pub fn init() {
+ static mut IS_INIT: bool = false;
+
+ unsafe {
+ assert!(!IS_INIT);
+ IS_INIT = true;
+ }
+}
+```
+
+If you run `rustdoc --test` on this code, it'll panic on the second doctest being
+run because `IS_INIT` value is not `false` anymore.
+
+This is where the `standalone` attribute comes in: it tells `rustdoc` that a doctest
+should not be merged with the others and should be run in its own process. So the
+previous code should use it:
+
+```rust
+//! ```standalone
+//! foo::init();
+//! ```
+
+/// ```standalone
+/// foo::init();
+/// ```
+pub fn init() {
+ static mut IS_INIT: bool = false;
+
+ unsafe {
+ assert!(!IS_INIT);
+ IS_INIT = true;
+ }
+}
+```
+
 ## Syntax reference
 
 The *exact* syntax for code blocks, including the edge cases, can be found

src/doc/unstable-book/src/language-features/link-arg-attribute.md

@@ -8,7 +8,7 @@ The `link_arg_attribute` feature allows passing arguments into the linker
 from inside of the source code. Order is preserved for link attributes as
 they were defined on a single extern block:
 
-```rust,no_run
+```rust,ignore (linking to "c" segfaults)
 #![feature(link_arg_attribute)]
 
 #[link(kind = "link-arg", name = "--start-group")]