WIP

compiler/src/yul/operations/abi.rs

@@ -27,12 +27,14 @@ pub fn encode_size<T: AbiEncoding>(types: Vec<T>, vals: Vec<yul::Expression>) ->
     for (typ, val) in typed_vals {
         match typ.abi_type() {
             AbiType::Uint { .. } => static_size += 32,
+            AbiType::Tuple => unimplemented!("encode_size for tuple"),
             AbiType::Array { inner, size } => {
                 let inner_size = match *inner {
                     AbiType::Uint {
                         size: AbiUintSize { padded_size, .. },
                     } => padded_size,
                     AbiType::Array { .. } => unimplemented!(),
+                    AbiType::Tuple => unimplemented!("Encode size for tuple in array")
                 };
                 match size {
                     AbiArraySize::Static { size } => {

compiler/src/yul/runtime/functions/abi.rs

@@ -89,6 +89,7 @@ fn encode<T: AbiEncoding>(types: Vec<T>) -> yul::Statement {
                 encode_uint(dyn_offset)
             }
             AbiType::Uint { .. } => encode_uint(param),
+            AbiType::Tuple => unimplemented!("encode for Tuple"),
         })
         .collect::<Vec<_>>();
 
@@ -118,6 +119,7 @@ fn decode<T: AbiEncoding>(typ: T, location: AbiDecodeLocation) -> yul::Statement
             AbiArraySize::Static { size } => decode_static_array(*inner, size, location),
             AbiArraySize::Dynamic => decode_dyn_array(*inner, location),
         },
+        AbiType::Tuple => unimplemented!("decode for Tuple")
     };
 
     function_definition! {
@@ -178,7 +180,8 @@ fn dyn_array_data_size(val: yul::Expression, inner: AbiType) -> yul::Expression
             let array_size = expression! { mload([val]) };
             let elements_size = expression! { mul([array_size], [inner_padded_size]) };
             expression! { add(32, (ceil32([elements_size]))) }
-        }
+        },
+        AbiType::Tuple => unimplemented!(),
     }
 }
 
@@ -233,7 +236,8 @@ fn encode_array(
             } else {
                 statement! { abi_unpack([val], [array_size], [inner_data_size]) }
             }
-        }
+        },
+        AbiType::Tuple => unimplemented!("encoding of tuples in arrays")
     }
 }
 
@@ -281,7 +285,8 @@ fn decode_dyn_array(inner: AbiType, location: AbiDecodeLocation) -> yul::Express
             } else {
                 unimplemented!("packing of dynamically sized arrays")
             }
-        }
+        },
+        AbiType::Tuple => unimplemented!("Decoding of tuples in arrays")
     }
 }
 
@@ -327,7 +332,8 @@ fn decode_static_array(
                     }
                 }
             }
-        }
+        },
+        AbiType::Tuple => unimplemented!("Decoding of tuples in arrays")
     }
 }
 

compiler/src/yul/utils.rs

@@ -41,10 +41,12 @@ pub fn abi_head_offsets<T: AbiEncoding>(types: &[T]) -> (Vec<usize>, usize) {
                 AbiType::Uint {
                     size: AbiUintSize { padded_size, .. },
                 } => ceil_32(padded_size * size),
+                AbiType::Tuple => unimplemented!(),
             },
             AbiType::Uint {
                 size: AbiUintSize { padded_size, .. },
             } => padded_size,
+            AbiType::Tuple => unimplemented!(),
         };
     }
 

compiler/tests/fixtures/structs.fe

@@ -7,4 +7,5 @@ contract Foo:
     citizen: u256
 
     pub def bar() -> u256:
-        return 42
+        self.building = House(1, 1)
+        return 10

output/Foo/Foo_ir.yul

