rustc_trait_selection/traits/

mod.rs

//! Trait Resolution. See the [rustc dev guide] for more information on how this works.
//!
//! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/traits/resolution.html

pub mod auto_trait;
pub(crate) mod coherence;
pub mod const_evaluatable;
mod dyn_compatibility;
pub mod effects;
mod engine;
mod fulfill;
pub mod implied_outlives_bounds;
pub mod misc;
pub mod normalize;
pub mod outlives_bounds;
pub mod outlives_for_liveness;
pub mod project;
pub mod query;
pub mod select;
pub mod specialize;
mod structural_normalize;
pub mod util;
pub mod vtable;
pub mod wf;

use std::fmt::Debug;
use std::ops::ControlFlow;

use rustc_errors::ErrorGuaranteed;
pub use rustc_infer::traits::*;
use rustc_macros::TypeVisitable;
use rustc_middle::query::Providers;
use rustc_middle::ty::consts::ConstExt;
use rustc_middle::ty::error::{ExpectedFound, TypeError};
use rustc_middle::ty::{
    self, BottomUpFolder, Clause, GenericArgs, GenericArgsRef, Ty, TyCtxt, TypeFoldable,
    TypeFolder, TypeSuperFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypingMode,
    Unnormalized, Upcast,
};
use rustc_span::Span;
use rustc_span::def_id::DefId;
use tracing::{debug, instrument};

pub use self::coherence::{
    InCrate, IsFirstInputType, OrphanCheckErr, OrphanCheckMode, OverlapResult, UncoveredTyParams,
    add_placeholder_note, orphan_check_trait_ref, overlapping_inherent_impls,
    overlapping_trait_impls,
};
pub use self::dyn_compatibility::{
    DynCompatibilityViolation, dyn_compatibility_violations_for_assoc_item,
    hir_ty_lowering_dyn_compatibility_violations, is_vtable_safe_method,
};
pub use self::engine::{FulfillmentEngine, ObligationCtxt};
pub use self::fulfill::{FulfillmentContext, OldSolverError, PendingPredicateObligation};
pub use self::normalize::NormalizeExt;
pub use self::project::{normalize_inherent_projection, normalize_projection_term};
pub use self::select::{
    EvaluationCache, EvaluationResult, IntercrateAmbiguityCause, OverflowError, SelectionCache,
    SelectionContext,
};
pub use self::specialize::specialization_graph::{
    FutureCompatOverlapError, FutureCompatOverlapErrorKind,
};
pub use self::specialize::{
    OverlapError, specialization_graph, translate_args, translate_args_with_cause,
};
pub use self::structural_normalize::StructurallyNormalizeExt;
pub use self::util::{
    BoundVarReplacer, PlaceholderReplacer, elaborate, expand_trait_aliases, impl_item_is_final,
    sizedness_fast_path, supertrait_def_ids, supertraits, transitive_bounds_that_define_assoc_item,
    upcast_choices, with_replaced_escaping_bound_vars,
};
use crate::error_reporting::InferCtxtErrorExt;
use crate::infer::outlives::env::OutlivesEnvironment;
use crate::infer::{InferCtxt, TyCtxtInferExt};
use crate::regions::InferCtxtRegionExt;
use crate::traits::query::evaluate_obligation::InferCtxtExt as _;

#[derive(Debug, TypeVisitable)]
pub struct FulfillmentError<'tcx> {
    pub obligation: PredicateObligation<'tcx>,
    pub code: FulfillmentErrorCode<'tcx>,
    /// Diagnostics only: the 'root' obligation which resulted in
    /// the failure to process `obligation`. This is the obligation
    /// that was initially passed to `register_predicate_obligation`
    pub root_obligation: PredicateObligation<'tcx>,
}

impl<'tcx> FulfillmentError<'tcx> {
    pub fn new(
        obligation: PredicateObligation<'tcx>,
        code: FulfillmentErrorCode<'tcx>,
        root_obligation: PredicateObligation<'tcx>,
    ) -> FulfillmentError<'tcx> {
        FulfillmentError { obligation, code, root_obligation }
    }

    pub fn is_true_error(&self) -> bool {
        match self.code {
            FulfillmentErrorCode::Select(_)
            | FulfillmentErrorCode::Project(_)
            | FulfillmentErrorCode::Outlives
            | FulfillmentErrorCode::Subtype(_, _)
            | FulfillmentErrorCode::ConstEquate(_, _) => true,
            FulfillmentErrorCode::Cycle(_) | FulfillmentErrorCode::Ambiguity { overflow: _ } => {
                false
            }
        }
    }
}

