Module refactors (#5793)

## Description

Some minor cleanups and refactors to module-related code. 

## Checklist

- [ ] I have linked to any relevant issues.
- [ ] I have commented my code, particularly in hard-to-understand
areas.
- [ ] I have updated the documentation where relevant (API docs, the
reference, and the Sway book).
- [ ] If my change requires substantial documentation changes, I have
[requested support from the DevRel
team](https://github.com/FuelLabs/devrel-requests/issues/new/choose)
- [ ] I have added tests that prove my fix is effective or that my
feature works.
- [ ] I have added (or requested a maintainer to add) the necessary
`Breaking*` or `New Feature` labels where relevant.
- [x] I have done my best to ensure that my PR adheres to [the Fuel Labs
Code Review
Standards](https://github.com/FuelLabs/rfcs/blob/master/text/code-standards/external-contributors.md).
- [x] I have requested a review from the relevant team or maintainers.

Author: tritao

sway-core/src/error.rs

@@ -1,6 +1,6 @@
 //! Tools related to handling/recovering from Sway compile errors and reporting them to the user.
 
-use crate::{language::parsed::VariableDeclaration, namespace::Path, Namespace};
+use crate::{language::parsed::VariableDeclaration, namespace::ModulePath, Namespace};
 
 /// Acts as the result of parsing `Declaration`s, `Expression`s, etc.
 /// Some `Expression`s need to be able to create `VariableDeclaration`s,
@@ -31,7 +31,7 @@ impl<T> ParserLifter<T> {
 /// this function returns true if the programmer can change that module.
 pub(crate) fn module_can_be_changed(
     issue_namespace: &Namespace,
-    absolute_module_path: &Path,
+    absolute_module_path: &ModulePath,
 ) -> bool {
     // For now, we assume that the programmers can change the module
     // if the module is in the same package where the issue is.

sway-core/src/language/call_path.rs

@@ -19,7 +19,7 @@ use sway_error::{
 };
 use sway_types::{span::Span, Spanned};
 
-use super::parsed::QualifiedPathRootTypes;
+use super::parsed::QualifiedPathType;
 
 #[derive(Clone, Debug)]
 pub struct CallPathTree {
@@ -70,7 +70,7 @@ impl OrdWithEngines for CallPathTree {
 
 pub struct QualifiedCallPath {
     pub call_path: CallPath,
-    pub qualified_path_root: Option<Box<QualifiedPathRootTypes>>,
+    pub qualified_path_root: Option<Box<QualifiedPathType>>,
 }
 
 impl std::convert::From<Ident> for QualifiedCallPath {

sway-core/src/language/parsed/expression/mod.rs

@@ -112,15 +112,15 @@ impl Spanned for AmbiguousSuffix {
 }
 
 #[derive(Debug, Clone)]
-pub struct QualifiedPathRootTypes {
+pub struct QualifiedPathType {
     pub ty: TypeArgument,
     pub as_trait: TypeId,
     pub as_trait_span: Span,
 }
 
-impl HashWithEngines for QualifiedPathRootTypes {
+impl HashWithEngines for QualifiedPathType {
     fn hash<H: Hasher>(&self, state: &mut H, engines: &Engines) {
-        let QualifiedPathRootTypes {
+        let QualifiedPathType {
             ty,
             as_trait,
             // ignored fields
@@ -131,10 +131,10 @@ impl HashWithEngines for QualifiedPathRootTypes {
     }
 }
 
-impl EqWithEngines for QualifiedPathRootTypes {}
-impl PartialEqWithEngines for QualifiedPathRootTypes {
+impl EqWithEngines for QualifiedPathType {}
+impl PartialEqWithEngines for QualifiedPathType {
     fn eq(&self, other: &Self, engines: &Engines) -> bool {
-        let QualifiedPathRootTypes {
+        let QualifiedPathType {
             ty,
             as_trait,
             // ignored fields
@@ -148,15 +148,15 @@ impl PartialEqWithEngines for QualifiedPathRootTypes {
     }
 }
 
-impl OrdWithEngines for QualifiedPathRootTypes {
+impl OrdWithEngines for QualifiedPathType {
     fn cmp(&self, other: &Self, engines: &Engines) -> Ordering {
-        let QualifiedPathRootTypes {
+        let QualifiedPathType {
             ty: l_ty,
             as_trait: l_as_trait,
             // ignored fields
             as_trait_span: _,
         } = self;
-        let QualifiedPathRootTypes {
+        let QualifiedPathType {
             ty: r_ty,
             as_trait: r_as_trait,
             // ignored fields
@@ -171,7 +171,7 @@ impl OrdWithEngines for QualifiedPathRootTypes {
     }
 }
 
-impl DisplayWithEngines for QualifiedPathRootTypes {
+impl DisplayWithEngines for QualifiedPathType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>, engines: &Engines) -> fmt::Result {
         write!(
             f,
@@ -182,15 +182,15 @@ impl DisplayWithEngines for QualifiedPathRootTypes {
     }
 }
 
-impl DebugWithEngines for QualifiedPathRootTypes {
+impl DebugWithEngines for QualifiedPathType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>, engines: &Engines) -> fmt::Result {
         write!(f, "{}", engines.help_out(self),)
     }
 }
 
 #[derive(Debug, Clone)]
 pub struct AmbiguousPathExpression {
-    pub qualified_path_root: Option<QualifiedPathRootTypes>,
+    pub qualified_path_root: Option<QualifiedPathType>,
     pub call_path_binding: TypeBinding<CallPath<AmbiguousSuffix>>,
     pub args: Vec<Expression>,
 }

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

@@ -1159,12 +1159,12 @@ impl ty::TyExpression {
         }: TypeBinding<CallPath<AmbiguousSuffix>>,
         span: Span,
         args: Vec<Expression>,
-        qualified_path_root: Option<QualifiedPathRootTypes>,
+        qualified_path_root: Option<QualifiedPathType>,
     ) -> Result<ty::TyExpression, ErrorEmitted> {
         let engines = ctx.engines;
         let decl_engine = engines.de();
 
-        if let Some(QualifiedPathRootTypes { ty, as_trait, .. }) = qualified_path_root.clone() {
+        if let Some(QualifiedPathType { ty, as_trait, .. }) = qualified_path_root.clone() {
             let method_name_binding = if !prefixes.is_empty() || before.is_some() {
                 let mut prefixes_and_before = prefixes.clone();
                 if let Some(before) = before {
@@ -1282,7 +1282,10 @@ impl ty::TyExpression {
         path.push(before.inner.clone());
         let not_module = {
             let h = Handler::default();
-            ctx.namespace().module().check_submodule(&h, &path).is_err()
+            ctx.namespace()
+                .module()
+                .lookup_submodule(&h, &path)
+                .is_err()
         };
 
         // Not a module? Not a `Enum::Variant` either?
@@ -1402,7 +1405,7 @@ impl ty::TyExpression {
                 let call_path_binding = unknown_call_path_binding.clone();
                 ctx.namespace()
                     .module()
-                    .check_submodule(
+                    .lookup_submodule(
                         &module_probe_handler,
                         &[
                             call_path_binding.inner.call_path.prefixes,

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

@@ -635,9 +635,9 @@ pub(crate) fn resolve_method_name(
             // find the module that the symbol is in
             let type_info_prefix = ctx
                 .namespace()
-                .find_module_path(&call_path_binding.inner.prefixes);
+                .prepend_module_path(&call_path_binding.inner.prefixes);
             ctx.namespace()
-                .check_absolute_path_to_submodule(handler, &type_info_prefix)?;
+                .lookup_submodule_from_absolute_path(handler, &type_info_prefix)?;
 
             // find the method
             let decl_ref = ctx.find_method_for_type(
@@ -656,7 +656,7 @@ pub(crate) fn resolve_method_name(
         MethodName::FromTrait { call_path } => {
             // find the module that the symbol is in
             let module_path = if !call_path.is_absolute {
-                ctx.namespace().find_module_path(&call_path.prefixes)
+                ctx.namespace().prepend_module_path(&call_path.prefixes)
             } else {
                 let mut module_path = call_path.prefixes.clone();
                 if let (Some(root_mod), Some(root_name)) = (
@@ -692,7 +692,7 @@ pub(crate) fn resolve_method_name(
         }
         MethodName::FromModule { method_name } => {
             // find the module that the symbol is in
-            let module_path = ctx.namespace().find_module_path(vec![]);
+            let module_path = ctx.namespace().prepend_module_path(vec![]);
 
             // find the type of the first argument
             let type_id = arguments_types

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

@@ -78,9 +78,9 @@ pub(crate) fn struct_instantiation(
     };
 
     // find the module that the struct decl is in
-    let type_info_prefix = ctx.namespace().find_module_path(prefixes);
+    let type_info_prefix = ctx.namespace().prepend_module_path(prefixes);
     ctx.namespace()
-        .check_absolute_path_to_submodule(handler, &type_info_prefix)?;
+        .lookup_submodule_from_absolute_path(handler, &type_info_prefix)?;
 
     // resolve the type of the struct decl
     let type_id = ctx

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

@@ -62,7 +62,7 @@ impl ty::TyAstNode {
                     let path = if is_external || a.is_absolute {
                         a.call_path.clone()
                     } else {
-                        ctx.namespace().find_module_path(&a.call_path)
+                        ctx.namespace().prepend_module_path(&a.call_path)
                     };
                     let _ = match a.import_type {
                         ImportType::Star => {

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

@@ -17,8 +17,6 @@ pub(super) use trait_map::TraitMap;
 
 use sway_types::Ident;
 
-pub type Path = [Ident];
-pub type PathBuf = Vec<Ident>;
-
 type ModuleName = String;
-pub type ModulePath = PathBuf;
+pub type ModulePath = [Ident];
+pub type ModulePathBuf = Vec<Ident>;

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

@@ -14,7 +14,7 @@ use crate::{
 use super::{
     lexical_scope::{Items, LexicalScope, SymbolMap},
     root::Root,
-    LexicalScopeId, ModuleName, ModulePath, Path,
+    LexicalScopeId, ModuleName, ModulePath, ModulePathBuf,
 };
 
 use sway_ast::ItemConst;
@@ -59,7 +59,7 @@ pub struct Module {
     ///
     /// When this is the root module, this is equal to `[]`. When this is a
     /// submodule of the root called "foo", this would be equal to `[foo]`.
-    pub mod_path: ModulePath,
+    pub(crate) mod_path: ModulePathBuf,
 }
 
 impl Default for Module {
@@ -78,6 +78,14 @@ impl Default for Module {
 }
 
 impl Module {
+    pub fn mod_path(&self) -> &ModulePath {
+        self.mod_path.as_slice()
+    }
+
+    pub fn mod_path_buf(&self) -> ModulePathBuf {
+        self.mod_path.clone()
+    }
+
     /// `contract_id_value` is injected here via forc-pkg when producing the `dependency_namespace` for a contract which has tests enabled.
     /// This allows us to provide a contract's `CONTRACT_ID` constant to its own unit tests.
     ///
@@ -200,7 +208,7 @@ impl Module {
     }
 
     /// Lookup the submodule at the given path.
-    pub fn submodule(&self, path: &Path) -> Option<&Module> {
+    pub fn submodule(&self, path: &ModulePath) -> Option<&Module> {
         let mut module = self;
         for ident in path.iter() {
             match module.submodules.get(ident.as_str()) {
@@ -212,7 +220,7 @@ impl Module {
     }
 
     /// Unique access to the submodule at the given path.
-    pub fn submodule_mut(&mut self, path: &Path) -> Option<&mut Module> {
+    pub fn submodule_mut(&mut self, path: &ModulePath) -> Option<&mut Module> {
         let mut module = self;
         for ident in path.iter() {
             match module.submodules.get_mut(ident.as_str()) {
@@ -226,7 +234,7 @@ impl Module {
     /// Lookup the submodule at the given path.
     ///
     /// This should be used rather than `Index` when we don't yet know whether the module exists.
-    pub(crate) fn check_submodule(
+    pub(crate) fn lookup_submodule(
         &self,
         handler: &Handler,
         path: &[Ident],
@@ -295,7 +303,7 @@ impl Module {
         &self,
         handler: &Handler,
         engines: &Engines,
-        mod_path: &Path,
+        mod_path: &ModulePath,
         call_path: &CallPath,
         self_type: Option<TypeId>,
     ) -> Result<ty::TyDecl, ErrorEmitted> {
@@ -308,7 +316,7 @@ impl Module {
         &self,
         handler: &Handler,
         engines: &Engines,
-        mod_path: &Path,
+        mod_path: &ModulePath,
         call_path: &CallPath,
         self_type: Option<TypeId>,
     ) -> Result<(ty::TyDecl, Vec<Ident>), ErrorEmitted> {
@@ -397,7 +405,7 @@ impl Module {
         &self,
         handler: &Handler,
         engines: &Engines,
-        mod_path: &Path,
+        mod_path: &ModulePath,
         symbol: &Ident,
         self_type: Option<TypeId>,
     ) -> Result<ty::TyDecl, ErrorEmitted> {
@@ -410,7 +418,7 @@ impl Module {
         &self,
         handler: &Handler,
         engines: &Engines,
-        mod_path: &Path,
+        mod_path: &ModulePath,
         symbol: &Ident,
         self_type: Option<TypeId>,
     ) -> Result<(ty::TyDecl, Vec<Ident>), ErrorEmitted> {
@@ -448,7 +456,7 @@ impl Module {
             return Ok((decl, current_mod_path));
         }
 
-        self.check_submodule(handler, mod_path).and_then(|module| {
+        self.lookup_submodule(handler, mod_path).and_then(|module| {
             let decl =
                 self.resolve_symbol_helper(handler, engines, mod_path, symbol, module, self_type)?;
             Ok((decl, mod_path.to_vec()))
@@ -589,7 +597,7 @@ impl Module {
         &self,
         handler: &Handler,
         engines: &Engines,
-        mod_path: &Path,
+        mod_path: &ModulePath,
         symbol: &Ident,
         module: &Module,
         self_type: Option<TypeId>,
@@ -625,16 +633,16 @@ impl Module {
     }
 }
 
-impl<'a> std::ops::Index<&'a Path> for Module {
+impl<'a> std::ops::Index<&'a ModulePath> for Module {
     type Output = Module;
-    fn index(&self, path: &'a Path) -> &Self::Output {
+    fn index(&self, path: &'a ModulePath) -> &Self::Output {
         self.submodule(path)
             .unwrap_or_else(|| panic!("no module for the given path {path:?}"))
     }
 }
 
-impl<'a> std::ops::IndexMut<&'a Path> for Module {
-    fn index_mut(&mut self, path: &'a Path) -> &mut Self::Output {
+impl<'a> std::ops::IndexMut<&'a ModulePath> for Module {
+    fn index_mut(&mut self, path: &'a ModulePath) -> &mut Self::Output {
         self.submodule_mut(path)
             .unwrap_or_else(|| panic!("no module for the given path {path:?}"))
     }