Rollup of 16 pull requests

[JonathanBrouwer]

Successful merges:

• std: implement sleep_until for Fuchsia #152617 (std: implement sleep_until for Fuchsia)
• diagnostics: fix let x: vec![] suggestion pointing into stdlib #158934 (diagnostics: fix let x: vec![] suggestion pointing into stdlib)
• bootstrap: Move all non-module items out of the crate root #161277 (bootstrap: Move all non-module items out of the crate root)
• std: don't panic on long-elapsed deadlines for sleep_until #161295 (std: don't panic on long-elapsed deadlines for sleep_until)
• Double-word align _Unwind_Exception #161368 (Double-word align _Unwind_Exception)
• Uplift rustfmt macro formatting fix #161370 (Uplift rustfmt macro formatting fix)
• FlowSensitiveAnalysis cleanups #161378 (FlowSensitiveAnalysis cleanups)
• Offload expose device selection #158032 (Offload expose device selection)
• Add desktop method to CommandExt #158855 (Add desktop method to CommandExt)
• core: Make funnel shifts panic only if overflow checks are enabled #161204 (core: Make funnel shifts panic only if overflow checks are enabled)
• Add regression tests for a few fixed issues with E-needs-test #161329 (Add regression tests for a few fixed issues with E-needs-test)
• Add regression test for nested RPIT not an iterator ICE #161330 (Add regression test for nested RPIT not an iterator ICE)
• Cleanup: Move impl of #[rustc_dump_object_lifetime_defaults] #161351 (Cleanup: Move impl of #[rustc_dump_object_lifetime_defaults])
• Add file path to some archive build errors #161355 (Add file path to some archive build errors)
• Allow running EC2 jobs locally #161373 (Allow running EC2 jobs locally)
• Configure LLM policy URL for triagebot #161393 (Configure LLM policy URL for triagebot)

r? @ghost

Create a similar rollup

[JonathanBrouwer]

@bors r+ p=5

Trying commonly failed jobs
@bors try jobs=dist-various-1,test-various,x86_64-gnu-aux,x86_64-gnu-llvm-21-3,x86_64-msvc-1,aarch64-apple-1,aarch64-apple-2,x86_64-mingw-1,i686-msvc-1,i686-msvc-2

[rust-bors]

📌 Commit 9f8402b has been approved by JonathanBrouwer

It is now in the queue for this repository.

🌲 The tree is currently closed for pull requests below priority 10. This pull request will be tested once the tree is reopened.

Reason for tree closure: Main branch is broken

[rust-log-analyzer]

The job test-various failed! Check out the build log: (web) (plain enhanced) (plain)

Click to see the possible cause of the failure (guessed by this bot)

[RUSTC-TIMING] core test:false 17.842
error[E0308]: mismatched types
    --> library/coretests/tests/num/uint_macros.rs:235:44
     |
   1 | / macro_rules! uint_module {
   2 | |     ($T:ident) => {
   3 | |         use core::num::ParseIntError;
   4 | |         use core::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
...    |
 235 | |             let _ = <$T>::funnel_shl(A, B, A);
     | |                     ----------------       ^ expected `u32`, found `u128`
     | |                     |
     | |                     arguments to this function are incorrect
...    |
 840 | |     };
 841 | | }
     | |_- in this expansion of `uint_module!`
     |
    ::: library/coretests/tests/num/u128.rs:1:1
     |
   1 |   uint_module!(u128);
     |   ------------------ in this macro invocation
     |
