gpui_util_gpui_unofficial/
lib.rs

1// FluentBuilder
2// pub use gpui_util::{FutureExt, Timeout, arc_cow::ArcCow};
3
4use std::{
5    env,
6    ops::AddAssign,
7    panic::Location,
8    pin::Pin,
9    sync::OnceLock,
10    task::{Context, Poll},
11    time::Instant,
12};
13
14pub mod arc_cow;
15
16pub fn post_inc<T: From<u8> + AddAssign<T> + Copy>(value: &mut T) -> T {
17    let prev = *value;
18    *value += T::from(1);
19    prev
20}
21
22pub fn measure<R>(label: &str, f: impl FnOnce() -> R) -> R {
23    static ZED_MEASUREMENTS: OnceLock<bool> = OnceLock::new();
24    let zed_measurements = ZED_MEASUREMENTS.get_or_init(|| {
25        env::var("ZED_MEASUREMENTS")
26            .map(|measurements| measurements == "1" || measurements == "true")
27            .unwrap_or(false)
28    });
29
30    if *zed_measurements {
31        let start = Instant::now();
32        let result = f();
33        let elapsed = start.elapsed();
34        eprintln!("{}: {:?}", label, elapsed);
35        result
36    } else {
37        f()
38    }
39}
40
41#[macro_export]
42macro_rules! debug_panic {
43    ( $($fmt_arg:tt)* ) => {
44        if cfg!(debug_assertions) {
45            panic!( $($fmt_arg)* );
46        } else {
47            let backtrace = std::backtrace::Backtrace::capture();
48            log::error!("{}\n{:?}", format_args!($($fmt_arg)*), backtrace);
49        }
50    };
51}
52
53#[track_caller]
54pub fn some_or_debug_panic<T>(option: Option<T>) -> Option<T> {
55    #[cfg(debug_assertions)]
56    if option.is_none() {
57        panic!("Unexpected None");
58    }
59    option
60}
61
62/// Expands to an immediately-invoked function expression. Good for using the ? operator
63/// in functions which do not return an Option or Result.
64///
65/// Accepts a normal block, an async block, or an async move block.
66#[macro_export]
67macro_rules! maybe {
68    ($block:block) => {
69        (|| $block)()
70    };
71    (async $block:block) => {
72        (async || $block)()
73    };
74    (async move $block:block) => {
75        (async move || $block)()
76    };
77}
78pub trait ResultExt<E> {
79    type Ok;
80
81    fn log_err(self) -> Option<Self::Ok>;
82    /// Like [`ResultExt::log_err`], but uses `{:?}` formatting so `anyhow::Error` values emit their
83    /// full backtrace. Reach for this only when a backtrace is genuinely wanted — most call sites
84    /// should stick with `log_err` / `warn_on_err`, whose output is a single chained error message.
85    fn log_err_with_backtrace(self) -> Option<Self::Ok>
86    where
87        E: std::fmt::Debug;
88    /// Assert that this result should never be an error in development or tests.
89    fn debug_assert_ok(self, reason: &str) -> Self;
90    fn warn_on_err(self) -> Option<Self::Ok>;
91    fn log_with_level(self, level: log::Level) -> Option<Self::Ok>;
92    fn anyhow(self) -> anyhow::Result<Self::Ok>
93    where
94        E: Into<anyhow::Error>;
95}
96
97impl<T, E> ResultExt<E> for Result<T, E>
98where
99    E: std::fmt::Display,
100{
101    type Ok = T;
102
103    #[track_caller]
104    fn log_err(self) -> Option<T> {
105        self.log_with_level(log::Level::Error)
106    }
107
108    #[track_caller]
109    fn log_err_with_backtrace(self) -> Option<T>
110    where
111        E: std::fmt::Debug,
112    {
113        match self {
114            Ok(value) => Some(value),
115            Err(error) => {
116                log_error_with_caller(
117                    *Location::caller(),
118                    DebugAsDisplay(&error),
119                    log::Level::Error,
120                );
121                None
122            }
123        }
124    }
125
126    #[track_caller]
127    fn debug_assert_ok(self, reason: &str) -> Self {
128        if let Err(error) = &self {
129            debug_panic!("{reason} - {error:#}");
130        }
131        self
132    }
133
134    #[track_caller]
135    fn warn_on_err(self) -> Option<T> {
136        self.log_with_level(log::Level::Warn)
137    }
138
139    #[track_caller]
140    fn log_with_level(self, level: log::Level) -> Option<T> {
141        match self {
142            Ok(value) => Some(value),
143            Err(error) => {
144                log_error_with_caller(*Location::caller(), error, level);
145                None
146            }
147        }
148    }
149
150    fn anyhow(self) -> anyhow::Result<T>
151    where
152        E: Into<anyhow::Error>,
153    {
154        self.map_err(Into::into)
155    }
156}
157
158fn log_error_with_caller<E>(caller: core::panic::Location<'_>, error: E, level: log::Level)
159where
160    E: std::fmt::Display,
161{
162    #[cfg(not(windows))]
163    let file = caller.file();
164    #[cfg(windows)]
165    let file = caller.file().replace('\\', "/");
166    // In this codebase all crates reside in a `crates` directory,
167    // so discard the prefix up to that segment to find the crate name
168    let file = file.split_once("crates/");
169    let target = file.as_ref().and_then(|(_, s)| s.split_once("/src/"));
170
171    let module_path = target.map(|(krate, module)| {
172        if module.starts_with(krate) {
173            module.trim_end_matches(".rs").replace('/', "::")
174        } else {
175            krate.to_owned() + "::" + &module.trim_end_matches(".rs").replace('/', "::")
176        }
177    });
178    let file = file.map(|(_, file)| format!("crates/{file}"));
179    log::logger().log(
180        &log::Record::builder()
181            .target(module_path.as_deref().unwrap_or(""))
182            .module_path(file.as_deref())
183            .args(format_args!("{:#}", error))
184            .file(Some(caller.file()))
185            .line(Some(caller.line()))
186            .level(level)
187            .build(),
188    );
189}
190
191pub fn log_err<E: std::fmt::Display>(error: &E) {
192    log_error_with_caller(*Location::caller(), error, log::Level::Error);
193}
194
195// Forces `{:?}` formatting through a `Display`-bounded logging helper so `anyhow::Error` emits a
196// backtrace instead of the single-line chained message produced by its `Display`/`{:#}` forms.
197struct DebugAsDisplay<'a, E>(&'a E);
198
199impl<E: std::fmt::Debug> std::fmt::Display for DebugAsDisplay<'_, E> {
200    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
201        write!(f, "{:?}", self.0)
202    }
203}
204
205pub trait TryFutureExt {
206    fn log_err(self) -> LogErrorFuture<Self>
207    where
208        Self: Sized;
209
210    fn log_tracked_err(self, location: core::panic::Location<'static>) -> LogErrorFuture<Self>
211    where
212        Self: Sized;
213
214    fn warn_on_err(self) -> LogErrorFuture<Self>
215    where
216        Self: Sized;
217    fn unwrap(self) -> UnwrapFuture<Self>
218    where
219        Self: Sized;
220}
221
222/// `{:?}`-formatting companion to [`TryFutureExt`]; emits a backtrace for `anyhow::Error`. Prefer
223/// [`TryFutureExt`] unless a backtrace is genuinely wanted.
224pub trait TryFutureExtBacktrace {
225    fn log_err_with_backtrace(self) -> LogErrorWithBacktraceFuture<Self>
226    where
227        Self: Sized;
228
229    fn log_tracked_err_with_backtrace(
230        self,
231        location: core::panic::Location<'static>,
232    ) -> LogErrorWithBacktraceFuture<Self>
233    where
234        Self: Sized;
235}
236
237impl<F, T, E> TryFutureExt for F
238where
239    F: Future<Output = Result<T, E>>,
240    E: std::fmt::Display,
241{
242    #[track_caller]
243    fn log_err(self) -> LogErrorFuture<Self>
244    where
245        Self: Sized,
246    {
247        let location = Location::caller();
248        LogErrorFuture(self, log::Level::Error, *location)
249    }
250
251    fn log_tracked_err(self, location: core::panic::Location<'static>) -> LogErrorFuture<Self>
252    where
253        Self: Sized,
254    {
255        LogErrorFuture(self, log::Level::Error, location)
256    }
257
258    #[track_caller]
259    fn warn_on_err(self) -> LogErrorFuture<Self>
260    where
261        Self: Sized,
262    {
263        let location = Location::caller();
264        LogErrorFuture(self, log::Level::Warn, *location)
265    }
266
267    fn unwrap(self) -> UnwrapFuture<Self>
268    where
269        Self: Sized,
270    {
271        UnwrapFuture(self)
272    }
273}
274
275impl<F, T, E> TryFutureExtBacktrace for F
276where
277    F: Future<Output = Result<T, E>>,
278    E: std::fmt::Debug,
279{
280    #[track_caller]
281    fn log_err_with_backtrace(self) -> LogErrorWithBacktraceFuture<Self>
282    where
283        Self: Sized,
284    {
285        let location = Location::caller();
286        LogErrorWithBacktraceFuture(self, log::Level::Error, *location)
287    }
288
289    fn log_tracked_err_with_backtrace(
290        self,
291        location: core::panic::Location<'static>,
292    ) -> LogErrorWithBacktraceFuture<Self>
293    where
294        Self: Sized,
295    {
296        LogErrorWithBacktraceFuture(self, log::Level::Error, location)
297    }
298}
299
300#[must_use]
301pub struct LogErrorFuture<F>(F, log::Level, core::panic::Location<'static>);
302
303impl<F, T, E> Future for LogErrorFuture<F>
304where
305    F: Future<Output = Result<T, E>>,
306    E: std::fmt::Display,
307{
308    type Output = Option<T>;
309
310    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
311        let level = self.1;
312        let location = self.2;
313        let inner = unsafe { Pin::new_unchecked(&mut self.get_unchecked_mut().0) };
314        match inner.poll(cx) {
315            Poll::Ready(output) => Poll::Ready(match output {
316                Ok(output) => Some(output),
317                Err(error) => {
318                    log_error_with_caller(location, error, level);
319                    None
320                }
321            }),
322            Poll::Pending => Poll::Pending,
323        }
324    }
325}
326
327#[must_use]
328pub struct LogErrorWithBacktraceFuture<F>(F, log::Level, core::panic::Location<'static>);
329
330impl<F, T, E> Future for LogErrorWithBacktraceFuture<F>
331where
332    F: Future<Output = Result<T, E>>,
333    E: std::fmt::Debug,
334{
335    type Output = Option<T>;
336
337    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
338        let level = self.1;
339        let location = self.2;
340        let inner = unsafe { Pin::new_unchecked(&mut self.get_unchecked_mut().0) };
341        match inner.poll(cx) {
342            Poll::Ready(output) => Poll::Ready(match output {
343                Ok(output) => Some(output),
344                Err(error) => {
345                    log_error_with_caller(location, DebugAsDisplay(&error), level);
346                    None
347                }
348            }),
349            Poll::Pending => Poll::Pending,
350        }
351    }
352}
353
354pub struct UnwrapFuture<F>(F);
355
356impl<F, T, E> Future for UnwrapFuture<F>
357where
358    F: Future<Output = Result<T, E>>,
359    E: std::fmt::Debug,
360{
361    type Output = T;
362
363    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
364        let inner = unsafe { Pin::new_unchecked(&mut self.get_unchecked_mut().0) };
365        match inner.poll(cx) {
366            Poll::Ready(result) => Poll::Ready(result.unwrap()),
367            Poll::Pending => Poll::Pending,
368        }
369    }
370}
371
372pub struct Deferred<F: FnOnce()>(Option<F>);
373
374impl<F: FnOnce()> Deferred<F> {
375    /// Drop without running the deferred function.
376    pub fn abort(mut self) {
377        self.0.take();
378    }
379}
380
381impl<F: FnOnce()> Drop for Deferred<F> {
382    fn drop(&mut self) {
383        if let Some(f) = self.0.take() {
384            f()
385        }
386    }
387}
388
389/// Run the given function when the returned value is dropped (unless it's cancelled).
390#[must_use]
391pub fn defer<F: FnOnce()>(f: F) -> Deferred<F> {
392    Deferred(Some(f))
393}
gpui_util_gpui_unofficial/lib.rs

gpui_util_gpui_unofficial/
lib.rs
