Struct rustc_trait_selection::traits::coherence::OrphanChecker

struct OrphanChecker<'tcx> {
    tcx: TyCtxt<'tcx>,
    in_crate: InCrate,
    in_self_ty: bool,
    search_first_local_ty: bool,
    non_local_tys: Vec<(Ty<'tcx>, bool)>,
}

Fields

tcx: TyCtxt<'tcx>

in_crate: InCrate

in_self_ty: bool

search_first_local_ty: bool

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

non_local_tys: Vec<(Ty<'tcx>, bool)>

Implementations

impl<'tcx> OrphanChecker<'tcx>

fn new(tcx: TyCtxt<'tcx>, in_crate: InCrate) -> Self

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

fn found_param_ty(
    &mut self,
    t: Ty<'tcx>
) -> ControlFlow<OrphanCheckEarlyExit<'tcx>>

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

Trait Implementations

impl<'tcx> TypeVisitor<'tcx> for OrphanChecker<'tcx>

fn visit_const(&mut self, _c: Const<'tcx>) -> ControlFlow<Self::BreakTy>

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 src/test/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 BreakTy = OrphanCheckEarlyExit<'tcx>

fn visit_region(&mut self, _r: Region<'tcx>) -> ControlFlow<Self::BreakTy>

fn visit_ty(&mut self, ty: Ty<'tcx>) -> ControlFlow<Self::BreakTy>

fn visit_binder<T>(
    &mut self,
    t: &Binder<'tcx, T>
) -> ControlFlow<Self::BreakTy, ()>where
    T: TypeVisitable<'tcx>,

fn visit_predicate(
    &mut self,
    p: Predicate<'tcx>
) -> ControlFlow<Self::BreakTy, ()>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference’s “Type Layout” chapter for details on type layout guarantees.

Size: 40 bytes