diff --git a/zokrates_core/src/static_analysis/flatten_complex_types.rs b/zokrates_core/src/static_analysis/flatten_complex_types.rs
index f8ba3acd..a1b69639 100644
--- a/zokrates_core/src/static_analysis/flatten_complex_types.rs
+++ b/zokrates_core/src/static_analysis/flatten_complex_types.rs
@@ -82,8 +82,8 @@ impl<'ast, T: Field> Flattener<T> {
     }
 
     fn fold_variable(&mut self, v: typed_absy::Variable<'ast, T>) -> Vec<zir::Variable<'ast>> {
-        let id = self.fold_name(v.id.clone());
         let ty = v.get_type();
+        let id = self.fold_name(v.id);
 
         let ty = typed_absy::types::ConcreteType::try_from(ty).unwrap();
 
@@ -543,9 +543,7 @@ pub fn fold_member_expression<'ast, T: Field, E>(
     let s = *m.struc;
     let id = m.id;
 
-    let members = s.ty().clone();
-
-    let s = f.fold_struct_expression(statements_buffer, s);
+    let members = s.ty();
 
     let size = typed_absy::types::ConcreteType::try_from(
         *members
@@ -568,6 +566,8 @@ pub fn fold_member_expression<'ast, T: Field, E>(
         })
         .sum();
 
+    let s = f.fold_struct_expression(statements_buffer, s);
+
     s[offset..offset + size].to_vec()
 }
 
@@ -605,9 +605,10 @@ pub fn fold_field_expression<'ast, T: Field>(
                 flatten_identifier_rec(
                     f.fold_name(id),
                     &typed_absy::types::ConcreteType::FieldElement,
-                )[0]
-                .id
-                .clone(),
+                )
+                .pop()
+                .unwrap()
+                .id,
             )
         }
         typed_absy::FieldElementExpression::Add(box e1, box e2) => {
@@ -667,29 +668,16 @@ pub fn fold_field_expression<'ast, T: Field>(
             zir::FieldElementExpression::IfElse(box condition, box consequence, box alternative)
         }
         typed_absy::FieldElementExpression::FunctionCall(..) => unreachable!(""),
-        typed_absy::FieldElementExpression::Member(m) => {
-            let s = *m.struc;
-            let id = m.id;
-
-            let members = s.ty().clone();
-
-            let s = f.fold_struct_expression(statements_buffer, s);
-
-            let offset: usize = members
-                .iter()
-                .take_while(|member| member.id != id)
-                .map(|member| {
-                    typed_absy::types::ConcreteType::try_from(*member.ty.clone())
-                        .unwrap()
-                        .get_primitive_count()
-                })
-                .sum();
-
-            s[offset].clone().try_into().unwrap()
-        }
         typed_absy::FieldElementExpression::Select(select) => f
-            .fold_select_expression(statements_buffer, select)[0]
-            .clone()
+            .fold_select_expression(statements_buffer, select)
+            .pop()
+            .unwrap()
+            .try_into()
+            .unwrap(),
+        typed_absy::FieldElementExpression::Member(m) => f
+            .fold_member_expression(statements_buffer, m)
+            .pop()
+            .unwrap()
             .try_into()
             .unwrap(),
         typed_absy::FieldElementExpression::Block(block) => {
@@ -717,9 +705,10 @@ pub fn fold_boolean_expression<'ast, T: Field>(
         }
         typed_absy::BooleanExpression::Value(v) => zir::BooleanExpression::Value(v),
         typed_absy::BooleanExpression::Identifier(id) => zir::BooleanExpression::Identifier(
-            flatten_identifier_rec(f.fold_name(id), &typed_absy::types::ConcreteType::Boolean)[0]
-                .id
-                .clone(),
+            flatten_identifier_rec(f.fold_name(id), &typed_absy::types::ConcreteType::Boolean)
+                .pop()
+                .unwrap()
+                .id,
         ),
         typed_absy::BooleanExpression::FieldEq(box e1, box e2) => {
             let e1 = f.fold_field_expression(statements_buffer, e1);
@@ -864,14 +853,16 @@ pub fn fold_boolean_expression<'ast, T: Field>(
             zir::BooleanExpression::IfElse(box condition, box consequence, box alternative)
         }
         typed_absy::BooleanExpression::FunctionCall(..) => unreachable!(),
-        typed_absy::BooleanExpression::Member(m) => f.fold_member_expression(statements_buffer, m)
-            [0]
-        .clone()
-        .try_into()
-        .unwrap(),
         typed_absy::BooleanExpression::Select(select) => f
-            .fold_select_expression(statements_buffer, select)[0]
-            .clone()
+            .fold_select_expression(statements_buffer, select)
+            .pop()
+            .unwrap()
+            .try_into()
+            .unwrap(),
+        typed_absy::BooleanExpression::Member(m) => f
+            .fold_member_expression(statements_buffer, m)
+            .pop()
+            .unwrap()
             .try_into()
             .unwrap(),
     }
@@ -906,9 +897,10 @@ pub fn fold_uint_expression_inner<'ast, T: Field>(
             flatten_identifier_rec(
                 f.fold_name(id),
                 &typed_absy::types::ConcreteType::Uint(bitwidth),
-            )[0]
-            .id
-            .clone(),
+            )
+            .pop()
+            .unwrap()
+            .id,
         ),
         typed_absy::UExpressionInner::Add(box left, box right) => {
             let left = f.fold_uint_expression(statements_buffer, left);
@@ -1003,15 +995,19 @@ pub fn fold_uint_expression_inner<'ast, T: Field>(
             unreachable!("function calls should have been removed")
         }
         typed_absy::UExpressionInner::Select(select) => zir::UExpression::try_from(
-            f.fold_select_expression(statements_buffer, select)[0].clone(),
+            f.fold_select_expression(statements_buffer, select)
+                .pop()
+                .unwrap(),
+        )
+        .unwrap()
+        .into_inner(),
+        typed_absy::UExpressionInner::Member(m) => zir::UExpression::try_from(
+            f.fold_member_expression(statements_buffer, m)
+                .pop()
+                .unwrap(),
         )
         .unwrap()
         .into_inner(),
-        typed_absy::UExpressionInner::Member(m) => {
-            zir::UExpression::try_from(f.fold_member_expression(statements_buffer, m)[0].clone())
-                .unwrap()
-                .into_inner()
-        }
         typed_absy::UExpressionInner::IfElse(box condition, box consequence, box alternative) => {
             let mut consequence_statements = vec![];
             let mut alternative_statements = vec![];