Refactor: Access to externals moved from Root to Namespace

forc-pkg/src/pkg.rs

@@ -28,7 +28,7 @@ use std::{
     str::FromStr,
     sync::{atomic::AtomicBool, Arc},
 };
-use sway_core::namespace::Root;
+use sway_core::namespace::Package;
 pub use sway_core::Programs;
 use sway_core::{
     abi_generation::{
@@ -181,7 +181,7 @@ pub struct CompiledPackage {
     pub program_abi: ProgramABI,
     pub storage_slots: Vec<StorageSlot>,
     pub bytecode: BuiltPackageBytecode,
-    pub root_module: namespace::Root,
+    pub namespace: namespace::Package,
     pub warnings: Vec<CompileWarning>,
     pub metrics: PerformanceData,
 }
@@ -1583,28 +1583,28 @@ pub fn sway_build_config(
 /// This allows us to provide a contract's `CONTRACT_ID` constant to its own unit tests.
 #[allow(clippy::too_many_arguments)]
 pub fn dependency_namespace(
-    lib_namespace_map: &HashMap<NodeIx, namespace::Root>,
+    lib_namespace_map: &HashMap<NodeIx, namespace::Package>,
     compiled_contract_deps: &CompiledContractDeps,
     graph: &Graph,
     node: NodeIx,
     engines: &Engines,
     contract_id_value: Option<ContractIdConst>,
     program_id: ProgramId,
     experimental: ExperimentalFeatures,
-) -> Result<namespace::Root, vec1::Vec1<CompileError>> {
+) -> Result<namespace::Package, vec1::Vec1<CompileError>> {
     // TODO: Clean this up when config-time constants v1 are removed.
     let node_idx = &graph[node];
     let name = Ident::new_no_span(node_idx.name.clone());
-    let mut root_namespace = if let Some(contract_id_value) = contract_id_value {
-        namespace::namespace_with_contract_id(
+    let mut namespace = if let Some(contract_id_value) = contract_id_value {
+        namespace::package_with_contract_id(
             engines,
             name.clone(),
             program_id,
             contract_id_value,
             experimental,
         )?
     } else {
-        Root::new(name.clone(), None, program_id, false)
+        Package::new(name.clone(), None, program_id, false)
     };
 
     // Add direct dependencies.
@@ -1628,7 +1628,7 @@ pub fn dependency_namespace(
                 let contract_id_value = format!("0x{dep_contract_id}");
                 let node_idx = &graph[dep_node];
                 let name = Ident::new_no_span(node_idx.name.clone());
-                namespace::namespace_with_contract_id(
+                namespace::package_with_contract_id(
                     engines,
                     name.clone(),
                     program_id,
@@ -1637,10 +1637,10 @@ pub fn dependency_namespace(
                 )?
             }
         };
-        root_namespace.add_external(dep_name, dep_namespace);
+        namespace.add_external(dep_name, dep_namespace);
     }
 
-    Ok(root_namespace)
+    Ok(namespace)
 }
 
 /// Compiles the given package.
@@ -1665,7 +1665,7 @@ pub fn compile(
     pkg: &PackageDescriptor,
     profile: &BuildProfile,
     engines: &Engines,
-    namespace: namespace::Root,
+    namespace: namespace::Package,
     source_map: &mut SourceMap,
     experimental: ExperimentalFeatures,
 ) -> Result<CompiledPackage> {
@@ -1888,7 +1888,7 @@ pub fn compile(
         storage_slots,
         tree_type,
         bytecode,
-        root_module: typed_program.namespace.root_ref().clone(),
+        namespace: typed_program.namespace.current_package_ref().clone(),
         warnings,
         metrics,
     };
@@ -2515,7 +2515,7 @@ pub fn build(
         }
 
         if let TreeType::Library = compiled.tree_type {
-            lib_namespace_map.insert(node, compiled.root_module);
+            lib_namespace_map.insert(node, compiled.namespace);
         }
         source_map.insert_dependency(descriptor.manifest_file.dir());
 
@@ -2647,8 +2647,8 @@ pub fn check(
 
         if let Ok(typed_program) = programs.typed.as_ref() {
             if let TreeType::Library = typed_program.kind.tree_type() {
-                let mut lib_root = typed_program.namespace.root_ref().clone();
-                lib_root.current_package_root_module_mut().set_span(
+                let mut lib_namespace = typed_program.namespace.current_package_ref().clone();
+                lib_namespace.root_module_mut().set_span(
                     Span::new(
                         manifest.entry_string()?,
                         0,
@@ -2657,7 +2657,7 @@ pub fn check(
                     )
                     .unwrap(),
                 );
-                lib_namespace_map.insert(node, lib_root);
+                lib_namespace_map.insert(node, lib_namespace);
             }
             source_map.insert_dependency(manifest.dir());
         } else {

sway-core/src/ir_generation.rs

@@ -166,7 +166,7 @@ pub fn compile_program<'eng>(
             engines,
             &mut ctx,
             entry_function,
-            namespace.root_ref(),
+            namespace,
             &logged_types,
             &messages_types,
             &test_fns,
@@ -176,7 +176,7 @@ pub fn compile_program<'eng>(
             engines,
             &mut ctx,
             entry_function,
-            namespace.root_ref(),
+            namespace,
             &logged_types,
             &messages_types,
             &test_fns,
@@ -189,7 +189,7 @@ pub fn compile_program<'eng>(
             &mut ctx,
             entry_function.as_ref(),
             abi_entries,
-            namespace.root_ref(),
+            namespace,
             declarations,
             &logged_types,
             &messages_types,
@@ -200,7 +200,7 @@ pub fn compile_program<'eng>(
         ty::TyProgramKind::Library { .. } => compile::compile_library(
             engines,
             &mut ctx,
-            namespace.root_ref(),
+            namespace,
             &logged_types,
             &messages_types,
             &test_fns,

sway-core/src/ir_generation/compile.rs

@@ -27,7 +27,7 @@ pub(super) fn compile_script(
     engines: &Engines,
     context: &mut Context,
     entry_function: &DeclId<ty::TyFunctionDecl>,
-    namespace: &namespace::Root,
+    namespace: &namespace::Namespace,
     logged_types_map: &HashMap<TypeId, LogId>,
     messages_types_map: &HashMap<TypeId, MessageId>,
     test_fns: &[(Arc<ty::TyFunctionDecl>, DeclRefFunction)],
@@ -80,7 +80,7 @@ pub(super) fn compile_predicate(
     engines: &Engines,
     context: &mut Context,
     entry_function: &DeclId<ty::TyFunctionDecl>,
-    namespace: &namespace::Root,
+    namespace: &namespace::Namespace,
     logged_types: &HashMap<TypeId, LogId>,
     messages_types: &HashMap<TypeId, MessageId>,
     test_fns: &[(Arc<ty::TyFunctionDecl>, DeclRefFunction)],
@@ -133,7 +133,7 @@ pub(super) fn compile_contract(
     context: &mut Context,
     entry_function: Option<&DeclId<ty::TyFunctionDecl>>,
     abi_entries: &[DeclId<ty::TyFunctionDecl>],
-    namespace: &namespace::Root,
+    namespace: &namespace::Namespace,
     declarations: &[ty::TyDecl],
     logged_types_map: &HashMap<TypeId, LogId>,
     messages_types_map: &HashMap<TypeId, MessageId>,
@@ -226,7 +226,7 @@ pub(super) fn compile_contract(
 pub(super) fn compile_library(
     engines: &Engines,
     context: &mut Context,
-    namespace: &namespace::Root,
+    namespace: &namespace::Namespace,
     logged_types_map: &HashMap<TypeId, LogId>,
     messages_types_map: &HashMap<TypeId, MessageId>,
     test_fns: &[(Arc<ty::TyFunctionDecl>, DeclRefFunction)],
@@ -257,25 +257,29 @@ pub(crate) fn compile_constants_for_package(
     engines: &Engines,
     context: &mut Context,
     module: Module,
-    namespace: &namespace::Root,
+    namespace: &namespace::Namespace,
 ) -> Result<Module, Vec<CompileError>> {
-    let mut md_mgr = MetadataManager::default();
+    // Traverses the tree of externals and collects all constants
+    fn traverse(
+        engines: &Engines,
+        context: &mut Context,
+        module: Module,
+        current: &namespace::Package,
+    ) -> Result<Module, Vec<CompileError>> {
+        let mut md_mgr = MetadataManager::default();
+
+        // Collect constant for all dependencies
+        for ext_package in current.external_packages.values() {
+            traverse(engines, context, module, ext_package)?;
+        }
 
-    // Collect constant for all dependencies
-    for ext_package in namespace.external_packages().values() {
-        compile_constants_for_package(engines, context, module, ext_package)?;
-    }
+        compile_constants(engines, context, &mut md_mgr, module, current.root_module())
+            .map_err(|err| vec![err])?;
 
-    compile_constants(
-        engines,
-        context,
-        &mut md_mgr,
-        module,
-        namespace.current_package_root_module(),
-    )
-    .map_err(|err| vec![err])?;
+        Ok(module)
+    }
 
-    Ok(module)
+    traverse(engines, context, module, namespace.current_package_ref())
 }
 
 fn compile_constants(

sway-core/src/ir_generation/const_eval.rs

@@ -1706,7 +1706,7 @@ mod tests {
         let handler = Handler::default();
         let mut context = Context::new(engines.se(), ExperimentalFeatures::default());
         let mut md_mgr = MetadataManager::default();
-        let core_lib = namespace::Root::new(
+        let core_lib = namespace::Package::new(
             sway_types::Ident::new_no_span("assert_is_constant_test".to_string()),
             None,
             ProgramId::new(0),

sway-core/src/language/call_path.rs

@@ -417,7 +417,7 @@ impl CallPath {
             CallPathDisplayType::Regular => {}
             CallPathDisplayType::StripPackagePrefix => {
                 if let Some(first) = self.prefixes.first() {
-                    if namespace.root_ref().current_package_root_module().name() == first {
+                    if namespace.current_package_name() == first {
                         display_path = display_path.lshift();
                     }
                 }

sway-core/src/lib.rs

@@ -550,7 +550,7 @@ pub fn parsed_to_ast(
     handler: &Handler,
     engines: &Engines,
     parse_program: &mut parsed::ParseProgram,
-    initial_namespace: namespace::Root,
+    initial_namespace: namespace::Package,
     build_config: Option<&BuildConfig>,
     package_name: &str,
     retrigger_compilation: Option<Arc<AtomicBool>>,
@@ -586,7 +586,7 @@ pub fn parsed_to_ast(
         Namespace::new(handler, engines, initial_namespace, true).map_err(|error| {
             TypeCheckFailed {
                 root_module: None,
-                namespace: collection_ctx.namespace().root_ref().clone(),
+                namespace: collection_ctx.namespace().current_package_ref().clone(),
                 error,
             }
         })?;
@@ -607,7 +607,7 @@ pub fn parsed_to_ast(
     check_should_abort(handler, retrigger_compilation.clone()).map_err(|error| {
         TypeCheckFailed {
             root_module: Some(Arc::new(typed_program.root_module.clone())),
-            namespace: typed_program.namespace.root_ref().clone(),
+            namespace: typed_program.namespace.current_package_ref().clone(),
             error,
         }
     })?;
@@ -626,7 +626,7 @@ pub fn parsed_to_ast(
             handler.dedup();
             return Err(TypeCheckFailed {
                 root_module: Some(Arc::new(typed_program.root_module.clone())),
-                namespace: typed_program.namespace.root().clone(),
+                namespace: typed_program.namespace.current_package().clone(),
                 error,
             });
         }
@@ -645,7 +645,7 @@ pub fn parsed_to_ast(
                 handler.dedup();
                 return Err(TypeCheckFailed {
                     root_module: Some(Arc::new(typed_program.root_module.clone())),
-                    namespace: typed_program.namespace.root().clone(),
+                    namespace: typed_program.namespace.current_package().clone(),
                     error,
                 });
             }
@@ -676,7 +676,7 @@ pub fn parsed_to_ast(
         check_should_abort(handler, retrigger_compilation.clone()).map_err(|error| {
             TypeCheckFailed {
                 root_module: Some(Arc::new(typed_program.root_module.clone())),
-                namespace: typed_program.namespace.root_ref().clone(),
+                namespace: typed_program.namespace.current_package_ref().clone(),
                 error,
             }
         })?;
@@ -702,7 +702,7 @@ pub fn parsed_to_ast(
         engines,
         &mut ctx,
         module,
-        typed_program.namespace.root_ref(),
+        &typed_program.namespace,
     ) {
         errs.into_iter().for_each(|err| {
             handler.emit_err(err.clone());
@@ -730,7 +730,7 @@ pub fn parsed_to_ast(
             handler.dedup();
             TypeCheckFailed {
                 root_module: Some(Arc::new(typed_program.root_module.clone())),
-                namespace: typed_program.namespace.root_ref().clone(),
+                namespace: typed_program.namespace.current_package_ref().clone(),
                 error,
             }
         })?;
@@ -756,7 +756,7 @@ pub fn compile_to_ast(
     handler: &Handler,
     engines: &Engines,
     input: Arc<str>,
-    initial_namespace: namespace::Root,
+    initial_namespace: namespace::Package,
     build_config: Option<&BuildConfig>,
     package_name: &str,
     retrigger_compilation: Option<Arc<AtomicBool>>,
@@ -852,7 +852,7 @@ pub fn compile_to_asm(
     handler: &Handler,
     engines: &Engines,
     input: Arc<str>,
-    initial_namespace: namespace::Root,
+    initial_namespace: namespace::Package,
     build_config: &BuildConfig,
     package_name: &str,
     experimental: ExperimentalFeatures,
@@ -1019,7 +1019,7 @@ pub fn compile_to_bytecode(
     handler: &Handler,
     engines: &Engines,
     input: Arc<str>,
-    initial_namespace: namespace::Root,
+    initial_namespace: namespace::Package,
     build_config: &BuildConfig,
     source_map: &mut SourceMap,
     package_name: &str,

sway-core/src/semantic_analysis/ast_node/expression/typed_expression.rs

@@ -3291,7 +3291,7 @@ mod tests {
         experimental: ExperimentalFeatures,
     ) -> Result<ty::TyExpression, ErrorEmitted> {
         let root_module_name = sway_types::Ident::new_no_span("do_type_check_test".to_string());
-        let root_module = namespace::Root::new(root_module_name, None, ProgramId::new(0), false);
+        let root_module = namespace::Package::new(root_module_name, None, ProgramId::new(0), false);
         let collection_ctx_ns = Namespace::new(handler, engines, root_module.clone(), true)?;
         let mut collection_ctx = SymbolCollectionContext::new(collection_ctx_ns);
         let mut namespace = Namespace::new(handler, engines, root_module, true)?;