Remove require_module from Root

Author: jjcnn

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

@@ -170,7 +170,20 @@ impl Namespace {
         handler: &Handler,
         path: &ModulePathBuf,
     ) -> Result<&Module, ErrorEmitted> {
-        self.root.require_module(handler, path)
+        if path.is_empty() {
+            return Err(handler.emit_err(CompileError::Internal(
+                "Found empty absolute mod path",
+                Span::dummy(),
+            )));
+        }
+        let is_in_current_package = self.root.check_path_is_in_current_package(path);
+        match self.module_from_absolute_path(path) {
+            Some(module) => Ok(module),
+            None => Err(handler.emit_err(crate::namespace::module::module_not_found(
+                path,
+                is_in_current_package,
+            ))),
+        }
     }
 
     /// Returns true if the current module being checked is a direct or indirect submodule of
@@ -369,7 +382,7 @@ impl Namespace {
     ) -> Result<(), ErrorEmitted> {
         self.check_module_visibility(handler, src)?;
 
-        let src_mod = self.root.require_module(handler, &src.to_vec())?;
+        let src_mod = self.require_module_from_absolute_path(handler, &src.to_vec())?;
 
         let mut decls_and_item_imports = vec![];
 
@@ -565,7 +578,7 @@ impl Namespace {
     ) -> Result<(), ErrorEmitted> {
         self.check_module_visibility(handler, src)?;
 
-        let src_mod = self.root.require_module(handler, &src.to_vec())?;
+        let src_mod = self.require_module_from_absolute_path(handler, &src.to_vec())?;
 
         let (decl, path) = self.item_lookup(handler, engines, item, src, false)?;
 
@@ -810,7 +823,7 @@ impl Namespace {
         src: &ModulePath,
         ignore_visibility: bool,
     ) -> Result<(ResolvedDeclaration, ModulePathBuf), ErrorEmitted> {
-        let src_mod = self.root.require_module(handler, &src.to_vec())?;
+        let src_mod = self.require_module_from_absolute_path(handler, &src.to_vec())?;
         let src_items = src_mod.root_items();
 
         let (decl, path, src_visibility) = if let Some(decl) = src_items.symbols.get(item) {

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

@@ -14,10 +14,7 @@ use crate::{
 };
 use rustc_hash::FxHasher;
 use std::hash::BuildHasherDefault;
-use sway_error::{
-    error::CompileError,
-    handler::{ErrorEmitted, Handler},
-};
+use sway_error::handler::{ErrorEmitted, Handler};
 use sway_types::{span::Span, ProgramId};
 
 #[derive(Clone, Debug)]
@@ -222,7 +219,7 @@ impl Root {
         self.program_id
     }
 
-    fn check_path_is_in_current_package(&self, mod_path: &ModulePathBuf) -> bool {
+    pub(crate) fn check_path_is_in_current_package(&self, mod_path: &ModulePathBuf) -> bool {
         !mod_path.is_empty() && mod_path[0] == *self.current_package.name()
     }
 
@@ -250,29 +247,6 @@ impl Root {
         }
     }
 
-    // Find module in the current environment. `mod_path` must be a fully qualified path.
-    // Throw an error if the module doesn't exist
-    pub(crate) fn require_module(
-        &self,
-        handler: &Handler,
-        mod_path: &ModulePathBuf,
-    ) -> Result<&Module, ErrorEmitted> {
-        if mod_path.is_empty() {
-            return Err(handler.emit_err(CompileError::Internal(
-                "Found empty absolute mod path",
-                Span::dummy(),
-            )));
-        }
-        let is_in_current_package = self.check_path_is_in_current_package(mod_path);
-        match self.module_from_absolute_path(mod_path) {
-            Some(module) => Ok(module),
-            None => Err(handler.emit_err(crate::namespace::module::module_not_found(
-                mod_path,
-                is_in_current_package,
-            ))),
-        }
-    }
-
     // Find a module in the current package. `mod_path` must be a fully qualified path
     pub(super) fn module_in_current_package(&self, mod_path: &ModulePathBuf) -> Option<&Module> {
         assert!(self.check_path_is_in_current_package(mod_path));

sway-core/src/semantic_analysis/type_resolve.rs

@@ -10,7 +10,7 @@ use crate::{
         CallPath, QualifiedCallPath,
     },
     monomorphization::type_decl_opt_to_type_id,
-    namespace::{Module, ModulePath, ResolvedDeclaration, ResolvedTraitImplItem, Root},
+    namespace::{Module, ModulePath, ResolvedDeclaration, ResolvedTraitImplItem},
     type_system::SubstTypes,
     EnforceTypeArguments, Engines, Namespace, SubstTypesContext, TypeId, TypeInfo,
 };
@@ -336,7 +336,14 @@ pub(super) fn resolve_symbol_and_mod_path(
     assert!(!mod_path.is_empty());
     let root = namespace.root_ref();
     if mod_path[0] == *root.current_package_name() {
-        resolve_symbol_and_mod_path_inner(handler, engines, root, mod_path, symbol, self_type)
+        resolve_symbol_and_mod_path_inner(
+            handler,
+            engines,
+            root.current_package_root_module(),
+            mod_path,
+            symbol,
+            self_type,
+        )
     } else {
         match namespace.get_external_package(&mod_path[0].to_string()) {
             Some(ext_root) => {
@@ -350,7 +357,7 @@ pub(super) fn resolve_symbol_and_mod_path(
                 resolve_symbol_and_mod_path_inner(
                     handler,
                     engines,
-                    ext_root,
+                    ext_root.current_package_root_module(),
                     &new_mod_path,
                     symbol,
                     self_type,
@@ -367,16 +374,16 @@ pub(super) fn resolve_symbol_and_mod_path(
 fn resolve_symbol_and_mod_path_inner(
     handler: &Handler,
     engines: &Engines,
-    root: &Root,
+    root_module: &Module,
     mod_path: &ModulePath,
     symbol: &Ident,
     self_type: Option<TypeId>,
 ) -> Result<(ResolvedDeclaration, Vec<Ident>), ErrorEmitted> {
     assert!(!mod_path.is_empty());
-    assert!(mod_path[0] == *root.current_package_name());
+    assert!(mod_path[0] == root_module.mod_path()[0]);
 
     // This block tries to resolve associated types
-    let mut current_module = root.current_package_root_module();
+    let mut current_module = root_module;
     let mut current_mod_path = vec![mod_path[0].clone()];
     let mut decl_opt = None;
     for ident in mod_path.iter().skip(1) {
@@ -416,7 +423,8 @@ fn resolve_symbol_and_mod_path_inner(
         return Ok((decl, current_mod_path));
     }
 
-    root.require_module(handler, &mod_path.to_vec())
+    root_module
+        .lookup_submodule(handler, &mod_path[1..])
         .and_then(|module| {
             let (decl, decl_path) = module.resolve_symbol(handler, engines, symbol)?;
             Ok((decl, decl_path))