Struct Module 

pub struct Module {
    pub name: String,
    pub path: Vec<String>,
    pub decls: Vec<Decl>,
    pub imports: Vec<String>,
    pub exports: Vec<String>,
    pub import_specs: Vec<ImportSpec>,
    pub export_spec: Option<ExportSpec>,
    pub namespaces: Vec<NamespaceScope>,
    pub opens: Vec<OpenDirective>,
    pub visibility_map: HashMap<String, Visibility>,
    pub config: ModuleConfig,
}

A module containing declarations.

Fields

name: String

Module name

path: Vec<String>

Module path

decls: Vec<Decl>

Declarations in this module

imports: Vec<String>

Imported modules

exports: Vec<String>

Exported names

import_specs: Vec<ImportSpec>

Import specifications

export_spec: Option<ExportSpec>

Export specification

namespaces: Vec<NamespaceScope>

Namespace scopes

opens: Vec<OpenDirective>

Open directives

visibility_map: HashMap<String, Visibility>

Name visibility information

config: ModuleConfig

Module configuration

Implementations

impl Module

pub fn new(name: String) -> Self

Create a new module.

pub fn with_config(name: String, config: ModuleConfig) -> Self

Create a module with configuration.

pub fn add_decl(&mut self, decl: Decl)

Add a declaration to this module.

pub fn add_import(&mut self, module: String)

Add an import.

pub fn add_export(&mut self, name: String)

Add an export.

pub fn full_path(&self) -> String

Get the full path of this module.

pub fn resolve_name(&self, name: &str) -> ResolvedName

Resolve a name within this module.

Checks local declarations first, then imported modules via import specs, then namespace aliases.

pub fn visible_names(&self) -> Vec<String>

Get all visible names (declared + imported).

pub fn exported_names(&self) -> Vec<String>

Get names visible to importers of this module.

pub fn add_namespace(&mut self, ns: NamespaceScope)

Add a namespace scope.

pub fn with_import_spec(&mut self, spec: ImportSpec)

Apply an import specification.

pub fn set_visibility(&mut self, name: String, visibility: Visibility)

Set visibility for a name.

pub fn get_visibility(&self, name: &str) -> Visibility

Get visibility of a name.

pub fn add_open(&mut self, module: String, scoped: bool)

Add an open directive.

pub fn get_opens(&self) -> Vec<String>

Get all open modules.

pub fn resolve_with_opens(&self, name: &str) -> ResolvedName

Resolve a name considering all open modules and imports.

pub fn all_visible_names(&self) -> Vec<NameVisibility>

Get all visible names including from opens.

pub fn is_accessible(&self, name: &str, from_same_module: bool) -> bool

Check if a name is accessible with given visibility context.

pub fn get_dependencies(&self) -> HashSet<String>

Get all direct dependencies (imports and opens).

pub fn imports_module(&self, other: &str) -> bool

Check if this module directly imports another.

pub fn resolve_selective_import( &self, _module: &str, selected: &[String], ) -> Vec<String>

Resolve a selective import to actual names.

pub fn get_hidden_names(&self, module: &str) -> Vec<String>

Get all names hidden by a hiding import.

pub fn create_nested_namespace(&mut self, name: String, parent: NamespaceScope)

Create a nested namespace scope.

pub fn lookup_in_namespaces(&self, name: &str) -> Option<String>

Look up a name in namespace hierarchy.

pub fn namespace_names(&self, ns_name: &str) -> Vec<String>

Get all names in a specific namespace.

pub fn set_default_visibility(&mut self, visibility: Visibility)

Set default visibility for all names (for private_by_default config).

Trait Implementations

impl Clone for Module

fn clone(&self) -> Module

Returns a duplicate 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.