Struct rustc_next_trait_solver::coherence::OrphanChecker

struct OrphanChecker<'a, Infcx, I: Interner, F> {
    infcx: &'a Infcx,
    in_crate: InCrate,
    in_self_ty: bool,
    lazily_normalize_ty: F,
    search_first_local_ty: bool,
    non_local_tys: Vec<(I::Ty, IsFirstInputType)>,
}

Fields

infcx: &'a Infcx

in_crate: InCrate

in_self_ty: bool

lazily_normalize_ty: F

search_first_local_ty: bool

Ignore orphan check failures and exclusively search for the first local type.

non_local_tys: Vec<(I::Ty, IsFirstInputType)>

Implementations

impl<'a, Infcx, I, F, E> OrphanChecker<'a, Infcx, I, F>

where Infcx: InferCtxtLike<Interner = I>, I: Interner, F: FnOnce(I::Ty) -> Result<I::Ty, E>,

fn new(infcx: &'a Infcx, in_crate: InCrate, lazily_normalize_ty: F) -> Self

fn found_non_local_ty( &mut self, t: I::Ty, ) -> ControlFlow<OrphanCheckEarlyExit<I, E>>

fn found_uncovered_ty_param( &mut self, ty: I::Ty, ) -> ControlFlow<OrphanCheckEarlyExit<I, E>>

fn def_id_is_local(&mut self, def_id: I::DefId) -> bool

Trait Implementations

impl<'a, Infcx, I, F, E> TypeVisitor<I> for OrphanChecker<'a, Infcx, I, F>

where Infcx: InferCtxtLike<Interner = I>, I: Interner, F: FnMut(I::Ty) -> Result<I::Ty, E>,

fn visit_const(&mut self, _c: I::Const) -> Self::Result

All possible values for a constant parameter already exist in the crate defining the trait, so they are always non-local¹.

Because there’s no way to have an impl where the first local generic argument is a constant, we also don’t have to fail the orphan check when encountering a parameter or a generic constant.

This means that we can completely ignore constants during the orphan check.

See tests/ui/coherence/const-generics-orphan-check-ok.rs for examples.

---

1. This might not hold for function pointers or trait objects in the future. As these should be quite rare as const arguments and especially rare as impl parameters, allowing uncovered const parameters in impls seems more useful than allowing impl<T> Trait<local_fn_ptr, T> for i32 to compile. ↩

type Result = ControlFlow<OrphanCheckEarlyExit<I, E>>

fn visit_region(&mut self, _r: I::Region) -> Self::Result

fn visit_ty(&mut self, ty: I::Ty) -> Self::Result

fn visit_binder<T>(&mut self, t: &Binder<I, T>) -> Self::Result

where T: TypeVisitable<I>,

fn visit_predicate(&mut self, p: <I as Interner>::Predicate) -> Self::Result

fn visit_clauses(&mut self, p: <I as Interner>::Clauses) -> Self::Result

fn visit_error( &mut self, _guar: <I as Interner>::ErrorGuaranteed, ) -> Self::Result

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.