Auto merge of #161338 - jhpratt:rollup-gDOZoei, r=jhpratt

Rollup of 18 pull requests

Successful merges:

 - rust-lang/rust#154210 (fix: fix the capture behavior of `if let` in closures)
 - rust-lang/rust#156176 (Initial implementation of `FnPtr` trait)
 - rust-lang/rust#160767 (Unify E0117 foreign-trait label for ADT/primitive types with existing Slice/Array/Tuple handling)
 - rust-lang/rust#161297 (std: use UNIX's `Instant` and `SystemTime` on Hermit)
 - rust-lang/rust#160489 (Adding diagnostic item markers for multiple fs functions and structs)
 - rust-lang/rust#160643 (Require windowed (and exception) for Xtensa ABI)
 - rust-lang/rust#161088 (suppress projection errors already covered by a trait error)
 - rust-lang/rust#161114 (Remove fields from TypeKind: Struct, Enum, Union and Tuple)
 - rust-lang/rust#161115 (Assorted allocator nitpicks)
 - rust-lang/rust#161220 (bootstrap: Allow `./x fix --allow-dirty`)
 - rust-lang/rust#161296 (Enable overflow checks in `rustc_thread_pool`)
 - rust-lang/rust#161298 (remove rustc_error_messages dependency)
 - rust-lang/rust#161304 (Rename test so it matches the issue)
 - rust-lang/rust#161309 (`allow(non_camel_case_types)` in `minicore.rs`)
 - rust-lang/rust#161315 (Relax codgen test variable regex)
 - rust-lang/rust#161318 (Doc: clarify how `Read::bytes` handling Interrupted errors)
 - rust-lang/rust#161321 (Update books)
 - rust-lang/rust#161335 ([compiletest] Use the correct rustc lib directory for query_rustc_output)

Author: bors

tests/fail/match/closures/if-let-deref-in-pattern.rs

@@ -0,0 +1,25 @@
+// This test serves to document the change in semantics introduced by
+// rust-lang/rust#138961, extended to `if let` closure captures.
+//
+// A corollary of partial-pattern.rs: while the tuple access testcase makes
+// it clear why these semantics are useful, it is actually the dereference
+// being performed by the pattern that matters.
+//
+// Before rust-lang/rust#154210, `if let` in closures captured all of `x`, so
+// this test did not fail because the closure is never called.
+//@normalize-stderr-test: "constructing invalid value of type [^:]+:" -> "constructing invalid value:"
+
+#![allow(irrefutable_let_patterns)]
+
+fn main() {
+    // the inner reference is dangling
+    let x: &&u32 = unsafe {
+        let x: u32 = 42;
+        &&*&raw const x
+    };
+
+    //~v ERROR: encountered a dangling reference
+    let _ = || {
+        if let &&_y = x {}
+    };
+}

tests/fail/match/closures/if-let-deref-in-pattern.stderr

@@ -0,0 +1,16 @@
+error: Undefined Behavior: constructing invalid value: encountered a dangling reference (use-after-free)
+  --> tests/fail/match/closures/if-let-deref-in-pattern.rs:LL:CC
+   |
+LL |       let _ = || {
+   |  _____________^
+LL | |         if let &&_y = x {}
+LL | |     };
+   | |_____^ Undefined Behavior occurred here
+   |
+   = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
+   = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+

tests/fail/match/closures/if-let-partial-pattern.rs

@@ -0,0 +1,33 @@
+// This test serves to document the change in semantics introduced by
+// rust-lang/rust#138961, extended to `if let` closure captures.
+//
+// Previously, the closure would capture the entirety of x, and access *(*x).0
+// when called. Now, the closure only captures *(*x).0, which means that
+// a &*(*x).0 reborrow happens when the closure is constructed.
+//
+// Hence, if one of the references is dangling, this constitutes newly introduced UB
+// in the case where the closure doesn't get called. This isn't a big deal,
+// because while opsem only now considers this to be UB, the unsafe code
+// guidelines have long recommended against any handling of dangling references.
+//
+// Before rust-lang/rust#154210, `if let` in closures captured all of `x`, so
+// this test did not fail because the closure is never called.
+//@normalize-stderr-test: "constructing invalid value of type [^:]+:" -> "constructing invalid value:"
+
+#![allow(irrefutable_let_patterns)]
+
+fn main() {
+    // the inner references are dangling
+    let x: &(&u32, &u32) = unsafe {
+        let a = 21;
+        let b = 37;
+        let ra = &*&raw const a;
+        let rb = &*&raw const b;
+        &(ra, rb)
+    };
+
+    //~v ERROR: encountered a dangling reference
+    let _ = || {
+        if let &(&_y, _) = x {}
+    };
+}

tests/fail/match/closures/if-let-partial-pattern.stderr

@@ -0,0 +1,16 @@
+error: Undefined Behavior: constructing invalid value: encountered a dangling reference (use-after-free)
+  --> tests/fail/match/closures/if-let-partial-pattern.rs:LL:CC
+   |
+LL |       let _ = || {
+   |  _____________^
+LL | |         if let &(&_y, _) = x {}
+LL | |     };
+   | |_____^ Undefined Behavior occurred here
+   |
+   = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
+   = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+