Tail Recursion Modulo Cons for record payloads

.cargo/config.toml

@@ -48,3 +48,4 @@ ROC_PRINT_RUNTIME_ERROR_GEN            = "0"
 ROC_DEBUG_ALIAS_ANALYSIS               = "0"
 ROC_PRINT_LLVM_FN_VERIFICATION         = "0"
 ROC_PRINT_LOAD_LOG                     = "0"
+ROC_PRINT_IR_AFTER_TRMC                = "0"

crates/compiler/alias_analysis/src/lib.rs

@@ -1442,7 +1442,14 @@ fn expr_spec<'a>(
             union_layout,
             ..
         } => {
-            debug_assert!(indices.len() >= 2);
+            //TODO: indices can have > 2 values. The first 2 is tag_id and index,
+            //and after that, it depends on the layout of the element at index.
+            //If it is a struct, the next index
+            //denotes which field we are targeting. If it is a tag union (only non recursive), than
+            //there is at least 2 more "indices".
+            //1st is the tag_id, 2nd is the
+            //index and so on recursively for arbitrary length.
+            debug_assert!(indices.len() == 2);
             let tag_id = indices[0] as u32;
             let index = indices[1];
             let tag_value_id = env.symbols[structure];

crates/compiler/gen_dev/src/generic64/mod.rs

@@ -3434,25 +3434,27 @@ impl<
         &mut self,
         sym: &Symbol,
         structure: &Symbol,
-        tag_id: TagIdIntType,
-        index: u64,
+        indices: &[u64],
         union_layout: &UnionLayout<'a>,
     ) {
+        let tag_id = indices[0] as TagIdIntType;
         let ptr_reg = self
             .storage_manager
             .load_to_general_reg(&mut self.buf, structure);
 
         let sym_reg = self.storage_manager.claim_general_reg(&mut self.buf, sym);
-
+        let indices = &indices[1..];
         match union_layout {
             UnionLayout::NonRecursive(_) => {
                 unreachable!("operation not supported")
             }
             UnionLayout::NonNullableUnwrapped(field_layouts) => {
-                let mut offset = 0;
-                for field in &field_layouts[..index as usize] {
-                    offset += self.layout_interner.stack_size(*field);
-                }
+                let offset = load_union_field_ptr_at_index_help(
+                    self.layout_interner,
+                    indices,
+                    field_layouts,
+                    0,
+                );
 
                 ASM::add_reg64_reg64_imm32(&mut self.buf, sym_reg, ptr_reg, offset as i32);
             }
@@ -3462,10 +3464,12 @@ impl<
             } => {
                 debug_assert_ne!(tag_id, *nullable_id as TagIdIntType);
 
-                let mut offset = 0;
-                for field in &other_fields[..index as usize] {
-                    offset += self.layout_interner.stack_size(*field);
-                }
+                let offset = load_union_field_ptr_at_index_help(
+                    self.layout_interner,
+                    indices,
+                    other_fields,
+                    0,
+                );
 
                 ASM::add_reg64_reg64_imm32(&mut self.buf, sym_reg, ptr_reg, offset as i32);
             }
@@ -3484,10 +3488,12 @@ impl<
 
                 let (mask_symbol, mask_reg) = self.clear_tag_id(ptr_reg);
 
-                let mut offset = 0;
-                for field in &other_fields[..index as usize] {
-                    offset += self.layout_interner.stack_size(*field);
-                }
+                let offset = load_union_field_ptr_at_index_help(
+                    self.layout_interner,
+                    indices,
+                    other_fields,
+                    0,
+                );
 
                 ASM::add_reg64_reg64_imm32(&mut self.buf, sym_reg, mask_reg, offset as i32);
 
@@ -3509,10 +3515,12 @@ impl<
                         (Some(mask_symbol), mask_reg)
                     };
 
-                let mut offset = 0;
-                for field in &other_fields[..index as usize] {
-                    offset += self.layout_interner.stack_size(*field);
-                }
+                let offset = load_union_field_ptr_at_index_help(
+                    self.layout_interner,
+                    indices,
+                    other_fields,
+                    0,
+                );
 
                 ASM::add_reg64_reg64_imm32(&mut self.buf, sym_reg, unmasked_reg, offset as i32);
 
@@ -5367,6 +5375,46 @@ impl<
     }
 }
 
+fn load_union_field_ptr_at_index_help<'a>(
+    layout_interner: &'a STLayoutInterner<'a>,
+    indices: &[u64],
+    layouts: &[InLayout<'a>],
+    mut offset: u32,
+) -> u32 {
+    debug_assert_ne!(indices.len(), 0);
+
+    let idx = indices[0];
+    for field in &layouts[..idx as usize] {
+        offset += layout_interner.stack_size(*field);
+    }
+
+    if indices.len() <= 1 {
+        return offset;
+    }
+    use LayoutRepr::*;
+    let enclosing_layout = layouts[idx as usize];
+    return match layout_interner.get_repr(enclosing_layout) {
+        Struct(layouts) => {
+            load_union_field_ptr_at_index_help(layout_interner, &indices[1..], layouts, offset)
+        },
+        Union(UnionLayout::NonRecursive(tags)) => {
+            // apart from the current index, to get information out of a
+            // non-recursive tag union we need 2 more number: a tag id and an index
+            debug_assert!(indices.len() >= 3);
+            let tag_id = indices[1] as usize;
+            let tag_layout = tags[tag_id];
+
+            load_union_field_ptr_at_index_help(layout_interner, &indices[2..], tag_layout, offset)
+        }
+        //TODO: can any of these be a valid target for getting a pointer out of their inner layouts?
+        //(so not them being pointers)
+        Union(_) | Builtin(_) | Ptr(_) | RecursivePointer(_) | LambdaSet(_) | FunctionPointer(_)
+        | Erased(_) => unreachable!(
+            "Following the path of the indices, a layout has been reached where the address of the desired pointer is behind another pointer"
+        ),
+    };
+}
+
 #[macro_export]
 macro_rules! sign_extended_int_builtins {
     () => {

crates/compiler/gen_dev/src/lib.rs

@@ -856,13 +856,7 @@ trait Backend<'a> {
                 ..
             } => {
                 debug_assert!(indices.len() >= 2);
-                self.load_union_field_ptr_at_index(
-                    sym,
-                    structure,
-                    indices[0] as u16,
-                    indices[1],
-                    union_layout,
-                );
+                self.load_union_field_ptr_at_index(sym, structure, indices, union_layout);
             }
             Expr::GetTagId {
                 structure,
@@ -2437,8 +2431,7 @@ trait Backend<'a> {
         &mut self,
         sym: &Symbol,
         structure: &Symbol,
-        tag_id: TagIdIntType,
-        index: u64,
+        indices: &[u64],
         union_layout: &UnionLayout<'a>,
     );
 

crates/compiler/mono/src/debug/checker.rs

@@ -618,6 +618,8 @@ impl<'a, 'r> Ctx<'a, 'r> {
         })
     }
 
+    //TODO: make it work for Expr::GetElementPointer
+    //which has list of indices, not a single index
     fn check_union_field_ptr_at_index(
         &mut self,
         structure: Symbol,