internal: pin_data: allow lifetime to be shortened per field drop order

Add the outlive relations per field drop order. This allows a single
lifetime to be used when a field potentially borrow from two different
fields, by allowing the longer-living field lifetime to be shortened to a
shorter-living field lifetime.

Signed-off-by: Gary Guo <gary@garyguo.net>

Author: nbdd0121

internal/src/pin_data.rs

@@ -16,7 +16,7 @@ use syn::{
 
 use crate::{
     diagnostics::{DiagCtxt, ErrorGuaranteed},
-    util::{Binder, LifetimeExt, TypeExt},
+    util::{Binder, GenericsExt, LifetimeExt, TypeExt},
 };
 
 pub(crate) mod kw {
@@ -293,14 +293,48 @@ pub(crate) fn pin_data(
         }
     }
 
+    // Create a lifetime parameter for each field.
+    let field_lts: Vec<_> = fields
+        .iter()
+        .filter(|f| f.borrowed.is_some())
+        .map(|f| Lifetime::from_ident(f.field.ident.as_ref().unwrap()))
+        .collect();
+    let field_lt_generics = Generics {
+        lt_token: Some(Default::default()),
+        params: field_lts
+            .iter()
+            .zip(std::iter::once(None).chain(field_lts.iter().map(Some)))
+            .map(|(lt, prev)| {
+                GenericParam::Lifetime(LifetimeParam {
+                    attrs: Vec::new(),
+                    lifetime: lt.clone(),
+                    colon_token: prev.map(|_| Default::default()),
+                    bounds: prev.iter().map(|&lt| lt.clone()).collect(),
+                })
+            })
+            .collect(),
+        gt_token: Some(Default::default()),
+        where_clause: None,
+    };
+
     let struct_def = generate_struct_def(&struct_, &fields);
     let unpin_impl = generate_unpin_impl(&struct_.ident, &struct_.generics, &fields);
     let drop_impl = generate_drop_impl(&struct_.ident, &struct_.generics, args);
-    let drop_check = generate_drop_check(dcx, &struct_, &fields);
-    let projections =
-        generate_projections(&struct_.vis, &struct_.ident, &struct_.generics, &fields);
-    let the_pin_data =
-        generate_the_pin_data(&struct_.vis, &struct_.ident, &struct_.generics, &fields);
+    let drop_check = generate_drop_check(dcx, &struct_, &fields, &field_lt_generics);
+    let projections = generate_projections(
+        &struct_.vis,
+        &struct_.ident,
+        &struct_.generics,
+        &fields,
+        &field_lt_generics,
+    );
+    let the_pin_data = generate_the_pin_data(
+        &struct_.vis,
+        &struct_.ident,
+        &struct_.generics,
+        &fields,
+        &field_lt_generics,
+    );
 
     Ok(quote! {
         #struct_def
@@ -518,6 +552,7 @@ fn generate_drop_check(
     dcx: &mut DiagCtxt,
     struct_: &ItemStruct,
     fields: &[FieldInfo<'_>],
+    field_lt_generics: &Generics,
 ) -> TokenStream {
     let struct_name = &struct_.ident;
     // If the struct is not self-referential then we can just skip. However, still leave a
@@ -554,22 +589,12 @@ fn generate_drop_check(
         }
     }
 
-    // Create a lifetime parameter for each field.
-    let field_lt_params: Vec<_> = fields
-        .iter()
-        .filter(|f| f.borrowed.is_some())
-        .map(|f| {
-            GenericParam::Lifetime(LifetimeParam::new(Lifetime::from_ident(
-                f.field.ident.as_ref().unwrap(),
-            )))
-        })
-        .collect();
-
     let mut generics_with_field_lt = struct_.generics.clone();
     generics_with_field_lt
         .params
-        .extend(field_lt_params.iter().cloned());
+        .extend(field_lt_generics.params.iter().cloned());
 
+    let field_lt_for_generics = field_lt_generics.for_generics();
     let (_, ty_generics_with_field_lt, _) = generics_with_field_lt.split_for_impl();
     let (impl_generics, ty_generics, whr) = struct_.generics.split_for_impl();
 
@@ -668,7 +693,7 @@ fn generate_drop_check(
         fn __drop_check #impl_generics (
             // This must be present so the function can observe the implied bounds.
             _: &#struct_name #ty_generics,
-            f: impl for<#(#field_lt_params,)*>::core::ops::FnOnce(__DropCheck #ty_generics_with_field_lt)
+            f: impl #field_lt_for_generics ::core::ops::FnOnce(__DropCheck #ty_generics_with_field_lt)
         ) #whr {
             #(#guards)*
 
@@ -684,6 +709,7 @@ fn generate_projections(
     ident: &Ident,
     generics: &Generics,
     fields: &[FieldInfo<'_>],
+    field_lt_generics: &Generics,
 ) -> TokenStream {
     let pin_lt = Lifetime::new("'__pin", Span::mixed_site());
 
@@ -695,19 +721,11 @@ fn generate_projections(
     );
     let (_, ty_generics_with_pin_lt, whr) = generics_with_pin_lt.split_for_impl();
 
-    let field_lt_params: Vec<_> = fields
-        .iter()
-        .filter(|f| f.borrowed.is_some())
-        .map(|f| {
-            GenericParam::Lifetime(LifetimeParam::new(Lifetime::from_ident(
-                f.field.ident.as_ref().unwrap(),
-            )))
-        })
-        .collect();
     let mut generics_with_field_lt = generics.clone();
     generics_with_field_lt
         .params
-        .extend(field_lt_params.iter().cloned());
+        .extend(field_lt_generics.params.iter().cloned());
+    let field_lt_for_generics = field_lt_generics.for_generics();
     let (_, ty_generics_with_field_lt, _) = generics_with_field_lt.split_for_impl();
 
     let mut generics_with_pin_field_lt = generics_with_field_lt.clone();
@@ -1008,7 +1026,7 @@ fn generate_projections(
             #[inline]
             #vis fn with_project<'__pin, R>(
                 self: ::core::pin::Pin<&'__pin mut Self>,
-                f: impl for<#(#field_lt_params,)*>::core::ops::FnOnce(__ProjectionLt #ty_generics_with_pin_field_lt) -> R
+                f: impl #field_lt_for_generics ::core::ops::FnOnce(__ProjectionLt #ty_generics_with_pin_field_lt) -> R
             ) -> R {
                 // SAFETY: we only give access to `&mut` for fields not structurally pinned.
                 let #this = unsafe { ::core::pin::Pin::get_unchecked_mut(self) };
@@ -1028,22 +1046,14 @@ fn generate_the_pin_data(
     struct_name: &Ident,
     generics: &Generics,
     fields: &[FieldInfo<'_>],
+    field_lt_generics: &Generics,
 ) -> TokenStream {
-    let field_lt_params: Vec<_> = fields
-        .iter()
-        .filter(|f| f.borrowed.is_some())
-        .map(|f| {
-            GenericParam::Lifetime(LifetimeParam::new(Lifetime::from_ident(
-                f.field.ident.as_ref().unwrap(),
-            )))
-        })
-        .collect();
-
     let mut generics_with_field_lt = generics.clone();
     generics_with_field_lt
         .params
-        .extend(field_lt_params.iter().cloned());
+        .extend(field_lt_generics.params.iter().cloned());
 
+    let field_lt_for_generics = field_lt_generics.for_generics();
     let (impl_generics_with_lt, ty_generics_with_field_lt, _) =
         generics_with_field_lt.split_for_impl();
     let (impl_generics, ty_generics, whr) = generics.split_for_impl();
@@ -1189,14 +1199,14 @@ fn generate_the_pin_data(
             #[inline(always)]
             #vis fn __make_closure<__F, __E>(self, f: __F) -> __F
             where
-                __F: for<#(#field_lt_params,)*>::core::ops::FnOnce(*mut #struct_name #ty_generics, __PinDataLt #ty_generics_with_field_lt) ->
+                __F: #field_lt_for_generics  ::core::ops::FnOnce(*mut #struct_name #ty_generics, __PinDataLt #ty_generics_with_field_lt) ->
                     ::core::result::Result<::pin_init::__internal::InitOk, __E>,
             {
                 f
             }
 
             #[inline(always)]
-            fn __with_lt<#(#field_lt_params,)*>(self) -> __PinDataLt #ty_generics_with_field_lt {
+            fn __with_lt #field_lt_generics(self) -> __PinDataLt #ty_generics_with_field_lt {
                 __PinDataLt { __phantom: ::core::marker::PhantomData }
             }
         }

internal/src/util.rs

@@ -2,12 +2,12 @@
 
 use std::collections::BTreeSet;
 
-use proc_macro2::Span;
-use quote::quote;
+use proc_macro2::{Span, TokenStream};
+use quote::{quote, ToTokens};
 use syn::punctuated::Punctuated;
 use syn::visit::Visit;
 use syn::visit_mut::VisitMut;
-use syn::{BoundLifetimes, GenericParam, Ident, LifetimeParam};
+use syn::{BoundLifetimes, GenericParam, Generics, Ident, LifetimeParam, Token};
 use syn::{Lifetime, Type};
 
 pub(crate) trait TypeExt {
@@ -210,3 +210,26 @@ impl LifetimeExt for Lifetime {
         }
     }
 }
+
+pub(crate) struct ForGenerics<'a>(&'a Generics);
+
+pub(crate) trait GenericsExt {
+    fn for_generics(&self) -> ForGenerics<'_>;
+}
+
+impl GenericsExt for Generics {
+    fn for_generics(&self) -> ForGenerics<'_> {
+        ForGenerics(self)
+    }
+}
+
+impl ToTokens for ForGenerics<'_> {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        if self.0.params.is_empty() {
+            return;
+        }
+
+        <Token![for]>::default().to_tokens(tokens);
+        self.0.split_for_impl().1.to_tokens(tokens);
+    }
+}

tests/selfref_shorten.rs

@@ -0,0 +1,26 @@
+use pin_init::*;
+
+#[pin_data]
+struct SelfRef {
+    #[borrows(foo, bar)]
+    part: &'foo str,
+    foo: String,
+    bar: String,
+}
+
+#[test]
+fn self_ref() {
+    stack_pin_init!(let foo = pin_init!(SelfRef {
+        foo: "hello world".to_owned(),
+        bar: "hello world".to_owned(),
+        part: &foo[..5],
+    }));
+
+    stack_pin_init!(let bar = pin_init!(SelfRef {
+        foo: "hello world".to_owned(),
+        bar: "hello world".to_owned(),
+        // In this case, we borrow from a field that lives longers.
+        // We're allowed to coerce it into a shorter-living lifetime.
+        part: &bar[..5],
+    }));
+}