language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-26 13:29:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

List takes interned element

Browse source
This commit is contained in:
Ayaz Hafiz 2022-12-29 08:52:37 -06:00
parent f2a42affd1
commit e4b5252e51
No known key found for this signature in database
GPG key ID: 0E2A37416A25EF58
16 changed files with 173 additions and 83 deletions
Download patch file Download diff file Expand all files Collapse all files

25
crates/compiler/alias_analysis/src/lib.rs
View file

@ -136,7 +136,7 @@ fn bytes_as_ascii(bytes: &[u8]) -> String {
pub fn spec_program<'a, I>(
arena: &'a Bump,
interner: &STLayoutInterner<'a>,
interner: &mut STLayoutInterner<'a>,
opt_level: OptLevel,
entry_point: roc_mono::ir::EntryPoint<'a>,
procs: I,
@ -449,7 +449,7 @@ fn build_entry_point<'a>(
fn proc_spec<'a>(
arena: &'a Bump,
interner: &STLayoutInterner<'a>,
interner: &mut STLayoutInterner<'a>,
proc: &Proc<'a>,
) -> Result<(FuncDef, MutSet<UnionLayout<'a>>)> {
let mut builder = FuncDefBuilder::new();
@ -546,7 +546,7 @@ fn apply_refcount_operation<'a>(
fn stmt_spec<'a>(
builder: &mut FuncDefBuilder,
interner: &STLayoutInterner<'a>,
interner: &mut STLayoutInterner<'a>,
env: &mut Env<'a>,
block: BlockId,
layout: &Layout<'a>,
@ -788,7 +788,7 @@ fn add_loop(
fn call_spec<'a>(
builder: &mut FuncDefBuilder,
interner: &STLayoutInterner<'a>,
interner: &mut STLayoutInterner<'a>,
env: &mut Env<'a>,
block: BlockId,
layout: &Layout<'a>,
@ -909,6 +909,8 @@ fn call_spec<'a>(
&WhenRecursive::Unreachable,
)?;
let return_layout = interner.insert(return_layout);
let state_layout = Layout::Builtin(Builtin::List(return_layout));
let state_type = layout_spec(
env,
@ -940,7 +942,9 @@ fn call_spec<'a>(
with_new_heap_cell(builder, block, bag)
};
let state_layout = Layout::Builtin(Builtin::List(&argument_layouts[0]));
let arg0_layout = interner.insert(&argument_layouts[0]);
let state_layout = Layout::Builtin(Builtin::List(arg0_layout));
let state_type = layout_spec(
env,
builder,
@ -979,6 +983,8 @@ fn call_spec<'a>(
&WhenRecursive::Unreachable,
)?;
let return_layout = interner.insert(return_layout);
let state_layout = Layout::Builtin(Builtin::List(return_layout));
let state_type = layout_spec(
env,
@ -1024,6 +1030,8 @@ fn call_spec<'a>(
&WhenRecursive::Unreachable,
)?;
let return_layout = interner.insert(return_layout);
let state_layout = Layout::Builtin(Builtin::List(return_layout));
let state_type = layout_spec(
env,
@ -1075,6 +1083,8 @@ fn call_spec<'a>(
&WhenRecursive::Unreachable,
)?;
let return_layout = interner.insert(return_layout);
let state_layout = Layout::Builtin(Builtin::List(return_layout));
let state_type = layout_spec(
env,
@ -1245,6 +1255,7 @@ fn lowlevel_spec<'a>(
match layout {
Layout::Builtin(Builtin::List(element_layout)) => {
let element_layout = interner.get(*element_layout);
let type_id = layout_spec(
env,
builder,
@ -1413,7 +1424,7 @@ fn worst_case_type(context: &mut impl TypeContext) -> Result<TypeId> {
fn expr_spec<'a>(
builder: &mut FuncDefBuilder,
interner: &STLayoutInterner<'a>,
interner: &mut STLayoutInterner<'a>,
env: &mut Env<'a>,
block: BlockId,
layout: &Layout<'a>,
@ -1583,6 +1594,7 @@ fn expr_spec<'a>(
EmptyArray => match layout {
Layout::Builtin(Builtin::List(element_layout)) => {
let element_layout = interner.get(*element_layout);
let type_id = layout_spec(
env,
builder,
@ -1772,6 +1784,7 @@ fn builtin_spec<'a>(
Decimal | Float(_) => builder.add_tuple_type(&[]),
Str => str_type(builder),
List(element_layout) => {
let element_layout = interner.get(*element_layout);
let element_type =
layout_spec_help(env, builder, interner, element_layout, when_recursive)?;

24
crates/compiler/gen_llvm/src/llvm/build_list.rs
View file

@ -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()],

7
crates/compiler/gen_llvm/src/llvm/compare.rs
View file

@ -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)

1
crates/compiler/gen_llvm/src/llvm/expect.rs
View file

@ -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);

62
crates/compiler/gen_llvm/src/llvm/lowlevel.rs
View file

@ -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)

14
crates/compiler/gen_llvm/src/llvm/refcounting.rs
View file

@ -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);

25
crates/compiler/gen_wasm/src/low_level.rs
View file

@ -7,7 +7,7 @@ use roc_module::low_level::LowLevel;
use roc_module::symbol::Symbol;
use roc_mono::code_gen_help::HelperOp;
use roc_mono::ir::{HigherOrderLowLevel, PassedFunction, ProcLayout};
use roc_mono::layout::{Builtin, FieldOrderHash, Layout, UnionLayout};
use roc_mono::layout::{Builtin, FieldOrderHash, InLayout, Layout, UnionLayout};
use roc_mono::low_level::HigherOrder;
use crate::backend::{ProcLookupData, ProcSource, WasmBackend};
@ -416,7 +416,7 @@ impl<'a> LowLevelCall<'a> {
Layout::Struct {
field_layouts: &[Layout::Builtin(Builtin::List(list_elem)), value_layout],
..
} if value_layout == *list_elem => {
} if value_layout == *backend.layout_interner.get(list_elem) => {
let list_offset = 0;
let elem_offset = Layout::Builtin(Builtin::List(list_elem))
.stack_size(backend.layout_interner, TARGET_INFO);
@ -425,7 +425,7 @@ impl<'a> LowLevelCall<'a> {
Layout::Struct {
field_layouts: &[value_layout, Layout::Builtin(Builtin::List(list_elem))],
..
} if value_layout == *list_elem => {
} if value_layout == *backend.layout_interner.get(list_elem) => {
let list_offset =
value_layout.stack_size(backend.layout_interner, TARGET_INFO);
let elem_offset = 0;
@ -484,6 +484,7 @@ impl<'a> LowLevelCall<'a> {
let capacity: Symbol = self.arguments[0];
let elem_layout = unwrap_list_elem_layout(self.ret_layout);
let elem_layout = backend.layout_interner.get(elem_layout);
let (elem_width, elem_align) =
elem_layout.stack_size_and_alignment(backend.layout_interner, TARGET_INFO);
@ -522,6 +523,7 @@ impl<'a> LowLevelCall<'a> {
// Load monomorphization constants
let elem_layout = unwrap_list_elem_layout(self.ret_layout);
let elem_layout = backend.layout_interner.get(elem_layout);
let (elem_width, elem_align) =
elem_layout.stack_size_and_alignment(backend.layout_interner, TARGET_INFO);
backend.code_builder.i32_const(elem_align as i32);
@ -537,6 +539,7 @@ impl<'a> LowLevelCall<'a> {
let spare: Symbol = self.arguments[1];
let elem_layout = unwrap_list_elem_layout(self.ret_layout);
let elem_layout = backend.layout_interner.get(elem_layout);
let (elem_width, elem_align) =
elem_layout.stack_size_and_alignment(backend.layout_interner, TARGET_INFO);
let (spare_local, spare_offset, _) = ensure_symbol_is_in_memory(
@ -586,6 +589,7 @@ impl<'a> LowLevelCall<'a> {
let elem: Symbol = self.arguments[1];
let elem_layout = unwrap_list_elem_layout(self.ret_layout);
let elem_layout = backend.layout_interner.get(elem_layout);
let elem_width = elem_layout.stack_size(backend.layout_interner, TARGET_INFO);
let (elem_local, elem_offset, _) =
ensure_symbol_is_in_memory(backend, elem, *elem_layout, backend.env.arena);
@ -623,6 +627,7 @@ impl<'a> LowLevelCall<'a> {
let elem: Symbol = self.arguments[1];
let elem_layout = unwrap_list_elem_layout(self.ret_layout);
let elem_layout = backend.layout_interner.get(elem_layout);
let (elem_width, elem_align) =
elem_layout.stack_size_and_alignment(backend.layout_interner, TARGET_INFO);
let (elem_local, elem_offset, _) =
@ -665,6 +670,7 @@ impl<'a> LowLevelCall<'a> {
let len: Symbol = self.arguments[2];
let elem_layout = unwrap_list_elem_layout(self.ret_layout);
let elem_layout = backend.layout_interner.get(elem_layout);
let (elem_width, elem_align) =
elem_layout.stack_size_and_alignment(backend.layout_interner, TARGET_INFO);
@ -710,6 +716,7 @@ impl<'a> LowLevelCall<'a> {
let drop_index: Symbol = self.arguments[1];
let elem_layout = unwrap_list_elem_layout(self.ret_layout);
let elem_layout = backend.layout_interner.get(elem_layout);
let (elem_width, elem_align) =
elem_layout.stack_size_and_alignment(backend.layout_interner, TARGET_INFO);
@ -756,6 +763,7 @@ impl<'a> LowLevelCall<'a> {
let index_2: Symbol = self.arguments[2];
let elem_layout = unwrap_list_elem_layout(self.ret_layout);
let elem_layout = backend.layout_interner.get(elem_layout);
let (elem_width, elem_align) =
elem_layout.stack_size_and_alignment(backend.layout_interner, TARGET_INFO);
@ -2325,6 +2333,7 @@ pub fn call_higher_order_lowlevel<'a>(
ListSortWith { xs } => {
let elem_layout = unwrap_list_elem_layout(backend.storage.symbol_layouts[xs]);
let elem_layout = backend.layout_interner.get(elem_layout);
let (element_width, alignment) =
elem_layout.stack_size_and_alignment(backend.layout_interner, TARGET_INFO);
@ -2361,7 +2370,7 @@ pub fn call_higher_order_lowlevel<'a>(
}
}
fn unwrap_list_elem_layout(list_layout: Layout<'_>) -> &Layout<'_> {
fn unwrap_list_elem_layout(list_layout: Layout<'_>) -> InLayout<'_> {
match list_layout {
Layout::Builtin(Builtin::List(x)) => x,
e => internal_error!("expected List layout, got {:?}", e),
@ -2382,13 +2391,15 @@ fn list_map_n<'a>(
owns_captured_environment: bool,
) {
let arg_elem_layouts = Vec::from_iter_in(
arg_symbols
.iter()
.map(|sym| *unwrap_list_elem_layout(backend.storage.symbol_layouts[sym])),
arg_symbols.iter().map(|sym| {
let lay = unwrap_list_elem_layout(backend.storage.symbol_layouts[sym]);
*backend.layout_interner.get(lay)
}),
backend.env.arena,
);
let elem_ret = unwrap_list_elem_layout(return_layout);
let elem_ret = backend.layout_interner.get(elem_ret);
let (elem_ret_size, elem_ret_align) =
elem_ret.stack_size_and_alignment(backend.layout_interner, TARGET_INFO);

4
crates/compiler/mono/src/code_gen_help/equality.rs
View file

@ -630,12 +630,14 @@ fn eq_list<'a>(
ident_ids: &mut IdentIds,
ctx: &mut Context<'a>,
layout_interner: &mut STLayoutInterner<'a>,
elem_layout: &Layout<'a>,
elem_layout: InLayout<'a>,
) -> Stmt<'a> {
use LowLevel::*;
let layout_isize = root.layout_isize;
let arena = root.arena;
let elem_layout = layout_interner.get(elem_layout);
// A "Box" layout (heap pointer to a single list element)
let box_union_layout = UnionLayout::NonNullableUnwrapped(root.arena.alloc([*elem_layout]));
let box_layout = Layout::Union(box_union_layout);

9
crates/compiler/mono/src/code_gen_help/mod.rs
View file

@ -444,10 +444,11 @@ impl<'a> CodeGenHelp<'a> {
layout: Layout<'a>,
) -> Layout<'a> {
match layout {
Layout::Builtin(Builtin::List(v)) => Layout::Builtin(Builtin::List(
self.arena
.alloc(self.replace_rec_ptr(ctx, layout_interner, *v)),
)),
Layout::Builtin(Builtin::List(v)) => {
let v = self.replace_rec_ptr(ctx, layout_interner, *layout_interner.get(v));
let v = layout_interner.insert(self.arena.alloc(v));
Layout::Builtin(Builtin::List(v))
}
Layout::Builtin(_) => layout,

11
crates/compiler/mono/src/code_gen_help/refcount.rs
View file

@ -11,7 +11,7 @@ use crate::code_gen_help::let_lowlevel;
use crate::ir::{
BranchInfo, Call, CallType, Expr, JoinPointId, Literal, ModifyRc, Param, Stmt, UpdateModeId,
};
use crate::layout::{Builtin, Layout, STLayoutInterner, TagIdIntType, UnionLayout};
use crate::layout::{Builtin, InLayout, Layout, STLayoutInterner, TagIdIntType, UnionLayout};
use super::{CodeGenHelp, Context, HelperOp};
@ -425,7 +425,10 @@ where
use UnionLayout::*;
match layout {
Layout::Builtin(Builtin::List(elem_layout)) => is_rc_implemented_yet(interner, elem_layout),
Layout::Builtin(Builtin::List(elem_layout)) => {
let elem_layout = interner.get(*elem_layout);
is_rc_implemented_yet(interner, elem_layout)
}
Layout::Builtin(_) => true,
Layout::Struct { field_layouts, .. } => field_layouts
.iter()
@ -761,12 +764,14 @@ fn refcount_list<'a>(
ctx: &mut Context<'a>,
layout_interner: &mut STLayoutInterner<'a>,
layout: &Layout,
elem_layout: &'a Layout,
elem_layout: InLayout<'a>,
structure: Symbol,
) -> Stmt<'a> {
let layout_isize = root.layout_isize;
let arena = root.arena;
let elem_layout = layout_interner.get(elem_layout);
// A "Box" layout (heap pointer to a single list element)
let box_union_layout = UnionLayout::NonNullableUnwrapped(arena.alloc([*elem_layout]));
let box_layout = Layout::Union(box_union_layout);

6
crates/compiler/mono/src/debug/checker.rs
View file

@ -427,7 +427,8 @@ impl<'a, 'r> Ctx<'a, 'r> {
}
}
}
Some(Layout::Builtin(Builtin::List(self.alloc(*elem_layout))))
let elem_layout = self.interner.insert(self.alloc(*elem_layout));
Some(Layout::Builtin(Builtin::List(elem_layout)))
}
Expr::EmptyArray => {
// TODO don't know what the element layout is
@ -694,9 +695,10 @@ fn resolve_recursive_layout<'a>(
let inner = arena.alloc(resolve_recursive_layout(
arena,
interner,
*inner,
*interner.get(inner),
when_recursive,
));
let inner = interner.insert(arena.alloc(inner));
Layout::Builtin(Builtin::List(inner))
}
Builtin::Int(_)

21
crates/compiler/mono/src/decision_tree.rs
View file

@ -2,11 +2,12 @@ use crate::ir::{
build_list_index_probe, BranchInfo, Call, CallType, DestructType, Env, Expr, JoinPointId,
ListIndex, Literal, Param, Pattern, Procs, Stmt,
};
use crate::layout::{Builtin, Layout, LayoutCache, TagIdIntType, UnionLayout};
use crate::layout::{Builtin, Layout, LayoutCache, LayoutInterner, TagIdIntType, UnionLayout};
use roc_builtins::bitcode::{FloatWidth, IntWidth};
use roc_collections::all::{MutMap, MutSet};
use roc_error_macros::internal_error;
use roc_exhaustive::{Ctor, CtorName, ListArity, RenderAs, TagId, Union};
use roc_intern::Interner;
use roc_module::ident::TagName;
use roc_module::low_level::LowLevel;
use roc_module::symbol::Symbol;
@ -1358,6 +1359,7 @@ enum PathInstruction {
fn path_to_expr_help<'a>(
env: &mut Env<'a, '_>,
layout_interner: &LayoutInterner<'a>,
mut symbol: Symbol,
path: &[PathInstruction],
mut layout: Layout<'a>,
@ -1442,6 +1444,8 @@ fn path_to_expr_help<'a>(
arguments: env.arena.alloc([list_sym, index_sym]),
});
let elem_layout = layout_interner.get(elem_layout);
stores.push((load_sym, *elem_layout, load_expr));
layout = *elem_layout;
@ -1458,13 +1462,14 @@ fn path_to_expr_help<'a>(
fn test_to_comparison<'a>(
env: &mut Env<'a, '_>,
layout_interner: &LayoutInterner<'a>,
cond_symbol: Symbol,
cond_layout: &Layout<'a>,
path: &[PathInstruction],
test: Test<'a>,
) -> (StoresVec<'a>, Comparison, Option<ConstructorKnown<'a>>) {
let (rhs_symbol, mut stores, test_layout) =
path_to_expr_help(env, cond_symbol, path, *cond_layout);
path_to_expr_help(env, layout_interner, cond_symbol, path, *cond_layout);
match test {
Test::IsCtor { tag_id, union, .. } => {
@ -1614,6 +1619,7 @@ type Tests<'a> = std::vec::Vec<(
fn stores_and_condition<'a>(
env: &mut Env<'a, '_>,
layout_interner: &LayoutInterner<'a>,
cond_symbol: Symbol,
cond_layout: &Layout<'a>,
test_chain: Vec<(Vec<PathInstruction>, Test<'a>)>,
@ -1624,6 +1630,7 @@ fn stores_and_condition<'a>(
for (path, test) in test_chain {
tests.push(test_to_comparison(
env,
layout_interner,
cond_symbol,
cond_layout,
&path,
@ -1942,7 +1949,13 @@ fn decide_to_branching<'a>(
let chain_branch_info =
ConstructorKnown::from_test_chain(cond_symbol, &cond_layout, &test_chain);
let tests = stores_and_condition(env, cond_symbol, &cond_layout, test_chain);
let tests = stores_and_condition(
env,
&layout_cache.interner,
cond_symbol,
&cond_layout,
test_chain,
);
let number_of_tests = tests.len() as i64;
@ -1990,7 +2003,7 @@ fn decide_to_branching<'a>(
// switch on the tag discriminant (currently an i64 value)
// NOTE the tag discriminant is not actually loaded, `cond` can point to a tag
let (inner_cond_symbol, cond_stores_vec, inner_cond_layout) =
path_to_expr_help(env, cond_symbol, &path, cond_layout);
path_to_expr_help(env, &layout_cache.interner, cond_symbol, &path, cond_layout);
let default_branch = decide_to_branching(
env,

12
crates/compiler/mono/src/ir.rs
View file

@ -4631,19 +4631,23 @@ pub fn with_hole<'a>(
match opt_elem_layout {
Ok(elem_layout) => {
let expr = Expr::EmptyArray;
// TODO don't alloc once elem_layout is interned
let elem_layout = layout_cache.put_in(env.arena.alloc(elem_layout));
Stmt::Let(
assigned,
expr,
Layout::Builtin(Builtin::List(env.arena.alloc(elem_layout))),
Layout::Builtin(Builtin::List(elem_layout)),
hole,
)
}
Err(LayoutProblem::UnresolvedTypeVar(_)) => {
let expr = Expr::EmptyArray;
// TODO don't alloc once elem_layout is interned
let elem_layout = layout_cache.put_in(env.arena.alloc(Layout::VOID));
Stmt::Let(
assigned,
expr,
Layout::Builtin(Builtin::List(&Layout::VOID)),
Layout::Builtin(Builtin::List(elem_layout)),
hole,
)
}
@ -4688,10 +4692,12 @@ pub fn with_hole<'a>(
elems: elements.into_bump_slice(),
};
let elem_layout = layout_cache.put_in(env.arena.alloc(elem_layout));
let stmt = Stmt::Let(
assigned,
expr,
Layout::Builtin(Builtin::List(env.arena.alloc(elem_layout))),
Layout::Builtin(Builtin::List(elem_layout)),
hole,
);

17
crates/compiler/mono/src/layout.rs
View file

@ -2012,7 +2012,7 @@ pub enum Builtin<'a> {
Bool,
Decimal,
Str,
List(&'a Layout<'a>),
List(InLayout<'a>),
}
pub struct Env<'a, 'b> {
@ -2875,6 +2875,7 @@ impl<'a> Builtin<'a> {
Str => alloc.text("Str"),
List(layout) => {
let layout = interner.get(layout);
alloc
.text("List ")
.append(layout.to_doc(alloc, interner, Parens::InTypeParam))
@ -2890,7 +2891,10 @@ impl<'a> Builtin<'a> {
let allocation = match self {
Builtin::Str => ptr_width,
Builtin::List(e) => e.alignment_bytes(interner, target_info).max(ptr_width),
Builtin::List(e) => {
let e = interner.get(*e);
e.alignment_bytes(interner, target_info).max(ptr_width)
}
// The following are usually not heap-allocated, but they might be when inside a Box.
Builtin::Int(int_width) => int_width.alignment_bytes(target_info).max(ptr_width),
Builtin::Float(float_width) => float_width.alignment_bytes(target_info).max(ptr_width),
@ -4140,12 +4144,9 @@ pub(crate) fn list_layout_from_elem<'a>(
cached!(Layout::from_var(env, element_var), criteria)
};
Cacheable(
Ok(Layout::Builtin(Builtin::List(
env.arena.alloc(element_layout),
))),
criteria,
)
let element_layout = env.cache.put_in(env.arena.alloc(element_layout));
Cacheable(Ok(Layout::Builtin(Builtin::List(element_layout))), criteria)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]

5
crates/glue/src/types.rs
View file

@ -1097,6 +1097,7 @@ fn add_builtin_type<'a>(
let args = env.subs.get_subs_slice(*args);
debug_assert_eq!(args.len(), 1);
let elem_layout = env.layout_cache.get_in(elem_layout);
let elem_id = add_type_help(env, *elem_layout, args[0], opt_name, types);
let list_id = types.add_anonymous(
&env.layout_cache.interner,
@ -1113,7 +1114,7 @@ fn add_builtin_type<'a>(
Alias(Symbol::DICT_DICT, _alias_variables, alias_var, AliasKind::Opaque),
) => {
match (
elem_layout,
*env.layout_cache.get_in(elem_layout),
env.subs.get_content_without_compacting(*alias_var),
) {
(
@ -1163,7 +1164,7 @@ fn add_builtin_type<'a>(
Alias(Symbol::SET_SET, _alias_vars, alias_var, AliasKind::Opaque),
) => {
match (
elem_layout,
env.layout_cache.get_in(elem_layout),
env.subs.get_content_without_compacting(*alias_var),
) {
(

13
crates/repl_eval/src/eval.rs
View file

@ -11,8 +11,8 @@ use roc_module::ident::TagName;
use roc_module::symbol::{Interns, ModuleId, Symbol};
use roc_mono::ir::ProcLayout;
use roc_mono::layout::{
self, union_sorted_tags_pub, Builtin, Layout, LayoutCache, LayoutInterner, UnionLayout,
UnionVariant, WrappedVariant,
self, union_sorted_tags_pub, Builtin, InLayout, Layout, LayoutCache, LayoutInterner,
UnionLayout, UnionVariant, WrappedVariant,
};
use roc_parse::ast::{AssignedField, Collection, Expr, Pattern, StrLiteral};
use roc_region::all::{Loc, Region};
@ -409,7 +409,7 @@ fn jit_to_ast_help<'a, A: ReplApp<'a>>(
mem,
addr,
len,
elem_layout,
*elem_layout,
env.subs.get_content_without_compacting(raw_var),
)
},
@ -597,7 +597,7 @@ fn addr_to_ast<'a, M: ReplAppMemory>(
let len = mem.deref_usize(addr + env.target_info.ptr_width() as usize);
let _cap = mem.deref_usize(addr + 2 * env.target_info.ptr_width() as usize);
list_to_ast(env, mem, elem_addr, len, elem_layout, raw_content)
list_to_ast(env, mem, elem_addr, len, *elem_layout, raw_content)
}
(_, Layout::Builtin(Builtin::Str)) => {
let string = mem.deref_str(addr);
@ -892,7 +892,7 @@ fn list_to_ast<'a, M: ReplAppMemory>(
mem: &'a M,
addr: usize,
len: usize,
elem_layout: &Layout<'a>,
elem_layout: InLayout<'a>,
content: &Content,
) -> Expr<'a> {
let elem_var = match content {
@ -912,6 +912,7 @@ fn list_to_ast<'a, M: ReplAppMemory>(
let arena = env.arena;
let mut output = Vec::with_capacity_in(len, arena);
let elem_layout = *env.layout_cache.get_in(elem_layout);
let elem_size = elem_layout.stack_size(&env.layout_cache.interner, env.target_info) as usize;
for index in 0..len {
@ -923,7 +924,7 @@ fn list_to_ast<'a, M: ReplAppMemory>(
env,
mem,
elem_addr,
elem_layout,
&elem_layout,
WhenRecursive::Unreachable,
elem_content,
);