free or reuse unconditionally when value is unique

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

@@ -2919,6 +2919,39 @@ pub(crate) fn build_exp_stmt<'a, 'ctx>(
                         cont,
                     )
                 }
+
+                Free(symbol) => {
+                    // unconditionally deallocate the symbol
+                    let (value, layout) = scope.load_symbol_and_layout(symbol);
+                    let alignment = layout_interner.alignment_bytes(layout);
+
+                    debug_assert!(value.is_pointer_value());
+                    let value = value.into_pointer_value();
+
+                    let clear_tag_id = match layout_interner.chase_recursive(layout) {
+                        LayoutRepr::Union(union) => union.stores_tag_id_in_pointer(env.target_info),
+                        _ => false,
+                    };
+
+                    let ptr = if clear_tag_id {
+                        tag_pointer_clear_tag_id(env, value)
+                    } else {
+                        value
+                    };
+
+                    let rc_ptr = PointerToRefcount::from_ptr_to_data(env, ptr);
+                    rc_ptr.deallocate(env, alignment);
+
+                    build_exp_stmt(
+                        env,
+                        layout_interner,
+                        layout_ids,
+                        func_spec_solutions,
+                        scope,
+                        parent,
+                        cont,
+                    )
+                }
             }
         }
 

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

@@ -1325,6 +1325,12 @@ pub(crate) fn run_low_level<'a, 'ctx>(
                 .new_build_load(element_type, ptr.into_pointer_value(), "ptr_load")
         }
 
+        PtrClearTagId => {
+            arguments!(ptr);
+
+            tag_pointer_clear_tag_id(env, ptr.into_pointer_value()).into()
+        }
+
         Alloca => {
             arguments!(initial_value);
 

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

@@ -14,7 +14,7 @@ use bumpalo::collections::Vec;
 use inkwell::basic_block::BasicBlock;
 use inkwell::module::Linkage;
 use inkwell::types::{AnyTypeEnum, BasicMetadataTypeEnum, BasicType, BasicTypeEnum};
-use inkwell::values::{BasicValueEnum, FunctionValue, IntValue, PointerValue};
+use inkwell::values::{BasicValueEnum, FunctionValue, InstructionValue, IntValue, PointerValue};
 use inkwell::{AddressSpace, IntPredicate};
 use roc_module::symbol::Interns;
 use roc_module::symbol::Symbol;
@@ -193,6 +193,14 @@ impl<'ctx> PointerToRefcount<'ctx> {
 
         builder.build_return(None);
     }
+
+    pub fn deallocate<'a, 'env>(
+        &self,
+        env: &Env<'a, 'ctx, 'env>,
+        alignment: u32,
+    ) -> InstructionValue<'ctx> {
+        free_pointer(env, self.value, alignment)
+    }
 }
 
 fn incref_pointer<'ctx>(
@@ -216,6 +224,28 @@ fn incref_pointer<'ctx>(
     );
 }
 
+fn free_pointer<'ctx>(
+    env: &Env<'_, 'ctx, '_>,
+    pointer: PointerValue<'ctx>,
+    alignment: u32,
+) -> InstructionValue<'ctx> {
+    let alignment = env.context.i32_type().const_int(alignment as _, false);
+    call_void_bitcode_fn(
+        env,
+        &[
+            env.builder
+                .build_pointer_cast(
+                    pointer,
+                    env.ptr_int().ptr_type(AddressSpace::default()),
+                    "to_isize_ptr",
+                )
+                .into(),
+            alignment.into(),
+        ],
+        roc_builtins::bitcode::UTILS_FREE_RC_PTR,
+    )
+}
+
 fn decref_pointer<'ctx>(env: &Env<'_, 'ctx, '_>, pointer: PointerValue<'ctx>, alignment: u32) {
     let alignment = env.context.i32_type().const_int(alignment as _, false);
     call_void_bitcode_fn(