4752 lines
182 KiB
Rust
4752 lines
182 KiB
Rust
use std::{rc::Rc, sync::Arc};
|
|
|
|
use indexmap::{IndexMap, IndexSet};
|
|
use itertools::Itertools;
|
|
use uplc::{
|
|
ast::{Constant as UplcConstant, Name, NamedDeBruijn, Program, Term, Type as UplcType},
|
|
builder::{CONSTR_FIELDS_EXPOSER, CONSTR_GET_FIELD, CONSTR_INDEX_EXPOSER},
|
|
builtins::DefaultFunction,
|
|
machine::cost_model::ExBudget,
|
|
optimize::aiken_optimize_and_intern,
|
|
parser::interner::Interner,
|
|
};
|
|
|
|
use crate::{
|
|
ast::{
|
|
ArgName, AssignmentKind, BinOp, Pattern, TypedClause, TypedDataType, TypedFunction,
|
|
TypedValidator, UnOp,
|
|
},
|
|
builtins::bool,
|
|
expr::TypedExpr,
|
|
tipo::{
|
|
ModuleValueConstructor, PatternConstructor, Type, TypeInfo, ValueConstructor,
|
|
ValueConstructorVariant,
|
|
},
|
|
IdGenerator,
|
|
};
|
|
|
|
pub mod air;
|
|
pub mod builder;
|
|
pub mod scope;
|
|
pub mod stack;
|
|
|
|
use air::Air;
|
|
use builder::{
|
|
AssignmentProperties, ClauseProperties, DataTypeKey, FuncComponents, FunctionAccessKey,
|
|
};
|
|
|
|
use self::{scope::Scope, stack::AirStack};
|
|
|
|
#[derive(Clone)]
|
|
pub struct CodeGenerator<'a> {
|
|
defined_functions: IndexMap<FunctionAccessKey, ()>,
|
|
functions: IndexMap<FunctionAccessKey, &'a TypedFunction>,
|
|
data_types: IndexMap<DataTypeKey, &'a TypedDataType>,
|
|
module_types: IndexMap<&'a String, &'a TypeInfo>,
|
|
id_gen: Rc<IdGenerator>,
|
|
needs_field_access: bool,
|
|
used_data_assert_on_list: bool,
|
|
zero_arg_functions: IndexMap<FunctionAccessKey, Vec<Air>>,
|
|
}
|
|
|
|
impl<'a> CodeGenerator<'a> {
|
|
pub fn new(
|
|
functions: IndexMap<FunctionAccessKey, &'a TypedFunction>,
|
|
data_types: IndexMap<DataTypeKey, &'a TypedDataType>,
|
|
module_types: IndexMap<&'a String, &'a TypeInfo>,
|
|
) -> Self {
|
|
CodeGenerator {
|
|
defined_functions: IndexMap::new(),
|
|
functions,
|
|
data_types,
|
|
module_types,
|
|
id_gen: IdGenerator::new().into(),
|
|
needs_field_access: false,
|
|
used_data_assert_on_list: false,
|
|
zero_arg_functions: IndexMap::new(),
|
|
}
|
|
}
|
|
|
|
pub fn reset(&mut self) {
|
|
self.needs_field_access = false;
|
|
self.used_data_assert_on_list = false;
|
|
self.zero_arg_functions = IndexMap::new();
|
|
self.id_gen = IdGenerator::new().into();
|
|
self.defined_functions = IndexMap::new();
|
|
}
|
|
|
|
pub fn generate(
|
|
&mut self,
|
|
TypedValidator {
|
|
fun,
|
|
other_fun,
|
|
params,
|
|
..
|
|
}: &TypedValidator,
|
|
) -> Program<Name> {
|
|
let mut ir_stack = AirStack::new(self.id_gen.clone());
|
|
|
|
ir_stack.noop();
|
|
|
|
self.build(&fun.body, &mut ir_stack);
|
|
|
|
let mut ir_stack = ir_stack.complete();
|
|
|
|
self.define_ir(&mut ir_stack);
|
|
|
|
self.convert_opaque_type_to_inner_ir(&mut ir_stack);
|
|
|
|
let mut term = self.uplc_code_gen(&mut ir_stack);
|
|
|
|
// Wrap the validator body if ifThenElse term unit error
|
|
term = term.final_wrapper();
|
|
|
|
term = builder::wrap_validator_args(term, &fun.arguments);
|
|
|
|
if let Some(other) = other_fun {
|
|
self.reset();
|
|
|
|
let mut other_ir_stack = AirStack::new(self.id_gen.clone());
|
|
other_ir_stack.noop();
|
|
|
|
self.build(&other.body, &mut other_ir_stack);
|
|
|
|
let mut other_ir_stack = other_ir_stack.complete();
|
|
|
|
self.define_ir(&mut other_ir_stack);
|
|
|
|
self.convert_opaque_type_to_inner_ir(&mut other_ir_stack);
|
|
|
|
let other_term = self.uplc_code_gen(&mut other_ir_stack);
|
|
|
|
let other_term = other_term.final_wrapper();
|
|
|
|
let other_term = builder::wrap_validator_args(other_term, &other.arguments);
|
|
|
|
let (spend, mint) = if other.arguments.len() > fun.arguments.len() {
|
|
(other_term, term)
|
|
} else {
|
|
(term, other_term)
|
|
};
|
|
|
|
term = builder::wrap_as_multi_validator(spend, mint);
|
|
self.needs_field_access = true;
|
|
}
|
|
|
|
term = builder::wrap_validator_args(term, params);
|
|
|
|
self.finalize(term, true)
|
|
}
|
|
|
|
pub fn generate_test(&mut self, test_body: &TypedExpr) -> Program<Name> {
|
|
let mut ir_stack = AirStack::new(self.id_gen.clone());
|
|
|
|
ir_stack.noop();
|
|
|
|
self.build(test_body, &mut ir_stack);
|
|
|
|
let mut ir_stack = ir_stack.complete();
|
|
|
|
self.define_ir(&mut ir_stack);
|
|
|
|
self.convert_opaque_type_to_inner_ir(&mut ir_stack);
|
|
|
|
let term = self.uplc_code_gen(&mut ir_stack);
|
|
|
|
self.finalize(term, false)
|
|
}
|
|
|
|
fn finalize(&mut self, term: Term<Name>, wrap_as_validator: bool) -> Program<Name> {
|
|
let mut term = if wrap_as_validator || self.used_data_assert_on_list {
|
|
term.assert_on_list()
|
|
} else {
|
|
term
|
|
};
|
|
|
|
if self.needs_field_access {
|
|
term = term
|
|
.constr_get_field()
|
|
.constr_fields_exposer()
|
|
.constr_index_exposer();
|
|
}
|
|
|
|
let mut program = Program {
|
|
version: (1, 0, 0),
|
|
term,
|
|
};
|
|
|
|
program = aiken_optimize_and_intern(program);
|
|
|
|
// This is very important to call here.
|
|
// If this isn't done, re-using the same instance
|
|
// of the generator will result in free unique errors
|
|
// among other unpredictable things. In fact,
|
|
// switching to a shared code generator caused some
|
|
// instability issues and we fixed it by placing this
|
|
// method here.
|
|
self.reset();
|
|
|
|
program
|
|
}
|
|
|
|
pub(crate) fn build(&mut self, body: &TypedExpr, ir_stack: &mut AirStack) {
|
|
match body {
|
|
TypedExpr::Int { value, .. } => ir_stack.integer(value.to_string()),
|
|
TypedExpr::String { value, .. } => ir_stack.string(value.to_string()),
|
|
TypedExpr::ByteArray { bytes, .. } => ir_stack.byte_array(bytes.to_vec()),
|
|
TypedExpr::Pipeline { expressions, .. } | TypedExpr::Sequence { expressions, .. } => {
|
|
let mut stacks = Vec::new();
|
|
|
|
for (index, expr) in expressions.iter().enumerate() {
|
|
if index == 0 {
|
|
self.build(expr, ir_stack);
|
|
} else {
|
|
let mut stack = ir_stack.empty_with_scope();
|
|
self.build(expr, &mut stack);
|
|
stacks.push(stack);
|
|
}
|
|
}
|
|
|
|
ir_stack.sequence(stacks);
|
|
}
|
|
TypedExpr::Var {
|
|
constructor, name, ..
|
|
} => match &constructor.variant {
|
|
ValueConstructorVariant::ModuleConstant { literal, .. } => {
|
|
builder::constants_ir(literal, ir_stack);
|
|
}
|
|
ValueConstructorVariant::ModuleFn {
|
|
builtin: Some(builtin),
|
|
..
|
|
} => {
|
|
ir_stack.builtin(*builtin, constructor.tipo.clone(), vec![]);
|
|
}
|
|
_ => {
|
|
ir_stack.var(constructor.clone(), name, "");
|
|
}
|
|
},
|
|
TypedExpr::Fn { args, body, .. } => {
|
|
let mut body_stack = ir_stack.empty_with_scope();
|
|
|
|
self.build(body, &mut body_stack);
|
|
|
|
let params = args
|
|
.iter()
|
|
.map(|arg| arg.arg_name.get_variable_name().unwrap_or("_").to_string())
|
|
.collect();
|
|
|
|
ir_stack.anonymous_function(params, body_stack);
|
|
}
|
|
TypedExpr::List {
|
|
elements,
|
|
tail,
|
|
tipo,
|
|
..
|
|
} => {
|
|
let mut stacks = Vec::new();
|
|
for element in elements {
|
|
let mut stack = ir_stack.empty_with_scope();
|
|
|
|
self.build(element, &mut stack);
|
|
|
|
stacks.push(stack);
|
|
}
|
|
|
|
let tail = tail.as_ref().map(|tail| {
|
|
let mut tail_stack = ir_stack.empty_with_scope();
|
|
|
|
self.build(tail, &mut tail_stack);
|
|
|
|
tail_stack
|
|
});
|
|
|
|
ir_stack.list(tipo.clone(), stacks, tail);
|
|
}
|
|
TypedExpr::Call {
|
|
fun, args, tipo, ..
|
|
} => {
|
|
match &**fun {
|
|
TypedExpr::Var { constructor, .. } => match &constructor.variant {
|
|
ValueConstructorVariant::Record {
|
|
name: constr_name, ..
|
|
} => {
|
|
if let Some(data_type) =
|
|
builder::lookup_data_type_by_tipo(self.data_types.clone(), tipo)
|
|
{
|
|
let (constr_index, _) = data_type
|
|
.constructors
|
|
.iter()
|
|
.enumerate()
|
|
.find(|(_, dt)| &dt.name == constr_name)
|
|
.unwrap();
|
|
|
|
let Some(fun_arg_types) = fun.tipo().arg_types() else {
|
|
unreachable!()
|
|
};
|
|
|
|
let mut stacks = Vec::new();
|
|
|
|
for (arg, func_type) in args.iter().zip(fun_arg_types) {
|
|
let mut stack = ir_stack.empty_with_scope();
|
|
|
|
if func_type.is_data() && !arg.value.tipo().is_data() {
|
|
stack.wrap_data(arg.value.tipo());
|
|
}
|
|
|
|
self.build(&arg.value, &mut stack);
|
|
|
|
stacks.push(stack);
|
|
}
|
|
|
|
ir_stack.record(constructor.tipo.clone(), constr_index, stacks);
|
|
|
|
return;
|
|
}
|
|
}
|
|
ValueConstructorVariant::ModuleFn {
|
|
builtin: Some(func),
|
|
..
|
|
} => {
|
|
let Some(fun_arg_types) = fun.tipo().arg_types() else {unreachable!()};
|
|
|
|
let mut stacks = Vec::new();
|
|
|
|
for (arg, func_type) in args.iter().zip(fun_arg_types) {
|
|
let mut stack = ir_stack.empty_with_scope();
|
|
|
|
if func_type.is_data() && !arg.value.tipo().is_data() {
|
|
stack.wrap_data(arg.value.tipo());
|
|
}
|
|
|
|
self.build(&arg.value, &mut stack);
|
|
|
|
stacks.push(stack);
|
|
}
|
|
|
|
ir_stack.builtin(*func, tipo.clone(), stacks);
|
|
|
|
return;
|
|
}
|
|
_ => {}
|
|
},
|
|
TypedExpr::ModuleSelect {
|
|
constructor,
|
|
module_name,
|
|
..
|
|
} => match constructor {
|
|
ModuleValueConstructor::Record {
|
|
name: constr_name,
|
|
tipo,
|
|
..
|
|
} => {
|
|
if let Some(data_type) =
|
|
builder::lookup_data_type_by_tipo(self.data_types.clone(), tipo)
|
|
{
|
|
let (constr_index, _) = data_type
|
|
.constructors
|
|
.iter()
|
|
.enumerate()
|
|
.find(|(_, dt)| &dt.name == constr_name)
|
|
.unwrap();
|
|
|
|
let Some(fun_arg_types) = fun.tipo().arg_types() else {unreachable!()};
|
|
|
|
let mut stacks = Vec::new();
|
|
|
|
for (arg, func_type) in args.iter().zip(fun_arg_types) {
|
|
let mut stack = ir_stack.empty_with_scope();
|
|
|
|
if func_type.is_data() && !arg.value.tipo().is_data() {
|
|
stack.wrap_data(arg.value.tipo());
|
|
}
|
|
|
|
self.build(&arg.value, &mut stack);
|
|
|
|
stacks.push(stack);
|
|
}
|
|
|
|
ir_stack.record(tipo.clone(), constr_index, stacks);
|
|
|
|
return;
|
|
}
|
|
}
|
|
ModuleValueConstructor::Fn { name, .. } => {
|
|
let type_info = self.module_types.get(module_name).unwrap();
|
|
let value = type_info.values.get(name).unwrap();
|
|
|
|
let ValueConstructorVariant::ModuleFn { builtin, .. } = &value.variant else {unreachable!()};
|
|
|
|
if let Some(func) = builtin {
|
|
let Some(fun_arg_types) = fun.tipo().arg_types() else {unreachable!()};
|
|
|
|
let mut stacks = Vec::new();
|
|
for (arg, func_type) in args.iter().zip(fun_arg_types) {
|
|
let mut stack = ir_stack.empty_with_scope();
|
|
|
|
if func_type.is_data() && !arg.value.tipo().is_data() {
|
|
stack.wrap_data(arg.value.tipo());
|
|
}
|
|
|
|
self.build(&arg.value, &mut stack);
|
|
|
|
stacks.push(stack);
|
|
}
|
|
|
|
ir_stack.builtin(*func, tipo.clone(), stacks);
|
|
|
|
return;
|
|
}
|
|
}
|
|
_ => {}
|
|
},
|
|
_ => {}
|
|
}
|
|
|
|
let mut fun_stack = ir_stack.empty_with_scope();
|
|
|
|
self.build(fun, &mut fun_stack);
|
|
|
|
let fun_arg_types = fun.tipo().arg_types().unwrap_or_default();
|
|
|
|
let mut stacks = Vec::new();
|
|
for (arg, func_type) in args.iter().zip(fun_arg_types) {
|
|
let mut stack = ir_stack.empty_with_scope();
|
|
|
|
if func_type.is_data() && !arg.value.tipo().is_data() {
|
|
stack.wrap_data(arg.value.tipo());
|
|
}
|
|
|
|
self.build(&arg.value, &mut stack);
|
|
|
|
stacks.push(stack);
|
|
}
|
|
|
|
ir_stack.call(tipo.clone(), fun_stack, stacks);
|
|
}
|
|
TypedExpr::BinOp {
|
|
name, left, right, ..
|
|
} => {
|
|
let mut left_stack = ir_stack.empty_with_scope();
|
|
let mut right_stack = ir_stack.empty_with_scope();
|
|
|
|
self.build(left, &mut left_stack);
|
|
self.build(right, &mut right_stack);
|
|
|
|
ir_stack.binop(*name, left.tipo(), left_stack, right_stack);
|
|
}
|
|
TypedExpr::Assignment {
|
|
value,
|
|
pattern,
|
|
kind,
|
|
tipo,
|
|
..
|
|
} => {
|
|
let mut value_stack = ir_stack.empty_with_scope();
|
|
let mut pattern_stack = ir_stack.empty_with_scope();
|
|
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
self.build(value, &mut value_stack);
|
|
|
|
self.assignment(
|
|
pattern,
|
|
&mut pattern_stack,
|
|
value_stack,
|
|
&replaced_type,
|
|
AssignmentProperties {
|
|
value_type: value.tipo(),
|
|
kind: *kind,
|
|
},
|
|
);
|
|
|
|
ir_stack.merge(pattern_stack);
|
|
}
|
|
TypedExpr::When {
|
|
subject, clauses, ..
|
|
} => {
|
|
let subject_name = format!("__subject_name_{}", self.id_gen.next());
|
|
let constr_var = format!("__constr_name_{}", self.id_gen.next());
|
|
|
|
let subject_tipo = subject.tipo();
|
|
|
|
if clauses.len() <= 1 {
|
|
let mut value_stack = ir_stack.empty_with_scope();
|
|
let mut pattern_stack = ir_stack.empty_with_scope();
|
|
let mut subject_stack = ir_stack.empty_with_scope();
|
|
|
|
self.build(&clauses[0].then, &mut value_stack);
|
|
|
|
self.build(subject, &mut subject_stack);
|
|
|
|
self.assignment(
|
|
&clauses[0].pattern,
|
|
&mut pattern_stack,
|
|
subject_stack,
|
|
&subject_tipo,
|
|
AssignmentProperties {
|
|
value_type: clauses[0].then.tipo(),
|
|
kind: AssignmentKind::Let,
|
|
},
|
|
);
|
|
|
|
pattern_stack.merge_child(value_stack);
|
|
ir_stack.merge_child(pattern_stack);
|
|
} else {
|
|
// TODO: go over rearrange clauses
|
|
let clauses = if subject_tipo.is_list() {
|
|
builder::rearrange_clauses(clauses.clone())
|
|
} else {
|
|
clauses.clone()
|
|
};
|
|
|
|
if let Some((last_clause, clauses)) = clauses.split_last() {
|
|
let mut pattern_stack = ir_stack.empty_with_scope();
|
|
|
|
let mut clause_properties = ClauseProperties::init(
|
|
&subject_tipo,
|
|
constr_var.clone(),
|
|
subject_name.clone(),
|
|
);
|
|
|
|
self.handle_each_clause(
|
|
&mut pattern_stack,
|
|
&mut clause_properties,
|
|
clauses,
|
|
&subject_tipo,
|
|
);
|
|
|
|
let last_pattern = &last_clause.pattern;
|
|
|
|
let mut final_pattern_stack = ir_stack.empty_with_scope();
|
|
let mut final_clause_stack = ir_stack.empty_with_scope();
|
|
let mut finally_stack = ir_stack.empty_with_scope();
|
|
|
|
self.build(&last_clause.then, &mut final_clause_stack);
|
|
|
|
*clause_properties.is_final_clause() = true;
|
|
|
|
self.when_pattern(
|
|
last_pattern,
|
|
&mut final_pattern_stack,
|
|
final_clause_stack,
|
|
&subject_tipo,
|
|
&mut clause_properties,
|
|
);
|
|
|
|
if !matches!(last_pattern, Pattern::Tuple { .. }) {
|
|
finally_stack.finally(final_pattern_stack);
|
|
} else {
|
|
finally_stack.merge(final_pattern_stack);
|
|
}
|
|
|
|
if *clause_properties.needs_constr_var() {
|
|
let mut subject_stack = ir_stack.empty_with_scope();
|
|
|
|
self.build(subject, &mut subject_stack);
|
|
|
|
ir_stack.let_assignment(constr_var.clone(), subject_stack);
|
|
|
|
let mut var_stack = ir_stack.empty_with_scope();
|
|
|
|
var_stack.local_var(subject_tipo.clone(), constr_var);
|
|
|
|
ir_stack.when(
|
|
subject_tipo,
|
|
subject_name,
|
|
var_stack,
|
|
pattern_stack,
|
|
finally_stack,
|
|
);
|
|
} else {
|
|
let mut subject_stack = ir_stack.empty_with_scope();
|
|
|
|
self.build(subject, &mut subject_stack);
|
|
|
|
ir_stack.when(
|
|
subject_tipo,
|
|
subject_name,
|
|
subject_stack,
|
|
pattern_stack,
|
|
finally_stack,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
TypedExpr::If {
|
|
branches,
|
|
final_else,
|
|
tipo,
|
|
..
|
|
} => {
|
|
for branch in branches.iter() {
|
|
let mut condition_stack = ir_stack.empty_with_scope();
|
|
let mut branch_body_stack = ir_stack.empty_with_scope();
|
|
|
|
self.build(&branch.condition, &mut condition_stack);
|
|
|
|
self.build(&branch.body, &mut branch_body_stack);
|
|
|
|
ir_stack.if_branch(tipo.clone(), condition_stack, branch_body_stack);
|
|
}
|
|
|
|
let mut else_stack = ir_stack.empty_with_scope();
|
|
|
|
self.build(final_else, &mut else_stack);
|
|
|
|
ir_stack.merge_child(else_stack);
|
|
}
|
|
TypedExpr::RecordAccess {
|
|
record,
|
|
index,
|
|
tipo,
|
|
..
|
|
} => {
|
|
let mut record_access_stack = ir_stack.empty_with_scope();
|
|
|
|
self.build(record, &mut record_access_stack);
|
|
|
|
ir_stack.record_access(tipo.clone(), *index, record_access_stack);
|
|
}
|
|
TypedExpr::ModuleSelect {
|
|
constructor,
|
|
module_name,
|
|
tipo,
|
|
..
|
|
} => match constructor {
|
|
ModuleValueConstructor::Record { .. } => {
|
|
todo!("Records from modules not yet implemented.")
|
|
}
|
|
ModuleValueConstructor::Fn { name, module, .. } => {
|
|
let func = self.functions.get(&FunctionAccessKey {
|
|
module_name: module_name.clone(),
|
|
function_name: name.clone(),
|
|
variant_name: String::new(),
|
|
});
|
|
|
|
let type_info = self.module_types.get(module_name).unwrap();
|
|
let value = type_info.values.get(name).unwrap();
|
|
|
|
if let Some(_func) = func {
|
|
ir_stack.var(
|
|
ValueConstructor::public(tipo.clone(), value.variant.clone()),
|
|
format!("{module}_{name}"),
|
|
"",
|
|
);
|
|
} else {
|
|
let ValueConstructorVariant::ModuleFn {
|
|
builtin: Some(builtin), ..
|
|
} = &value.variant else {
|
|
unreachable!()
|
|
};
|
|
|
|
ir_stack.builtin(*builtin, tipo.clone(), vec![]);
|
|
}
|
|
}
|
|
ModuleValueConstructor::Constant { literal, .. } => {
|
|
builder::constants_ir(literal, ir_stack);
|
|
}
|
|
},
|
|
TypedExpr::RecordUpdate {
|
|
spread, args, tipo, ..
|
|
} => {
|
|
let mut index_types = vec![];
|
|
let mut highest_index = 0;
|
|
|
|
let mut update_stack = ir_stack.empty_with_scope();
|
|
|
|
self.build(spread, &mut update_stack);
|
|
|
|
for arg in args {
|
|
let mut arg_stack = update_stack.empty_with_scope();
|
|
|
|
self.build(&arg.value, &mut arg_stack);
|
|
|
|
update_stack.merge(arg_stack);
|
|
|
|
if arg.index > highest_index {
|
|
highest_index = arg.index;
|
|
}
|
|
|
|
index_types.push((arg.index, arg.value.tipo()));
|
|
}
|
|
|
|
ir_stack.record_update(tipo.clone(), highest_index, index_types, update_stack);
|
|
}
|
|
TypedExpr::UnOp { value, op, .. } => {
|
|
let mut value_stack = ir_stack.empty_with_scope();
|
|
|
|
self.build(value, &mut value_stack);
|
|
|
|
ir_stack.unop(*op, value_stack);
|
|
}
|
|
TypedExpr::Tuple { elems, tipo, .. } => {
|
|
let mut stacks = vec![];
|
|
|
|
for elem in elems {
|
|
let mut elem_stack = ir_stack.empty_with_scope();
|
|
self.build(elem, &mut elem_stack);
|
|
stacks.push(elem_stack);
|
|
}
|
|
|
|
ir_stack.tuple(tipo.clone(), stacks);
|
|
}
|
|
|
|
TypedExpr::Trace {
|
|
tipo, then, text, ..
|
|
} => {
|
|
let mut text_stack = ir_stack.empty_with_scope();
|
|
let mut then_stack = ir_stack.empty_with_scope();
|
|
|
|
self.build(text, &mut text_stack);
|
|
self.build(then, &mut then_stack);
|
|
|
|
ir_stack.trace(tipo.clone());
|
|
ir_stack.merge_child(text_stack);
|
|
ir_stack.merge_child(then_stack);
|
|
}
|
|
|
|
TypedExpr::TupleIndex { index, tuple, .. } => {
|
|
let mut tuple_stack = ir_stack.empty_with_scope();
|
|
|
|
self.build(tuple, &mut tuple_stack);
|
|
|
|
ir_stack.tuple_index(tuple.tipo(), *index, tuple_stack);
|
|
}
|
|
|
|
TypedExpr::ErrorTerm { tipo, .. } => {
|
|
ir_stack.error(tipo.clone());
|
|
}
|
|
}
|
|
}
|
|
|
|
fn handle_each_clause(
|
|
&mut self,
|
|
ir_stack: &mut AirStack,
|
|
clause_properties: &mut ClauseProperties,
|
|
clauses: &[TypedClause],
|
|
subject_type: &Arc<Type>,
|
|
) {
|
|
for (index, clause) in clauses.iter().enumerate() {
|
|
// holds when clause pattern Air
|
|
let mut clause_pattern_stack = ir_stack.empty_with_scope();
|
|
let mut clause_then_stack = ir_stack.empty_with_scope();
|
|
|
|
// reset complex clause setting per clause back to default
|
|
*clause_properties.is_complex_clause() = false;
|
|
|
|
self.build(&clause.then, &mut clause_then_stack);
|
|
|
|
if let Some(clause_guard) = &clause.guard {
|
|
let mut clause_guard_stack = ir_stack.empty_with_scope();
|
|
let mut clause_guard_condition = ir_stack.empty_with_scope();
|
|
|
|
*clause_properties.is_complex_clause() = true;
|
|
|
|
let clause_guard_name = format!("__clause_guard_{}", self.id_gen.next());
|
|
|
|
builder::handle_clause_guard(clause_guard, &mut clause_guard_condition);
|
|
|
|
clause_guard_stack
|
|
.let_assignment(clause_guard_name.clone(), clause_guard_condition);
|
|
|
|
let mut condition_stack = ir_stack.empty_with_scope();
|
|
|
|
condition_stack.bool(true);
|
|
|
|
clause_guard_stack.clause_guard(
|
|
clause_guard_name,
|
|
bool(),
|
|
condition_stack,
|
|
clause_then_stack,
|
|
);
|
|
|
|
clause_then_stack = clause_guard_stack;
|
|
}
|
|
|
|
match clause_properties {
|
|
ClauseProperties::ConstrClause {
|
|
original_subject_name,
|
|
..
|
|
} => {
|
|
let subject_name = original_subject_name.clone();
|
|
|
|
self.when_pattern(
|
|
&clause.pattern,
|
|
&mut clause_pattern_stack,
|
|
clause_then_stack,
|
|
subject_type,
|
|
clause_properties,
|
|
);
|
|
|
|
let data_type =
|
|
builder::lookup_data_type_by_tipo(self.data_types.clone(), subject_type);
|
|
|
|
if let Some(data_type) = data_type {
|
|
if data_type.constructors.len() > 1 {
|
|
ir_stack.clause(
|
|
subject_type.clone(),
|
|
subject_name,
|
|
*clause_properties.is_complex_clause(),
|
|
clause_pattern_stack,
|
|
);
|
|
} else {
|
|
let mut condition_stack = ir_stack.empty_with_scope();
|
|
|
|
condition_stack.integer(0.to_string());
|
|
|
|
condition_stack.merge_child(clause_pattern_stack);
|
|
|
|
ir_stack.clause(
|
|
subject_type.clone(),
|
|
subject_name,
|
|
*clause_properties.is_complex_clause(),
|
|
condition_stack,
|
|
);
|
|
}
|
|
} else {
|
|
ir_stack.clause(
|
|
subject_type.clone(),
|
|
subject_name,
|
|
*clause_properties.is_complex_clause(),
|
|
clause_pattern_stack,
|
|
);
|
|
}
|
|
}
|
|
ClauseProperties::ListClause {
|
|
original_subject_name,
|
|
current_index,
|
|
..
|
|
} => {
|
|
let (current_clause_index, has_tail) =
|
|
if let Pattern::List { elements, tail, .. } = &clause.pattern {
|
|
(elements.len(), tail.is_some())
|
|
} else if let Pattern::Assign { pattern, .. } = &clause.pattern {
|
|
let Pattern::List { elements, tail, .. } = pattern.as_ref() else {
|
|
unreachable!("{:#?}", pattern)
|
|
};
|
|
|
|
(elements.len(), tail.is_some())
|
|
} else {
|
|
unreachable!("{:#?}", &clause.pattern)
|
|
};
|
|
|
|
let prev_index = *current_index;
|
|
|
|
let subject_name = if current_clause_index == 0 {
|
|
original_subject_name.clone()
|
|
} else {
|
|
format!("__tail_{}", current_clause_index - 1)
|
|
};
|
|
|
|
self.when_pattern(
|
|
&clause.pattern,
|
|
&mut clause_pattern_stack,
|
|
clause_then_stack,
|
|
subject_type,
|
|
clause_properties,
|
|
);
|
|
|
|
let next_tail = if index == clauses.len() - 1 {
|
|
None
|
|
} else {
|
|
let next_list_size = if let Pattern::List { elements, .. } =
|
|
&clauses[index + 1].pattern
|
|
{
|
|
elements.len()
|
|
} else if let Pattern::Assign { pattern, .. } = &clauses[index + 1].pattern
|
|
{
|
|
let Pattern::List { elements, .. } = pattern.as_ref() else {
|
|
unreachable!("{:#?}", pattern)
|
|
};
|
|
elements.len()
|
|
} else {
|
|
unreachable!()
|
|
};
|
|
|
|
if next_list_size == current_clause_index {
|
|
None
|
|
} else {
|
|
Some(format!("__tail_{current_clause_index}"))
|
|
}
|
|
};
|
|
|
|
let minus_tail = has_tail as i64;
|
|
|
|
if current_clause_index as i64 - minus_tail == prev_index {
|
|
ir_stack.wrap_clause(clause_pattern_stack);
|
|
} else {
|
|
ir_stack.list_clause(
|
|
subject_type.clone(),
|
|
subject_name,
|
|
next_tail,
|
|
*clause_properties.is_complex_clause(),
|
|
clause_pattern_stack,
|
|
);
|
|
}
|
|
|
|
let ClauseProperties::ListClause { current_index, .. } = clause_properties else {
|
|
unreachable!()
|
|
};
|
|
|
|
*current_index = current_clause_index as i64;
|
|
}
|
|
ClauseProperties::TupleClause {
|
|
original_subject_name,
|
|
defined_tuple_indices,
|
|
..
|
|
} => {
|
|
let prev_defined_tuple_indices = defined_tuple_indices.clone();
|
|
let subject_name = original_subject_name.clone();
|
|
|
|
self.when_pattern(
|
|
&clause.pattern,
|
|
&mut clause_pattern_stack,
|
|
clause_then_stack,
|
|
subject_type,
|
|
clause_properties,
|
|
);
|
|
|
|
let current_defined_tuple_indices = match clause_properties {
|
|
ClauseProperties::TupleClause {
|
|
defined_tuple_indices,
|
|
..
|
|
} => defined_tuple_indices.clone(),
|
|
_ => unreachable!(),
|
|
};
|
|
|
|
let indices_to_define = current_defined_tuple_indices
|
|
.difference(&prev_defined_tuple_indices)
|
|
.cloned()
|
|
.collect();
|
|
|
|
ir_stack.tuple_clause(
|
|
subject_type.clone(),
|
|
subject_name,
|
|
indices_to_define,
|
|
prev_defined_tuple_indices,
|
|
*clause_properties.is_complex_clause(),
|
|
clause_pattern_stack,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn when_pattern(
|
|
&mut self,
|
|
pattern: &Pattern<PatternConstructor, Arc<Type>>,
|
|
pattern_stack: &mut AirStack,
|
|
value_stack: AirStack,
|
|
tipo: &Type,
|
|
clause_properties: &mut ClauseProperties,
|
|
) {
|
|
match pattern {
|
|
Pattern::Int { value, .. } => {
|
|
pattern_stack.integer(value.clone());
|
|
|
|
pattern_stack.merge_child(value_stack);
|
|
}
|
|
Pattern::Var { name, .. } => {
|
|
pattern_stack.void();
|
|
|
|
let mut var_stack = pattern_stack.empty_with_scope();
|
|
|
|
var_stack.local_var(
|
|
tipo.clone().into(),
|
|
clause_properties.original_subject_name(),
|
|
);
|
|
|
|
pattern_stack.let_assignment(name, var_stack);
|
|
|
|
pattern_stack.merge_child(value_stack);
|
|
}
|
|
Pattern::Assign { name, pattern, .. } => {
|
|
let mut new_stack = pattern_stack.empty_with_scope();
|
|
|
|
new_stack.local_var(
|
|
tipo.clone().into(),
|
|
clause_properties.original_subject_name(),
|
|
);
|
|
|
|
let mut let_stack = pattern_stack.empty_with_scope();
|
|
|
|
let_stack.let_assignment(name.clone(), new_stack);
|
|
|
|
let_stack.merge_child(value_stack);
|
|
|
|
self.when_pattern(pattern, pattern_stack, let_stack, tipo, clause_properties);
|
|
}
|
|
Pattern::Discard { .. } => {
|
|
pattern_stack.void();
|
|
pattern_stack.merge_child(value_stack);
|
|
}
|
|
Pattern::List { elements, tail, .. } => {
|
|
for element in elements {
|
|
builder::check_when_pattern_needs(element, clause_properties);
|
|
}
|
|
|
|
if let Some(tail) = tail {
|
|
builder::check_when_pattern_needs(tail, clause_properties);
|
|
}
|
|
|
|
*clause_properties.needs_constr_var() = false;
|
|
|
|
pattern_stack.void();
|
|
|
|
self.expose_elements(pattern, pattern_stack, value_stack, clause_properties, tipo);
|
|
}
|
|
Pattern::Constructor {
|
|
arguments,
|
|
name: constr_name,
|
|
..
|
|
} => {
|
|
let mut temp_clause_properties = clause_properties.clone();
|
|
*temp_clause_properties.needs_constr_var() = false;
|
|
|
|
if tipo.is_bool() {
|
|
pattern_stack.bool(constr_name == "True");
|
|
} else {
|
|
for arg in arguments {
|
|
builder::check_when_pattern_needs(&arg.value, &mut temp_clause_properties);
|
|
}
|
|
|
|
// find data type definition
|
|
let data_type =
|
|
builder::lookup_data_type_by_tipo(self.data_types.clone(), tipo).unwrap();
|
|
|
|
let (index, _) = data_type
|
|
.constructors
|
|
.iter()
|
|
.enumerate()
|
|
.find(|(_, dt)| &dt.name == constr_name)
|
|
.unwrap();
|
|
|
|
let mut new_stack = pattern_stack.empty_with_scope();
|
|
|
|
new_stack.local_var(
|
|
tipo.clone().into(),
|
|
temp_clause_properties.clause_var_name(),
|
|
);
|
|
|
|
// if only one constructor, no need to check
|
|
if data_type.constructors.len() > 1 {
|
|
// push constructor Index
|
|
pattern_stack.integer(index.to_string());
|
|
}
|
|
|
|
if *temp_clause_properties.needs_constr_var() {
|
|
self.expose_elements(
|
|
pattern,
|
|
pattern_stack,
|
|
new_stack,
|
|
clause_properties,
|
|
tipo,
|
|
);
|
|
} else {
|
|
let empty_stack = pattern_stack.empty_with_scope();
|
|
|
|
self.expose_elements(
|
|
pattern,
|
|
pattern_stack,
|
|
empty_stack,
|
|
clause_properties,
|
|
tipo,
|
|
);
|
|
}
|
|
}
|
|
|
|
pattern_stack.merge_child(value_stack);
|
|
|
|
// unify clause properties
|
|
*clause_properties.is_complex_clause() = *clause_properties.is_complex_clause()
|
|
|| *temp_clause_properties.is_complex_clause();
|
|
|
|
*clause_properties.needs_constr_var() = *clause_properties.needs_constr_var()
|
|
|| *temp_clause_properties.needs_constr_var();
|
|
}
|
|
Pattern::Tuple { elems, .. } => {
|
|
for elem in elems {
|
|
builder::check_when_pattern_needs(elem, clause_properties);
|
|
}
|
|
|
|
*clause_properties.needs_constr_var() = false;
|
|
|
|
let temp = pattern_stack.empty_with_scope();
|
|
|
|
self.expose_elements(pattern, pattern_stack, temp, clause_properties, tipo);
|
|
|
|
pattern_stack.merge_child(value_stack);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn expose_elements(
|
|
&mut self,
|
|
pattern: &Pattern<PatternConstructor, Arc<Type>>,
|
|
pattern_stack: &mut AirStack,
|
|
value_stack: AirStack,
|
|
clause_properties: &mut ClauseProperties,
|
|
tipo: &Type,
|
|
) {
|
|
match pattern {
|
|
Pattern::Int { .. } => unreachable!(),
|
|
Pattern::Var { .. } => unreachable!(),
|
|
Pattern::Assign { .. } => todo!("Nested assign not yet implemented"),
|
|
Pattern::Discard { .. } => {
|
|
pattern_stack.void();
|
|
|
|
pattern_stack.merge_child(value_stack);
|
|
}
|
|
Pattern::List { elements, tail, .. } => {
|
|
let mut names = vec![];
|
|
let mut nested_pattern = pattern_stack.empty_with_scope();
|
|
let items_type = &tipo.get_inner_types()[0];
|
|
// let mut nested_pattern = vec![];
|
|
for element in elements {
|
|
let name = self.nested_pattern_ir_and_label(
|
|
element,
|
|
&mut nested_pattern,
|
|
items_type,
|
|
*clause_properties.is_final_clause(),
|
|
);
|
|
|
|
names.push(name.unwrap_or_else(|| "_".to_string()))
|
|
}
|
|
|
|
let mut tail_name = String::new();
|
|
|
|
if let Some(tail) = tail {
|
|
match &**tail {
|
|
Pattern::Var { name, .. } => {
|
|
tail_name = name.clone();
|
|
}
|
|
Pattern::Discard { .. } => {
|
|
tail_name = "_".to_string();
|
|
}
|
|
_ => unreachable!("Patterns in tail of list should not allow this"),
|
|
}
|
|
}
|
|
|
|
let tail_head_names = names
|
|
.iter()
|
|
.enumerate()
|
|
.filter(|(_, name)| *name != &"_".to_string())
|
|
.map(|(index, name)| {
|
|
if index == 0 {
|
|
(
|
|
clause_properties.original_subject_name().clone(),
|
|
name.clone(),
|
|
)
|
|
} else {
|
|
(format!("__tail_{}", index - 1), name.clone())
|
|
}
|
|
})
|
|
.collect_vec();
|
|
|
|
if tail.is_some() && !elements.is_empty() {
|
|
let tail_var = if elements.len() == 1 {
|
|
clause_properties.original_subject_name().clone()
|
|
} else {
|
|
format!("__tail_{}", elements.len() - 2)
|
|
};
|
|
|
|
let tail = if &tail_name == "_" {
|
|
None
|
|
} else {
|
|
Some((tail_var, tail_name))
|
|
};
|
|
|
|
pattern_stack.list_expose(
|
|
tipo.clone().into(),
|
|
tail_head_names,
|
|
tail,
|
|
nested_pattern,
|
|
);
|
|
} else if !elements.is_empty() {
|
|
pattern_stack.list_expose(
|
|
tipo.clone().into(),
|
|
tail_head_names,
|
|
None,
|
|
nested_pattern,
|
|
);
|
|
}
|
|
|
|
pattern_stack.merge_child(value_stack);
|
|
}
|
|
Pattern::Constructor {
|
|
is_record,
|
|
name: constr_name,
|
|
arguments,
|
|
constructor,
|
|
tipo,
|
|
..
|
|
} => {
|
|
let data_type =
|
|
builder::lookup_data_type_by_tipo(self.data_types.clone(), tipo).unwrap();
|
|
|
|
let (_, constructor_type) = data_type
|
|
.constructors
|
|
.iter()
|
|
.enumerate()
|
|
.find(|(_, dt)| &dt.name == constr_name)
|
|
.unwrap();
|
|
let mut nested_pattern = pattern_stack.empty_with_scope();
|
|
if *is_record {
|
|
let field_map = match constructor {
|
|
PatternConstructor::Record { field_map, .. } => field_map.clone().unwrap(),
|
|
};
|
|
|
|
let mut type_map: IndexMap<String, Arc<Type>> = IndexMap::new();
|
|
|
|
for (index, arg) in tipo.arg_types().unwrap().iter().enumerate() {
|
|
let label = constructor_type.arguments[index].label.clone().unwrap();
|
|
let field_type = arg.clone();
|
|
|
|
type_map.insert(label, field_type);
|
|
}
|
|
|
|
let arguments_index = arguments
|
|
.iter()
|
|
.filter_map(|item| {
|
|
let label = item.label.clone().unwrap_or_default();
|
|
let field_index = field_map
|
|
.fields
|
|
.get(&label)
|
|
.map(|(index, _)| index)
|
|
.unwrap_or(&0);
|
|
let var_name = self.nested_pattern_ir_and_label(
|
|
&item.value,
|
|
&mut nested_pattern,
|
|
type_map.get(&label).unwrap_or(
|
|
&Type::App {
|
|
public: true,
|
|
module: "".to_string(),
|
|
name: "Discard".to_string(),
|
|
args: vec![],
|
|
}
|
|
.into(),
|
|
),
|
|
*clause_properties.is_final_clause(),
|
|
);
|
|
|
|
var_name.map_or(
|
|
Some((label.clone(), "_".to_string(), *field_index)),
|
|
|var_name| Some((label, var_name, *field_index)),
|
|
)
|
|
})
|
|
.sorted_by(|item1, item2| item1.2.cmp(&item2.2))
|
|
.collect::<Vec<(String, String, usize)>>();
|
|
let indices = arguments_index
|
|
.iter()
|
|
.map(|(label, var_name, index)| {
|
|
let field_type = type_map
|
|
.get(label)
|
|
.unwrap_or_else(|| type_map.get_index(*index).unwrap().1);
|
|
(*index, var_name.clone(), field_type.clone())
|
|
})
|
|
.collect_vec();
|
|
|
|
if indices.is_empty() {
|
|
pattern_stack.merge_child(value_stack);
|
|
} else {
|
|
pattern_stack.fields_expose(indices, false, value_stack);
|
|
}
|
|
} else {
|
|
let mut type_map: IndexMap<usize, Arc<Type>> = IndexMap::new();
|
|
|
|
for (index, arg) in tipo.arg_types().unwrap().iter().enumerate() {
|
|
let field_type = arg.clone();
|
|
|
|
type_map.insert(index, field_type);
|
|
}
|
|
|
|
let arguments_index = arguments
|
|
.iter()
|
|
.enumerate()
|
|
.filter_map(|(index, item)| {
|
|
let var_name = self.nested_pattern_ir_and_label(
|
|
&item.value,
|
|
&mut nested_pattern,
|
|
type_map.get(&index).unwrap(),
|
|
*clause_properties.is_final_clause(),
|
|
);
|
|
|
|
var_name.map_or(Some(("_".to_string(), index)), |var_name| {
|
|
Some((var_name, index))
|
|
})
|
|
})
|
|
.collect::<Vec<(String, usize)>>();
|
|
|
|
let indices = arguments_index
|
|
.iter()
|
|
.map(|(name, index)| {
|
|
let field_type = type_map.get(index).unwrap();
|
|
|
|
(*index, name.clone(), field_type.clone())
|
|
})
|
|
.collect_vec();
|
|
|
|
if indices.is_empty() {
|
|
pattern_stack.merge_child(value_stack);
|
|
} else {
|
|
pattern_stack.fields_expose(indices, false, value_stack);
|
|
}
|
|
}
|
|
|
|
pattern_stack.merge_child(nested_pattern);
|
|
}
|
|
Pattern::Tuple { elems, .. } => {
|
|
let mut names = vec![];
|
|
let mut nested_pattern = pattern_stack.empty_with_scope();
|
|
let items_type = &tipo.get_inner_types();
|
|
|
|
for (index, element) in elems.iter().enumerate() {
|
|
let name = self.nested_pattern_ir_and_label(
|
|
element,
|
|
&mut nested_pattern,
|
|
&items_type[index],
|
|
*clause_properties.is_final_clause(),
|
|
);
|
|
|
|
names.push((name.unwrap_or_else(|| "_".to_string()), index))
|
|
}
|
|
let mut defined_indices = match clause_properties.clone() {
|
|
ClauseProperties::TupleClause {
|
|
defined_tuple_indices,
|
|
..
|
|
} => defined_tuple_indices,
|
|
_ => unreachable!(),
|
|
};
|
|
|
|
let mut previous_defined_names = vec![];
|
|
for (name, index) in names.clone() {
|
|
if let Some(defined_index) = defined_indices
|
|
.iter()
|
|
.find(|(defined_index, _)| *defined_index == index)
|
|
{
|
|
previous_defined_names.push(defined_index.clone());
|
|
} else {
|
|
defined_indices.insert((index, name));
|
|
}
|
|
}
|
|
|
|
for (index, name) in previous_defined_names {
|
|
let mut var_stack = pattern_stack.empty_with_scope();
|
|
|
|
let new_name = names
|
|
.iter()
|
|
.find(|(_, current_index)| *current_index == index)
|
|
.map(|(new_name, _)| new_name)
|
|
.unwrap();
|
|
|
|
let pattern_type = &tipo.get_inner_types()[index];
|
|
|
|
var_stack.local_var(pattern_type.clone(), name);
|
|
|
|
pattern_stack.let_assignment(new_name, var_stack);
|
|
}
|
|
|
|
match clause_properties {
|
|
ClauseProperties::TupleClause {
|
|
defined_tuple_indices,
|
|
..
|
|
} => {
|
|
*defined_tuple_indices = defined_indices;
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
|
|
pattern_stack.merge_child(nested_pattern);
|
|
pattern_stack.merge_child(value_stack);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn nested_pattern_ir_and_label(
|
|
&mut self,
|
|
pattern: &Pattern<PatternConstructor, Arc<Type>>,
|
|
pattern_stack: &mut AirStack,
|
|
pattern_type: &Type,
|
|
final_clause: bool,
|
|
) -> Option<String> {
|
|
match pattern {
|
|
Pattern::Var { name, .. } => Some(name.clone()),
|
|
Pattern::Discard { .. } => None,
|
|
pattern @ Pattern::List { elements, tail, .. } => {
|
|
let item_name = format!("__list_item_id_{}", self.id_gen.next());
|
|
let new_tail_name = "__tail".to_string();
|
|
|
|
if elements.is_empty() {
|
|
let mut void_stack = pattern_stack.empty_with_scope();
|
|
|
|
void_stack.void();
|
|
|
|
pattern_stack.list_clause_guard(
|
|
pattern_type.clone().into(),
|
|
item_name.clone(),
|
|
None,
|
|
false,
|
|
void_stack,
|
|
);
|
|
} else {
|
|
for (index, _) in elements.iter().enumerate() {
|
|
let prev_tail_name = if index == 0 {
|
|
item_name.clone()
|
|
} else {
|
|
format!("{}_{}", new_tail_name, index - 1)
|
|
};
|
|
|
|
let mut clause_properties = ClauseProperties::ListClause {
|
|
clause_var_name: item_name.clone(),
|
|
needs_constr_var: false,
|
|
is_complex_clause: false,
|
|
original_subject_name: item_name.clone(),
|
|
current_index: index as i64,
|
|
final_clause,
|
|
};
|
|
|
|
let tail_name = format!("{new_tail_name}_{index}");
|
|
|
|
if elements.len() - 1 == index {
|
|
if tail.is_some() {
|
|
let mut elements_stack = pattern_stack.empty_with_scope();
|
|
|
|
self.when_pattern(
|
|
pattern,
|
|
&mut elements_stack,
|
|
pattern_stack.empty_with_scope(),
|
|
pattern_type,
|
|
&mut clause_properties,
|
|
);
|
|
|
|
pattern_stack.list_clause_guard(
|
|
pattern_type.clone().into(),
|
|
prev_tail_name,
|
|
None,
|
|
true,
|
|
elements_stack,
|
|
);
|
|
} else {
|
|
let mut elements_stack = pattern_stack.empty_with_scope();
|
|
|
|
let mut void_stack = pattern_stack.empty_with_scope();
|
|
|
|
void_stack.void();
|
|
|
|
self.when_pattern(
|
|
pattern,
|
|
&mut elements_stack,
|
|
pattern_stack.empty_with_scope(),
|
|
pattern_type,
|
|
&mut clause_properties,
|
|
);
|
|
|
|
void_stack.list_clause_guard(
|
|
pattern_type.clone().into(),
|
|
&tail_name,
|
|
None,
|
|
false,
|
|
elements_stack,
|
|
);
|
|
|
|
pattern_stack.list_clause_guard(
|
|
pattern_type.clone().into(),
|
|
prev_tail_name,
|
|
Some(tail_name),
|
|
true,
|
|
void_stack,
|
|
);
|
|
}
|
|
} else {
|
|
let mut void_stack = pattern_stack.empty_with_scope();
|
|
|
|
void_stack.void();
|
|
|
|
pattern_stack.list_clause_guard(
|
|
pattern_type.clone().into(),
|
|
prev_tail_name,
|
|
Some(tail_name),
|
|
true,
|
|
void_stack,
|
|
);
|
|
};
|
|
}
|
|
}
|
|
|
|
Some(item_name)
|
|
}
|
|
pattern @ Pattern::Constructor {
|
|
tipo,
|
|
name: constr_name,
|
|
..
|
|
} => {
|
|
let id = self.id_gen.next();
|
|
let constr_var_name = format!("{constr_name}_{id}");
|
|
let data_type =
|
|
builder::lookup_data_type_by_tipo(self.data_types.clone(), tipo).unwrap();
|
|
|
|
let mut when_stack = pattern_stack.empty_with_scope();
|
|
|
|
let mut clause_properties = ClauseProperties::ConstrClause {
|
|
clause_var_name: constr_var_name.clone(),
|
|
needs_constr_var: false,
|
|
is_complex_clause: false,
|
|
original_subject_name: constr_var_name.clone(),
|
|
final_clause,
|
|
};
|
|
|
|
self.when_pattern(
|
|
pattern,
|
|
&mut when_stack,
|
|
pattern_stack.empty_with_scope(),
|
|
tipo,
|
|
&mut clause_properties,
|
|
);
|
|
|
|
if data_type.constructors.len() > 1 {
|
|
if final_clause {
|
|
pattern_stack.finally(when_stack);
|
|
} else {
|
|
let empty_stack = pattern_stack.empty_with_scope();
|
|
pattern_stack.clause_guard(
|
|
constr_var_name.clone(),
|
|
tipo.clone(),
|
|
when_stack,
|
|
empty_stack,
|
|
);
|
|
}
|
|
}
|
|
|
|
Some(constr_var_name)
|
|
}
|
|
a @ Pattern::Tuple { .. } => {
|
|
let item_name = format!("__tuple_item_id_{}", self.id_gen.next());
|
|
|
|
let mut clause_properties = ClauseProperties::TupleClause {
|
|
clause_var_name: item_name.clone(),
|
|
needs_constr_var: false,
|
|
is_complex_clause: false,
|
|
original_subject_name: item_name.clone(),
|
|
defined_tuple_indices: IndexSet::new(),
|
|
final_clause,
|
|
};
|
|
|
|
let mut inner_pattern_stack = pattern_stack.empty_with_scope();
|
|
|
|
self.when_pattern(
|
|
a,
|
|
&mut inner_pattern_stack,
|
|
pattern_stack.empty_with_scope(),
|
|
pattern_type,
|
|
&mut clause_properties,
|
|
);
|
|
|
|
let defined_indices = match clause_properties.clone() {
|
|
ClauseProperties::TupleClause {
|
|
defined_tuple_indices,
|
|
..
|
|
} => defined_tuple_indices,
|
|
_ => unreachable!(),
|
|
};
|
|
|
|
pattern_stack.tuple_clause(
|
|
pattern_type.clone().into(),
|
|
clause_properties.original_subject_name(),
|
|
defined_indices,
|
|
IndexSet::new(),
|
|
false,
|
|
inner_pattern_stack,
|
|
);
|
|
|
|
Some(item_name)
|
|
}
|
|
Pattern::Assign { name, pattern, .. } => {
|
|
let inner_name = self.nested_pattern_ir_and_label(
|
|
pattern,
|
|
pattern_stack,
|
|
pattern_type,
|
|
final_clause,
|
|
);
|
|
|
|
let mut var_stack = pattern_stack.empty_with_scope();
|
|
var_stack.local_var(pattern_type.clone().into(), inner_name.clone().unwrap());
|
|
|
|
pattern_stack.let_assignment(name, var_stack);
|
|
|
|
inner_name
|
|
}
|
|
Pattern::Int { .. } => {
|
|
let error_message = "Nested pattern-match on integers isn't implemented yet. Use when clause-guard as an alternative, or break down the pattern.";
|
|
todo!("{}", error_message)
|
|
}
|
|
}
|
|
}
|
|
|
|
fn assignment(
|
|
&mut self,
|
|
pattern: &Pattern<PatternConstructor, Arc<Type>>,
|
|
pattern_stack: &mut AirStack,
|
|
value_stack: AirStack,
|
|
tipo: &Type,
|
|
assignment_properties: AssignmentProperties,
|
|
) {
|
|
let mut value_stack = if assignment_properties.value_type.is_data()
|
|
&& !tipo.is_data()
|
|
&& !pattern.is_discard()
|
|
{
|
|
let mut wrap_stack = pattern_stack.empty_with_scope();
|
|
wrap_stack.un_wrap_data(tipo.clone().into());
|
|
wrap_stack.merge_child(value_stack);
|
|
wrap_stack
|
|
} else if !assignment_properties.value_type.is_data()
|
|
&& tipo.is_data()
|
|
&& !pattern.is_discard()
|
|
{
|
|
let mut wrap_stack = pattern_stack.empty_with_scope();
|
|
wrap_stack.wrap_data(assignment_properties.value_type.clone());
|
|
wrap_stack.merge_child(value_stack);
|
|
wrap_stack
|
|
} else {
|
|
value_stack
|
|
};
|
|
|
|
match pattern {
|
|
Pattern::Int { .. } => todo!(),
|
|
Pattern::Var { name, .. } => {
|
|
let expect_value_stack = value_stack.empty_with_scope();
|
|
pattern_stack.let_assignment(name, value_stack);
|
|
|
|
if matches!(assignment_properties.kind, AssignmentKind::Expect)
|
|
&& assignment_properties.value_type.is_data()
|
|
&& !tipo.is_data()
|
|
{
|
|
let mut expect_stack = pattern_stack.empty_with_scope();
|
|
|
|
self.expect_pattern(
|
|
pattern,
|
|
&mut expect_stack,
|
|
expect_value_stack,
|
|
tipo,
|
|
assignment_properties,
|
|
);
|
|
|
|
pattern_stack.merge(expect_stack);
|
|
}
|
|
}
|
|
Pattern::Assign { .. } => todo!("Assign not yet implemented"),
|
|
Pattern::Discard { .. } => {
|
|
pattern_stack.let_assignment("_", value_stack);
|
|
}
|
|
list @ Pattern::List { .. } => {
|
|
if matches!(assignment_properties.kind, AssignmentKind::Expect)
|
|
&& assignment_properties.value_type.is_data()
|
|
&& !tipo.is_data()
|
|
{
|
|
self.expect_pattern(
|
|
list,
|
|
pattern_stack,
|
|
value_stack,
|
|
tipo,
|
|
assignment_properties,
|
|
);
|
|
} else {
|
|
self.pattern_ir(
|
|
list,
|
|
pattern_stack,
|
|
value_stack,
|
|
tipo,
|
|
assignment_properties,
|
|
);
|
|
}
|
|
}
|
|
constr @ Pattern::Constructor { .. } => {
|
|
if matches!(assignment_properties.kind, AssignmentKind::Expect)
|
|
&& assignment_properties.value_type.is_data()
|
|
&& !tipo.is_data()
|
|
{
|
|
self.expect_pattern(
|
|
constr,
|
|
pattern_stack,
|
|
value_stack,
|
|
tipo,
|
|
assignment_properties,
|
|
);
|
|
} else {
|
|
self.pattern_ir(
|
|
constr,
|
|
pattern_stack,
|
|
value_stack,
|
|
tipo,
|
|
assignment_properties,
|
|
);
|
|
}
|
|
}
|
|
tuple @ Pattern::Tuple { .. } => {
|
|
if matches!(assignment_properties.kind, AssignmentKind::Expect)
|
|
&& assignment_properties.value_type.is_data()
|
|
&& !tipo.is_data()
|
|
{
|
|
self.expect_pattern(
|
|
tuple,
|
|
pattern_stack,
|
|
value_stack,
|
|
tipo,
|
|
assignment_properties,
|
|
);
|
|
} else {
|
|
self.pattern_ir(
|
|
tuple,
|
|
pattern_stack,
|
|
value_stack,
|
|
tipo,
|
|
assignment_properties,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn pattern_ir(
|
|
&mut self,
|
|
pattern: &Pattern<PatternConstructor, Arc<Type>>,
|
|
pattern_stack: &mut AirStack,
|
|
value_stack: AirStack,
|
|
tipo: &Type,
|
|
assignment_properties: AssignmentProperties,
|
|
) {
|
|
match pattern {
|
|
Pattern::Int { .. } => todo!(),
|
|
Pattern::Var { .. } => todo!(),
|
|
Pattern::Assign { .. } => todo!(),
|
|
Pattern::Discard { .. } => todo!(),
|
|
Pattern::List { elements, tail, .. } => {
|
|
let inner_list_type = &tipo.get_inner_types()[0];
|
|
let mut elements_stack = pattern_stack.empty_with_scope();
|
|
let mut names = vec![];
|
|
|
|
for element in elements {
|
|
match element {
|
|
Pattern::Var { name, .. } => {
|
|
names.push(name.clone());
|
|
}
|
|
pattern @ (Pattern::List { .. }
|
|
| Pattern::Constructor { .. }
|
|
| Pattern::Tuple { .. }) => {
|
|
let mut var_stack = pattern_stack.empty_with_scope();
|
|
|
|
let item_name = format!("list_item_id_{}", self.id_gen.next());
|
|
|
|
names.push(item_name.clone());
|
|
|
|
let mut element_stack = pattern_stack.empty_with_scope();
|
|
|
|
var_stack.local_var(inner_list_type.clone(), item_name);
|
|
|
|
self.pattern_ir(
|
|
pattern,
|
|
&mut element_stack,
|
|
var_stack,
|
|
&tipo.get_inner_types()[0],
|
|
assignment_properties.clone(),
|
|
);
|
|
|
|
elements_stack.merge(element_stack);
|
|
}
|
|
Pattern::Int { .. } => todo!(),
|
|
Pattern::Assign { .. } => todo!(),
|
|
Pattern::Discard { .. } => {
|
|
names.push("_".to_string());
|
|
}
|
|
}
|
|
}
|
|
|
|
if let Some(tail) = tail {
|
|
match &**tail {
|
|
Pattern::Var { name, .. } => names.push(name.clone()),
|
|
Pattern::Discard { .. } => {}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
if !names.is_empty() {
|
|
pattern_stack.list_accessor(
|
|
tipo.clone().into(),
|
|
names,
|
|
tail.is_some(),
|
|
true,
|
|
value_stack,
|
|
);
|
|
} else {
|
|
pattern_stack.let_assignment("_", value_stack);
|
|
}
|
|
|
|
pattern_stack.merge_child(elements_stack);
|
|
}
|
|
Pattern::Constructor {
|
|
arguments,
|
|
constructor,
|
|
tipo: constr_tipo,
|
|
name: constructor_name,
|
|
..
|
|
} => {
|
|
let mut stacks = pattern_stack.empty_with_scope();
|
|
|
|
let field_map = match constructor {
|
|
PatternConstructor::Record { field_map, .. } => field_map.clone(),
|
|
};
|
|
|
|
let mut type_map: IndexMap<usize, Arc<Type>> = IndexMap::new();
|
|
|
|
for (index, arg) in constr_tipo.arg_types().unwrap().iter().enumerate() {
|
|
let field_type = arg.clone();
|
|
type_map.insert(index, field_type);
|
|
}
|
|
|
|
let arguments_index = arguments
|
|
.iter()
|
|
.enumerate()
|
|
.filter_map(|(index, item)| {
|
|
let label = item.label.clone().unwrap_or_default();
|
|
|
|
let field_index = if let Some(field_map) = &field_map {
|
|
*field_map.fields.get(&label).map(|x| &x.0).unwrap_or(&index)
|
|
} else {
|
|
index
|
|
};
|
|
|
|
let mut nested_pattern = pattern_stack.empty_with_scope();
|
|
|
|
let name = self.extract_arg_name(
|
|
&item.value,
|
|
&mut nested_pattern,
|
|
type_map.get(&field_index).unwrap(),
|
|
&assignment_properties,
|
|
);
|
|
|
|
stacks.merge(nested_pattern);
|
|
|
|
name.map_or(Some(("_".to_string(), field_index)), |name| {
|
|
Some((name, field_index))
|
|
})
|
|
})
|
|
.sorted_by(|item1, item2| item1.1.cmp(&item2.1))
|
|
.collect::<Vec<(String, usize)>>();
|
|
|
|
let constr_name = format!("__{}_{}", constructor_name, self.id_gen.next());
|
|
|
|
let mut expect_stack = pattern_stack.empty_with_scope();
|
|
|
|
match assignment_properties.kind {
|
|
AssignmentKind::Let => {
|
|
expect_stack.merge_child(value_stack);
|
|
}
|
|
AssignmentKind::Expect => {
|
|
if tipo.is_bool() {
|
|
expect_stack.expect_bool(constr_name == "True", value_stack);
|
|
|
|
expect_stack.local_var(tipo.clone().into(), constr_name);
|
|
} else {
|
|
let data_type =
|
|
builder::lookup_data_type_by_tipo(self.data_types.clone(), tipo)
|
|
.unwrap();
|
|
|
|
let (index, _) = data_type
|
|
.constructors
|
|
.iter()
|
|
.enumerate()
|
|
.find(|(_, constr)| constr.name == *constructor_name)
|
|
.unwrap();
|
|
|
|
let constr_name = format!("__{}_{}", constr_name, self.id_gen.next());
|
|
let mut var_stack = expect_stack.empty_with_scope();
|
|
|
|
var_stack.local_var(tipo.clone().into(), constr_name.clone());
|
|
|
|
expect_stack.let_assignment(constr_name.clone(), value_stack);
|
|
|
|
expect_stack.expect_constr(index, var_stack);
|
|
|
|
expect_stack.local_var(tipo.clone().into(), constr_name);
|
|
}
|
|
}
|
|
}
|
|
if !arguments_index.is_empty() {
|
|
let indices = arguments_index
|
|
.iter()
|
|
.map(|(var_name, index)| {
|
|
let field_type = type_map.get(index).unwrap();
|
|
(*index, var_name.clone(), field_type.clone())
|
|
})
|
|
.collect_vec();
|
|
|
|
pattern_stack.fields_expose(indices, false, expect_stack);
|
|
} else if !tipo.is_bool() {
|
|
pattern_stack.let_assignment("_", expect_stack);
|
|
}
|
|
|
|
pattern_stack.merge_child(stacks);
|
|
}
|
|
Pattern::Tuple { elems, .. } => {
|
|
let mut stacks = pattern_stack.empty_with_scope();
|
|
let mut type_map: IndexMap<usize, Arc<Type>> = IndexMap::new();
|
|
|
|
for (index, arg) in tipo.get_inner_types().iter().enumerate() {
|
|
let field_type = arg.clone();
|
|
type_map.insert(index, field_type);
|
|
}
|
|
|
|
let arguments_index = elems
|
|
.iter()
|
|
.enumerate()
|
|
.filter_map(|(tuple_index, item)| {
|
|
let mut nested_stack = pattern_stack.empty_with_scope();
|
|
|
|
let name = self
|
|
.extract_arg_name(
|
|
item,
|
|
&mut nested_stack,
|
|
type_map.get(&tuple_index).unwrap(),
|
|
&assignment_properties,
|
|
)
|
|
.map(|name| (name, tuple_index));
|
|
|
|
stacks.merge(nested_stack);
|
|
|
|
name
|
|
})
|
|
.sorted_by(|item1, item2| item1.1.cmp(&item2.1))
|
|
.collect::<Vec<(String, usize)>>();
|
|
|
|
if !arguments_index.is_empty() {
|
|
let mut current_index = 0;
|
|
let mut final_args = vec![];
|
|
|
|
for index in 0..elems.len() {
|
|
if arguments_index.get(current_index).is_some()
|
|
&& arguments_index[current_index].1 == index
|
|
{
|
|
final_args.push(arguments_index.get(current_index).unwrap().clone());
|
|
current_index += 1;
|
|
} else {
|
|
final_args.push(("_".to_string(), index));
|
|
}
|
|
}
|
|
|
|
pattern_stack.tuple_accessor(
|
|
tipo.clone().into(),
|
|
final_args.into_iter().map(|(item, _)| item).collect_vec(),
|
|
false,
|
|
value_stack,
|
|
);
|
|
} else {
|
|
pattern_stack.let_assignment("_", value_stack);
|
|
}
|
|
|
|
pattern_stack.merge_child(stacks);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn expect_pattern(
|
|
&mut self,
|
|
pattern: &Pattern<PatternConstructor, Arc<Type>>,
|
|
expect_stack: &mut AirStack,
|
|
value_stack: AirStack,
|
|
tipo: &Type,
|
|
assignment_properties: AssignmentProperties,
|
|
) {
|
|
match pattern {
|
|
Pattern::Int { .. } => unreachable!(),
|
|
Pattern::Var { name, .. } => {
|
|
expect_stack.merge(value_stack);
|
|
|
|
self.expect_type(tipo, expect_stack, name);
|
|
}
|
|
Pattern::Assign { .. } => todo!(),
|
|
Pattern::Discard { .. } => unreachable!(),
|
|
Pattern::List { elements, tail, .. } => {
|
|
let inner_list_type = &tipo.get_inner_types()[0];
|
|
let mut names = vec![];
|
|
|
|
let mut expect_list_stacks = vec![];
|
|
|
|
for element in elements {
|
|
match element {
|
|
Pattern::Var { name, .. } => {
|
|
names.push(name.clone());
|
|
}
|
|
Pattern::Assign { .. } => todo!(),
|
|
element_pattern @ (Pattern::List { .. }
|
|
| Pattern::Constructor { .. }
|
|
| Pattern::Tuple { .. }) => {
|
|
let name = format!("list_item_id_{}", self.id_gen.next());
|
|
|
|
names.push(name.clone());
|
|
|
|
let mut element_stack = expect_stack.empty_with_scope();
|
|
let mut value_stack = element_stack.empty_with_scope();
|
|
|
|
value_stack.local_var(inner_list_type.clone(), name);
|
|
|
|
self.expect_pattern(
|
|
element_pattern,
|
|
&mut element_stack,
|
|
value_stack,
|
|
inner_list_type,
|
|
assignment_properties.clone(),
|
|
);
|
|
|
|
expect_list_stacks.push(element_stack);
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
let mut tail_stack = expect_stack.empty_with_scope();
|
|
|
|
let name = if let Some(tail) = tail {
|
|
match &**tail {
|
|
Pattern::Var { name, .. } => name.clone(),
|
|
_ => format!("__tail_{}", self.id_gen.next()),
|
|
}
|
|
} else {
|
|
format!("__tail_{}", self.id_gen.next())
|
|
};
|
|
|
|
self.expect_type(inner_list_type, &mut tail_stack, &name);
|
|
|
|
names.push(name);
|
|
|
|
expect_stack.list_accessor(tipo.clone().into(), names, true, false, value_stack);
|
|
|
|
expect_stack.merge_children(expect_list_stacks);
|
|
}
|
|
Pattern::Constructor {
|
|
arguments,
|
|
constructor,
|
|
name: constr_name,
|
|
tipo,
|
|
..
|
|
} => {
|
|
let field_map = match constructor {
|
|
PatternConstructor::Record { field_map, .. } => field_map.clone().unwrap(),
|
|
};
|
|
|
|
let data_type =
|
|
builder::lookup_data_type_by_tipo(self.data_types.clone(), tipo).unwrap();
|
|
|
|
let (index, data_type_constr) = data_type
|
|
.constructors
|
|
.iter()
|
|
.enumerate()
|
|
.find(|(_, constr)| &constr.name == constr_name)
|
|
.unwrap();
|
|
|
|
let mut type_map: IndexMap<usize, Arc<Type>> = IndexMap::new();
|
|
|
|
let arg_types = tipo.arg_types().unwrap();
|
|
|
|
for (index, arg) in arg_types.iter().enumerate() {
|
|
let field_type = arg.clone();
|
|
type_map.insert(index, field_type);
|
|
}
|
|
|
|
let mut stacks = expect_stack.empty_with_scope();
|
|
|
|
let arguments_index = arguments
|
|
.iter()
|
|
.filter_map(|item| {
|
|
let label = item.label.clone().unwrap_or_default();
|
|
|
|
let field_index = field_map.fields.get(&label).map(|x| &x.0).unwrap_or(&0);
|
|
|
|
let mut inner_stack = expect_stack.empty_with_scope();
|
|
|
|
let name = self.extract_arg_name(
|
|
&item.value,
|
|
&mut inner_stack,
|
|
type_map.get(field_index).unwrap(),
|
|
&assignment_properties,
|
|
);
|
|
|
|
stacks.merge(inner_stack);
|
|
|
|
name.map(|name| (name, *field_index))
|
|
})
|
|
.sorted_by(|item1, item2| item1.1.cmp(&item2.1))
|
|
.collect::<Vec<(String, usize)>>();
|
|
|
|
let total_fields = data_type_constr.arguments.len();
|
|
let mut final_args = vec![];
|
|
let mut current_index = 0;
|
|
|
|
for index in 0..total_fields {
|
|
if arguments_index.get(current_index).is_some()
|
|
&& arguments_index[current_index].1 == index
|
|
{
|
|
final_args.push(arguments_index.get(current_index).unwrap().clone());
|
|
current_index += 1;
|
|
} else {
|
|
let id_next = self.id_gen.next();
|
|
|
|
final_args.push((format!("__field_{index}_{id_next}"), index));
|
|
|
|
self.expect_type(
|
|
type_map.get(&index).unwrap(),
|
|
&mut stacks,
|
|
&format!("__field_{index}_{id_next}"),
|
|
)
|
|
}
|
|
}
|
|
|
|
let constr_var = format!("__constr_{}", self.id_gen.next());
|
|
|
|
expect_stack.let_assignment(constr_var.clone(), value_stack);
|
|
|
|
let mut var_stack = expect_stack.empty_with_scope();
|
|
var_stack.local_var(tipo.clone(), constr_var.clone());
|
|
expect_stack.expect_constr(index, var_stack);
|
|
|
|
if !arguments_index.is_empty() {
|
|
let mut fields_stack = expect_stack.empty_with_scope();
|
|
fields_stack.local_var(tipo.clone(), constr_var);
|
|
|
|
let indices = final_args
|
|
.iter()
|
|
.map(|(var_name, index)| {
|
|
let field_type = type_map.get(index).unwrap();
|
|
(*index, var_name.clone(), field_type.clone())
|
|
})
|
|
.collect_vec();
|
|
|
|
expect_stack.fields_expose(indices, true, fields_stack);
|
|
}
|
|
|
|
expect_stack.merge_child(stacks);
|
|
}
|
|
Pattern::Tuple { elems, .. } => {
|
|
let mut type_map: IndexMap<usize, Arc<Type>> = IndexMap::new();
|
|
|
|
for (index, arg) in tipo.arg_types().unwrap().iter().enumerate() {
|
|
let field_type = arg.clone();
|
|
type_map.insert(index, field_type);
|
|
}
|
|
|
|
let mut stacks = expect_stack.empty_with_scope();
|
|
|
|
let arguments_index = elems
|
|
.iter()
|
|
.enumerate()
|
|
.filter_map(|(index, item)| {
|
|
let field_index = index;
|
|
|
|
let mut inner_stack = expect_stack.empty_with_scope();
|
|
|
|
let name = self.extract_arg_name(
|
|
item,
|
|
&mut inner_stack,
|
|
type_map.get(&field_index).unwrap(),
|
|
&assignment_properties,
|
|
);
|
|
|
|
stacks.merge(inner_stack);
|
|
|
|
name.map(|name| (name, field_index))
|
|
})
|
|
.sorted_by(|item1, item2| item1.1.cmp(&item2.1))
|
|
.collect::<Vec<(String, usize)>>();
|
|
|
|
let total_fields = type_map.len();
|
|
let mut final_args = vec![];
|
|
let mut current_index = 0;
|
|
|
|
for index in 0..total_fields {
|
|
if arguments_index.get(current_index).is_some()
|
|
&& arguments_index[current_index].1 == index
|
|
{
|
|
final_args.push(arguments_index.get(current_index).unwrap().clone());
|
|
|
|
current_index += 1;
|
|
} else {
|
|
let id_next = self.id_gen.next();
|
|
|
|
final_args.push((format!("__tuple_{index}_{id_next}"), index));
|
|
|
|
self.expect_type(
|
|
type_map.get(&index).unwrap(),
|
|
&mut stacks,
|
|
&format!("__tuple_{index}_{id_next}"),
|
|
)
|
|
}
|
|
}
|
|
|
|
expect_stack.tuple_accessor(
|
|
tipo.clone().into(),
|
|
final_args.into_iter().map(|(item, _)| item).collect_vec(),
|
|
true,
|
|
value_stack,
|
|
);
|
|
|
|
expect_stack.merge_child(stacks);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn expect_type(&mut self, tipo: &Type, expect_stack: &mut AirStack, name: &str) {
|
|
let mut tipo = tipo.clone().into();
|
|
builder::replace_opaque_type(&mut tipo, self.data_types.clone());
|
|
|
|
if tipo.is_bool()
|
|
|| tipo.is_bytearray()
|
|
|| tipo.is_int()
|
|
|| tipo.is_string()
|
|
|| tipo.is_void()
|
|
|| tipo.get_generic().is_some()
|
|
|| tipo.is_data()
|
|
{
|
|
} else if tipo.is_map() {
|
|
self.used_data_assert_on_list = true;
|
|
let new_id = self.id_gen.next();
|
|
let id_pair = (self.id_gen.next(), self.id_gen.next());
|
|
let inner_list_type = &tipo.get_inner_types()[0];
|
|
let inner_pair_types = inner_list_type.get_inner_types();
|
|
|
|
let mut unwrap_function_stack = expect_stack.empty_with_scope();
|
|
let mut pair_access_stack = unwrap_function_stack.empty_with_scope();
|
|
let mut local_var_stack = pair_access_stack.empty_with_scope();
|
|
|
|
local_var_stack.local_var(inner_list_type.clone(), format!("__pair_{new_id}"));
|
|
|
|
pair_access_stack.tuple_accessor(
|
|
inner_list_type.clone(),
|
|
vec![
|
|
format!("__pair_fst_{}", id_pair.0),
|
|
format!("__pair_snd_{}", id_pair.1),
|
|
],
|
|
false,
|
|
local_var_stack,
|
|
);
|
|
|
|
self.expect_type(
|
|
&inner_pair_types[0],
|
|
&mut pair_access_stack,
|
|
&format!("__pair_fst_{}", id_pair.0),
|
|
);
|
|
|
|
self.expect_type(
|
|
&inner_pair_types[1],
|
|
&mut pair_access_stack,
|
|
&format!("__pair_snd_{}", id_pair.1),
|
|
);
|
|
|
|
unwrap_function_stack
|
|
.anonymous_function(vec![format!("__pair_{new_id}")], pair_access_stack);
|
|
|
|
expect_stack.expect_list_from_data(tipo.clone(), name, unwrap_function_stack);
|
|
|
|
expect_stack.void();
|
|
} else if tipo.is_list() {
|
|
self.used_data_assert_on_list = true;
|
|
let new_id = self.id_gen.next();
|
|
let inner_list_type = &tipo.get_inner_types()[0];
|
|
|
|
let mut unwrap_function_stack = expect_stack.empty_with_scope();
|
|
let mut list_access_stack = unwrap_function_stack.empty_with_scope();
|
|
let mut local_var_stack = list_access_stack.empty_with_scope();
|
|
|
|
local_var_stack.un_wrap_data(inner_list_type.clone());
|
|
local_var_stack.local_var(inner_list_type.clone(), format!("__list_item_{new_id}"));
|
|
|
|
list_access_stack.let_assignment(format!("__list_item_{new_id}"), local_var_stack);
|
|
|
|
self.expect_type(
|
|
inner_list_type,
|
|
&mut list_access_stack,
|
|
&format!("__list_item_{new_id}"),
|
|
);
|
|
|
|
unwrap_function_stack
|
|
.anonymous_function(vec![format!("__list_item_{new_id}")], list_access_stack);
|
|
|
|
expect_stack.expect_list_from_data(tipo.clone(), name, unwrap_function_stack);
|
|
|
|
expect_stack.void();
|
|
} else if tipo.is_tuple() {
|
|
let tuple_inner_types = tipo.get_inner_types();
|
|
let mut new_id_list = vec![];
|
|
|
|
for (index, _) in tuple_inner_types.iter().enumerate() {
|
|
new_id_list.push((index, self.id_gen.next()));
|
|
}
|
|
|
|
let mut local_var_stack = expect_stack.empty_with_scope();
|
|
|
|
local_var_stack.local_var(tipo.clone(), name);
|
|
|
|
let names = new_id_list
|
|
.iter()
|
|
.map(|(index, id)| format!("__tuple_index_{index}_{id}"))
|
|
.collect();
|
|
|
|
expect_stack.tuple_accessor(tipo.clone(), names, true, local_var_stack);
|
|
|
|
for (index, name) in new_id_list
|
|
.into_iter()
|
|
.map(|(index, id)| (index, format!("__tuple_index_{index}_{id}")))
|
|
{
|
|
self.expect_type(&tuple_inner_types[index], expect_stack, &name);
|
|
}
|
|
} else {
|
|
let data_type =
|
|
builder::lookup_data_type_by_tipo(self.data_types.clone(), &tipo).unwrap();
|
|
|
|
let new_id = self.id_gen.next();
|
|
|
|
// START HERE
|
|
|
|
let mut clause_stack = expect_stack.empty_with_scope();
|
|
let mut when_stack = expect_stack.empty_with_scope();
|
|
let mut trace_stack = expect_stack.empty_with_scope();
|
|
let mut subject_stack = expect_stack.empty_with_scope();
|
|
|
|
for (index, constr) in data_type.constructors.iter().enumerate() {
|
|
let arg_indices = constr
|
|
.arguments
|
|
.iter()
|
|
.enumerate()
|
|
.map(|(index, arg)| {
|
|
let arg_name = arg
|
|
.label
|
|
.clone()
|
|
.unwrap_or(format!("__field_{index}_{new_id}"));
|
|
|
|
(index, arg_name, arg.tipo.clone())
|
|
})
|
|
.collect_vec();
|
|
|
|
let mut arg_stack = expect_stack.empty_with_scope();
|
|
|
|
let mut arg_stack = if !arg_indices.is_empty() {
|
|
arg_stack.local_var(tipo.clone(), name);
|
|
|
|
let mut field_expose_stack = expect_stack.empty_with_scope();
|
|
field_expose_stack.integer(index.to_string());
|
|
|
|
field_expose_stack.fields_expose(arg_indices.clone(), true, arg_stack);
|
|
|
|
field_expose_stack
|
|
} else {
|
|
arg_stack.integer(index.to_string());
|
|
arg_stack
|
|
};
|
|
|
|
for (_index, name, tipo) in arg_indices {
|
|
self.expect_type(&tipo, &mut arg_stack, &name);
|
|
}
|
|
|
|
arg_stack.void();
|
|
|
|
clause_stack.clause(
|
|
tipo.clone(),
|
|
format!("__subject_{new_id}"),
|
|
false,
|
|
arg_stack,
|
|
);
|
|
}
|
|
|
|
trace_stack.trace(tipo.clone());
|
|
|
|
trace_stack.string("Constr index did not match any type variant");
|
|
|
|
trace_stack.error(tipo.clone());
|
|
|
|
subject_stack.local_var(tipo.clone(), name);
|
|
|
|
when_stack.when(
|
|
tipo.clone(),
|
|
format!("__subject_{new_id}"),
|
|
subject_stack,
|
|
clause_stack,
|
|
trace_stack,
|
|
);
|
|
|
|
// Only used here
|
|
expect_stack.expect_constr_from_data(tipo.clone(), when_stack);
|
|
}
|
|
}
|
|
|
|
fn extract_arg_name(
|
|
&mut self,
|
|
item: &Pattern<PatternConstructor, Arc<Type>>,
|
|
nested_pattern_stack: &mut AirStack,
|
|
tipo: &Type,
|
|
assignment_properties: &AssignmentProperties,
|
|
) -> Option<String> {
|
|
match item {
|
|
Pattern::Var { name, .. } => Some(name.clone()),
|
|
Pattern::Discard { .. } => None,
|
|
a @ Pattern::List { .. } => {
|
|
let id = self.id_gen.next();
|
|
let list_name = format!("__list_{id}");
|
|
|
|
let mut value_stack = nested_pattern_stack.empty_with_scope();
|
|
|
|
value_stack.local_var(tipo.clone().into(), list_name.clone());
|
|
|
|
if matches!(assignment_properties.kind, AssignmentKind::Expect)
|
|
&& assignment_properties.value_type.is_data()
|
|
&& !tipo.is_data()
|
|
{
|
|
self.expect_pattern(
|
|
a,
|
|
nested_pattern_stack,
|
|
value_stack,
|
|
tipo,
|
|
assignment_properties.clone(),
|
|
);
|
|
} else {
|
|
self.pattern_ir(
|
|
a,
|
|
nested_pattern_stack,
|
|
value_stack,
|
|
tipo,
|
|
assignment_properties.clone(),
|
|
);
|
|
}
|
|
|
|
Some(list_name)
|
|
}
|
|
a @ Pattern::Constructor {
|
|
tipo,
|
|
name: constr_name,
|
|
..
|
|
} => {
|
|
let id = self.id_gen.next();
|
|
let constr_name = format!("{constr_name}_{id}");
|
|
|
|
let mut local_var_stack = nested_pattern_stack.empty_with_scope();
|
|
|
|
local_var_stack.local_var(tipo.clone(), constr_name.clone());
|
|
|
|
if matches!(assignment_properties.kind, AssignmentKind::Expect)
|
|
&& assignment_properties.value_type.is_data()
|
|
&& !tipo.is_data()
|
|
{
|
|
self.expect_pattern(
|
|
a,
|
|
nested_pattern_stack,
|
|
local_var_stack,
|
|
tipo,
|
|
assignment_properties.clone(),
|
|
);
|
|
} else {
|
|
self.pattern_ir(
|
|
a,
|
|
nested_pattern_stack,
|
|
local_var_stack,
|
|
tipo,
|
|
assignment_properties.clone(),
|
|
);
|
|
}
|
|
|
|
Some(constr_name)
|
|
}
|
|
a @ Pattern::Tuple { .. } => {
|
|
let id = self.id_gen.next();
|
|
let tuple_name = format!("__tuple_name_{id}");
|
|
|
|
let mut local_var_stack = nested_pattern_stack.empty_with_scope();
|
|
|
|
local_var_stack.local_var(tipo.clone().into(), tuple_name.clone());
|
|
|
|
if matches!(assignment_properties.kind, AssignmentKind::Expect)
|
|
&& assignment_properties.value_type.is_data()
|
|
&& !tipo.is_data()
|
|
{
|
|
self.expect_pattern(
|
|
a,
|
|
nested_pattern_stack,
|
|
local_var_stack,
|
|
tipo,
|
|
assignment_properties.clone(),
|
|
);
|
|
} else {
|
|
self.pattern_ir(
|
|
a,
|
|
nested_pattern_stack,
|
|
local_var_stack,
|
|
tipo,
|
|
assignment_properties.clone(),
|
|
);
|
|
}
|
|
|
|
Some(tuple_name)
|
|
}
|
|
Pattern::Int { .. } => todo!(),
|
|
Pattern::Assign { .. } => todo!(),
|
|
}
|
|
}
|
|
|
|
fn define_ir(&mut self, ir_stack: &mut Vec<Air>) {
|
|
let mut function_definitions = IndexMap::new();
|
|
let mut func_index_map = IndexMap::new();
|
|
|
|
let recursion_func_map = IndexMap::new();
|
|
|
|
self.define_ir_recurse(
|
|
ir_stack,
|
|
&mut function_definitions,
|
|
&mut func_index_map,
|
|
recursion_func_map,
|
|
false,
|
|
);
|
|
|
|
let mut final_func_dep_ir = IndexMap::new();
|
|
let mut to_be_defined = IndexMap::new();
|
|
|
|
let mut dependency_map = IndexMap::new();
|
|
let mut dependency_vec = vec![];
|
|
|
|
let mut func_keys = function_definitions
|
|
.clone()
|
|
.into_iter()
|
|
.filter(|(_, val)| !val.defined_by_zero_arg)
|
|
.map(|(key, val)| (key, val.defined_by_zero_arg))
|
|
.collect_vec();
|
|
|
|
// deal with function dependencies by sorting order in which we iter over them.
|
|
while let Some(function) = func_keys.pop() {
|
|
let funct_comp = function_definitions.get(&function.0).unwrap();
|
|
if dependency_map.contains_key(&function.0) {
|
|
dependency_map.shift_remove(&function.0);
|
|
}
|
|
dependency_map.insert(function.0, function.1);
|
|
func_keys.extend(
|
|
funct_comp
|
|
.dependencies
|
|
.iter()
|
|
.map(|key| {
|
|
(
|
|
key.clone(),
|
|
function_definitions.get(key).unwrap().defined_by_zero_arg,
|
|
)
|
|
})
|
|
.collect_vec(),
|
|
);
|
|
}
|
|
|
|
dependency_vec.extend(
|
|
dependency_map
|
|
.iter()
|
|
.filter(|(_, defined_in_zero_arg)| !**defined_in_zero_arg)
|
|
.map(|(key, _)| key.clone())
|
|
.collect_vec(),
|
|
);
|
|
|
|
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();
|
|
|
|
let mut dep_ir = vec![];
|
|
|
|
if !function_component.args.is_empty() {
|
|
// deal with function dependencies
|
|
builder::handle_func_dependencies(
|
|
&mut dep_ir,
|
|
function_component,
|
|
&function_definitions,
|
|
&mut self.defined_functions,
|
|
&func_index_map,
|
|
func_scope,
|
|
&mut to_be_defined,
|
|
self.id_gen.clone(),
|
|
);
|
|
final_func_dep_ir.insert(func, dep_ir);
|
|
} else {
|
|
// since zero arg functions are run at compile time we need to pull all deps
|
|
// note anon functions are not included in the above. They exist in a function anyway
|
|
let mut defined_functions = IndexMap::new();
|
|
|
|
// deal with function dependencies in zero arg functions
|
|
builder::handle_func_dependencies(
|
|
&mut dep_ir,
|
|
function_component,
|
|
&function_definitions,
|
|
&mut defined_functions,
|
|
&func_index_map,
|
|
func_scope,
|
|
&mut to_be_defined,
|
|
self.id_gen.clone(),
|
|
);
|
|
|
|
let mut final_zero_arg_ir = dep_ir;
|
|
final_zero_arg_ir.extend(function_component.ir.clone());
|
|
|
|
self.convert_opaque_type_to_inner_ir(&mut final_zero_arg_ir);
|
|
|
|
self.zero_arg_functions.insert(func, final_zero_arg_ir);
|
|
// zero arg functions don't contain the dependencies since they are pre-evaluated
|
|
// As such we add functions to defined only after dependencies for all other functions are calculated
|
|
}
|
|
}
|
|
|
|
while let Some(func) = to_be_defined.pop() {
|
|
let mut dep_ir = vec![];
|
|
let mut defined_functions = IndexMap::new();
|
|
|
|
// deal with function dependencies in zero arg functions
|
|
let funt_comp = function_definitions.get(&func.0).unwrap();
|
|
let func_scope = func_index_map.get(&func.0).unwrap();
|
|
|
|
builder::handle_func_dependencies(
|
|
&mut dep_ir,
|
|
funt_comp,
|
|
&function_definitions,
|
|
&mut defined_functions,
|
|
&func_index_map,
|
|
func_scope,
|
|
&mut to_be_defined,
|
|
self.id_gen.clone(),
|
|
);
|
|
|
|
let mut final_zero_arg_ir = dep_ir;
|
|
final_zero_arg_ir.extend(funt_comp.ir.clone());
|
|
|
|
self.convert_opaque_type_to_inner_ir(&mut final_zero_arg_ir);
|
|
|
|
self.zero_arg_functions.insert(func.0, final_zero_arg_ir);
|
|
}
|
|
|
|
for (index, ir) in ir_stack.clone().into_iter().enumerate().rev() {
|
|
{
|
|
let temp_func_index_map = func_index_map.clone();
|
|
let to_insert = final_func_dep_ir
|
|
.iter()
|
|
.filter_map(|(func_key, _)| {
|
|
temp_func_index_map
|
|
.get(func_key)
|
|
.map(|scope| (func_key.clone(), scope.clone()))
|
|
})
|
|
.filter(|func| {
|
|
(func.1.common_ancestor(&ir.scope()) == ir.scope()
|
|
|| (index == 0 && func.1.is_empty()))
|
|
&& !self.defined_functions.contains_key(&func.0)
|
|
&& !self.zero_arg_functions.contains_key(&func.0)
|
|
&& !(*dependency_map.get(&func.0).unwrap())
|
|
})
|
|
.collect_vec();
|
|
|
|
for (function_access_key, scopes) in to_insert.into_iter().rev() {
|
|
func_index_map.remove(&function_access_key);
|
|
|
|
self.defined_functions
|
|
.insert(function_access_key.clone(), ());
|
|
|
|
let mut full_func_ir =
|
|
final_func_dep_ir.get(&function_access_key).unwrap().clone();
|
|
|
|
let func_comp = function_definitions
|
|
.get(&function_access_key)
|
|
.unwrap()
|
|
.clone();
|
|
|
|
// zero arg functions are not recursive
|
|
if !func_comp.args.is_empty() {
|
|
let mut recursion_ir = vec![];
|
|
builder::handle_recursion_ir(
|
|
&function_access_key,
|
|
&func_comp,
|
|
&mut recursion_ir,
|
|
);
|
|
|
|
let recursion_stack = AirStack {
|
|
id_gen: self.id_gen.clone(),
|
|
scope: scopes.clone(),
|
|
air: recursion_ir,
|
|
};
|
|
|
|
let mut func_stack = AirStack {
|
|
id_gen: self.id_gen.clone(),
|
|
scope: scopes.clone(),
|
|
air: vec![],
|
|
};
|
|
|
|
func_stack.define_func(
|
|
function_access_key.function_name.clone(),
|
|
function_access_key.module_name.clone(),
|
|
function_access_key.variant_name.clone(),
|
|
func_comp.args.clone(),
|
|
func_comp.recursive,
|
|
recursion_stack,
|
|
);
|
|
|
|
full_func_ir.extend(func_stack.complete());
|
|
|
|
for ir in full_func_ir.into_iter().rev() {
|
|
ir_stack.insert(index, ir);
|
|
}
|
|
} else {
|
|
full_func_ir.extend(func_comp.ir.clone());
|
|
|
|
self.zero_arg_functions
|
|
.insert(function_access_key, full_func_ir);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn define_ir_recurse(
|
|
&mut self,
|
|
ir_stack: &mut [Air],
|
|
func_components: &mut IndexMap<FunctionAccessKey, FuncComponents>,
|
|
func_index_map: &mut IndexMap<FunctionAccessKey, Scope>,
|
|
mut recursion_func_map: IndexMap<FunctionAccessKey, ()>,
|
|
in_zero_arg_func: bool,
|
|
) {
|
|
self.define_ir_processor(ir_stack, func_components, func_index_map, in_zero_arg_func);
|
|
|
|
let mut recursion_func_map_to_add = recursion_func_map.clone();
|
|
|
|
for func_index in func_index_map.clone().iter() {
|
|
let func = func_index.0;
|
|
|
|
let function_components = func_components.get_mut(func).unwrap();
|
|
let mut function_ir = function_components.ir.clone();
|
|
let in_zero_arg = function_components.args.is_empty() || in_zero_arg_func;
|
|
let mut skip = false;
|
|
|
|
for ir in function_ir.clone() {
|
|
if let Air::Var {
|
|
constructor:
|
|
ValueConstructor {
|
|
variant:
|
|
ValueConstructorVariant::ModuleFn {
|
|
name: func_name,
|
|
module,
|
|
..
|
|
},
|
|
..
|
|
},
|
|
variant_name,
|
|
..
|
|
} = ir
|
|
{
|
|
if recursion_func_map.contains_key(&FunctionAccessKey {
|
|
module_name: module.clone(),
|
|
function_name: func_name.clone(),
|
|
variant_name: variant_name.clone(),
|
|
}) && func.clone()
|
|
== (FunctionAccessKey {
|
|
module_name: module.clone(),
|
|
function_name: func_name.clone(),
|
|
variant_name: variant_name.clone(),
|
|
})
|
|
{
|
|
skip = true;
|
|
} else if func.clone()
|
|
== (FunctionAccessKey {
|
|
module_name: module.clone(),
|
|
function_name: func_name.clone(),
|
|
variant_name: variant_name.clone(),
|
|
})
|
|
{
|
|
recursion_func_map_to_add.insert(
|
|
FunctionAccessKey {
|
|
module_name: module.clone(),
|
|
function_name: func_name.clone(),
|
|
variant_name: variant_name.clone(),
|
|
},
|
|
(),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
recursion_func_map = recursion_func_map_to_add.clone();
|
|
if !skip {
|
|
let mut inner_func_components = IndexMap::new();
|
|
|
|
let mut inner_func_index_map = IndexMap::new();
|
|
|
|
self.define_ir_recurse(
|
|
&mut function_ir,
|
|
&mut inner_func_components,
|
|
&mut inner_func_index_map,
|
|
recursion_func_map.clone(),
|
|
in_zero_arg,
|
|
);
|
|
|
|
function_components.ir = function_ir;
|
|
|
|
//now unify
|
|
for item in inner_func_components {
|
|
if let Some(entry) = func_components.get_mut(&item.0) {
|
|
entry.defined_by_zero_arg =
|
|
entry.defined_by_zero_arg && item.1.defined_by_zero_arg
|
|
} else {
|
|
func_components.insert(item.0, item.1);
|
|
}
|
|
}
|
|
|
|
for item in inner_func_index_map {
|
|
if let Some(entry) = func_index_map.get_mut(&item.0) {
|
|
*entry = entry.common_ancestor(&item.1);
|
|
} else {
|
|
func_index_map.insert(item.0, item.1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn define_ir_processor(
|
|
&mut self,
|
|
ir_stack: &mut [Air],
|
|
func_components: &mut IndexMap<FunctionAccessKey, FuncComponents>,
|
|
func_index_map: &mut IndexMap<FunctionAccessKey, Scope>,
|
|
in_zero_arg_func: bool,
|
|
) {
|
|
let mut to_be_defined_map: IndexMap<FunctionAccessKey, Scope> = IndexMap::new();
|
|
for (index, ir) in ir_stack.to_vec().iter().enumerate().rev() {
|
|
match ir {
|
|
Air::Var {
|
|
scope,
|
|
constructor,
|
|
name: dummy,
|
|
..
|
|
} => {
|
|
if let ValueConstructorVariant::ModuleFn {
|
|
name,
|
|
module,
|
|
builtin: None,
|
|
..
|
|
} = &constructor.variant
|
|
{
|
|
let non_variant_function_key = FunctionAccessKey {
|
|
module_name: module.clone(),
|
|
function_name: name.clone(),
|
|
variant_name: String::new(),
|
|
};
|
|
|
|
let function = *self.functions.get(&non_variant_function_key).unwrap();
|
|
|
|
let mut func_stack =
|
|
AirStack::with_scope(self.id_gen.clone(), scope.clone());
|
|
|
|
self.build(&function.body, &mut func_stack);
|
|
|
|
let func_ir = func_stack.complete();
|
|
|
|
let param_types = constructor.tipo.arg_types().unwrap();
|
|
|
|
let mut mono_types: IndexMap<u64, Arc<Type>> = IndexMap::new();
|
|
let mut map = mono_types.into_iter().collect_vec();
|
|
|
|
for (index, arg) in function.arguments.iter().enumerate() {
|
|
if arg.tipo.is_generic() {
|
|
let param_type = ¶m_types[index];
|
|
|
|
map.append(&mut builder::get_generic_id_and_type(
|
|
&arg.tipo, param_type,
|
|
));
|
|
}
|
|
}
|
|
|
|
if function.return_type.is_generic() {
|
|
if let Type::Fn { ret, .. } = &*constructor.tipo {
|
|
map.append(&mut builder::get_generic_id_and_type(
|
|
&function.return_type,
|
|
ret,
|
|
))
|
|
}
|
|
}
|
|
|
|
mono_types = map.into_iter().collect();
|
|
|
|
let (variant_name, func_ir) =
|
|
builder::monomorphize(func_ir, mono_types, &constructor.tipo);
|
|
|
|
let function_key = FunctionAccessKey {
|
|
module_name: module.clone(),
|
|
function_name: non_variant_function_key.function_name,
|
|
variant_name: variant_name.clone(),
|
|
};
|
|
|
|
ir_stack[index] = Air::Var {
|
|
scope: scope.clone(),
|
|
constructor: constructor.clone(),
|
|
name: name.clone(),
|
|
variant_name: variant_name.clone(),
|
|
};
|
|
|
|
if let Some(scope_prev) = to_be_defined_map.get(&function_key) {
|
|
let new_scope = scope.common_ancestor(scope_prev);
|
|
|
|
to_be_defined_map.insert(function_key, new_scope);
|
|
} else if func_components.get(&function_key).is_some() {
|
|
to_be_defined_map.insert(function_key.clone(), scope.clone());
|
|
} else {
|
|
to_be_defined_map.insert(function_key.clone(), scope.clone());
|
|
let mut func_calls = IndexMap::new();
|
|
|
|
for ir in func_ir.clone().into_iter() {
|
|
if let Air::Var {
|
|
constructor:
|
|
ValueConstructor {
|
|
variant:
|
|
ValueConstructorVariant::ModuleFn {
|
|
name: func_name,
|
|
module,
|
|
..
|
|
},
|
|
tipo,
|
|
..
|
|
},
|
|
..
|
|
} = ir
|
|
{
|
|
let current_func = FunctionAccessKey {
|
|
module_name: module.clone(),
|
|
function_name: func_name.clone(),
|
|
variant_name: String::new(),
|
|
};
|
|
|
|
let current_func_as_variant = FunctionAccessKey {
|
|
module_name: module.clone(),
|
|
function_name: func_name.clone(),
|
|
variant_name: variant_name.clone(),
|
|
};
|
|
|
|
let function = self.functions.get(¤t_func);
|
|
if function_key.clone() == current_func_as_variant {
|
|
func_calls.insert(current_func_as_variant, ());
|
|
} else if let (Some(function), Type::Fn { .. }) =
|
|
(function, &*tipo)
|
|
{
|
|
let param_types = tipo.arg_types().unwrap();
|
|
|
|
let mut mono_types: IndexMap<u64, Arc<Type>> =
|
|
IndexMap::new();
|
|
let mut map = mono_types.into_iter().collect_vec();
|
|
|
|
for (index, arg) in function.arguments.iter().enumerate() {
|
|
if arg.tipo.is_generic() {
|
|
let param_type = ¶m_types[index];
|
|
|
|
map.append(&mut builder::get_generic_id_and_type(
|
|
&arg.tipo, param_type,
|
|
));
|
|
}
|
|
}
|
|
|
|
if function.return_type.is_generic() {
|
|
if let Type::Fn { ret, .. } = &*constructor.tipo {
|
|
map.append(&mut builder::get_generic_id_and_type(
|
|
&function.return_type,
|
|
ret,
|
|
))
|
|
}
|
|
}
|
|
|
|
mono_types = map.into_iter().collect();
|
|
let mut func_stack = AirStack::with_scope(
|
|
self.id_gen.clone(),
|
|
scope.clone(),
|
|
);
|
|
|
|
self.build(&function.body, &mut func_stack);
|
|
|
|
let temp_ir = func_stack.complete();
|
|
|
|
let (variant_name, _) =
|
|
builder::monomorphize(temp_ir, mono_types, &tipo);
|
|
|
|
func_calls.insert(
|
|
FunctionAccessKey {
|
|
module_name: current_func.module_name,
|
|
function_name: current_func.function_name,
|
|
variant_name,
|
|
},
|
|
(),
|
|
);
|
|
} else {
|
|
func_calls.insert(current_func, ());
|
|
}
|
|
}
|
|
}
|
|
|
|
let mut args = vec![];
|
|
|
|
for arg in function.arguments.iter() {
|
|
match &arg.arg_name {
|
|
ArgName::Named { name, .. } => {
|
|
args.push(name.clone());
|
|
}
|
|
_ => {
|
|
args.push("_".to_string());
|
|
}
|
|
}
|
|
}
|
|
|
|
let recursive = if func_calls.get(&function_key).is_some() {
|
|
func_calls.remove(&function_key);
|
|
true
|
|
} else {
|
|
false
|
|
};
|
|
|
|
func_components.insert(
|
|
function_key,
|
|
FuncComponents {
|
|
ir: func_ir,
|
|
dependencies: func_calls.keys().cloned().collect_vec(),
|
|
recursive,
|
|
args,
|
|
defined_by_zero_arg: in_zero_arg_func,
|
|
},
|
|
);
|
|
}
|
|
} else {
|
|
for func in to_be_defined_map.clone().iter() {
|
|
if scope.common_ancestor(func.1) == scope.clone() {
|
|
if let Some(index_scope) = func_index_map.get(func.0) {
|
|
if index_scope.common_ancestor(func.1) == scope.clone() {
|
|
func_index_map.insert(func.0.clone(), scope.clone());
|
|
to_be_defined_map.shift_remove(func.0);
|
|
} else {
|
|
to_be_defined_map.insert(
|
|
func.0.clone(),
|
|
index_scope.common_ancestor(func.1),
|
|
);
|
|
}
|
|
} else {
|
|
func_index_map.insert(func.0.clone(), scope.clone());
|
|
to_be_defined_map.shift_remove(func.0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
a => {
|
|
let scope = a.scope();
|
|
|
|
for func in to_be_defined_map.clone().iter() {
|
|
if scope.common_ancestor(func.1) == scope.clone() {
|
|
if let Some(index_scope) = func_index_map.get(func.0) {
|
|
if index_scope.common_ancestor(func.1) == scope.clone() {
|
|
func_index_map.insert(func.0.clone(), scope.clone());
|
|
to_be_defined_map.shift_remove(func.0);
|
|
} else {
|
|
to_be_defined_map.insert(
|
|
func.0.clone(),
|
|
index_scope.common_ancestor(func.1),
|
|
);
|
|
}
|
|
} else {
|
|
func_index_map.insert(func.0.clone(), scope.clone());
|
|
to_be_defined_map.shift_remove(func.0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Still to be defined
|
|
for func in to_be_defined_map.clone().iter() {
|
|
let index_scope = func_index_map.get(func.0).unwrap();
|
|
func_index_map.insert(func.0.clone(), func.1.common_ancestor(index_scope));
|
|
}
|
|
}
|
|
|
|
fn convert_opaque_type_to_inner_ir(&mut self, ir_stack: &mut Vec<Air>) {
|
|
let mut indices_to_remove = vec![];
|
|
for (index, ir) in ir_stack.clone().into_iter().enumerate() {
|
|
match ir {
|
|
Air::Var {
|
|
scope,
|
|
constructor,
|
|
name,
|
|
variant_name,
|
|
} => {
|
|
let mut replaced_type = constructor.tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::Var {
|
|
scope,
|
|
constructor: ValueConstructor {
|
|
public: constructor.public,
|
|
variant: constructor.variant,
|
|
tipo: replaced_type,
|
|
},
|
|
name,
|
|
variant_name,
|
|
};
|
|
}
|
|
Air::List {
|
|
tipo,
|
|
scope,
|
|
count,
|
|
tail,
|
|
} => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::List {
|
|
scope,
|
|
tipo: replaced_type,
|
|
count,
|
|
tail,
|
|
};
|
|
}
|
|
Air::ListAccessor {
|
|
tipo,
|
|
scope,
|
|
names,
|
|
tail,
|
|
check_last_item,
|
|
} => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::ListAccessor {
|
|
scope,
|
|
tipo: replaced_type,
|
|
names,
|
|
tail,
|
|
check_last_item,
|
|
};
|
|
}
|
|
Air::ListExpose {
|
|
tipo,
|
|
scope,
|
|
tail_head_names,
|
|
tail,
|
|
} => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::ListExpose {
|
|
scope,
|
|
tipo: replaced_type,
|
|
tail_head_names,
|
|
tail,
|
|
};
|
|
}
|
|
Air::Builtin {
|
|
tipo,
|
|
scope,
|
|
func,
|
|
count,
|
|
} => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::Builtin {
|
|
scope,
|
|
func,
|
|
count,
|
|
tipo: replaced_type,
|
|
};
|
|
}
|
|
Air::BinOp { tipo, scope, name } => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::BinOp {
|
|
scope,
|
|
name,
|
|
tipo: replaced_type,
|
|
};
|
|
}
|
|
Air::When {
|
|
tipo,
|
|
scope,
|
|
subject_name,
|
|
} => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::When {
|
|
scope,
|
|
tipo: replaced_type,
|
|
subject_name,
|
|
};
|
|
}
|
|
Air::Clause {
|
|
tipo,
|
|
scope,
|
|
subject_name,
|
|
complex_clause,
|
|
} => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::Clause {
|
|
scope,
|
|
tipo: replaced_type,
|
|
subject_name,
|
|
complex_clause,
|
|
};
|
|
}
|
|
Air::ListClause {
|
|
tipo,
|
|
scope,
|
|
tail_name,
|
|
next_tail_name,
|
|
complex_clause,
|
|
} => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::ListClause {
|
|
scope,
|
|
tipo: replaced_type,
|
|
tail_name,
|
|
next_tail_name,
|
|
complex_clause,
|
|
};
|
|
}
|
|
Air::TupleClause {
|
|
tipo,
|
|
scope,
|
|
indices,
|
|
predefined_indices,
|
|
subject_name,
|
|
count,
|
|
complex_clause,
|
|
} => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::TupleClause {
|
|
scope,
|
|
tipo: replaced_type,
|
|
indices,
|
|
predefined_indices,
|
|
subject_name,
|
|
count,
|
|
complex_clause,
|
|
};
|
|
}
|
|
Air::ClauseGuard {
|
|
tipo,
|
|
scope,
|
|
subject_name,
|
|
} => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::ClauseGuard {
|
|
scope,
|
|
subject_name,
|
|
tipo: replaced_type,
|
|
};
|
|
}
|
|
Air::ListClauseGuard {
|
|
tipo,
|
|
scope,
|
|
tail_name,
|
|
next_tail_name,
|
|
inverse,
|
|
} => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::ListClauseGuard {
|
|
scope,
|
|
tipo: replaced_type,
|
|
tail_name,
|
|
next_tail_name,
|
|
inverse,
|
|
};
|
|
}
|
|
Air::Tuple { tipo, scope, count } => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::Tuple {
|
|
scope,
|
|
tipo: replaced_type,
|
|
count,
|
|
};
|
|
}
|
|
Air::TupleIndex {
|
|
tipo,
|
|
scope,
|
|
tuple_index,
|
|
} => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::TupleIndex {
|
|
scope,
|
|
tipo: replaced_type,
|
|
tuple_index,
|
|
};
|
|
}
|
|
Air::ErrorTerm { tipo, scope } => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::ErrorTerm {
|
|
scope,
|
|
tipo: replaced_type,
|
|
};
|
|
}
|
|
Air::Trace { tipo, scope } => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::Trace {
|
|
scope,
|
|
tipo: replaced_type,
|
|
};
|
|
}
|
|
Air::TupleAccessor {
|
|
tipo,
|
|
scope,
|
|
names,
|
|
check_last_item,
|
|
} => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::TupleAccessor {
|
|
scope,
|
|
names,
|
|
tipo: replaced_type,
|
|
check_last_item,
|
|
};
|
|
}
|
|
Air::RecordUpdate {
|
|
highest_index,
|
|
indices,
|
|
scope,
|
|
tipo,
|
|
} => {
|
|
let mut new_indices = vec![];
|
|
for (ind, tipo) in indices {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
new_indices.push((ind, replaced_type));
|
|
}
|
|
|
|
ir_stack[index] = Air::RecordUpdate {
|
|
scope,
|
|
indices: new_indices,
|
|
highest_index,
|
|
tipo,
|
|
};
|
|
}
|
|
Air::Record {
|
|
tag: constr_index,
|
|
tipo,
|
|
count,
|
|
scope,
|
|
} => {
|
|
if builder::check_replaceable_opaque_type(&tipo, &self.data_types) {
|
|
indices_to_remove.push(index);
|
|
} else {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::Record {
|
|
scope,
|
|
tag: constr_index,
|
|
tipo: replaced_type,
|
|
count,
|
|
};
|
|
}
|
|
}
|
|
Air::RecordAccess {
|
|
record_index,
|
|
tipo,
|
|
scope,
|
|
} => {
|
|
let record = ir_stack[index + 1].clone();
|
|
let record_type = record.tipo();
|
|
if let Some(record_type) = record_type {
|
|
if builder::check_replaceable_opaque_type(&record_type, &self.data_types) {
|
|
indices_to_remove.push(index);
|
|
} else {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(
|
|
&mut replaced_type,
|
|
self.data_types.clone(),
|
|
);
|
|
|
|
ir_stack[index] = Air::RecordAccess {
|
|
scope,
|
|
record_index,
|
|
tipo: replaced_type,
|
|
};
|
|
}
|
|
} else {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::RecordAccess {
|
|
scope,
|
|
record_index,
|
|
tipo: replaced_type,
|
|
};
|
|
}
|
|
}
|
|
Air::FieldsExpose {
|
|
indices,
|
|
scope,
|
|
check_last_item,
|
|
} => {
|
|
let record = ir_stack[index + 1].clone();
|
|
let record_type = record.tipo();
|
|
if let Some(record_type) = record_type {
|
|
if builder::check_replaceable_opaque_type(&record_type, &self.data_types) {
|
|
ir_stack[index] = Air::Let {
|
|
scope,
|
|
name: indices[0].1.clone(),
|
|
};
|
|
} else {
|
|
let mut new_indices = vec![];
|
|
for (ind, name, tipo) in indices {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(
|
|
&mut replaced_type,
|
|
self.data_types.clone(),
|
|
);
|
|
new_indices.push((ind, name, replaced_type));
|
|
}
|
|
|
|
ir_stack[index] = Air::FieldsExpose {
|
|
scope,
|
|
indices: new_indices,
|
|
check_last_item,
|
|
};
|
|
}
|
|
} else {
|
|
let mut new_indices = vec![];
|
|
for (ind, name, tipo) in indices {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(
|
|
&mut replaced_type,
|
|
self.data_types.clone(),
|
|
);
|
|
new_indices.push((ind, name, replaced_type));
|
|
}
|
|
|
|
ir_stack[index] = Air::FieldsExpose {
|
|
scope,
|
|
indices: new_indices,
|
|
check_last_item,
|
|
};
|
|
}
|
|
}
|
|
Air::Call { scope, count, tipo } => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::Call {
|
|
scope,
|
|
tipo: replaced_type,
|
|
count,
|
|
};
|
|
}
|
|
Air::If { scope, tipo } => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::If {
|
|
scope,
|
|
tipo: replaced_type,
|
|
};
|
|
}
|
|
Air::UnWrapData { scope, tipo } => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::UnWrapData {
|
|
scope,
|
|
tipo: replaced_type,
|
|
};
|
|
}
|
|
Air::WrapData { scope, tipo } => {
|
|
let mut replaced_type = tipo.clone();
|
|
builder::replace_opaque_type(&mut replaced_type, self.data_types.clone());
|
|
|
|
ir_stack[index] = Air::WrapData {
|
|
scope,
|
|
tipo: replaced_type,
|
|
};
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
for index in indices_to_remove.into_iter().rev() {
|
|
ir_stack.remove(index);
|
|
}
|
|
}
|
|
|
|
fn uplc_code_gen(&mut self, ir_stack: &mut Vec<Air>) -> Term<Name> {
|
|
let mut arg_stack: Vec<Term<Name>> = vec![];
|
|
|
|
while let Some(ir_element) = ir_stack.pop() {
|
|
self.gen_uplc(ir_element, &mut arg_stack);
|
|
}
|
|
arg_stack[0].clone()
|
|
}
|
|
|
|
fn gen_uplc(&mut self, ir: Air, arg_stack: &mut Vec<Term<Name>>) {
|
|
match ir {
|
|
Air::Int { value, .. } => {
|
|
arg_stack.push(Term::integer(value.parse().unwrap()));
|
|
}
|
|
Air::String { 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::Var {
|
|
name,
|
|
constructor,
|
|
variant_name,
|
|
..
|
|
} => {
|
|
match &constructor.variant {
|
|
ValueConstructorVariant::LocalVariable { .. } => arg_stack.push(Term::Var(
|
|
Name {
|
|
text: name,
|
|
unique: 0.into(),
|
|
}
|
|
.into(),
|
|
)),
|
|
ValueConstructorVariant::ModuleConstant { .. } => {
|
|
unreachable!()
|
|
}
|
|
ValueConstructorVariant::ModuleFn {
|
|
name: func_name,
|
|
module,
|
|
..
|
|
} => {
|
|
let name = if (*func_name == name
|
|
|| name == format!("{module}_{func_name}"))
|
|
&& !module.is_empty()
|
|
{
|
|
format!("{module}_{func_name}{variant_name}")
|
|
} else {
|
|
format!("{func_name}{variant_name}")
|
|
};
|
|
|
|
arg_stack.push(Term::Var(
|
|
Name {
|
|
text: name,
|
|
unique: 0.into(),
|
|
}
|
|
.into(),
|
|
));
|
|
}
|
|
ValueConstructorVariant::Record {
|
|
name: constr_name, ..
|
|
} => {
|
|
if constructor.tipo.is_bool() {
|
|
arg_stack.push(Term::bool(constr_name == "True"));
|
|
} else if constructor.tipo.is_void() {
|
|
arg_stack.push(Term::Constant(UplcConstant::Unit.into()));
|
|
} else {
|
|
let data_type = builder::lookup_data_type_by_tipo(
|
|
self.data_types.clone(),
|
|
&constructor.tipo,
|
|
)
|
|
.unwrap();
|
|
|
|
let (constr_index, _) = data_type
|
|
.constructors
|
|
.iter()
|
|
.enumerate()
|
|
.find(|(_, x)| x.name == *constr_name)
|
|
.unwrap();
|
|
|
|
let fields = Term::empty_list();
|
|
|
|
let term = Term::constr_data()
|
|
.apply(Term::integer(constr_index.try_into().unwrap()))
|
|
.apply(fields);
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
Air::Void { .. } => arg_stack.push(Term::Constant(UplcConstant::Unit.into())),
|
|
Air::List {
|
|
count, tipo, tail, ..
|
|
} => {
|
|
let mut args = vec![];
|
|
|
|
for _ in 0..count {
|
|
let arg = arg_stack.pop().unwrap();
|
|
args.push(arg);
|
|
}
|
|
let mut constants = vec![];
|
|
for arg in &args {
|
|
if let Term::Constant(c) = arg {
|
|
constants.push(c.clone())
|
|
}
|
|
}
|
|
|
|
let list_type = tipo.get_inner_types()[0].clone();
|
|
|
|
if constants.len() == args.len() && !tail {
|
|
let list = if tipo.is_map() {
|
|
let mut convert_keys = vec![];
|
|
let mut convert_values = vec![];
|
|
for constant in constants {
|
|
match constant.as_ref() {
|
|
UplcConstant::ProtoPair(_, _, fst, snd) => {
|
|
convert_keys.push(fst.clone());
|
|
convert_values.push(snd.clone());
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
let convert_keys = builder::convert_constants_to_data(convert_keys);
|
|
let convert_values = builder::convert_constants_to_data(convert_values);
|
|
|
|
Term::Constant(
|
|
UplcConstant::ProtoList(
|
|
UplcType::Pair(UplcType::Data.into(), UplcType::Data.into()),
|
|
convert_keys
|
|
.into_iter()
|
|
.zip(convert_values.into_iter())
|
|
.map(|(key, value)| {
|
|
UplcConstant::ProtoPair(
|
|
UplcType::Data,
|
|
UplcType::Data,
|
|
key.into(),
|
|
value.into(),
|
|
)
|
|
})
|
|
.collect_vec(),
|
|
)
|
|
.into(),
|
|
)
|
|
} else {
|
|
Term::Constant(
|
|
UplcConstant::ProtoList(
|
|
UplcType::Data,
|
|
builder::convert_constants_to_data(constants),
|
|
)
|
|
.into(),
|
|
)
|
|
};
|
|
|
|
arg_stack.push(list);
|
|
} else {
|
|
let mut term = if tail {
|
|
arg_stack.pop().unwrap()
|
|
} else if tipo.is_map() {
|
|
Term::empty_map()
|
|
} else {
|
|
Term::empty_list()
|
|
};
|
|
|
|
for arg in args.into_iter().rev() {
|
|
let list_item = if tipo.is_map() {
|
|
arg
|
|
} else {
|
|
builder::convert_type_to_data(arg, &list_type)
|
|
};
|
|
term = Term::mk_cons().apply(list_item).apply(term);
|
|
}
|
|
arg_stack.push(term);
|
|
}
|
|
}
|
|
Air::ListAccessor {
|
|
names,
|
|
tail,
|
|
tipo,
|
|
check_last_item,
|
|
..
|
|
} => {
|
|
let value = arg_stack.pop().unwrap();
|
|
let mut term = arg_stack.pop().unwrap();
|
|
let list_id = self.id_gen.next();
|
|
|
|
let mut id_list = vec![];
|
|
id_list.push(list_id);
|
|
|
|
for _ in 0..names.len() {
|
|
id_list.push(self.id_gen.next());
|
|
}
|
|
|
|
let inner_types = tipo
|
|
.get_inner_types()
|
|
.into_iter()
|
|
.cycle()
|
|
.take(names.len())
|
|
.collect_vec();
|
|
|
|
term = builder::list_access_to_uplc(
|
|
&names,
|
|
&id_list,
|
|
tail,
|
|
0,
|
|
term,
|
|
inner_types,
|
|
check_last_item,
|
|
true,
|
|
)
|
|
.apply(value);
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::ListExpose {
|
|
tail_head_names,
|
|
tail,
|
|
tipo,
|
|
..
|
|
} => {
|
|
let mut term = arg_stack.pop().unwrap();
|
|
|
|
if let Some((tail_var, tail_name)) = tail {
|
|
term = term
|
|
.lambda(tail_name)
|
|
.apply(Term::tail_list().apply(Term::var(tail_var)));
|
|
}
|
|
|
|
for (tail_var, head_name) in tail_head_names.into_iter().rev() {
|
|
let head_list = if tipo.is_map() {
|
|
Term::head_list().apply(Term::var(tail_var))
|
|
} else {
|
|
builder::convert_data_to_type(
|
|
Term::head_list().apply(Term::var(tail_var)),
|
|
&tipo.get_inner_types()[0],
|
|
)
|
|
};
|
|
term = term.lambda(head_name).apply(head_list);
|
|
}
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::Fn { params, .. } => {
|
|
let mut term = arg_stack.pop().unwrap();
|
|
|
|
for param in params.iter().rev() {
|
|
term = term.lambda(param);
|
|
}
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::Call { count, .. } => {
|
|
if count >= 1 {
|
|
let mut term = arg_stack.pop().unwrap();
|
|
|
|
for _ in 0..count {
|
|
let arg = arg_stack.pop().unwrap();
|
|
|
|
term = term.apply(arg);
|
|
}
|
|
arg_stack.push(term);
|
|
} else {
|
|
let term = arg_stack.pop().unwrap();
|
|
|
|
let zero_arg_functions = self.zero_arg_functions.clone();
|
|
let mut anon_func = true;
|
|
|
|
if let Term::Var(name) = term.clone() {
|
|
let text = &name.text;
|
|
|
|
for (
|
|
FunctionAccessKey {
|
|
module_name,
|
|
function_name,
|
|
variant_name,
|
|
},
|
|
ir,
|
|
) in zero_arg_functions.into_iter()
|
|
{
|
|
let name_module =
|
|
format!("{module_name}_{function_name}{variant_name}");
|
|
let name = format!("{function_name}{variant_name}");
|
|
if text == &name || text == &name_module {
|
|
let mut term = self.uplc_code_gen(&mut ir.clone());
|
|
term = term
|
|
.constr_get_field()
|
|
.constr_fields_exposer()
|
|
.constr_index_exposer();
|
|
|
|
let mut program: Program<Name> = Program {
|
|
version: (1, 0, 0),
|
|
term,
|
|
};
|
|
|
|
let mut interner = Interner::new();
|
|
|
|
interner.program(&mut program);
|
|
|
|
let eval_program: Program<NamedDeBruijn> =
|
|
program.try_into().unwrap();
|
|
|
|
let evaluated_term: Term<NamedDeBruijn> =
|
|
eval_program.eval(ExBudget::default()).result().unwrap();
|
|
|
|
arg_stack.push(evaluated_term.try_into().unwrap());
|
|
anon_func = false;
|
|
}
|
|
}
|
|
}
|
|
if anon_func {
|
|
arg_stack.push(term);
|
|
}
|
|
}
|
|
}
|
|
Air::Builtin {
|
|
func, tipo, count, ..
|
|
} => {
|
|
let mut term: Term<Name> = Term::Builtin(func);
|
|
for _ in 0..func.force_count() {
|
|
term = term.force();
|
|
}
|
|
|
|
let mut arg_vec = vec![];
|
|
for _ in 0..count {
|
|
arg_vec.push(arg_stack.pop().unwrap());
|
|
}
|
|
|
|
for (index, arg) in arg_vec.into_iter().enumerate() {
|
|
let arg = if matches!(func, DefaultFunction::ChooseData) && index > 0 {
|
|
arg.delay()
|
|
} else {
|
|
arg
|
|
};
|
|
term = term.apply(arg.clone());
|
|
}
|
|
|
|
match func {
|
|
DefaultFunction::FstPair
|
|
| DefaultFunction::SndPair
|
|
| DefaultFunction::HeadList => {
|
|
let temp_var = format!("__item_{}", self.id_gen.next());
|
|
|
|
if count == 0 {
|
|
term = term.apply(Term::var(temp_var.clone()));
|
|
}
|
|
|
|
term = builder::convert_data_to_type(term, &tipo);
|
|
|
|
if count == 0 {
|
|
term = term.lambda(temp_var);
|
|
}
|
|
}
|
|
DefaultFunction::UnConstrData => {
|
|
let temp_tuple = format!("__unconstr_tuple_{}", self.id_gen.next());
|
|
|
|
let temp_var = format!("__item_{}", self.id_gen.next());
|
|
|
|
if count == 0 {
|
|
term = term.apply(Term::var(temp_var.clone()));
|
|
}
|
|
|
|
term = Term::mk_pair_data()
|
|
.apply(
|
|
Term::i_data()
|
|
.apply(Term::fst_pair().apply(Term::var(temp_tuple.clone()))),
|
|
)
|
|
.apply(
|
|
Term::list_data()
|
|
.apply(Term::snd_pair().apply(Term::var(temp_tuple.clone()))),
|
|
)
|
|
.lambda(temp_tuple)
|
|
.apply(term);
|
|
|
|
if count == 0 {
|
|
term = term.lambda(temp_var);
|
|
}
|
|
}
|
|
DefaultFunction::MkCons => {
|
|
unimplemented!("Use brackets instead.");
|
|
}
|
|
DefaultFunction::IfThenElse
|
|
| DefaultFunction::ChooseList
|
|
| DefaultFunction::Trace => unimplemented!("{func:#?}"),
|
|
DefaultFunction::ChooseData => {
|
|
let temp_vars = (0..func.arity())
|
|
.map(|_| format!("__item_{}", self.id_gen.next()))
|
|
.collect_vec();
|
|
|
|
if count == 0 {
|
|
for (index, temp_var) in temp_vars.iter().enumerate() {
|
|
term = term.apply(if index > 0 {
|
|
Term::var(temp_var.clone()).delay()
|
|
} else {
|
|
Term::var(temp_var.clone())
|
|
});
|
|
}
|
|
}
|
|
|
|
term = term.force();
|
|
|
|
if count == 0 {
|
|
for temp_var in temp_vars.into_iter().rev() {
|
|
term = term.lambda(temp_var);
|
|
}
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
arg_stack.push(term);
|
|
}
|
|
Air::BinOp { name, tipo, .. } => {
|
|
let left = arg_stack.pop().unwrap();
|
|
let right = arg_stack.pop().unwrap();
|
|
|
|
let builtin = if tipo.is_int() {
|
|
Term::equals_integer()
|
|
} else if tipo.is_string() {
|
|
Term::equals_string()
|
|
} else if tipo.is_bytearray() {
|
|
Term::equals_bytestring()
|
|
} else {
|
|
Term::equals_data()
|
|
};
|
|
|
|
let term =
|
|
match name {
|
|
BinOp::And => left.delayed_if_else(right, Term::bool(false)),
|
|
BinOp::Or => left.delayed_if_else(Term::bool(true), right),
|
|
BinOp::Eq => {
|
|
if tipo.is_bool() {
|
|
let term = left.delayed_if_else(
|
|
right.clone(),
|
|
right.if_else(Term::bool(false), Term::bool(true)),
|
|
);
|
|
|
|
arg_stack.push(term);
|
|
return;
|
|
} else if tipo.is_map() {
|
|
let term = builtin
|
|
.apply(Term::map_data().apply(left))
|
|
.apply(Term::map_data().apply(right));
|
|
|
|
arg_stack.push(term);
|
|
return;
|
|
} else if tipo.is_tuple()
|
|
&& matches!(tipo.get_uplc_type(), UplcType::Pair(_, _))
|
|
{
|
|
let term = builtin
|
|
.apply(Term::map_data().apply(
|
|
Term::mk_cons().apply(left).apply(Term::empty_map()),
|
|
))
|
|
.apply(Term::map_data().apply(
|
|
Term::mk_cons().apply(right).apply(Term::empty_map()),
|
|
));
|
|
|
|
arg_stack.push(term);
|
|
return;
|
|
} else if tipo.is_list() || tipo.is_tuple() {
|
|
let term = builtin
|
|
.apply(Term::list_data().apply(left))
|
|
.apply(Term::list_data().apply(right));
|
|
|
|
arg_stack.push(term);
|
|
return;
|
|
} else if tipo.is_void() {
|
|
arg_stack.push(Term::bool(true));
|
|
return;
|
|
}
|
|
|
|
builtin.apply(left).apply(right)
|
|
}
|
|
BinOp::NotEq => {
|
|
if tipo.is_bool() {
|
|
let term = left.delayed_if_else(
|
|
right.clone().if_else(Term::bool(false), Term::bool(true)),
|
|
right,
|
|
);
|
|
|
|
arg_stack.push(term);
|
|
return;
|
|
} else if tipo.is_map() {
|
|
let term = builtin
|
|
.apply(Term::map_data().apply(left))
|
|
.apply(Term::map_data().apply(right))
|
|
.if_else(Term::bool(false), Term::bool(true));
|
|
|
|
arg_stack.push(term);
|
|
return;
|
|
} else if tipo.is_tuple()
|
|
&& matches!(tipo.get_uplc_type(), UplcType::Pair(_, _))
|
|
{
|
|
let term = builtin
|
|
.apply(Term::map_data().apply(
|
|
Term::mk_cons().apply(left).apply(Term::empty_map()),
|
|
))
|
|
.apply(Term::map_data().apply(
|
|
Term::mk_cons().apply(right).apply(Term::empty_map()),
|
|
))
|
|
.if_else(Term::bool(false), Term::bool(true));
|
|
|
|
arg_stack.push(term);
|
|
return;
|
|
} else if tipo.is_list() || tipo.is_tuple() {
|
|
let term = builtin
|
|
.apply(Term::list_data().apply(left))
|
|
.apply(Term::list_data().apply(right))
|
|
.if_else(Term::bool(false), Term::bool(true));
|
|
|
|
arg_stack.push(term);
|
|
return;
|
|
} else if tipo.is_void() {
|
|
arg_stack.push(Term::bool(false));
|
|
return;
|
|
}
|
|
|
|
builtin
|
|
.apply(left)
|
|
.apply(right)
|
|
.if_else(Term::bool(false), Term::bool(true))
|
|
}
|
|
BinOp::LtInt => Term::Builtin(DefaultFunction::LessThanInteger)
|
|
.apply(left)
|
|
.apply(right),
|
|
BinOp::LtEqInt => Term::Builtin(DefaultFunction::LessThanEqualsInteger)
|
|
.apply(left)
|
|
.apply(right),
|
|
BinOp::GtEqInt => Term::Builtin(DefaultFunction::LessThanEqualsInteger)
|
|
.apply(right)
|
|
.apply(left),
|
|
BinOp::GtInt => Term::Builtin(DefaultFunction::LessThanInteger)
|
|
.apply(right)
|
|
.apply(left),
|
|
BinOp::AddInt => Term::add_integer().apply(left).apply(right),
|
|
BinOp::SubInt => Term::Builtin(DefaultFunction::SubtractInteger)
|
|
.apply(left)
|
|
.apply(right),
|
|
BinOp::MultInt => Term::Builtin(DefaultFunction::MultiplyInteger)
|
|
.apply(left)
|
|
.apply(right),
|
|
BinOp::DivInt => Term::Builtin(DefaultFunction::DivideInteger)
|
|
.apply(left)
|
|
.apply(right),
|
|
BinOp::ModInt => Term::Builtin(DefaultFunction::ModInteger)
|
|
.apply(left)
|
|
.apply(right),
|
|
};
|
|
arg_stack.push(term);
|
|
}
|
|
Air::DefineFunc {
|
|
func_name,
|
|
params,
|
|
recursive,
|
|
module_name,
|
|
variant_name,
|
|
..
|
|
} => {
|
|
let func_name = if module_name.is_empty() {
|
|
format!("{func_name}{variant_name}")
|
|
} else {
|
|
format!("{module_name}_{func_name}{variant_name}")
|
|
};
|
|
let mut func_body = arg_stack.pop().unwrap();
|
|
|
|
let mut term = arg_stack.pop().unwrap();
|
|
|
|
for param in params.iter().rev() {
|
|
func_body = func_body.lambda(param.clone());
|
|
}
|
|
|
|
if !recursive {
|
|
term = term.lambda(func_name).apply(func_body);
|
|
|
|
arg_stack.push(term);
|
|
} else {
|
|
func_body = func_body.lambda(func_name.clone());
|
|
|
|
term = term
|
|
.lambda(func_name.clone())
|
|
.apply(Term::var(func_name.clone()).apply(Term::var(func_name.clone())))
|
|
.lambda(func_name)
|
|
.apply(func_body);
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
}
|
|
Air::Let { name, .. } => {
|
|
let arg = arg_stack.pop().unwrap();
|
|
|
|
let mut term = arg_stack.pop().unwrap();
|
|
|
|
term = term.lambda(name).apply(arg);
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::UnWrapData { tipo, .. } => {
|
|
let mut term = arg_stack.pop().unwrap();
|
|
|
|
term = builder::convert_data_to_type(term, &tipo);
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::WrapData { tipo, .. } => {
|
|
let mut term = arg_stack.pop().unwrap();
|
|
|
|
term = builder::convert_type_to_data(term, &tipo);
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::AssertConstr { constr_index, .. } => {
|
|
self.needs_field_access = true;
|
|
let constr = arg_stack.pop().unwrap();
|
|
|
|
let mut term = arg_stack.pop().unwrap();
|
|
|
|
let error_term =
|
|
Term::Error.trace(Term::string("Expected on incorrect constructor variant."));
|
|
|
|
term = Term::equals_integer()
|
|
.apply(Term::integer(constr_index.into()))
|
|
.apply(Term::var(CONSTR_INDEX_EXPOSER).apply(constr))
|
|
.delayed_if_else(term, error_term);
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::AssertBool { is_true, .. } => {
|
|
let value = arg_stack.pop().unwrap();
|
|
let mut term = arg_stack.pop().unwrap();
|
|
|
|
let error_term =
|
|
Term::Error.trace(Term::string("Expected on incorrect boolean variant"));
|
|
|
|
if is_true {
|
|
term = value.delayed_if_else(term, error_term)
|
|
} else {
|
|
term = value.delayed_if_else(error_term, term)
|
|
}
|
|
arg_stack.push(term);
|
|
}
|
|
Air::When {
|
|
subject_name, tipo, ..
|
|
} => {
|
|
self.needs_field_access = true;
|
|
let subject = arg_stack.pop().unwrap();
|
|
|
|
let subject = if tipo.is_int()
|
|
|| tipo.is_bytearray()
|
|
|| tipo.is_string()
|
|
|| tipo.is_list()
|
|
|| tipo.is_tuple()
|
|
|| tipo.is_bool()
|
|
{
|
|
subject
|
|
} else {
|
|
Term::var(CONSTR_INDEX_EXPOSER).apply(subject)
|
|
};
|
|
|
|
let mut term = arg_stack.pop().unwrap();
|
|
|
|
term = term.lambda(subject_name).apply(subject);
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::Clause {
|
|
tipo,
|
|
subject_name,
|
|
complex_clause,
|
|
..
|
|
} => {
|
|
// clause to compare
|
|
let clause = arg_stack.pop().unwrap();
|
|
|
|
// the body to be run if the clause matches
|
|
let mut body = arg_stack.pop().unwrap();
|
|
|
|
// the next branch in the when expression
|
|
let mut term = arg_stack.pop().unwrap();
|
|
|
|
if tipo.is_bool() {
|
|
let other_clauses = if complex_clause {
|
|
Term::var("__other_clauses_delayed")
|
|
} else {
|
|
term.clone()
|
|
};
|
|
|
|
if matches!(clause, Term::Constant(boolean) if matches!(boolean.as_ref(), UplcConstant::Bool(true)))
|
|
{
|
|
body = Term::var(subject_name)
|
|
.if_else(body.delay(), other_clauses)
|
|
.force();
|
|
} else {
|
|
body = Term::var(subject_name)
|
|
.if_else(other_clauses, body.delay())
|
|
.force();
|
|
}
|
|
|
|
if complex_clause {
|
|
term = body.lambda("__other_clauses_delayed").apply(term.delay());
|
|
}
|
|
} else {
|
|
let condition = if tipo.is_int() {
|
|
Term::equals_integer()
|
|
.apply(clause)
|
|
.apply(Term::var(subject_name))
|
|
} else if tipo.is_bytearray() {
|
|
Term::equals_bytestring()
|
|
.apply(clause)
|
|
.apply(Term::var(subject_name))
|
|
} else if tipo.is_string() {
|
|
Term::equals_string()
|
|
.apply(clause)
|
|
.apply(Term::var(subject_name))
|
|
} else if tipo.is_list() || tipo.is_tuple() {
|
|
unreachable!("{:#?}", tipo)
|
|
} else {
|
|
Term::equals_integer()
|
|
.apply(clause)
|
|
.apply(Term::var(subject_name))
|
|
};
|
|
|
|
if complex_clause {
|
|
term = condition
|
|
.if_else(body.delay(), Term::var("__other_clauses_delayed"))
|
|
.force()
|
|
.lambda("__other_clauses_delayed")
|
|
.apply(term.delay());
|
|
} else {
|
|
term = condition.delayed_if_else(body, term);
|
|
}
|
|
}
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::ListClause {
|
|
tail_name,
|
|
next_tail_name,
|
|
complex_clause,
|
|
..
|
|
} => {
|
|
// discard to pop off
|
|
let _ = arg_stack.pop().unwrap();
|
|
|
|
let body = arg_stack.pop().unwrap();
|
|
let mut term = arg_stack.pop().unwrap();
|
|
|
|
let arg = if let Some(next_tail_name) = next_tail_name {
|
|
term.lambda(next_tail_name)
|
|
.apply(Term::tail_list().apply(Term::var(tail_name.clone())))
|
|
} else {
|
|
term
|
|
};
|
|
|
|
if complex_clause {
|
|
term = Term::var(tail_name)
|
|
.choose_list(body.delay(), Term::var("__other_clauses_delayed"))
|
|
.force()
|
|
.lambda("__other_clauses_delayed")
|
|
.apply(arg.delay());
|
|
} else {
|
|
term = Term::var(tail_name).delayed_choose_list(body, arg);
|
|
}
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::WrapClause { .. } => {
|
|
let _ = arg_stack.pop().unwrap();
|
|
|
|
let mut term = arg_stack.pop().unwrap();
|
|
let arg = arg_stack.pop().unwrap();
|
|
|
|
term = term.lambda("__other_clauses_delayed").apply(arg.delay());
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::ClauseGuard {
|
|
subject_name, tipo, ..
|
|
} => {
|
|
let checker = arg_stack.pop().unwrap();
|
|
|
|
let then = arg_stack.pop().unwrap();
|
|
|
|
if tipo.is_bool() {
|
|
let mut term = Term::var("__other_clauses_delayed");
|
|
if matches!(checker, Term::Constant(boolean) if matches!(boolean.as_ref(), UplcConstant::Bool(true)))
|
|
{
|
|
term = Term::var(subject_name).if_else(then.delay(), term).force();
|
|
} else {
|
|
term = Term::var(subject_name).if_else(term, then.delay()).force();
|
|
}
|
|
arg_stack.push(term);
|
|
} else {
|
|
let condition = if tipo.is_int() {
|
|
Term::equals_integer()
|
|
.apply(checker)
|
|
.apply(Term::var(subject_name))
|
|
} else if tipo.is_bytearray() {
|
|
Term::equals_bytestring()
|
|
.apply(checker)
|
|
.apply(Term::var(subject_name))
|
|
} else if tipo.is_string() {
|
|
Term::equals_string()
|
|
.apply(checker)
|
|
.apply(Term::var(subject_name))
|
|
} else if tipo.is_list() || tipo.is_tuple() {
|
|
unreachable!()
|
|
} else {
|
|
Term::equals_integer()
|
|
.apply(checker)
|
|
.apply(Term::var(CONSTR_INDEX_EXPOSER).apply(Term::var(subject_name)))
|
|
};
|
|
|
|
let term = condition
|
|
.if_else(then.delay(), Term::var("__other_clauses_delayed"))
|
|
.force();
|
|
arg_stack.push(term);
|
|
}
|
|
}
|
|
Air::ListClauseGuard {
|
|
tail_name,
|
|
next_tail_name,
|
|
inverse,
|
|
..
|
|
} => {
|
|
// discard to pop off
|
|
let _ = arg_stack.pop().unwrap();
|
|
|
|
// the body to be run if the clause matches
|
|
// the next branch in the when expression
|
|
let mut term = arg_stack.pop().unwrap();
|
|
|
|
term = if let Some(next_tail_name) = next_tail_name {
|
|
term.lambda(next_tail_name)
|
|
.apply(Term::tail_list().apply(Term::var(tail_name.clone())))
|
|
} else {
|
|
term
|
|
};
|
|
|
|
if !inverse {
|
|
term = Term::var(tail_name)
|
|
.choose_list(term.delay(), Term::var("__other_clauses_delayed"))
|
|
.force();
|
|
} else {
|
|
term = Term::var(tail_name)
|
|
.choose_list(Term::var("__other_clauses_delayed"), term.delay())
|
|
.force();
|
|
}
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::Finally { .. } => {
|
|
let _clause = arg_stack.pop().unwrap();
|
|
}
|
|
Air::If { .. } => {
|
|
let condition = arg_stack.pop().unwrap();
|
|
let then = arg_stack.pop().unwrap();
|
|
let mut term = arg_stack.pop().unwrap();
|
|
|
|
term = condition.delayed_if_else(then, term);
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::Record {
|
|
tag: constr_index,
|
|
tipo,
|
|
count,
|
|
..
|
|
} => {
|
|
let mut arg_vec = vec![];
|
|
for _ in 0..count {
|
|
arg_vec.push(arg_stack.pop().unwrap());
|
|
}
|
|
let mut term = Term::empty_list();
|
|
|
|
for (index, arg) in arg_vec.iter().enumerate().rev() {
|
|
term = Term::mk_cons()
|
|
.apply(builder::convert_type_to_data(
|
|
arg.clone(),
|
|
&tipo.arg_types().unwrap()[index],
|
|
))
|
|
.apply(term);
|
|
}
|
|
|
|
term = Term::constr_data()
|
|
.apply(Term::integer(constr_index.into()))
|
|
.apply(term);
|
|
|
|
if arg_vec.iter().all(|item| matches!(item, Term::Constant(_))) {
|
|
let mut program: Program<Name> = Program {
|
|
version: (1, 0, 0),
|
|
term,
|
|
};
|
|
|
|
let mut interner = Interner::new();
|
|
|
|
interner.program(&mut program);
|
|
|
|
let eval_program: Program<NamedDeBruijn> = program.try_into().unwrap();
|
|
|
|
let evaluated_term: Term<NamedDeBruijn> =
|
|
eval_program.eval(ExBudget::default()).result().unwrap();
|
|
term = evaluated_term.try_into().unwrap();
|
|
}
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::RecordAccess {
|
|
record_index, tipo, ..
|
|
} => {
|
|
self.needs_field_access = true;
|
|
let constr = arg_stack.pop().unwrap();
|
|
|
|
let mut term = Term::var(CONSTR_GET_FIELD)
|
|
.apply(Term::var(CONSTR_FIELDS_EXPOSER).apply(constr))
|
|
.apply(Term::integer(record_index.into()));
|
|
|
|
term = builder::convert_data_to_type(term, &tipo);
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::FieldsExpose {
|
|
indices,
|
|
check_last_item,
|
|
..
|
|
} => {
|
|
self.needs_field_access = true;
|
|
let mut id_list = vec![];
|
|
let value = arg_stack.pop().unwrap();
|
|
let mut term = arg_stack.pop().unwrap();
|
|
let list_id = self.id_gen.next();
|
|
|
|
id_list.push(list_id);
|
|
|
|
for _ in 0..indices.len() {
|
|
id_list.push(self.id_gen.next());
|
|
}
|
|
|
|
let current_index = 0;
|
|
|
|
let names = indices.iter().cloned().map(|item| item.1).collect_vec();
|
|
let inner_types = indices.iter().cloned().map(|item| item.2).collect_vec();
|
|
|
|
term = if !indices.is_empty() {
|
|
builder::list_access_to_uplc(
|
|
&names,
|
|
&id_list,
|
|
false,
|
|
current_index,
|
|
term,
|
|
inner_types,
|
|
check_last_item,
|
|
false,
|
|
)
|
|
} else {
|
|
term
|
|
};
|
|
|
|
term = term.apply(Term::var(CONSTR_FIELDS_EXPOSER).apply(value));
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::Tuple { tipo, count, .. } => {
|
|
let mut args = vec![];
|
|
|
|
for _ in 0..count {
|
|
let arg = arg_stack.pop().unwrap();
|
|
args.push(arg);
|
|
}
|
|
let mut constants = vec![];
|
|
for arg in &args {
|
|
if let Term::Constant(c) = arg {
|
|
constants.push(c.clone())
|
|
}
|
|
}
|
|
|
|
let tuple_sub_types = tipo.get_inner_types();
|
|
|
|
if constants.len() == args.len() {
|
|
let data_constants = builder::convert_constants_to_data(constants);
|
|
|
|
if count == 2 {
|
|
let term = Term::Constant(
|
|
UplcConstant::ProtoPair(
|
|
UplcType::Data,
|
|
UplcType::Data,
|
|
data_constants[0].clone().into(),
|
|
data_constants[1].clone().into(),
|
|
)
|
|
.into(),
|
|
);
|
|
arg_stack.push(term);
|
|
} else {
|
|
let term = Term::Constant(
|
|
UplcConstant::ProtoList(UplcType::Data, data_constants).into(),
|
|
);
|
|
arg_stack.push(term);
|
|
}
|
|
} else if count == 2 {
|
|
let term = Term::mk_pair_data()
|
|
.apply(builder::convert_type_to_data(
|
|
args[0].clone(),
|
|
&tuple_sub_types[0],
|
|
))
|
|
.apply(builder::convert_type_to_data(
|
|
args[1].clone(),
|
|
&tuple_sub_types[1],
|
|
));
|
|
|
|
arg_stack.push(term);
|
|
} else {
|
|
let mut term = Term::empty_list();
|
|
for (arg, tipo) in args.into_iter().zip(tuple_sub_types.into_iter()).rev() {
|
|
term = Term::mk_cons()
|
|
.apply(builder::convert_type_to_data(arg, &tipo))
|
|
.apply(term);
|
|
}
|
|
arg_stack.push(term);
|
|
}
|
|
}
|
|
Air::RecordUpdate {
|
|
highest_index,
|
|
indices,
|
|
..
|
|
} => {
|
|
self.needs_field_access = true;
|
|
let tail_name_prefix = "__tail_index";
|
|
|
|
let record = arg_stack.pop().unwrap();
|
|
|
|
let mut args = IndexMap::new();
|
|
let mut unchanged_field_indices = vec![];
|
|
let mut prev_index = 0;
|
|
for (index, tipo) in indices
|
|
.iter()
|
|
.sorted_by(|(index1, _), (index2, _)| index1.cmp(index2))
|
|
.rev()
|
|
{
|
|
let arg = arg_stack.pop().unwrap();
|
|
args.insert(*index, (tipo.clone(), arg));
|
|
|
|
for field_index in prev_index..*index {
|
|
unchanged_field_indices.push(field_index);
|
|
}
|
|
prev_index = *index;
|
|
}
|
|
|
|
unchanged_field_indices.reverse();
|
|
|
|
let mut term = Term::tail_list()
|
|
.apply(Term::var(format!("{tail_name_prefix}_{highest_index}")));
|
|
|
|
for current_index in (0..(highest_index + 1)).rev() {
|
|
let tail_name = format!("{tail_name_prefix}_{current_index}");
|
|
|
|
if let Some((tipo, arg)) = args.get(¤t_index) {
|
|
term = Term::mk_cons()
|
|
.apply(builder::convert_type_to_data(arg.clone(), tipo))
|
|
.apply(term);
|
|
} else {
|
|
term = Term::mk_cons()
|
|
.apply(Term::head_list().apply(Term::var(tail_name)))
|
|
.apply(term);
|
|
}
|
|
}
|
|
|
|
term = Term::constr_data()
|
|
.apply(Term::integer(0.into()))
|
|
.apply(term);
|
|
|
|
if !unchanged_field_indices.is_empty() {
|
|
prev_index = highest_index;
|
|
for index in unchanged_field_indices.into_iter() {
|
|
let tail_name = format!("{tail_name_prefix}_{prev_index}");
|
|
let prev_tail_name = format!("{tail_name_prefix}_{index}");
|
|
|
|
let mut tail_list = Term::var(prev_tail_name);
|
|
|
|
if index < prev_index {
|
|
for _ in index..prev_index {
|
|
tail_list = Term::tail_list().apply(tail_list);
|
|
}
|
|
|
|
term = term.lambda(tail_name).apply(tail_list);
|
|
}
|
|
prev_index = index;
|
|
}
|
|
}
|
|
let tail_name = format!("{tail_name_prefix}_{prev_index}");
|
|
let prev_tail_name = format!("{tail_name_prefix}_0");
|
|
|
|
let mut tail_list = Term::var(prev_tail_name.clone());
|
|
|
|
for _ in 0..prev_index {
|
|
tail_list = Term::tail_list().apply(tail_list);
|
|
}
|
|
if prev_index != 0 {
|
|
term = term.lambda(tail_name).apply(tail_list);
|
|
}
|
|
|
|
term = term
|
|
.lambda(prev_tail_name)
|
|
.apply(Term::var(CONSTR_FIELDS_EXPOSER).apply(record));
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::UnOp { op, .. } => {
|
|
let value = arg_stack.pop().unwrap();
|
|
|
|
let term = match op {
|
|
UnOp::Not => value.if_else(Term::bool(false), Term::bool(true)),
|
|
UnOp::Negate => Term::sub_integer()
|
|
.apply(Term::integer(0.into()))
|
|
.apply(value),
|
|
};
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::TupleIndex {
|
|
tipo, tuple_index, ..
|
|
} => {
|
|
let mut term = arg_stack.pop().unwrap();
|
|
|
|
if matches!(tipo.get_uplc_type(), UplcType::Pair(_, _)) {
|
|
if tuple_index == 0 {
|
|
term = builder::convert_data_to_type(
|
|
Term::fst_pair().apply(term),
|
|
&tipo.get_inner_types()[0],
|
|
);
|
|
} else {
|
|
term = builder::convert_data_to_type(
|
|
Term::snd_pair().apply(term),
|
|
&tipo.get_inner_types()[1],
|
|
);
|
|
}
|
|
} else {
|
|
self.needs_field_access = true;
|
|
term = builder::convert_data_to_type(
|
|
Term::var(CONSTR_GET_FIELD)
|
|
.apply(term)
|
|
.apply(Term::integer(tuple_index.into())),
|
|
&tipo.get_inner_types()[tuple_index],
|
|
);
|
|
}
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::TupleAccessor {
|
|
tipo,
|
|
names,
|
|
check_last_item,
|
|
..
|
|
} => {
|
|
let inner_types = tipo.get_inner_types();
|
|
let value = arg_stack.pop().unwrap();
|
|
let mut term = arg_stack.pop().unwrap();
|
|
let list_id = self.id_gen.next();
|
|
|
|
if names.len() == 2 {
|
|
term = term
|
|
.lambda(names[1].clone())
|
|
.apply(builder::convert_data_to_type(
|
|
Term::snd_pair().apply(Term::var(format!("__tuple_{list_id}"))),
|
|
&inner_types[1],
|
|
))
|
|
.lambda(names[0].clone())
|
|
.apply(builder::convert_data_to_type(
|
|
Term::fst_pair().apply(Term::var(format!("__tuple_{list_id}"))),
|
|
&inner_types[0],
|
|
))
|
|
.lambda(format!("__tuple_{list_id}"))
|
|
.apply(value);
|
|
} else {
|
|
let mut id_list = vec![];
|
|
id_list.push(list_id);
|
|
|
|
for _ in 0..names.len() {
|
|
id_list.push(self.id_gen.next());
|
|
}
|
|
|
|
term = builder::list_access_to_uplc(
|
|
&names,
|
|
&id_list,
|
|
false,
|
|
0,
|
|
term,
|
|
tipo.get_inner_types(),
|
|
check_last_item,
|
|
false,
|
|
)
|
|
.apply(value);
|
|
}
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::Trace { .. } => {
|
|
let text = arg_stack.pop().unwrap();
|
|
|
|
let term = arg_stack.pop().unwrap();
|
|
|
|
let term = term.trace(text);
|
|
|
|
arg_stack.push(term);
|
|
}
|
|
Air::ErrorTerm { .. } => arg_stack.push(Term::Error),
|
|
Air::TupleClause {
|
|
tipo,
|
|
indices,
|
|
subject_name,
|
|
complex_clause,
|
|
..
|
|
} => {
|
|
let mut term = arg_stack.pop().unwrap();
|
|
|
|
let tuple_types = tipo.get_inner_types();
|
|
|
|
if complex_clause {
|
|
let next_clause = arg_stack.pop().unwrap();
|
|
|
|
term = term
|
|
.lambda("__other_clauses_delayed")
|
|
.apply(next_clause.delay());
|
|
}
|
|
|
|
if tuple_types.len() == 2 {
|
|
for (index, name) in indices.iter() {
|
|
let builtin = if *index == 0 {
|
|
Term::fst_pair()
|
|
} else {
|
|
Term::snd_pair()
|
|
};
|
|
|
|
term = term.lambda(name).apply(builder::convert_data_to_type(
|
|
builtin.apply(Term::var(subject_name.clone())),
|
|
&tuple_types[*index].clone(),
|
|
));
|
|
}
|
|
} else {
|
|
for (index, name) in indices.iter() {
|
|
term = term
|
|
.lambda(name.clone())
|
|
.apply(builder::convert_data_to_type(
|
|
Term::head_list().apply(
|
|
Term::var(subject_name.clone()).repeat_tail_list(*index),
|
|
),
|
|
&tuple_types[*index].clone(),
|
|
));
|
|
}
|
|
}
|
|
arg_stack.push(term);
|
|
}
|
|
Air::Noop { .. } => {}
|
|
}
|
|
}
|
|
}
|