From 88ef74ec8f1ac1544e4b97544132df4d87f1f0d8 Mon Sep 17 00:00:00 2001
From: Marshall Bowers <elliott.codes@gmail.com>
Date: Thu, 26 Oct 2023 15:20:38 +0200
Subject: [PATCH] Checkpoint: Compiling after view type removal

---
 crates/gpui2_macros/src/derive_component.rs   |  2 +-
 crates/storybook2/src/stories/z_index.rs      | 27 ++----
 crates/ui2/src/components/assistant_panel.rs  | 14 +--
 crates/ui2/src/components/breadcrumb.rs       | 26 ++----
 crates/ui2/src/components/buffer.rs           | 28 ++----
 crates/ui2/src/components/chat_panel.rs       | 34 +++----
 crates/ui2/src/components/collab_panel.rs     | 27 ++----
 crates/ui2/src/components/command_palette.rs  | 28 ++----
 crates/ui2/src/components/context_menu.rs     | 36 +++-----
 crates/ui2/src/components/copilot.rs          | 28 ++----
 crates/ui2/src/components/editor_pane.rs      |  8 +-
 crates/ui2/src/components/facepile.rs         | 24 ++---
 crates/ui2/src/components/icon_button.rs      | 16 +---
 crates/ui2/src/components/keybinding.rs       | 37 +++-----
 .../ui2/src/components/language_selector.rs   | 28 ++----
 crates/ui2/src/components/list.rs             | 91 +++++++++----------
 crates/ui2/src/components/modal.rs            | 10 +-
 crates/ui2/src/components/multi_buffer.rs     | 32 +++----
 .../ui2/src/components/notification_toast.rs  | 10 +-
 .../ui2/src/components/notifications_panel.rs | 23 ++---
 crates/ui2/src/components/palette.rs          | 38 +++-----
 crates/ui2/src/components/panel.rs            | 22 ++---
 crates/ui2/src/components/panes.rs            |  9 +-
 crates/ui2/src/components/player_stack.rs     | 10 +-
 crates/ui2/src/components/project_panel.rs    | 28 ++----
 crates/ui2/src/components/recent_projects.rs  | 28 ++----
 crates/ui2/src/components/tab.rs              | 24 ++---
 crates/ui2/src/components/tab_bar.rs          | 28 ++----
 crates/ui2/src/components/terminal.rs         | 28 ++----
 crates/ui2/src/components/theme_selector.rs   | 28 ++----
 crates/ui2/src/components/toast.rs            | 20 ++--
 crates/ui2/src/components/toolbar.rs          | 19 ++--
 crates/ui2/src/components/traffic_lights.rs   | 32 +++----
 crates/ui2/src/element_ext.rs                 |  4 +-
 crates/ui2/src/elements/avatar.rs             | 24 ++---
 crates/ui2/src/elements/button.rs             | 50 +++++-----
 crates/ui2/src/elements/details.rs            | 24 ++---
 crates/ui2/src/elements/icon.rs               | 24 ++---
 crates/ui2/src/elements/input.rs              | 24 ++---
 crates/ui2/src/elements/label.rs              | 32 +++----
 crates/ui2/src/elements/stack.rs              |  6 +-
 crates/ui2/src/elements/tool_divider.rs       | 14 +--
 crates/ui2/src/static_data.rs                 | 34 +++----
 crates/ui2/src/story.rs                       |  8 +-
 44 files changed, 392 insertions(+), 695 deletions(-)

