Rollup of 6 pull requests

[matthiaskrgr]

Successful merges:

• std: clarify OpenOptions error for create without write access #144964 (std: clarify OpenOptions error for create without write access)
• std: use a TAIT to define SplitPaths on UNIX #145242 (std: use a TAIT to define SplitPaths on UNIX)
• Stabilize strict_provenance_atomic_ptr feature #145467 (Stabilize strict_provenance_atomic_ptr feature)
• AutoDeref::final_ty is already resolved #145990 (AutoDeref::final_ty is already resolved)
• std: haiku: fix B_FIND_PATH_IMAGE_PATH #145991 (std: haiku: fix B_FIND_PATH_IMAGE_PATH)
• Improve librustdoc error when a file creation/modification failed #146000 (Improve librustdoc error when a file creation/modification failed)

r? @ghost
@rustbot modify labels: rollup

Create a similar rollup

[matthiaskrgr]

@bors r+ rollup=never p=5

[bors]

📌 Commit 2f674fd has been approved by matthiaskrgr

It is now in the queue for this repository.

[bors]

⌛ Testing commit 2f674fd with merge a268e92...

[rust-log-analyzer]

The job aarch64-msvc-1 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] error test:true 2.029
error[E0308]: mismatched types
    --> library\std\src\fs\tests.rs:1291:60
     |
  53 |                 assert!(err.raw_os_error() == Some($s), "`{}` did not have a code of `{}`", err, $s)
     |                                               ---- arguments to this enum variant are incorrect
...
1291 |     error!(c(&r).create_new(true).open(&tmpdir.join("b")), invalid_options);
     |                                                            ^^^^^^^^^^^^^^^ expected `i32`, found `&str`
     |
