rustc_trait_selection/error_reporting/traits/

mod.rs

pub mod ambiguity;
pub mod call_kind;
pub mod fulfillment_errors;
pub mod on_unimplemented;
mod overflow;
pub mod suggestions;

use std::{fmt, iter};

use rustc_crate_store::{ExternCrate, ExternCrateSource};
use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
use rustc_data_structures::unord::UnordSet;
use rustc_errors::{Applicability, Diag, E0038, E0276, MultiSpan, struct_span_code_err};
use rustc_hir::attrs::lang_items::LangItem;
use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
use rustc_hir::intravisit::Visitor;
use rustc_hir::{self as hir, AmbigArg};
use rustc_infer::traits::solve::Goal;
use rustc_infer::traits::{
    DynCompatibilityViolation, Obligation, ObligationCause, ObligationCauseCode,
    PredicateObligation, SelectionError,
};
use rustc_middle::ty::print::{PrintTraitRefExt as _, with_no_trimmed_paths};
use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitableExt as _};
use rustc_next_trait_solver::solve::TyOrConstInferVar;
use rustc_span::{DesugaringKind, ErrorGuaranteed, ExpnKind, Span};
use thin_vec::ThinVec;
use tracing::{info, instrument};

pub use self::overflow::*;
use crate::error_reporting::TypeErrCtxt;
use crate::traits::{FulfillmentError, FulfillmentErrorCode};

// When outputting impl candidates, prefer showing those that are more similar.
//
// We also compare candidates after skipping lifetimes, which has a lower
// priority than exact matches.
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub enum CandidateSimilarity {
    Exact { ignoring_lifetimes: bool },
    Fuzzy { ignoring_lifetimes: bool },
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ImplCandidate<'tcx> {
    pub trait_ref: ty::TraitRef<'tcx>,
    pub similarity: CandidateSimilarity,
    impl_def_id: DefId,
}

enum GetSafeTransmuteErrorAndReason {
    Silent,
    Default,
    Error { err_msg: String, safe_transmute_explanation: Option<String> },
}

/// Crude way of getting back an `Expr` from a `Span`.
pub struct FindExprBySpan<'hir> {
    pub span: Span,
    pub result: Option<&'hir hir::Expr<'hir>>,
    pub ty_result: Option<&'hir hir::Ty<'hir>>,
    pub include_closures: bool,
    pub tcx: TyCtxt<'hir>,
}

impl<'hir> FindExprBySpan<'hir> {
    pub fn new(span: Span, tcx: TyCtxt<'hir>) -> Self {
        Self { span, result: None, ty_result: None, tcx, include_closures: false }
    }
}

impl<'v> Visitor<'v> for FindExprBySpan<'v> {
    type NestedFilter = rustc_middle::hir::nested_filter::OnlyBodies;

    fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
        self.tcx
    }

    fn visit_expr(&mut self, ex: &'v hir::Expr<'v>) {
        if self.span == ex.span {
            self.result = Some(ex);
        } else {
            if let hir::ExprKind::Closure(..) = ex.kind
                && self.include_closures
                && let closure_header_sp = self.span.with_hi(ex.span.hi())
                && closure_header_sp == ex.span
            {
                self.result = Some(ex);
            }
            hir::intravisit::walk_expr(self, ex);
        }
    }

    fn visit_ty(&mut self, ty: &'v hir::Ty<'v, AmbigArg>) {
        if self.span == ty.span {
            self.ty_result = Some(ty.as_unambig_ty());
        } else {
            hir::intravisit::walk_ty(self, ty);
        }
    }
}

/// Summarizes information
#[derive(Clone)]
pub enum ArgKind {
    /// An argument of non-tuple type. Parameters are (name, ty)
    Arg(String, String),

    /// An argument of tuple type. For a "found" argument, the span is
    /// the location in the source of the pattern. For an "expected"
    /// argument, it will be None. The vector is a list of (name, ty)
    /// strings for the components of the tuple.
    Tuple(Option<Span>, Vec<(String, String)>),
}

