fix generics causing a free unique due to ordering in expect_type

crates/aiken-lang/src/gen_uplc.rs

@@ -20,6 +20,7 @@ use crate::{
     },
     builtins::{bool, data},
     expr::TypedExpr,
+    gen_uplc::builder::{find_and_replace_generics, get_generic_id_and_type},
     tipo::{
         ModuleValueConstructor, PatternConstructor, Type, TypeInfo, ValueConstructor,
         ValueConstructorVariant,
@@ -113,6 +114,10 @@ impl<'a> CodeGenerator<'a> {
 
         self.convert_opaque_type_to_inner_ir(&mut ir_stack);
 
+        println!("{:#?}", self.code_gen_functions);
+
+        println!("{:#?}", ir_stack);
+
         let mut term = self.uplc_code_gen(&mut ir_stack);
 
         if let Some(other) = other_fun {
@@ -167,6 +172,8 @@ impl<'a> CodeGenerator<'a> {
 
         self.convert_opaque_type_to_inner_ir(&mut ir_stack);
 
+        println!("{:#?}", ir_stack);
+
         let term = self.uplc_code_gen(&mut ir_stack);
 
         self.finalize(term)
@@ -187,6 +194,8 @@ impl<'a> CodeGenerator<'a> {
             term,
         };
 
+        println!("{}", program.to_pretty());
+
         program = aiken_optimize_and_intern(program);
 
         // This is very important to call here.
@@ -2298,6 +2307,12 @@ impl<'a> CodeGenerator<'a> {
                 );
             }
 
+            if let Some(counter) = defined_data_types.get_mut(EXPECT_ON_LIST) {
+                *counter += 1
+            } else {
+                defined_data_types.insert(EXPECT_ON_LIST.to_string(), 1);
+            }
+
             expect_stack.expect_list_from_data(tipo.clone(), name, unwrap_function_stack);
 
             expect_stack.void();
@@ -2336,6 +2351,12 @@ impl<'a> CodeGenerator<'a> {
                 );
             }
 
+            if let Some(counter) = defined_data_types.get_mut(EXPECT_ON_LIST) {
+                *counter += 1
+            } else {
+                defined_data_types.insert(EXPECT_ON_LIST.to_string(), 1);
+            }
+
             expect_stack.expect_list_from_data(tipo.clone(), name, unwrap_function_stack);
 
             expect_stack.void();
@@ -2373,6 +2394,9 @@ impl<'a> CodeGenerator<'a> {
             let data_type =
                 builder::lookup_data_type_by_tipo(self.data_types.clone(), &tipo).unwrap();
 
+            println!("NAME IS {} AND TYPE IS {:#?}", name, tipo);
+            println!("DATATYPE IS {:#?}", data_type);
+
             let new_id = self.id_gen.next();
 
             let mut var_stack = expect_stack.empty_with_scope();
@@ -2386,6 +2410,18 @@ impl<'a> CodeGenerator<'a> {
             if function.is_none() && defined_data_types.get(&data_type_name).is_none() {
                 defined_data_types.insert(data_type_name.clone(), 1);
 
+                let mono_types: IndexMap<u64, Arc<Type>> = if !data_type.typed_parameters.is_empty()
+                {
+                    data_type
+                        .typed_parameters
+                        .iter()
+                        .zip(tipo.arg_types().unwrap())
+                        .flat_map(|item| get_generic_id_and_type(item.0, &item.1))
+                        .collect()
+                } else {
+                    vec![].into_iter().collect()
+                };
+
                 let current_defined_state = defined_data_types.clone();
                 let mut diff_defined_types = IndexMap::new();
 
@@ -2406,7 +2442,10 @@ impl<'a> CodeGenerator<'a> {
                                 .clone()
                                 .unwrap_or(format!("__field_{index}_{new_id}"));
 
-                            (index, arg_name, arg.tipo.clone())
+                            let mut arg_tipo = arg.tipo.clone();
+
+                            find_and_replace_generics(&mut arg_tipo, &mono_types);
+                            (index, arg_name, arg_tipo)
                         })
                         .collect_vec();
 
@@ -2450,6 +2489,7 @@ impl<'a> CodeGenerator<'a> {
                             diff_defined_types.insert(inner_data_type.to_string(), *inner_count);
                         }
                     }
+                    println!("DIFF DEFINED TYPES {:#?}", diff_defined_types);
 
                     arg_stack.void();
 
@@ -2499,7 +2539,7 @@ impl<'a> CodeGenerator<'a> {
                             .collect_vec(),
                     ),
                 );
-            } else if defined_data_types.get(&data_type_name).is_some() && function.is_none() {
+            } else if defined_data_types.get(&data_type_name).is_some() {
                 let Some(counter) = defined_data_types.get_mut(&data_type_name)
                 else {
                     unreachable!();
@@ -2709,12 +2749,43 @@ impl<'a> CodeGenerator<'a> {
                 .collect_vec(),
         );
 
+        println!("DEPENDENCY VEC IS {:#?}", dependency_vec);
+        println!("FUNC INDEX MAP IS {:#?}", func_index_map);
+
         for func in dependency_vec {
             if self.defined_functions.contains_key(&func) {
                 continue;
             }
-            let function_component = function_definitions.get(&func).unwrap();
+
             let func_scope = func_index_map.get(&func).unwrap();
+            println!("FUNC IS {:#?}", func);
+            println!("FUNC SCOPE IS {:#?}", func_scope);
+
+            let mut added_dependencies = vec![];
+
+            for same_scope_func in func_index_map
+                .iter()
+                .filter(|item| item.1 == func_scope && &func != item.0)
+                .map(|item| item.0)
+            {
+                added_dependencies.push(same_scope_func.clone());
+                let same_scope_func_dependencies = function_definitions
+                    .get(same_scope_func)
+                    .unwrap()
+                    .dependencies
+                    .clone();
+                added_dependencies.extend(same_scope_func_dependencies.iter().cloned())
+            }
+
+            let Some(function_component) = function_definitions.get_mut(&func)
+            else {
+                unreachable!("Function Definition should exist");
+            };
+
+            function_component.dependencies.extend(added_dependencies);
+            function_component.dependencies.dedup();
+
+            let function_component = function_definitions.get(&func).unwrap();
 
             let mut dep_ir = vec![];
 
@@ -4922,6 +4993,8 @@ impl<'a> CodeGenerator<'a> {
 
                 replace_opaque_type(&mut actual_type, self.data_types.clone());
 
+                println!("ACTUAL TYPE IS {:#?}", actual_type);
+
                 self.assignment(
                     &Pattern::Var {
                         location: Span::empty(),

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

@@ -1440,29 +1440,31 @@ pub fn handle_func_dependencies(
     to_be_defined: &mut IndexMap<FunctionAccessKey, ()>,
     id_gen: Rc<IdGenerator>,
 ) {
-    let mut function_component = function_component.clone();
+    let function_component = function_component.clone();
+
+    let mut function_dependency_order = function_component.dependencies.clone();
 
     let mut dependency_map = IndexMap::new();
     let mut dependency_vec = vec![];
 
     // deal with function dependencies by sorting order in which we pop them.
-    while let Some(dependency) = function_component.dependencies.pop() {
+    while let Some(dependency) = function_dependency_order.pop() {
         let depend_comp = func_components.get(&dependency).unwrap();
 
         if dependency_map.contains_key(&dependency) {
             dependency_map.shift_remove(&dependency);
         }
 
-        dependency_map.insert(dependency, ());
+        function_dependency_order.extend(depend_comp.dependencies.iter().cloned().collect_vec());
 
-        function_component
+        dependency_map.insert(dependency, ());
-            .dependencies
-            .extend(depend_comp.dependencies.clone().into_iter());
     }
 
     dependency_vec.extend(dependency_map.keys().cloned());
     dependency_vec.reverse();
 
+    println!("HANDLE FUNC DEP VEC {:#?}", dependency_vec);
+
     while let Some(dependency) = dependency_vec.pop() {
         let func_component_dep = func_components.get(&dependency);
 
@@ -1472,7 +1474,13 @@ pub fn handle_func_dependencies(
 
         let Some(depend_comp) = func_component_dep else {continue};
 
-        let dep_scope = func_index_map.get(&dependency).unwrap();
+        let dep_scope = func_index_map
+            .get(&dependency)
+            .unwrap_or_else(|| unreachable!());
+
+        println!("THING @ {:#?}", depend_comp.ir);
+
+        println!("FUNC DEFINE IS {:#?}", function_component.ir[0]);
 
         if (dep_scope.common_ancestor(func_scope) == *func_scope && !depend_comp.args.is_empty())
             || function_component.args.is_empty()
@@ -1494,6 +1502,7 @@ pub fn handle_func_dependencies(
 
             if depend_comp.is_code_gen_func {
                 temp_stack = recursion_stack;
+                println!("TEMP STACK IS {:#?}", temp_stack);
             } else {
                 temp_stack.define_func(
                     dependency.function_name.clone(),