Возврат структуры со ссылкой на значение и значением?

Question

[Имя]

Пытаюсь вернуть из функции структуру которая содержит вектор и ссылку на значение из вектора:

pub struct Graphics<'a> {
    adapters: Vec<Adapter>,
    adapter: &'a Adapter,
}

impl Graphics<'_> {
    pub fn new(args: &Args) -> Result<Self, anyhow::Error> {
        let adapters: Vec<Adapter> = instance.enumerate_adapters();
        let adapter: &Adapter = select_adapter(&adapters)?;

        Self {
            adapters,
            adapter,
        }
    }
}

// Возвращает ссылку на элемент вектора
fn select_adapter<'a>(adapters: &'a Vec<Adapter>) -> Result<&'a Adapter, anyhow::Error>;

Сталкиваюсь с такой ошибкой: `adapters` does not live long enough

Полный текст

pub fn new(args: &Args) -> Result<Self, anyhow::Error> {
   |                                --------------------------- return type is std::result::Result<Graphics<'1>, anyhow::Error>
...
32 |         let adapters = instance.enumerate_adapters(get_wgpu_backend());
   |             -------- binding `adapters` declared here
33 |         // Select adapter
34 |         let adapter = select_adapter(&instance, &adapters, args.adapter_index, &surface)?;
   |                                                 ^^^^^^^^^ borrowed value does not live long enough
...
                 // Тут возврат Self из функции
74 |             adapter,
   |             ------- this usage requires that `adapters` is borrowed for `'1`
...
78 |     }
   |     - `adapters` dropped here while still borrowed

Что за this usage requires that `adapters` is borrowed for `'1` и особенно что за `adapters` dropped here while still borrowed? Ведь adapters ни не дропается, а в Self перемещается, очевидный же бред в ошибке.
Как это исправлять?

Решил для упрощения кода повторить его на Rust Playground

struct A;

struct S<'a> {
    a_vec: Vec<A>,
    a_ref: &'a A
}

impl S<'_> {
    fn new() -> Self {
        let a_vec = vec![A, A, A];
        let a_ref = get_ref(&a_vec);

        Self {
            a_vec,
            a_ref,
        }
    }
}

fn get_ref<'a>(a_vec: &'a Vec<A>) -> &'a A {
    &a_vec[0]
}

Но тут к моему удивлению совершенно другие ошибки:

spoiler

error[E0515]: cannot return value referencing local variable `a_vec`
  --> src/main.rs:13:9
   |
11 |           let a_ref = get_ref(&a_vec).unwrap();
   |                               ------ `a_vec` is borrowed here
12 |
13 | /         Self {
14 | |             a_vec,
15 | |             a_ref
16 | |         }
   | |_________^ returns a value referencing data owned by the current function

error[E0505]: cannot move out of `a_vec` because it is borrowed
  --> src/main.rs:14:13
   |
9  |       fn new() -> Self {
   |                   ---- return type is S<'1>
10 |           let a_vec = vec![A, A, A];
   |               ----- binding `a_vec` declared here
11 |           let a_ref = get_ref(&a_vec).unwrap();
   |                               ------ borrow of `a_vec` occurs here
12 |
13 | /         Self {
14 | |             a_vec,
   | |             ^^^^^ move out of `a_vec` occurs here
15 | |             a_ref
16 | |         }
   | |_________- returning this value requires that `a_vec` is borrowed for `'1`

И почему тут ошибки другие, если код в целом тот-же?

Comments

[Василий Банников]

Это у тебя self referential struct возникает, там сложно немного
https://doc.rust-lang.org/std/pin/#a-self-referent...

[Имя]

Василий Банников, а починят это дело когда-нибудь? Очевидно же, что ссылка живёт не вектора, т.к. оба они в одной структуре оказываются.

[Василий Банников]

Имя,
Для человека это очевидно, а вот у машины нет способа в этом убедиться.
(Vec можно мувнуть и тогда ссылка больше не валидная)

А вот на счёт текста ошибки - поменяется, если пропозал напишешь.

В принципе есть практика давать для частных случаев более полезные сообщения

Answer 1

[Василий Банников]

У тебя там self referential struct, так что придётся при помощи NonNull указателей сделать и запретить перемещение структуры при помощи PhantomPin.
Лайфтайма наподобие 'self нету

Comments

[Имя]

А пример какой-то можно?

[Василий Банников]

Имя, ну вот в комментах ссылку на доку кидал)

use std::pin::Pin;
use std::marker::PhantomPinned;
use std::ptr::NonNull;

/// This is a self-referential struct because `self.slice` points into `self.data`.
struct Unmovable {
    /// Backing buffer.
    data: [u8; 64],
    /// Points at `self.data` which we know is itself non-null. Raw pointer because we can't do
    /// this with a normal reference.
    slice: NonNull<[u8]>,
    /// Suppress `Unpin` so that this cannot be moved out of a `Pin` once constructed.
    _pin: PhantomPinned,
}

impl Unmovable {
    /// Create a new `Unmovable`.
    ///
    /// To ensure the data doesn't move we place it on the heap behind a pinning Box.
    /// Note that the data is pinned, but the `Pin<Box<Self>>` which is pinning it can
    /// itself still be moved. This is important because it means we can return the pinning
    /// pointer from the function, which is itself a kind of move!
    fn new() -> Pin<Box<Self>> {
        let res = Unmovable {
            data: [0; 64],
            // We only create the pointer once the data is in place
            // otherwise it will have already moved before we even started.
            slice: NonNull::from(&[]),
            _pin: PhantomPinned,
        };
        // First we put the data in a box, which will be its final resting place
        let mut boxed = Box::new(res);

        // Then we make the slice field point to the proper part of that boxed data.
        // From now on we need to make sure we don't move the boxed data.
        boxed.slice = NonNull::from(&boxed.data);

        // To do that, we pin the data in place by pointing to it with a pinning
        // (`Pin`-wrapped) pointer.
        //
        // `Box::into_pin` makes existing `Box` pin the data in-place without moving it,
        // so we can safely do this now *after* inserting the slice pointer above, but we have
        // to take care that we haven't performed any other semantic moves of `res` in between.
        let pin = Box::into_pin(boxed);

        // Now we can return the pinned (through a pinning Box) data
        pin
    }
}

let unmovable: Pin<Box<Unmovable>> = Unmovable::new();

// The inner pointee `Unmovable` struct will now never be allowed to move.
// Meanwhile, we are free to move the pointer around.
let mut still_unmoved = unmovable;
assert_eq!(still_unmoved.slice, NonNull::from(&still_unmoved.data));

// We cannot mutably dereference a `Pin<Ptr>` unless the pointee is `Unpin` or we use unsafe.
// Since our type doesn't implement `Unpin`, this will fail to compile.
// let mut new_unmoved = Unmovable::new();
// std::mem::swap(&mut *still_unmoved, &mut *new_unmoved);