Struct nag_driver::Driver

pub struct Driver { /* private fields */ }

The entry point for a custom linter.

Use it like this:

fn main() -> ExitCode {
    Driver::new()
        .with_cfg("nag")
        .with_callbacks([
            lints::register,
            external_lints::register,
        ])
        .run()
}

Implementations

impl Driver

pub fn new() -> Self

Create a new Driver.

pub fn with_cfg(self, cfg: impl Into<String>) -> Self

Add --cfg={cfg} flag to the compiler invocation.

This allows for the following pattern:

#[cfg_attr(nag, allow(custom_lint))]
fn func() {
    // ...
}

pub fn with_callback<F>(self, callback: F) -> Selfwhere
    F: Fn(&Session, &mut LintStore) + Send + Sync + 'static,

Add a single callback for registering lints.

pub fn with_callbacks<F, I>(self, callbacks: I) -> Selfwhere
    F: Fn(&Session, &mut LintStore) + Send + Sync + 'static,
    I: IntoIterator<Item = F>,

Add multiple callbacks for registering lints.

pub fn run(self) -> ExitCode

Run the driver with args from the std::env::args. This is probably what you want.

pub fn run_with_args(self, args: impl IntoIterator<Item = String>) -> ExitCode

Run the driver with custom args.

Note: argv[0], i.e. the executable name (rustc), should be passed into this function.

Trait Implementations

impl Callbacks for Driver

This implementation will clear the callbacks list stored inside of Driver.

You probably should use Driver::run() or Driver::run_with_args() instead.

fn config(&mut self, config: &mut Config)

Called before creating the compiler instance

fn after_parsing<'tcx>(
    &mut self,
    _compiler: &Compiler,
    _queries: &'tcx Queries<'tcx>
) -> Compilation

Called after parsing. Return value instructs the compiler whether to continue the compilation afterwards (defaults to Compilation::Continue)

fn after_expansion<'tcx>(
    &mut self,
    _compiler: &Compiler,
    _queries: &'tcx Queries<'tcx>
) -> Compilation

Called after expansion. Return value instructs the compiler whether to continue the compilation afterwards (defaults to Compilation::Continue)

fn after_analysis<'tcx>(
    &mut self,
    _compiler: &Compiler,
    _queries: &'tcx Queries<'tcx>
) -> Compilation

Called after analysis. Return value instructs the compiler whether to continue the compilation afterwards (defaults to Compilation::Continue)

impl Default for Driver

fn default() -> Driver

Returns the “default value” for a type.