help: the type constructed contains `&str` due to the type of the argument passed
    --> library\std\src\fs\tests.rs:53:47
     |
  48 | / macro_rules! error {
  49 | |     ($e:expr, $s:expr) => {
  50 | |         match $e {
  51 | |             Ok(_) => panic!("Unexpected success. Should've been: {:?}", $s),
  52 | |             Err(ref err) => {
  53 | |                 assert!(err.raw_os_error() == Some($s), "`{}` did not have a code of `{}`", err, $s)
     | |                                               ^^^^^^^^
...    |
  56 | |     };
  57 | | }
     | |_- in this expansion of `error!`
...
1291 |       error!(c(&r).create_new(true).open(&tmpdir.join("b")), invalid_options);
     |       -----------------------------------------------------------------------
     |       |                                                      |
     |       |                                                      this argument influences the type of `Some`
     |       in this macro invocation
note: tuple variant defined here
---

error[E0308]: mismatched types
    --> library\std\src\fs\tests.rs:1292:71
     |
  53 |                 assert!(err.raw_os_error() == Some($s), "`{}` did not have a code of `{}`", err, $s)
     |                                               ---- arguments to this enum variant are incorrect
...
1292 |     error!(c(&r).create(true).truncate(true).open(&tmpdir.join("b")), invalid_options);
     |                                                                       ^^^^^^^^^^^^^^^ expected `i32`, found `&str`
     |
help: the type constructed contains `&str` due to the type of the argument passed
    --> library\std\src\fs\tests.rs:53:47
     |
  48 | / macro_rules! error {
  49 | |     ($e:expr, $s:expr) => {
  50 | |         match $e {
  51 | |             Ok(_) => panic!("Unexpected success. Should've been: {:?}", $s),
  52 | |             Err(ref err) => {
  53 | |                 assert!(err.raw_os_error() == Some($s), "`{}` did not have a code of `{}`", err, $s)
     | |                                               ^^^^^^^^
...    |
  56 | |     };
  57 | | }
     | |_- in this expansion of `error!`
...
1292 |       error!(c(&r).create(true).truncate(true).open(&tmpdir.join("b")), invalid_options);
     |       ----------------------------------------------------------------------------------
     |       |                                                                 |
     |       |                                                                 this argument influences the type of `Some`
     |       in this macro invocation
note: tuple variant defined here
---

error[E0308]: mismatched types
    --> library\std\src\fs\tests.rs:1293:58
     |
  53 |                 assert!(err.raw_os_error() == Some($s), "`{}` did not have a code of `{}`", err, $s)
     |                                               ---- arguments to this enum variant are incorrect
...
1293 |     error!(c(&r).truncate(true).open(&tmpdir.join("b")), invalid_options);
     |                                                          ^^^^^^^^^^^^^^^ expected `i32`, found `&str`
     |
help: the type constructed contains `&str` due to the type of the argument passed
    --> library\std\src\fs\tests.rs:53:47
     |
  48 | / macro_rules! error {
  49 | |     ($e:expr, $s:expr) => {
  50 | |         match $e {
  51 | |             Ok(_) => panic!("Unexpected success. Should've been: {:?}", $s),
  52 | |             Err(ref err) => {
  53 | |                 assert!(err.raw_os_error() == Some($s), "`{}` did not have a code of `{}`", err, $s)
     | |                                               ^^^^^^^^
...    |
  56 | |     };
  57 | | }
     | |_- in this expansion of `error!`
...
1293 |       error!(c(&r).truncate(true).open(&tmpdir.join("b")), invalid_options);
     |       ---------------------------------------------------------------------
     |       |                                                    |
     |       |                                                    this argument influences the type of `Some`
     |       in this macro invocation
note: tuple variant defined here
---

error[E0308]: mismatched types
    --> library\std\src\fs\tests.rs:1294:56
     |
  53 |                 assert!(err.raw_os_error() == Some($s), "`{}` did not have a code of `{}`", err, $s)
     |                                               ---- arguments to this enum variant are incorrect
...
1294 |     error!(c(&r).create(true).open(&tmpdir.join("b")), invalid_options);
     |                                                        ^^^^^^^^^^^^^^^ expected `i32`, found `&str`
     |
help: the type constructed contains `&str` due to the type of the argument passed
    --> library\std\src\fs\tests.rs:53:47
     |
  48 | / macro_rules! error {
  49 | |     ($e:expr, $s:expr) => {
  50 | |         match $e {
  51 | |             Ok(_) => panic!("Unexpected success. Should've been: {:?}", $s),
  52 | |             Err(ref err) => {
  53 | |                 assert!(err.raw_os_error() == Some($s), "`{}` did not have a code of `{}`", err, $s)
     | |                                               ^^^^^^^^
...    |
  56 | |     };
  57 | | }
     | |_- in this expansion of `error!`
...
1294 |       error!(c(&r).create(true).open(&tmpdir.join("b")), invalid_options);
     |       -------------------------------------------------------------------
     |       |                                                  |
     |       |                                                  this argument influences the type of `Some`
     |       in this macro invocation
note: tuple variant defined here
---

error[E0308]: mismatched types
    --> library\std\src\fs\tests.rs:1306:71
     |
  53 |                 assert!(err.raw_os_error() == Some($s), "`{}` did not have a code of `{}`", err, $s)
     |                                               ---- arguments to this enum variant are incorrect
...
1306 |     error!(c(&a).create(true).truncate(true).open(&tmpdir.join("d")), invalid_options);
     |                                                                       ^^^^^^^^^^^^^^^ expected `i32`, found `&str`
     |
help: the type constructed contains `&str` due to the type of the argument passed
    --> library\std\src\fs\tests.rs:53:47
     |
  48 | / macro_rules! error {
  49 | |     ($e:expr, $s:expr) => {
  50 | |         match $e {
  51 | |             Ok(_) => panic!("Unexpected success. Should've been: {:?}", $s),
  52 | |             Err(ref err) => {
  53 | |                 assert!(err.raw_os_error() == Some($s), "`{}` did not have a code of `{}`", err, $s)
     | |                                               ^^^^^^^^
...    |
  56 | |     };
  57 | | }
     | |_- in this expansion of `error!`
...
1306 |       error!(c(&a).create(true).truncate(true).open(&tmpdir.join("d")), invalid_options);
     |       ----------------------------------------------------------------------------------
     |       |                                                                 |
     |       |                                                                 this argument influences the type of `Some`
     |       in this macro invocation
note: tuple variant defined here
---

error[E0308]: mismatched types
    --> library\std\src\fs\tests.rs:1307:58
     |
  53 |                 assert!(err.raw_os_error() == Some($s), "`{}` did not have a code of `{}`", err, $s)
     |                                               ---- arguments to this enum variant are incorrect
...
1307 |     error!(c(&a).truncate(true).open(&tmpdir.join("d")), invalid_options);
     |                                                          ^^^^^^^^^^^^^^^ expected `i32`, found `&str`
     |
help: the type constructed contains `&str` due to the type of the argument passed
    --> library\std\src\fs\tests.rs:53:47
     |
  48 | / macro_rules! error {
  49 | |     ($e:expr, $s:expr) => {
  50 | |         match $e {
  51 | |             Ok(_) => panic!("Unexpected success. Should've been: {:?}", $s),
  52 | |             Err(ref err) => {
  53 | |                 assert!(err.raw_os_error() == Some($s), "`{}` did not have a code of `{}`", err, $s)
     | |                                               ^^^^^^^^
...    |
  56 | |     };
  57 | | }
     | |_- in this expansion of `error!`
...
1307 |       error!(c(&a).truncate(true).open(&tmpdir.join("d")), invalid_options);
     |       ---------------------------------------------------------------------
     |       |                                                    |
     |       |                                                    this argument influences the type of `Some`
     |       in this macro invocation
note: tuple variant defined here
---

error[E0308]: mismatched types
    --> library\std\src\fs\tests.rs:1313:72
     |
  53 |                 assert!(err.raw_os_error() == Some($s), "`{}` did not have a code of `{}`", err, $s)
     |                                               ---- arguments to this enum variant are incorrect
...
1313 |     error!(c(&ra).create(true).truncate(true).open(&tmpdir.join("e")), invalid_options);
     |                                                                        ^^^^^^^^^^^^^^^ expected `i32`, found `&str`
     |
help: the type constructed contains `&str` due to the type of the argument passed
    --> library\std\src\fs\tests.rs:53:47
     |
  48 | / macro_rules! error {
  49 | |     ($e:expr, $s:expr) => {
  50 | |         match $e {
  51 | |             Ok(_) => panic!("Unexpected success. Should've been: {:?}", $s),
  52 | |             Err(ref err) => {
  53 | |                 assert!(err.raw_os_error() == Some($s), "`{}` did not have a code of `{}`", err, $s)
     | |                                               ^^^^^^^^
...    |
  56 | |     };
  57 | | }
     | |_- in this expansion of `error!`
...
1313 |       error!(c(&ra).create(true).truncate(true).open(&tmpdir.join("e")), invalid_options);
     |       -----------------------------------------------------------------------------------
     |       |                                                                  |
     |       |                                                                  this argument influences the type of `Some`
     |       in this macro invocation
note: tuple variant defined here
---

error[E0308]: mismatched types
    --> library\std\src\fs\tests.rs:1314:59
     |
  53 |                 assert!(err.raw_os_error() == Some($s), "`{}` did not have a code of `{}`", err, $s)
     |                                               ---- arguments to this enum variant are incorrect
...
1314 |     error!(c(&ra).truncate(true).open(&tmpdir.join("e")), invalid_options);
     |                                                           ^^^^^^^^^^^^^^^ expected `i32`, found `&str`
     |
help: the type constructed contains `&str` due to the type of the argument passed
    --> library\std\src\fs\tests.rs:53:47
     |
  48 | / macro_rules! error {
  49 | |     ($e:expr, $s:expr) => {
  50 | |         match $e {
  51 | |             Ok(_) => panic!("Unexpected success. Should've been: {:?}", $s),
  52 | |             Err(ref err) => {
  53 | |                 assert!(err.raw_os_error() == Some($s), "`{}` did not have a code of `{}`", err, $s)
     | |                                               ^^^^^^^^
...    |
  56 | |     };
  57 | | }
     | |_- in this expansion of `error!`
...
1314 |       error!(c(&ra).truncate(true).open(&tmpdir.join("e")), invalid_options);
     |       ----------------------------------------------------------------------
     |       |                                                     |
     |       |                                                     this argument influences the type of `Some`
     |       in this macro invocation
note: tuple variant defined here
---

error[E0308]: mismatched types
    --> library\std\src\fs\tests.rs:1320:56
     |
  53 |                 assert!(err.raw_os_error() == Some($s), "`{}` did not have a code of `{}`", err, $s)
     |                                               ---- arguments to this enum variant are incorrect
...
1320 |     error!(blank.create(true).open(&tmpdir.join("f")), invalid_options);
     |                                                        ^^^^^^^^^^^^^^^ expected `i32`, found `&str`
     |
help: the type constructed contains `&str` due to the type of the argument passed
    --> library\std\src\fs\tests.rs:53:47
     |
  48 | / macro_rules! error {
  49 | |     ($e:expr, $s:expr) => {
  50 | |         match $e {
  51 | |             Ok(_) => panic!("Unexpected success. Should've been: {:?}", $s),
  52 | |             Err(ref err) => {
  53 | |                 assert!(err.raw_os_error() == Some($s), "`{}` did not have a code of `{}`", err, $s)
     | |                                               ^^^^^^^^
...    |
  56 | |     };
  57 | | }
     | |_- in this expansion of `error!`
...
1320 |       error!(blank.create(true).open(&tmpdir.join("f")), invalid_options);
     |       -------------------------------------------------------------------
     |       |                                                  |
     |       |                                                  this argument influences the type of `Some`
     |       in this macro invocation
note: tuple variant defined here
---
[RUSTC-TIMING] corebenches test:true 67.184
[RUSTC-TIMING] coretests test:true 119.875
Bootstrap failed while executing `test --stage 2 --skip=compiler --skip=src`
Build completed unsuccessfully in 1:26:06
make: *** [Makefile:112: ci-msvc-py] Error 1
  local time: Fri Aug 29 22:33:09 CUT 2025
  network time: Fri, 29 Aug 2025 22:33:10 GMT
##[error]Process completed with exit code 2.
Post job cleanup.
[command]"C:\Program Files\Git\bin\git.exe" version

[bors]

💔 Test failed - checks-actions