diff --git a/crates/gpui2_macros/src/derive_component.rs b/crates/gpui2_macros/src/derive_component.rs
index 97cfac1ae53e747894541fd6f7b222a688bafbf0..f30ff3748fd90fd745a567c54b7727cc6f97d068 100644
--- a/crates/gpui2_macros/src/derive_component.rs
+++ b/crates/gpui2_macros/src/derive_component.rs
@@ -19,7 +19,7 @@ pub fn derive_component(input: TokenStream) -> TokenStream {
         }) {
             quote! { #first_type_param }
         } else {
-            trait_generics.params.push(parse_quote! { V: 'static + Send + Sync });
+            trait_generics.params.push(parse_quote! { V: 'static });
             quote! { V }
         }
     };
diff --git a/crates/storybook2/src/stories/z_index.rs b/crates/storybook2/src/stories/z_index.rs
index d68b4916c247e6aabd012dac936a899b6dba6a8e..7fa078c4e3fc70b7a3900c958f5df02c854d4390 100644
--- a/crates/storybook2/src/stories/z_index.rs
+++ b/crates/storybook2/src/stories/z_index.rs
@@ -1,4 +1,3 @@
-use std::marker::PhantomData;
 
 use gpui2::{px, rgb, Div, Hsla};
 use ui::prelude::*;
@@ -8,18 +7,14 @@ use crate::story::Story;
 /// A reimplementation of the MDN `z-index` example, found here:
 /// [https://developer.mozilla.org/en-US/docs/Web/CSS/z-index](https://developer.mozilla.org/en-US/docs/Web/CSS/z-index).
 #[derive(Component)]
-pub struct ZIndexStory<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
-}
+pub struct ZIndexStory;
 
-impl<S: 'static + Send + Sync> ZIndexStory<S> {
+impl ZIndexStory {
     pub fn new() -> Self {
-        Self {
-            state_type: PhantomData,
-        }
+        Self
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         Story::container(cx)
             .child(Story::title(cx, "z-index"))
             .child(
@@ -86,23 +81,19 @@ trait Styles: Styled + Sized {
     }
 }
 
-impl<V: 'static + Send + Sync> Styles for Div<V> {}
+impl<V: 'static> Styles for Div<V> {}
 
 #[derive(Component)]
-struct ZIndexExample<V: 'static + Send + Sync> {
-    view_type: PhantomData<V>,
+struct ZIndexExample {
     z_index: u32,
 }
 
-impl<V: 'static + Send + Sync> ZIndexExample<V> {
+impl ZIndexExample {
     pub fn new(z_index: u32) -> Self {
-        Self {
-            view_type: PhantomData,
-            z_index,
-        }
+        Self { z_index }
     }
 
-    fn render(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
+    fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
         div()
             .relative()
             .size_full()
diff --git a/crates/ui2/src/components/assistant_panel.rs b/crates/ui2/src/components/assistant_panel.rs
index 25f24f14836b00a7c297e2b3faf8af3e41334e64..defd05f500904e1b6a4974300c49df8f35745fe9 100644
--- a/crates/ui2/src/components/assistant_panel.rs
+++ b/crates/ui2/src/components/assistant_panel.rs
@@ -1,22 +1,18 @@
-use std::marker::PhantomData;
-
 use gpui2::{rems, AbsoluteLength};
 
 use crate::prelude::*;
 use crate::{Icon, IconButton, Label, Panel, PanelSide};
 
 #[derive(Component)]
-pub struct AssistantPanel<S: 'static + Send + Sync> {
+pub struct AssistantPanel {
     id: ElementId,
-    state_type: PhantomData<S>,
     current_side: PanelSide,
 }
 
-impl<S: 'static + Send + Sync> AssistantPanel<S> {
+impl AssistantPanel {
     pub fn new(id: impl Into<ElementId>) -> Self {
         Self {
             id: id.into(),
-            state_type: PhantomData,
             current_side: PanelSide::default(),
         }
     }
@@ -26,7 +22,7 @@ impl<S: 'static + Send + Sync> AssistantPanel<S> {
         self
     }
 
-    fn render(self, view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<V: 'static>(self, view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
         Panel::new(self.id.clone(), cx)
             .children(vec![div()
                 .flex()
@@ -92,9 +88,9 @@ mod stories {
             Self {}
         }
 
-        fn render<V: 'static + Send + Sync>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
+        fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
             Story::container(cx)
-                .child(Story::title_for::<_, AssistantPanel<V>>(cx))
+                .child(Story::title_for::<_, AssistantPanel>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(AssistantPanel::new("assistant-panel"))
         }
diff --git a/crates/ui2/src/components/breadcrumb.rs b/crates/ui2/src/components/breadcrumb.rs
index 289c0710212fc5aaf2e2703985f26ebc832b6fda..3cba3b7248a668f5499a7da35b739a3c84711422 100644
--- a/crates/ui2/src/components/breadcrumb.rs
+++ b/crates/ui2/src/components/breadcrumb.rs
@@ -1,8 +1,6 @@
-use std::marker::PhantomData;
 use std::path::PathBuf;
 
 use gpui2::Div;
-
 use crate::prelude::*;
 use crate::{h_stack, HighlightedText};
 
@@ -10,28 +8,26 @@ use crate::{h_stack, HighlightedText};
 pub struct Symbol(pub Vec<HighlightedText>);
 
 #[derive(Component)]
-pub struct Breadcrumb<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
+pub struct Breadcrumb {
     path: PathBuf,
     symbols: Vec<Symbol>,
 }
 
-impl<S: 'static + Send + Sync> Breadcrumb<S> {
+impl Breadcrumb {
     pub fn new(path: PathBuf, symbols: Vec<Symbol>) -> Self {
         Self {
-            state_type: PhantomData,
             path,
             symbols,
         }
     }
 
-    fn render_separator(&self, cx: &WindowContext) -> Div<S> {
+    fn render_separator<V: 'static>(&self, cx: &WindowContext) -> Div<V> {
         let theme = theme(cx);
 
         div().child(" › ").text_color(theme.text_muted)
     }
 
-    fn render(self, view_state: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<V: 'static>(self, view_state: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
         let theme = theme(cx);
 
         let symbols_len = self.symbols.len();
@@ -87,22 +83,18 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct BreadcrumbStory<S: 'static + Send + Sync> {
-        state_type: PhantomData<S>,
-    }
+    pub struct BreadcrumbStory;
 
-    impl<S: 'static + Send + Sync> BreadcrumbStory<S> {
+    impl BreadcrumbStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, view_state: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<V: 'static>(self, view_state: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
             let theme = theme(cx);
 
             Story::container(cx)
-                .child(Story::title_for::<_, Breadcrumb<S>>(cx))
+                .child(Story::title_for::<_, Breadcrumb>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(Breadcrumb::new(
                     PathBuf::from_str("crates/ui/src/components/toolbar.rs").unwrap(),
diff --git a/crates/ui2/src/components/buffer.rs b/crates/ui2/src/components/buffer.rs
index ffef5c4039e6f391ef423ab8f0014728682563ed..b4ccb89b5c994665a71c35f4a41924288849b97f 100644
--- a/crates/ui2/src/components/buffer.rs
+++ b/crates/ui2/src/components/buffer.rs
@@ -1,5 +1,3 @@
-use std::marker::PhantomData;
-
 use gpui2::{Hsla, WindowContext};
 
 use crate::prelude::*;
@@ -110,9 +108,8 @@ impl BufferRow {
 }
 
 #[derive(Component, Clone)]
-pub struct Buffer<S: 'static + Send + Sync + Clone> {
+pub struct Buffer {
     id: ElementId,
-    state_type: PhantomData<S>,
     rows: Option<BufferRows>,
     readonly: bool,
     language: Option<String>,
@@ -120,11 +117,10 @@ pub struct Buffer<S: 'static + Send + Sync + Clone> {
     path: Option<String>,
 }
 
-impl<S: 'static + Send + Sync + Clone> Buffer<S> {
+impl Buffer {
     pub fn new(id: impl Into<ElementId>) -> Self {
         Self {
             id: id.into(),
-            state_type: PhantomData,
             rows: Some(BufferRows::default()),
             readonly: false,
             language: None,
@@ -158,7 +154,7 @@ impl<S: 'static + Send + Sync + Clone> Buffer<S> {
         self
     }
 
-    fn render_row(row: BufferRow, cx: &WindowContext) -> impl Component<S> {
+    fn render_row<S: 'static>(row: BufferRow, cx: &WindowContext) -> impl Component<S> {
         let theme = theme(cx);
 
         let line_background = if row.current {
@@ -208,7 +204,7 @@ impl<S: 'static + Send + Sync + Clone> Buffer<S> {
             }))
     }
 
-    fn render_rows(&self, cx: &WindowContext) -> Vec<impl Component<S>> {
+    fn render_rows<S: 'static>(&self, cx: &WindowContext) -> Vec<impl Component<S>> {
         match &self.rows {
             Some(rows) => rows
                 .rows
@@ -219,7 +215,7 @@ impl<S: 'static + Send + Sync + Clone> Buffer<S> {
         }
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         let theme = theme(cx);
         let rows = self.render_rows(cx);
 
@@ -247,22 +243,18 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct BufferStory<S: 'static + Send + Sync + Clone> {
-        state_type: PhantomData<S>,
-    }
+    pub struct BufferStory;
 
-    impl<S: 'static + Send + Sync + Clone> BufferStory<S> {
+    impl BufferStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
             let theme = theme(cx);
 
             Story::container(cx)
-                .child(Story::title_for::<_, Buffer<S>>(cx))
+                .child(Story::title_for::<_, Buffer>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(div().w(rems(64.)).h_96().child(empty_buffer_example()))
                 .child(Story::label(cx, "Hello World (Rust)"))
diff --git a/crates/ui2/src/components/chat_panel.rs b/crates/ui2/src/components/chat_panel.rs
index 2800207b3423088c449f7e54d055fc6a78bb0c3c..e4494f461487365187aed31839a455bf38d655a5 100644
--- a/crates/ui2/src/components/chat_panel.rs
+++ b/crates/ui2/src/components/chat_panel.rs
@@ -1,17 +1,15 @@
-use std::marker::PhantomData;
-
 use chrono::NaiveDateTime;
 
 use crate::prelude::*;
 use crate::{Icon, IconButton, Input, Label, LabelColor};
 
 #[derive(Component)]
-pub struct ChatPanel<S: 'static + Send + Sync> {
+pub struct ChatPanel {
     element_id: ElementId,
-    messages: Vec<ChatMessage<S>>,
+    messages: Vec<ChatMessage>,
 }
 
-impl<S: 'static + Send + Sync> ChatPanel<S> {
+impl ChatPanel {
     pub fn new(element_id: impl Into<ElementId>) -> Self {
         Self {
             element_id: element_id.into(),
@@ -19,12 +17,12 @@ impl<S: 'static + Send + Sync> ChatPanel<S> {
         }
     }
 
-    pub fn messages(mut self, messages: Vec<ChatMessage<S>>) -> Self {
+    pub fn messages(mut self, messages: Vec<ChatMessage>) -> Self {
         self.messages = messages;
         self
     }
 
-    fn render(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         div()
             .id(self.element_id.clone())
             .flex()
@@ -71,24 +69,22 @@ impl<S: 'static + Send + Sync> ChatPanel<S> {
 }
 
 #[derive(Component)]
-pub struct ChatMessage<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
+pub struct ChatMessage {
     author: String,
     text: String,
     sent_at: NaiveDateTime,
 }
 
-impl<S: 'static + Send + Sync> ChatMessage<S> {
+impl ChatMessage {
     pub fn new(author: String, text: String, sent_at: NaiveDateTime) -> Self {
         Self {
-            state_type: PhantomData,
             author,
             text,
             sent_at,
         }
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         div()
             .flex()
             .flex_col()
@@ -118,20 +114,16 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct ChatPanelStory<S: 'static + Send + Sync> {
-        state_type: PhantomData<S>,
-    }
+    pub struct ChatPanelStory;
 
-    impl<S: 'static + Send + Sync> ChatPanelStory<S> {
+    impl ChatPanelStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
             Story::container(cx)
-                .child(Story::title_for::<_, ChatPanel<S>>(cx))
+                .child(Story::title_for::<_, ChatPanel>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(
                     Panel::new("chat-panel-1-outer", cx)
diff --git a/crates/ui2/src/components/collab_panel.rs b/crates/ui2/src/components/collab_panel.rs
index 8f30b33da0f1707fb581c7f58e048170b490d091..6d2cbd8e14e402bfd2bc0d1480d4408c4767765d 100644
--- a/crates/ui2/src/components/collab_panel.rs
+++ b/crates/ui2/src/components/collab_panel.rs
@@ -3,23 +3,18 @@ use crate::{
     static_collab_panel_channels, static_collab_panel_current_call, v_stack, Icon, List,
     ListHeader, ToggleState,
 };
-use std::marker::PhantomData;
 
 #[derive(Component)]
-pub struct CollabPanel<S: 'static + Send + Sync> {
+pub struct CollabPanel {
     id: ElementId,
-    state_type: PhantomData<S>,
 }
 
-impl<S: 'static + Send + Sync> CollabPanel<S> {
+impl CollabPanel {
     pub fn new(id: impl Into<ElementId>) -> Self {
-        Self {
-            id: id.into(),
-            state_type: PhantomData,
-        }
+        Self { id: id.into() }
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         let theme = theme(cx);
 
         v_stack()
@@ -99,20 +94,16 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct CollabPanelStory<S: 'static + Send + Sync> {
-        state_type: PhantomData<S>,
-    }
+    pub struct CollabPanelStory;
 
-    impl<S: 'static + Send + Sync> CollabPanelStory<S> {
+    impl CollabPanelStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
             Story::container(cx)
-                .child(Story::title_for::<_, CollabPanel<S>>(cx))
+                .child(Story::title_for::<_, CollabPanel>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(CollabPanel::new("collab-panel"))
         }
diff --git a/crates/ui2/src/components/command_palette.rs b/crates/ui2/src/components/command_palette.rs
index d00b9b77437ed8c8ca7e68f18540a1148d1fd817..065ee9a052bdbe219cff6b7a4b4fff68f2c81aea 100644
--- a/crates/ui2/src/components/command_palette.rs
+++ b/crates/ui2/src/components/command_palette.rs
@@ -1,23 +1,17 @@
-use std::marker::PhantomData;
-
 use crate::prelude::*;
 use crate::{example_editor_actions, OrderMethod, Palette};
 
 #[derive(Component)]
-pub struct CommandPalette<S: 'static + Send + Sync> {
+pub struct CommandPalette {
     id: ElementId,
-    state_type: PhantomData<S>,
 }
 
-impl<S: 'static + Send + Sync> CommandPalette<S> {
+impl CommandPalette {
     pub fn new(id: impl Into<ElementId>) -> Self {
-        Self {
-            id: id.into(),
-            state_type: PhantomData,
-        }
+        Self { id: id.into() }
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         div().id(self.id.clone()).child(
             Palette::new("palette")
                 .items(example_editor_actions())
@@ -38,20 +32,16 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct CommandPaletteStory<S: 'static + Send + Sync> {
-        state_type: PhantomData<S>,
-    }
+    pub struct CommandPaletteStory;
 
-    impl<S: 'static + Send + Sync> CommandPaletteStory<S> {
+    impl CommandPaletteStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
             Story::container(cx)
-                .child(Story::title_for::<_, CommandPalette<S>>(cx))
+                .child(Story::title_for::<_, CommandPalette>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(CommandPalette::new("command-palette"))
         }
diff --git a/crates/ui2/src/components/context_menu.rs b/crates/ui2/src/components/context_menu.rs
index b52051daa3eed70497d3246698937343488b5cc6..3e0323d9422af69bf5b204ca935d9756a160f5e9 100644
--- a/crates/ui2/src/components/context_menu.rs
+++ b/crates/ui2/src/components/context_menu.rs
@@ -1,14 +1,14 @@
 use crate::{prelude::*, ListItemVariant};
 use crate::{v_stack, Label, List, ListEntry, ListItem, ListSeparator, ListSubHeader};
 
-pub enum ContextMenuItem<S: 'static + Send + Sync> {
+pub enum ContextMenuItem {
     Header(SharedString),
-    Entry(Label<S>),
+    Entry(Label),
     Separator,
 }
 
-impl<S: 'static + Send + Sync> ContextMenuItem<S> {
-    fn to_list_item(self) -> ListItem<S> {
+impl ContextMenuItem {
+    fn to_list_item<V: 'static>(self) -> ListItem<V> {
         match self {
             ContextMenuItem::Header(label) => ListSubHeader::new(label).into(),
             ContextMenuItem::Entry(label) => {
@@ -26,23 +26,23 @@ impl<S: 'static + Send + Sync> ContextMenuItem<S> {
         Self::Separator
     }
 
-    pub fn entry(label: Label<S>) -> Self {
+    pub fn entry(label: Label) -> Self {
         Self::Entry(label)
     }
 }
 
 #[derive(Component)]
-pub struct ContextMenu<S: 'static + Send + Sync> {
-    items: Vec<ContextMenuItem<S>>,
+pub struct ContextMenu {
+    items: Vec<ContextMenuItem>,
 }
 
-impl<S: 'static + Send + Sync> ContextMenu<S> {
-    pub fn new(items: impl IntoIterator<Item = ContextMenuItem<S>>) -> Self {
+impl ContextMenu {
+    pub fn new(items: impl IntoIterator<Item = ContextMenuItem>) -> Self {
         Self {
             items: items.into_iter().collect(),
         }
     }
-    fn render(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         let theme = theme(cx);
 
         v_stack()
@@ -67,27 +67,21 @@ pub use stories::*;
 
 #[cfg(feature = "stories")]
 mod stories {
-    use std::marker::PhantomData;
-
     use crate::story::Story;
 
     use super::*;
 
     #[derive(Component)]
-    pub struct ContextMenuStory<S: 'static + Send + Sync> {
-        state_type: PhantomData<S>,
-    }
+    pub struct ContextMenuStory;
 
-    impl<S: 'static + Send + Sync> ContextMenuStory<S> {
+    impl ContextMenuStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
             Story::container(cx)
-                .child(Story::title_for::<_, ContextMenu<S>>(cx))
+                .child(Story::title_for::<_, ContextMenu>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(ContextMenu::new([
                     ContextMenuItem::header("Section header"),
diff --git a/crates/ui2/src/components/copilot.rs b/crates/ui2/src/components/copilot.rs
index 9e5454ee8aa39dad8a18616b64c65417886b7176..3c48ef20d085b7d5b0f9b44cb80aebf684d05e5f 100644
--- a/crates/ui2/src/components/copilot.rs
+++ b/crates/ui2/src/components/copilot.rs
@@ -1,22 +1,16 @@
-use std::marker::PhantomData;
-
 use crate::{prelude::*, Button, Label, LabelColor, Modal};
 
 #[derive(Component)]
-pub struct CopilotModal<S: 'static + Send + Sync + Clone> {
+pub struct CopilotModal {
     id: ElementId,
-    state_type: PhantomData<S>,
 }
 
-impl<S: 'static + Send + Sync + Clone> CopilotModal<S> {
+impl CopilotModal {
     pub fn new(id: impl Into<ElementId>) -> Self {
-        Self {
-            id: id.into(),
-            state_type: PhantomData,
-        }
+        Self { id: id.into() }
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         div().id(self.id.clone()).child(
             Modal::new("some-id")
                 .title("Connect Copilot to Zed")
@@ -36,20 +30,16 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct CopilotModalStory<S: 'static + Send + Sync + Clone> {
-        state_type: PhantomData<S>,
-    }
+    pub struct CopilotModalStory;
 
-    impl<S: 'static + Send + Sync + Clone> CopilotModalStory<S> {
+    impl CopilotModalStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
             Story::container(cx)
-                .child(Story::title_for::<_, CopilotModal<S>>(cx))
+                .child(Story::title_for::<_, CopilotModal>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(CopilotModal::new("copilot-modal"))
         }
diff --git a/crates/ui2/src/components/editor_pane.rs b/crates/ui2/src/components/editor_pane.rs
index fb26dad7918cb167eade1dc742987a8b1de8357f..9c9638d0579f89e430353816a96c1cab1b2f1613 100644
--- a/crates/ui2/src/components/editor_pane.rs
+++ b/crates/ui2/src/components/editor_pane.rs
@@ -10,10 +10,10 @@ use crate::{
 
 #[derive(Clone)]
 pub struct EditorPane {
-    tabs: Vec<Tab<Self>>,
+    tabs: Vec<Tab>,
     path: PathBuf,
     symbols: Vec<Symbol>,
-    buffer: Buffer<Self>,
+    buffer: Buffer,
     buffer_search: View<BufferSearch>,
     is_buffer_search_open: bool,
 }
@@ -21,10 +21,10 @@ pub struct EditorPane {
 impl EditorPane {
     pub fn new(
         cx: &mut WindowContext,
-        tabs: Vec<Tab<Self>>,
+        tabs: Vec<Tab>,
         path: PathBuf,
         symbols: Vec<Symbol>,
-        buffer: Buffer<Self>,
+        buffer: Buffer,
     ) -> Self {
         Self {
             tabs,
diff --git a/crates/ui2/src/components/facepile.rs b/crates/ui2/src/components/facepile.rs
index 565396e7335900f6418c52c18c4b0552b77b04e2..898489f1edb27551880201d1704068a4b0e4913a 100644
--- a/crates/ui2/src/components/facepile.rs
+++ b/crates/ui2/src/components/facepile.rs
@@ -1,23 +1,19 @@
-use std::marker::PhantomData;
-
 use crate::prelude::*;
 use crate::{Avatar, Player};
 
 #[derive(Component)]
-pub struct Facepile<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
+pub struct Facepile {
     players: Vec<Player>,
 }
 
-impl<S: 'static + Send + Sync> Facepile<S> {
+impl Facepile {
     pub fn new<P: Iterator<Item = Player>>(players: P) -> Self {
         Self {
-            state_type: PhantomData,
             players: players.collect(),
         }
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         let player_count = self.players.len();
         let player_list = self.players.iter().enumerate().map(|(ix, player)| {
             let isnt_last = ix < player_count - 1;
@@ -40,22 +36,18 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct FacepileStory<S: 'static + Send + Sync> {
-        state_type: PhantomData<S>,
-    }
+    pub struct FacepileStory;
 
-    impl<S: 'static + Send + Sync> FacepileStory<S> {
+    impl FacepileStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
             let players = static_players();
 
             Story::container(cx)
-                .child(Story::title_for::<_, Facepile<S>>(cx))
+                .child(Story::title_for::<_, Facepile>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(
                     div()
diff --git a/crates/ui2/src/components/icon_button.rs b/crates/ui2/src/components/icon_button.rs
index fe41de15a0e085837202122a828c752561a2d62a..2891ce6bd837fd2d63d2194387c449dcc321fa23 100644
--- a/crates/ui2/src/components/icon_button.rs
+++ b/crates/ui2/src/components/icon_button.rs
@@ -1,4 +1,3 @@
-use std::marker::PhantomData;
 use std::sync::Arc;
 
 use gpui2::MouseButton;
@@ -6,19 +5,18 @@ use gpui2::MouseButton;
 use crate::{h_stack, prelude::*};
 use crate::{ClickHandler, Icon, IconColor, IconElement};
 
-struct IconButtonHandlers<S: 'static + Send + Sync> {
+struct IconButtonHandlers<S: 'static> {
     click: Option<ClickHandler<S>>,
 }
 
-impl<S: 'static + Send + Sync> Default for IconButtonHandlers<S> {
+impl<S: 'static> Default for IconButtonHandlers<S> {
     fn default() -> Self {
         Self { click: None }
     }
 }
 
 #[derive(Component)]
-pub struct IconButton<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
+pub struct IconButton<S: 'static> {
     id: ElementId,
     icon: Icon,
     color: IconColor,
@@ -27,10 +25,9 @@ pub struct IconButton<S: 'static + Send + Sync> {
     handlers: IconButtonHandlers<S>,
 }
 
-impl<S: 'static + Send + Sync> IconButton<S> {
+impl<S: 'static> IconButton<S> {
     pub fn new(id: impl Into<ElementId>, icon: Icon) -> Self {
         Self {
-            state_type: PhantomData,
             id: id.into(),
             icon,
             color: IconColor::default(),
@@ -60,10 +57,7 @@ impl<S: 'static + Send + Sync> IconButton<S> {
         self
     }
 
-    pub fn on_click(
-        mut self,
-        handler: impl Fn(&mut S, &mut ViewContext<S>) + 'static + Send + Sync,
-    ) -> Self {
+    pub fn on_click(mut self, handler: impl 'static + Fn(&mut S, &mut ViewContext<S>) + Send + Sync) -> Self {
         self.handlers.click = Some(Arc::new(handler));
         self
     }
diff --git a/crates/ui2/src/components/keybinding.rs b/crates/ui2/src/components/keybinding.rs
index d77798ad6c76e6eee84cc21d6ee20d435cc08d0f..2b0eefa4eaa347bf8c6b5b3d05f985921a824298 100644
--- a/crates/ui2/src/components/keybinding.rs
+++ b/crates/ui2/src/components/keybinding.rs
@@ -1,14 +1,11 @@
 use std::collections::HashSet;
-use std::marker::PhantomData;
 
 use strum::{EnumIter, IntoEnumIterator};
 
 use crate::prelude::*;
 
 #[derive(Component)]
-pub struct Keybinding<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
-
+pub struct Keybinding {
     /// A keybinding consists of a key and a set of modifier keys.
     /// More then one keybinding produces a chord.
     ///
@@ -16,10 +13,9 @@ pub struct Keybinding<S: 'static + Send + Sync> {
     keybinding: Vec<(String, ModifierKeys)>,
 }
 
-impl<S: 'static + Send + Sync> Keybinding<S> {
+impl Keybinding {
     pub fn new(key: String, modifiers: ModifierKeys) -> Self {
         Self {
-            state_type: PhantomData,
             keybinding: vec![(key, modifiers)],
         }
     }
@@ -29,12 +25,11 @@ impl<S: 'static + Send + Sync> Keybinding<S> {
         second_note: (String, ModifierKeys),
     ) -> Self {
         Self {
-            state_type: PhantomData,
             keybinding: vec![first_note, second_note],
         }
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         div()
             .flex()
             .gap_2()
@@ -55,20 +50,16 @@ impl<S: 'static + Send + Sync> Keybinding<S> {
 }
 
 #[derive(Component)]
-pub struct Key<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
+pub struct Key {
     key: SharedString,
 }
 
-impl<S: 'static + Send + Sync> Key<S> {
+impl Key {
     pub fn new(key: impl Into<SharedString>) -> Self {
-        Self {
-            state_type: PhantomData,
-            key: key.into(),
-        }
+        Self { key: key.into() }
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         let theme = theme(cx);
 
         div()
@@ -174,22 +165,18 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct KeybindingStory<S: 'static + Send + Sync + Clone> {
-        state_type: PhantomData<S>,
-    }
+    pub struct KeybindingStory;
 
-    impl<S: 'static + Send + Sync + Clone> KeybindingStory<S> {
+    impl KeybindingStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
             let all_modifier_permutations = ModifierKey::iter().permutations(2);
 
             Story::container(cx)
-                .child(Story::title_for::<_, Keybinding<S>>(cx))
+                .child(Story::title_for::<_, Keybinding>(cx))
                 .child(Story::label(cx, "Single Key"))
                 .child(Keybinding::new("Z".to_string(), ModifierKeys::new()))
                 .child(Story::label(cx, "Single Key with Modifier"))
diff --git a/crates/ui2/src/components/language_selector.rs b/crates/ui2/src/components/language_selector.rs
index ebb8f152f820562bea936070a36d8ad8cb46a1d3..db42b28281171e243a1d8b7c47e6d67ac1c4dd02 100644
--- a/crates/ui2/src/components/language_selector.rs
+++ b/crates/ui2/src/components/language_selector.rs
@@ -1,23 +1,17 @@
-use std::marker::PhantomData;
-
 use crate::prelude::*;
 use crate::{OrderMethod, Palette, PaletteItem};
 
 #[derive(Component)]
-pub struct LanguageSelector<S: 'static + Send + Sync + Clone> {
+pub struct LanguageSelector {
     id: ElementId,
-    state_type: PhantomData<S>,
 }
 
-impl<S: 'static + Send + Sync + Clone> LanguageSelector<S> {
+impl LanguageSelector {
     pub fn new(id: impl Into<ElementId>) -> Self {
-        Self {
-            id: id.into(),
-            state_type: PhantomData,
-        }
+        Self { id: id.into() }
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         div().id(self.id.clone()).child(
             Palette::new("palette")
                 .items(vec![
@@ -49,20 +43,16 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct LanguageSelectorStory<S: 'static + Send + Sync + Clone> {
-        state_type: PhantomData<S>,
-    }
+    pub struct LanguageSelectorStory;
 
-    impl<S: 'static + Send + Sync + Clone> LanguageSelectorStory<S> {
+    impl LanguageSelectorStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
             Story::container(cx)
-                .child(Story::title_for::<_, LanguageSelector<S>>(cx))
+                .child(Story::title_for::<_, LanguageSelector>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(LanguageSelector::new("language-selector"))
         }
diff --git a/crates/ui2/src/components/list.rs b/crates/ui2/src/components/list.rs
index b1b3f506eab67aa94ac9a7adfa0db8df03bf2ef3..0bf413e2172654db6b2828cc383928ec05fa6499 100644
--- a/crates/ui2/src/components/list.rs
+++ b/crates/ui2/src/components/list.rs
@@ -1,5 +1,3 @@
-use std::marker::PhantomData;
-
 use gpui2::{div, relative, Div};
 
 use crate::settings::user_settings;
@@ -18,8 +16,7 @@ pub enum ListItemVariant {
 }
 
 #[derive(Component)]
-pub struct ListHeader<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
+pub struct ListHeader {
     label: SharedString,
     left_icon: Option<Icon>,
     variant: ListItemVariant,
@@ -27,10 +24,9 @@ pub struct ListHeader<S: 'static + Send + Sync> {
     toggleable: Toggleable,
 }
 
-impl<S: 'static + Send + Sync> ListHeader<S> {
+impl ListHeader {
     pub fn new(label: impl Into<SharedString>) -> Self {
         Self {
-            state_type: PhantomData,
             label: label.into(),
             left_icon: None,
             variant: ListItemVariant::default(),
@@ -59,7 +55,7 @@ impl<S: 'static + Send + Sync> ListHeader<S> {
         self
     }
 
-    fn disclosure_control(&self) -> Div<S> {
+    fn disclosure_control<S: 'static>(&self) -> Div<S> {
         let is_toggleable = self.toggleable != Toggleable::NotToggleable;
         let is_toggled = Toggleable::is_toggled(&self.toggleable);
 
@@ -92,7 +88,7 @@ impl<S: 'static + Send + Sync> ListHeader<S> {
         }
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         let theme = theme(cx);
 
         let is_toggleable = self.toggleable != Toggleable::NotToggleable;
@@ -135,17 +131,15 @@ impl<S: 'static + Send + Sync> ListHeader<S> {
 }
 
 #[derive(Component)]
-pub struct ListSubHeader<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
+pub struct ListSubHeader {
     label: SharedString,
     left_icon: Option<Icon>,
     variant: ListItemVariant,
 }
 
-impl<S: 'static + Send + Sync> ListSubHeader<S> {
+impl ListSubHeader {
     pub fn new(label: impl Into<SharedString>) -> Self {
         Self {
-            state_type: PhantomData,
             label: label.into(),
             left_icon: None,
             variant: ListItemVariant::default(),
@@ -157,7 +151,7 @@ impl<S: 'static + Send + Sync> ListSubHeader<S> {
         self
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         h_stack().flex_1().w_full().relative().py_1().child(
             div()
                 .h_6()
@@ -198,38 +192,38 @@ pub enum ListEntrySize {
 }
 
 #[derive(Component)]
-pub enum ListItem<S: 'static + Send + Sync> {
-    Entry(ListEntry<S>),
+pub enum ListItem<S: 'static> {
+    Entry(ListEntry),
     Details(ListDetailsEntry<S>),
-    Separator(ListSeparator<S>),
-    Header(ListSubHeader<S>),
+    Separator(ListSeparator),
+    Header(ListSubHeader),
 }
 
-impl<S: 'static + Send + Sync> From<ListEntry<S>> for ListItem<S> {
-    fn from(entry: ListEntry<S>) -> Self {
+impl<S: 'static> From<ListEntry> for ListItem<S> {
+    fn from(entry: ListEntry) -> Self {
         Self::Entry(entry)
     }
 }
 
-impl<S: 'static + Send + Sync> From<ListDetailsEntry<S>> for ListItem<S> {
+impl<S: 'static> From<ListDetailsEntry<S>> for ListItem<S> {
     fn from(entry: ListDetailsEntry<S>) -> Self {
         Self::Details(entry)
     }
 }
 
-impl<S: 'static + Send + Sync> From<ListSeparator<S>> for ListItem<S> {
-    fn from(entry: ListSeparator<S>) -> Self {
+impl<S: 'static> From<ListSeparator> for ListItem<S> {
+    fn from(entry: ListSeparator) -> Self {
         Self::Separator(entry)
     }
 }
 
-impl<S: 'static + Send + Sync> From<ListSubHeader<S>> for ListItem<S> {
-    fn from(entry: ListSubHeader<S>) -> Self {
+impl<S: 'static> From<ListSubHeader> for ListItem<S> {
+    fn from(entry: ListSubHeader) -> Self {
         Self::Header(entry)
     }
 }
 
-impl<S: 'static + Send + Sync> ListItem<S> {
+impl<S: 'static> ListItem<S> {
     fn render(self, view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         match self {
             ListItem::Entry(entry) => div().child(entry.render(view, cx)),
@@ -239,11 +233,11 @@ impl<S: 'static + Send + Sync> ListItem<S> {
         }
     }
 
-    pub fn new(label: Label<S>) -> Self {
+    pub fn new(label: Label) -> Self {
         Self::Entry(ListEntry::new(label))
     }
 
-    pub fn as_entry(&mut self) -> Option<&mut ListEntry<S>> {
+    pub fn as_entry(&mut self) -> Option<&mut ListEntry> {
         if let Self::Entry(entry) = self {
             Some(entry)
         } else {
@@ -253,10 +247,10 @@ impl<S: 'static + Send + Sync> ListItem<S> {
 }
 
 #[derive(Component)]
-pub struct ListEntry<S: 'static + Send + Sync> {
+pub struct ListEntry {
     disclosure_control_style: DisclosureControlVisibility,
     indent_level: u32,
-    label: Option<Label<S>>,
+    label: Option<Label>,
     left_content: Option<LeftContent>,
     variant: ListItemVariant,
     size: ListEntrySize,
@@ -265,8 +259,8 @@ pub struct ListEntry<S: 'static + Send + Sync> {
     overflow: OverflowStyle,
 }
 
-impl<S: 'static + Send + Sync> ListEntry<S> {
-    pub fn new(label: Label<S>) -> Self {
+impl ListEntry {
+    pub fn new(label: Label) -> Self {
         Self {
             disclosure_control_style: DisclosureControlVisibility::default(),
             indent_level: 0,
@@ -344,7 +338,10 @@ impl<S: 'static + Send + Sync> ListEntry<S> {
         }
     }
 
-    fn disclosure_control(&mut self, cx: &mut ViewContext<S>) -> Option<impl Component<S>> {
+    fn disclosure_control<V: 'static>(
+        &mut self,
+        cx: &mut ViewContext<V>,
+    ) -> Option<impl Component<V>> {
         let disclosure_control_icon = if let Some(ToggleState::Toggled) = self.toggle {
             IconElement::new(Icon::ChevronDown)
         } else {
@@ -364,7 +361,7 @@ impl<S: 'static + Send + Sync> ListEntry<S> {
         }
     }
 
-    fn render(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         let settings = user_settings(cx);
         let theme = theme(cx);
 
@@ -420,18 +417,18 @@ impl<S: 'static + Send + Sync> ListEntry<S> {
     }
 }
 
-struct ListDetailsEntryHandlers<S: 'static + Send + Sync> {
+struct ListDetailsEntryHandlers<S: 'static> {
     click: Option<ClickHandler<S>>,
 }
 
-impl<S: 'static + Send + Sync> Default for ListDetailsEntryHandlers<S> {
+impl<S: 'static> Default for ListDetailsEntryHandlers<S> {
     fn default() -> Self {
         Self { click: None }
     }
 }
 
 #[derive(Component)]
-pub struct ListDetailsEntry<S: 'static + Send + Sync> {
+pub struct ListDetailsEntry<S: 'static> {
     label: SharedString,
     meta: Option<SharedString>,
     left_content: Option<LeftContent>,
@@ -442,7 +439,7 @@ pub struct ListDetailsEntry<S: 'static + Send + Sync> {
     seen: bool,
 }
 
-impl<S: 'static + Send + Sync> ListDetailsEntry<S> {
+impl<S: 'static> ListDetailsEntry<S> {
     pub fn new(label: impl Into<SharedString>) -> Self {
         Self {
             label: label.into(),
@@ -520,18 +517,14 @@ impl<S: 'static + Send + Sync> ListDetailsEntry<S> {
 }
 
 #[derive(Clone, Component)]
-pub struct ListSeparator<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
-}
+pub struct ListSeparator;
 
-impl<S: 'static + Send + Sync> ListSeparator<S> {
+impl ListSeparator {
     pub fn new() -> Self {
-        Self {
-            state_type: PhantomData,
-        }
+        Self
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
         let theme = theme(cx);
 
         div().h_px().w_full().bg(theme.border)
@@ -539,14 +532,14 @@ impl<S: 'static + Send + Sync> ListSeparator<S> {
 }
 
 #[derive(Component)]
-pub struct List<S: 'static + Send + Sync> {
+pub struct List<S: 'static> {
     items: Vec<ListItem<S>>,
     empty_message: SharedString,
-    header: Option<ListHeader<S>>,
+    header: Option<ListHeader>,
     toggleable: Toggleable,
 }
 
-impl<S: 'static + Send + Sync> List<S> {
+impl<S: 'static> List<S> {
     pub fn new(items: Vec<ListItem<S>>) -> Self {
         Self {
             items,
@@ -561,7 +554,7 @@ impl<S: 'static + Send + Sync> List<S> {
         self
     }
 
-    pub fn header(mut self, header: ListHeader<S>) -> Self {
+    pub fn header(mut self, header: ListHeader) -> Self {
         self.header = Some(header);
         self
     }
diff --git a/crates/ui2/src/components/modal.rs b/crates/ui2/src/components/modal.rs
index 0d57013e5d53e301528fca44dc8712ffb90e85c5..2036c5df116019321b4a7225ca464a810e73e97a 100644
--- a/crates/ui2/src/components/modal.rs
+++ b/crates/ui2/src/components/modal.rs
@@ -1,25 +1,21 @@
-use std::marker::PhantomData;
-
 use gpui2::AnyElement;
 use smallvec::SmallVec;
 
 use crate::{h_stack, prelude::*, v_stack, Button, Icon, IconButton, Label};
 
 #[derive(Component)]
-pub struct Modal<S: 'static + Send + Sync> {
+pub struct Modal<S: 'static> {
     id: ElementId,
-    state_type: PhantomData<S>,
     title: Option<SharedString>,
     primary_action: Option<Button<S>>,
     secondary_action: Option<Button<S>>,
     children: SmallVec<[AnyElement<S>; 2]>,
 }
 
-impl<S: 'static + Send + Sync> Modal<S> {
+impl<S: 'static> Modal<S> {
     pub fn new(id: impl Into<ElementId>) -> Self {
         Self {
             id: id.into(),
-            state_type: PhantomData,
             title: None,
             primary_action: None,
             secondary_action: None,
@@ -80,7 +76,7 @@ impl<S: 'static + Send + Sync> Modal<S> {
     }
 }
 
-impl<S: 'static + Send + Sync> ParentElement<S> for Modal<S> {
+impl<S: 'static> ParentElement<S> for Modal<S> {
     fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<S>; 2]> {
         &mut self.children
     }
diff --git a/crates/ui2/src/components/multi_buffer.rs b/crates/ui2/src/components/multi_buffer.rs
index 30fcb935bbd5c4107c674317a14d62ce748dca43..bbf893f8eff2955ab4354c90e4a874d91e987146 100644
--- a/crates/ui2/src/components/multi_buffer.rs
+++ b/crates/ui2/src/components/multi_buffer.rs
@@ -1,23 +1,17 @@
-use std::marker::PhantomData;
-
 use crate::prelude::*;
 use crate::{v_stack, Buffer, Icon, IconButton, Label};
 
 #[derive(Component)]
-pub struct MultiBuffer<S: 'static + Send + Sync + Clone> {
-    state_type: PhantomData<S>,
-    buffers: Vec<Buffer<S>>,
+pub struct MultiBuffer {
+    buffers: Vec<Buffer>,
 }
 
-impl<S: 'static + Send + Sync + Clone> MultiBuffer<S> {
-    pub fn new(buffers: Vec<Buffer<S>>) -> Self {
-        Self {
-            state_type: PhantomData,
-            buffers,
-        }
+impl MultiBuffer {
+    pub fn new(buffers: Vec<Buffer>) -> Self {
+        Self { buffers }
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
         let theme = theme(cx);
 
         v_stack()
@@ -51,22 +45,18 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct MultiBufferStory<S: 'static + Send + Sync + Clone> {
-        state_type: PhantomData<S>,
-    }
+    pub struct MultiBufferStory;
 
-    impl<S: 'static + Send + Sync + Clone> MultiBufferStory<S> {
+    impl MultiBufferStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
             let theme = theme(cx);
 
             Story::container(cx)
-                .child(Story::title_for::<_, MultiBuffer<S>>(cx))
+                .child(Story::title_for::<_, MultiBuffer>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(MultiBuffer::new(vec![
                     hello_world_rust_buffer_example(&theme),
diff --git a/crates/ui2/src/components/notification_toast.rs b/crates/ui2/src/components/notification_toast.rs
index 6460c2f693db871807206506cfe5ec630125f79d..6be3e3b1b55e4b0f414c9cb93624961603111e4d 100644
--- a/crates/ui2/src/components/notification_toast.rs
+++ b/crates/ui2/src/components/notification_toast.rs
@@ -1,20 +1,16 @@
-use std::marker::PhantomData;
-
 use gpui2::rems;
 
 use crate::{h_stack, prelude::*, Icon};
 
 #[derive(Component)]
-pub struct NotificationToast<S: 'static + Send + Sync + Clone> {
-    state_type: PhantomData<S>,
+pub struct NotificationToast {
     label: SharedString,
     icon: Option<Icon>,
 }
 
-impl<S: 'static + Send + Sync + Clone> NotificationToast<S> {
+impl NotificationToast {
     pub fn new(label: SharedString) -> Self {
         Self {
-            state_type: PhantomData,
             label,
             icon: None,
         }
@@ -28,7 +24,7 @@ impl<S: 'static + Send + Sync + Clone> NotificationToast<S> {
         self
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         let theme = theme(cx);
 
         h_stack()
diff --git a/crates/ui2/src/components/notifications_panel.rs b/crates/ui2/src/components/notifications_panel.rs
index 39ec9ea73f41ea63d3f5c0e093ca3681cd256c20..e154d717d47acd4e525f02898924d285cc64dfb2 100644
--- a/crates/ui2/src/components/notifications_panel.rs
+++ b/crates/ui2/src/components/notifications_panel.rs
@@ -1,23 +1,20 @@
-use std::marker::PhantomData;
 
 use crate::{prelude::*, static_new_notification_items, static_read_notification_items};
 use crate::{List, ListHeader};
 
 #[derive(Component)]
-pub struct NotificationsPanel<S: 'static + Send + Sync> {
+pub struct NotificationsPanel {
     id: ElementId,
-    state_type: PhantomData<S>,
 }
 
-impl<S: 'static + Send + Sync> NotificationsPanel<S> {
+impl NotificationsPanel {
     pub fn new(id: impl Into<ElementId>) -> Self {
         Self {
             id: id.into(),
-            state_type: PhantomData,
         }
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         let theme = theme(cx);
 
         div()
@@ -59,20 +56,16 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct NotificationsPanelStory<S: 'static + Send + Sync + Clone> {
-        state_type: PhantomData<S>,
-    }
+    pub struct NotificationsPanelStory;
 
-    impl<S: 'static + Send + Sync + Clone> NotificationsPanelStory<S> {
+    impl NotificationsPanelStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
             Story::container(cx)
-                .child(Story::title_for::<_, NotificationsPanel<S>>(cx))
+                .child(Story::title_for::<_, NotificationsPanel>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(
                     Panel::new("panel", cx).child(NotificationsPanel::new("notifications_panel")),
diff --git a/crates/ui2/src/components/palette.rs b/crates/ui2/src/components/palette.rs
index 56928d4192574e4769972396a834680919ea87bd..9f2da78a53942a49c4eea0130efac740f3c033b9 100644
--- a/crates/ui2/src/components/palette.rs
+++ b/crates/ui2/src/components/palette.rs
@@ -1,23 +1,19 @@
-use std::marker::PhantomData;
-
 use crate::prelude::*;
 use crate::{h_stack, v_stack, Keybinding, Label, LabelColor};
 
 #[derive(Component)]
-pub struct Palette<S: 'static + Send + Sync> {
+pub struct Palette {
     id: ElementId,
-    state_type: PhantomData<S>,
     input_placeholder: SharedString,
     empty_string: SharedString,
-    items: Vec<PaletteItem<S>>,
+    items: Vec<PaletteItem>,
     default_order: OrderMethod,
 }
 
-impl<S: 'static + Send + Sync> Palette<S> {
+impl Palette {
     pub fn new(id: impl Into<ElementId>) -> Self {
         Self {
             id: id.into(),
-            state_type: PhantomData,
             input_placeholder: "Find something...".into(),
             empty_string: "No items found.".into(),
             items: vec![],
@@ -25,7 +21,7 @@ impl<S: 'static + Send + Sync> Palette<S> {
         }
     }
 
-    pub fn items(mut self, items: Vec<PaletteItem<S>>) -> Self {
+    pub fn items(mut self, items: Vec<PaletteItem>) -> Self {
         self.items = items;
         self
     }
@@ -46,7 +42,7 @@ impl<S: 'static + Send + Sync> Palette<S> {
         self
     }
 
-    fn render(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         let theme = theme(cx);
 
         v_stack()
@@ -102,13 +98,13 @@ impl<S: 'static + Send + Sync> Palette<S> {
 }
 
 #[derive(Component)]
-pub struct PaletteItem<S: 'static + Send + Sync> {
+pub struct PaletteItem {
     pub label: SharedString,
     pub sublabel: Option<SharedString>,
-    pub keybinding: Option<Keybinding<S>>,
+    pub keybinding: Option<Keybinding>,
 }
 
-impl<S: 'static + Send + Sync> PaletteItem<S> {
+impl PaletteItem {
     pub fn new(label: impl Into<SharedString>) -> Self {
         Self {
             label: label.into(),
@@ -129,13 +125,13 @@ impl<S: 'static + Send + Sync> PaletteItem<S> {
 
     pub fn keybinding<K>(mut self, keybinding: K) -> Self
     where
-        K: Into<Option<Keybinding<S>>>,
+        K: Into<Option<Keybinding>>,
     {
         self.keybinding = keybinding.into();
         self
     }
 
-    fn render(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(mut self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         div()
             .flex()
             .flex_row()
@@ -161,20 +157,16 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct PaletteStory<S: 'static + Send + Sync + Clone> {
-        state_type: PhantomData<S>,
-    }
+    pub struct PaletteStory;
 
-    impl<S: 'static + Send + Sync + Clone> PaletteStory<S> {
+    impl PaletteStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
             Story::container(cx)
-                .child(Story::title_for::<_, Palette<S>>(cx))
+                .child(Story::title_for::<_, Palette>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(Palette::new("palette-1"))
                 .child(Story::label(cx, "With Items"))
diff --git a/crates/ui2/src/components/panel.rs b/crates/ui2/src/components/panel.rs
index 63c694a7a3c602167984dc18faaef1c220558616..a1a075a4b2f1a81468137ec9964630fc897b7d55 100644
--- a/crates/ui2/src/components/panel.rs
+++ b/crates/ui2/src/components/panel.rs
@@ -1,5 +1,3 @@
-use std::marker::PhantomData;
-
 use gpui2::{AbsoluteLength, AnyElement};
 use smallvec::SmallVec;
 
@@ -41,9 +39,8 @@ pub enum PanelSide {
 use std::collections::HashSet;
 
 #[derive(Component)]
-pub struct Panel<S: 'static + Send + Sync> {
+pub struct Panel<S: 'static> {
     id: ElementId,
-    state_type: PhantomData<S>,
     current_side: PanelSide,
     /// Defaults to PanelAllowedSides::LeftAndRight
     allowed_sides: PanelAllowedSides,
@@ -52,13 +49,12 @@ pub struct Panel<S: 'static + Send + Sync> {
     children: SmallVec<[AnyElement<S>; 2]>,
 }
 
-impl<S: 'static + Send + Sync> Panel<S> {
+impl<S: 'static> Panel<S> {
     pub fn new(id: impl Into<ElementId>, cx: &mut WindowContext) -> Self {
         let settings = user_settings(cx);
 
         Self {
             id: id.into(),
-            state_type: PhantomData,
             current_side: PanelSide::default(),
             allowed_sides: PanelAllowedSides::default(),
             initial_width: *settings.default_panel_size,
@@ -121,7 +117,7 @@ impl<S: 'static + Send + Sync> Panel<S> {
     }
 }
 
-impl<S: 'static + Send + Sync> ParentElement<S> for Panel<S> {
+impl<S: 'static> ParentElement<S> for Panel<S> {
     fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<S>; 2]> {
         &mut self.children
     }
@@ -137,18 +133,14 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct PanelStory<S: 'static + Send + Sync + Clone> {
-        state_type: PhantomData<S>,
-    }
+    pub struct PanelStory;
 
-    impl<S: 'static + Send + Sync + Clone> PanelStory<S> {
+    impl PanelStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
             Story::container(cx)
                 .child(Story::title_for::<_, Panel<S>>(cx))
                 .child(Story::label(cx, "Default"))
diff --git a/crates/ui2/src/components/panes.rs b/crates/ui2/src/components/panes.rs
index fafa2dd2a1be6649a1abce026a1fa06674f26a59..a8dd202c50fc54f672650a4153b21beb85fb828a 100644
--- a/crates/ui2/src/components/panes.rs
+++ b/crates/ui2/src/components/panes.rs
@@ -1,5 +1,3 @@
-use std::marker::PhantomData;
-
 use gpui2::{hsla, red, AnyElement, ElementId, ExternalPaths, Hsla, Length, Size};
 use smallvec::SmallVec;
 
@@ -76,17 +74,15 @@ impl<V: 'static> ParentElement<V> for Pane<V> {
 }
 
 #[derive(Component)]
-pub struct PaneGroup<V: 'static + Send + Sync> {
-    state_type: PhantomData<V>,
+pub struct PaneGroup<V: 'static> {
     groups: Vec<PaneGroup<V>>,
     panes: Vec<Pane<V>>,
     split_direction: SplitDirection,
 }
 
-impl<V: 'static + Send + Sync> PaneGroup<V> {
+impl<V: 'static> PaneGroup<V> {
     pub fn new_groups(groups: Vec<PaneGroup<V>>, split_direction: SplitDirection) -> Self {
         Self {
-            state_type: PhantomData,
             groups,
             panes: Vec::new(),
             split_direction,
@@ -95,7 +91,6 @@ impl<V: 'static + Send + Sync> PaneGroup<V> {
 
     pub fn new_panes(panes: Vec<Pane<V>>, split_direction: SplitDirection) -> Self {
         Self {
-            state_type: PhantomData,
             groups: Vec::new(),
             panes,
             split_direction,
diff --git a/crates/ui2/src/components/player_stack.rs b/crates/ui2/src/components/player_stack.rs
index f1a8df821885cd26ff70e7e5255b31be331c257d..8c2d0bbf25788b5f0f74362656500335e31a191c 100644
--- a/crates/ui2/src/components/player_stack.rs
+++ b/crates/ui2/src/components/player_stack.rs
@@ -1,23 +1,19 @@
-use std::marker::PhantomData;
-
 use crate::prelude::*;
 use crate::{Avatar, Facepile, PlayerWithCallStatus};
 
 #[derive(Component)]
-pub struct PlayerStack<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
+pub struct PlayerStack {
     player_with_call_status: PlayerWithCallStatus,
 }
 
-impl<S: 'static + Send + Sync> PlayerStack<S> {
+impl PlayerStack {
     pub fn new(player_with_call_status: PlayerWithCallStatus) -> Self {
         Self {
-            state_type: PhantomData,
             player_with_call_status,
         }
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         let theme = theme(cx);
         let player = self.player_with_call_status.get_player();
         self.player_with_call_status.get_call_status();
diff --git a/crates/ui2/src/components/project_panel.rs b/crates/ui2/src/components/project_panel.rs
index e0791ab323d134653f06fbb7fab55b4af49345cc..0898b70c8e48cdac8afb5dba985ccfcdf33d1cb7 100644
--- a/crates/ui2/src/components/project_panel.rs
+++ b/crates/ui2/src/components/project_panel.rs
@@ -1,25 +1,19 @@
-use std::marker::PhantomData;
-
 use crate::prelude::*;
 use crate::{
     static_project_panel_project_items, static_project_panel_single_items, Input, List, ListHeader,
 };
 
 #[derive(Component)]
-pub struct ProjectPanel<S: 'static + Send + Sync> {
+pub struct ProjectPanel {
     id: ElementId,
-    state_type: PhantomData<S>,
 }
 
-impl<S: 'static + Send + Sync> ProjectPanel<S> {
+impl ProjectPanel {
     pub fn new(id: impl Into<ElementId>) -> Self {
-        Self {
-            id: id.into(),
-            state_type: PhantomData,
-        }
+        Self { id: id.into() }
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         let theme = theme(cx);
 
         div()
@@ -68,20 +62,16 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct ProjectPanelStory<S: 'static + Send + Sync + Clone> {
-        state_type: PhantomData<S>,
-    }
+    pub struct ProjectPanelStory;
 
-    impl<S: 'static + Send + Sync + Clone> ProjectPanelStory<S> {
+    impl ProjectPanelStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
             Story::container(cx)
-                .child(Story::title_for::<_, ProjectPanel<S>>(cx))
+                .child(Story::title_for::<_, ProjectPanel>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(
                     Panel::new("project-panel-outer", cx)
diff --git a/crates/ui2/src/components/recent_projects.rs b/crates/ui2/src/components/recent_projects.rs
index 94d4c467f8e35d6f287222d29fd7a0de0320d0b1..67a32ad009d0a703d9b9ef9d054c175abc0c1737 100644
--- a/crates/ui2/src/components/recent_projects.rs
+++ b/crates/ui2/src/components/recent_projects.rs
@@ -1,23 +1,17 @@
-use std::marker::PhantomData;
-
 use crate::prelude::*;
 use crate::{OrderMethod, Palette, PaletteItem};
 
 #[derive(Component)]
-pub struct RecentProjects<S: 'static + Send + Sync + Clone> {
+pub struct RecentProjects {
     id: ElementId,
-    state_type: PhantomData<S>,
 }
 
-impl<S: 'static + Send + Sync + Clone> RecentProjects<S> {
+impl RecentProjects {
     pub fn new(id: impl Into<ElementId>) -> Self {
-        Self {
-            id: id.into(),
-            state_type: PhantomData,
-        }
+        Self { id: id.into() }
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         div().id(self.id.clone()).child(
             Palette::new("palette")
                 .items(vec![
@@ -45,20 +39,16 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct RecentProjectsStory<S: 'static + Send + Sync + Clone> {
-        state_type: PhantomData<S>,
-    }
+    pub struct RecentProjectsStory;
 
-    impl<S: 'static + Send + Sync + Clone> RecentProjectsStory<S> {
+    impl RecentProjectsStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
             Story::container(cx)
-                .child(Story::title_for::<_, RecentProjects<S>>(cx))
+                .child(Story::title_for::<_, RecentProjects>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(RecentProjects::new("recent-projects"))
         }
diff --git a/crates/ui2/src/components/tab.rs b/crates/ui2/src/components/tab.rs
index 63cdd55b76842d930e50f32df55af458493cc0cc..45c57ae4842a813acf87d8017a934271c1531528 100644
--- a/crates/ui2/src/components/tab.rs
+++ b/crates/ui2/src/components/tab.rs
@@ -1,11 +1,8 @@
-use std::marker::PhantomData;
-
 use crate::prelude::*;
 use crate::{Icon, IconColor, IconElement, Label, LabelColor};
 
 #[derive(Component, Clone)]
-pub struct Tab<S: 'static + Send + Sync + Clone> {
-    state_type: PhantomData<S>,
+pub struct Tab {
     id: ElementId,
     title: String,
     icon: Option<Icon>,
@@ -22,10 +19,9 @@ struct TabDragState {
     title: String,
 }
 
-impl<S: 'static + Send + Sync + Clone> Tab<S> {
+impl Tab {
     pub fn new(id: impl Into<ElementId>) -> Self {
         Self {
-            state_type: PhantomData,
             id: id.into(),
             title: "untitled".to_string(),
             icon: None,
@@ -81,7 +77,7 @@ impl<S: 'static + Send + Sync + Clone> Tab<S> {
         self
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
         let theme = theme(cx);
         let has_fs_conflict = self.fs_status == FileSystemStatus::Conflict;
         let is_deleted = self.fs_status == FileSystemStatus::Deleted;
@@ -177,23 +173,19 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct TabStory<S: 'static + Send + Sync + Clone> {
-        state_type: PhantomData<S>,
-    }
+    pub struct TabStory;
 
-    impl<S: 'static + Send + Sync + Clone> TabStory<S> {
+    impl TabStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
             let git_statuses = GitStatus::iter();
             let fs_statuses = FileSystemStatus::iter();
 
             Story::container(cx)
-                .child(Story::title_for::<_, Tab<S>>(cx))
+                .child(Story::title_for::<_, Tab>(cx))
                 .child(
                     h_stack().child(
                         v_stack()
diff --git a/crates/ui2/src/components/tab_bar.rs b/crates/ui2/src/components/tab_bar.rs
index 344baaab4b405587e45c3c4588ca2abafff5374a..4ebf7c6376960267b01c3b494d5ae4f81520eb9c 100644
--- a/crates/ui2/src/components/tab_bar.rs
+++ b/crates/ui2/src/components/tab_bar.rs
@@ -1,22 +1,18 @@
-use std::marker::PhantomData;
-
 use crate::prelude::*;
 use crate::{Icon, IconButton, Tab};
 
 #[derive(Component)]
-pub struct TabBar<S: 'static + Send + Sync + Clone> {
+pub struct TabBar {
     id: ElementId,
-    state_type: PhantomData<S>,
     /// Backwards, Forwards
     can_navigate: (bool, bool),
-    tabs: Vec<Tab<S>>,
+    tabs: Vec<Tab>,
 }
 
-impl<S: 'static + Send + Sync + Clone> TabBar<S> {
-    pub fn new(id: impl Into<ElementId>, tabs: Vec<Tab<S>>) -> Self {
+impl TabBar {
+    pub fn new(id: impl Into<ElementId>, tabs: Vec<Tab>) -> Self {
         Self {
             id: id.into(),
-            state_type: PhantomData,
             can_navigate: (false, false),
             tabs,
         }
@@ -27,7 +23,7 @@ impl<S: 'static + Send + Sync + Clone> TabBar<S> {
         self
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         let theme = theme(cx);
 
         let (can_navigate_back, can_navigate_forward) = self.can_navigate;
@@ -101,20 +97,16 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct TabBarStory<S: 'static + Send + Sync + Clone> {
-        state_type: PhantomData<S>,
-    }
+    pub struct TabBarStory;
 
-    impl<S: 'static + Send + Sync + Clone> TabBarStory<S> {
+    impl TabBarStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
             Story::container(cx)
-                .child(Story::title_for::<_, TabBar<S>>(cx))
+                .child(Story::title_for::<_, TabBar>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(TabBar::new(
                     "tab-bar",
diff --git a/crates/ui2/src/components/terminal.rs b/crates/ui2/src/components/terminal.rs
index 1f00a506857db86d7cdb3fb854fa4d98fb9fbbc2..eb95458f0fb8282c94044ed7e2b1f2c2021903ec 100644
--- a/crates/ui2/src/components/terminal.rs
+++ b/crates/ui2/src/components/terminal.rs
@@ -1,23 +1,17 @@
-use std::marker::PhantomData;
-
 use gpui2::{relative, rems, Size};
 
 use crate::prelude::*;
 use crate::{Icon, IconButton, Pane, Tab};
 
 #[derive(Component)]
-pub struct Terminal<S: 'static + Send + Sync + Clone> {
-    state_type: PhantomData<S>,
-}
+pub struct Terminal;
 
-impl<S: 'static + Send + Sync + Clone> Terminal<S> {
+impl Terminal {
     pub fn new() -> Self {
-        Self {
-            state_type: PhantomData,
-        }
+        Self
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         let theme = theme(cx);
 
         let can_navigate_back = true;
@@ -94,20 +88,16 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct TerminalStory<S: 'static + Send + Sync + Clone> {
-        state_type: PhantomData<S>,
-    }
+    pub struct TerminalStory;
 
-    impl<S: 'static + Send + Sync + Clone> TerminalStory<S> {
+    impl TerminalStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
             Story::container(cx)
-                .child(Story::title_for::<_, Terminal<S>>(cx))
+                .child(Story::title_for::<_, Terminal>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(Terminal::new())
         }
diff --git a/crates/ui2/src/components/theme_selector.rs b/crates/ui2/src/components/theme_selector.rs
index e0865c3bcb691b69be644749454ad9d5087c940d..18dbaac407a433528c1fca1a72b92d205f99bb8f 100644
--- a/crates/ui2/src/components/theme_selector.rs
+++ b/crates/ui2/src/components/theme_selector.rs
@@ -1,23 +1,17 @@
-use std::marker::PhantomData;
-
 use crate::prelude::*;
 use crate::{OrderMethod, Palette, PaletteItem};
 
 #[derive(Component)]
-pub struct ThemeSelector<S: 'static + Send + Sync> {
+pub struct ThemeSelector {
     id: ElementId,
-    state_type: PhantomData<S>,
 }
 
-impl<S: 'static + Send + Sync> ThemeSelector<S> {
+impl ThemeSelector {
     pub fn new(id: impl Into<ElementId>) -> Self {
-        Self {
-            id: id.into(),
-            state_type: PhantomData,
-        }
+        Self { id: id.into() }
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         div().child(
             Palette::new(self.id.clone())
                 .items(vec![
@@ -50,20 +44,16 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct ThemeSelectorStory<S: 'static + Send + Sync + Clone> {
-        state_type: PhantomData<S>,
-    }
+    pub struct ThemeSelectorStory;
 
-    impl<S: 'static + Send + Sync + Clone> ThemeSelectorStory<S> {
+    impl ThemeSelectorStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
             Story::container(cx)
-                .child(Story::title_for::<_, ThemeSelector<S>>(cx))
+                .child(Story::title_for::<_, ThemeSelector>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(ThemeSelector::new("theme-selector"))
         }
diff --git a/crates/ui2/src/components/toast.rs b/crates/ui2/src/components/toast.rs
index 78bb467aa60c2c5aab1822a67ebb4bc0207e8452..40c1e3a6a4a667aad6f526898072111b64faf4c8 100644
--- a/crates/ui2/src/components/toast.rs
+++ b/crates/ui2/src/components/toast.rs
@@ -23,12 +23,12 @@ pub enum ToastOrigin {
 ///
 /// Only one toast may be visible at a time.
 #[derive(Component)]
-pub struct Toast<S: 'static + Send + Sync> {
+pub struct Toast<S: 'static> {
     origin: ToastOrigin,
     children: SmallVec<[AnyElement<S>; 2]>,
 }
 
-impl<S: 'static + Send + Sync> Toast<S> {
+impl<S: 'static> Toast<S> {
     pub fn new(origin: ToastOrigin) -> Self {
         Self {
             origin,
@@ -61,7 +61,7 @@ impl<S: 'static + Send + Sync> Toast<S> {
     }
 }
 
-impl<S: 'static + Send + Sync> ParentElement<S> for Toast<S> {
+impl<S: 'static> ParentElement<S> for Toast<S> {
     fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<S>; 2]> {
         &mut self.children
     }
@@ -72,25 +72,19 @@ pub use stories::*;
 
 #[cfg(feature = "stories")]
 mod stories {
-    use std::marker::PhantomData;
-
     use crate::{Label, Story};
 
     use super::*;
 
     #[derive(Component)]
-    pub struct ToastStory<S: 'static + Send + Sync> {
-        state_type: PhantomData<S>,
-    }
+    pub struct ToastStory;
 
-    impl<S: 'static + Send + Sync> ToastStory<S> {
+    impl ToastStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
             Story::container(cx)
                 .child(Story::title_for::<_, Toast<S>>(cx))
                 .child(Story::label(cx, "Default"))
diff --git a/crates/ui2/src/components/toolbar.rs b/crates/ui2/src/components/toolbar.rs
index 3f629f93adb4e80d94706cd37521876615166ad6..e32697388e0d24908e3e8aa18409701b7fddf0b7 100644
--- a/crates/ui2/src/components/toolbar.rs
+++ b/crates/ui2/src/components/toolbar.rs
@@ -7,12 +7,12 @@ use crate::prelude::*;
 pub struct ToolbarItem {}
 
 #[derive(Component)]
-pub struct Toolbar<S: 'static + Send + Sync> {
+pub struct Toolbar<S: 'static> {
     left_items: SmallVec<[AnyElement<S>; 2]>,
     right_items: SmallVec<[AnyElement<S>; 2]>,
 }
 
-impl<S: 'static + Send + Sync> Toolbar<S> {
+impl<S: 'static> Toolbar<S> {
     pub fn new() -> Self {
         Self {
             left_items: SmallVec::new(),
@@ -72,7 +72,6 @@ pub use stories::*;
 
 #[cfg(feature = "stories")]
 mod stories {
-    use std::marker::PhantomData;
     use std::path::PathBuf;
     use std::str::FromStr;
 
@@ -81,22 +80,18 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct ToolbarStory<S: 'static + Send + Sync + Clone> {
-        state_type: PhantomData<S>,
-    }
+    pub struct ToolbarStory;
 
-    impl<S: 'static + Send + Sync + Clone> ToolbarStory<S> {
+    impl ToolbarStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
             let theme = theme(cx);
 
             Story::container(cx)
-                .child(Story::title_for::<_, Toolbar<S>>(cx))
+                .child(Story::title_for::<_, Toolbar<V>>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(
                     Toolbar::new()
diff --git a/crates/ui2/src/components/traffic_lights.rs b/crates/ui2/src/components/traffic_lights.rs
index 25b6d535c5ff9b414083fb936d6ce7c23946e8c8..e3698adbf90dc940d781ed7e7570de18b3f4215c 100644
--- a/crates/ui2/src/components/traffic_lights.rs
+++ b/crates/ui2/src/components/traffic_lights.rs
@@ -1,5 +1,3 @@
-use std::marker::PhantomData;
-
 use crate::prelude::*;
 
 #[derive(Clone, Copy)]
@@ -10,22 +8,20 @@ enum TrafficLightColor {
 }
 
 #[derive(Component)]
-struct TrafficLight<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
+struct TrafficLight {
     color: TrafficLightColor,
     window_has_focus: bool,
 }
 
-impl<S: 'static + Send + Sync> TrafficLight<S> {
+impl TrafficLight {
     fn new(color: TrafficLightColor, window_has_focus: bool) -> Self {
         Self {
-            state_type: PhantomData,
             color,
             window_has_focus,
         }
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         let theme = theme(cx);
 
         let fill = match (self.window_has_focus, self.color) {
@@ -40,15 +36,13 @@ impl<S: 'static + Send + Sync> TrafficLight<S> {
 }
 
 #[derive(Component)]
-pub struct TrafficLights<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
+pub struct TrafficLights {
     window_has_focus: bool,
 }
 
-impl<S: 'static + Send + Sync> TrafficLights<S> {
+impl TrafficLights {
     pub fn new() -> Self {
         Self {
-            state_type: PhantomData,
             window_has_focus: true,
         }
     }
@@ -58,7 +52,7 @@ impl<S: 'static + Send + Sync> TrafficLights<S> {
         self
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         div()
             .flex()
             .items_center()
@@ -88,20 +82,16 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct TrafficLightsStory<S: 'static + Send + Sync> {
-        state_type: PhantomData<S>,
-    }
+    pub struct TrafficLightsStory;
 
-    impl<S: 'static + Send + Sync> TrafficLightsStory<S> {
+    impl TrafficLightsStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
             Story::container(cx)
-                .child(Story::title_for::<_, TrafficLights<S>>(cx))
+                .child(Story::title_for::<_, TrafficLights>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(TrafficLights::new())
                 .child(Story::label(cx, "Unfocused"))
diff --git a/crates/ui2/src/element_ext.rs b/crates/ui2/src/element_ext.rs
index fb31307d12c45d2ca8e9a888e4e67e38f3cf3090..69603bbb59cd37826083dc1026214816fe77ee21 100644
--- a/crates/ui2/src/element_ext.rs
+++ b/crates/ui2/src/element_ext.rs
@@ -1,6 +1,6 @@
 use gpui2::Element;
 
-pub trait ElementExt<S: 'static + Send + Sync>: Element<S> {
+pub trait ElementExt<S: 'static>: Element<S> {
     // fn when(mut self, condition: bool, then: impl FnOnce(Self) -> Self) -> Self
     // where
     //     Self: Sized,
@@ -22,4 +22,4 @@ pub trait ElementExt<S: 'static + Send + Sync>: Element<S> {
     // }
 }
 
-impl<S: 'static + Send + Sync, E: Element<S>> ElementExt<S> for E {}
+impl<S: 'static, E: Element<S>> ElementExt<S> for E {}
diff --git a/crates/ui2/src/elements/avatar.rs b/crates/ui2/src/elements/avatar.rs
index 53f3dab58a4021dd495bbd921f127124fdfea59c..3d540ec9ee29fd2624be11cd34af96fe35fc2422 100644
--- a/crates/ui2/src/elements/avatar.rs
+++ b/crates/ui2/src/elements/avatar.rs
@@ -1,20 +1,16 @@
-use std::marker::PhantomData;
-
 use gpui2::img;
 
 use crate::prelude::*;
 
 #[derive(Component)]
-pub struct Avatar<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
+pub struct Avatar {
     src: SharedString,
     shape: Shape,
 }
 
-impl<S: 'static + Send + Sync> Avatar<S> {
+impl Avatar {
     pub fn new(src: impl Into<SharedString>) -> Self {
         Self {
-            state_type: PhantomData,
             src: src.into(),
             shape: Shape::Circle,
         }
@@ -25,7 +21,7 @@ impl<S: 'static + Send + Sync> Avatar<S> {
         self
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
         let theme = theme(cx);
 
         let mut img = img();
@@ -52,20 +48,16 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct AvatarStory<S: 'static + Send + Sync> {
-        state_type: PhantomData<S>,
-    }
+    pub struct AvatarStory;
 
-    impl<S: 'static + Send + Sync> AvatarStory<S> {
+    impl AvatarStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
             Story::container(cx)
-                .child(Story::title_for::<_, Avatar<S>>(cx))
+                .child(Story::title_for::<_, Avatar>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(Avatar::new(
                     "https://avatars.githubusercontent.com/u/1714999?v=4",
diff --git a/crates/ui2/src/elements/button.rs b/crates/ui2/src/elements/button.rs
index 7c4290bd54efb9520fcffc78e088011de0bccea0..24776c52c3ad162c349c4297ced751663cd0e8c7 100644
--- a/crates/ui2/src/elements/button.rs
+++ b/crates/ui2/src/elements/button.rs
@@ -1,4 +1,3 @@
-use std::marker::PhantomData;
 use std::sync::Arc;
 
 use gpui2::{div, DefiniteLength, Hsla, MouseButton, WindowContext};
@@ -49,21 +48,23 @@ impl ButtonVariant {
     }
 }
 
-pub type ClickHandler<S> = Arc<dyn Fn(&mut S, &mut ViewContext<S>) + 'static + Send + Sync>;
+pub type ClickHandler<S> = Arc<dyn Fn(&mut S, &mut ViewContext<S>) + Send + Sync>;
 
-struct ButtonHandlers<S: 'static + Send + Sync> {
+struct ButtonHandlers<S: 'static> {
     click: Option<ClickHandler<S>>,
 }
 
-impl<S: 'static + Send + Sync> Default for ButtonHandlers<S> {
+unsafe impl<S> Send for ButtonHandlers<S> {}
+unsafe impl<S> Sync for ButtonHandlers<S> {}
+
+impl<S: 'static> Default for ButtonHandlers<S> {
     fn default() -> Self {
         Self { click: None }
     }
 }
 
 #[derive(Component)]
-pub struct Button<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
+pub struct Button<S: 'static> {
     disabled: bool,
     handlers: ButtonHandlers<S>,
     icon: Option<Icon>,
@@ -73,10 +74,9 @@ pub struct Button<S: 'static + Send + Sync> {
     width: Option<DefiniteLength>,
 }
 
-impl<S: 'static + Send + Sync> Button<S> {
+impl<S: 'static> Button<S> {
     pub fn new(label: impl Into<SharedString>) -> Self {
         Self {
-            state_type: PhantomData,
             disabled: false,
             handlers: ButtonHandlers::default(),
             icon: None,
@@ -140,13 +140,13 @@ impl<S: 'static + Send + Sync> Button<S> {
         }
     }
 
-    fn render_label(&self) -> Label<S> {
+    fn render_label(&self) -> Label {
         Label::new(self.label.clone())
             .color(self.label_color())
             .line_height_style(LineHeightStyle::UILabel)
     }
 
-    fn render_icon(&self, icon_color: IconColor) -> Option<IconElement<S>> {
+    fn render_icon(&self, icon_color: IconColor) -> Option<IconElement> {
         self.icon.map(|i| IconElement::new(i).color(icon_color))
     }
 
@@ -194,20 +194,16 @@ impl<S: 'static + Send + Sync> Button<S> {
 }
 
 #[derive(Component)]
-pub struct ButtonGroup<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
-    buttons: Vec<Button<S>>,
+pub struct ButtonGroup<V: 'static> {
+    buttons: Vec<Button<V>>,
 }
 
-impl<S: 'static + Send + Sync> ButtonGroup<S> {
-    pub fn new(buttons: Vec<Button<S>>) -> Self {
-        Self {
-            state_type: PhantomData,
-            buttons,
-        }
+impl<V: 'static> ButtonGroup<V> {
+    pub fn new(buttons: Vec<Button<V>>) -> Self {
+        Self { buttons }
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
         let mut el = h_stack().text_size(ui_size(cx, 1.));
 
         for button in self.buttons {
@@ -231,22 +227,18 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct ButtonStory<S: 'static + Send + Sync + Clone> {
-        state_type: PhantomData<S>,
-    }
+    pub struct ButtonStory;
 
-    impl<S: 'static + Send + Sync + Clone> ButtonStory<S> {
+    impl ButtonStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
             let states = InteractionState::iter();
 
             Story::container(cx)
-                .child(Story::title_for::<_, Button<S>>(cx))
+                .child(Story::title_for::<_, Button<V>>(cx))
                 .child(
                     div()
                         .flex()
diff --git a/crates/ui2/src/elements/details.rs b/crates/ui2/src/elements/details.rs
index 84af82500b8c9a89f713ee82f6f6e5968d8f2cec..e39b8b9e1a145fbe42522aaeaf93c27768728e83 100644
--- a/crates/ui2/src/elements/details.rs
+++ b/crates/ui2/src/elements/details.rs
@@ -1,19 +1,15 @@
-use std::marker::PhantomData;
-
 use crate::{prelude::*, v_stack, ButtonGroup};
 
 #[derive(Component)]
-pub struct Details<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
+pub struct Details<V: 'static> {
     text: &'static str,
     meta: Option<&'static str>,
-    actions: Option<ButtonGroup<S>>,
+    actions: Option<ButtonGroup<V>>,
 }
 
-impl<S: 'static + Send + Sync> Details<S> {
+impl<S: 'static> Details<S> {
     pub fn new(text: &'static str) -> Self {
         Self {
-            state_type: PhantomData,
             text,
             meta: None,
             actions: None,
@@ -55,20 +51,16 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct DetailsStory<S: 'static + Send + Sync + Clone> {
-        state_type: PhantomData<S>,
-    }
+    pub struct DetailsStory;
 
-    impl<S: 'static + Send + Sync + Clone> DetailsStory<S> {
+    impl DetailsStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
             Story::container(cx)
-                .child(Story::title_for::<_, Details<S>>(cx))
+                .child(Story::title_for::<_, Details<V>>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(Details::new("The quick brown fox jumps over the lazy dog"))
                 .child(Story::label(cx, "With meta"))
diff --git a/crates/ui2/src/elements/icon.rs b/crates/ui2/src/elements/icon.rs
index a29202aca0663349d544bfb5d4fa54c8c528e80c..7816086a78c0a01e34160b8efb4c036797fdb038 100644
--- a/crates/ui2/src/elements/icon.rs
+++ b/crates/ui2/src/elements/icon.rs
@@ -1,5 +1,3 @@
-use std::marker::PhantomData;
-
 use gpui2::{svg, Hsla};
 use strum::EnumIter;
 
@@ -149,17 +147,15 @@ impl Icon {
 }
 
 #[derive(Component)]
-pub struct IconElement<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
+pub struct IconElement {
     icon: Icon,
     color: IconColor,
     size: IconSize,
 }
 
-impl<S: 'static + Send + Sync> IconElement<S> {
+impl IconElement {
     pub fn new(icon: Icon) -> Self {
         Self {
-            state_type: PhantomData,
             icon,
             color: IconColor::default(),
             size: IconSize::default(),
@@ -176,7 +172,7 @@ impl<S: 'static + Send + Sync> IconElement<S> {
         self
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
         let fill = self.color.color(cx);
         let svg_size = match self.size {
             IconSize::Small => ui_size(cx, 12. / 14.),
@@ -203,22 +199,18 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct IconStory<S: 'static + Send + Sync> {
-        state_type: PhantomData<S>,
-    }
+    pub struct IconStory;
 
-    impl<S: 'static + Send + Sync> IconStory<S> {
+    impl IconStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
             let icons = Icon::iter();
 
             Story::container(cx)
-                .child(Story::title_for::<_, IconElement<S>>(cx))
+                .child(Story::title_for::<_, IconElement>(cx))
                 .child(Story::label(cx, "All Icons"))
                 .child(div().flex().gap_3().children(icons.map(IconElement::new)))
         }
diff --git a/crates/ui2/src/elements/input.rs b/crates/ui2/src/elements/input.rs
index d65dc62d654e43fd680599d104d909713578ed9f..30b930b315d71c3b7c5f3d9a6d3a2cb2437373b0 100644
--- a/crates/ui2/src/elements/input.rs
+++ b/crates/ui2/src/elements/input.rs
@@ -1,5 +1,3 @@
-use std::marker::PhantomData;
-
 use crate::prelude::*;
 use crate::Label;
 use crate::LabelColor;
@@ -12,8 +10,7 @@ pub enum InputVariant {
 }
 
 #[derive(Component)]
-pub struct Input<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
+pub struct Input {
     placeholder: SharedString,
     value: String,
     state: InteractionState,
@@ -22,10 +19,9 @@ pub struct Input<S: 'static + Send + Sync> {
     is_active: bool,
 }
 
-impl<S: 'static + Send + Sync> Input<S> {
+impl Input {
     pub fn new(placeholder: impl Into<SharedString>) -> Self {
         Self {
-            state_type: PhantomData,
             placeholder: placeholder.into(),
             value: "".to_string(),
             state: InteractionState::default(),
@@ -60,7 +56,7 @@ impl<S: 'static + Send + Sync> Input<S> {
         self
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<S: 'static>(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
         let theme = theme(cx);
 
         let (input_bg, input_hover_bg, input_active_bg) = match self.variant {
@@ -121,20 +117,16 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct InputStory<S: 'static + Send + Sync> {
-        state_type: PhantomData<S>,
-    }
+    pub struct InputStory;
 
-    impl<S: 'static + Send + Sync> InputStory<S> {
+    impl InputStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
             Story::container(cx)
-                .child(Story::title_for::<_, Input<S>>(cx))
+                .child(Story::title_for::<_, Input>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(div().flex().child(Input::new("Search")))
         }
diff --git a/crates/ui2/src/elements/label.rs b/crates/ui2/src/elements/label.rs
index 0910a59b5544f428015dd9ad9a202a7e1c7dff5b..87076441ae3ff656706f3430c3824e12ff9d9864 100644
--- a/crates/ui2/src/elements/label.rs
+++ b/crates/ui2/src/elements/label.rs
@@ -1,5 +1,3 @@
-use std::marker::PhantomData;
-
 use gpui2::{relative, Hsla, WindowContext};
 use smallvec::SmallVec;
 
@@ -49,18 +47,16 @@ pub enum LineHeightStyle {
 }
 
 #[derive(Component)]
-pub struct Label<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
+pub struct Label {
     label: SharedString,
     line_height_style: LineHeightStyle,
     color: LabelColor,
     strikethrough: bool,
 }
 
-impl<S: 'static + Send + Sync> Label<S> {
+impl Label {
     pub fn new(label: impl Into<SharedString>) -> Self {
         Self {
-            state_type: PhantomData,
             label: label.into(),
             line_height_style: LineHeightStyle::default(),
             color: LabelColor::Default,
@@ -83,7 +79,7 @@ impl<S: 'static + Send + Sync> Label<S> {
         self
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
         div()
             .when(self.strikethrough, |this| {
                 this.relative().child(
@@ -106,18 +102,16 @@ impl<S: 'static + Send + Sync> Label<S> {
 }
 
 #[derive(Component)]
-pub struct HighlightedLabel<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
+pub struct HighlightedLabel {
     label: SharedString,
     color: LabelColor,
     highlight_indices: Vec<usize>,
     strikethrough: bool,
 }
 
-impl<S: 'static + Send + Sync> HighlightedLabel<S> {
+impl HighlightedLabel {
     pub fn new(label: impl Into<SharedString>, highlight_indices: Vec<usize>) -> Self {
         Self {
-            state_type: PhantomData,
             label: label.into(),
             color: LabelColor::Default,
             highlight_indices,
@@ -135,7 +129,7 @@ impl<S: 'static + Send + Sync> HighlightedLabel<S> {
         self
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
         let theme = theme(cx);
 
         let highlight_color = theme.text_accent;
@@ -212,20 +206,16 @@ mod stories {
     use super::*;
 
     #[derive(Component)]
-    pub struct LabelStory<S: 'static + Send + Sync> {
-        state_type: PhantomData<S>,
-    }
+    pub struct LabelStory;
 
-    impl<S: 'static + Send + Sync> LabelStory<S> {
+    impl LabelStory {
         pub fn new() -> Self {
-            Self {
-                state_type: PhantomData,
-            }
+            Self
         }
 
-        fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+        fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
             Story::container(cx)
-                .child(Story::title_for::<_, Label<S>>(cx))
+                .child(Story::title_for::<_, Label>(cx))
                 .child(Story::label(cx, "Default"))
                 .child(Label::new("Hello, world!"))
                 .child(Story::label(cx, "Highlighted"))
diff --git a/crates/ui2/src/elements/stack.rs b/crates/ui2/src/elements/stack.rs
index dbd0dae9d3be9e650cdd173c4b1bd55f80d7f6be..35ba00cecdb8782f5d46739bd4dc66fd95125a01 100644
--- a/crates/ui2/src/elements/stack.rs
+++ b/crates/ui2/src/elements/stack.rs
@@ -14,18 +14,18 @@ pub trait Stack: Styled + Sized {
     }
 }
 
-impl<S: 'static + Send + Sync> Stack for Div<S> {}
+impl<S: 'static> Stack for Div<S> {}
 
 /// Horizontally stacks elements.
 ///
 /// Sets `flex()`, `flex_row()`, `items_center()`
-pub fn h_stack<S: 'static + Send + Sync>() -> Div<S> {
+pub fn h_stack<S: 'static>() -> Div<S> {
     div().h_stack()
 }
 
 /// Vertically stacks elements.
 ///
 /// Sets `flex()`, `flex_col()`
-pub fn v_stack<S: 'static + Send + Sync>() -> Div<S> {
+pub fn v_stack<S: 'static>() -> Div<S> {
     div().v_stack()
 }
diff --git a/crates/ui2/src/elements/tool_divider.rs b/crates/ui2/src/elements/tool_divider.rs
index 1c80bca05eca022555d286734e1e81067b1ef943..e1ebb294a003a398cf5f26a9c8a58823089e6bd2 100644
--- a/crates/ui2/src/elements/tool_divider.rs
+++ b/crates/ui2/src/elements/tool_divider.rs
@@ -1,20 +1,14 @@
-use std::marker::PhantomData;
-
 use crate::prelude::*;
 
 #[derive(Component)]
-pub struct ToolDivider<S: 'static + Send + Sync> {
-    state_type: PhantomData<S>,
-}
+pub struct ToolDivider;
 
-impl<S: 'static + Send + Sync> ToolDivider<S> {
+impl ToolDivider {
     pub fn new() -> Self {
-        Self {
-            state_type: PhantomData,
-        }
+        Self
     }
 
-    fn render(self, _view: &mut S, cx: &mut ViewContext<S>) -> impl Component<S> {
+    fn render<V: 'static>(self, _view: &mut V, cx: &mut ViewContext<V>) -> impl Component<V> {
         let theme = theme(cx);
 
         div().w_px().h_3().bg(theme.border)
diff --git a/crates/ui2/src/static_data.rs b/crates/ui2/src/static_data.rs
index 82ab7da0e4cbc435e03334a20bdee78b68be5903..f1b2405e72bc6fd559e37b2590fd9bd029a965c8 100644
--- a/crates/ui2/src/static_data.rs
+++ b/crates/ui2/src/static_data.rs
@@ -13,7 +13,7 @@ use crate::{
 };
 use crate::{HighlightedText, ListDetailsEntry};
 
-pub fn static_tabs_example<S: 'static + Send + Sync + Clone>() -> Vec<Tab<S>> {
+pub fn static_tabs_example() -> Vec<Tab> {
     vec![
         Tab::new("wip.rs")
             .title("wip.rs".to_string())
@@ -63,7 +63,7 @@ pub fn static_tabs_example<S: 'static + Send + Sync + Clone>() -> Vec<Tab<S>> {
     ]
 }
 
-pub fn static_tabs_1<S: 'static + Send + Sync + Clone>() -> Vec<Tab<S>> {
+pub fn static_tabs_1() -> Vec<Tab> {
     vec![
         Tab::new("project_panel.rs")
             .title("project_panel.rs".to_string())
@@ -87,7 +87,7 @@ pub fn static_tabs_1<S: 'static + Send + Sync + Clone>() -> Vec<Tab<S>> {
     ]
 }
 
-pub fn static_tabs_2<S: 'static + Send + Sync + Clone>() -> Vec<Tab<S>> {
+pub fn static_tabs_2() -> Vec<Tab> {
     vec![
         Tab::new("tab_bar.rs")
             .title("tab_bar.rs".to_string())
@@ -102,7 +102,7 @@ pub fn static_tabs_2<S: 'static + Send + Sync + Clone>() -> Vec<Tab<S>> {
     ]
 }
 
-pub fn static_tabs_3<S: 'static + Send + Sync + Clone>() -> Vec<Tab<S>> {
+pub fn static_tabs_3() -> Vec<Tab> {
     vec![Tab::new("static_tabs_3")
         .git_status(GitStatus::Created)
         .current(true)]
@@ -325,7 +325,7 @@ pub fn static_players_with_call_status() -> Vec<PlayerWithCallStatus> {
     ]
 }
 
-pub fn static_new_notification_items<S: 'static + Send + Sync>() -> Vec<ListItem<S>> {
+pub fn static_new_notification_items<S: 'static>() -> Vec<ListItem<S>> {
     vec![
         ListDetailsEntry::new("maxdeviant invited you to join a stream in #design.")
             .meta("4 people in stream."),
@@ -336,7 +336,7 @@ pub fn static_new_notification_items<S: 'static + Send + Sync>() -> Vec<ListItem
     .collect()
 }
 
-pub fn static_read_notification_items<S: 'static + Send + Sync>() -> Vec<ListItem<S>> {
+pub fn static_read_notification_items<S: 'static>() -> Vec<ListItem<S>> {
     vec![
         ListDetailsEntry::new("mikaylamaki added you as a contact.").actions(vec![
             Button::new("Decline"),
@@ -352,7 +352,7 @@ pub fn static_read_notification_items<S: 'static + Send + Sync>() -> Vec<ListIte
     .collect()
 }
 
-pub fn static_project_panel_project_items<S: 'static + Send + Sync>() -> Vec<ListItem<S>> {
+pub fn static_project_panel_project_items<S: 'static>() -> Vec<ListItem<S>> {
     vec![
         ListEntry::new(Label::new("zed"))
             .left_icon(Icon::FolderOpen.into())
@@ -479,7 +479,7 @@ pub fn static_project_panel_project_items<S: 'static + Send + Sync>() -> Vec<Lis
     .collect()
 }
 
-pub fn static_project_panel_single_items<S: 'static + Send + Sync>() -> Vec<ListItem<S>> {
+pub fn static_project_panel_single_items<S: 'static>() -> Vec<ListItem<S>> {
     vec![
         ListEntry::new(Label::new("todo.md"))
             .left_icon(Icon::FileDoc.into())
@@ -496,7 +496,7 @@ pub fn static_project_panel_single_items<S: 'static + Send + Sync>() -> Vec<List
     .collect()
 }
 
-pub fn static_collab_panel_current_call<S: 'static + Send + Sync>() -> Vec<ListItem<S>> {
+pub fn static_collab_panel_current_call<S: 'static>() -> Vec<ListItem<S>> {
     vec![
         ListEntry::new(Label::new("as-cii")).left_avatar("http://github.com/as-cii.png?s=50"),
         ListEntry::new(Label::new("nathansobo"))
@@ -509,7 +509,7 @@ pub fn static_collab_panel_current_call<S: 'static + Send + Sync>() -> Vec<ListI
     .collect()
 }
 
-pub fn static_collab_panel_channels<S: 'static + Send + Sync>() -> Vec<ListItem<S>> {
+pub fn static_collab_panel_channels<S: 'static>() -> Vec<ListItem<S>> {
     vec![
         ListEntry::new(Label::new("zed"))
             .left_icon(Icon::Hash.into())
@@ -573,7 +573,7 @@ pub fn static_collab_panel_channels<S: 'static + Send + Sync>() -> Vec<ListItem<
     .collect()
 }
 
-pub fn example_editor_actions<S: 'static + Send + Sync>() -> Vec<PaletteItem<S>> {
+pub fn example_editor_actions() -> Vec<PaletteItem> {
     vec![
         PaletteItem::new("New File").keybinding(Keybinding::new(
             "N".to_string(),
@@ -638,7 +638,7 @@ pub fn empty_editor_example(cx: &mut WindowContext) -> EditorPane {
     )
 }
 
-pub fn empty_buffer_example<S: 'static + Send + Sync + Clone>() -> Buffer<S> {
+pub fn empty_buffer_example() -> Buffer {
     Buffer::new("empty-buffer").set_rows(Some(BufferRows::default()))
 }
 
@@ -663,9 +663,7 @@ pub fn hello_world_rust_editor_example(cx: &mut WindowContext) -> EditorPane {
     )
 }
 
-pub fn hello_world_rust_buffer_example<S: 'static + Send + Sync + Clone>(
-    theme: &Theme,
-) -> Buffer<S> {
+pub fn hello_world_rust_buffer_example(theme: &Theme) -> Buffer {
     Buffer::new("hello-world-rust-buffer")
         .set_title("hello_world.rs".to_string())
         .set_path("src/hello_world.rs".to_string())
@@ -804,9 +802,7 @@ pub fn hello_world_rust_editor_with_status_example(cx: &mut WindowContext) -> Ed
     )
 }
 
-pub fn hello_world_rust_buffer_with_status_example<S: 'static + Send + Sync + Clone>(
-    theme: &Theme,
-) -> Buffer<S> {
+pub fn hello_world_rust_buffer_with_status_example(theme: &Theme) -> Buffer {
     Buffer::new("hello-world-rust-buffer-with-status")
         .set_title("hello_world.rs".to_string())
         .set_path("src/hello_world.rs".to_string())
@@ -952,7 +948,7 @@ pub fn hello_world_rust_with_status_buffer_rows(theme: &Theme) -> Vec<BufferRow>
     ]
 }
 
-pub fn terminal_buffer<S: 'static + Send + Sync + Clone>(theme: &Theme) -> Buffer<S> {
+pub fn terminal_buffer(theme: &Theme) -> Buffer {
     Buffer::new("terminal")
         .set_title("zed — fish".to_string())
         .set_rows(Some(BufferRows {
diff --git a/crates/ui2/src/story.rs b/crates/ui2/src/story.rs
index c35ddff0a9254c042efb1c9cb826f5180dc75514..fae65a16b705f84f8532a5c514da7c4cac92798d 100644
--- a/crates/ui2/src/story.rs
+++ b/crates/ui2/src/story.rs
@@ -5,7 +5,7 @@ use crate::prelude::*;
 pub struct Story {}
 
 impl Story {
-    pub fn container<S: 'static + Send + Sync>(cx: &mut ViewContext<S>) -> Div<S> {
+    pub fn container<S: 'static>(cx: &mut ViewContext<S>) -> Div<S> {
         let theme = theme(cx);
 
         div()
@@ -18,7 +18,7 @@ impl Story {
             .bg(theme.background)
     }
 
-    pub fn title<S: 'static + Send + Sync>(
+    pub fn title<S: 'static>(
         cx: &mut ViewContext<S>,
         title: &str,
     ) -> impl Component<S> {
@@ -30,11 +30,11 @@ impl Story {
             .child(title.to_owned())
     }
 
-    pub fn title_for<S: 'static + Send + Sync, T>(cx: &mut ViewContext<S>) -> impl Component<S> {
+    pub fn title_for<S: 'static, T>(cx: &mut ViewContext<S>) -> impl Component<S> {
         Self::title(cx, std::any::type_name::<T>())
     }
 
-    pub fn label<S: 'static + Send + Sync>(
+    pub fn label<S: 'static>(
         cx: &mut ViewContext<S>,
         label: &str,
     ) -> impl Component<S> {