From ed3d143477f1500c9d4714c60863c373054ec23d Mon Sep 17 00:00:00 2001 From: rvcas Date: Mon, 5 Dec 2022 12:59:30 -0500 Subject: [PATCH] feat: rename ir to air --- crates/lang/src/{ir.rs => air.rs} | 107 +++++--------- crates/lang/src/lib.rs | 2 +- crates/lang/src/uplc.rs | 228 +++++++++++++++--------------- 3 files changed, 146 insertions(+), 191 deletions(-) rename crates/lang/src/{ir.rs => air.rs} (65%) diff --git a/crates/lang/src/ir.rs b/crates/lang/src/air.rs similarity index 65% rename from crates/lang/src/ir.rs rename to crates/lang/src/air.rs index 1075db9a..054aad7f 100644 --- a/crates/lang/src/ir.rs +++ b/crates/lang/src/air.rs @@ -7,10 +7,8 @@ use crate::{ tipo::{Type, ValueConstructor}, }; -// [] - #[derive(Debug, Clone)] -pub enum IR { +pub enum Air { Int { scope: Vec, value: String, @@ -236,78 +234,41 @@ pub enum IR { }, } -impl IR { +impl Air { pub fn scope(&self) -> Vec { match self { - IR::Int { scope, .. } - | IR::String { scope, .. } - | IR::ByteArray { scope, .. } - | IR::Var { scope, .. } - | IR::List { scope, .. } - | IR::Tail { scope, .. } - | IR::ListAccessor { scope, .. } - | IR::ListExpose { scope, .. } - | IR::Call { scope, .. } - | IR::Builtin { scope, .. } - | IR::BinOp { scope, .. } - | IR::Assignment { scope, .. } - | IR::DefineFunc { scope, .. } - | IR::DefineConst { scope, .. } - | IR::DefineConstrFields { scope, .. } - | IR::DefineConstrFieldAccess { scope, .. } - | IR::Lam { scope, .. } - | IR::When { scope, .. } - | IR::Clause { scope, .. } - | IR::ListClause { scope, .. } - | IR::ClauseGuard { scope, .. } - | IR::Discard { scope } - | IR::Finally { scope } - | IR::If { scope, .. } - | IR::Constr { scope, .. } - | IR::Fields { scope, .. } - | IR::RecordAccess { scope, .. } - | IR::FieldsExpose { scope, .. } - | IR::Todo { scope, .. } - | IR::Record { scope, .. } - | IR::RecordUpdate { scope, .. } - | IR::Negate { scope, .. } => scope.to_vec(), + Air::Int { scope, .. } + | Air::String { scope, .. } + | Air::ByteArray { scope, .. } + | Air::Var { scope, .. } + | Air::List { scope, .. } + | Air::Tail { scope, .. } + | Air::ListAccessor { scope, .. } + | Air::ListExpose { scope, .. } + | Air::Call { scope, .. } + | Air::Builtin { scope, .. } + | Air::BinOp { scope, .. } + | Air::Assignment { scope, .. } + | Air::DefineFunc { scope, .. } + | Air::DefineConst { scope, .. } + | Air::DefineConstrFields { scope, .. } + | Air::DefineConstrFieldAccess { scope, .. } + | Air::Lam { scope, .. } + | Air::When { scope, .. } + | Air::Clause { scope, .. } + | Air::ListClause { scope, .. } + | Air::ClauseGuard { scope, .. } + | Air::Discard { scope } + | Air::Finally { scope } + | Air::If { scope, .. } + | Air::Constr { scope, .. } + | Air::Fields { scope, .. } + | Air::RecordAccess { scope, .. } + | Air::FieldsExpose { scope, .. } + | Air::Todo { scope, .. } + | Air::Record { scope, .. } + | Air::RecordUpdate { scope, .. } + | Air::Negate { scope, .. } => scope.to_vec(), } } } -// pub fn get(r: Int) -> This{g: Int}{ -// This{ g: r } -// } -//let x = get(rdmr) when datum is { Hold(h, thing: f) -> h > x.g, Sell{price} -> x.g == price } - -// [ When(3) datum_var Clause(2) FieldsExpose(3) datum_var h_field_var f_field_var Binop(Greater, 2) h_var FieldAccess(2) x_var g_field Finally(2) Binop(2, EqualsInteger) FieldAccess x_var g_field_var ] - -// [ Assignment(2) ] - -// [ Assignment(2) x_var ] - -// [ Assignment(2) x_var Call(2) ] - -// [ Assignment(2) x_var Call(2) func_get_var ] -// ^Mark this index function insertion - -// [ Assignment(2) x_var Call(2) func_get_var rdmr_var When(4)] - -// [ Assignment(2) x_var Call(2) func_get_var ] - -// (var rdmr) - -// [ Assignment(2) x_var Call(2) ] - -// (var func_get) - -// arg stack [ (var rdmr)] - -// [ Assignment(2) x_var ] - -// [(var func_get) (var rdmr)] - -// [ Assignment(2)] - -// (var x) - -// arg stack [ [(var func_get) (var rdmr)] ] diff --git a/crates/lang/src/lib.rs b/crates/lang/src/lib.rs index 81af0c7a..a3d8a530 100644 --- a/crates/lang/src/lib.rs +++ b/crates/lang/src/lib.rs @@ -3,11 +3,11 @@ use std::sync::{ Arc, }; +pub mod air; pub mod ast; pub mod builtins; pub mod expr; pub mod format; -pub mod ir; pub mod parser; pub mod pretty; pub mod tipo; diff --git a/crates/lang/src/uplc.rs b/crates/lang/src/uplc.rs index 799c2f3b..260ab378 100644 --- a/crates/lang/src/uplc.rs +++ b/crates/lang/src/uplc.rs @@ -13,19 +13,19 @@ use uplc::{ }; use crate::{ + air::Air, ast::{ ArgName, AssignmentKind, BinOp, Clause, Constant, DataType, Function, Pattern, Span, TypedArg, }, expr::TypedExpr, - ir::IR, tipo::{self, PatternConstructor, Type, TypeInfo, ValueConstructor, ValueConstructorVariant}, IdGenerator, }; #[derive(Clone, Debug)] pub struct FuncComponents { - ir: Vec, + ir: Vec, dependencies: Vec, args: Vec, recursive: bool, @@ -100,12 +100,8 @@ impl<'a> CodeGenerator<'a> { self.build_ir(&body, &mut ir_stack, scope); - println!("INITIAL: {ir_stack:#?}"); - self.define_ir(&mut ir_stack); - println!("AFTER FUNCTION DEFINITIONS: {ir_stack:#?}"); - let mut term = self.uplc_code_gen(&mut ir_stack); if self.needs_field_access { @@ -134,24 +130,22 @@ impl<'a> CodeGenerator<'a> { let mut interner = Interner::new(); - println!("{}", program.to_pretty()); - interner.program(&mut program); program } - pub(crate) fn build_ir(&mut self, body: &TypedExpr, ir_stack: &mut Vec, scope: Vec) { + pub(crate) fn build_ir(&mut self, body: &TypedExpr, ir_stack: &mut Vec, scope: Vec) { match body { - TypedExpr::Int { value, .. } => ir_stack.push(IR::Int { + TypedExpr::Int { value, .. } => ir_stack.push(Air::Int { scope, value: value.to_string(), }), - TypedExpr::String { value, .. } => ir_stack.push(IR::String { + TypedExpr::String { value, .. } => ir_stack.push(Air::String { scope, value: value.to_string(), }), - TypedExpr::ByteArray { bytes, .. } => ir_stack.push(IR::ByteArray { + TypedExpr::ByteArray { bytes, .. } => ir_stack.push(Air::ByteArray { scope, bytes: bytes.to_vec(), }), @@ -172,7 +166,7 @@ impl<'a> CodeGenerator<'a> { TypedExpr::Var { constructor, name, .. } => { - ir_stack.push(IR::Var { + ir_stack.push(Air::Var { scope, constructor: constructor.clone(), name: name.clone(), @@ -185,7 +179,7 @@ impl<'a> CodeGenerator<'a> { tipo, .. } => { - ir_stack.push(IR::List { + ir_stack.push(Air::List { scope: scope.clone(), count: if tail.is_some() { elements.len() + 1 @@ -210,7 +204,7 @@ impl<'a> CodeGenerator<'a> { } } TypedExpr::Call { fun, args, .. } => { - ir_stack.push(IR::Call { + ir_stack.push(Air::Call { scope: scope.clone(), count: args.len() + 1, }); @@ -227,7 +221,7 @@ impl<'a> CodeGenerator<'a> { TypedExpr::BinOp { name, left, right, .. } => { - ir_stack.push(IR::BinOp { + ir_stack.push(Air::BinOp { scope: scope.clone(), name: *name, count: 2, @@ -249,9 +243,9 @@ impl<'a> CodeGenerator<'a> { tipo, .. } => { - let mut define_vec: Vec = vec![]; - let mut value_vec: Vec = vec![]; - let mut pattern_vec: Vec = vec![]; + let mut define_vec: Vec = vec![]; + let mut value_vec: Vec = vec![]; + let mut pattern_vec: Vec = vec![]; let mut value_scope = scope.clone(); value_scope.push(self.id_gen.next()); @@ -304,7 +298,7 @@ impl<'a> CodeGenerator<'a> { let mut scope = scope.clone(); scope.push(self.id_gen.next()); - // holds when clause pattern IR + // holds when clause pattern Air let mut clause_subject_vec = vec![]; // reset complex clause setting per clause back to default @@ -331,7 +325,7 @@ impl<'a> CodeGenerator<'a> { format!("__tail_{}", clause_properties.current_index - 1) }; - // Clause is first in IR pattern vec + // Clause is first in Air pattern vec if subject.tipo().is_list() { let next_tail = if index == clauses.len() - 1 { None @@ -339,7 +333,7 @@ impl<'a> CodeGenerator<'a> { Some(format!("__tail_{}", clause_properties.current_index)) }; - pattern_vec.push(IR::ListClause { + pattern_vec.push(Air::ListClause { scope, tipo: subject.tipo().clone(), tail_name: subject_name, @@ -349,7 +343,7 @@ impl<'a> CodeGenerator<'a> { clause_properties.current_index += 1; } else { - pattern_vec.push(IR::Clause { + pattern_vec.push(Air::Clause { scope, tipo: subject.tipo().clone(), subject_name, @@ -364,7 +358,7 @@ impl<'a> CodeGenerator<'a> { let mut final_scope = scope.clone(); final_scope.push(self.id_gen.next()); - pattern_vec.push(IR::Finally { + pattern_vec.push(Air::Finally { scope: final_scope.clone(), }); @@ -380,14 +374,14 @@ impl<'a> CodeGenerator<'a> { ); if needs_subject_var || clause_properties.needs_constr_var { - ir_stack.push(IR::Lam { + ir_stack.push(Air::Lam { scope: scope.clone(), name: constr_var.clone(), }); self.build_ir(&subject, ir_stack, scope.clone()); - ir_stack.push(IR::When { + ir_stack.push(Air::When { scope: scope.clone(), subject_name, tipo: subject.tipo(), @@ -396,7 +390,7 @@ impl<'a> CodeGenerator<'a> { let mut scope = scope; scope.push(self.id_gen.next()); - ir_stack.push(IR::Var { + ir_stack.push(Air::Var { scope, constructor: ValueConstructor::public( subject.tipo(), @@ -407,7 +401,7 @@ impl<'a> CodeGenerator<'a> { name: constr_var, }) } else { - ir_stack.push(IR::When { + ir_stack.push(Air::When { scope: scope.clone(), subject_name, tipo: subject.tipo(), @@ -434,11 +428,11 @@ impl<'a> CodeGenerator<'a> { branch_scope.push(self.id_gen.next()); if index == 0 { - if_ir.push(IR::If { + if_ir.push(Air::If { scope: scope.clone(), }); } else { - if_ir.push(IR::If { + if_ir.push(Air::If { scope: branch_scope.clone(), }); } @@ -461,7 +455,7 @@ impl<'a> CodeGenerator<'a> { } => { self.needs_field_access = true; - ir_stack.push(IR::RecordAccess { + ir_stack.push(Air::RecordAccess { scope: scope.clone(), index: *index, tipo: tipo.clone(), @@ -482,7 +476,7 @@ impl<'a> CodeGenerator<'a> { }); if let Some(func) = func { - ir_stack.push(IR::Var { + ir_stack.push(Air::Var { scope, constructor: ValueConstructor::public( func.return_type.clone(), @@ -504,7 +498,7 @@ impl<'a> CodeGenerator<'a> { ValueConstructorVariant::ModuleFn { builtin, .. } => { let builtin = builtin.unwrap(); - ir_stack.push(IR::Builtin { + ir_stack.push(Air::Builtin { func: builtin, scope, }); @@ -518,7 +512,7 @@ impl<'a> CodeGenerator<'a> { } }, TypedExpr::Todo { label, tipo, .. } => { - ir_stack.push(IR::Todo { + ir_stack.push(Air::Todo { scope, label: label.clone(), tipo: tipo.clone(), @@ -533,15 +527,15 @@ impl<'a> CodeGenerator<'a> { fn when_ir( &mut self, pattern: &Pattern>, - pattern_vec: &mut Vec, - values: &mut Vec, + pattern_vec: &mut Vec, + values: &mut Vec, tipo: &Type, clause_properties: &mut ClauseProperties, scope: Vec, ) { match pattern { Pattern::Int { value, .. } => { - pattern_vec.push(IR::Int { + pattern_vec.push(Air::Int { scope, value: value.clone(), }); @@ -550,15 +544,15 @@ impl<'a> CodeGenerator<'a> { } Pattern::String { .. } => todo!(), Pattern::Var { name, .. } => { - pattern_vec.push(IR::Discard { + pattern_vec.push(Air::Discard { scope: scope.clone(), }); - pattern_vec.push(IR::Lam { + pattern_vec.push(Air::Lam { scope: scope.clone(), name: name.clone(), }); - pattern_vec.push(IR::Var { + pattern_vec.push(Air::Var { scope, constructor: ValueConstructor::public( tipo.clone().into(), @@ -573,11 +567,11 @@ impl<'a> CodeGenerator<'a> { Pattern::VarUsage { .. } => todo!(), Pattern::Assign { name, pattern, .. } => { let mut new_vec = vec![]; - new_vec.push(IR::Lam { + new_vec.push(Air::Lam { scope: scope.clone(), name: name.clone(), }); - new_vec.push(IR::Var { + new_vec.push(Air::Var { scope: scope.clone(), constructor: ValueConstructor::public( tipo.clone().into(), @@ -601,7 +595,7 @@ impl<'a> CodeGenerator<'a> { ); } Pattern::Discard { .. } => { - pattern_vec.push(IR::Discard { scope }); + pattern_vec.push(Air::Discard { scope }); pattern_vec.append(values); } Pattern::List { elements, tail, .. } => { @@ -619,7 +613,7 @@ impl<'a> CodeGenerator<'a> { clause_properties.is_complex_clause = true; } - pattern_vec.push(IR::Discard { + pattern_vec.push(Air::Discard { scope: scope.clone(), }); @@ -674,7 +668,7 @@ impl<'a> CodeGenerator<'a> { .find(|(_, dt)| &dt.name == constr_name) .unwrap(); - let mut new_vec = vec![IR::Var { + let mut new_vec = vec![Air::Var { constructor: ValueConstructor::public( tipo.clone().into(), ValueConstructorVariant::LocalVariable { @@ -688,7 +682,7 @@ impl<'a> CodeGenerator<'a> { // if only one constructor, no need to check if data_type.constructors.len() > 1 { // push constructor Index - pattern_vec.push(IR::Int { + pattern_vec.push(Air::Int { value: index.to_string(), scope: scope.clone(), }); @@ -729,8 +723,8 @@ impl<'a> CodeGenerator<'a> { fn when_recursive_ir( &mut self, pattern: &Pattern>, - pattern_vec: &mut Vec, - values: &mut Vec, + pattern_vec: &mut Vec, + values: &mut Vec, clause_properties: ClauseProperties, _tipo: &Type, scope: Vec, @@ -742,7 +736,7 @@ impl<'a> CodeGenerator<'a> { Pattern::VarUsage { .. } => todo!(), Pattern::Assign { .. } => todo!(), Pattern::Discard { .. } => { - pattern_vec.push(IR::Discard { scope }); + pattern_vec.push(Air::Discard { scope }); pattern_vec.append(values); } @@ -763,7 +757,7 @@ impl<'a> CodeGenerator<'a> { // let mut var_vec = vec![]; // let item_name = format!("list_item_id_{}", self.id_gen.next()); // names.push(item_name.clone()); - // var_vec.push(IR::Var { + // var_vec.push(Air::Var { // constructor: ValueConstructor::public( // Type::App { // public: true, @@ -820,13 +814,13 @@ impl<'a> CodeGenerator<'a> { format!("__tail_{}", elements.len() - 2) }; - pattern_vec.push(IR::ListExpose { + pattern_vec.push(Air::ListExpose { scope, tail_head_names, tail: Some((tail_var, tail_name)), }); } else { - pattern_vec.push(IR::ListExpose { + pattern_vec.push(Air::ListExpose { scope, tail_head_names, tail: None, @@ -916,7 +910,7 @@ impl<'a> CodeGenerator<'a> { let data_type = self.data_types.get(&data_type_key).unwrap(); if data_type.constructors.len() > 1 { - nested_pattern.push(IR::ClauseGuard { + nested_pattern.push(Air::ClauseGuard { scope: scope.clone(), tipo: tipo.clone(), subject_name: constr_var_name.clone(), @@ -952,7 +946,7 @@ impl<'a> CodeGenerator<'a> { .collect::>(); if !arguments_index.is_empty() { - pattern_vec.push(IR::FieldsExpose { + pattern_vec.push(Air::FieldsExpose { count: arguments_index.len() + 2, indices: arguments_index .iter() @@ -1006,7 +1000,7 @@ impl<'a> CodeGenerator<'a> { let data_type = self.data_types.get(&data_type_key).unwrap(); if data_type.constructors.len() > 1 { - nested_pattern.push(IR::ClauseGuard { + nested_pattern.push(Air::ClauseGuard { scope: scope.clone(), tipo: tipo.clone(), subject_name: constr_var_name.clone(), @@ -1040,7 +1034,7 @@ impl<'a> CodeGenerator<'a> { .collect::>(); if !arguments_index.is_empty() { - pattern_vec.push(IR::FieldsExpose { + pattern_vec.push(Air::FieldsExpose { count: arguments_index.len() + 2, indices: arguments_index .iter() @@ -1065,8 +1059,8 @@ impl<'a> CodeGenerator<'a> { fn assignment_ir( &mut self, pattern: &Pattern>, - pattern_vec: &mut Vec, - value_vec: &mut Vec, + pattern_vec: &mut Vec, + value_vec: &mut Vec, _tipo: &Type, kind: AssignmentKind, scope: Vec, @@ -1075,7 +1069,7 @@ impl<'a> CodeGenerator<'a> { Pattern::Int { .. } => todo!(), Pattern::String { .. } => todo!(), Pattern::Var { name, .. } => { - pattern_vec.push(IR::Assignment { + pattern_vec.push(Air::Assignment { name: name.clone(), kind, scope, @@ -1099,8 +1093,8 @@ impl<'a> CodeGenerator<'a> { fn pattern_ir( &mut self, pattern: &Pattern>, - pattern_vec: &mut Vec, - values: &mut Vec, + pattern_vec: &mut Vec, + values: &mut Vec, scope: Vec, ) { match pattern { @@ -1110,7 +1104,7 @@ impl<'a> CodeGenerator<'a> { Pattern::VarUsage { .. } => todo!(), Pattern::Assign { .. } => todo!(), Pattern::Discard { .. } => { - pattern_vec.push(IR::Discard { scope }); + pattern_vec.push(Air::Discard { scope }); pattern_vec.append(values); } @@ -1127,7 +1121,7 @@ impl<'a> CodeGenerator<'a> { let mut var_vec = vec![]; let item_name = format!("list_item_id_{}", self.id_gen.next()); names.push(item_name.clone()); - var_vec.push(IR::Var { + var_vec.push(Air::Var { constructor: ValueConstructor::public( Type::App { public: true, @@ -1157,7 +1151,7 @@ impl<'a> CodeGenerator<'a> { } } - pattern_vec.push(IR::ListAccessor { + pattern_vec.push(Air::ListAccessor { names, tail: tail.is_some(), scope, @@ -1232,7 +1226,7 @@ impl<'a> CodeGenerator<'a> { self.pattern_ir( a, &mut nested_pattern, - &mut vec![IR::Var { + &mut vec![Air::Var { scope: scope.clone(), constructor: ValueConstructor::public( tipo.clone(), @@ -1257,7 +1251,7 @@ impl<'a> CodeGenerator<'a> { .collect::>(); if !arguments_index.is_empty() { - pattern_vec.push(IR::FieldsExpose { + pattern_vec.push(Air::FieldsExpose { count: arguments_index.len() + 2, indices: arguments_index .iter() @@ -1296,7 +1290,7 @@ impl<'a> CodeGenerator<'a> { self.pattern_ir( a, &mut nested_pattern, - &mut vec![IR::Var { + &mut vec![Air::Var { scope: scope.clone(), constructor: ValueConstructor::public( tipo.clone(), @@ -1320,7 +1314,7 @@ impl<'a> CodeGenerator<'a> { .collect::>(); if !arguments_index.is_empty() { - pattern_vec.push(IR::FieldsExpose { + pattern_vec.push(Air::FieldsExpose { count: arguments_index.len() + 2, indices: arguments_index .iter() @@ -1342,7 +1336,7 @@ impl<'a> CodeGenerator<'a> { } } - fn uplc_code_gen(&mut self, ir_stack: &mut Vec) -> Term { + fn uplc_code_gen(&mut self, ir_stack: &mut Vec) -> Term { let mut arg_stack: Vec> = vec![]; while let Some(ir_element) = ir_stack.pop() { @@ -1352,25 +1346,25 @@ impl<'a> CodeGenerator<'a> { arg_stack[0].clone() } - fn gen_uplc(&mut self, ir: IR, arg_stack: &mut Vec>) { + fn gen_uplc(&mut self, ir: Air, arg_stack: &mut Vec>) { match ir { - IR::Int { value, .. } => { + Air::Int { value, .. } => { let integer = value.parse().unwrap(); let term = Term::Constant(UplcConstant::Integer(integer)); arg_stack.push(term); } - IR::String { value, .. } => { + Air::String { value, .. } => { let term = Term::Constant(UplcConstant::String(value)); arg_stack.push(term); } - IR::ByteArray { bytes, .. } => { + Air::ByteArray { bytes, .. } => { let term = Term::Constant(UplcConstant::ByteString(bytes)); arg_stack.push(term); } - IR::Var { + Air::Var { name, constructor, .. } => match constructor.variant { ValueConstructorVariant::LocalVariable { .. } => arg_stack.push(Term::Var(Name { @@ -1495,10 +1489,10 @@ impl<'a> CodeGenerator<'a> { } } }, - IR::Discard { .. } => { + Air::Discard { .. } => { arg_stack.push(Term::Constant(UplcConstant::Unit)); } - IR::List { + Air::List { count, tipo, tail, .. } => { let mut args = vec![]; @@ -1550,8 +1544,8 @@ impl<'a> CodeGenerator<'a> { } } - IR::Tail { .. } => todo!(), - IR::ListAccessor { names, tail, .. } => { + Air::Tail { .. } => todo!(), + Air::ListAccessor { names, tail, .. } => { let value = arg_stack.pop().unwrap(); let mut term = arg_stack.pop().unwrap(); @@ -1601,7 +1595,7 @@ impl<'a> CodeGenerator<'a> { arg_stack.push(term); } - IR::ListExpose { + Air::ListExpose { tail_head_names, tail, .. @@ -1653,7 +1647,7 @@ impl<'a> CodeGenerator<'a> { arg_stack.push(term); } - IR::Call { count, .. } => { + Air::Call { count, .. } => { if count >= 2 { let mut term = arg_stack.pop().unwrap(); @@ -1670,14 +1664,14 @@ impl<'a> CodeGenerator<'a> { todo!() } } - IR::Builtin { func, .. } => { + Air::Builtin { func, .. } => { let mut term = Term::Builtin(func); for _ in 0..func.force_count() { term = Term::Force(term.into()); } arg_stack.push(term); } - IR::BinOp { name, tipo, .. } => { + Air::BinOp { name, tipo, .. } => { let left = arg_stack.pop().unwrap(); let right = arg_stack.pop().unwrap(); @@ -1951,7 +1945,7 @@ impl<'a> CodeGenerator<'a> { }; arg_stack.push(term); } - IR::Assignment { name, .. } => { + Air::Assignment { name, .. } => { let right_hand = arg_stack.pop().unwrap(); let lam_body = arg_stack.pop().unwrap(); @@ -1969,7 +1963,7 @@ impl<'a> CodeGenerator<'a> { arg_stack.push(term); } - IR::DefineFunc { + Air::DefineFunc { func_name, params, recursive, @@ -2078,10 +2072,10 @@ impl<'a> CodeGenerator<'a> { arg_stack.push(term); } } - IR::DefineConst { .. } => todo!(), - IR::DefineConstrFields { .. } => todo!(), - IR::DefineConstrFieldAccess { .. } => todo!(), - IR::Lam { name, .. } => { + Air::DefineConst { .. } => todo!(), + Air::DefineConstrFields { .. } => todo!(), + Air::DefineConstrFieldAccess { .. } => todo!(), + Air::Lam { name, .. } => { let arg = arg_stack.pop().unwrap(); let mut term = arg_stack.pop().unwrap(); @@ -2099,7 +2093,7 @@ impl<'a> CodeGenerator<'a> { }; arg_stack.push(term); } - IR::When { + Air::When { subject_name, tipo, .. } => { let subject = arg_stack.pop().unwrap(); @@ -2135,7 +2129,7 @@ impl<'a> CodeGenerator<'a> { arg_stack.push(term); } - IR::Clause { + Air::Clause { tipo, subject_name, complex_clause, @@ -2250,7 +2244,7 @@ impl<'a> CodeGenerator<'a> { arg_stack.push(term); } - IR::ListClause { + Air::ListClause { tail_name, next_tail_name, .. @@ -2311,7 +2305,7 @@ impl<'a> CodeGenerator<'a> { arg_stack.push(term); } - IR::ClauseGuard { + Air::ClauseGuard { subject_name, tipo, .. } => { let condition = arg_stack.pop().unwrap(); @@ -2386,10 +2380,10 @@ impl<'a> CodeGenerator<'a> { arg_stack.push(term); } - IR::Finally { .. } => { + Air::Finally { .. } => { let _clause = arg_stack.pop().unwrap(); } - IR::If { .. } => { + Air::If { .. } => { let condition = arg_stack.pop().unwrap(); let then = arg_stack.pop().unwrap(); let mut term = arg_stack.pop().unwrap(); @@ -2414,9 +2408,9 @@ impl<'a> CodeGenerator<'a> { arg_stack.push(term); } - IR::Constr { .. } => todo!(), - IR::Fields { .. } => todo!(), - IR::RecordAccess { index, tipo, .. } => { + Air::Constr { .. } => todo!(), + Air::Fields { .. } => todo!(), + Air::RecordAccess { index, tipo, .. } => { let constr = arg_stack.pop().unwrap(); let mut term = Term::Apply { @@ -2459,7 +2453,7 @@ impl<'a> CodeGenerator<'a> { arg_stack.push(term); } - IR::FieldsExpose { indices, .. } => { + Air::FieldsExpose { indices, .. } => { self.needs_field_access = true; let constr_var = arg_stack.pop().unwrap(); @@ -2697,16 +2691,16 @@ impl<'a> CodeGenerator<'a> { arg_stack.push(body); } - IR::Todo { .. } => { + Air::Todo { .. } => { arg_stack.push(Term::Error); } - IR::Record { .. } => todo!(), - IR::RecordUpdate { .. } => todo!(), - IR::Negate { .. } => todo!(), + Air::Record { .. } => todo!(), + Air::RecordUpdate { .. } => todo!(), + Air::Negate { .. } => todo!(), } } - pub(crate) fn define_ir(&mut self, ir_stack: &mut Vec) { + pub(crate) fn define_ir(&mut self, ir_stack: &mut Vec) { let mut func_components = IndexMap::new(); let mut func_index_map = IndexMap::new(); @@ -2745,7 +2739,7 @@ impl<'a> CodeGenerator<'a> { .dependencies .extend(depend_comp.dependencies.clone()); - let mut temp_ir = vec![IR::DefineFunc { + let mut temp_ir = vec![Air::DefineFunc { scope: func_scope.clone(), func_name: dependency.function_name.clone(), module_name: dependency.module_name.clone(), @@ -2767,7 +2761,7 @@ impl<'a> CodeGenerator<'a> { for (index, ir) in ir_stack.clone().into_iter().enumerate().rev() { match ir { - IR::Var { constructor, .. } => { + Air::Var { constructor, .. } => { if let ValueConstructorVariant::ModuleFn { .. } = &constructor.variant {} } a => { @@ -2788,7 +2782,7 @@ impl<'a> CodeGenerator<'a> { let funt_comp = func_components.get(item.0).unwrap(); - full_func_ir.push(IR::DefineFunc { + full_func_ir.push(Air::DefineFunc { scope: item.1.clone(), func_name: item.0.function_name.clone(), module_name: item.0.module_name.clone(), @@ -2809,7 +2803,7 @@ impl<'a> CodeGenerator<'a> { fn define_recurse_ir( &mut self, - ir_stack: &[IR], + ir_stack: &[Air], func_components: &mut IndexMap, func_index_map: &mut IndexMap>, recursion_func_map: IndexMap, @@ -2825,7 +2819,7 @@ impl<'a> CodeGenerator<'a> { let function_ir = function_components.ir.clone(); for ir in function_ir.clone() { - if let IR::Var { + if let Air::Var { constructor: ValueConstructor { variant: @@ -2886,14 +2880,14 @@ impl<'a> CodeGenerator<'a> { fn process_define_ir( &mut self, - ir_stack: &[IR], + ir_stack: &[Air], func_components: &mut IndexMap, func_index_map: &mut IndexMap>, ) { let mut to_be_defined_map: IndexMap> = IndexMap::new(); for ir in ir_stack.iter().rev() { match ir { - IR::Var { + Air::Var { scope, constructor, .. } => { if let ValueConstructorVariant::ModuleFn { @@ -2926,7 +2920,7 @@ impl<'a> CodeGenerator<'a> { let mut func_calls = vec![]; for ir in func_ir.clone() { - if let IR::Var { + if let Air::Var { constructor: ValueConstructor { variant: @@ -3012,16 +3006,16 @@ impl<'a> CodeGenerator<'a> { } } -fn constants_ir(literal: &Constant, String>, ir_stack: &mut Vec, scope: Vec) { +fn constants_ir(literal: &Constant, String>, ir_stack: &mut Vec, scope: Vec) { match literal { Constant::Int { value, .. } => { - ir_stack.push(IR::Int { + ir_stack.push(Air::Int { scope, value: value.clone(), }); } Constant::String { value, .. } => { - ir_stack.push(IR::String { + ir_stack.push(Air::String { scope, value: value.clone(), }); @@ -3030,7 +3024,7 @@ fn constants_ir(literal: &Constant, String>, ir_stack: &mut Vec, s todo!() } Constant::List { elements, tipo, .. } => { - ir_stack.push(IR::List { + ir_stack.push(Air::List { scope: scope.clone(), count: elements.len(), tipo: tipo.clone(), @@ -3042,11 +3036,11 @@ fn constants_ir(literal: &Constant, String>, ir_stack: &mut Vec, s } } Constant::Record { .. } => { - // ir_stack.push(IR::Record { scope, }); + // ir_stack.push(Air::Record { scope, }); todo!() } Constant::ByteArray { bytes, .. } => { - ir_stack.push(IR::ByteArray { + ir_stack.push(Air::ByteArray { scope, bytes: bytes.clone(), });