Eliminate GPUI View, ViewContext, and WindowContext types (#22632)

There's still a bit more work to do on this, but this PR is compiling
(with warnings) after eliminating the key types. When the tasks below
are complete, this will be the new narrative for GPUI:

- `Entity<T>` - This replaces `View<T>`/`Model<T>`. It represents a unit
of state, and if `T` implements `Render`, then `Entity<T>` implements
`Element`.
- `&mut App` This replaces `AppContext` and represents the app.
- `&mut Context<T>` This replaces `ModelContext` and derefs to `App`. It
is provided by the framework when updating an entity.
- `&mut Window` Broken out of `&mut WindowContext` which no longer
exists. Every method that once took `&mut WindowContext` now takes `&mut
Window, &mut App` and every method that took `&mut ViewContext<T>` now
takes `&mut Window, &mut Context<T>`

Not pictured here are the two other failed attempts. It's been quite a
month!

Tasks:

- [x] Remove `View`, `ViewContext`, `WindowContext` and thread through
`Window`
- [x] [@cole-miller @mikayla-maki] Redraw window when entities change
- [x] [@cole-miller @mikayla-maki] Get examples and Zed running
- [x] [@cole-miller @mikayla-maki] Fix Zed rendering
- [x] [@mikayla-maki] Fix todo! macros and comments
- [x] Fix a bug where the editor would not be redrawn because of view
caching
- [x] remove publicness window.notify() and replace with
`AppContext::notify`
- [x] remove `observe_new_window_models`, replace with
`observe_new_models` with an optional window
- [x] Fix a bug where the project panel would not be redrawn because of
the wrong refresh() call being used
- [x] Fix the tests
- [x] Fix warnings by eliminating `Window` params or using `_`
- [x] Fix conflicts
- [x] Simplify generic code where possible
- [x] Rename types
- [ ] Update docs

### issues post merge

- [x] Issues switching between normal and insert mode
- [x] Assistant re-rendering failure
- [x] Vim test failures
- [x] Mac build issue



Release Notes:

- N/A

---------

Co-authored-by: Antonio Scandurra <me@as-cii.com>
Co-authored-by: Cole Miller <cole@zed.dev>
Co-authored-by: Mikayla <mikayla@zed.dev>
Co-authored-by: Joseph <joseph@zed.dev>
Co-authored-by: max <max@zed.dev>
Co-authored-by: Michael Sloan <michael@zed.dev>
Co-authored-by: Mikayla Maki <mikaylamaki@Mikaylas-MacBook-Pro.local>
Co-authored-by: Mikayla <mikayla.c.maki@gmail.com>
Co-authored-by: joão <joao@zed.dev>

crates/gpui/src/gpui.rs

@@ -138,7 +138,6 @@ pub use keymap::*;
 pub use platform::*;
 pub use refineable::*;
 pub use scene::*;
-use seal::Sealed;
 pub use shared_string::*;
 pub use shared_uri::*;
 pub use smol::Timer;
@@ -159,16 +158,16 @@ use taffy::TaffyLayoutEngine;
 
 /// The context trait, allows the different contexts in GPUI to be used
 /// interchangeably for certain operations.
-pub trait Context {
+pub trait AppContext {
     /// The result type for this context, used for async contexts that
     /// can't hold a direct reference to the application context.
     type Result<T>;
 
     /// Create a new model in the app context.
-    fn new_model<T: 'static>(
+    fn new<T: 'static>(
         &mut self,
-        build_model: impl FnOnce(&mut ModelContext<'_, T>) -> T,
-    ) -> Self::Result<Model<T>>;
+        build_model: impl FnOnce(&mut Context<'_, T>) -> T,
+    ) -> Self::Result<Entity<T>>;
 
     /// Reserve a slot for a model to be inserted later.
     /// The returned [Reservation] allows you to obtain the [EntityId] for the future model.
@@ -180,14 +179,14 @@ pub trait Context {
     fn insert_model<T: 'static>(
         &mut self,
         reservation: Reservation<T>,
-        build_model: impl FnOnce(&mut ModelContext<'_, T>) -> T,
-    ) -> Self::Result<Model<T>>;
+        build_model: impl FnOnce(&mut Context<'_, T>) -> T,
+    ) -> Self::Result<Entity<T>>;
 
     /// Update a model in the app context.
     fn update_model<T, R>(
         &mut self,
-        handle: &Model<T>,
-        update: impl FnOnce(&mut T, &mut ModelContext<'_, T>) -> R,
+        handle: &Entity<T>,
+        update: impl FnOnce(&mut T, &mut Context<'_, T>) -> R,
     ) -> Self::Result<R>
     where
         T: 'static;
@@ -195,8 +194,8 @@ pub trait Context {
     /// Read a model from the app context.
     fn read_model<T, R>(
         &self,
-        handle: &Model<T>,
-        read: impl FnOnce(&T, &AppContext) -> R,
+        handle: &Entity<T>,
+        read: impl FnOnce(&T, &App) -> R,
     ) -> Self::Result<R>
     where
         T: 'static;
@@ -204,13 +203,13 @@ pub trait Context {
     /// Update a window for the given handle.
     fn update_window<T, F>(&mut self, window: AnyWindowHandle, f: F) -> Result<T>
     where
-        F: FnOnce(AnyView, &mut WindowContext) -> T;
+        F: FnOnce(AnyView, &mut Window, &mut App) -> T;
 
     /// Read a window off of the application context.
     fn read_window<T, R>(
         &self,
         window: &WindowHandle<T>,
-        read: impl FnOnce(View<T>, &AppContext) -> R,
+        read: impl FnOnce(Entity<T>, &App) -> R,
     ) -> Result<R>
     where
         T: 'static;
@@ -229,56 +228,35 @@ impl<T: 'static> Reservation<T> {
 
 /// This trait is used for the different visual contexts in GPUI that
 /// require a window to be present.
-pub trait VisualContext: Context {
-    /// Construct a new view in the window referenced by this context.
-    fn new_view<V>(
-        &mut self,
-        build_view: impl FnOnce(&mut ViewContext<V>) -> V,
-    ) -> Self::Result<View<V>>
-    where
-        V: 'static + Render;
+pub trait VisualContext: AppContext {
+    /// Returns the handle of the window associated with this context.
+    fn window_handle(&self) -> AnyWindowHandle;
 
     /// Update a view with the given callback
-    fn update_view<V: 'static, R>(
+    fn update_window_model<T: 'static, R>(
         &mut self,
-        view: &View<V>,
-        update: impl FnOnce(&mut V, &mut ViewContext<V>) -> R,
+        model: &Entity<T>,
+        update: impl FnOnce(&mut T, &mut Window, &mut Context<T>) -> R,
     ) -> Self::Result<R>;
 
+    /// Update a view with the given callback
+    fn new_window_model<T: 'static>(
+        &mut self,
+        build_model: impl FnOnce(&mut Window, &mut Context<'_, T>) -> T,
+    ) -> Self::Result<Entity<T>>;
+
     /// Replace the root view of a window with a new view.
     fn replace_root_view<V>(
         &mut self,
-        build_view: impl FnOnce(&mut ViewContext<V>) -> V,
-    ) -> Self::Result<View<V>>
+        build_view: impl FnOnce(&mut Window, &mut Context<V>) -> V,
+    ) -> Self::Result<Entity<V>>
     where
         V: 'static + Render;
 
-    /// Focus a view in the window, if it implements the [`FocusableView`] trait.
-    fn focus_view<V>(&mut self, view: &View<V>) -> Self::Result<()>
+    /// Focus a model in the window, if it implements the [`Focusable`] trait.
+    fn focus<V>(&mut self, model: &Entity<V>) -> Self::Result<()>
     where
-        V: FocusableView;
-
-    /// Dismiss a view in the window, if it implements the [`ManagedView`] trait.
-    fn dismiss_view<V>(&mut self, view: &View<V>) -> Self::Result<()>
-    where
-        V: ManagedView;
-}
-
-/// A trait that allows models and views to be interchangeable in certain operations
-pub trait Entity<T>: Sealed {
-    /// The weak reference type for this entity.
-    type Weak: 'static;
-
-    /// The ID for this entity
-    fn entity_id(&self) -> EntityId;
-
-    /// Downgrade this entity to a weak reference.
-    fn downgrade(&self) -> Self::Weak;
-
-    /// Upgrade this entity from a weak reference.
-    fn upgrade_from(weak: &Self::Weak) -> Option<Self>
-    where
-        Self: Sized;
+        V: Focusable;
 }
 
 /// A trait for tying together the types of a GPUI entity and the events it can
@@ -302,7 +280,7 @@ pub trait BorrowAppContext {
 
 impl<C> BorrowAppContext for C
 where
-    C: BorrowMut<AppContext>,
+    C: BorrowMut<App>,
 {
     fn set_global<G: Global>(&mut self, global: G) {
         self.borrow_mut().set_global(global)