Struct BodyTransCtx

Source
pub(crate) struct BodyTransCtx<'tcx, 'tctx, 'ictx> {
    pub i_ctx: &'ictx mut ItemTransCtx<'tcx, 'tctx>,
    pub locals: Locals,
    pub locals_map: HashMap<usize, LocalId>,
    pub blocks: Vector<BlockId, BlockData>,
    pub blocks_map: HashMap<BasicBlock, BlockId>,
    pub blocks_stack: VecDeque<BasicBlock>,
}
Expand description

A translation context for function bodies.

Fields§

§i_ctx: &'ictx mut ItemTransCtx<'tcx, 'tctx>

The translation context for the item.

§locals: Locals

The (regular) variables in the current function body.

§locals_map: HashMap<usize, LocalId>

The map from rust variable indices to translated variables indices.

§blocks: Vector<BlockId, BlockData>

The translated blocks.

§blocks_map: HashMap<BasicBlock, BlockId>

The map from rust blocks to translated blocks. Note that when translating terminators like DropAndReplace, we might have to introduce new blocks which don’t appear in the original MIR.

§blocks_stack: VecDeque<BasicBlock>

We register the blocks to translate in a stack, so as to avoid writing the translation functions as recursive functions. We do so because we had stack overflows in the past.

Implementations§

Source§

impl<'tcx, 'tctx, 'ictx> BodyTransCtx<'tcx, 'tctx, 'ictx>

Source

