// Tests for the `blocking_io_on_foreground` lint. #![allow(unused, let_underscore_lock)] extern crate gpui; use gpui::*; struct Editor; // ============================================================// SHOULD WARN — blocking IO in functions with GPUI context params// ============================================================ // --- std::fs free functions --- fn read_config_with_app(cx: &mut App) {    let _ = std::fs::read_to_string("config.toml");} fn write_file_with_app(cx: &App) {    let _ = std::fs::write("out.txt", b"data");} fn read_with_window(window: &mut Window, cx: &mut App) {    let _ = std::fs::read("data.bin");} fn metadata_with_app(cx: &mut App) {    let _ = std::fs::metadata("file.txt");} fn create_dir_with_app(cx: &mut App) {    let _ = std::fs::create_dir_all("some/path");} fn remove_file_with_app(cx: &mut App) {    let _ = std::fs::remove_file("old.txt");} fn canonicalize_with_app(cx: &mut App) {    let _ = std::fs::canonicalize("./relative");} fn read_dir_with_app(cx: &mut App) {    let _ = std::fs::read_dir("some/dir");} fn read_link_with_app(cx: &mut App) {    let _ = std::fs::read_link("some/link");} fn symlink_metadata_with_app(cx: &mut App) {    let _ = std::fs::symlink_metadata("file.txt");} fn set_permissions_with_app(cx: &mut App) {    if let Ok(meta) = std::fs::metadata("file.txt") {        let _ = std::fs::set_permissions("file.txt", meta.permissions());    }} fn copy_with_app(cx: &mut App) {    let _ = std::fs::copy("a.txt", "b.txt");} fn rename_with_app(cx: &mut App) {    let _ = std::fs::rename("old.txt", "new.txt");} fn hard_link_with_app(cx: &mut App) {    let _ = std::fs::hard_link("original", "link");} fn create_dir_with_app_single(cx: &mut App) {    let _ = std::fs::create_dir("one_dir");} fn remove_dir_with_app(cx: &mut App) {    let _ = std::fs::remove_dir("empty_dir");} fn remove_dir_all_with_app(cx: &mut App) {    let _ = std::fs::remove_dir_all("dir_tree");} // --- std::fs::File associated functions --- fn file_open_with_app(cx: &mut App) {    let _ = std::fs::File::open("data.bin");} fn file_create_with_app(cx: &mut App) {    let _ = std::fs::File::create("out.bin");} fn file_create_new_with_app(cx: &mut App) {    let _ = std::fs::File::create_new("new.bin");} // --- std::fs::File instance methods --- fn file_sync_all_with_app(cx: &mut App) {    if let Ok(f) = std::fs::File::open("x") {        let _ = f.sync_all();    }} fn file_sync_data_with_app(cx: &mut App) {    if let Ok(f) = std::fs::File::open("x") {        let _ = f.sync_data();    }} fn file_set_len_with_app(cx: &mut App) {    if let Ok(f) = std::fs::File::open("x") {        let _ = f.set_len(0);    }} fn file_metadata_with_app(cx: &mut App) {    if let Ok(f) = std::fs::File::open("x") {        let _ = f.metadata();    }} fn file_try_clone_with_app(cx: &mut App) {    if let Ok(f) = std::fs::File::open("x") {        let _ = f.try_clone();    }} // --- std::thread --- fn sleep_with_context(cx: &mut Context<'_, Editor>) {    std::thread::sleep(std::time::Duration::from_millis(100));} // --- std::path::Path methods --- fn path_metadata_with_app(cx: &mut App) {    let _ = std::path::Path::new("file.txt").metadata();} fn path_symlink_metadata_with_app(cx: &mut App) {    let _ = std::path::Path::new("link").symlink_metadata();} fn path_read_link_with_app(cx: &mut App) {    let _ = std::path::Path::new("link").read_link();} fn path_read_dir_with_app(cx: &mut App) {    let _ = std::path::Path::new("dir").read_dir();} fn path_exists_with_app(cx: &mut App) {    let _ = std::path::Path::new("file.txt").exists();} fn path_try_exists_with_app(cx: &mut App) {    let _ = std::path::Path::new("file.txt").try_exists();} fn path_is_file_with_app(cx: &mut App) {    let _ = std::path::Path::new("file.txt").is_file();} fn path_is_dir_with_app(cx: &mut App) {    let _ = std::path::Path::new("dir").is_dir();} fn path_is_symlink_with_app(cx: &mut App) {    let _ = std::path::Path::new("link").is_symlink();} fn path_canonicalize_with_app(cx: &mut App) {    let _ = std::path::Path::new("./relative").canonicalize();} // PathBuf derefs to Path, so the same methods fire.fn pathbuf_exists_with_app(cx: &mut App) {    let _ = std::path::PathBuf::from("file.txt").exists();} // --- std::net --- fn tcp_listener_bind_with_app(cx: &mut App) {    let _ = std::net::TcpListener::bind("127.0.0.1:0");} fn tcp_stream_connect_with_app(cx: &mut App) {    let _ = std::net::TcpStream::connect("127.0.0.1:80");} fn tcp_stream_connect_timeout_with_app(cx: &mut App) {    let addr = std::net::SocketAddr::from(([127, 0, 0, 1], 80));    let _ = std::net::TcpStream::connect_timeout(&addr, std::time::Duration::from_secs(1));} fn tcp_listener_accept_with_app(cx: &mut App) {    if let Ok(listener) = std::net::TcpListener::bind("127.0.0.1:0") {        let _ = listener.accept();    }} fn udp_socket_bind_with_app(cx: &mut App) {    let _ = std::net::UdpSocket::bind("127.0.0.1:0");} fn udp_socket_send_recv_with_app(cx: &mut App) {    if let Ok(socket) = std::net::UdpSocket::bind("127.0.0.1:0") {        let mut buf = [0u8; 64];        let _ = socket.recv_from(&mut buf);    }} // --- std::process --- fn command_output_with_app(cx: &mut App) {    let _ = std::process::Command::new("echo").output();} fn command_status_with_app(cx: &mut App) {    let _ = std::process::Command::new("echo").status();} fn command_spawn_with_app(cx: &mut App) {    let _ = std::process::Command::new("echo").spawn();} fn child_wait_with_app(cx: &mut App) {    if let Ok(mut child) = std::process::Command::new("echo").spawn() {        let _ = child.wait();    }} fn child_wait_with_output_with_app(cx: &mut App) {    if let Ok(child) = std::process::Command::new("echo").spawn() {        let _ = child.wait_with_output();    }} // --- std::sync --- fn mutex_lock_with_app(cx: &mut App) {    let m = std::sync::Mutex::new(42);    let _ = m.lock();} fn rwlock_read_with_app(cx: &mut App) {    let rw = std::sync::RwLock::new(42);    let _ = rw.read();} fn rwlock_write_with_app(cx: &mut App) {    let rw = std::sync::RwLock::new(42);    let _ = rw.write();} fn barrier_wait_with_app(cx: &mut App) {    let b = std::sync::Barrier::new(1);    b.wait();} fn receiver_recv_with_app(cx: &mut App) {    let (_tx, rx) = std::sync::mpsc::channel::<i32>();    let _ = rx.recv();} fn sync_sender_send_with_app(cx: &mut App) {    let (tx, _rx) = std::sync::mpsc::sync_channel::<i32>(1);    let _ = tx.send(42);} // --- Render impl --- struct BlockingRenderView; impl Render for BlockingRenderView {    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {        let _ = std::fs::read_to_string("layout.toml");        ()    }} // ============================================================// SHOULD NOT WARN — no GPUI context, or inside closure// ============================================================ // Plain function with no GPUI parameter.fn load_config_plain() -> String {    std::fs::read_to_string("config.toml").unwrap_or_default()} // Blocking IO inside a closure (could be passed to background_spawn).fn setup_with_closure(cx: &mut App) {    let _handler = || {        let _ = std::fs::read_to_string("config.toml");    };} // Blocking IO in a function with no GPUI types at all.fn standalone_sleep() {    std::thread::sleep(std::time::Duration::from_millis(10));} // Path methods with no GPUI parameter.fn path_exists_plain() -> bool {    std::path::Path::new("file.txt").exists()} // Net calls with no GPUI parameter.fn tcp_bind_plain() {    let _ = std::net::TcpListener::bind("127.0.0.1:0");} // Mutex lock with no GPUI parameter.fn mutex_lock_plain() {    let m = std::sync::Mutex::new(0);    let _ = m.lock();} fn main() {}