Merge remote-tracking branch 'origin/trunk' into tag-union-imitate-rust

compiler/gen_llvm/src/llvm/build.rs

@@ -9,15 +9,16 @@ 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_any, list_append, list_concat,
-    list_contains, list_drop, list_drop_at, 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_swap,
+    list_contains, list_drop, 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_swap, list_take_first,
+    list_take_last,
 };
 use crate::llvm::build_str::{
     empty_str, str_concat, str_count_graphemes, str_ends_with, str_from_float, str_from_int,
     str_from_utf8, str_from_utf8_range, str_join_with, str_number_of_bytes, str_repeat, str_split,
-    str_starts_with, str_starts_with_code_point, str_to_utf8, str_trim,
+    str_starts_with, str_starts_with_code_point, str_to_utf8, str_trim, str_trim_left,
 };
 use crate::llvm::compare::{generic_eq, generic_neq};
 use crate::llvm::convert::{
@@ -5174,6 +5175,38 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>(
                 _ => unreachable!("invalid list layout"),
             }
         }
+        ListFindUnsafe { xs } => {
+            let (list, list_layout) = load_symbol_and_layout(scope, &xs);
+
+            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(
+                        env,
+                        layout_ids,
+                        function,
+                        closure,
+                        closure_layout,
+                        function_owns_closure_data,
+                        argument_layouts,
+                        Layout::Builtin(Builtin::Int1),
+                    );
+                    list_find_unsafe(env, layout_ids, roc_function_call, list, element_layout)
+                }
+                _ => unreachable!("invalid list layout"),
+            }
+        }
         DictWalk { xs, state } => {
             let (dict, dict_layout) = load_symbol_and_layout(scope, &xs);
             let (default, default_layout) = load_symbol_and_layout(scope, &state);
@@ -5342,6 +5375,12 @@ fn run_low_level<'a, 'ctx, 'env>(
 
             str_trim(env, scope, args[0])
         }
+        StrTrimLeft => {
+            // Str.trim : Str -> Str
+            debug_assert_eq!(args.len(), 1);
+
+            str_trim_left(env, scope, args[0])
+        }
         ListLen => {
             // List.len : List * -> Int
             debug_assert_eq!(args.len(), 1);
@@ -5440,6 +5479,47 @@ fn run_low_level<'a, 'ctx, 'env>(
                 _ => unreachable!("Invalid layout {:?} in List.swap", list_layout),
             }
         }
+        ListTakeFirst => {
+            // List.takeFirst : List elem, Nat -> List elem
+            debug_assert_eq!(args.len(), 2);
+
+            let (list, list_layout) = load_symbol_and_layout(scope, &args[0]);
+            let original_wrapper = list.into_struct_value();
+
+            let count = load_symbol(scope, &args[1]);
+
+            match list_layout {
+                Layout::Builtin(Builtin::EmptyList) => empty_list(env),
+                Layout::Builtin(Builtin::List(element_layout)) => list_take_first(
+                    env,
+                    original_wrapper,
+                    count.into_int_value(),
+                    element_layout,
+                ),
+                _ => unreachable!("Invalid layout {:?} in List.takeFirst", list_layout),
+            }
+        }
+        ListTakeLast => {
+            // List.takeLast : List elem, Nat -> List elem
+            debug_assert_eq!(args.len(), 2);
+
+            let (list, list_layout) = load_symbol_and_layout(scope, &args[0]);
+            let original_wrapper = list.into_struct_value();
+
+            let count = load_symbol(scope, &args[1]);
+
+            match list_layout {
+                Layout::Builtin(Builtin::EmptyList) => empty_list(env),
+                Layout::Builtin(Builtin::List(element_layout)) => list_take_last(
+                    env,
+                    layout_ids,
+                    original_wrapper,
+                    count.into_int_value(),
+                    element_layout,
+                ),
+                _ => unreachable!("Invalid layout {:?} in List.takeLast", list_layout),
+            }
+        }
         ListDrop => {
             // List.drop : List elem, Nat -> List elem
             debug_assert_eq!(args.len(), 2);
@@ -6025,7 +6105,9 @@ fn run_low_level<'a, 'ctx, 'env>(
 
         ListMap | ListMap2 | ListMap3 | ListMap4 | ListMapWithIndex | ListKeepIf | ListWalk
         | ListWalkUntil | ListWalkBackwards | ListKeepOks | ListKeepErrs | ListSortWith
-        | ListAny | DictWalk => unreachable!("these are higher order, and are handled elsewhere"),
+        | ListAny | ListFindUnsafe | DictWalk => {
+            unreachable!("these are higher order, and are handled elsewhere")
+        }
     }
 }
 

compiler/gen_llvm/src/llvm/build_list.rs

@@ -300,6 +300,47 @@ pub fn list_swap<'a, 'ctx, 'env>(
     )
 }
 
