argument_type_from_layout takes layoutrepr

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

@@ -5034,7 +5034,8 @@ fn build_proc_header<'a, 'ctx>(
     let mut arg_basic_types = Vec::with_capacity_in(args.len(), arena);
 
     for (layout, _) in args.iter() {
-        let arg_type = argument_type_from_layout(env, layout_interner, *layout);
+        let arg_type =
+            argument_type_from_layout(env, layout_interner, layout_interner.get_repr(*layout));
 
         arg_basic_types.push(arg_type);
     }
@@ -5966,7 +5967,11 @@ fn build_foreign_symbol<'a, 'ctx>(
 
                 cc_argument_types.push(to_cc_type(env, layout_interner, layout));
 
-                let basic_type = argument_type_from_layout(env, layout_interner, layout);
+                let basic_type = argument_type_from_layout(
+                    env,
+                    layout_interner,
+                    layout_interner.get_repr(layout),
+                );
                 fastcc_argument_types.push(basic_type);
 
                 arguments.push(value);

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

@@ -665,7 +665,11 @@ fn build_struct_eq<'a, 'ctx>(
     let function = match env.module.get_function(fn_name.as_str()) {
         Some(function_value) => function_value,
         None => {
-            let arg_type = argument_type_from_layout(env, layout_interner, struct_layout);
+            let arg_type = argument_type_from_layout(
+                env,
+                layout_interner,
+                layout_interner.get_repr(struct_layout),
+            );
 
             let function_value = crate::llvm::refcounting::build_header_help(
                 env,

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

@@ -153,28 +153,29 @@ pub fn basic_type_from_builtin<'ctx>(
 pub fn argument_type_from_layout<'a, 'ctx>(
     env: &Env<'a, 'ctx, '_>,
     layout_interner: &STLayoutInterner<'a>,
-    layout: InLayout<'a>,
+    layout: LayoutRepr<'a>,
 ) -> BasicTypeEnum<'ctx> {
     use LayoutRepr::*;
 
     // TODO: can this just be "basic_type_from_layout => ptr if passed_by_ref"?
-    match layout_interner.get_repr(layout) {
+    match layout {
-        LambdaSet(lambda_set) => {
+        LambdaSet(lambda_set) => argument_type_from_layout(
-            argument_type_from_layout(env, layout_interner, lambda_set.runtime_representation())
+            env,
-        }
+            layout_interner,
+            layout_interner.get_repr(lambda_set.runtime_representation()),
+        ),
         Union(union_layout) => argument_type_from_union_layout(env, layout_interner, &union_layout),
         Builtin(_) => {
-            let base =
+            let base = basic_type_from_layout(env, layout_interner, layout);
-                basic_type_from_layout(env, layout_interner, layout_interner.get_repr(layout));
 
-            if layout_interner.is_passed_by_reference(layout) {
+            if layout.is_passed_by_reference(layout_interner) {
                 base.ptr_type(AddressSpace::default()).into()
             } else {
                 base
             }
         }
         Struct(_) => argument_type_from_struct_layout(env, layout_interner, layout),
-        _ => basic_type_from_layout(env, layout_interner, layout_interner.get_repr(layout)),
+        _ => basic_type_from_layout(env, layout_interner, layout),
     }
 }
 
@@ -182,19 +183,12 @@ pub fn argument_type_from_layout<'a, 'ctx>(
 fn argument_type_from_struct_layout<'a, 'ctx>(
     env: &Env<'a, 'ctx, '_>,
     layout_interner: &STLayoutInterner<'a>,
-    struct_layout: InLayout<'a>,
+    struct_layout: LayoutRepr<'a>,
 ) -> BasicTypeEnum<'ctx> {
-    debug_assert!(matches!(
+    debug_assert!(matches!(struct_layout, LayoutRepr::Struct(_)));
-        layout_interner.get_repr(struct_layout),
+    let stack_type = basic_type_from_layout(env, layout_interner, struct_layout);
-        LayoutRepr::Struct(_)
-    ));
-    let stack_type = basic_type_from_layout(
-        env,
-        layout_interner,
-        layout_interner.get_repr(struct_layout),
-    );
 
-    if layout_interner.is_passed_by_reference(struct_layout) {
+    if struct_layout.is_passed_by_reference(layout_interner) {
         stack_type.ptr_type(AddressSpace::default()).into()
     } else {
         stack_type

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

@@ -316,7 +316,8 @@ pub(crate) fn run_low_level<'a, 'ctx>(
 
             // zig passes the result as a packed integer sometimes, instead of a struct. So we cast if needed.
             // We check the type as expected in an argument position, since that is how we actually will use it.
-            let expected_type = argument_type_from_layout(env, layout_interner, layout);
+            let expected_type =
+                argument_type_from_layout(env, layout_interner, layout_interner.get_repr(layout));
             let actual_type = result.get_type();
 
             if expected_type != actual_type {
@@ -2148,8 +2149,11 @@ fn build_int_unary_op<'a, 'ctx, 'env>(
             )
             .into_struct_type();
             // How the return type is actually used, in the Roc calling convention.
-            let return_type_use_type =
+            let return_type_use_type = convert::argument_type_from_layout(
-                convert::argument_type_from_layout(env, layout_interner, return_layout);
+                env,
+                layout_interner,
+                layout_interner.get_repr(return_layout),
+            );
 
             if arg_always_fits_in_target {
                 // This is guaranteed to succeed so we can just make it an int cast and let LLVM

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

@@ -280,7 +280,11 @@ fn modify_refcount_struct<'a, 'ctx>(
     let function = match env.module.get_function(fn_name.as_str()) {
         Some(function_value) => function_value,
         None => {
-            let arg_type = argument_type_from_layout(env, layout_interner, struct_layout);
+            let arg_type = argument_type_from_layout(
+                env,
+                layout_interner,
+                layout_interner.get_repr(struct_layout),
+            );
             let function_value = build_header(env, arg_type, mode, &fn_name);
 
             modify_refcount_struct_help(
@@ -620,7 +624,11 @@ fn modify_refcount_list<'a, 'ctx>(
     let function = match env.module.get_function(fn_name.as_str()) {
         Some(function_value) => function_value,
         None => {
-            let basic_type = argument_type_from_layout(env, layout_interner, list_layout);
+            let basic_type = argument_type_from_layout(
+                env,
+                layout_interner,
+                layout_interner.get_repr(list_layout),
+            );
             let function_value = build_header(env, basic_type, mode, &fn_name);
 
             modify_refcount_list_help(
@@ -764,7 +772,8 @@ fn modify_refcount_str<'a, 'ctx>(
     let function = match env.module.get_function(fn_name.as_str()) {
         Some(function_value) => function_value,
         None => {
-            let basic_type = argument_type_from_layout(env, layout_interner, layout);
+            let basic_type =
+                argument_type_from_layout(env, layout_interner, layout_interner.get_repr(layout));
             let function_value = build_header(env, basic_type, mode, &fn_name);
 
             modify_refcount_str_help(env, layout_interner, mode, layout, function_value);