Edition 2024 unsafe_attr_outside_unsafe migration produces invalid suggestion

[eric-seppanen]

I ran cargo +nightly fix --edition on the following code:

[package]
name = "test_2024_edition"
version = "0.1.0"
edition = "2021"

[dependencies]
cxx = "=1.0.78"
log = "=0.4.21"

Note that the cxx version matters. 1.0.78 .. 1.0.129 fail, 1.0.130 .. 1.0.133 succeed.

#[cxx::bridge(namespace = "mt")]
mod ffi {
    enum CxxLevel {
        Error,
        Warn,
        Info,
        Debug,
        Trace,
    }

    extern "Rust" {
        fn cxx_log(level: CxxLevel, target: &str, file: &'static str, line: u32, contents: &str);
    }
}

pub fn cxx_log(level: ffi::CxxLevel, target: &str, file: &'static str, line: u32, contents: &str) {
    let level = match level {
        ffi::CxxLevel::Error => log::Level::Error,
        ffi::CxxLevel::Warn => log::Level::Warn,
        ffi::CxxLevel::Info => log::Level::Info,
        ffi::CxxLevel::Debug => log::Level::Debug,
        ffi::CxxLevel::Trace => log::Level::Trace,
        _ => panic!("Invalid level from C++ log call"),
    };
    log::logger().log(
        &log::RecordBuilder::new()
            .args(format_args!("{}", contents))
            .level(level)
            .target(target)
            .file_static(Some(file))
            .line(Some(line))
            .build(),
    );
}

I expected to see this happen: Migration succeeds.

Instead, this happened:

   Migrating Cargo.toml from 2021 edition to 2024
    Checking test_2024_edition v0.1.0 (/home/eric/work/play/cxx_2024_edition)
   Migrating src/lib.rs from 2021 edition to 2024
warning: failed to automatically apply fixes suggested by rustc to crate `test_2024_edition`

after fixes were automatically applied the compiler reported errors within these files:

  * src/lib.rs

This likely indicates a bug in either rustc or cargo itself,
and we would appreciate a bug report! You're likely to see
a number of compiler warnings after this message which cargo
attempted to fix but failed. If you could open an issue at
https://github.com/rust-lang/rust/issues
quoting the full output of this command we'd be very appreciative!
Note that you may be able to make some more progress in the near-term
fixing code with the `--broken-code` flag

The following errors were reported:
error: expected `{`, found `;`
  --> src/lib.rs:12:106
   |
12 |         fn cxx_log(level: CxxLevel, target: &str, file: &'static str, line: u32, contents: &str){ unsafe ;}
   |                                                                                                   ------ ^ expected `{`
   |                                                                                                   |
   |                                                                                                   while parsing this `unsafe` expression

error: expected one of: `trait`, `auto`, `impl`, `extern`, `mod`
  --> src/lib.rs:12:106
   |
12 |         fn cxx_log(level: CxxLevel, target: &str, file: &'static str, line: u32, contents: &str){ unsafe ;}
   |                                                                                                          ^

error[E0433]: failed to resolve: use of undeclared crate or module `ffi`
  --> src/lib.rs:18:9
   |
18 |         ffi::CxxLevel::Error => log::Level::Error,
   |         ^^^ use of undeclared crate or module `ffi`

error[E0433]: failed to resolve: use of undeclared crate or module `ffi`
  --> src/lib.rs:19:9
   |
19 |         ffi::CxxLevel::Warn => log::Level::Warn,
   |         ^^^ use of undeclared crate or module `ffi`

error[E0433]: failed to resolve: use of undeclared crate or module `ffi`
  --> src/lib.rs:20:9
   |
20 |         ffi::CxxLevel::Info => log::Level::Info,
   |         ^^^ use of undeclared crate or module `ffi`

error[E0433]: failed to resolve: use of undeclared crate or module `ffi`
  --> src/lib.rs:21:9
   |
21 |         ffi::CxxLevel::Debug => log::Level::Debug,
   |         ^^^ use of undeclared crate or module `ffi`

error[E0433]: failed to resolve: use of undeclared crate or module `ffi`
  --> src/lib.rs:22:9
   |
22 |         ffi::CxxLevel::Trace => log::Level::Trace,
   |         ^^^ use of undeclared crate or module `ffi`

error[E0433]: failed to resolve: use of undeclared crate or module `ffi`
  --> src/lib.rs:16:23
   |
16 | pub fn cxx_log(level: ffi::CxxLevel, target: &str, file: &'static str, line: u32, contents: &str) {
   |                       ^^^ use of undeclared crate or module `ffi`

error: aborting due to 8 previous errors

For more information about this error, try `rustc --explain E0433`.
Original diagnostics will follow.

warning: unsafe attribute used without unsafe
  --> src/lib.rs:12:97
   |
12 |         fn cxx_log(level: CxxLevel, target: &str, file: &'static str, line: u32, contents: &str);
   |                                                                                                 ^ usage of unsafe attribute
   |
   = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
   = note: for more information, see issue #123757 <https://github.com/rust-lang/rust/issues/123757>
   = note: `--force-warn unsafe-attr-outside-unsafe` implied by `--force-warn rust-2024-compatibility`
help: wrap the attribute in `unsafe(...)`
   |
12 |         fn cxx_log(level: CxxLevel, target: &str, file: &'static str, line: u32, contents: &str)unsafe(;)
   |                                                                                                 +++++++ +

warning[E0133]: call to unsafe function `cxx::private::RustStr::as_str` is unsafe and requires unsafe block
  --> src/lib.rs:12:37
   |
12 |         fn cxx_log(level: CxxLevel, target: &str, file: &'static str, line: u32, contents: &str);
   |                                     ^^^^^^ call to unsafe function
   |
   = note: for more information, see issue #71668 <https://github.com/rust-lang/rust/issues/71668>
   = note: consult the function's documentation for information on how to avoid undefined behavior
note: an unsafe function restricts its caller, but its body is safe by default
  --> src/lib.rs:12:97
   |
12 |         fn cxx_log(level: CxxLevel, target: &str, file: &'static str, line: u32, contents: &str);
   |                                                                                                 ^
   = note: `--force-warn unsafe-op-in-unsafe-fn` implied by `--force-warn rust-2024-compatibility`

warning[E0133]: call to unsafe function `cxx::private::RustStr::as_str` is unsafe and requires unsafe block
  --> src/lib.rs:12:51
   |
12 |         fn cxx_log(level: CxxLevel, target: &str, file: &'static str, line: u32, contents: &str);
   |                                                   ^^^^ call to unsafe function
   |
   = note: for more information, see issue #71668 <https://github.com/rust-lang/rust/issues/71668>
   = note: consult the function's documentation for information on how to avoid undefined behavior

warning[E0133]: call to unsafe function `cxx::private::RustStr::as_str` is unsafe and requires unsafe block
  --> src/lib.rs:12:82
   |
12 |         fn cxx_log(level: CxxLevel, target: &str, file: &'static str, line: u32, contents: &str);
   |                                                                                  ^^^^^^^^ call to unsafe function
   |
   = note: for more information, see issue #71668 <https://github.com/rust-lang/rust/issues/71668>
   = note: consult the function's documentation for information on how to avoid undefined behavior

For more information about this error, try `rustc --explain E0133`.
warning: `test_2024_edition` (lib test) generated 4 warnings (run `cargo fix --lib -p test_2024_edition --tests` to apply 2 suggestions)

Cargo then repeated all of that error output a second time; I'm not sure why.

This happens in a new project with no other files present (i.e. no C/C++ header files or build.rs).

Meta

rustc --version --verbose:

rustc 1.85.0-nightly (c94848c04 2024-12-05)
binary: rustc
commit-hash: c94848c046d29f9a80c09aae758e27e418a289f2
commit-date: 2024-12-05
host: x86_64-unknown-linux-gnu
release: 1.85.0-nightly
LLVM version: 19.1.5

[jieyouxu]

This was probably fixed cxx side by dtolnay/cxx#1395. Something about the proc-macro, tagging as A-edition-2024.

[jieyouxu]

Tagging as L-missing_unsafe_on_extern as that seems most plausible to me.

[cyrgani]

Reduction of the macro:

use proc_macro::TokenStream;
use quote::quote_spanned;
use syn::{parse_macro_input, ForeignItemFn};

#[proc_macro_attribute]
pub fn bridge(_: TokenStream, input: TokenStream) -> TokenStream {
    let ffi = parse_macro_input!(input as ForeignItemFn);

    let body_span = ffi.semi_token.span;
    quote_spanned! {body_span=>
        #[export_name = "foo"]
        unsafe extern "C" fn bar() {}
    }
    .into()
}

called as:

#[cxxbridge_macro::bridge]
fn cxx_log();

The problem is that export_name should be unsafe, but the respanning causes the unsafe to end up as fn cxx_log()unsafe(;).

@rustbot label: -E-needs-mcve -L-missing_unsafe_on_extern +L-unsafe_attr_outside_unsafe

[traviscross]

We can close this as it was fixed on the cxx side, and there's probably nothing else that can or could have been done on the rustc side other than for us to work out a way of giving proc macro authors better tools for indicating the correct span for edition purposes while still giving nice errors to the user.

[eric-seppanen]

Is the error explosion of broken syntax is an acceptable result of running cargo fix?

If tooling is going to fail, I would expect better than barfing out a non-actionable mess that doesn't do anything to guide me toward the actual problem/fix.

How are users supposed to know to update cxx? This seems like a poor user experience.

It would be a big improvement for it to say "there's a macro in use here, and I'm unable to generate a fix. You may need to update the crate ____ containing the macro."

[eric-seppanen]

@traviscross Would you consider reopening this? I don't think "fixed by cxx" is really addressing the issue here, which is that cargo fix spews errors that don't help the user understand what they're supposed to do.