impl ArgKind {
    fn empty() -> ArgKind {
        ArgKind::Arg("_".to_owned(), "_".to_owned())
    }

    /// Creates an `ArgKind` from the expected type of an
    /// argument. It has no name (`_`) and an optional source span.
    pub fn from_expected_ty(t: Ty<'_>, span: Option<Span>) -> ArgKind {
        match t.kind() {
            ty::Tuple(tys) => ArgKind::Tuple(
                span,
                tys.iter().map(|ty| ("_".to_owned(), ty.to_string())).collect::<Vec<_>>(),
            ),
            _ => ArgKind::Arg("_".to_owned(), t.to_string()),
        }
    }
}

#[derive(Copy, Clone)]
pub enum DefIdOrName {
    DefId(DefId),
    Name(&'static str),
}

impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
    pub fn report_fulfillment_errors(
        &self,
        mut errors: ThinVec<FulfillmentError<'tcx>>,
    ) -> ErrorGuaranteed {
        #[derive(Debug)]
        struct ErrorDescriptor<'tcx> {
            goal: Goal<'tcx, ty::Predicate<'tcx>>,
            index: Option<usize>, // None if this is an old error
        }

        let mut error_map: FxIndexMap<_, Vec<_>> = self
            .reported_trait_errors
            .borrow()
            .iter()
            .map(|(&span, goals)| {
                (span, goals.0.iter().map(|&goal| ErrorDescriptor { goal, index: None }).collect())
            })
            .collect();

