Struct sway_core::semantic_analysis::namespace::Module

pub struct Module {
    pub name: Option<Ident>,
    pub span: Option<Span>,
    pub is_external: bool,
    /* private fields */
}

A single Module within a Sway project.

A Module is most commonly associated with an individual file of Sway code, e.g. a top-level script/predicate/contract file or some library dependency whether introduced via mod or the [dependencies] table of a forc manifest.

A Module contains a set of all items that exist within the lexical scope via declaration or importing, along with a map of each of its submodules.

Fields

name: Option<Ident>

Name of the module, package name for root module, module name for other modules. Module name used is the same as declared in mod name;.

span: Option<Span>

Empty span at the beginning of the file implementing the module

is_external: bool

Indicates whether the module is external to the current package. External modules are imported in the Forc.toml file.

Implementations

impl Module

pub fn default_with_contract_id( engines: Engines<'_>, name: Option<Ident>, contract_id_value: String ) -> Result<Self, Vec1<CompileError>>

contract_id_value is injected here via forc-pkg when producing the dependency_namespace for a contract which has tests enabled. This allows us to provide a contract’s CONTRACT_ID constant to its own unit tests.

This will eventually be refactored out of sway-core in favor of creating temporary package dependencies for providing these CONTRACT_ID-containing modules: https://github.com/FuelLabs/sway/issues/3077

pub fn submodules(&self) -> &OrdMap<String, Module>

Immutable access to this module’s submodules.

pub fn insert_submodule(&mut self, name: String, submodule: Module)

Insert a submodule into this Module.

pub fn submodule(&self, path: &Path) -> Option<&Module>

Lookup the submodule at the given path.

pub fn submodule_mut(&mut self, path: &Path) -> Option<&mut Module>

Unique access to the submodule at the given path.

pub fn star_import_with_reexports( &mut self, src: &Path, dst: &Path, engines: Engines<'_> ) -> CompileResult<()>

Given a path to a src module, create synonyms to every symbol in that module to the given dst module.

This is used when an import path contains an asterisk.

Paths are assumed to be relative to self.

Methods from Deref<Target = Items>

pub fn symbols(&self) -> &OrdMap<Ident, TyDecl>

Immutable access to the inner symbol map.

pub fn apply_storage_load( &self, engines: Engines<'_>, fields: Vec<Ident>, storage_fields: &[TyStorageField] ) -> CompileResult<(TyStorageAccess, TypeId)>

pub fn set_storage_declaration( &mut self, decl_ref: DeclRefStorage ) -> CompileResult<()>

pub fn get_all_declared_symbols(&self) -> impl Iterator<Item = &Ident>

pub fn get_items_for_type( &self, engines: Engines<'_>, type_id: TypeId ) -> Vec<TyTraitItem>

pub fn get_methods_for_type( &self, engines: Engines<'_>, type_id: TypeId ) -> Vec<DeclRefFunction>

pub fn get_declared_storage( &self, decl_engine: &DeclEngine ) -> Option<TyStorageDecl>

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

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

Formats the value using the given formatter.

impl Default for Module

fn default() -> Module

Returns the “default value” for a type.

impl Deref for Module

type Target = Items

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Module

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl From<Module> for Root

fn from(module: Module) -> Self

Converts to this type from the input type.

impl From<Root> for Module

fn from(root: Root) -> Self

Converts to this type from the input type.

impl<'a> Index<&'a [BaseIdent]> for Module

type Output = Module

The returned type after indexing.

fn index(&self, path: &'a Path) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> IndexMut<&'a [BaseIdent]> for Module

fn index_mut(&mut self, path: &'a Path) -> &mut Self::Output

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