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

refactor: change codegen uplc to have more type safety 

Also refactor list_access_to_uplc
This commit is contained in:
microproofs 2024-01-08 14:06:29 -05:00 committed by Kasey
parent 7992a50bec
commit 2216f387c3
2 changed files with 318 additions and 458 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -3709,13 +3709,16 @@ impl<'a> CodeGenerator<'a> {
fn uplc_code_gen(&mut self, mut ir_stack: Vec<Air>) -> Term<Name> { fn uplc_code_gen(&mut self, mut ir_stack: Vec<Air>) -> Term<Name> {
let mut arg_stack: Vec<Term<Name>> = vec![]; let mut arg_stack: Vec<Term<Name>> = vec![];
while let Some(ir_element) = ir_stack.pop() { while let Some(air_element) = ir_stack.pop() {
self.gen_uplc(ir_element, &mut arg_stack); let arg = self.gen_uplc(air_element, &mut arg_stack);
if let Some(arg) = arg {
arg_stack.push(arg);
}
} }
arg_stack.pop().unwrap() arg_stack.pop().unwrap()
} }
fn gen_uplc(&mut self, ir: Air, arg_stack: &mut Vec<Term<Name>>) { fn gen_uplc(&mut self, ir: Air, arg_stack: &mut Vec<Term<Name>>) -> Option<Term<Name>> {
// Going to mark the changes made to code gen after air tree implementation // Going to mark the changes made to code gen after air tree implementation
let error_term = if self.tracing && air_holds_msg(&ir) { let error_term = if self.tracing && air_holds_msg(&ir) {
// In the case of an air that holds a msg and tracing is active // In the case of an air that holds a msg and tracing is active
@ -3728,29 +3731,20 @@ impl<'a> CodeGenerator<'a> {
}; };
match ir { match ir {
Air::Int { value } => { Air::Int { value } => Some(Term::integer(value.parse().unwrap())),
arg_stack.push(Term::integer(value.parse().unwrap())); Air::String { value } => Some(Term::string(value)),
} Air::ByteArray { bytes } => Some(Term::byte_string(bytes)),
Air::String { value } => { Air::Bool { value } => Some(Term::bool(value)),
arg_stack.push(Term::string(value));
}
Air::ByteArray { bytes } => {
arg_stack.push(Term::byte_string(bytes));
}
Air::Bool { value } => {
arg_stack.push(Term::bool(value));
}
Air::CurvePoint { point, .. } => match point { Air::CurvePoint { point, .. } => match point {
Curve::Bls12_381(Bls12_381Point::G1(g1)) => arg_stack.push(Term::bls12_381_g1(g1)), Curve::Bls12_381(Bls12_381Point::G1(g1)) => Some(Term::bls12_381_g1(g1)),
Curve::Bls12_381(Bls12_381Point::G2(g2)) => arg_stack.push(Term::bls12_381_g2(g2)), Curve::Bls12_381(Bls12_381Point::G2(g2)) => Some(Term::bls12_381_g2(g2)),
}, },
Air::Var { Air::Var {
name, name,
constructor, constructor,
variant_name, variant_name,
} => { } => match &constructor.variant {
match &constructor.variant { ValueConstructorVariant::LocalVariable { .. } => Some(Term::Var(
ValueConstructorVariant::LocalVariable { .. } => arg_stack.push(Term::Var(
Name { Name {
text: name, text: name,
unique: 0.into(), unique: 0.into(),
@ -3795,7 +3789,7 @@ impl<'a> CodeGenerator<'a> {
term term
} }
}; };
arg_stack.push(term); Some(term)
} }
ValueConstructorVariant::ModuleFn { ValueConstructorVariant::ModuleFn {
name: func_name, name: func_name,
@ -3825,7 +3819,7 @@ impl<'a> CodeGenerator<'a> {
let term = Term::var(cyclic_var_name).apply(arg_var); let term = Term::var(cyclic_var_name).apply(arg_var);
arg_stack.push(term); Some(term)
} else { } else {
let name = if (*func_name == name let name = if (*func_name == name
|| name == format!("{module}_{func_name}")) || name == format!("{module}_{func_name}"))
@ -3836,27 +3830,25 @@ impl<'a> CodeGenerator<'a> {
format!("{func_name}{variant_name}") format!("{func_name}{variant_name}")
}; };
arg_stack.push(Term::Var( Some(Term::Var(
Name { Name {
text: name, text: name,
unique: 0.into(), unique: 0.into(),
} }
.into(), .into(),
)); ))
} }
} }
ValueConstructorVariant::Record { ValueConstructorVariant::Record {
name: constr_name, .. name: constr_name, ..
} => { } => {
if constructor.tipo.is_bool() { if constructor.tipo.is_bool() {
arg_stack.push(Term::bool(constr_name == "True")); Some(Term::bool(constr_name == "True"))
} else if constructor.tipo.is_void() { } else if constructor.tipo.is_void() {
arg_stack.push(Term::Constant(UplcConstant::Unit.into())); Some(Term::Constant(UplcConstant::Unit.into()))
} else { } else {
let data_type = builder::lookup_data_type_by_tipo( let data_type =
&self.data_types, builder::lookup_data_type_by_tipo(&self.data_types, &constructor.tipo)
&constructor.tipo,
)
.unwrap(); .unwrap();
let (constr_index, constr_type) = data_type let (constr_index, constr_type) = data_type
@ -3882,8 +3874,7 @@ impl<'a> CodeGenerator<'a> {
interner.program(&mut program); interner.program(&mut program);
let eval_program: Program<NamedDeBruijn> = let eval_program: Program<NamedDeBruijn> = program.try_into().unwrap();
program.try_into().unwrap();
let evaluated_term: Term<NamedDeBruijn> = let evaluated_term: Term<NamedDeBruijn> =
eval_program.eval(ExBudget::default()).result().unwrap(); eval_program.eval(ExBudget::default()).result().unwrap();
@ -3912,12 +3903,11 @@ impl<'a> CodeGenerator<'a> {
) )
} }
} }
arg_stack.push(term); Some(term)
} }
} }
}; },
} Air::Void => Some(Term::Constant(UplcConstant::Unit.into())),
Air::Void => arg_stack.push(Term::Constant(UplcConstant::Unit.into())),
Air::List { count, tipo, tail } => { Air::List { count, tipo, tail } => {
let mut args = vec![]; let mut args = vec![];
@ -3978,7 +3968,7 @@ impl<'a> CodeGenerator<'a> {
) )
}; };
arg_stack.push(list); Some(list)
} else { } else {
let mut term = if tail { let mut term = if tail {
args.pop().unwrap() args.pop().unwrap()
@ -3999,7 +3989,7 @@ impl<'a> CodeGenerator<'a> {
}; };
term = Term::mk_cons().apply(list_item).apply(term); term = Term::mk_cons().apply(list_item).apply(term);
} }
arg_stack.push(term); Some(term)
} }
} }
Air::ListAccessor { Air::ListAccessor {
@ -4020,11 +4010,9 @@ impl<'a> CodeGenerator<'a> {
let mut id_list = vec![]; let mut id_list = vec![];
id_list.push(list_id); id_list.push(list_id);
for _ in 0..names.len() { names.iter().for_each(|_| {
id_list.push(self.id_gen.next()); id_list.push(self.id_gen.next());
} });
let names_empty = names.is_empty();
let names_types = tipo let names_types = tipo
.get_inner_types() .get_inner_types()
@ -4032,15 +4020,13 @@ impl<'a> CodeGenerator<'a> {
.cycle() .cycle()
.take(names.len()) .take(names.len())
.zip(names) .zip(names)
.map(|(tipo, name)| (name, tipo)) .zip(id_list)
.map(|((tipo, name), id)| (name, tipo, id))
.collect_vec(); .collect_vec();
if !names_empty {
term = builder::list_access_to_uplc( term = builder::list_access_to_uplc(
&names_types, &names_types,
&id_list,
tail, tail,
0,
term, term,
is_expect && !tail, is_expect && !tail,
true, true,
@ -4048,14 +4034,7 @@ impl<'a> CodeGenerator<'a> {
) )
.apply(value); .apply(value);
arg_stack.push(term); Some(term)
} else if is_expect {
term = value.delayed_choose_list(term, error_term);
arg_stack.push(term);
} else {
arg_stack.push(term);
}
} }
Air::ListExpose { Air::ListExpose {
tail_head_names, tail_head_names,
@ -4084,7 +4063,7 @@ impl<'a> CodeGenerator<'a> {
term = term.lambda(head_name).apply(head_list); term = term.lambda(head_name).apply(head_list);
} }
arg_stack.push(term); Some(term)
} }
Air::Fn { params } => { Air::Fn { params } => {
let mut term = arg_stack.pop().unwrap(); let mut term = arg_stack.pop().unwrap();
@ -4094,9 +4073,9 @@ impl<'a> CodeGenerator<'a> {
} }
if params.is_empty() { if params.is_empty() {
arg_stack.push(term.delay()) Some(term.delay())
} else { } else {
arg_stack.push(term); Some(term)
} }
} }
Air::Call { count, .. } => { Air::Call { count, .. } => {
@ -4108,7 +4087,7 @@ impl<'a> CodeGenerator<'a> {
term = term.apply(arg); term = term.apply(arg);
} }
arg_stack.push(term); Some(term)
} else { } else {
let term = arg_stack.pop().unwrap(); let term = arg_stack.pop().unwrap();
@ -4154,9 +4133,9 @@ impl<'a> CodeGenerator<'a> {
let evaluated_term: Term<NamedDeBruijn> = let evaluated_term: Term<NamedDeBruijn> =
eval_program.eval(ExBudget::max()).result().unwrap(); eval_program.eval(ExBudget::max()).result().unwrap();
arg_stack.push(evaluated_term.try_into().unwrap()); Some(evaluated_term.try_into().unwrap())
} else { } else {
arg_stack.push(term.force()) Some(term.force())
} }
} else { } else {
unreachable!("Shouldn't call anything other than var") unreachable!("Shouldn't call anything other than var")
@ -4206,7 +4185,7 @@ impl<'a> CodeGenerator<'a> {
} }
}; };
arg_stack.push(term); Some(term)
} }
Air::BinOp { Air::BinOp {
name, name,
@ -4244,15 +4223,13 @@ impl<'a> CodeGenerator<'a> {
right.if_then_else(Term::bool(false), Term::bool(true)), right.if_then_else(Term::bool(false), Term::bool(true)),
); );
arg_stack.push(term); return Some(term);
return;
} else if tipo.is_map() { } else if tipo.is_map() {
let term = builtin let term = builtin
.apply(Term::map_data().apply(left)) .apply(Term::map_data().apply(left))
.apply(Term::map_data().apply(right)); .apply(Term::map_data().apply(right));
arg_stack.push(term); return Some(term);
return;
} else if tipo.is_tuple() } else if tipo.is_tuple()
&& matches!(tipo.get_uplc_type(), UplcType::Pair(_, _)) && matches!(tipo.get_uplc_type(), UplcType::Pair(_, _))
{ {
@ -4264,19 +4241,17 @@ impl<'a> CodeGenerator<'a> {
Term::mk_cons().apply(right).apply(Term::empty_map()), Term::mk_cons().apply(right).apply(Term::empty_map()),
)); ));
arg_stack.push(term); return Some(term);
return;
} else if tipo.is_list() || tipo.is_tuple() { } else if tipo.is_list() || tipo.is_tuple() {
let term = builtin let term = builtin
.apply(Term::list_data().apply(left)) .apply(Term::list_data().apply(left))
.apply(Term::list_data().apply(right)); .apply(Term::list_data().apply(right));
arg_stack.push(term); return Some(term);
return;
} else if tipo.is_void() { } else if tipo.is_void() {
let term = left.choose_unit(right.choose_unit(Term::bool(true))); let term = left.choose_unit(right.choose_unit(Term::bool(true)));
arg_stack.push(term);
return; return Some(term);
} }
builtin.apply(left).apply(right) builtin.apply(left).apply(right)
@ -4290,16 +4265,14 @@ impl<'a> CodeGenerator<'a> {
right, right,
); );
arg_stack.push(term); return Some(term);
return;
} else if tipo.is_map() { } else if tipo.is_map() {
let term = builtin let term = builtin
.apply(Term::map_data().apply(left)) .apply(Term::map_data().apply(left))
.apply(Term::map_data().apply(right)) .apply(Term::map_data().apply(right))
.if_then_else(Term::bool(false), Term::bool(true)); .if_then_else(Term::bool(false), Term::bool(true));
arg_stack.push(term); return Some(term);
return;
} else if tipo.is_tuple() } else if tipo.is_tuple()
&& matches!(tipo.get_uplc_type(), UplcType::Pair(_, _)) && matches!(tipo.get_uplc_type(), UplcType::Pair(_, _))
{ {
@ -4312,19 +4285,16 @@ impl<'a> CodeGenerator<'a> {
)) ))
.if_then_else(Term::bool(false), Term::bool(true)); .if_then_else(Term::bool(false), Term::bool(true));
arg_stack.push(term); return Some(term);
return;
} else if tipo.is_list() || tipo.is_tuple() { } else if tipo.is_list() || tipo.is_tuple() {
let term = builtin let term = builtin
.apply(Term::list_data().apply(left)) .apply(Term::list_data().apply(left))
.apply(Term::list_data().apply(right)) .apply(Term::list_data().apply(right))
.if_then_else(Term::bool(false), Term::bool(true)); .if_then_else(Term::bool(false), Term::bool(true));
arg_stack.push(term); return Some(term);
return;
} else if tipo.is_void() { } else if tipo.is_void() {
arg_stack.push(Term::bool(false)); return Some(Term::bool(false));
return;
} }
builtin builtin
@ -4358,7 +4328,7 @@ impl<'a> CodeGenerator<'a> {
.apply(left) .apply(left)
.apply(right), .apply(right),
}; };
arg_stack.push(term); Some(term)
} }
Air::DefineFunc { Air::DefineFunc {
func_name, func_name,
@ -4388,7 +4358,7 @@ impl<'a> CodeGenerator<'a> {
if !recursive { if !recursive {
term = term.lambda(func_name).apply(func_body); term = term.lambda(func_name).apply(func_body);
arg_stack.push(term); Some(term)
} else { } else {
func_body = func_body.lambda(func_name.clone()); func_body = func_body.lambda(func_name.clone());
@ -4422,7 +4392,7 @@ impl<'a> CodeGenerator<'a> {
term = term.lambda(&func_name).apply(outer_func_body); term = term.lambda(&func_name).apply(outer_func_body);
} }
arg_stack.push(term); Some(term)
} }
} }
Air::DefineCyclicFuncs { Air::DefineCyclicFuncs {
@ -4469,7 +4439,7 @@ impl<'a> CodeGenerator<'a> {
.lambda(&func_name) .lambda(&func_name)
.apply(cyclic_body.lambda("__chooser").lambda(func_name)); .apply(cyclic_body.lambda("__chooser").lambda(func_name));
arg_stack.push(term); Some(term)
} }
Air::Let { name } => { Air::Let { name } => {
let arg = arg_stack.pop().unwrap(); let arg = arg_stack.pop().unwrap();
@ -4478,7 +4448,7 @@ impl<'a> CodeGenerator<'a> {
term = term.lambda(name).apply(arg); term = term.lambda(name).apply(arg);
arg_stack.push(term); Some(term)
} }
Air::CastFromData { tipo } => { Air::CastFromData { tipo } => {
let mut term = arg_stack.pop().unwrap(); let mut term = arg_stack.pop().unwrap();
@ -4504,7 +4474,7 @@ impl<'a> CodeGenerator<'a> {
term = builder::convert_data_to_type(term, &tipo); term = builder::convert_data_to_type(term, &tipo);
} }
arg_stack.push(term); Some(term)
} }
Air::CastToData { tipo } => { Air::CastToData { tipo } => {
let mut term = arg_stack.pop().unwrap(); let mut term = arg_stack.pop().unwrap();
@ -4530,7 +4500,7 @@ impl<'a> CodeGenerator<'a> {
term = builder::convert_type_to_data(term, &tipo); term = builder::convert_type_to_data(term, &tipo);
} }
arg_stack.push(term); Some(term)
} }
Air::AssertConstr { constr_index } => { Air::AssertConstr { constr_index } => {
let constr = arg_stack.pop().unwrap(); let constr = arg_stack.pop().unwrap();
@ -4548,7 +4518,7 @@ impl<'a> CodeGenerator<'a> {
) )
.delayed_if_then_else(term, error_term); .delayed_if_then_else(term, error_term);
arg_stack.push(term); Some(term)
} }
Air::AssertBool { is_true } => { Air::AssertBool { is_true } => {
let value = arg_stack.pop().unwrap(); let value = arg_stack.pop().unwrap();
@ -4560,7 +4530,7 @@ impl<'a> CodeGenerator<'a> {
} else { } else {
term = value.delayed_if_then_else(error_term, term) term = value.delayed_if_then_else(error_term, term)
} }
arg_stack.push(term); Some(term)
} }
Air::When { Air::When {
subject_name, subject_name,
@ -4590,7 +4560,7 @@ impl<'a> CodeGenerator<'a> {
term = term.lambda(subject_name).apply(subject); term = term.lambda(subject_name).apply(subject);
arg_stack.push(term); Some(term)
} }
Air::Clause { Air::Clause {
subject_tipo: tipo, subject_tipo: tipo,
@ -4661,7 +4631,7 @@ impl<'a> CodeGenerator<'a> {
} }
} }
arg_stack.push(term); Some(term)
} }
Air::ListClause { Air::ListClause {
tail_name, tail_name,
@ -4690,7 +4660,7 @@ impl<'a> CodeGenerator<'a> {
term = Term::var(tail_name).delayed_choose_list(body, arg); term = Term::var(tail_name).delayed_choose_list(body, arg);
} }
arg_stack.push(term); Some(term)
} }
Air::WrapClause => { Air::WrapClause => {
// no longer need to pop off discard // no longer need to pop off discard
@ -4699,7 +4669,7 @@ impl<'a> CodeGenerator<'a> {
term = term.lambda("__other_clauses_delayed").apply(arg.delay()); term = term.lambda("__other_clauses_delayed").apply(arg.delay());
arg_stack.push(term); Some(term)
} }
Air::TupleClause { Air::TupleClause {
subject_tipo: tipo, subject_tipo: tipo,
@ -4748,7 +4718,7 @@ impl<'a> CodeGenerator<'a> {
)); ));
} }
} }
arg_stack.push(term); Some(term)
} }
Air::ClauseGuard { Air::ClauseGuard {
subject_name, subject_name,
@ -4770,7 +4740,7 @@ impl<'a> CodeGenerator<'a> {
.if_then_else(term, then.delay()) .if_then_else(term, then.delay())
.force(); .force();
} }
arg_stack.push(term); Some(term)
} else { } else {
let condition = if tipo.is_int() { let condition = if tipo.is_int() {
Term::equals_integer() Term::equals_integer()
@ -4799,7 +4769,7 @@ impl<'a> CodeGenerator<'a> {
let term = condition let term = condition
.if_then_else(then.delay(), Term::var("__other_clauses_delayed")) .if_then_else(then.delay(), Term::var("__other_clauses_delayed"))
.force(); .force();
arg_stack.push(term); Some(term)
} }
} }
Air::ListClauseGuard { Air::ListClauseGuard {
@ -4831,7 +4801,7 @@ impl<'a> CodeGenerator<'a> {
.force(); .force();
} }
arg_stack.push(term); Some(term)
} }
Air::TupleGuard { Air::TupleGuard {
subject_tipo: tipo, subject_tipo: tipo,
@ -4870,10 +4840,12 @@ impl<'a> CodeGenerator<'a> {
)); ));
} }
} }
arg_stack.push(term); Some(term)
} }
Air::Finally => { Air::Finally => {
let _clause = arg_stack.pop().unwrap(); let _clause = arg_stack.pop().unwrap();
None
} }
Air::If { .. } => { Air::If { .. } => {
let condition = arg_stack.pop().unwrap(); let condition = arg_stack.pop().unwrap();
@ -4882,7 +4854,7 @@ impl<'a> CodeGenerator<'a> {
term = condition.delayed_if_then_else(then, term); term = condition.delayed_if_then_else(then, term);
arg_stack.push(term); Some(term)
} }
Air::Constr { Air::Constr {
tag: constr_index, tag: constr_index,
@ -4929,7 +4901,7 @@ impl<'a> CodeGenerator<'a> {
term = evaluated_term.try_into().unwrap(); term = evaluated_term.try_into().unwrap();
} }
arg_stack.push(term); Some(term)
} }
Air::FieldsExpose { indices, is_expect } => { Air::FieldsExpose { indices, is_expect } => {
let mut id_list = vec![]; let mut id_list = vec![];
@ -4941,24 +4913,26 @@ impl<'a> CodeGenerator<'a> {
id_list.push(list_id); id_list.push(list_id);
for _ in 0..indices.len() { indices.iter().for_each(|_| {
id_list.push(self.id_gen.next()); id_list.push(self.id_gen.next());
} });
let current_index = 0;
let names_types = indices let names_types = indices
.iter() .iter()
.cloned() .cloned()
.map(|item| (item.1, item.2)) .zip(id_list)
.map(|(item, id)| (item.1, item.2, id))
.collect_vec(); .collect_vec();
if !indices.is_empty() { let named_indices = names_types
.iter()
.skip_while(|(name, _, _)| name.is_empty())
.collect_vec();
if !named_indices.is_empty() || is_expect {
term = builder::list_access_to_uplc( term = builder::list_access_to_uplc(
&names_types, &names_types,
&id_list,
false, false,
current_index,
term, term,
is_expect, is_expect,
false, false,
@ -4973,19 +4947,10 @@ impl<'a> CodeGenerator<'a> {
.apply(value), .apply(value),
); );
arg_stack.push(term); Some(term)
} else if is_expect {
term = Term::var(
self.special_functions
.use_function_uplc(CONSTR_FIELDS_EXPOSER.to_string()),
)
.apply(value)
.delayed_choose_list(term, error_term);
arg_stack.push(term);
} else { } else {
arg_stack.push(term); Some(term)
}; }
} }
Air::FieldsEmpty => { Air::FieldsEmpty => {
let value = arg_stack.pop().unwrap(); let value = arg_stack.pop().unwrap();
@ -4999,7 +4964,7 @@ impl<'a> CodeGenerator<'a> {
.apply(value) .apply(value)
.delayed_choose_list(term, error_term); .delayed_choose_list(term, error_term);
arg_stack.push(term); Some(term)
} }
Air::ListEmpty => { Air::ListEmpty => {
let value = arg_stack.pop().unwrap(); let value = arg_stack.pop().unwrap();
@ -5008,7 +4973,7 @@ impl<'a> CodeGenerator<'a> {
term = value.delayed_choose_list(term, error_term); term = value.delayed_choose_list(term, error_term);
arg_stack.push(term); Some(term)
} }
Air::Tuple { count, tipo } => { Air::Tuple { count, tipo } => {
let mut args = vec![]; let mut args = vec![];
@ -5040,12 +5005,12 @@ impl<'a> CodeGenerator<'a> {
) )
.into(), .into(),
); );
arg_stack.push(term); Some(term)
} else { } else {
let term = Term::Constant( let term = Term::Constant(
UplcConstant::ProtoList(UplcType::Data, data_constants).into(), UplcConstant::ProtoList(UplcType::Data, data_constants).into(),
); );
arg_stack.push(term); Some(term)
} }
} else if count == 2 { } else if count == 2 {
let term = Term::mk_pair_data() let term = Term::mk_pair_data()
@ -5058,7 +5023,7 @@ impl<'a> CodeGenerator<'a> {
&tuple_sub_types[1], &tuple_sub_types[1],
)); ));
arg_stack.push(term); Some(term)
} else { } else {
let mut term = Term::empty_list(); let mut term = Term::empty_list();
for (arg, tipo) in args.into_iter().zip(tuple_sub_types.into_iter()).rev() { for (arg, tipo) in args.into_iter().zip(tuple_sub_types.into_iter()).rev() {
@ -5066,7 +5031,7 @@ impl<'a> CodeGenerator<'a> {
.apply(builder::convert_type_to_data(arg, &tipo)) .apply(builder::convert_type_to_data(arg, &tipo))
.apply(term); .apply(term);
} }
arg_stack.push(term); Some(term)
} }
} }
Air::RecordUpdate { Air::RecordUpdate {
@ -5160,7 +5125,7 @@ impl<'a> CodeGenerator<'a> {
.apply(record), .apply(record),
); );
arg_stack.push(term); Some(term)
} }
Air::UnOp { op } => { Air::UnOp { op } => {
let value = arg_stack.pop().unwrap(); let value = arg_stack.pop().unwrap();
@ -5184,7 +5149,7 @@ impl<'a> CodeGenerator<'a> {
} }
}; };
arg_stack.push(term); Some(term)
} }
Air::TupleAccessor { Air::TupleAccessor {
tipo, tipo,
@ -5220,22 +5185,25 @@ impl<'a> CodeGenerator<'a> {
term = term.lambda(format!("__tuple_{list_id}")).apply(value); term = term.lambda(format!("__tuple_{list_id}")).apply(value);
arg_stack.push(term); Some(term)
} else if !names.is_empty() { } else {
let mut id_list = vec![]; let mut id_list = vec![];
id_list.push(list_id); id_list.push(list_id);
for _ in 0..names.len() { names.iter().for_each(|_| {
id_list.push(self.id_gen.next()); id_list.push(self.id_gen.next());
} });
let names_types = names.into_iter().zip(inner_types).collect_vec(); let names_types = names
.into_iter()
.zip(inner_types)
.zip(id_list)
.map(|((name, tipo), id)| (name, tipo, id))
.collect_vec();
term = builder::list_access_to_uplc( term = builder::list_access_to_uplc(
&names_types, &names_types,
&id_list,
false, false,
0,
term, term,
is_expect, is_expect,
false, false,
@ -5243,9 +5211,7 @@ impl<'a> CodeGenerator<'a> {
) )
.apply(value); .apply(value);
arg_stack.push(term); Some(term)
} else {
unreachable!("HOW DID YOU DO THIS");
} }
} }
Air::Trace { .. } => { Air::Trace { .. } => {
@ -5255,17 +5221,17 @@ impl<'a> CodeGenerator<'a> {
let term = term.delayed_trace(text); let term = term.delayed_trace(text);
arg_stack.push(term); Some(term)
} }
Air::ErrorTerm { validator, .. } => { Air::ErrorTerm { validator, .. } => {
if validator { if validator {
arg_stack.push(Term::Error.apply(Term::Error.force())) Some(Term::Error.apply(Term::Error.force()))
} else { } else {
arg_stack.push(Term::Error); Some(Term::Error)
} }
} }
Air::NoOp => {} Air::NoOp => None,
} }
} }
} }

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