        // Ensure `T: Sized`, `T: MetaSized`, `T: PointeeSized` and `T: WF` obligations come last,
        // and `Subtype` obligations from `FormatLiteral` desugarings come first.
        // This lets us display diagnostics with more relevant type information and hide redundant
        // E0282 errors.
        #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
        enum ErrorSortKey {
            SubtypeFormat(usize, usize),
            OtherKind,
            SizedTrait,
            MetaSizedTrait,
            PointeeSizedTrait,
            Coerce,
            WellFormed,
        }
        errors.sort_by_key(|e| {
            let maybe_sizedness_did = match e.obligation.predicate.kind().skip_binder() {
                ty::PredicateKind::Clause(ty::ClauseKind::Trait(pred)) => Some(pred.def_id()),
                ty::PredicateKind::Clause(ty::ClauseKind::HostEffect(pred)) => Some(pred.def_id()),
                _ => None,
            };

            match e.obligation.predicate.kind().skip_binder() {
                ty::PredicateKind::Subtype(_)
                    if matches!(
                        e.obligation.cause.span.desugaring_kind(),
                        Some(DesugaringKind::FormatLiteral { .. })
                    ) =>
                {
                    let (_, row, col, ..) =
                        self.tcx.sess.source_map().span_to_location_info(e.obligation.cause.span);
                    ErrorSortKey::SubtypeFormat(row, col)
                }
                _ if maybe_sizedness_did == self.tcx.lang_items().sized_trait() => {
                    ErrorSortKey::SizedTrait
                }
                _ if maybe_sizedness_did == self.tcx.lang_items().meta_sized_trait() => {
                    ErrorSortKey::MetaSizedTrait
                }
                _ if maybe_sizedness_did == self.tcx.lang_items().pointee_sized_trait() => {
                    ErrorSortKey::PointeeSizedTrait
                }
                ty::PredicateKind::Coerce(_) => ErrorSortKey::Coerce,
                ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(_)) => {
                    ErrorSortKey::WellFormed
                }
                _ => ErrorSortKey::OtherKind,
            }
        });

        for (index, error) in errors.iter().enumerate() {
            // We want to ignore desugarings here: spans are equivalent even
            // if one is the result of a desugaring and the other is not.
            let mut span = error.obligation.cause.span;
            let expn_data = span.ctxt().outer_expn_data();
            if let ExpnKind::Desugaring(_) = expn_data.kind {
                span = expn_data.call_site;
            }

            error_map
                .entry(span)
                .or_default()
                .push(ErrorDescriptor { goal: error.obligation.as_goal(), index: Some(index) });
        }

        // We do this in 2 passes because we want to display errors in order, though
        // maybe it *is* better to sort errors by span or something.
        let mut is_suppressed = vec![false; errors.len()];
        // A failing trait goal also fails every projection goal resting on it. Ambiguity
        // errors are exempt: they get merged into a single diagnostic whose notes list all
        // the constraints the annotation has to satisfy, so their projections still say
        // something the trait error doesn't.
        let covered_by_trait_error =
            |cond: &ErrorDescriptor<'tcx>, error: &ErrorDescriptor<'tcx>| {
                let is_definite = |error: &ErrorDescriptor<'tcx>| {
                    error.index.is_some_and(|index| {
                        !matches!(errors[index].code, FulfillmentErrorCode::Ambiguity { .. })
                    })
                };
                is_definite(cond)
                    && is_definite(error)
                    && self.trait_error_implies_projection_error(cond.goal, error.goal)
            };
        for (_, error_set) in error_map.iter() {
            // We want to suppress "duplicate" errors with the same span.
            for error in error_set {
                if let Some(index) = error.index {
                    // Suppress errors that are either:
                    // 1) strictly implied by another error.
                    // 2) implied by an error with a smaller index.
                    for error2 in error_set {
                        if error2.index.is_some_and(|index2| is_suppressed[index2]) {
                            // Avoid errors being suppressed by already-suppressed
                            // errors, to prevent all errors from being suppressed
                            // at once.
                            continue;
                        }

                        if (self.error_implies(error2.goal, error.goal)
                            && !(error2.index >= error.index
                                && self.error_implies(error.goal, error2.goal)))
                            || covered_by_trait_error(error2, error)
                        {
                            info!("skipping {:?} (implied by {:?})", error, error2);
                            is_suppressed[index] = true;
                            break;
                        }
                    }
                }
            }
        }

        // Ambiguity errors blaming the same inference variable describe a single problem:
        // annotating that one variable has to satisfy all of them at once. Reporting them
        // separately loses all but the first, as the rest get canceled as duplicates once
        // the `infcx` is tainted (see `maybe_report_ambiguity`), hiding their requirements
        // from the user. Instead, report the first one (the sort above placed the most
        // informative obligation first) and mention the requirements of the others in it.
        //
        // Type variables that are only related through a pending `Coerce` or `Subtype`
        // obligation still concern the same annotation, so compare their sub-unification
        // roots, like `need_type_info` does when looking for the annotation source.
        let ambiguity_infer_var = |error: &FulfillmentError<'tcx>| match error.code {
            FulfillmentErrorCode::Ambiguity { overflow: None } => self
                .ambiguity_term(self.resolve_vars_if_possible(error.obligation.predicate))
                .and_then(|term| {
                    ty::GenericArg::from(term)
                        .walk()
                        .find_map(TyOrConstInferVar::maybe_from_generic_arg::<TyCtxt<'tcx>>)
                })
                .map(|var| match var {
                    TyOrConstInferVar::Ty(vid) => {
                        TyOrConstInferVar::Ty(self.sub_unification_table_root_var(vid))
                    }
                    other => other,
                }),
            _ => None,
        };
        let infer_vars: Vec<_> = errors.iter().map(ambiguity_infer_var).collect();

        let mut reported = None;
        let mut merged = vec![None; errors.len()];
        let mut reported_as_primary = vec![false; errors.len()];
        for from_expansion in [false, true] {
            for (index, (error, suppressed)) in iter::zip(&errors, &is_suppressed).enumerate() {
                if !suppressed && error.obligation.cause.span.from_expansion() == from_expansion {
                    if !error.references_error() {
                        let guar = if let Some(guar) = merged[index] {
                            guar
                        } else {
                            let group: Vec<usize> = match infer_vars[index] {
                                Some(var) => (0..errors.len())
                                    .filter(|&other| {
                                        other != index && infer_vars[other] == Some(var)
                                    })
                                    .collect(),
                                None => vec![],
                            };
                            // Only merge errors that a note on this diagnostic can fully
                            // represent. An error blaming a different expression labels that
                            // expression and suggests how to annotate it, and one whose
                            // predicate we can't phrase as a note (e.g. const evaluatability)
                            // says nothing here, so both keep their own error.
                            let merges = |other: usize| {
                                errors[other].obligation.cause.span == error.obligation.cause.span
                                    && match errors[other].obligation.predicate.kind().skip_binder()
                                    {
                                        ty::PredicateKind::Clause(ty::ClauseKind::Trait(data)) => {
                                            !matches!(
                                                self.tcx.as_lang_item(data.def_id()),
                                                Some(
                                                    LangItem::Sized
                                                        | LangItem::MetaSized
                                                        | LangItem::PointeeSized
                                                )
                                            )
                                        }
                                        ty::PredicateKind::Clause(ty::ClauseKind::Projection(
                                            _,
                                        )) => true,
                                        _ => false,
                                    }
                            };
                            let related: Vec<_> = group
                                .iter()
                                .filter(|&&other| {
                                    // Exclude already-reported primaries: they were their own
                                    // canonical error and adding them as notes here would
                                    // produce duplicate information.
                                    merges(other)
                                        && !is_suppressed[other]
                                        && !errors[other].references_error()
                                        && !reported_as_primary[other]
                                })
                                .map(|&other| &errors[other])
                                .collect();
                            let guar = self.report_fulfillment_error(error, &related);
                            for &other in &group {
                                if merges(other) {
                                    merged[other] = Some(guar);
                                }
                            }
                            reported_as_primary[index] = true;
                            guar
                        };
                        self.infcx.set_tainted_by_errors(guar);
                        reported = Some(guar);
                        // We want to ignore desugarings here: spans are equivalent even
                        // if one is the result of a desugaring and the other is not.
                        let mut span = error.obligation.cause.span;
                        let expn_data = span.ctxt().outer_expn_data();
                        if let ExpnKind::Desugaring(_) = expn_data.kind {
                            span = expn_data.call_site;
                        }
                        self.reported_trait_errors
                            .borrow_mut()
                            .entry(span)
                            .or_insert_with(|| (vec![], guar))
                            .0
                            .push(error.obligation.as_goal());
                    }
                    if let Some(guar) = self.dcx().has_errors() {
                        self.infcx.set_tainted_by_errors(guar);
                    }
                }
            }
        }

        // It could be that we don't report an error because we have seen an `ErrorReported` from
        // another source. We should probably be able to fix most of these, but some are delayed
        // bugs that get a proper error after this function.
        reported.unwrap_or_else(|| self.dcx().delayed_bug("failed to report fulfillment errors"))
    }

    #[instrument(skip(self), level = "debug")]
    fn report_fulfillment_error(
        &self,
        error: &FulfillmentError<'tcx>,
        related: &[&FulfillmentError<'tcx>],
    ) -> ErrorGuaranteed {
        let mut error = FulfillmentError {
            obligation: error.obligation.clone(),
            code: error.code.clone(),
            root_obligation: error.root_obligation.clone(),
        };
        if matches!(
            error.code,
            FulfillmentErrorCode::Select(crate::traits::SelectionError::Unimplemented)
                | FulfillmentErrorCode::Project(_)
        ) && self.apply_do_not_recommend(&mut error.obligation, &error.root_obligation)
        {
            error.code = FulfillmentErrorCode::Select(SelectionError::Unimplemented);
        }

        match error.code {
            FulfillmentErrorCode::Select(ref selection_error) => self.report_selection_error(
                error.obligation.clone(),
                &error.root_obligation,
                selection_error,
            ),
            FulfillmentErrorCode::Project(ref e) => {
                self.report_projection_error(&error.obligation, e)
            }
            FulfillmentErrorCode::Outlives => self
                .dcx()
                .struct_span_err(
                    error.obligation.cause.span,
                    "higher-ranked lifetime bound could not be satisfied",
                )
                .emit(),
            FulfillmentErrorCode::Ambiguity { overflow: None } => {
                self.maybe_report_ambiguity(&error.obligation, related)
            }
            FulfillmentErrorCode::Ambiguity { overflow: Some(suggest_increasing_limit) } => {
                self.report_overflow_no_abort(error.obligation.clone(), suggest_increasing_limit)
            }
            FulfillmentErrorCode::Subtype(ref expected_found, ref err) => self
                .report_mismatched_types(
                    &error.obligation.cause,
                    error.obligation.param_env,
                    expected_found.expected,
                    expected_found.found,
                    *err,
                )
                .emit(),
            FulfillmentErrorCode::ConstEquate(ref expected_found, ref err) => {
                let mut diag = self.report_mismatched_consts(
                    &error.obligation.cause,
                    error.obligation.param_env,
                    expected_found.expected,
                    expected_found.found,
                    *err,
                );
                let code = error.obligation.cause.code().peel_derives().peel_match_impls();
                if let ObligationCauseCode::WhereClause(..)
                | ObligationCauseCode::WhereClauseInExpr(..) = code
                {
                    self.note_obligation_cause_code(
                        error.obligation.cause.body_def_id,
                        &mut diag,
                        error.obligation.predicate,
                        error.obligation.param_env,
                        code,
                        &mut vec![],
                        &mut Default::default(),
                    );
                }
                diag.emit()
            }
            FulfillmentErrorCode::Cycle(ref cycle) => self.report_overflow_obligation_cycle(cycle),
        }
    }

    /// If the crates of `expected_def_id` and `trait_def_id` are imported as extern crate
    /// under the same name (`extern crate foo as a` and `extern crate bar as a`) returns true,
    /// otherwise returns false.
    fn extern_crates_with_the_same_name(
        &self,
        expected_def_id: DefId,
        trait_def_id: DefId,
    ) -> bool {
        if expected_def_id.is_local() || trait_def_id.is_local() {
            return false;
        }
        // We only compare direct dependencies of the current crate, so it avoids unnecessary
        // processing and excludes indirect dependencies, like `std` or `core`. In such a case
        // both would be imported under the same name `std`.
        match (
            self.tcx.extern_crate(expected_def_id.krate),
            self.tcx.extern_crate(trait_def_id.krate),
        ) {
            (
                Some(&ExternCrate {
                    src: ExternCrateSource::Extern(expected_def_id),
                    dependency_of: LOCAL_CRATE,
                    ..
                }),
                Some(&ExternCrate {
                    src: ExternCrateSource::Extern(trait_def_id),
                    dependency_of: LOCAL_CRATE,
                    ..
                }),
            ) => self.tcx.item_name(expected_def_id) == self.tcx.item_name(trait_def_id),
            _ => false,
        }
    }

    pub fn check_same_definition_different_crate<F>(
        &self,
        err: &mut Diag<'_>,
        expected_did: DefId,
        found_dids: impl Iterator<Item = DefId>,
        get_impls: F,
        ty: &str,
    ) -> bool
    where
        F: Fn(DefId) -> Vec<Span>,
    {
        let krate = self.tcx.crate_name(expected_did.krate);
        let name = self.tcx.item_name(expected_did);
        let definitions_with_same_path: UnordSet<_> = found_dids
            .filter(|&def_id| {
                def_id.krate != expected_did.krate
                    && (self.extern_crates_with_the_same_name(expected_did, def_id)
                        || self.tcx.crate_name(def_id.krate) == krate)
                    && self.tcx.item_name(def_id) == name
            })
            .map(|def_id| (self.tcx.def_path_str(def_id), def_id))
            .collect();

        let definitions_with_same_path =
            definitions_with_same_path.into_items().into_sorted_stable_ord_by_key(|(p, _)| p);
        let mut suggested = false;
        let mut trait_is_impl = false;

        if !definitions_with_same_path.is_empty() {
            let mut span: MultiSpan = self.tcx.def_span(expected_did).into();
            span.push_span_label(
                self.tcx.def_span(expected_did),
                format!("this is the expected {ty}"),
            );
            suggested = true;
            for (_, definition_with_same_path) in &definitions_with_same_path {
                let definitions_impls = get_impls(*definition_with_same_path);
                if definitions_impls.is_empty() {
                    continue;
                }

                for candidate_span in definitions_impls {
                    span.push_span_label(candidate_span, format!("this is the found {ty}"));
                    trait_is_impl = true;
                }
            }
            if !trait_is_impl {
                for (_, def_id) in definitions_with_same_path {
                    span.push_span_label(
                        self.tcx.def_span(def_id),
                        format!("this is the {ty} that was imported"),
                    );
                }
            }
            self.note_two_crate_versions(expected_did.krate, span, err);
            err.help("you can use `cargo tree` to explore your dependency tree");
        }
        suggested
    }
}