@@ -0,0 +1,174 @@
+object \"Contract\" {
+     code {
+         let size := datasize(\"runtime\") datacopy(0, dataoffset(\"runtime\"), size) return(0, size) 
+    }
+    object \"runtime\" {
+         code {
+             function $$bar() -> return_val {
+                 sstoren(0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6, 3, 32) {
+                     return_val := 10 leave 
+                }
+
+            }
+            function avail() -> ptr {
+                 ptr := mload(0x00) if eq(ptr, 0x00) {
+                     ptr := 0x20 
+                }
+
+            }
+            function alloc(size) -> ptr {
+                 ptr := mload(0x00) if eq(ptr, 0x00) {
+                     ptr := 0x20 
+                }
+                mstore(0x00, add(ptr, size)) 
+            }
+            function alloc_mstoren(val, size) -> ptr {
+                 ptr := alloc(size) mstoren(ptr, val, size) 
+            }
+            function free(ptr) {
+                 mstore(0x00, ptr) 
+            }
+            function ccopym(cptr, size) -> mptr {
+                 mptr := alloc(size) calldatacopy(mptr, cptr, size) 
+            }
+            function load_data_string(code_ptr, size) -> mptr {
+                 mptr := alloc(32) mstore(mptr, size) let content_ptr := alloc(size) datacopy(content_ptr, code_ptr, size) 
+            }
+            function mcopys(mptr, sptr, size) {
+                 let offset := 0 for {
+
+                }
+                lt(add(offset, 32), size) {
+
+                }
+                {
+                     let _mptr := add(mptr, offset) let _sptr := add(sptr, offset) sstore(_sptr, mload(_mptr)) offset := add(offset, 32) 
+                }
+                let rem := sub(size, offset) if gt(rem, 0) {
+                     let _mptr := add(mptr, offset) let _sptr := add(sptr, offset) sstoren(_sptr, mloadn(_mptr, rem), rem) 
+                }
+
+            }
+            function scopym(sptr, size) -> mptr {
+                 mptr := alloc(size) let offset := 0 for {
+
+                }
+                lt(add(offset, 32), size) {
+
+                }
+                {
+                     let _mptr := add(mptr, offset) let _sptr := add(sptr, offset) mstore(_mptr, sload(_sptr)) offset := add(offset, 32) 
+                }
+                let rem := sub(size, offset) if gt(rem, 0) {
+                     let _mptr := add(mptr, offset) let _sptr := add(sptr, offset) mstoren(_mptr, sloadn(_sptr, rem), rem) 
+                }
+
+            }
+            function mcopym(ptr1, size) -> ptr2 {
+                 ptr2 := alloc(size) let offset := 0 for {
+
+                }
+                lt(add(offset, 32), size) {
+
+                }
+                {
+                     let _ptr1 := add(ptr1, offset) let _ptr2 := add(ptr2, offset) mstore(_ptr2, mload(_ptr1)) offset := add(offset, 32) 
+                }
+                let rem := sub(size, offset) if gt(rem, 0) {
+                     let _ptr1 := add(ptr1, offset) let _ptr2 := add(ptr2, offset) mstoren(_ptr2, mloadn(_ptr1, rem), rem) 
+                }
+
+            }
+            function scopys(ptr1, ptr2, size) {
+                 let offset := 0 for {
+
+                }
+                lt(add(offset, 32), size) {
+
+                }
+                {
+                     let _ptr1 := add(ptr1, offset) let _ptr2 := add(ptr2, offset) sstore(_ptr2, sload(_ptr1)) offset := add(offset, 32) 
+                }
+                let rem := sub(size, offset) if gt(rem, 0) {
+                     let _ptr1 := add(ptr1, offset) let _ptr2 := add(ptr2, offset) sstoren(_ptr2, sloadn(_ptr1, rem), rem) 
+                }
+
+            }
+            function mloadn(ptr, size) -> val {
+                 val := shr(sub(256, mul(8, size)), mload(ptr)) 
+            }
+            function sloadn(ptr, size) -> val {
+                 val := shr(sub(256, mul(8, size)), sload(ptr)) 
+            }
+            function cloadn(ptr, size) -> val {
+                 val := shr(sub(256, mul(8, size)), calldataload(ptr)) 
+            }
+            function mstoren(ptr, val, size) {
+                 let size_bits := mul(8, size) let left := shl(sub(256, size_bits), val) let right := shr(size_bits, mload(add(ptr, size))) mstore(ptr, or(left, right)) 
+            }
+            function sstoren(ptr, val, size) {
+                 let size_bits := mul(8, size) let left := shl(sub(256, size_bits), val) let right := shr(size_bits, sload(add(ptr, size))) sstore(ptr, or(left, right)) 
+            }
+            function dualkeccak256(a, b) -> return_val {
+                 let ptr := avail() mstore(ptr, a) mstore(add(ptr, 32), b) return_val := keccak256(ptr, 64) 
+            }
+            function ceil32(n) -> return_val {
+                 return_val := mul(div(add(n, 31), 32), 32) 
+            }
+            function ternary(test, if_expr, else_expr) -> result {
+                 switch test case 1 {
+                     result := if_expr 
+                }
+                case 0 {
+                     result := else_expr 
+                }
+
+            }
+            function abi_unpack(mptr, array_size, inner_data_size) {
+                 for {
+                     let i := 0 
+                }
+                lt(i, array_size) {
+                     i := add(i, 1) 
+                }
+                {
+                     let val_ptr := add(mptr, mul(i, inner_data_size)) let val := mloadn(val_ptr, inner_data_size) pop(alloc_mstoren(val, 32)) 
+                }
+
+            }
+            function abi_pack_calldata(mptr, array_size, inner_data_size) -> packed_ptr {
+                 packed_ptr := avail() for {
+                     let i := 0 
+                }
+                lt(i, array_size) {
+                     i := add(i, 1) 
+                }
+                {
+                     let val_ptr := add(mptr, mul(i, 32)) let val := calldataload(val_ptr) pop(alloc_mstoren(val, inner_data_size)) 
+                }
+
+            }
+            function abi_pack_mem(mptr, array_size, inner_data_size) -> packed_ptr {
+                 packed_ptr := avail() for {
+                     let i := 0 
+                }
+                lt(i, array_size) {
+                     i := add(i, 1) 
+                }
+                {
+                     let val_ptr := add(mptr, mul(i, 32)) let val := mload(val_ptr) pop(alloc_mstoren(val, inner_data_size)) 
+                }
+
+            }
+            function abi_encode_uint256(val_0) -> ptr {
+                 ptr := avail() pop(alloc_mstoren(val_0, 32)) 
+            }
+            switch cloadn(0, 4) case 0xfebb0f7e {
+                 let raw_return := $$bar() return(abi_encode_uint256(raw_return), add(32, 0)) 
+            }
+
+        }
+
+    }
+
+}

semantics/src/namespace/types.rs

@@ -62,6 +62,8 @@ pub enum AbiType {
     },
     /// All elements are encoded as a uint or set of uints.
     Uint { size: AbiUintSize },
+    Tuple,
+
 }
 
 /// Data can be decoded from memory or calldata.