start resetref

crates/compiler/gen_llvm/src/llvm/build.rs

@@ -5,7 +5,8 @@ use crate::llvm::convert::{
 };
 use crate::llvm::expect::{clone_to_shared_memory, SharedMemoryPointer};
 use crate::llvm::refcounting::{
-    build_reset, decrement_refcount_layout, increment_refcount_layout, PointerToRefcount,
+    build_reset, build_resetref, decrement_refcount_layout, increment_refcount_layout,
+    PointerToRefcount,
 };
 use bumpalo::collections::Vec;
 use bumpalo::Bump;
@@ -1226,6 +1227,74 @@ pub fn build_exp_expr<'a, 'ctx, 'env>(
                 phi.as_basic_value()
             }
         }
+        ResetRef {
+            symbol,
+            update_mode,
+        } => {
+            let bytes = update_mode.to_bytes();
+            let update_var = UpdateModeVar(&bytes);
+            let update_mode = func_spec_solutions
+                .update_mode(update_var)
+                .unwrap_or(UpdateMode::Immutable);
+
+            let (tag_ptr, layout) = load_symbol_and_layout(scope, symbol);
+            let tag_ptr = tag_ptr.into_pointer_value();
+
+            // reset is only generated for union values
+            let union_layout = match layout_interner.get(layout) {
+                Layout::Union(ul) => ul,
+                _ => unreachable!(),
+            };
+
+            let ctx = env.context;
+            let then_block = ctx.append_basic_block(parent, "then_resetref");
+            let else_block = ctx.append_basic_block(parent, "else_decref");
+            let cont_block = ctx.append_basic_block(parent, "cont");
+
+            let refcount_ptr =
+                PointerToRefcount::from_ptr_to_data(env, tag_pointer_clear_tag_id(env, tag_ptr));
+
+            let is_unique = match update_mode {
+                UpdateMode::InPlace => env.context.bool_type().const_int(1, false),
+                UpdateMode::Immutable => refcount_ptr.is_1(env),
+            };
+
+            env.builder
+                .build_conditional_branch(is_unique, then_block, else_block);
+
+            {
+                // reset, when used on a unique reference, eagerly decrements the components of the
+                // referenced value, and returns the location of the now-invalid cell
+                env.builder.position_at_end(then_block);
+
+                let reset_function = build_resetref(env, layout_interner, layout_ids, union_layout);
+                let call =
+                    env.builder
+                        .build_call(reset_function, &[tag_ptr.into()], "call_resetref");
+
+                call.set_call_convention(FAST_CALL_CONV);
+
+                let _ = call.try_as_basic_value();
+
+                env.builder.build_unconditional_branch(cont_block);
+            }
+            {
+                // If reset is used on a shared, non-reusable reference, it behaves
+                // like dec and returns NULL, which instructs reuse to behave like ctor
+                env.builder.position_at_end(else_block);
+                refcount_ptr.decrement(env, layout_interner, layout);
+                env.builder.build_unconditional_branch(cont_block);
+            }
+            {
+                env.builder.position_at_end(cont_block);
+                let phi = env.builder.build_phi(tag_ptr.get_type(), "branch");
+
+                let null_ptr = tag_ptr.get_type().const_null();
+                phi.add_incoming(&[(&tag_ptr, then_block), (&null_ptr, else_block)]);
+
+                phi.as_basic_value()
+            }
+        }
 
         StructAtIndex {
             index, structure, ..

crates/compiler/gen_llvm/src/llvm/refcounting.rs

@@ -1543,6 +1543,61 @@ pub fn build_reset<'a, 'ctx, 'env>(
     function
 }
 
+pub fn build_resetref<'a, 'ctx, 'env>(
+    env: &Env<'a, 'ctx, 'env>,
+    layout_interner: &mut STLayoutInterner<'a>,
+    layout_ids: &mut LayoutIds<'a>,
+    union_layout: UnionLayout<'a>,
+) -> FunctionValue<'ctx> {
+    // TODO update to not decref the children.
+    todo!("update to not decref the children.");
+    let mode = Mode::Dec;
+
+    let union_layout_in = layout_interner.insert(Layout::Union(union_layout));
+    let layout_id = layout_ids.get(Symbol::DEC, &union_layout_in);
+    let fn_name = layout_id.to_symbol_string(Symbol::DEC, &env.interns);
+    let fn_name = format!("{}_resetref", fn_name);
+
+    let when_recursive = WhenRecursive::Loop(union_layout);
+    let dec_function = build_rec_union(
+        env,
+        layout_interner,
+        layout_ids,
+        Mode::Dec,
+        &when_recursive,
+        union_layout,
+    );
+
+    let function = match env.module.get_function(fn_name.as_str()) {
+        Some(function_value) => function_value,
+        None => {
+            let block = env.builder.get_insert_block().expect("to be in a function");
+            let di_location = env.builder.get_current_debug_location().unwrap();
+
+            let basic_type = basic_type_from_layout(env, layout_interner, union_layout_in);
+            let function_value = build_header(env, basic_type, mode, &fn_name);
+
+            build_reuse_rec_union_help(
+                env,
+                layout_interner,
+                layout_ids,
+                &when_recursive,
+                union_layout,
+                function_value,
+                dec_function,
+            );
+
+            env.builder.position_at_end(block);
+            env.builder
+                .set_current_debug_location(env.context, di_location);
+
+            function_value
+        }
+    };
+
+    function
+}
+
 #[allow(clippy::too_many_arguments)]
 fn build_reuse_rec_union_help<'a, 'ctx, 'env>(
     env: &Env<'a, 'ctx, 'env>,