Struct Module

pub struct Module { /* private fields */ }

The abstract syntax tree for a single Miden Assembly module.

All module kinds share this AST representation, as they are largely identical. However, the ModuleKind dictates how the parsed module is semantically analyzed and validated.

Implementations

impl Module

Constants

pub const FILE_EXTENSION: &'static str = "masm"

File extension for a Assembly Module.

pub const ROOT: &'static str = "mod"

Name of the root module.

pub const ROOT_FILENAME: &'static str = "mod.masm"

File name of the root module.

impl Module

Construction

pub fn new(kind: ModuleKind, path: LibraryPath) -> Module

Creates a new Module with the specified kind and fully-qualified path, e.g. std::math::u64.

pub fn new_kernel() -> Module

An alias for creating the default, but empty, #kernel Module.

pub fn new_executable() -> Module

An alias for creating the default, but empty, #exec Module.

pub fn with_span(self, span: SourceSpan) -> Module

Specifies the source span in the source file in which this module was defined, that covers the full definition of this module.

pub fn set_path(&mut self, path: LibraryPath)

Sets the LibraryPath for this module

pub fn set_namespace(&mut self, ns: LibraryNamespace)

Sets the LibraryNamespace for this module

pub fn set_docs(&mut self, docs: Option<Span<String>>)

Sets the documentation for this module

pub fn set_span(&mut self, span: SourceSpan)

Like Module::with_span, but does not require ownership of the Module.

pub fn define_procedure( &mut self, export: Export, ) -> Result<(), SemanticAnalysisError>

Defines a procedure, raising an error if the procedure is invalid, or conflicts with a previous definition

pub fn define_import( &mut self, import: Import, ) -> Result<(), SemanticAnalysisError>

Defines an import, raising an error if the import is invalid, or conflicts with a previous definition.

impl Module

Parsing

pub fn parse( name: LibraryPath, kind: ModuleKind, source_file: Arc<SourceFile>, ) -> Result<Box<Module>, Report>

Parse a Module, name, of the given ModuleKind, from source_file.

pub fn parser(kind: ModuleKind) -> ModuleParser

Get a ModuleParser for parsing modules of the provided ModuleKind

impl Module

Metadata

pub fn name(&self) -> &str

Get the name of this specific module, i.e. the last component of the LibraryPath that represents the fully-qualified name of the module, e.g. u64 in std::math::u64

pub fn path(&self) -> &LibraryPath

Get the fully-qualified name of this module, e.g. std::math::u64

pub fn namespace(&self) -> &LibraryNamespace

Get the namespace of this module, e.g. std in std::math::u64

pub fn is_in_namespace(&self, namespace: &LibraryNamespace) -> bool

Returns true if this module belongs to the provided namespace.

pub fn docs(&self) -> Option<Span<&str>>

Get the module documentation for this module, if it was present in the source code the module was parsed from

pub fn kind(&self) -> ModuleKind

Get the type of module this represents:

See ModuleKind for details on the different types of modules.

pub fn is_executable(&self) -> bool

Returns true if this module is an executable module.

pub fn is_kernel(&self) -> bool

Returns true if this module is a kernel module.

pub fn has_entrypoint(&self) -> bool

Returns true if this module has an entrypoint procedure defined, i.e. a begin..end block.

pub fn procedures(&self) -> Iter<'_, Export>

Get an iterator over the procedures defined in this module.

The entity returned is an Export, which abstracts over locally-defined procedures and re-exported procedures from imported modules.

pub fn procedures_mut(&mut self) -> IterMut<'_, Export>

Same as Module::procedures, but returns mutable references.

pub fn exported_procedures( &self, ) -> impl Iterator<Item = (ProcedureIndex, QualifiedProcedureName)>

Returns procedures exported from this module.

Each exported procedure is represented by its local procedure index and a fully qualified name.

pub fn imports(&self) -> Iter<'_, Import>

Get an iterator over the imports declared in this module.

See Import for details on what information is available for imports.

pub fn imports_mut(&mut self) -> IterMut<'_, Import>

Same as Self::imports, but returns mutable references to each import.

