List takes interned element

crates/compiler/gen_llvm/src/llvm/build_list.rs

@@ -11,8 +11,9 @@ use inkwell::values::{BasicValueEnum, FunctionValue, IntValue, PointerValue, Str
 use inkwell::{AddressSpace, IntPredicate};
 use morphic_lib::UpdateMode;
 use roc_builtins::bitcode;
+use roc_intern::Interner;
 use roc_module::symbol::Symbol;
-use roc_mono::layout::{Builtin, Layout, LayoutIds};
+use roc_mono::layout::{Builtin, InLayout, Layout, LayoutIds};
 
 use super::bitcode::{call_list_bitcode_fn, BitcodeReturns};
 use super::build::{
@@ -108,8 +109,9 @@ pub(crate) fn pass_as_opaque<'a, 'ctx, 'env>(
 pub(crate) fn list_with_capacity<'a, 'ctx, 'env>(
     env: &Env<'a, 'ctx, 'env>,
     capacity: IntValue<'ctx>,
-    element_layout: &Layout<'a>,
+    element_layout: InLayout<'a>,
 ) -> BasicValueEnum<'ctx> {
+    let element_layout = env.layout_interner.get(element_layout);
     call_list_bitcode_fn(
         env,
         &[],
@@ -126,12 +128,13 @@ pub(crate) fn list_with_capacity<'a, 'ctx, 'env>(
 pub(crate) fn list_get_unsafe<'a, 'ctx, 'env>(
     env: &Env<'a, 'ctx, 'env>,
     layout_ids: &mut LayoutIds<'a>,
-    element_layout: &Layout<'a>,
+    element_layout: InLayout<'a>,
     elem_index: IntValue<'ctx>,
     wrapper_struct: StructValue<'ctx>,
 ) -> BasicValueEnum<'ctx> {
     let builder = env.builder;
 
+    let element_layout = env.layout_interner.get(element_layout);
     let elem_type = basic_type_from_layout(env, element_layout);
     let ptr_type = elem_type.ptr_type(AddressSpace::Generic);
     // Load the pointer to the array data
@@ -160,9 +163,10 @@ pub(crate) fn list_reserve<'a, 'ctx, 'env>(
     env: &Env<'a, 'ctx, 'env>,
     list: BasicValueEnum<'ctx>,
     spare: BasicValueEnum<'ctx>,
-    element_layout: &Layout<'a>,
+    element_layout: InLayout<'a>,
     update_mode: UpdateMode,
 ) -> BasicValueEnum<'ctx> {
+    let element_layout = env.layout_interner.get(element_layout);
     call_list_bitcode_fn_1(
         env,
         list.into_struct_value(),
@@ -219,9 +223,10 @@ pub(crate) fn list_swap<'a, 'ctx, 'env>(
     original_wrapper: StructValue<'ctx>,
     index_1: IntValue<'ctx>,
     index_2: IntValue<'ctx>,
-    element_layout: &Layout<'a>,
+    element_layout: InLayout<'a>,
     update_mode: UpdateMode,
 ) -> BasicValueEnum<'ctx> {
+    let element_layout = env.layout_interner.get(element_layout);
     call_list_bitcode_fn_1(
         env,
         original_wrapper,
@@ -243,8 +248,9 @@ pub(crate) fn list_sublist<'a, 'ctx, 'env>(
     original_wrapper: StructValue<'ctx>,
     start: IntValue<'ctx>,
     len: IntValue<'ctx>,
-    element_layout: &Layout<'a>,
+    element_layout: InLayout<'a>,
 ) -> BasicValueEnum<'ctx> {
+    let element_layout = env.layout_interner.get(element_layout);
     let dec_element_fn = build_dec_wrapper(env, layout_ids, element_layout);
     call_list_bitcode_fn_1(
         env,
@@ -266,8 +272,9 @@ pub(crate) fn list_drop_at<'a, 'ctx, 'env>(
     layout_ids: &mut LayoutIds<'a>,
     original_wrapper: StructValue<'ctx>,
     count: IntValue<'ctx>,
-    element_layout: &Layout<'a>,
+    element_layout: InLayout<'a>,
 ) -> BasicValueEnum<'ctx> {
+    let element_layout = env.layout_interner.get(element_layout);
     let dec_element_fn = build_dec_wrapper(env, layout_ids, element_layout);
     call_list_bitcode_fn_1(
         env,
@@ -589,8 +596,9 @@ pub(crate) fn list_concat<'a, 'ctx, 'env>(
     env: &Env<'a, 'ctx, 'env>,
     list1: BasicValueEnum<'ctx>,
     list2: BasicValueEnum<'ctx>,
-    element_layout: &Layout<'a>,
+    element_layout: InLayout<'a>,
 ) -> BasicValueEnum<'ctx> {
