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 access_levels: &'tcx AccessLevels,
pub lint_store: &'tcx LintStore,
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.
access_levels: &'tcx AccessLevels
Items accessible from the crate being checked.
lint_store: &'tcx LintStore
The store of registered lints and the lint levels.
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
sourceimpl<'tcx> LateContext<'tcx>
impl<'tcx> LateContext<'tcx>
sourcepub fn maybe_typeck_results(&self) -> Option<&'tcx TypeckResults<'tcx>>
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.
sourcepub fn typeck_results(&self) -> &'tcx TypeckResults<'tcx>
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).
sourcepub fn qpath_res(&self, qpath: &QPath<'_>, id: HirId) -> Res
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.
sourcepub fn match_def_path(&self, def_id: DefId, path: &[Symbol]) -> bool
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.
Trait Implementations
sourceimpl<'tcx> HasDataLayout for LateContext<'tcx>
impl<'tcx> HasDataLayout for LateContext<'tcx>
fn data_layout(&self) -> &TargetDataLayout
sourceimpl<'tcx> HasParamEnv<'tcx> for LateContext<'tcx>
impl<'tcx> HasParamEnv<'tcx> for LateContext<'tcx>
sourceimpl<'tcx> LayoutOfHelpers<'tcx> for LateContext<'tcx>
impl<'tcx> LayoutOfHelpers<'tcx> for LateContext<'tcx>
type LayoutOfResult = Result<TyAndLayout<'tcx, Ty<'tcx>>, LayoutError<'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
). Read more
sourcefn handle_layout_err(
&self,
err: LayoutError<'tcx>,
_: Span,
_: Ty<'tcx>
) -> LayoutError<'tcx>
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
sourcefn layout_tcx_at_span(&self) -> Span
fn layout_tcx_at_span(&self) -> Span
Span
to use for tcx.at(span)
, from layout_of
.
sourceimpl LintContext for LateContext<'_>
impl LintContext for LateContext<'_>
type PassObject = Box<dyn LateLintPass<'tcx> + Sync + Send + 'static, Global>
fn lints(&self) -> &LintStore
fn lookup<S: Into<MultiSpan>>(
&self,
lint: &'static Lint,
span: Option<S>,
decorate: impl for<'a> FnOnce(LintDiagnosticBuilder<'a, ()>)
)
fn lookup_with_diagnostics(
&self,
lint: &'static Lint,
span: Option<impl Into<MultiSpan>>,
decorate: impl for<'a> FnOnce(LintDiagnosticBuilder<'a, ()>),
diagnostic: BuiltinLintDiagnostics
)
fn struct_span_lint<S: Into<MultiSpan>>(
&self,
lint: &'static Lint,
span: S,
decorate: impl for<'a> FnOnce(LintDiagnosticBuilder<'a, ()>)
)
Auto Trait Implementations
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
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<'tcx, C> LayoutOf<'tcx> for C where
C: LayoutOfHelpers<'tcx>,
impl<'tcx, C> LayoutOf<'tcx> for C where
C: LayoutOfHelpers<'tcx>,
sourcefn layout_of(&self, ty: Ty<'tcx>) -> Self::LayoutOfResult
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. Read more
sourcefn spanned_layout_of(&self, ty: Ty<'tcx>, span: Span) -> Self::LayoutOfResult
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. Read more
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: 72 bytes