chore: convert acceptance test 5

Also constructors with no fields are now converted to a constant data term.

crates/aiken-lang/src/gen_uplc.rs

@@ -3786,10 +3786,25 @@ impl<'a> CodeGenerator<'a> {
 
                             let fields = Term::empty_list();
 
-                            let term = Term::constr_data()
+                            let mut term = Term::constr_data()
                                 .apply(Term::integer(constr_index.try_into().unwrap()))
                                 .apply(fields);
 
+                            let mut program: Program<Name> = Program {
+                                version: (1, 0, 0),
+                                term,
+                            };
+
+                            let mut interner = Interner::new();
+
+                            interner.program(&mut program);
+
+                            let eval_program: Program<NamedDeBruijn> = program.try_into().unwrap();
+
+                            let evaluated_term: Term<NamedDeBruijn> =
+                                eval_program.eval(ExBudget::default()).result().unwrap();
+                            term = evaluated_term.try_into().unwrap();
+
                             arg_stack.push(term);
                         }
                     }

crates/aiken-project/src/blueprint/validator.rs

@@ -193,7 +193,7 @@ mod test {
     use uplc::{
         ast::{self as uplc_ast, Constant, Name},
         machine::cost_model::ExBudget,
-        optimize, BigInt, PlutusData,
+        optimize, BigInt, Constr, PlutusData,
     };
 
     use super::{
@@ -368,11 +368,8 @@ mod test {
             term: expected,
         };
 
-        println!("EXP BEFORE {}", expected.to_pretty());
-
         let expected = optimize::aiken_optimize_and_intern(expected);
 
-        println!("EXP AFTER {}", expected.to_pretty());
         let expected: Program<DeBruijn> = expected.try_into().unwrap();
 
         assert_eq!(debruijn_program.to_pretty(), expected.to_pretty());
@@ -804,6 +801,65 @@ mod test {
         );
     }
 
+    #[test]
+    fn acceptance_test_5_head_not_empty() {
+        let src = r#"
+          use aiken/builtin.{head_list}
+
+          pub fn head(xs: List<a>) -> Option<a> {
+            when xs is {
+              [] -> None
+              _ -> Some(head_list(xs))
+            }
+          }
+            
+          test head_1() {
+            head([1, 2, 3]) == Some(1)
+          }     
+        "#;
+
+        assert_uplc(
+            src,
+            Term::equals_data()
+                .apply(
+                    Term::var("head")
+                        .lambda("head")
+                        .apply(
+                            Term::var("xs")
+                                .delayed_choose_list(
+                                    Term::Constant(
+                                        Constant::Data(PlutusData::Constr(Constr {
+                                            tag: 122,
+                                            any_constructor: None,
+                                            fields: vec![],
+                                        }))
+                                        .into(),
+                                    ),
+                                    Term::constr_data().apply(Term::integer(0.into())).apply(
+                                        Term::mk_cons()
+                                            .apply(Term::head_list().apply(Term::var("xs")))
+                                            .apply(Term::empty_list()),
+                                    ),
+                                )
+                                .lambda("xs"),
+                        )
+                        .apply(Term::list_values(vec![
+                            Constant::Data(PlutusData::BigInt(BigInt::Int(1.into()))),
+                            Constant::Data(PlutusData::BigInt(BigInt::Int(2.into()))),
+                            Constant::Data(PlutusData::BigInt(BigInt::Int(3.into()))),
+                        ])),
+                )
+                .apply(Term::Constant(
+                    Constant::Data(PlutusData::Constr(Constr {
+                        tag: 121,
+                        any_constructor: None,
+                        fields: vec![PlutusData::BigInt(BigInt::Int(1.into()))],
+                    }))
+                    .into(),
+                )),
+        );
+    }
+
     #[test]
     fn mint_parameterized() {
         assert_validator(

crates/uplc/src/optimize/shrinker.rs

@@ -236,46 +236,20 @@ fn wrap_data_reduce(term: &mut Term<Name>) {
                 return;
             };
 
+            wrap_data_reduce(Rc::make_mut(inner_arg));
+
             match (first_action, second_action) {
-                (DefaultFunction::UnIData, DefaultFunction::IData) => {
+                (DefaultFunction::UnIData, DefaultFunction::IData)
-                    *term = argument.as_ref().clone();
+                | (DefaultFunction::IData, DefaultFunction::UnIData)
-                    wrap_data_reduce(term);
+                | (DefaultFunction::BData, DefaultFunction::UnBData)
-                }
+                | (DefaultFunction::UnBData, DefaultFunction::BData)
-                (DefaultFunction::IData, DefaultFunction::UnIData) => {
+                | (DefaultFunction::ListData, DefaultFunction::UnListData)
-                    *term = argument.as_ref().clone();
+                | (DefaultFunction::UnListData, DefaultFunction::ListData)
-                    wrap_data_reduce(term);
+                | (DefaultFunction::MapData, DefaultFunction::UnMapData)
-                }
+                | (DefaultFunction::UnMapData, DefaultFunction::MapData)
-                (DefaultFunction::BData, DefaultFunction::UnBData) => {
+                | (DefaultFunction::UnConstrData, DefaultFunction::ConstrData)
-                    *term = argument.as_ref().clone();
+                | (DefaultFunction::ConstrData, DefaultFunction::UnConstrData) => {
-                    wrap_data_reduce(term);
+                    *term = inner_arg.as_ref().clone();
-                }
-                (DefaultFunction::UnBData, DefaultFunction::BData) => {
-                    *term = argument.as_ref().clone();
-                    wrap_data_reduce(term);
-                }
-                (DefaultFunction::ListData, DefaultFunction::UnListData) => {
-                    *term = argument.as_ref().clone();
-                    wrap_data_reduce(term);
-                }
-                (DefaultFunction::UnListData, DefaultFunction::ListData) => {
-                    *term = argument.as_ref().clone();
-                    wrap_data_reduce(term);
-                }
-                (DefaultFunction::MapData, DefaultFunction::UnMapData) => {
-                    *term = argument.as_ref().clone();
-                    wrap_data_reduce(term);
-                }
-                (DefaultFunction::UnMapData, DefaultFunction::MapData) => {
-                    *term = argument.as_ref().clone();
-                    wrap_data_reduce(term);
-                }
-                (DefaultFunction::UnConstrData, DefaultFunction::ConstrData) => {
-                    *term = argument.as_ref().clone();
-                    wrap_data_reduce(term);
-                }
-                (DefaultFunction::ConstrData, DefaultFunction::UnConstrData) => {
-                    *term = argument.as_ref().clone();
-                    wrap_data_reduce(term);
                 }
                 _ => {}
             }

examples/acceptance_tests/005/lib/tests.ak

@@ -2,10 +2,8 @@ use aiken/builtin.{head_list}
 
 pub fn head(xs: List<a>) -> Option<a> {
   when xs is {
-    [] ->
+    [] -> None
-      None
+    _ -> Some(head_list(xs))
-    _ ->
-      Some(head_list(xs))
   }
 }