Struct rustc_infer::infer::error_reporting::nice_region_error::NiceRegionError

pub struct NiceRegionError<'cx, 'tcx> {
    infcx: &'cx InferCtxt<'cx, 'tcx>,
    error: Option<RegionResolutionError<'tcx>>,
    regions: Option<(Span, Region<'tcx>, Region<'tcx>)>,
}

Fields

infcx: &'cx InferCtxt<'cx, 'tcx>

error: Option<RegionResolutionError<'tcx>>

regions: Option<(Span, Region<'tcx>, Region<'tcx>)>

Implementations

impl<'a, 'tcx> NiceRegionError<'a, 'tcx>

pub(super) fn try_report_anon_anon_conflict(&self) -> Option<ErrorReported>

Print the error message for lifetime errors when both the concerned regions are anonymous.

Consider a case where we have

fn foo(x: &mut Vec<&u8>, y: &u8) {
    x.push(y);
}

The example gives

fn foo(x: &mut Vec<&u8>, y: &u8) {
                   ---      --- these references are declared with different lifetimes...
    x.push(y);
    ^ ...but data from `y` flows into `x` here

It has been extended for the case of structs too.

Consider the example

struct Ref<'a> { x: &'a u32 }

fn foo(mut x: Vec<Ref>, y: Ref) {
                  ---      --- these structs are declared with different lifetimes...
    x.push(y);
    ^ ...but data from `y` flows into `x` here
}

It will later be extended to trait objects.

fn suggest_adding_lifetime_params(
    &self,
    sub: Region<'tcx>,
    ty_sup: &Ty<'_>,
    ty_sub: &Ty<'_>,
    err: &mut DiagnosticBuilder<'_>
)

impl<'a, 'tcx> NiceRegionError<'a, 'tcx>

pub(super) fn try_report_mismatched_static_lifetime(
    &self
) -> Option<ErrorReported>

impl<'a, 'tcx> NiceRegionError<'a, 'tcx>

pub(super) fn try_report_named_anon_conflict(
    &self
) -> Option<DiagnosticBuilder<'tcx>>

When given a ConcreteFailure for a function with parameters containing a named region and an anonymous region, emit an descriptive diagnostic error.

impl<'tcx> NiceRegionError<'_, 'tcx>

pub(super) fn try_report_placeholder_conflict(
    &self
) -> Option<DiagnosticBuilder<'tcx>>

When given a ConcreteFailure for a function with arguments containing a named region and an anonymous region, emit a descriptive diagnostic error.

fn try_report_trait_placeholder_mismatch(
    &self,
    vid: Option<Region<'tcx>>,
    cause: &ObligationCause<'tcx>,
    sub_placeholder: Option<Region<'tcx>>,
    sup_placeholder: Option<Region<'tcx>>,
    value_pairs: &ValuePairs<'tcx>
) -> Option<DiagnosticBuilder<'tcx>>

fn report_trait_placeholder_mismatch(
    &self,
    vid: Option<Region<'tcx>>,
    cause: &ObligationCause<'tcx>,
    sub_placeholder: Option<Region<'tcx>>,
    sup_placeholder: Option<Region<'tcx>>,
    trait_def_id: DefId,
    expected_substs: SubstsRef<'tcx>,
    actual_substs: SubstsRef<'tcx>
) -> DiagnosticBuilder<'tcx>

fn explain_actual_impl_that_was_found(
    &self,
    err: &mut DiagnosticBuilder<'_>,
    sub_placeholder: Option<Region<'tcx>>,
    sup_placeholder: Option<Region<'tcx>>,
    has_sub: Option<usize>,
    has_sup: Option<usize>,
    expected_trait_ref: TraitRef<'tcx>,
    actual_trait_ref: TraitRef<'tcx>,
    vid: Option<Region<'tcx>>,
    expected_has_vid: Option<usize>,
    actual_has_vid: Option<usize>,
    any_self_ty_has_vid: bool,
    leading_ellipsis: bool
)

Add notes with details about the expected and actual trait refs, with attention to cases when placeholder regions are involved: either the trait or the self type containing them needs to be mentioned the closest to the placeholders. This makes the error messages read better, however at the cost of some complexity due to the number of combinations we have to deal with.

impl<'a, 'tcx> NiceRegionError<'a, 'tcx>

pub(super) fn try_report_static_impl_trait(&self) -> Option<ErrorReported>

Print the error message for lifetime errors when the return type is a static impl Trait, dyn Trait or if a method call on a trait object introduces a static requirement.

impl<'a, 'tcx> NiceRegionError<'a, 'tcx>

fn get_impl_ident_and_self_ty_from_trait(
    &self,
    def_id: DefId,
    trait_objects: &FxHashSet<DefId>
) -> Option<(Ident, &'tcx Ty<'tcx>)>

fn find_impl_on_dyn_trait(
    &self,
    err: &mut DiagnosticBuilder<'_>,
    ty: Ty<'_>,
    ctxt: &UnifyReceiverContext<'tcx>
) -> bool

When we call a method coming from an impl Foo for dyn Bar, dyn Bar introduces a default 'static obligation. Suggest relaxing that implicit bound.

fn suggest_constrain_dyn_trait_in_impl(
    &self,
    err: &mut DiagnosticBuilder<'_>,
    found_dids: &FxHashSet<DefId>,
    ident: Ident,
    self_ty: &Ty<'_>
) -> bool

impl<'a, 'tcx> NiceRegionError<'a, 'tcx>

pub(super) fn try_report_impl_not_conforming_to_trait(
    &self
) -> Option<ErrorReported>

Print the error message for lifetime errors when the impl doesn’t conform to the trait.

fn emit_err(
    &self,
    sp: Span,
    expected: Ty<'tcx>,
    found: Ty<'tcx>,
    trait_def_id: DefId
)

fn emit_associated_type_err(
    &self,
    span: Span,
    item_name: Symbol,
    impl_item_def_id: DefId,
    trait_item_def_id: DefId
)

impl<'a, 'tcx> NiceRegionError<'a, 'tcx>

pub(super) fn find_param_with_region(
    &self,
    anon_region: Region<'tcx>,
    replace_region: Region<'tcx>
) -> Option<AnonymousParamInfo<'_>>

pub(super) fn future_return_type(
    &self,
    local_def_id: LocalDefId
) -> Option<&Ty<'_>>

pub(super) fn asyncness(&self, local_def_id: LocalDefId) -> Option<IsAsync>

pub(super) fn is_return_type_anon(
    &self,
    scope_def_id: LocalDefId,
    br: BoundRegionKind,
    decl: &FnDecl<'_>
) -> Option<Span>

pub(super) fn is_self_anon(
    &self,
    is_first: bool,
    scope_def_id: LocalDefId
) -> bool

impl<'cx, 'tcx> NiceRegionError<'cx, 'tcx>

pub fn new(
    infcx: &'cx InferCtxt<'cx, 'tcx>,
    error: RegionResolutionError<'tcx>
) -> Self

pub fn new_from_span(
    infcx: &'cx InferCtxt<'cx, 'tcx>,
    span: Span,
    sub: Region<'tcx>,
    sup: Region<'tcx>
) -> Self

fn tcx(&self) -> TyCtxt<'tcx>

pub fn try_report_from_nll(&self) -> Option<DiagnosticBuilder<'tcx>>

pub fn try_report(&self) -> Option<ErrorReported>

pub fn regions(&self) -> Option<(Span, Region<'tcx>, Region<'tcx>)>

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: 184 bytes