Struct Module 

pub struct Module {
    pub diagnostics: Vec<Recorded>,
    pub errors: usize,
    pub warnings: usize,
    pub lints: usize,
    pub deps: Vec<String>,
    pub requires: Vec<RequireJson>,
    pub code: Option<String>,
    pub check: Option<CheckInfoJson>,
}

What checking one module reported.

Fields

diagnostics: Vec<Recorded>

Its diagnostics, its contract lints included, in the order they were printed.

errors: usize

How many of diagnostics were errors, counted when the entry was written.

Stored rather than recounted on replay: the three are what a run adds up to decide its exit code, and a replay that recounted them would be deciding that from its own reading of the severity strings instead of from what the original run concluded.

warnings: usize

Warnings, as errors.

lints: usize

Lints, as errors.

deps: Vec<String>

What the checker resolved this module’s requires to. The next run keys on these, which is how a dependency’s edit invalidates its dependents.

requires: Vec<RequireJson>

Every require in the source and where it went, which deps is the resolved, deduplicated half of. Kept whole because the cycle lint reports a call site, and a path cannot say which line asked for it.

code: Option<String>

The Lua this module generates, for entries under gen_key. htl check never needs it and stores None; htl test stores it so a replay can go straight to running. Absent when checking produced errors, since there is nothing to run then.

check: Option<CheckInfoJson>

What checking reported, in the form the test runner needs it back.

htl check replays diagnostics straight into the sink and never reconstructs a CheckInfo; the test runner puts one into its report, so a replayed test file needs the structured form rather than the printed one. Only gen_key entries carry it.

Implementations

impl Module

pub fn requires_only(&self) -> CheckInfo

A CheckInfo carrying only what the project-level lints read.

require_cycles runs over every file in the walk, replayed ones included — a cycle that closes through a module nobody edited is still a cycle — so a replayed module has to produce something that lint can read. Its diagnostics are already printed by then, and nothing downstream looks at the other fields.

pub fn generated(c: &CheckInfo, code: String) -> Self

A gen entry as the linker and the test runner write it: no printed diagnostics (they print from the structured form), the generated Lua, and what the check said.

Trait Implementations

impl Clone for Module

fn clone(&self) -> Module

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Module

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Module

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Module

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.