pub fn dependencies(&self) -> impl Iterator<Item = &LibraryNamespace>

Get an iterator over the “dependencies” of a module, i.e. what library namespaces we expect to find imported procedures in.

For example, if we have imported std::math::u64, then we would expect to find a library on disk named std.masl, although that isn’t a strict requirement. This notion of dependencies may go away with future packaging-related changed.

pub fn get(&self, index: ProcedureIndex) -> Option<&Export>

Get the procedure at index in this module’s procedure table.

The procedure returned may be either a locally-defined procedure, or a re-exported procedure. See Export for details.

pub fn index_of<F>(&self, predicate: F) -> Option<ProcedureIndex>

where F: FnMut(&Export) -> bool,

Get the ProcedureIndex for the first procedure in this module’s procedure table which returns true for predicate.

pub fn index_of_name(&self, name: &ProcedureName) -> Option<ProcedureIndex>

Get the ProcedureIndex for the procedure whose name is name in this module’s procedure table, if that procedure is exported.

Non-exported procedures can be retrieved by using Module::index_of.

pub fn resolve(&self, name: &ProcedureName) -> Option<ResolvedProcedure>

Resolves name to a procedure within the local scope of this module

pub fn resolver(&self) -> LocalNameResolver

Construct a search structure that can resolve procedure names local to this module

pub fn resolve_import(&self, module_name: &Ident) -> Option<&Import>

Resolves module_name to an Import within the context of this module

pub fn resolve_import_mut(&mut self, module_name: &Ident) -> Option<&mut Import>

Same as Module::resolve_import, but returns a mutable reference to the Import

pub fn import_paths(&self) -> impl Iterator<Item = &LibraryPath>

Return an iterator over the paths of all imports in this module

Trait Implementations

impl Clone for Module

fn clone(&self) -> Module

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Compile for &Module

fn compile_with_options( self, source_manager: &dyn SourceManager, options: Options, ) -> Result<Box<Module>, Report>

Compile (or convert) self into a Module using the provided options.

fn compile( self, source_manager: &dyn SourceManager, ) -> Result<Box<Module>, Report>

Compile (or convert) self into an executable Module.

impl Compile for Module

fn compile_with_options( self, source_manager: &dyn SourceManager, options: Options, ) -> Result<Box<Module>, Report>

Compile (or convert) self into a Module using the provided options.

fn compile( self, source_manager: &dyn SourceManager, ) -> Result<Box<Module>, Report>

Compile (or convert) self into an executable Module.

impl Debug for Module

Debug representation of this module

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

Formats the value using the given formatter.

impl Display for Module

Pretty-printed representation of this module as Miden Assembly text format

NOTE: Delegates to the crate::prettier::PrettyPrint implementation internally

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

Writes this Module as formatted MASM code into the formatter.

The formatted code puts each instruction on a separate line and preserves correct indentation for instruction blocks.

impl Emit for Module

fn name(&self) -> Option<Symbol>

The name of this item, if applicable

fn output_type(&self, _mode: OutputMode) -> OutputType

The output type associated with this item and the given mode

fn write_to<W>( &self, writer: W, mode: OutputMode, _session: &Session, ) -> Result<(), Error>

where W: Writer,

Write this item to the given std::io::Write handle, using mode to determine the output type

impl Index<ProcedureIndex> for Module

type Output = Export

The returned type after indexing.

fn index( &self, index: ProcedureIndex, ) -> &<Module as Index<ProcedureIndex>>::Output

Performs the indexing (container[index]) operation.

impl IndexMut<ProcedureIndex> for Module

fn index_mut( &mut self, index: ProcedureIndex, ) -> &mut <Module as Index<ProcedureIndex>>::Output

Performs the mutable indexing (container[index]) operation.

impl PartialEq for Module

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

The pretty-printer for Module

fn render(&self) -> Document

The core of the PrettyPrint functionality.

fn to_pretty_string(&self) -> String

Produce a String containing the results of pretty-printing this object.

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

Pretty-print this object to the given core::fmt::Formatter.

impl Spanned for Module

fn span(&self) -> SourceSpan

impl Eq for Module