Implement mutability checks for references to aggregate type fields.

Fixes #6368.

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

@@ -2326,26 +2326,14 @@ impl ty::TyExpression {
         let expr = ty::TyExpression::type_check(handler, ctx, value)?;
 
         if to_mutable_value {
-            match expr.expression {
-                ty::TyExpressionVariant::ConstantExpression { .. } => {
-                    return Err(
-                        handler.emit_err(CompileError::RefMutCannotReferenceConstant {
-                            constant: expr_span.str(),
-                            span,
-                        }),
-                    )
-                }
-                ty::TyExpressionVariant::VariableExpression {
-                    name: decl_name,
-                    mutability: VariableMutability::Immutable,
-                    ..
-                } => {
-                    return Err(handler.emit_err(
-                        CompileError::RefMutCannotReferenceImmutableVariable { decl_name, span },
-                    ))
-                }
-                // TODO-IG: Check referencing parts of aggregates once reassignment is implemented.
-                _ => (),
+            if let Some(value) = Self::check_ref_mutability_mismatch(
+                &expr.expression,
+                handler,
+                expr_span,
+                span.clone(),
+                engines,
+            ) {
+                return value;
             }
         };
 
@@ -2366,6 +2354,57 @@ impl ty::TyExpression {
         Ok(typed_expr)
     }
 
+    fn check_ref_mutability_mismatch(
+        expr: &TyExpressionVariant,
+        handler: &Handler,
+        expr_span: Span,
+        ref_span: Span,
+        engines: &Engines,
+    ) -> Option<Result<TyExpression, ErrorEmitted>> {
+        match expr {
+            ty::TyExpressionVariant::ConstantExpression { .. } => {
+                return Some(Err(handler.emit_err(
+                    CompileError::RefMutCannotReferenceConstant {
+                        constant: expr_span.str(),
+                        span: ref_span,
+                    },
+                )))
+            }
+            ty::TyExpressionVariant::VariableExpression {
+                name: decl_name,
+                mutability: VariableMutability::Immutable,
+                ..
+            } => {
+                return Some(Err(handler.emit_err(
+                    CompileError::RefMutCannotReferenceImmutableVariable {
+                        decl_name: decl_name.clone(),
+                        span: ref_span,
+                    },
+                )))
+            }
+            ty::TyExpressionVariant::StructFieldAccess { ref prefix, .. } => {
+                return Self::check_ref_mutability_mismatch(
+                    &prefix.expression,
+                    handler,
+                    expr_span,
+                    ref_span,
+                    engines,
+                )
+            }
+            ty::TyExpressionVariant::TupleElemAccess { ref prefix, .. } => {
+                return Self::check_ref_mutability_mismatch(
+                    &prefix.expression,
+                    handler,
+                    expr_span,
+                    ref_span,
+                    engines,
+                )
+            }
+            _ => (),
+        }
+        None
+    }
+
     fn type_check_deref(
         handler: &Handler,
         mut ctx: TypeCheckContext<'_>,

test/src/e2e_vm_tests/test_programs/should_fail/language/references/references_to_mutable_values/src/main.sw

@@ -15,6 +15,10 @@ impl S {
     const X = 0;
 }
 
+struct S2 {
+    s: S,
+}
+
 fn function(f_x: u8) {
     let _ = &mut f_x;
 }
@@ -73,5 +77,18 @@ fn main() {
     }
 
     function(0);
+
+    // aggregates checking
+
+    let _ = &mut s.x;
+
+    let s2 = S2 { s: S { x: 0 } };
+
+    let _ = &mut s2.s.x;
+
+    let t : (u32, u32) = (0, 0);
+    let _ : &mut u32 = &mut t.0;
+
+    let _ = &mut { t }; // No error here.
 }
 

test/src/e2e_vm_tests/test_programs/should_fail/language/references/references_to_mutable_values/test.toml

@@ -93,3 +93,24 @@ category = "fail"
 #check: $()let _ = &mut n;
 #nextln: $()"n" is an immutable variable. `&mut` cannot reference immutable variables.
 #check: $()- referencing a mutable copy of "n", by returning it from a block: `&mut { n }`.
+
+#check: $()References to mutable values cannot reference immutable variables
+#check: $()let s = S { x: 0 };
+#nextln: $()Variable "s" is declared here as immutable.
+#check: $()let _ = &mut s.x;
+#nextln: $()"s" is an immutable variable. `&mut` cannot reference immutable variables.
+#check: $()- referencing a mutable copy of "s", by returning it from a block: `&mut { s }`.
+
+#check: $()References to mutable values cannot reference immutable variables
+#check: $()let s2 = S2 { s: S { x: 0 } };
+#nextln: $()Variable "s2" is declared here as immutable.
+#check: $()let _ = &mut s2.s.x;
+#nextln: $()"s2" is an immutable variable. `&mut` cannot reference immutable variables.
+#check: $()- referencing a mutable copy of "s2", by returning it from a block: `&mut { s2 }`.
+
+#check: $()References to mutable values cannot reference immutable variables
+#check: $()let t : (u32, u32) = (0, 0);
+#nextln: $()Variable "t" is declared here as immutable.
+#check: $()let _ : &mut u32 = &mut t.0;
+#nextln: $()"t" is an immutable variable. `&mut` cannot reference immutable variables.
+#check: $()- referencing a mutable copy of "t", by returning it from a block: `&mut { t }`.