Struct sway_core::semantic_analysis::namespace::Root

pub struct Root { /* private fields */ }

The root module, from which all other modules can be accessed.

This is equivalent to the “crate root” of a Rust crate.

We use a custom type for the Root in order to ensure that methods that only work with canonical paths, or that use canonical paths internally, are only called from the root. This normally includes methods that first lookup some canonical path via use_synonyms before using that canonical path to look up the symbol declaration.

Methods from Deref<Target = Module>

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
) -> 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, TyDeclaration>

Immutable access to the inner symbol map.

pub fn apply_storage_load(
    &self,
    fields: Vec<Ident>,
    storage_fields: &[TyStorageField],
    access_span: &Span
) -> CompileResult<(TyStorageAccess, TypeId)>

pub fn set_storage_declaration(
    &mut self,
    decl_id: DeclarationId
) -> CompileResult<()>

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

Trait Implementations

impl Clone for Root

fn clone(&self) -> Root

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Root

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

Formats the value using the given formatter.

impl Deref for Root

type Target = Module

The resulting type after dereferencing.

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

Dereferences the value.

impl DerefMut for Root

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<Namespace> for Root

fn from(namespace: Namespace) -> 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 PartialEq<Root> for Root

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Root