/// Recovers the "impl X for Y" signature from `impl_def_id` and returns it as a
/// string.
pub(crate) fn to_pretty_impl_header(tcx: TyCtxt<'_>, impl_def_id: DefId) -> Option<String> {
    use std::fmt::Write;

    let trait_ref = tcx.impl_opt_trait_ref(impl_def_id)?.instantiate_identity().skip_norm_wip();
    let mut w = "impl".to_owned();

    #[derive(Debug, Default)]
    struct SizednessFound {
        sized: bool,
        meta_sized: bool,
    }

    let mut types_with_sizedness_bounds = FxIndexMap::<_, SizednessFound>::default();

    let args = ty::GenericArgs::identity_for_item(tcx, impl_def_id);

    let arg_names = args.iter().map(|k| k.to_string()).filter(|k| k != "'_").collect::<Vec<_>>();
    if !arg_names.is_empty() {
        w.push('<');
        w.push_str(&arg_names.join(", "));
        w.push('>');

        for ty in args.types() {
            // `PointeeSized` params might have no predicates.
            types_with_sizedness_bounds.insert(ty, SizednessFound::default());
        }
    }

    write!(
        w,
        " {}{} for {}",
        tcx.impl_polarity(impl_def_id).as_str(),
        trait_ref.print_only_trait_path(),
        tcx.type_of(impl_def_id).instantiate_identity().skip_norm_wip()
    )
    .unwrap();

    let clauses = tcx.clauses_of(impl_def_id).clauses;
    let mut pretty_clauses = Vec::with_capacity(clauses.len());

    let sized_trait = tcx.lang_items().sized_trait();
    let meta_sized_trait = tcx.lang_items().meta_sized_trait();

    for (c, _) in clauses {
        // Accumulate the sizedness bounds for each self ty.
        if let Some(trait_clause) = c.as_trait_clause() {
            let self_ty = trait_clause.self_ty().skip_binder();
            let sizedness_of = types_with_sizedness_bounds.entry(self_ty).or_default();
            if Some(trait_clause.def_id()) == sized_trait {
                sizedness_of.sized = true;
                continue;
            } else if Some(trait_clause.def_id()) == meta_sized_trait {
                sizedness_of.meta_sized = true;
                continue;
            }
        }

        pretty_clauses.push(c.to_string());
    }

    for (ty, sizedness) in types_with_sizedness_bounds {
        if !tcx.features().sized_hierarchy() {
            if sizedness.sized {
                // Maybe a default bound, don't write anything.
            } else {
                pretty_clauses.push(format!("{ty}: ?Sized"));
            }
        } else {
            if sizedness.sized {
                // Maybe a default bound, don't write anything.
                pretty_clauses.push(format!("{ty}: Sized"));
            } else if sizedness.meta_sized {
                pretty_clauses.push(format!("{ty}: MetaSized"));
            } else {
                pretty_clauses.push(format!("{ty}: PointeeSized"));
            }
        }
    }

    if !pretty_clauses.is_empty() {
        write!(w, "\n  where {}", pretty_clauses.join(", ")).unwrap();
    }

    w.push(';');
    Some(w)
}

impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
    pub fn report_extra_impl_obligation(
        &self,
        error_span: Span,
        impl_item_def_id: LocalDefId,
        trait_item_def_id: DefId,
        requirement: &dyn fmt::Display,
    ) -> Diag<'a> {
        let mut err = struct_span_code_err!(
            self.dcx(),
            error_span,
            E0276,
            "impl has stricter requirements than trait"
        );

        if !self.tcx.is_impl_trait_in_trait(trait_item_def_id) {
            if let Some(span) = self.tcx.hir_span_if_local(trait_item_def_id) {
                let item_name = self.tcx.item_name(impl_item_def_id.to_def_id());
                err.span_label(span, format!("definition of `{item_name}` from trait"));
            }
        }

        err.span_label(error_span, format!("impl has extra requirement {requirement}"));

        err
    }
}

pub fn report_dyn_incompatibility<'tcx>(
    tcx: TyCtxt<'tcx>,
    span: Span,
    hir_id: Option<hir::HirId>,
    trait_def_id: DefId,
    violations: &[DynCompatibilityViolation],
) -> Diag<'tcx> {
    let trait_str = tcx.def_path_str(trait_def_id);
    let trait_span = tcx.hir_get_if_local(trait_def_id).and_then(|node| match node {
        hir::Node::Item(item) => match item.kind {
            hir::ItemKind::Trait { ident, .. } | hir::ItemKind::TraitAlias(_, ident, _, _) => {
                Some(ident.span)
            }
            _ => unreachable!(),
        },
        _ => None,
    });

    let mut err = struct_span_code_err!(
        tcx.dcx(),
        span,
        E0038,
        "the {} `{}` is not dyn compatible",
        tcx.def_descr(trait_def_id),
        trait_str
    );
    err.span_label(span, format!("`{trait_str}` is not dyn compatible"));

    attempt_dyn_to_impl_suggestion(tcx, hir_id, &mut err);

    let mut reported_violations = FxIndexSet::default();
    let mut multi_span = vec![];
    let mut messages = vec![];
    for violation in violations {
        if let DynCompatibilityViolation::SizedSelf(sp) = &violation
            && !sp.is_empty()
        {
            // Do not report `SizedSelf` without spans pointing at `SizedSelf` obligations
            // with a `Span`.
            reported_violations.insert(DynCompatibilityViolation::SizedSelf(vec![].into()));
        }
        if reported_violations.insert(violation.clone()) {
            let spans = violation.spans();
            let msg = if trait_span.is_none() || spans.is_empty() {
                format!("the trait is not dyn compatible because {}", violation.error_msg())
            } else {
                format!("...because {}", violation.error_msg())
            };
            if spans.is_empty() {
                err.note(msg);
            } else {
                for span in spans {
                    multi_span.push(span);
                    messages.push(msg.clone());
                }
            }
        }
    }
    let has_multi_span = !multi_span.is_empty();
    let mut note_span = MultiSpan::from_spans(multi_span.clone());
    if let (Some(trait_span), true) = (trait_span, has_multi_span) {
        note_span.push_span_label(trait_span, "this trait is not dyn compatible...");
    }
    for (span, msg) in iter::zip(multi_span, messages) {
        note_span.push_span_label(span, msg);
    }
    err.span_note(
        note_span,
        "for a trait to be dyn compatible it needs to allow building a vtable\n\
        for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>",
    );

    // Only provide the help if its a local trait, otherwise it's not actionable.
    if trait_span.is_some() {
        let mut potential_solutions: Vec<_> =
            reported_violations.into_iter().map(|violation| violation.solution()).collect();
        potential_solutions.sort();
        // Allows us to skip suggesting that the same item should be moved to another trait multiple times.
        potential_solutions.dedup();
        for solution in potential_solutions {
            solution.add_to(&mut err);
        }
    }

    attempt_dyn_to_enum_suggestion(tcx, trait_def_id, &*trait_str, &mut err);

    err
}