#[derive(Clone, TypeVisitable)]
pub enum FulfillmentErrorCode<'tcx> {
    /// Inherently impossible to fulfill; this trait is implemented if and only
    /// if it is already implemented.
    Cycle(PredicateObligations<'tcx>),
    Select(SelectionError<'tcx>),
    Project(MismatchedProjectionTypes<'tcx>),
    /// An outlives constraint emitted for `-Zassumptions-on-binders` was unsatisfiable.
    Outlives,
    Subtype(ExpectedFound<Ty<'tcx>>, TypeError<'tcx>), // always comes from a SubtypePredicate
    ConstEquate(ExpectedFound<ty::Const<'tcx>>, TypeError<'tcx>),
    Ambiguity {
        /// Overflow is only `Some(suggest_recursion_limit)` when using the next generation
        /// trait solver `-Znext-solver`. With the old solver overflow is eagerly handled by
        /// emitting a fatal error instead.
        overflow: Option<bool>,
    },
}

impl<'tcx> Debug for FulfillmentErrorCode<'tcx> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match *self {
            FulfillmentErrorCode::Select(ref e) => write!(f, "{e:?}"),
            FulfillmentErrorCode::Project(ref e) => write!(f, "{e:?}"),
            FulfillmentErrorCode::Outlives => write!(f, "CodeOutlivesError"),
            FulfillmentErrorCode::Subtype(ref a, ref b) => {
                write!(f, "CodeSubtypeError({a:?}, {b:?})")
            }
            FulfillmentErrorCode::ConstEquate(ref a, ref b) => {
                write!(f, "CodeConstEquateError({a:?}, {b:?})")
            }
            FulfillmentErrorCode::Ambiguity { overflow: None } => write!(f, "Ambiguity"),
            FulfillmentErrorCode::Ambiguity { overflow: Some(suggest_increasing_limit) } => {
                write!(f, "Overflow({suggest_increasing_limit})")
            }
            FulfillmentErrorCode::Cycle(ref cycle) => write!(f, "Cycle({cycle:?})"),
        }
    }
}

/// Whether to skip the leak check, as part of a future compatibility warning step.
///
/// The "default" for skip-leak-check corresponds to the current
/// behavior (do not skip the leak check) -- not the behavior we are
/// transitioning into.
#[derive(Copy, Clone, PartialEq, Eq, Debug, Default)]
pub enum SkipLeakCheck {
    Yes,
    #[default]
    No,
}

impl SkipLeakCheck {
    fn is_yes(self) -> bool {
        self == SkipLeakCheck::Yes
    }
}

/// The mode that trait queries run in.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum TraitQueryMode {
    /// Standard/un-canonicalized queries get accurate
    /// spans etc. passed in and hence can do reasonable
    /// error reporting on their own.
    Standard,
    /// Canonical queries get dummy spans and hence
    /// must generally propagate errors to
    /// pre-canonicalization callsites.
    Canonical,
}

/// Creates predicate obligations from the generic bounds.
#[instrument(level = "debug", skip(cause, param_env, normalize_clause))]
pub fn predicates_for_generics<'tcx>(
    cause: impl Fn(usize, Span) -> ObligationCause<'tcx>,
    mut normalize_clause: impl FnMut(Unnormalized<'tcx, Clause<'tcx>>) -> Clause<'tcx>,
    param_env: ty::ParamEnv<'tcx>,
    generic_bounds: ty::InstantiatedClauses<'tcx>,
) -> impl Iterator<Item = PredicateObligation<'tcx>> {
    generic_bounds.into_iter().enumerate().map(move |(idx, (clause, span))| Obligation {
        cause: cause(idx, span),
        recursion_depth: 0,
        param_env,
        predicate: normalize_clause(clause).as_predicate(),
    })
}

/// Determines whether the type `ty` is known to meet `bound` and
/// returns true if so. Returns false if `ty` either does not meet
/// `bound` or is not known to meet bound (note that this is
/// conservative towards *no impl*, which is the opposite of the
/// `evaluate` methods).
pub fn type_known_to_meet_bound_modulo_regions<'tcx>(
    infcx: &InferCtxt<'tcx>,
    param_env: ty::ParamEnv<'tcx>,
    ty: Ty<'tcx>,
    def_id: DefId,
) -> bool {
    let trait_ref = ty::TraitRef::new(infcx.tcx, def_id, [ty]);
    pred_known_to_hold_modulo_regions(infcx, param_env, trait_ref)
}

/// FIXME(@lcnr): this function doesn't seem right and shouldn't exist?
///
/// Ping me on zulip if you want to use this method and need help with finding
/// an appropriate replacement.
#[instrument(level = "debug", skip(infcx, param_env, pred), ret)]
fn pred_known_to_hold_modulo_regions<'tcx>(
    infcx: &InferCtxt<'tcx>,
    param_env: ty::ParamEnv<'tcx>,
    pred: impl Upcast<TyCtxt<'tcx>, ty::Predicate<'tcx>>,
) -> bool {
    let obligation = Obligation::new(infcx.tcx, ObligationCause::dummy(), param_env, pred);

    let result = infcx.evaluate_obligation_no_overflow(&obligation);
    debug!(?result);

    if result.must_apply_modulo_regions() {
        true
    } else if result.may_apply() && !infcx.next_trait_solver() {
        // Sometimes obligations are ambiguous because the recursive evaluator
        // is not smart enough, so we fall back to fulfillment when we're not certain
        // that an obligation holds or not. Even still, we must make sure that
        // the we do no inference in the process of checking this obligation.
        let goal =
            infcx.deeply_resolve_ignoring_regions((obligation.predicate, obligation.param_env));
        infcx.probe(|_| {
            let ocx = ObligationCtxt::new(infcx);
            ocx.register_obligation(obligation);

            let errors = ocx.evaluate_obligations_error_on_ambiguity();
            match errors {
                // Only known to hold if we did no inference.
                TraitErrors::NoErrors => infcx.deeply_resolve_ignoring_regions(goal) == goal,

                TraitErrors::HasErrors(errors) => {
                    debug!(?errors);
                    false
                }
            }
        })
    } else {
        false
    }
}

