clarify basic_type_from_layout function

compiler/gen_llvm/src/llvm/build.rs

@@ -24,7 +24,7 @@ use crate::llvm::build_str::{
 };
 use crate::llvm::compare::{generic_eq, generic_neq};
 use crate::llvm::convert::{
-    self, basic_type_from_builtin, basic_type_from_layout, basic_type_from_layout_tag_as_alloca,
+    self, argument_type_from_layout, basic_type_from_builtin, basic_type_from_layout,
     block_of_memory_slices,
 };
 use crate::llvm::refcounting::{
@@ -4225,7 +4225,7 @@ fn build_proc_header<'a, 'ctx, 'env>(
     let mut arg_basic_types = Vec::with_capacity_in(args.len(), arena);
 
     for (layout, _) in args.iter() {
-        let arg_type = basic_type_from_layout_tag_as_alloca(env, layout);
+        let arg_type = argument_type_from_layout(env, layout);
 
         arg_basic_types.push(arg_type);
     }

compiler/gen_llvm/src/llvm/build_hash.rs

@@ -4,7 +4,7 @@ use crate::llvm::build::tag_pointer_clear_tag_id;
 use crate::llvm::build::Env;
 use crate::llvm::build::{get_tag_id, FAST_CALL_CONV, TAG_DATA_INDEX};
 use crate::llvm::build_str;
-use crate::llvm::convert::{basic_type_from_layout, basic_type_from_layout_tag_as_alloca};
+use crate::llvm::convert::basic_type_from_layout;
 use bumpalo::collections::Vec;
 use inkwell::values::{
     BasicValue, BasicValueEnum, FunctionValue, IntValue, PointerValue, StructValue,
@@ -13,7 +13,7 @@ use roc_builtins::bitcode;
 use roc_module::symbol::Symbol;
 use roc_mono::layout::{Builtin, Layout, LayoutIds, UnionLayout};
 
-use super::convert::stack_basic_type_from_union_layout;
+use super::convert::argument_type_from_union_layout;
 
 #[derive(Clone, Debug)]
 enum WhenRecursive<'a> {
@@ -318,7 +318,7 @@ fn build_hash_tag<'a, 'ctx, 'env>(
         None => {
             let seed_type = env.context.i64_type();
 
-            let arg_type = stack_basic_type_from_union_layout(env, union_layout);
+            let arg_type = argument_type_from_union_layout(env, union_layout);
 
             let function_value = crate::llvm::refcounting::build_header_help(
                 env,
@@ -797,7 +797,7 @@ fn hash_ptr_to_struct<'a, 'ctx, 'env>(
 ) -> IntValue<'ctx> {
     use inkwell::types::BasicType;
 
-    let wrapper_type = basic_type_from_layout_tag_as_alloca(env, &Layout::Union(*union_layout));
+    let wrapper_type = argument_type_from_union_layout(env, union_layout);
 
     // cast the opaque pointer to a pointer of the correct shape
     let wrapper_ptr = env

compiler/gen_llvm/src/llvm/compare.rs

@@ -2,7 +2,7 @@ use crate::llvm::bitcode::call_bitcode_fn;
 use crate::llvm::build::{get_tag_id, tag_pointer_clear_tag_id, Env, FAST_CALL_CONV};
 use crate::llvm::build_list::{list_len, load_list_ptr};
 use crate::llvm::build_str::str_equal;
-use crate::llvm::convert::{basic_type_from_layout, basic_type_from_layout_tag_as_alloca};
+use crate::llvm::convert::basic_type_from_layout;
 use bumpalo::collections::Vec;
 use inkwell::types::BasicType;
 use inkwell::values::{
@@ -15,6 +15,7 @@ use roc_module::symbol::Symbol;
 use roc_mono::layout::{Builtin, Layout, LayoutIds, UnionLayout};
 
 use super::build::load_roc_value;
+use super::convert::argument_type_from_union_layout;
 
 #[derive(Clone, Debug)]
 enum WhenRecursive<'a> {
@@ -176,7 +177,6 @@ fn build_eq<'a, 'ctx, 'env>(
             env,
             layout_ids,
             when_recursive,
-            lhs_layout,
             union_layout,
             lhs_val,
             rhs_val,
@@ -207,7 +207,6 @@ fn build_eq<'a, 'ctx, 'env>(
                     env,
                     layout_ids,
                     WhenRecursive::Loop(union_layout),
-                    &layout,
                     &union_layout,
                     field1_cast.into(),
                     field2_cast.into(),
@@ -350,7 +349,6 @@ fn build_neq<'a, 'ctx, 'env>(
                 env,
                 layout_ids,
                 when_recursive,
-                lhs_layout,
                 union_layout,
                 lhs_val,
                 rhs_val,
@@ -764,7 +762,6 @@ fn build_tag_eq<'a, 'ctx, 'env>(
     env: &Env<'a, 'ctx, 'env>,
     layout_ids: &mut LayoutIds<'a>,
     when_recursive: WhenRecursive<'a>,
-    tag_layout: &Layout<'a>,
     union_layout: &UnionLayout<'a>,
     tag1: BasicValueEnum<'ctx>,
     tag2: BasicValueEnum<'ctx>,
@@ -772,15 +769,16 @@ fn build_tag_eq<'a, 'ctx, 'env>(
     let block = env.builder.get_insert_block().expect("to be in a function");
     let di_location = env.builder.get_current_debug_location().unwrap();
 
+    let tag_layout = Layout::Union(*union_layout);
     let symbol = Symbol::GENERIC_EQ;
     let fn_name = layout_ids
-        .get(symbol, tag_layout)
+        .get(symbol, &tag_layout)
         .to_symbol_string(symbol, &env.interns);
 
     let function = match env.module.get_function(fn_name.as_str()) {
         Some(function_value) => function_value,
         None => {
-            let arg_type = basic_type_from_layout_tag_as_alloca(env, tag_layout);
+            let arg_type = argument_type_from_union_layout(env, union_layout);
 
             let function_value = crate::llvm::refcounting::build_header_help(
                 env,

compiler/gen_llvm/src/llvm/convert.rs

@@ -1,3 +1,4 @@
+use crate::llvm::build::Env;
 use bumpalo::collections::Vec;
 use inkwell::context::Context;
 use inkwell::types::{BasicType, BasicTypeEnum, FloatType, IntType, StructType};
@@ -7,7 +8,7 @@ use roc_mono::layout::{Builtin, Layout, UnionLayout};
 use roc_target::TargetInfo;
 
 fn basic_type_from_record<'a, 'ctx, 'env>(
-    env: &crate::llvm::build::Env<'a, 'ctx, 'env>,
+    env: &Env<'a, 'ctx, 'env>,
     fields: &[Layout<'_>],
 ) -> BasicTypeEnum<'ctx> {
     let mut field_types = Vec::with_capacity_in(fields.len(), env.arena);
@@ -22,7 +23,7 @@ fn basic_type_from_record<'a, 'ctx, 'env>(
 }
 
 pub fn basic_type_from_layout<'a, 'ctx, 'env>(
-    env: &crate::llvm::build::Env<'a, 'ctx, 'env>,
+    env: &Env<'a, 'ctx, 'env>,
     layout: &Layout<'_>,
 ) -> BasicTypeEnum<'ctx> {
     use Layout::*;
@@ -33,57 +34,19 @@ pub fn basic_type_from_layout<'a, 'ctx, 'env>(
             ..
         } => basic_type_from_record(env, sorted_fields),
         LambdaSet(lambda_set) => basic_type_from_layout(env, &lambda_set.runtime_representation()),
-        Union(union_layout) => {
-            use UnionLayout::*;
-
-            let tag_id_type = basic_type_from_layout(env, &union_layout.tag_id_layout());
-
-            match union_layout {
-                NonRecursive(tags) => {
-                    let data = block_of_memory_slices(env.context, tags, env.target_info);
-
-                    env.context.struct_type(&[data, tag_id_type], false).into()
-                }
-                Recursive(tags)
-                | NullableWrapped {
-                    other_tags: tags, ..
-                } => {
-                    let data = block_of_memory_slices(env.context, tags, env.target_info);
-
-                    if union_layout.stores_tag_id_as_data(env.target_info) {
-                        env.context
-                            .struct_type(&[data, tag_id_type], false)
-                            .ptr_type(AddressSpace::Generic)
-                            .into()
-                    } else {
-                        data.ptr_type(AddressSpace::Generic).into()
-                    }
-                }
-                NullableUnwrapped { other_fields, .. } => {
-                    let block =
-                        block_of_memory_slices(env.context, &[other_fields], env.target_info);
-                    block.ptr_type(AddressSpace::Generic).into()
-                }
-                NonNullableUnwrapped(fields) => {
-                    let block = block_of_memory_slices(env.context, &[fields], env.target_info);
-                    block.ptr_type(AddressSpace::Generic).into()
-                }
-            }
-        }
-        RecursivePointer => {
-            // TODO make this dynamic
-            env.context
-                .i64_type()
-                .ptr_type(AddressSpace::Generic)
-                .as_basic_type_enum()
-        }
+        Union(union_layout) => basic_type_from_union_layout(env, union_layout),
+        RecursivePointer => env
+            .context
+            .i64_type()
+            .ptr_type(AddressSpace::Generic)
+            .as_basic_type_enum(),
 
         Builtin(builtin) => basic_type_from_builtin(env, builtin),
     }
 }
 
-pub fn stack_basic_type_from_union_layout<'a, 'ctx, 'env>(
-    env: &crate::llvm::build::Env<'a, 'ctx, 'env>,
+pub fn basic_type_from_union_layout<'a, 'ctx, 'env>(
+    env: &Env<'a, 'ctx, 'env>,
     union_layout: &UnionLayout<'_>,
 ) -> BasicTypeEnum<'ctx> {
     use UnionLayout::*;
@@ -93,9 +56,8 @@ pub fn stack_basic_type_from_union_layout<'a, 'ctx, 'env>(
     match union_layout {
         NonRecursive(tags) => {
             let data = block_of_memory_slices(env.context, tags, env.target_info);
-            let struct_type = env.context.struct_type(&[data, tag_id_type], false);
 
-            struct_type.ptr_type(AddressSpace::Generic).into()
+            env.context.struct_type(&[data, tag_id_type], false).into()
         }
         Recursive(tags)
         | NullableWrapped {
@@ -123,37 +85,8 @@ pub fn stack_basic_type_from_union_layout<'a, 'ctx, 'env>(
     }
 }
 
-/// If the layout is a layout of a non-recursive tag,
-/// give not the representation of this tag value but a pointer type to that value.
-pub fn basic_type_from_layout_tag_as_alloca<'a, 'ctx, 'env>(
-    env: &crate::llvm::build::Env<'a, 'ctx, 'env>,
-    layout: &Layout<'_>,
-) -> BasicTypeEnum<'ctx> {
-    use Layout::*;
-
-    match layout {
-        Struct {
-            field_layouts: sorted_fields,
-            ..
-        } => basic_type_from_record(env, sorted_fields),
-        LambdaSet(lambda_set) => {
-            basic_type_from_layout_tag_as_alloca(env, &lambda_set.runtime_representation())
-        }
-        Union(union_layout) => stack_basic_type_from_union_layout(env, union_layout),
-        RecursivePointer => {
-            // TODO make this dynamic
-            env.context
-                .i64_type()
-                .ptr_type(AddressSpace::Generic)
-                .as_basic_type_enum()
-        }
-
-        Builtin(builtin) => basic_type_from_builtin(env, builtin),
-    }
-}
-
 pub fn basic_type_from_builtin<'a, 'ctx, 'env>(
