Auto merge of rust-lang#40206 - GuillaumeGomez:rollup, r=GuillaumeGomez

Rollup of 9 pull requests

- Successful merges: rust-lang#40081, rust-lang#40144, rust-lang#40168, rust-lang#40169, rust-lang#40170, rust-lang#40173, rust-lang#40175, rust-lang#40191, rust-lang#40194
- Failed merges:

src/doc/book/src/const-and-static.md

@@ -32,7 +32,7 @@ static N: i32 = 5;
 Unlike [`let`][let] bindings, you must annotate the type of a `static`.
 
 Statics live for the entire lifetime of a program, and therefore any
-reference stored in a constant has a [`'static` lifetime][lifetimes]:
+reference stored in a static has a [`'static` lifetime][lifetimes]:
 
 ```rust
 static NAME: &'static str = "Steve";

src/doc/book/src/guessing-game.md

@@ -255,7 +255,7 @@ and other whitespace. This helps you split up long lines. We _could_ have
 done:
 
 ```rust,ignore
-    io::stdin().read_line(&mut guess).expect("failed to read line");
+    io::stdin().read_line(&mut guess).expect("Failed to read line");
 ```
 
 But that gets hard to read. So we’ve split it up, two lines for two method
@@ -473,7 +473,7 @@ fn main() {
     let mut guess = String::new();
 
     io::stdin().read_line(&mut guess)
-        .expect("failed to read line");
+        .expect("Failed to read line");
 
     println!("You guessed: {}", guess);
 }
@@ -563,7 +563,7 @@ fn main() {
     let mut guess = String::new();
 
     io::stdin().read_line(&mut guess)
-        .expect("failed to read line");
+        .expect("Failed to read line");
 
     println!("You guessed: {}", guess);
 
@@ -678,7 +678,7 @@ fn main() {
     let mut guess = String::new();
 
     io::stdin().read_line(&mut guess)
-        .expect("failed to read line");
+        .expect("Failed to read line");
 
     let guess: u32 = guess.trim().parse()
         .expect("Please type a number!");
@@ -780,7 +780,7 @@ fn main() {
         let mut guess = String::new();
 
         io::stdin().read_line(&mut guess)
-            .expect("failed to read line");
+            .expect("Failed to read line");
 
         let guess: u32 = guess.trim().parse()
             .expect("Please type a number!");
@@ -847,7 +847,7 @@ fn main() {
         let mut guess = String::new();
 
         io::stdin().read_line(&mut guess)
-            .expect("failed to read line");
+            .expect("Failed to read line");
 
         let guess: u32 = guess.trim().parse()
             .expect("Please type a number!");
@@ -892,7 +892,7 @@ fn main() {
         let mut guess = String::new();
 
         io::stdin().read_line(&mut guess)
-            .expect("failed to read line");
+            .expect("Failed to read line");
 
         let guess: u32 = match guess.trim().parse() {
             Ok(num) => num,
@@ -981,7 +981,7 @@ fn main() {
         let mut guess = String::new();
 
         io::stdin().read_line(&mut guess)
-            .expect("failed to read line");
+            .expect("Failed to read line");
 
         let guess: u32 = match guess.trim().parse() {
             Ok(num) => num,

src/doc/book/src/if-let.md

@@ -1,6 +1,6 @@
 # if let
 
-`if let` permits [patterns][pattern] matching within the condition of an [if][if] statement.
+`if let` permits [patterns][patterns] matching within the condition of an [if][if] statement.
 This allows us to reduce the overhead of certain kinds of [pattern][patterns] matches
 and express them in a more convenient way.  
 

src/doc/book/src/strings.md

@@ -145,7 +145,7 @@ This emphasizes that we have to walk from the beginning of the list of `chars`.
 
 ## Slicing
 
-You can get a slice of a string with slicing syntax:
+You can get a slice of a string with the slicing syntax:
 
 ```rust
 let dog = "hachiko";

src/doc/book/src/structs.md

@@ -255,13 +255,14 @@ rather than positions.
 
 You can define a `struct` with no members at all:
 
-```rust
+```rust,compile_fail,E0423
 struct Electron {} // Use empty braces...
 struct Proton;     // ...or just a semicolon.
 
-// Whether you declared the struct with braces or not, do the same when creating one.
+// Use the same notation when creating an instance.
 let x = Electron {};
 let y = Proton;
