From f3979a9f283181cb1a0feb15322247704f78f7df Mon Sep 17 00:00:00 2001
From: Antonio Scandurra <me@as-cii.com>
Date: Sat, 21 Oct 2023 15:59:52 +0200
Subject: [PATCH] Checkpoint

---
 Cargo.lock                                    |  30 --
 Cargo.toml                                    |   2 -
 crates/gpui2/Cargo.toml                       |  32 --
 crates/gpui2/src/adapter.rs                   |  76 ---
 crates/gpui2/src/color.rs                     | 324 ------------
 crates/gpui2/src/element.rs                   | 232 --------
 crates/gpui2/src/elements.rs                  |  10 -
 crates/gpui2/src/elements/div.rs              | 320 -----------
 crates/gpui2/src/elements/hoverable.rs        | 105 ----
 crates/gpui2/src/elements/img.rs              | 110 ----
 crates/gpui2/src/elements/pressable.rs        | 113 ----
 crates/gpui2/src/elements/svg.rs              |  84 ---
 crates/gpui2/src/elements/text.rs             | 105 ----
 crates/gpui2/src/gpui2.rs                     |  22 -
 crates/gpui2/src/interactive.rs               | 165 ------
 crates/gpui2/src/style.rs                     | 498 ------------------
 crates/gpui2/src/view.rs                      |  26 -
 crates/gpui2/src/view_context.rs              |  79 ---
 crates/gpui2/src/view_handle.rs               |  60 ---
 crates/gpui2_macros/Cargo.toml                |  14 -
 crates/gpui2_macros/src/derive_element.rs     |  93 ----
 .../gpui2_macros/src/derive_into_element.rs   |  69 ---
 crates/gpui2_macros/src/gpui2_macros.rs       |  20 -
 crates/gpui2_macros/src/styleable_helpers.rs  | 408 --------------
 24 files changed, 2997 deletions(-)
 delete mode 100644 crates/gpui2/Cargo.toml
 delete mode 100644 crates/gpui2/src/adapter.rs
 delete mode 100644 crates/gpui2/src/color.rs
 delete mode 100644 crates/gpui2/src/element.rs
 delete mode 100644 crates/gpui2/src/elements.rs
 delete mode 100644 crates/gpui2/src/elements/div.rs
 delete mode 100644 crates/gpui2/src/elements/hoverable.rs
 delete mode 100644 crates/gpui2/src/elements/img.rs
 delete mode 100644 crates/gpui2/src/elements/pressable.rs
 delete mode 100644 crates/gpui2/src/elements/svg.rs
 delete mode 100644 crates/gpui2/src/elements/text.rs
 delete mode 100644 crates/gpui2/src/gpui2.rs
 delete mode 100644 crates/gpui2/src/interactive.rs
 delete mode 100644 crates/gpui2/src/style.rs
 delete mode 100644 crates/gpui2/src/view.rs
 delete mode 100644 crates/gpui2/src/view_context.rs
 delete mode 100644 crates/gpui2/src/view_handle.rs
 delete mode 100644 crates/gpui2_macros/Cargo.toml
 delete mode 100644 crates/gpui2_macros/src/derive_element.rs
 delete mode 100644 crates/gpui2_macros/src/derive_into_element.rs
 delete mode 100644 crates/gpui2_macros/src/gpui2_macros.rs
 delete mode 100644 crates/gpui2_macros/src/styleable_helpers.rs

diff --git a/Cargo.lock b/Cargo.lock
index e18edc304a..5c87911491 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3271,36 +3271,6 @@ dependencies = [
  "waker-fn",
 ]
 
-[[package]]
-name = "gpui2"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "derive_more",
- "futures 0.3.28",
- "gpui",
- "gpui2_macros",
- "log",
- "parking_lot 0.11.2",
- "refineable",
- "rust-embed",
- "serde",
- "settings",
- "simplelog",
- "smallvec",
- "theme",
- "util",
-]
-
-[[package]]
-name = "gpui2_macros"
-version = "0.1.0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "gpui3"
 version = "0.1.0"
