Add base piping for list.Replace

compiler/builtins/bitcode/README.md

@@ -7,7 +7,7 @@ To add a builtin:
 2. Make sure the function is public with the `pub` keyword and uses the C calling convention. This is really easy, just add `pub` and `callconv(.C)` to the function declaration like so: `pub fn atan(num: f64) callconv(.C) f64 { ... }`
 3. In `src/main.zig`, export the function. This is also organized by module. For example, for a `Num` function find the `Num` section and add: `comptime { exportNumFn(num.atan, "atan"); }`. The first argument is the function, the second is the name of it in LLVM.
 4. In `compiler/builtins/src/bitcode.rs`, add a constant for the new function. This is how we use it in Rust. Once again, this is organized by module, so just find the relevant area and add your new function.
-5. You can now  your function in Rust using `call_bitcode_fn` in `llvm/src/build.rs`!
+5. You can now use your function in Rust using `call_bitcode_fn` in `llvm/src/build.rs`!
 
 ## How it works
 

compiler/builtins/bitcode/src/list.zig

@@ -1256,6 +1256,93 @@ pub fn listConcat(list_a: RocList, list_b: RocList, alignment: u32, element_widt
     return output;
 }
 
+pub fn listReplaceInPlace(
+    bytes: ?[*]u8,
+    index: usize,
+    element: Opaque,
+    element_width: usize,
+) callconv(.C) ?[*]u8 {
+    // INVARIANT: bounds checking happens on the roc side
+    //
+    // at the time of writing, the function is implemented roughly as
+    // `if inBounds then LowLevelListReplace input index item else input`
+    // so we don't do a bounds check here. Hence, the list is also non-empty,
+    // because inserting into an empty list is always out of bounds
+
+    return listReplaceInPlaceHelp(bytes, index, element, element_width);
+}
+
+pub fn listReplace(
+    bytes: ?[*]u8,
+    length: usize,
+    alignment: u32,
+    index: usize,
+    element: Opaque,
+    element_width: usize,
+) callconv(.C) ?[*]u8 {
+    // INVARIANT: bounds checking happens on the roc side
+    //
+    // at the time of writing, the function is implemented roughly as
+    // `if inBounds then LowLevelListReplace input index item else input`
+    // so we don't do a bounds check here. Hence, the list is also non-empty,
+    // because inserting into an empty list is always out of bounds
+    const ptr: [*]usize = @ptrCast([*]usize, @alignCast(@alignOf(usize), bytes));
+
+    if ((ptr - 1)[0] == utils.REFCOUNT_ONE) {
+        return listReplaceInPlaceHelp(bytes, index, element, element_width);
+    } else {
+        return listReplaceImmutable(bytes, length, alignment, index, element, element_width);
+    }
+}
+
+inline fn listReplaceInPlaceHelp(
+    bytes: ?[*]u8,
+    index: usize,
+    element: Opaque,
+    element_width: usize,
+) ?[*]u8 {
+    // the element we will replace
+    var element_at_index = (bytes orelse undefined) + (index * element_width);
+
+    // decrement its refcount
+    // dec(element_at_index);
+
+    // copy in the new element
+    @memcpy(element_at_index, element orelse undefined, element_width);
+
+    return bytes;
+}
+
+inline fn listReplaceImmutable(
+    old_bytes: ?[*]u8,
+    length: usize,
+    alignment: u32,
+    index: usize,
+    element: Opaque,
+    element_width: usize,
+) ?[*]u8 {
+    const data_bytes = length * element_width;
+
+    var new_bytes = utils.allocateWithRefcount(data_bytes, alignment);
+
+    @memcpy(new_bytes, old_bytes orelse undefined, data_bytes);
+
+    // the element we will replace
+    var element_at_index = new_bytes + (index * element_width);
+
+    // decrement its refcount
+    // dec(element_at_index);
+
+    // copy in the new element
+    @memcpy(element_at_index, element orelse undefined, element_width);
+
+    // consume RC token of original
+    utils.decref(old_bytes, data_bytes, alignment);
+
+    //return list;
+    return new_bytes;
+}
+
 pub fn listSetInPlace(
     bytes: ?[*]u8,
     index: usize,

compiler/builtins/bitcode/src/main.zig

@@ -49,6 +49,8 @@ comptime {
     exportListFn(list.listConcat, "concat");
     exportListFn(list.listSublist, "sublist");
     exportListFn(list.listDropAt, "drop_at");
+    exportListFn(list.listReplace, "replace");
+    exportListFn(list.listReplaceInPlace, "replace_in_place");
     exportListFn(list.listSet, "set");
     exportListFn(list.listSetInPlace, "set_in_place");
     exportListFn(list.listSwap, "swap");