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

Fixing other tests

This commit is contained in:
microproofs 2024-08-07 00:11:04 -04:00 committed by Kasey
parent 7ad5491ea9
commit 56ff4ec678
3 changed files with 209 additions and 329 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -947,6 +947,8 @@ pub fn softcast_data_to_type_otherwise(
then: Term<Name>, then: Term<Name>,
otherwise_delayed: Term<Name>, otherwise_delayed: Term<Name>,
) -> Term<Name> { ) -> Term<Name> {
assert!(matches!(otherwise_delayed, Term::Var(_)));
let uplc_type = field_type.get_uplc_type(); let uplc_type = field_type.get_uplc_type();
let callback = |v| then.lambda(name).apply(v); let callback = |v| then.lambda(name).apply(v);

1
crates/aiken-lang/src/gen_uplc/tree.rs
View File

@ -2,7 +2,6 @@ use super::air::{Air, ExpectLevel};
use crate::{ use crate::{
ast::{BinOp, Curve, Span, UnOp}, ast::{BinOp, Curve, Span, UnOp},
builtins::{bool, byte_array, data, int, list, string, void}, builtins::{bool, byte_array, data, int, list, string, void},
gen_uplc::AssignmentProperties,
tipo::{Type, ValueConstructor, ValueConstructorVariant}, tipo::{Type, ValueConstructor, ValueConstructorVariant},
}; };
use indexmap::IndexSet; use indexmap::IndexSet;

409
crates/aiken-project/src/tests/gen_uplc.rs
View File

@ -3699,12 +3699,7 @@ fn when_tuple_deconstruction() {
} }
"#; "#;
assert_uplc( let delayed_then = Term::equals_integer()
src,
Term::choose_data_constr(
Name::text("__val").into(),
|v| {
Term::equals_integer()
.apply(Term::integer(0.into())) .apply(Term::integer(0.into()))
.apply(Term::var(CONSTR_INDEX_EXPOSER).apply(Term::var("dat"))) .apply(Term::var(CONSTR_INDEX_EXPOSER).apply(Term::var("dat")))
.delay_true_if_then_else( .delay_true_if_then_else(
@ -3713,23 +3708,24 @@ fn when_tuple_deconstruction() {
.apply(Term::var(CONSTR_INDEX_EXPOSER).apply(Term::var("red"))) .apply(Term::var(CONSTR_INDEX_EXPOSER).apply(Term::var("red")))
.delay_true_if_then_else( .delay_true_if_then_else(
Term::equals_integer() Term::equals_integer()
.apply(Term::un_i_data().apply(Term::head_list().apply( .apply(
Term::var(CONSTR_FIELDS_EXPOSER).apply(Term::var("a")), Term::un_i_data().apply(
))) Term::head_list()
.apply(Term::var(CONSTR_FIELDS_EXPOSER).apply(Term::var("a"))),
),
)
.apply(Term::var("x")) .apply(Term::var("x"))
.delayed_if_then_else( .delayed_if_then_else(
Term::bool(true), Term::bool(true),
Term::bool(false) Term::bool(false).delayed_trace(Term::string("a.idx == x ? False")),
.delayed_trace(Term::string("a.idx == x ? False")),
) )
.lambda("x") .lambda("x")
.apply(Term::un_i_data().apply(
Term::head_list().apply(Term::var("red_constr_fields")),
))
.lambda("red_constr_fields")
.apply( .apply(
Term::var(CONSTR_FIELDS_EXPOSER).apply(Term::var("red")), Term::un_i_data()
), .apply(Term::head_list().apply(Term::var("red_constr_fields"))),
)
.lambda("red_constr_fields")
.apply(Term::var(CONSTR_FIELDS_EXPOSER).apply(Term::var("red"))),
Term::var("other_clauses"), Term::var("other_clauses"),
) )
.lambda("a") .lambda("a")
@ -3743,9 +3739,7 @@ fn when_tuple_deconstruction() {
.lambda("dat") .lambda("dat")
.apply(Term::head_list().apply(Term::var("pair_subject"))) .apply(Term::head_list().apply(Term::var("pair_subject")))
.lambda("red") .lambda("red")
.apply( .apply(Term::head_list().apply(Term::tail_list().apply(Term::var("pair_subject"))))
Term::head_list().apply(Term::tail_list().apply(Term::var("pair_subject"))),
)
.lambda("pair_subject") .lambda("pair_subject")
.apply( .apply(
Term::mk_cons().apply(Term::var("dat")).apply( Term::mk_cons().apply(Term::var("dat")).apply(
@ -3761,217 +3755,107 @@ fn when_tuple_deconstruction() {
.delayed_trace(Term::string("Validator returned false")), .delayed_trace(Term::string("Validator returned false")),
) )
.lambda("ctx") .lambda("ctx")
.lambda("_") .delay();
.apply(
Term::var("expect_RedSpend") let otherwise_delay = &Term::var("otherwise_delayed");
.lambda("expect_RedSpend")
.apply( let redSpend = Term::var(CONSTR_INDEX_EXPOSER)
Term::equals_integer() .apply(Term::var("__param_0"))
.as_var("subject", |subject| {
let subject_second_constr = Term::equals_integer()
.apply(Term::integer(1.into()))
.apply(Term::Var(subject.clone()))
.delay_true_if_then_else(
Term::var(CONSTR_FIELDS_EXPOSER)
.apply(Term::var("__param_0"))
.delay_empty_choose_list(
Term::var("then_delayed").force(),
otherwise_delay.clone(),
),
otherwise_delay.clone(),
);
let subject_first_constr = Term::equals_integer()
.apply(Term::integer(0.into())) .apply(Term::integer(0.into()))
.apply(Term::var("subject")) .apply(Term::Var(subject.clone()))
.delayed_if_then_else( .delayed_if_then_else(
Term::var("red_constr_fields") Term::var(CONSTR_FIELDS_EXPOSER)
.delay_filled_choose_list( .apply(Term::var("__params_0"))
Term::var("param_msg"), .as_var("fields", |fields| {
Term::unwrap_tail_or(
fields.clone(),
|after_fields| {
Term::head_list().apply(Term::Var(fields)).as_var(
"head",
|head| {
Term::choose_data_integer( Term::choose_data_integer(
Name::text("__val").into(), head,
|v| { |field_0| {
Term::tail_list() after_fields
.apply(Term::var("red_constr_fields"))
.delay_empty_choose_list( .delay_empty_choose_list(
Term::unit(), Term::var("then_delayed").force(),
Term::var("param_msg"), otherwise_delay.clone(),
) )
.lambda("field_1") .lambda("field_0")
.apply(v) .apply(field_0)
}, },
&Term::var("param_msg"), otherwise_delay,
) )
.lambda("__val") },
.apply( )
},
otherwise_delay,
)
}),
subject_second_constr,
);
subject_first_constr
.lambda("otherwise_delayed")
.lambda("then_delayed")
.lambda("__param_0")
.lambda(NO_INLINE)
});
let thing = Term::equals_integer()
.apply(Term::integer(0.into()))
.apply(Term::var(CONSTR_INDEX_EXPOSER).apply(Term::var("__param_0")))
.delay_true_if_then_else(
Term::var(CONSTR_FIELDS_EXPOSER)
.apply(Term::var("__param_0"))
.as_var("fields", |fields| {
Term::unwrap_tail_or(
fields.clone(),
|tail| {
Term::head_list() Term::head_list()
.apply(Term::var("red_constr_fields")), .apply(Term::Var(fields))
), .as_var("head", |head| {
) Term::choose_data_integer(
.lambda("red_constr_fields") head,
.apply( |head_field| {
Term::var(CONSTR_FIELDS_EXPOSER) tail.delay_empty_choose_list(
.apply(Term::var("red")), Term::var("then_delayed").force(),
), otherwise_delay.clone(),
Term::equals_integer()
.apply(Term::integer(1.into()))
.apply(Term::var("subject"))
.delay_true_if_then_else(
Term::var(CONSTR_FIELDS_EXPOSER)
.apply(Term::var("red"))
.delay_empty_choose_list(
Term::unit(),
Term::var("param_msg"),
),
Term::var("param_msg"),
),
)
.lambda("subject")
.apply(Term::var(CONSTR_INDEX_EXPOSER).apply(Term::var("red")))
.lambda("param_msg")
.lambda("red"),
)
.apply(Term::var("red"))
.apply(Term::var("red:RedSpend")),
)
.lambda("red")
.apply(v)
},
&Term::var("red:RedSpend"),
)
.lambda("__val")
.apply(Term::var("red"))
.lambda("red")
.lambda("_")
.apply(
Term::var("expect_Datum")
.lambda("expect_Datum")
.apply(
Term::equals_integer()
.apply(Term::integer(0.into()))
.apply(Term::var("subject"))
.delayed_if_then_else(
Term::var("dat_constr_fields")
.delay_filled_choose_list(
Term::var("param_msg"),
Term::choose_data_constr(
Name::text("__val").into(),
|v| {
Term::tail_list()
.apply(Term::var("dat_constr_fields"))
.delay_empty_choose_list(
Term::unit().lambda("_").apply(
Term::var("expect_Thing")
.apply(Term::var("field_1"))
.apply(Term::var("param_msg")),
),
Term::var("param_msg"),
)
.lambda("field_1")
.apply(v)
},
&Term::var("param_msg"),
)
.lambda("__val")
.apply(Term::head_list().apply(Term::var("dat_constr_fields"))),
)
.lambda("dat_constr_fields")
.apply(Term::var(CONSTR_FIELDS_EXPOSER).apply(Term::var("dat"))),
Term::equals_integer()
.apply(Term::integer(1.into()))
.apply(Term::var("subject"))
.delay_true_if_then_else(
Term::var(CONSTR_FIELDS_EXPOSER)
.apply(Term::var("dat"))
.delay_empty_choose_list(
Term::unit(),
Term::var("param_msg"),
),
Term::var("param_msg"),
),
)
.lambda("subject")
.apply(Term::var(CONSTR_INDEX_EXPOSER).apply(Term::var("dat")))
.lambda("param_msg")
.lambda("dat"),
)
.lambda("expect_Thing")
.apply(
Term::equals_integer()
.apply(Term::integer(0.into()))
.apply(Term::var("subject"))
.delay_true_if_then_else(
Term::var("field_1_constr_fields")
.delay_filled_choose_list(
Term::var("param_msg"),
Term::tail_list()
.apply(Term::var("field_1_constr_fields"))
.delay_empty_choose_list(
Term::unit(),
Term::var("param_msg"),
) )
.lambda("idx") .lambda("idx")
.apply( .apply(head_field)
Term::var("__val") },
.choose_data( otherwise_delay,
Term::var("param_msg"),
Term::var("param_msg"),
Term::var("param_msg"),
Term::un_i_data()
.apply(Term::var("__val"))
.delay(),
Term::var("param_msg"),
) )
.force() })
.lambda("__val") },
.apply( otherwise_delay,
Term::head_list()
.apply(Term::var("field_1_constr_fields")),
),
),
) )
.lambda("field_1_constr_fields") }),
.apply( otherwise_delay.clone(),
Term::var(CONSTR_FIELDS_EXPOSER).apply(Term::var("field_1")),
),
Term::var("param_msg"),
) )
.lambda("subject") .lambda("otherwise_delayed")
.apply(Term::var(CONSTR_INDEX_EXPOSER).apply(Term::var("field_1"))) .lambda("then_delayed")
.lambda("param_msg") .lambda("__param_0");
.lambda("field_1"),
) let datum: Term<Name> = Term::Error;
.apply(Term::var("dat"))
.apply(Term::var("dat:Datum")), assert_uplc(src, Term::Error, false);
)
.lambda("dat")
.apply(
Term::var("__val")
.choose_data(
Term::var("__val").delay(),
Term::var("dat:Datum"),
Term::var("dat:Datum"),
Term::var("dat:Datum"),
Term::var("dat:Datum"),
)
.force()
.lambda("__val")
.apply(Term::var("dat")),
)
.lambda("dat")
.apply(Term::var("dat"))
.lambda("dat")
.lambda(CONSTR_FIELDS_EXPOSER)
.apply(
Term::snd_pair()
.apply(Term::unconstr_data().apply(Term::var("x")))
.lambda("x"),
)
.lambda("red:RedSpend")
.apply(
Term::Error
.delayed_trace(Term::string("red: RedSpend"))
.delay(),
)
.lambda("dat:Datum")
.apply(
Term::Error
.delayed_trace(Term::string("dat: Datum"))
.delay(),
)
.lambda(CONSTR_INDEX_EXPOSER)
.apply(
Term::fst_pair()
.apply(Term::unconstr_data().apply(Term::var("x")))
.lambda("x"),
),
false,
);
} }
#[test] #[test]
@ -5888,41 +5772,51 @@ fn opaque_value_in_test() {
} }
"#; "#;
assert_uplc( let expect_otherwise = &Term::var("expect[Pair(_,amount)]=val.inner.inner");
src, let expect_delay_error: Term<Name> = Term::Error
Term::var("val") .delayed_trace(Term::string("expect [Pair(_, amount)] = val.inner.inner"))
.delay_filled_choose_list( .delay();
Term::var("expect[Pair(_,amount)]=val.inner.inner"),
Term::tail_list() let final_comparison = Term::equals_data()
.apply(Term::var("val"))
.delay_empty_choose_list(
Term::equals_data()
.apply(Term::map_data().apply(Term::var("final_amount"))) .apply(Term::map_data().apply(Term::var("final_amount")))
.apply(Term::map_data().apply(Term::var("amount"))) .apply(Term::map_data().apply(Term::var("amount")));
.lambda("final_amount")
.apply(Term::map_values(vec![Constant::ProtoPair( let assignments_body = Term::unmap_data()
.apply(Term::head_list().apply(
Term::tail_list().apply(Term::var(CONSTR_FIELDS_EXPOSER).apply(Term::var("dat"))),
))
.as_var("val", |val| {
Term::unwrap_tail_or(
val.clone(),
|tail| {
Term::head_list()
.apply(Term::Var(val))
.as_var("elem_0", |elem| {
tail.delay_empty_choose_list(
Term::unmap_data()
.apply(Term::snd_pair().apply(Term::Var(elem)))
.as_var("amount", |_| {
Term::map_values(vec![Constant::ProtoPair(
Type::Data, Type::Data,
Type::Data, Type::Data,
Constant::Data(Data::bytestring(vec![170])).into(), Constant::Data(Data::bytestring(vec![170])).into(),
Constant::Data(Data::integer(4.into())).into(), Constant::Data(Data::integer(4.into())).into(),
)])) )])
.lambda("amount") .as_var("final_amount", |_| final_comparison)
.apply( }),
Term::unmap_data() expect_otherwise.clone(),
.apply(Term::snd_pair().apply(Term::var("tuple_item_0"))),
),
Term::var("expect[Pair(_,amount)]=val.inner.inner"),
) )
.lambda("tuple_item_0") })
.apply(Term::head_list().apply(Term::var("val"))), },
expect_otherwise,
) )
.lambda("val") });
.apply(Term::unmap_data().apply(Term::head_list().apply(
Term::tail_list().apply(Term::var(CONSTR_FIELDS_EXPOSER).apply(Term::var("dat"))), assert_uplc(
))) src,
assignments_body
.lambda("dat") .lambda("dat")
.apply(Term::Constant( .apply(Term::data(Data::constr(
Constant::Data(Data::constr(
0, 0,
vec![ vec![
Data::integer(0.into()), Data::integer(0.into()),
@ -5931,27 +5825,12 @@ fn opaque_value_in_test() {
Data::map(vec![(Data::bytestring(vec![170]), Data::integer(4.into()))]), Data::map(vec![(Data::bytestring(vec![170]), Data::integer(4.into()))]),
)]), )]),
], ],
)) )))
.into(), .constr_fields_exposer()
))
.lambda("v")
.apply(Term::map_values(vec![Constant::ProtoPair(
Type::Data,
Type::Data,
Constant::Data(Data::bytestring(vec![])).into(),
Constant::Data(Data::map(vec![(
Data::bytestring(vec![170]),
Data::integer(4.into()),
)]))
.into(),
)]))
.lambda("expect[Pair(_,amount)]=val.inner.inner") .lambda("expect[Pair(_,amount)]=val.inner.inner")
.apply( .apply(expect_delay_error)
Term::Error .lambda("dat:Dat")
.delayed_trace(Term::string("expect [Pair(_, amount)] = val.inner.inner")) .apply(Term::Error.delayed_trace(Term::string("dat: Dat")).delay()),
.delay(),
)
.constr_fields_exposer(),
false, false,
); );
} }