Fix `responsive`, `component`, and `lazy` always returning an `overlay`

3 files changed, 80 insertions, 61 deletions

diff --git a/widget/src/lazy.rs b/widget/src/lazy.rs
index 221f9de3..6642c986 100644
--- a/widget/src/lazy.rs
+++ b/widget/src/lazy.rs
@@ -270,29 +270,40 @@ where
         renderer: &Renderer,
         translation: Vector,
     ) -> Option<overlay::Element<'_, Message, Theme, Renderer>> {
-        let overlay = Overlay(Some(
-            InnerBuilder {
-                cell: self.element.borrow().as_ref().unwrap().clone(),
-                element: self
-                    .element
-                    .borrow()
-                    .as_ref()
-                    .unwrap()
-                    .borrow_mut()
-                    .take()
-                    .unwrap(),
-                tree: &mut tree.children[0],
-                overlay_builder: |element, tree| {
-                    element
-                        .as_widget_mut()
-                        .overlay(tree, layout, renderer, translation)
-                        .map(|overlay| RefCell::new(Nested::new(overlay)))
-                },
-            }
-            .build(),
-        ));
-
-        Some(overlay::Element::new(Box::new(overlay)))
+        let overlay = InnerBuilder {
+            cell: self.element.borrow().as_ref().unwrap().clone(),
+            element: self
+                .element
+                .borrow()
+                .as_ref()
+                .unwrap()
+                .borrow_mut()
+                .take()
+                .unwrap(),
+            tree: &mut tree.children[0],
+            overlay_builder: |element, tree| {
+                element
+                    .as_widget_mut()
+                    .overlay(tree, layout, renderer, translation)
+                    .map(|overlay| RefCell::new(Nested::new(overlay)))
+            },
+        }
+        .build();
+
+        #[allow(clippy::redundant_closure_for_method_calls)]
+        if overlay.with_overlay(|overlay| overlay.is_some()) {
+            Some(overlay::Element::new(Box::new(Overlay(Some(overlay)))))
+        } else {
+            let heads = overlay.into_heads();
+
+            // - You may not like it, but this is what peak performance looks like
+            // - TODO: Get rid of ouroboros, for good
+            // - What?!
+            *self.element.borrow().as_ref().unwrap().borrow_mut() =
+                Some(heads.element);
+
+            None
+        }
     }
 }
 
diff --git a/widget/src/lazy/component.rs b/widget/src/lazy/component.rs
index 2bdfa2c0..c7bc1264 100644
--- a/widget/src/lazy/component.rs
+++ b/widget/src/lazy/component.rs
@@ -446,44 +446,48 @@ where
     ) -> Option<overlay::Element<'b, Message, Theme, Renderer>> {
         self.rebuild_element_if_necessary();
 
-        let tree = tree
-            .state
-            .downcast_mut::<Rc<RefCell<Option<Tree>>>>()
-            .borrow_mut()
-            .take()
-            .unwrap();
-
-        let overlay = Overlay(Some(
-            InnerBuilder {
-                instance: self,
-                tree,
-                types: PhantomData,
-                overlay_builder: |instance, tree| {
-                    instance.state.get_mut().as_mut().unwrap().with_element_mut(
-                        move |element| {
-                            element
-                                .as_mut()
-                                .unwrap()
-                                .as_widget_mut()
-                                .overlay(
-                                    &mut tree.children[0],
-                                    layout,
-                                    renderer,
-                                    translation,
-                                )
-                                .map(|overlay| {
-                                    RefCell::new(Nested::new(overlay))
-                                })
-                        },
-                    )
-                },
-            }
-            .build(),
-        ));
+        let state = tree.state.downcast_mut::<Rc<RefCell<Option<Tree>>>>();
+        let tree = state.borrow_mut().take().unwrap();
+
+        let overlay = InnerBuilder {
+            instance: self,
+            tree,
+            types: PhantomData,
+            overlay_builder: |instance, tree| {
+                instance.state.get_mut().as_mut().unwrap().with_element_mut(
+                    move |element| {
+                        element
+                            .as_mut()
+                            .unwrap()
+                            .as_widget_mut()
+                            .overlay(
+                                &mut tree.children[0],
+                                layout,
+                                renderer,
+                                translation,
+                            )
+                            .map(|overlay| RefCell::new(Nested::new(overlay)))
+                    },
+                )
+            },
+        }
+        .build();
+
+        #[allow(clippy::redundant_closure_for_method_calls)]
+        if overlay.with_overlay(|overlay| overlay.is_some()) {
+            Some(overlay::Element::new(Box::new(OverlayInstance {
+                overlay: Some(Overlay(Some(overlay))), // Beautiful, I know
+            })))
+        } else {
+            let heads = overlay.into_heads();
+
+            // - You may not like it, but this is what peak performance looks like
+            // - TODO: Get rid of ouroboros, for good
+            // - What?!
+            *state.borrow_mut() = Some(heads.tree);
 
-        Some(overlay::Element::new(Box::new(OverlayInstance {
-            overlay: Some(overlay),
-        })))
+            None
+        }
     }
 }
 
diff --git a/widget/src/lazy/responsive.rs b/widget/src/lazy/responsive.rs
index 2b92c6dc..a7a99f56 100644
--- a/widget/src/lazy/responsive.rs
+++ b/widget/src/lazy/responsive.rs
@@ -320,7 +320,11 @@ where
         }
         .build();
 
-        Some(overlay::Element::new(Box::new(overlay)))
+        if overlay.with_overlay(|(overlay, _layout)| overlay.is_some()) {
+            Some(overlay::Element::new(Box::new(overlay)))
+        } else {
+            None
+        }
     }
 }