Struct Module

pub struct Module {
    pub names: HashMap<String, Decl>,
    pub redirects: Vec<Ident>,
    pub shadowed: Option<Box<Decl>>,
}

Fields

names: HashMap<String, Decl>

Names declared in this module. This is the important thing.

redirects: Vec<Ident>

List of relative paths to include in search path when doing lookup in this module.

Assuming we want to lookup average, which is in std. The root module does not contain the average. So instead:

• look for average in root module and find nothing,
• follow redirects in root module,
• because of redirect std, so we look for average in std,
• there is average is std,
• result of the lookup is FQ ident std.average.

shadowed: Option<Box<Decl>>

A declaration that has been shadowed (overwritten) by this module.

Implementations

impl Module

pub fn singleton<S>(name: S, entry: Decl) -> Module

where S: ToString,

pub fn new_root() -> Module

pub fn new_database() -> Module

pub fn insert( &mut self, fq_ident: Ident, decl: Decl, ) -> Result<Option<Decl>, Error>

pub fn get_mut(&mut self, ident: &Ident) -> Option<&mut Decl>

pub fn get(&self, fq_ident: &Ident) -> Option<&Decl>

Get namespace entry using a fully qualified ident.

pub fn lookup(&self, ident: &Ident) -> HashSet<Ident>

pub fn shadow(&mut self, ident: &str)

pub fn unshadow(&mut self, ident: &str)

pub fn stack_push(&mut self, ident: &str, namespace: Module)

pub fn stack_pop(&mut self, ident: &str) -> Option<Module>

pub fn as_decls(&self) -> Vec<(Ident, &Decl)>

pub fn find_by_suffix(&self, suffix: &str) -> Vec<Ident>

Recursively finds all declarations that end in suffix.

pub fn find_by_annotation_name(&self, annotation_name: &Ident) -> Vec<Ident>

Recursively finds all declarations with an annotation that has a specific name.

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<(), Error>

Formats the value using the given formatter.

impl Default for Module

fn default() -> Module

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Module

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

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 Module