Struct Module 

pub struct Module {

    pub name: ModuleName,
    pub visibility: Visibility,
    pub behaviours: Vec<ModuleName>,
    pub exports: Vec<FunArity>,
    pub export_types: Vec<TypeArity>,
    pub callbacks: Vec<CallbackSig>,
    pub optional_callbacks: Vec<FunArity>,
    pub specs: Vec<SpecSig>,
    pub types: Vec<TypeDecl>,
    pub opaques: Vec<TypeArity>,
    pub deprecations: Vec<Deprecation>,
    pub clause_heads: BTreeMap<FunArity, Vec<Vec<ArgShape>>>,
    pub path: Option<RelativePath>,
    pub app: Option<ApplicationName>,
    pub records: Vec<RecordDecl>,
    pub test_only_exports: Vec<TestOnlyExport>,
    pub ifdef_macros: Vec<IfdefMacro>,
    pub variant_c_blocks: Vec<VariantCBlock>,
    pub versioned_machine_version: Option<VersionedMachineVersion>,
    pub wire_constants: Vec<WireConstantBinding>,
}

Fields

name: ModuleName

visibility: Visibility

behaviours: Vec<ModuleName>

exports: Vec<FunArity>

export_types: Vec<TypeArity>

callbacks: Vec<CallbackSig>

optional_callbacks: Vec<FunArity>

specs: Vec<SpecSig>

types: Vec<TypeDecl>

opaques: Vec<TypeArity>

deprecations: Vec<Deprecation>

clause_heads: BTreeMap<FunArity, Vec<Vec<ArgShape>>>

Per-export clause-head patterns: the disjunction of clauses that define this function. Used by the analyzer to flag calls whose argument shape doesn’t satisfy any clause head at the pin.

path: Option<RelativePath>

Source path relative to the project root. None on format version 1 snapshots; populated on v2.

app: Option<ApplicationName>

Application this module belongs to. None on v1 and for single-app projects.

records: Vec<RecordDecl>

Records declared inline in the .erl file. Distinct from HrlFile.records. v2 and later.

test_only_exports: Vec<TestOnlyExport>

Exports declared inside an -ifdef(TEST) block. Test-only exports drive cascade planning for the unconditional-exports refactor: they are not part of the public API at the tag but the planner needs them recorded for this branch.

ifdef_macros: Vec<IfdefMacro>

-define(...) macros inside -ifdef(TEST) body blocks (the macro itself is only visible under the guard). Needed by the Variant B unwrap planner: when the body block becomes unconditional, every macro it depends on must move out together with the function bodies.

variant_c_blocks: Vec<VariantCBlock>

-ifndef(TEST)/-else/-endif regions: a function with two bodies, a production one and a test one. Recorded for surfacing; no verdict rule fires on them.

versioned_machine_version: Option<VersionedMachineVersion>

Extracted body of the version function for modules that implement a versioned_machine_impl declared by the project family (e.g. rabbit_fifo:version/0). None when the module is not a declared versioned-machine impl or when the body did not resolve. Format version 4 and later.

wire_constants: Vec<WireConstantBinding>

Bound values of the wire-bearing macros declared by the project family for this module (e.g. RA_PROTO_VERSION on ra). Empty when the module declares no tracked wire constants. Format version 4 and later.

Implementations

impl Module

pub fn new(name: ModuleName) -> Self

pub fn exports_function(&self, function: &FunctionName, arity: Arity) -> bool

Whether the module exports function/arity. The export list is sorted in a canonical snapshot.

pub fn exports_type(&self, name: &TypeName, arity: Arity) -> bool

Whether the module lists name/arity in -export_type.

pub fn missing_clause_bodies(&self) -> Vec<FunArity>

Exports that have no matching clause head. An empty clause_heads (older snapshots without the field populated) returns an empty list so this never false-fires on legacy data.

Trait Implementations

impl Clone for Module

fn clone(&self) -> Self

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 Eq for Module

impl PartialEq for Module

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

Equality operator ==.

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

Inequality operator !=.

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.

impl StructuralPartialEq for Module