Rename IncludeStatement to ModStatement.

Author: tritao

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

@@ -2,15 +2,15 @@
 mod code_block;
 pub mod declaration;
 mod expression;
-mod include_statement;
+mod mod_statement;
 mod module;
 mod program;
 mod use_statement;
 
 pub use code_block::*;
 pub use declaration::*;
 pub use expression::*;
-pub use include_statement::IncludeStatement;
+pub use mod_statement::ModStatement;
 pub use module::{ModuleEvaluationOrder, ParseModule, ParseSubmodule};
 pub use program::{ParseProgram, TreeType};
 use sway_error::handler::ErrorEmitted;
@@ -62,7 +62,7 @@ pub enum AstNodeContent {
     /// Any type of expression, of which there are quite a few. See [Expression] for more details.
     Expression(Expression),
     /// A statement of the form `mod foo::bar;` which imports/includes another source file.
-    IncludeStatement(IncludeStatement),
+    ModStatement(ModStatement),
     /// A malformed statement.
     ///
     /// Used for parser recovery when we cannot form a more specific node.
@@ -80,7 +80,7 @@ impl PartialEqWithEngines for AstNodeContent {
                 lhs.eq(rhs, ctx)
             }
             (AstNodeContent::Expression(lhs), AstNodeContent::Expression(rhs)) => lhs.eq(rhs, ctx),
-            (AstNodeContent::IncludeStatement(lhs), AstNodeContent::IncludeStatement(rhs)) => {
+            (AstNodeContent::ModStatement(lhs), AstNodeContent::ModStatement(rhs)) => {
                 lhs.eq(rhs)
             }
             (AstNodeContent::Error(lhs, ..), AstNodeContent::Error(rhs, ..)) => lhs.eq(rhs),

sway-core/src/language/parsed/include_statement.rs renamed to sway-core/src/language/parsed/mod_statement.rs

@@ -3,7 +3,7 @@ use sway_types::{span::Span, Ident};
 use crate::language::Visibility;
 
 #[derive(Clone, Debug, PartialEq)]
-pub struct IncludeStatement {
+pub struct ModStatement {
     // this span may be used for errors in the future, although it is not right now.
     pub span: Span,
     pub mod_name: Ident,

sway-core/src/language/ty/ast_node.rs

@@ -104,7 +104,7 @@ impl UpdateConstantExpression for TyAstNode {
                         .value
                         .update_constant_expression(engines, implementing_type);
                 }
-                TyStatement::Use(_) | TyStatement::Include(_) => {}
+                TyStatement::Use(_) | TyStatement::Mod(_) => {}
             },
             TyAstNodeContent::Expression(ref mut expr) => {
                 expr.update_constant_expression(engines, implementing_type)
@@ -339,7 +339,7 @@ impl TyAstNode {
                         .value
                         .check_deprecated(engines, handler, allow_deprecated);
                 }
-                TyStatement::Use(_) | TyStatement::Include(_) => {}
+                TyStatement::Use(_) | TyStatement::Mod(_) => {}
             },
             TyAstNodeContent::Error(_, _) => {}
         }

sway-core/src/language/ty/statement/mod.rs

@@ -1,7 +1,7 @@
 use crate::{
     decl_engine::{DeclMapping, MaterializeConstGenerics, ReplaceDecls},
     engine_threading::*,
-    language::{parsed, Visibility, ty::{TyExpression, TyVariableDecl}},
+    language::{parsed, Visibility, ty::{TyExpression, TyVariableDecl, VariableMutability}},
     semantic_analysis::{
         TypeCheckAnalysis, TypeCheckAnalysisContext, TypeCheckContext, TypeCheckFinalization,
         TypeCheckFinalizationContext,
@@ -17,13 +17,13 @@ use sway_error::handler::{ErrorEmitted, Handler};
 use sway_types::{ident::Ident as BaseIdent, Ident, Named, Span, Spanned};
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub struct TyIncludeStatement {
+pub struct TyModStatement {
     pub span: Span,
     pub visibility: Visibility,
     pub mod_name: BaseIdent,
 }
 
-impl Spanned for TyIncludeStatement {
+impl Spanned for TyModStatement {
     fn span(&self) -> Span {
         self.span.clone()
     }
@@ -58,7 +58,7 @@ impl Spanned for TyUseStatement {
 pub enum TyStatement {
     Let(TyLetBinding),
     Use(TyUseStatement),
-    Include(TyIncludeStatement),
+    Mod(TyModStatement),
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -88,7 +88,7 @@ impl PartialEqWithEngines for TyStatement {
         match (self, other) {
             (TyStatement::Let(lhs), TyStatement::Let(rhs)) => lhs.eq(rhs, ctx),
             (TyStatement::Use(lhs), TyStatement::Use(rhs)) => lhs == rhs,
-            (TyStatement::Include(lhs), TyStatement::Include(rhs)) => lhs == rhs,
+            (TyStatement::Mod(lhs), TyStatement::Mod(rhs)) => lhs == rhs,
             _ => false,
         }
     }
@@ -99,7 +99,7 @@ impl HashWithEngines for TyStatement {
         match self {
             TyStatement::Let(binding) => binding.hash(state, engines),
             TyStatement::Use(stmt) => stmt.hash(state),
-            TyStatement::Include(stmt) => stmt.hash(state),
+            TyStatement::Mod(stmt) => stmt.hash(state),
         }
     }
 }
@@ -108,7 +108,7 @@ impl SubstTypes for TyStatement {
     fn subst_inner(&mut self, ctx: &SubstTypesContext) -> HasChanges {
         match self {
             TyStatement::Let(binding) => binding.subst(ctx),
-            TyStatement::Use(_) | TyStatement::Include(_) => HasChanges::No,
+            TyStatement::Use(_) | TyStatement::Mod(_) => HasChanges::No,
         }
     }
 }
@@ -122,7 +122,7 @@ impl ReplaceDecls for TyStatement {
     ) -> Result<bool, ErrorEmitted> {
         match self {
             TyStatement::Let(binding) => binding.value.replace_decls(decl_mapping, handler, ctx),
-            TyStatement::Use(_) | TyStatement::Include(_) => Ok(false),
+            TyStatement::Use(_) | TyStatement::Mod(_) => Ok(false),
         }
     }
 }
@@ -135,7 +135,7 @@ impl TypeCheckAnalysis for TyStatement {
     ) -> Result<(), ErrorEmitted> {
         match self {
             TyStatement::Let(binding) => binding.value.type_check_analyze(handler, ctx)?,
-            TyStatement::Use(_) | TyStatement::Include(_) => {}
+            TyStatement::Use(_) | TyStatement::Mod(_) => {}
         }
         Ok(())
     }
@@ -149,7 +149,7 @@ impl TypeCheckFinalization for TyStatement {
     ) -> Result<(), ErrorEmitted> {
         match self {
             TyStatement::Let(binding) => binding.value.type_check_finalize(handler, ctx)?,
-            TyStatement::Use(_) | TyStatement::Include(_) => {}
+            TyStatement::Use(_) | TyStatement::Mod(_) => {}
         }
         Ok(())
     }
@@ -172,7 +172,7 @@ impl CollectTypesMetadata for TyStatement {
                 );
                 Ok(metadata)
             }
-            TyStatement::Use(_) | TyStatement::Include(_) => Ok(vec![]),
+            TyStatement::Use(_) | TyStatement::Mod(_) => Ok(vec![]),
         }
     }
 }
@@ -209,7 +209,7 @@ impl MaterializeConstGenerics for TyStatement {
                 }
                 Ok(())
             }
-            TyStatement::Use(_) | TyStatement::Include(_) => Ok(()),
+            TyStatement::Use(_) | TyStatement::Mod(_) => Ok(()),
         }
     }
 }

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

