Use transient-0 instead of flatbuffersmain

1 files changed, 104 insertions, 53 deletions

diff --git a/patio-to-cranelift/src/codegen/values.rs b/patio-to-cranelift/src/codegen/values.rs
index 229dbc6f..e4bcec2b 100644
--- a/patio-to-cranelift/src/codegen/values.rs
+++ b/patio-to-cranelift/src/codegen/values.rs
@@ -1,6 +1,9 @@
 use crate::{
     codegen::types,
-    patio::values::{PatioDataPtrValue, PatioDataValue, PatioIntValue},
+    patio::{
+        types::{PatioDataValue, PatioDataValueDataPtr},
+        values::{PatioDataPtrValue, PatioIntValue},
+    },
 };
 
 pub(crate) fn data_value_to_bytes(
@@ -24,37 +27,38 @@ fn write_data_value(
     target_triple: &target_lexicon::Triple,
 ) {
     match value {
-        PatioDataValue::Array {
-            element_layout: _,
-            elements,
-        } => {
-            for element in elements {
+        PatioDataValue::PatioDataValueArray(array) => {
+            for element in &array.elements {
                 write_data_value(element, bytes, target_triple);
             }
         }
 
-        PatioDataValue::Bool(value) => bytes.push(if *value { 1 } else { 0 }),
+        PatioDataValue::PatioDataValueBool(bool) => bytes.push(if bool.value { 1 } else { 0 }),
 
-        PatioDataValue::Byte(value) => bytes.push(*value),
+        PatioDataValue::PatioDataValueByte(byte) => bytes.push(byte.value as u8),
 
-        PatioDataValue::DataPtr(PatioDataPtrValue::DataElement { name: _ }) => todo!(),
+        PatioDataValue::PatioDataValueDataPtr(PatioDataValueDataPtr {
+            value: PatioDataPtrValue::PatioDataPtrValueDataElement(_),
+        }) => todo!(),
 
-        PatioDataValue::DataPtr(PatioDataPtrValue::Null) => {
+        PatioDataValue::PatioDataValueDataPtr(PatioDataValueDataPtr {
+            value: PatioDataPtrValue::PatioDataPtrValueNull(_),
+        }) => {
             write_patio_int(0, bytes, target_triple);
         }
 
-        PatioDataValue::Int(int_value) => {
-            let value = eval_int_value(int_value, target_triple);
+        PatioDataValue::PatioDataValueInt(int_value) => {
+            let value = eval_int_value(&int_value.value, target_triple);
             write_patio_int(value, bytes, target_triple);
         }
 
-        PatioDataValue::Int32(int_value) => {
-            let value: i32 = eval_int_value(int_value, target_triple);
+        PatioDataValue::PatioDataValueInt32(int_value) => {
+            let value: i32 = eval_int_value(&int_value.value, target_triple);
             bytes.extend_from_slice(&value.to_le_bytes());
         }
 
-        PatioDataValue::Struct { elements } => {
-            for element in elements {
+        PatioDataValue::PatioDataValueStruct(value_struct) => {
+            for element in &value_struct.elements {
                 write_data_value(element, bytes, target_triple);
             }
         }
@@ -80,18 +84,21 @@ fn write_patio_int(value: i32, bytes: &mut Vec<u8>, target_triple: &target_lexic
 
 pub(crate) fn eval_int_value(value: &PatioIntValue, target_triple: &target_lexicon::Triple) -> i32 {
     match value {
-        PatioIntValue::ByteOffsetOf {
-            layout,
-            element_offsets,
-        } => types::data_layout_byte_offset(layout, element_offsets, target_triple)
-            .try_into()
-            .unwrap(),
+        PatioIntValue::PatioIntValueByteOffsetOf(byte_offset_of) => types::data_layout_byte_offset(
+            &byte_offset_of.layout,
+            &byte_offset_of.element_offsets,
+            target_triple,
+        )
+        .try_into()
+        .unwrap(),
 
-        PatioIntValue::ByteSizeOf { layout } => types::data_layout_byte_size(layout, target_triple)
-            .try_into()
-            .unwrap(),
+        PatioIntValue::PatioIntValueByteSizeOf(byte_size_of) => {
+            types::data_layout_byte_size(&byte_size_of.layout, target_triple)
+                .try_into()
+                .unwrap()
+        }
 
-        PatioIntValue::Literal { value } => *value,
+        PatioIntValue::PatioIntValueLiteral(literal) => literal.value,
     }
 }
 
@@ -100,8 +107,12 @@ mod data_value_to_bytes_test {
     use std::str::FromStr;
 
     use crate::patio::{
-        types::PatioDataLayout,
-        values::{PatioDataPtrValue, PatioDataValue, PatioIntValue},
+        types::{
+            PatioDataLayoutInt32, PatioDataValue, PatioDataValueArray, PatioDataValueBool,
+            PatioDataValueByte, PatioDataValueDataPtr, PatioDataValueInt, PatioDataValueInt32,
+            PatioDataValueStruct,
+        },
+        values::{PatioDataPtrValueNull, PatioIntValueLiteral},
     };
 
     fn data_value_to_bytes(data_value: PatioDataValue) -> Box<[u8]> {
@@ -113,13 +124,20 @@ mod data_value_to_bytes_test {
 
     #[test]
     fn array_is_written_as_elements() {
-        let data_value = PatioDataValue::Array {
-            element_layout: PatioDataLayout::Int32,
+        let data_value = PatioDataValueArray {
+            element_layout: PatioDataLayoutInt32.into(),
             elements: vec![
-                PatioDataValue::Int32(PatioIntValue::Literal { value: 0x12345678 }),
-                PatioDataValue::Int32(PatioIntValue::Literal { value: 0x23456789 }),
+                PatioDataValueInt32 {
+                    value: PatioIntValueLiteral { value: 0x12345678 }.into(),
+                }
+                .into(),
+                PatioDataValueInt32 {
+                    value: PatioIntValueLiteral { value: 0x23456789 }.into(),
+                }
+                .into(),
             ],
-        };
+        }
+        .into();
 
         let bytes = data_value_to_bytes(data_value);
 
@@ -131,7 +149,7 @@ mod data_value_to_bytes_test {
 
     #[test]
     fn false_is_single_byte_0() {
-        let data_value = PatioDataValue::Bool(false);
+        let data_value = PatioDataValueBool { value: false }.into();
 
         let bytes = data_value_to_bytes(data_value);
 
@@ -140,7 +158,7 @@ mod data_value_to_bytes_test {
 
     #[test]
     fn true_is_single_byte_1() {
-        let data_value = PatioDataValue::Bool(true);
+        let data_value = PatioDataValueBool { value: true }.into();
 
         let bytes = data_value_to_bytes(data_value);
 
@@ -149,7 +167,7 @@ mod data_value_to_bytes_test {
 
     #[test]
     fn byte_is_written_as_single_byte() {
-        let data_value = PatioDataValue::Byte(42);
+        let data_value = PatioDataValueByte { value: 42 }.into();
 
         let bytes = data_value_to_bytes(data_value);
 
@@ -159,7 +177,10 @@ mod data_value_to_bytes_test {
     #[test]
     fn given_pointer_is_64_bits_wide_then_null_data_ptr_is_written_as_64_bit_0() {
         let target_triple = target_lexicon::Triple::from_str("x86_64-unknown-linux-gnu").unwrap();
-        let data_value = PatioDataValue::DataPtr(PatioDataPtrValue::Null);
+        let data_value = PatioDataValueDataPtr {
+            value: PatioDataPtrValueNull {}.into(),
+        }
+        .into();
 
         let bytes = super::data_value_to_bytes(&data_value, &target_triple);
 
@@ -169,7 +190,10 @@ mod data_value_to_bytes_test {
     #[test]
     fn given_pointer_is_32_bits_wide_then_null_data_ptr_is_written_as_32_bit_0() {
         let target_triple = target_lexicon::Triple::from_str("i686-unknown-linux-gnu").unwrap();
-        let data_value = PatioDataValue::DataPtr(PatioDataPtrValue::Null);
+        let data_value = PatioDataValueDataPtr {
+            value: PatioDataPtrValueNull {}.into(),
+        }
+        .into();
 
         let bytes = super::data_value_to_bytes(&data_value, &target_triple);
 
@@ -179,7 +203,10 @@ mod data_value_to_bytes_test {
     #[test]
     fn given_pointer_is_64_bits_wide_then_int_is_written_with_pointer_width() {
         let target_triple = target_lexicon::Triple::from_str("x86_64-unknown-linux-gnu").unwrap();
-        let data_value = PatioDataValue::Int(PatioIntValue::Literal { value: 0x12345678 });
+        let data_value = PatioDataValueInt {
+            value: PatioIntValueLiteral { value: 0x12345678 }.into(),
+        }
+        .into();
 
         let bytes = super::data_value_to_bytes(&data_value, &target_triple);
 
@@ -189,7 +216,10 @@ mod data_value_to_bytes_test {
     #[test]
     fn given_pointer_is_32_bits_wide_then_int_is_written_with_pointer_width() {
         let target_triple = target_lexicon::Triple::from_str("i686-unknown-linux-gnu").unwrap();
-        let data_value = PatioDataValue::Int(PatioIntValue::Literal { value: 0x12345678 });
+        let data_value = PatioDataValueInt {
+            value: PatioIntValueLiteral { value: 0x12345678 }.into(),
+        }
+        .into();
 
         let bytes = super::data_value_to_bytes(&data_value, &target_triple);
 
@@ -198,7 +228,10 @@ mod data_value_to_bytes_test {
 
     #[test]
     fn int_32_is_written_as_four_bytes() {
-        let data_value = PatioDataValue::Int32(PatioIntValue::Literal { value: 0x12345678 });
+        let data_value = PatioDataValueInt32 {
+            value: PatioIntValueLiteral { value: 0x12345678 }.into(),
+        }
+        .into();
 
         let bytes = data_value_to_bytes(data_value);
 
@@ -207,12 +240,19 @@ mod data_value_to_bytes_test {
 
     #[test]
     fn struct_is_written_as_elements() {
-        let data_value = PatioDataValue::Struct {
+        let data_value = PatioDataValueStruct {
             elements: vec![
-                PatioDataValue::Int32(PatioIntValue::Literal { value: 0x12345678 }),
-                PatioDataValue::Int32(PatioIntValue::Literal { value: 0x23456789 }),
+                PatioDataValueInt32 {
+                    value: PatioIntValueLiteral { value: 0x12345678 }.into(),
+                }
+                .into(),
+                PatioDataValueInt32 {
+                    value: PatioIntValueLiteral { value: 0x23456789 }.into(),
+                }
+                .into(),
             ],
-        };
+        }
+        .into();
 
         let bytes = data_value_to_bytes(data_value);
 
@@ -227,7 +267,12 @@ mod data_value_to_bytes_test {
 mod eval_int_value_test {
     use std::str::FromStr;
 
-    use crate::patio::{types::PatioDataLayout, values::PatioIntValue};
+    use crate::patio::{
+        types::{PatioDataLayoutArray, PatioDataLayoutInt32},
+        values::{
+            PatioIntValue, PatioIntValueByteOffsetOf, PatioIntValueByteSizeOf, PatioIntValueLiteral,
+        },
+    };
 
     fn eval_int_value(int_value: PatioIntValue) -> i32 {
         super::eval_int_value(
@@ -238,7 +283,7 @@ mod eval_int_value_test {
 
     #[test]
     fn int_value_literal_is_used_verbatim() {
-        let int_value = PatioIntValue::Literal { value: 0x12345678 };
+        let int_value = PatioIntValueLiteral { value: 0x12345678 }.into();
 
         let value = eval_int_value(int_value);
 
@@ -247,9 +292,10 @@ mod eval_int_value_test {
 
     #[test]
     fn int_can_have_size_of_layout() {
-        let int_value = PatioIntValue::ByteSizeOf {
-            layout: PatioDataLayout::Int32,
-        };
+        let int_value = PatioIntValueByteSizeOf {
+            layout: PatioDataLayoutInt32.into(),
+        }
+        .into();
 
         let value = eval_int_value(int_value);
 
@@ -258,10 +304,15 @@ mod eval_int_value_test {
 
     #[test]
     fn int_can_have_byte_offset() {
-        let int_value = PatioIntValue::ByteOffsetOf {
-            layout: PatioDataLayout::array(PatioDataLayout::Int32, 7),
+        let int_value = PatioIntValueByteOffsetOf {
+            layout: PatioDataLayoutArray {
+                element: PatioDataLayoutInt32.into(),
+                size: 7,
+            }
+            .into(),
             element_offsets: vec![5],
-        };
+        }
+        .into();
 
         let value = eval_int_value(int_value);