Write to array and struct members.

This is supported with a new pass, `WriteTransforming`,
which converts assignments to struct or array members
into assignments to variables, and any time the
struct or array is accessed, reconstructs it
from the variables.

Tests for this functionality are in `array_write.leo`.

Also fixed the test `assign_fail.leo`, which seems to have been
in a useless state for a long time.

Fixes #28389, #28430

Author: mikebenfield

compiler/ast/src/expressions/literal.rs

@@ -101,6 +101,14 @@ impl Literal {
     pub fn display_decimal(&self) -> impl '_ + fmt::Display {
         DisplayDecimal(self)
     }
+
+    pub fn as_u32(&self) -> Option<u32> {
+        if let LiteralVariant::Integer(_, s) = &self.variant {
+            u32::from_str_by_radix(&s.replace("_", "")).ok()
+        } else {
+            panic!("");
+        }
+    }
 }
 
 impl fmt::Display for DisplayDecimal<'_> {

compiler/compiler/src/compiler.rs

@@ -187,6 +187,10 @@ impl<N: Network> Compiler<N> {
 
         self.do_pass::<SsaForming>(SsaFormingInput { rename_defs: false })?;
 
+        self.do_pass::<WriteTransforming>(())?;
+
+        self.do_pass::<SsaForming>(SsaFormingInput { rename_defs: false })?;
+
         self.do_pass::<Flattening>(())?;
 
         self.do_pass::<FunctionInlining>(())?;

compiler/passes/src/const_propagation/statement.rs

@@ -54,7 +54,9 @@ impl StatementReconstructor for ConstPropagationVisitor<'_> {
     }
 
     fn reconstruct_assign(&mut self, assign: AssignStatement) -> (Statement, Self::AdditionalOutput) {
-        (AssignStatement { value: self.reconstruct_expression(assign.value).0, ..assign }.into(), None)
+        let value = self.reconstruct_expression(assign.value).0;
+        let place = self.reconstruct_expression(assign.place).0;
+        (AssignStatement { value, place, ..assign }.into(), None)
     }
 
     fn reconstruct_block(&mut self, mut block: Block) -> (Block, Self::AdditionalOutput) {

compiler/passes/src/destructuring/statement.rs

@@ -40,72 +40,83 @@ impl StatementReconstructor for DestructuringVisitor<'_> {
     fn reconstruct_assign(&mut self, mut assign: AssignStatement) -> (Statement, Self::AdditionalOutput) {
         let (value, mut statements) = self.reconstruct_expression(assign.value);
 
-        match assign.place {
-            Expression::Identifier(identifier) => {
-                if let Type::Tuple(tuple_type) =
-                    self.state.type_table.get(&value.id()).expect("Expressions should have types.")
-                {
-                    // It's a variable of tuple type. Aleo VM doesn't know about tuples, so
-                    // we'll need to handle this.
-                    let new_symbol = self.state.assigner.unique_symbol(identifier, "##");
-                    let new_identifier = Identifier::new(new_symbol, self.state.node_builder.next_id());
-                    self.state.type_table.insert(new_identifier.id(), Type::Tuple(tuple_type.clone()));
-
-                    let identifiers = self.tuples.get(&identifier.name).expect("Tuple should have been encountered.");
-
-                    let Expression::Identifier(rhs) = value else {
-                        panic!("SSA should have ensured this is an identifier.");
-                    };
-
-                    let rhs_identifiers = self.tuples.get(&rhs.name).expect("Tuple should have been encountered.");
+        if let Expression::Identifier(identifier) = assign.place {
+            if let Type::Tuple(tuple_type) =
+                self.state.type_table.get(&value.id()).expect("Expressions should have types.")
+            {
+                // It's a variable of tuple type. Aleo VM doesn't know about tuples, so
+                // we'll need to handle this.
+                let new_symbol = self.state.assigner.unique_symbol(identifier, "##");
+                let new_identifier = Identifier::new(new_symbol, self.state.node_builder.next_id());
+                self.state.type_table.insert(new_identifier.id(), Type::Tuple(tuple_type.clone()));
+
+                let identifiers = self.tuples.get(&identifier.name).expect("Tuple should have been encountered.");
+
+                let Expression::Identifier(rhs) = value else {
+                    panic!("SSA should have ensured this is an identifier.");
+                };
 
-                    // Again, make an assignment for each identifier.
-                    for (identifier, rhs_identifier) in identifiers.iter().zip_eq(rhs_identifiers) {
-                        let stmt = AssignStatement {
-                            place: (*identifier).into(),
-                            value: (*rhs_identifier).into(),
-                            id: self.state.node_builder.next_id(),
-                            span: Default::default(),
-                        }
-                        .into();
+                let rhs_identifiers = self.tuples.get(&rhs.name).expect("Tuple should have been encountered.");
 
-                        statements.push(stmt);
+                // Again, make an assignment for each identifier.
+                for (identifier, rhs_identifier) in identifiers.iter().zip_eq(rhs_identifiers) {
+                    let stmt = AssignStatement {
+                        place: (*identifier).into(),
+                        value: (*rhs_identifier).into(),
+                        id: self.state.node_builder.next_id(),
+                        span: Default::default(),
                     }
+                    .into();
 
-                    (Statement::dummy(), statements)
-                } else {
-                    assign.value = value;
-                    (assign.into(), statements)
+                    statements.push(stmt);
                 }
+
+                return (Statement::dummy(), statements);
             }
+        }
 
-            Expression::TupleAccess(access) => {
-                // We're assigning to a tuple member. Again, Aleo VM doesn't know about tuples,
-                // so we'll need to handle this.
-                let Expression::Identifier(identifier) = &access.tuple else {
-                    panic!("SSA should have ensured this is an identifier.");
-                };
+        // We may be assigning to a tuple access followed by struct or array accesses, like
+        // `tupl.1[2u8].mem = 5u8`
+        // So we need to loop and see if we find a tuple.
 
-                let tuple_ids = self.tuples.get(&identifier.name).expect("Tuple should have been encountered.");
+        assign.value = value;
+        let mut place = &mut assign.place;
 
-                // This is the correspondig variable name of the member we're assigning to.
-                let identifier = tuple_ids[access.index.value()];
+        loop {
+            match place {
+                Expression::TupleAccess(access) => {
+                    // We're assigning to a tuple member. Again, Aleo VM doesn't know about tuples,
+                    // so we'll need to handle this.
+                    let Expression::Identifier(identifier) = &access.tuple else {
+                        panic!("SSA should have ensured this is an identifier.");
+                    };
 
-                // So just assign to the variable.
-                let assign = AssignStatement {
-                    place: Expression::Identifier(identifier),
-                    value,
-                    span: Default::default(),
-                    id: self.state.node_builder.next_id(),
+                    let tuple_ids = self.tuples.get(&identifier.name).expect("Tuple should have been encountered.");
+
+                    // This is the corresponding variable name of the member we're assigning to.
+                    let identifier = tuple_ids[access.index.value()];
+
+                    *place = identifier.into();
+
+                    return (assign.into(), statements);
                 }
-                .into();
 
-                (assign, statements)
-            }
+                Expression::ArrayAccess(access) => {
+                    // We need to investigate the array, as maybe it's inside a tuple access, like `tupl.0[1u8]`.
+                    place = &mut access.array;
+                }
+
+                Expression::MemberAccess(access) => {
+                    // We need to investigate the struct, as maybe it's inside a tuple access, like `tupl.0.mem`.
+                    place = &mut access.inner;
+                }
+
+                Expression::Identifier(..) => {
+                    // There was no tuple access, so there's nothing to do.
+                    return (assign.into(), statements);
+                }
 
-            _ => {
-                assign.value = value;
-                (assign.into(), statements)
+                _ => panic!("Type checking should have prevented this."),
             }
         }
     }

compiler/passes/src/lib.rs

@@ -55,3 +55,6 @@ pub use symbol_table_creation::*;
 
 mod type_checking;
 pub use type_checking::*;
+
+mod write_transforming;
+pub use write_transforming::*;