zed/tooling/lints/src/render_helpers.rs

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
}