Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Add dylint lint library for Zed-specific patterns (#58496)
Miguel Raz Guzmán Macedo4b7369481dcf
diff --git a/.agents/skills/lint-creator/SKILL.md b/.agents/skills/lint-creator/SKILL.mdnew file mode 100644index 00000000000..e72e83a9aba--- /dev/null+++ b/.agents/skills/lint-creator/SKILL.md@@ -0,0 +1,17 @@+---+name: lint-creator+description: An auxiliary skill to add more dylints to `tooling/lints`+disable-model-invocation: false+---++# Lint RULES++1. Every lint MUST have accompanying `ui` tests+2. `ui` tests MUST be in the `ui` folder+3. Every lint MUST be in a separate module+4. Every lint MUST have negative `ui` tests+5. Lints should be as simple as possible.+6. Reporting is fine if it's simple, it does not need to be elaborate or lengthy code.+7. Do NOT suggest how to fix the lint, only flag it.+8. Do NOT make lints machine applicable.+9. Detect if lints are redundant vs clippy's capabilities.diff --git a/Cargo.toml b/Cargo.tomlindex 5e7703aaaee..2adf179e513 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -1070,3 +1070,10 @@ ignored = ["documented","sea-orm-macros",]++# Dylint discovers our custom lints through this entry, so `cargo dylint --all`+# runs them without a `--path` argument. The `lints` package pins its own+# nightly toolchain (see `tooling/lints/rust-toolchain.toml`) and is kept out of+# this workspace on purpose.+[workspace.metadata.dylint]+libraries = [{ path = "tooling/lints" }]diff --git a/tooling/lints/.cargo/config.toml b/tooling/lints/.cargo/config.tomlnew file mode 100644index 00000000000..93dceb69922--- /dev/null+++ b/tooling/lints/.cargo/config.toml@@ -0,0 +1,2 @@+[target.'cfg(all())']+linker = "dylint-link"diff --git a/tooling/lints/.gitignore b/tooling/lints/.gitignorenew file mode 100644index 00000000000..26b452057c5--- /dev/null+++ b/tooling/lints/.gitignore@@ -0,0 +1,4 @@+/target/+/test_fixture/target/+Cargo.lock+test_fixture/Cargo.lockdiff --git a/tooling/lints/Cargo.toml b/tooling/lints/Cargo.tomlnew file mode 100644index 00000000000..d70050bfa61--- /dev/null+++ b/tooling/lints/Cargo.toml@@ -0,0 +1,29 @@+[package]+name = "lints"+version = "0.1.0"+edition = "2024"+publish = false+description = "Dylint lints for catching bad Zed specific patterns."++[lib]+crate-type = ["cdylib"]++[dependencies]+clippy_utils = { git = "https://github.com/rust-lang/rust-clippy", rev = "86390a3c03438b660c5efc64d4e18ae65982f5c0" }+dylint_linting = "6.0"++[dev-dependencies]+# `deny_warnings` restores `-D warnings` for the UI fixtures (off by default+# since dylint 3.0), so toolchain drift surfaces as a failing test.+dylint_testing = { version = "6.0", features = ["deny_warnings"] }++[package.metadata.rust-analyzer]+rustc_private = true++# Keep this crate out of the zed workspace. It pins its own nightly toolchain+# (see `rust-toolchain.toml`) to match `clippy_utils`.+[workspace]++[lints.rust.unexpected_cfgs]+level = "warn"+check-cfg = ["cfg(dylint_lib, values(any()))"]diff --git a/tooling/lints/README.md b/tooling/lints/README.mdnew file mode 100644index 00000000000..6804a2e9093--- /dev/null+++ b/tooling/lints/README.md@@ -0,0 +1,86 @@+# lints++A [dylint](https://github.com/trailofbits/dylint) library that flags various bad patterns in our codebase.++Install `dylint`, a pinned nightly toolchain and the necessary tools with++```+cargo install cargo-dylint dylint-link+cd tooling/lints+rustup toolchain install+```++The channel and its components (`rustc-dev`, `rust-src`, `llvm-tools-preview`)+are declared in `tooling/lints/rust-toolchain.toml`, so `rustup toolchain install`+picks them up automatically when run from that directory.++# Demo++```+./single-lint blocking_io_on_foreground+```+++## Current lints+- `shared_string_from_str_literal` — `SharedString::new/from` etc where `SharedString::from_static` should be used instead.+- `async_block_without_await` — `async { … }` blocks whose body contains no `.await` expression.+- `entity_update_in_render` — `Entity::update`/`WeakEntity::update` mutating an entity inside `Render::render`.+- `notify_in_render` — `Context::notify()` called inside `Render::render`.+- `owned_string_into_shared` — `String::from(<lit>).into()` / `<lit>.to_string().into()` / `<lit>.to_owned().into()` whose target is `SharedString`, `Arc<str>`, `Rc<str>`, or `Cow<'_, str>`.+- `blocking_io_on_foreground` - Catch blocking IO calls that are called on the main thread (but not on closures or background threads)++## How to run++Ideally you run this as part of the `clippy` script in the `zed/scripts` directory since this will also run our other linters.++### Prerequisites++Install both tools (version 6 or later):++```+cargo install cargo-dylint dylint-link+```++- `cargo-dylint` is the `cargo` subcommand that builds and runs the lints; `dylint-link` is the linker used to build the lint library.++The workspace registers this library under `[workspace.metadata.dylint]` in the+root `Cargo.toml`, so Dylint discovers it automatically — you do not pass a+`--path`. The first run builds the library against its pinned nightly (see+`rust-toolchain.toml`) and is slow; later runs are cached.++### Run all lints against the whole repo++```+cargo dylint --all -- --workspace+```++### Run all lints against a single crate++```+cargo dylint --all -- -p project_panel+```++### Run a single lint++The library loads every lint at once. To run just one, use the `single-lint`+helper, which silences the rest and force-enables the one you name:++```+tooling/lints/single-lint blocking_io_on_foreground -p project_panel+```++The first argument is the lint name (one of the snake_case identifiers under+[Current lints](#current-lints)); everything after it is passed to `cargo check`+and defaults to `--workspace`. Under the hood the script runs:++```+DYLINT_RUSTFLAGS="-A warnings --force-warn <lint>" cargo dylint --all -- <args>+```++It also handles two non-obvious gotchas:++- `--force-warn` is required: after `-A warnings` silences the group, a plain+ `-W <lint>` does not reliably re-enable a driver-registered lint.+- `DYLINT_RUSTFLAGS` is not part of Cargo's fingerprint, so the script cleans the+ targeted package(s) first; otherwise Cargo replays a stale cache and the filter+ appears to do nothing.diff --git a/tooling/lints/rust-toolchain.toml b/tooling/lints/rust-toolchain.tomlnew file mode 100644index 00000000000..0ba86155420--- /dev/null+++ b/tooling/lints/rust-toolchain.toml@@ -0,0 +1,3 @@+[toolchain]+channel = "nightly-2026-03-21"+components = ["llvm-tools-preview", "rustc-dev", "rust-src"]diff --git a/tooling/lints/single-lint b/tooling/lints/single-lintnew file mode 100755index 00000000000..e481cf91bc6--- /dev/null+++ b/tooling/lints/single-lint@@ -0,0 +1,64 @@+#!/usr/bin/env bash+#+# Run a single lint from this dylint library against the Zed workspace.+#+# Usage: tooling/lints/single-lint <lint_name> [cargo check args...]+# Example: tooling/lints/single-lint blocking_io_on_foreground -p project_panel+#+# Dylint loads the whole library, so we silence every lint with `-A warnings`+# and force just the requested one back on with `--force-warn`. A plain+# `-W <lint>` is dropped for a driver-registered lint once the group is allowed,+# which is why `--force-warn` is required.+#+# `DYLINT_RUSTFLAGS` is not part of Cargo's fingerprint, so changing it does not+# invalidate already-checked crates. We therefore clean the targeted package(s)+# first so the filter actually applies instead of replaying a stale cache. When+# no package is named (a `--workspace` run) we drop the whole check cache.+set -euo pipefail++if [ "$#" -lt 1 ]; then+ echo "usage: $(basename "$0") <lint_name> [cargo check args...]" >&2+ exit 1+fi++lint="$1"+shift+if [ "$#" -eq 0 ]; then+ set -- --workspace+fi++script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"+repo_root="$(cd "$script_dir/../.." && pwd)"++toolchain="$(awk -F'"' '/^channel/ {print $2}' "$script_dir/rust-toolchain.toml")"+host="$(rustc -vV | awk '/^host:/ {print $2}')"+check_target="$repo_root/target/dylint/target/${toolchain}-${host}"++# Force a re-check of the requested package(s) so the lint filter takes effect.+cleaned_any=0+prev=""+for arg in "$@"; do+ pkg=""+ case "$arg" in+ -p=* | --package=*)+ pkg="${arg#*=}"+ ;;+ *)+ if [ "$prev" = "-p" ] || [ "$prev" = "--package" ]; then+ pkg="$arg"+ fi+ ;;+ esac+ if [ -n "$pkg" ]; then+ cargo clean -p "$pkg" --target-dir "$check_target" 2>/dev/null || true+ cleaned_any=1+ fi+ prev="$arg"+done++if [ "$cleaned_any" -eq 0 ]; then+ rm -rf "$check_target"+fi++cd "$repo_root"+DYLINT_RUSTFLAGS="-A warnings --force-warn $lint" exec cargo dylint --all -- "$@"diff --git a/tooling/lints/src/blocking_io_on_foreground.rs b/tooling/lints/src/blocking_io_on_foreground.rsnew file mode 100644index 00000000000..d8d7fe16e91--- /dev/null+++ b/tooling/lints/src/blocking_io_on_foreground.rs@@ -0,0 +1,246 @@+use clippy_utils::diagnostics::span_lint;+use rustc_hir::def::Res;+use rustc_hir::{Expr, ExprKind, HirId, Node};+use rustc_lint::{LateContext, LateLintPass};+use rustc_middle::ty::Ty;++use crate::render_helpers::is_directly_in_render_method;++rustc_session::declare_lint! {+ /// ### What it does+ ///+ /// Flags calls to known blocking IO functions from the standard library+ /// (`std::fs`, `std::thread::sleep`, `std::process::Command`, `std::net`)+ /// when they appear inside a function that receives a synchronous GPUI+ /// context parameter (`&App`, `&mut App`, `&Context<T>`,+ /// `&mut Context<T>`, `&mut Window`) or directly inside a+ /// `Render::render` / `RenderOnce::render` method.+ ///+ /// ### Why is this bad?+ ///+ /// In GPUI, code that receives a synchronous context type runs on the+ /// foreground (UI) thread. A blocking IO call on this thread freezes the+ /// application until the syscall returns.+ pub BLOCKING_IO_ON_FOREGROUND,+ Warn,+ "blocking IO call on the GPUI foreground thread"+}++pub(crate) struct BlockingIoOnForeground;++rustc_session::impl_lint_pass!(BlockingIoOnForeground => [BLOCKING_IO_ON_FOREGROUND]);++const BLOCKING_FN_PATHS: &[&str] = &[+ // std::fs free functions+ "std::fs::read",+ "std::fs::read_to_string",+ "std::fs::write",+ "std::fs::read_dir",+ "std::fs::read_link",+ "std::fs::metadata",+ "std::fs::symlink_metadata",+ "std::fs::set_permissions",+ "std::fs::canonicalize",+ "std::fs::create_dir",+ "std::fs::create_dir_all",+ "std::fs::remove_file",+ "std::fs::remove_dir",+ "std::fs::remove_dir_all",+ "std::fs::copy",+ "std::fs::rename",+ "std::fs::hard_link",+ // std::fs::File associated functions+ "std::fs::File::open",+ "std::fs::File::create",+ "std::fs::File::create_new",+ // std::thread+ "std::thread::sleep",+ // std::path::Path methods (resolved via method call def_id)+ "std::path::Path::metadata",+ "std::path::Path::symlink_metadata",+ "std::path::Path::read_link",+ "std::path::Path::read_dir",+ "std::path::Path::exists",+ "std::path::Path::try_exists",+ "std::path::Path::is_file",+ "std::path::Path::is_dir",+ "std::path::Path::is_symlink",+ "std::path::Path::canonicalize",+ // std::net associated functions+ "std::net::TcpStream::connect",+ "std::net::TcpStream::connect_timeout",+ "std::net::TcpListener::bind",+ "std::net::UdpSocket::bind",+];++const BLOCKING_METHODS: &[(&str, &str)] = &[+ // std::process+ ("Command", "output"),+ ("Command", "status"),+ ("Command", "spawn"),+ ("Child", "wait"),+ ("Child", "wait_with_output"),+ // std::fs::File instance methods+ ("File", "sync_all"),+ ("File", "sync_data"),+ ("File", "set_len"),+ ("File", "metadata"),+ ("File", "try_clone"),+ ("File", "set_permissions"),+ // std::net — TCP+ ("TcpStream", "connect"),+ ("TcpStream", "peek"),+ ("TcpListener", "bind"),+ ("TcpListener", "accept"),+ ("TcpListener", "incoming"),+ // std::net — UDP+ ("UdpSocket", "send"),+ ("UdpSocket", "send_to"),+ ("UdpSocket", "recv"),+ ("UdpSocket", "recv_from"),+ ("UdpSocket", "peek"),+ ("UdpSocket", "peek_from"),+ // std::sync+ ("Mutex", "lock"),+ ("RwLock", "read"),+ ("RwLock", "write"),+ ("Condvar", "wait"),+ ("Condvar", "wait_timeout"),+ ("Condvar", "wait_while"),+ ("Barrier", "wait"),+ // std::sync::mpsc+ ("Receiver", "recv"),+ ("Receiver", "recv_timeout"),+ ("SyncSender", "send"),+];++fn is_blocking_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {+ match &expr.kind {+ ExprKind::Call(callee, _) => {+ if let ExprKind::Path(qpath) = &callee.kind {+ if let Res::Def(_, def_id) = cx.qpath_res(qpath, callee.hir_id) {+ let path = cx.tcx.def_path_str(def_id);+ return BLOCKING_FN_PATHS.iter().any(|blocked| path == *blocked);+ }+ }+ false+ }+ ExprKind::MethodCall(segment, receiver, _args, _span) => {+ if let Some(def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) {+ let path = cx.tcx.def_path_str(def_id);+ if BLOCKING_FN_PATHS.iter().any(|blocked| path == *blocked) {+ return true;+ }+ }+ let method_name = segment.ident.name.as_str();+ if !BLOCKING_METHODS+ .iter()+ .any(|(_, name)| *name == method_name)+ {+ return false;+ }+ let receiver_ty = cx.typeck_results().expr_ty(receiver).peel_refs();+ if let Some(adt) = receiver_ty.ty_adt_def() {+ let type_name = cx.tcx.item_name(adt.did());+ return BLOCKING_METHODS+ .iter()+ .any(|(ty, name)| *name == method_name && type_name.as_str() == *ty);+ }+ false+ }+ _ => false,+ }+}++/// Returns `true` if `ty` (after peeling references) is a synchronous GPUI+/// foreground type: `App`, `Context`, or `Window`.+fn is_gpui_foreground_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {+ let peeled = ty.peel_refs();+ let Some(adt) = peeled.ty_adt_def() else {+ return false;+ };+ let did = adt.did();+ let crate_name = cx.tcx.crate_name(did.krate);+ if crate_name.as_str() != "gpui" {+ return false;+ }+ let name = cx.tcx.item_name(did);+ matches!(name.as_str(), "App" | "Context" | "Window")+}++/// Walks up the HIR parent chain from `hir_id` to find the enclosing+/// function. Returns `true` if that function has a parameter whose type is a+/// synchronous GPUI context type. Returns `false` if a closure boundary is+/// crossed first (the closure might run on a background thread).+fn is_in_foreground_fn(cx: &LateContext<'_>, hir_id: HirId) -> bool {+ for (_parent_id, node) in cx.tcx.hir_parent_iter(hir_id) {+ match node {+ Node::Expr(expr) if matches!(expr.kind, ExprKind::Closure(_)) => {+ return false;+ }+ Node::Item(item) => {+ if let rustc_hir::ItemKind::Fn { .. } = &item.kind {+ let owner_id = item.owner_id.def_id;+ return owner_has_foreground_param(cx, owner_id);+ }+ return false;+ }+ Node::ImplItem(impl_item) => {+ if let rustc_hir::ImplItemKind::Fn(_, _) = &impl_item.kind {+ let owner_id = impl_item.owner_id.def_id;+ return owner_has_foreground_param(cx, owner_id);+ }+ return false;+ }+ Node::TraitItem(trait_item) => {+ if let rustc_hir::TraitItemKind::Fn(_, _) = &trait_item.kind {+ let owner_id = trait_item.owner_id.def_id;+ return owner_has_foreground_param(cx, owner_id);+ }+ return false;+ }+ _ => {}+ }+ }+ false+}++/// Checks whether the function identified by `local_def_id` has any parameter+/// whose type is a synchronous GPUI foreground type.+fn owner_has_foreground_param(+ cx: &LateContext<'_>,+ local_def_id: rustc_hir::def_id::LocalDefId,+) -> bool {+ let def_id = local_def_id.to_def_id();+ let sig = cx.tcx.fn_sig(def_id).instantiate_identity();+ sig.inputs()+ .skip_binder()+ .iter()+ .any(|ty| is_gpui_foreground_type(cx, *ty))+}++impl<'tcx> LateLintPass<'tcx> for BlockingIoOnForeground {+ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {+ if expr.span.from_expansion() {+ return;+ }++ if !is_blocking_call(cx, expr) {+ return;+ }++ let in_render = is_directly_in_render_method(cx, expr.hir_id);+ let in_foreground_fn = is_in_foreground_fn(cx, expr.hir_id);++ if !in_render && !in_foreground_fn {+ return;+ }++ span_lint(+ cx,+ BLOCKING_IO_ON_FOREGROUND,+ expr.span,+ "blocking IO call on the GPUI foreground thread",+ );+ }+}diff --git a/tooling/lints/src/entity_update_in_render.rs b/tooling/lints/src/entity_update_in_render.rsnew file mode 100644index 00000000000..fc17f3de2be--- /dev/null+++ b/tooling/lints/src/entity_update_in_render.rs@@ -0,0 +1,66 @@+use clippy_utils::diagnostics::span_lint;+use rustc_hir::{Expr, ExprKind};+use rustc_lint::{LateContext, LateLintPass};++use crate::render_helpers::{+ is_directly_in_render_method, is_gpui_entity_or_weak, is_unit_or_result_unit,+};++rustc_session::declare_lint! {+ /// ### What it does+ ///+ /// Flags calls to `Entity::update` or `WeakEntity::update` that execute+ /// synchronously inside a `Render::render` or `RenderOnce::render` method+ /// and whose closure returns `()` (indicating mutation rather than reading).+ ///+ /// ### Why is this bad?+ ///+ /// The `render` method should be a pure function of state. Calling+ /// `.update()` mutates an entity during the render pass, which can trigger+ /// re-renders mid-render and lead to inconsistent UI state or infinite+ /// render loops.+ pub ENTITY_UPDATE_IN_RENDER,+ Warn,+ "mutating an entity via `.update()` during render"+}++pub(crate) struct EntityUpdateInRender;++rustc_session::impl_lint_pass!(EntityUpdateInRender => [ENTITY_UPDATE_IN_RENDER]);++impl<'tcx> LateLintPass<'tcx> for EntityUpdateInRender {+ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {+ if expr.span.from_expansion() {+ return;+ }++ let ExprKind::MethodCall(segment, receiver, _args, _span) = &expr.kind else {+ return;+ };++ if segment.ident.name.as_str() != "update" {+ return;+ }++ let receiver_ty = cx.typeck_results().expr_ty(receiver);+ if !is_gpui_entity_or_weak(cx, receiver_ty) {+ return;+ }++ let call_ty = cx.typeck_results().expr_ty(expr);+ if !is_unit_or_result_unit(cx, call_ty) {+ return;+ }++ if !is_directly_in_render_method(cx, expr.hir_id) {+ return;+ }++ span_lint(+ cx,+ ENTITY_UPDATE_IN_RENDER,+ expr.span,+ "entity `.update()` called during render mutates state in the render pass",+ );+ }+}diff --git a/tooling/lints/src/lib.rs b/tooling/lints/src/lib.rsnew file mode 100644index 00000000000..bf4289673dd--- /dev/null+++ b/tooling/lints/src/lib.rs@@ -0,0 +1,565 @@+#![feature(rustc_private)]+#![warn(unused_extern_crates)]++extern crate rustc_ast;+extern crate rustc_errors;+extern crate rustc_hir;+extern crate rustc_lint;+extern crate rustc_middle;+extern crate rustc_session;+extern crate rustc_span;++use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};+use clippy_utils::is_def_id_trait_method;+use clippy_utils::source::snippet_opt;+use rustc_ast::ast::LitKind;+use rustc_errors::Applicability;+use rustc_hir::def::{DefKind, Res};+use rustc_hir::def_id::DefId;+use rustc_hir::intravisit::{Visitor, walk_expr};+use rustc_hir::{+ Closure, ClosureKind, CoroutineDesugaring, CoroutineKind, CoroutineSource, Expr, ExprKind,+ YieldSource,+};+use rustc_lint::{LateContext, LateLintPass};+use rustc_middle::hir::nested_filter;+use rustc_middle::ty::Ty;+use rustc_span::Span;++mod blocking_io_on_foreground;+mod entity_update_in_render;+mod notify_in_render;+mod owned_string_into_shared;+mod render_helpers;++use blocking_io_on_foreground::BLOCKING_IO_ON_FOREGROUND;+use entity_update_in_render::ENTITY_UPDATE_IN_RENDER;+use notify_in_render::NOTIFY_IN_RENDER;+use owned_string_into_shared::OWNED_STRING_INTO_SHARED;++// ---------------------------------------------------------------------------+// Boilerplate: export the dylint ABI version symbol.+// ---------------------------------------------------------------------------+dylint_linting::dylint_library!();++// ---------------------------------------------------------------------------+// Registration: a single entry point that hands both lints to the compiler.+// ---------------------------------------------------------------------------+#[allow(clippy::no_mangle_with_rust_abi)]+#[unsafe(no_mangle)]+pub fn register_lints(sess: &rustc_session::Session, lint_store: &mut rustc_lint::LintStore) {+ dylint_linting::init_config(sess);+ lint_store.register_lints(&[+ SHARED_STRING_FROM_STR_LITERAL,+ ASYNC_BLOCK_WITHOUT_AWAIT,+ BLOCKING_IO_ON_FOREGROUND,+ ENTITY_UPDATE_IN_RENDER,+ NOTIFY_IN_RENDER,+ OWNED_STRING_INTO_SHARED,+ ]);+ lint_store.register_late_pass(|_| Box::new(SharedStringFromStrLiteral));+ lint_store.register_late_pass(|_| Box::new(AsyncBlockWithoutAwait));+ lint_store.register_late_pass(|_| Box::new(blocking_io_on_foreground::BlockingIoOnForeground));+ lint_store.register_late_pass(|_| Box::new(entity_update_in_render::EntityUpdateInRender));+ lint_store.register_late_pass(|_| Box::new(notify_in_render::NotifyInRender));+ lint_store.register_late_pass(|_| Box::new(owned_string_into_shared::OwnedStringIntoShared));+}++// ===========================================================================+// Lint A — SHARED_STRING_FROM_STR_LITERAL+// ===========================================================================++rustc_session::declare_lint! {+ /// ### What it does+ ///+ /// Flags `gpui::SharedString` values constructed from a string literal by+ /// any path other than `SharedString::new_static`.+ ///+ /// ### Why is this bad?+ ///+ /// `SharedString` wraps a `SmolStr`. `SmolStr::from` either copies the+ /// bytes into inline storage (literals ≤ 23 bytes) or allocates a fresh+ /// `Arc<str>` on the heap (literals > 23 bytes). `SharedString::new_static`+ /// does neither: it stores the `'static` pointer directly. For a string+ /// literal the constant-pointer path is always available and strictly+ /// cheaper.+ ///+ /// This lint fires on `SharedString::from("…")`, `SharedString::new("…")`,+ /// `<SharedString as From<_>>::from("…")`, and `"…".into()` whose inferred+ /// target type is `SharedString`. It does not fire on+ /// `SharedString::new_static(…)`.+ ///+ /// The lint distinguishes two tiers of wastefulness:+ /// * Literals > 23 bytes trigger a heap allocation per call site, flagged+ /// at full severity.+ /// * Literals ≤ 23 bytes "only" pay a memcpy; still strictly worse than+ /// `new_static`, but cheaper to leave alone.+ ///+ /// ### Example+ ///+ /// ```ignore+ /// let s: SharedString = SharedString::from("Right-click for more options");+ /// let t: SharedString = "hello".into();+ /// ```+ ///+ /// Use instead:+ ///+ /// ```ignore+ /// let s = SharedString::new_static("Right-click for more options");+ /// let t = SharedString::new_static("hello");+ /// ```+ pub SHARED_STRING_FROM_STR_LITERAL,+ Warn,+ "constructing a `SharedString` from a string literal via a copying/allocating path"+}++rustc_session::declare_lint_pass!(SharedStringFromStrLiteral => [SHARED_STRING_FROM_STR_LITERAL]);++/// Maximum number of bytes that `SmolStr` (and therefore `SharedString`) can+/// store inline on 64-bit targets. Literals larger than this trigger an+/// `Arc<str>` allocation on every conversion.+///+/// Source: `smol_str` v0.3's `INLINE_CAP`. See+/// <https://docs.rs/smol_str/0.3.6/smol_str/>.+const SMOL_STR_INLINE_CAP: usize = 23;++impl<'tcx> LateLintPass<'tcx> for SharedStringFromStrLiteral {+ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {+ // Do not descend into macro-expanded code: we'd be suggesting edits to+ // spans the user cannot actually touch.+ if expr.span.from_expansion() {+ return;+ }++ let ty = cx.typeck_results().expr_ty(expr);+ if !is_shared_string(cx, ty) {+ return;+ }++ let Some(literal) = extract_literal_source(cx, expr) else {+ return;+ };++ emit_shared_string(cx, expr.span, literal);+ }+}++/// A string literal the user wrote and that we are confident we can replace.+struct LiteralSource {+ /// The literal's decoded contents.+ contents: String,+ /// The span of the full expression that should be replaced (e.g. the whole+ /// `SharedString::from("x")` call), not just the literal token.+ replace_span: Span,+}++fn extract_literal_source<'tcx>(+ cx: &LateContext<'tcx>,+ expr: &'tcx Expr<'tcx>,+) -> Option<LiteralSource> {+ match &expr.kind {+ // `SharedString::from(lit)`, `SharedString::new(lit)`, or any other+ // associated/trait function resolving onto `SharedString` with a+ // single string-literal argument.+ ExprKind::Call(func, [arg]) => {+ let def_id = call_def_id(cx, func)?;+ if !is_interesting_shared_string_constructor(cx, def_id) {+ return None;+ }+ let contents = str_literal_contents(arg)?;+ Some(LiteralSource {+ contents,+ replace_span: expr.span,+ })+ }++ // `lit.into()` where the target type is `SharedString`.+ ExprKind::MethodCall(path_seg, receiver, [], _)+ if path_seg.ident.name.as_str() == "into" =>+ {+ let contents = str_literal_contents(receiver)?;+ Some(LiteralSource {+ contents,+ replace_span: expr.span,+ })+ }++ _ => None,+ }+}++/// Extract the contents of a string literal expression, peeling through a+/// single layer of reference if the user wrote `&"lit"`.+fn str_literal_contents<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<String> {+ let inner = match &expr.kind {+ ExprKind::AddrOf(_, _, inner) => *inner,+ _ => expr,+ };+ if let ExprKind::Lit(lit) = &inner.kind+ && let LitKind::Str(sym, _) = lit.node+ {+ Some(sym.as_str().to_owned())+ } else {+ None+ }+}++/// Returns the `DefId` of the function being called, if `func` is a direct+/// path to a function or associated function. This handles both+/// `Type::method(...)` syntax (including type-relative paths that resolve+/// through `typeck_results`) and free-function paths.+fn call_def_id<'tcx>(cx: &LateContext<'tcx>, func: &'tcx Expr<'tcx>) -> Option<DefId> {+ let ExprKind::Path(qpath) = &func.kind else {+ return None;+ };+ match cx.qpath_res(qpath, func.hir_id) {+ Res::Def(DefKind::Fn | DefKind::AssocFn, def_id) => Some(def_id),+ _ => None,+ }+}++/// True if `def_id` names a `SharedString` constructor that we treat as a+/// wasteful alternative to `SharedString::new_static` when passed a string+/// literal.+///+/// This covers two distinct resolutions rustc produces for these call sites:+///+/// * `SharedString::new("x")` resolves to the inherent associated function+/// on `impl SharedString`. The impl's `Self` type is `SharedString`.+/// * `SharedString::from("x")` resolves to the trait method+/// `core::convert::From::from`. The impl is not recorded on the `def_id`+/// itself; we instead verify the enclosing trait is `From` and rely on the+/// caller having already checked that the call's result type is+/// `SharedString`.+///+/// `SharedString::new_static` is explicitly exempted because it is the+/// preferred alternative.+fn is_interesting_shared_string_constructor(cx: &LateContext<'_>, def_id: DefId) -> bool {+ let tcx = cx.tcx;+ let name = tcx.item_name(def_id);+ if name.as_str() == "new_static" {+ return false;+ }+ if !matches!(name.as_str(), "from" | "new") {+ return false;+ }+ if let Some(impl_id) = tcx.impl_of_assoc(def_id) {+ let self_ty = tcx.type_of(impl_id).skip_binder();+ return is_shared_string(cx, self_ty);+ }+ if let Some(trait_id) = tcx.trait_of_assoc(def_id) {+ // The caller has already asserted that the call's result type is+ // `SharedString`, so a `From::from` call resolving here is+ // equivalent to `<SharedString as From<_>>::from`.+ let path = tcx.def_path_str(trait_id);+ return path == "core::convert::From" || path == "std::convert::From";+ }+ false+}++/// Match the canonical definition path of `gpui_shared_string::SharedString`.+/// Re-exports through `gpui` resolve back to the same `DefId`.+fn is_shared_string(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {+ let Some(adt) = ty.ty_adt_def() else {+ return false;+ };+ let did = adt.did();+ let krate = cx.tcx.crate_name(did.krate);+ if krate.as_str() != "gpui_shared_string" {+ return false;+ }+ cx.tcx.item_name(did).as_str() == "SharedString"+}++fn emit_shared_string(cx: &LateContext<'_>, call_span: Span, literal: LiteralSource) {+ let LiteralSource {+ contents,+ replace_span,+ } = literal;+ let byte_len = contents.len();+ let over_inline = byte_len > SMOL_STR_INLINE_CAP;++ // Use the original source text for the replacement where possible so we+ // preserve raw-string syntax, escapes, etc. Fall back to debug-formatting+ // the decoded contents if the source is unavailable (e.g. macro-generated).+ let replacement_lit = snippet_opt(cx, replace_span)+ .and_then(extract_embedded_string_literal)+ .unwrap_or_else(|| format!("{contents:?}"));++ let suggestion = format!("SharedString::new_static({replacement_lit})");++ let primary_msg = if over_inline {+ "this `SharedString` construction heap-allocates on every call"+ } else {+ "this `SharedString` construction copies the literal on every call"+ };++ span_lint_and_then(+ cx,+ SHARED_STRING_FROM_STR_LITERAL,+ call_span,+ primary_msg,+ |diag| {+ if over_inline {+ diag.note(format!(+ "the literal is {byte_len} bytes, which exceeds `SmolStr`'s {SMOL_STR_INLINE_CAP}-byte inline capacity, so `SmolStr::from` allocates an `Arc<str>` here",+ ));+ } else {+ diag.note(format!(+ "the literal is {byte_len} bytes (≤ {SMOL_STR_INLINE_CAP}) so it stays inline, but the copy is still avoidable",+ ));+ }+ diag.note("`SharedString::new_static` stores the `'static` pointer directly and performs no allocation or copy");+ diag.span_suggestion(+ replace_span,+ "use the zero-cost static constructor",+ suggestion,+ Applicability::MachineApplicable,+ );+ },+ );+}++/// Given a snippet like `SharedString::from("hi")` or `"hi".into()`, extract+/// the first embedded string literal token (including any `r#"..."#` prefix)+/// so we can paste it back unchanged. This is a best-effort scanner and+/// returns `None` when the snippet has no literal or an unterminated one.+fn extract_embedded_string_literal(snippet: String) -> Option<String> {+ let bytes = snippet.as_bytes();+ let mut i = 0;+ while i < bytes.len() {+ // Raw string: optional `b`, then `r`, then `#`*, then `"`.+ let raw_start = i;+ let mut j = i;+ if j < bytes.len() && bytes[j] == b'b' {+ j += 1;+ }+ if j < bytes.len() && bytes[j] == b'r' {+ let mut hashes = 0;+ let mut k = j + 1;+ while k < bytes.len() && bytes[k] == b'#' {+ hashes += 1;+ k += 1;+ }+ if k < bytes.len() && bytes[k] == b'"' {+ // Scan for closing `"` followed by the same number of `#`.+ let mut m = k + 1;+ while m < bytes.len() {+ if bytes[m] == b'"' {+ let mut close_hashes = 0;+ let mut n = m + 1;+ while close_hashes < hashes && n < bytes.len() && bytes[n] == b'#' {+ close_hashes += 1;+ n += 1;+ }+ if close_hashes == hashes {+ return Some(snippet[raw_start..n].to_owned());+ }+ }+ m += 1;+ }+ return None;+ }+ }+ // Regular string: optional `b`, then `"`, until matching unescaped `"`.+ let mut j = i;+ if j < bytes.len() && bytes[j] == b'b' {+ j += 1;+ }+ if j < bytes.len() && bytes[j] == b'"' {+ let mut m = j + 1;+ while m < bytes.len() {+ match bytes[m] {+ b'\\' => {+ m += 2;+ continue;+ }+ b'"' => return Some(snippet[raw_start..=m].to_owned()),+ _ => m += 1,+ }+ }+ return None;+ }+ i += 1;+ }+ None+}++// ===========================================================================+// Lint B — ASYNC_BLOCK_WITHOUT_AWAIT+// ===========================================================================++rustc_session::declare_lint! {+ /// ### What it does+ ///+ /// Flags `async { … }` and `async move { … }` blocks whose body contains+ /// no `.await` expression at their own nesting level.+ ///+ /// ### Why is this bad?+ ///+ /// An async block without an `.await` wraps synchronous code in a `Future`+ /// state machine for no benefit. The state machine adds binary size, and+ /// the indirection may hide the fact that the code never actually yields.+ /// Either the `async` should be removed (the code is synchronous), or a+ /// missing `.await` is a bug.+ ///+ /// ### Example+ ///+ /// ```ignore+ /// let future = async { compute_something() };+ /// ```+ ///+ /// Use instead:+ ///+ /// ```ignore+ /// let value = compute_something();+ /// ```+ pub ASYNC_BLOCK_WITHOUT_AWAIT,+ Warn,+ "`async` block that contains no `.await` expression"+}++rustc_session::declare_lint_pass!(AsyncBlockWithoutAwait => [ASYNC_BLOCK_WITHOUT_AWAIT]);++impl<'tcx> LateLintPass<'tcx> for AsyncBlockWithoutAwait {+ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {+ if expr.span.from_expansion() {+ return;+ }++ // Match only async blocks — not async function bodies or async closures.+ let ExprKind::Closure(Closure {+ kind:+ ClosureKind::Coroutine(CoroutineKind::Desugared(+ CoroutineDesugaring::Async,+ CoroutineSource::Block,+ )),+ body,+ ..+ }) = &expr.kind+ else {+ return;+ };++ // Trait impls are constrained by the trait's signature. If the trait+ // requires a method that returns a future, the implementor must produce+ // an async block even when their implementation has nothing to await.+ let enclosing_body_owner = cx.tcx.hir_enclosing_body_owner(expr.hir_id);+ if is_def_id_trait_method(cx, enclosing_body_owner) {+ return;+ }++ let body = cx.tcx.hir_body(*body);+ let mut visitor = AwaitVisitor {+ cx,+ found_await: false,+ async_depth: 0,+ };+ walk_expr(&mut visitor, body.value);++ if !visitor.found_await {+ span_lint_and_help(+ cx,+ ASYNC_BLOCK_WITHOUT_AWAIT,+ expr.span,+ "this `async` block contains no `.await`",+ None,+ "consider removing the `async` block or adding the missing `.await`",+ );+ }+ }+}++/// Walks the body of an async block looking for `.await` expressions. Tracks+/// nesting depth so that an `.await` inside a *nested* async block is not+/// attributed to the *outer* block.+struct AwaitVisitor<'a, 'tcx> {+ cx: &'a LateContext<'tcx>,+ found_await: bool,+ async_depth: usize,+}++impl<'tcx> Visitor<'tcx> for AwaitVisitor<'_, 'tcx> {+ type NestedFilter = nested_filter::OnlyBodies;++ fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {+ self.cx.tcx+ }++ fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {+ if let ExprKind::Yield(_, YieldSource::Await { .. }) = expr.kind {+ if self.async_depth == 0 {+ self.found_await = true;+ return;+ }+ }++ let is_nested_async_block = matches!(+ expr.kind,+ ExprKind::Closure(Closure {+ kind: ClosureKind::Coroutine(CoroutineKind::Desugared(+ CoroutineDesugaring::Async,+ _+ )),+ ..+ })+ );++ if is_nested_async_block {+ self.async_depth += 1;+ }++ walk_expr(self, expr);++ if is_nested_async_block {+ self.async_depth -= 1;+ }+ }+}++// ===========================================================================+// Tests+// ===========================================================================++#[cfg(test)]+mod tests {+ use std::path::PathBuf;+ use std::process::Command;++ /// Build the test-fixture `gpui` crate and return rustc flags that make+ /// it available to standalone UI test files via `extern crate gpui`.+ fn gpui_fixture_rustc_flags() -> Vec<String> {+ let fixture_dir: PathBuf = [env!("CARGO_MANIFEST_DIR"), "test_fixture"]+ .iter()+ .collect();++ let status = Command::new("cargo")+ .args(["build", "--package", "gpui"])+ .current_dir(&fixture_dir)+ .status()+ .expect("failed to run cargo build for gpui fixture");+ assert!(status.success(), "gpui fixture build failed");++ let rlib: PathBuf = fixture_dir.join("target/debug/libgpui.rlib");+ let deps: PathBuf = fixture_dir.join("target/debug/deps");++ vec![+ "--edition=2021".to_string(),+ format!("--extern=gpui={}", rlib.display()),+ format!("-Ldependency={}", deps.display()),+ ]+ }++ #[test]+ fn ui() {+ let flags = gpui_fixture_rustc_flags();+ dylint_testing::ui::Test::src_base(env!("CARGO_PKG_NAME"), "ui")+ .rustc_flags(flags)+ .run();+ }++ #[test]+ fn ui_shared_string() {+ dylint_testing::ui_test_examples(env!("CARGO_PKG_NAME"));+ }+}diff --git a/tooling/lints/src/notify_in_render.rs b/tooling/lints/src/notify_in_render.rsnew file mode 100644index 00000000000..edc5fb26f4d--- /dev/null+++ b/tooling/lints/src/notify_in_render.rs@@ -0,0 +1,58 @@+use clippy_utils::diagnostics::span_lint;+use rustc_hir::{Expr, ExprKind};+use rustc_lint::{LateContext, LateLintPass};++use crate::render_helpers::{is_directly_in_render_method, is_gpui_context};++rustc_session::declare_lint! {+ /// ### What it does+ ///+ /// Flags calls to `Context::notify()` that execute synchronously inside a+ /// `Render::render` method.+ ///+ /// ### Why is this bad?+ ///+ /// `notify()` tells the framework that the entity's state has changed and+ /// it should be re-rendered. Calling it during render means every render+ /// pass schedules another render pass — either an infinite loop or wasted+ /// work.+ pub NOTIFY_IN_RENDER,+ Warn,+ "calling `cx.notify()` during render schedules a redundant re-render"+}++pub(crate) struct NotifyInRender;++rustc_session::impl_lint_pass!(NotifyInRender => [NOTIFY_IN_RENDER]);++impl<'tcx> LateLintPass<'tcx> for NotifyInRender {+ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {+ if expr.span.from_expansion() {+ return;+ }++ let ExprKind::MethodCall(segment, receiver, _args, _span) = &expr.kind else {+ return;+ };++ if segment.ident.name.as_str() != "notify" {+ return;+ }++ let receiver_ty = cx.typeck_results().expr_ty(receiver);+ if !is_gpui_context(cx, receiver_ty) {+ return;+ }++ if !is_directly_in_render_method(cx, expr.hir_id) {+ return;+ }++ span_lint(+ cx,+ NOTIFY_IN_RENDER,+ expr.span,+ "`cx.notify()` called during render schedules a re-render every render pass",+ );+ }+}diff --git a/tooling/lints/src/owned_string_into_shared.rs b/tooling/lints/src/owned_string_into_shared.rsnew file mode 100644index 00000000000..a47f2f43432--- /dev/null+++ b/tooling/lints/src/owned_string_into_shared.rs@@ -0,0 +1,171 @@+use clippy_utils::diagnostics::span_lint;+use rustc_ast::ast::LitKind;+use rustc_hir::def::{DefKind, Res};+use rustc_hir::{Expr, ExprKind};+use rustc_lint::{LateContext, LateLintPass};+use rustc_middle::ty::Ty;++rustc_session::declare_lint! {+ /// ### What it does+ ///+ /// Flags expressions that build an owned `String` from a string literal+ /// and then immediately convert it with `.into()` into one of the+ /// refcounted/shared string types: `gpui::SharedString`, `Arc<str>`,+ /// `Rc<str>`, or `Cow<'_, str>`.+ ///+ /// The flagged shapes are:+ ///+ /// ```ignore+ /// let label: SharedString = String::from("foo").into();+ /// let key: Arc<str> = "foo".to_string().into();+ /// let value: Rc<str> = "foo".to_owned().into();+ /// ```+ ///+ /// ### Why is this bad?+ ///+ /// Two heap allocations and two copies of the literal happen where one is+ /// enough: `String::from` (or `to_string`/`to_owned`) allocates a `String`+ /// and copies the bytes; the `.into()` conversion into the refcounted+ /// destination then allocates an `Arc<str>`-like buffer and copies the+ /// bytes a second time. For string literals the destination can be built+ /// directly from `'static` data with no allocation at all.+ pub OWNED_STRING_INTO_SHARED,+ Warn,+ "an owned `String` is built from a string literal only to be converted into a refcounted string"+}++pub(crate) struct OwnedStringIntoShared;++rustc_session::impl_lint_pass!(OwnedStringIntoShared => [OWNED_STRING_INTO_SHARED]);++impl<'tcx> LateLintPass<'tcx> for OwnedStringIntoShared {+ fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {+ if expr.span.from_expansion() {+ return;+ }++ let ExprKind::MethodCall(segment, receiver, [], _) = &expr.kind else {+ return;+ };+ if segment.ident.name.as_str() != "into" {+ return;+ }++ let dest_ty = cx.typeck_results().expr_ty(expr);+ if !is_refcounted_string_destination(cx, dest_ty) {+ return;+ }++ // The receiver must produce an owned `String`. Confirming this rules+ // out custom `into` impls on unrelated types that just happen to look+ // similar.+ let receiver_ty = cx.typeck_results().expr_ty(receiver);+ if !is_std_string(cx, receiver_ty) {+ return;+ }++ if !is_owned_string_built_from_literal(cx, receiver) {+ return;+ }++ span_lint(+ cx,+ OWNED_STRING_INTO_SHARED,+ expr.span,+ "this allocates an owned `String` from a string literal only to convert it into a refcounted string",+ );+ }+}++/// Returns `true` when `ty` is one of the refcounted/shared string types this+/// lint targets: `gpui::SharedString`, `Arc<str>`, `Rc<str>`, or+/// `Cow<'_, str>`.+fn is_refcounted_string_destination<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {+ let Some(adt) = ty.ty_adt_def() else {+ return false;+ };+ let did = adt.did();++ if cx.tcx.crate_name(did.krate).as_str() == "gpui_shared_string"+ && cx.tcx.item_name(did).as_str() == "SharedString"+ {+ return true;+ }++ let path = cx.tcx.def_path_str(did);+ let is_str_wrapper = matches!(+ path.as_str(),+ "alloc::sync::Arc"+ | "std::sync::Arc"+ | "alloc::rc::Rc"+ | "std::rc::Rc"+ | "alloc::borrow::Cow"+ | "std::borrow::Cow"+ );+ if !is_str_wrapper {+ return false;+ }++ let rustc_middle::ty::TyKind::Adt(_, args) = ty.kind() else {+ return false;+ };+ args.iter()+ .find_map(|arg| arg.as_type())+ .is_some_and(|inner| inner.is_str())+}++/// Returns `true` when `ty` is `alloc::string::String`.+fn is_std_string(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {+ let Some(adt) = ty.ty_adt_def() else {+ return false;+ };+ let path = cx.tcx.def_path_str(adt.did());+ path == "alloc::string::String" || path == "std::string::String"+}++/// Returns `true` if `expr` matches one of:+///+/// * `String::from(<string literal>)`+/// * `<string literal>.to_string()`+/// * `<string literal>.to_owned()`+fn is_owned_string_built_from_literal<'tcx>(+ cx: &LateContext<'tcx>,+ expr: &'tcx Expr<'tcx>,+) -> bool {+ match &expr.kind {+ ExprKind::Call(func, [arg]) => {+ let ExprKind::Path(qpath) = &func.kind else {+ return false;+ };+ let Res::Def(DefKind::Fn | DefKind::AssocFn, def_id) = cx.qpath_res(qpath, func.hir_id)+ else {+ return false;+ };+ if cx.tcx.item_name(def_id).as_str() != "from" {+ return false;+ }+ is_string_literal(arg)+ }+ ExprKind::MethodCall(segment, receiver, [], _) => {+ let name = segment.ident.name.as_str();+ if name != "to_string" && name != "to_owned" {+ return false;+ }+ is_string_literal(receiver)+ }+ _ => false,+ }+}++/// Returns `true` if `expr` is a string-literal expression, optionally wrapped+/// in a single layer of reference (`&"lit"`).+fn is_string_literal<'tcx>(expr: &'tcx Expr<'tcx>) -> bool {+ let inner = match &expr.kind {+ ExprKind::AddrOf(_, _, inner) => *inner,+ _ => expr,+ };+ matches!(+ &inner.kind,+ ExprKind::Lit(lit) if matches!(lit.node, LitKind::Str(..))+ )+}diff --git a/tooling/lints/src/render_helpers.rs b/tooling/lints/src/render_helpers.rsnew file mode 100644index 00000000000..f85adacc0cc--- /dev/null+++ b/tooling/lints/src/render_helpers.rs@@ -0,0 +1,98 @@+use rustc_hir::def_id::DefId;+use rustc_hir::{ExprKind, HirId, Node};+use rustc_lint::LateContext;+use rustc_middle::ty::Ty;++/// Returns `true` when `hir_id` sits directly inside a `fn render` that+/// implements `gpui::Render` or `gpui::RenderOnce`, without an intervening+/// closure. If a closure sits between `hir_id` and the `render` method, the+/// expression executes later (e.g. in an event handler) and is not flagged.+pub(crate) fn is_directly_in_render_method(cx: &LateContext<'_>, hir_id: HirId) -> bool {+ for (parent_id, node) in cx.tcx.hir_parent_iter(hir_id) {+ match node {+ Node::Expr(expr) if matches!(expr.kind, ExprKind::Closure(_)) => {+ return false;+ }+ Node::ImplItem(impl_item) if impl_item.ident.name.as_str() == "render" => {+ return is_render_trait_impl(cx, parent_id);+ }+ _ => {}+ }+ }+ false+}++/// Returns `true` when the `impl` block that owns `impl_item_hir_id` is an+/// implementation of `gpui::Render` or `gpui::RenderOnce`.+fn is_render_trait_impl(cx: &LateContext<'_>, impl_item_hir_id: HirId) -> bool {+ let parent_owner = cx.tcx.hir_get_parent_item(impl_item_hir_id);+ let node = cx.tcx.hir_node(parent_owner.into());+ if let Node::Item(item) = node {+ if let rustc_hir::ItemKind::Impl(impl_block) = &item.kind {+ if let Some(trait_ref) = &impl_block.of_trait {+ if let rustc_hir::def::Res::Def(_, trait_def_id) = trait_ref.trait_ref.path.res {+ return is_gpui_render_trait(cx, trait_def_id);+ }+ }+ }+ }+ false+}++fn is_gpui_render_trait(cx: &LateContext<'_>, trait_def_id: DefId) -> bool {+ let crate_name = cx.tcx.crate_name(trait_def_id.krate);+ if crate_name.as_str() != "gpui" {+ return false;+ }+ let name = cx.tcx.item_name(trait_def_id);+ name.as_str() == "Render" || name.as_str() == "RenderOnce"+}++/// Returns `true` when `ty` is `gpui::Entity<T>` or `gpui::WeakEntity<T>`.+pub(crate) fn is_gpui_entity_or_weak(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {+ let peeled = ty.peel_refs();+ let Some(adt) = peeled.ty_adt_def() else {+ return false;+ };+ let did = adt.did();+ let crate_name = cx.tcx.crate_name(did.krate);+ if crate_name.as_str() != "gpui" {+ return false;+ }+ let name = cx.tcx.item_name(did);+ name.as_str() == "Entity" || name.as_str() == "WeakEntity"+}++/// Returns `true` when `ty` is `gpui::Context<T>`.+pub(crate) fn is_gpui_context(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {+ let peeled = ty.peel_refs();+ let Some(adt) = peeled.ty_adt_def() else {+ return false;+ };+ let did = adt.did();+ let crate_name = cx.tcx.crate_name(did.krate);+ if crate_name.as_str() != "gpui" {+ return false;+ }+ cx.tcx.item_name(did).as_str() == "Context"+}++/// Returns `true` when the expression type indicates a unit-returning update+/// call — either `()` (from `Entity::update`) or `Result<(), _>` (from+/// `WeakEntity::update`).+pub(crate) fn is_unit_or_result_unit(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {+ if ty.is_unit() {+ return true;+ }+ if let Some(adt) = ty.ty_adt_def() {+ let path = cx.tcx.def_path_str(adt.did());+ if path == "core::result::Result" || path == "std::result::Result" {+ if let Some(substs) = ty.walk().nth(1) {+ if let Some(inner_ty) = substs.as_type() {+ return inner_ty.is_unit();+ }+ }+ }+ }+ false+}diff --git a/tooling/lints/test_fixture/Cargo.toml b/tooling/lints/test_fixture/Cargo.tomlnew file mode 100644index 00000000000..a07c992855c--- /dev/null+++ b/tooling/lints/test_fixture/Cargo.toml@@ -0,0 +1,6 @@+[workspace]+resolver = "2"+members = ["gpui", "gpui_shared_string", "consumer", "render_consumer"]++[workspace.metadata.dylint]+libraries = [{ path = ".." }]diff --git a/tooling/lints/test_fixture/consumer/Cargo.toml b/tooling/lints/test_fixture/consumer/Cargo.tomlnew file mode 100644index 00000000000..dd822953c2c--- /dev/null+++ b/tooling/lints/test_fixture/consumer/Cargo.toml@@ -0,0 +1,11 @@+[package]+name = "consumer"+version = "0.0.0"+edition = "2021"+publish = false++[lib]+path = "src/lib.rs"++[dependencies]+gpui_shared_string = { path = "../gpui_shared_string" }diff --git a/tooling/lints/test_fixture/consumer/src/lib.rs b/tooling/lints/test_fixture/consumer/src/lib.rsnew file mode 100644index 00000000000..6b5d905664c--- /dev/null+++ b/tooling/lints/test_fixture/consumer/src/lib.rs@@ -0,0 +1,63 @@+use gpui_shared_string::SharedString;++// Should fire: `from` with a short literal (≤ 23 bytes).+pub fn from_short() -> SharedString {+ SharedString::from("Favorites")+}++// Should fire at elevated severity: `from` with a long literal (> 23 bytes).+pub fn from_long() -> SharedString {+ SharedString::from("Right-click for more options")+}++// Should fire: explicit `.into()` from a string literal.+pub fn into_short() -> SharedString {+ "hello".into()+}++// Should fire: `SharedString::new("...")`.+pub fn new_short() -> SharedString {+ SharedString::new("hi")+}++// Should NOT fire: the zero-cost constructor.+pub fn new_static_short() -> SharedString {+ SharedString::new_static("Favorites")+}++// Should NOT fire: non-literal input.+pub fn from_variable(s: &str) -> SharedString {+ SharedString::from(s)+}++// Should NOT fire: `.into()` on a non-literal.+pub fn into_variable(s: &str) -> SharedString {+ s.into()+}++// Should fire: `.into()` on a string literal that exceeds the 23-byte cap.+pub fn into_long() -> SharedString {+ "this literal is definitely longer than twenty three bytes".into()+}++// ---- owned_string_into_shared cases targeting `SharedString` ----++// Should fire (owned_string_into_shared): `String::from(<lit>).into()`.+pub fn shared_string_from_string_from() -> SharedString {+ String::from("label").into()+}++// Should fire (owned_string_into_shared): `<lit>.to_string().into()`.+pub fn shared_string_from_to_string() -> SharedString {+ "label".to_string().into()+}++// Should fire (owned_string_into_shared): `<lit>.to_owned().into()`.+pub fn shared_string_from_to_owned() -> SharedString {+ "label".to_owned().into()+}++// Should NOT fire owned_string_into_shared: the source is a non-literal `String`.+pub fn shared_string_from_dynamic_string(s: String) -> SharedString {+ s.into()+}diff --git a/tooling/lints/test_fixture/gpui/Cargo.toml b/tooling/lints/test_fixture/gpui/Cargo.tomlnew file mode 100644index 00000000000..5d01d426808--- /dev/null+++ b/tooling/lints/test_fixture/gpui/Cargo.toml@@ -0,0 +1,8 @@+[package]+name = "gpui"+version = "0.0.0"+edition = "2021"+publish = false++[lib]+path = "src/lib.rs"diff --git a/tooling/lints/test_fixture/gpui/src/lib.rs b/tooling/lints/test_fixture/gpui/src/lib.rsnew file mode 100644index 00000000000..7d863fbe836--- /dev/null+++ b/tooling/lints/test_fixture/gpui/src/lib.rs@@ -0,0 +1,100 @@+//! Minimal stand-in for the real `gpui` crate. The lints key off the crate+//! name and the type names, so we only need to reproduce the relevant API+//! surface.++use std::marker::PhantomData;++// --- AppContext ---++pub trait AppContext {+ fn as_app_mut(&mut self) -> &mut App;+}++// --- App ---++pub struct App;++impl AppContext for App {+ fn as_app_mut(&mut self) -> &mut App {+ self+ }+}++// --- Context ---++pub struct Context<'a, T> {+ _marker: PhantomData<&'a mut T>,+}++impl<T> AppContext for Context<'_, T> {+ fn as_app_mut(&mut self) -> &mut App {+ unimplemented!()+ }+}++impl<T> Context<'_, T> {+ pub fn notify(&mut self) {}+}++// --- Window ---++pub struct Window;++// --- Entity ---++pub struct Entity<T> {+ _marker: PhantomData<T>,+}++impl<T> Entity<T> {+ pub fn update<R, C: AppContext>(+ &self,+ _cx: &mut C,+ _f: impl FnOnce(&mut T, &mut Context<T>) -> R,+ ) -> R {+ unimplemented!()+ }++ pub fn read<'a>(&self, _cx: &'a App) -> &'a T {+ unimplemented!()+ }++ pub fn read_with<R>(&self, _cx: &App, _f: impl FnOnce(&T, &App) -> R) -> R {+ unimplemented!()+ }++ pub fn downgrade(&self) -> WeakEntity<T> {+ unimplemented!()+ }+}++// --- WeakEntity ---++pub struct WeakEntity<T> {+ _marker: PhantomData<T>,+}++impl<T> WeakEntity<T> {+ pub fn update<R, C: AppContext>(+ &self,+ _cx: &mut C,+ _f: impl FnOnce(&mut T, &mut Context<T>) -> R,+ ) -> Result<R, ()> {+ unimplemented!()+ }+}++// --- Render traits ---++pub trait IntoElement {}++pub trait Render: 'static + Sized {+ fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement;+}++pub trait RenderOnce: 'static {+ fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement;+}++impl IntoElement for () {}+impl IntoElement for &str {}diff --git a/tooling/lints/test_fixture/gpui_shared_string/Cargo.toml b/tooling/lints/test_fixture/gpui_shared_string/Cargo.tomlnew file mode 100644index 00000000000..4bb3411b825--- /dev/null+++ b/tooling/lints/test_fixture/gpui_shared_string/Cargo.toml@@ -0,0 +1,8 @@+[package]+name = "gpui_shared_string"+version = "0.0.0"+edition = "2021"+publish = false++[lib]+path = "src/lib.rs"diff --git a/tooling/lints/test_fixture/gpui_shared_string/src/lib.rs b/tooling/lints/test_fixture/gpui_shared_string/src/lib.rsnew file mode 100644index 00000000000..bce372c06ee--- /dev/null+++ b/tooling/lints/test_fixture/gpui_shared_string/src/lib.rs@@ -0,0 +1,31 @@+//! Minimal stand-in for the real `gpui_shared_string` crate. The lint keys+//! off the crate name and the type name `SharedString`, so we only need to+//! reproduce those.++#[derive(Clone)]+pub struct SharedString(String);++impl SharedString {+ pub const fn new_static(s: &'static str) -> Self {+ // The real implementation stores the `'static` pointer; we just wrap+ // an empty String at compile time to keep this `const`.+ let _ = s;+ SharedString(String::new())+ }++ pub fn new(s: impl AsRef<str>) -> Self {+ SharedString(s.as_ref().to_owned())+ }+}++impl From<&str> for SharedString {+ fn from(s: &str) -> Self {+ SharedString(s.to_owned())+ }+}++impl From<String> for SharedString {+ fn from(s: String) -> Self {+ SharedString(s)+ }+}diff --git a/tooling/lints/test_fixture/render_consumer/Cargo.toml b/tooling/lints/test_fixture/render_consumer/Cargo.tomlnew file mode 100644index 00000000000..25a93028de2--- /dev/null+++ b/tooling/lints/test_fixture/render_consumer/Cargo.toml@@ -0,0 +1,11 @@+[package]+name = "render_consumer"+version = "0.0.0"+edition = "2021"+publish = false++[lib]+path = "src/lib.rs"++[dependencies]+gpui = { path = "../gpui" }diff --git a/tooling/lints/test_fixture/render_consumer/src/lib.rs b/tooling/lints/test_fixture/render_consumer/src/lib.rsnew file mode 100644index 00000000000..e578844dcdb--- /dev/null+++ b/tooling/lints/test_fixture/render_consumer/src/lib.rs@@ -0,0 +1,154 @@+#![allow(unused, dead_code)]++use gpui::*;++// ============================================================+// Helper types for tests+// ============================================================++struct Editor;++impl Editor {+ fn set_text(&mut self, _text: &str) {}+ fn text(&self) -> String {+ String::new()+ }+}++struct Counter {+ count: u32,+ editor: Entity<Editor>,+}++struct CounterOnce {+ editor: Entity<Editor>,+ weak_editor: WeakEntity<Editor>,+}++// ============================================================+// entity_update_in_render — SHOULD WARN+// ============================================================++// Entity::update with unit-returning closure in Render::render+impl Render for Counter {+ fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {+ self.editor.update(cx, |editor, _cx| {+ editor.set_text("hello");+ });+ ()+ }+}++// Entity::update with unit-returning closure in RenderOnce::render+impl RenderOnce for CounterOnce {+ fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {+ self.editor.update(cx, |editor, _cx| {+ editor.set_text("hello");+ });+ ()+ }+}++// WeakEntity::update with unit-returning closure in RenderOnce::render+struct WeakUpdater {+ weak_editor: WeakEntity<Editor>,+}++impl RenderOnce for WeakUpdater {+ fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {+ let _ = self.weak_editor.update(cx, |editor, _cx| {+ editor.set_text("world");+ });+ ()+ }+}++// ============================================================+// entity_update_in_render — SHOULD NOT WARN+// ============================================================++// Entity::update with value-returning closure (reading, not mutating)+struct ReaderView {+ editor: Entity<Editor>,+}++impl RenderOnce for ReaderView {+ fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {+ let _text = self.editor.update(cx, |editor, _cx| editor.text());+ ()+ }+}++// Entity::update outside render entirely+fn update_outside_render(editor: &Entity<Editor>, cx: &mut App) {+ editor.update(cx, |editor, _cx| {+ editor.set_text("fine here");+ });+}++// Entity::read in render (not update)+struct ReadOnlyView {+ editor: Entity<Editor>,+}++impl RenderOnce for ReadOnlyView {+ fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {+ let _editor = self.editor.read(cx);+ ()+ }+}++// Entity::update inside a closure in render (simulating an event handler+// that executes later, not during render itself)+struct ClosureView {+ editor: Entity<Editor>,+}++impl RenderOnce for ClosureView {+ fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {+ let editor = self.editor;+ let _handler = move |cx: &mut App| {+ editor.update(cx, |editor, _cx| {+ editor.set_text("inside closure");+ });+ };+ ()+ }+}++// ============================================================+// notify_in_render — SHOULD WARN+// ============================================================++struct NotifyView {+ count: u32,+}++impl Render for NotifyView {+ fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {+ self.count += 1;+ cx.notify();+ ()+ }+}++// ============================================================+// notify_in_render — SHOULD NOT WARN+// ============================================================++// notify outside render+fn notify_outside_render<T>(cx: &mut Context<'_, T>) {+ cx.notify();+}++// notify inside a closure in render (event handler — runs later)+struct NotifyClosureView;++impl Render for NotifyClosureView {+ fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {+ let _handler = |cx: &mut Context<'_, Self>| {+ cx.notify();+ };+ ()+ }+}diff --git a/tooling/lints/ui/async_block_without_await.rs b/tooling/lints/ui/async_block_without_await.rsnew file mode 100644index 00000000000..f95de0aa1f9--- /dev/null+++ b/tooling/lints/ui/async_block_without_await.rs@@ -0,0 +1,79 @@+// Tests for the `async_block_without_await` lint.++#![allow(unused)]++async fn returns_42() -> i32 {+ 42+}++fn sync_fn() -> i32 {+ 42+}++fn main() {+ // --- Should warn ---++ // Empty async block.+ let _f = async {};++ // Async block with a pure expression.+ let _f = async { 42 };++ // Async move block without await.+ let _f = async move {+ let x = 1;+ x + 2+ };++ // Async block calling a sync function.+ let _f = async { sync_fn() };++ // Nested: the *inner* async block has no await (should warn on it).+ // The outer block awaits the inner future, so the outer is fine.+ let _f = async {+ let inner = async { 42 };+ inner.await+ };++ // --- Should NOT warn ---++ // Async block with an await.+ let _f = async { returns_42().await };++ // Async block with await in a let binding.+ let _f = async {+ let x = returns_42().await;+ x + 1+ };++ // Async move block with await.+ let _f = async move { returns_42().await };++ // Regular closure (not async at all).+ let _f = || 42;+}++// --- Trait impl cases ---++use std::future::Future;++trait AsyncWork {+ fn do_work(&self) -> impl Future<Output = i32>;+}++struct Worker;++// Should NOT warn: the trait requires returning a future, so the+// implementor has no choice but to use `async { ... }`.+impl AsyncWork for Worker {+ fn do_work(&self) -> impl Future<Output = i32> {+ async { 42 }+ }+}++// Should warn: inherent impl — the author chose `async` freely.+impl Worker {+ fn compute(&self) -> impl Future<Output = i32> {+ async { 42 }+ }+}diff --git a/tooling/lints/ui/async_block_without_await.stderr b/tooling/lints/ui/async_block_without_await.stderrnew file mode 100644index 00000000000..e5f5197af5e--- /dev/null+++ b/tooling/lints/ui/async_block_without_await.stderr@@ -0,0 +1,56 @@+error: this `async` block contains no `.await`+ --> $DIR/async_block_without_await.rs:17:14+ |+LL | let _f = async {};+ | ^^^^^^^^+ |+ = help: consider removing the `async` block or adding the missing `.await`+ = note: `-D async-block-without-await` implied by `-D warnings`+ = help: to override `-D warnings` add `#[allow(async_block_without_await)]`++error: this `async` block contains no `.await`+ --> $DIR/async_block_without_await.rs:20:14+ |+LL | let _f = async { 42 };+ | ^^^^^^^^^^^^+ |+ = help: consider removing the `async` block or adding the missing `.await`++error: this `async` block contains no `.await`+ --> $DIR/async_block_without_await.rs:23:14+ |+LL | let _f = async move {+ | ______________^+LL | | let x = 1;+LL | | x + 2+LL | | };+ | |_____^+ |+ = help: consider removing the `async` block or adding the missing `.await`++error: this `async` block contains no `.await`+ --> $DIR/async_block_without_await.rs:29:14+ |+LL | let _f = async { sync_fn() };+ | ^^^^^^^^^^^^^^^^^^^+ |+ = help: consider removing the `async` block or adding the missing `.await`++error: this `async` block contains no `.await`+ --> $DIR/async_block_without_await.rs:34:21+ |+LL | let inner = async { 42 };+ | ^^^^^^^^^^^^+ |+ = help: consider removing the `async` block or adding the missing `.await`++error: this `async` block contains no `.await`+ --> $DIR/async_block_without_await.rs:77:9+ |+LL | async { 42 }+ | ^^^^^^^^^^^^+ |+ = help: consider removing the `async` block or adding the missing `.await`++error: aborting due to 6 previous errors+diff --git a/tooling/lints/ui/blocking_io_on_foreground.rs b/tooling/lints/ui/blocking_io_on_foreground.rsnew file mode 100644index 00000000000..f645bebbadc--- /dev/null+++ b/tooling/lints/ui/blocking_io_on_foreground.rs@@ -0,0 +1,324 @@+// 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() {}diff --git a/tooling/lints/ui/blocking_io_on_foreground.stderr b/tooling/lints/ui/blocking_io_on_foreground.stderrnew file mode 100644index 00000000000..fb502d22f02--- /dev/null+++ b/tooling/lints/ui/blocking_io_on_foreground.stderr@@ -0,0 +1,395 @@+error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:18:13+ |+LL | let _ = std::fs::read_to_string("config.toml");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^+ |+ = note: `-D blocking-io-on-foreground` implied by `-D warnings`+ = help: to override `-D warnings` add `#[allow(blocking_io_on_foreground)]`++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:22:13+ |+LL | let _ = std::fs::write("out.txt", b"data");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:26:13+ |+LL | let _ = std::fs::read("data.bin");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:30:13+ |+LL | let _ = std::fs::metadata("file.txt");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:34:13+ |+LL | let _ = std::fs::create_dir_all("some/path");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:38:13+ |+LL | let _ = std::fs::remove_file("old.txt");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:42:13+ |+LL | let _ = std::fs::canonicalize("./relative");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:46:13+ |+LL | let _ = std::fs::read_dir("some/dir");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:50:13+ |+LL | let _ = std::fs::read_link("some/link");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:54:13+ |+LL | let _ = std::fs::symlink_metadata("file.txt");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:58:23+ |+LL | if let Ok(meta) = std::fs::metadata("file.txt") {+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:59:17+ |+LL | let _ = std::fs::set_permissions("file.txt", meta.permissions());+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:64:13+ |+LL | let _ = std::fs::copy("a.txt", "b.txt");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:68:13+ |+LL | let _ = std::fs::rename("old.txt", "new.txt");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:72:13+ |+LL | let _ = std::fs::hard_link("original", "link");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:76:13+ |+LL | let _ = std::fs::create_dir("one_dir");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:80:13+ |+LL | let _ = std::fs::remove_dir("empty_dir");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:84:13+ |+LL | let _ = std::fs::remove_dir_all("dir_tree");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:90:13+ |+LL | let _ = std::fs::File::open("data.bin");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:94:13+ |+LL | let _ = std::fs::File::create("out.bin");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:98:13+ |+LL | let _ = std::fs::File::create_new("new.bin");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:104:20+ |+LL | if let Ok(f) = std::fs::File::open("x") {+ | ^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:105:17+ |+LL | let _ = f.sync_all();+ | ^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:110:20+ |+LL | if let Ok(f) = std::fs::File::open("x") {+ | ^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:111:17+ |+LL | let _ = f.sync_data();+ | ^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:116:20+ |+LL | if let Ok(f) = std::fs::File::open("x") {+ | ^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:117:17+ |+LL | let _ = f.set_len(0);+ | ^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:122:20+ |+LL | if let Ok(f) = std::fs::File::open("x") {+ | ^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:123:17+ |+LL | let _ = f.metadata();+ | ^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:128:20+ |+LL | if let Ok(f) = std::fs::File::open("x") {+ | ^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:129:17+ |+LL | let _ = f.try_clone();+ | ^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:136:5+ |+LL | std::thread::sleep(std::time::Duration::from_millis(100));+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:142:13+ |+LL | let _ = std::path::Path::new("file.txt").metadata();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:146:13+ |+LL | let _ = std::path::Path::new("link").symlink_metadata();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:150:13+ |+LL | let _ = std::path::Path::new("link").read_link();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:154:13+ |+LL | let _ = std::path::Path::new("dir").read_dir();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:158:13+ |+LL | let _ = std::path::Path::new("file.txt").exists();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:162:13+ |+LL | let _ = std::path::Path::new("file.txt").try_exists();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:166:13+ |+LL | let _ = std::path::Path::new("file.txt").is_file();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:170:13+ |+LL | let _ = std::path::Path::new("dir").is_dir();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:174:13+ |+LL | let _ = std::path::Path::new("link").is_symlink();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:178:13+ |+LL | let _ = std::path::Path::new("./relative").canonicalize();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:183:13+ |+LL | let _ = std::path::PathBuf::from("file.txt").exists();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:189:13+ |+LL | let _ = std::net::TcpListener::bind("127.0.0.1:0");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:193:13+ |+LL | let _ = std::net::TcpStream::connect("127.0.0.1:80");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:198:13+ |+LL | let _ = std::net::TcpStream::connect_timeout(&addr, std::time::Duration::from_secs(1));+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:202:27+ |+LL | if let Ok(listener) = std::net::TcpListener::bind("127.0.0.1:0") {+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:203:17+ |+LL | let _ = listener.accept();+ | ^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:208:13+ |+LL | let _ = std::net::UdpSocket::bind("127.0.0.1:0");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:212:25+ |+LL | if let Ok(socket) = std::net::UdpSocket::bind("127.0.0.1:0") {+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:214:17+ |+LL | let _ = socket.recv_from(&mut buf);+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:221:13+ |+LL | let _ = std::process::Command::new("echo").output();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:225:13+ |+LL | let _ = std::process::Command::new("echo").status();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:229:13+ |+LL | let _ = std::process::Command::new("echo").spawn();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:233:28+ |+LL | if let Ok(mut child) = std::process::Command::new("echo").spawn() {+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:234:17+ |+LL | let _ = child.wait();+ | ^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:239:24+ |+LL | if let Ok(child) = std::process::Command::new("echo").spawn() {+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:240:17+ |+LL | let _ = child.wait_with_output();+ | ^^^^^^^^^^^^^^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:248:13+ |+LL | let _ = m.lock();+ | ^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:253:13+ |+LL | let _ = rw.read();+ | ^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:258:13+ |+LL | let _ = rw.write();+ | ^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:263:5+ |+LL | b.wait();+ | ^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:268:13+ |+LL | let _ = rx.recv();+ | ^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:273:13+ |+LL | let _ = tx.send(42);+ | ^^^^^^^^^^^++error: blocking IO call on the GPUI foreground thread+ --> $DIR/blocking_io_on_foreground.rs:282:17+ |+LL | let _ = std::fs::read_to_string("layout.toml");+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: aborting due to 65 previous errors+diff --git a/tooling/lints/ui/entity_update_in_render.rs b/tooling/lints/ui/entity_update_in_render.rsnew file mode 100644index 00000000000..d9e733902a1--- /dev/null+++ b/tooling/lints/ui/entity_update_in_render.rs@@ -0,0 +1,116 @@+// Tests for the `entity_update_in_render` lint.++#![allow(unused)]++extern crate gpui;++use gpui::*;++struct Counter {+ value: i32,+}++// ============================================================+// SHOULD WARN — .update() returning () inside Render::render+// ============================================================++struct MutatingView {+ counter: Entity<Counter>,+}++impl Render for MutatingView {+ fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {+ self.counter.update(cx, |counter, _cx| {+ counter.value += 1;+ });+ ()+ }+}++// WeakEntity::update returning Result<(), _> inside Render::render+struct WeakMutatingView {+ counter: WeakEntity<Counter>,+}++impl Render for WeakMutatingView {+ fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {+ let _ = self.counter.update(cx, |counter, _cx| {+ counter.value += 1;+ });+ ()+ }+}++// Entity::update returning () inside RenderOnce::render+struct OnceMutatingView {+ counter: Entity<Counter>,+}++impl RenderOnce for OnceMutatingView {+ fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {+ self.counter.update(cx, |counter, _cx| {+ counter.value += 1;+ });+ ()+ }+}++// ============================================================+// SHOULD NOT WARN+// ============================================================++// .update() returning a value (reading, not mutating)+struct ReadingView {+ counter: Entity<Counter>,+}++impl Render for ReadingView {+ fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {+ let _val: i32 = self.counter.update(cx, |counter, _cx| counter.value);+ ()+ }+}++// .update() inside a closure (e.g. event handler), not directly in render+struct ClosureView {+ counter: Entity<Counter>,+}++impl Render for ClosureView {+ fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {+ let counter = &self.counter;+ let _handler = |cx: &mut App| {+ counter.update(cx, |counter, _cx| {+ counter.value += 1;+ });+ };+ ()+ }+}++// .update() outside of render entirely+fn update_outside_render(entity: &Entity<Counter>, cx: &mut App) {+ entity.update(cx, |counter, _cx| {+ counter.value += 1;+ });+}++// .update() on a non-gpui type (unrelated method named "update")+struct FakeEntity;++impl FakeEntity {+ fn update(&self) {}+}++struct FakeView {+ thing: FakeEntity,+}++impl Render for FakeView {+ fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {+ self.thing.update();+ ()+ }+}++fn main() {}diff --git a/tooling/lints/ui/entity_update_in_render.stderr b/tooling/lints/ui/entity_update_in_render.stderrnew file mode 100644index 00000000000..53d9b7d9927--- /dev/null+++ b/tooling/lints/ui/entity_update_in_render.stderr@@ -0,0 +1,30 @@+error: entity `.update()` called during render mutates state in the render pass+ --> $DIR/entity_update_in_render.rs:23:9+ |+LL | / self.counter.update(cx, |counter, _cx| {+LL | | counter.value += 1;+LL | | });+ | |__________^+ |+ = note: `-D entity-update-in-render` implied by `-D warnings`+ = help: to override `-D warnings` add `#[allow(entity_update_in_render)]`++error: entity `.update()` called during render mutates state in the render pass+ --> $DIR/entity_update_in_render.rs:37:17+ |+LL | let _ = self.counter.update(cx, |counter, _cx| {+ | _________________^+LL | | counter.value += 1;+LL | | });+ | |__________^++error: entity `.update()` called during render mutates state in the render pass+ --> $DIR/entity_update_in_render.rs:51:9+ |+LL | / self.counter.update(cx, |counter, _cx| {+LL | | counter.value += 1;+LL | | });+ | |__________^++error: aborting due to 3 previous errors+diff --git a/tooling/lints/ui/owned_string_into_shared.rs b/tooling/lints/ui/owned_string_into_shared.rsnew file mode 100644index 00000000000..b4dd0aa9f54--- /dev/null+++ b/tooling/lints/ui/owned_string_into_shared.rs@@ -0,0 +1,68 @@+// Tests for the `owned_string_into_shared` lint.++#![allow(unused)]++use std::borrow::Cow;+use std::rc::Rc;+use std::sync::Arc;++fn main() {+ // --- Should warn ---++ // String::from(<literal>).into() into Arc<str>.+ let _a: Arc<str> = String::from("hello").into();++ // String::from(<literal>).into() into Rc<str>.+ let _b: Rc<str> = String::from("world").into();++ // String::from(<literal>).into() into Cow<'_, str>.+ let _c: Cow<'_, str> = String::from("borrowed-or-owned").into();++ // <literal>.to_string().into() into Arc<str>.+ let _d: Arc<str> = "via-to-string".to_string().into();++ // <literal>.to_owned().into() into Arc<str>.+ let _e: Arc<str> = "via-to-owned".to_owned().into();++ // <literal>.to_string().into() into Rc<str>.+ let _f: Rc<str> = "rc-via-to-string".to_string().into();++ // <literal>.to_owned().into() into Cow<'_, str>.+ let _g: Cow<'_, str> = "cow-via-to-owned".to_owned().into();++ // Long literal still flagged the same way.+ let _h: Arc<str> =+ String::from("this literal is definitely longer than twenty three bytes").into();++ // --- Should NOT warn ---++ // Direct construction from the literal — already optimal.+ let _ok1: Arc<str> = Arc::from("hello");+ let _ok2: Rc<str> = Rc::from("world");+ let _ok3: Cow<'_, str> = Cow::Borrowed("borrowed");++ // Producing a plain `String` (not a refcounted destination).+ let _ok4: String = String::from("not refcounted");+ let _ok5: String = "x".to_string();+ let _ok6: String = "x".to_owned();++ // `.into()` from a non-literal `String` — the allocation is unavoidable.+ let dynamic: String = make_string();+ let _ok7: Arc<str> = dynamic.into();++ // `.into()` from a `&str` directly (no owned `String` in between).+ let _ok8: Arc<str> = "direct".into();++ // `.into()` whose destination is not one of the targeted types.+ let _ok9: Box<str> = String::from("box-str").into();++ // `String::new()` is not built from a literal.+ let _ok10: Arc<str> = String::new().into();++ // Method call that is not `into`.+ let _ok11: String = String::from("foo").clone();+}++fn make_string() -> String {+ String::from("dynamic")+}diff --git a/tooling/lints/ui/owned_string_into_shared.stderr b/tooling/lints/ui/owned_string_into_shared.stderrnew file mode 100644index 00000000000..ec6e13ea508--- /dev/null+++ b/tooling/lints/ui/owned_string_into_shared.stderr@@ -0,0 +1,53 @@+error: this allocates an owned `String` from a string literal only to convert it into a refcounted string+ --> $DIR/owned_string_into_shared.rs:13:24+ |+LL | let _a: Arc<str> = String::from("hello").into();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^+ |+ = note: `-D owned-string-into-shared` implied by `-D warnings`+ = help: to override `-D warnings` add `#[allow(owned_string_into_shared)]`++error: this allocates an owned `String` from a string literal only to convert it into a refcounted string+ --> $DIR/owned_string_into_shared.rs:16:23+ |+LL | let _b: Rc<str> = String::from("world").into();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: this allocates an owned `String` from a string literal only to convert it into a refcounted string+ --> $DIR/owned_string_into_shared.rs:19:28+ |+LL | let _c: Cow<'_, str> = String::from("borrowed-or-owned").into();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: this allocates an owned `String` from a string literal only to convert it into a refcounted string+ --> $DIR/owned_string_into_shared.rs:22:24+ |+LL | let _d: Arc<str> = "via-to-string".to_string().into();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: this allocates an owned `String` from a string literal only to convert it into a refcounted string+ --> $DIR/owned_string_into_shared.rs:25:24+ |+LL | let _e: Arc<str> = "via-to-owned".to_owned().into();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: this allocates an owned `String` from a string literal only to convert it into a refcounted string+ --> $DIR/owned_string_into_shared.rs:28:23+ |+LL | let _f: Rc<str> = "rc-via-to-string".to_string().into();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: this allocates an owned `String` from a string literal only to convert it into a refcounted string+ --> $DIR/owned_string_into_shared.rs:31:28+ |+LL | let _g: Cow<'_, str> = "cow-via-to-owned".to_owned().into();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: this allocates an owned `String` from a string literal only to convert it into a refcounted string+ --> $DIR/owned_string_into_shared.rs:35:9+ |+LL | String::from("this literal is definitely longer than twenty three bytes").into();+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^++error: aborting due to 8 previous errors+