fn set_projection_term_to_non_rigid<'tcx>(
    tcx: TyCtxt<'tcx>,
    predicates: impl IntoIterator<Item = ty::Clause<'tcx>>,
) -> impl Iterator<Item = ty::Clause<'tcx>> {
    predicates.into_iter().map(move |clause| {
        if let ty::ClauseKind::Projection(projection_pred) = clause.kind().skip_binder() {
            clause
                .kind()
                .rebind(ty::ProjectionClause {
                    projection_term: projection_pred.projection_term,
                    term: ty::set_aliases_to_non_rigid(tcx, projection_pred.term).skip_norm_wip(),
                })
                .upcast(tcx)
        } else {
            clause
        }
    })
}

enum ReplaceRegions {
    Yes,
    No,
}

fn replace_infer_and_non_rigid_alias_with_error<'tcx, T>(
    infcx: &InferCtxt<'tcx>,
    value: T,
    guar: ErrorGuaranteed,
    replace_regions: ReplaceRegions,
) -> T
where
    T: TypeFoldable<TyCtxt<'tcx>>,
{
    let tcx = infcx.tcx;
    value.fold_with(&mut BottomUpFolder {
        tcx,
        ty_op: |ty| {
            let ty = infcx.shallow_resolve(ty);
            match ty.kind() {
                ty::Infer(ty::TyVar(_) | ty::IntVar(_) | ty::FloatVar(_)) => {
                    Ty::new_error(tcx, guar)
                }
                ty::Alias(ty::IsRigid::No, _) if tcx.next_trait_solver_globally() => {
                    Ty::new_error(tcx, guar)
                }
                _ => ty,
            }
        },
        lt_op: |lt| match replace_regions {
            // We can't resolve regions using lexical resolution here since
            // that's private. It probably doesn't matter since we already
            // got more severe error.
            ReplaceRegions::Yes => match lt.kind() {
                ty::ReVar(_) => ty::Region::new_error(tcx, guar),
                _ => lt,
            },
            ReplaceRegions::No => lt,
        },
        ct_op: |ct| {
            let ct = infcx.shallow_resolve_const(ct);
            match ct.kind() {
                ty::ConstKind::Infer(ty::InferConst::Var(_)) => ty::Const::new_error(tcx, guar),
                ty::ConstKind::Alias(ty::IsRigid::No, _) if tcx.next_trait_solver_globally() => {
                    ty::Const::new_error(tcx, guar)
                }
                _ => ct,
            }
        },
    })
}

#[instrument(level = "debug", skip(tcx, elaborated_env))]
fn do_normalize_clauses<'tcx>(
    tcx: TyCtxt<'tcx>,
    cause: ObligationCause<'tcx>,
    elaborated_env: ty::ParamEnv<'tcx>,
    clauses: Vec<ty::Clause<'tcx>>,
) -> Vec<ty::Clause<'tcx>> {
    // FIXME. We should really... do something with these region
    // obligations. But this call just continues the older
    // behavior (i.e., doesn't cause any new bugs), and it would
    // take some further refactoring to actually solve them. In
    // particular, we would have to handle implied bounds
    // properly, and that code is currently largely confined to
    // regionck (though I made some efforts to extract it
    // out). -nmatsakis
    //
    // @arielby: In any case, these obligations are checked
    // by wfcheck anyway, so I'm not sure we have to check
    // them here too, and we will remove this function when
    // we move over to lazy normalization *anyway*.
    let infcx = tcx.infer_ctxt().ignoring_regions().build(TypingMode::non_body_analysis());
    let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
    // FIXME: `elaborated_env` is not really rigid. We do this to be
    // consistent with the old solver.
    let elaborated_env = if tcx.next_trait_solver_globally()
        && !tcx.disable_param_env_normalization_hack()
    {
        let elaborated_env = ty::set_type_aliases_to_rigid(tcx, elaborated_env);
        let elaborated_env = set_projection_term_to_non_rigid(tcx, elaborated_env.caller_bounds());
        ty::ParamEnv::new(tcx, elaborated_env)
    } else {
        elaborated_env
    };
    let clauses = ocx.normalize(&cause, elaborated_env, Unnormalized::new_wip(clauses));
    let clauses = if tcx.next_trait_solver_globally() {
        if !tcx.disable_param_env_normalization_hack() {
            let clauses: Vec<_> = set_projection_term_to_non_rigid(tcx, clauses).collect();
            // FIXME(type_alias_impl_trait): opaque types in param env might be
            // in defining scope but we're using non body analysis here.
            // So the rigidness marker is wrong.
            ty::set_opaques_to_non_rigid(tcx, clauses).skip_norm_wip()
        } else {
            // Param env is used in different typing modes but itself
            // is normalized in `non_body_analysis`.
            // That not only makes the rigidness of opaques types wrong,
            // other aliases can be indirectly affected as well.
            // So we conservatively set everything to be non-rigid.
            ty::set_aliases_to_non_rigid(tcx, clauses).skip_norm_wip()
        }
    } else {
        clauses
    };

    let errors = ocx.evaluate_obligations_error_on_ambiguity();
    let clauses = if let TraitErrors::HasErrors(errors) = errors {
        debug!("do_normalize_clauses: failed to normalize clauses");
        let guar = infcx.err_ctxt().report_fulfillment_errors(errors);
        replace_infer_and_non_rigid_alias_with_error(&infcx, clauses, guar, ReplaceRegions::No)
    } else {
        clauses
    };

    debug!("do_normalize_clauses: normalized clauses = {:?}", clauses);

    // FIXME: It's very weird that we ignore region obligations but apparently
    // still need to use `resolve_regions` as we need the resolved regions in
    // the normalized clauses.
    //
    // FIXME(-Zhigher-ranked-assumptions): We're ignoring region errors for now.
    // There're placeholder constraints `leaking` out. This is a hack to work around
    // the fact that we don't support placeholder assumptions right now and is necessary
    // for `compare_method_clause_entailment`. We should remove this once we have proper
    // support for implied bounds on binders.
    //
    // This ignoring is required by trait-system-refactor-initiative#166. The new solver encounters
    // this more frequently as we entirely ignore outlives clauses with the old solver.
    //
    // FIXME: We should avoid interning clauses both here and at the
    // caller sites. We should also avoid cloning if possible.
    let normalized_env = ty::ParamEnv::new(tcx, clauses.iter().copied());
    let _errors = infcx.resolve_regions(cause.body_def_id, normalized_env, []);
    match infcx.deeply_resolve_via_region_graph(clauses.clone()) {
        Ok(clauses) => clauses,
        Err(fixup_err) => {
            // The first folder only replaces infers from normalization failure. We might not have
            // normalization failure and have unconstrained ty/const vars from ill-formed impls.
            // See `tests/ui/traits/normalize/self-referential-param-env-normalization.rs`.
            //
            // We delay a bug here instead of immediately ICEing and let type checking report the
            // actual user-facing errors.
            let guar = tcx.dcx().span_delayed_bug(
                cause.span,
                format!("inference variables in normalized parameter environment: {fixup_err}"),
            );

            // This is slightly wrong as we replace opaques with errors.
            //
            // We still need to replace regions because `fully_resolve` eagerly returns `Err` if
            // it encounters unconstrained ty/const var. Thus region vars might not get replaced.
            replace_infer_and_non_rigid_alias_with_error(&infcx, clauses, guar, ReplaceRegions::Yes)
        }
    }
}

