Struct Engine 

pub struct Engine { /* private fields */ }

Everything a run needs, built once and shared across workers.

Implementations

impl Engine

pub fn prepare( config: &Config, project_root: &Path, rules_root: RuleRoot, config_path: &Path, registry: &LanguageRegistry, typescript: Arc<dyn Language>, javascript: Arc<dyn Language>, ) -> Result<Self, RunError>

Prepare a run.

Everything that can fail on a rule’s own contents fails here, before any file is read — a run that dies halfway through because rule seventeen has a typo has already wasted the work.

Errors

Returns RunError for an invalid query, gate, or language reference.

pub const fn without_cache(self) -> Self

Turn the cache off, for --no-cache and for tests that need a cold run.

pub const fn profiling(self) -> Self

Collect per-rule timings.

Off by default because measuring costs a clock read per handler invocation, and the path a warm run takes is the one place that matters most.

pub const fn reporting_unused_suppressions(self) -> Self

Report suppressions that silenced nothing.

Off by default because it is hygiene rather than correctness: a suppression whose violation no longer exists is debt, and debt is worth surfacing on request rather than in everyone’s inner loop.

pub const fn with_today(self, today: Date) -> Self

Fix the date expires: is compared against.

For tests, which otherwise could not assert anything about expiry without waiting.

pub const fn without_reduce(self) -> Self

Skip every reduce phase.

For a run over a deliberately partial corpus. A cross-file rule consumes facts from every file, so running one over a subset does not give a smaller answer — it gives a wrong one. no-unused-exports over three changed files would report every export in them as unused, because the importers were never looked at.

Skipping is therefore the only sound option, and the caller that narrowed the corpus is the one that has to say so to the user.

pub fn discover(&self) -> Vec<FilePath>

The files discovery selects, before any gate.

For a caller narrowing the corpus: intersecting with this is what keeps include and exclude in force, so --staged cannot check a file the config excluded.

pub fn rule_count(&self) -> usize

How many rules will actually run. Rules set to off are dropped at preparation.

pub fn rules(&self) -> impl Iterator<Item = &RuleSpec>

The rules that will run, in the order the config declared them.

The specs rather than a rendered listing: what a listing should look like is the reporter’s problem, and an engine that decided it would have to be changed for every new output format.

pub fn run(&self) -> Result<Outcome, RunError>

Run over the whole corpus.

Errors

Returns the first RunError any worker produced. Rayon’s reduction is not order-dependent, so which of several simultaneous failures surfaces is arbitrary — but every one of them aborts the run, so the choice does not change the outcome.

pub fn run_over(&self, files: &[FilePath]) -> Result<Outcome, RunError>

Run over an explicit file list, for --since and --staged.

Errors

As Engine::run.

Trait Implementations

impl Debug for Engine

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.