note: method defined here
    --> library/core/src/num/uint_macros.rs:567:22
     |
   1 | / macro_rules! uint_impl {
   2 | |     (
   3 | |         Self = $SelfT:ty,
   4 | |         ActualT = $ActualT:ident,
...    |
 567 | |         pub const fn funnel_shl(self, right: Self, n: u32) -> Self {
     | |                      ^^^^^^^^^^
...    |
4410 | | }
     | |_- in this expansion of `uint_impl!`
     |
---
1380 | |     }
     | |_____- in this macro invocation
help: you can convert a `u128` to a `u32` and panic if the converted value doesn't fit
     |
 235 |             let _ = <$T>::funnel_shl(A, B, A.try_into().unwrap());
     |                                             ++++++++++++++++++++

error[E0308]: mismatched types
    --> library/coretests/tests/num/uint_macros.rs:241:44
     |
   1 | / macro_rules! uint_module {
   2 | |     ($T:ident) => {
   3 | |         use core::num::ParseIntError;
   4 | |         use core::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
...    |
 241 | |             let _ = <$T>::funnel_shr(A, B, B);
     | |                     ----------------       ^ expected `u32`, found `u128`
     | |                     |
     | |                     arguments to this function are incorrect
...    |
 840 | |     };
 841 | | }
     | |_- in this expansion of `uint_module!`
     |
    ::: library/coretests/tests/num/u128.rs:1:1
     |
   1 |   uint_module!(u128);
     |   ------------------ in this macro invocation
     |
note: method defined here
    --> library/core/src/num/uint_macros.rs:638:22
     |
   1 | / macro_rules! uint_impl {
   2 | |     (
   3 | |         Self = $SelfT:ty,
   4 | |         ActualT = $ActualT:ident,
...    |
 638 | |         pub const fn funnel_shr(self, right: Self, n: u32) -> Self {
     | |                      ^^^^^^^^^^
...    |
4410 | | }
     | |_- in this expansion of `uint_impl!`
     |
---
1380 | |     }
     | |_____- in this macro invocation
help: you can convert a `u128` to a `u32` and panic if the converted value doesn't fit
     |
 241 |             let _ = <$T>::funnel_shr(A, B, B.try_into().unwrap());
     |                                             ++++++++++++++++++++

error[E0308]: mismatched types
    --> library/coretests/tests/num/uint_macros.rs:235:44
     |
   1 | / macro_rules! uint_module {
   2 | |     ($T:ident) => {
   3 | |         use core::num::ParseIntError;
   4 | |         use core::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
...    |
 235 | |             let _ = <$T>::funnel_shl(A, B, A);
     | |                     ----------------       ^ expected `u32`, found `u16`
     | |                     |
     | |                     arguments to this function are incorrect
...    |
 840 | |     };
 841 | | }
     | |_- in this expansion of `uint_module!`
     |
    ::: library/coretests/tests/num/u16.rs:1:1
     |
   1 |   uint_module!(u16);
     |   ----------------- in this macro invocation
     |
note: method defined here
    --> library/core/src/num/uint_macros.rs:567:22
     |
   1 | / macro_rules! uint_impl {
   2 | |     (
   3 | |         Self = $SelfT:ty,
   4 | |         ActualT = $ActualT:ident,
...    |
 567 | |         pub const fn funnel_shl(self, right: Self, n: u32) -> Self {
     | |                      ^^^^^^^^^^
...    |
4410 | | }
     | |_- in this expansion of `uint_impl!`
     |
---
1258 | |     }
     | |_____- in this macro invocation
help: you can convert a `u16` to a `u32`
     |
 235 |             let _ = <$T>::funnel_shl(A, B, A.into());
     |                                             +++++++

error[E0308]: mismatched types
    --> library/coretests/tests/num/uint_macros.rs:241:44
     |
   1 | / macro_rules! uint_module {
   2 | |     ($T:ident) => {
   3 | |         use core::num::ParseIntError;
   4 | |         use core::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
...    |
 241 | |             let _ = <$T>::funnel_shr(A, B, B);
     | |                     ----------------       ^ expected `u32`, found `u16`
     | |                     |
     | |                     arguments to this function are incorrect
...    |
 840 | |     };
 841 | | }
     | |_- in this expansion of `uint_module!`
     |
    ::: library/coretests/tests/num/u16.rs:1:1
     |
   1 |   uint_module!(u16);
     |   ----------------- in this macro invocation
     |
note: method defined here
    --> library/core/src/num/uint_macros.rs:638:22
     |
   1 | / macro_rules! uint_impl {
   2 | |     (
   3 | |         Self = $SelfT:ty,
   4 | |         ActualT = $ActualT:ident,
...    |
 638 | |         pub const fn funnel_shr(self, right: Self, n: u32) -> Self {
     | |                      ^^^^^^^^^^
...    |
4410 | | }
     | |_- in this expansion of `uint_impl!`
     |
---
1258 | |     }
     | |_____- in this macro invocation
help: you can convert a `u16` to a `u32`
     |
 241 |             let _ = <$T>::funnel_shr(A, B, B.into());
     |                                             +++++++

error[E0308]: mismatched types
    --> library/coretests/tests/num/uint_macros.rs:235:44
     |
   1 | / macro_rules! uint_module {
   2 | |     ($T:ident) => {
   3 | |         use core::num::ParseIntError;
   4 | |         use core::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
...    |
 235 | |             let _ = <$T>::funnel_shl(A, B, A);
     | |                     ----------------       ^ expected `u32`, found `u64`
     | |                     |
     | |                     arguments to this function are incorrect
...    |
 840 | |     };
 841 | | }
     | |_- in this expansion of `uint_module!`
     |
    ::: library/coretests/tests/num/u64.rs:1:1
     |
   1 |   uint_module!(u64);
     |   ----------------- in this macro invocation
     |
note: method defined here
    --> library/core/src/num/uint_macros.rs:567:22
     |
   1 | / macro_rules! uint_impl {
   2 | |     (
   3 | |         Self = $SelfT:ty,
   4 | |         ActualT = $ActualT:ident,
...    |
 567 | |         pub const fn funnel_shl(self, right: Self, n: u32) -> Self {
     | |                      ^^^^^^^^^^
...    |
4410 | | }
     | |_- in this expansion of `uint_impl!`
     |
---
1346 | |     }
     | |_____- in this macro invocation
help: you can convert a `u64` to a `u32` and panic if the converted value doesn't fit
     |
 235 |             let _ = <$T>::funnel_shl(A, B, A.try_into().unwrap());
     |                                             ++++++++++++++++++++

error[E0308]: mismatched types
    --> library/coretests/tests/num/uint_macros.rs:241:44
     |
   1 | / macro_rules! uint_module {
   2 | |     ($T:ident) => {
   3 | |         use core::num::ParseIntError;
   4 | |         use core::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
...    |
 241 | |             let _ = <$T>::funnel_shr(A, B, B);
     | |                     ----------------       ^ expected `u32`, found `u64`
     | |                     |
     | |                     arguments to this function are incorrect
...    |
 840 | |     };
 841 | | }
     | |_- in this expansion of `uint_module!`
     |
    ::: library/coretests/tests/num/u64.rs:1:1
     |
   1 |   uint_module!(u64);
     |   ----------------- in this macro invocation
     |
note: method defined here
    --> library/core/src/num/uint_macros.rs:638:22
     |
   1 | / macro_rules! uint_impl {
   2 | |     (
   3 | |         Self = $SelfT:ty,
   4 | |         ActualT = $ActualT:ident,
...    |
 638 | |         pub const fn funnel_shr(self, right: Self, n: u32) -> Self {
     | |                      ^^^^^^^^^^
...    |
4410 | | }
     | |_- in this expansion of `uint_impl!`
     |
---
1346 | |     }
     | |_____- in this macro invocation
help: you can convert a `u64` to a `u32` and panic if the converted value doesn't fit
     |
 241 |             let _ = <$T>::funnel_shr(A, B, B.try_into().unwrap());
     |                                             ++++++++++++++++++++

error[E0308]: mismatched types
    --> library/coretests/tests/num/uint_macros.rs:235:44
     |
   1 | / macro_rules! uint_module {
   2 | |     ($T:ident) => {
   3 | |         use core::num::ParseIntError;
   4 | |         use core::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
...    |
 235 | |             let _ = <$T>::funnel_shl(A, B, A);
     | |                     ----------------       ^ expected `u32`, found `u8`
     | |                     |
     | |                     arguments to this function are incorrect
...    |
 840 | |     };
 841 | | }
     | |_- in this expansion of `uint_module!`
     |
    ::: library/coretests/tests/num/u8.rs:1:1
     |
   1 |   uint_module!(u8);
     |   ---------------- in this macro invocation
     |
note: method defined here
    --> library/core/src/num/uint_macros.rs:567:22
     |
   1 | / macro_rules! uint_impl {
   2 | |     (
   3 | |         Self = $SelfT:ty,
   4 | |         ActualT = $ActualT:ident,
...    |
 567 | |         pub const fn funnel_shl(self, right: Self, n: u32) -> Self {
     | |                      ^^^^^^^^^^
...    |
4410 | | }
     | |_- in this expansion of `uint_impl!`
     |
---
 610 | |     }
     | |_____- in this macro invocation
help: you can convert a `u8` to a `u32`
     |
 235 |             let _ = <$T>::funnel_shl(A, B, A.into());
     |                                             +++++++

error[E0308]: mismatched types
    --> library/coretests/tests/num/uint_macros.rs:241:44
     |
   1 | / macro_rules! uint_module {
   2 | |     ($T:ident) => {
   3 | |         use core::num::ParseIntError;
   4 | |         use core::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
...    |
 241 | |             let _ = <$T>::funnel_shr(A, B, B);
     | |                     ----------------       ^ expected `u32`, found `u8`
     | |                     |
     | |                     arguments to this function are incorrect
...    |
 840 | |     };
 841 | | }
     | |_- in this expansion of `uint_module!`
     |
    ::: library/coretests/tests/num/u8.rs:1:1
     |
   1 |   uint_module!(u8);
     |   ---------------- in this macro invocation
     |
note: method defined here
    --> library/core/src/num/uint_macros.rs:638:22
     |
   1 | / macro_rules! uint_impl {
   2 | |     (
   3 | |         Self = $SelfT:ty,
   4 | |         ActualT = $ActualT:ident,
...    |
 638 | |         pub const fn funnel_shr(self, right: Self, n: u32) -> Self {
     | |                      ^^^^^^^^^^
...    |
4410 | | }
     | |_- in this expansion of `uint_impl!`
     |
---
 610 | |     }
     | |_____- in this macro invocation
help: you can convert a `u8` to a `u32`
     |
 241 |             let _ = <$T>::funnel_shr(A, B, B.into());
     |                                             +++++++

For more information about this error, try `rustc --explain E0308`.
[RUSTC-TIMING] coretests test:true 41.157
error: could not compile `coretests` (test "coretests") due to 8 previous errors

[rust-bors]

PR #161204, which is a member of this rollup, was unapproved.

This rollup was thus unapproved.

[rust-bors]

💔 Test for 7fa0181 failed: CI. Failed job:

• try - test-various (web logs, enhanced plaintext logs)