language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-29 06:44:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

remove empty layout types (list,str,dict,set)

Browse source
This commit is contained in:
Folkert 2021-11-27 14:05:16 +01:00
parent 8d668514e4
commit a1fd34feef
11 changed files with 94 additions and 296 deletions
Download patch file Download diff file Expand all files Collapse all files

91
compiler/gen_llvm/src/llvm/build.rs
View file

@ -8,11 +8,11 @@ use crate::llvm::build_dict::{
};
use crate::llvm::build_hash::generic_hash;
use crate::llvm::build_list::{
self, allocate_list, empty_list, empty_polymorphic_list, list_all, list_any, list_append,
list_concat, list_contains, list_drop_at, list_find_trivial_not_found, list_find_unsafe,
list_get_unsafe, list_join, list_keep_errs, list_keep_if, list_keep_oks, list_len, list_map,
list_map2, list_map3, list_map4, list_map_with_index, list_prepend, list_range, list_repeat,
list_reverse, list_set, list_single, list_sort_with, list_sublist, list_swap,
self, allocate_list, empty_polymorphic_list, list_all, list_any, list_append, list_concat,
list_contains, list_drop_at, list_find_unsafe, list_get_unsafe, list_join, list_keep_errs,
list_keep_if, list_keep_oks, list_len, list_map, list_map2, list_map3, list_map4,
list_map_with_index, list_prepend, list_range, list_repeat, list_reverse, list_set,
list_single, list_sort_with, list_sublist, list_swap,
};
use crate::llvm::build_str::{
empty_str, str_concat, str_count_graphemes, str_ends_with, str_from_float, str_from_int,
@ -4726,7 +4726,6 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>(
let (function, closure, closure_layout) = function_details!();
match list_layout {
Layout::Builtin(Builtin::EmptyList) => default,
Layout::Builtin(Builtin::List(element_layout)) => {
let argument_layouts = &[*default_layout, **element_layout];
@ -4765,7 +4764,6 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>(
let (function, closure, closure_layout) = function_details!();
match (list_layout, return_layout) {
(Layout::Builtin(Builtin::EmptyList), _) => empty_list(env),
(
Layout::Builtin(Builtin::List(element_layout)),
Layout::Builtin(Builtin::List(result_layout)),
@ -4824,8 +4822,6 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>(
result_layout,
)
}
(Layout::Builtin(Builtin::EmptyList), _, _)
| (_, Layout::Builtin(Builtin::EmptyList), _) => empty_list(env),
_ => unreachable!("invalid list layout"),
}
}
@ -4870,9 +4866,6 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>(
result_layout,
)
}
(Layout::Builtin(Builtin::EmptyList), _, _, _)
| (_, Layout::Builtin(Builtin::EmptyList), _, _)
| (_, _, Layout::Builtin(Builtin::EmptyList), _) => empty_list(env),
_ => unreachable!("invalid list layout"),
}
}
@ -4931,10 +4924,6 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>(
result_layout,
)
}
(Layout::Builtin(Builtin::EmptyList), _, _, _, _)
| (_, Layout::Builtin(Builtin::EmptyList), _, _, _)
| (_, _, Layout::Builtin(Builtin::EmptyList), _, _)
| (_, _, _, Layout::Builtin(Builtin::EmptyList), _) => empty_list(env),
_ => unreachable!("invalid list layout"),
}
}
@ -4945,7 +4934,6 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>(
let (function, closure, closure_layout) = function_details!();
match (list_layout, return_layout) {
(Layout::Builtin(Builtin::EmptyList), _) => empty_list(env),
(
Layout::Builtin(Builtin::List(element_layout)),
Layout::Builtin(Builtin::List(result_layout)),
@ -4975,7 +4963,6 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>(
let (function, closure, closure_layout) = function_details!();
match list_layout {
Layout::Builtin(Builtin::EmptyList) => empty_list(env),
Layout::Builtin(Builtin::List(element_layout)) => {
let argument_layouts = &[**element_layout];
@ -5002,8 +4989,6 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>(
let (function, closure, closure_layout) = function_details!();
match (list_layout, return_layout) {
(_, Layout::Builtin(Builtin::EmptyList))
| (Layout::Builtin(Builtin::EmptyList), _) => empty_list(env),
(
Layout::Builtin(Builtin::List(before_layout)),
Layout::Builtin(Builtin::List(after_layout)),
@ -5043,8 +5028,6 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>(
let (function, closure, closure_layout) = function_details!();
match (list_layout, return_layout) {
(_, Layout::Builtin(Builtin::EmptyList))
| (Layout::Builtin(Builtin::EmptyList), _) => empty_list(env),
(
Layout::Builtin(Builtin::List(before_layout)),
Layout::Builtin(Builtin::List(after_layout)),
@ -5093,7 +5076,6 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>(
let (function, closure, closure_layout) = function_details!();
match list_layout {
Layout::Builtin(Builtin::EmptyList) => empty_list(env),
Layout::Builtin(Builtin::List(element_layout)) => {
use crate::llvm::bitcode::build_compare_wrapper;
@ -5131,7 +5113,6 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>(
let (function, closure, closure_layout) = function_details!();
match list_layout {
Layout::Builtin(Builtin::EmptyList) => env.context.bool_type().const_zero().into(),
Layout::Builtin(Builtin::List(element_layout)) => {
let argument_layouts = &[**element_layout];
@ -5156,9 +5137,6 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>(
let (function, closure, closure_layout) = function_details!();
match list_layout {
Layout::Builtin(Builtin::EmptyList) => {
env.context.bool_type().const_int(1, false).into()
}
Layout::Builtin(Builtin::List(element_layout)) => {
let argument_layouts = &[**element_layout];
@ -5184,15 +5162,6 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>(
let (function, closure, closure_layout) = function_details!();
match list_layout {
Layout::Builtin(Builtin::EmptyList) => {
// Returns { found: False, elem: \empty }, where the `elem` field is zero-sized.
// NB: currently we never hit this case, since the only caller of this
// lowlevel, namely List.find, will fail during monomorphization when there is no
// concrete list element type. This is because List.find returns a
// `Result elem [ NotFound ]*`, and we can't figure out the size of that if
// `elem` is not concrete.
list_find_trivial_not_found(env)
}
Layout::Builtin(Builtin::List(element_layout)) => {
let argument_layouts = &[**element_layout];
let roc_function_call = roc_function_call(
@ -5217,10 +5186,6 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>(
let (function, closure, closure_layout) = function_details!();
match dict_layout {
Layout::Builtin(Builtin::EmptyDict) => {
// no elements, so `key` is not in here
panic!("key type unknown")
}
Layout::Builtin(Builtin::Dict(key_layout, value_layout)) => {
let argument_layouts = &[*default_layout, **key_layout, **value_layout];
@ -5484,7 +5449,6 @@ fn run_low_level<'a, 'ctx, 'env>(
let index_2 = load_symbol(scope, &args[2]);
match list_layout {
Layout::Builtin(Builtin::EmptyList) => empty_list(env),
Layout::Builtin(Builtin::List(element_layout)) => list_swap(
env,
original_wrapper,
@ -5510,7 +5474,6 @@ fn run_low_level<'a, 'ctx, 'env>(
let len = load_symbol(scope, &args[2]);
match list_layout {
Layout::Builtin(Builtin::EmptyList) => empty_list(env),
Layout::Builtin(Builtin::List(element_layout)) => list_sublist(
env,
layout_ids,
@ -5532,7 +5495,6 @@ fn run_low_level<'a, 'ctx, 'env>(
let count = load_symbol(scope, &args[1]);
match list_layout {
Layout::Builtin(Builtin::EmptyList) => empty_list(env),
Layout::Builtin(Builtin::List(element_layout)) => list_drop_at(
env,
layout_ids,
@ -5846,10 +5808,6 @@ fn run_low_level<'a, 'ctx, 'env>(
let (element, _) = load_symbol_and_layout(scope, &args[2]);
match list_layout {
Layout::Builtin(Builtin::EmptyList) => {
// no elements, so nothing to remove
empty_list(env)
}
Layout::Builtin(Builtin::List(element_layout)) => list_set(
env,
layout_ids,
@ -5894,10 +5852,6 @@ fn run_low_level<'a, 'ctx, 'env>(
let (key, key_layout) = load_symbol_and_layout(scope, &args[1]);
match dict_layout {
Layout::Builtin(Builtin::EmptyDict) => {
// no elements, so nothing to remove
dict
}
Layout::Builtin(Builtin::Dict(_, value_layout)) => {
dict_remove(env, layout_ids, dict, key, key_layout, value_layout)
}
@ -5911,10 +5865,6 @@ fn run_low_level<'a, 'ctx, 'env>(
let (key, key_layout) = load_symbol_and_layout(scope, &args[1]);
match dict_layout {
Layout::Builtin(Builtin::EmptyDict) => {
// no elements, so `key` is not in here
env.context.bool_type().const_zero().into()
}
Layout::Builtin(Builtin::Dict(_, value_layout)) => {
dict_contains(env, layout_ids, dict, key, key_layout, value_layout)
}
@ -5928,10 +5878,6 @@ fn run_low_level<'a, 'ctx, 'env>(
let (key, key_layout) = load_symbol_and_layout(scope, &args[1]);
match dict_layout {
Layout::Builtin(Builtin::EmptyDict) => {
unreachable!("we can't make up a layout for the return value");
// in other words, make sure to check whether the dict is empty first
}
Layout::Builtin(Builtin::Dict(_, value_layout)) => {
dict_get(env, layout_ids, dict, key, key_layout, value_layout)
}
@ -5944,10 +5890,6 @@ fn run_low_level<'a, 'ctx, 'env>(
let (dict, dict_layout) = load_symbol_and_layout(scope, &args[0]);
match dict_layout {
Layout::Builtin(Builtin::EmptyDict) => {
// no elements, so `key` is not in here
empty_list(env)
}
Layout::Builtin(Builtin::Dict(key_layout, value_layout)) => {
dict_keys(env, layout_ids, dict, key_layout, value_layout)
}
@ -5960,10 +5902,6 @@ fn run_low_level<'a, 'ctx, 'env>(
let (dict, dict_layout) = load_symbol_and_layout(scope, &args[0]);
match dict_layout {
Layout::Builtin(Builtin::EmptyDict) => {
// no elements, so `key` is not in here
empty_list(env)
}
Layout::Builtin(Builtin::Dict(key_layout, value_layout)) => {
dict_values(env, layout_ids, dict, key_layout, value_layout)
}
@ -5977,10 +5915,6 @@ fn run_low_level<'a, 'ctx, 'env>(
let (dict2, _) = load_symbol_and_layout(scope, &args[1]);
match dict_layout {
Layout::Builtin(Builtin::EmptyDict) => {
// no elements, so `key` is not in here
panic!("key type unknown")
}
Layout::Builtin(Builtin::Dict(key_layout, value_layout)) => {
dict_union(env, layout_ids, dict1, dict2, key_layout, value_layout)
}
@ -5994,10 +5928,6 @@ fn run_low_level<'a, 'ctx, 'env>(
let (dict2, _) = load_symbol_and_layout(scope, &args[1]);
match dict_layout {
Layout::Builtin(Builtin::EmptyDict) => {
// no elements, so `key` is not in here
panic!("key type unknown")
}
Layout::Builtin(Builtin::Dict(key_layout, value_layout)) => {
dict_difference(env, layout_ids, dict1, dict2, key_layout, value_layout)
}
@ -6011,10 +5941,6 @@ fn run_low_level<'a, 'ctx, 'env>(
let (dict2, _) = load_symbol_and_layout(scope, &args[1]);
match dict_layout {
Layout::Builtin(Builtin::EmptyDict) => {
// no elements, so `key` is not in here
panic!("key type unknown")
}
Layout::Builtin(Builtin::Dict(key_layout, value_layout)) => {
dict_intersection(env, layout_ids, dict1, dict2, key_layout, value_layout)
}
@ -6027,7 +5953,6 @@ fn run_low_level<'a, 'ctx, 'env>(
let (list, list_layout) = load_symbol_and_layout(scope, &args[0]);
match list_layout {
Layout::Builtin(Builtin::EmptyList) => dict_empty(env),
Layout::Builtin(Builtin::List(key_layout)) => {
set_from_list(env, layout_ids, list, key_layout)
}
@ -6123,10 +6048,8 @@ fn to_cc_type_builtin<'a, 'ctx, 'env>(
Builtin::Int(_) | Builtin::Float(_) | Builtin::Bool | Builtin::Decimal => {
basic_type_from_builtin(env, builtin)
}
Builtin::Str | Builtin::EmptyStr | Builtin::List(_) | Builtin::EmptyList => {
env.str_list_c_abi().into()
}
Builtin::Dict(_, _) | Builtin::Set(_) | Builtin::EmptyDict | Builtin::EmptySet => {
Builtin::Str | Builtin::List(_) => env.str_list_c_abi().into(),
Builtin::Dict(_, _) | Builtin::Set(_) => {
// TODO verify this is what actually happens
basic_type_from_builtin(env, builtin)
}

1
compiler/gen_llvm/src/llvm/build_dict.rs
View file

@ -64,7 +64,6 @@ pub fn dict_len<'a, 'ctx, 'env>(
.build_int_cast(length_i64.into_int_value(), env.ptr_int(), "to_usize")
.into()
}
Layout::Builtin(Builtin::EmptyDict) => env.ptr_int().const_zero().into(),
_ => unreachable!("Invalid layout given to Dict.len : {:?}", dict_layout),
}
}

7
compiler/gen_llvm/src/llvm/build_hash.rs
View file

@ -136,9 +136,6 @@ fn hash_builtin<'a, 'ctx, 'env>(
)
.into_int_value()
}
Builtin::EmptyStr | Builtin::EmptyDict | Builtin::EmptyList | Builtin::EmptySet => {
hash_empty_collection(seed)
}
Builtin::Dict(_, _) => {
todo!("Implement hash for Dict")
@ -793,10 +790,6 @@ fn hash_null(seed: IntValue<'_>) -> IntValue<'_> {
seed
}
fn hash_empty_collection(seed: IntValue<'_>) -> IntValue<'_> {
seed
}
fn hash_ptr_to_struct<'a, 'ctx, 'env>(
env: &Env<'a, 'ctx, 'env>,
layout_ids: &mut LayoutIds<'a>,

48
compiler/gen_llvm/src/llvm/build_list.rs
View file

@ -150,12 +150,6 @@ pub fn list_join<'a, 'ctx, 'env>(
outer_list_layout: &Layout<'a>,
) -> BasicValueEnum<'ctx> {
match outer_list_layout {
Layout::Builtin(Builtin::EmptyList)
| Layout::Builtin(Builtin::List(Layout::Builtin(Builtin::EmptyList))) => {
// If the input list is empty, or if it is a list of empty lists
// then simply return an empty list
empty_list(env)
}
Layout::Builtin(Builtin::List(Layout::Builtin(Builtin::List(element_layout)))) => {
call_bitcode_fn_returns_list(
env,
@ -181,11 +175,6 @@ pub fn list_reverse<'a, 'ctx, 'env>(
update_mode: UpdateMode,
) -> BasicValueEnum<'ctx> {
let element_layout = match *list_layout {
Layout::Builtin(Builtin::EmptyList) => {
// this pointer will never actually be dereferenced
Layout::i64()
}
Layout::Builtin(Builtin::List(elem_layout)) => *elem_layout,
_ => unreachable!("Invalid layout {:?} in List.reverse", list_layout),
@ -881,11 +870,6 @@ pub fn list_concat<'a, 'ctx, 'env>(
list_layout: &Layout<'a>,
) -> BasicValueEnum<'ctx> {
match list_layout {
Layout::Builtin(Builtin::EmptyList) => {
// If the input list is empty, or if it is a list of empty lists
// then simply return an empty list
empty_list(env)
}
Layout::Builtin(Builtin::List(elem_layout)) => call_bitcode_fn_returns_list(
env,
&[
@ -1038,29 +1022,6 @@ pub fn list_find_unsafe<'a, 'ctx, 'env>(
.into()
}
/// Returns { value: \empty, found: False }, representing that no element was found in a call
/// to List.find when the layout of the element is also unknown.
pub fn list_find_trivial_not_found<'a, 'ctx, 'env>(
env: &Env<'a, 'ctx, 'env>,
) -> BasicValueEnum<'ctx> {
let empty_type = env.context.custom_width_int_type(0);
let result = env
.context
.struct_type(&[empty_type.into(), env.context.bool_type().into()], false)
.const_zero();
env.builder
.build_insert_value(
result,
env.context.bool_type().const_zero(),
1,
"insert_found",
)
.unwrap()
.into_struct_value()
.into()
}
pub fn decrementing_elem_loop<'ctx, LoopFn>(
builder: &Builder<'ctx>,
ctx: &'ctx Context,
@ -1269,15 +1230,6 @@ pub fn empty_polymorphic_list<'a, 'ctx, 'env>(env: &Env<'a, 'ctx, 'env>) -> Basi
BasicValueEnum::StructValue(struct_type.const_zero())
}
// TODO investigate: does this cause problems when the layout is known? this value is now not refcounted!
pub fn empty_list<'a, 'ctx, 'env>(env: &Env<'a, 'ctx, 'env>) -> BasicValueEnum<'ctx> {
let struct_type = super::convert::zig_list_type(env);
// The pointer should be null (aka zero) and the length should be zero,
// so the whole struct should be a const_zero
BasicValueEnum::StructValue(struct_type.const_zero())
}
pub fn load_list<'ctx>(
builder: &Builder<'ctx>,
wrapper_struct: StructValue<'ctx>,

12
compiler/gen_llvm/src/llvm/compare.rs
View file

@ -135,12 +135,6 @@ fn build_eq_builtin<'a, 'ctx, 'env>(
),
Builtin::Set(_elem) => todo!("equality on Set"),
Builtin::Dict(_key, _value) => todo!("equality on Dict"),
// empty structures are always equal to themselves
Builtin::EmptyStr => env.context.bool_type().const_int(1, false).into(),
Builtin::EmptyList => env.context.bool_type().const_int(1, false).into(),
Builtin::EmptyDict => env.context.bool_type().const_int(1, false).into(),
Builtin::EmptySet => env.context.bool_type().const_int(1, false).into(),
}
}
@ -310,12 +304,6 @@ fn build_neq_builtin<'a, 'ctx, 'env>(
}
Builtin::Set(_elem) => todo!("equality on Set"),
Builtin::Dict(_key, _value) => todo!("equality on Dict"),
// empty structures are always equal to themselves
Builtin::EmptyStr => env.context.bool_type().const_int(0, false).into(),
Builtin::EmptyList => env.context.bool_type().const_int(0, false).into(),
Builtin::EmptyDict => env.context.bool_type().const_int(0, false).into(),
Builtin::EmptySet => env.context.bool_type().const_int(0, false).into(),
}
}

8
compiler/gen_llvm/src/llvm/convert.rs
View file

@ -150,10 +150,10 @@ pub fn basic_type_from_builtin<'a, 'ctx, 'env>(
Float(float_width) => float_type_from_float_width(env, *float_width).as_basic_type_enum(),
Bool => context.bool_type().as_basic_type_enum(),
Decimal => context.i128_type().as_basic_type_enum(),
Dict(_, _) | EmptyDict => zig_dict_type(env).into(),
Set(_) | EmptySet => zig_dict_type(env).into(),
List(_) | EmptyList => zig_list_type(env).into(),
Str | EmptyStr => zig_str_type(env).into(),
Dict(_, _) => zig_dict_type(env).into(),
Set(_) => zig_dict_type(env).into(),
List(_) => zig_list_type(env).into(),
Str => zig_str_type(env).into(),
}
}