Struct Declarations 

pub struct Declarations {
    pub environments: EnvironmentDecls,
}

Every declaration a project makes, as authored — unresolved and unvalidated.

BTreeMap rather than HashMap so iteration order is deterministic: resolution reports errors in the order the user reads them, and the value ends up on a salsa input whose equality must not depend on hash order.

Fields

environments: EnvironmentDecls

The [environments.<name>] entries.

Implementations

impl Declarations

pub fn is_empty(&self) -> bool

Whether the project declares nothing at all — the overwhelmingly common case, and the one the parse must not pay anything for.

pub fn resolve(&self) -> Result<ResolvedDeclarations, DeclarationError>

Check every rule and project the declarations into a ResolvedDeclarations: an environment signature per like, and the delimiter spellings as opener and closer alias entries.

Internally a SignatureDb, because that is already the shape holding exactly these three maps: the declared tier folds into a document’s scope with the existing SignatureDb::merge_from, and the ParseCtx seed reads it the same way it already reads the per-file scan’s — no new plumbing, and [commands.*] slots in later without changing the signature of this function.

Every failure is an error, never a silent no-op. A declaration that quietly does nothing is the worst outcome available here: the user sees unchanged output and has no way to tell a typo from an unimplemented feature. Errors surface in key order (the map is a BTreeMap), so the message is stable across runs.

An entry that declares behavior alone is unrestricted — like = "lstlisting" is exactly how a project names a verbatim environment the definition scan cannot find. The extra restrictions below apply only to an entry that declares delimiter spellings, since those are the ones a command has to stand in for. An entry that declares nothing is the one shape rejected for saying too little rather than too much.

Trait Implementations

impl Clone for Declarations

fn clone(&self) -> Declarations

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Declarations

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

Formats the value using the given formatter.

impl Default for Declarations

fn default() -> Declarations

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Declarations

where Declarations: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Declarations

impl Hash for Declarations

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Declarations

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Declarations

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Declarations