diff --git a/Cargo.toml b/Cargo.toml
index 715d085371..16907100a0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -34,8 +34,6 @@ members = [
     "crates/go_to_line",
     "crates/gpui",
     "crates/gpui_macros",
-    "crates/gpui2",
-    "crates/gpui2_macros",
     "crates/gpui3",
     "crates/gpui3_macros",
     "crates/install_cli",
diff --git a/crates/gpui2/Cargo.toml b/crates/gpui2/Cargo.toml
deleted file mode 100644
index 093ab1e347..0000000000
--- a/crates/gpui2/Cargo.toml
+++ /dev/null
@@ -1,32 +0,0 @@
-[package]
-name = "gpui2"
-version = "0.1.0"
-edition = "2021"
-publish = false
-
-[lib]
-name = "gpui2"
-path = "src/gpui2.rs"
-
-[features]
-test-support = ["gpui/test-support"]
-
-[dependencies]
-anyhow.workspace = true
-derive_more.workspace = true
-gpui = { path = "../gpui" }
-log.workspace = true
-futures.workspace = true
-gpui2_macros = { path = "../gpui2_macros" }
-parking_lot.workspace = true
-refineable.workspace = true
-rust-embed.workspace = true
-serde.workspace = true
-settings = { path = "../settings" }
-simplelog = "0.9"
-smallvec.workspace = true
-theme = { path = "../theme" }
-util = { path = "../util" }
-
-[dev-dependencies]
-gpui = { path = "../gpui", features = ["test-support"] }
diff --git a/crates/gpui2/src/adapter.rs b/crates/gpui2/src/adapter.rs
deleted file mode 100644
index c36966d722..0000000000
--- a/crates/gpui2/src/adapter.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-use crate::ViewContext;
-use gpui::{geometry::rect::RectF, LayoutEngine, LayoutId};
-use util::ResultExt;
-
-/// Makes a new, gpui2-style element into a legacy element.
-pub struct AdapterElement<V>(pub(crate) crate::element::AnyElement<V>);
-
-impl<V: 'static> gpui::Element<V> for AdapterElement<V> {
-    type LayoutState = Option<(LayoutEngine, LayoutId)>;
-    type PaintState = ();
-
-    fn layout(
-        &mut self,
-        constraint: gpui::SizeConstraint,
-        view: &mut V,
-        cx: &mut gpui::ViewContext<V>,
-    ) -> (gpui::geometry::vector::Vector2F, Self::LayoutState) {
-        cx.push_layout_engine(LayoutEngine::new());
-
-        let mut cx = ViewContext::new(cx);
-        let layout_id = self.0.layout(view, &mut cx).log_err();
-        if let Some(layout_id) = layout_id {
-            cx.layout_engine()
-                .unwrap()
-                .compute_layout(layout_id, constraint.max)
-                .log_err();
-        }
-
-        let layout_engine = cx.pop_layout_engine();
-        debug_assert!(layout_engine.is_some(),
-            "unexpected layout stack state. is there an unmatched pop_layout_engine in the called code?"
-        );
-
-        (constraint.max, layout_engine.zip(layout_id))
-    }
-
-    fn paint(
-        &mut self,
-        bounds: RectF,
-        _visible_bounds: RectF,
-        layout_data: &mut Option<(LayoutEngine, LayoutId)>,
-        view: &mut V,
-        cx: &mut gpui::ViewContext<V>,
-    ) -> Self::PaintState {
-        let (layout_engine, layout_id) = layout_data.take().unwrap();
-        cx.push_layout_engine(layout_engine);
-        self.0
-            .paint(view, bounds.origin(), &mut ViewContext::new(cx));
-        *layout_data = cx.pop_layout_engine().zip(Some(layout_id));
-        debug_assert!(layout_data.is_some());
-    }
-
-    fn rect_for_text_range(
-        &self,
-        _range_utf16: std::ops::Range<usize>,
-        _bounds: RectF,
-        _visible_bounds: RectF,
-        _layout: &Self::LayoutState,
-        _paint: &Self::PaintState,
-        _view: &V,
-        _cx: &gpui::ViewContext<V>,
-    ) -> Option<RectF> {
-        todo!("implement before merging to main")
-    }
-
-    fn debug(
-        &self,
-        _bounds: RectF,
-        _layout: &Self::LayoutState,
-        _paint: &Self::PaintState,
-        _view: &V,
-        _cx: &gpui::ViewContext<V>,
-    ) -> gpui::serde_json::Value {
-        todo!("implement before merging to main")
-    }
-}
diff --git a/crates/gpui2/src/color.rs b/crates/gpui2/src/color.rs
deleted file mode 100644
index 11590f967c..0000000000
--- a/crates/gpui2/src/color.rs
+++ /dev/null
@@ -1,324 +0,0 @@
-#![allow(dead_code)]
-
-use serde::de::{self, Deserialize, Deserializer, Visitor};
-use smallvec::SmallVec;
-use std::fmt;
-use std::{num::ParseIntError, ops::Range};
-
-pub fn rgb<C: From<Rgba>>(hex: u32) -> C {
-    let r = ((hex >> 16) & 0xFF) as f32 / 255.0;
-    let g = ((hex >> 8) & 0xFF) as f32 / 255.0;
-    let b = (hex & 0xFF) as f32 / 255.0;
-    Rgba { r, g, b, a: 1.0 }.into()
-}
-
-#[derive(Clone, Copy, Default, Debug)]
-pub struct Rgba {
-    pub r: f32,
-    pub g: f32,
-    pub b: f32,
-    pub a: f32,
-}
-
-struct RgbaVisitor;
-
-impl<'de> Visitor<'de> for RgbaVisitor {
-    type Value = Rgba;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a string in the format #rrggbb or #rrggbbaa")
-    }
-
-    fn visit_str<E: de::Error>(self, value: &str) -> Result<Rgba, E> {
-        if value.len() == 7 || value.len() == 9 {
-            let r = u8::from_str_radix(&value[1..3], 16).unwrap() as f32 / 255.0;
-            let g = u8::from_str_radix(&value[3..5], 16).unwrap() as f32 / 255.0;
-            let b = u8::from_str_radix(&value[5..7], 16).unwrap() as f32 / 255.0;
-            let a = if value.len() == 9 {
-                u8::from_str_radix(&value[7..9], 16).unwrap() as f32 / 255.0
-            } else {
-                1.0
-            };
-            Ok(Rgba { r, g, b, a })
-        } else {
-            Err(E::custom(
-                "Bad format for RGBA. Expected #rrggbb or #rrggbbaa.",
-            ))
-        }
-    }
-}
-
-impl<'de> Deserialize<'de> for Rgba {
-    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        deserializer.deserialize_str(RgbaVisitor)
-    }
-}
-
-pub trait Lerp {
-    fn lerp(&self, level: f32) -> Hsla;
-}
-
-impl Lerp for Range<Hsla> {
-    fn lerp(&self, level: f32) -> Hsla {
-        let level = level.clamp(0., 1.);
-        Hsla {
-            h: self.start.h + (level * (self.end.h - self.start.h)),
-            s: self.start.s + (level * (self.end.s - self.start.s)),
-            l: self.start.l + (level * (self.end.l - self.start.l)),
-            a: self.start.a + (level * (self.end.a - self.start.a)),
-        }
-    }
-}
-
-impl From<gpui::color::Color> for Rgba {
-    fn from(value: gpui::color::Color) -> Self {
-        Self {
-            r: value.0.r as f32 / 255.0,
-            g: value.0.g as f32 / 255.0,
-            b: value.0.b as f32 / 255.0,
-            a: value.0.a as f32 / 255.0,
-        }
-    }
-}
-
-impl From<Hsla> for Rgba {
-    fn from(color: Hsla) -> Self {
-        let h = color.h;
-        let s = color.s;
-        let l = color.l;
-
-        let c = (1.0 - (2.0 * l - 1.0).abs()) * s;
-        let x = c * (1.0 - ((h * 6.0) % 2.0 - 1.0).abs());
-        let m = l - c / 2.0;
-        let cm = c + m;
-        let xm = x + m;
-
-        let (r, g, b) = match (h * 6.0).floor() as i32 {
-            0 | 6 => (cm, xm, m),
-            1 => (xm, cm, m),
-            2 => (m, cm, xm),
-            3 => (m, xm, cm),
-            4 => (xm, m, cm),
-            _ => (cm, m, xm),
-        };
-
-        Rgba {
-            r,
-            g,
-            b,
-            a: color.a,
-        }
-    }
-}
-
-impl TryFrom<&'_ str> for Rgba {
-    type Error = ParseIntError;
-
-    fn try_from(value: &'_ str) -> Result<Self, Self::Error> {
-        let r = u8::from_str_radix(&value[1..3], 16)? as f32 / 255.0;
-        let g = u8::from_str_radix(&value[3..5], 16)? as f32 / 255.0;
-        let b = u8::from_str_radix(&value[5..7], 16)? as f32 / 255.0;
-        let a = if value.len() > 7 {
-            u8::from_str_radix(&value[7..9], 16)? as f32 / 255.0
-        } else {
-            1.0
-        };
-
-        Ok(Rgba { r, g, b, a })
-    }
-}
-
-impl Into<gpui::color::Color> for Rgba {
-    fn into(self) -> gpui::color::Color {
-        gpui::color::rgba(self.r, self.g, self.b, self.a)
-    }
-}
-
-#[derive(Default, Copy, Clone, Debug, PartialEq)]
-pub struct Hsla {
-    pub h: f32,
-    pub s: f32,
-    pub l: f32,
-    pub a: f32,
-}
-
-pub fn hsla(h: f32, s: f32, l: f32, a: f32) -> Hsla {
-    Hsla {
-        h: h.clamp(0., 1.),
-        s: s.clamp(0., 1.),
-        l: l.clamp(0., 1.),
-        a: a.clamp(0., 1.),
-    }
-}
-
-pub fn black() -> Hsla {
-    Hsla {
-        h: 0.,
-        s: 0.,
-        l: 0.,
-        a: 1.,
-    }
-}
-
-impl From<Rgba> for Hsla {
-    fn from(color: Rgba) -> Self {
-        let r = color.r;
-        let g = color.g;
-        let b = color.b;
-
-        let max = r.max(g.max(b));
-        let min = r.min(g.min(b));
-        let delta = max - min;
-
-        let l = (max + min) / 2.0;
-        let s = if l == 0.0 || l == 1.0 {
-            0.0
-        } else if l < 0.5 {
-            delta / (2.0 * l)
-        } else {
-            delta / (2.0 - 2.0 * l)
-        };
-
-        let h = if delta == 0.0 {
-            0.0
-        } else if max == r {
-            ((g - b) / delta).rem_euclid(6.0) / 6.0
-        } else if max == g {
-            ((b - r) / delta + 2.0) / 6.0
-        } else {
-            ((r - g) / delta + 4.0) / 6.0
-        };
-
-        Hsla {
-            h,
-            s,
-            l,
-            a: color.a,
-        }
-    }
-}
-
-impl Hsla {
-    /// Scales the saturation and lightness by the given values, clamping at 1.0.
-    pub fn scale_sl(mut self, s: f32, l: f32) -> Self {
-        self.s = (self.s * s).clamp(0., 1.);
-        self.l = (self.l * l).clamp(0., 1.);
-        self
-    }
-
-    /// Increases the saturation of the color by a certain amount, with a max
-    /// value of 1.0.
-    pub fn saturate(mut self, amount: f32) -> Self {
-        self.s += amount;
-        self.s = self.s.clamp(0.0, 1.0);
-        self
-    }
-
-    /// Decreases the saturation of the color by a certain amount, with a min
-    /// value of 0.0.
-    pub fn desaturate(mut self, amount: f32) -> Self {
-        self.s -= amount;
-        self.s = self.s.max(0.0);
-        if self.s < 0.0 {
-            self.s = 0.0;
-        }
-        self
-    }
-
-    /// Brightens the color by increasing the lightness by a certain amount,
-    /// with a max value of 1.0.
-    pub fn brighten(mut self, amount: f32) -> Self {
-        self.l += amount;
-        self.l = self.l.clamp(0.0, 1.0);
-        self
-    }
-
-    /// Darkens the color by decreasing the lightness by a certain amount,
-    /// with a max value of 0.0.
-    pub fn darken(mut self, amount: f32) -> Self {
-        self.l -= amount;
-        self.l = self.l.clamp(0.0, 1.0);
-        self
-    }
-}
-
-impl From<gpui::color::Color> for Hsla {
-    fn from(value: gpui::color::Color) -> Self {
-        Rgba::from(value).into()
-    }
-}
-
-impl Into<gpui::color::Color> for Hsla {
-    fn into(self) -> gpui::color::Color {
-        Rgba::from(self).into()
-    }
-}
-
-impl<'de> Deserialize<'de> for Hsla {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        // First, deserialize it into Rgba
-        let rgba = Rgba::deserialize(deserializer)?;
-
-        // Then, use the From<Rgba> for Hsla implementation to convert it
-        Ok(Hsla::from(rgba))
-    }
-}
-
-pub struct ColorScale {
-    colors: SmallVec<[Hsla; 2]>,
-    positions: SmallVec<[f32; 2]>,
-}
-
-pub fn scale<I, C>(colors: I) -> ColorScale
-where
-    I: IntoIterator<Item = C>,
-    C: Into<Hsla>,
-{
-    let mut scale = ColorScale {
-        colors: colors.into_iter().map(Into::into).collect(),
-        positions: SmallVec::new(),
-    };
-    let num_colors: f32 = scale.colors.len() as f32 - 1.0;
-    scale.positions = (0..scale.colors.len())
-        .map(|i| i as f32 / num_colors)
-        .collect();
-    scale
-}
-
-impl ColorScale {
-    fn at(&self, t: f32) -> Hsla {
-        // Ensure that the input is within [0.0, 1.0]
-        debug_assert!(
-            0.0 <= t && t <= 1.0,
-            "t value {} is out of range. Expected value in range 0.0 to 1.0",
-            t
-        );
-
-        let position = match self
-            .positions
-            .binary_search_by(|a| a.partial_cmp(&t).unwrap())
-        {
-            Ok(index) | Err(index) => index,
-        };
-        let lower_bound = position.saturating_sub(1);
-        let upper_bound = position.min(self.colors.len() - 1);
-        let lower_color = &self.colors[lower_bound];
-        let upper_color = &self.colors[upper_bound];
-
-        match upper_bound.checked_sub(lower_bound) {
-            Some(0) | None => *lower_color,
-            Some(_) => {
-                let interval_t = (t - self.positions[lower_bound])
-                    / (self.positions[upper_bound] - self.positions[lower_bound]);
-                let h = lower_color.h + interval_t * (upper_color.h - lower_color.h);
-                let s = lower_color.s + interval_t * (upper_color.s - lower_color.s);
-                let l = lower_color.l + interval_t * (upper_color.l - lower_color.l);
-                let a = lower_color.a + interval_t * (upper_color.a - lower_color.a);
-                Hsla { h, s, l, a }
-            }
-        }
-    }
-}
diff --git a/crates/gpui2/src/element.rs b/crates/gpui2/src/element.rs
deleted file mode 100644
index 5fb7288585..0000000000
--- a/crates/gpui2/src/element.rs
+++ /dev/null
@@ -1,232 +0,0 @@
-pub use crate::ViewContext;
-use anyhow::Result;
-use gpui::geometry::vector::Vector2F;
-pub use gpui::{Layout, LayoutId};
-use smallvec::SmallVec;
-
-pub trait Element<V: 'static>: 'static + IntoElement<V> {
-    type PaintState;
-
-    fn layout(
-        &mut self,
-        view: &mut V,
-        cx: &mut ViewContext<V>,
-    ) -> Result<(LayoutId, Self::PaintState)>
-    where
-        Self: Sized;
-
-    fn paint(
-        &mut self,
-        view: &mut V,
-        parent_origin: Vector2F,
-        layout: &Layout,
-        state: &mut Self::PaintState,
-        cx: &mut ViewContext<V>,
-    ) where
-        Self: Sized;
-
-    fn into_any(self) -> AnyElement<V>
-    where
-        Self: 'static + Sized,
-    {
-        AnyElement(Box::new(StatefulElement {
-            element: self,
-            phase: ElementPhase::Init,
-        }))
-    }
-
-    /// Applies a given function `then` to the current element if `condition` is true.
-    /// This function is used to conditionally modify the element based on a given condition.
-    /// If `condition` is false, it just returns the current element as it is.
-    ///
-    /// # Parameters
-    /// - `self`: The current element
-    /// - `condition`: The boolean condition based on which `then` is applied to the element.
-    /// - `then`: A function that takes in the current element and returns a possibly modified element.
-    ///
-    /// # Return
-    /// It returns the potentially modified element.
-    fn when(mut self, condition: bool, then: impl FnOnce(Self) -> Self) -> Self
-    where
-        Self: Sized,
-    {
-        if condition {
-            self = then(self);
-        }
-        self
-    }
-}
-
-/// Used to make ElementState<V, E> into a trait object, so we can wrap it in AnyElement<V>.
-trait AnyStatefulElement<V> {
-    fn layout(&mut self, view: &mut V, cx: &mut ViewContext<V>) -> Result<LayoutId>;
-    fn paint(&mut self, view: &mut V, parent_origin: Vector2F, cx: &mut ViewContext<V>);
-}
-
-/// A wrapper around an element that stores its layout state.
-struct StatefulElement<V: 'static, E: Element<V>> {
-    element: E,
-    phase: ElementPhase<V, E>,
-}
-
-enum ElementPhase<V: 'static, E: Element<V>> {
-    Init,
-    PostLayout {
-        layout_id: LayoutId,
-        paint_state: E::PaintState,
-    },
-    #[allow(dead_code)]
-    PostPaint {
-        layout: Layout,
-        paint_state: E::PaintState,
-    },
-    Error(String),
-}
-
-impl<V: 'static, E: Element<V>> std::fmt::Debug for ElementPhase<V, E> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            ElementPhase::Init => write!(f, "Init"),
-            ElementPhase::PostLayout { layout_id, .. } => {
-                write!(f, "PostLayout with layout id: {:?}", layout_id)
-            }
-            ElementPhase::PostPaint { layout, .. } => {
-                write!(f, "PostPaint with layout: {:?}", layout)
-            }
-            ElementPhase::Error(err) => write!(f, "Error: {}", err),
-        }
-    }
-}
-
-impl<V: 'static, E: Element<V>> Default for ElementPhase<V, E> {
-    fn default() -> Self {
-        Self::Init
-    }
-}
-
-/// We blanket-implement the object-safe ElementStateObject interface to make ElementStates into trait objects
-impl<V, E: Element<V>> AnyStatefulElement<V> for StatefulElement<V, E> {
-    fn layout(&mut self, view: &mut V, cx: &mut ViewContext<V>) -> Result<LayoutId> {
-        let result;
-        self.phase = match self.element.layout(view, cx) {
-            Ok((layout_id, paint_state)) => {
-                result = Ok(layout_id);
-                ElementPhase::PostLayout {
-                    layout_id,
-                    paint_state,
-                }
-            }
-            Err(error) => {
-                let message = error.to_string();
-                result = Err(error);
-                ElementPhase::Error(message)
-            }
-        };
-        result
-    }
-
-    fn paint(&mut self, view: &mut V, parent_origin: Vector2F, cx: &mut ViewContext<V>) {
-        self.phase = match std::mem::take(&mut self.phase) {
-            ElementPhase::PostLayout {
-                layout_id,
-                mut paint_state,
-            } => match cx.computed_layout(layout_id) {
-                Ok(layout) => {
-                    self.element
-                        .paint(view, parent_origin, &layout, &mut paint_state, cx);
-                    ElementPhase::PostPaint {
-                        layout,
-                        paint_state,
-                    }
-                }
-                Err(error) => ElementPhase::Error(error.to_string()),
-            },
-            ElementPhase::PostPaint {
-                layout,
-                mut paint_state,
-            } => {
-                self.element
-                    .paint(view, parent_origin, &layout, &mut paint_state, cx);
-                ElementPhase::PostPaint {
-                    layout,
-                    paint_state,
-                }
-            }
-            phase @ ElementPhase::Error(_) => phase,
-
-            phase @ _ => {
-                panic!("invalid element phase to call paint: {:?}", phase);
-            }
-        };
-    }
-}
-
-/// A dynamic element.
-pub struct AnyElement<V>(Box<dyn AnyStatefulElement<V>>);
-
-impl<V> AnyElement<V> {
-    pub fn layout(&mut self, view: &mut V, cx: &mut ViewContext<V>) -> Result<LayoutId> {
-        self.0.layout(view, cx)
-    }
-
-    pub fn paint(&mut self, view: &mut V, parent_origin: Vector2F, cx: &mut ViewContext<V>) {
-        self.0.paint(view, parent_origin, cx)
-    }
-}
-
-pub trait ParentElement<V: 'static> {
-    fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<V>; 2]>;
-
-    fn child(mut self, child: impl IntoElement<V>) -> Self
-    where
-        Self: Sized,
-    {
-        self.children_mut().push(child.into_element().into_any());
-        self
-    }
-
-    fn children<I, E>(mut self, children: I) -> Self
-    where
-        I: IntoIterator<Item = E>,
-        E: IntoElement<V>,
-        Self: Sized,
-    {
-        self.children_mut().extend(
-            children
-                .into_iter()
-                .map(|child| child.into_element().into_any()),
-        );
-        self
-    }
-
-    // HACK: This is a temporary hack to get children working for the purposes
-    // of building UI on top of the current version of gpui2.
-    //
-    // We'll (hopefully) be moving away from this in the future.
-    fn children_any<I>(mut self, children: I) -> Self
-    where
-        I: IntoIterator<Item = AnyElement<V>>,
-        Self: Sized,
-    {
-        self.children_mut().extend(children.into_iter());
-        self
-    }
-
-    // HACK: This is a temporary hack to get children working for the purposes
-    // of building UI on top of the current version of gpui2.
-    //
-    // We'll (hopefully) be moving away from this in the future.
-    fn child_any(mut self, children: AnyElement<V>) -> Self
-    where
-        Self: Sized,
-    {
-        self.children_mut().push(children);
-        self
-    }
-}
-
-pub trait IntoElement<V: 'static> {
-    type Element: Element<V>;
-
-    fn into_element(self) -> Self::Element;
-}
diff --git a/crates/gpui2/src/elements.rs b/crates/gpui2/src/elements.rs
deleted file mode 100644
index 5b4942fc46..0000000000
--- a/crates/gpui2/src/elements.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-pub mod div;
-pub mod hoverable;
-mod img;
-pub mod pressable;
-pub mod svg;
-pub mod text;
-
-pub use div::div;
-pub use img::img;
-pub use svg::svg;
diff --git a/crates/gpui2/src/elements/div.rs b/crates/gpui2/src/elements/div.rs
deleted file mode 100644
index 2fd85f6465..0000000000
--- a/crates/gpui2/src/elements/div.rs
+++ /dev/null
@@ -1,320 +0,0 @@
-use std::{cell::Cell, rc::Rc};
-
-use crate::{
-    element::{AnyElement, Element, IntoElement, Layout, ParentElement},
-    hsla,
-    style::{CornerRadii, Overflow, Style, StyleHelpers, Styleable},
-    InteractionHandlers, Interactive, ViewContext,
-};
-use anyhow::Result;
-use gpui::{
-    geometry::{rect::RectF, vector::Vector2F, Point},
-    platform::{MouseButton, MouseButtonEvent, MouseMovedEvent, ScrollWheelEvent},
-    scene::{self},
-    LayoutId,
-};
-use refineable::{Cascade, Refineable};
-use smallvec::SmallVec;
-use util::ResultExt;
-
-pub struct Div<V: 'static> {
-    styles: Cascade<Style>,
-    handlers: InteractionHandlers<V>,
-    children: SmallVec<[AnyElement<V>; 2]>,
-    scroll_state: Option<ScrollState>,
-}
-
-pub fn div<V>() -> Div<V> {
-    Div {
-        styles: Default::default(),
-        handlers: Default::default(),
-        children: Default::default(),
-        scroll_state: None,
-    }
-}
-
-impl<V: 'static> Element<V> for Div<V> {
-    type PaintState = Vec<LayoutId>;
-
-    fn layout(
-        &mut self,
-        view: &mut V,
-        cx: &mut ViewContext<V>,
-    ) -> Result<(LayoutId, Self::PaintState)>
-    where
-        Self: Sized,
-    {
-        let style = self.computed_style();
-        let pop_text_style = style.text_style(cx).map_or(false, |style| {
-            cx.push_text_style(&style).log_err().is_some()
-        });
-
-        let children = self
-            .children
-            .iter_mut()
-            .map(|child| child.layout(view, cx))
-            .collect::<Result<Vec<LayoutId>>>()?;
-
-        if pop_text_style {
-            cx.pop_text_style();
-        }
-
-        Ok((cx.add_layout_node(style, children.clone())?, children))
-    }
-
-    fn paint(
-        &mut self,
-        view: &mut V,
-        parent_origin: Vector2F,
-        layout: &Layout,
-        child_layouts: &mut Vec<LayoutId>,
-        cx: &mut ViewContext<V>,
-    ) where
-        Self: Sized,
-    {
-        let order = layout.order;
-        let bounds = layout.bounds + parent_origin;
-
-        let style = self.computed_style();
-        let pop_text_style = style.text_style(cx).map_or(false, |style| {
-            cx.push_text_style(&style).log_err().is_some()
-        });
-        style.paint_background(bounds, cx);
-        self.interaction_handlers().paint(order, bounds, cx);
-
-        let scrolled_origin = bounds.origin() - self.scroll_offset(&style.overflow);
-
-        // TODO: Support only one dimension being hidden
-        let mut pop_layer = false;
-        if style.overflow.y != Overflow::Visible || style.overflow.x != Overflow::Visible {
-            cx.scene().push_layer(Some(bounds));
-            pop_layer = true;
-        }
-
-        for child in &mut self.children {
-            child.paint(view, scrolled_origin, cx);
-        }
-
-        if pop_layer {
-            cx.scene().pop_layer();
-        }
-
-        style.paint_foreground(bounds, cx);
-        if pop_text_style {
-            cx.pop_text_style();
-        }
-
-        self.handle_scroll(order, bounds, style.overflow.clone(), child_layouts, cx);
-
-        if cx.is_inspector_enabled() {
-            self.paint_inspector(parent_origin, layout, cx);
-        }
-    }
-}
-
-impl<V: 'static> Div<V> {
-    pub fn overflow_hidden(mut self) -> Self {
-        self.declared_style().overflow.x = Some(Overflow::Hidden);
-        self.declared_style().overflow.y = Some(Overflow::Hidden);
-        self
-    }
-
-    pub fn overflow_hidden_x(mut self) -> Self {
-        self.declared_style().overflow.x = Some(Overflow::Hidden);
-        self
-    }
-
-    pub fn overflow_hidden_y(mut self) -> Self {
-        self.declared_style().overflow.y = Some(Overflow::Hidden);
-        self
-    }
-
-    pub fn overflow_scroll(mut self, scroll_state: ScrollState) -> Self {
-        self.scroll_state = Some(scroll_state);
-        self.declared_style().overflow.x = Some(Overflow::Scroll);
-        self.declared_style().overflow.y = Some(Overflow::Scroll);
-        self
-    }
-
-    pub fn overflow_x_scroll(mut self, scroll_state: ScrollState) -> Self {
-        self.scroll_state = Some(scroll_state);
-        self.declared_style().overflow.x = Some(Overflow::Scroll);
-        self
-    }
-
-    pub fn overflow_y_scroll(mut self, scroll_state: ScrollState) -> Self {
-        self.scroll_state = Some(scroll_state);
-        self.declared_style().overflow.y = Some(Overflow::Scroll);
-        self
-    }
-
-    fn scroll_offset(&self, overflow: &Point<Overflow>) -> Vector2F {
-        let mut offset = Vector2F::zero();
-        if overflow.y == Overflow::Scroll {
-            offset.set_y(self.scroll_state.as_ref().unwrap().y());
-        }
-        if overflow.x == Overflow::Scroll {
-            offset.set_x(self.scroll_state.as_ref().unwrap().x());
-        }
-
-        offset
-    }
-
-    fn handle_scroll(
-        &mut self,
-        order: u32,
-        bounds: RectF,
-        overflow: Point<Overflow>,
-        child_layout_ids: &[LayoutId],
-        cx: &mut ViewContext<V>,
-    ) {
-        if overflow.y == Overflow::Scroll || overflow.x == Overflow::Scroll {
-            let mut scroll_max = Vector2F::zero();
-            for child_layout_id in child_layout_ids {
-                if let Some(child_layout) = cx
-                    .layout_engine()
-                    .unwrap()
-                    .computed_layout(*child_layout_id)
-                    .log_err()
-                {
-                    scroll_max = scroll_max.max(child_layout.bounds.lower_right());
-                }
-            }
-            scroll_max -= bounds.size();
-
-            let scroll_state = self.scroll_state.as_ref().unwrap().clone();
-            cx.on_event(order, move |_, event: &ScrollWheelEvent, cx| {
-                if bounds.contains_point(event.position) {
-                    let scroll_delta = match event.delta {
-                        gpui::platform::ScrollDelta::Pixels(delta) => delta,
-                        gpui::platform::ScrollDelta::Lines(delta) => {
-                            delta * cx.text_style().font_size
-                        }
-                    };
-                    if overflow.x == Overflow::Scroll {
-                        scroll_state.set_x(
-                            (scroll_state.x() - scroll_delta.x())
-                                .max(0.)
-                                .min(scroll_max.x()),
-                        );
-                    }
-                    if overflow.y == Overflow::Scroll {
-                        scroll_state.set_y(
-                            (scroll_state.y() - scroll_delta.y())
-                                .max(0.)
-                                .min(scroll_max.y()),
-                        );
-                    }
-                    cx.repaint();
-                } else {
-                    cx.bubble_event();
-                }
-            })
-        }
-    }
-
-    fn paint_inspector(&self, parent_origin: Vector2F, layout: &Layout, cx: &mut ViewContext<V>) {
-        let style = self.styles.merged();
-        let bounds = layout.bounds + parent_origin;
-
-        let hovered = bounds.contains_point(cx.mouse_position());
-        if hovered {
-            let rem_size = cx.rem_size();
-            cx.scene().push_quad(scene::Quad {
-                bounds,
-                background: Some(hsla(0., 0., 1., 0.05).into()),
-                border: gpui::Border {
-                    color: hsla(0., 0., 1., 0.2).into(),
-                    top: 1.,
-                    right: 1.,
-                    bottom: 1.,
-                    left: 1.,
-                },
-                corner_radii: CornerRadii::default()
-                    .refined(&style.corner_radii)
-                    .to_gpui(bounds.size(), rem_size),
-            })
-        }
-
-        let pressed = Cell::new(hovered && cx.is_mouse_down(MouseButton::Left));
-        cx.on_event(layout.order, move |_, event: &MouseButtonEvent, _| {
-            if bounds.contains_point(event.position) {
-                if event.is_down {
-                    pressed.set(true);
-                } else if pressed.get() {
-                    pressed.set(false);
-                    eprintln!("clicked div {:?} {:#?}", bounds, style);
-                }
-            }
-        });
-
-        let hovered = Cell::new(hovered);
-        cx.on_event(layout.order, move |_, event: &MouseMovedEvent, cx| {
-            cx.bubble_event();
-            let hovered_now = bounds.contains_point(event.position);
-            if hovered.get() != hovered_now {
-                hovered.set(hovered_now);
-                cx.repaint();
-            }
-        });
-    }
-}
-
-impl<V> Styleable for Div<V> {
-    type Style = Style;
-
-    fn style_cascade(&mut self) -> &mut Cascade<Self::Style> {
-        &mut self.styles
-    }
-
-    fn declared_style(&mut self) -> &mut <Self::Style as Refineable>::Refinement {
-        self.styles.base()
-    }
-}
-
-impl<V> StyleHelpers for Div<V> {}
-
-impl<V> Interactive<V> for Div<V> {
-    fn interaction_handlers(&mut self) -> &mut InteractionHandlers<V> {
-        &mut self.handlers
-    }
-}
-
-impl<V: 'static> ParentElement<V> for Div<V> {
-    fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<V>; 2]> {
-        &mut self.children
-    }
-}
-
-impl<V: 'static> IntoElement<V> for Div<V> {
-    type Element = Self;
-
-    fn into_element(self) -> Self::Element {
-        self
-    }
-}
-
-#[derive(Default, Clone)]
-pub struct ScrollState(Rc<Cell<Vector2F>>);
-
-impl ScrollState {
-    pub fn x(&self) -> f32 {
-        self.0.get().x()
-    }
-
-    pub fn set_x(&self, value: f32) {
-        let mut current_value = self.0.get();
-        current_value.set_x(value);
-        self.0.set(current_value);
-    }
-
-    pub fn y(&self) -> f32 {
-        self.0.get().y()
-    }
-
-    pub fn set_y(&self, value: f32) {
-        let mut current_value = self.0.get();
-        current_value.set_y(value);
-        self.0.set(current_value);
-    }
-}
diff --git a/crates/gpui2/src/elements/hoverable.rs b/crates/gpui2/src/elements/hoverable.rs
deleted file mode 100644
index 25ee90d468..0000000000
--- a/crates/gpui2/src/elements/hoverable.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-use crate::{
-    element::{AnyElement, Element, IntoElement, Layout, ParentElement},
-    interactive::{InteractionHandlers, Interactive},
-    style::{Style, StyleHelpers, Styleable},
-    ViewContext,
-};
-use anyhow::Result;
-use gpui::{geometry::vector::Vector2F, platform::MouseMovedEvent, LayoutId};
-use refineable::{Cascade, CascadeSlot, Refineable};
-use smallvec::SmallVec;
-use std::{cell::Cell, rc::Rc};
-
-pub struct Hoverable<E: Styleable> {
-    hovered: Rc<Cell<bool>>,
-    cascade_slot: CascadeSlot,
-    hovered_style: <E::Style as Refineable>::Refinement,
-    child: E,
-}
-
-pub fn hoverable<E: Styleable>(mut child: E) -> Hoverable<E> {
-    Hoverable {
-        hovered: Rc::new(Cell::new(false)),
-        cascade_slot: child.style_cascade().reserve(),
-        hovered_style: Default::default(),
-        child,
-    }
-}
-
-impl<E: Styleable> Styleable for Hoverable<E> {
-    type Style = E::Style;
-
-    fn style_cascade(&mut self) -> &mut Cascade<Self::Style> {
-        self.child.style_cascade()
-    }
-
-    fn declared_style(&mut self) -> &mut <Self::Style as Refineable>::Refinement {
-        &mut self.hovered_style
-    }
-}
-
-impl<V: 'static, E: Element<V> + Styleable> Element<V> for Hoverable<E> {
-    type PaintState = E::PaintState;
-
-    fn layout(
-        &mut self,
-        view: &mut V,
-        cx: &mut ViewContext<V>,
-    ) -> Result<(LayoutId, Self::PaintState)>
-    where
-        Self: Sized,
-    {
-        Ok(self.child.layout(view, cx)?)
-    }
-
-    fn paint(
-        &mut self,
-        view: &mut V,
-        parent_origin: Vector2F,
-        layout: &Layout,
-        paint_state: &mut Self::PaintState,
-        cx: &mut ViewContext<V>,
-    ) where
-        Self: Sized,
-    {
-        let bounds = layout.bounds + parent_origin;
-        self.hovered.set(bounds.contains_point(cx.mouse_position()));
-
-        let slot = self.cascade_slot;
-        let style = self.hovered.get().then_some(self.hovered_style.clone());
-        self.style_cascade().set(slot, style);
-
-        let hovered = self.hovered.clone();
-        cx.on_event(layout.order, move |_view, _: &MouseMovedEvent, cx| {
-            cx.bubble_event();
-            if bounds.contains_point(cx.mouse_position()) != hovered.get() {
-                cx.repaint();
-            }
-        });
-
-        self.child
-            .paint(view, parent_origin, layout, paint_state, cx);
-    }
-}
-
-impl<E: Styleable<Style = Style>> StyleHelpers for Hoverable<E> {}
-
-impl<V: 'static, E: Interactive<V> + Styleable> Interactive<V> for Hoverable<E> {
-    fn interaction_handlers(&mut self) -> &mut InteractionHandlers<V> {
-        self.child.interaction_handlers()
-    }
-}
-
-impl<V: 'static, E: ParentElement<V> + Styleable> ParentElement<V> for Hoverable<E> {
-    fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<V>; 2]> {
-        self.child.children_mut()
-    }
-}
-
-impl<V: 'static, E: Element<V> + Styleable> IntoElement<V> for Hoverable<E> {
-    type Element = Self;
-
-    fn into_element(self) -> Self::Element {
-        self
-    }
-}
diff --git a/crates/gpui2/src/elements/img.rs b/crates/gpui2/src/elements/img.rs
deleted file mode 100644
index 221fea04a5..0000000000
--- a/crates/gpui2/src/elements/img.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-use crate as gpui2;
-use crate::{
-    style::{Style, StyleHelpers, Styleable},
-    Element,
-};
-use futures::FutureExt;
-use gpui::geometry::vector::Vector2F;
-use gpui::scene;
-use gpui2_macros::IntoElement;
-use refineable::Cascade;
-use util::arc_cow::ArcCow;
-use util::ResultExt;
-
-#[derive(IntoElement)]
-pub struct Img {
-    style: Cascade<Style>,
-    uri: Option<ArcCow<'static, str>>,
-}
-
-pub fn img() -> Img {
-    Img {
-        style: Cascade::default(),
-        uri: None,
-    }
-}
-
-impl Img {
-    pub fn uri(mut self, uri: impl Into<ArcCow<'static, str>>) -> Self {
-        self.uri = Some(uri.into());
-        self
-    }
-}
-
-impl<V: 'static> Element<V> for Img {
-    type PaintState = ();
-
-    fn layout(
-        &mut self,
-        _: &mut V,
-        cx: &mut crate::ViewContext<V>,
-    ) -> anyhow::Result<(gpui::LayoutId, Self::PaintState)>
-    where
-        Self: Sized,
-    {
-        let style = self.computed_style();
-        let layout_id = cx.add_layout_node(style, [])?;
-        Ok((layout_id, ()))
-    }
-
-    fn paint(
-        &mut self,
-        _: &mut V,
-        parent_origin: Vector2F,
-        layout: &gpui::Layout,
-        _: &mut Self::PaintState,
-        cx: &mut crate::ViewContext<V>,
-    ) where
-        Self: Sized,
-    {
-        let style = self.computed_style();
-        let bounds = layout.bounds + parent_origin;
-
-        style.paint_background(bounds, cx);
-
-        if let Some(uri) = &self.uri {
-            let image_future = cx.image_cache.get(uri.clone());
-            if let Some(data) = image_future
-                .clone()
-                .now_or_never()
-                .and_then(ResultExt::log_err)
-            {
-                let rem_size = cx.rem_size();
-                cx.scene().push_image(scene::Image {
-                    bounds,
-                    border: gpui::Border {
-                        color: style.border_color.unwrap_or_default().into(),
-                        top: style.border_widths.top.to_pixels(rem_size),
-                        right: style.border_widths.right.to_pixels(rem_size),
-                        bottom: style.border_widths.bottom.to_pixels(rem_size),
-                        left: style.border_widths.left.to_pixels(rem_size),
-                    },
-                    corner_radii: style.corner_radii.to_gpui(bounds.size(), rem_size),
-                    grayscale: false,
-                    data,
-                })
-            } else {
-                cx.spawn(|this, mut cx| async move {
-                    if image_future.await.log_err().is_some() {
-                        this.update(&mut cx, |_, cx| cx.notify()).ok();
-                    }
-                })
-                .detach();
-            }
-        }
-    }
-}
-
-impl Styleable for Img {
-    type Style = Style;
-
-    fn style_cascade(&mut self) -> &mut Cascade<Self::Style> {
-        &mut self.style
-    }
-
-    fn declared_style(&mut self) -> &mut <Self::Style as refineable::Refineable>::Refinement {
-        self.style.base()
-    }
-}
-
-impl StyleHelpers for Img {}
diff --git a/crates/gpui2/src/elements/pressable.rs b/crates/gpui2/src/elements/pressable.rs
deleted file mode 100644
index 4c3acb4bdd..0000000000
--- a/crates/gpui2/src/elements/pressable.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-use crate::{
-    element::{AnyElement, Element, IntoElement, Layout, ParentElement},
-    interactive::{InteractionHandlers, Interactive},
-    style::{Style, StyleHelpers, Styleable},
-    ViewContext,
-};
-use anyhow::Result;
-use gpui::{geometry::vector::Vector2F, platform::MouseButtonEvent, LayoutId};
-use refineable::{Cascade, CascadeSlot, Refineable};
-use smallvec::SmallVec;
-use std::{cell::Cell, rc::Rc};
-
-pub struct Pressable<E: Styleable> {
-    pressed: Rc<Cell<bool>>,
-    pressed_style: <E::Style as Refineable>::Refinement,
-    cascade_slot: CascadeSlot,
-    child: E,
-}
-
-pub fn pressable<E: Styleable>(mut child: E) -> Pressable<E> {
-    Pressable {
-        pressed: Rc::new(Cell::new(false)),
-        pressed_style: Default::default(),
-        cascade_slot: child.style_cascade().reserve(),
-        child,
-    }
-}
-
-impl<E: Styleable> Styleable for Pressable<E> {
-    type Style = E::Style;
-
-    fn declared_style(&mut self) -> &mut <Self::Style as Refineable>::Refinement {
-        &mut self.pressed_style
-    }
-
-    fn style_cascade(&mut self) -> &mut Cascade<E::Style> {
-        self.child.style_cascade()
-    }
-}
-
-impl<V: 'static, E: Element<V> + Styleable> Element<V> for Pressable<E> {
-    type PaintState = E::PaintState;
-
-    fn layout(
-        &mut self,
-        view: &mut V,
-        cx: &mut ViewContext<V>,
-    ) -> Result<(LayoutId, Self::PaintState)>
-    where
-        Self: Sized,
-    {
-        self.child.layout(view, cx)
-    }
-
-    fn paint(
-        &mut self,
-        view: &mut V,
-        parent_origin: Vector2F,
-        layout: &Layout,
-        paint_state: &mut Self::PaintState,
-        cx: &mut ViewContext<V>,
-    ) where
-        Self: Sized,
-    {
-        let slot = self.cascade_slot;
-        let style = self.pressed.get().then_some(self.pressed_style.clone());
-        self.style_cascade().set(slot, style);
-
-        let pressed = self.pressed.clone();
-        let bounds = layout.bounds + parent_origin;
-        cx.on_event(layout.order, move |_view, event: &MouseButtonEvent, cx| {
-            if event.is_down {
-                if bounds.contains_point(event.position) {
-                    pressed.set(true);
-                    cx.repaint();
-                } else {
-                    cx.bubble_event();
-                }
-            } else {
-                if pressed.get() {
-                    pressed.set(false);
-                    cx.repaint();
-                }
-                cx.bubble_event();
-            }
-        });
-
-        self.child
-            .paint(view, parent_origin, layout, paint_state, cx);
-    }
-}
-
-impl<E: Styleable<Style = Style>> StyleHelpers for Pressable<E> {}
-
-impl<V: 'static, E: Interactive<V> + Styleable> Interactive<V> for Pressable<E> {
-    fn interaction_handlers(&mut self) -> &mut InteractionHandlers<V> {
-        self.child.interaction_handlers()
-    }
-}
-
-impl<V: 'static, E: ParentElement<V> + Styleable> ParentElement<V> for Pressable<E> {
-    fn children_mut(&mut self) -> &mut SmallVec<[AnyElement<V>; 2]> {
-        self.child.children_mut()
-    }
-}
-
-impl<V: 'static, E: Element<V> + Styleable> IntoElement<V> for Pressable<E> {
-    type Element = Self;
-
-    fn into_element(self) -> Self::Element {
-        self
-    }
-}
diff --git a/crates/gpui2/src/elements/svg.rs b/crates/gpui2/src/elements/svg.rs
deleted file mode 100644
index a9177945c3..0000000000
--- a/crates/gpui2/src/elements/svg.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-use crate::{
-    self as gpui2, scene,
-    style::{Style, StyleHelpers, Styleable},
-    Element, IntoElement, Layout, LayoutId, Rgba,
-};
-use gpui::geometry::vector::Vector2F;
-use refineable::Cascade;
-use std::borrow::Cow;
-use util::ResultExt;
-
-#[derive(IntoElement)]
-pub struct Svg {
-    path: Option<Cow<'static, str>>,
-    style: Cascade<Style>,
-}
-
-pub fn svg() -> Svg {
-    Svg {
-        path: None,
-        style: Cascade::<Style>::default(),
-    }
-}
-
-impl Svg {
-    pub fn path(mut self, path: impl Into<Cow<'static, str>>) -> Self {
-        self.path = Some(path.into());
-        self
-    }
-}
-
-impl<V: 'static> Element<V> for Svg {
-    type PaintState = ();
-
-    fn layout(
-        &mut self,
-        _: &mut V,
-        cx: &mut crate::ViewContext<V>,
-    ) -> anyhow::Result<(LayoutId, Self::PaintState)>
-    where
-        Self: Sized,
-    {
-        let style = self.computed_style();
-        Ok((cx.add_layout_node(style, [])?, ()))
-    }
-
-    fn paint(
-        &mut self,
-        _: &mut V,
-        parent_origin: Vector2F,
-        layout: &Layout,
-        _: &mut Self::PaintState,
-        cx: &mut crate::ViewContext<V>,
-    ) where
-        Self: Sized,
-    {
-        let fill_color = self.computed_style().fill.and_then(|fill| fill.color());
-        if let Some((path, fill_color)) = self.path.as_ref().zip(fill_color) {
-            if let Some(svg_tree) = cx.asset_cache.svg(path).log_err() {
-                let icon = scene::Icon {
-                    bounds: layout.bounds + parent_origin,
-                    svg: svg_tree,
-                    path: path.clone(),
-                    color: Rgba::from(fill_color).into(),
-                };
-
-                cx.scene().push_icon(icon);
-            }
-        }
-    }
-}
-
-impl Styleable for Svg {
-    type Style = Style;
-
-    fn style_cascade(&mut self) -> &mut refineable::Cascade<Self::Style> {
-        &mut self.style
-    }
-
-    fn declared_style(&mut self) -> &mut <Self::Style as refineable::Refineable>::Refinement {
-        self.style.base()
-    }
-}
-
-impl StyleHelpers for Svg {}
diff --git a/crates/gpui2/src/elements/text.rs b/crates/gpui2/src/elements/text.rs
deleted file mode 100644
index 323b3d9f89..0000000000
--- a/crates/gpui2/src/elements/text.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-use crate::{
-    element::{Element, IntoElement, Layout},
-    ViewContext,
-};
-use anyhow::Result;
-use gpui::{
-    geometry::{vector::Vector2F, Size},
-    text_layout::Line,
-    LayoutId,
-};
-use parking_lot::Mutex;
-use std::sync::Arc;
-use util::arc_cow::ArcCow;
-
-impl<V: 'static, S: Into<ArcCow<'static, str>>> IntoElement<V> for S {
-    type Element = Text;
-
-    fn into_element(self) -> Self::Element {
-        Text { text: self.into() }
-    }
-}
-
-pub struct Text {
-    text: ArcCow<'static, str>,
-}
-
-impl<V: 'static> Element<V> for Text {
-    type PaintState = Arc<Mutex<Option<TextLayout>>>;
-
-    fn layout(
-        &mut self,
-        _view: &mut V,
-        cx: &mut ViewContext<V>,
-    ) -> Result<(LayoutId, Self::PaintState)> {
-        let layout_cache = cx.text_layout_cache().clone();
-        let text_style = cx.text_style();
-        let line_height = cx.font_cache().line_height(text_style.font_size);
-        let text = self.text.clone();
-        let paint_state = Arc::new(Mutex::new(None));
-
-        let layout_id = cx.add_measured_layout_node(Default::default(), {
-            let paint_state = paint_state.clone();
-            move |_params| {
-                let line_layout = layout_cache.layout_str(
-                    text.as_ref(),
-                    text_style.font_size,
-                    &[(text.len(), text_style.to_run())],
-                );
-
-                let size = Size {
-                    width: line_layout.width(),
-                    height: line_height,
-                };
-
-                paint_state.lock().replace(TextLayout {
-                    line_layout: Arc::new(line_layout),
-                    line_height,
-                });
-
-                size
-            }
-        });
-
-        Ok((layout_id?, paint_state))
-    }
-
-    fn paint<'a>(
-        &mut self,
-        _view: &mut V,
-        parent_origin: Vector2F,
-        layout: &Layout,
-        paint_state: &mut Self::PaintState,
-        cx: &mut ViewContext<V>,
-    ) {
-        let bounds = layout.bounds + parent_origin;
-
-        let line_layout;
-        let line_height;
-        {
-            let paint_state = paint_state.lock();
-            let paint_state = paint_state
-                .as_ref()
-                .expect("measurement has not been performed");
-            line_layout = paint_state.line_layout.clone();
-            line_height = paint_state.line_height;
-        }
-
-        // TODO: We haven't added visible bounds to the new element system yet, so this is a placeholder.
-        let visible_bounds = bounds;
-        line_layout.paint(bounds.origin(), visible_bounds, line_height, cx.legacy_cx);
-    }
-}
-
-impl<V: 'static> IntoElement<V> for Text {
-    type Element = Self;
-
-    fn into_element(self) -> Self::Element {
-        self
-    }
-}
-
-pub struct TextLayout {
-    line_layout: Arc<Line>,
-    line_height: f32,
-}
diff --git a/crates/gpui2/src/gpui2.rs b/crates/gpui2/src/gpui2.rs
deleted file mode 100644
index 355697595f..0000000000
--- a/crates/gpui2/src/gpui2.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-pub mod adapter;
-pub mod color;
-pub mod element;
-pub mod elements;
-pub mod interactive;
-pub mod style;
-pub mod view;
-pub mod view_context;
-
-pub use color::*;
-pub use element::{AnyElement, Element, IntoElement, Layout, ParentElement};
-pub use geometry::{
-    rect::RectF,
-    vector::{vec2f, Vector2F},
-};
-pub use gpui::*;
-pub use gpui2_macros::{Element, *};
-pub use interactive::*;
-pub use platform::{Platform, WindowBounds, WindowOptions};
-pub use util::arc_cow::ArcCow;
-pub use view::*;
-pub use view_context::ViewContext;
diff --git a/crates/gpui2/src/interactive.rs b/crates/gpui2/src/interactive.rs
deleted file mode 100644
index 4533e7dbec..0000000000
--- a/crates/gpui2/src/interactive.rs
+++ /dev/null
@@ -1,165 +0,0 @@
-use gpui::{
-    geometry::rect::RectF,
-    platform::{MouseButton, MouseButtonEvent},
-    EventContext,
-};
-use smallvec::SmallVec;
-use std::{cell::Cell, rc::Rc};
-
-use crate::ViewContext;
-
-pub trait Interactive<V: 'static> {
-    fn interaction_handlers(&mut self) -> &mut InteractionHandlers<V>;
-
-    fn on_mouse_down(
-        mut self,
-        button: MouseButton,
-        handler: impl Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>) + 'static,
-    ) -> Self
-    where
-        Self: Sized,
-    {
-        self.interaction_handlers()
-            .mouse_down
-            .push(Rc::new(move |view, event, cx| {
-                if event.button == button {
-                    handler(view, event, cx)
-                }
-            }));
-        self
-    }
-
-    fn on_mouse_up(
-        mut self,
-        button: MouseButton,
-        handler: impl Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>) + 'static,
-    ) -> Self
-    where
-        Self: Sized,
-    {
-        self.interaction_handlers()
-            .mouse_up
-            .push(Rc::new(move |view, event, cx| {
-                if event.button == button {
-                    handler(view, event, cx)
-                }
-            }));
-        self
-    }
-
-    fn on_mouse_down_out(
-        mut self,
-        button: MouseButton,
-        handler: impl Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>) + 'static,
-    ) -> Self
-    where
-        Self: Sized,
-    {
-        self.interaction_handlers()
-            .mouse_down_out
-            .push(Rc::new(move |view, event, cx| {
-                if event.button == button {
-                    handler(view, event, cx)
-                }
-            }));
-        self
-    }
-
-    fn on_mouse_up_out(
-        mut self,
-        button: MouseButton,
-        handler: impl Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>) + 'static,
-    ) -> Self
-    where
-        Self: Sized,
-    {
-        self.interaction_handlers()
-            .mouse_up_out
-            .push(Rc::new(move |view, event, cx| {
-                if event.button == button {
-                    handler(view, event, cx)
-                }
-            }));
-        self
-    }
-
-    fn on_click(
-        self,
-        button: MouseButton,
-        handler: impl Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>) + 'static,
-    ) -> Self
-    where
-        Self: Sized,
-    {
-        let pressed = Rc::new(Cell::new(false));
-        self.on_mouse_down(button, {
-            let pressed = pressed.clone();
-            move |_, _, _| {
-                pressed.set(true);
-            }
-        })
-        .on_mouse_up_out(button, {
-            let pressed = pressed.clone();
-            move |_, _, _| {
-                pressed.set(false);
-            }
-        })
-        .on_mouse_up(button, move |view, event, cx| {
-            if pressed.get() {
-                pressed.set(false);
-                handler(view, event, cx);
-            }
-        })
-    }
-}
-
-pub struct InteractionHandlers<V: 'static> {
-    mouse_down: SmallVec<[Rc<dyn Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>)>; 2]>,
-    mouse_down_out: SmallVec<[Rc<dyn Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>)>; 2]>,
-    mouse_up: SmallVec<[Rc<dyn Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>)>; 2]>,
-    mouse_up_out: SmallVec<[Rc<dyn Fn(&mut V, &MouseButtonEvent, &mut EventContext<V>)>; 2]>,
-}
-
-impl<V: 'static> InteractionHandlers<V> {
-    pub fn paint(&self, order: u32, bounds: RectF, cx: &mut ViewContext<V>) {
-        for handler in self.mouse_down.iter().cloned() {
-            cx.on_event(order, move |view, event: &MouseButtonEvent, cx| {
-                if event.is_down && bounds.contains_point(event.position) {
-                    handler(view, event, cx);
-                }
-            })
-        }
-        for handler in self.mouse_up.iter().cloned() {
-            cx.on_event(order, move |view, event: &MouseButtonEvent, cx| {
-                if !event.is_down && bounds.contains_point(event.position) {
-                    handler(view, event, cx);
-                }
-            })
-        }
-        for handler in self.mouse_down_out.iter().cloned() {
-            cx.on_event(order, move |view, event: &MouseButtonEvent, cx| {
-                if event.is_down && !bounds.contains_point(event.position) {
-                    handler(view, event, cx);
-                }
-            })
-        }
-        for handler in self.mouse_up_out.iter().cloned() {
-            cx.on_event(order, move |view, event: &MouseButtonEvent, cx| {
-                if !event.is_down && !bounds.contains_point(event.position) {
-                    handler(view, event, cx);
-                }
-            })
-        }
-    }
-}
-
-impl<V> Default for InteractionHandlers<V> {
-    fn default() -> Self {
-        Self {
-            mouse_down: Default::default(),
-            mouse_up: Default::default(),
-            mouse_down_out: Default::default(),
-            mouse_up_out: Default::default(),
-        }
-    }
-}
diff --git a/crates/gpui2/src/style.rs b/crates/gpui2/src/style.rs
deleted file mode 100644
index 8b8491b1cc..0000000000
--- a/crates/gpui2/src/style.rs
+++ /dev/null
@@ -1,498 +0,0 @@
-use crate::{
-    color::Hsla,
-    elements::hoverable::{hoverable, Hoverable},
-    elements::pressable::{pressable, Pressable},
-    ViewContext,
-};
-pub use fonts::Style as FontStyle;
-pub use fonts::Weight as FontWeight;
-pub use gpui::taffy::style::{
-    AlignContent, AlignItems, AlignSelf, Display, FlexDirection, FlexWrap, JustifyContent,
-    Overflow, Position,
-};
-use gpui::{
-    fonts::{self, TextStyleRefinement},
-    geometry::{
-        rect::RectF, relative, vector::Vector2F, AbsoluteLength, DefiniteLength, Edges,
-        EdgesRefinement, Length, Point, PointRefinement, Size, SizeRefinement,
-    },
-    scene, taffy, WindowContext,
-};
-use gpui2_macros::styleable_helpers;
-use refineable::{Cascade, Refineable};
-use std::sync::Arc;
-
-#[derive(Clone, Refineable, Debug)]
-#[refineable(debug)]
-pub struct Style {
-    /// What layout strategy should be used?
-    pub display: Display,
-
-    // Overflow properties
-    /// How children overflowing their container should affect layout
-    #[refineable]
-    pub overflow: Point<Overflow>,
-    /// How much space (in points) should be reserved for the scrollbars of `Overflow::Scroll` and `Overflow::Auto` nodes.
-    pub scrollbar_width: f32,
-
-    // Position properties
-    /// What should the `position` value of this struct use as a base offset?
-    pub position: Position,
-    /// How should the position of this element be tweaked relative to the layout defined?
-    #[refineable]
-    pub inset: Edges<Length>,
-
-    // Size properies
-    /// Sets the initial size of the item
-    #[refineable]
-    pub size: Size<Length>,
-    /// Controls the minimum size of the item
-    #[refineable]
-    pub min_size: Size<Length>,
-    /// Controls the maximum size of the item
-    #[refineable]
-    pub max_size: Size<Length>,
-    /// Sets the preferred aspect ratio for the item. The ratio is calculated as width divided by height.
-    pub aspect_ratio: Option<f32>,
-
-    // Spacing Properties
-    /// How large should the margin be on each side?
-    #[refineable]
-    pub margin: Edges<Length>,
-    /// How large should the padding be on each side?
-    #[refineable]
-    pub padding: Edges<DefiniteLength>,
-    /// How large should the border be on each side?
-    #[refineable]
-    pub border_widths: Edges<AbsoluteLength>,
-
-    // Alignment properties
-    /// How this node's children aligned in the cross/block axis?
-    pub align_items: Option<AlignItems>,
-    /// How this node should be aligned in the cross/block axis. Falls back to the parents [`AlignItems`] if not set
-    pub align_self: Option<AlignSelf>,
-    /// How should content contained within this item be aligned in the cross/block axis
-    pub align_content: Option<AlignContent>,
-    /// How should contained within this item be aligned in the main/inline axis
-    pub justify_content: Option<JustifyContent>,
-    /// How large should the gaps between items in a flex container be?
-    #[refineable]
-    pub gap: Size<DefiniteLength>,
-
-    // Flexbox properies
-    /// Which direction does the main axis flow in?
-    pub flex_direction: FlexDirection,
-    /// Should elements wrap, or stay in a single line?
-    pub flex_wrap: FlexWrap,
-    /// Sets the initial main axis size of the item
-    pub flex_basis: Length,
-    /// The relative rate at which this item grows when it is expanding to fill space, 0.0 is the default value, and this value must be positive.
-    pub flex_grow: f32,
-    /// The relative rate at which this item shrinks when it is contracting to fit into space, 1.0 is the default value, and this value must be positive.
-    pub flex_shrink: f32,
-
-    /// The fill color of this element
-    pub fill: Option<Fill>,
-
-    /// The border color of this element
-    pub border_color: Option<Hsla>,
-
-    /// The radius of the corners of this element
-    #[refineable]
-    pub corner_radii: CornerRadii,
-
-    /// The color of text within this element. Cascades to children unless overridden.
-    pub text_color: Option<Hsla>,
-
-    /// The font size in rems.
-    pub font_size: Option<f32>,
-
-    pub font_family: Option<Arc<str>>,
-
-    pub font_weight: Option<FontWeight>,
-
-    pub font_style: Option<FontStyle>,
-}
-
-impl Style {
-    pub fn text_style(&self, cx: &WindowContext) -> Option<TextStyleRefinement> {
-        if self.text_color.is_none()
-            && self.font_size.is_none()
-            && self.font_family.is_none()
-            && self.font_weight.is_none()
-            && self.font_style.is_none()
-        {
-            return None;
-        }
-
-        Some(TextStyleRefinement {
-            color: self.text_color.map(Into::into),
-            font_family: self.font_family.clone(),
-            font_size: self.font_size.map(|size| size * cx.rem_size()),
-            font_weight: self.font_weight,
-            font_style: self.font_style,
-            underline: None,
-        })
-    }
-
-    pub fn to_taffy(&self, rem_size: f32) -> taffy::style::Style {
-        taffy::style::Style {
-            display: self.display,
-            overflow: self.overflow.clone().into(),
-            scrollbar_width: self.scrollbar_width,
-            position: self.position,
-            inset: self.inset.to_taffy(rem_size),
-            size: self.size.to_taffy(rem_size),
-            min_size: self.min_size.to_taffy(rem_size),
-            max_size: self.max_size.to_taffy(rem_size),
-            aspect_ratio: self.aspect_ratio,
-            margin: self.margin.to_taffy(rem_size),
-            padding: self.padding.to_taffy(rem_size),
-            border: self.border_widths.to_taffy(rem_size),
-            align_items: self.align_items,
-            align_self: self.align_self,
-            align_content: self.align_content,
-            justify_content: self.justify_content,
-            gap: self.gap.to_taffy(rem_size),
-            flex_direction: self.flex_direction,
-            flex_wrap: self.flex_wrap,
-            flex_basis: self.flex_basis.to_taffy(rem_size).into(),
-            flex_grow: self.flex_grow,
-            flex_shrink: self.flex_shrink,
-            ..Default::default() // Ignore grid properties for now
-        }
-    }
-
-    /// Paints the background of an element styled with this style.
-    pub fn paint_background<V: 'static>(&self, bounds: RectF, cx: &mut ViewContext<V>) {
-        let rem_size = cx.rem_size();
-        if let Some(color) = self.fill.as_ref().and_then(Fill::color) {
-            cx.scene().push_quad(gpui::Quad {
-                bounds,
-                background: Some(color.into()),
-                corner_radii: self.corner_radii.to_gpui(bounds.size(), rem_size),
-                border: Default::default(),
-            });
-        }
-    }
-
-    /// Paints the foreground of an element styled with this style.
-    pub fn paint_foreground<V: 'static>(&self, bounds: RectF, cx: &mut ViewContext<V>) {
-        let rem_size = cx.rem_size();
-
-        if let Some(color) = self.border_color {
-            let border = self.border_widths.to_pixels(rem_size);
-            if !border.is_empty() {
-                cx.scene().push_quad(gpui::Quad {
-                    bounds,
-                    background: None,
-                    corner_radii: self.corner_radii.to_gpui(bounds.size(), rem_size),
-                    border: scene::Border {
-                        color: color.into(),
-                        top: border.top,
-                        right: border.right,
-                        bottom: border.bottom,
-                        left: border.left,
-                    },
-                });
-            }
-        }
-    }
-}
-
-impl Default for Style {
-    fn default() -> Self {
-        Style {
-            display: Display::Block,
-            overflow: Point {
-                x: Overflow::Visible,
-                y: Overflow::Visible,
-            },
-            scrollbar_width: 0.0,
-            position: Position::Relative,
-            inset: Edges::auto(),
-            margin: Edges::<Length>::zero(),
-            padding: Edges::<DefiniteLength>::zero(),
-            border_widths: Edges::<AbsoluteLength>::zero(),
-            size: Size::auto(),
-            min_size: Size::auto(),
-            max_size: Size::auto(),
-            aspect_ratio: None,
-            gap: Size::zero(),
-            // Aligment
-            align_items: None,
-            align_self: None,
-            align_content: None,
-            justify_content: None,
-            // Flexbox
-            flex_direction: FlexDirection::Row,
-            flex_wrap: FlexWrap::NoWrap,
-            flex_grow: 0.0,
-            flex_shrink: 1.0,
-            flex_basis: Length::Auto,
-            fill: None,
-            border_color: None,
-            corner_radii: CornerRadii::default(),
-            text_color: None,
-            font_size: Some(1.),
-            font_family: None,
-            font_weight: None,
-            font_style: None,
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub enum Fill {
-    Color(Hsla),
-}
-
-impl Fill {
-    pub fn color(&self) -> Option<Hsla> {
-        match self {
-            Fill::Color(color) => Some(*color),
-        }
-    }
-}
-
-impl Default for Fill {
-    fn default() -> Self {
-        Self::Color(Hsla::default())
-    }
-}
-
-impl From<Hsla> for Fill {
-    fn from(color: Hsla) -> Self {
-        Self::Color(color)
-    }
-}
-
-#[derive(Clone, Refineable, Default, Debug)]
-#[refineable(debug)]
-pub struct CornerRadii {
-    top_left: AbsoluteLength,
-    top_right: AbsoluteLength,
-    bottom_left: AbsoluteLength,
-    bottom_right: AbsoluteLength,
-}
-
-impl CornerRadii {
-    pub fn to_gpui(&self, box_size: Vector2F, rem_size: f32) -> gpui::scene::CornerRadii {
-        let max_radius = box_size.x().min(box_size.y()) / 2.;
-
-        gpui::scene::CornerRadii {
-            top_left: self.top_left.to_pixels(rem_size).min(max_radius),
-            top_right: self.top_right.to_pixels(rem_size).min(max_radius),
-            bottom_left: self.bottom_left.to_pixels(rem_size).min(max_radius),
-            bottom_right: self.bottom_right.to_pixels(rem_size).min(max_radius),
-        }
-    }
-}
-
-pub trait Styleable {
-    type Style: Refineable + Default;
-
-    fn style_cascade(&mut self) -> &mut Cascade<Self::Style>;
-    fn declared_style(&mut self) -> &mut <Self::Style as Refineable>::Refinement;
-
-    fn computed_style(&mut self) -> Self::Style {
-        Self::Style::from_refinement(&self.style_cascade().merged())
-    }
-
-    fn hover(self) -> Hoverable<Self>
-    where
-        Self: Sized,
-    {
-        hoverable(self)
-    }
-
-    fn active(self) -> Pressable<Self>
-    where
-        Self: Sized,
-    {
-        pressable(self)
-    }
-}
-
-use crate as gpui2;
-
-// Helpers methods that take and return mut self. This includes tailwind style methods for standard sizes etc.
-//
-// Example:
-// // Sets the padding to 0.5rem, just like class="p-2" in Tailwind.
-// fn p_2(mut self) -> Self;
-pub trait StyleHelpers: Sized + Styleable<Style = Style> {
-    styleable_helpers!();
-
-    fn full(mut self) -> Self {
-        self.declared_style().size.width = Some(relative(1.).into());
-        self.declared_style().size.height = Some(relative(1.).into());
-        self
-    }
-
-    fn relative(mut self) -> Self {
-        self.declared_style().position = Some(Position::Relative);
-        self
-    }
-
-    fn absolute(mut self) -> Self {
-        self.declared_style().position = Some(Position::Absolute);
-        self
-    }
-
-    fn block(mut self) -> Self {
-        self.declared_style().display = Some(Display::Block);
-        self
-    }
-
-    fn flex(mut self) -> Self {
-        self.declared_style().display = Some(Display::Flex);
-        self
-    }
-
-    fn flex_col(mut self) -> Self {
-        self.declared_style().flex_direction = Some(FlexDirection::Column);
-        self
-    }
-
-    fn flex_row(mut self) -> Self {
-        self.declared_style().flex_direction = Some(FlexDirection::Row);
-        self
-    }
-
-    fn flex_1(mut self) -> Self {
-        self.declared_style().flex_grow = Some(1.);
-        self.declared_style().flex_shrink = Some(1.);
-        self.declared_style().flex_basis = Some(relative(0.).into());
-        self
-    }
-
-    fn flex_auto(mut self) -> Self {
-        self.declared_style().flex_grow = Some(1.);
-        self.declared_style().flex_shrink = Some(1.);
-        self.declared_style().flex_basis = Some(Length::Auto);
-        self
-    }
-
-    fn flex_initial(mut self) -> Self {
-        self.declared_style().flex_grow = Some(0.);
-        self.declared_style().flex_shrink = Some(1.);
-        self.declared_style().flex_basis = Some(Length::Auto);
-        self
-    }
-
-    fn flex_none(mut self) -> Self {
-        self.declared_style().flex_grow = Some(0.);
-        self.declared_style().flex_shrink = Some(0.);
-        self
-    }
-
-    fn grow(mut self) -> Self {
-        self.declared_style().flex_grow = Some(1.);
-        self
-    }
-
-    fn items_start(mut self) -> Self {
-        self.declared_style().align_items = Some(AlignItems::FlexStart);
-        self
-    }
-
-    fn items_end(mut self) -> Self {
-        self.declared_style().align_items = Some(AlignItems::FlexEnd);
-        self
-    }
-
-    fn items_center(mut self) -> Self {
-        self.declared_style().align_items = Some(AlignItems::Center);
-        self
-    }
-
-    fn justify_between(mut self) -> Self {
-        self.declared_style().justify_content = Some(JustifyContent::SpaceBetween);
-        self
-    }
-
-    fn justify_center(mut self) -> Self {
-        self.declared_style().justify_content = Some(JustifyContent::Center);
-        self
-    }
-
-    fn justify_start(mut self) -> Self {
-        self.declared_style().justify_content = Some(JustifyContent::Start);
-        self
-    }
-
-    fn justify_end(mut self) -> Self {
-        self.declared_style().justify_content = Some(JustifyContent::End);
-        self
-    }
-
-    fn justify_around(mut self) -> Self {
-        self.declared_style().justify_content = Some(JustifyContent::SpaceAround);
-        self
-    }
-
-    fn fill<F>(mut self, fill: F) -> Self
-    where
-        F: Into<Fill>,
-    {
-        self.declared_style().fill = Some(fill.into());
-        self
-    }
-
-    fn border_color<C>(mut self, border_color: C) -> Self
-    where
-        C: Into<Hsla>,
-    {
-        self.declared_style().border_color = Some(border_color.into());
-        self
-    }
-
-    fn text_color<C>(mut self, color: C) -> Self
-    where
-        C: Into<Hsla>,
-    {
-        self.declared_style().text_color = Some(color.into());
-        self
-    }
-
-    fn text_xs(mut self) -> Self {
-        self.declared_style().font_size = Some(0.75);
-        self
-    }
-
-    fn text_sm(mut self) -> Self {
-        self.declared_style().font_size = Some(0.875);
-        self
-    }
-
-    fn text_base(mut self) -> Self {
-        self.declared_style().font_size = Some(1.0);
-        self
-    }
-
-    fn text_lg(mut self) -> Self {
-        self.declared_style().font_size = Some(1.125);
-        self
-    }
-
-    fn text_xl(mut self) -> Self {
-        self.declared_style().font_size = Some(1.25);
-        self
-    }
-
-    fn text_2xl(mut self) -> Self {
-        self.declared_style().font_size = Some(1.5);
-        self
-    }
-
-    fn text_3xl(mut self) -> Self {
-        self.declared_style().font_size = Some(1.875);
-        self
-    }
-
-    fn font(mut self, family_name: impl Into<Arc<str>>) -> Self {
-        self.declared_style().font_family = Some(family_name.into());
-        self
-    }
-}
diff --git a/crates/gpui2/src/view.rs b/crates/gpui2/src/view.rs
deleted file mode 100644
index cb0eebed7b..0000000000
--- a/crates/gpui2/src/view.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-use crate::{
-    adapter::AdapterElement,
-    element::{AnyElement, Element},
-};
-use gpui::ViewContext;
-
-pub fn view<F, E>(mut render: F) -> ViewFn
-where
-    F: 'static + FnMut(&mut ViewContext<ViewFn>) -> E,
-    E: Element<ViewFn>,
-{
-    ViewFn(Box::new(move |cx| (render)(cx).into_any()))
-}
-
-pub struct ViewFn(Box<dyn FnMut(&mut ViewContext<ViewFn>) -> AnyElement<ViewFn>>);
-
-impl gpui::Entity for ViewFn {
-    type Event = ();
-}
-
-impl gpui::View for ViewFn {
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> gpui::AnyElement<Self> {
-        use gpui::Element as _;
-        AdapterElement((self.0)(cx)).into_any()
-    }
-}
diff --git a/crates/gpui2/src/view_context.rs b/crates/gpui2/src/view_context.rs
deleted file mode 100644
index d6c0960a34..0000000000
--- a/crates/gpui2/src/view_context.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-use std::{any::TypeId, rc::Rc};
-
-use crate::{element::LayoutId, style::Style};
-use anyhow::{anyhow, Result};
-use derive_more::{Deref, DerefMut};
-use gpui::{geometry::Size, scene::EventHandler, EventContext, Layout, MeasureParams};
-pub use gpui::{taffy::tree::NodeId, ViewContext as LegacyViewContext};
-
-#[derive(Deref, DerefMut)]
-pub struct ViewContext<'a, 'b, 'c, V> {
-    #[deref]
-    #[deref_mut]
-    pub(crate) legacy_cx: &'c mut LegacyViewContext<'a, 'b, V>,
-}
-
-impl<'a, 'b, 'c, V: 'static> ViewContext<'a, 'b, 'c, V> {
-    pub fn new(legacy_cx: &'c mut LegacyViewContext<'a, 'b, V>) -> Self {
-        Self { legacy_cx }
-    }
-
-    pub fn add_layout_node(
-        &mut self,
-        style: Style,
-        children: impl IntoIterator<Item = NodeId>,
-    ) -> Result<LayoutId> {
-        let rem_size = self.rem_size();
-        let style = style.to_taffy(rem_size);
-        let id = self
-            .legacy_cx
-            .layout_engine()
-            .ok_or_else(|| anyhow!("no layout engine"))?
-            .add_node(style, children)?;
-
-        Ok(id)
-    }
-
-    pub fn add_measured_layout_node<F>(&mut self, style: Style, measure: F) -> Result<LayoutId>
-    where
-        F: Fn(MeasureParams) -> Size<f32> + Sync + Send + 'static,
-    {
-        let rem_size = self.rem_size();
-        let layout_id = self
-            .layout_engine()
-            .ok_or_else(|| anyhow!("no layout engine"))?
-            .add_measured_node(style.to_taffy(rem_size), measure)?;
-
-        Ok(layout_id)
-    }
-
-    pub fn on_event<E: 'static>(
-        &mut self,
-        order: u32,
-        handler: impl Fn(&mut V, &E, &mut EventContext<V>) + 'static,
-    ) {
-        let view = self.weak_handle();
-
-        self.scene().event_handlers.push(EventHandler {
-            order,
-            handler: Rc::new(move |event, window_cx| {
-                if let Some(view) = view.upgrade(window_cx) {
-                    view.update(window_cx, |view, view_cx| {
-                        let mut event_cx = EventContext::new(view_cx);
-                        handler(view, event.downcast_ref().unwrap(), &mut event_cx);
-                        event_cx.bubble
-                    })
-                } else {
-                    true
-                }
-            }),
-            event_type: TypeId::of::<E>(),
-        })
-    }
-
-    pub(crate) fn computed_layout(&mut self, layout_id: LayoutId) -> Result<Layout> {
-        self.layout_engine()
-            .ok_or_else(|| anyhow!("no layout engine present"))?
-            .computed_layout(layout_id)
-    }
-}
diff --git a/crates/gpui2/src/view_handle.rs b/crates/gpui2/src/view_handle.rs
deleted file mode 100644
index dfbe76be2e..0000000000
--- a/crates/gpui2/src/view_handle.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-use crate::{style::Style, Element, IntoElement, ViewContext};
-use gpui::{
-    geometry::{Point, Size},
-    taffy::style::Overflow,
-    AnyElement, View, ViewHandle,
-};
-
-impl<ParentView: 'static, ChildView: View> Element<ParentView> for ViewHandle<ChildView> {
-    type PaintState = AnyElement<ChildView>;
-
-    fn layout(
-        &mut self,
-        _: &mut ParentView,
-        cx: &mut ViewContext<ParentView>,
-    ) -> anyhow::Result<(gpui::LayoutId, Self::PaintState)>
-    where
-        Self: Sized,
-    {
-        let layout_id = cx.add_layout_node(
-            Style {
-                overflow: Point {
-                    x: Overflow::Hidden,
-                    y: Overflow::Hidden,
-                },
-                size: Size::full(),
-                ..Default::default()
-            },
-            None,
-        )?;
-        let element = self.update(cx, |view, cx| view.render(cx));
-        Ok((layout_id, element))
-    }
-
-    fn paint(
-        &mut self,
-        _: &mut ParentView,
-        parent_origin: gpui::geometry::vector::Vector2F,
-        layout: &gpui::Layout,
-        element: &mut AnyElement<ChildView>,
-        cx: &mut ViewContext<ParentView>,
-    ) where
-        Self: Sized,
-    {
-        self.update(cx, |view, cx| {
-            let bounds = layout.bounds + parent_origin;
-            element.layout(gpui::SizeConstraint::strict(bounds.size()), view, cx);
-            cx.paint_layer(Some(layout.bounds), |cx| {
-                element.paint(bounds.origin(), bounds, view, cx);
-            });
-        })
-    }
-}
-
-impl<ParentView: 'static, ChildView: View> IntoElement<ParentView> for ViewHandle<ChildView> {
-    type Element = Self;
-
-    fn into_element(self) -> Self::Element {
-        self
-    }
-}
diff --git a/crates/gpui2_macros/Cargo.toml b/crates/gpui2_macros/Cargo.toml
deleted file mode 100644
index eb44334095..0000000000
--- a/crates/gpui2_macros/Cargo.toml
+++ /dev/null
@@ -1,14 +0,0 @@
-[package]
-name = "gpui2_macros"
-version = "0.1.0"
-edition = "2021"
-publish = false
-
-[lib]
-path = "src/gpui2_macros.rs"
-proc-macro = true
-
-[dependencies]
-syn = "1.0.72"
-quote = "1.0.9"
-proc-macro2 = "1.0.66"
diff --git a/crates/gpui2_macros/src/derive_element.rs b/crates/gpui2_macros/src/derive_element.rs
deleted file mode 100644
index 304caa99e6..0000000000
--- a/crates/gpui2_macros/src/derive_element.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-use proc_macro::TokenStream;
-use proc_macro2::Ident;
-use quote::quote;
-use syn::{parse_macro_input, parse_quote, DeriveInput, GenericParam, Generics};
-
-use crate::derive_into_element::impl_into_element;
-
-pub fn derive_element(input: TokenStream) -> TokenStream {
-    let ast = parse_macro_input!(input as DeriveInput);
-    let type_name = ast.ident;
-    let placeholder_view_generics: Generics = parse_quote! { <V: 'static> };
-
-    let (impl_generics, type_generics, where_clause, view_type_name, lifetimes) =
-        if let Some(first_type_param) = ast.generics.params.iter().find_map(|param| {
-            if let GenericParam::Type(type_param) = param {
-                Some(type_param.ident.clone())
-            } else {
-                None
-            }
-        }) {
-            let mut lifetimes = vec![];
-            for param in ast.generics.params.iter() {
-                if let GenericParam::Lifetime(lifetime_def) = param {
-                    lifetimes.push(lifetime_def.lifetime.clone());
-                }
-            }
-            let generics = ast.generics.split_for_impl();
-            (
-                generics.0,
-                Some(generics.1),
-                generics.2,
-                first_type_param,
-                lifetimes,
-            )
-        } else {
-            let generics = placeholder_view_generics.split_for_impl();
-            let placeholder_view_type_name: Ident = parse_quote! { V };
-            (
-                generics.0,
-                None,
-                generics.2,
-                placeholder_view_type_name,
-                vec![],
-            )
-        };
-
-    let lifetimes = if !lifetimes.is_empty() {
-        quote! { <#(#lifetimes),*> }
-    } else {
-        quote! {}
-    };
-
-    let impl_into_element = impl_into_element(
-        &impl_generics,
-        &view_type_name,
-        &type_name,
-        &type_generics,
-        &where_clause,
-    );
-
-    let gen = quote! {
-        impl #impl_generics gpui2::element::Element<#view_type_name> for #type_name #type_generics
-        #where_clause
-        {
-            type PaintState = gpui2::element::AnyElement<#view_type_name #lifetimes>;
-
-            fn layout(
-                &mut self,
-                view: &mut V,
-                cx: &mut gpui2::ViewContext<V>,
-            ) -> anyhow::Result<(gpui2::element::LayoutId, Self::PaintState)> {
-                let mut rendered_element = self.render(view, cx).into_element().into_any();
-                let layout_id = rendered_element.layout(view, cx)?;
-                Ok((layout_id, rendered_element))
-            }
-
-            fn paint(
-                &mut self,
-                view: &mut V,
-                parent_origin: gpui2::Vector2F,
-                _: &gpui2::element::Layout,
-                rendered_element: &mut Self::PaintState,
-                cx: &mut gpui2::ViewContext<V>,
-            ) {
-                rendered_element.paint(view, parent_origin, cx);
-            }
-        }
-
-        #impl_into_element
-    };
-
-    gen.into()
-}
diff --git a/crates/gpui2_macros/src/derive_into_element.rs b/crates/gpui2_macros/src/derive_into_element.rs
deleted file mode 100644
index 6ede89e284..0000000000
--- a/crates/gpui2_macros/src/derive_into_element.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-use proc_macro::TokenStream;
-use quote::quote;
-use syn::{
-    parse_macro_input, parse_quote, DeriveInput, GenericParam, Generics, Ident, WhereClause,
-};
-
-pub fn derive_into_element(input: TokenStream) -> TokenStream {
-    let ast = parse_macro_input!(input as DeriveInput);
-    let type_name = ast.ident;
-
-    let placeholder_view_generics: Generics = parse_quote! { <V: 'static> };
-    let placeholder_view_type_name: Ident = parse_quote! { V };
-    let view_type_name: Ident;
-    let impl_generics: syn::ImplGenerics<'_>;
-    let type_generics: Option<syn::TypeGenerics<'_>>;
-    let where_clause: Option<&'_ WhereClause>;
-
-    match ast.generics.params.iter().find_map(|param| {
-        if let GenericParam::Type(type_param) = param {
-            Some(type_param.ident.clone())
-        } else {
-            None
-        }
-    }) {
-        Some(type_name) => {
-            view_type_name = type_name;
-            let generics = ast.generics.split_for_impl();
-            impl_generics = generics.0;
-            type_generics = Some(generics.1);
-            where_clause = generics.2;
-        }
-        _ => {
-            view_type_name = placeholder_view_type_name;
-            let generics = placeholder_view_generics.split_for_impl();
-            impl_generics = generics.0;
-            type_generics = None;
-            where_clause = generics.2;
-        }
-    }
-
-    impl_into_element(
-        &impl_generics,
-        &view_type_name,
-        &type_name,
-        &type_generics,
-        &where_clause,
-    )
-    .into()
-}
-
-pub fn impl_into_element(
-    impl_generics: &syn::ImplGenerics<'_>,
-    view_type_name: &Ident,
-    type_name: &Ident,
-    type_generics: &Option<syn::TypeGenerics<'_>>,
-    where_clause: &Option<&WhereClause>,
-) -> proc_macro2::TokenStream {
-    quote! {
-        impl #impl_generics gpui2::element::IntoElement<#view_type_name> for #type_name #type_generics
-        #where_clause
-        {
-            type Element = Self;
-
-            fn into_element(self) -> Self {
-                self
-            }
-        }
-    }
-}
diff --git a/crates/gpui2_macros/src/gpui2_macros.rs b/crates/gpui2_macros/src/gpui2_macros.rs
deleted file mode 100644
index fbb0d06ed5..0000000000
--- a/crates/gpui2_macros/src/gpui2_macros.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-use proc_macro::TokenStream;
-
-mod derive_element;
-mod derive_into_element;
-mod styleable_helpers;
-
-#[proc_macro]
-pub fn styleable_helpers(args: TokenStream) -> TokenStream {
-    styleable_helpers::styleable_helpers(args)
-}
-
-#[proc_macro_derive(Element, attributes(element_crate))]
-pub fn derive_element(input: TokenStream) -> TokenStream {
-    derive_element::derive_element(input)
-}
-
-#[proc_macro_derive(IntoElement, attributes(element_crate))]
-pub fn derive_into_element(input: TokenStream) -> TokenStream {
-    derive_into_element::derive_into_element(input)
-}
diff --git a/crates/gpui2_macros/src/styleable_helpers.rs b/crates/gpui2_macros/src/styleable_helpers.rs
deleted file mode 100644
index 7283870858..0000000000
--- a/crates/gpui2_macros/src/styleable_helpers.rs
+++ /dev/null
@@ -1,408 +0,0 @@
-use proc_macro::TokenStream;
-use proc_macro2::TokenStream as TokenStream2;
-use quote::{format_ident, quote};
-use syn::{
-    parse::{Parse, ParseStream, Result},
-    parse_macro_input,
-};
-
-struct StyleableMacroInput;
-
-impl Parse for StyleableMacroInput {
-    fn parse(_input: ParseStream) -> Result<Self> {
-        Ok(StyleableMacroInput)
-    }
-}
-
-pub fn styleable_helpers(input: TokenStream) -> TokenStream {
-    let _ = parse_macro_input!(input as StyleableMacroInput);
-    let methods = generate_methods();
-    let output = quote! {
-        #(#methods)*
-    };
-
-    output.into()
-}
-
-fn generate_methods() -> Vec<TokenStream2> {
-    let mut methods = Vec::new();
-
-    for (prefix, auto_allowed, fields) in box_prefixes() {
-        methods.push(generate_custom_value_setter(
-            prefix,
-            if auto_allowed {
-                quote! { Length }
-            } else {
-                quote! { DefiniteLength }
-            },
-            &fields,
-        ));
-
-        for (suffix, length_tokens, doc_string) in box_suffixes() {
-            if suffix != "auto" || auto_allowed {
-                methods.push(generate_predefined_setter(
-                    prefix,
-                    suffix,
-                    &fields,
-                    &length_tokens,
-                    false,
-                    doc_string,
-                ));
-            }
-
-            if suffix != "auto" {
-                methods.push(generate_predefined_setter(
-                    prefix,
-                    suffix,
-                    &fields,
-                    &length_tokens,
-                    true,
-                    doc_string,
-                ));
-            }
-        }
-    }
-
-    for (prefix, fields) in corner_prefixes() {
-        methods.push(generate_custom_value_setter(
-            prefix,
-            quote! { AbsoluteLength },
-            &fields,
-        ));
-
-        for (suffix, radius_tokens, doc_string) in corner_suffixes() {
-            methods.push(generate_predefined_setter(
-                prefix,
-                suffix,
-                &fields,
-                &radius_tokens,
-                false,
-                doc_string,
-            ));
-        }
-    }
-
-    for (prefix, fields) in border_prefixes() {
-        for (suffix, width_tokens, doc_string) in border_suffixes() {
-            methods.push(generate_predefined_setter(
-                prefix,
-                suffix,
-                &fields,
-                &width_tokens,
-                false,
-                doc_string,
-            ));
-        }
-    }
-    methods
-}
-
-fn generate_predefined_setter(
-    name: &'static str,
-    length: &'static str,
-    fields: &Vec<TokenStream2>,
-    length_tokens: &TokenStream2,
-    negate: bool,
-    doc_string: &'static str,
-) -> TokenStream2 {
-    let (negation_prefix, negation_token) = if negate {
-        ("neg_", quote! { - })
-    } else {
-        ("", quote! {})
-    };
-
-    let method_name = if length.is_empty() {
-        format_ident!("{}{}", negation_prefix, name)
-    } else {
-        format_ident!("{}{}_{}", negation_prefix, name, length)
-    };
-
-    let field_assignments = fields
-        .iter()
-        .map(|field_tokens| {
-            quote! {
-                style.#field_tokens = Some((#negation_token gpui2::geometry::#length_tokens).into());
-            }
-        })
-        .collect::<Vec<_>>();
-
-    let method = quote! {
-        #[doc = #doc_string]
-        fn #method_name(mut self) -> Self where Self: std::marker::Sized {
-            let mut style = self.declared_style();
-            #(#field_assignments)*
-            self
-        }
-    };
-
-    method
-}
-
-fn generate_custom_value_setter(
-    prefix: &'static str,
-    length_type: TokenStream2,
-    fields: &Vec<TokenStream2>,
-) -> TokenStream2 {
-    let method_name = format_ident!("{}", prefix);
-
-    let mut iter = fields.into_iter();
-    let last = iter.next_back().unwrap();
-    let field_assignments = iter
-        .map(|field_tokens| {
-            quote! {
-                style.#field_tokens = Some(length.clone().into());
-            }
-        })
-        .chain(std::iter::once(quote! {
-            style.#last = Some(length.into());
-        }))
-        .collect::<Vec<_>>();
-
-    let method = quote! {
-        fn #method_name(mut self, length: impl std::clone::Clone + Into<gpui2::geometry::#length_type>) -> Self where Self: std::marker::Sized {
-            let mut style = self.declared_style();
-            #(#field_assignments)*
-            self
-        }
-    };
-
-    method
-}
-
-fn box_prefixes() -> Vec<(&'static str, bool, Vec<TokenStream2>)> {
-    vec![
-        ("w", true, vec![quote! { size.width }]),
-        ("h", true, vec![quote! { size.height }]),
-        (
-            "size",
-            true,
-            vec![quote! {size.width}, quote! {size.height}],
-        ),
-        ("min_w", true, vec![quote! { min_size.width }]),
-        ("min_h", true, vec![quote! { min_size.height }]),
-        ("max_w", true, vec![quote! { max_size.width }]),
-        ("max_h", true, vec![quote! { max_size.height }]),
-        (
-            "m",
-            true,
-            vec![
-                quote! { margin.top },
-                quote! { margin.bottom },
-                quote! { margin.left },
-                quote! { margin.right },
-            ],
-        ),
-        ("mt", true, vec![quote! { margin.top }]),
-        ("mb", true, vec![quote! { margin.bottom }]),
-        (
-            "my",
-            true,
-            vec![quote! { margin.top }, quote! { margin.bottom }],
-        ),
-        (
-            "mx",
-            true,
-            vec![quote! { margin.left }, quote! { margin.right }],
-        ),
-        ("ml", true, vec![quote! { margin.left }]),
-        ("mr", true, vec![quote! { margin.right }]),
-        (
-            "p",
-            false,
-            vec![
-                quote! { padding.top },
-                quote! { padding.bottom },
-                quote! { padding.left },
-                quote! { padding.right },
-            ],
-        ),
-        ("pt", false, vec![quote! { padding.top }]),
-        ("pb", false, vec![quote! { padding.bottom }]),
-        (
-            "px",
-            false,
-            vec![quote! { padding.left }, quote! { padding.right }],
-        ),
-        (
-            "py",
-            false,
-            vec![quote! { padding.top }, quote! { padding.bottom }],
-        ),
-        ("pl", false, vec![quote! { padding.left }]),
-        ("pr", false, vec![quote! { padding.right }]),
-        ("top", true, vec![quote! { inset.top }]),
-        ("bottom", true, vec![quote! { inset.bottom }]),
-        ("left", true, vec![quote! { inset.left }]),
-        ("right", true, vec![quote! { inset.right }]),
-        (
-            "gap",
-            false,
-            vec![quote! { gap.width }, quote! { gap.height }],
-        ),
-        ("gap_x", false, vec![quote! { gap.width }]),
-        ("gap_y", false, vec![quote! { gap.height }]),
-    ]
-}
-
-fn box_suffixes() -> Vec<(&'static str, TokenStream2, &'static str)> {
-    vec![
-        ("0", quote! { pixels(0.) }, "0px"),
-        ("0p5", quote! { rems(0.125) }, "2px (0.125rem)"),
-        ("1", quote! { rems(0.25) }, "4px (0.25rem)"),
-        ("1p5", quote! { rems(0.375) }, "6px (0.375rem)"),
-        ("2", quote! { rems(0.5) }, "8px (0.5rem)"),
-        ("2p5", quote! { rems(0.625) }, "10px (0.625rem)"),
-        ("3", quote! { rems(0.75) }, "12px (0.75rem)"),
-        ("3p5", quote! { rems(0.875) }, "14px (0.875rem)"),
-        ("4", quote! { rems(1.) }, "16px (1rem)"),
-        ("5", quote! { rems(1.25) }, "20px (1.25rem)"),
-        ("6", quote! { rems(1.5) }, "24px (1.5rem)"),
-        ("7", quote! { rems(1.75) }, "28px (1.75rem)"),
-        ("8", quote! { rems(2.0) }, "32px (2rem)"),
-        ("9", quote! { rems(2.25) }, "36px (2.25rem)"),
-        ("10", quote! { rems(2.5) }, "40px (2.5rem)"),
-        ("11", quote! { rems(2.75) }, "44px (2.75rem)"),
-        ("12", quote! { rems(3.) }, "48px (3rem)"),
-        ("16", quote! { rems(4.) }, "64px (4rem)"),
-        ("20", quote! { rems(5.) }, "80px (5rem)"),
-        ("24", quote! { rems(6.) }, "96px (6rem)"),
-        ("32", quote! { rems(8.) }, "128px (8rem)"),
-        ("40", quote! { rems(10.) }, "160px (10rem)"),
-        ("48", quote! { rems(12.) }, "192px (12rem)"),
-        ("56", quote! { rems(14.) }, "224px (14rem)"),
-        ("64", quote! { rems(16.) }, "256px (16rem)"),
-        ("72", quote! { rems(18.) }, "288px (18rem)"),
-        ("80", quote! { rems(20.) }, "320px (20rem)"),
-        ("96", quote! { rems(24.) }, "384px (24rem)"),
-        ("auto", quote! { auto() }, "Auto"),
-        ("px", quote! { pixels(1.) }, "1px"),
-        ("full", quote! { relative(1.) }, "100%"),
-        ("1_2", quote! { relative(0.5) }, "50% (1/2)"),
-        ("1_3", quote! { relative(1./3.) }, "33% (1/3)"),
-        ("2_3", quote! { relative(2./3.) }, "66% (2/3)"),
-        ("1_4", quote! { relative(0.25) }, "25% (1/4)"),
-        ("2_4", quote! { relative(0.5) }, "50% (2/4)"),
-        ("3_4", quote! { relative(0.75) }, "75% (3/4)"),
-        ("1_5", quote! { relative(0.2) }, "20% (1/5)"),
-        ("2_5", quote! { relative(0.4) }, "40% (2/5)"),
-        ("3_5", quote! { relative(0.6) }, "60% (3/5)"),
-        ("4_5", quote! { relative(0.8) }, "80% (4/5)"),
-        ("1_6", quote! { relative(1./6.) }, "16% (1/6)"),
-        ("5_6", quote! { relative(5./6.) }, "80% (5/6)"),
-        ("1_12", quote! { relative(1./12.) }, "8% (1/12)"),
-    ]
-}
-
-fn corner_prefixes() -> Vec<(&'static str, Vec<TokenStream2>)> {
-    vec![
-        (
-            "rounded",
-            vec![
-                quote! { corner_radii.top_left },
-                quote! { corner_radii.top_right },
-                quote! { corner_radii.bottom_right },
-                quote! { corner_radii.bottom_left },
-            ],
-        ),
-        (
-            "rounded_t",
-            vec![
-                quote! { corner_radii.top_left },
-                quote! { corner_radii.top_right },
-            ],
-        ),
-        (
-            "rounded_b",
-            vec![
-                quote! { corner_radii.bottom_left },
-                quote! { corner_radii.bottom_right },
-            ],
-        ),
-        (
-            "rounded_r",
-            vec![
-                quote! { corner_radii.top_right },
-                quote! { corner_radii.bottom_right },
-            ],
-        ),
-        (
-            "rounded_l",
-            vec![
-                quote! { corner_radii.top_left },
-                quote! { corner_radii.bottom_left },
-            ],
-        ),
-        ("rounded_tl", vec![quote! { corner_radii.top_left }]),
-        ("rounded_tr", vec![quote! { corner_radii.top_right }]),
-        ("rounded_bl", vec![quote! { corner_radii.bottom_left }]),
-        ("rounded_br", vec![quote! { corner_radii.bottom_right }]),
-    ]
-}
-
-fn corner_suffixes() -> Vec<(&'static str, TokenStream2, &'static str)> {
-    vec![
-        ("none", quote! { pixels(0.) }, "0px"),
-        ("sm", quote! { rems(0.125) }, "2px (0.125rem)"),
-        ("md", quote! { rems(0.25) }, "4px (0.25rem)"),
-        ("lg", quote! { rems(0.5) }, "8px (0.5rem)"),
-        ("xl", quote! { rems(0.75) }, "12px (0.75rem)"),
-        ("2xl", quote! { rems(1.) }, "16px (1rem)"),
-        ("3xl", quote! { rems(1.5) }, "24px (1.5rem)"),
-        ("full", quote! {  pixels(9999.) }, "9999px"),
-    ]
-}
-
-fn border_prefixes() -> Vec<(&'static str, Vec<TokenStream2>)> {
-    vec![
-        (
-            "border",
-            vec![
-                quote! { border_widths.top },
-                quote! { border_widths.right },
-                quote! { border_widths.bottom },
-                quote! { border_widths.left },
-            ],
-        ),
-        ("border_t", vec![quote! { border_widths.top }]),
-        ("border_b", vec![quote! { border_widths.bottom }]),
-        ("border_r", vec![quote! { border_widths.right }]),
-        ("border_l", vec![quote! { border_widths.left }]),
-        (
-            "border_x",
-            vec![
-                quote! { border_widths.left },
-                quote! { border_widths.right },
-            ],
-        ),
-        (
-            "border_y",
-            vec![
-                quote! { border_widths.top },
-                quote! { border_widths.bottom },
-            ],
-        ),
-    ]
-}
-
-fn border_suffixes() -> Vec<(&'static str, TokenStream2, &'static str)> {
-    vec![
-        ("", quote! { pixels(1.)}, "1px"),
-        ("0", quote! { pixels(0.)}, "0px"),
-        ("1", quote! { pixels(1.) }, "1px"),
-        ("2", quote! { pixels(2.) }, "2px"),
-        ("3", quote! { pixels(3.) }, "3px"),
-        ("4", quote! { pixels(4.) }, "4px"),
-        ("5", quote! { pixels(5.) }, "5px"),
-        ("6", quote! { pixels(6.) }, "6px"),
-        ("7", quote! { pixels(7.) }, "7px"),
-        ("8", quote! { pixels(8.) }, "8px"),
-        ("9", quote! { pixels(9.) }, "9px"),
-        ("10", quote! { pixels(10.) }, "10px"),
-        ("11", quote! { pixels(11.) }, "11px"),
-        ("12", quote! { pixels(12.) }, "12px"),
-        ("16", quote! { pixels(16.) }, "16px"),
-        ("20", quote! { pixels(20.) }, "20px"),
-        ("24", quote! { pixels(24.) }, "24px"),
-        ("32", quote! { pixels(32.) }, "32px"),
-    ]
-}