feat: generate_test doesn't need arguments

crates/aiken-lang/src/uplc.rs

@@ -20,8 +20,8 @@ use uplc::{
 use crate::{
     air::Air,
     ast::{
-        ArgName, AssignmentKind, BinOp, Pattern, Span, TypedArg, TypedClause, TypedDataType,
+        ArgName, AssignmentKind, BinOp, Pattern, Span, TypedClause, TypedDataType, TypedFunction,
-        TypedFunction, TypedValidator, UnOp,
+        TypedValidator, UnOp,
     },
     builder::{
         check_replaceable_opaque_type, check_when_pattern_needs, constants_ir,
@@ -145,11 +145,7 @@ impl<'a> CodeGenerator<'a> {
         self.finalize(term, true)
     }
 
-    pub fn generate_test(
+    pub fn generate_test(&mut self, test_body: &TypedExpr) -> Program<Name> {
-        &mut self,
-        test_body: &TypedExpr,
-        arguments: &[TypedArg],
-    ) -> Program<Name> {
         let mut ir_stack = vec![];
         let scope = vec![self.id_gen.next()];
 
@@ -167,8 +163,6 @@ impl<'a> CodeGenerator<'a> {
             term = builder::constr_fields_exposer(term);
         }
 
-        term = wrap_validator_args(term, arguments);
-
         self.finalize(term, false)
     }
 

crates/aiken-project/src/lib.rs

@@ -675,12 +675,7 @@ where
         let mut programs = Vec::new();
 
         for (input_path, module_name, func_def) in scripts {
-            let Function {
+            let Function { name, body, .. } = func_def;
-                arguments,
-                name,
-                body,
-                ..
-            } = func_def;
 
             if verbose {
                 self.event_listener.handle_event(Event::GeneratingUPLCFor {
@@ -695,30 +690,27 @@ where
                 &self.module_types,
             );
 
-            let evaluation_hint = if let Some((bin_op, left_src, right_src)) = func_def.test_hint()
+            let evaluation_hint = func_def.test_hint().map(|(bin_op, left_src, right_src)| {
-            {
                 let left = generator
                     .clone()
-                    .generate_test(&left_src, &[])
+                    .generate_test(&left_src)
                     .try_into()
                     .unwrap();
 
                 let right = generator
                     .clone()
-                    .generate_test(&right_src, &[])
+                    .generate_test(&right_src)
                     .try_into()
                     .unwrap();
 
-                Some(EvalHint {
+                EvalHint {
                     bin_op,
                     left,
                     right,
-                })
+                }
-            } else {
+            });
-                None
-            };
 
-            let program = generator.generate_test(body, arguments);
+            let program = generator.generate_test(body);
 
             let script = Script::new(
                 input_path,