Add IntoIter derive for custom views

shipyard_proc/src/borrow_expand.rs

@@ -18,11 +18,8 @@ pub(crate) fn expand_borrow(
     };
 
     let mut gat_generics = generics.clone();
-    for generic in gat_generics.params.iter_mut() {
-        if let syn::GenericParam::Lifetime(lifetime) = generic {
-            lifetime.lifetime = parse_quote!('__view);
-            break;
-        }
+    if let Some(lifetime) = gat_generics.lifetimes_mut().next() {
+        lifetime.lifetime = parse_quote!('__view);
     }
 
     let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();

shipyard_proc/src/lib.rs

@@ -3,12 +3,14 @@ extern crate proc_macro;
 mod borrow_expand;
 mod borrow_info_expand;
 mod component_expand;
+mod into_iter_expand;
 mod label_expand;
 mod world_borrow_expand;
 
 use borrow_expand::expand_borrow;
 use borrow_info_expand::expand_borrow_info;
 use component_expand::{expand_component, expand_unique};
+use into_iter_expand::expand_into_iter;
 use label_expand::expand_label;
 use world_borrow_expand::expand_world_borrow;
 
@@ -97,3 +99,16 @@ pub fn label(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
 
     expand_label(name, generics).into()
 }
+
+#[proc_macro_derive(IntoIter)]
+pub fn into_iter(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = syn::parse_macro_input!(item as syn::DeriveInput);
+
+    let name = input.ident;
+    let generics = input.generics;
+    let data = input.data;
+
+    expand_into_iter(name, generics, data)
+        .unwrap_or_else(|err| err.to_compile_error())
+        .into()
+}

src/iter/into_abstract/mod.rs

@@ -53,8 +53,8 @@ pub trait IntoAbstract {
     }
 }
 
-impl<'a, T: Component, Track: Tracking> IntoAbstract for &'a View<'a, T, Track> {
-    type AbsView = FullRawWindow<'a, T>;
+impl<'a: 'b, 'b, T: Component, Track: Tracking> IntoAbstract for &'b View<'a, T, Track> {
+    type AbsView = FullRawWindow<'b, T>;
 
     #[inline]
     fn into_abstract(self) -> Self::AbsView {

src/iter/mod.rs

@@ -26,5 +26,12 @@ pub use par_iter::ParIter;
 pub use par_mixed::ParMixed;
 #[cfg(feature = "parallel")]
 pub use par_tight::ParTight;
+// used by proc macros
+#[cfg(feature = "parallel")]
+#[doc(hidden)]
+pub use rayon::iter::{
+    plumbing::UnindexedConsumer as __UnindexedConsumer,
+    IndexedParallelIterator as __IndexedParallelIterator, ParallelIterator as __ParallelIterator,
+};
 pub use tight::Tight;
 pub use with_id::{IntoWithId, LastId, WithId};

src/iter/par_iter.rs

@@ -27,6 +27,7 @@ where
 {
     type Item = <Storage as AbstractMut>::Out;
 
+    #[inline]
     fn drive_unindexed<C>(self, consumer: C) -> C::Result
     where
         C: UnindexedConsumer<Self::Item>,
@@ -36,6 +37,8 @@ where
             ParIter::Mixed(mixed) => mixed.drive_unindexed(consumer),
         }
     }
+
+    #[inline]
     fn opt_len(&self) -> Option<usize> {
         match self {
             ParIter::Tight(tight) => tight.opt_len(),

src/iter/par_mixed.rs

@@ -19,6 +19,7 @@ where
 {
     type Item = <Mixed<Storage> as Iterator>::Item;
 
+    #[inline]
     fn drive_unindexed<C>(self, consumer: C) -> C::Result
     where
         C: UnindexedConsumer<Self::Item>,

src/iter/par_tight.rs

@@ -19,12 +19,15 @@ where
 {
     type Item = <Tight<Storage> as Iterator>::Item;
 
+    #[inline]
     fn drive_unindexed<C>(self, consumer: C) -> C::Result
     where
         C: UnindexedConsumer<Self::Item>,
     {
         bridge(self, consumer)
     }
+
+    #[inline]
     fn opt_len(&self) -> Option<usize> {
         Some(self.len())
     }
@@ -35,12 +38,17 @@ where
     Storage: Clone + Send,
     <Storage as AbstractMut>::Out: Send,
 {
+    #[inline]
     fn len(&self) -> usize {
         self.0.len()
     }
+
+    #[inline]
     fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result {
         bridge(self, consumer)
     }
+
+    #[inline]
     fn with_producer<CB: ProducerCallback<Self::Item>>(self, callback: CB) -> CB::Output {
         callback.callback(self.0)
     }

src/lib.rs

@@ -110,7 +110,7 @@ pub use scheduler::{
     ScheduledWorkload, SystemModificator, Workload, WorkloadModificator, WorkloadSystem,
 };
 #[cfg(feature = "proc")]
-pub use shipyard_proc::{Borrow, BorrowInfo, Component, Label, Unique, WorldBorrow};
+pub use shipyard_proc::{Borrow, BorrowInfo, Component, IntoIter, Label, Unique, WorldBorrow};
 pub use sparse_set::{
     BulkAddEntity, SparseArray, SparseSet, SparseSetDrain, TupleAddComponent, TupleDelete,
     TupleRemove,

tests/derive/mod.rs

@@ -23,6 +23,17 @@ fn check_derive() {
 
     #[derive(Component, Unique)]
     struct E;
+
+    #[derive(IntoIter)]
+    struct CustomView<'a> {
+        comp_a: shipyard::View<'a, A>,
+        v_comp_aa: shipyard::View<'a, A>,
+        comp_b: shipyard::ViewMut<'a, B>,
+        vm_comp_bb: shipyard::ViewMut<'a, B>,
+    }
+
+    #[derive(IntoIter)]
+    struct CustomView2<'a>(shipyard::View<'a, A>, shipyard::ViewMut<'a, B>);
 }
 
 /// Verify that the "default" attribute compiles.