Struct LintStore 

pub struct LintStore {
    lints: Vec<&'static Lint>,
    pub(crate) pre_expansion_lint_passes: Vec<Box<dyn Fn() -> Box<dyn EarlyLintPass> + DynSend + DynSync>>,
    pub(crate) early_lint_passes: Vec<Box<dyn Fn() -> Box<dyn EarlyLintPass> + DynSend + DynSync>>,
    pub(crate) late_lint_passes: Vec<Box<dyn for<'tcx> Fn(TyCtxt<'tcx>) -> Box<dyn LateLintPass<'tcx> + 'tcx> + DynSend + DynSync>>,
    pub(crate) late_lint_mod_passes: Vec<Box<dyn for<'tcx> Fn(TyCtxt<'tcx>) -> Box<dyn LateLintPass<'tcx> + 'tcx> + DynSend + DynSync>>,
    by_name: UnordMap<String, TargetLint>,
    lint_groups: FxIndexMap<&'static str, LintGroup>,
}

Information about the registered lints.

Fields

lints: Vec<&'static Lint>

Registered lints.

pre_expansion_lint_passes: Vec<Box<dyn Fn() -> Box<dyn EarlyLintPass> + DynSend + DynSync>>

This lint pass kind is softly deprecated. It misses expanded code and has caused a few errors in the past. Currently, it is only used in Clippy. New implementations should avoid using this interface, as it might be removed in the future.

• See rust#69838
• See rust-clippy#5518

early_lint_passes: Vec<Box<dyn Fn() -> Box<dyn EarlyLintPass> + DynSend + DynSync>>

These lint passes run on AST nodes.

late_lint_passes: Vec<Box<dyn for<'tcx> Fn(TyCtxt<'tcx>) -> Box<dyn LateLintPass<'tcx> + 'tcx> + DynSend + DynSync>>

These lint passes run on HIR nodes. Each one processes an entire crate. They don’t benefit from incremental compilation. late_lint_mod_passes should be used in preference where possible; only use late_lint_passes for lints that implement check_crate and/or check_crate_post and accumulate cross-module state.

The exception is Clippy, which uses late_lint_passes for all late lint passes. It needs check_crate/check_crate_post for some of its lints and uses late lint passes throughout for consistency. This is ok because Clippy isn’t wired for incremental compilation.

late_lint_mod_passes: Vec<Box<dyn for<'tcx> Fn(TyCtxt<'tcx>) -> Box<dyn LateLintPass<'tcx> + 'tcx> + DynSend + DynSync>>

These lint passes run on HIR nodes, and are constructed per-module (i.e. multiple times). They benefit from incremental compilation.

by_name: UnordMap<String, TargetLint>

Lints indexed by name.

lint_groups: FxIndexMap<&'static str, LintGroup>

Map of registered lint groups to what lints they expand to.

Implementations

impl LintStore

pub fn new() -> LintStore

pub fn get_lints<'t>(&'t self) -> &'t [&'static Lint]

pub fn get_lint_groups( &self, ) -> impl Iterator<Item = (&'static str, Vec<LintId>, bool)>

pub fn get_all_group_names(&self) -> impl Iterator<Item = &'static str>

Returns all lint group names, including deprecated/aliased groups

pub fn register_pre_expansion_lint_pass( &mut self, pass: Box<dyn Fn() -> Box<dyn EarlyLintPass> + DynSend + DynSync>, )

See the comment on LintStore::pre_expansion_lint_passes.

pub fn register_early_lint_pass( &mut self, pass: Box<dyn Fn() -> Box<dyn EarlyLintPass> + DynSend + DynSync>, )

See the comment on LintStore::early_lint_passes.

pub fn register_late_lint_pass( &mut self, pass: Box<dyn for<'tcx> Fn(TyCtxt<'tcx>) -> Box<dyn LateLintPass<'tcx> + 'tcx> + DynSend + DynSync>, )

See the comment on LintStore::late_lint_passes.

pub fn register_late_lint_mod_pass( &mut self, pass: Box<dyn for<'tcx> Fn(TyCtxt<'tcx>) -> Box<dyn LateLintPass<'tcx> + 'tcx> + DynSend + DynSync>, )

See the comment on LintStore::late_lint_mod_passes.

pub fn register_lints(&mut self, lints: &[&'static Lint])

Helper method for register_early/late_pass

fn insert_group(&mut self, name: &'static str, group: LintGroup)

pub fn register_group_alias( &mut self, group_name: &'static str, alias: &'static str, )

pub fn register_group( &mut self, is_externally_loaded: bool, name: &'static str, deprecated_name: Option<&'static str>, to: Vec<LintId>, )

pub fn register_ignored(&mut self, name: &str)

This lint should give no warning and have no effect.

This is used by rustc to avoid warning about old rustdoc lints before rustdoc registers them as tool lints.

pub fn register_renamed(&mut self, old_name: &str, new_name: &str)

This lint has been renamed; warn about using the new name and apply the lint.

pub fn register_removed(&mut self, name: &str, reason: &str)

pub fn find_lints(&self, lint_name: &str) -> Option<&[LintId]>

pub fn is_lint_group(&self, lint_name: Symbol) -> bool

True if this symbol represents a lint group name.

pub fn check_lint_name( &self, lint_name: &str, tool_name: Option<Symbol>, registered_tools: &RegisteredTools, ) -> CheckLintNameResult<'_>

Checks the name of a lint for its existence, and whether it was renamed or removed. Generates a Diag containing a warning for renamed and removed lints. This is over both lint names from attributes and those passed on the command line. Since it emits non-fatal warnings and there are two lint passes that inspect attributes, this is only run from the late pass to avoid printing duplicate warnings.

fn no_lint_suggestion( &self, lint_name: &str, tool_name: &str, ) -> CheckLintNameResult<'_>

fn check_tool_name_for_backwards_compat( &self, lint_name: &str, tool_name: &str, ) -> CheckLintNameResult<'_>

Trait Implementations

impl DynLintStore for LintStore

fn lint_groups_iter(&self) -> Box<dyn Iterator<Item = LintGroup> + '_>

Provides a way to access lint groups without depending on rustc_lint

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