Struct LintState 

struct LintState<'tcx> {
    tcx: TyCtxt<'tcx>,
    item: LocalDefId,
    annotation: Option<Span>,
    shown_item: bool,
    shown_lints: FxHashSet<DefId>,
}

Fields

tcx: TyCtxt<'tcx>

item: LocalDefId

The item we are currently linting.

annotation: Option<Span>

For diagnostics; used to point to the #[ferrocene::prevalidated] attribute.

shown_item: bool

For diagnostics; see lint_use.

shown_lints: FxHashSet<DefId>

For deduplication; see check_use.

Implementations

impl<'tcx> LintState<'tcx>

Diagnostics.

fn func_span(&self, def_id: DefId) -> Span

pub(super) fn lint_use(&mut self, lint_node: HirId, use_: Use<'tcx>)

fn decorate_cast(&self, use_: Use<'tcx>, diag: &mut Diag<'_, ()>)

fn decorate_instantiation( &self, use_: Use<'tcx>, diag: &mut Diag<'_, ()>, validated_span: Option<&mut MultiSpan>, )

impl<'tcx> LintState<'tcx>

pub(super) fn check_fn_ptr_coercion( &self, source: Ty<'tcx>, dst_trait: PolyTraitRef<'tcx>, try_instantiate: &mut impl FnMut(DefId, GenericArgsRef<'tcx>) -> InstantiateResult<'tcx>, span: Span, ) -> Option<UseKind<'tcx>>

pub(super) fn check_dyn_trait_coercion( &self, dest_ty: Ty<'tcx>, source_ty: Ty<'tcx>, typing_env: TypingEnv<'tcx>, try_instantiate: &mut impl FnMut(DefId, GenericArgsRef<'tcx>) -> InstantiateResult<'tcx>, span: Span, ) -> Option<UseKind<'tcx>>

Given a source expression that has an unsizing cast to dest, determine whether the cast is valid. If not, return a TraitObjectCast showing why not.

This works in four main parts:

1. “Peel” as many types as possible. For example, if we are casting Vec<Box<String>> to Vec<Box<dyn Display + Clone + Sync>, peel that to String and dyn Display + Clone + Sync. We call these coerce_src and coerce_dst.
2. Determine all traits in dest’s type that have at least one method. For example, dyn Display + Clone + Sync contains the traits Display and Clone.
3. For each trait, find coerce_src’s implementation of it. For example, impl Display for String.
4. For each method in the impl, check whether it’s validated. For example, we would check <String as Diplay>::fmt, see that it’s unvalidated, and return its DefId in the UseKind.

pub(super) fn instance_of_ty( &self, ty: Ty<'tcx>, fn_trait_ref: Option<PolyTraitRef<'tcx>>, try_instantiate: &mut impl FnMut(DefId, GenericArgsRef<'tcx>) -> InstantiateResult<'tcx>, span: Span, ) -> Option<Instance<'tcx>>

Given a call to a function-like type, return the instantiated function definition, or None if we can’t find it until it’s been monomorphized.

Panics if given a type that isn’t callable.

fn peel_unsized_tys( &self, src_ty: Ty<'tcx>, dst_ty: Ty<'tcx>, typing_env: TypingEnv<'tcx>, span: Span, ) -> Option<(Ty<'tcx>, Ty<'tcx>)>

Given an Unsize coersion from src_ty to dst_ty, return the innermost “difference” between the two. Returns None if this isn’t a cast to a trait object.

This is quite similar to struct_lockstep_tails_for_codegen, except it considers all ZSTs, not just those at the tail.

c.f. Zulip

See CoerceUnsized for a full list of types we need to handle here.

This is adapted from rustc_monomorphize::collector::find_tails_for_unsizing.

fn custom_coerce_unsize_info( &self, source_ty: Ty<'tcx>, target_ty: Ty<'tcx>, span: Span, ) -> Option<CustomCoerceUnsized>

fn find_unvalidated_impl_fn(&self, impl_block: DefId) -> Option<DefId>

Given an impl, find the first associated function that isn’t validated.

FIXME: list all unvalidated functions, not just the first.

fn find_trait_impl( &self, trait_ref: PolyTraitRef<'tcx>, typing_env: TypingEnv<'tcx>, span: Span, ) -> ImplSource<'tcx, Span>

fn try_find_trait_impl( &self, trait_ref: PolyTraitRef<'tcx>, typing_env: TypingEnv<'tcx>, span: Span, ) -> Option<ImplSource<'tcx, Span>>

Given a Trait<Ty> reference, find impl Trait for Ty.

This calls into the trait solver to select a suitable impl block.

c.f. hax::exporter::traits::resolution::shallow_resolve_trait_ref

Ideally, this would never return None, but sometimes our code is buggy … failures here only degrade the diagnostic, they don’t cause soundness issues.

fn dyn_trait_refs( &self, source_ty: Ty<'tcx>, dst_ty: Ty<'tcx>, ) -> Vec<Binder<'tcx, TraitRef<'tcx>>>

Given a Rust type, find (at any level of nesting) dyn Trait objects contained within it that have at least one method. For example, dyn Send + Sync + Display + Clone would return [Display, Clone].

impl<'tcx> LintState<'tcx>

fn new(tcx: TyCtxt<'tcx>, item: LocalDefId) -> Option<Self>

Check whether item needs to be linted at all. If so, return a new LintState.

fn check_use(&mut self, lint_node: HirId, use_: Use<'tcx>)

Check whether an item use needs to be linted. If so, lint it.

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