Calling multiple mutable functions (e.g. signals) on Pin<&mut T>

[SanderVocke]

Hi there,

First of all, thanks for your quick responses to two questions I posted recently. I'm slowly getting the hang of it.

I am wondering how to emit two signals in a row in a Rust-safe manner. Given:

pub fn some_invokable_implementation(self : Pin<&mut Self>) {
        self.emitSignal1();
        self.emitSignal2();
    }

The Rust compiler will complain on emitting the second signal, because both signals take a Pinned mutable reference and this cannot be copied: use of moved value: self.
Is this indeed a fundamentally "unsafe" (from the Rust point of view) operation? Is it required to use unsafe code to emit the second signal?

Edit: call me a Rust noob (I am), but I haven´t even found an unsafe way to do this in Rust.

[LeonMatthesKDAB]

Hi @SanderVocke , this is a common question we get that stems from Rusts somewhat suboptimal Pin implementation.
It's a complicated topic to why this happens, but it luckily has an easy fix :)

TL;DR:

Use as_mut() to "re-borrow" the pin:

self.as_mut().emitSignal1();
self.emitSignal2(); // could use as_mut() here as well.

Long-winded explanation:

Functions that take a Pinned mutable reference usually take self: Pin<&mut T>.
This will "consume" the Pin, as it's taking the Pin itself by value.
For unpinned mutable references (&mut T), this wouldn't consume the T itself, as the compiler will create a new reference from the owned object automatically.

But as Pin is just a "normal" struct that contains a reference, it will consume the struct itself (i.e. the Pin).
This makes more sense if you think about Pin as a general wrapper around a pointer.
If you take a self: Pin<UniquePtr<T>> as input, it should be clear that this will indeed consume the pointer, and therefore the Pin as well.
Unfortunately, the same happens for pinned mutable references, even though those could be easily re-created.

That is what as_mut() allows you to do.
It allows you to go from:
&'a mut Pin<UniquePtr<T>> to: Pin<&'a mut T>.
So to go from a reference to a pinned pointer to a pinned mutable reference to the inner T.
As that takes the reference to the Pin as input, it won't consume it, but create a new Pin, which is bound by the 'a lifetime to the input.

As &mut is just another pointer type, you can use as_mut() to go from:
&'a mut Pin<&mut T> to: Pin<&'a mut T> and keep the original Pin intact.

It's unfortunate that you always have to do this explicitly, but that's how Rust has implemented this at the moment.
Maybe some future compiler revisions will be able to help with this 🤞

[SanderVocke]

Rust doesn´t allow me to re-borrow: cannot borrow "self" as mutable, as it is not declared as mutable. This error remains even if defining the function as unsafe:

error[E0596]: cannot borrow `self` as mutable, as it is not declared as mutable
   --> src/shoop_rs_qobj/qobj_file_io.rs:106:23
    |
106 |     pub fn write_file(self : Pin<&mut FileIO>, file_name : QString, data : QString) -> bool {
    |                       ^^^^ not mutable
107 |         self.as_mut().startSavingFile();
    |         ---- cannot borrow as mutable
...
111 |         self.as_mut().doneSavingFile();
    |         ---- cannot borrow as mutable

Apparently this would only be allowed if the function signature was taking a mut self : Pin<&Self>.

This concurs with what you mentioned: as_mut requires a &'a mut Pin<&mut T>, but cxx-qt gives me a Pin<&mut T>.

The shortest way to illustrate is to try: let s = &mut self, which is also not allowed.

[ahayzen-kdab]

Yes you would need the implementation to have marked self as mutable

pub fn some_invokable_implementation(mut self : Pin<&mut Self>) {
    self.as_mut().emitSignal1();
    self.emitSignal2();
}

You can see an example of this here

cxx-qt/examples/qml_features/rust/src/threading.rs

Line 85 in 78554ec

pub fn fetch_title(mut self: Pin<&mut Self>) {

where we have fetch_title with a mut then as_mut() is used within the function

cxx-qt/examples/qml_features/rust/src/threading.rs

Line 103 in 78554ec

self.as_mut().set_title(QString::from("Loading..."));

Note how the CXX bridge part does not need this mut

cxx-qt/examples/qml_features/rust/src/threading.rs

Line 44 in 78554ec

fn fetch_title(self: Pin<&mut ThreadingWebsite>);

[SanderVocke]

Ah, well there you go. I didn´t realize the impl signature was allowed to be any different than the bridge one. Thanks again for the lightning-fast responses!