+/// List.takeFirst : List elem, Nat -> List elem
+pub fn list_take_first<'a, 'ctx, 'env>(
+    env: &Env<'a, 'ctx, 'env>,
+    original_wrapper: StructValue<'ctx>,
+    count: IntValue<'ctx>,
+    element_layout: &Layout<'a>,
+) -> BasicValueEnum<'ctx> {
+    call_bitcode_fn_returns_list(
+        env,
+        &[
+            pass_list_cc(env, original_wrapper.into()),
+            env.alignment_intvalue(element_layout),
+            layout_width(env, element_layout),
+            count.into(),
+        ],
+        bitcode::LIST_TAKE_FIRST,
+    )
+}
+
+/// List.takeLast : List elem, Nat -> List elem
+pub fn list_take_last<'a, 'ctx, 'env>(
+    env: &Env<'a, 'ctx, 'env>,
+    layout_ids: &mut LayoutIds<'a>,
+    original_wrapper: StructValue<'ctx>,
+    count: IntValue<'ctx>,
+    element_layout: &Layout<'a>,
+) -> BasicValueEnum<'ctx> {
+    let dec_element_fn = build_dec_wrapper(env, layout_ids, element_layout);
+    call_bitcode_fn_returns_list(
+        env,
+        &[
+            pass_list_cc(env, original_wrapper.into()),
+            env.alignment_intvalue(element_layout),
+            layout_width(env, element_layout),
+            count.into(),
+            dec_element_fn.as_global_value().as_pointer_value().into(),
+        ],
+        bitcode::LIST_TAKE_LAST,
+    )
+}
+
 /// List.drop : List elem, Nat -> List elem
 pub fn list_drop<'a, 'ctx, 'env>(
     env: &Env<'a, 'ctx, 'env>,
@@ -920,6 +961,123 @@ pub fn list_any<'a, 'ctx, 'env>(
     )
 }
 
+/// List.findUnsafe : List elem, (elem -> Bool) -> { value: elem, found: bool }
+pub fn list_find_unsafe<'a, 'ctx, 'env>(
+    env: &Env<'a, 'ctx, 'env>,
+    layout_ids: &mut LayoutIds<'a>,
+    roc_function_call: RocFunctionCall<'ctx>,
+    list: BasicValueEnum<'ctx>,
+    element_layout: &Layout<'a>,
+) -> BasicValueEnum<'ctx> {
+    let inc_element_fn = build_inc_wrapper(env, layout_ids, element_layout);
+    let dec_element_fn = build_dec_wrapper(env, layout_ids, element_layout);
+
+    // { value: *const u8, found: bool }
+    let result = call_bitcode_fn(
+        env,
+        &[
+            pass_list_cc(env, list),
+            roc_function_call.caller.into(),
+            pass_as_opaque(env, roc_function_call.data),
+            roc_function_call.inc_n_data.into(),
+            roc_function_call.data_is_owned.into(),
+            env.alignment_intvalue(element_layout),
+            layout_width(env, element_layout),
+            inc_element_fn.as_global_value().as_pointer_value().into(),
+            dec_element_fn.as_global_value().as_pointer_value().into(),
+        ],
+        bitcode::LIST_FIND_UNSAFE,
+    )
+    .into_struct_value();
+
+    // We promised the caller we'd give them back a struct containing the element
+    // loaded on the stack, so we do that now. The element can't be loaded directly
+    // in the Zig definition called above, because we don't know the size of the
+    // element until user compile time, which is later than the compile time of bitcode defs.
+
+    let value_u8_ptr = env
+        .builder
+        .build_extract_value(result, 0, "get_value_ptr")
+        .unwrap()
+        .into_pointer_value();
+
+    let found = env
+        .builder
+        .build_extract_value(result, 1, "get_found")
+        .unwrap()
+        .into_int_value();
+
+    let start_block = env.builder.get_insert_block().unwrap();
+    let parent = start_block.get_parent().unwrap();
+
+    let if_not_null = env.context.append_basic_block(parent, "if_not_null");
+    let done_block = env.context.append_basic_block(parent, "done");
+
+    let value_bt = basic_type_from_layout(env, element_layout);
+    let default = value_bt.const_zero();
+
+    env.builder
+        .build_conditional_branch(found, if_not_null, done_block);
+
+    env.builder.position_at_end(if_not_null);
+    let value_ptr = env
+        .builder
+        .build_bitcast(
+            value_u8_ptr,
+            value_bt.ptr_type(AddressSpace::Generic),
+            "from_opaque",
+        )
+        .into_pointer_value();
+    let loaded = env.builder.build_load(value_ptr, "load_value");
+    env.builder.build_unconditional_branch(done_block);
+
+    env.builder.position_at_end(done_block);
+    let result_phi = env.builder.build_phi(value_bt, "result");
+
+    result_phi.add_incoming(&[(&default, start_block), (&loaded, if_not_null)]);
+
+    let value = result_phi.as_basic_value();
+
+    let result = env
+        .context
+        .struct_type(&[value_bt, env.context.bool_type().into()], false)
+        .const_zero();
+
+    let result = env
+        .builder
+        .build_insert_value(result, value, 0, "insert_value")
+        .unwrap();
+
+    env.builder
+        .build_insert_value(result, found, 1, "insert_found")
+        .unwrap()
+        .into_struct_value()
+        .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,

compiler/gen_llvm/src/llvm/build_str.rs

@@ -259,6 +259,16 @@ pub fn str_trim<'a, 'ctx, 'env>(
     call_bitcode_fn(env, &[str_i128.into()], bitcode::STR_TRIM)
 }
 
+/// Str.trimLeft : Str -> Str
+pub fn str_trim_left<'a, 'ctx, 'env>(
+    env: &Env<'a, 'ctx, 'env>,
+    scope: &Scope<'a, 'ctx>,
+    str_symbol: Symbol,
+) -> BasicValueEnum<'ctx> {
+    let str_i128 = str_symbol_to_c_abi(env, scope, str_symbol);
+    call_bitcode_fn(env, &[str_i128.into()], bitcode::STR_TRIM_LEFT)
+}
+
 /// Str.fromInt : Int -> Str
 pub fn str_from_int<'a, 'ctx, 'env>(
     env: &Env<'a, 'ctx, 'env>,