Use rust-native PatioCompilationUnit and PatioCompilationUnitElement

3 files changed, 113 insertions, 51 deletions

diff --git a/patio-to-cranelift/src/lib.rs b/patio-to-cranelift/src/lib.rs
index ad54d59e..e62daae3 100644
--- a/patio-to-cranelift/src/lib.rs
+++ b/patio-to-cranelift/src/lib.rs
@@ -6,7 +6,10 @@ use crate::{
     context::{CompilerContext, CompilerFunctionContext},
     errors::CompileError,
     patio::{
-        compilation_unit::{PatioLocal, PatioLocalType, PatioVisibility},
+        compilation_unit::{
+            PatioCompilationUnit, PatioCompilationUnitElement, PatioFunctionDeclaration,
+            PatioFunctionDefinition, PatioLocal, PatioLocalType, PatioVisibility,
+        },
         instructions::{
             PatioBlock, PatioBoolToInt, PatioCall, PatioIf, PatioInstruction, PatioIntAdd,
             PatioIntEquals, PatioIntNotEqual, PatioIntSub, PatioIntToBool, PatioLocalStore,
@@ -16,9 +19,6 @@ use crate::{
         types::{PatioDataLayout, PatioType},
         values::PatioIntValue,
     },
-    patio_generated::patio::{
-        PatioCompilationUnitElement, PatioCompilationUnitElementValue, PatioFunctionDefinition,
-    },
 };
 
 #[allow(dead_code, unused_imports)]
@@ -36,19 +36,21 @@ mod patio;
 pub fn compile(source_path: &Path, target_str: &str) -> Result<(), CompileError> {
     let source_bytes = std::fs::read(source_path).map_err(CompileError::ReadSourceBytes)?;
 
-    let compilation_unit = patio_generated::patio::root_as_patio_compilation_unit(&source_bytes)
-        .map_err(CompileError::InvalidFlatbuffer)?;
+    let compilation_unit: PatioCompilationUnit =
+        patio_generated::patio::root_as_patio_compilation_unit(&source_bytes)
+            .map_err(CompileError::InvalidFlatbuffer)?
+            .into();
 
     let target_triple =
         target_lexicon::Triple::from_str(target_str).map_err(CompileError::ParseTargetTriple)?;
 
     let mut context = CompilerContext::for_object(source_path, target_triple)?;
 
-    for element in compilation_unit.elements() {
+    for element in &compilation_unit.elements {
         declare_compilation_unit_element(&element, &mut context);
     }
 
-    for element in compilation_unit.elements() {
+    for element in &compilation_unit.elements {
         define_compilation_unit_element(&element, &mut context);
     }
 
@@ -65,24 +67,14 @@ fn declare_compilation_unit_element(
     element: &PatioCompilationUnitElement,
     context: &mut CompilerContext,
 ) {
-    match element.value_type() {
-        PatioCompilationUnitElementValue::PatioFunctionDeclaration => {
-            let function_declaration = element.value_as_patio_function_declaration().unwrap();
-
+    match element {
+        PatioCompilationUnitElement::FunctionDeclaration(function_declaration) => {
             declare_function_declaration(function_declaration, context);
         }
 
-        PatioCompilationUnitElementValue::PatioFunctionDefinition => {
-            let function_definition = element.value_as_patio_function_definition().unwrap();
-
-            declare_function_definition(&function_definition, context);
+        PatioCompilationUnitElement::FunctionDefinition(function_definition) => {
+            declare_function_definition(function_definition, context);
         }
-
-        element_type => todo!(
-            "Unhandled compilation unit element type: {:?} {}",
-            element_type.variant_name(),
-            element_type.0,
-        ),
     }
 }
 
@@ -90,35 +82,27 @@ fn define_compilation_unit_element(
     element: &PatioCompilationUnitElement,
     context: &mut CompilerContext,
 ) {
-    match element.value_type() {
-        PatioCompilationUnitElementValue::PatioFunctionDeclaration => {}
-
-        PatioCompilationUnitElementValue::PatioFunctionDefinition => {
-            let function_definition = element.value_as_patio_function_definition().unwrap();
+    match element {
+        PatioCompilationUnitElement::FunctionDeclaration(_) => {}
 
+        PatioCompilationUnitElement::FunctionDefinition(function_definition) => {
             define_function_definition(&function_definition, context);
         }
-
-        element_type => todo!(
-            "Unhandled compilation unit element type: {:?} {}",
-            element_type.variant_name(),
-            element_type.0,
-        ),
     }
 }
 
 fn declare_function_declaration(
-    function_declaration: patio_generated::patio::PatioFunctionDeclaration<'_>,
+    function_declaration: &PatioFunctionDeclaration,
     context: &mut CompilerContext,
 ) {
     let cranelift_signature = cranelift_signature(
-        function_declaration.params().iter().map(Into::into),
-        function_declaration.return_type().into(),
+        function_declaration.params.iter(),
+        function_declaration.return_type,
         &context.target_triple,
     );
 
     context.declare_function(
-        function_declaration.name(),
+        &function_declaration.name,
         cranelift_module::Linkage::Import,
         &cranelift_signature,
     );
@@ -129,16 +113,15 @@ fn declare_function_definition(
     context: &mut CompilerContext,
 ) {
     let cranelift_signature = cranelift_signature(
-        function_definition.locals().iter().map(Into::into),
-        function_definition.return_type().into(),
+        function_definition.locals.iter().map(Into::into),
+        function_definition.return_type,
         &context.target_triple,
     );
 
-    let cranelift_linkage =
-        patio_visibility_to_cranelift_linkage(function_definition.visibility().into());
+    let cranelift_linkage = patio_visibility_to_cranelift_linkage(function_definition.visibility);
 
     context.declare_function(
-        function_definition.name(),
+        &function_definition.name,
         cranelift_linkage,
         &cranelift_signature,
     );
@@ -149,16 +132,16 @@ fn define_function_definition(
     context: &mut CompilerContext,
 ) {
     let cranelift_signature = cranelift_signature(
-        function_definition.locals().iter().map(Into::into),
-        function_definition.return_type().into(),
+        function_definition.locals.iter().map(Into::into),
+        function_definition.return_type,
         &context.target_triple,
     );
 
     context.enter_function(
-        function_definition.name(),
+        &function_definition.name,
         cranelift_signature,
         |function_context| {
-            for local in function_definition.locals().iter().map(PatioLocal::from) {
+            for local in &function_definition.locals {
                 match local.local_type {
                     PatioLocalType::Param => {}
 
@@ -180,8 +163,8 @@ fn define_function_definition(
                 }
             }
 
-            for instruction in function_definition.body() {
-                compile_instruction(&instruction.into(), function_context)
+            for instruction in &function_definition.body {
+                compile_instruction(instruction, function_context)
             }
         },
     );
@@ -544,7 +527,7 @@ fn def_destination(
 }
 
 fn cranelift_signature<'a>(
-    locals: impl Iterator<Item = PatioLocal>,
+    locals: impl Iterator<Item = &'a PatioLocal>,
     return_type: PatioType,
     target_triple: &target_lexicon::Triple,
 ) -> cranelift::prelude::Signature {
diff --git a/patio-to-cranelift/src/patio/compilation_unit.rs b/patio-to-cranelift/src/patio/compilation_unit.rs
index a07d964f..585f50fd 100644
--- a/patio-to-cranelift/src/patio/compilation_unit.rs
+++ b/patio-to-cranelift/src/patio/compilation_unit.rs
@@ -1,4 +1,27 @@
-use crate::patio::types::PatioType;
+use crate::patio::{instructions::PatioInstruction, types::PatioType};
+
+pub(crate) struct PatioCompilationUnit {
+    pub(crate) elements: Vec<PatioCompilationUnitElement>,
+}
+
+pub(crate) enum PatioCompilationUnitElement {
+    FunctionDeclaration(PatioFunctionDeclaration),
+    FunctionDefinition(PatioFunctionDefinition),
+}
+
+pub(crate) struct PatioFunctionDeclaration {
+    pub(crate) name: String,
+    pub(crate) params: Vec<PatioLocal>,
+    pub(crate) return_type: PatioType,
+}
+
+pub(crate) struct PatioFunctionDefinition {
+    pub(crate) name: String,
+    pub(crate) visibility: PatioVisibility,
+    pub(crate) locals: Vec<PatioLocal>,
+    pub(crate) return_type: PatioType,
+    pub(crate) body: Vec<PatioInstruction>,
+}
 
 pub(crate) struct PatioLocal {
     pub(crate) name: String,
@@ -13,6 +36,7 @@ pub(crate) enum PatioLocalType {
     Var,
 }
 
+#[derive(Clone, Copy)]
 pub(crate) enum PatioVisibility {
     Public,
     Private,
diff --git a/patio-to-cranelift/src/patio/flatbuffers.rs b/patio-to-cranelift/src/patio/flatbuffers.rs
index 9f147695..64e8b569 100644
--- a/patio-to-cranelift/src/patio/flatbuffers.rs
+++ b/patio-to-cranelift/src/patio/flatbuffers.rs
@@ -1,6 +1,9 @@
 use crate::{
     patio::{
-        compilation_unit::{PatioLocal, PatioLocalType, PatioVisibility},
+        compilation_unit::{
+            PatioCompilationUnit, PatioCompilationUnitElement, PatioFunctionDeclaration,
+            PatioFunctionDefinition, PatioLocal, PatioLocalType, PatioVisibility,
+        },
         instructions::{
             PatioBlock, PatioBoolToInt, PatioCall, PatioIf, PatioInstruction, PatioIntAdd,
             PatioIntEquals, PatioIntNotEqual, PatioIntSub, PatioIntToBool, PatioLocalStore,
@@ -16,8 +19,60 @@ use crate::{
     },
 };
 
+// == Compilation unit ==
+
+impl From<patio_generated::patio::PatioCompilationUnit<'_>> for PatioCompilationUnit {
+    fn from(value: patio_generated::patio::PatioCompilationUnit<'_>) -> Self {
+        Self {
+            elements: value.elements().iter().map(Into::into).collect(),
+        }
+    }
+}
+
 // == Compilation unit elements ==
 
+impl From<patio_generated::patio::PatioCompilationUnitElement<'_>> for PatioCompilationUnitElement {
+    fn from(value: patio_generated::patio::PatioCompilationUnitElement<'_>) -> Self {
+        match value.value_type() {
+            patio_generated::patio::PatioCompilationUnitElementValue::PatioFunctionDeclaration => {
+                let function_declaration = value.value_as_patio_function_declaration().unwrap();
+
+                Self::FunctionDeclaration(PatioFunctionDeclaration {
+                    name: function_declaration.name().to_string(),
+                    params: function_declaration
+                        .params()
+                        .iter()
+                        .map(Into::into)
+                        .collect(),
+                    return_type: function_declaration.return_type().into(),
+                })
+            }
+
+            patio_generated::patio::PatioCompilationUnitElementValue::PatioFunctionDefinition => {
+                let function_definition = value.value_as_patio_function_definition().unwrap();
+
+                Self::FunctionDefinition(PatioFunctionDefinition {
+                    name: function_definition.name().to_string(),
+                    visibility: function_definition.visibility().into(),
+                    locals: function_definition
+                        .locals()
+                        .iter()
+                        .map(Into::into)
+                        .collect(),
+                    return_type: function_definition.return_type().into(),
+                    body: function_definition.body().iter().map(Into::into).collect(),
+                })
+            }
+
+            element_type => todo!(
+                "Unhandled compilation unit element type: {:?} {}",
+                element_type.variant_name(),
+                element_type.0
+            ),
+        }
+    }
+}
+
 impl From<patio_generated::patio::PatioLocal<'_>> for PatioLocal {
     fn from(value: patio_generated::patio::PatioLocal<'_>) -> Self {
         Self {