Enum ModuleRule 

#[non_exhaustive]
pub enum ModuleRule {
    MustNotImport {
        module: String,
    },
    RestrictImportsTo {
        allowed: Vec<String>,
    },
    MustNotBeImportedBy {
        importer: String,
    },
    MustOnlyBeImportedBy {
        allowed: Vec<String>,
    },
    ConfineExternalCrate {
        crate_name: String,
    },
    ConfineInlineSymbolPath {
        prefix: String,
        ending_with: Option<Vec<String>>,
        strict: bool,
    },
}

What a module boundary forbids.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

MustNotImport

The governed module must not import this module (or anything beneath it).

Fields

module: String

The forbidden module path (e.g. "crate::projection").

RestrictImportsTo

The governed module may import only these modules (each “or beneath”), plus its own subtree; any other internal import is a violation. An empty allowlist permits only the module’s own subtree.

Fields

allowed: Vec<String>

The closed allowlist of importable module paths (e.g. ["crate::types"]).

MustNotBeImportedBy

The governed (protected) module must not be imported by this module (or anything beneath it) — an inbound encapsulation rule, the mirror of MustNotImport. A module within the protected module’s own subtree is never an importer.

Fields

importer: String

The forbidden importer module path (e.g. "crate::http").

MustOnlyBeImportedBy

The governed (protected) module may be imported only by these importers (each “or beneath”) or by its own subtree; any other module that imports it (or anything beneath it) is a violation — the inbound dual of RestrictImportsTo. An empty allowlist permits only the protected module’s own subtree.

Fields

allowed: Vec<String>

The closed allowlist of importer module paths (e.g. ["crate::facade"]).

ConfineExternalCrate

An external crate may be imported only within the governed module’s own subtree (the permitted subtree, or beneath it); any use <crate_name>::… from a module outside that subtree is a violation. The first module rule that observes external imports — every other rule ignores them. The confined crate is the violation target, so identity stays injective across different confined crates on the same subtree.

Fields

crate_name: String

The confined external crate name (e.g. "libc").

ConfineInlineSymbolPath

Within the governed module’s subtree, forbid inline symbol-path calls resolving under a declared module-path prefix — the inline-symbol-path (layer b) sibling of ConfineExternalCrate, observing calls rather than use imports. The “core reads no ambient clock; time is injected” pattern. The confined prefix is the violation target, so identity stays injective across nested prefixes on the same subtree.

Fields

prefix: String

The confined module-path prefix (e.g. "std::time").

ending_with: Option<Vec<String>>

If Some, react only on calls whose terminal segment (leaf-exact) is one of these verbs (e.g. ["now"]); None reacts on every call under the prefix. Adopter-owned: a read reachable only through an undeclared verb is a false negative the adopter accepts by narrowing.

strict: bool

If true, react on any path under the prefix (mentions included — type annotations, constants, value captures), not only calls. Mutually exclusive with ending_with (both set is a constitution error).

Trait Implementations

impl Clone for ModuleRule

fn clone(&self) -> ModuleRule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModuleRule

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

Formats the value using the given formatter.

impl Eq for ModuleRule

impl PartialEq for ModuleRule

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ModuleRule