Struct ModuleArtifact 

pub struct ModuleArtifact {
    pub module_ref: ModuleRef,
    pub host_requirements_ref: HostRequirementsRef,
    pub host_requirements: HostRequirements,
    pub exports: ModuleExports,
    pub canonical_ir: Program,
    pub dependencies: Vec<ModuleRef>,
}

Fields

module_ref: ModuleRef

host_requirements_ref: HostRequirementsRef

host_requirements: HostRequirements

exports: ModuleExports

canonical_ir: Program

dependencies: Vec<ModuleRef>

Implementations

impl ModuleArtifact

pub fn from_program(program: Program) -> Result<Self, ModuleArtifactError>

pub fn process_ref(&self, process_name: &str) -> Option<&ProcessRef>

pub fn process_name_for_ref(&self, process_ref: &ProcessRef) -> Option<&str>

pub fn canonical_source(&self) -> Result<String, CanonicalSourceError>

Pretty-print the saved canonical IR as Lashlang source.

The returned source is generated from canonical IR and host requirements. It preserves compile-equivalent structure, not comments or original formatting.

pub fn canonical_process_source( &self, process_ref: &ProcessRef, ) -> Result<Option<String>, CanonicalSourceError>

Pretty-print a focused process definition by process ref.

Returns Ok(None) when the ref is not exported by this module artifact. The fragment is the process declaration itself; use Self::canonical_source when the host needs a complete module snippet.

pub fn canonical_process_source_by_name( &self, process_name: &str, ) -> Result<Option<String>, CanonicalSourceError>

Pretty-print a focused process definition by exported process name.

Returns Ok(None) when the process is not declared by this artifact.

pub fn introspect( &self, ) -> Result<ModuleIntrospection, ModuleIntrospectionError>

pub fn verify(&self) -> Result<(), ModuleArtifactError>

pub fn to_store_bytes(&self) -> Result<Vec<u8>, ModuleArtifactError>

pub fn from_store_bytes(bytes: &[u8]) -> Result<Self, ModuleArtifactError>

Trait Implementations

impl Clone for ModuleArtifact

fn clone(&self) -> ModuleArtifact

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModuleArtifact

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ModuleArtifact

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ModuleArtifact

fn eq(&self, other: &ModuleArtifact) -> 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 Serialize for ModuleArtifact

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 ModuleArtifact