diff --git a/crates/agent_skills/agent_skills.rs b/crates/agent_skills/agent_skills.rs index 7153b5e6dd5..34eaeabcf08 100644 --- a/crates/agent_skills/agent_skills.rs +++ b/crates/agent_skills/agent_skills.rs @@ -745,10 +745,8 @@ pub fn builtin_skill_content(skill_file_path: &Path) -> Option<&'static str> { /// location, so a Zed installation may have skills here even before the /// rest of Zed's skills support ships. /// -/// In test builds, `paths::home_dir()` is hardcoded to a fixed path -/// (e.g. `/Users/zed`), so all tests using this function operate on the -/// same simulated home directory. Each test should use its own `FakeFs` -/// instance to keep skill setups from leaking across tests. +/// Tests see the real home directory here, so they should resolve this path +/// against their own `FakeFs` instance rather than the real filesystem. pub fn global_skills_dir() -> PathBuf { paths::home_dir() .join(AGENTS_DIR_NAME) diff --git a/crates/gpui/Cargo.toml b/crates/gpui/Cargo.toml index c345f09b14a..222777fa396 100644 --- a/crates/gpui/Cargo.toml +++ b/crates/gpui/Cargo.toml @@ -19,7 +19,6 @@ workspace = true [features] default = ["font-kit", "wayland", "x11", "windows-manifest"] test-support = [ - "leak-detection", "collections/test-support", "http_client/test-support", "wayland", @@ -30,7 +29,9 @@ bench-support = ["profiler", "dep:criterion", "dep:bench_metrics"] # Preserve the published feature name while consumers migrate to `bench-support`. bench = ["bench-support"] inspector = ["gpui_macros/inspector"] -leak-detection = ["backtrace"] +# Tracks every entity handle so tests can assert nothing leaked. Also enabled +# by setting `GPUI_LEAK_DETECTION` when building; see `build.rs`. +leak-detection = [] wayland = [] x11 = [ "scap?/x11", @@ -49,7 +50,7 @@ path = "src/gpui.rs" accesskit.workspace = true anyhow.workspace = true async-task.workspace = true -backtrace = { workspace = true, optional = true } +backtrace.workspace = true bitflags.workspace = true collections.workspace = true diff --git a/crates/gpui/build.rs b/crates/gpui/build.rs index 79ca3f96a73..504a0152eb7 100644 --- a/crates/gpui/build.rs +++ b/crates/gpui/build.rs @@ -3,6 +3,18 @@ fn main() { println!("cargo::rustc-check-cfg=cfg(gles)"); + // Leak detection does bookkeeping on every entity handle, so `test-support` + // does not enable it: that feature must stay cheap enough to compile into + // every build. CI sets `GPUI_LEAK_DETECTION`; the `leak-detection` feature + // turns it on explicitly. + println!("cargo::rustc-check-cfg=cfg(gpui_leak_detection)"); + println!("cargo::rerun-if-env-changed=GPUI_LEAK_DETECTION"); + let requested_by_environment = + std::env::var_os("GPUI_LEAK_DETECTION").is_some_and(|value| !value.is_empty()); + if requested_by_environment || std::env::var_os("CARGO_FEATURE_LEAK_DETECTION").is_some() { + println!("cargo::rustc-cfg=gpui_leak_detection"); + } + let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default(); if target_os == "windows" { diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs index 24e0ea05daf..9ef3d6d33e4 100644 --- a/crates/gpui/src/app.rs +++ b/crates/gpui/src/app.rs @@ -839,7 +839,7 @@ pub struct App { // We need to ensure the leak detector drops last, after all tasks, callbacks and things have been dropped. // Otherwise it may report false positives. - #[cfg(any(test, feature = "leak-detection"))] + #[cfg(any(test, gpui_leak_detection))] _ref_counts: Arc>, } @@ -865,7 +865,7 @@ impl App { let keyboard_layout = platform.keyboard_layout(); let keyboard_mapper = platform.keyboard_mapper(); - #[cfg(any(test, feature = "leak-detection"))] + #[cfg(any(test, gpui_leak_detection))] let _ref_counts = entities.ref_counts_drop_handle(); let app = Rc::new_cyclic(|this| AppCell { @@ -942,7 +942,7 @@ impl App { element_arena: RefCell::new(Arena::new(1024 * 1024)), event_arena: Arena::new(1024 * 1024), - #[cfg(any(test, feature = "leak-detection"))] + #[cfg(any(test, gpui_leak_detection))] _ref_counts, }), }); @@ -1035,7 +1035,7 @@ impl App { /// The returned [`LeakDetectorSnapshot`] can later be passed to /// [`assert_no_new_leaks`](Self::assert_no_new_leaks) to verify that no /// entities created after the snapshot are still alive. - #[cfg(any(test, feature = "leak-detection"))] + #[cfg(any(test, gpui_leak_detection))] pub fn leak_detector_snapshot(&self) -> LeakDetectorSnapshot { self.entities.leak_detector_snapshot() } @@ -1051,11 +1051,22 @@ impl App { /// Panics if any new entity handles exist. The panic message lists every /// leaked entity with its type name, and includes allocation-site backtraces /// when `LEAK_BACKTRACE` is set. - #[cfg(any(test, feature = "leak-detection"))] + #[cfg(any(test, gpui_leak_detection))] pub fn assert_no_new_leaks(&self, snapshot: &LeakDetectorSnapshot) { self.entities.assert_no_new_leaks(snapshot) } + /// Without leak detection compiled in, this records nothing. + #[cfg(all(feature = "test-support", not(any(test, gpui_leak_detection))))] + pub fn leak_detector_snapshot(&self) -> LeakDetectorSnapshot { + LeakDetectorSnapshot::default() + } + + /// Without leak detection compiled in, this checks nothing. Set + /// `GPUI_LEAK_DETECTION` when building to enable it. + #[cfg(all(feature = "test-support", not(any(test, gpui_leak_detection))))] + pub fn assert_no_new_leaks(&self, _snapshot: &LeakDetectorSnapshot) {} + /// Quit the application gracefully. /// /// Native applications give handlers registered with [`Context::on_app_quit`] @@ -2041,6 +2052,12 @@ impl App { &self.background_executor } + /// Whether this app runs on the deterministic test scheduler. See + /// [`BackgroundExecutor::is_test`]. + pub fn is_test(&self) -> bool { + self.background_executor.is_test() + } + /// Obtains a reference to the executor, which can be used to spawn futures. pub fn foreground_executor(&self) -> &ForegroundExecutor { if self.quitting { diff --git a/crates/gpui/src/app/async_context.rs b/crates/gpui/src/app/async_context.rs index c3af6028be6..7190dff709b 100644 --- a/crates/gpui/src/app/async_context.rs +++ b/crates/gpui/src/app/async_context.rs @@ -160,6 +160,12 @@ impl AsyncApp { &self.background_executor } + /// Whether this app runs on the deterministic test scheduler. See + /// [`BackgroundExecutor::is_test`]. + pub fn is_test(&self) -> bool { + self.background_executor.is_test() + } + /// Get an executor which can be used to spawn futures in the foreground. pub fn foreground_executor(&self) -> &ForegroundExecutor { &self.foreground_executor diff --git a/crates/gpui/src/app/entity_map.rs b/crates/gpui/src/app/entity_map.rs index 4184503ba3a..38ba7604f77 100644 --- a/crates/gpui/src/app/entity_map.rs +++ b/crates/gpui/src/app/entity_map.rs @@ -21,7 +21,7 @@ use std::{ use super::Context; use crate::util::atomic_incr_if_not_zero; -#[cfg(any(test, feature = "leak-detection"))] +#[cfg(any(test, gpui_leak_detection))] use collections::HashMap; slotmap::new_key_type! { @@ -63,7 +63,7 @@ pub(crate) struct EntityMap { pub(crate) struct EntityRefCounts { counts: SlotMap, dropped_entity_ids: Vec, - #[cfg(any(test, feature = "leak-detection"))] + #[cfg(any(test, gpui_leak_detection))] leak_detector: LeakDetector, } @@ -79,7 +79,7 @@ impl EntityMap { ref_counts: Arc::new(RwLock::new(EntityRefCounts { counts: SlotMap::with_key(), dropped_entity_ids: Vec::new(), - #[cfg(any(test, feature = "leak-detection"))] + #[cfg(any(test, gpui_leak_detection))] leak_detector: LeakDetector { next_handle_id: 0, entity_handles: HashMap::default(), @@ -98,7 +98,7 @@ impl EntityMap { /// The returned [`LeakDetectorSnapshot`] can later be passed to /// [`assert_no_new_leaks`](Self::assert_no_new_leaks) to verify that no /// entities created after the snapshot are still alive. - #[cfg(any(test, feature = "leak-detection"))] + #[cfg(any(test, gpui_leak_detection))] pub fn leak_detector_snapshot(&self) -> LeakDetectorSnapshot { self.ref_counts.read().leak_detector.snapshot() } @@ -106,7 +106,7 @@ impl EntityMap { /// Asserts that no entities created after `snapshot` still have alive handles. /// /// See [`LeakDetector::assert_no_new_leaks`] for details. - #[cfg(any(test, feature = "leak-detection"))] + #[cfg(any(test, gpui_leak_detection))] pub fn assert_no_new_leaks(&self, snapshot: &LeakDetectorSnapshot) { self.ref_counts .read() @@ -268,7 +268,7 @@ pub struct AnyEntity { pub(crate) entity_id: EntityId, pub(crate) entity_type: TypeId, entity_map: Weak>, - #[cfg(any(test, feature = "leak-detection"))] + #[cfg(any(test, gpui_leak_detection))] handle_id: HandleId, } @@ -277,12 +277,12 @@ impl AnyEntity { id: EntityId, entity_type: TypeId, entity_map: Weak>, - #[cfg(any(test, feature = "leak-detection"))] type_name: &'static str, + #[cfg(any(test, gpui_leak_detection))] type_name: &'static str, ) -> Self { Self { entity_id: id, entity_type, - #[cfg(any(test, feature = "leak-detection"))] + #[cfg(any(test, gpui_leak_detection))] handle_id: entity_map .clone() .upgrade() @@ -345,7 +345,7 @@ impl Clone for AnyEntity { entity_id: self.entity_id, entity_type: self.entity_type, entity_map: self.entity_map.clone(), - #[cfg(any(test, feature = "leak-detection"))] + #[cfg(any(test, gpui_leak_detection))] handle_id: self .entity_map .upgrade() @@ -374,7 +374,7 @@ impl Drop for AnyEntity { } } - #[cfg(any(test, feature = "leak-detection"))] + #[cfg(any(test, gpui_leak_detection))] if let Some(entity_map) = self.entity_map.upgrade() { entity_map .write() @@ -452,7 +452,7 @@ impl Entity { id, TypeId::of::(), entity_map, - #[cfg(any(test, feature = "leak-detection"))] + #[cfg(any(test, gpui_leak_detection))] std::any::type_name::(), ), entity_type: PhantomData, @@ -626,7 +626,7 @@ impl AnyWeakEntity { entity_id: self.entity_id, entity_type: self.entity_type, entity_map: self.entity_ref_counts.clone(), - #[cfg(any(test, feature = "leak-detection"))] + #[cfg(any(test, gpui_leak_detection))] handle_id: self .entity_ref_counts .upgrade() @@ -652,11 +652,12 @@ impl AnyWeakEntity { /// /// # Debugging Leaks /// - /// If this method panics due to leaked handles, set the `LEAK_BACKTRACE` environment - /// variable to see where the leaked handles were allocated: + /// With leak detection enabled (build with `GPUI_LEAK_DETECTION=1`), a failure + /// lists each leaked handle. Also set the `LEAK_BACKTRACE` environment variable + /// to see where they were allocated: /// /// ```bash - /// LEAK_BACKTRACE=1 cargo test my_test + /// GPUI_LEAK_DETECTION=1 LEAK_BACKTRACE=1 cargo test my_test /// ``` /// /// # Panics @@ -664,8 +665,9 @@ impl AnyWeakEntity { /// - Panics if any strong handles to the entity are still alive. /// - Panics if the entity was recently dropped but cleanup hasn't completed yet /// (resources are retained until the end of the effect cycle). - #[cfg(any(test, feature = "leak-detection"))] + #[cfg(any(test, feature = "test-support", gpui_leak_detection))] pub fn assert_released(&self) { + #[cfg(any(test, gpui_leak_detection))] self.entity_ref_counts .upgrade() .unwrap() @@ -680,7 +682,9 @@ impl AnyWeakEntity { .is_some() { panic!( - "entity was recently dropped but resources are retained until the end of the effect cycle." + "entity is still alive, or was recently dropped and its resources are retained \ + until the end of the effect cycle. Build with GPUI_LEAK_DETECTION=1 to list \ + its live handles." ) } } @@ -890,7 +894,7 @@ impl PartialOrd for WeakEntity { /// /// Set the `LEAK_BACKTRACE` environment variable to any non-empty value to enable /// backtrace capture. This helps identify where leaked handles were allocated. -#[cfg(any(test, feature = "leak-detection"))] +#[cfg(any(test, gpui_leak_detection))] static LEAK_BACKTRACE: std::sync::LazyLock = std::sync::LazyLock::new(|| std::env::var("LEAK_BACKTRACE").is_ok_and(|b| !b.is_empty())); @@ -898,7 +902,7 @@ static LEAK_BACKTRACE: std::sync::LazyLock = /// /// This is distinct from `EntityId` - while multiple handles can point to the same /// entity (same `EntityId`), each handle has its own unique `HandleId`. -#[cfg(any(test, feature = "leak-detection"))] +#[cfg(any(test, gpui_leak_detection))] #[derive(Clone, Copy, Debug, Default, Hash, PartialEq, Eq)] pub(crate) struct HandleId { id: u64, @@ -953,7 +957,7 @@ pub(crate) struct HandleId { /// `WeakEntity::upgrade`), `handle_created` is called to register the handle. /// - When a handle is dropped, `handle_released` removes it from tracking. /// - `assert_released` verifies that no handles remain for a given entity. -#[cfg(any(test, feature = "leak-detection"))] +#[cfg(any(test, gpui_leak_detection))] pub(crate) struct LeakDetector { next_handle_id: u64, entity_handles: HashMap, @@ -964,18 +968,20 @@ pub(crate) struct LeakDetector { /// Created by [`LeakDetector::snapshot`]. Can later be passed to /// [`LeakDetector::assert_no_new_leaks`] to verify that no new entity /// handles remain between the snapshot and the current state. -#[cfg(any(test, feature = "leak-detection"))] +#[cfg(any(test, feature = "test-support", gpui_leak_detection))] +#[derive(Default)] pub struct LeakDetectorSnapshot { + #[cfg(any(test, gpui_leak_detection))] entity_ids: collections::HashSet, } -#[cfg(any(test, feature = "leak-detection"))] +#[cfg(any(test, gpui_leak_detection))] struct EntityLeakData { handles: HashMap>, type_name: &'static str, } -#[cfg(any(test, feature = "leak-detection"))] +#[cfg(any(test, gpui_leak_detection))] impl LeakDetector { /// Records that a new handle has been created for the given entity. /// @@ -1106,7 +1112,7 @@ impl LeakDetector { } } -#[cfg(any(test, feature = "leak-detection"))] +#[cfg(any(test, gpui_leak_detection))] impl Drop for LeakDetector { fn drop(&mut self) { use std::fmt::Write; @@ -1141,10 +1147,10 @@ impl Drop for LeakDetector { } } -#[cfg(any(test, feature = "leak-detection"))] +#[cfg(any(test, gpui_leak_detection))] struct BacktraceFormatter(backtrace::Backtrace); -#[cfg(any(test, feature = "leak-detection"))] +#[cfg(any(test, gpui_leak_detection))] impl fmt::Debug for BacktraceFormatter { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { use backtrace::{BacktraceFmt, BytesOrWideString, PrintFmt}; diff --git a/crates/gpui/src/executor.rs b/crates/gpui/src/executor.rs index b4348e940d0..78928d0f541 100644 --- a/crates/gpui/src/executor.rs +++ b/crates/gpui/src/executor.rs @@ -281,6 +281,15 @@ impl BackgroundExecutor { self.dispatcher.is_main_thread() } + /// Whether this executor runs on the deterministic test scheduler. + /// + /// Available in every build. Use it, rather than `cfg(feature = + /// "test-support")`, for behavior that must differ under tests, so that + /// compiling `test-support` into an application doesn't change it. + pub fn is_test(&self) -> bool { + self.inner.is_test() + } + #[doc(hidden)] pub fn dispatcher(&self) -> &Arc { &self.dispatcher diff --git a/crates/gpui_apple/src/metal_renderer.rs b/crates/gpui_apple/src/metal_renderer.rs index df6b17a9b0a..a2a78ed3033 100644 --- a/crates/gpui_apple/src/metal_renderer.rs +++ b/crates/gpui_apple/src/metal_renderer.rs @@ -180,8 +180,10 @@ impl MetalRenderer { // https://developer.apple.com/documentation/metal/managing-your-game-window-for-metal-in-macos layer.set_opaque(!transparent); layer.set_maximum_drawable_count(3); - // Allow texture reading for visual tests (captures screenshots without ScreenCaptureKit) - #[cfg(any(test, feature = "test-support"))] + // Allow texture reading for visual tests and UI automation screenshots + // (captures without ScreenCaptureKit). Only debug builds pay the + // presentation cost, even when `test-support` is compiled in. + #[cfg(all(feature = "test-support", debug_assertions))] layer.set_framebuffer_only(false); // metal-rs doesn't bind these setters, so view the same object through // objc2's typed CAMetalLayer binding. diff --git a/crates/scheduler/src/executor.rs b/crates/scheduler/src/executor.rs index ad2ea929dc1..7e684d0b427 100644 --- a/crates/scheduler/src/executor.rs +++ b/crates/scheduler/src/executor.rs @@ -59,6 +59,11 @@ impl LocalExecutor { &self.scheduler } + /// Whether this executor runs on a [`TestScheduler`](crate::TestScheduler). + pub fn is_test(&self) -> bool { + self.scheduler.as_test().is_some() + } + #[track_caller] pub fn spawn(&self, future: F) -> Task where @@ -290,6 +295,11 @@ impl BackgroundExecutor { &self.scheduler } + /// Whether this executor runs on a [`TestScheduler`](crate::TestScheduler). + pub fn is_test(&self) -> bool { + self.scheduler.as_test().is_some() + } + /// Spawn a closure on a fresh session pinned to its own [`LocalExecutor`]. /// The closure runs on a new OS thread under `PlatformScheduler`, or on /// the test scheduler's loop under `TestScheduler`. diff --git a/crates/scheduler/src/scheduler.rs b/crates/scheduler/src/scheduler.rs index 325ec7b2b57..6f83a6a139d 100644 --- a/crates/scheduler/src/scheduler.rs +++ b/crates/scheduler/src/scheduler.rs @@ -8,6 +8,20 @@ pub use clock::*; pub use executor::*; pub use test_scheduler::*; +static TEST_SCHEDULER_CREATED: std::sync::atomic::AtomicBool = + std::sync::atomic::AtomicBool::new(false); + +/// Whether this process has created a [`TestScheduler`]. +/// +/// Test harnesses create one before the test body runs, and applications never +/// do. Code with no executor at hand, such as expensive data-structure invariant +/// checks, can use this to run only in test processes. Code that has an +/// executor should prefer [`BackgroundExecutor::is_test`], which is correct per +/// executor. +pub fn test_scheduler_created() -> bool { + TEST_SCHEDULER_CREATED.load(std::sync::atomic::Ordering::Relaxed) +} + use async_task::Runnable; use futures::channel::oneshot; use std::{ diff --git a/crates/scheduler/src/test_scheduler.rs b/crates/scheduler/src/test_scheduler.rs index bd342037b9c..45cbc0b83df 100644 --- a/crates/scheduler/src/test_scheduler.rs +++ b/crates/scheduler/src/test_scheduler.rs @@ -159,6 +159,7 @@ impl TestScheduler { } pub fn new(config: TestSchedulerConfig) -> Self { + crate::TEST_SCHEDULER_CREATED.store(true, std::sync::atomic::Ordering::Relaxed); Self { rng: Arc::new(Mutex::new(StdRng::seed_from_u64(config.seed))), state: Arc::new(Mutex::new(SchedulerState { diff --git a/crates/util/src/paths.rs b/crates/util/src/paths.rs index 42133b3df3e..90ce3f86150 100644 --- a/crates/util/src/paths.rs +++ b/crates/util/src/paths.rs @@ -20,11 +20,14 @@ use path::rel_path::RelPathBuf; pub use path::PathStyle; /// Returns the path to the user's home directory. +/// +/// This crate's own tests see a fixed fake path. Every other build, including +/// builds with `test-support`, sees the real home directory. #[cfg(not(target_family = "wasm"))] pub fn home_dir() -> &'static PathBuf { static HOME_DIR: std::sync::OnceLock = std::sync::OnceLock::new(); HOME_DIR.get_or_init(|| { - if cfg!(any(test, feature = "test-support")) { + if cfg!(test) { if cfg!(target_os = "macos") { PathBuf::from("/Users/zed") } else if cfg!(target_os = "windows") {