// FIXME: this is gonna need to be removed ...
/// Normalizes the parameter environment, reporting errors if they occur.
#[instrument(level = "debug", skip(tcx))]
pub fn normalize_param_env_or_error<'tcx>(
    tcx: TyCtxt<'tcx>,
    unnormalized_env: ty::ParamEnv<'tcx>,
    cause: ObligationCause<'tcx>,
) -> ty::ParamEnv<'tcx> {
    // I'm not wild about reporting errors here; I'd prefer to
    // have the errors get reported at a defined place (e.g.,
    // during typeck). Instead I have all parameter
    // environments, in effect, going through this function
    // and hence potentially reporting errors. This ensures of
    // course that we never forget to normalize (the
    // alternative seemed like it would involve a lot of
    // manual invocations of this fn -- and then we'd have to
    // deal with the errors at each of those sites).
    //
    // In any case, in practice, typeck constructs all the
    // parameter environments once for every fn as it goes,
    // and errors will get reported then; so outside of type inference we
    // can be sure that no errors should occur.
    let mut clauses: Vec<_> = util::elaborate(
        tcx,
        unnormalized_env.caller_bounds().into_iter().map(|clause| {
            if tcx.features().generic_const_exprs() || tcx.next_trait_solver_globally() {
                return clause;
            }

            struct ConstNormalizer<'tcx>(TyCtxt<'tcx>);

            impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ConstNormalizer<'tcx> {
                fn cx(&self) -> TyCtxt<'tcx> {
                    self.0
                }

                fn fold_const(&mut self, c: ty::Const<'tcx>) -> ty::Const<'tcx> {
                    // FIXME(return_type_notation): track binders in this normalizer, as
                    // `ty::Const::normalize` can only work with properly preserved binders.

                    if c.has_escaping_bound_vars() {
                        return ty::Const::new_misc_error(self.0);
                    }

                    // While it is pretty sus to be evaluating things with an empty param env, it
                    // should actually be okay since without `feature(generic_const_exprs)` the only
                    // const arguments that have a non-empty param env are array repeat counts. These
                    // do not appear in the type system though.
                    if let ty::ConstKind::Alias(_, alias_const) = c.kind()
                        && matches!(alias_const.kind, ty::AliasConstKind::Anon { .. })
                    {
                        let infcx = self.0.infer_ctxt().build(TypingMode::non_body_analysis());
                        let c = evaluate_const(&infcx, c, ty::ParamEnv::empty());
                        // We should never wind up with any `infcx` local state when normalizing anon consts
                        // under min const generics.
                        assert!(!c.has_infer() && !c.has_placeholders());
                        return c;
                    }

                    c
                }
            }

            // This whole normalization step is a hack to work around the fact that
            // `normalize_param_env_or_error` is fundamentally broken from using an
            // unnormalized param env with a trait solver that expects the param env
            // to be normalized.
            //
            // When normalizing the param env we can end up evaluating obligations
            // that have been normalized but can only be proven via a where clause
            // which is still in its unnormalized form. example:
            //
            // Attempting to prove `T: Trait<<u8 as Identity>::Assoc>` in a param env
            // with a `T: Trait<<u8 as Identity>::Assoc>` where clause will fail because
            // we first normalize obligations before proving them so we end up proving
            // `T: Trait<u8>`. Since lazy normalization is not implemented equating `u8`
            // with `<u8 as Identity>::Assoc` fails outright so we incorrectly believe that
            // we cannot prove `T: Trait<u8>`.
            //
            // The same thing is true for const generics- attempting to prove
            // `T: Trait<ConstKind::Alias(...)>` with the same thing as a where clauses
            // will fail. After normalization we may be attempting to prove `T: Trait<4>` with
            // the unnormalized where clause `T: Trait<ConstKind::Alias(...)>`. In order
            // for the obligation to hold `4` must be equal to `ConstKind::Alias(...)`
            // but as we do not have lazy norm implemented, equating the two consts fails outright.
            //
            // Ideally we would not normalize consts here at all but it is required for backwards
            // compatibility. Eventually when lazy norm is implemented this can just be removed.
            // We do not normalize types here as there is no backwards compatibility requirement
            // for us to do so.
            clause.fold_with(&mut ConstNormalizer(tcx))
        }),
    )
    .collect();

    debug!("normalize_param_env_or_error: elaborated-clauses={:?}", clauses);

    let elaborated_env = ty::ParamEnv::new(tcx, clauses.iter().copied());
    if !elaborated_env.has_aliases() {
        return elaborated_env;
    }

    // HACK: we are trying to normalize the param-env inside *itself*. The problem is that
    // normalization expects its param-env to be already normalized, which means we have
    // a circularity.
    //
    // The way we handle this is by normalizing the param-env inside an unnormalized version
    // of the param-env, which means that if the param-env contains unnormalized projections,
    // we'll have some normalization failures. This is unfortunate.
    //
    // Lazy normalization would basically handle this by treating just the
    // normalizing-a-trait-ref-requires-itself cycles as evaluation failures.
    //
    // Inferred outlives bounds can create a lot of `TypeOutlives` predicates for associated
    // types, so to make the situation less bad, we normalize all the predicates *but*
    // the `TypeOutlives` predicates first inside the unnormalized parameter environment, and
    // then we normalize the `TypeOutlives` bounds inside the normalized parameter environment.
    //
    // This works fairly well because trait matching does not actually care about param-env
    // TypeOutlives clauses - these are normally used by regionck.
    let outlives_clauses: Vec<_> = clauses
        .extract_if(.., |clause| {
            matches!(clause.kind().skip_binder(), ty::ClauseKind::TypeOutlives(..))
        })
        .collect();

    debug!(
        "normalize_param_env_or_error: clauses=(non-outlives={:?}, outlives={:?})",
        clauses, outlives_clauses
    );
    let non_outlives_clauses = do_normalize_clauses(tcx, cause.clone(), elaborated_env, clauses);

    debug!("normalize_param_env_or_error: non-outlives clauses={:?}", non_outlives_clauses);

    // Not sure whether it is better to include the unnormalized TypeOutlives clauses
    // here. I believe they should not matter, because we are ignoring TypeOutlives param-env
    // clauses here anyway. Keeping them here anyway because it seems safer.
    let outlives_env = non_outlives_clauses.iter().chain(&outlives_clauses).cloned();
    let outlives_env = ty::ParamEnv::new(tcx, outlives_env);
    let outlives_clauses = do_normalize_clauses(tcx, cause, outlives_env, outlives_clauses);
    debug!("normalize_param_env_or_error: outlives clauses={:?}", outlives_clauses);

    let mut clauses = non_outlives_clauses;
    clauses.extend(outlives_clauses);
    debug!("normalize_param_env_or_error: final clauses={:?}", clauses);
    ty::ParamEnv::new(tcx, clauses)
}

