From 9d9f8a914a93e4dec9e279f038f66e1057774414 Mon Sep 17 00:00:00 2001 From: Kasey White Date: Sat, 8 Apr 2023 14:17:42 -0400 Subject: [PATCH] fix generics causing a free unique due to ordering in expect_type --- crates/aiken-lang/src/gen_uplc.rs | 79 ++++++++++++++++++++++- crates/aiken-lang/src/gen_uplc/builder.rs | 23 +++++-- 2 files changed, 92 insertions(+), 10 deletions(-) diff --git a/crates/aiken-lang/src/gen_uplc.rs b/crates/aiken-lang/src/gen_uplc.rs index 544109ea..b9ab776d 100644 --- a/crates/aiken-lang/src/gen_uplc.rs +++ b/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> = 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(), diff --git a/crates/aiken-lang/src/gen_uplc/builder.rs b/crates/aiken-lang/src/gen_uplc/builder.rs index 70b02564..38729449 100644 --- a/crates/aiken-lang/src/gen_uplc/builder.rs +++ b/crates/aiken-lang/src/gen_uplc/builder.rs @@ -1440,29 +1440,31 @@ pub fn handle_func_dependencies( to_be_defined: &mut IndexMap, id_gen: Rc, ) { - 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 - .dependencies - .extend(depend_comp.dependencies.clone().into_iter()); + dependency_map.insert(dependency, ()); } 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(),