Refactor (step 3).

Author: tritao

docs/book/src/basics/variables.md

@@ -30,7 +30,7 @@ let mut foo = 5;
 foo = 6;
 ```
 
-Now, `foo` is mutable, and the reassignment to the number `6` is valid. That is, we are allowed to _mutate_ the variable `foo` to change its value.
+Now, `foo` is mutable, and the assignment to the number `6` is valid. That is, we are allowed to _mutate_ the variable `foo` to change its value.
 
 When assigning to a mutable variable, the right-hand side of the assignment is evaluated before the left-hand side. In the below example, the mutable variable `i` will first be increased and the resulting value of `1` will be stored to `array[1]`, thus resulting in `array` being changed to `[0, 1, 0]`.
 

docs/internals.md

@@ -190,15 +190,13 @@ pub struct ParseModule {
 ```rust
 /// Represents the various structures that constitute a Sway program.
 pub enum AstNodeContent {
-    /// A statement of the form `use foo::bar;` or `use ::foo::bar;`
-    UseStatement(UseStatement),
+    /// Any standalone statement (currently `let`, `use`, or `mod`).
+    Statement(Statement),
     /// Any type of declaration, of which there are quite a few. See [Declaration] for more details
     /// on the possible variants.
     Declaration(Declaration),
     /// 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),
     ...
 }
 ```

docs/reference/src/code/language/variables/src/lib.sw

@@ -25,14 +25,14 @@ fn immutable() {
     // ANCHOR_END: immutable
 }
 
-fn reassignment() {
-    // ANCHOR: reassignment
+fn assignment() {
+    // ANCHOR: assignment
     // Set `foo` to take the value of `5` and the default `u64` type
     let foo = 5;
 
     // Reassign `foo` to be a `str` with the value of `Fuel`
     let foo = "Fuel";
-    // ANCHOR_END: reassignment
+    // ANCHOR_END: assignment
 }
 
 fn shadowing() {

docs/reference/src/documentation/language/variables/variable-shadowing.md

@@ -1,13 +1,13 @@
 # Shadowing
 
-When looking at the [let](let.md) variable we've seen that the value can be changed through the use of the `mut` keyword. We can take this a couple steps further through [reassignment](#reassignment) and [variable shadowing](#variable-shadowing). Note that shadowing applies only to variables. [Constants](const.md) cannot be shadowed.
+When looking at the [let](let.md) variable we've seen that the value can be changed through the use of the `mut` keyword. We can take this a couple steps further through [assignment](#assignment) and [variable shadowing](#variable-shadowing). Note that shadowing applies only to variables. [Constants](const.md) cannot be shadowed.
 
-## Reassignment
+## Assignment
 
 We can redefine the type and value of a variable by instantiating a new version after the first declaration.
 
 ```sway