+let z = Electron; // Error
 ```
 
 Such a `struct` is called ‘unit-like’ because it resembles the empty

src/doc/unstable-book/src/SUMMARY.md

@@ -5,6 +5,7 @@
 - [abi_sysv64](abi-sysv64.md)
 - [abi_unadjusted](abi-unadjusted.md)
 - [abi_vectorcall](abi-vectorcall.md)
+- [abi_x86_interrupt](abi-x86-interrupt.md)
 - [advanced_slice_patterns](advanced-slice-patterns.md)
 - [alloc_jemalloc](alloc-jemalloc.md)
 - [alloc_system](alloc-system.md)

src/doc/unstable-book/src/abi-x86-interrupt.md

@@ -0,0 +1,7 @@
+# `abi_x86_interrupt`
+
+The tracking issue for this feature is: [#40180]
+
+[#40180]: https://github.com/rust-lang/rust/issues/40180
+
+------------------------

src/libstd/sys_common/poison.rs

@@ -60,10 +60,13 @@ pub struct Guard {
 
 /// A type of error which can be returned whenever a lock is acquired.
 ///
-/// Both Mutexes and RwLocks are poisoned whenever a thread fails while the lock
+/// Both [`Mutex`]es and [`RwLock`]s are poisoned whenever a thread fails while the lock
 /// is held. The precise semantics for when a lock is poisoned is documented on
 /// each lock, but once a lock is poisoned then all future acquisitions will
 /// return this error.
+///
+/// [`Mutex`]: ../../std/sync/struct.Mutex.html
+/// [`RwLock`]: ../../std/sync/struct.RwLock.html
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct PoisonError<T> {
     guard: T,
@@ -85,19 +88,26 @@ pub enum TryLockError<T> {
 
 /// A type alias for the result of a lock method which can be poisoned.
 ///
-/// The `Ok` variant of this result indicates that the primitive was not
-/// poisoned, and the `Guard` is contained within. The `Err` variant indicates
-/// that the primitive was poisoned. Note that the `Err` variant *also* carries
-/// the associated guard, and it can be acquired through the `into_inner`
+/// The [`Ok`] variant of this result indicates that the primitive was not
+/// poisoned, and the `Guard` is contained within. The [`Err`] variant indicates
+/// that the primitive was poisoned. Note that the [`Err`] variant *also* carries
+/// the associated guard, and it can be acquired through the [`into_inner`]
 /// method.
+///
+/// [`Ok`]: ../../std/result/enum.Result.html#variant.Ok
+/// [`Err`]: ../../std/result/enum.Result.html#variant.Err
+/// [`into_inner`]: ../../std/sync/struct.Mutex.html#method.into_inner
 #[stable(feature = "rust1", since = "1.0.0")]
 pub type LockResult<Guard> = Result<Guard, PoisonError<Guard>>;
 
 /// A type alias for the result of a nonblocking locking method.
 ///
-/// For more information, see `LockResult`. A `TryLockResult` doesn't
-/// necessarily hold the associated guard in the `Err` type as the lock may not
+/// For more information, see [`LockResult`]. A `TryLockResult` doesn't
+/// necessarily hold the associated guard in the [`Err`] type as the lock may not
 /// have been acquired for other reasons.
+///
+/// [`LockResult`]: ../../std/sync/type.LockResult.html
+/// [`Err`]: ../../std/result/enum.Result.html#variant.Err
 #[stable(feature = "rust1", since = "1.0.0")]
 pub type TryLockResult<Guard> = Result<Guard, TryLockError<Guard>>;
 
@@ -124,6 +134,11 @@ impl<T> Error for PoisonError<T> {
 
 impl<T> PoisonError<T> {
     /// Creates a `PoisonError`.
+    ///
+    /// This is generally created by methods like [`Mutex::lock`] or [`RwLock::read`].
+    ///
+    /// [`Mutex::lock`]: ../../std/sync/struct.Mutex.html#method.lock
+    /// [`RwLock::read`]: ../../std/sync/struct.RwLock.html#method.read
     #[stable(feature = "sync_poison", since = "1.2.0")]
     pub fn new(guard: T) -> PoisonError<T> {
         PoisonError { guard: guard }

src/test/compile-fail/feature-gate-abi.rs

@@ -11,13 +11,15 @@
 // gate-test-intrinsics
 // gate-test-platform_intrinsics
 // gate-test-abi_vectorcall
+// gate-test-abi_ptx
 
 // Functions
 extern "rust-intrinsic" fn f1() {} //~ ERROR intrinsics are subject to change
 extern "platform-intrinsic" fn f2() {} //~ ERROR platform intrinsics are experimental
 extern "vectorcall" fn f3() {} //~ ERROR vectorcall is experimental and subject to change
 extern "rust-call" fn f4() {} //~ ERROR rust-call ABI is subject to change
 extern "msp430-interrupt" fn f5() {} //~ ERROR msp430-interrupt ABI is experimental
+extern "ptx-kernel" fn f6() {} //~ ERROR PTX ABIs are experimental and subject to change
 
 // Methods in trait definition
 trait Tr {
@@ -26,12 +28,14 @@ trait Tr {
     extern "vectorcall" fn m3(); //~ ERROR vectorcall is experimental and subject to change
     extern "rust-call" fn m4(); //~ ERROR rust-call ABI is subject to change
     extern "msp430-interrupt" fn m5(); //~ ERROR msp430-interrupt ABI is experimental
+    extern "ptx-kernel" fn m6(); //~ ERROR PTX ABIs are experimental and subject to change
 
     extern "rust-intrinsic" fn dm1() {} //~ ERROR intrinsics are subject to change
     extern "platform-intrinsic" fn dm2() {} //~ ERROR platform intrinsics are experimental
     extern "vectorcall" fn dm3() {} //~ ERROR vectorcall is experimental and subject to change
     extern "rust-call" fn dm4() {} //~ ERROR rust-call ABI is subject to change
     extern "msp430-interrupt" fn dm5() {} //~ ERROR msp430-interrupt ABI is experimental
+    extern "ptx-kernel" fn dm6() {} //~ ERROR PTX ABIs are experimental and subject to change
 }
 
 struct S;
@@ -43,6 +47,7 @@ impl Tr for S {
     extern "vectorcall" fn m3() {} //~ ERROR vectorcall is experimental and subject to change
     extern "rust-call" fn m4() {} //~ ERROR rust-call ABI is subject to change
     extern "msp430-interrupt" fn m5() {} //~ ERROR msp430-interrupt ABI is experimental
+    extern "ptx-kernel" fn m6() {} //~ ERROR PTX ABIs are experimental and subject to change
 }
 
 // Methods in inherent impl
@@ -52,6 +57,7 @@ impl S {
     extern "vectorcall" fn im3() {} //~ ERROR vectorcall is experimental and subject to change
     extern "rust-call" fn im4() {} //~ ERROR rust-call ABI is subject to change
     extern "msp430-interrupt" fn im5() {} //~ ERROR msp430-interrupt ABI is experimental
+    extern "ptx-kernel" fn im6() {} //~ ERROR PTX ABIs are experimental and subject to change
 }
 
 // Function pointer types
@@ -60,12 +66,14 @@ type A2 = extern "platform-intrinsic" fn(); //~ ERROR platform intrinsics are ex
 type A3 = extern "vectorcall" fn(); //~ ERROR vectorcall is experimental and subject to change
 type A4 = extern "rust-call" fn(); //~ ERROR rust-call ABI is subject to change
 type A5 = extern "msp430-interrupt" fn(); //~ ERROR msp430-interrupt ABI is experimental
+type A6 = extern "ptx-kernel" fn (); //~ ERROR PTX ABIs are experimental and subject to change
 
 // Foreign modules
 extern "rust-intrinsic" {} //~ ERROR intrinsics are subject to change
 extern "platform-intrinsic" {} //~ ERROR platform intrinsics are experimental
 extern "vectorcall" {} //~ ERROR vectorcall is experimental and subject to change
 extern "rust-call" {} //~ ERROR rust-call ABI is subject to change
 extern "msp430-interrupt" {} //~ ERROR msp430-interrupt ABI is experimental
+extern "ptx-kernel" {} //~ ERROR PTX ABIs are experimental and subject to change
 
 fn main() {}

src/test/run-make/issue-24445/Makefile

@@ -3,9 +3,9 @@
 ifeq ($(UNAME),Linux)
 all:
 	$(RUSTC) foo.rs
-	$(CC) foo.c -lfoo -L $(TMPDIR) -Wl,--gc-sections -lpthread -o $(TMPDIR)/foo
+	$(CC) foo.c -lfoo -L $(TMPDIR) -Wl,--gc-sections -lpthread -ldl -o $(TMPDIR)/foo
 	$(call RUN,foo)
-	$(CC) foo.c -lfoo -L $(TMPDIR) -Wl,--gc-sections -lpthread -pie -fPIC -o $(TMPDIR)/foo
+	$(CC) foo.c -lfoo -L $(TMPDIR) -Wl,--gc-sections -lpthread -ldl -pie -fPIC -o $(TMPDIR)/foo
 	$(call RUN,foo)
 else
 all:

src/tools/tidy/src/features.rs

@@ -167,7 +167,7 @@ pub fn check(path: &Path, bad: &mut bool) {
 
     // FIXME get this whitelist empty.
     let whitelist = vec![
-        "abi_ptx", "simd",
+        "simd",
         "stmt_expr_attributes",
         "cfg_target_thread_local", "unwind_attributes",
     ];