waalge
/
aiken
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix generics causing a free unique due to ordering in expect_type

This commit is contained in:
Kasey White 2023-04-08 14:17:42 -04:00 committed by Kasey
parent 581c86ed83
commit 9d9f8a914a
2 changed files with 92 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
crates/aiken-lang/src/gen_uplc.rs
View File

@ -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(),

23
crates/aiken-lang/src/gen_uplc/builder.rs
View File

@ -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
.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(),