fix: list clause guard for final clause needs to use list accessor

crates/aiken-lang/src/gen_uplc2.rs

@@ -1509,8 +1509,7 @@ impl<'a> CodeGenerator<'a> {
                 let elems = elements
                     .iter()
                     .enumerate()
-                    .zip(defined_tails.iter())
+                    .map(|(index, elem)| {
-                    .map(|((index, elem), tail)| {
                         let elem_name = match elem {
                             Pattern::Var { name, .. } => name.to_string(),
                             Pattern::Assign { name, .. } => name.to_string(),
@@ -1535,26 +1534,22 @@ impl<'a> CodeGenerator<'a> {
 
                         *complex_clause = *complex_clause || elem_props.complex_clause;
 
-                        (tail, elem_name, statement)
+                        (elem_name, statement)
                     })
                     .collect_vec();
 
-                let defined_tail_heads = elems
+                let mut defined_heads =
-                    .iter()
+                    elems.iter().map(|(head, _)| head.to_string()).collect_vec();
-                    .map(|(tail, head, _)| (tail.to_string(), head.to_string()))
-                    .collect_vec();
 
                 let mut air_elems = elems
                     .into_iter()
-                    .map(|(_, _, statement)| statement)
+                    .map(|(_, statement)| statement)
                     .collect_vec();
 
                 let mut list_tail = None;
 
                 tail.iter().for_each(|elem| {
-                    let tail = defined_tails
+                    let tail = defined_tails.last().cloned().unwrap_or_default();
-                        .last()
-                        .unwrap_or_else(|| panic!("WHERE IS THE TAIL???"));
                     let elem_name = match elem.as_ref() {
                         Pattern::Var { name, .. } => name.to_string(),
                         Pattern::Assign { name, .. } => name.to_string(),
@@ -1578,15 +1573,28 @@ impl<'a> CodeGenerator<'a> {
                     *complex_clause = *complex_clause || elem_props.complex_clause;
 
                     air_elems.push(statement);
-                    list_tail = Some((tail.to_string(), elem_name));
+                    list_tail = Some((tail, elem_name.to_string()));
+                    defined_heads.push(elem_name)
                 });
 
-                let list_assign = AirTree::list_expose(
+                let list_assign = if props.final_clause {
-                    defined_tail_heads,
+                    AirTree::list_access(
+                        defined_heads,
+                        subject_tipo.clone(),
+                        tail.is_some(),
+                        false,
+                        AirTree::local_var(&props.original_subject_name, subject_tipo.clone()),
+                    )
+                } else {
+                    AirTree::list_expose(
+                        defined_heads
+                            .into_iter()
+                            .zip(defined_tails.into_iter())
+                            .collect_vec(),
                         list_tail,
                         subject_tipo.clone(),
-                    AirTree::local_var(&props.original_subject_name, subject_tipo.clone()),
+                    )
-                );
+                };
 
                 let mut sequence = vec![list_assign];
 

crates/aiken-lang/src/gen_uplc2/tree.rs

@@ -80,7 +80,6 @@ pub enum AirStatement {
         tipo: Arc<Type>,
         tail_head_names: Vec<(String, String)>,
         tail: Option<(String, String)>,
-        list: Box<AirTree>,
     },
     // Tuple Access
     TupleAccessor {
@@ -614,14 +613,12 @@ impl AirTree {
         tail_head_names: Vec<(String, String)>,
         tail: Option<(String, String)>,
         tipo: Arc<Type>,
-        list: AirTree,
     ) -> AirTree {
         AirTree::Statement {
             statement: AirStatement::ListExpose {
                 tipo,
                 tail_head_names,
                 tail,
-                list: list.into(),
             },
             hoisted_over: None,
         }
@@ -854,14 +851,12 @@ impl AirTree {
                         tipo,
                         tail_head_names,
                         tail,
-                        list,
                     } => {
                         air_vec.push(Air::ListExpose {
                             tipo: tipo.clone(),
                             tail_head_names: tail_head_names.clone(),
                             tail: tail.clone(),
                         });
-                        list.create_air_vec(air_vec);
                     }
                     AirStatement::TupleAccessor {
                         names,