Add a live Rust style editor to inspector to edit a sequence of no-argument style modifiers (#31443)

Editing JSON styles is not very helpful for bringing style changes back
to the actual code. This PR adds a buffer that pretends to be Rust,
applying any style attribute identifiers it finds. Also supports
completions with display of documentation. The effect of the currently
selected completion is previewed. Warning diagnostics appear on any
unrecognized identifier.


https://github.com/user-attachments/assets/af39ff0a-26a5-4835-a052-d8f642b2080c

Adds a `#[derive_inspector_reflection]` macro which allows these methods
to be enumerated and called by their name. The macro code changes were
95% generated by Zed Agent + Opus 4.

Release Notes:

* Added an element inspector for development. On debug builds,
`dev::ToggleInspector` will open a pane allowing inspecting of element
info and modifying styles.

crates/refineable/derive_refineable/src/derive_refineable.rs

@@ -66,7 +66,7 @@ pub fn derive_refineable(input: TokenStream) -> TokenStream {
         })
         .collect();
 
-    // Create trait bound that each wrapped type must implement Clone // & Default
+    // Create trait bound that each wrapped type must implement Clone
     let type_param_bounds: Vec<_> = wrapped_types
         .iter()
         .map(|ty| {
@@ -273,6 +273,116 @@ pub fn derive_refineable(input: TokenStream) -> TokenStream {
         })
         .collect();
 
+    let refineable_is_superset_conditions: Vec<TokenStream2> = fields
+        .iter()
+        .map(|field| {
+            let name = &field.ident;
+            let is_refineable = is_refineable_field(field);
+            let is_optional = is_optional_field(field);
+
+            if is_refineable {
+                quote! {
+                    if !self.#name.is_superset_of(&refinement.#name) {
+                        return false;
+                    }
+                }
+            } else if is_optional {
+                quote! {
+                    if refinement.#name.is_some() && &self.#name != &refinement.#name {
+                        return false;
+                    }
+                }
+            } else {
+                quote! {
+                    if let Some(refinement_value) = &refinement.#name {
+                        if &self.#name != refinement_value {
+                            return false;
+                        }
+                    }
+                }
+            }
+        })
+        .collect();
+
+    let refinement_is_superset_conditions: Vec<TokenStream2> = fields
+        .iter()
+        .map(|field| {
+            let name = &field.ident;
+            let is_refineable = is_refineable_field(field);
+
+            if is_refineable {
+                quote! {
+                    if !self.#name.is_superset_of(&refinement.#name) {
+                        return false;
+                    }
+                }
+            } else {
+                quote! {
+                    if refinement.#name.is_some() && &self.#name != &refinement.#name {
+                        return false;
+                    }
+                }
+            }
+        })
+        .collect();
+
+    let refineable_subtract_assignments: Vec<TokenStream2> = fields
+        .iter()
+        .map(|field| {
+            let name = &field.ident;
+            let is_refineable = is_refineable_field(field);
+            let is_optional = is_optional_field(field);
+
+            if is_refineable {
+                quote! {
+                    #name: self.#name.subtract(&refinement.#name),
+                }
+            } else if is_optional {
+                quote! {
+                    #name: if &self.#name == &refinement.#name {
+                        None
+                    } else {
+                        self.#name.clone()
+                    },
+                }
+            } else {
+                quote! {
+                    #name: if let Some(refinement_value) = &refinement.#name {
+                        if &self.#name == refinement_value {
+                            None
+                        } else {
+                            Some(self.#name.clone())
+                        }
+                    } else {
+                        Some(self.#name.clone())
+                    },
+                }
+            }
+        })
+        .collect();
+
+    let refinement_subtract_assignments: Vec<TokenStream2> = fields
+        .iter()
+        .map(|field| {
+            let name = &field.ident;
+            let is_refineable = is_refineable_field(field);
+
+            if is_refineable {
+                quote! {
+                    #name: self.#name.subtract(&refinement.#name),
+                }
+            } else {
+                quote! {
+                    #name: if &self.#name == &refinement.#name {
+                        None
+                    } else {
+                        self.#name.clone()
+                    },
+                }
+            }
+        })
+        .collect();
+
     let mut derive_stream = quote! {};
     for trait_to_derive in refinement_traits_to_derive {
         derive_stream.extend(quote! { #[derive(#trait_to_derive)] })
@@ -303,6 +413,19 @@ pub fn derive_refineable(input: TokenStream) -> TokenStream {
                 #( #refineable_refined_assignments )*
                 self
             }
+
+            fn is_superset_of(&self, refinement: &Self::Refinement) -> bool
+            {
+                #( #refineable_is_superset_conditions )*
+                true
+            }
+
+            fn subtract(&self, refinement: &Self::Refinement) -> Self::Refinement
+            {
+                #refinement_ident {
+                    #( #refineable_subtract_assignments )*
+                }
+            }
         }
 
         impl #impl_generics Refineable for #refinement_ident #ty_generics
@@ -318,6 +441,19 @@ pub fn derive_refineable(input: TokenStream) -> TokenStream {
                 #( #refinement_refined_assignments )*
                 self
             }
+
+            fn is_superset_of(&self, refinement: &Self::Refinement) -> bool
+            {
+                #( #refinement_is_superset_conditions )*
+                true
+            }
+
+            fn subtract(&self, refinement: &Self::Refinement) -> Self::Refinement
+            {
+                #refinement_ident {
+                    #( #refinement_subtract_assignments )*
+                }
+            }
         }
 
         impl #impl_generics ::refineable::IsEmpty for #refinement_ident #ty_generics