Struct rustc_borrowck::region_infer::TypeTest

pub struct TypeTest<'tcx> {
    pub generic_kind: GenericKind<'tcx>,
    pub lower_bound: RegionVid,
    pub span: Span,
    pub verify_bound: VerifyBound<'tcx>,
}

A “type test” corresponds to an outlives constraint between a type and a lifetime, like T: 'x or <T as Foo>::Bar: 'x. They are translated from the Verify region constraints in the ordinary inference context.

These sorts of constraints are handled differently than ordinary constraints, at least at present. During type checking, the InferCtxt::process_registered_region_obligations method will attempt to convert a type test like T: 'x into an ordinary outlives constraint when possible (for example, &'a T: 'b will be converted into 'a: 'b and registered as a Constraint).

In some cases, however, there are outlives relationships that are not converted into a region constraint, but rather into one of these “type tests”. The distinction is that a type test does not influence the inference result, but instead just examines the values that we ultimately inferred for each region variable and checks that they meet certain extra criteria. If not, an error can be issued.

One reason for this is that these type tests typically boil down to a check like 'a: 'x where 'a is a universally quantified region – and therefore not one whose value is really meant to be inferred, precisely (this is not always the case: one can have a type test like <Foo as Trait<'?0>>::Bar: 'x, where '?0 is an inference variable). Another reason is that these type tests can involve disjunction – that is, they can be satisfied in more than one way.

For more information about this translation, see InferCtxt::process_registered_region_obligations and InferCtxt::type_must_outlive in rustc_infer::infer::InferCtxt.

Fields

generic_kind: GenericKind<'tcx>

The type T that must outlive the region.

lower_bound: RegionVid

The region 'x that the type must outlive.

span: Span

The span to blame.

verify_bound: VerifyBound<'tcx>

A test which, if met by the region 'x, proves that this type constraint is satisfied.

Trait Implementations

impl<'tcx> Clone for TypeTest<'tcx>

fn clone(&self) -> TypeTest<'tcx>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'tcx> Debug for TypeTest<'tcx>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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