Struct rustc_lint::LateContext

source ·
pub struct LateContext<'tcx> {
    pub tcx: TyCtxt<'tcx>,
    pub enclosing_body: Option<BodyId>,
    pub(crate) cached_typeck_results: Cell<Option<&'tcx TypeckResults<'tcx>>>,
    pub param_env: ParamEnv<'tcx>,
    pub effective_visibilities: &'tcx EffectiveVisibilities,
    pub last_node_with_lint_attrs: HirId,
    pub generics: Option<&'tcx Generics<'tcx>>,
    pub only_module: bool,
}
Expand description

Context for lint checking outside of type inference.

Fields§

§tcx: TyCtxt<'tcx>

Type context we’re checking in.

§enclosing_body: Option<BodyId>

Current body, or None if outside a body.

§cached_typeck_results: Cell<Option<&'tcx TypeckResults<'tcx>>>

Type-checking results for the current body. Access using the typeck_results and maybe_typeck_results methods, which handle querying the typeck results on demand.

§param_env: ParamEnv<'tcx>

Parameter environment for the item we are in.

§effective_visibilities: &'tcx EffectiveVisibilities

Items accessible from the crate being checked.

§last_node_with_lint_attrs: HirId§generics: Option<&'tcx Generics<'tcx>>

Generic type parameters in scope for the item we are in.

§only_module: bool

We are only looking at one module

Implementations§

source§

impl<'tcx> LateContext<'tcx>

source

pub fn maybe_typeck_results(&self) -> Option<&'tcx TypeckResults<'tcx>>

Gets the type-checking results for the current body, or None if outside a body.

source

pub fn typeck_results(&self) -> &'tcx TypeckResults<'tcx>

Gets the type-checking results for the current body. As this will ICE if called outside bodies, only call when working with Expr or Pat nodes (they are guaranteed to be found only in bodies).

source