#[derive(Debug)]
pub enum EvaluateConstErr<E> {
    /// The constant being evaluated was either a generic parameter or inference variable, *or*,
    /// some alias const with either generic parameters or inference variables in its
    /// generic arguments.
    HasGenericsOrInfers,
    /// The type this constant evaluated to is not valid for use in const generics. This should
    /// always result in an error when checking the constant is correctly typed for the parameter
    /// it is an argument to, so a bug is delayed when encountering this.
    InvalidConstParamTy(ErrorGuaranteed),
    /// CTFE failed to evaluate the constant in some unrecoverable way (e.g. encountered a `panic!`).
    /// This is also used when the constant was already tainted by error.
    EvaluationFailure(ErrorGuaranteed),
    FailedNormalization(E),
}

// FIXME(BoxyUwU): Private this once we `generic_const_exprs` isn't doing its own normalization routine
// FIXME(generic_const_exprs): Consider accepting a `ty::AliasConst` when we are not rolling our own
// normalization scheme
/// Evaluates a type system constant returning a `ConstKind::Error` in cases where CTFE failed and
/// returning the passed in constant if it was not fully concrete (i.e. depended on generic parameters
/// or inference variables)
///
/// You should not call this function unless you are implementing normalization itself. Prefer to use
/// `normalize_erasing_regions` or the `normalize` functions on `ObligationCtxt`/`FnCtxt`/`InferCtxt`.
pub fn evaluate_const<'tcx>(
    infcx: &InferCtxt<'tcx>,
    ct: ty::Const<'tcx>,
    param_env: ty::ParamEnv<'tcx>,
) -> ty::Const<'tcx> {
    match try_evaluate_const(infcx, ct, param_env, |v| Ok::<_, !>(v.skip_norm_wip())) {
        Ok(ct) => ct,
        Err(EvaluateConstErr::EvaluationFailure(e) | EvaluateConstErr::InvalidConstParamTy(e)) => {
            ty::Const::new_error(infcx.tcx, e)
        }
        Err(EvaluateConstErr::HasGenericsOrInfers) => ct,
    }
}

