[INFO] fetching crate breakpad-rs 0.2.0... [INFO] checking breakpad-rs-0.2.0 against try#65132f36b923285d5da381c2fbafee6ce899e841 for pr-132712-1 [INFO] extracting crate breakpad-rs 0.2.0 into /workspace/builds/worker-7-tc2/source [INFO] validating manifest of crates.io crate breakpad-rs 0.2.0 on toolchain 65132f36b923285d5da381c2fbafee6ce899e841 [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+65132f36b923285d5da381c2fbafee6ce899e841" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }` [INFO] removed /workspace/builds/worker-7-tc2/source/rust-toolchain.toml [INFO] started tweaking crates.io crate breakpad-rs 0.2.0 [INFO] removed 0 missing examples [INFO] finished tweaking crates.io crate breakpad-rs 0.2.0 [INFO] tweaked toml for crates.io crate breakpad-rs 0.2.0 written to /workspace/builds/worker-7-tc2/source/Cargo.toml [INFO] crate crates.io crate breakpad-rs 0.2.0 already has a lockfile, it will not be regenerated [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+65132f36b923285d5da381c2fbafee6ce899e841" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:4a844ea9eb2546a2d2c7022eacef16ef2e8229c7fbb2c7d4d55a9ceca922f72d" "/opt/rustwide/cargo-home/bin/cargo" "+65132f36b923285d5da381c2fbafee6ce899e841" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] [stdout] 634b9cd6853b14faf9def77dca180da1e7b8f192ddda1dbf8c10667bc1b89b85 [INFO] running `Command { std: "docker" "start" "-a" "634b9cd6853b14faf9def77dca180da1e7b8f192ddda1dbf8c10667bc1b89b85", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "634b9cd6853b14faf9def77dca180da1e7b8f192ddda1dbf8c10667bc1b89b85", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "634b9cd6853b14faf9def77dca180da1e7b8f192ddda1dbf8c10667bc1b89b85", kill_on_drop: false }` [INFO] [stdout] 634b9cd6853b14faf9def77dca180da1e7b8f192ddda1dbf8c10667bc1b89b85 [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=allow" "-e" "RUSTDOCFLAGS=--cap-lints=allow" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:4a844ea9eb2546a2d2c7022eacef16ef2e8229c7fbb2c7d4d55a9ceca922f72d" "/opt/rustwide/cargo-home/bin/cargo" "+65132f36b923285d5da381c2fbafee6ce899e841" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }` [INFO] [stdout] 2b7b71ef0bde5b2a0243e838bde327346519d701062670f2f4e3f4e498209a3c [INFO] running `Command { std: "docker" "start" "-a" "2b7b71ef0bde5b2a0243e838bde327346519d701062670f2f4e3f4e498209a3c", kill_on_drop: false }` [INFO] [stderr] Copying to /tmp/fixit [INFO] [stderr] Running `cargo fix --edition` [INFO] [stderr] Migrating Cargo.toml from 2021 edition to 2024 [INFO] [stderr] Compiling proc-macro2 v1.0.88 [INFO] [stderr] Compiling memchr v2.7.4 [INFO] [stderr] Compiling libc v0.2.161 [INFO] [stderr] Compiling serde v1.0.210 [INFO] [stderr] Compiling thiserror v1.0.64 [INFO] [stderr] Compiling serde_json v1.0.131 [INFO] [stderr] Compiling log v0.4.22 [INFO] [stderr] Compiling cc v1.1.30 [INFO] [stderr] Compiling proc-macro-error-attr v1.0.4 [INFO] [stderr] Compiling indexmap v1.9.3 [INFO] [stderr] Compiling proc-macro-error v1.0.4 [INFO] [stderr] Compiling clang-sys v1.8.1 [INFO] [stderr] Compiling regex-syntax v0.8.5 [INFO] [stderr] Compiling gimli v0.31.1 [INFO] [stderr] Compiling itoa v1.0.11 [INFO] [stderr] Compiling ryu v1.0.18 [INFO] [stderr] Compiling unicode-width v0.1.14 [INFO] [stderr] Compiling adler2 v2.0.0 [INFO] [stderr] Compiling rustc-demangle v0.1.24 [INFO] [stderr] Compiling termcolor v1.4.1 [INFO] [stderr] Compiling rustix v0.38.37 [INFO] [stderr] Compiling miniz_oxide v0.8.0 [INFO] [stderr] Compiling cxxbridge-flags v1.0.129 [INFO] [stderr] Compiling minimal-lexical v0.2.1 [INFO] [stderr] Compiling libloading v0.8.5 [INFO] [stderr] Compiling itertools v0.9.0 [INFO] [stderr] Compiling is_ci v1.2.0 [INFO] [stderr] Compiling prettyplease v0.2.22 [INFO] [stderr] Compiling autocxx-bindgen v0.69.5 [INFO] [stderr] Compiling unicode-linebreak v0.1.5 [INFO] [stderr] Compiling smawk v0.3.2 [INFO] [stderr] Compiling codespan-reporting v0.11.1 [INFO] [stderr] Compiling itertools v0.13.0 [INFO] [stderr] Compiling rustc-hash v1.1.0 [INFO] [stderr] Compiling aho-corasick v1.1.3 [INFO] [stderr] Compiling object v0.36.5 [INFO] [stderr] Compiling nom v7.1.3 [INFO] [stderr] Compiling textwrap v0.15.2 [INFO] [stderr] Compiling owo-colors v3.5.0 [INFO] [stderr] Compiling fastrand v2.1.1 [INFO] [stderr] Compiling indoc v1.0.9 [INFO] [stderr] Compiling quote v1.0.37 [INFO] [stderr] Compiling humantime v2.1.0 [INFO] [stderr] Compiling syn v2.0.79 [INFO] [stderr] Compiling syn v1.0.109 [INFO] [stderr] Compiling is-terminal v0.4.13 [INFO] [stderr] Compiling terminal_size v0.1.17 [INFO] [stderr] Compiling supports-color v2.1.0 [INFO] [stderr] Compiling supports-hyperlinks v2.1.0 [INFO] [stderr] Compiling supports-unicode v2.1.0 [INFO] [stderr] Compiling atty v0.2.14 [INFO] [stderr] Compiling autocxx v0.27.0 [INFO] [stderr] Compiling link-cplusplus v1.0.9 [INFO] [stderr] Compiling cxx v1.0.129 [INFO] [stderr] Compiling regex-automata v0.4.8 [INFO] [stderr] Compiling cexpr v0.6.0 [INFO] [stderr] Compiling addr2line v0.24.2 [INFO] [stderr] Compiling tempfile v3.13.0 [INFO] [stderr] Compiling aquamarine v0.1.12 [INFO] [stderr] Compiling backtrace v0.3.74 [INFO] [stderr] Compiling regex v1.11.0 [INFO] [stderr] Compiling cxx-gen v0.7.129 [INFO] [stderr] Compiling env_logger v0.9.3 [INFO] [stderr] Compiling backtrace-ext v0.2.1 [INFO] [stderr] Compiling serde_derive v1.0.210 [INFO] [stderr] Compiling thiserror-impl v1.0.64 [INFO] [stderr] Compiling miette-derive v5.10.0 [INFO] [stderr] Compiling cxxbridge-macro v1.0.129 [INFO] [stderr] Compiling miette v5.10.0 [INFO] [stderr] Checking moveit v0.6.0 [INFO] [stderr] Compiling autocxx-parser v0.27.0 [INFO] [stderr] Compiling autocxx-engine v0.27.0 [INFO] [stderr] Compiling autocxx-macro v0.27.0 [INFO] [stderr] Compiling autocxx-build v0.27.0 [INFO] [stderr] Compiling breakpad-rs v0.2.0 (/tmp/fixit) [INFO] [stderr] Migrating build.rs from 2021 edition to 2024 [INFO] [stderr] Migrating src/lib.rs from 2021 edition to 2024 [INFO] [stderr] warning: failed to automatically apply fixes suggested by rustc to crate `breakpad_rs` [INFO] [stderr] [INFO] [stderr] after fixes were automatically applied the compiler reported errors within these files: [INFO] [stderr] [INFO] [stderr] * /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs [INFO] [stderr] * src/lib.rs [INFO] [stderr] [INFO] [stderr] This likely indicates a bug in either rustc or cargo itself, [INFO] [stderr] and we would appreciate a bug report! You're likely to see [INFO] [stderr] a number of compiler warnings after this message which cargo [INFO] [stderr] attempted to fix but failed. If you could open an issue at [INFO] [stderr] https://github.com/rust-lang/rust/issues [INFO] [stderr] quoting the full output of this command we'd be very appreciative! [INFO] [stderr] Note that you may be able to make some more progress in the near-term [INFO] [stderr] fixing code with the `--broken-code` flag [INFO] [stderr] [INFO] [stderr] The following errors were reported: [INFO] [stderr] error: expected one of `!`, `+`, `::`, `;`, `where`, or `{`, found keyword `unsafe` [INFO] [stderr] --> src/lib.rs:20:48 [INFO] [stderr] | [INFO] [stderr] 14 | unsafe extern "C++" { [INFO] [stderr] | - while parsing this item list starting here [INFO] [stderr] ... [INFO] [stderr] 20 | ) -> UniquePtrunsafe ; [INFO] [stderr] | ^^^^^^ expected one of `!`, `+`, `::`, `;`, `where`, or `{` [INFO] [stderr] 21 | } [INFO] [stderr] | - the item list ends here [INFO] [stderr] [INFO] [stderr] error: expected type, found keyword `unsafe` [INFO] [stderr] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8324 [INFO] [stderr] | [INFO] [stderr] 1 | ...e { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > unsafe { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > unsafe { } im... [INFO] [stderr] | ^^^^^^ expected type [INFO] [stderr] [INFO] [stderr] error: expected `;` [INFO] [stderr] --> src/lib.rs:20:48 [INFO] [stderr] | [INFO] [stderr] 20 | ) -> UniquePtrunsafe ; [INFO] [stderr] | ^^^^^^ [INFO] [stderr] [INFO] [stderr] error[E0432]: unresolved import `ffi` [INFO] [stderr] --> src/lib.rs:4:5 [INFO] [stderr] | [INFO] [stderr] 4 | use ffi::ToCppString; [INFO] [stderr] | ^^^ help: a similar path exists: `std::ffi` [INFO] [stderr] [INFO] [stderr] error[E0433]: failed to resolve: use of undeclared crate or module `ffi` [INFO] [stderr] --> src/lib.rs:46:6 [INFO] [stderr] | [INFO] [stderr] 46 | impl ffi::breakpad::ExceptionHandlerDelegate_methods for ExceptionHandlerDelegateBridge { [INFO] [stderr] | ^^^ use of undeclared crate or module `ffi` [INFO] [stderr] [INFO] [stderr] error[E0433]: failed to resolve: use of undeclared crate or module `ffi` [INFO] [stderr] --> src/lib.rs:26:1 [INFO] [stderr] | [INFO] [stderr] 26 | #[subclass(superclass("breakpad::ExceptionHandlerDelegate"))] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ use of undeclared crate or module `ffi` [INFO] [stderr] | [INFO] [stderr] = note: this error originates in the attribute macro `subclass` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] [INFO] [stderr] error[E0433]: failed to resolve: use of undeclared crate or module `breakpad` [INFO] [stderr] --> src/lib.rs:79:39 [INFO] [stderr] | [INFO] [stderr] 79 | exception_handler: cxx::UniquePtr, [INFO] [stderr] | ^^^^^^^^ use of undeclared crate or module `breakpad` [INFO] [stderr] [INFO] [stderr] error[E0433]: failed to resolve: use of undeclared crate or module `breakpad` [INFO] [stderr] --> src/lib.rs:87:32 [INFO] [stderr] | [INFO] [stderr] 87 | exception_handler: breakpad::CreateExceptionHandler(bridge.as_ref().borrow().as_ref()), [INFO] [stderr] | ^^^^^^^^ [INFO] [stderr] | | [INFO] [stderr] | use of undeclared crate or module `breakpad` [INFO] [stderr] | help: a struct with a similar name exists: `Breakpad` [INFO] [stderr] [INFO] [stderr] error: aborting due to 8 previous errors [INFO] [stderr] [INFO] [stderr] Some errors have detailed explanations: E0432, E0433. [INFO] [stderr] For more information about an error, try `rustc --explain E0432`. [INFO] [stderr] Original diagnostics will follow. [INFO] [stderr] [INFO] [stdout] warning: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10746 [INFO] [stdout] | [INFO] [stdout] 1 | ...fi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Bo... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123757 [INFO] [stdout] = note: `--force-warn unsafe-attr-outside-unsafe` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type Exunsafe(ceptionHandlerDelegateBridgeHolde)r ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10936 [INFO] [stdout] | [INFO] [stdout] 1 | ...r >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f3... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123757 [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > unsafe(;) fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:11127 [INFO] [stdout] | [INFO] [stdout] 1 | ...king_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123757 [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) unsafe(;) fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:11286 [INFO] [stdout] | [INFO] [stdout] 1 | ...dlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe908895... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123757 [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > unsafe(;) fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:11431 [INFO] [stdout] | [INFO] [stdout] 1 | ...me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autoc... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123757 [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool unsafe(;) } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10627 [INFO] [stdout] | [INFO] [stdout] 1 | ... , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123757 [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder unsafe(>)) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8648 [INFO] [stdout] | [INFO] [stdout] 1 | ..._ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f39193... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] = note: `--force-warn missing-unsafe-on-extern` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8793 [INFO] [stdout] | [INFO] [stdout] 1 | ...mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8940 [INFO] [stdout] | [INFO] [stdout] 1 | ...ut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9082 [INFO] [stdout] | [INFO] [stdout] 1 | ... & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHand... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9190 [INFO] [stdout] | [INFO] [stdout] 1 | ...dgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) ->... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9326 [INFO] [stdout] | [INFO] [stdout] 1 | ...in < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < Ex... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9499 [INFO] [stdout] | [INFO] [stdout] 1 | ...niquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> ... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9626 [INFO] [stdout] | [INFO] [stdout] 1 | ... () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 :... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9755 [INFO] [stdout] | [INFO] [stdout] 1 | ...rg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wra... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9980 [INFO] [stdout] | [INFO] [stdout] 1 | ...xxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandle... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10114 [INFO] [stdout] | [INFO] [stdout] 1 | ...rDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionH... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10234 [INFO] [stdout] | [INFO] [stdout] 1 | ...: & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10373 [INFO] [stdout] | [INFO] [stdout] 1 | ...his : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_n... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10630 [INFO] [stdout] | [INFO] [stdout] 1 | ...ceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } exter... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8284 [INFO] [stdout] | [INFO] [stdout] 1 | ...< ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDele... [INFO] [stdout] | -^^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8341 [INFO] [stdout] | [INFO] [stdout] 1 | ...< ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDele... [INFO] [stdout] | -^^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8396 [INFO] [stdout] | [INFO] [stdout] 1 | ...< ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > ... [INFO] [stdout] | -^^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8444 [INFO] [stdout] | [INFO] [stdout] 1 | ...niquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { ... [INFO] [stdout] | -^^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8492 [INFO] [stdout] | [INFO] [stdout] 1 | ...haredPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0... [INFO] [stdout] | -^^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8538 [INFO] [stdout] | [INFO] [stdout] 1 | ... WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr ... [INFO] [stdout] | -^^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> src/lib.rs:20:41 [INFO] [stdout] | [INFO] [stdout] 20 | ) -> UniquePtr; [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> src/lib.rs:20:40 [INFO] [stdout] | [INFO] [stdout] 20 | ) -> UniquePtr; [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `ffi::cxxbridge::ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c` is unsafe and requires unsafe block [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:5842 [INFO] [stdout] | [INFO] [stdout] 1 | ...Cpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialize... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:5741 [INFO] [stdout] | [INFO] [stdout] 1 | ...legateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: Ex... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] = note: `--force-warn unsafe-op-in-unsafe-fn` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `ffi::cxxbridge::ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c` is unsafe and requires unsafe block [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:6043 [INFO] [stdout] | [INFO] [stdout] 1 | ...) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [al... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:5943 [INFO] [stdout] | [INFO] [stdout] 1 | ...8953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: Exc... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `ffi::cxxbridge::ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c` is unsafe and requires unsafe block [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:7360 [INFO] [stdout] | [INFO] [stdout] 1 | ...elegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:7256 [INFO] [stdout] | [INFO] [stdout] 1 | ...ndlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: E... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `ffi::cxxbridge::ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c` is unsafe and requires unsafe block [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:7555 [INFO] [stdout] | [INFO] [stdout] 1 | ...egate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakp... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:7452 [INFO] [stdout] | [INFO] [stdout] 1 | ...953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: E... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] For more information about this error, try `rustc --explain E0133`. [INFO] [stdout] [INFO] [stderr] Migrating examples/crash.rs from 2021 edition to 2024 [INFO] [stderr] warning: failed to automatically apply fixes suggested by rustc to crate `breakpad_rs` [INFO] [stderr] [INFO] [stderr] after fixes were automatically applied the compiler reported errors within these files: [INFO] [stderr] [INFO] [stderr] * /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs [INFO] [stderr] * src/lib.rs [INFO] [stderr] [INFO] [stderr] This likely indicates a bug in either rustc or cargo itself, [INFO] [stderr] and we would appreciate a bug report! You're likely to see [INFO] [stderr] a number of compiler warnings after this message which cargo [INFO] [stderr] attempted to fix but failed. If you could open an issue at [INFO] [stderr] https://github.com/rust-lang/rust/issues [INFO] [stderr] quoting the full output of this command we'd be very appreciative! [INFO] [stderr] Note that you may be able to make some more progress in the near-term [INFO] [stderr] fixing code with the `--broken-code` flag [INFO] [stderr] [INFO] [stderr] The following errors were reported: [INFO] [stderr] error: expected one of `!`, `+`, `::`, `;`, `where`, or `{`, found keyword `unsafe` [INFO] [stderr] --> src/lib.rs:20:48 [INFO] [stderr] | [INFO] [stderr] 14 | unsafe extern "C++" { [INFO] [stderr] | - while parsing this item list starting here [INFO] [stderr] ... [INFO] [stderr] 20 | ) -> UniquePtrunsafe ; [INFO] [stderr] | ^^^^^^ expected one of `!`, `+`, `::`, `;`, `where`, or `{` [INFO] [stderr] 21 | } [INFO] [stderr] | - the item list ends here [INFO] [stderr] [INFO] [stderr] error: expected type, found keyword `unsafe` [INFO] [stderr] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8324 [INFO] [stderr] | [INFO] [stderr] 1 | ...e { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > unsafe { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > unsafe { } im... [INFO] [stderr] | ^^^^^^ expected type [INFO] [stderr] [INFO] [stderr] error: expected `;` [INFO] [stderr] --> src/lib.rs:20:48 [INFO] [stderr] | [INFO] [stderr] 20 | ) -> UniquePtrunsafe ; [INFO] [stderr] | ^^^^^^ [INFO] [stderr] [INFO] [stderr] error[E0432]: unresolved import `ffi` [INFO] [stderr] --> src/lib.rs:4:5 [INFO] [stderr] | [INFO] [stderr] 4 | use ffi::ToCppString; [INFO] [stderr] | ^^^ help: a similar path exists: `std::ffi` [INFO] [stderr] [INFO] [stderr] error[E0433]: failed to resolve: use of undeclared crate or module `ffi` [INFO] [stderr] --> src/lib.rs:46:6 [INFO] [stderr] | [INFO] [stderr] 46 | impl ffi::breakpad::ExceptionHandlerDelegate_methods for ExceptionHandlerDelegateBridge { [INFO] [stderr] | ^^^ use of undeclared crate or module `ffi` [INFO] [stderr] [INFO] [stderr] error[E0433]: failed to resolve: use of undeclared crate or module `ffi` [INFO] [stderr] --> src/lib.rs:26:1 [INFO] [stderr] | [INFO] [stderr] 26 | #[subclass(superclass("breakpad::ExceptionHandlerDelegate"))] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ use of undeclared crate or module `ffi` [INFO] [stderr] | [INFO] [stderr] = note: this error originates in the attribute macro `subclass` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] [INFO] [stderr] error[E0433]: failed to resolve: use of undeclared crate or module `breakpad` [INFO] [stderr] --> src/lib.rs:79:39 [INFO] [stderr] | [INFO] [stderr] 79 | exception_handler: cxx::UniquePtr, [INFO] [stderr] | ^^^^^^^^ use of undeclared crate or module `breakpad` [INFO] [stderr] [INFO] [stderr] error[E0433]: failed to resolve: use of undeclared crate or module `breakpad` [INFO] [stderr] --> src/lib.rs:87:32 [INFO] [stderr] | [INFO] [stderr] 87 | exception_handler: breakpad::CreateExceptionHandler(bridge.as_ref().borrow().as_ref()), [INFO] [stderr] | ^^^^^^^^ [INFO] [stderr] | | [INFO] [stderr] | use of undeclared crate or module `breakpad` [INFO] [stderr] | help: a struct with a similar name exists: `Breakpad` [INFO] [stderr] [INFO] [stderr] error: aborting due to 8 previous errors [INFO] [stderr] [INFO] [stderr] Some errors have detailed explanations: E0432, E0433. [INFO] [stderr] For more information about an error, try `rustc --explain E0432`. [INFO] [stderr] Original diagnostics will follow. [INFO] [stderr] [INFO] [stdout] warning: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10746 [INFO] [stdout] | [INFO] [stdout] 1 | ...fi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Bo... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123757 [INFO] [stdout] = note: `--force-warn unsafe-attr-outside-unsafe` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type Exunsafe(ceptionHandlerDelegateBridgeHolde)r ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10936 [INFO] [stdout] | [INFO] [stdout] 1 | ...r >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f3... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123757 [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > unsafe(;) fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:11127 [INFO] [stdout] | [INFO] [stdout] 1 | ...king_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123757 [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) unsafe(;) fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:11286 [INFO] [stdout] | [INFO] [stdout] 1 | ...dlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe908895... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123757 [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > unsafe(;) fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:11431 [INFO] [stdout] | [INFO] [stdout] 1 | ...me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autoc... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123757 [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool unsafe(;) } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10627 [INFO] [stdout] | [INFO] [stdout] 1 | ... , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123757 [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder unsafe(>)) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8648 [INFO] [stdout] | [INFO] [stdout] 1 | ..._ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f39193... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] = note: `--force-warn missing-unsafe-on-extern` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8793 [INFO] [stdout] | [INFO] [stdout] 1 | ...mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8940 [INFO] [stdout] | [INFO] [stdout] 1 | ...ut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9082 [INFO] [stdout] | [INFO] [stdout] 1 | ... & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHand... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9190 [INFO] [stdout] | [INFO] [stdout] 1 | ...dgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) ->... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9326 [INFO] [stdout] | [INFO] [stdout] 1 | ...in < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < Ex... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9499 [INFO] [stdout] | [INFO] [stdout] 1 | ...niquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> ... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9626 [INFO] [stdout] | [INFO] [stdout] 1 | ... () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 :... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9755 [INFO] [stdout] | [INFO] [stdout] 1 | ...rg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wra... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9980 [INFO] [stdout] | [INFO] [stdout] 1 | ...xxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandle... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10114 [INFO] [stdout] | [INFO] [stdout] 1 | ...rDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionH... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10234 [INFO] [stdout] | [INFO] [stdout] 1 | ...: & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10373 [INFO] [stdout] | [INFO] [stdout] 1 | ...his : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_n... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10630 [INFO] [stdout] | [INFO] [stdout] 1 | ...ceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } exter... [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8284 [INFO] [stdout] | [INFO] [stdout] 1 | ...< ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDele... [INFO] [stdout] | -^^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8341 [INFO] [stdout] | [INFO] [stdout] 1 | ...< ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDele... [INFO] [stdout] | -^^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8396 [INFO] [stdout] | [INFO] [stdout] 1 | ...< ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > ... [INFO] [stdout] | -^^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8444 [INFO] [stdout] | [INFO] [stdout] 1 | ...niquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { ... [INFO] [stdout] | -^^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8492 [INFO] [stdout] | [INFO] [stdout] 1 | ...haredPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0... [INFO] [stdout] | -^^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8538 [INFO] [stdout] | [INFO] [stdout] 1 | ... WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr ... [INFO] [stdout] | -^^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> src/lib.rs:20:41 [INFO] [stdout] | [INFO] [stdout] 20 | ) -> UniquePtr; [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: extern blocks should be unsafe [INFO] [stdout] --> src/lib.rs:20:40 [INFO] [stdout] | [INFO] [stdout] 20 | ) -> UniquePtr; [INFO] [stdout] | ^ [INFO] [stdout] | | [INFO] [stdout] | help: needs `unsafe` before the extern keyword: `unsafe` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123743 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `ffi::cxxbridge::ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c` is unsafe and requires unsafe block [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:5842 [INFO] [stdout] | [INFO] [stdout] 1 | ...Cpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialize... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:5741 [INFO] [stdout] | [INFO] [stdout] 1 | ...legateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: Ex... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] = note: `--force-warn unsafe-op-in-unsafe-fn` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `ffi::cxxbridge::ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c` is unsafe and requires unsafe block [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:6043 [INFO] [stdout] | [INFO] [stdout] 1 | ...) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [al... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:5943 [INFO] [stdout] | [INFO] [stdout] 1 | ...8953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: Exc... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `ffi::cxxbridge::ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c` is unsafe and requires unsafe block [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:7360 [INFO] [stdout] | [INFO] [stdout] 1 | ...elegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:7256 [INFO] [stdout] | [INFO] [stdout] 1 | ...ndlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: E... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `ffi::cxxbridge::ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c` is unsafe and requires unsafe block [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:7555 [INFO] [stdout] | [INFO] [stdout] 1 | ...egate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakp... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:7452 [INFO] [stdout] | [INFO] [stdout] 1 | ...953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: E... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] For more information about this error, try `rustc --explain E0133`. [INFO] [stdout] [INFO] [stderr] Finished `dev` profile [unoptimized + debuginfo] target(s) in 21.46s [INFO] [stderr] Running `cargo check` to verify 2024 [INFO] [stderr] Compiling breakpad-rs v0.2.0 (/tmp/fixit) [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8648 [INFO] [stdout] | [INFO] [stdout] 1 | ...ring_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_auto... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8793 [INFO] [stdout] | [INFO] [stdout] 1 | ..._0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autoc... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8940 [INFO] [stdout] | [INFO] [stdout] 1 | ...e9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelega... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8648 [INFO] [stdout] | [INFO] [stdout] 1 | ...ring_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_auto... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9082 [INFO] [stdout] | [INFO] [stdout] 1 | ...Cpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateB... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8793 [INFO] [stdout] | [INFO] [stdout] 1 | ..._0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autoc... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9190 [INFO] [stdout] | [INFO] [stdout] 1 | ... ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHa... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8940 [INFO] [stdout] | [INFO] [stdout] 1 | ...e9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelega... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9326 [INFO] [stdout] | [INFO] [stdout] 1 | ...lerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_U... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9082 [INFO] [stdout] | [INFO] [stdout] 1 | ...Cpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateB... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9499 [INFO] [stdout] | [INFO] [stdout] 1 | ...lerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapp... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9190 [INFO] [stdout] | [INFO] [stdout] 1 | ... ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHa... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9626 [INFO] [stdout] | [INFO] [stdout] 1 | ...x_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrappe... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9755 [INFO] [stdout] | [INFO] [stdout] 1 | ...rapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn ... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9326 [INFO] [stdout] | [INFO] [stdout] 1 | ...lerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_U... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9980 [INFO] [stdout] | [INFO] [stdout] 1 | ...elegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9499 [INFO] [stdout] | [INFO] [stdout] 1 | ...lerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapp... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10114 [INFO] [stdout] | [INFO] [stdout] 1 | ...gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (aut... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9626 [INFO] [stdout] | [INFO] [stdout] 1 | ...x_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrappe... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9755 [INFO] [stdout] | [INFO] [stdout] 1 | ...rapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn ... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10234 [INFO] [stdout] | [INFO] [stdout] 1 | ...3f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:9980 [INFO] [stdout] | [INFO] [stdout] 1 | ...elegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10373 [INFO] [stdout] | [INFO] [stdout] 1 | ...88953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn Excepti... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10114 [INFO] [stdout] | [INFO] [stdout] 1 | ...gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (aut... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10630 [INFO] [stdout] | [INFO] [stdout] 1 | ...eBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10234 [INFO] [stdout] | [INFO] [stdout] 1 | ...3f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8284 [INFO] [stdout] | [INFO] [stdout] 1 | ...cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl Wea... [INFO] [stdout] | ^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10373 [INFO] [stdout] | [INFO] [stdout] 1 | ...88953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn Excepti... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8341 [INFO] [stdout] | [INFO] [stdout] 1 | ...geCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl Uniqu... [INFO] [stdout] | ^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10630 [INFO] [stdout] | [INFO] [stdout] 1 | ...eBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("... [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8396 [INFO] [stdout] | [INFO] [stdout] 1 | ...idgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ... [INFO] [stdout] | ^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8284 [INFO] [stdout] | [INFO] [stdout] 1 | ...cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl Wea... [INFO] [stdout] | ^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8444 [INFO] [stdout] | [INFO] [stdout] 1 | ...egateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < Ex... [INFO] [stdout] | ^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8341 [INFO] [stdout] | [INFO] [stdout] 1 | ...geCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl Uniqu... [INFO] [stdout] | ^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8492 [INFO] [stdout] | [INFO] [stdout] 1 | ...andlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++"... [INFO] [stdout] | ^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8396 [INFO] [stdout] | [INFO] [stdout] 1 | ...idgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ... [INFO] [stdout] | ^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8538 [INFO] [stdout] | [INFO] [stdout] 1 | ...nHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (... [INFO] [stdout] | ^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8444 [INFO] [stdout] | [INFO] [stdout] 1 | ...egateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < Ex... [INFO] [stdout] | ^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8492 [INFO] [stdout] | [INFO] [stdout] 1 | ...andlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++"... [INFO] [stdout] | ^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:8538 [INFO] [stdout] | [INFO] [stdout] 1 | ...nHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (... [INFO] [stdout] | ^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10746 [INFO] [stdout] | [INFO] [stdout] 1 | ...fi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Bo... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type Exunsafe(ceptionHandlerDelegateBridgeHolde)r ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10746 [INFO] [stdout] | [INFO] [stdout] 1 | ...fi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Bo... [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type Exunsafe(ceptionHandlerDelegateBridgeHolde)r ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10936 [INFO] [stdout] | [INFO] [stdout] 1 | ...r >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f3... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > unsafe(;) fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10936 [INFO] [stdout] | [INFO] [stdout] 1 | ...r >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f3... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > unsafe(;) fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:11127 [INFO] [stdout] | [INFO] [stdout] 1 | ...king_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) unsafe(;) fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:11127 [INFO] [stdout] | [INFO] [stdout] 1 | ...king_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) unsafe(;) fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:11286 [INFO] [stdout] | [INFO] [stdout] 1 | ...dlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe908895... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > unsafe(;) fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:11286 [INFO] [stdout] | [INFO] [stdout] 1 | ...dlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe908895... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > unsafe(;) fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:11431 [INFO] [stdout] | [INFO] [stdout] 1 | ...me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autoc... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool unsafe(;) } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:11431 [INFO] [stdout] | [INFO] [stdout] 1 | ...me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autoc... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool unsafe(;) } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10627 [INFO] [stdout] | [INFO] [stdout] 1 | ... , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder unsafe(>)) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> src/lib.rs:20:41 [INFO] [stdout] | [INFO] [stdout] 20 | ) -> UniquePtr; [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> src/lib.rs:20:40 [INFO] [stdout] | [INFO] [stdout] 20 | ) -> UniquePtr; [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: unsafe attribute used without unsafe [INFO] [stdout] --> /opt/rustwide/target/debug/build/breakpad-rs-efd4ae20eaaa1e8f/out/autocxx-build-dir/rs/autocxx-ffi-default-gen.rs:1:10627 [INFO] [stdout] | [INFO] [stdout] 1 | ... , peer : Box < ExceptionHandlerDelegateBridgeHolder >) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen... [INFO] [stdout] | ^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 1 | # [allow (non_snake_case)] # [allow (dead_code)] # [allow (non_upper_case_globals)] # [allow (non_camel_case_types)] mod ffi { pub trait ToCppString { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > ; } impl ToCppString for & str { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (& self) } } impl ToCppString for & String { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { make_string (self) } } impl ToCppString for cxx :: UniquePtr < cxx :: CxxString > { fn into_cpp (self) -> cxx :: UniquePtr < cxx :: CxxString > { self } } pub use bindgen :: root :: ExceptionHandlerDelegateBridgeHolder ; # [allow (non_snake_case)] pub fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > { Box :: new (ExceptionHandlerDelegateBridgeHolder (me . 0 . relinquish_ownership ())) } fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { let rc = me . 0 . get () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method DidWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: DidWriteMinidump (r , working_path , minidump_id) } fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> cxx :: UniquePtr < cxx :: CxxString > { let rc = me . 0 . get () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method GetWorkingPath of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: GetWorkingPath (r ,) } fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool { let rc = me . 0 . get () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called after subclass destroyed") ; let b = rc . as_ref () . try_borrow () . expect ("Rust subclass API (method ShouldWriteMinidump of subclass ExceptionHandlerDelegateBridge of superclass ExceptionHandlerDelegate) called whilst subclass already borrowed - likely a re-entrant call") ; let r = :: core :: ops :: Deref :: deref (& b) ; root :: breakpad :: ExceptionHandlerDelegate_methods :: ShouldWriteMinidump (r ,) } mod bindgen { pub (super) mod root { pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub struct ExceptionHandlerDelegateBridgeHolder (pub autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) ; impl autocxx :: subclass :: CppSubclassCppPeer for ExceptionHandlerDelegateBridgeCpp { fn relinquish_ownership (& self) { self . ExceptionHandlerDelegateBridgeCpp_remove_ownership () ; } } impl autocxx :: subclass :: CppPeerConstructor < ExceptionHandlerDelegateBridgeCpp > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn make_peer (& mut self , peer_holder : autocxx :: subclass :: CppSubclassRustPeerHolder < Self >) -> cxx :: UniquePtr < root :: ExceptionHandlerDelegateBridgeCpp > { use autocxx :: moveit :: Emplace ; cxx :: UniquePtr :: emplace (ExceptionHandlerDelegateBridgeCpp :: new (peer_holder)) } } impl AsRef < root :: breakpad :: ExceptionHandlerDelegate > for super :: super :: super :: ExceptionHandlerDelegateBridge { fn as_ref (& self) -> & cxxbridge :: ExceptionHandlerDelegate { use autocxx :: subclass :: CppSubclass ; self . peer () . As_ExceptionHandlerDelegate () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn pin_mut (& mut self) -> :: core :: pin :: Pin < & mut cxxbridge :: ExceptionHandlerDelegate > { use autocxx :: subclass :: CppSubclass ; self . peer_mut () . As_ExceptionHandlerDelegate_mut () } } impl super :: super :: super :: ExceptionHandlerDelegateBridge { pub fn as_ExceptionHandlerDelegate_unique_ptr (u : cxx :: UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> cxx :: UniquePtr < cxxbridge :: ExceptionHandlerDelegate > { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u) } } impl ExceptionHandlerDelegateBridgeCpp { # [doc = "Synthesized default constructor."] pub fn new (peer : autocxx :: subclass :: CppSubclassRustPeerHolder < super :: super :: super :: ExceptionHandlerDelegateBridge >) -> impl autocxx :: moveit :: new :: New < Output = Self > { unsafe { autocxx :: moveit :: new :: by_raw (move | this | { let this = this . get_unchecked_mut () . as_mut_ptr () ; cxxbridge :: ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (this , Box :: new (ExceptionHandlerDelegateBridgeHolder (peer))) }) } } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: ExceptionHandlerDelegateBridgeCpp { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: ExceptionHandlerDelegateBridgeCpp { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: ExceptionHandlerDelegateBridgeCpp) { cxxbridge :: ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } pub mod breakpad { # [allow (non_snake_case)] pub trait ExceptionHandlerDelegate_methods { fn DidWriteMinidump (& self , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) ; fn GetWorkingPath (& self) -> cxx :: UniquePtr < cxx :: CxxString > ; fn ShouldWriteMinidump (& self) -> bool ; } pub use cxxbridge :: ExceptionHandlerDelegate ; impl ExceptionHandlerDelegate { pub fn DidWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate , working_path : & cxx :: CxxString , minidump_id : & cxx :: CxxString) { cxxbridge :: DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self , working_path , minidump_id) } pub fn GetWorkingPath (self : & root :: breakpad :: ExceptionHandlerDelegate) -> cxx :: UniquePtr < cxx :: CxxString > { cxxbridge :: GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (self) } pub fn ShouldWriteMinidump (self : & root :: breakpad :: ExceptionHandlerDelegate) -> bool { cxxbridge :: ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (self) } } unsafe impl autocxx :: moveit :: MakeCppStorage for root :: breakpad :: ExceptionHandlerDelegate { unsafe fn allocate_uninitialized_cpp_storage () -> * mut root :: breakpad :: ExceptionHandlerDelegate { cxxbridge :: ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () } unsafe fn free_uninitialized_cpp_storage (arg0 : * mut root :: breakpad :: ExceptionHandlerDelegate) { cxxbridge :: ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0) } } impl Drop for root :: breakpad :: ExceptionHandlerDelegate { fn drop (self : & mut root :: breakpad :: ExceptionHandlerDelegate) { unsafe { cxxbridge :: ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (self) } } } # [allow (unused_imports)] use self :: super :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: super :: root ; } # [allow (unused_imports)] use self :: super :: super :: { cxxbridge , ToCppString } ; # [allow (unused_imports)] use self :: super :: root ; } } # [cxx :: bridge] mod cxxbridge { impl UniquePtr < ExceptionHandlerDelegateBridgeCpp > { } impl SharedPtr < ExceptionHandlerDelegateBridgeCpp > { } impl WeakPtr < ExceptionHandlerDelegateBridgeCpp > { } impl UniquePtr < ExceptionHandlerDelegate > { } impl SharedPtr < ExceptionHandlerDelegate > { } impl WeakPtr < ExceptionHandlerDelegate > { } unsafe extern "C++" { fn autocxx_make_string_0xe9088953f391938c (str_ : & str) -> UniquePtr < CxxString > ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegateBridgeCpp ; pub unsafe fn ExceptionHandlerDelegateBridgeCpp_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegateBridgeCpp) ; type ExceptionHandlerDelegateBridgeCpp ; fn ExceptionHandlerDelegateBridgeCpp_remove_ownership (self : & ExceptionHandlerDelegateBridgeCpp) ; fn As_ExceptionHandlerDelegate (self : & ExceptionHandlerDelegateBridgeCpp) -> & ExceptionHandlerDelegate ; fn As_ExceptionHandlerDelegate_mut (self : Pin < & mut ExceptionHandlerDelegateBridgeCpp >) -> Pin < & mut ExceptionHandlerDelegate > ; fn ExceptionHandlerDelegateBridgeCpp_As_ExceptionHandlerDelegate_UniquePtr (u : UniquePtr < ExceptionHandlerDelegateBridgeCpp >) -> UniquePtr < ExceptionHandlerDelegate > ; pub unsafe fn ExceptionHandlerDelegate_autocxx_alloc_autocxx_wrapper_0xe9088953f391938c () -> * mut ExceptionHandlerDelegate ; pub unsafe fn ExceptionHandlerDelegate_autocxx_free_autocxx_wrapper_0xe9088953f391938c (arg0 : * mut ExceptionHandlerDelegate) ; # [namespace = "breakpad"] type ExceptionHandlerDelegate ; pub fn DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate , working_path : & CxxString , minidump_id : & CxxString) ; pub fn GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> UniquePtr < CxxString > ; pub fn ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : & ExceptionHandlerDelegate) -> bool ; pub unsafe fn ExceptionHandlerDelegate_destructor_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegate) ; # [doc = "Synthesized default constructor."] pub unsafe fn ExceptionHandlerDelegateBridgeCpp_new_autocxx_autocxx_wrapper_0xe9088953f391938c (autocxx_gen_this : * mut ExceptionHandlerDelegateBridgeCpp , peer : Box < ExceptionHandlerDelegateBridgeHolder unsafe(>)) ; include ! ("breakpad_exception_handler_delegate.h") ; include ! ("autocxxgen_ffi.h") ; } extern "Rust" { pub type ExceptionHandlerDelegateBridgeHolder ; fn ExceptionHandlerDelegateBridge_remove_ownership (me : Box < ExceptionHandlerDelegateBridgeHolder >) -> Box < ExceptionHandlerDelegateBridgeHolder > ; fn ExceptionHandlerDelegateBridge_DidWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder , working_path : & CxxString , minidump_id : & CxxString) ; fn ExceptionHandlerDelegateBridge_GetWorkingPath_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> UniquePtr < CxxString > ; fn ExceptionHandlerDelegateBridge_ShouldWriteMinidump_autocxx_wrapper_0xe9088953f391938c (me : & ExceptionHandlerDelegateBridgeHolder) -> bool ; } } # [allow (unused_imports)] use bindgen :: root ; pub use cxxbridge :: autocxx_make_string_0xe9088953f391938c as make_string ; pub use cxxbridge :: ExceptionHandlerDelegateBridgeCpp ; pub mod breakpad { # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate ; # [allow (unused_imports)] pub use super :: bindgen :: root :: breakpad :: ExceptionHandlerDelegate_methods ; } } [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> src/lib.rs:20:41 [INFO] [stdout] | [INFO] [stdout] 20 | ) -> UniquePtr; [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: extern blocks must be unsafe [INFO] [stdout] --> src/lib.rs:20:40 [INFO] [stdout] | [INFO] [stdout] 20 | ) -> UniquePtr; [INFO] [stdout] | ^ [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] error: could not compile `breakpad-rs` (lib) due to 28 previous errors [INFO] [stderr] warning: build failed, waiting for other jobs to finish... [INFO] [stderr] error: could not compile `breakpad-rs` (lib test) due to 28 previous errors [INFO] [stderr] error: failed to check after updating to 2024 [INFO] [stderr] [INFO] [stderr] Caused by: [INFO] [stderr] process didn't exit successfully: `cargo check --frozen --all --all-targets --message-format=json` (exit status: 101) [INFO] running `Command { std: "docker" "inspect" "2b7b71ef0bde5b2a0243e838bde327346519d701062670f2f4e3f4e498209a3c", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "2b7b71ef0bde5b2a0243e838bde327346519d701062670f2f4e3f4e498209a3c", kill_on_drop: false }` [INFO] [stdout] 2b7b71ef0bde5b2a0243e838bde327346519d701062670f2f4e3f4e498209a3c