pub fn qpath_res(&self, qpath: &QPath<'_>, id: HirId) -> Res

Returns the final resolution of a QPath, or Res::Err if unavailable. Unlike .typeck_results().qpath_res(qpath, id), this can be used even outside bodies (e.g. for paths in hir::Ty), without any risk of ICE-ing.

source

pub fn match_def_path(&self, def_id: DefId, path: &[Symbol]) -> bool

Check if a DefId’s path matches the given absolute type path usage.

Anonymous scopes such as extern imports are matched with kw::Empty; inherent impl blocks are matched with the name of the type.

Instead of using this method, it is often preferable to instead use rustc_diagnostic_item or a lang_item. This is less prone to errors as paths get invalidated if the target definition moves.

§Examples
if cx.match_def_path(def_id, &[sym::core, sym::option, sym::Option]) {
    // The given `def_id` is that of an `Option` type
}

Used by clippy, but should be replaced by diagnostic items eventually.

source

pub fn get_def_path(&self, def_id: DefId) -> Vec<Symbol>

Gets the absolute path of def_id as a vector of Symbol.

§Examples
let def_path = cx.get_def_path(def_id);
if let &[sym::core, sym::option, sym::Option] = &def_path[..] {
    // The given `def_id` is that of an `Option` type
}
source

pub fn get_associated_type( &self, self_ty: Ty<'tcx>, trait_id: DefId, name: &str ) -> Option<Ty<'tcx>>

Returns the associated type name for self_ty as an implementation of trait_id. Do not invoke without first verifying that the type implements the trait.

source

pub fn expr_or_init<'a>(&self, expr: &'a Expr<'tcx>) -> &'a Expr<'tcx>

If the given expression is a local binding, find the initializer expression. If that initializer expression is another local binding, find its initializer again.

This process repeats as long as possible (but usually no more than once). Type-check adjustments are not taken in account in this function.

Examples:

let abc = 1;
let def = abc + 2;
//        ^^^^^^^ output
let def = def;
dbg!(def);
//   ^^^ input
source

pub fn expr_or_init_with_outside_body<'a>( &self, expr: &'a Expr<'tcx> ) -> &'a Expr<'tcx>

If the given expression is a local binding, find the initializer expression. If that initializer expression is another local or outside (const/static) binding, find its initializer again.

This process repeats as long as possible (but usually no more than once). Type-check adjustments are not taken in account in this function.

Examples:

const ABC: i32 = 1;
//               ^ output
let def = ABC;
dbg!(def);
//   ^^^ input

// or...
let abc = 1;
let def = abc + 2;
//        ^^^^^^^ output
dbg!(def);
//   ^^^ input

Trait Implementations§

source§

impl<'tcx> HasDataLayout for LateContext<'tcx>

source§

impl<'tcx> HasParamEnv<'tcx> for LateContext<'tcx>

source§

fn param_env(&self) -> ParamEnv<'tcx>

source§

impl<'tcx> HasTyCtxt<'tcx> for LateContext<'tcx>

source§

fn tcx(&self) -> TyCtxt<'tcx>

source§

impl<'tcx> LayoutOfHelpers<'tcx> for LateContext<'tcx>

§

type LayoutOfResult = Result<TyAndLayout<'tcx, Ty<'tcx>>, LayoutError<'tcx>>

The TyAndLayout-wrapping type (or TyAndLayout itself), which will be returned from layout_of (see also handle_layout_err).
source§

fn handle_layout_err( &self, err: LayoutError<'tcx>, _: Span, _: Ty<'tcx> ) -> LayoutError<'tcx>

Helper used for layout_of, to adapt tcx.layout_of(...) into a Self::LayoutOfResult (which does not need to be a Result<...>). Read more
source§

fn layout_tcx_at_span(&self) -> Span

Span to use for tcx.at(span), from layout_of.
source§

impl<'tcx> LintContext for LateContext<'tcx>

source§

fn sess(&self) -> &Session

Gets the overall compiler Session object.

source§

fn opt_span_lint<S: Into<MultiSpan>>( &self, lint: &'static Lint, span: Option<S>, msg: impl Into<DiagMessage>, decorate: impl for<'a, 'b> FnOnce(&'b mut Diag<'a, ()>) )

Emit a lint at the appropriate level, with an optional associated span.
source§

fn get_lint_level(&self, lint: &'static Lint) -> Level

This returns the lint level for the given lint at the current location.
source§

fn span_lint_with_diagnostics( &self, lint: &'static Lint, span: Option<impl Into<MultiSpan>>, msg: impl Into<DiagMessage>, decorate: impl for<'a, 'b> FnOnce(&'b mut Diag<'a, ()>), diagnostic: BuiltinLintDiag )

Emit a lint at the appropriate level, with an optional associated span and an existing diagnostic.
source§

fn emit_span_lint<S: Into<MultiSpan>>( &self, lint: &'static Lint, span: S, decorator: impl for<'a> LintDiagnostic<'a, ()> )

Emit a lint at span from a lint struct (some type that implements LintDiagnostic, typically generated by #[derive(LintDiagnostic)]).
source§

fn span_lint<S: Into<MultiSpan>>( &self, lint: &'static Lint, span: S, msg: impl Into<DiagMessage>, decorate: impl for<'a, 'b> FnOnce(&'b mut Diag<'a, ()>) )

Emit a lint at the appropriate level, with an associated span.
source§

fn emit_lint( &self, lint: &'static Lint, decorator: impl for<'a> LintDiagnostic<'a, ()> )

Emit a lint from a lint struct (some type that implements LintDiagnostic, typically generated by #[derive(LintDiagnostic)]).
source§

fn lint( &self, lint: &'static Lint, msg: impl Into<DiagMessage>, decorate: impl for<'a, 'b> FnOnce(&'b mut Diag<'a, ()>) )

Emit a lint at the appropriate level, with no associated span.
source§

fn fulfill_expectation(&self, expectation: LintExpectationId)

This function can be used to manually fulfill an expectation. This can be used for lints which contain several spans, and should be suppressed, if either location was marked with an expectation. Read more

Auto Trait Implementations§

§

impl<'tcx> DynSend for LateContext<'tcx>

§

impl<'tcx> !DynSync for LateContext<'tcx>

§

impl<'tcx> !Freeze for LateContext<'tcx>

§

impl<'tcx> !RefUnwindSafe for LateContext<'tcx>

§

impl<'tcx> !Send for LateContext<'tcx>

§

impl<'tcx> !Sync for LateContext<'tcx>

§

impl<'tcx> Unpin for LateContext<'tcx>

§

impl<'tcx> !UnwindSafe for LateContext<'tcx>

Blanket Implementations§

source§

impl<T> Aligned for T

source§

const ALIGN: Alignment = _

Alignment of Self.
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
source§

impl<T, R> CollectAndApply<T, R> for T

source§

fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

Equivalent to f(&iter.collect::<Vec<_>>()).

§

type Output = R

source§

impl<T> Filterable for T

source§

fn filterable( self, filter_name: &'static str ) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>

Creates a filterable data provider with the given name for debugging. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> Instrument for T

source§

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

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

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<P> IntoQueryParam<P> for P

source§

impl<'tcx, C> LayoutOf<'tcx> for C
where C: LayoutOfHelpers<'tcx>,

source§

fn layout_of(&self, ty: Ty<'tcx>) -> Self::LayoutOfResult

Computes the layout of a type. Note that this implicitly executes in “reveal all” mode, and will normalize the input type.
source§

fn spanned_layout_of(&self, ty: Ty<'tcx>, span: Span) -> Self::LayoutOfResult

Computes the layout of a type, at span. Note that this implicitly executes in “reveal all” mode, and will normalize the input type.
source§

impl<T> MaybeResult<T> for T

§

type Error = !

source§

fn from(_: Result<T, <T as MaybeResult<T>>::Error>) -> T

source§

fn to_result(self) -> Result<T, <T as MaybeResult<T>>::Error>

source§

impl<T> Pointable for T

source§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> PointerArithmetic for T
where T: HasDataLayout,

source§

fn pointer_size(&self) -> Size

source§

fn max_size_of_val(&self) -> Size

source§

fn target_usize_max(&self) -> u64

source§

fn target_isize_min(&self) -> i64

source§

fn target_isize_max(&self) -> i64

source§

fn target_usize_to_isize(&self, val: u64) -> i64

source§

fn truncate_to_ptr(&self, _: (u64, bool)) -> (u64, bool)

Helper function: truncate given value-“overflowed flag” pair to pointer size and update “overflowed flag” if there was an overflow. This should be called by all the other methods before returning!
source§

fn overflowing_offset(&self, val: u64, i: u64) -> (u64, bool)

source§

fn overflowing_signed_offset(&self, val: u64, i: i64) -> (u64, bool)

source§

fn offset<'tcx>(&self, val: u64, i: u64) -> Result<u64, InterpErrorInfo<'tcx>>

source§

fn signed_offset<'tcx>( &self, val: u64, i: i64 ) -> Result<u64, InterpErrorInfo<'tcx>>

source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<'tcx, T> ToPredicate<'tcx, T> for T

source§

fn to_predicate(self, _tcx: TyCtxt<'tcx>) -> T

source§

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

§

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>,

§

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.
source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

source§

fn vzip(self) -> V

source§

impl<Tcx, T> Value<Tcx> for T
where Tcx: DepContext,

source§

default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed ) -> T

source§

impl<T> WithSubscriber for T

source§

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
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

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

impl<'a, T> Captures<'a> for T
where T: ?Sized,

source§

impl<T> ErasedDestructor for T
where 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: 64 bytes