-    env: &crate::llvm::build::Env<'a, 'ctx, 'env>,
+    env: &Env<'a, 'ctx, 'env>,
     builtin: &Builtin<'_>,
 ) -> BasicTypeEnum<'ctx> {
     use Builtin::*;
@@ -172,8 +105,48 @@ pub fn basic_type_from_builtin<'a, 'ctx, 'env>(
     }
 }
 
+/// Turn a layout into a BasicType that we use in LLVM function arguments.
+///
+/// This makes it possible to pass values as something different from how they are typically stored.
+/// Current differences
+///
+/// - tag unions are passed by-reference. That means that
+///     * `f : [ Some I64, None ] -> I64` is typed `{ { i64, i8 }, i64 }* -> i64`
+///     * `f : { x : [ Some I64, None ] } -> I64 is typed `{ { { i64, i8 }, i64 } } -> i64`
+///
+/// Ideas exist to have (bigger than 2 register) records also be passed by-reference, but this
+/// is not currently implemented
+pub fn argument_type_from_layout<'a, 'ctx, 'env>(
+    env: &Env<'a, 'ctx, 'env>,
+    layout: &Layout<'_>,
+) -> BasicTypeEnum<'ctx> {
+    use Layout::*;
+
+    match layout {
+        LambdaSet(lambda_set) => {
+            argument_type_from_layout(env, &lambda_set.runtime_representation())
+        }
+        Union(union_layout) => argument_type_from_union_layout(env, union_layout),
+        other => basic_type_from_layout(env, other),
+    }
+}
+
+/// Non-recursive tag unions are stored on the stack, but passed by-reference
+pub fn argument_type_from_union_layout<'a, 'ctx, 'env>(
+    env: &Env<'a, 'ctx, 'env>,
+    union_layout: &UnionLayout<'_>,
+) -> BasicTypeEnum<'ctx> {
+    let heap_type = basic_type_from_union_layout(env, union_layout);
+
+    if let UnionLayout::NonRecursive(_) = union_layout {
+        heap_type.ptr_type(AddressSpace::Generic).into()
+    } else {
+        heap_type
+    }
+}
+
 pub fn int_type_from_int_width<'a, 'ctx, 'env>(
