Struct rustc_trait_selection::opaque_types::OpaqueTypeDecl

pub struct OpaqueTypeDecl<'tcx> {
    pub opaque_type: Ty<'tcx>,
    pub substs: SubstsRef<'tcx>,
    pub definition_span: Span,
    pub concrete_ty: Ty<'tcx>,
    pub has_required_region_bounds: bool,
    pub origin: OpaqueTyOrigin,
}

Information about the opaque types whose values we are inferring in this function (these are the impl Trait that appear in the return type).

Fields

opaque_type: Ty<'tcx>

The opaque type (ty::Opaque) for this declaration.

substs: SubstsRef<'tcx>

The substitutions that we apply to the opaque type that this impl Trait desugars to. e.g., if:

fn foo<'a, 'b, T>() -> impl Trait<'a>

winds up desugared to:

type Foo<'x, X> = impl Trait<'x>
fn foo<'a, 'b, T>() -> Foo<'a, T>

then substs would be ['a, T].

definition_span: Span

The span of this particular definition of the opaque type. So for example:

type Foo = impl Baz;
fn bar() -> Foo {
//          ^^^ This is the span we are looking for!

In cases where the fn returns (impl Trait, impl Trait) or other such combinations, the result is currently over-approximated, but better than nothing.

concrete_ty: Ty<'tcx>

The type variable that represents the value of the opaque type that we require. In other words, after we compile this function, we will be created a constraint like:

Foo<'a, T> = ?C

where ?C is the value of this type variable. =) It may naturally refer to the type and lifetime parameters in scope in this function, though ultimately it should only reference those that are arguments to Foo in the constraint above. (In other words, ?C should not include 'b, even though it’s a lifetime parameter on foo.)

has_required_region_bounds: bool

Returns true if the impl Trait bounds include region bounds. For example, this would be true for:

fn foo<'a, 'b, 'c>() -> impl Trait<'c> + 'a + 'b

but false for:

fn foo<'c>() -> impl Trait<'c>

unless Trait was declared like:

trait Trait<'c>: 'c

in which case it would be true.

This is used during regionck to decide whether we need to impose any additional constraints to ensure that region variables in concrete_ty wind up being constrained to something from substs (or, at minimum, things that outlive the fn body). (Ultimately, writeback is responsible for this check.)

origin: OpaqueTyOrigin

The origin of the opaque type.

Trait Implementations

impl<'tcx> Clone for OpaqueTypeDecl<'tcx>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for OpaqueTypeDecl<'tcx>

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

Formats the value using the given formatter.

impl<'tcx> Copy for OpaqueTypeDecl<'tcx>