Struct HostSchemas 

pub struct HostSchemas { /* private fields */ }

The host modules one compilation may name: the ones the toolchain ships, plus any an embedder added.

The shipped tables answer for cove check on their own, and did so alone until this existed: a module SHIPPED did not name was Unknown to the checker and checked by the boundary and nothing else. An embedder is not a lesser kind of host, though — embedding is why HostApi is a trait — so a module it registers should be checked exactly as a shipped one is, and the only thing missing was a way to hand its table over. This is that way.

A custom module answers before a shipped one of the same name. An embedding that replaces documents with an implementation of its own registers a description of its own with it, and the description a run enforces is the one the checker has to read: a checker reading the shipped table there would be checking a module nothing is going to run.

A set built with HostSchemas::only answers for the modules it was given and no others. That is for an embedding that registers a registry of its own: a set that still fell back to SHIPPED would tell such a program that files.write is a checked call, when the run it is about to make has no files module to dispatch it to.

The tables are Copy and their contents are 'static, so this owns only the list. Looking one up hands back the entry itself rather than a borrow, which is what lets a caller hold a schema while it goes on reading whatever it asked.

Implementations

impl HostSchemas

pub fn new() -> HostSchemas

The shipped modules and nothing else, which is what every command that is not an embedding reads.

pub fn only(schemas: impl IntoIterator<Item = ModuleSchema>) -> HostSchemas

Exactly the modules in schemas, with no fallback to SHIPPED.

This is what an embedding hands over when its registry is its own rather than the shipped one plus additions. HostRegistry dispatches only what was registered with it, so a checker that still read the shipped tables would check files.write against a description of a module the run has not got and report nothing, leaving the boundary’s unknown host module to be the first mention of it — which is the one failure moving schemas to the checker is meant to prevent.

A shipped module the embedding does register is described here the same as any other: it is in schemas because the registry has it.

pub fn reads_shipped(&self) -> bool

Whether a name this set was not given is answered from SHIPPED.

pub fn with(self, schema: ModuleSchema) -> HostSchemas

Adds schema, taking the set by value so a pipeline can be configured in one expression.

pub fn insert(&mut self, schema: ModuleSchema)

Adds schema, replacing any module already added under that name.

Replacing rather than appending keeps one name to one description: two tables under one name would make every lookup depend on which was added first, which is the drift this crate exists to prevent.

pub fn module(&self, name: &str) -> Option<ModuleSchema>

The module name describes itself with, if this set has one.

A name that is not here is not an error: a host may register any module it likes, and a checker reading this says only that it cannot check what it was not shown.

pub fn custom(&self) -> &[ModuleSchema]

Only the modules an embedder added.

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

Every module name this set answers for, added ones first.

A custom module that takes a shipped module’s name is named once: it is one module, described by whichever table answers for it.

Trait Implementations

impl Clone for HostSchemas

fn clone(&self) -> HostSchemas

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HostSchemas

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

Formats the value using the given formatter.

impl Default for HostSchemas

fn default() -> HostSchemas

Returns the “default value” for a type.

impl Eq for HostSchemas

impl Extend<ModuleSchema> for HostSchemas

fn extend<I>(&mut self, schemas: I)

where I: IntoIterator<Item = ModuleSchema>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl FromIterator<ModuleSchema> for HostSchemas

fn from_iter<I>(schemas: I) -> HostSchemas

where I: IntoIterator<Item = ModuleSchema>,

Creates a value from an iterator.

impl PartialEq for HostSchemas

fn eq(&self, other: &HostSchemas) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for HostSchemas