Auto merge of #151521 - jhpratt:rollup-PFh8sRJ, r=jhpratt

bors · bors · commit 165591238e72 · 2026-01-23T04:07:21.000Z
Rollup of 4 pull requests Successful merges: - #151450 (std: use `clock_nanosleep` for `sleep` where available) - #151494 (std: ensure that the deadline has passed in `sleep_until`) - #151498 (global.rs: improve readability of re-entrance section) - #151504 (Reorganizing tests/ui/issues 11 tests [3/N]) r? @ghost
diff --git a/library/core/src/alloc/global.rs b/library/core/src/alloc/global.rs
@@ -118,12 +118,12 @@ use crate::{cmp, ptr};
 ///
 /// # Re-entrance
 ///
-/// When implementing a global allocator one has to be careful not to create an infinitely recursive
+/// When implementing a global allocator, one has to be careful not to create an infinitely recursive
 /// implementation by accident, as many constructs in the Rust standard library may allocate in
-/// their implementation. For example, on some platforms [`std::sync::Mutex`] may allocate, so using
+/// their implementation. For example, on some platforms, [`std::sync::Mutex`] may allocate, so using
 /// it is highly problematic in a global allocator.
 ///
-/// Generally speaking for this reason one should stick to library features available through
+/// For this reason, one should generally stick to library features available through
 /// [`core`], and avoid using [`std`] in a global allocator. A few features from [`std`] are
 /// guaranteed to not use `#[global_allocator]` to allocate:
 ///
