Merge pull request #490 from kas-gui/push-tlnpmvnkvtrl

Replace fns for_child* with get_child* to reduce stack depth

Author: dhardy

crates/kas-core/src/core/collection.rs

@@ -38,12 +38,7 @@ pub trait Collection {
     fn get_mut_tile(&mut self, index: usize) -> Option<&mut dyn Tile>;
 
     /// Operate on a widget as a [`Node`]
-    fn for_node(
-        &mut self,
-        data: &Self::Data,
-        index: usize,
-        closure: Box<dyn FnOnce(Node<'_>) + '_>,
-    );
+    fn child_node<'n>(&'n mut self, data: &'n Self::Data, index: usize) -> Option<Node<'n>>;
 
     /// Iterate over elements as [`Tile`] items within `range`
     ///
@@ -255,15 +250,12 @@ macro_rules! impl_slice {
             }
 
             #[inline]
-            fn for_node(
-                &mut self,
-                data: &W::Data,
+            fn child_node<'n>(
+                &'n mut self,
+                data: &'n Self::Data,
                 index: usize,
-                closure: Box<dyn FnOnce(Node<'_>) + '_>,
-            ) {
-                if let Some($pat) = self.get_mut(index) {
-                    closure($w.as_node(data));
-                }
+            ) -> Option<Node<'n>> {
+                self.get_mut(index).map(|$pat| $w.as_node(data))
             }
 
             #[inline]

crates/kas-core/src/core/impls.rs

@@ -42,10 +42,10 @@ pub fn _send<W: Events>(
         if let Some(index) = widget.find_child_index(&id) {
             let translation = widget.translation();
             let mut _found = false;
-            widget.as_node(data).for_child(index, |mut node| {
+            if let Some(mut node) = widget.as_node(data).get_child(index) {
                 is_used = node._send(cx, id.clone(), event.clone() + translation);
                 _found = true;
-            });
+            }
 
             #[cfg(debug_assertions)]
             if !_found {
@@ -81,10 +81,10 @@ pub fn _send<W: Events>(
 pub fn _replay<W: Events>(widget: &mut W, cx: &mut EventCx, data: &<W as Widget>::Data, id: Id) {
     if let Some(index) = widget.find_child_index(&id) {
         let mut _found = false;
-        widget.as_node(data).for_child(index, |mut node| {
+        if let Some(mut node) = widget.as_node(data).get_child(index) {
             node._replay(cx, id.clone());
             _found = true;
-        });
+        }
 
         #[cfg(debug_assertions)]
         if !_found {
@@ -147,7 +147,9 @@ fn nav_next(
     if let Some(index) = child {
         let mut opt_id = None;
         let out = &mut opt_id;
-        widget.for_child(index, |mut node| *out = node._nav_next(cx, focus, advance));
+        if let Some(mut node) = widget.get_child(index) {
+            *out = node._nav_next(cx, focus, advance);
+        }
         if let Some(id) = opt_id {
             return Some(id);
         }
@@ -174,7 +176,9 @@ fn nav_next(
     while let Some(index) = widget.nav_next(rev, child) {
         let mut opt_id = None;
         let out = &mut opt_id;
-        widget.for_child(index, |mut node| *out = node._nav_next(cx, focus, advance));
+        if let Some(mut node) = widget.get_child(index) {
+            *out = node._nav_next(cx, focus, advance);
+        }
         if let Some(id) = opt_id {
             return Some(id);
         }

crates/kas-core/src/core/node.rs

@@ -22,7 +22,7 @@ trait NodeT {
 
     fn num_children(&self) -> usize;
     fn find_child_index(&self, id: &Id) -> Option<usize>;
-    fn for_child_node(&mut self, index: usize, f: Box<dyn FnOnce(Node<'_>) + '_>);
+    fn child_node(&mut self, index: usize) -> Option<Node<'_>>;
 
     fn size_rules(&mut self, sizer: SizeCx, axis: AxisInfo) -> SizeRules;
     fn set_rect(&mut self, cx: &mut ConfigCx, rect: Rect, hints: AlignHints);
@@ -64,8 +64,8 @@ impl<'a, T> NodeT for (&'a mut dyn Widget<Data = T>, &'a T) {
         self.0.find_child_index(id)
     }
 
-    fn for_child_node(&mut self, index: usize, f: Box<dyn FnOnce(Node<'_>) + '_>) {
-        self.0.for_child_node(self.1, index, f);
+    fn child_node(&mut self, index: usize) -> Option<Node<'_>> {
+        self.0.child_node(self.1, index)
     }
 
     fn size_rules(&mut self, sizer: SizeCx, axis: AxisInfo) -> SizeRules {
@@ -218,13 +218,12 @@ impl<'a> Node<'a> {
     ///
     /// Calls the closure exactly when `index < self.num_children()`.
     #[inline(always)]
-    pub fn for_child(&mut self, index: usize, f: impl FnOnce(Node<'_>)) {
-        let f: Box<dyn for<'b> FnOnce(Node<'b>)> = Box::new(f);
+    pub fn get_child(&mut self, index: usize) -> Option<Node<'_>> {
         cfg_if::cfg_if! {
             if #[cfg(feature = "unsafe_node")] {
-                self.0.for_child_node(self.1, index, f);
+                self.0.child_node(self.1, index)
             } else {
-                self.0.for_child_node(index, f);
+                self.0.child_node(index)
             }
         }
     }
@@ -234,12 +233,17 @@ impl<'a> Node<'a> {
     pub fn for_children(&mut self, mut f: impl FnMut(Node<'_>)) {
         for index in 0..self.0.num_children() {
             let f: Box<dyn for<'b> FnOnce(Node<'b>)> = Box::new(&mut f);
-            cfg_if::cfg_if! {
-                if #[cfg(feature = "unsafe_node")] {
-                    self.0.for_child_node(self.1, index, f);
-                } else {
-                    self.0.for_child_node(index, f);
+            let opt_node = {
+                cfg_if::cfg_if! {
+                    if #[cfg(feature = "unsafe_node")] {
+                        self.0.child_node(self.1, index)
+                    } else {
+                        self.0.child_node(index)
+                    }
                 }
+            };
+            if let Some(node) = opt_node {
+                f(node);
             }
         }
     }
@@ -259,10 +263,12 @@ impl<'a> Node<'a> {
     #[inline(always)]
     pub fn find_node<F: FnOnce(Node<'_>) -> T, T>(&mut self, id: &Id, cb: F) -> Option<T> {
         if let Some(index) = self.find_child_index(id) {
-            let mut result = None;
-            let out = &mut result;
-            self.for_child(index, |mut node| *out = node.find_node(id, cb));
-            result
+            if let Some(mut node) = self.get_child(index) {
+                node.find_node(id, cb)
+            } else {
+                debug_assert!(false);
+                None
+            }
         } else if self.eq_id(id) {
             Some(cb(self.re()))
         } else {

crates/kas-core/src/core/tile.rs

@@ -91,7 +91,7 @@ pub trait Tile: Layout {
     ///
     /// This method is usually implemented automatically by the `#[widget]`
     /// macro. It should be implemented directly if and only if
-    /// [`Tile::get_child`] and [`Widget::for_child_node`] are
+    /// [`Tile::get_child`] and [`Widget::child_node`] are
     /// implemented directly.
     fn num_children(&self) -> usize {
         unimplemented!() // make rustdoc show that this is a provided method

crates/kas-core/src/core/widget.rs

@@ -102,8 +102,9 @@ pub trait Events: Widget + Sized {
         for index in 0..self.num_children() {
             let id = self.make_child_id(index);
             if id.is_valid() {
-                self.as_node(data)
-                    .for_child(index, |node| cx.configure(node, id));
+                if let Some(node) = self.as_node(data).get_child(index) {
+                    cx.configure(node, id);
+                }
             }
         }
     }
@@ -134,7 +135,9 @@ pub trait Events: Widget + Sized {
     /// Use [`ConfigCx::update`].
     fn update_recurse(&mut self, cx: &mut ConfigCx, data: &Self::Data) {
         for index in 0..self.num_children() {
-            self.as_node(data).for_child(index, |node| cx.update(node));
+            if let Some(node) = self.as_node(data).get_child(index) {
+                cx.update(node);
+            }
         }
     }
 
@@ -315,7 +318,7 @@ pub enum NavAdvance {
 /// -   **Core** methods of [`Tile`] are *always* implemented via the [`#widget`]
 ///     macro, whether or not an `impl Tile { ... }` item is present.
 /// -   **Introspection** methods [`Tile::num_children`], [`Tile::get_child`]
-///     and [`Widget::for_child_node`] are implemented by the [`#widget`] macro
+///     and [`Widget::child_node`] are implemented by the [`#widget`] macro
 ///     in most cases: child widgets embedded within a layout descriptor or
 ///     included as fields marked with `#[widget]` are enumerated.
 /// -   **Introspection** methods [`Tile::find_child_index`] and
@@ -362,13 +365,8 @@ pub trait Widget: Tile {
     ///
     /// It is recommended to use the methods on [`Node`]
     /// instead of calling this method.
-    fn for_child_node(
-        &mut self,
-        data: &Self::Data,
-        index: usize,
-        closure: Box<dyn FnOnce(Node<'_>) + '_>,
-    ) {
-        let _ = (data, index, closure);
+    fn child_node<'n>(&'n mut self, data: &'n Self::Data, index: usize) -> Option<Node<'n>> {
+        let _ = (data, index);
         unimplemented!() // make rustdoc show that this is a provided method
     }
 

crates/kas-macros/src/collection.rs

@@ -356,7 +356,7 @@ impl Collection {
                 #index => Some(&mut self.#path),
             });
             for_node_rules.append_all(quote! {
-                #index => closure(self.#path.as_node(data)),
+                #index => Some(self.#path.as_node(data)),
             });
         }
 
@@ -398,16 +398,16 @@ impl Collection {
                     _ => None,
                 }
             }
-            fn for_node(
-                &mut self,
-                data: &Self::Data,
+            #[inline]
+            fn child_node<'__n>(
+                &'__n mut self,
+                data: &'__n Self::Data,
                 index: usize,
-                closure: Box<dyn FnOnce(::kas::Node<'_>) + '_>,
-            ) {
+            ) -> Option<::kas::Node<'__n>> {
                 use ::kas::Widget;
                 match index {
                     #for_node_rules
-                    _ => (),
+                    _ => None,
                 }
             }
         };

crates/kas-macros/src/widget.rs

@@ -37,7 +37,7 @@ pub fn widget(attr_span: Span, mut args: WidgetArgs, scope: &mut Scope) -> Resul
 
     let mut num_children = None;
     let mut get_child = None;
-    let mut for_child_node = None;
+    let mut child_node = None;
     let mut find_child_index = None;
     let mut make_child_id = None;
     for (index, impl_) in scope.impls.iter().enumerate() {
@@ -50,8 +50,8 @@ pub fn widget(attr_span: Span, mut args: WidgetArgs, scope: &mut Scope) -> Resul
 
                 for item in &impl_.items {
                     if let ImplItem::Fn(ref item) = item {
-                        if item.sig.ident == "for_child_node" {
-                            for_child_node = Some(item.sig.ident.clone());
+                        if item.sig.ident == "child_node" {
+                            child_node = Some(item.sig.ident.clone());
                         }
                     } else if let ImplItem::Type(ref item) = item {
                         if item.ident == "Data" {
@@ -293,11 +293,11 @@ pub fn widget(attr_span: Span, mut args: WidgetArgs, scope: &mut Scope) -> Resul
         if get_child.is_none() {
             emit_warning!(span, "fn num_children without fn get_child");
         }
-        if for_child_node.is_none() {
-            emit_warning!(span, "fn num_children without fn for_child_node");
+        if child_node.is_none() {
+            emit_warning!(span, "fn num_children without fn child_node");
         }
     }
-    if let Some(span) = get_child.as_ref().or(for_child_node.as_ref()) {
+    if let Some(span) = get_child.as_ref().or(child_node.as_ref()) {
         if num_children.is_none() {
             emit_warning!(span, "associated impl of `fn Tile::num_children` required");
         }
@@ -321,7 +321,7 @@ pub fn widget(attr_span: Span, mut args: WidgetArgs, scope: &mut Scope) -> Resul
         #core_path.status.require_rect(&#core_path._id);
     };
 
-    let do_impl_widget_children = get_child.is_none() && for_child_node.is_none();
+    let do_impl_widget_children = get_child.is_none() && child_node.is_none();
     let fns_get_child = if do_impl_widget_children {
         let mut get_rules = quote! {};
         for (index, child) in children.iter().enumerate() {
@@ -349,7 +349,7 @@ pub fn widget(attr_span: Span, mut args: WidgetArgs, scope: &mut Scope) -> Resul
         let item_idents = collect_idents(widget_impl);
         let has_item = |name| item_idents.iter().any(|(_, ident)| ident == name);
 
-        // If the user impls Widget, they must supply type Data and fn for_child_node
+        // If the user impls Widget, they must supply type Data and fn child_node
 
         // Always impl fn as_node
         widget_impl.items.push(Verbatim(widget_as_node()));
@@ -841,26 +841,25 @@ pub fn impl_widget(
             };
 
             get_mut_rules.append_all(if let Some(ref data) = child.data_binding {
-                quote! { #i => closure(#path.as_node(#data)), }
+                quote! { #i => Some(#path.as_node(#data)), }
             } else {
                 if let Some(ref span) = child.attr_span {
-                    quote_spanned! {*span=> #i => closure(#path.as_node(data)), }
+                    quote_spanned! {*span=> #i => Some(#path.as_node(data)), }
                 } else {
-                    quote! { #i => closure(#path.as_node(data)), }
+                    quote! { #i => Some(#path.as_node(data)), }
                 }
             });
         }
 
         quote! {
-            fn for_child_node(
-                &mut self,
-                data: &Self::Data,
+            fn child_node<'__n>(
+                &'__n mut self,
+                data: &'__n Self::Data,
                 index: usize,
-                closure: Box<dyn FnOnce(::kas::Node<'_>) + '_>,
-            ) {
+            ) -> Option<::kas::Node<'__n>> {
                 match index {
                     #get_mut_rules
-                    _ => (),
+                    _ => None,
                 }
             }
         }
@@ -885,7 +884,7 @@ pub fn impl_widget(
 pub fn widget_as_node() -> Toks {
     quote! {
         #[inline]
-        fn as_node<'a>(&'a mut self, data: &'a Self::Data) -> ::kas::Node<'a> {
+        fn as_node<'__a>(&'__a mut self, data: &'__a Self::Data) -> ::kas::Node<'__a> {
             ::kas::Node::new(self, data)
         }
     }

crates/kas-macros/src/widget_derive.rs

@@ -274,16 +274,15 @@ pub fn widget(_attr_span: Span, args: WidgetArgs, scope: &mut Scope) -> Result<(
 
     // Widget methods are derived. Cost: cannot override any Events methods or translation().
     let fn_as_node = widget_as_node();
-    let fn_for_child_node = quote! {
+    let fn_child_node = quote! {
         #[inline]
-        fn for_child_node(
-            &mut self,
-            data: &Self::Data,
+        fn child_node<'__n>(
+            &'__n mut self,
+            data: &'__n Self::Data,
             index: usize,
-            closure: Box<dyn FnOnce(::kas::Node<'_>) + '_>,
-        ) {
+        ) -> Option<::kas::Node<'__n>> {
             #map_data
-            self.#inner.for_child_node(data, index, closure)
+            self.#inner.child_node(data, index)
         }
     };
     let fn_configure = quote! {
@@ -358,8 +357,8 @@ pub fn widget(_attr_span: Span, args: WidgetArgs, scope: &mut Scope) -> Result<(
             widget_impl.items.push(Verbatim(fn_as_node));
         }
 
-        if !has_item("for_child_node") {
-            widget_impl.items.push(Verbatim(fn_for_child_node));
+        if !has_item("child_node") {
+            widget_impl.items.push(Verbatim(fn_child_node));
         }
 
         if !has_item("_configure") {
@@ -386,7 +385,7 @@ pub fn widget(_attr_span: Span, args: WidgetArgs, scope: &mut Scope) -> Result<(
             impl #impl_generics ::kas::Widget for #impl_target {
                 type Data = #data_ty;
                 #fn_as_node
-                #fn_for_child_node
+                #fn_child_node
                 #fn_configure
                 #fn_update
                 #fn_send