//! The code in this module gathers up all of the inherent impls in
//! the current crate and organizes them in a map. It winds up
//! touching the whole crate and thus must be recomputed completely
//! for any change, but it is very cheap to compute. In practice, most
//! code in the compiler never *directly* requests this map. Instead,
//! it requests the inherent impls specific to some type (via
//! `tcx.inherent_impls(def_id)`). That value, however,
//! is computed by selecting an idea from this table.

use rustc_errors::struct_span_err;
use rustc_hir as hir;
use rustc_hir::def_id::{CrateNum, DefId, LocalDefId};
use rustc_hir::itemlikevisit::ItemLikeVisitor;
use rustc_middle::ty::fast_reject::{simplify_type, SimplifiedType, TreatParams};
use rustc_middle::ty::{self, CrateInherentImpls, Ty, TyCtxt};
use rustc_span::symbol::sym;
use rustc_span::Span;

/// On-demand query: yields a map containing all types mapped to their inherent impls.
pub fn crate_inherent_impls(tcx: TyCtxt<'_>, (): ()) -> CrateInherentImpls {
    let mut collect = InherentCollect { tcx, impls_map: Default::default() };
    tcx.hir().visit_all_item_likes(&mut collect);
    collect.impls_map
}

pub fn crate_incoherent_impls(tcx: TyCtxt<'_>, (_, simp): (CrateNum, SimplifiedType)) -> &[DefId] {
    let crate_map = tcx.crate_inherent_impls(());
    tcx.arena.alloc_from_iter(
        crate_map.incoherent_impls.get(&simp).unwrap_or(&Vec::new()).iter().map(|d| d.to_def_id()),
    )
}

/// On-demand query: yields a vector of the inherent impls for a specific type.
pub fn inherent_impls(tcx: TyCtxt<'_>, ty_def_id: DefId) -> &[DefId] {
    let ty_def_id = ty_def_id.expect_local();

    let crate_map = tcx.crate_inherent_impls(());
    match crate_map.inherent_impls.get(&ty_def_id) {
        Some(v) => &v[..],
        None => &[],
    }
}

struct InherentCollect<'tcx> {
    tcx: TyCtxt<'tcx>,
    impls_map: CrateInherentImpls,
}

impl<'tcx> ItemLikeVisitor<'_> for InherentCollect<'tcx> {
    fn visit_item(&mut self, item: &hir::Item<'_>) {
        let hir::ItemKind::Impl(hir::Impl { of_trait: None, self_ty: ty, ref items, .. }) = item.kind else {
            return;
        };

        let self_ty = self.tcx.type_of(item.def_id);
        match *self_ty.kind() {
            ty::Adt(def, _) => {
                let def_id = def.did();
                if !def_id.is_local() && Some(def_id) == self.tcx.lang_items().c_str() {
                    self.check_primitive_impl(item.def_id, self_ty, items, ty.span)
                } else {
                    self.check_def_id(item, def_id);
                }
            }
            ty::Foreign(did) => {
                self.check_def_id(item, did);
            }
            ty::Dynamic(data, ..) if data.principal_def_id().is_some() => {
                self.check_def_id(item, data.principal_def_id().unwrap());
            }
            ty::Dynamic(..) => {
                struct_span_err!(
                    self.tcx.sess,
                    ty.span,
                    E0785,
                    "cannot define inherent `impl` for a dyn auto trait"
                )
                .span_label(ty.span, "impl requires at least one non-auto trait")
                .note("define and implement a new trait or type instead")
                .emit();
            }
            ty::Bool
            | ty::Char
            | ty::Int(_)
            | ty::Uint(_)
            | ty::Float(_)
            | ty::Str
            | ty::Array(..)
            | ty::Slice(_)
            | ty::RawPtr(_)
            | ty::Ref(..)
            | ty::Never
            | ty::Tuple(..) => self.check_primitive_impl(item.def_id, self_ty, items, ty.span),
            ty::FnPtr(_) | ty::Projection(..) | ty::Opaque(..) | ty::Param(_) => {
                let mut err = struct_span_err!(
                    self.tcx.sess,
                    ty.span,
                    E0118,
                    "no nominal type found for inherent implementation"
                );

                err.span_label(ty.span, "impl requires a nominal type")
                    .note("either implement a trait on it or create a newtype to wrap it instead");

                err.emit();
            }
            ty::FnDef(..)
            | ty::Closure(..)
            | ty::Generator(..)
            | ty::GeneratorWitness(..)
            | ty::Bound(..)
            | ty::Placeholder(_)
            | ty::Infer(_) => {
                bug!("unexpected impl self type of impl: {:?} {:?}", item.def_id, self_ty);
            }
            ty::Error(_) => {}
        }
    }

    fn visit_trait_item(&mut self, _trait_item: &hir::TraitItem<'_>) {}

    fn visit_impl_item(&mut self, _impl_item: &hir::ImplItem<'_>) {}

    fn visit_foreign_item(&mut self, _foreign_item: &hir::ForeignItem<'_>) {}
}

impl<'tcx> InherentCollect<'tcx> {
    fn check_def_id(&mut self, item: &hir::Item<'_>, def_id: DefId) {
        if let Some(def_id) = def_id.as_local() {
            // Add the implementation to the mapping from implementation to base
            // type def ID, if there is a base type for this implementation and
            // the implementation does not have any associated traits.
            let vec = self.impls_map.inherent_impls.entry(def_id).or_default();
            vec.push(item.def_id.to_def_id());
        } else {
            struct_span_err!(
                self.tcx.sess,
                item.span,
                E0116,
                "cannot define inherent `impl` for a type outside of the crate \
                              where the type is defined"
            )
            .span_label(item.span, "impl for type defined outside of crate.")
            .note("define and implement a trait or new type instead")
            .emit();
        }
    }

    fn check_primitive_impl(
        &mut self,
        impl_def_id: LocalDefId,
        ty: Ty<'tcx>,
        items: &[hir::ImplItemRef],
        span: Span,
    ) {
        const INTO_CORE: &str = "consider moving this inherent impl into `core` if possible";
        const ADD_ATTR: &str =
            "alternatively add `#[rustc_allow_incoherent_impl]` to the relevant impl items";
        if !self.tcx.hir().rustc_coherence_is_core() {
            if self.tcx.features().rustc_attrs {
                for item in items {
                    if !self
                        .tcx
                        .has_attr(item.id.def_id.to_def_id(), sym::rustc_allow_incoherent_impl)
                    {
                        struct_span_err!(
                            self.tcx.sess,
                            span,
                            E0390,
                            "cannot define inherent `impl` for primitive types outside of `core`",
                        )
                        .help(INTO_CORE)
                        .span_help(item.span, ADD_ATTR)
                        .emit();
                        return;
                    }
                }
            } else {
                let mut err = struct_span_err!(
                    self.tcx.sess,
                    span,
                    E0390,
                    "cannot define inherent `impl` for primitive types",
                );
                err.help("consider using an extension trait instead");
                if let ty::Ref(_, subty, _) = ty.kind() {
                    err.note(&format!(
                        "you could also try moving the reference to \
                            uses of `{}` (such as `self`) within the implementation",
                        subty
                    ));
                }
                err.emit();
                return;
            }
        }

        if let Some(simp) = simplify_type(self.tcx, ty, TreatParams::AsPlaceholders) {
            self.impls_map.incoherent_impls.entry(simp).or_default().push(impl_def_id);
        } else {
            bug!("unexpected primitive type: {:?}", ty);
        }
    }
}