Struct rustc_const_eval::const_eval::machine::CompileTimeMachine
source · pub struct CompileTimeMachine<'tcx> {
pub(super) num_evaluated_steps: usize,
pub(super) stack: Vec<Frame<'tcx>>,
pub(super) can_access_mut_global: CanAccessMutGlobal,
pub(super) check_alignment: CheckAlignment,
pub(crate) static_root_ids: Option<(AllocId, LocalDefId)>,
}
Expand description
Extra machine state for CTFE, and the Machine instance.
Fields§
§num_evaluated_steps: usize
The number of terminators that have been evaluated.
This is used to produce lints informing the user that the compiler is not stuck.
Set to usize::MAX
to never report anything.
stack: Vec<Frame<'tcx>>
The virtual call stack.
can_access_mut_global: CanAccessMutGlobal
Pattern matching on consts with references would be unsound if those references could point to anything mutable. Therefore, when evaluating consts and when constructing valtrees, we ensure that only immutable global memory can be accessed.
check_alignment: CheckAlignment
Whether to check alignment during evaluation.
static_root_ids: Option<(AllocId, LocalDefId)>
If Some
, we are evaluating the initializer of the static with the given LocalDefId
,
storing the result in the given AllocId
.
Used to prevent reads from a static’s base allocation, as that may allow for self-initialization loops.
Implementations§
source§impl<'tcx> CompileTimeMachine<'tcx>
impl<'tcx> CompileTimeMachine<'tcx>
pub(crate) fn new( can_access_mut_global: CanAccessMutGlobal, check_alignment: CheckAlignment, ) -> Self
source§impl<'tcx> CompileTimeMachine<'tcx>
impl<'tcx> CompileTimeMachine<'tcx>
sourcepub fn best_lint_scope(&self, tcx: TyCtxt<'tcx>) -> HirId
pub fn best_lint_scope(&self, tcx: TyCtxt<'tcx>) -> HirId
Find the first stack frame that is within the current crate, if any. Otherwise, return the crate’s HirId
Trait Implementations§
source§impl HasStaticRootDefId for CompileTimeMachine<'_>
impl HasStaticRootDefId for CompileTimeMachine<'_>
source§fn static_def_id(&self) -> Option<LocalDefId>
fn static_def_id(&self) -> Option<LocalDefId>
DefId
of the static item that is currently being evaluated.
Used for interning to be able to handle nested allocations.source§impl<'tcx> Machine<'tcx> for CompileTimeMachine<'tcx>
impl<'tcx> Machine<'tcx> for CompileTimeMachine<'tcx>
source§const GLOBAL_KIND: Option<Self::MemoryKind> = None
const GLOBAL_KIND: Option<Self::MemoryKind> = None
tcx
) –
or None if such memory should not be mutated and thus any such attempt will cause
a ModifiedStatic
error to be raised.
Statics are copied under two circumstances: When they are mutated, and when
adjust_allocation
(see below) returns an owned allocation
that is added to the memory so that the work is not done twice.source§const PANIC_ON_ALLOC_FAIL: bool = false
const PANIC_ON_ALLOC_FAIL: bool = false
source§type Provenance = CtfeProvenance
type Provenance = CtfeProvenance
AllocId
they belong to.source§type ProvenanceExtra = bool
type ProvenanceExtra = bool
source§type ExtraFnVal = !
type ExtraFnVal = !
dlsym
that can later be called to execute the right thing.source§type MemoryMap = IndexMap<AllocId, (MemoryKind<MemoryKind>, Allocation), BuildHasherDefault<FxHasher>>
type MemoryMap = IndexMap<AllocId, (MemoryKind<MemoryKind>, Allocation), BuildHasherDefault<FxHasher>>
source§type AllocExtra = ()
type AllocExtra = ()
source§type FrameExtra = ()
type FrameExtra = ()
source§type MemoryKind = MemoryKind
type MemoryKind = MemoryKind
source§fn ignore_optional_overflow_checks(_ecx: &InterpCx<'tcx, Self>) -> bool
fn ignore_optional_overflow_checks(_ecx: &InterpCx<'tcx, Self>) -> bool
source§fn unwind_terminate(
_ecx: &mut InterpCx<'tcx, Self>,
_reason: UnwindTerminateReason,
) -> InterpResult<'tcx>
fn unwind_terminate( _ecx: &mut InterpCx<'tcx, Self>, _reason: UnwindTerminateReason, ) -> InterpResult<'tcx>
source§fn check_fn_target_features(
_ecx: &InterpCx<'tcx, Self>,
_instance: Instance<'tcx>,
) -> InterpResult<'tcx>
fn check_fn_target_features( _ecx: &InterpCx<'tcx, Self>, _instance: Instance<'tcx>, ) -> InterpResult<'tcx>
source§fn call_extra_fn(
_ecx: &mut InterpCx<'tcx, Self>,
fn_val: !,
_abi: CallAbi,
_args: &[FnArg<'tcx>],
_destination: &MPlaceTy<'tcx, Self::Provenance>,
_target: Option<BasicBlock>,
_unwind: UnwindAction,
) -> InterpResult<'tcx>
fn call_extra_fn( _ecx: &mut InterpCx<'tcx, Self>, fn_val: !, _abi: CallAbi, _args: &[FnArg<'tcx>], _destination: &MPlaceTy<'tcx, Self::Provenance>, _target: Option<BasicBlock>, _unwind: UnwindAction, ) -> InterpResult<'tcx>
fn_val
. It is the hook’s responsibility to advance the instruction
pointer as appropriate.source§fn ub_checks(_ecx: &InterpCx<'tcx, Self>) -> InterpResult<'tcx, bool>
fn ub_checks(_ecx: &InterpCx<'tcx, Self>) -> InterpResult<'tcx, bool>
NullaryOp::UbChecks
invocation.source§fn adjust_global_allocation<'b>(
_ecx: &InterpCx<'tcx, Self>,
_id: AllocId,
alloc: &'b Allocation,
) -> InterpResult<'tcx, Cow<'b, Allocation<Self::Provenance>>>
fn adjust_global_allocation<'b>( _ecx: &InterpCx<'tcx, Self>, _id: AllocId, alloc: &'b Allocation, ) -> InterpResult<'tcx, Cow<'b, Allocation<Self::Provenance>>>
source§fn init_alloc_extra(
_ecx: &InterpCx<'tcx, Self>,
_id: AllocId,
_kind: MemoryKind<Self::MemoryKind>,
_size: Size,
_align: Align,
) -> InterpResult<'tcx, Self::AllocExtra>
fn init_alloc_extra( _ecx: &InterpCx<'tcx, Self>, _id: AllocId, _kind: MemoryKind<Self::MemoryKind>, _size: Size, _align: Align, ) -> InterpResult<'tcx, Self::AllocExtra>
source§fn extern_static_pointer(
ecx: &InterpCx<'tcx, Self>,
def_id: DefId,
) -> InterpResult<'tcx, Pointer>
fn extern_static_pointer( ecx: &InterpCx<'tcx, Self>, def_id: DefId, ) -> InterpResult<'tcx, Pointer>
AllocId
for the given extern static
.source§fn adjust_alloc_root_pointer(
_ecx: &InterpCx<'tcx, Self>,
ptr: Pointer<CtfeProvenance>,
_kind: Option<MemoryKind<Self::MemoryKind>>,
) -> InterpResult<'tcx, Pointer<CtfeProvenance>>
fn adjust_alloc_root_pointer( _ecx: &InterpCx<'tcx, Self>, ptr: Pointer<CtfeProvenance>, _kind: Option<MemoryKind<Self::MemoryKind>>, ) -> InterpResult<'tcx, Pointer<CtfeProvenance>>
source§fn ptr_from_addr_cast(
_ecx: &InterpCx<'tcx, Self>,
addr: u64,
) -> InterpResult<'tcx, Pointer<Option<CtfeProvenance>>>
fn ptr_from_addr_cast( _ecx: &InterpCx<'tcx, Self>, addr: u64, ) -> InterpResult<'tcx, Pointer<Option<CtfeProvenance>>>
source§fn ptr_get_alloc(
_ecx: &InterpCx<'tcx, Self>,
ptr: Pointer<CtfeProvenance>,
_size: i64,
) -> Option<(AllocId, Size, Self::ProvenanceExtra)>
fn ptr_get_alloc( _ecx: &InterpCx<'tcx, Self>, ptr: Pointer<CtfeProvenance>, _size: i64, ) -> Option<(AllocId, Size, Self::ProvenanceExtra)>
size
says how many bytes of memory are expected at that pointer. The sign of size
can
be used to disambiguate situations where a wildcard pointer sits right in between two
allocations. Read moresource§fn get_global_alloc_salt(
_ecx: &InterpCx<'tcx, Self>,
_instance: Option<Instance<'tcx>>,
) -> usize
fn get_global_alloc_salt( _ecx: &InterpCx<'tcx, Self>, _instance: Option<Instance<'tcx>>, ) -> usize
source§fn enforce_alignment(ecx: &InterpCx<'tcx, Self>) -> bool
fn enforce_alignment(ecx: &InterpCx<'tcx, Self>) -> bool
source§fn enforce_validity(
ecx: &InterpCx<'tcx, Self>,
layout: TyAndLayout<'tcx>,
) -> bool
fn enforce_validity( ecx: &InterpCx<'tcx, Self>, layout: TyAndLayout<'tcx>, ) -> bool
source§fn load_mir(
ecx: &InterpCx<'tcx, Self>,
instance: InstanceKind<'tcx>,
) -> InterpResult<'tcx, &'tcx Body<'tcx>>
fn load_mir( ecx: &InterpCx<'tcx, Self>, instance: InstanceKind<'tcx>, ) -> InterpResult<'tcx, &'tcx Body<'tcx>>
source§fn find_mir_or_eval_fn(
ecx: &mut InterpCx<'tcx, Self>,
orig_instance: Instance<'tcx>,
_abi: CallAbi,
args: &[FnArg<'tcx>],
dest: &MPlaceTy<'tcx>,
ret: Option<BasicBlock>,
_unwind: UnwindAction,
) -> InterpResult<'tcx, Option<(&'tcx Body<'tcx>, Instance<'tcx>)>>
fn find_mir_or_eval_fn( ecx: &mut InterpCx<'tcx, Self>, orig_instance: Instance<'tcx>, _abi: CallAbi, args: &[FnArg<'tcx>], dest: &MPlaceTy<'tcx>, ret: Option<BasicBlock>, _unwind: UnwindAction, ) -> InterpResult<'tcx, Option<(&'tcx Body<'tcx>, Instance<'tcx>)>>
source§fn panic_nounwind(
ecx: &mut InterpCx<'tcx, Self>,
msg: &str,
) -> InterpResult<'tcx>
fn panic_nounwind( ecx: &mut InterpCx<'tcx, Self>, msg: &str, ) -> InterpResult<'tcx>
source§fn call_intrinsic(
ecx: &mut InterpCx<'tcx, Self>,
instance: Instance<'tcx>,
args: &[OpTy<'tcx>],
dest: &MPlaceTy<'tcx, Self::Provenance>,
target: Option<BasicBlock>,
_unwind: UnwindAction,
) -> InterpResult<'tcx, Option<Instance<'tcx>>>
fn call_intrinsic( ecx: &mut InterpCx<'tcx, Self>, instance: Instance<'tcx>, args: &[OpTy<'tcx>], dest: &MPlaceTy<'tcx, Self::Provenance>, target: Option<BasicBlock>, _unwind: UnwindAction, ) -> InterpResult<'tcx, Option<Instance<'tcx>>>
source§fn assert_panic(
ecx: &mut InterpCx<'tcx, Self>,
msg: &AssertMessage<'tcx>,
_unwind: UnwindAction,
) -> InterpResult<'tcx>
fn assert_panic( ecx: &mut InterpCx<'tcx, Self>, msg: &AssertMessage<'tcx>, _unwind: UnwindAction, ) -> InterpResult<'tcx>
Assert
MIR terminators that trigger a panic.source§fn binary_ptr_op(
_ecx: &InterpCx<'tcx, Self>,
_bin_op: BinOp,
_left: &ImmTy<'tcx>,
_right: &ImmTy<'tcx>,
) -> InterpResult<'tcx, ImmTy<'tcx>>
fn binary_ptr_op( _ecx: &InterpCx<'tcx, Self>, _bin_op: BinOp, _left: &ImmTy<'tcx>, _right: &ImmTy<'tcx>, ) -> InterpResult<'tcx, ImmTy<'tcx>>
source§fn increment_const_eval_counter(
ecx: &mut InterpCx<'tcx, Self>,
) -> InterpResult<'tcx>
fn increment_const_eval_counter( ecx: &mut InterpCx<'tcx, Self>, ) -> InterpResult<'tcx>
StatementKind::ConstEvalCounter
instruction.
You can use this to detect long or endlessly running programs.source§fn expose_ptr(
_ecx: &mut InterpCx<'tcx, Self>,
_ptr: Pointer,
) -> InterpResult<'tcx>
fn expose_ptr( _ecx: &mut InterpCx<'tcx, Self>, _ptr: Pointer, ) -> InterpResult<'tcx>
source§fn init_frame(
ecx: &mut InterpCx<'tcx, Self>,
frame: Frame<'tcx>,
) -> InterpResult<'tcx, Frame<'tcx>>
fn init_frame( ecx: &mut InterpCx<'tcx, Self>, frame: Frame<'tcx>, ) -> InterpResult<'tcx, Frame<'tcx>>
source§fn stack<'a>(
ecx: &'a InterpCx<'tcx, Self>,
) -> &'a [Frame<'tcx, Self::Provenance, Self::FrameExtra>]
fn stack<'a>( ecx: &'a InterpCx<'tcx, Self>, ) -> &'a [Frame<'tcx, Self::Provenance, Self::FrameExtra>]
source§fn stack_mut<'a>(
ecx: &'a mut InterpCx<'tcx, Self>,
) -> &'a mut Vec<Frame<'tcx, Self::Provenance, Self::FrameExtra>>
fn stack_mut<'a>( ecx: &'a mut InterpCx<'tcx, Self>, ) -> &'a mut Vec<Frame<'tcx, Self::Provenance, Self::FrameExtra>>
source§fn before_access_global(
_tcx: TyCtxtAt<'tcx>,
machine: &Self,
alloc_id: AllocId,
alloc: ConstAllocation<'tcx>,
_static_def_id: Option<DefId>,
is_write: bool,
) -> InterpResult<'tcx>
fn before_access_global( _tcx: TyCtxtAt<'tcx>, machine: &Self, alloc_id: AllocId, alloc: ConstAllocation<'tcx>, _static_def_id: Option<DefId>, is_write: bool, ) -> InterpResult<'tcx>
def_id
is Some
if this is the “lazy” allocation of a static.source§fn retag_ptr_value(
ecx: &mut InterpCx<'tcx, Self>,
_kind: RetagKind,
val: &ImmTy<'tcx, CtfeProvenance>,
) -> InterpResult<'tcx, ImmTy<'tcx, CtfeProvenance>>
fn retag_ptr_value( ecx: &mut InterpCx<'tcx, Self>, _kind: RetagKind, val: &ImmTy<'tcx, CtfeProvenance>, ) -> InterpResult<'tcx, ImmTy<'tcx, CtfeProvenance>>
source§fn before_memory_write(
_tcx: TyCtxtAt<'tcx>,
_machine: &mut Self,
_alloc_extra: &mut Self::AllocExtra,
(_alloc_id, immutable): (AllocId, bool),
range: AllocRange,
) -> InterpResult<'tcx>
fn before_memory_write( _tcx: TyCtxtAt<'tcx>, _machine: &mut Self, _alloc_extra: &mut Self::AllocExtra, (_alloc_id, immutable): (AllocId, bool), range: AllocRange, ) -> InterpResult<'tcx>
source§fn before_alloc_read(
ecx: &InterpCx<'tcx, Self>,
alloc_id: AllocId,
) -> InterpResult<'tcx>
fn before_alloc_read( ecx: &InterpCx<'tcx, Self>, alloc_id: AllocId, ) -> InterpResult<'tcx>
source§const ALL_CONSTS_ARE_PRECHECKED: bool = true
const ALL_CONSTS_ARE_PRECHECKED: bool = true
eval_mir_constant
can never fail because all required consts have
already been checked before.source§fn alignment_check(
_ecx: &InterpCx<'tcx, Self>,
_alloc_id: AllocId,
_alloc_align: Align,
_alloc_kind: AllocKind,
_offset: Size,
_align: Align,
) -> Option<Misalignment>
fn alignment_check( _ecx: &InterpCx<'tcx, Self>, _alloc_id: AllocId, _alloc_align: Align, _alloc_kind: AllocKind, _offset: Size, _align: Align, ) -> Option<Misalignment>
source§fn enforce_validity_recursively(
_ecx: &InterpCx<'tcx, Self>,
_layout: TyAndLayout<'tcx>,
) -> bool
fn enforce_validity_recursively( _ecx: &InterpCx<'tcx, Self>, _layout: TyAndLayout<'tcx>, ) -> bool
source§fn generate_nan<F1: Float + FloatConvert<F2>, F2: Float>(
_ecx: &InterpCx<'tcx, Self>,
_inputs: &[F1],
) -> F2
fn generate_nan<F1: Float + FloatConvert<F2>, F2: Float>( _ecx: &InterpCx<'tcx, Self>, _inputs: &[F1], ) -> F2
source§fn before_terminator(_ecx: &mut InterpCx<'tcx, Self>) -> InterpResult<'tcx>
fn before_terminator(_ecx: &mut InterpCx<'tcx, Self>) -> InterpResult<'tcx>
source§fn thread_local_static_pointer(
_ecx: &mut InterpCx<'tcx, Self>,
def_id: DefId,
) -> InterpResult<'tcx, Pointer<Self::Provenance>>
fn thread_local_static_pointer( _ecx: &mut InterpCx<'tcx, Self>, def_id: DefId, ) -> InterpResult<'tcx, Pointer<Self::Provenance>>
AllocId
for the given thread-local static in the current thread.source§fn eval_inline_asm(
_ecx: &mut InterpCx<'tcx, Self>,
_template: &'tcx [InlineAsmTemplatePiece],
_operands: &[InlineAsmOperand<'tcx>],
_options: InlineAsmOptions,
_targets: &[BasicBlock],
) -> InterpResult<'tcx>
fn eval_inline_asm( _ecx: &mut InterpCx<'tcx, Self>, _template: &'tcx [InlineAsmTemplatePiece], _operands: &[InlineAsmOperand<'tcx>], _options: InlineAsmOptions, _targets: &[BasicBlock], ) -> InterpResult<'tcx>
source§fn before_memory_read(
_tcx: TyCtxtAt<'tcx>,
_machine: &Self,
_alloc_extra: &Self::AllocExtra,
_prov: (AllocId, Self::ProvenanceExtra),
_range: AllocRange,
) -> InterpResult<'tcx>
fn before_memory_read( _tcx: TyCtxtAt<'tcx>, _machine: &Self, _alloc_extra: &Self::AllocExtra, _prov: (AllocId, Self::ProvenanceExtra), _range: AllocRange, ) -> InterpResult<'tcx>
source§fn before_memory_deallocation(
_tcx: TyCtxtAt<'tcx>,
_machine: &mut Self,
_alloc_extra: &mut Self::AllocExtra,
_prov: (AllocId, Self::ProvenanceExtra),
_size: Size,
_align: Align,
_kind: MemoryKind<Self::MemoryKind>,
) -> InterpResult<'tcx>
fn before_memory_deallocation( _tcx: TyCtxtAt<'tcx>, _machine: &mut Self, _alloc_extra: &mut Self::AllocExtra, _prov: (AllocId, Self::ProvenanceExtra), _size: Size, _align: Align, _kind: MemoryKind<Self::MemoryKind>, ) -> InterpResult<'tcx>
source§fn retag_place_contents(
_ecx: &mut InterpCx<'tcx, Self>,
_kind: RetagKind,
_place: &PlaceTy<'tcx, Self::Provenance>,
) -> InterpResult<'tcx>
fn retag_place_contents( _ecx: &mut InterpCx<'tcx, Self>, _kind: RetagKind, _place: &PlaceTy<'tcx, Self::Provenance>, ) -> InterpResult<'tcx>
source§fn protect_in_place_function_argument(
ecx: &mut InterpCx<'tcx, Self>,
mplace: &MPlaceTy<'tcx, Self::Provenance>,
) -> InterpResult<'tcx>
fn protect_in_place_function_argument( ecx: &mut InterpCx<'tcx, Self>, mplace: &MPlaceTy<'tcx, Self::Provenance>, ) -> InterpResult<'tcx>
source§fn after_stack_push(_ecx: &mut InterpCx<'tcx, Self>) -> InterpResult<'tcx>
fn after_stack_push(_ecx: &mut InterpCx<'tcx, Self>) -> InterpResult<'tcx>
source§fn before_stack_pop(
_ecx: &InterpCx<'tcx, Self>,
_frame: &Frame<'tcx, Self::Provenance, Self::FrameExtra>,
) -> InterpResult<'tcx>
fn before_stack_pop( _ecx: &InterpCx<'tcx, Self>, _frame: &Frame<'tcx, Self::Provenance, Self::FrameExtra>, ) -> InterpResult<'tcx>
source§fn after_stack_pop(
_ecx: &mut InterpCx<'tcx, Self>,
_frame: Frame<'tcx, Self::Provenance, Self::FrameExtra>,
unwinding: bool,
) -> InterpResult<'tcx, ReturnAction>
fn after_stack_pop( _ecx: &mut InterpCx<'tcx, Self>, _frame: Frame<'tcx, Self::Provenance, Self::FrameExtra>, unwinding: bool, ) -> InterpResult<'tcx, ReturnAction>
locals
have already been destroyed!source§fn after_local_allocated(
_ecx: &mut InterpCx<'tcx, Self>,
_local: Local,
_mplace: &MPlaceTy<'tcx, Self::Provenance>,
) -> InterpResult<'tcx>
fn after_local_allocated( _ecx: &mut InterpCx<'tcx, Self>, _local: Local, _mplace: &MPlaceTy<'tcx, Self::Provenance>, ) -> InterpResult<'tcx>
source§fn eval_mir_constant<F>(
ecx: &InterpCx<'tcx, Self>,
val: Const<'tcx>,
span: Span,
layout: Option<TyAndLayout<'tcx>>,
eval: F,
) -> InterpResult<'tcx, OpTy<'tcx, Self::Provenance>>where
F: Fn(&InterpCx<'tcx, Self>, Const<'tcx>, Span, Option<TyAndLayout<'tcx>>) -> InterpResult<'tcx, OpTy<'tcx, Self::Provenance>>,
fn eval_mir_constant<F>(
ecx: &InterpCx<'tcx, Self>,
val: Const<'tcx>,
span: Span,
layout: Option<TyAndLayout<'tcx>>,
eval: F,
) -> InterpResult<'tcx, OpTy<'tcx, Self::Provenance>>where
F: Fn(&InterpCx<'tcx, Self>, Const<'tcx>, Span, Option<TyAndLayout<'tcx>>) -> InterpResult<'tcx, OpTy<'tcx, Self::Provenance>>,
eval
function will do all the required evaluation,
but this hook has the chance to do some pre/postprocessing.Auto Trait Implementations§
impl<'tcx> !DynSend for CompileTimeMachine<'tcx>
impl<'tcx> !DynSync for CompileTimeMachine<'tcx>
impl<'tcx> Freeze for CompileTimeMachine<'tcx>
impl<'tcx> !RefUnwindSafe for CompileTimeMachine<'tcx>
impl<'tcx> !Send for CompileTimeMachine<'tcx>
impl<'tcx> !Sync for CompileTimeMachine<'tcx>
impl<'tcx> Unpin for CompileTimeMachine<'tcx>
impl<'tcx> !UnwindSafe for CompileTimeMachine<'tcx>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T, R> CollectAndApply<T, R> for T
impl<T, R> CollectAndApply<T, R> for T
source§impl<T> Filterable for T
impl<T> Filterable for T
source§fn filterable(
self,
filter_name: &'static str,
) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>
fn filterable( self, filter_name: &'static str, ) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>
source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
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 moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
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 moresource§impl<P> IntoQueryParam<P> for P
impl<P> IntoQueryParam<P> for P
fn into_query_param(self) -> P
source§impl<T> MaybeResult<T> for T
impl<T> MaybeResult<T> for T
source§impl<T> Pointable for T
impl<T> Pointable for T
source§impl<I, T, U> Upcast<I, U> for Twhere
U: UpcastFrom<I, T>,
impl<I, T, U> Upcast<I, U> for Twhere
U: UpcastFrom<I, T>,
source§impl<I, T> UpcastFrom<I, T> for T
impl<I, T> UpcastFrom<I, T> for T
fn upcast_from(from: T, _tcx: I) -> T
source§impl<Tcx, T> Value<Tcx> for Twhere
Tcx: DepContext,
impl<Tcx, T> Value<Tcx> for Twhere
Tcx: DepContext,
default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed, ) -> T
source§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
source§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
source§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
impl<'a, T> Captures<'a> for Twhere
T: ?Sized,
impl<T> ErasedDestructor for Twhere
T: 'static,
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: 56 bytes