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(..))
    )
}