// FIXME(BoxyUwU): Private this once we `generic_const_exprs` isn't doing its own normalization routine
// FIXME(generic_const_exprs): Consider accepting a `ty::AliasConst` when we are not rolling our own
// normalization scheme
/// Evaluates a type system constant making sure to not allow constants that depend on generic parameters
/// or inference variables to succeed in evaluating.
///
/// You should not call this function unless you are implementing normalization itself. Prefer to use
/// `normalize_erasing_regions` or the `normalize` functions on `ObligationCtxt`/`FnCtxt`/`InferCtxt`.
#[instrument(level = "debug", skip(infcx, normalize_ty), ret)]
pub fn try_evaluate_const<'tcx, E: Debug>(
    infcx: &InferCtxt<'tcx>,
    ct: ty::Const<'tcx>,
    param_env: ty::ParamEnv<'tcx>,
    normalize_ty: impl FnOnce(Unnormalized<'tcx, Ty<'tcx>>) -> Result<Ty<'tcx>, E>,
) -> Result<ty::Const<'tcx>, EvaluateConstErr<E>> {
    let tcx = infcx.tcx;
    let ct = infcx.deeply_resolve_ignoring_regions(ct);
    debug!(?ct);

    match ct.kind() {
        ty::ConstKind::Value(..) => Ok(ct),
        ty::ConstKind::Error(e) => Err(EvaluateConstErr::EvaluationFailure(e)),
        ty::ConstKind::Param(_)
        | ty::ConstKind::Infer(_)
        | ty::ConstKind::Bound(_, _)
        | ty::ConstKind::Placeholder(_)
        | ty::ConstKind::Expr(_) => Err(EvaluateConstErr::HasGenericsOrInfers),
        ty::ConstKind::Alias(_, alias_const) => {
            let opt_anon_const_kind = match alias_const.kind {
                ty::AliasConstKind::Anon { def_id } => Some((def_id, tcx.anon_const_kind(def_id))),
                _ => None,
            };

            // Postpone evaluation of constants that depend on generic parameters or
            // inference variables.
            //
            // We use `TypingMode::PostAnalysis` here which is not *technically* correct
            // to be revealing opaque types here as borrowcheck has not run yet. However,
            // CTFE itself uses `TypingMode::PostAnalysis` unconditionally even during
            // typeck and not doing so has a lot of (undesirable) fallout (#101478, #119821).
            // As a result we always use a revealed env when resolving the instance to evaluate.
            //
            // FIXME: `const_eval_resolve_for_typeck` should probably just modify the env itself
            // instead of having this logic here
            let (args, typing_env) = match opt_anon_const_kind {
                // We handle `generic_const_exprs` separately as reasonable ways of handling constants in the type system
                // completely fall apart under `generic_const_exprs` and makes this whole function Really hard to reason
                // about if you have to consider gce whatsoever.
                Some((def_id, ty::AnonConstKind::GCE)) => {
                    if alias_const.has_non_region_infer() || alias_const.has_non_region_param() {
                        // `feature(generic_const_exprs)` causes anon consts to inherit all parent generics. This can cause
                        // inference variables and generic parameters to show up in `ty::Const` even though the anon const
                        // does not actually make use of them. We handle this case specially and attempt to evaluate anyway.
                        match tcx.thir_abstract_const(def_id) {
                            Ok(Some(ct)) => {
                                let ct = tcx.expand_abstract_consts(
                                    ct.instantiate(tcx, alias_const.args).skip_norm_wip(),
                                );
                                if let Err(e) = ct.error_reported() {
                                    return Err(EvaluateConstErr::EvaluationFailure(e));
                                } else if ct.has_non_region_infer() || ct.has_non_region_param() {
                                    // If the anon const *does* actually use generic parameters or inference variables from
                                    // the generic arguments provided for it, then we should *not* attempt to evaluate it.
                                    return Err(EvaluateConstErr::HasGenericsOrInfers);
                                } else {
                                    let args = replace_param_and_infer_args_with_placeholder(
                                        tcx,
                                        alias_const.args,
                                    );
                                    let typing_env = infcx
                                        .typing_env(tcx.erase_and_anonymize_regions(param_env))
                                        .with_post_analysis_normalized(tcx);
                                    (args, typing_env)
                                }
                            }
                            Err(_) | Ok(None) => {
                                let args = GenericArgs::identity_for_item(tcx, def_id);
                                let typing_env = ty::TypingEnv::post_analysis(tcx, def_id);
                                (args, typing_env)
                            }
                        }
                    } else {
                        let typing_env = infcx
                            .typing_env(tcx.erase_and_anonymize_regions(param_env))
                            .with_post_analysis_normalized(tcx);
                        (alias_const.args, typing_env)
                    }
                }
                Some((def_id, ty::AnonConstKind::RepeatExprCount)) => {
                    if alias_const.has_non_region_infer() {
                        // Diagnostics will sometimes replace the identity args of anon consts in
                        // array repeat expr counts with inference variables so we have to handle this
                        // even though it is not something we should ever actually encounter.
                        //
                        // Array repeat expr counts are allowed to syntactically use generic parameters
                        // but must not actually depend on them in order to evalaute successfully. This means
                        // that it is actually fine to evalaute them in their own environment rather than with
                        // the actually provided generic arguments.
                        tcx.dcx().delayed_bug("AnonConst with infer args but no error reported");
                    }

                    // The generic args of repeat expr counts under `min_const_generics` are not supposed to
                    // affect evaluation of the constant as this would make it a "truly" generic const arg.
                    // To prevent this we discard all the generic arguments and evalaute with identity args
                    // and in its own environment instead of the current environment we are normalizing in.
                    let args = GenericArgs::identity_for_item(tcx, def_id);
                    let typing_env = ty::TypingEnv::post_analysis(tcx, def_id);

                    (args, typing_env)
                }
                Some((
                    _,
                    ty::AnonConstKind::MCG
                    | ty::AnonConstKind::NonTypeSystemAnon
                    | ty::AnonConstKind::NonTypeSystemInline,
                ))
                | None => {
                    // We are only dealing with "truly" generic/uninferred constants here:
                    // - GCEConsts have been handled separately
                    // - Repeat expr count back compat consts have also been handled separately
                    // So we are free to simply defer evaluation here.
                    //
                    // FIXME: This assumes that `args` are normalized which is not necessarily true
                    //
                    // Const patterns are converted to type system constants before being
                    // evaluated. However, we don't care about them here as pattern evaluation
                    // logic does not go through type system normalization. If it did this would
                    // be a backwards compatibility problem as we do not enforce "syntactic" non-
                    // usage of generic parameters like we do here.
                    if alias_const.args.has_non_region_param()
                        || alias_const.args.has_non_region_infer()
                        || alias_const.args.has_non_region_placeholders()
                    {
                        return Err(EvaluateConstErr::HasGenericsOrInfers);
                    }

                    // Since there is no generic parameter, we can just drop the environment
                    // to prevent query cycle.
                    let typing_env = ty::TypingEnv::fully_monomorphized();

                    (alias_const.args, typing_env)
                }
            };

            let alias_const = ty::AliasConst::new(tcx, alias_const.kind, args);
            let erased_alias_const = tcx.erase_and_anonymize_regions(alias_const);

            use rustc_middle::mir::interpret::ErrorHandled;
            // FIXME: `def_span` will point at the definition of this const; ideally, we'd point at
            // where it gets used as a const generic.
            let span = alias_const.kind.def_span(tcx);
            match tcx.const_eval_resolve_for_typeck(typing_env, erased_alias_const, span) {
                Ok(Ok(val)) => {
                    let ty = normalize_ty(alias_const.type_of(tcx))
                        .map_err(EvaluateConstErr::FailedNormalization)?;
                    Ok(ty::Const::new_value(tcx, val, ty))
                }
                Ok(Err(_)) => {
                    let e = tcx.dcx().delayed_bug(
                        "Type system constant with non valtree'able type evaluated but no error emitted",
                    );
                    Err(EvaluateConstErr::InvalidConstParamTy(e))
                }
                Err(ErrorHandled::Reported(info, _)) => {
                    Err(EvaluateConstErr::EvaluationFailure(info.into()))
                }
                Err(ErrorHandled::TooGeneric(_)) => Err(EvaluateConstErr::HasGenericsOrInfers),
            }
        }
    }
}

