Rebase 1.0.150 #17
Merged
Rebase 1.0.150 #17
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Let's define the project version so that a dependant may define a specific version (or minimum version) of cxx as a dependency.
Let's add the -Wno-dollar-in-identifier-extension flag to cpp compilers that support that option as we make use of dollars in identifiers extensively.
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
= 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
warning: extern blocks should be unsafe
--> tests/ffi/module.rs:76:23
|
76 | impl 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
warning: extern blocks should be unsafe
--> tests/ffi/module.rs:77:23
|
77 | impl 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
warning: extern blocks should be unsafe
--> tests/ffi/module.rs:57:51
|
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
warning: extern blocks should be unsafe
--> tests/ffi/module.rs:71:54
|
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
warning: extern blocks should be unsafe
--> tests/ffi/lib.rs:103:41
|
103 | fn c_return_primitive() -> usize;
| ^
| |
| 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
warning: extern blocks should be unsafe
--> tests/ffi/lib.rs:104:39
|
104 | fn c_return_shared() -> Shared;
| ^
| |
| 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
warning: extern blocks should be unsafe
--> tests/ffi/lib.rs:105:36
|
105 | fn c_return_box() -> Box<R>;
| ^
| |
| 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
warning: extern blocks should be unsafe
--> tests/ffi/lib.rs:106:49
|
106 | fn c_return_unique_ptr() -> 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
warning: extern blocks should be unsafe
--> tests/ffi/lib.rs:107:49
|
107 | fn c_return_shared_ptr() -> SharedPtr<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
warning: extern blocks should be unsafe
--> tests/ffi/lib.rs:108:51
|
108 | fn c_return_ref(shared: &Shared) -> &usize;
| ^
| |
| 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
warning: extern blocks should be unsafe
--> tests/ffi/lib.rs:109:59
|
109 | fn c_return_mut(shared: &mut Shared) -> &mut usize;
| ^
| |
| …
Make generated code compatible with Rust 2024 edition
Delete meson build
BUILD FAILED
Error running analysis for `root//tests:test (prelude//platforms:default#904931f735703749)`
Caused by:
0: Error in configured node dependency, dependency chain follows (-> indicates depends on, ^ indicates same configuration as previous):
root//tests:test (prelude//platforms:default#904931f735703749)
-> toolchains//:test (^)
1: looking up unconfigured target node `toolchains//:test`
2: Unknown target `test` from package `toolchains//`.
Did you mean one of the 5 targets in toolchains//:BUCK?
Maybe you meant one of these similar targets?
toolchains//:rust
toolchains//:cxx
Add rules_cc as bazel_dep
warning: this `map_or` is redundant
--> gen/build/src/target.rs:31:20
|
31 | && dir
| ____________________^
32 | | .parent()
33 | | .map_or(false, |parent| parent.join("Cargo.toml").exists())
| |_______________________________________________________________________________^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_map_or
help: use is_some_and instead
|
31 ~ && dir
32 + .parent().is_some_and(|parent| parent.join("Cargo.toml").exists())
|
warning: this `map_or` is redundant
--> gen/src/write.rs:1151:5
|
1151 | / sig.ret
1152 | | .as_ref()
1153 | | .map_or(false, |ret| sig.throws || types.needs_indirect_abi(ret))
| |_________________________________________________________________________^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_map_or
= note: `-W clippy::unnecessary-map-or` implied by `-W clippy::all`
= help: to override `-W clippy::all` add `#[allow(clippy::unnecessary_map_or)]`
help: use is_some_and instead
|
1151 ~ sig.ret
1152 + .as_ref().is_some_and(|ret| sig.throws || types.needs_indirect_abi(ret))
|
warning: this `map_or` is redundant
--> macro/src/expand.rs:1837:5
|
1837 | / sig.ret
1838 | | .as_ref()
1839 | | .map_or(false, |ret| sig.throws || types.needs_indirect_abi(ret))
| |_________________________________________________________________________^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_map_or
= note: `-W clippy::unnecessary-map-or` implied by `-W clippy::all`
= help: to override `-W clippy::all` add `#[allow(clippy::unnecessary_map_or)]`
help: use is_some_and instead
|
1837 ~ sig.ret
1838 + .as_ref().is_some_and(|ret| sig.throws || types.needs_indirect_abi(ret))
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/app.rs:145:36
|
145 | return Err(format!("cannot have both {0}=false and {0}=true", name));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
= note: `-W clippy::uninlined-format-args` implied by `-W clippy::pedantic`
= help: to override `-W clippy::pedantic` add `#[allow(clippy::uninlined_format_args)]`
help: change this to
|
145 - return Err(format!("cannot have both {0}=false and {0}=true", name));
145 + return Err(format!("cannot have both {name}=false and {name}=true"));
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/cfg.rs:37:27
|
37 | let msg = format!(
| ___________________________^
38 | | "pass `--cfg {}=\"...\"` to be able to use this attribute",
39 | | name,
40 | | );
| |_________________^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/cfg.rs:50:27
|
50 | let msg = format!("the cxxbridge flags say both {0}=false and {0}=true", name);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
50 - let msg = format!("the cxxbridge flags say both {0}=false and {0}=true", name);
50 + let msg = format!("the cxxbridge flags say both {name}=false and {name}=true");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/cfg.rs:57:27
|
57 | let msg = format!(
| ___________________________^
58 | | "pass either `--cfg {0}=true` or `--cfg {0}=false` to be able to use this cfg attribute",
59 | | name,
60 | | );
| |_________________^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/error.rs:94:17
|
94 | write!(formatter, "\n\nCaused by:\n {}", cause)?;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
94 - write!(formatter, "\n\nCaused by:\n {}", cause)?;
94 + write!(formatter, "\n\nCaused by:\n {cause}")?;
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/ifndef.rs:5:18
|
5 | let ifndef = format!("#ifndef {}", guard);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
5 - let ifndef = format!("#ifndef {}", guard);
5 + let ifndef = format!("#ifndef {guard}");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/ifndef.rs:6:18
|
6 | let define = format!("#define {}", guard);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
6 - let define = format!("#define {}", guard);
6 + let define = format!("#define {guard}");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/ifndef.rs:7:17
|
7 | let endif = format!("#endif // {}", guard);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
7 - let endif = format!("#endif // {}", guard);
7 + let endif = format!("#endif // {guard}");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/ifndef.rs:19:17
|
19 | writeln!(out, "{}", ifndef);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
19 - writeln!(out, "{}", ifndef);
19 + writeln!(out, "{ifndef}");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/ifndef.rs:20:17
|
20 | writeln!(out, "{}", define);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
20 - writeln!(out, "{}", define);
20 + writeln!(out, "{define}");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/ifndef.rs:24:21
|
24 | writeln!(out, "{}", line);
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
24 - writeln!(out, "{}", line);
24 + writeln!(out, "{line}");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/ifndef.rs:29:13
|
29 | panic!("not found in cxx.h header: {}", guard)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
29 - panic!("not found in cxx.h header: {}", guard)
29 + panic!("not found in cxx.h header: {guard}")
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/ifndef.rs:31:13
|
31 | writeln!(out, "{}", endif);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
31 - writeln!(out, "{}", endif);
31 + writeln!(out, "{endif}");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:177:17
|
177 | writeln!(out, "template <> struct hash<{}> {{", qualified);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
177 - writeln!(out, "template <> struct hash<{}> {{", qualified);
177 + writeln!(out, "template <> struct hash<{qualified}> {{");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:178:17
|
178 | / writeln!(
179 | | out,
180 | | " ::std::size_t operator()({} const &self) const noexcept {{",
181 | | qualified,
182 | | );
| |_________________^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:186:21
|
186 | write!(out, "{}::", name);
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
186 - write!(out, "{}::", name);
186 + write!(out, "{name}::");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:188:17
|
188 | writeln!(out, "{}(self);", link_name);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
188 - writeln!(out, "{}(self);", link_name);
188 + writeln!(out, "{link_name}(self);");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:233:13
|
233 | writeln!(out, "{}///{}", indent, line);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
233 - writeln!(out, "{}///{}", indent, line);
233 + writeln!(out, "{indent}///{line}");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:235:13
|
235 | writeln!(out, "{}//{}", indent, line);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
235 - writeln!(out, "{}//{}", indent, line);
235 + writeln!(out, "{indent}//{line}");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:244:9
|
244 | writeln!(out, "{}///", indent);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
244 - writeln!(out, "{}///", indent);
244 + writeln!(out, "{indent}///");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:254:5
|
254 | writeln!(out, "#ifndef {}", guard);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
254 - writeln!(out, "#ifndef {}", guard);
254 + writeln!(out, "#ifndef {guard}");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:255:5
|
255 | writeln!(out, "#define {}", guard);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
255 - writeln!(out, "#define {}", guard);
255 + writeln!(out, "#define {guard}");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:324:5
|
324 | writeln!(out, "#endif // {}", guard);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
324 - writeln!(out, "#endif // {}", guard);
324 + writeln!(out, "#endif // {guard}");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:349:5
|
349 | writeln!(out, "#ifndef {}", guard);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
349 - writeln!(out, "#ifndef {}", guard);
349 + writeln!(out, "#ifndef {guard}");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:350:5
|
350 | writeln!(out, "#define {}", guard);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
350 - writeln!(out, "#define {}", guard);
350 + writeln!(out, "#define {guard}");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:388:5
|
388 | writeln!(out, "#endif // {}", guard);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
388 - writeln!(out, "#endif // {}", guard);
388 + writeln!(out, "#endif // {guard}");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:399:5
|
399 | writeln!(out, "#ifndef {}", guard);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
399 - writeln!(out, "#ifndef {}", guard);
399 + writeln!(out, "#ifndef {guard}");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:400:5
|
400 | writeln!(out, "#define {}", guard);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
400 - writeln!(out, "#define {}", guard);
400 + writeln!(out, "#define {guard}");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:410:5
|
410 | writeln!(out, "#endif // {}", guard);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
410 - writeln!(out, "#endif // {}", guard);
410 + writeln!(out, "#endif // {guard}");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:492:9
|
492 | writeln!(out, " ::rust::IsRelocatableOrArray<{}>::value,", id);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
492 - writeln!(out, " ::rust::IsRelocatableOrArray<{}>::value,", id);
492 + writeln!(out, " ::rust::IsRelocatableOrArray<{id}>::value,");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:494:9
|
494 | writeln!(out, " ::rust::IsRelocatable<{}>::value,", id);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
494 - writeln!(out, " ::rust::IsRelocatable<{}>::value,", id);
494 + writeln!(out, " ::rust::IsRelocatable<{id}>::value,");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:586:9
|
586 | writeln!(out, " return {}(*this, rhs);", link_name);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
586 - writeln!(out, " return {}(*this, rhs);", link_name);
586 + writeln!(out, " return {link_name}(*this, rhs);");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:599:13
|
599 | writeln!(out, " return {}(*this, rhs);", link_name);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
599 - writeln!(out, " return {}(*this, rhs);", link_name);
599 + writeln!(out, " return {link_name}(*this, rhs);");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:612:9
|
612 | writeln!(out, " return {}(*this, rhs);", link_name);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
612 - writeln!(out, " return {}(*this, rhs);", link_name);
612 + writeln!(out, " return {link_name}(*this, rhs);");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:622:9
|
622 | writeln!(out, " return {}(*this, rhs);", link_name);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
622 - writeln!(out, " return {}(*this, rhs);", link_name);
622 + writeln!(out, " return {link_name}(*this, rhs);");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:635:13
|
635 | writeln!(out, " return {}(*this, rhs);", link_name);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
635 - writeln!(out, " return {}(*this, rhs);", link_name);
635 + writeln!(out, " return {link_name}(*this, rhs);");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:649:13
|
649 | writeln!(out, " return {}(*this, rhs);", link_name);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
649 - writeln!(out, " return {}(*this, rhs);", link_name);
649 + writeln!(out, " return {link_name}(*this, rhs);");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:660:5
|
660 | writeln!(out, "::std::size_t {}() noexcept;", link_name);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
660 - writeln!(out, "::std::size_t {}() noexcept;", link_name);
660 + writeln!(out, "::std::size_t {link_name}() noexcept;");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:663:5
|
663 | writeln!(out, "::std::size_t {}() noexcept;", link_name);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
663 - writeln!(out, "::std::size_t {}() noexcept;", link_name);
663 + writeln!(out, "::std::size_t {link_name}() noexcept;");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:682:5
|
682 | writeln!(out, " return {}();", link_name);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
682 - writeln!(out, " return {}();", link_name);
682 + writeln!(out, " return {link_name}();");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:692:5
|
692 | writeln!(out, " return {}();", link_name);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
692 - writeln!(out, " return {}();", link_name);
692 + writeln!(out, " return {link_name}();");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:698:9
|
698 | write!(out, "{} ", annotation);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
698 - write!(out, "{} ", annotation);
698 + write!(out, "{annotation} ");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:714:5
|
714 | write!(out, "{}(", mangled);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
714 - write!(out, "{}(", mangled);
714 + write!(out, "{mangled}(");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:906:5
|
906 | write!(out, "{}(", link_name);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
906 - write!(out, "{}(", link_name);
906 + write!(out, "{link_name}(");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:977:5
|
977 | write!(out, "{}(", local_name);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
977 - write!(out, "{}(", local_name);
977 + write!(out, "{local_name}(");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1079:5
|
1079 | write!(out, "{}(", invoke);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1079 - write!(out, "{}(", invoke);
1079 + write!(out, "{invoke}(");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1438:5
|
1438 | / writeln!(
1439 | | out,
1440 | | "{} *cxxbridge1$box${}$alloc() noexcept;",
1441 | | inner, instance,
1442 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1443:5
|
1443 | / writeln!(
1444 | | out,
1445 | | "void cxxbridge1$box${}$dealloc({} *) noexcept;",
1446 | | instance, inner,
1447 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1448:5
|
1448 | / writeln!(
1449 | | out,
1450 | | "void cxxbridge1$box${}$drop(::rust::Box<{}> *ptr) noexcept;",
1451 | | instance, inner,
1452 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1462:5
|
1462 | / writeln!(
1463 | | out,
1464 | | "void cxxbridge1$rust_vec${}$new(::rust::Vec<{}> const *ptr) noexcept;",
1465 | | instance, inner,
1466 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1467:5
|
1467 | / writeln!(
1468 | | out,
1469 | | "void cxxbridge1$rust_vec${}$drop(::rust::Vec<{}> *ptr) noexcept;",
1470 | | instance, inner,
1471 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1472:5
|
1472 | / writeln!(
1473 | | out,
1474 | | "::std::size_t cxxbridge1$rust_vec${}$len(::rust::Vec<{}> const *ptr) noexcept;",
1475 | | instance, inner,
1476 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1477:5
|
1477 | / writeln!(
1478 | | out,
1479 | | "::std::size_t cxxbridge1$rust_vec${}$capacity(::rust::Vec<{}> const *ptr) noexcept;",
1480 | | instance, inner,
1481 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1482:5
|
1482 | / writeln!(
1483 | | out,
1484 | | "{} const *cxxbridge1$rust_vec${}$data(::rust::Vec<{0}> const *ptr) noexcept;",
1485 | | inner, instance,
1486 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1487:5
|
1487 | / writeln!(
1488 | | out,
1489 | | "void cxxbridge1$rust_vec${}$reserve_total(::rust::Vec<{}> *ptr, ::std::size_t new_cap) noexcept;",
1490 | | instance, inner,
1491 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1492:5
|
1492 | / writeln!(
1493 | | out,
1494 | | "void cxxbridge1$rust_vec${}$set_len(::rust::Vec<{}> *ptr, ::std::size_t len) noexcept;",
1495 | | instance, inner,
1496 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1497:5
|
1497 | / writeln!(
1498 | | out,
1499 | | "void cxxbridge1$rust_vec${}$truncate(::rust::Vec<{}> *ptr, ::std::size_t len) noexcept;",
1500 | | instance, inner,
1501 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1511:5
|
1511 | / writeln!(
1512 | | out,
1513 | | "{} *Box<{}>::allocation::alloc() noexcept {{",
1514 | | inner, inner,
1515 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1516:5
|
1516 | writeln!(out, " return cxxbridge1$box${}$alloc();", instance);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1516 - writeln!(out, " return cxxbridge1$box${}$alloc();", instance);
1516 + writeln!(out, " return cxxbridge1$box${instance}$alloc();");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1521:5
|
1521 | / writeln!(
1522 | | out,
1523 | | "void Box<{}>::allocation::dealloc({} *ptr) noexcept {{",
1524 | | inner, inner,
1525 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1526:5
|
1526 | writeln!(out, " cxxbridge1$box${}$dealloc(ptr);", instance);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1526 - writeln!(out, " cxxbridge1$box${}$dealloc(ptr);", instance);
1526 + writeln!(out, " cxxbridge1$box${instance}$dealloc(ptr);");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1531:5
|
1531 | writeln!(out, "void Box<{}>::drop() noexcept {{", inner);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1531 - writeln!(out, "void Box<{}>::drop() noexcept {{", inner);
1531 + writeln!(out, "void Box<{inner}>::drop() noexcept {{");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1532:5
|
1532 | writeln!(out, " cxxbridge1$box${}$drop(this);", instance);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1532 - writeln!(out, " cxxbridge1$box${}$drop(this);", instance);
1532 + writeln!(out, " cxxbridge1$box${instance}$drop(this);");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1545:5
|
1545 | writeln!(out, "Vec<{}>::Vec() noexcept {{", inner);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1545 - writeln!(out, "Vec<{}>::Vec() noexcept {{", inner);
1545 + writeln!(out, "Vec<{inner}>::Vec() noexcept {{");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1546:5
|
1546 | writeln!(out, " cxxbridge1$rust_vec${}$new(this);", instance);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1546 - writeln!(out, " cxxbridge1$rust_vec${}$new(this);", instance);
1546 + writeln!(out, " cxxbridge1$rust_vec${instance}$new(this);");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1551:5
|
1551 | writeln!(out, "void Vec<{}>::drop() noexcept {{", inner);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1551 - writeln!(out, "void Vec<{}>::drop() noexcept {{", inner);
1551 + writeln!(out, "void Vec<{inner}>::drop() noexcept {{");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1552:5
|
1552 | writeln!(out, " return cxxbridge1$rust_vec${}$drop(this);", instance);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1552 - writeln!(out, " return cxxbridge1$rust_vec${}$drop(this);", instance);
1552 + writeln!(out, " return cxxbridge1$rust_vec${instance}$drop(this);");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1557:5
|
1557 | / writeln!(
1558 | | out,
1559 | | "::std::size_t Vec<{}>::size() const noexcept {{",
1560 | | inner,
1561 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1562:5
|
1562 | writeln!(out, " return cxxbridge1$rust_vec${}$len(this);", instance);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1562 - writeln!(out, " return cxxbridge1$rust_vec${}$len(this);", instance);
1562 + writeln!(out, " return cxxbridge1$rust_vec${instance}$len(this);");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1567:5
|
1567 | / writeln!(
1568 | | out,
1569 | | "::std::size_t Vec<{}>::capacity() const noexcept {{",
1570 | | inner,
1571 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1572:5
|
1572 | / writeln!(
1573 | | out,
1574 | | " return cxxbridge1$rust_vec${}$capacity(this);",
1575 | | instance,
1576 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1581:5
|
1581 | writeln!(out, "{} const *Vec<{0}>::data() const noexcept {{", inner);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1581 - writeln!(out, "{} const *Vec<{0}>::data() const noexcept {{", inner);
1581 + writeln!(out, "{inner} const *Vec<{inner}>::data() const noexcept {{");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1582:5
|
1582 | writeln!(out, " return cxxbridge1$rust_vec${}$data(this);", instance);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1582 - writeln!(out, " return cxxbridge1$rust_vec${}$data(this);", instance);
1582 + writeln!(out, " return cxxbridge1$rust_vec${instance}$data(this);");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1587:5
|
1587 | / writeln!(
1588 | | out,
1589 | | "void Vec<{}>::reserve_total(::std::size_t new_cap) noexcept {{",
1590 | | inner,
1591 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1592:5
|
1592 | / writeln!(
1593 | | out,
1594 | | " return cxxbridge1$rust_vec${}$reserve_total(this, new_cap);",
1595 | | instance,
1596 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1601:5
|
1601 | / writeln!(
1602 | | out,
1603 | | "void Vec<{}>::set_len(::std::size_t len) noexcept {{",
1604 | | inner,
1605 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1606:5
|
1606 | / writeln!(
1607 | | out,
1608 | | " return cxxbridge1$rust_vec${}$set_len(this, len);",
1609 | | instance,
1610 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1615:5
|
1615 | writeln!(out, "void Vec<{}>::truncate(::std::size_t len) {{", inner,);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1615 - writeln!(out, "void Vec<{}>::truncate(::std::size_t len) {{", inner,);
1615 + writeln!(out, "void Vec<{inner}>::truncate(::std::size_t len) {{",);
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1616:5
|
1616 | / writeln!(
1617 | | out,
1618 | | " return cxxbridge1$rust_vec${}$truncate(this, len);",
1619 | | instance,
1620 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1658:9
|
1658 | / writeln!(
1659 | | out,
1660 | | "static_assert(::rust::detail::is_complete<{}>::value, \"definition of {} is required\");",
1661 | | inner, definition,
1662 | | );
| |_________^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1664:5
|
1664 | / writeln!(
1665 | | out,
1666 | | "static_assert(sizeof(::std::unique_ptr<{}>) == sizeof(void *), \"\");",
1667 | | inner,
1668 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1669:5
|
1669 | / writeln!(
1670 | | out,
1671 | | "static_assert(alignof(::std::unique_ptr<{}>) == alignof(void *), \"\");",
1672 | | inner,
1673 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1676:5
|
1676 | / writeln!(
1677 | | out,
1678 | | "void cxxbridge1$unique_ptr${}$null(::std::unique_ptr<{}> *ptr) noexcept {{",
1679 | | instance, inner,
1680 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1681:5
|
1681 | writeln!(out, " ::new (ptr) ::std::unique_ptr<{}>();", inner);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1681 - writeln!(out, " ::new (ptr) ::std::unique_ptr<{}>();", inner);
1681 + writeln!(out, " ::new (ptr) ::std::unique_ptr<{inner}>();");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1687:9
|
1687 | / writeln!(
1688 | | out,
1689 | | "{} *cxxbridge1$unique_ptr${}$uninit(::std::unique_ptr<{}> *ptr) noexcept {{",
1690 | | inner, instance, inner,
1691 | | );
| |_________^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1692:9
|
1692 | / writeln!(
1693 | | out,
1694 | | " {} *uninit = reinterpret_cast<{} *>(new ::rust::MaybeUninit<{}>);",
1695 | | inner, inner, inner,
1696 | | );
| |_________^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1697:9
|
1697 | writeln!(out, " ::new (ptr) ::std::unique_ptr<{}>(uninit);", inner);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1697 - writeln!(out, " ::new (ptr) ::std::unique_ptr<{}>(uninit);", inner);
1697 + writeln!(out, " ::new (ptr) ::std::unique_ptr<{inner}>(uninit);");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1703:5
|
1703 | / writeln!(
1704 | | out,
1705 | | "void cxxbridge1$unique_ptr${}$raw(::std::unique_ptr<{}> *ptr, {} *raw) noexcept {{",
1706 | | instance, inner, inner,
1707 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1708:5
|
1708 | writeln!(out, " ::new (ptr) ::std::unique_ptr<{}>(raw);", inner);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1708 - writeln!(out, " ::new (ptr) ::std::unique_ptr<{}>(raw);", inner);
1708 + writeln!(out, " ::new (ptr) ::std::unique_ptr<{inner}>(raw);");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1712:5
|
1712 | / writeln!(
1713 | | out,
1714 | | "{} const *cxxbridge1$unique_ptr${}$get(::std::unique_ptr<{}> const &ptr) noexcept {{",
1715 | | inner, instance, inner,
1716 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1721:5
|
1721 | / writeln!(
1722 | | out,
1723 | | "{} *cxxbridge1$unique_ptr${}$release(::std::unique_ptr<{}> &ptr) noexcept {{",
1724 | | inner, instance, inner,
1725 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1730:5
|
1730 | / writeln!(
1731 | | out,
1732 | | "void cxxbridge1$unique_ptr${}$drop(::std::unique_ptr<{}> *ptr) noexcept {{",
1733 | | instance, inner,
1734 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1737:9
|
1737 | / writeln!(
1738 | | out,
1739 | | " ::rust::deleter_if<::rust::detail::is_complete<{}>::value>{{}}(ptr);",
1740 | | inner,
1741 | | );
| |_________^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1763:5
|
1763 | / writeln!(
1764 | | out,
1765 | | "static_assert(sizeof(::std::shared_ptr<{}>) == 2 * sizeof(void *), \"\");",
1766 | | inner,
1767 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1768:5
|
1768 | / writeln!(
1769 | | out,
1770 | | "static_assert(alignof(::std::shared_ptr<{}>) == alignof(void *), \"\");",
1771 | | inner,
1772 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1775:5
|
1775 | / writeln!(
1776 | | out,
1777 | | "void cxxbridge1$shared_ptr${}$null(::std::shared_ptr<{}> *ptr) noexcept {{",
1778 | | instance, inner,
1779 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1780:5
|
1780 | writeln!(out, " ::new (ptr) ::std::shared_ptr<{}>();", inner);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1780 - writeln!(out, " ::new (ptr) ::std::shared_ptr<{}>();", inner);
1780 + writeln!(out, " ::new (ptr) ::std::shared_ptr<{inner}>();");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1786:9
|
1786 | / writeln!(
1787 | | out,
1788 | | "{} *cxxbridge1$shared_ptr${}$uninit(::std::shared_ptr<{}> *ptr) noexcept {{",
1789 | | inner, instance, inner,
1790 | | );
| |_________^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1791:9
|
1791 | / writeln!(
1792 | | out,
1793 | | " {} *uninit = reinterpret_cast<{} *>(new ::rust::MaybeUninit<{}>);",
1794 | | inner, inner, inner,
1795 | | );
| |_________^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1796:9
|
1796 | writeln!(out, " ::new (ptr) ::std::shared_ptr<{}>(uninit);", inner);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1796 - writeln!(out, " ::new (ptr) ::std::shared_ptr<{}>(uninit);", inner);
1796 + writeln!(out, " ::new (ptr) ::std::shared_ptr<{inner}>(uninit);");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1802:5
|
1802 | / writeln!(
1803 | | out,
1804 | | "void cxxbridge1$shared_ptr${}$clone(::std::shared_ptr<{}> const &self, ::std::shared_ptr<{}> *ptr)...
1805 | | instance, inner, inner,
1806 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1807:5
|
1807 | writeln!(out, " ::new (ptr) ::std::shared_ptr<{}>(self);", inner);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1807 - writeln!(out, " ::new (ptr) ::std::shared_ptr<{}>(self);", inner);
1807 + writeln!(out, " ::new (ptr) ::std::shared_ptr<{inner}>(self);");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1811:5
|
1811 | / writeln!(
1812 | | out,
1813 | | "{} const *cxxbridge1$shared_ptr${}$get(::std::shared_ptr<{}> const &self) noexcept {{",
1814 | | inner, instance, inner,
1815 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1820:5
|
1820 | / writeln!(
1821 | | out,
1822 | | "void cxxbridge1$shared_ptr${}$drop(::std::shared_ptr<{}> *self) noexcept {{",
1823 | | instance, inner,
1824 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1837:5
|
1837 | / writeln!(
1838 | | out,
1839 | | "static_assert(sizeof(::std::weak_ptr<{}>) == 2 * sizeof(void *), \"\");",
1840 | | inner,
1841 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1842:5
|
1842 | / writeln!(
1843 | | out,
1844 | | "static_assert(alignof(::std::weak_ptr<{}>) == alignof(void *), \"\");",
1845 | | inner,
1846 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1849:5
|
1849 | / writeln!(
1850 | | out,
1851 | | "void cxxbridge1$weak_ptr${}$null(::std::weak_ptr<{}> *ptr) noexcept {{",
1852 | | instance, inner,
1853 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1854:5
|
1854 | writeln!(out, " ::new (ptr) ::std::weak_ptr<{}>();", inner);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1854 - writeln!(out, " ::new (ptr) ::std::weak_ptr<{}>();", inner);
1854 + writeln!(out, " ::new (ptr) ::std::weak_ptr<{inner}>();");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1858:5
|
1858 | / writeln!(
1859 | | out,
1860 | | "void cxxbridge1$weak_ptr${}$clone(::std::weak_ptr<{}> const &self, ::std::weak_ptr<{}> *ptr) noexc...
1861 | | instance, inner, inner,
1862 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1863:5
|
1863 | writeln!(out, " ::new (ptr) ::std::weak_ptr<{}>(self);", inner);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1863 - writeln!(out, " ::new (ptr) ::std::weak_ptr<{}>(self);", inner);
1863 + writeln!(out, " ::new (ptr) ::std::weak_ptr<{inner}>(self);");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1867:5
|
1867 | / writeln!(
1868 | | out,
1869 | | "void cxxbridge1$weak_ptr${}$downgrade(::std::shared_ptr<{}> const &shared, ::std::weak_ptr<{}> *we...
1870 | | instance, inner, inner,
1871 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1872:5
|
1872 | writeln!(out, " ::new (weak) ::std::weak_ptr<{}>(shared);", inner);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1872 - writeln!(out, " ::new (weak) ::std::weak_ptr<{}>(shared);", inner);
1872 + writeln!(out, " ::new (weak) ::std::weak_ptr<{inner}>(shared);");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1876:5
|
1876 | / writeln!(
1877 | | out,
1878 | | "void cxxbridge1$weak_ptr${}$upgrade(::std::weak_ptr<{}> const &weak, ::std::shared_ptr<{}> *shared...
1879 | | instance, inner, inner,
1880 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1881:5
|
1881 | / writeln!(
1882 | | out,
1883 | | " ::new (shared) ::std::shared_ptr<{}>(weak.lock());",
1884 | | inner,
1885 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1889:5
|
1889 | / writeln!(
1890 | | out,
1891 | | "void cxxbridge1$weak_ptr${}$drop(::std::weak_ptr<{}> *self) noexcept {{",
1892 | | instance, inner,
1893 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1908:5
|
1908 | / writeln!(
1909 | | out,
1910 | | "::std::vector<{}> *cxxbridge1$std$vector${}$new() noexcept {{",
1911 | | inner, instance,
1912 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1913:5
|
1913 | writeln!(out, " return new ::std::vector<{}>();", inner);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
help: change this to
|
1913 - writeln!(out, " return new ::std::vector<{}>();", inner);
1913 + writeln!(out, " return new ::std::vector<{inner}>();");
|
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1917:5
|
1917 | / writeln!(
1918 | | out,
1919 | | "::std::size_t cxxbridge1$std$vector${}$size(::std::vector<{}> const &s) noexcept {{",
1920 | | instance, inner,
1921 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1926:5
|
1926 | / writeln!(
1927 | | out,
1928 | | "{} *cxxbridge1$std$vector${}$get_unchecked(::std::vector<{}> *s, ::std::size_t pos) noexcept {{",
1929 | | inner, instance, inner,
1930 | | );
| |_____^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1936:9
|
1936 | / writeln!(
1937 | | out,
1938 | | "void cxxbridge1$std$vector${}$push_back(::std::vector<{}> *v, {} *value) noexcept {{",
1939 | | instance, inner, inner,
1940 | | );
| |_________^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1946:9
|
1946 | / writeln!(
1947 | | out,
1948 | | "void cxxbridge1$std$vector${}$pop_back(::std::vector<{}> *v, {} *out) noexcept {{",
1949 | | instance, inner, inner,
1950 | | );
| |_________^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#uninlined_format_args
warning: variables can be used directly in the `format!` string
--> gen/cmd/src/gen/write.rs:1951:9
|
1951 | writeln!(out, " ::new (out) {}(::std::move(v->back()));", inner);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html…
Touch up asset publish workflow
Include Bazel on Windows in lockfile verification
Buildifier is fine with it either way.
Account for source tar filepaths surpassing xargs size limit
Do not apply tar transform to symbolic link targets
Not immediately relevant to cxx but could be important if someone replicates this action in a different repo.
Make source tars deterministic and reproducible
Update codespan-reporting to 0.12
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Rebase onto master from dtolnay/cxx