fix errors

crates/aiken-lang/src/ast.rs

@@ -1119,6 +1119,9 @@ impl Annotation {
                 elems.iter().find_map(|arg| arg.find_node(byte_index))
             }
             Annotation::Var { .. } | Annotation::Hole { .. } => None,
+            Annotation::Pair { fst, snd, .. } => fst
+                .find_node(byte_index)
+                .or_else(|| snd.find_node(byte_index)),
         };
 
         located.or(Some(Located::Annotation(self)))

crates/aiken-lang/src/gen_uplc.rs

@@ -372,15 +372,6 @@ impl<'a> CodeGenerator<'a> {
                             },
                         ..
                     } => {
-                        if tipo.is_pair() {
-                            assert!(args.len() == 2);
-
-                            let arg1 = self.build(&args[0].value, module_build_name, &[]);
-
-                            let arg2 = self.build(&args[1].value, module_build_name, &[]);
-
-                            AirTree::pair(arg1, arg2, tipo.clone())
-                        } else {
                         let data_type = lookup_data_type_by_tipo(&self.data_types, tipo)
                             .expect("Creating a record with no record definition.");
 
@@ -408,7 +399,6 @@ impl<'a> CodeGenerator<'a> {
 
                         AirTree::create_constr(constr_index, constr_tipo.clone(), constr_args)
                     }
-                    }
 
                     TypedExpr::Var {
                         constructor:
@@ -659,12 +649,6 @@ impl<'a> CodeGenerator<'a> {
                 } => {
                     if check_replaceable_opaque_type(&record.tipo(), &self.data_types) {
                         self.build(record, module_build_name, &[])
-                    } else if record.tipo().is_pair() {
-                        AirTree::pair_index(
-                            *index,
-                            tipo.clone(),
-                            self.build(record, module_build_name, &[]),
-                        )
                     } else {
                         let function_name = format!("__access_index_{}", *index);
 
@@ -714,19 +698,7 @@ impl<'a> CodeGenerator<'a> {
                         field_map,
                         ..
                     } => {
-                        let val_constructor = if tipo.is_pair() {
-                            ValueConstructor::public(
-                                tipo.clone(),
-                                ValueConstructorVariant::Record {
-                                    module: "".into(),
-                                    name: name.clone(),
-                                    field_map: field_map.clone(),
-                                    arity: 2,
-                                    location: Span::empty(),
-                                    constructors_count: 1,
-                                },
-                            )
-                        } else {
+                        let val_constructor = {
                             let data_type = lookup_data_type_by_tipo(&self.data_types, tipo);
 
                             ValueConstructor::public(
@@ -792,6 +764,13 @@ impl<'a> CodeGenerator<'a> {
                 TypedExpr::TupleIndex {
                     index, tuple, tipo, ..
                 } => {
+                    if tuple.tipo().is_pair() {
+                        AirTree::pair_index(
+                            *index,
+                            tipo.clone(),
+                            self.build(tuple, module_build_name, &[]),
+                        )
+                    } else {
                         let function_name = format!("__access_index_{}", *index);
 
                         if self.code_gen_functions.get(&function_name).is_none() {
@@ -822,45 +801,13 @@ impl<'a> CodeGenerator<'a> {
                             self.build(tuple, module_build_name, &[]),
                         )
                     }
+                }
 
                 TypedExpr::ErrorTerm { tipo, .. } => AirTree::error(tipo.clone(), false),
 
                 TypedExpr::RecordUpdate {
                     tipo, spread, args, ..
                 } => {
-                    if tipo.is_pair() {
-                        assert!(args.len() == 1);
-
-                        let Some(arg) = args.first() else {
-                            unreachable!("Pair update with no arguments")
-                        };
-
-                        let arg_val = self.build(&arg.value, module_build_name, &[]);
-
-                        let other_pair = self.build(spread, module_build_name, &[]);
-
-                        if arg.index == 0 {
-                            AirTree::pair(
-                                arg_val,
-                                AirTree::pair_index(
-                                    1,
-                                    tipo.get_inner_types()[1].clone(),
-                                    other_pair,
-                                ),
-                                tipo.clone(),
-                            )
-                        } else {
-                            AirTree::pair(
-                                AirTree::pair_index(
-                                    0,
-                                    tipo.get_inner_types()[0].clone(),
-                                    other_pair,
-                                ),
-                                arg_val,
-                                tipo.clone(),
-                            )
-                        }
-                    } else {
                     let mut index_types = vec![];
                     let mut update_args = vec![];
 
@@ -888,7 +835,6 @@ impl<'a> CodeGenerator<'a> {
                         update_args,
                     )
                 }
-                }
                 TypedExpr::UnOp { value, op, .. } => {
                     AirTree::unop(*op, self.build(value, module_build_name, &[]))
                 }
@@ -4521,8 +4467,9 @@ impl<'a> CodeGenerator<'a> {
                     arg_vec.push(arg_stack.pop().unwrap());
                 }
 
-                let tipo = match tipo.as_ref() {
+                let ret_tipo = match tipo.as_ref() {
                     Type::Fn { ret, .. } => ret,
+                    // In this case the Air Opcode only holds the return type and not the function type
                     _ => &tipo,
                 };
 
@@ -4537,11 +4484,11 @@ impl<'a> CodeGenerator<'a> {
                     }
 
                     DefaultFunction::FstPair | DefaultFunction::SndPair => {
-                        builder::undata_builtin(&func, count, tipo, arg_vec)
+                        builder::undata_builtin(&func, count, ret_tipo, arg_vec)
                     }
 
                     DefaultFunction::HeadList if !tipo.is_pair() => {
-                        builder::undata_builtin(&func, count, tipo, arg_vec)
+                        builder::undata_builtin(&func, count, ret_tipo, arg_vec)
                     }
 
                     DefaultFunction::MkCons | DefaultFunction::MkPairData => {

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

@@ -937,7 +937,7 @@ impl AirTree {
         }
     }
 
-    pub fn pair_index(index: u64, tipo: Rc<Type>, tuple: AirTree) -> AirTree {
+    pub fn pair_index(index: usize, tipo: Rc<Type>, tuple: AirTree) -> AirTree {
         AirTree::cast_from_data(
             AirTree::builtin(
                 if index == 0 {

crates/aiken-project/src/tests/gen_uplc.rs

@@ -2143,7 +2143,7 @@ fn acceptance_test_23_to_list() {
             when elems is {
             [] ->
                 [Pair(k, v)]
-            [Pair { fst: k2, snd: v2 }, ..rest] ->
+            [Pair(k2, v2), ..rest] ->
                 if k == k2 {
                   [Pair(k, v), ..rest]
                 } else {
@@ -2159,7 +2159,7 @@ fn acceptance_test_23_to_list() {
         }
         
         test to_list_2() {
-            to_list(fixture_1()) == [Pair("foo", 42), Pair("bar", 14)]
+            to_list(fixture_1()) == [Pair("foo", 42).2nd, Pair("bar", 14)]
         }
     "#;
 
@@ -2996,8 +2996,6 @@ fn acceptance_test_28_unique_list() {
 #[test]
 fn acceptance_test_29_union_pair() {
     let src = r#"
-      type Map<a,b> = List<Pair<a,b>>
-
       pub opaque type AssocList<key, value> {
         inner: Map<key, value>,
       }
@@ -3054,7 +3052,7 @@ fn acceptance_test_29_union_pair() {
         when left is {
           [] ->
             right
-          [Pair{fst: k, snd: v}, ..rest] ->
+          [Pair(k, v), ..rest] ->
             do_union(rest, do_insert(right, k, v))
         }
       }