/// Replaces args that reference param or infer variables with suitable
/// placeholders. This function is meant to remove these param and infer
/// args when they're not actually needed to evaluate a constant.
fn replace_param_and_infer_args_with_placeholder<'tcx>(
    tcx: TyCtxt<'tcx>,
    args: GenericArgsRef<'tcx>,
) -> GenericArgsRef<'tcx> {
    struct ReplaceParamAndInferWithPlaceholder<'tcx> {
        tcx: TyCtxt<'tcx>,
        idx: ty::BoundVar,
    }

    impl<'tcx> TypeFolder<TyCtxt<'tcx>> for ReplaceParamAndInferWithPlaceholder<'tcx> {
        fn cx(&self) -> TyCtxt<'tcx> {
            self.tcx
        }

        fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
            if let ty::Infer(_) = t.kind() {
                let idx = self.idx;
                self.idx += 1;
                Ty::new_placeholder(
                    self.tcx,
                    ty::PlaceholderType::new(
                        ty::UniverseIndex::ROOT,
                        ty::BoundTy { var: idx, kind: ty::BoundTyKind::Anon },
                    ),
                )
            } else {
                t.super_fold_with(self)
            }
        }

        fn fold_const(&mut self, c: ty::Const<'tcx>) -> ty::Const<'tcx> {
            if let ty::ConstKind::Infer(_) = c.kind() {
                let idx = self.idx;
                self.idx += 1;
                ty::Const::new_placeholder(
                    self.tcx,
                    ty::PlaceholderConst::new(ty::UniverseIndex::ROOT, ty::BoundConst::new(idx)),
                )
            } else {
                c.super_fold_with(self)
            }
        }
    }

    args.fold_with(&mut ReplaceParamAndInferWithPlaceholder { tcx, idx: ty::BoundVar::ZERO })
}

/// Normalizes the clauses and checks whether they hold in an empty environment. If this
/// returns true, then either normalize encountered an error or one of the clauses did not
/// hold. Used when creating vtables to check for unsatisfiable methods. This should not be
/// used during analysis.
pub fn impossible_clauses<'tcx>(tcx: TyCtxt<'tcx>, clauses: Vec<ty::Clause<'tcx>>) -> bool {
    debug!("impossible_clauses(clauses={:?})", clauses);
    let (infcx, param_env) = tcx
        .infer_ctxt()
        .with_next_trait_solver(true)
        .enable_next_solver_overflow_fcw(false)
        .build_with_typing_env(ty::TypingEnv::fully_monomorphized());

    let ocx = ObligationCtxt::new(&infcx);
    let clauses =
        ocx.normalize(&ObligationCause::dummy(), param_env, Unnormalized::new_wip(clauses));
    for clause in clauses {
        let obligation = Obligation::new(tcx, ObligationCause::dummy(), param_env, clause);
        ocx.register_obligation(obligation);
    }

    // Use `try_evaluate_obligations` to only return impossible for true errors,
    // and not ambiguities or overflows. Since the new trait solver forces
    // some currently undetected overlap between `dyn Trait: Trait` built-in
    // vs user-written impls to AMBIGUOUS, this may return ambiguity even
    // with no infer vars. There may also be ways to encounter ambiguity due
    // to post-mono overflow.
    !ocx.try_evaluate_obligations().no_errors()
}

