Skip to content

Commit

Permalink
Turn on rust-2024-compatibility lints in test crate
Browse files Browse the repository at this point in the history
    warning: unsafe attribute used without unsafe
      --> tests/ffi/module.rs:15:19
       |
    15 |     impl Vec<Job> {}
       |                   ^^ 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: the lint level is defined here
      --> tests/ffi/lib.rs:18:9
       |
    18 | #![warn(rust_2024_compatibility)]
       |         ^^^^^^^^^^^^^^^^^^^^^^^
       = note: `#[warn(unsafe_attr_outside_unsafe)]` implied by `#[warn(rust_2024_compatibility)]`
    help: wrap the attribute in `unsafe(...)`
       |
    15 |     impl Vec<Job> {unsafe(})
       |                    +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:171:58
        |
    171 |         fn c_take_callback(callback: fn(String) -> usize);
        |                                                          ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    171 |         fn c_take_callback(callback: fn(String) -> usize)unsafe(;)
        |                                                          +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:172:54
        |
    172 |         fn c_take_callback_ref(callback: fn(&String));
        |                                                      ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    172 |         fn c_take_callback_ref(callback: fn(&String))unsafe(;)
        |                                                      +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:174:70
        |
    174 |         fn c_take_callback_ref_lifetime<'a>(callback: fn(&'a String));
        |                                                                      ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    174 |         fn c_take_callback_ref_lifetime<'a>(callback: fn(&'a String))unsafe(;)
        |                                                                      +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:175:58
        |
    175 |         fn c_take_callback_mut(callback: fn(&mut String));
        |                                                          ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    175 |         fn c_take_callback_mut(callback: fn(&mut String))unsafe(;)
        |                                                          +++++++ +

    warning: unsafe attribute used without unsafe
      --> tests/ffi/lib.rs:31:28
       |
    31 |     #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
       |                            ^^^^^^^^^ 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>
    help: wrap the attribute in `unsafe(...)`
       |
    31 |     #[derive(Clone, Debug, Paunsafe(rtialE)q, Eq, PartialOrd, Ord)]
       |                              +++++++      +

    warning: unsafe attribute used without unsafe
      --> tests/ffi/lib.rs:31:43
       |
    31 |     #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
       |                                           ^^^^^^^^^^ 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>
    help: wrap the attribute in `unsafe(...)`
       |
    31 |     #[derive(Clone, Debug, PartialEq, Eq, Paunsafe(rtialOr)d, Ord)]
       |                                             +++++++       +

    warning: unsafe attribute used without unsafe
      --> tests/ffi/lib.rs:36:14
       |
    36 |     #[derive(PartialEq, PartialOrd)]
       |              ^^^^^^^^^ 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>
    help: wrap the attribute in `unsafe(...)`
       |
    36 |     #[derive(Paunsafe(rtialE)q, PartialOrd)]
       |                +++++++      +

    warning: unsafe attribute used without unsafe
      --> tests/ffi/lib.rs:36:25
       |
    36 |     #[derive(PartialEq, PartialOrd)]
       |                         ^^^^^^^^^^ 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>
    help: wrap the attribute in `unsafe(...)`
       |
    36 |     #[derive(PartialEq, Paunsafe(rtialOr)d)]
       |                           +++++++       +

    warning: unsafe attribute used without unsafe
      --> tests/ffi/lib.rs:82:14
       |
    82 |     #[derive(Hash)]
       |              ^^^^ 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>
    help: wrap the attribute in `unsafe(...)`
       |
    82 |     #[derive(Haunsafe(s)h)]
       |                +++++++ +

    warning: unsafe attribute used without unsafe
      --> tests/ffi/lib.rs:93:47
       |
    93 |     #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
       |                                               ^^^^ 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>
    help: wrap the attribute in `unsafe(...)`
       |
    93 |     #[derive(Copy, Clone, Debug, Default, Eq, Haunsafe(s)h, Ord, PartialEq, PartialOrd)]
       |                                                 +++++++ +

    warning: unsafe attribute used without unsafe
      --> tests/ffi/lib.rs:93:58
       |
    93 |     #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
       |                                                          ^^^^^^^^^ 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>
    help: wrap the attribute in `unsafe(...)`
       |
    93 |     #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, Paunsafe(rtialE)q, PartialOrd)]
       |                                                            +++++++      +

    warning: unsafe attribute used without unsafe
      --> tests/ffi/lib.rs:93:69
       |
    93 |     #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
       |                                                                     ^^^^^^^^^^ 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>
    help: wrap the attribute in `unsafe(...)`
       |
    93 |     #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, Paunsafe(rtialOr)d)]
       |                                                                       +++++++       +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:236:14
        |
    236 |         type Reference<'a>;
        |              ^^^^^^^^^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    236 |         type Reunsafe(ferenc)e<'a>;
        |                +++++++      +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:265:14
        |
    265 |         type R;
        |              ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    265 |         type unsafe(R);
        |              +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:267:41
        |
    267 |         fn r_return_primitive() -> usize;
        |                                         ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    267 |         fn r_return_primitive() -> usizeunsafe(;)
        |                                         +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:268:39
        |
    268 |         fn r_return_shared() -> Shared;
        |                                       ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    268 |         fn r_return_shared() -> Sharedunsafe(;)
        |                                       +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:269:36
        |
    269 |         fn r_return_box() -> Box<R>;
        |                                    ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    269 |         fn r_return_box() -> Box<R>unsafe(;)
        |                                    +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:270:49
        |
    270 |         fn r_return_unique_ptr() -> UniquePtr<C>;
        |                                                 ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    270 |         fn r_return_unique_ptr() -> UniquePtr<C>unsafe(;)
        |                                                 +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:271:49
        |
    271 |         fn r_return_shared_ptr() -> SharedPtr<C>;
        |                                                 ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    271 |         fn r_return_shared_ptr() -> SharedPtr<C>unsafe(;)
        |                                                 +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:272:51
        |
    272 |         fn r_return_ref(shared: &Shared) -> &usize;
        |                                                   ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    272 |         fn r_return_ref(shared: &Shared) -> &usizeunsafe(;)
        |                                                   +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:273:59
        |
    273 |         fn r_return_mut(shared: &mut Shared) -> &mut usize;
        |                                                           ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    273 |         fn r_return_mut(shared: &mut Shared) -> &mut usizeunsafe(;)
        |                                                           +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:274:49
        |
    274 |         fn r_return_str(shared: &Shared) -> &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>
    help: wrap the attribute in `unsafe(...)`
        |
    274 |         fn r_return_str(shared: &Shared) -> &strunsafe(;)
        |                                                 +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:275:54
        |
    275 |         fn r_return_sliceu8(shared: &Shared) -> &[u8];
        |                                                      ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    275 |         fn r_return_sliceu8(shared: &Shared) -> &[u8]unsafe(;)
        |                                                      +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:276:62
        |
    276 |         fn r_return_mutsliceu8(slice: &mut [u8]) -> &mut [u8];
        |                                                              ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    276 |         fn r_return_mutsliceu8(slice: &mut [u8]) -> &mut [u8]unsafe(;)
        |                                                              +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:277:44
        |
    277 |         fn r_return_rust_string() -> String;
        |                                            ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    277 |         fn r_return_rust_string() -> Stringunsafe(;)
        |                                            +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:278:64
        |
    278 |         fn r_return_unique_ptr_string() -> UniquePtr<CxxString>;
        |                                                                ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    278 |         fn r_return_unique_ptr_string() -> UniquePtr<CxxString>unsafe(;)
        |                                                                +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:279:42
        |
    279 |         fn r_return_rust_vec() -> Vec<u8>;
        |                                          ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    279 |         fn r_return_rust_vec() -> Vec<u8>unsafe(;)
        |                                          +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:280:53
        |
    280 |         fn r_return_rust_vec_string() -> Vec<String>;
        |                                                     ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    280 |         fn r_return_rust_vec_string() -> Vec<String>unsafe(;)
        |                                                     +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:281:57
        |
    281 |         fn r_return_rust_vec_extern_struct() -> Vec<Job>;
        |                                                         ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    281 |         fn r_return_rust_vec_extern_struct() -> Vec<Job>unsafe(;)
        |                                                         +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:282:62
        |
    282 |         fn r_return_ref_rust_vec(shared: &Shared) -> &Vec<u8>;
        |                                                              ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    282 |         fn r_return_ref_rust_vec(shared: &Shared) -> &Vec<u8>unsafe(;)
        |                                                              +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:283:70
        |
    283 |         fn r_return_mut_rust_vec(shared: &mut Shared) -> &mut Vec<u8>;
        |                                                                      ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    283 |         fn r_return_mut_rust_vec(shared: &mut Shared) -> &mut Vec<u8>unsafe(;)
        |                                                                      +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:284:48
        |
    284 |         fn r_return_identity(_: usize) -> usize;
        |                                                ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    284 |         fn r_return_identity(_: usize) -> usizeunsafe(;)
        |                                                +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:285:53
        |
    285 |         fn r_return_sum(_: usize, _: usize) -> usize;
        |                                                     ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    285 |         fn r_return_sum(_: usize, _: usize) -> usizeunsafe(;)
        |                                                     +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:286:41
        |
    286 |         fn r_return_enum(n: u32) -> Enum;
        |                                         ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    286 |         fn r_return_enum(n: u32) -> Enumunsafe(;)
        |                                         +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:288:38
        |
    288 |         fn r_take_primitive(n: usize);
        |                                      ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    288 |         fn r_take_primitive(n: usize)unsafe(;)
        |                                      +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:289:41
        |
    289 |         fn r_take_shared(shared: Shared);
        |                                         ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    289 |         fn r_take_shared(shared: Shared)unsafe(;)
        |                                         +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:290:33
        |
    290 |         fn r_take_box(r: Box<R>);
        |                                 ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    290 |         fn r_take_box(r: Box<R>)unsafe(;)
        |                                 +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:291:46
        |
    291 |         fn r_take_unique_ptr(c: UniquePtr<C>);
        |                                              ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    291 |         fn r_take_unique_ptr(c: UniquePtr<C>)unsafe(;)
        |                                              +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:292:46
        |
    292 |         fn r_take_shared_ptr(c: SharedPtr<C>);
        |                                              ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    292 |         fn r_take_shared_ptr(c: SharedPtr<C>)unsafe(;)
        |                                              +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:293:31
        |
    293 |         fn r_take_ref_r(r: &R);
        |                               ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    293 |         fn r_take_ref_r(r: &R)unsafe(;)
        |                               +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:294:31
        |
    294 |         fn r_take_ref_c(c: &C);
        |                               ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    294 |         fn r_take_ref_c(c: &C)unsafe(;)
        |                               +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:295:31
        |
    295 |         fn r_take_str(s: &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>
    help: wrap the attribute in `unsafe(...)`
        |
    295 |         fn r_take_str(s: &str)unsafe(;)
        |                               +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:296:43
        |
    296 |         fn r_take_slice_char(s: &[c_char]);
        |                                           ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    296 |         fn r_take_slice_char(s: &[c_char])unsafe(;)
        |                                           +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:297:41
        |
    297 |         fn r_take_rust_string(s: String);
        |                                         ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    297 |         fn r_take_rust_string(s: String)unsafe(;)
        |                                         +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:298:61
        |
    298 |         fn r_take_unique_ptr_string(s: UniquePtr<CxxString>);
        |                                                             ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    298 |         fn r_take_unique_ptr_string(s: UniquePtr<CxxString>)unsafe(;)
        |                                                             +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:299:48
        |
    299 |         fn r_take_ref_vector(v: &CxxVector<u8>);
        |                                                ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    299 |         fn r_take_ref_vector(v: &CxxVector<u8>)unsafe(;)
        |                                                +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:300:55
        |
    300 |         fn r_take_ref_empty_vector(v: &CxxVector<u64>);
        |                                                       ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    300 |         fn r_take_ref_empty_vector(v: &CxxVector<u64>)unsafe(;)
        |                                                       +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:301:39
        |
    301 |         fn r_take_rust_vec(v: Vec<u8>);
        |                                       ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    301 |         fn r_take_rust_vec(v: Vec<u8>)unsafe(;)
        |                                       +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:302:50
        |
    302 |         fn r_take_rust_vec_string(v: Vec<String>);
        |                                                  ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    302 |         fn r_take_rust_vec_string(v: Vec<String>)unsafe(;)
        |                                                  +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:303:44
        |
    303 |         fn r_take_ref_rust_vec(v: &Vec<u8>);
        |                                            ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    303 |         fn r_take_ref_rust_vec(v: &Vec<u8>)unsafe(;)
        |                                            +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:304:55
        |
    304 |         fn r_take_ref_rust_vec_string(v: &Vec<String>);
        |                                                       ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    304 |         fn r_take_ref_rust_vec_string(v: &Vec<String>)unsafe(;)
        |                                                       +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:305:32
        |
    305 |         fn r_take_enum(e: Enum);
        |                                ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    305 |         fn r_take_enum(e: Enum)unsafe(;)
        |                                +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:307:45
        |
    307 |         fn r_try_return_void() -> Result<()>;
        |                                             ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    307 |         fn r_try_return_void() -> Result<()>unsafe(;)
        |                                             +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:308:53
        |
    308 |         fn r_try_return_primitive() -> Result<usize>;
        |                                                     ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    308 |         fn r_try_return_primitive() -> Result<usize>unsafe(;)
        |                                                     +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:309:48
        |
    309 |         fn r_try_return_box() -> Result<Box<R>>;
        |                                                ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    309 |         fn r_try_return_box() -> Result<Box<R>>unsafe(;)
        |                                                +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:310:54
        |
    310 |         fn r_fail_return_primitive() -> Result<usize>;
        |                                                      ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    310 |         fn r_fail_return_primitive() -> Result<usize>unsafe(;)
        |                                                      +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:311:59
        |
    311 |         fn r_try_return_sliceu8(s: &[u8]) -> Result<&[u8]>;
        |                                                           ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    311 |         fn r_try_return_sliceu8(s: &[u8]) -> Result<&[u8]>unsafe(;)
        |                                                           +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:312:70
        |
    312 |         fn r_try_return_mutsliceu8(s: &mut [u8]) -> Result<&mut [u8]>;
        |                                                                      ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    312 |         fn r_try_return_mutsliceu8(s: &mut [u8]) -> Result<&mut [u8]>unsafe(;)
        |                                                                      +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:314:34
        |
    314 |         fn get(self: &R) -> usize;
        |                                  ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    314 |         fn get(self: &R) -> usizeunsafe(;)
        |                                  +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:315:48
        |
    315 |         fn set(self: &mut R, n: usize) -> usize;
        |                                                ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    315 |         fn set(self: &mut R, n: usize) -> usizeunsafe(;)
        |                                                +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:316:55
        |
    316 |         fn r_method_on_shared(self: &Shared) -> String;
        |                                                       ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    316 |         fn r_method_on_shared(self: &Shared) -> Stringunsafe(;)
        |                                                       +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:317:48
        |
    317 |         fn r_get_array_sum(self: &Array) -> i32;
        |                                                ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    317 |         fn r_get_array_sum(self: &Array) -> i32unsafe(;)
        |                                                +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:320:48
        |
    320 |         fn r_aliased_function(x: i32) -> String;
        |                                                ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    320 |         fn r_aliased_function(x: i32) -> Stringunsafe(;)
        |                                                +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:344:22
        |
    344 |     impl Box<Shared> {}
        |                      ^^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    344 |     impl Box<Shared> {unsafe(})
        |                       +++++++ +

    warning: unsafe attribute used without unsafe
      --> tests/ffi/lib.rs:78:27
       |
    78 |         second: Box<Second>,
       |                           ^ 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>
    help: wrap the attribute in `unsafe(...)`
       |
    78 |         second: Box<Secondunsafe(>),
       |                           +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:105:35
        |
    105 |         fn c_return_box() -> Box<R>;
        |                                   ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    105 |         fn c_return_box() -> Box<Runsafe(>);
        |                                   +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:157:48
        |
    157 |         fn c_take_rust_vec_shared(v: Vec<Shared>);
        |                                                ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    157 |         fn c_take_rust_vec_shared(v: Vec<Sharedunsafe(>));
        |                                                +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:181:52
        |
    181 |         fn c_take_rust_vec_ns_shared(v: Vec<AShared>);
        |                                                    ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    181 |         fn c_take_rust_vec_ns_shared(v: Vec<ASharedunsafe(>));
        |                                                    +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:182:60
        |
    182 |         fn c_take_rust_vec_nested_ns_shared(v: Vec<ABShared>);
        |                                                            ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    182 |         fn c_take_rust_vec_nested_ns_shared(v: Vec<ABSharedunsafe(>));
        |                                                            +++++++ +

    warning: unsafe attribute used without unsafe
       --> tests/ffi/lib.rs:329:22
        |
    329 |         vec: Vec<Dag3>,
        |                      ^ 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>
    help: wrap the attribute in `unsafe(...)`
        |
    329 |         vec: Vec<Dag3unsafe(>),
        |                      +++++++ +

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:12:46
       |
    12 |         fn c_take_unique_ptr(c: UniquePtr<C>);
       |                                              ^
       |                                              |
       |                                              help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>
       = note: `#[warn(missing_unsafe_on_extern)]` implied by `#[warn(rust_2024_compatibility)]`

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:33:47
       |
    33 |         fn c_take_trivial_ptr(d: UniquePtr<D>);
       |                                               ^
       |                                               |
       |                                               help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:34:37
       |
    34 |         fn c_take_trivial_ref(d: &D);
       |                                     ^
       |                                     |
       |                                     help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:35:45
       |
    35 |         fn c_take_trivial_mut_ref(d: &mut D);
       |                                             ^
       |                                             |
       |                                             help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:36:46
       |
    36 |         fn c_take_trivial_pin_ref(d: Pin<&D>);
       |                                              ^
       |                                              |
       |                                              help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:37:54
       |
    37 |         fn c_take_trivial_pin_mut_ref(d: Pin<&mut D>);
       |                                                      ^
       |                                                      |
       |                                                      help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:38:47
       |
    38 |         fn c_take_trivial_ref_method(self: &D);
       |                                               ^
       |                                               |
       |                                               help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:39:55
       |
    39 |         fn c_take_trivial_mut_ref_method(self: &mut D);
       |                                                       ^
       |                                                       |
       |                                                       help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:40:32
       |
    40 |         fn c_take_trivial(d: D);
       |                                ^
       |                                |
       |                                help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:41:50
       |
    41 |         fn c_take_trivial_ns_ptr(g: UniquePtr<G>);
       |                                                  ^
       |                                                  |
       |                                                  help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:42:40
       |
    42 |         fn c_take_trivial_ns_ref(g: &G);
       |                                        ^
       |                                        |
       |                                        help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:43:35
       |
    43 |         fn c_take_trivial_ns(g: G);
       |                                   ^
       |                                   |
       |                                   help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:44:46
       |
    44 |         fn c_take_opaque_ptr(e: UniquePtr<E>);
       |                                              ^
       |                                              |
       |                                              help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:45:36
       |
    45 |         fn c_take_opaque_ref(e: &E);
       |                                    ^
       |                                    |
       |                                    help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:46:46
       |
    46 |         fn c_take_opaque_ref_method(self: &E);
       |                                              ^
       |                                              |
       |                                              help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:47:59
       |
    47 |         fn c_take_opaque_mut_ref_method(self: Pin<&mut E>);
       |                                                           ^
       |                                                           |
       |                                                           help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:48:49
       |
    48 |         fn c_take_opaque_ns_ptr(e: UniquePtr<F>);
       |                                                 ^
       |                                                 |
       |                                                 help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:49:39
       |
    49 |         fn c_take_opaque_ns_ref(e: &F);
       |                                       ^
       |                                       |
       |                                       help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:50:50
       |
    50 |         fn c_return_trivial_ptr() -> UniquePtr<D>;
       |                                                  ^
       |                                                  |
       |                                                  help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:51:35
       |
    51 |         fn c_return_trivial() -> D;
       |                                   ^
       |                                   |
       |                                   help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:52:53
       |
    52 |         fn c_return_trivial_ns_ptr() -> UniquePtr<G>;
       |                                                     ^
       |                                                     |
       |                                                     help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:53:38
       |
    53 |         fn c_return_trivial_ns() -> G;
       |                                      ^
       |                                      |
       |                                      help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:54:49
       |
    54 |         fn c_return_opaque_ptr() -> UniquePtr<E>;
       |                                                 ^
       |                                                 |
       |                                                 help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:55:66
       |
    55 |         fn c_return_opaque_mut_pin(e: Pin<&mut E>) -> Pin<&mut E>;
       |                                                                  ^
       |                                                                  |
       |                                                                  help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:56:52
       |
    56 |         fn c_return_ns_opaque_ptr() -> UniquePtr<F>;
       |                                                    ^
       |                                                    |
       |                                                    help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:57:52
       |
    57 |         fn c_return_ns_unique_ptr() -> UniquePtr<H>;
       |                                                    ^
       |                                                    |
       |                                                    help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:58:34
       |
    58 |         fn c_take_ref_ns_c(h: &H);
       |                                  ^
       |                                  |
       |                                  help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:61:35
       |
    61 |         fn ns_c_take_trivial(d: D);
       |                                   ^
       |                                   |
       |                                   help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:63:38
       |
    63 |         fn ns_c_return_trivial() -> D;
       |                                      ^
       |                                      |
       |                                      help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:68:32
       |
    68 |         fn get(self: &I) -> u32;
       |                                ^
       |                                |
       |                                help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:71:55
       |
    71 |         fn ns_c_return_unique_ptr_ns() -> UniquePtr<I>;
       |                                                       ^
       |                                                       |
       |                                                       help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:74:23
       |
    74 |     impl UniquePtr<D> {}
       |                       -^
       |                       |
       |                       help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:75:23
       |
    75 |     impl UniquePtr<E> {}
       |                       -^
       |                       |
       |                       help: needs `unsafe` before the extern keyword: `unsafe`
       |
       = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024!
       = note: for more information, see issue #123743 <https://github.com/rust-lang/rust/issues/123743>

    warning: extern blocks should be unsafe
      --> tests/ffi/module.rs:76:23
       |
    76 |     impl UniquePtr<F> {}
       |                       -^
       |                       |
       |                       help: needs `unsafe` before the extern keyword: `unsafe`
…
  • Loading branch information
dtolnay committed Nov 12, 2024
1 parent 88ddad9 commit e7bceb9
Showing 1 changed file with 3 additions and 1 deletion.
4 changes: 3 additions & 1 deletion tests/ffi/lib.rs
Original file line number Diff line number Diff line change
@@ -1,4 +1,3 @@
#![forbid(unsafe_op_in_unsafe_fn)]
#![allow(
clippy::boxed_local,
clippy::derive_partial_eq_without_eq,
Expand All @@ -15,6 +14,9 @@
clippy::unnecessary_wraps,
clippy::unused_self
)]
#![allow(unknown_lints)]
#![warn(rust_2024_compatibility)]
#![forbid(unsafe_op_in_unsafe_fn)]

pub mod cast;
pub mod module;
Expand Down

0 comments on commit e7bceb9

Please sign in to comment.