diff --git a/library/std/src/sys/thread/mod.rs b/library/std/src/sys/thread/mod.rs
@@ -139,9 +139,16 @@ cfg_select! {
 pub fn sleep_until(deadline: crate::time::Instant) {
     use crate::time::Instant;
 
-    let now = Instant::now();
-
-    if let Some(delay) = deadline.checked_duration_since(now) {
+    // The clock source used for `sleep` might not be the same used for `Instant`.
+    // Since this function *must not* return before the deadline, we recheck the
+    // time after every call to `sleep`. See #149935 for an example of this
+    // occurring on older Windows systems.
+    while let Some(delay) = deadline.checked_duration_since(Instant::now()) {
+        // Sleep for the estimated time remaining until the deadline.
+        //
+        // If your system has a better way of estimating the delay time or
+        // provides a way to sleep until an absolute time, specialize this
+        // function for your system.
         sleep(delay);
     }
 }
diff --git a/library/std/src/sys/thread/unix.rs b/library/std/src/sys/thread/unix.rs
@@ -528,8 +528,51 @@ pub fn set_name(name: &CStr) {
     debug_assert_eq!(res, libc::OK);
 }
 
-#[cfg(not(any(target_os = "espidf", target_os = "wasi")))]
+#[cfg(not(target_os = "espidf"))]
 pub fn sleep(dur: Duration) {
+    cfg_select! {
+        // Any unix that has clock_nanosleep
+        // If this list changes update the MIRI chock_nanosleep shim
+        any(
+            target_os = "freebsd",
+            target_os = "netbsd",
+            target_os = "linux",
+            target_os = "android",
+            target_os = "solaris",
+            target_os = "illumos",
+            target_os = "dragonfly",
+            target_os = "hurd",
+            target_os = "fuchsia",
+            target_os = "vxworks",
+            target_os = "wasi",
+        ) => {
+            // POSIX specifies that `nanosleep` uses CLOCK_REALTIME, but is not
+            // affected by clock adjustments. The timing of `sleep` however should
+            // be tied to `Instant` where possible. Thus, we use `clock_nanosleep`
+            // with a relative time interval instead, which allows explicitly
+            // specifying the clock.
+            //
+            // In practice, most systems (like e.g. Linux) actually use
+            // CLOCK_MONOTONIC for `nanosleep` anyway, but others like FreeBSD don't
+            // so it's better to be safe.
+            //
+            // wasi-libc prior to WebAssembly/wasi-libc#696 has a broken implementation
+            // of `nanosleep` which used `CLOCK_REALTIME` even though it is unsupported
+            // on WASIp2. Using `clock_nanosleep` directly bypasses the issue.
+            unsafe fn nanosleep(rqtp: *const libc::timespec, rmtp: *mut libc::timespec) -> libc::c_int {
+                unsafe { libc::clock_nanosleep(crate::sys::time::Instant::CLOCK_ID, 0, rqtp, rmtp) }
+            }
+        }
+        _ => {
+            unsafe fn nanosleep(rqtp: *const libc::timespec, rmtp: *mut libc::timespec) -> libc::c_int {
+                let r = unsafe { libc::nanosleep(rqtp, rmtp) };
+                // `clock_nanosleep` returns the error number directly, so mimic
+                // that behaviour to make the shared code below simpler.
+                if r == 0 { 0 } else { sys::io::errno() }
+            }
+        }
+    }
+
     let mut secs = dur.as_secs();
     let mut nsecs = dur.subsec_nanos() as _;
 
@@ -543,8 +586,9 @@ pub fn sleep(dur: Duration) {
             };
             secs -= ts.tv_sec as u64;
             let ts_ptr = &raw mut ts;
-            if libc::nanosleep(ts_ptr, ts_ptr) == -1 {
-                assert_eq!(sys::io::errno(), libc::EINTR);
+            let r = nanosleep(ts_ptr, ts_ptr);
+            if r != 0 {
+                assert_eq!(r, libc::EINTR);
                 secs += ts.tv_sec as u64;
                 nsecs = ts.tv_nsec;
             } else {
@@ -554,13 +598,7 @@ pub fn sleep(dur: Duration) {
     }
 }
 
-#[cfg(any(
-    target_os = "espidf",
-    // wasi-libc prior to WebAssembly/wasi-libc#696 has a broken implementation
-    // of `nanosleep`, used above by most platforms, so use `usleep` until
-    // that fix propagates throughout the ecosystem.
-    target_os = "wasi",
-))]
+#[cfg(target_os = "espidf")]
 pub fn sleep(dur: Duration) {
     // ESP-IDF does not have `nanosleep`, so we use `usleep` instead.
     // As per the documentation of `usleep`, it is expected to support
diff --git a/tests/ui/cfg/struct-field-empty.rs b/tests/ui/cfg/struct-field-empty.rs
@@ -1,3 +1,4 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/16819>
 //@ run-pass
 #![allow(unused_variables)]
 // `#[cfg]` on struct field permits empty unusable struct
diff --git a/tests/ui/expr/if/expr-stack-overflow.rs b/tests/ui/expr/if/expr-stack-overflow.rs
@@ -1,3 +1,4 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/74564>
 //@ build-pass
 // ignore-tidy-filelength
 #![crate_type = "rlib"]
diff --git a/tests/ui/impl-trait/impl-trait-in-generic-param.rs b/tests/ui/impl-trait/impl-trait-in-generic-param.rs
@@ -1,3 +1,5 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/47715>
+
 trait Foo {}
 
 trait Bar<T> {}
diff --git a/tests/ui/impl-trait/impl-trait-in-generic-param.stderr b/tests/ui/impl-trait/impl-trait-in-generic-param.stderr
@@ -1,29 +1,29 @@
 error[E0562]: `impl Trait` is not allowed in generics
-  --> $DIR/issue-47715.rs:9:37
+  --> $DIR/impl-trait-in-generic-param.rs:11:37
    |
 LL | struct Container<T: Iterable<Item = impl Foo>> {
    |                                     ^^^^^^^^
    |
    = note: `impl Trait` is only allowed in arguments and return types of functions and methods
 
 error[E0562]: `impl Trait` is not allowed in generics
-  --> $DIR/issue-47715.rs:14:30
+  --> $DIR/impl-trait-in-generic-param.rs:16:30
    |
 LL | enum Enum<T: Iterable<Item = impl Foo>> {
    |                              ^^^^^^^^
    |
    = note: `impl Trait` is only allowed in arguments and return types of functions and methods
 
 error[E0562]: `impl Trait` is not allowed in generics
-  --> $DIR/issue-47715.rs:19:32
+  --> $DIR/impl-trait-in-generic-param.rs:21:32
    |
 LL | union Union<T: Iterable<Item = impl Foo> + Copy> {
    |                                ^^^^^^^^
    |
    = note: `impl Trait` is only allowed in arguments and return types of functions and methods
 
 error[E0562]: `impl Trait` is not allowed in generics
-  --> $DIR/issue-47715.rs:24:30
+  --> $DIR/impl-trait-in-generic-param.rs:26:30
    |
 LL | type Type<T: Iterable<Item = impl Foo>> = T;
    |                              ^^^^^^^^
diff --git a/tests/ui/issues/auxiliary/issue-11529.rs b/tests/ui/issues/auxiliary/issue-11529.rs
diff --git a/tests/ui/issues/issue-11529.rs b/tests/ui/issues/issue-11529.rs
diff --git a/tests/ui/issues/issue-49934-errors.rs b/tests/ui/issues/issue-49934-errors.rs
diff --git a/tests/ui/issues/issue-49934-errors.stderr b/tests/ui/issues/issue-49934-errors.stderr
diff --git a/tests/ui/lifetimes/auxiliary/lifetime-inference-across-mods.rs b/tests/ui/lifetimes/auxiliary/lifetime-inference-across-mods.rs
@@ -0,0 +1,2 @@
+//! auxiliary crate for <https://github.com/rust-lang/rust/issues/11529>
+pub struct A<'a>(pub &'a isize);
diff --git a/tests/ui/lifetimes/for-loop-region-links.rs b/tests/ui/lifetimes/for-loop-region-links.rs
@@ -1,3 +1,4 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/17068>
 //@ run-pass
 // Test that regionck creates the right region links in the pattern
 // binding of a for loop
diff --git a/tests/ui/lifetimes/lifetime-inference-across-mods.rs b/tests/ui/lifetimes/lifetime-inference-across-mods.rs
@@ -0,0 +1,11 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/11529>
+//@ run-pass
+//@ aux-build:lifetime-inference-across-mods.rs
+
+
+extern crate lifetime_inference_across_mods as a;
+
+fn main() {
+    let one = 1;
+    let _a = a::A(&one);
+}
diff --git a/tests/ui/lifetimes/unit-struct-as-rvalue.rs b/tests/ui/lifetimes/unit-struct-as-rvalue.rs
@@ -1,3 +1,4 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/11681>
 // This tests verifies that unary structs and enum variants
 // are treated as rvalues and their lifetime is not bounded to
 // the static scope.
diff --git a/tests/ui/lifetimes/unit-struct-as-rvalue.stderr b/tests/ui/lifetimes/unit-struct-as-rvalue.stderr
@@ -1,5 +1,5 @@
 error[E0515]: cannot return value referencing temporary value
-  --> $DIR/issue-11681.rs:13:10
+  --> $DIR/unit-struct-as-rvalue.rs:14:10
    |
 LL |   let testValue = &Test;
    |                    ---- temporary value created here
diff --git a/tests/ui/match/match-large-array.rs b/tests/ui/match/match-large-array.rs
@@ -1,3 +1,4 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/17877>
 //@ run-pass
 
 fn main() {
diff --git a/tests/ui/match/match-tuple-slice.rs b/tests/ui/match/match-tuple-slice.rs
@@ -1,3 +1,4 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/16648>
 //@ run-pass
 fn main() {
     let x: (isize, &[isize]) = (2, &[1, 2]);
diff --git a/tests/ui/proc-macro/derive-macro-invalid-placement.rs b/tests/ui/proc-macro/derive-macro-invalid-placement.rs
@@ -1,5 +1,14 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/49934>
+
 #![feature(stmt_expr_attributes)]
 
+fn foo<#[derive(Debug)] T>() { //~ ERROR expected non-macro attribute, found attribute macro
+    match 0 {
+        #[derive(Debug)] //~ ERROR expected non-macro attribute, found attribute macro
+        _ => (),
+    }
+}
+
 fn main() {
     // fold_stmt (Item)
     #[allow(dead_code)]
diff --git a/tests/ui/proc-macro/derive-macro-invalid-placement.stderr b/tests/ui/proc-macro/derive-macro-invalid-placement.stderr
@@ -1,43 +1,55 @@
+error: expected non-macro attribute, found attribute macro `derive`
+  --> $DIR/derive-macro-invalid-placement.rs:5:10
+   |
+LL | fn foo<#[derive(Debug)] T>() {
+   |          ^^^^^^ not a non-macro attribute
+
+error: expected non-macro attribute, found attribute macro `derive`
+  --> $DIR/derive-macro-invalid-placement.rs:7:11
+   |
+LL |         #[derive(Debug)]
+   |           ^^^^^^ not a non-macro attribute
+
 error[E0774]: `derive` may only be applied to `struct`s, `enum`s and `union`s
-  --> $DIR/issue-49934.rs:10:5
+  --> $DIR/derive-macro-invalid-placement.rs:19:5
    |
 LL |     #[derive(Debug)]
    |     ^^^^^^^^^^^^^^^^ not applicable here
 LL |     println!("Hello, world!");
    |     -------------------------- not a `struct`, `enum` or `union`
 
 error[E0774]: `derive` may only be applied to `struct`s, `enum`s and `union`s
-  --> $DIR/issue-49934.rs:14:5
+  --> $DIR/derive-macro-invalid-placement.rs:23:5
    |
 LL |     #[derive(Debug)]
    |     ^^^^^^^^^^^^^^^^ not applicable here
 LL |     "Hello, world!";
    |     ---------------- not a `struct`, `enum` or `union`
 
 error[E0774]: `derive` may only be applied to `struct`s, `enum`s and `union`s
-  --> $DIR/issue-49934.rs:18:5
+  --> $DIR/derive-macro-invalid-placement.rs:27:5
    |
 LL |     #[derive(Debug)]
    |     ^^^^^^^^^^^^^^^^ not applicable here
 LL |     let _ = "Hello, world!";
    |     ------------------------ not a `struct`, `enum` or `union`
 
 error[E0774]: `derive` may only be applied to `struct`s, `enum`s and `union`s
-  --> $DIR/issue-49934.rs:22:13
+  --> $DIR/derive-macro-invalid-placement.rs:31:13
    |
 LL |     let _ = #[derive(Debug)] "Hello, world!";
    |             ^^^^^^^^^^^^^^^^ --------------- not a `struct`, `enum` or `union`
    |             |
    |             not applicable here
 
 error[E0774]: `derive` may only be applied to `struct`s, `enum`s and `union`s
-  --> $DIR/issue-49934.rs:27:9
+  --> $DIR/derive-macro-invalid-placement.rs:36:9
    |
 LL |         #[derive(Debug)]
    |         ^^^^^^^^^^^^^^^^ not applicable here
 LL |         "Hello, world!",
    |         --------------- not a `struct`, `enum` or `union`
 
-error: aborting due to 5 previous errors
+error: aborting due to 7 previous errors
 
 For more information about this error, try `rustc --explain E0774`.
diff --git a/tests/ui/unsized/enum-struct-optimization.rs b/tests/ui/unsized/enum-struct-optimization.rs
@@ -1,3 +1,4 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/18353>
 //@ run-pass
 #![allow(dead_code)]
 // Test that wrapping an unsized struct in an enum which gets optimised does

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+//! regression test for <https://github.com/rust-lang/rust/issues/16819>`
`1`	`2`	`//@ run-pass`
`2`	`3`	`#![allow(unused_variables)]`
`3`	`4`	// `#[cfg]` on struct field permits empty unusable struct
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+//! regression test for <https://github.com/rust-lang/rust/issues/74564>`
`1`	`2`	`//@ build-pass`
`2`	`3`	`// ignore-tidy-filelength`
`3`	`4`	`#![crate_type = "rlib"]`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+//! regression test for <https://github.com/rust-lang/rust/issues/47715>`
	`2`	`+`
`1`	`3`	`trait Foo {}`
`2`	`4`
`3`	`5`	`trait Bar<T> {}`
Original file line number	Diff line number	Diff line change
`@@ -1,29 +1,29 @@`
`1`	`1`	error[E0562]: `impl Trait` is not allowed in generics
`2`		`- --> $DIR/issue-47715.rs:9:37`
	`2`	`+ --> $DIR/impl-trait-in-generic-param.rs:11:37`
`3`	`3`	`\|`
`4`	`4`	`LL \| struct Container<T: Iterable<Item = impl Foo>> {`
`5`	`5`	`\| ^^^^^^^^`
`6`	`6`	`\|`
`7`	`7`	= note: `impl Trait` is only allowed in arguments and return types of functions and methods
`8`	`8`
`9`	`9`	error[E0562]: `impl Trait` is not allowed in generics
`10`		`- --> $DIR/issue-47715.rs:14:30`
	`10`	`+ --> $DIR/impl-trait-in-generic-param.rs:16:30`
`11`	`11`	`\|`
`12`	`12`	`LL \| enum Enum<T: Iterable<Item = impl Foo>> {`
`13`	`13`	`\| ^^^^^^^^`
`14`	`14`	`\|`
`15`	`15`	= note: `impl Trait` is only allowed in arguments and return types of functions and methods
`16`	`16`
`17`	`17`	error[E0562]: `impl Trait` is not allowed in generics
`18`		`- --> $DIR/issue-47715.rs:19:32`
	`18`	`+ --> $DIR/impl-trait-in-generic-param.rs:21:32`
`19`	`19`	`\|`
`20`	`20`	`LL \| union Union<T: Iterable<Item = impl Foo> + Copy> {`
`21`	`21`	`\| ^^^^^^^^`
`22`	`22`	`\|`
`23`	`23`	= note: `impl Trait` is only allowed in arguments and return types of functions and methods
`24`	`24`
`25`	`25`	error[E0562]: `impl Trait` is not allowed in generics
`26`		`- --> $DIR/issue-47715.rs:24:30`
	`26`	`+ --> $DIR/impl-trait-in-generic-param.rs:26:30`
`27`	`27`	`\|`
`28`	`28`	`LL \| type Type<T: Iterable<Item = impl Foo>> = T;`
`29`	`29`	`\| ^^^^^^^^`