Use transient-0 instead of flatbuffersmain

1 files changed, 88 insertions, 71 deletions

diff --git a/patio-to-cranelift/src/codegen/mod.rs b/patio-to-cranelift/src/codegen/mod.rs
index be98a0a3..a9cfab5b 100644
--- a/patio-to-cranelift/src/codegen/mod.rs
+++ b/patio-to-cranelift/src/codegen/mod.rs
@@ -9,12 +9,10 @@ use crate::{
     },
     errors::CompileError,
     patio::{
-        compilation_unit::{
-            PatioCompilationUnit, PatioCompilationUnitElement, PatioDataElementImmutableDefinition,
-            PatioDataElementMutableDeclaration, PatioDataElementMutableDefinition,
-            PatioFunctionDeclaration, PatioFunctionDefinition, PatioLocal, PatioLocalType,
-            PatioVisibility,
-        },
+        PatioCompilationUnit, PatioCompilationUnitElement, PatioDataElementImmutableDefinition,
+        PatioDataElementMutableDeclaration, PatioDataElementMutableDefinition,
+        PatioFunctionDeclaration, PatioFunctionDefinition, PatioLocal, PatioLocalType,
+        PatioVisibility,
         instructions::{
             PatioBlock, PatioBoolToInt, PatioCall, PatioCallPointer, PatioDataPtrToInt, PatioIf,
             PatioInstruction, PatioIntAdd, PatioIntEquals, PatioIntNotEqual, PatioIntSub,
@@ -23,7 +21,10 @@ use crate::{
             PatioUnreachable, PatioVarLoad, PatioVarStore,
         },
         operands::{PatioLocalRef, PatioOperand},
-        types::PatioType,
+        types::{
+            PatioBoolType, PatioByteType, PatioDataPtrType, PatioFunctionPtrType, PatioInt32Type,
+            PatioIntType, PatioType,
+        },
         values::{PatioDataPtrValue, PatioIntValue},
     },
 };
