Set up many basic details for Str.split- no implementation yet

compiler/gen/src/llvm/build.rs

@@ -4,7 +4,7 @@ use crate::llvm::build_list::{
     list_join, list_keep_if, list_len, list_map, list_prepend, list_repeat, list_reverse, list_set,
     list_single, list_walk_right,
 };
-use crate::llvm::build_str::{str_concat, str_len, CHAR_LAYOUT};
+use crate::llvm::build_str::{str_concat, str_len, str_split, CHAR_LAYOUT};
 use crate::llvm::compare::{build_eq, build_neq};
 use crate::llvm::convert::{
     basic_type_from_layout, block_of_memory, collection, get_fn_type, get_ptr_type, ptr_int,
@@ -1809,6 +1809,12 @@ fn run_low_level<'a, 'ctx, 'env>(
 
             str_concat(env, inplace, scope, parent, args[0], args[1])
         }
+        StrSplit => {
+            // Str.split : Str, Str -> List Str
+            debug_assert_eq!(args.len(), 2);
+
+            str_split(env, scope, parent, args[0], args[1])
+        }
         StrIsEmpty => {
             // Str.isEmpty : Str -> Str
             debug_assert_eq!(args.len(), 1);

compiler/gen/src/llvm/build_str.rs

@@ -12,6 +12,43 @@ use roc_mono::layout::{Builtin, Layout};
 
 pub static CHAR_LAYOUT: Layout = Layout::Builtin(Builtin::Int8);
 
+/// Str.split : Str, Str -> List Str
+pub fn str_split<'a, 'ctx, 'env>(
+    env: &Env<'a, 'ctx, 'env>,
+    scope: &Scope<'a, 'ctx>,
+    parent: FunctionValue<'ctx>,
+    str_symbol: Symbol,
+    delimiter_symbol: Symbol,
+) -> BasicValueEnum<'ctx> {
+    let builder = env.builder;
+    let ctx = env.context;
+
+    let str_ptr = ptr_from_symbol(scope, str_symbol);
+    let delimiter_ptr = ptr_from_symbol(scope, delimiter_symbol);
+
+    let str_wrapper_type = BasicTypeEnum::StructType(collection(ctx, env.ptr_bytes));
+
+    load_str(
+        env,
+        parent,
+        *str_ptr,
+        str_wrapper_type,
+        |_, str_len, str_smallness| {
+            load_str(
+                env,
+                parent,
+                *delimiter_ptr,
+                |_, delimiter_len, delimiter_smallness| {
+                    let ret_list_len_alloca =
+                        builder.build_alloca(ctx.i64_type(), "ret_list_len_alloca");
+
+                    builder.build_store(ret_list_len_alloca, ctx.i64_type().const_zero());
+                },
+            )
+        },
+    )
+}
+
 /// Str.concat : Str, Str -> Str
 pub fn str_concat<'a, 'ctx, 'env>(
     env: &Env<'a, 'ctx, 'env>,

compiler/module/src/low_level.rs

@@ -5,6 +5,7 @@
 pub enum LowLevel {
     StrConcat,
     StrIsEmpty,
+    StrSplit,
     ListLen,
     ListGetUnsafe,
     ListSet,

compiler/module/src/symbol.rs

@@ -660,6 +660,7 @@ define_builtins! {
         2 STR_IS_EMPTY: "isEmpty"
         3 STR_APPEND: "append"
         4 STR_CONCAT: "concat"
+        5 STR_SPLIT: "split"
     }
     4 LIST: "List" => {
         0 LIST_LIST: "List" imported // the List.List type alias

compiler/mono/src/borrow.rs

@@ -510,7 +510,7 @@ pub fn lowlevel_borrow_signature(arena: &Bump, op: LowLevel) -> &[bool] {
         ListSetInPlace => arena.alloc_slice_copy(&[owned, irrelevant, irrelevant]),
         ListGetUnsafe => arena.alloc_slice_copy(&[borrowed, irrelevant]),
         ListConcat | StrConcat => arena.alloc_slice_copy(&[owned, borrowed]),
-
+        StrSplit => arena.alloc_slice_copy(&[borrowed, borrowed]),
         ListSingle => arena.alloc_slice_copy(&[irrelevant]),
         ListRepeat => arena.alloc_slice_copy(&[irrelevant, irrelevant]),
         ListReverse => arena.alloc_slice_copy(&[owned]),