Trait ArenaCached 

pub trait ArenaCached<'tcx>: Sized {
    type Provided;
    type Allocated: 'tcx;

    // Required method
    fn alloc_in_arena(
        tcx: TyCtxt<'tcx>,
        typed_arena: &'tcx TypedArena<Self::Allocated>,
        value: Self::Provided,
    ) -> Self;
}

Helper trait that allows arena_cache queries to return:

• Option<&T> instead of &Option<T>, and avoid allocating None in the arena; or
• Result<&T, ErrorGuaranteed> instead of &Result<T, ErrorGuaranteed>, and avoid allocating Err(ErrorGuaranteed) in the arena.

An arena-cached query must be declared to return a type that implements this trait, i.e. &'tcx T, Option<&'tcx T>, or Result<&'tcx T, ErrorGuaranteed>. This trait then determines the types returned by the provider and stored in the arena, and provides a function to bridge between the three types.

Required Associated Types

type Provided

Type that is returned by the query provider.

type Allocated: 'tcx

Type that is stored in the arena.

Required Methods

fn alloc_in_arena( tcx: TyCtxt<'tcx>, typed_arena: &'tcx TypedArena<Self::Allocated>, value: Self::Provided, ) -> Self

Takes a provided value, and allocates it in an appropriate arena, unless the particular value doesn’t need allocation (e.g. None).

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<'tcx, T> ArenaCached<'tcx> for &'tcx T

type Provided = T

type Allocated = T

fn alloc_in_arena( tcx: TyCtxt<'tcx>, typed_arena: &'tcx TypedArena<T>, value: T, ) -> Self

impl<'tcx, T> ArenaCached<'tcx> for Option<&'tcx T>

type Allocated = T

The provide value is Option<T>, but we only store T in the arena.

type Provided = Option<T>

fn alloc_in_arena( tcx: TyCtxt<'tcx>, typed_arena: &'tcx TypedArena<T>, value: Option<T>, ) -> Self

impl<'tcx, T> ArenaCached<'tcx> for Result<&'tcx T, ErrorGuaranteed>

type Allocated = T

The provide value is Result<T, ErrorGuaranteed>, but we only store T in the arena.

type Provided = Result<T, ErrorGuaranteed>

fn alloc_in_arena( tcx: TyCtxt<'tcx>, typed_arena: &'tcx TypedArena<T>, value: Result<T, ErrorGuaranteed>, ) -> Self

Implementors