@@ -32,7 +32,7 @@ impl ty::TyAstNode {
             AstNodeContent::UseStatement(stmt) => {
                 collect_use_statement(handler, engines, ctx, &stmt);
             }
-            AstNodeContent::IncludeStatement(_i) => (),
+            AstNodeContent::ModStatement(_i) => (),
             AstNodeContent::Declaration(decl) => ty::TyDecl::collect(handler, engines, ctx, decl)?,
             AstNodeContent::Expression(expr) => {
                 ty::TyExpression::collect(handler, engines, ctx, &expr)?
@@ -64,8 +64,8 @@ impl ty::TyAstNode {
                         import_type: stmt.import_type,
                     }))
                 }
-                AstNodeContent::IncludeStatement(i) => ty::TyAstNodeContent::Statement(
-                    ty::TyStatement::Include(ty::TyIncludeStatement {
+                AstNodeContent::ModStatement(i) => ty::TyAstNodeContent::Statement(
+                    ty::TyStatement::Mod(ty::TyModStatement {
                         mod_name: i.mod_name,
                         span: i.span,
                         visibility: i.visibility,

sway-core/src/semantic_analysis/module.rs

@@ -832,7 +832,7 @@ impl ty::TySubmodule {
                 }
                 AstNodeContent::Declaration(_) => {}
                 AstNodeContent::Expression(_) => {}
-                AstNodeContent::IncludeStatement(_) => {}
+                AstNodeContent::ModStatement(_) => {}
                 AstNodeContent::Error(_, _) => {}
             }
         }

sway-core/src/semantic_analysis/node_dependencies.rs

@@ -268,16 +268,16 @@ fn depends_on(
 ) -> bool {
     match (&dependant_node.content, &dependee_node.content) {
         // Include statements first.
-        (AstNodeContent::IncludeStatement(_), AstNodeContent::IncludeStatement(_)) => false,
-        (_, AstNodeContent::IncludeStatement(_)) => true,
+        (AstNodeContent::ModStatement(_), AstNodeContent::ModStatement(_)) => false,
+        (_, AstNodeContent::ModStatement(_)) => true,
 
         // Use statements next.
-        (AstNodeContent::IncludeStatement(_), AstNodeContent::UseStatement(_)) => false,
+        (AstNodeContent::ModStatement(_), AstNodeContent::UseStatement(_)) => false,
         (AstNodeContent::UseStatement(_), AstNodeContent::UseStatement(_)) => false,
         (_, AstNodeContent::UseStatement(_)) => true,
 
         // Then declarations, ordered using the dependencies list.
-        (AstNodeContent::IncludeStatement(_), AstNodeContent::Declaration(_)) => false,
+        (AstNodeContent::ModStatement(_), AstNodeContent::Declaration(_)) => false,
         (AstNodeContent::UseStatement(_), AstNodeContent::Declaration(_)) => false,
         (AstNodeContent::Declaration(dependant), AstNodeContent::Declaration(dependee)) => {
             match (decl_name(engines, dependant), decl_name(engines, dependee)) {
@@ -769,7 +769,7 @@ impl Dependencies {
 
             // No deps from these guys.
             AstNodeContent::UseStatement(_)
-            | AstNodeContent::IncludeStatement(_)
+            | AstNodeContent::ModStatement(_)
             | AstNodeContent::Error(_, _) => self,
         }
     }

sway-core/src/semantic_analysis/symbol_resolve.rs

@@ -64,7 +64,7 @@ impl ResolveSymbols for AstNode {
             AstNodeContent::UseStatement(_) => {}
             AstNodeContent::Declaration(decl) => decl.resolve_symbols(handler, ctx),
             AstNodeContent::Expression(expr) => expr.resolve_symbols(handler, ctx),
-            AstNodeContent::IncludeStatement(_) => {}
+            AstNodeContent::ModStatement(_) => {}
             AstNodeContent::Error(_, _) => {}
         }
     }

sway-core/src/transform/to_parsed_lang/convert_parse_tree.rs

@@ -122,8 +122,8 @@ pub fn item_to_ast_nodes(
                 ));
             }
 
-            let incl_stmt = submodule_to_include_statement(&submodule);
-            vec![AstNodeContent::IncludeStatement(incl_stmt)]
+            let mod_stmt = submodule_to_mod_statement(&submodule);
+            vec![AstNodeContent::ModStatement(mod_stmt)]
         }
         ItemKind::Use(item_use) => item_use_to_use_statements(context, handler, item_use)?
             .into_iter()
@@ -4647,8 +4647,8 @@ fn statement_let_to_ast_nodes_unfold(
     Ok(ast_nodes)
 }
 
-fn submodule_to_include_statement(submodule: &Submodule) -> IncludeStatement {
-    IncludeStatement {
+fn submodule_to_mod_statement(submodule: &Submodule) -> ModStatement {
+    ModStatement {
         span: submodule.span(),
         mod_name: submodule.name.clone(),
         visibility: pub_token_opt_to_visibility(submodule.visibility.clone()),