I am trying to pass a GObject to a FFI function from libsecret-1 which requires it be in a GList. I have some code that almost compiles, but it complains about the lifetime of the borrowed vaue being too short and not outliving the function. The object itself was created from the FFI using the wrapper! macro from the glib crate for Rust. Here is a minimum-viable reproduction that produces the error I am getting:

我正在尝试将一个GObject从libret-1传递给FFI函数，这要求它出现在glist中。我有一些几乎可以编译的代码，但它抱怨借用的vaue的生命周期太短，并且没有超过函数的寿命。对象本身是使用包装器从FFI创建的！从油滑的板条箱里取来的宏，用于生锈。这是一个最小可行的复制，它产生了我得到的错误：

extern crate glib;                                                                                                                                                                            
                                                                                                                                                                                              
use glib::ffi::GList;
use glib::translate::{ToGlibPtr, GlibPtrDefault, ToGlibContainerFromSlice};

pub fn lock_object_test<'a, W: GlibPtrDefault +
  ToGlibPtr<'a, <W as GlibPtrDefault>::GlibType>>(obj: &'a W) {
    let arr = [obj];
    let slice: (*mut GList, <&W as ToGlibContainerFromSlice<'a, *mut GList>>::Storage) = 
        ToGlibContainerFromSlice::to_glib_none_from_slice(&arr[..]);
    // Would pass slice.0 here as a *mut GList argument to FFI
}

The GList should just be a shared reference that is only needed for the duration of the call to the FFI function so I am not sure why it thinks the lifetime need to live beyond the function. The error triggers on the &arr[..] due to it being borrowed for longer than the life of arr.

GLIST应该只是一个仅在调用FFI函数期间需要的共享引用，所以我不确定为什么它认为生存期需要存在于函数之外。错误在&arr[..]上触发因为它被借的时间比阿尔的寿命还长。

Also, any tips on how to make this less wordy would be nice.

此外，任何关于如何让这一点不那么冗长的提示都会很好。

The problem is you specify the caller can choose a lifetime 'a for which all of these bounds have to hold, but the caller can only specify lifetimes that live from before the call to after the function returned. But arr doesn't live that long.

问题是，您指定调用者可以选择所有这些界限都必须保持的生存期，但调用者只能指定从调用前到函数返回后的生存期。但arr没有那么长的生存期。

You can use higher ranked trait bounds (HRTB) to specify that W has to implement ToGlibPtr for any lifetime, not just lifetimes specified by the caller.

您可以使用更高级别的特征界限(HRTB)来指定W必须在任何生存期内实现ToGlibPtr，而不仅仅是调用者指定的生存期。

use glib::ffi::GList;
use glib::translate::{GlibPtrDefault, ToGlibPtr, ToGlibContainerFromSlice};
pub fn lock_object_test<W> (obj: &W)
where
    for<'a> W: GlibPtrDefault + ToGlibPtr<'a, <W as GlibPtrDefault>::GlibType>
{
    let arr = [obj];
    let (ptr, _zstorage): (*mut GList, <&W as ToGlibContainerFromSlice<*mut GList>>::Storage) = 
        ToGlibContainerFromSlice::to_glib_none_from_slice(&arr[..]);
    // pass ptr here as a *mut GList argument to FFI
}

The error you're encountering is due to Rust's borrow checker ensuring that the borrowed value (&arr[..]) doesn't outlive the reference itself (arr). In this case, Rust doesn't know how long the reference arr will be needed, so it assumes that you're trying to use the borrowed value outside its expected lifetime.

您遇到的错误是由于Rust的借入检查器确保借入的值(&arr[..])不会超过引用本身(ARR)。在本例中，Rust不知道需要引用arr多长时间，因此它假定您正在尝试使用超出其预期生命周期的借用值。

To address this issue, you can use the std::mem::ManuallyDrop wrapper to temporarily extend the lifetime of the arr variable. Here's a modified version of your code that avoids the lifetime issue and is less wordy:

要解决此问题，您可以使用std：：Mem：：ManuallyDrop包装来临时延长arr变量的生命周期。以下是代码的修改版本，它避免了生命周期问题，并且不那么冗长：

use glib::translate::*;
use glib::GlibPtrDefault;
use libc::GList;
use std::mem::ManuallyDrop;

pub fn lock_object_test<'a, W>(obj: &'a W)
where
    W: GlibPtrDefault + ToGlibPtr<'a, <W as GlibPtrDefault>::GlibType>,
{
    // Create a ManuallyDrop to extend the lifetime of 'arr'.
    let arr = ManuallyDrop::new([obj]);

    // Convert the ManuallyDrop reference to a GList.
    let slice = arr.as_ref();
    let slice_ptr: (*mut GList, <&W as ToGlibContainerFromSlice<'a, *mut GList>>::Storage) =
        ToGlibContainerFromSlice::to_glib_none_from_slice(slice);

    // Pass slice_ptr.0 as a *mut GList argument to FFI.
    // ...
}

fn main() {
    // Example usage:
    // let obj = ...; // Create your GObject here.
    // lock_object_test(&obj);
}