Refactor: Imports must use absolute paths

forc-pkg/src/pkg.rs

@@ -1595,11 +1595,11 @@ pub fn dependency_namespace(
     engines: &Engines,
     contract_id_value: Option<ContractIdConst>,
     experimental: sway_core::ExperimentalFlags,
-) -> Result<namespace::Module, vec1::Vec1<CompileError>> {
+) -> Result<namespace::Root, vec1::Vec1<CompileError>> {
     // TODO: Clean this up when config-time constants v1 are removed.
     let node_idx = &graph[node];
     let name = Some(Ident::new_no_span(node_idx.name.clone()));
-    let mut namespace = if let Some(contract_id_value) = contract_id_value {
+    let mut root_module = if let Some(contract_id_value) = contract_id_value {
         namespace::Module::default_with_contract_id(
             engines,
             name.clone(),
@@ -1610,9 +1610,9 @@ pub fn dependency_namespace(
         namespace::Module::default()
     };
 
-    namespace.is_external = true;
-    namespace.name = name;
-    namespace.visibility = Visibility::Public;
+    root_module.is_external = true;
+    root_module.name = name;
+    root_module.visibility = Visibility::Public;
 
     // Add direct dependencies.
     let mut core_added = false;
@@ -1647,7 +1647,7 @@ pub fn dependency_namespace(
                 ns
             }
         };
-        namespace.insert_submodule(dep_name, dep_namespace);
+        root_module.insert_submodule(dep_name, dep_namespace);
         let dep = &graph[dep_node];
         if dep.name == CORE {
             core_added = true;
@@ -1658,29 +1658,29 @@ pub fn dependency_namespace(
     if !core_added {
         if let Some(core_node) = find_core_dep(graph, node) {
             let core_namespace = &lib_namespace_map[&core_node];
-            namespace.insert_submodule(CORE.to_string(), core_namespace.clone());
+            root_module.insert_submodule(CORE.to_string(), core_namespace.clone());
         }
     }
 
-    let _ = namespace.star_import_with_reexports(
+    let mut root = namespace::Root::from(root_module);
+
+    let _ = root.star_import_with_reexports(
         &Handler::default(),
         engines,
         &[CORE, PRELUDE].map(|s| Ident::new_no_span(s.into())),
         &[],
-        true,
     );
 
     if has_std_dep(graph, node) {
-        let _ = namespace.star_import_with_reexports(
+        let _ = root.star_import_with_reexports(
             &Handler::default(),
             engines,
             &[STD, PRELUDE].map(|s| Ident::new_no_span(s.into())),
             &[],
-            true,
         );
     }
 
-    Ok(namespace)
+    Ok(root)
 }
 
 /// Find the `std` dependency, if it is a direct one, of the given node.
@@ -1757,7 +1757,7 @@ pub fn compile(
     pkg: &PackageDescriptor,
     profile: &BuildProfile,
     engines: &Engines,
-    namespace: namespace::Module,
+    namespace: namespace::Root,
     source_map: &mut SourceMap,
 ) -> Result<CompiledPackage> {
     let mut metrics = PerformanceData::default();

sway-core/src/ir_generation/const_eval.rs

@@ -1185,12 +1185,12 @@ mod tests {
         let handler = Handler::default();
         let mut context = Context::new(engines.se(), sway_ir::ExperimentalFlags::default());
         let mut md_mgr = MetadataManager::default();
-        let core_lib = namespace::Module {
+        let core_lib = namespace::Root::from(namespace::Module {
             name: Some(sway_types::Ident::new_no_span(
                 "assert_is_constant_test".to_string(),
             )),
             ..Default::default()
-        };
+        });
 
         let r = crate::compile_to_ast(
             &handler,

sway-core/src/language/call_path.rs

@@ -320,7 +320,7 @@ impl CallPath {
                 .get(&self.suffix)
             {
                 synonym_prefixes = use_synonym.0.clone();
-                is_absolute = use_synonym.3;
+                is_absolute = true;
                 let submodule = namespace.module().submodule(&[use_synonym.0[0].clone()]);
                 if let Some(submodule) = submodule {
                     is_external = submodule.is_external;

sway-core/src/lib.rs

@@ -474,7 +474,7 @@ pub fn parsed_to_ast(
     handler: &Handler,
     engines: &Engines,
     parse_program: &parsed::ParseProgram,
-    initial_namespace: namespace::Module,
+    initial_namespace: namespace::Root,
     build_config: Option<&BuildConfig>,
     package_name: &str,
     retrigger_compilation: Option<Arc<AtomicBool>>,
@@ -638,7 +638,7 @@ pub fn compile_to_ast(
     handler: &Handler,
     engines: &Engines,
     input: Arc<str>,
-    initial_namespace: namespace::Module,
+    initial_namespace: namespace::Root,
     build_config: Option<&BuildConfig>,
     package_name: &str,
     retrigger_compilation: Option<Arc<AtomicBool>>,
@@ -735,7 +735,7 @@ pub fn compile_to_asm(
     handler: &Handler,
     engines: &Engines,
     input: Arc<str>,
-    initial_namespace: namespace::Module,
+    initial_namespace: namespace::Root,
     build_config: BuildConfig,
     package_name: &str,
 ) -> Result<CompiledAsm, ErrorEmitted> {
@@ -892,7 +892,7 @@ pub fn compile_to_bytecode(
     handler: &Handler,
     engines: &Engines,
     input: Arc<str>,
-    initial_namespace: namespace::Module,
+    initial_namespace: namespace::Root,
     build_config: BuildConfig,
     source_map: &mut SourceMap,
     package_name: &str,

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

@@ -2433,7 +2433,8 @@ mod tests {
         type_annotation: TypeId,
         experimental: ExperimentalFlags,
     ) -> Result<ty::TyExpression, ErrorEmitted> {
-        let mut namespace = Namespace::init_root(namespace::Module::default());
+        let root_module = namespace::Root::from(namespace::Module::default());
+        let mut namespace = Namespace::init_root(root_module);
         let ctx = TypeCheckContext::from_namespace(&mut namespace, engines, experimental)
             .with_type_annotation(type_annotation);
         ty::TyExpression::type_check(handler, ctx, expr)

sway-core/src/semantic_analysis/ast_node/mod.rs

@@ -49,8 +49,7 @@ impl ty::TyAstNode {
                         ImportType::Star => {
                             // try a standard starimport first
                             let star_import_handler = Handler::default();
-                            let import =
-                                ctx.star_import(&star_import_handler, &path, a.is_absolute);
+                            let import = ctx.star_import(&star_import_handler, &path);
                             if import.is_ok() {
                                 handler.append(star_import_handler);
                                 import
@@ -62,7 +61,6 @@ impl ty::TyAstNode {
                                         &variant_import_handler,
                                         path,
                                         enum_name,
-                                        a.is_absolute,
                                     );
                                     if variant_import.is_ok() {
                                         handler.append(variant_import_handler);
@@ -78,18 +76,13 @@ impl ty::TyAstNode {
                             }
                         }
                         ImportType::SelfImport(_) => {
-                            ctx.self_import(handler, &path, a.alias.clone(), a.is_absolute)
+                            ctx.self_import(handler, &path, a.alias.clone())
                         }
                         ImportType::Item(ref s) => {
                             // try a standard item import first
                             let item_import_handler = Handler::default();
-                            let import = ctx.item_import(
-                                &item_import_handler,
-                                &path,
-                                s,
-                                a.alias.clone(),
-                                a.is_absolute,
-                            );
+                            let import =
+                                ctx.item_import(&item_import_handler, &path, s, a.alias.clone());
 
                             if import.is_ok() {
                                 handler.append(item_import_handler);
@@ -104,7 +97,6 @@ impl ty::TyAstNode {
                                         enum_name,
                                         s,
                                         a.alias.clone(),
-                                        a.is_absolute,
                                     );
                                     if variant_import.is_ok() {
                                         handler.append(variant_import_handler);

sway-core/src/semantic_analysis/namespace/lexical_scope.rs

@@ -28,8 +28,8 @@ pub(crate) enum GlobImport {
 }
 
 pub(super) type SymbolMap = im::OrdMap<Ident, ty::TyDecl>;
-// The final `bool` field of `UseSynonyms` is true if the `Vec<Ident>` path is absolute.
-pub(super) type UseSynonyms = im::HashMap<Ident, (Vec<Ident>, GlobImport, ty::TyDecl, bool)>;
+// The `Vec<Ident>` path is absolute.
+pub(super) type UseSynonyms = im::HashMap<Ident, (Vec<Ident>, GlobImport, ty::TyDecl)>;
 pub(super) type UseAliases = im::HashMap<String, Ident>;
 
 /// Represents a lexical scope integer-based identifier, which can be used to reference
@@ -261,8 +261,7 @@ impl Items {
             append_shadowing_error(ident, decl, false, false, &item, const_shadowing_mode);
         }
 
-        if let Some((ident, (_, GlobImport::No, decl, _))) = self.use_synonyms.get_key_value(&name)
-        {
+        if let Some((ident, (_, GlobImport::No, decl))) = self.use_synonyms.get_key_value(&name) {
             append_shadowing_error(
                 ident,
                 decl,