remove dict/set layout

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

@@ -423,35 +423,6 @@ fn modify_refcount_builtin<'a, 'ctx, 'env>(
 
             Some(function)
         }
-        Set(element_layout) => {
-            let key_layout = element_layout;
-            let value_layout = &Layout::UNIT;
-
-            let function = modify_refcount_dict(
-                env,
-                layout_ids,
-                mode,
-                when_recursive,
-                layout,
-                key_layout,
-                value_layout,
-            );
-
-            Some(function)
-        }
-        Dict(key_layout, value_layout) => {
-            let function = modify_refcount_dict(
-                env,
-                layout_ids,
-                mode,
-                when_recursive,
-                layout,
-                key_layout,
-                value_layout,
-            );
-
-            Some(function)
-        }
 
         Str => Some(modify_refcount_str(env, layout_ids, mode, layout)),
 
@@ -960,141 +931,6 @@ fn modify_refcount_box_help<'a, 'ctx, 'env>(
     builder.build_return(None);
 }
 
-#[allow(clippy::too_many_arguments)]
-fn modify_refcount_dict<'a, 'ctx, 'env>(
-    env: &Env<'a, 'ctx, 'env>,
-    layout_ids: &mut LayoutIds<'a>,
-    mode: Mode,
-    when_recursive: &WhenRecursive<'a>,
-    layout: &Layout<'a>,
-    key_layout: &Layout<'a>,
-    value_layout: &Layout<'a>,
-) -> FunctionValue<'ctx> {
-    let block = env.builder.get_insert_block().expect("to be in a function");
-    let di_location = env.builder.get_current_debug_location().unwrap();
-
-    let (_, fn_name) = function_name_from_mode(
-        layout_ids,
-        &env.interns,
-        "increment_dict",
-        "decrement_dict",
-        layout,
-        mode,
-    );
-
-    let function = match env.module.get_function(fn_name.as_str()) {
-        Some(function_value) => function_value,
-        None => {
-            let basic_type = basic_type_from_layout(env, layout);
-            let function_value = build_header(env, basic_type, mode, &fn_name);
-
-            modify_refcount_dict_help(
-                env,
-                layout_ids,
-                mode,
-                when_recursive,
-                layout,
-                key_layout,
-                value_layout,
-                function_value,
-            );
-
-            function_value
-        }
-    };
-
-    env.builder.position_at_end(block);
-    env.builder
-        .set_current_debug_location(env.context, di_location);
-
-    function
-}
-
-#[allow(clippy::too_many_arguments)]
-fn modify_refcount_dict_help<'a, 'ctx, 'env>(
-    env: &Env<'a, 'ctx, 'env>,
-    layout_ids: &mut LayoutIds<'a>,
-    mode: Mode,
-    when_recursive: &WhenRecursive<'a>,
-    layout: &Layout<'a>,
-    key_layout: &Layout<'a>,
-    value_layout: &Layout<'a>,
-    fn_val: FunctionValue<'ctx>,
-) {
-    debug_assert_eq!(
-        when_recursive,
-        &WhenRecursive::Unreachable,
-        "TODO pipe when_recursive through the dict key/value inc/dec"
-    );
-
-    let builder = env.builder;
-    let ctx = env.context;
-
-    // Add a basic block for the entry point
-    let entry = ctx.append_basic_block(fn_val, "entry");
-
-    builder.position_at_end(entry);
-
-    debug_info_init!(env, fn_val);
-
-    // Add args to scope
-    let arg_symbol = Symbol::ARG_1;
-    let arg_val = fn_val.get_param_iter().next().unwrap();
-
-    arg_val.set_name(arg_symbol.as_str(&env.interns));
-
-    let parent = fn_val;
-
-    let wrapper_struct = arg_val.into_struct_value();
-
-    let len = builder
-        .build_extract_value(wrapper_struct, 1, "read_dict_len")
-        .unwrap()
-        .into_int_value();
-
-    // the block we'll always jump to when we're done
-    let cont_block = ctx.append_basic_block(parent, "modify_rc_dict_cont");
-    let modification_block = ctx.append_basic_block(parent, "modify_rc");
-
-    let is_non_empty = builder.build_int_compare(
-        IntPredicate::SGT,
-        len,
-        env.ptr_int().const_zero(),
-        "is_non_empty",
-    );
-
-    builder.build_conditional_branch(is_non_empty, modification_block, cont_block);
-    builder.position_at_end(modification_block);
-
-    if key_layout.contains_refcounted() || value_layout.contains_refcounted() {
-        crate::llvm::build_dict::dict_elements_rc(
-            env,
-            layout_ids,
-            wrapper_struct.into(),
-            key_layout,
-            value_layout,
-            mode,
-        );
-    }
-
-    let data_ptr = env
-        .builder
-        .build_extract_value(wrapper_struct, 0, "get_data_ptr")
-        .unwrap()
-        .into_pointer_value();
-
-    let refcount_ptr = PointerToRefcount::from_ptr_to_data(env, data_ptr);
-    let call_mode = mode_to_call_mode(fn_val, mode);
-    refcount_ptr.modify(call_mode, layout, env);
-
-    builder.build_unconditional_branch(cont_block);
-
-    builder.position_at_end(cont_block);
-
-    // this function returns void
-    builder.build_return(None);
-}
-
 /// Build an increment or decrement function for a specific layout
 fn build_header<'a, 'ctx, 'env>(
     env: &Env<'a, 'ctx, 'env>,