+    let element_layout = env.layout_interner.get(element_layout);
     call_list_bitcode_fn(
         env,
         &[list1.into_struct_value(), list2.into_struct_value()],

crates/compiler/gen_llvm/src/llvm/compare.rs

@@ -127,7 +127,7 @@ fn build_eq_builtin<'a, 'ctx, 'env>(
             env,
             layout_ids,
             &Layout::Builtin(*builtin),
-            elem,
+            *elem,
             lhs_val.into_struct_value(),
             rhs_val.into_struct_value(),
             when_recursive,
@@ -299,7 +299,7 @@ fn build_neq_builtin<'a, 'ctx, 'env>(
                 env,
                 layout_ids,
                 &Layout::Builtin(*builtin),
-                elem,
+                *elem,
                 lhs_val.into_struct_value(),
                 rhs_val.into_struct_value(),
                 when_recursive,
@@ -394,7 +394,7 @@ fn build_list_eq<'a, 'ctx, 'env>(
     env: &Env<'a, 'ctx, 'env>,
     layout_ids: &mut LayoutIds<'a>,
     list_layout: &Layout<'a>,
-    element_layout: &Layout<'a>,
+    element_layout: InLayout<'a>,
     list1: StructValue<'ctx>,
     list2: StructValue<'ctx>,
     when_recursive: WhenRecursive<'a>,
@@ -403,6 +403,7 @@ fn build_list_eq<'a, 'ctx, 'env>(
     let di_location = env.builder.get_current_debug_location().unwrap();
 
     let symbol = Symbol::LIST_EQ;
+    let element_layout = env.layout_interner.get(element_layout);
     let element_layout = when_recursive.unwrap_recursive_pointer(*element_layout);
     let fn_name = layout_ids
         .get(symbol, &element_layout)

crates/compiler/gen_llvm/src/llvm/expect.rs

@@ -990,6 +990,7 @@ fn build_clone_builtin<'a, 'ctx, 'env>(
             offset = build_copy(env, ptr, offset, len.into());
             offset = build_copy(env, ptr, offset, len.into());
 
+            let elem = env.layout_interner.get(elem);
             let (element_width, _element_align) =
                 elem.stack_size_and_alignment(env.layout_interner, env.target_info);
             let element_width = env.ptr_int().const_int(element_width as _, false);

crates/compiler/gen_llvm/src/llvm/lowlevel.rs

@@ -9,6 +9,7 @@ use inkwell::{
 use morphic_lib::{FuncSpec, UpdateMode};
 use roc_builtins::bitcode::{self, FloatWidth, IntWidth};
 use roc_error_macros::internal_error;
+use roc_intern::Interner;
 use roc_module::{low_level::LowLevel, symbol::Symbol};
 use roc_mono::{
     ir::HigherOrderLowLevel,
@@ -52,7 +53,7 @@ use super::{
 macro_rules! list_element_layout {
     ($list_layout:expr) => {
         match $list_layout {
-            Layout::Builtin(Builtin::List(list_layout)) => *list_layout,
+            Layout::Builtin(Builtin::List(list_layout)) => list_layout,
             _ => unreachable!("invalid list layout"),
         }
     };
@@ -645,7 +646,7 @@ pub(crate) fn run_low_level<'a, 'ctx, 'env>(
             list_with_capacity(
                 env,
                 list_len.into_int_value(),
-                &list_element_layout!(result_layout),
+                list_element_layout!(result_layout),
             )
         }
         ListConcat => {
@@ -657,7 +658,7 @@ pub(crate) fn run_low_level<'a, 'ctx, 'env>(
 
             let element_layout = list_element_layout!(list_layout);
 
-            list_concat(env, first_list, second_list, element_layout)
+            list_concat(env, first_list, second_list, *element_layout)
         }
         ListAppendUnsafe => {
             // List.appendUnsafe : List elem, elem -> List elem
@@ -685,7 +686,7 @@ pub(crate) fn run_low_level<'a, 'ctx, 'env>(
             let element_layout = list_element_layout!(list_layout);
             let spare = load_symbol(scope, &args[1]);
 
-            list_reserve(env, list, spare, element_layout, update_mode)
+            list_reserve(env, list, spare, *element_layout, update_mode)
         }
         ListSwap => {
             // List.swap : List elem, Nat, Nat -> List elem
@@ -703,7 +704,7 @@ pub(crate) fn run_low_level<'a, 'ctx, 'env>(
                 original_wrapper,
                 index_1.into_int_value(),
                 index_2.into_int_value(),
-                element_layout,
+                *element_layout,
                 update_mode,
             )
         }
@@ -723,7 +724,7 @@ pub(crate) fn run_low_level<'a, 'ctx, 'env>(
                 original_wrapper,
                 start.into_int_value(),
                 len.into_int_value(),
-                element_layout,
+                *element_layout,
             )
         }
         ListDropAt => {
@@ -741,7 +742,7 @@ pub(crate) fn run_low_level<'a, 'ctx, 'env>(
                 layout_ids,
                 original_wrapper,
                 count.into_int_value(),
-                element_layout,
+                *element_layout,
             )
         }
         StrGetUnsafe => {
@@ -763,7 +764,7 @@ pub(crate) fn run_low_level<'a, 'ctx, 'env>(
             list_get_unsafe(
                 env,
                 layout_ids,
-                list_element_layout!(list_layout),
+                *list_element_layout!(list_layout),
                 element_index.into_int_value(),
                 wrapper_struct.into_struct_value(),
             )
@@ -2275,7 +2276,10 @@ pub(crate) fn run_higher_order_low_level<'a, 'ctx, 'env>(
                     Layout::Builtin(Builtin::List(element_layout)),
                     Layout::Builtin(Builtin::List(result_layout)),
                 ) => {
-                    let argument_layouts = &[**element_layout];
+                    let element_layout = env.layout_interner.get(*element_layout);
+                    let result_layout = env.layout_interner.get(*result_layout);
+
+                    let argument_layouts = &[*element_layout];
 
                     let roc_function_call = roc_function_call(
                         env,
@@ -2285,7 +2289,7 @@ pub(crate) fn run_higher_order_low_level<'a, 'ctx, 'env>(
                         closure_layout,
                         function_owns_closure_data,
                         argument_layouts,
-                        **result_layout,
+                        *result_layout,
                     );
 
                     list_map(env, roc_function_call, list, element_layout, result_layout)
@@ -2305,7 +2309,11 @@ pub(crate) fn run_higher_order_low_level<'a, 'ctx, 'env>(
                     Layout::Builtin(Builtin::List(element2_layout)),
                     Layout::Builtin(Builtin::List(result_layout)),
                 ) => {
-                    let argument_layouts = &[**element1_layout, **element2_layout];
+                    let element1_layout = env.layout_interner.get(*element1_layout);
+                    let element2_layout = env.layout_interner.get(*element2_layout);
+                    let result_layout = env.layout_interner.get(*result_layout);
+
+                    let argument_layouts = &[*element1_layout, *element2_layout];
 
                     let roc_function_call = roc_function_call(
                         env,
@@ -2315,7 +2323,7 @@ pub(crate) fn run_higher_order_low_level<'a, 'ctx, 'env>(
                         closure_layout,
                         function_owns_closure_data,
                         argument_layouts,
-                        **result_layout,
+                        *result_layout,
                     );
 
                     list_map2(
@@ -2346,8 +2354,12 @@ pub(crate) fn run_higher_order_low_level<'a, 'ctx, 'env>(
                     Layout::Builtin(Builtin::List(element3_layout)),
                     Layout::Builtin(Builtin::List(result_layout)),
                 ) => {
-                    let argument_layouts =
-                        &[**element1_layout, **element2_layout, **element3_layout];
+                    let element1_layout = env.layout_interner.get(*element1_layout);
+                    let element2_layout = env.layout_interner.get(*element2_layout);
+                    let element3_layout = env.layout_interner.get(*element3_layout);
+                    let result_layout = env.layout_interner.get(*result_layout);
+
+                    let argument_layouts = &[*element1_layout, *element2_layout, *element3_layout];
 
                     let roc_function_call = roc_function_call(
                         env,
@@ -2357,7 +2369,7 @@ pub(crate) fn run_higher_order_low_level<'a, 'ctx, 'env>(
                         closure_layout,
                         function_owns_closure_data,
                         argument_layouts,
-                        **result_layout,
+                        *result_layout,
                     );
 
                     list_map3(
@@ -2398,11 +2410,17 @@ pub(crate) fn run_higher_order_low_level<'a, 'ctx, 'env>(
                     Layout::Builtin(Builtin::List(element4_layout)),
                     Layout::Builtin(Builtin::List(result_layout)),
                 ) => {
+                    let element1_layout = env.layout_interner.get(*element1_layout);
+                    let element2_layout = env.layout_interner.get(*element2_layout);
+                    let element3_layout = env.layout_interner.get(*element3_layout);
+                    let element4_layout = env.layout_interner.get(*element4_layout);
+                    let result_layout = env.layout_interner.get(*result_layout);
+
                     let argument_layouts = &[
-                        **element1_layout,
-                        **element2_layout,
-                        **element3_layout,
-                        **element4_layout,
+                        *element1_layout,
+                        *element2_layout,
+                        *element3_layout,
+                        *element4_layout,
                     ];
 
                     let roc_function_call = roc_function_call(
@@ -2413,7 +2431,7 @@ pub(crate) fn run_higher_order_low_level<'a, 'ctx, 'env>(
                         closure_layout,
                         function_owns_closure_data,
                         argument_layouts,
-                        **result_layout,
+                        *result_layout,
                     );
 
                     list_map4(
@@ -2444,7 +2462,9 @@ pub(crate) fn run_higher_order_low_level<'a, 'ctx, 'env>(
                 Layout::Builtin(Builtin::List(element_layout)) => {
                     use crate::llvm::bitcode::build_compare_wrapper;
 
-                    let argument_layouts = &[**element_layout, **element_layout];
+                    let element_layout = env.layout_interner.get(*element_layout);
+
+                    let argument_layouts = &[*element_layout, *element_layout];
 
                     let compare_wrapper =
                         build_compare_wrapper(env, function, closure_layout, element_layout)

crates/compiler/gen_llvm/src/llvm/refcounting.rs

@@ -15,6 +15,7 @@ use inkwell::values::{
     BasicValue, BasicValueEnum, FunctionValue, IntValue, PointerValue, StructValue,
 };
 use inkwell::{AddressSpace, IntPredicate};
+use roc_intern::Interner;
 use roc_module::symbol::Interns;
 use roc_module::symbol::Symbol;
 use roc_mono::layout::{Builtin, InLayout, Layout, LayoutIds, STLayoutInterner, UnionLayout};
@@ -408,7 +409,7 @@ fn modify_refcount_builtin<'a, 'ctx, 'env>(
     match builtin {
         List(element_layout) => {
             let function =
-                modify_refcount_list(env, layout_ids, mode, when_recursive, element_layout);
+                modify_refcount_list(env, layout_ids, mode, when_recursive, *element_layout);
 
             Some(function)
         }
@@ -606,13 +607,15 @@ fn modify_refcount_list<'a, 'ctx, 'env>(
     layout_ids: &mut LayoutIds<'a>,
     mode: Mode,
     when_recursive: &WhenRecursive<'a>,
-    element_layout: &Layout<'a>,
+    element_layout: InLayout<'a>,
 ) -> FunctionValue<'ctx> {
     let block = env.builder.get_insert_block().expect("to be in a function");
     let di_location = env.builder.get_current_debug_location().unwrap();
 
+    let element_layout = env.layout_interner.get(element_layout);
     let element_layout = when_recursive.unwrap_recursive_pointer(*element_layout);
-    let list_layout = &Layout::Builtin(Builtin::List(env.arena.alloc(element_layout)));
+    let element_layout = env.layout_interner.insert(env.arena.alloc(element_layout));
+    let list_layout = &Layout::Builtin(Builtin::List(element_layout));
     let (_, fn_name) = function_name_from_mode(
         layout_ids,
         &env.interns,
@@ -634,7 +637,7 @@ fn modify_refcount_list<'a, 'ctx, 'env>(
                 mode,
                 when_recursive,
                 list_layout,
-                &element_layout,
+                element_layout,
                 function_value,
             );
 
@@ -662,7 +665,7 @@ fn modify_refcount_list_help<'a, 'ctx, 'env>(
     mode: Mode,
     when_recursive: &WhenRecursive<'a>,
     layout: &Layout<'a>,
-    element_layout: &Layout<'a>,
+    element_layout: InLayout<'a>,
     fn_val: FunctionValue<'ctx>,
 ) {
     let builder = env.builder;
@@ -701,6 +704,7 @@ fn modify_refcount_list_help<'a, 'ctx, 'env>(
 
     builder.position_at_end(modification_block);
 
+    let element_layout = env.layout_interner.get(element_layout);
     if element_layout.contains_refcounted(env.layout_interner) {
         let ptr_type = basic_type_from_layout(env, element_layout).ptr_type(AddressSpace::Generic);