/// Attempt to suggest converting the `dyn Trait` argument to an enumeration
/// over the types that implement `Trait`.
fn attempt_dyn_to_enum_suggestion(
    tcx: TyCtxt<'_>,
    trait_def_id: DefId,
    trait_str: &str,
    err: &mut Diag<'_>,
) {
    let impls_of = tcx.trait_impls_of(trait_def_id);

    if !impls_of.blanket_impls().is_empty() {
        return;
    }

    let concrete_impls: Option<Vec<Ty<'_>>> = impls_of
        .non_blanket_impls()
        .values()
        .flatten()
        .map(|impl_id| {
            // Don't suggest conversion to enum if the impl types have type parameters.
            // It's unlikely the user wants to define a generic enum.
            let Some(impl_type) = tcx.type_of(*impl_id).no_bound_vars() else { return None };

            // Obviously unsized impl types won't be usable in an enum.
            // Note: this doesn't use `Ty::has_trivial_sizedness` because that function
            // defaults to assuming that things are *not* sized, whereas we want to
            // fall back to assuming that things may be sized.
            match impl_type.kind() {
                ty::Str | ty::Slice(_) | ty::Dynamic(_, _) => {
                    return None;
                }
                _ => {}
            }
            Some(impl_type)
        })
        .collect();
    let Some(concrete_impls) = concrete_impls else { return };

    const MAX_IMPLS_TO_SUGGEST_CONVERTING_TO_ENUM: usize = 9;
    if concrete_impls.is_empty() || concrete_impls.len() > MAX_IMPLS_TO_SUGGEST_CONVERTING_TO_ENUM {
        return;
    }

    let externally_visible = if let Some(def_id) = trait_def_id.as_local() {
        // We may be executing this during typeck, which would result in cycle
        // if we used effective_visibilities query, which looks into opaque types
        // (and therefore calls typeck).
        tcx.resolutions(()).effective_visibilities.is_exported(def_id)
    } else {
        false
    };

    if let [only_impl] = &concrete_impls[..] {
        let within = if externally_visible { " within this crate" } else { "" };
        err.help(with_no_trimmed_paths!(format!(
            "only type `{only_impl}` implements `{trait_str}`{within}; \
            consider using it directly instead."
        )));
    } else {
        let types = concrete_impls
            .iter()
            .map(|t| with_no_trimmed_paths!(format!("  {}", t)))
            .collect::<Vec<String>>()
            .join("\n");

        err.help(format!(
            "the following types implement `{trait_str}`:\n\
             {types}\n\
             consider defining an enum where each variant holds one of these types,\n\
             implementing `{trait_str}` for this new enum and using it instead",
        ));
    }

    if externally_visible {
        err.note(format!(
            "`{trait_str}` may be implemented in other crates; if you want to support your users \
             passing their own types here, you can't refer to a specific type",
        ));
    }
}

/// Attempt to suggest that a `dyn Trait` argument or return type be converted
/// to use `impl Trait`.
fn attempt_dyn_to_impl_suggestion(tcx: TyCtxt<'_>, hir_id: Option<hir::HirId>, err: &mut Diag<'_>) {
    let Some(hir_id) = hir_id else { return };
    let hir::Node::Ty(ty) = tcx.hir_node(hir_id) else { return };
    let hir::TyKind::TraitObject([trait_ref, ..], ..) = ty.kind else { return };

    // Only suggest converting `dyn` to `impl` if we're in a function signature.
    // This ensures that we don't suggest converting e.g.
    //   `type Alias = Box<dyn DynIncompatibleTrait>;` to
    //   `type Alias = Box<impl DynIncompatibleTrait>;`
    let Some((_id, first_non_type_parent_node)) =
        tcx.hir_parent_iter(hir_id).find(|(_id, node)| !matches!(node, hir::Node::Ty(_)))
    else {
        return;
    };
    if first_non_type_parent_node.fn_sig().is_none() {
        return;
    }

    err.span_suggestion_verbose(
        ty.span.until(trait_ref.span),
        "consider using an opaque type instead",
        "impl ",
        Applicability::MaybeIncorrect,
    );
}