Struct ProcedureExport 

pub struct ProcedureExport {
    pub path: Arc<Path>,
    pub node: Option<MastNodeId>,
    pub source_node: Option<DebugSourceNodeId>,
    pub digest: Word,
    pub signature: Option<FunctionType>,
    pub attributes: AttributeSet,
}

A procedure exported by a package, along with its digest, signature, and attributes.

Fields

path: Arc<Path>

The fully-qualified path of the procedure exported by this package.

node: Option<MastNodeId>

The id of the MAST root node corresponding to this procedure

This is used for provenance, i.e. tracing which specific node in the package MAST this export corresponds to, when multiple exports may have the same digest (conversely, some procedure roots in the MAST may not be associated with any exports).

Provenance is important because multiple logically distinct procedures may compile to the same MAST digest while retaining distinct export identities. The MAST uses executable node fingerprints to collapse equivalent nodes in the forest. The only way to guarantee that you will get the precise MAST node that corresponds to the specific procedure you’ve named is to use the MAST node, rather than the digest.

NOTE: While one might get the impression that MastNodeId is a unique identifier for each procedure that gets assembled to the MAST, that isn’t actually true. If multiple nodes have the same executable fingerprint, they may be collapsed into a single node in the MAST and have the same MastNodeId.

If this field contains None, the digest is used to resolve a MAST node.

source_node: Option<DebugSourceNodeId>

Source/debug occurrence corresponding to this exported procedure, when package debug info is present.

This disambiguates exports that collapse to the same executable MastNodeId but retain distinct source/debug metadata in the package-owned source occurrence graph.

digest: Word

The digest of the procedure exported by this package.

signature: Option<FunctionType>

The type signature of the exported procedure.

attributes: AttributeSet

Attributes attached to the exported procedure.

Implementations

impl ProcedureExport

pub fn new( path: Arc<Path>, node: Option<MastNodeId>, digest: Word, signature: Option<FunctionType>, ) -> ProcedureExport

pub fn with_source_node( self, source_node: Option<DebugSourceNodeId>, ) -> ProcedureExport

impl ProcedureExport

pub fn read_from_safe<R>( source: &mut R, mast: &MastForest, ) -> Result<ProcedureExport, DeserializationError>

where R: ByteReader,

Trait Implementations

impl Clone for ProcedureExport

fn clone(&self) -> ProcedureExport

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProcedureExport

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

Formats the value using the given formatter.

impl Deserializable for ProcedureExport

fn read_from<R>(source: &mut R) -> Result<ProcedureExport, DeserializationError>

where R: ByteReader,

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

fn min_serialized_size() -> usize

Returns the minimum serialized size for one instance of this type.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

fn read_from_bytes_with_budget( bytes: &[u8], budget: usize, ) -> Result<Self, DeserializationError>

Deserializes Self from bytes with a byte budget limit.

impl<'de> Deserialize<'de> for ProcedureExport

fn deserialize<__D>( __deserializer: __D, ) -> Result<ProcedureExport, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ProcedureExport

impl PartialEq for ProcedureExport

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

Equality operator ==.

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

Inequality operator !=.

impl Serializable for ProcedureExport

fn write_into<W>(&self, target: &mut W)

where W: ByteWriter,

Serializes self into bytes and writes these bytes into the target.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

impl Serialize for ProcedureExport

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ProcedureExport