@@ -84,29 +85,31 @@ fn declare_compilation_unit_element(
     context: &mut CompilerContext,
 ) {
     match element {
-        PatioCompilationUnitElement::DataElementImmutableDefinition(
+        PatioCompilationUnitElement::PatioDataElementImmutableDefinition(
             data_element_immutable_definition,
         ) => {
             declare_data_element_immutable_definition(data_element_immutable_definition, context);
         }
 
-        PatioCompilationUnitElement::DataElementMutableDeclaration(
+        PatioCompilationUnitElement::PatioDataElementMutableDeclaration(
             data_element_mutable_declaration,
         ) => {
             declare_data_element_mutable_declaration(data_element_mutable_declaration, context);
         }
 
-        PatioCompilationUnitElement::DataElementMutableDefinition(
+        PatioCompilationUnitElement::PatioDataElementMutableDefinition(
             data_element_mutable_definition,
         ) => {
             declare_data_element_mutable_definition(data_element_mutable_definition, context);
         }
 
-        PatioCompilationUnitElement::FunctionDeclaration(function_declaration) => {
+        PatioCompilationUnitElement::PatioExceptionTypeDefinition(_) => todo!(),
+
+        PatioCompilationUnitElement::PatioFunctionDeclaration(function_declaration) => {
             declare_function_declaration(function_declaration, context);
         }
 
-        PatioCompilationUnitElement::FunctionDefinition(function_definition) => {
+        PatioCompilationUnitElement::PatioFunctionDefinition(function_definition) => {
             declare_function_definition(function_definition, context);
         }
     }
@@ -117,23 +120,25 @@ fn define_compilation_unit_element(
     context: &mut CompilerContext,
 ) {
     match element {
-        PatioCompilationUnitElement::DataElementImmutableDefinition(
+        PatioCompilationUnitElement::PatioDataElementImmutableDefinition(
             data_element_immutable_definition,
         ) => {
             define_data_element_immutable_definition(data_element_immutable_definition, context);
         }
 
-        PatioCompilationUnitElement::DataElementMutableDeclaration(_) => {}
+        PatioCompilationUnitElement::PatioDataElementMutableDeclaration(_) => {}
 
-        PatioCompilationUnitElement::DataElementMutableDefinition(
+        PatioCompilationUnitElement::PatioDataElementMutableDefinition(
             data_element_mutable_definition,
         ) => {
             define_data_element_mutable_definition(data_element_mutable_definition, context);
         }
 
-        PatioCompilationUnitElement::FunctionDeclaration(_) => {}
+        PatioCompilationUnitElement::PatioExceptionTypeDefinition(_) => todo!(),
 
-        PatioCompilationUnitElement::FunctionDefinition(function_definition) => {
+        PatioCompilationUnitElement::PatioFunctionDeclaration(_) => {}
+
+        PatioCompilationUnitElement::PatioFunctionDefinition(function_definition) => {
             define_function_definition(&function_definition, context);
         }
     }
@@ -254,7 +259,7 @@ fn define_function_definition(
 
             for local in &function_definition.locals {
                 let cranelift_type = types::patio_type_to_cranelift_type(
-                    local.type_,
+                    &local.r#type,
                     &function_context.target_triple,
                 );
 
@@ -284,95 +289,103 @@ fn define_function_definition(
 
 fn compile_instruction(instruction: &PatioInstruction, context: &mut CompilerFunctionContext<'_>) {
     match instruction {
-        PatioInstruction::Block(block) => {
+        PatioInstruction::PatioBlock(block) => {
             compile_block(block, context);
         }
 
-        PatioInstruction::BoolToInt(bool_to_int) => {
+        PatioInstruction::PatioBoolToInt(bool_to_int) => {
             compile_bool_to_int(bool_to_int, context);
         }
 
-        PatioInstruction::Call(call) => {
+        PatioInstruction::PatioCall(call) => {
             compile_call(call, context);
         }
 
-        PatioInstruction::CallPointer(call_pointer) => {
+        PatioInstruction::PatioCallPointer(call_pointer) => {
             compile_call_pointer(call_pointer, context);
         }
 
-        PatioInstruction::DataPtrToInt(data_ptr_to_int) => {
+        PatioInstruction::PatioDataPtrToInt(data_ptr_to_int) => {
             compile_data_ptr_to_int(data_ptr_to_int, context);
         }
 
-        PatioInstruction::If(if_) => {
+        PatioInstruction::PatioIf(if_) => {
             compile_if(if_, context);
         }
 
-        PatioInstruction::IntAdd(int_add) => {
+        PatioInstruction::PatioIntAdd(int_add) => {
             compile_int_add(int_add, context);
         }
 
-        PatioInstruction::IntEquals(int_equals) => {
+        PatioInstruction::PatioIntEquals(int_equals) => {
             compile_int_equals(int_equals, context);
         }
 
-        PatioInstruction::IntNotEqual(int_not_equal) => {
+        PatioInstruction::PatioIntNotEqual(int_not_equal) => {
             compile_int_not_equal(int_not_equal, context);
         }
 
-        PatioInstruction::IntSub(int_sub) => {
+        PatioInstruction::PatioIntSub(int_sub) => {
             compile_int_sub(int_sub, context);
         }
 
-        PatioInstruction::IntToBool(int_to_bool) => {
+        PatioInstruction::PatioIntToBool(int_to_bool) => {
             compile_int_to_bool(int_to_bool, context);
         }
 
-        PatioInstruction::IntToDataPtr(int_to_data_ptr) => {
+        PatioInstruction::PatioIntToDataPtr(int_to_data_ptr) => {
             compile_int_to_data_ptr(int_to_data_ptr, context);
         }
 
-        PatioInstruction::LocalStore(local_store) => {
+        PatioInstruction::PatioLocalStore(local_store) => {
             compile_local_store(local_store, context);
         }
 
-        PatioInstruction::Loop(loop_) => {
+        PatioInstruction::PatioLoop(loop_) => {
             compile_loop(loop_, context);
         }
 
-        PatioInstruction::LoopBreak(loop_break) => {
+        PatioInstruction::PatioLoopBreak(loop_break) => {
             compile_loop_break(loop_break, context);
         }
 
-        PatioInstruction::LoopContinue(loop_continue) => {
+        PatioInstruction::PatioLoopContinue(loop_continue) => {
             compile_loop_continue(loop_continue, context);
         }
 
-        PatioInstruction::MemoryLoad(memory_load) => {
+        PatioInstruction::PatioMemoryLoad(memory_load) => {
             compile_memory_load(memory_load, context);
         }
 
-        PatioInstruction::MemoryStore(memory_store) => {
+        PatioInstruction::PatioMemoryStore(memory_store) => {
             compile_memory_store(memory_store, context);
         }
 
-        PatioInstruction::Return(return_) => {
+        PatioInstruction::PatioReturn(return_) => {
             compile_return(return_, context);
         }
 
-        PatioInstruction::Switch(switch) => {
+        PatioInstruction::PatioSwitch(switch) => {
             compile_switch(switch, context);
         }
 
-        PatioInstruction::Unreachable(unreachable) => {
+        PatioInstruction::PatioThrow(_) => {
+            todo!();
+        }
+
+        PatioInstruction::PatioTry(_) => {
+            todo!();
+        }
+
+        PatioInstruction::PatioUnreachable(unreachable) => {
             compile_unreachable(unreachable, context);
         }
 
-        PatioInstruction::VarLoad(var_load) => {
+        PatioInstruction::PatioVarLoad(var_load) => {
             compile_var_load(var_load, context);
         }
 
-        PatioInstruction::VarStore(var_store) => {
+        PatioInstruction::PatioVarStore(var_store) => {
             compile_var_store(var_store, context);
         }
     }
@@ -640,7 +653,7 @@ fn compile_memory_load(memory_load: &PatioMemoryLoad, context: &mut CompilerFunc
     let value_layout =
         types::data_layout_element_at(&memory_load.layout, &memory_load.element_offsets);
     let value_type = types::data_layout_to_type(value_layout);
-    let cranelift_type = types::patio_type_to_cranelift_type(value_type, &context.target_triple);
+    let cranelift_type = types::patio_type_to_cranelift_type(&value_type, &context.target_triple);
 
     let cranelift_pointer = compile_operand(&memory_load.pointer, context);
     let cranelift_flags = cranelift_codegen::ir::MemFlags::new();
@@ -719,7 +732,7 @@ fn compile_switch(switch: &PatioSwitch, context: &mut CompilerFunctionContext<'_
     // Create the jump itself.
     let mut cranelift_switch = cranelift::frontend::Switch::new();
     for (case, case_block) in switch.cases.iter().zip(&case_blocks) {
-        cranelift_switch.set_entry(case.value.into(), *case_block);
+        cranelift_switch.set_entry(case.value.try_into().unwrap(), *case_block);
     }
     cranelift_switch.emit(
         &mut context.function_builder,
@@ -796,8 +809,8 @@ fn compile_operand(
     context: &mut CompilerFunctionContext<'_>,
 ) -> cranelift::prelude::Value {
     match operand {
-        PatioOperand::BoolConst(value) => {
-            let integer_value = if *value { 1 } else { 0 };
+        PatioOperand::PatioBoolConst(bool_const) => {
+            let integer_value = if bool_const.value { 1 } else { 0 };
 
             context
                 .function_builder
@@ -805,10 +818,12 @@ fn compile_operand(
                 .iconst(types::CRANELIFT_BOOL_TYPE, integer_value)
         }
 
-        PatioOperand::DataPtrConst(value) => compile_data_ptr_value(&value, context),
+        PatioOperand::PatioDataPtrConst(data_ptr_const) => {
+            compile_data_ptr_value(&data_ptr_const.value, context)
+        }
 
-        PatioOperand::FunctionPtrConst(name) => {
-            let func_ref = context.func_id(name);
+        PatioOperand::PatioFunctionPtrConst(function_ptr_const) => {
+            let func_ref = context.func_id(&function_ptr_const.name);
             let function_ptr_type = context.pointer_type();
 
             context
@@ -817,16 +832,16 @@ fn compile_operand(
                 .func_addr(function_ptr_type, func_ref)
         }
 
-        PatioOperand::IntConst(value) => {
+        PatioOperand::PatioIntConst(int_const) => {
             let cranelift_int_type = types::cranelift_int_type(&context.target_triple);
-            compile_int_value(&value, cranelift_int_type, context)
+            compile_int_value(&int_const.value, cranelift_int_type, context)
         }
 
-        PatioOperand::Int32Const(value) => {
-            compile_int_value(&value, types::CRANELIFT_INT_32_TYPE, context)
+        PatioOperand::PatioInt32Const(int_32_const) => {
+            compile_int_value(&int_32_const.value, types::CRANELIFT_INT_32_TYPE, context)
         }
 
-        PatioOperand::LocalRef(local_ref) => context.local_load(&local_ref.name),
+        PatioOperand::PatioLocalRef(local_ref) => context.local_load(&local_ref.name),
 
         _ => {
             todo!("Unhandled operand: {operand:?}",)
@@ -841,15 +856,17 @@ fn compile_data_ptr_value(
     let data_ptr_type = context.pointer_type();
 
     match data_ptr_value {
-        PatioDataPtrValue::DataElement { name } => {
-            let global_value = context.data_ptr(name);
+        PatioDataPtrValue::PatioDataPtrValueDataElement(data_element) => {
+            let global_value = context.data_ptr(&data_element.name);
             context
                 .function_builder
                 .ins()
                 .global_value(data_ptr_type, global_value)
         }
 
-        PatioDataPtrValue::Null => context.function_builder.ins().iconst(data_ptr_type, 0),
+        PatioDataPtrValue::PatioDataPtrValueNull(_) => {
+            context.function_builder.ins().iconst(data_ptr_type, 0)
+        }
     }
 }
 
@@ -896,7 +913,7 @@ fn cranelift_signature<'a>(
 
     for local in locals {
         if local.local_type == PatioLocalType::Param {
-            let param_type = types::patio_type_to_cranelift_type(local.type_, &target_triple);
+            let param_type = types::patio_type_to_cranelift_type(&local.r#type, &target_triple);
             let param = cranelift::prelude::AbiParam::new(param_type);
             signature.params.push(param);
         }
@@ -904,7 +921,7 @@ fn cranelift_signature<'a>(
 
     for return_type in return_types {
         let cranelift_return_type =
-            types::patio_type_to_cranelift_type(*return_type, &target_triple);
+            types::patio_type_to_cranelift_type(return_type, &target_triple);
         let returns = cranelift::prelude::AbiParam::new(cranelift_return_type);
         signature.returns.push(returns);
     }
@@ -924,25 +941,25 @@ fn patio_operand_to_cranelift_type(
     context: &mut CompilerFunctionContext<'_>,
 ) -> cranelift_codegen::ir::Type {
     match operand {
-        PatioOperand::BoolConst(_) => {
-            patio_type_to_cranelift_type(PatioType::Bool, &context.target_triple)
+        PatioOperand::PatioBoolConst(_) => {
+            patio_type_to_cranelift_type(&PatioBoolType.into(), &context.target_triple)
         }
-        PatioOperand::ByteConst(_) => {
-            patio_type_to_cranelift_type(PatioType::Byte, &context.target_triple)
+        PatioOperand::PatioByteConst(_) => {
+            patio_type_to_cranelift_type(&PatioByteType.into(), &context.target_triple)
         }
-        PatioOperand::DataPtrConst(_) => {
-            patio_type_to_cranelift_type(PatioType::DataPtr, &context.target_triple)
+        PatioOperand::PatioDataPtrConst(_) => {
+            patio_type_to_cranelift_type(&PatioDataPtrType.into(), &context.target_triple)
         }
-        PatioOperand::FunctionPtrConst(_) => {
-            patio_type_to_cranelift_type(PatioType::FunctionPtr, &context.target_triple)
+        PatioOperand::PatioFunctionPtrConst(_) => {
+            patio_type_to_cranelift_type(&PatioFunctionPtrType.into(), &context.target_triple)
         }
-        PatioOperand::IntConst(_) => {
-            patio_type_to_cranelift_type(PatioType::Int, &context.target_triple)
+        PatioOperand::PatioIntConst(_) => {
+            patio_type_to_cranelift_type(&PatioIntType.into(), &context.target_triple)
         }
-        PatioOperand::Int32Const(_) => {
-            patio_type_to_cranelift_type(PatioType::Int32, &context.target_triple)
+        PatioOperand::PatioInt32Const(_) => {
+            patio_type_to_cranelift_type(&PatioInt32Type.into(), &context.target_triple)
         }
-        PatioOperand::LocalRef(local_ref) => context.local_type(&local_ref.name),
+        PatioOperand::PatioLocalRef(local_ref) => context.local_type(&local_ref.name),
     }
 }