fix: Analyze assigned expr before bound variables

Let statements can redefine a variable. This variable can occur inside
the assigned expression. The assigned expression must be analyzed with
the old variable bindings (and types) before the variable bindings are
updated.

Assert correctness in a unit test.

Author: uncomputable

src/ast.rs

@@ -634,11 +634,11 @@ impl AbstractSyntaxTree for Assignment {
         // However, the expression evaluated in the assignment does have a type,
         // namely the type specified in the assignment.
         let ty_expr = scope.resolve(&from.ty).with_span(from)?;
+        let expression = Expression::analyze(&from.expression, &ty_expr, scope)?;
         let typed_variables = from.pattern.is_of_type(&ty_expr).with_span(from)?;
         for (identifier, ty) in typed_variables {
             scope.insert_variable(identifier, ty);
         }
-        let expression = Expression::analyze(&from.expression, &ty_expr, scope)?;
 
         Ok(Self {
             pattern: from.pattern.clone(),

src/lib.rs

@@ -107,7 +107,12 @@ mod tests {
                 panic!("{error}")
             }
         };
-        let redeem_prog = match satisfy(&prog_text, &witness) {
+
+        assert_success(&prog_text, &witness);
+    }
+
+    fn assert_success(prog_text: &str, witness: &WitnessValues) {
+        let redeem_prog = match satisfy(prog_text, witness) {
             Ok(x) => x,
             Err(error) => {
                 panic!("{error}");
@@ -120,10 +125,24 @@ mod tests {
         dbg!(&redeem_prog);
         println!("{}", Base64Display::new(&vec, &STANDARD));
 
-        let mut bit_mac = BitMachine::for_program(&redeem_prog);
+        let mut mac = BitMachine::for_program(&redeem_prog);
         let env = dummy_env::dummy();
-        bit_mac
-            .exec(&redeem_prog, &env)
+        mac.exec(&redeem_prog, &env)
             .expect("Machine execution failure");
     }
+
+    fn assert_success_empty_witness(prog_text: &str) {
+        let witness = WitnessValues::empty();
+        assert_success(prog_text, &witness)
+    }
+
+    #[test]
+    fn redefined_variable() {
+        let prog_text = r#"fn main() {
+    let beefbabe: (u16, u16) = (0xbeef, 0xbabe);
+    let beefbabe: u32 = <(u16, u16)>::into(beefbabe);
+}
+"#;
+        assert_success_empty_witness(prog_text);
+    }
 }