-{{#include ../../../code/language/variables/src/lib.sw:reassignment}}
+{{#include ../../../code/language/variables/src/lib.sw:assignment}}
 ```
 
 ## Variable Shadowing

forc-plugins/forc-migrate/src/migrations/error_type.rs

@@ -14,7 +14,7 @@ use sway_ast::{
 };
 use sway_core::language::{
     ty::{
-        TyExpression, TyExpressionVariant, TyFunctionDecl, TyReassignmentTarget, TyStructDecl,
+        TyAssignmentTarget, TyExpression, TyExpressionVariant, TyFunctionDecl, TyStructDecl,
         TyVariableDecl,
     },
     CallPathType,
@@ -312,12 +312,12 @@ fn rename_existing_panic_identifiers_to_r_panic_step(
             Ok(InvalidateTypedElement::No)
         }
 
-        fn visit_reassignment(
+        fn visit_assignment(
             &mut self,
             ctx: &VisitingContext,
-            _lexed_op: &mut expr::ReassignmentOp,
+            _lexed_op: &mut expr::AssignmentOp,
             lexed_lhs: &mut Assignable,
-            _ty_lhs: Option<&TyReassignmentTarget>,
+            _ty_lhs: Option<&TyAssignmentTarget>,
             _lexed_rhs: &mut Expr,
             _ty_rhs: Option<&TyExpression>,
             output: &mut Vec<Occurrence>,
@@ -326,7 +326,7 @@ fn rename_existing_panic_identifiers_to_r_panic_step(
             // - Variable names, e.g., `let panic = 42;`
             // - Single field access, e.g., `let x.panic = 42;`
             // But occurrences in, e.g., `foo[panic].x = 42;` will not be renamed.
-            // Full traversal of reassignments' LHS will be done as a part of migration
+            // Full traversal of assignments' LHS will be done as a part of migration
             // infrastructure in the future.
 
             // We report the occurrences only if it is not a dry-run.

forc-plugins/forc-migrate/src/visiting/mod.rs

@@ -9,7 +9,7 @@ use std::sync::Arc;
 use duplicate::duplicate_item;
 use sway_ast::{
     assignable::ElementAccess,
-    expr::{LoopControlFlow, ReassignmentOp, ReassignmentOpVariant},
+    expr::{AssignmentOp, AssignmentOpVariant, LoopControlFlow},
     keywords::*,
     AsmBlock, Assignable, Braces, CodeBlockContents, Expr, ExprArrayDescriptor, ExprStructField,
     ExprTupleDescriptor, IfCondition, IfExpr, Intrinsic, ItemAbi, ItemFn, ItemImpl, ItemImplItem,
@@ -21,9 +21,9 @@ use sway_core::{
     language::{
         lexed::LexedModule,
         ty::{
-            TyAbiDecl, TyAstNodeContent, TyCodeBlock, TyDecl, TyExpression, TyExpressionVariant,
-            TyFunctionDecl, TyImplSelfOrTrait, TyIntrinsicFunctionKind, TyModule,
-            TyReassignmentTarget, TySideEffect, TySideEffectVariant, TyStorageDecl, TyStorageField,
+            TyAbiDecl, TyAssignmentTarget, TyAstNodeContent, TyCodeBlock, TyDecl, TyExpression,
+            TyExpressionVariant, TyFunctionDecl, TyImplSelfOrTrait, TyIntrinsicFunctionKind,
+            TyModule, TySideEffect, TySideEffectVariant, TyStorageDecl, TyStorageField,
             TyStructDecl, TyTraitDecl, TyTraitItem, TyUseStatement, TyVariableDecl,
         },
         CallPath,
@@ -256,12 +256,12 @@ pub(crate) trait __TreesVisitor<O> {
         Ok(InvalidateTypedElement::No)
     }
     #[allow(clippy::too_many_arguments)]
-    fn visit_reassignment(
+    fn visit_assignment(
         &mut self,
         ctx: &VisitingContext,
-        lexed_op: __ref_type([ReassignmentOp]),
+        lexed_op: __ref_type([AssignmentOp]),
         lexed_lhs: __ref_type([Assignable]),
-        ty_lhs: Option<&TyReassignmentTarget>,
+        ty_lhs: Option<&TyAssignmentTarget>,
         lexed_rhs: __ref_type([Expr]),
         ty_rhs: Option<&TyExpression>,
         output: &mut Vec<O>,
@@ -1676,28 +1676,25 @@ impl __ProgramVisitor {
                     output,
                 )?;
             }
-            Expr::Reassignment {
+            Expr::Assignment {
                 assignable,
-                reassignment_op,
+                assignment_op,
                 expr,
             } => {
-                let ty_reassignment = ty_expr
+                let ty_assignment = ty_expr
                     .map(|ty_expr| match &ty_expr.expression {
-                        TyExpressionVariant::Reassignment(ty_reassignment) => {
-                            Ok(ty_reassignment.as_ref())
+                        TyExpressionVariant::Assignment(ty_assignment) => {
+                            Ok(ty_assignment.as_ref())
                         }
-                        _ => bail!(invalid_ty_expression_variant(
-                            "Reassignment",
-                            "Reassignment"
-                        )),
+                        _ => bail!(invalid_ty_expression_variant("Assignment", "Assignment")),
                     })
                     .transpose()?;
-                let ty_lhs = ty_reassignment.map(|ty_reassignment| &ty_reassignment.lhs);
-                let ty_rhs = ty_reassignment.map(|ty_reassignment| &ty_reassignment.rhs);
+                let ty_lhs = ty_assignment.map(|ty_assignment| &ty_assignment.lhs);
+                let ty_rhs = ty_assignment.map(|ty_assignment| &ty_assignment.rhs);
 
-                let (ty_lhs, ty_rhs) = match visitor.visit_reassignment(
+                let (ty_lhs, ty_rhs) = match visitor.visit_assignment(
                     ctx,
-                    reassignment_op,
+                    assignment_op,
                     assignable,
                     ty_lhs,
                     expr.__as_ref(),
@@ -1714,7 +1711,7 @@ impl __ProgramVisitor {
                         fn visit_element_access<V, O>(
                             ctx: &VisitingContext,
                             element_access: __ref_type([ElementAccess]),
-                            _ty_element_access: Option<&TyReassignmentTarget>,
+                            _ty_element_access: Option<&TyAssignmentTarget>,
                             visitor: &mut V,
                             output: &mut Vec<O>,
                         ) -> Result<()>
@@ -1724,7 +1721,7 @@ impl __ProgramVisitor {
                             match element_access {
                                 ElementAccess::Var(_base_ident) => {}
                                 ElementAccess::Index { target, arg } => {
-                                    // TODO: Implement extracting typed `reassignment LHS`.
+                                    // TODO: Implement extracting typed `assignment LHS`.
                                     let ty_target = None;
                                     visit_element_access(
                                         ctx,
@@ -1764,27 +1761,27 @@ impl __ProgramVisitor {
                         star_token: _,
                         expr,
                     } => {
-                        // TODO: Implement extracting typed `reassignment LHS`.
+                        // TODO: Implement extracting typed `assignment LHS`.
                         let ty_expr = None;
                         Self::visit_expr(ctx, expr.__as_ref(), ty_expr, visitor, output)?;
                     }
                 }
 
                 // Visit RHS.
-                match reassignment_op.variant {
-                    ReassignmentOpVariant::Equals => {
+                match assignment_op.variant {
+                    AssignmentOpVariant::Equals => {
                         Self::visit_expr(ctx, expr, ty_rhs, visitor, output)?;
                     }
                     _ => {
-                        // TODO: Implement extracting typed `ty_expr` when visiting `compound reassignments`.
+                        // TODO: Implement extracting typed `ty_expr` when visiting `compound assignments`.
                         //       We need to properly handle the desugaring.
                         //       E.g., `x += func(1, 2);`
                         //       will be desugared into `x = add(x, func(1, 2));`
                         //       When visiting the RHS in the lexed tree, we need to skip the
                         //       operator method call in the typed tree, and provide the
                         //       typed arguments instead.
                         //       To provide visiting without losing the information about compound
-                        //       reassignment, we will need to have a dedicated `visit_reassignment`
+                        //       assignment, we will need to have a dedicated `visit_assignment`
                         //       method.
                         Self::visit_expr(ctx, expr, None, visitor, output)?;
                     }

sway-ast/src/expr/mod.rs

@@ -186,9 +186,9 @@ pub enum Expr {
         double_pipe_token: DoublePipeToken,
         rhs: Box<Expr>,
     },
-    Reassignment {
+    Assignment {
         assignable: Assignable,
-        reassignment_op: ReassignmentOp,
+        assignment_op: AssignmentOp,
         expr: Box<Expr>,
     },
     Break {
@@ -283,7 +283,7 @@ impl Spanned for Expr {
             Expr::GreaterThanEq { lhs, rhs, .. } => Span::join(lhs.span(), &rhs.span()),
             Expr::LogicalAnd { lhs, rhs, .. } => Span::join(lhs.span(), &rhs.span()),
             Expr::LogicalOr { lhs, rhs, .. } => Span::join(lhs.span(), &rhs.span()),
-            Expr::Reassignment {
+            Expr::Assignment {
                 assignable, expr, ..
             } => Span::join(assignable.span(), &expr.span()),
             Expr::Break { break_token } => break_token.span(),
@@ -293,13 +293,13 @@ impl Spanned for Expr {
 }
 
 #[derive(Clone, Debug, Serialize)]
-pub struct ReassignmentOp {
-    pub variant: ReassignmentOpVariant,
+pub struct AssignmentOp {
+    pub variant: AssignmentOpVariant,
     pub span: Span,
 }
 
 #[derive(Clone, Debug, Serialize)]
-pub enum ReassignmentOpVariant {
+pub enum AssignmentOpVariant {
     Equals,
     AddEquals,
     SubEquals,
@@ -309,28 +309,28 @@ pub enum ReassignmentOpVariant {
     ShrEquals,
 }
 
-impl ReassignmentOpVariant {
+impl AssignmentOpVariant {
     pub fn std_name(&self) -> &'static str {
         match self {
-            ReassignmentOpVariant::Equals => "eq",
-            ReassignmentOpVariant::AddEquals => "add",
-            ReassignmentOpVariant::SubEquals => "subtract",
-            ReassignmentOpVariant::MulEquals => "multiply",
-            ReassignmentOpVariant::DivEquals => "divide",
-            ReassignmentOpVariant::ShlEquals => "lsh",
-            ReassignmentOpVariant::ShrEquals => "rsh",
+            AssignmentOpVariant::Equals => "eq",
+            AssignmentOpVariant::AddEquals => "add",
+            AssignmentOpVariant::SubEquals => "subtract",
+            AssignmentOpVariant::MulEquals => "multiply",
+            AssignmentOpVariant::DivEquals => "divide",
+            AssignmentOpVariant::ShlEquals => "lsh",
+            AssignmentOpVariant::ShrEquals => "rsh",
         }
     }
 
     pub fn as_str(&self) -> &'static str {
         match self {
-            ReassignmentOpVariant::Equals => EqToken::AS_STR,
-            ReassignmentOpVariant::AddEquals => AddEqToken::AS_STR,
-            ReassignmentOpVariant::SubEquals => SubEqToken::AS_STR,
-            ReassignmentOpVariant::MulEquals => StarEqToken::AS_STR,
-            ReassignmentOpVariant::DivEquals => DivEqToken::AS_STR,
-            ReassignmentOpVariant::ShlEquals => ShlEqToken::AS_STR,
-            ReassignmentOpVariant::ShrEquals => ShrEqToken::AS_STR,
+            AssignmentOpVariant::Equals => EqToken::AS_STR,
+            AssignmentOpVariant::AddEquals => AddEqToken::AS_STR,
+            AssignmentOpVariant::SubEquals => SubEqToken::AS_STR,
+            AssignmentOpVariant::MulEquals => StarEqToken::AS_STR,
+            AssignmentOpVariant::DivEquals => DivEqToken::AS_STR,
+            AssignmentOpVariant::ShlEquals => ShlEqToken::AS_STR,
+            AssignmentOpVariant::ShrEquals => ShrEqToken::AS_STR,
         }
     }
 }
@@ -611,7 +611,7 @@ impl Expr {
             | Expr::GreaterThanEq { .. }
             | Expr::LogicalAnd { .. }
             | Expr::LogicalOr { .. }
-            | Expr::Reassignment { .. }
+            | Expr::Assignment { .. }
             | Expr::Break { .. }
             | Expr::Continue { .. } => false,
         }
@@ -663,7 +663,7 @@ impl Expr {
             Expr::GreaterThanEq { .. } => "greater than or equal operation",
             Expr::LogicalAnd { .. } => "logical and",
             Expr::LogicalOr { .. } => "logical or",
-            Expr::Reassignment { .. } => "reassignment",
+            Expr::Assignment { .. } => "assignment",
             Expr::Break { .. } => "break",
             Expr::Continue { .. } => "continue",
         }

sway-core/src/control_flow_analysis/analyze_return_paths.rs

@@ -199,6 +199,9 @@ fn connect_node<'eng: 'cfg, 'cfg>(
                 }
                 Ok(NodeConnection::NextStep(Some(entry_node)))
             }
+            ty::TyStatement::Use(_) | ty::TyStatement::Mod(_) => {
+                Ok(NodeConnection::NextStep(leaf_opt))
+            }
         },
         ty::TyAstNodeContent::SideEffect(_) => Ok(NodeConnection::NextStep(leaf_opt)),
         ty::TyAstNodeContent::Declaration(decl) => Ok(NodeConnection::NextStep(