-    env: &crate::llvm::build::Env<'a, 'ctx, 'env>,
+    env: &Env<'a, 'ctx, 'env>,
     int_width: IntWidth,
 ) -> IntType<'ctx> {
     use IntWidth::*;
@@ -188,7 +161,7 @@ pub fn int_type_from_int_width<'a, 'ctx, 'env>(
 }
 
 pub fn float_type_from_float_width<'a, 'ctx, 'env>(
-    env: &crate::llvm::build::Env<'a, 'ctx, 'env>,
+    env: &Env<'a, 'ctx, 'env>,
     float_width: FloatWidth,
 ) -> FloatType<'ctx> {
     use FloatWidth::*;
@@ -273,33 +246,23 @@ pub fn str_list_int(ctx: &Context, target_info: TargetInfo) -> IntType<'_> {
     }
 }
 
-pub fn zig_dict_type<'a, 'ctx, 'env>(
-    env: &crate::llvm::build::Env<'a, 'ctx, 'env>,
-) -> StructType<'ctx> {
+pub fn zig_dict_type<'a, 'ctx, 'env>(env: &Env<'a, 'ctx, 'env>) -> StructType<'ctx> {
     env.module.get_struct_type("dict.RocDict").unwrap()
 }
 
-pub fn zig_list_type<'a, 'ctx, 'env>(
-    env: &crate::llvm::build::Env<'a, 'ctx, 'env>,
-) -> StructType<'ctx> {
+pub fn zig_list_type<'a, 'ctx, 'env>(env: &Env<'a, 'ctx, 'env>) -> StructType<'ctx> {
     env.module.get_struct_type("list.RocList").unwrap()
 }
 