pub(crate) fn new(i_ctx: &'ictx mut ItemTransCtx<'tcx, 'tctx>) -> Self

Source§

impl BodyTransCtx<'_, '_, '_>

Source

pub(crate) fn translate_local(&self, local: &Local) -> Option<LocalId>

Source

pub(crate) fn push_var(&mut self, rid: usize, ty: Ty, name: Option<String>)

Source

fn translate_binaryop_kind( &mut self, _span: Span, binop: BinOp, ) -> Result<BinOp, Error>

Source

fn translate_body_locals( &mut self, body: &MirBody<Unknown>, ) -> Result<(), Error>

Translate a function’s local variables by adding them in the environment.

Source

fn translate_basic_block_id(&mut self, block_id: BasicBlock) -> BlockId

Translate a basic block id and register it, if it hasn’t been done.

Source

fn translate_basic_block( &mut self, body: &MirBody<Unknown>, block: &BasicBlockData, ) -> Result<BlockData, Error>

Source

fn translate_place(&mut self, span: Span, place: &Place) -> Result<Place, Error>

Translate a place TODO: Hax represents places in a different manner than MIR. We should update our representation of places to match the Hax representation.

Source

fn translate_operand_with_type( &mut self, span: Span, operand: &Operand, ) -> Result<(Operand, Ty), Error>

Translate an operand with its type

Source

fn translate_operand( &mut self, span: Span, operand: &Operand, ) -> Result<Operand, Error>

Translate an operand

Source

fn translate_rvalue( &mut self, span: Span, rvalue: &Rvalue, ) -> Result<Rvalue, Error>

Translate an rvalue

Source

fn translate_statement( &mut self, body: &MirBody<Unknown>, statement: &Statement, ) -> Result<Option<Statement>, Error>

Translate a statement

We return an option, because we ignore some statements (Nop, StorageLive…)

Source

fn translate_terminator( &mut self, body: &MirBody<Unknown>, terminator: &Terminator, statements: &mut Vec<Statement>, ) -> Result<Terminator, Error>

Translate a terminator

Source

fn translate_switch_targets( &mut self, span: Span, switch_ty: &Ty, targets: &[(ScalarInt, BasicBlock)], otherwise: &BasicBlock, ) -> Result<SwitchTargets, Error>

Translate switch targets

Source

fn translate_function_call( &mut self, span: Span, fun: &FunOperand, args: &Vec<Spanned<Operand>>, destination: &Place, target: &Option<BasicBlock>, unwind: &UnwindAction, ) -> Result<TerminatorKind, Error>

Translate a function call statement. Note that body is the body of the function being translated, not of the function referenced in the function call: we need it in order to translate the blocks we go to after the function call returns.

Source

fn translate_arguments( &mut self, span: Span, args: &Vec<Spanned<Operand>>, ) -> Result<Vec<Operand>, Error>

Evaluate function arguments in a context, and return the list of computed values.

Source

fn translate_body_comments( &mut self, source_text: &Option<String>, charon_span: Span, ) -> Vec<(usize, Vec<String>)>

Gather all the lines that start with // inside the given span.

Source

pub fn translate_def_body( &mut self, span: Span, def: &FullDef, ) -> Result<Result<Body, Opaque>, Error>

Translate the MIR body of this definition if it has one.

Source

pub fn translate_body( &mut self, span: Span, body: &MirBody<Unknown>, source_text: &Option<String>, ) -> Result<Result<Body, Opaque>, Error>

Translate a function body.

Source

fn translate_body_aux( &mut self, body: &MirBody<Unknown>, source_text: &Option<String>, ) -> Result<Result<Body, Opaque>, Error>

Methods from Deref<Target = ItemTransCtx<'tcx, 'tctx>>§

Source

pub fn get_mir( &mut self, item_ref: &ItemRef, span: Span, ) -> Result<Option<MirBody<Unknown>>, Error>

Source

fn get_mir_inner( &mut self, item_ref: &ItemRef, span: Span, ) -> Result<Option<MirBody<Unknown>>, Error>

Source

pub fn translate_closure_info( &mut self, span: Span, args: &ClosureArgs, ) -> Result<ClosureInfo, Error>

Source

pub fn translate_closure_bound_type_ref( &mut self, span: Span, closure: &ClosureArgs, ) -> Result<RegionBinder<TypeDeclRef>, Error>

Translate a reference to the closure ADT. The resulting type needs lifetime arguments for the upvars (captured variables). If you don’t know what to do about the bound lifetimes, use translate_closure_type_ref instead.

Source

pub fn translate_closure_type_ref( &mut self, span: Span, closure: &ClosureArgs, ) -> Result<TypeDeclRef, Error>

Translate a reference to the closure ADT.

Source

pub fn translate_stateless_closure_as_fn_ref( &mut self, span: Span, closure: &ClosureArgs, ) -> Result<RegionBinder<FunDeclRef>, Error>

For stateless closures, translate a function reference to the top-level function that executes the closure code without taking the state as parameter.

Source

pub fn translate_closure_bound_impl_ref( &mut self, span: Span, closure: &ClosureArgs, target_kind: ClosureKind, ) -> Result<RegionBinder<TraitImplRef>, Error>

Translate a reference to the chosen closure impl. The resulting value needs lifetime arguments for late-bound lifetimes. If you don’t know what to do about the bound lifetimes, use translate_closure_impl_ref instead.

Source

pub fn translate_closure_impl_ref( &mut self, span: Span, closure: &ClosureArgs, target_kind: ClosureKind, ) -> Result<TraitImplRef, Error>

Translate a reference to the chosen closure impl.

Source

pub fn get_closure_state_ty( &mut self, span: Span, args: &ClosureArgs, ) -> Result<Ty, Error>

Source

pub fn translate_closure_adt( &mut self, _trans_id: TypeDeclId, span: Span, args: &ClosureArgs, ) -> Result<TypeDeclKind, Error>

Source

fn translate_closure_method_sig( &mut self, def: &FullDef, span: Span, args: &ClosureArgs, target_kind: ClosureKind, ) -> Result<FunSig, Error>

Given an item that is a closure, generate the signature of the call_once/call_mut/call method (depending on target_kind).

Source

fn translate_constant_literal_to_constant_expr_kind( &mut self, span: Span, v: &ConstantLiteral, ) -> Result<ConstantExprKind, Error>

Source

pub(crate) fn translate_constant_expr_to_constant_expr( &mut self, span: Span, v: &ConstantExpr, ) -> Result<ConstantExpr, Error>

Remark: [hax::ConstantExpr] contains span information, but it is often the default span (i.e., it is useless), hence the additional span argument. TODO: the user_ty might be None because hax doesn’t extract it (because we are translating a ConstantExpr instead of a Constant. We need to update hax.

Source

pub(crate) fn translate_constant_expr_to_const_generic( &mut self, span: Span, v: &ConstantExpr, ) -> Result<ConstGeneric, Error>

Remark: [hax::ConstantExpr] contains span information, but it is often the default span (i.e., it is useless), hence the additional span argument.

Source

pub(crate) fn make_dep_source(&self, span: Span) -> Option<DepSource>

Source

pub(crate) fn register_and_enqueue<T: TryFrom<AnyTransId>>( &mut self, span: Span, item_src: TransItemSource, ) -> T

Register this item source and enqueue it for translation.

Source

pub(crate) fn register_no_enqueue<T: TryFrom<AnyTransId>>( &mut self, span: Span, src: &TransItemSource, ) -> T

Source

pub(crate) fn register_item_maybe_enqueue<T: TryFrom<AnyTransId>>( &mut self, span: Span, enqueue: bool, item: &ItemRef, kind: TransItemSourceKind, ) -> T

Register this item and maybe enqueue it for translation.

Source

pub(crate) fn register_item<T: TryFrom<AnyTransId>>( &mut self, span: Span, item: &ItemRef, kind: TransItemSourceKind, ) -> T

Register this item and enqueue it for translation.

Source

pub(crate) fn register_item_no_enqueue<T: TryFrom<AnyTransId>>( &mut self, span: Span, item: &ItemRef, kind: TransItemSourceKind, ) -> T

Register this item without enqueueing it for translation.

Source

pub(crate) fn translate_item_maybe_enqueue<T: TryFrom<ItemRef<AnyTransId>>>( &mut self, span: Span, enqueue: bool, item: &ItemRef, kind: TransItemSourceKind, ) -> Result<T, Error>

Register this item and maybe enqueue it for translation.

Source

pub(crate) fn translate_item<T: TryFrom<ItemRef<AnyTransId>>>( &mut self, span: Span, item: &ItemRef, kind: TransItemSourceKind, ) -> Result<T, Error>

Register this item and enqueue it for translation.

Note: for FnPtrs use translate_fn_ptr instead, as this handles late-bound variables correctly. For TypeDeclRefs use translate_type_decl_ref instead, as this correctly recognizes built-in types.

Source

pub(crate) fn translate_item_no_enqueue<T: TryFrom<ItemRef<AnyTransId>>>( &mut self, span: Span, item: &ItemRef, kind: TransItemSourceKind, ) -> Result<T, Error>

Register this item and don’t enqueue it for translation.

Source

pub(crate) fn translate_type_decl_ref( &mut self, span: Span, item: &ItemRef, ) -> Result<TypeDeclRef, Error>

Translate a type def id

Source

pub(crate) fn translate_fun_item( &mut self, span: Span, item: &ItemRef, ) -> Result<MaybeBuiltinFunDeclRef, Error>

Translate a function def id

Source

pub(crate) fn translate_fn_ptr( &mut self, span: Span, item: &ItemRef, ) -> Result<RegionBinder<FnPtr>, Error>

Auxiliary function to translate function calls and references to functions. Translate a function id applied with some substitutions.

Source

pub(crate) fn translate_global_decl_ref( &mut self, span: Span, item: &ItemRef, ) -> Result<GlobalDeclRef, Error>

Source

pub(crate) fn translate_trait_decl_ref( &mut self, span: Span, item: &ItemRef, ) -> Result<TraitDeclRef, Error>

Source

pub(crate) fn translate_trait_impl_ref( &mut self, span: Span, item: &ItemRef, kind: TraitImplSource, ) -> Result<TraitImplRef, Error>

Source

pub fn monomorphize(&self) -> bool

Whether to monomorphize items we encounter.

Source

pub fn span_err(&self, span: Span, msg: &str, level: Level<'_>) -> Error

Source

pub fn hax_state(&self) -> &StateWithBase<'tcx>

Source

pub fn hax_state_with_id(&self) -> StateWithOwner<'tcx>

Source

pub fn hax_def(&mut self, item: &ItemRef) -> Result<Arc<FullDef>, Error>

Return the definition for this item. This uses the polymorphic or monomorphic definition depending on user choice.

Source

pub(crate) fn poly_hax_def( &mut self, def_id: &DefId, ) -> Result<Arc<FullDef>, Error>

Source

fn translate_drop_method_body( &mut self, span: Span, def: &FullDef, ) -> Result<Result<Body, Opaque>, Error>

Source

pub(crate) fn translate_function_signature( &mut self, def: &FullDef, item_meta: &ItemMeta, ) -> Result<FunSig, Error>

Translate a function’s signature, and initialize a body translation context at the same time - the function signature gives us the list of region and type parameters, that we put in the translation context.

Source

pub(crate) fn build_ctor_body( &mut self, span: Span, def: &FullDef, adt_def_id: &DefId, ctor_of: &CtorOf, variant_id: usize, fields: &IndexVec<FieldIdx, FieldDef>, output_ty: &Ty, ) -> Result<Body, Error>

Generate a fake function body for ADT constructors.

Source

pub(crate) fn recognize_builtin_fun( &mut self, item: &ItemRef, ) -> Result<Option<BuiltinFunId>, Error>

Checks whether the given id corresponds to a built-in type.

Source

pub(crate) fn the_only_binder(&self) -> &BindingLevel

Get the only binding level. Panics if there are other binding levels.

Source

pub(crate) fn the_only_binder_mut(&mut self) -> &mut BindingLevel

Get the only binding level. Panics if there are other binding levels.

Source

pub(crate) fn outermost_binder(&self) -> &BindingLevel

Source

pub(crate) fn outermost_binder_mut(&mut self) -> &mut BindingLevel

Source

pub(crate) fn innermost_binder(&self) -> &BindingLevel

Source

pub(crate) fn innermost_binder_mut(&mut self) -> &mut BindingLevel

Source

pub(crate) fn outermost_generics(&self) -> &GenericParams

Source

pub(crate) fn outermost_generics_mut(&mut self) -> &mut GenericParams

Source

pub(crate) fn innermost_generics(&self) -> &GenericParams

Source

pub(crate) fn innermost_generics_mut(&mut self) -> &mut GenericParams

Source

pub(crate) fn lookup_bound_region( &mut self, span: Span, dbid: DebruijnIndex, var: BoundVar, ) -> Result<RegionDbVar, Error>

Source

pub(crate) fn lookup_param<Id: Copy>( &mut self, span: Span, f: impl for<'a> Fn(&'a BindingLevel) -> Option<Id>, mk_err: impl FnOnce() -> String, ) -> Result<DeBruijnVar<Id>, Error>

Source

pub(crate) fn lookup_early_region( &mut self, span: Span, region: &EarlyParamRegion, ) -> Result<RegionDbVar, Error>

Source

pub(crate) fn lookup_type_var( &mut self, span: Span, param: &ParamTy, ) -> Result<TypeDbVar, Error>

Source

pub(crate) fn lookup_const_generic_var( &mut self, span: Span, param: &ParamConst, ) -> Result<ConstGenericDbVar, Error>

Source

pub(crate) fn lookup_clause_var( &mut self, span: Span, id: usize, ) -> Result<ClauseDbVar, Error>

Source

pub(crate) fn push_generic_params( &mut self, generics: &TyGenerics, ) -> Result<(), Error>

Source

pub(crate) fn push_generic_param( &mut self, param: &GenericParamDef, ) -> Result<(), Error>

Source

fn push_generics_for_def( &mut self, span: Span, def: &FullDef, is_parent: bool, ) -> Result<(), Error>

Add the generics and predicates of this item and its parents to the current context.

Source

fn push_generics_for_def_without_parents( &mut self, _span: Span, def: &FullDef, include_late_bound: bool, ) -> Result<(), Error>

Add the generics and predicates of this item. This does not include the parent generics; use push_generics_for_def to get the full list.

Source

pub(crate) fn translate_def_generics( &mut self, span: Span, def: &FullDef, ) -> Result<(), Error>

Translate the generics and predicates of this item and its parents. This adds generic parameters and predicates to the current environment (as a binder in self.binding_levels). This is necessary to translate types that depend on these generics (such as Ty and TraitRef). The constructed GenericParams can be recovered at the end using self.into_generics() and stored in the translated item.

Source

pub(crate) fn translate_def_generics_without_parents( &mut self, span: Span, def: &FullDef, ) -> Result<(), Error>

Translate the generics and predicates of this item without its parents.

Source

pub(crate) fn translate_binder_for_def<F, U>( &mut self, span: Span, kind: BinderKind, def: &FullDef, f: F, ) -> Result<Binder<U>, Error>
where F: FnOnce(&mut Self) -> Result<U, Error>,

Push a new binding level corresponding to the provided def for the duration of the inner function call.

Source

pub(crate) fn translate_region_binder<F, T, U>( &mut self, _span: Span, binder: &Binder<T>, f: F, ) -> Result<RegionBinder<U>, Error>
where F: FnOnce(&mut Self, &T) -> Result<U, Error>,

Push a group of bound regions and call the continuation. We use this when diving into a for<'a>, or inside an arrow type (because it contains universally quantified regions).

Source

pub(crate) fn register_module(&mut self, item_meta: ItemMeta, def: &FullDef)

Register the items inside this module or inherent impl.

Source

pub(crate) fn get_item_kind( &mut self, span: Span, def: &FullDef, ) -> Result<ItemKind, Error>

Source

pub fn translate_virtual_trait_impl( &mut self, def_id: TraitImplId, item_meta: ItemMeta, vimpl: &VirtualTraitImpl, ) -> Result<TraitImpl, Error>

Make a trait impl from a hax VirtualTraitImpl. Used for constructing fake trait impls for builtin types like FnOnce.

Source

pub(crate) fn translate_span_from_hax(&mut self, rspan: &Span) -> Span

Source

pub(crate) fn def_span(&mut self, def_id: &DefId) -> Span

Source

pub(crate) fn register_predicates( &mut self, preds: &GenericPredicates, origin: PredicateOrigin, ) -> Result<(), Error>

Translates the given predicates and stores them as resuired preciates of the innermost binder.

This function should be called after we translated the generics (type parameters, regions…).

Source

pub(crate) fn translate_predicates( &mut self, preds: &GenericPredicates, origin: PredicateOrigin, ) -> Result<GenericParams, Error>

Translates the given predicates. Returns a GenericParams that only contains predicates.

This function should be called after we translated the generics (type parameters, regions…).

Source

pub(crate) fn translate_poly_trait_ref( &mut self, span: Span, bound_trait_ref: &Binder<TraitRef>, ) -> Result<PolyTraitDeclRef, Error>

Source

pub(crate) fn translate_poly_trait_predicate( &mut self, span: Span, bound_trait_ref: &Binder<TraitPredicate>, ) -> Result<PolyTraitDeclRef, Error>

Source

pub(crate) fn translate_trait_predicate( &mut self, span: Span, trait_pred: &TraitPredicate, ) -> Result<TraitDeclRef, Error>

Source

pub(crate) fn translate_trait_ref( &mut self, span: Span, trait_ref: &TraitRef, ) -> Result<TraitDeclRef, Error>

Source

pub(crate) fn translate_predicate( &mut self, clause: &Clause, hspan: &Span, origin: PredicateOrigin, into: &mut GenericParams, ) -> Result<(), Error>

Source

pub(crate) fn translate_trait_impl_exprs( &mut self, span: Span, impl_sources: &[ImplExpr], ) -> Result<Vector<TraitClauseId, TraitRef>, Error>

Source

pub(crate) fn translate_trait_impl_expr( &mut self, span: Span, impl_expr: &ImplExpr, ) -> Result<TraitRef, Error>

Source

pub(crate) fn translate_trait_impl_expr_aux( &mut self, span: Span, impl_source: &ImplExpr, trait_decl_ref: PolyTraitDeclRef, ) -> Result<TraitRef, Error>

Source

pub fn check_at_most_one_pred_has_methods( &mut self, span: Span, preds: &GenericPredicates, ) -> Result<(), Error>

Source

pub fn translate_existential_predicates( &mut self, span: Span, self_ty: &ParamTy, preds: &GenericPredicates, region: &Region, ) -> Result<DynPredicate, Error>

Source

pub fn trait_is_dyn_compatible(&mut self, def_id: &DefId) -> Result<bool, Error>

Query whether a trait is dyn compatible. TODO(dyn): for now we return false if the trait has any associated types, as we don’t handle associated types in vtables.

Source

fn pred_is_for_self(&self, tref: &TraitRef) -> bool

Check whether this trait ref is of the form Self: Trait<...>.

Source

pub fn translate_vtable_struct_ref( &mut self, span: Span, tref: &TraitRef, ) -> Result<Option<TypeDeclRef>, Error>

Given a trait ref, return a reference to its vtable struct, if it is dyn compatible.

Source

fn add_method_to_vtable_def( &mut self, span: Span, trait_def: &FullDef, mk_field: impl FnMut(String, Ty), item: &AssocItem, ) -> Result<(), Error>

Add a method_name: fn(...) -> ... field for the method.

Source

fn add_supertraits_to_vtable_def( &mut self, span: Span, mk_field: impl FnMut(String, Ty), implied_predicates: &GenericPredicates, ) -> Result<(), Error>

Add super_trait_n: &'static SuperTraitNVTable fields.

Source

fn gen_vtable_struct_fields( &mut self, span: Span, trait_def: &FullDef, implied_predicates: &GenericPredicates, ) -> Result<Vector<FieldId, Field>, Error>

Source

pub fn translate_vtable_instance_ref( &mut self, span: Span, trait_ref: &TraitRef, impl_ref: &ItemRef, ) -> Result<Option<GlobalDeclRef>, Error>

Source

fn get_vtable_instance_info<'a>( &mut self, span: Span, impl_def: &'a FullDef, impl_kind: &TraitImplSource, ) -> Result<(TraitImplRef, TraitDeclRef, TypeDeclRef), Error>

Local helper function to get the vtable struct reference and trait declaration reference

Source

fn add_method_to_vtable_value( &mut self, span: Span, impl_def: &FullDef, item: &ImplAssocItem, mk_field: impl FnMut(ConstantExprKind), ) -> Result<(), Error>

Source

fn add_supertraits_to_vtable_value( &mut self, span: Span, trait_def: &FullDef, impl_def: &FullDef, mk_field: impl FnMut(ConstantExprKind), ) -> Result<(), Error>

Source

fn gen_vtable_instance_init_body( &mut self, span: Span, impl_def: &FullDef, vtable_struct_ref: TypeDeclRef, ) -> Result<Body, Error>

Generate the body of the vtable instance function. This is for impl Trait for T implementation, it does NOT handle builtin impls.

let ret@0 : VTable;
ret@0 = VTable { ... };
return;
Source

pub(crate) fn translate_region( &mut self, span: Span, region: &Region, ) -> Result<Region, Error>

Source

pub(crate) fn translate_ty(&mut self, span: Span, ty: &Ty) -> Result<Ty, Error>

Translate a Ty.

Typically used in this module to translate the fields of a structure/ enumeration definition, or later to translate the type of a variable.

Note that we take as parameter a function to translate regions, because regions can be translated in several manners (non-erased region or erased regions), in which case the return type is different.

Source

fn translate_ty_inner(&mut self, span: Span, ty: &Ty) -> Result<Ty, Error>

Source

pub fn translate_fun_sig( &mut self, span: Span, sig: &Binder<TyFnSig>, ) -> Result<RegionBinder<(Vec<Ty>, Ty)>, Error>

Source

pub fn translate_generic_args( &mut self, span: Span, substs: &[GenericArg], trait_refs: &[ImplExpr], ) -> Result<GenericArgs, Error>

Translate generic args. Don’t call directly; use translate_xxx_ref as much as possible.

Source

pub fn append_late_bound_to_generics( &mut self, span: Span, generics: GenericArgs, late_bound: Option<Binder<()>>, ) -> Result<RegionBinder<GenericArgs>, Error>

Append the given late bound variables to the provided generics.

Source

pub(crate) fn recognize_builtin_type( &mut self, item: &ItemRef, ) -> Result<Option<BuiltinTy>, Error>

Checks whether the given id corresponds to a built-in type.

Source

pub fn translate_ptr_metadata(&self, item: &ItemRef) -> Option<PtrMetadata>

Translate a Dynamically Sized Type metadata kind.

Returns None if the type is generic, or if it is not a DST.

Source

pub fn translate_layout(&self, item: &ItemRef) -> Option<Layout>

Translate a type layout.

Translates the layout as queried from rustc into the more restricted Layout.

Source

pub fn generate_naive_layout( &self, span: Span, ty: &TypeDeclKind, ) -> Result<Layout, Error>

Generate a naive layout for this type.

Source

pub(crate) fn translate_adt_def( &mut self, trans_id: TypeDeclId, def_span: Span, item_meta: &ItemMeta, def: &FullDef, ) -> Result<TypeDeclKind, Error>

Translate the body of a type declaration.

Note that the type may be external, in which case we translate the body only if it is public (i.e., it is a public enumeration, or it is a struct with only public fields).

Source

fn translate_discriminant( &mut self, def_span: Span, discr: &DiscriminantValue, ) -> Result<ScalarValue, Error>

Trait Implementations§

Source§

impl<'tcx, 'tctx, 'ictx> Deref for BodyTransCtx<'tcx, 'tctx, 'ictx>

Source§

type Target = ItemTransCtx<'tcx, 'tctx>

The resulting type after dereferencing.
Source§

fn deref(&self) -> &Self::Target

Dereferences the value.
Source§

impl<'tcx, 'tctx, 'ictx> DerefMut for BodyTransCtx<'tcx, 'tctx, 'ictx>

Source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
Source§

impl<'a> IntoFormatter for &'a BodyTransCtx<'_, '_, '_>

Source§

type C = FmtCtx<'a>

Source§

fn into_fmt(self) -> Self::C

Auto Trait Implementations§

§

impl<'tcx, 'tctx, 'ictx> Freeze for BodyTransCtx<'tcx, 'tctx, 'ictx>

§

impl<'tcx, 'tctx, 'ictx> !RefUnwindSafe for BodyTransCtx<'tcx, 'tctx, 'ictx>

§

impl<'tcx, 'tctx, 'ictx> !Send for BodyTransCtx<'tcx, 'tctx, 'ictx>

§

impl<'tcx, 'tctx, 'ictx> !Sync for BodyTransCtx<'tcx, 'tctx, 'ictx>

§

impl<'tcx, 'tctx, 'ictx> Unpin for BodyTransCtx<'tcx, 'tctx, 'ictx>

§

impl<'tcx, 'tctx, 'ictx> !UnwindSafe for BodyTransCtx<'tcx, 'tctx, 'ictx>

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<I, T> ExtractContext<I, ()> for T

§

fn extract_context(self, _original_input: I)

Given the context attached to a nom error, and given the original input to the nom parser, extract more the useful context information. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

Source§

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)
The target type on which the method may be called.
§

impl<I> RecreateContext<I> for I

§

fn recreate_context(_original_input: I, tail: I) -> I

Given the original input, as well as the context reported by nom, recreate a context in the original string where the error occurred. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more