@ -1402,189 +1402,83 @@ pub fn convert_type_to_data(term: Term<Name>, field_type: &Rc<Type>) -> Term<Nam
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
pub fn list_access_to_uplc( pub fn list_access_to_uplc(
names_types: &[(String, Rc<Type>)], names_types_ids: &[(String, Rc<Type>, u64)],
id_list: &[u64],
tail: bool, tail: bool,
current_index: usize,
term: Term<Name>, term: Term<Name>,
check_last_item: bool, check_last_item: bool,
is_list_accessor: bool, is_list_accessor: bool,
error_term: Term<Name>, error_term: Term<Name>,
) -> Term<Name> { ) -> Term<Name> {
if let Some(((first, current_tipo), names_types)) = names_types.split_first() { let names_len = names_types_ids.len();
let mut no_tailing_discards = names_types_ids
.iter()
.rev()
.skip_while(|(name, _, _)| name == "_")
.collect_vec();
// If the the is just discards and check_last_item then we check for empty list
if no_tailing_discards.is_empty() && !tail && check_last_item {
return Term::var("empty_list")
.delayed_choose_list(term, error_term)
.lambda("empty_list");
}
// reverse back to original order
no_tailing_discards.reverse();
let no_tailing_len = no_tailing_discards.len();
// If we cut off at least one element then that was tail and possibly some heads
let tail = tail && no_tailing_discards.len() == names_len;
no_tailing_discards.into_iter().enumerate().rev().fold(
term,
|acc, (index, (name, tipo, id))| {
let tail_name = format!("tail_index_{}_{}", index, id);
let head_list = let head_list =
if matches!(current_tipo.get_uplc_type(), UplcType::Pair(_, _)) && is_list_accessor { if matches!(tipo.get_uplc_type(), UplcType::Pair(_, _)) && is_list_accessor {
Term::head_list().apply(Term::var(format!( Term::head_list().apply(Term::var(tail_name.to_string()))
"tail_index_{}_{}",
current_index, id_list[current_index]
)))
} else { } else {
convert_data_to_type( convert_data_to_type(
Term::head_list().apply(Term::var(format!( Term::head_list().apply(Term::var(tail_name.to_string())),
"tail_index_{}_{}", &tipo.to_owned(),
current_index, id_list[current_index]
))),
&current_tipo.to_owned(),
) )
}; };
if names_types.len() == 1 && tail { // handle tail case
if first == "_" && names_types[0].0 == "_" { // name is guaranteed to not be discard at this point
term.lambda("_") if index == no_tailing_len - 1 && tail {
} else if first == "_" { // simply lambda for tail name
term.lambda(&names_types[0].0) acc.lambda(name)
.apply(Term::tail_list().apply(Term::var(format!( } else if index == no_tailing_len - 1 {
"tail_index_{}_{}", // case for no tail
current_index, id_list[current_index] // name is guaranteed to not be discard at this point
))))
.lambda(format!(
"tail_index_{}_{}",
current_index, id_list[current_index]
))
} else if names_types[0].0 == "_" {
term.lambda(first).apply(head_list).lambda(format!(
"tail_index_{}_{}",
current_index, id_list[current_index]
))
} else {
term.lambda(&names_types[0].0)
.apply(Term::tail_list().apply(Term::var(format!(
"tail_index_{}_{}",
current_index, id_list[current_index]
))))
.lambda(first)
.apply(head_list)
.lambda(format!(
"tail_index_{}_{}",
current_index, id_list[current_index]
))
}
} else if names_types.is_empty() {
if first == "_" {
if check_last_item { if check_last_item {
Term::tail_list() Term::tail_list()
.apply(Term::var(format!( .apply(Term::var(tail_name.to_string()))
"tail_index_{}_{}", .delayed_choose_list(acc, error_term.clone())
current_index, id_list[current_index] .lambda(name)
)))
.delayed_choose_list(term, error_term)
} else {
term
}
.lambda(if check_last_item {
format!("tail_index_{}_{}", current_index, id_list[current_index])
} else {
"_".to_string()
})
} else {
if check_last_item {
Term::tail_list()
.apply(Term::var(format!(
"tail_index_{}_{}",
current_index, id_list[current_index]
)))
.delayed_choose_list(term, error_term)
} else {
term
}
.lambda(first.clone())
.apply(head_list) .apply(head_list)
.lambda(format!( .lambda("tail_name")
"tail_index_{}_{}",
current_index, id_list[current_index]
))
}
} else if first == "_" {
let mut list_access_inner = list_access_to_uplc(
names_types,
id_list,
tail,
current_index + 1,
term,
check_last_item,
is_list_accessor,
error_term,
);
list_access_inner = match &list_access_inner {
Term::Lambda {
parameter_name,
body,
} => {
if &parameter_name.text == "_" {
body.as_ref().clone()
} else { } else {
list_access_inner acc.lambda(name)
.apply(Term::tail_list().apply(Term::var(format!(
"tail_index_{}_{}",
current_index, id_list[current_index]
))))
.lambda(format!(
"tail_index_{}_{}",
current_index, id_list[current_index]
))
}
}
_ => list_access_inner,
};
match &list_access_inner {
Term::Lambda { .. } => list_access_inner,
_ => list_access_inner.lambda("_"),
}
} else {
let mut list_access_inner = list_access_to_uplc(
names_types,
id_list,
tail,
current_index + 1,
term,
check_last_item,
is_list_accessor,
error_term,
);
list_access_inner = match &list_access_inner {
Term::Lambda {
parameter_name,
body,
} => {
if &parameter_name.text == "_" {
body.as_ref()
.clone()
.lambda(first.clone())
.apply(head_list) .apply(head_list)
.lambda(format!( .lambda(tail_name.to_string())
"tail_index_{}_{}", }
current_index, id_list[current_index] } else if name == "_" {
)) acc.apply(Term::tail_list().apply(Term::var(tail_name.to_string())))
.lambda(tail_name.to_string())
} else { } else {
list_access_inner acc.apply(Term::tail_list().apply(Term::var(tail_name.to_string())))
.apply(Term::tail_list().apply(Term::var(format!( .lambda(name)
"tail_index_{}_{}",
current_index, id_list[current_index]
))))
.lambda(first.clone())
.apply(head_list) .apply(head_list)
.lambda(format!( .lambda(tail_name.to_string())
"tail_index_{}_{}",
current_index, id_list[current_index]
))
}
}
_ => list_access_inner
.lambda(first.clone())
.apply(head_list)
.lambda(format!(
"tail_index_{}_{}",
current_index, id_list[current_index]
)),
};
list_access_inner
}
} else {
term
} }
},
)
} }
pub fn apply_builtin_forces(mut term: Term<Name>, force_count: u32) -> Term<Name> { pub fn apply_builtin_forces(mut term: Term<Name>, force_count: u32) -> Term<Name> {