Struct rustc_monomorphize::collector::MirUsedCollector

struct MirUsedCollector<'a, 'tcx> {
    tcx: TyCtxt<'tcx>,
    body: &'a Body<'tcx>,
    output: &'a mut Vec<Spanned<MonoItem<'tcx>>>,
    instance: Instance<'tcx>,
    move_size_spans: Vec<Span>,
    visiting_call_terminator: bool,
    skip_move_check_fns: Option<Vec<DefId>>,
}

Fields

tcx: TyCtxt<'tcx>

body: &'a Body<'tcx>

output: &'a mut Vec<Spanned<MonoItem<'tcx>>>

instance: Instance<'tcx>

move_size_spans: Vec<Span>

Spans for move size lints already emitted. Helps avoid duplicate lints.

visiting_call_terminator: bool

skip_move_check_fns: Option<Vec<DefId>>

Set of functions for which it is OK to move large data into.

Implementations

impl<'a, 'tcx> MirUsedCollector<'a, 'tcx>

pub fn monomorphize<T>(&self, value: T) -> T

where T: TypeFoldable<TyCtxt<'tcx>>,

fn check_operand_move_size( &mut self, operand: &Operand<'tcx>, location: Location )

fn check_fn_args_move_size( &mut self, callee_ty: Ty<'tcx>, args: &[Spanned<Operand<'tcx>>], fn_span: Span, location: Location )

fn operand_size_if_too_large( &mut self, limit: Limit, operand: &Operand<'tcx> ) -> Option<Size>

fn lint_large_assignment( &mut self, limit: usize, too_large_size: Size, location: Location, span: Span )

Trait Implementations

impl<'a, 'tcx> Visitor<'tcx> for MirUsedCollector<'a, 'tcx>

fn visit_constant(&mut self, constant: &ConstOperand<'tcx>, location: Location)

This does not walk the MIR of the constant as that is not needed for codegen, all we need is to ensure that the constant evaluates successfully and walk the result.

fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location)

fn visit_terminator( &mut self, terminator: &Terminator<'tcx>, location: Location )

fn visit_operand(&mut self, operand: &Operand<'tcx>, location: Location)

fn visit_body(&mut self, body: &Body<'tcx>)

fn visit_basic_block_data( &mut self, block: BasicBlock, data: &BasicBlockData<'tcx> )

fn visit_source_scope_data(&mut self, scope_data: &SourceScopeData<'tcx>)

fn visit_statement(&mut self, statement: &Statement<'tcx>, location: Location)

fn visit_assign( &mut self, place: &Place<'tcx>, rvalue: &Rvalue<'tcx>, location: Location )

fn visit_assert_message( &mut self, msg: &AssertKind<Operand<'tcx>>, location: Location )

fn visit_ascribe_user_ty( &mut self, place: &Place<'tcx>, variance: Variance, user_ty: &UserTypeProjection, location: Location )

fn visit_coverage(&mut self, coverage: &Coverage, location: Location)

fn visit_retag( &mut self, kind: RetagKind, place: &Place<'tcx>, location: Location )

fn visit_place( &mut self, place: &Place<'tcx>, context: PlaceContext, location: Location )

fn visit_projection( &mut self, place_ref: PlaceRef<'tcx>, context: PlaceContext, location: Location )

fn visit_projection_elem( &mut self, place_ref: PlaceRef<'tcx>, elem: ProjectionElem<Local, Ty<'tcx>>, context: PlaceContext, location: Location )

fn super_place( &mut self, place: &Place<'tcx>, context: PlaceContext, location: Location )

fn super_projection( &mut self, place_ref: PlaceRef<'tcx>, context: PlaceContext, location: Location )

fn super_projection_elem( &mut self, _place_ref: PlaceRef<'tcx>, elem: ProjectionElem<Local, Ty<'tcx>>, _context: PlaceContext, location: Location )

fn visit_ty_const(&mut self, ct: Const<'tcx>, location: Location)

fn visit_span(&mut self, span: Span)

fn visit_source_info(&mut self, source_info: &SourceInfo)

fn visit_ty(&mut self, ty: Ty<'tcx>, _: TyContext)

fn visit_user_type_projection(&mut self, ty: &UserTypeProjection)

fn visit_user_type_annotation( &mut self, index: UserTypeAnnotationIndex, ty: &CanonicalUserTypeAnnotation<'tcx> )

fn visit_region(&mut self, region: Region<'tcx>, _: Location)

fn visit_args(&mut self, args: &&'tcx List<GenericArg<'tcx>>, _: Location)

fn visit_local_decl(&mut self, local: Local, local_decl: &LocalDecl<'tcx>)

fn visit_var_debug_info(&mut self, var_debug_info: &VarDebugInfo<'tcx>)

fn visit_local( &mut self, _local: Local, _context: PlaceContext, _location: Location )

fn visit_source_scope(&mut self, scope: SourceScope)

fn super_body(&mut self, body: &Body<'tcx>)

fn super_basic_block_data( &mut self, block: BasicBlock, data: &BasicBlockData<'tcx> )

fn super_source_scope_data(&mut self, scope_data: &SourceScopeData<'tcx>)

fn super_statement(&mut self, statement: &Statement<'tcx>, location: Location)

fn super_assign( &mut self, place: &Place<'tcx>, rvalue: &Rvalue<'tcx>, location: Location )

fn super_terminator( &mut self, terminator: &Terminator<'tcx>, location: Location )

fn super_assert_message( &mut self, msg: &AssertKind<Operand<'tcx>>, location: Location )

fn super_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location)

fn super_operand(&mut self, operand: &Operand<'tcx>, location: Location)

fn super_ascribe_user_ty( &mut self, place: &Place<'tcx>, variance: Variance, user_ty: &UserTypeProjection, location: Location )

fn super_coverage(&mut self, _coverage: &Coverage, _location: Location)

fn super_retag( &mut self, _kind: RetagKind, place: &Place<'tcx>, location: Location )

fn super_local_decl(&mut self, local: Local, local_decl: &LocalDecl<'tcx>)

fn super_var_debug_info(&mut self, var_debug_info: &VarDebugInfo<'tcx>)

fn super_source_scope(&mut self, _scope: SourceScope)

fn super_constant(&mut self, constant: &ConstOperand<'tcx>, location: Location)

fn super_ty_const(&mut self, _ct: Const<'tcx>, _location: Location)

fn super_span(&mut self, _span: Span)

fn super_source_info(&mut self, source_info: &SourceInfo)

fn super_user_type_projection(&mut self, _ty: &UserTypeProjection)

fn super_user_type_annotation( &mut self, _index: UserTypeAnnotationIndex, ty: &CanonicalUserTypeAnnotation<'tcx> )

fn super_ty(&mut self, _ty: Ty<'tcx>)

fn super_region(&mut self, _region: Region<'tcx>)

fn super_args(&mut self, _args: &&'tcx List<GenericArg<'tcx>>)

fn visit_location(&mut self, body: &Body<'tcx>, location: Location)

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