Struct LintPostMono 

struct LintPostMono<'a, 'tcx> {
    instance: Instance<'tcx>,
    body: &'a Body<'tcx>,
    linter: &'a mut LintState<'tcx>,
    visited: &'a mut FxHashSet<Instance<'tcx>>,
    roots: &'a [MonoItem<'tcx>],
    from_instantiation: Option<InstantiationSite<'tcx>>,
}

Fields

instance: Instance<'tcx>

The function we are currently traversing.

body: &'a Body<'tcx>

Its body.

linter: &'a mut LintState<'tcx>

visited: &'a mut FxHashSet<Instance<'tcx>>

A list of all functions we have previously traversed. This needs to store Instances, not DefIds, because different instantiations may call different concrete functions, and we want to make sure we lint all of them.

roots: &'a [MonoItem<'tcx>]

A list of all items we are going to traverse. This is needed to avoid non-determinism in diagnostics; we don’t want from_instantiation to vary based on iteration order.

from_instantiation: Option<InstantiationSite<'tcx>>

May be None if this is a mono root.

Implementations

impl<'a, 'tcx> LintPostMono<'a, 'tcx>

fn find_dynamic_cast( &self, rval: &Rvalue<'tcx>, ) -> Option<(Span, UseKind<'tcx>)>

fn use_(&self, kind: UseKind<'tcx>, span: Span) -> Use<'tcx>

fn lint(&mut self, use_: Use<'tcx>, scope: SourceScope) -> HirId

fn on_edge( &mut self, use_: Use<'tcx>, scope: SourceScope, pre_mono_callee: DefId, )

fn visit_instance( linter: &'a mut LintState<'tcx>, visited: &mut FxHashSet<Instance<'tcx>>, roots: &'a [MonoItem<'tcx>], instance: Instance<'tcx>, from_instantiation: Option<InstantiationSite<'tcx>>, )

fn get_call_def_mir( &self, terminator: &Terminator<'tcx>, _loc: Location, ) -> Option<(Instance<'tcx>, DefId)>

fn monomorphize_instance( &self, def_id: DefId, generic_args: GenericArgsRef<'tcx>, span: Span, ) -> Instance<'tcx>

fn monomorphize_args<T>(&self, generic_args: T) -> (T, TypingEnv<'tcx>)

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

Trait Implementations

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

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

fn visit_rvalue(&mut self, rval: &Rvalue<'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_debuginfo( &mut self, stmt_debuginfo: &StmtDebugInfo<'tcx>, location: Location, )

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_operand(&mut self, operand: &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, kind: &CoverageKind, 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_const_operand( &mut self, constant: &ConstOperand<'tcx>, location: Location, )

This is called for every constant in the MIR body and every required_consts (i.e., including consts that have been dead-code-eliminated).

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<TyCtxt<'tcx>>, _: Location)

fn visit_args( &mut self, args: &&'tcx RawList<(), 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_debuginfo( &mut self, stmt_debuginfo: &StmtDebugInfo<'tcx>, location: Location, )

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, _kind: &CoverageKind, _location: Location)

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

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

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

fn super_source_scope(&mut self, _scope: SourceScope)

fn super_const_operand( &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<TyCtxt<'tcx>>)

fn super_args(&mut self, _args: &&'tcx RawList<(), 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: 136 bytes