-pub fn zig_str_type<'a, 'ctx, 'env>(
-    env: &crate::llvm::build::Env<'a, 'ctx, 'env>,
-) -> StructType<'ctx> {
+pub fn zig_str_type<'a, 'ctx, 'env>(env: &Env<'a, 'ctx, 'env>) -> StructType<'ctx> {
     env.module.get_struct_type("str.RocStr").unwrap()
 }
 
-pub fn zig_has_tag_id_type<'a, 'ctx, 'env>(
-    env: &crate::llvm::build::Env<'a, 'ctx, 'env>,
-) -> StructType<'ctx> {
+pub fn zig_has_tag_id_type<'a, 'ctx, 'env>(env: &Env<'a, 'ctx, 'env>) -> StructType<'ctx> {
     env.module.get_struct_type("list.HasTagId").unwrap()
 }
 
-pub fn zig_with_overflow_roc_dec<'a, 'ctx, 'env>(
-    env: &crate::llvm::build::Env<'a, 'ctx, 'env>,
-) -> StructType<'ctx> {
+pub fn zig_with_overflow_roc_dec<'a, 'ctx, 'env>(env: &Env<'a, 'ctx, 'env>) -> StructType<'ctx> {
     env.module
         .get_struct_type("utils.WithOverflow(dec.RocDec)")
         .unwrap()

compiler/gen_llvm/src/llvm/refcounting.rs

@@ -5,7 +5,7 @@ use crate::llvm::build::{
     FAST_CALL_CONV, TAG_DATA_INDEX, TAG_ID_INDEX,
 };
 use crate::llvm::build_list::{incrementing_elem_loop, list_len, load_list};
-use crate::llvm::convert::{basic_type_from_layout, basic_type_from_layout_tag_as_alloca};
+use crate::llvm::convert::basic_type_from_layout;
 use bumpalo::collections::Vec;
 use inkwell::basic_block::BasicBlock;
 use inkwell::context::Context;
@@ -20,6 +20,8 @@ use roc_module::symbol::Symbol;
 use roc_mono::layout::{Builtin, Layout, LayoutIds, UnionLayout};
 use roc_target::TargetInfo;
 
+use super::convert::argument_type_from_union_layout;
+
 /// "Infinite" reference count, for static values
 /// Ref counts are encoded as negative numbers where isize::MIN represents 1
 pub const REFCOUNT_MAX: usize = 0_usize;
@@ -1618,7 +1620,8 @@ fn modify_refcount_union<'a, 'ctx, 'env>(
     when_recursive: &WhenRecursive<'a>,
     fields: &'a [&'a [Layout<'a>]],
 ) -> FunctionValue<'ctx> {
-    let layout = Layout::Union(UnionLayout::NonRecursive(fields));
+    let union_layout = UnionLayout::NonRecursive(fields);
+    let layout = Layout::Union(union_layout);
 
     let block = env.builder.get_insert_block().expect("to be in a function");
     let di_location = env.builder.get_current_debug_location().unwrap();
@@ -1635,7 +1638,7 @@ fn modify_refcount_union<'a, 'ctx, 'env>(
     let function = match env.module.get_function(fn_name.as_str()) {
         Some(function_value) => function_value,
         None => {
-            let basic_type = basic_type_from_layout_tag_as_alloca(env, &layout);
+            let basic_type = argument_type_from_union_layout(env, &union_layout);
             let function_value = build_header(env, basic_type, mode, &fn_name);
 
             modify_refcount_union_help(