style: cargo fmt with the workspace tab policy (hard_tabs)

Whitespace only; the fork has no own rustfmt.toml so the Oak root
policy applies.

crates/gpui_refineable/src/refineable.rs

@@ -27,45 +27,45 @@ pub use derive_refineable::Refineable;
 /// Fields can be marked with:
 /// - `#[refineable]`: Field is itself refineable (uses nested refinement type)
 pub trait Refineable: Clone {
-    type Refinement: Refineable<Refinement = Self::Refinement> + IsEmpty + Default;
+	type Refinement: Refineable<Refinement = Self::Refinement> + IsEmpty + Default;
 
-    /// Applies the given refinement to this instance, modifying it in place.
-    ///
-    /// Only non-empty values in the refinement are applied.
-    ///
-    /// * For refineable fields, this recursively calls `refine`.
-    /// * For other fields, the value is replaced if present in the refinement.
-    fn refine(&mut self, refinement: &Self::Refinement);
+	/// Applies the given refinement to this instance, modifying it in place.
+	///
+	/// Only non-empty values in the refinement are applied.
+	///
+	/// * For refineable fields, this recursively calls `refine`.
+	/// * For other fields, the value is replaced if present in the refinement.
+	fn refine(&mut self, refinement: &Self::Refinement);
 
-    /// Returns a new instance with the refinement applied, equivalent to cloning `self` and calling
-    /// `refine` on it.
-    fn refined(self, refinement: Self::Refinement) -> Self;
+	/// Returns a new instance with the refinement applied, equivalent to cloning `self` and calling
+	/// `refine` on it.
+	fn refined(self, refinement: Self::Refinement) -> Self;
 
-    /// Creates an instance from a cascade by merging all refinements atop the default value.
-    fn from_cascade(cascade: &Cascade<Self>) -> Self
-    where
-        Self: Default + Sized,
-    {
-        Self::default().refined(cascade.merged())
-    }
+	/// Creates an instance from a cascade by merging all refinements atop the default value.
+	fn from_cascade(cascade: &Cascade<Self>) -> Self
+	where
+		Self: Default + Sized,
+	{
+		Self::default().refined(cascade.merged())
+	}
 
-    /// Returns `true` if this instance would contain all values from the refinement.
-    ///
-    /// For refineable fields, this recursively checks `is_superset_of`. For other fields, this
-    /// checks if the refinement's `Some` values match this instance's values.
-    fn is_superset_of(&self, refinement: &Self::Refinement) -> bool;
+	/// Returns `true` if this instance would contain all values from the refinement.
+	///
+	/// For refineable fields, this recursively checks `is_superset_of`. For other fields, this
+	/// checks if the refinement's `Some` values match this instance's values.
+	fn is_superset_of(&self, refinement: &Self::Refinement) -> bool;
 
-    /// Returns a refinement that represents the difference between this instance and the given
-    /// refinement.
-    ///
-    /// For refineable fields, this recursively calls `subtract`. For other fields, the field is
-    /// `None` if the field's value is equal to the refinement.
-    fn subtract(&self, refinement: &Self::Refinement) -> Self::Refinement;
+	/// Returns a refinement that represents the difference between this instance and the given
+	/// refinement.
+	///
+	/// For refineable fields, this recursively calls `subtract`. For other fields, the field is
+	/// `None` if the field's value is equal to the refinement.
+	fn subtract(&self, refinement: &Self::Refinement) -> Self::Refinement;
 }
 
 pub trait IsEmpty {
-    /// Returns `true` if applying this refinement would have no effect.
-    fn is_empty(&self) -> bool;
+	/// Returns `true` if applying this refinement would have no effect.
+	fn is_empty(&self) -> bool;
 }
 
 /// A cascade of refinements that can be merged in priority order.
@@ -80,9 +80,9 @@ pub trait IsEmpty {
 pub struct Cascade<S: Refineable>(Vec<Option<S::Refinement>>);
 
 impl<S: Refineable + Default> Default for Cascade<S> {
-    fn default() -> Self {
-        Self(vec![Some(Default::default())])
-    }
+	fn default() -> Self {
+		Self(vec![Some(Default::default())])
+	}
 }
 
 /// A handle to a specific slot in a cascade.
@@ -93,40 +93,40 @@ impl<S: Refineable + Default> Default for Cascade<S> {
 pub struct CascadeSlot(usize);
 
 impl<S: Refineable + Default> Cascade<S> {
-    /// Reserves a new slot in the cascade and returns a handle to it.
-    ///
-    /// The new slot is initially empty (`None`) and can be populated later
-    /// using `set()`.
-    pub fn reserve(&mut self) -> CascadeSlot {
-        self.0.push(None);
-        CascadeSlot(self.0.len() - 1)
-    }
+	/// Reserves a new slot in the cascade and returns a handle to it.
+	///
+	/// The new slot is initially empty (`None`) and can be populated later
+	/// using `set()`.
+	pub fn reserve(&mut self) -> CascadeSlot {
+		self.0.push(None);
+		CascadeSlot(self.0.len() - 1)
+	}
 
-    /// Returns a mutable reference to the base refinement (slot 0).
-    ///
-    /// The base refinement is always present and serves as the foundation
-    /// for the cascade.
-    pub fn base(&mut self) -> &mut S::Refinement {
-        self.0[0].as_mut().unwrap()
-    }
+	/// Returns a mutable reference to the base refinement (slot 0).
+	///
+	/// The base refinement is always present and serves as the foundation
+	/// for the cascade.
+	pub fn base(&mut self) -> &mut S::Refinement {
+		self.0[0].as_mut().unwrap()
+	}
 
-    /// Sets the refinement for a specific slot in the cascade.
-    ///
-    /// Setting a slot to `None` effectively removes it from consideration
-    /// during merging.
-    pub fn set(&mut self, slot: CascadeSlot, refinement: Option<S::Refinement>) {
-        self.0[slot.0] = refinement
-    }
+	/// Sets the refinement for a specific slot in the cascade.
+	///
+	/// Setting a slot to `None` effectively removes it from consideration
+	/// during merging.
+	pub fn set(&mut self, slot: CascadeSlot, refinement: Option<S::Refinement>) {
+		self.0[slot.0] = refinement
+	}
 
-    /// Merges all refinements in the cascade into a single refinement.
-    ///
-    /// Refinements are applied in order, with later slots taking precedence.
-    /// Empty slots (`None`) are skipped during merging.
-    pub fn merged(&self) -> S::Refinement {
-        let mut merged = self.0[0].clone().unwrap();
-        for refinement in self.0.iter().skip(1).flatten() {
-            merged.refine(refinement);
-        }
-        merged
-    }
+	/// Merges all refinements in the cascade into a single refinement.
+	///
+	/// Refinements are applied in order, with later slots taking precedence.
+	/// Empty slots (`None`) are skipped during merging.
+	pub fn merged(&self) -> S::Refinement {
+		let mut merged = self.0[0].clone().unwrap();
+		for refinement in self.0.iter().skip(1).flatten() {
+			merged.refine(refinement);
+		}
+		merged
+	}
 }