fn instantiate_and_check_impossible_clauses<'tcx>(
    tcx: TyCtxt<'tcx>,
    key: (DefId, GenericArgsRef<'tcx>),
) -> bool {
    debug!("instantiate_and_check_impossible_clauses(key={:?})", key);

    let mut clauses: Vec<_> = tcx
        .clauses_of(key.0)
        .instantiate(tcx, key.1)
        .clauses
        .into_iter()
        .map(Unnormalized::skip_norm_wip)
        .collect();

    // Specifically check trait fulfillment to avoid an error when trying to resolve
    // associated items.
    if let Some(trait_def_id) = tcx.trait_of_assoc(key.0) {
        let trait_ref = ty::TraitRef::from_assoc(tcx, trait_def_id, key.1);
        clauses.push(trait_ref.upcast(tcx));
    }

    clauses.retain(|clause| !clause.has_param());
    let result = impossible_clauses(tcx, clauses);

    debug!("instantiate_and_check_impossible_clauses(key={:?}) = {:?}", key, result);
    result
}

/// Checks whether a trait's associated item is impossible to reference on a given impl.
///
/// This only considers predicates that reference the impl's generics, and not
/// those that reference the method's generics.
fn is_impossible_associated_item(
    tcx: TyCtxt<'_>,
    (impl_def_id, trait_item_def_id): (DefId, DefId),
) -> bool {
    struct ReferencesOnlyParentGenerics<'tcx> {
        tcx: TyCtxt<'tcx>,
        generics: &'tcx ty::Generics,
        trait_item_def_id: DefId,
    }
    impl<'tcx> ty::TypeVisitor<TyCtxt<'tcx>> for ReferencesOnlyParentGenerics<'tcx> {
        type Result = ControlFlow<()>;
        fn visit_ty(&mut self, t: Ty<'tcx>) -> Self::Result {
            // If this is a parameter from the trait item's own generics, then bail
            if let ty::Param(param) = *t.kind()
                && let param_def_id = self.generics.type_param(param, self.tcx).def_id
                && self.tcx.parent(param_def_id) == self.trait_item_def_id
            {
                return ControlFlow::Break(());
            }
            t.super_visit_with(self)
        }
        fn visit_region(&mut self, r: ty::Region<'tcx>) -> Self::Result {
            if let ty::ReEarlyParam(param) = r.kind()
                && let param_def_id = self.generics.region_param(param, self.tcx).def_id
                && self.tcx.parent(param_def_id) == self.trait_item_def_id
            {
                return ControlFlow::Break(());
            }
            ControlFlow::Continue(())
        }
        fn visit_const(&mut self, ct: ty::Const<'tcx>) -> Self::Result {
            if let ty::ConstKind::Param(param) = ct.kind()
                && let param_def_id = self.generics.const_param(param, self.tcx).def_id
                && self.tcx.parent(param_def_id) == self.trait_item_def_id
            {
                return ControlFlow::Break(());
            }
            ct.super_visit_with(self)
        }
    }

    let generics = tcx.generics_of(trait_item_def_id);
    let gen_clauses = tcx.clauses_of(trait_item_def_id);

    // Be conservative in cases where we have `W<T: ?Sized>` and a method like `Self: Sized`,
    // since that method *may* have some substitutions where the predicates hold.
    //
    // This replicates the logic we use in coherence.
    let infcx = tcx
        .infer_ctxt()
        .ignoring_regions()
        .with_next_trait_solver(true)
        .enable_next_solver_overflow_fcw(false)
        .build(TypingMode::Coherence);
    let param_env = ty::ParamEnv::empty();
    let fresh_args = infcx.fresh_args_for_item(tcx.def_span(impl_def_id), impl_def_id);

    let impl_trait_ref =
        tcx.impl_trait_ref(impl_def_id).instantiate(tcx, fresh_args).skip_norm_wip();

    let mut visitor = ReferencesOnlyParentGenerics { tcx, generics, trait_item_def_id };
    let predicates_for_trait = gen_clauses.clauses.iter().filter_map(|(clause, span)| {
        clause.visit_with(&mut visitor).is_continue().then(|| {
            Obligation::new(
                tcx,
                ObligationCause::dummy_with_span(*span),
                param_env,
                ty::EarlyBinder::bind(tcx, *clause)
                    .instantiate(tcx, impl_trait_ref.args)
                    .skip_norm_wip(),
            )
        })
    });

    let ocx = ObligationCtxt::new(&infcx);
    ocx.register_obligations(predicates_for_trait);
    !ocx.try_evaluate_obligations().no_errors()
}

pub fn provide(providers: &mut Providers) {
    dyn_compatibility::provide(providers);
    vtable::provide(providers);
    *providers = Providers {
        specialization_graph_of: specialize::specialization_graph_provider,
        specializes: specialize::specializes,
        specialization_enabled_in: specialize::specialization_enabled_in,
        instantiate_and_check_impossible_clauses,
        is_impossible_associated_item,
        live_args_for_alias_from_outlives_bounds:
            outlives_for_liveness::live_args_for_alias_from_outlives_bounds,
        args_known_to_outlive_alias_params:
            outlives_for_liveness::args_known_to_outlive_alias_params,
        ..*providers
    };
}