revert workaround for alloc and free as coro params

reverts 4ac6c4d

the workaround didn't work

Author: andrewrk

src/all_types.hpp

@@ -2210,8 +2210,6 @@ struct IrInstructionCall {
     bool is_async;
 
     IrInstruction *async_allocator;
-    IrInstruction *alloc_fn;
-    IrInstruction *free_fn;
 };
 
 struct IrInstructionConst {
@@ -2852,16 +2850,8 @@ struct IrInstructionCancel {
     IrInstruction *target;
 };
 
-enum ImplicitAllocatorId {
-    ImplicitAllocatorIdContext,
-    ImplicitAllocatorIdAlloc,
-    ImplicitAllocatorIdFree,
-};
-
 struct IrInstructionGetImplicitAllocator {
     IrInstruction base;
-
-    ImplicitAllocatorId id;
 };
 
 struct IrInstructionCoroId {

src/analyze.cpp

@@ -1006,13 +1006,13 @@ TypeTableEntry *get_fn_type(CodeGen *g, FnTypeId *fn_type_id) {
             fn_type_id->return_type->id == TypeTableEntryIdErrorSet);
         // +1 for maybe making the first argument the return value
         // +1 for maybe first argument the error return trace
-        // +4 for maybe arguments async allocator and error code pointer
-        LLVMTypeRef *gen_param_types = allocate<LLVMTypeRef>(6 + fn_type_id->param_count);
+        // +2 for maybe arguments async allocator and error code pointer
+        LLVMTypeRef *gen_param_types = allocate<LLVMTypeRef>(4 + fn_type_id->param_count);
         // +1 because 0 is the return type and
         // +1 for maybe making first arg ret val and
         // +1 for maybe first argument the error return trace
-        // +4 for maybe arguments async allocator and error code pointer
-        ZigLLVMDIType **param_di_types = allocate<ZigLLVMDIType*>(7 + fn_type_id->param_count);
+        // +2 for maybe arguments async allocator and error code pointer
+        ZigLLVMDIType **param_di_types = allocate<ZigLLVMDIType*>(5 + fn_type_id->param_count);
         param_di_types[0] = fn_type_id->return_type->di_type;
         size_t gen_param_index = 0;
         TypeTableEntry *gen_return_type;
@@ -1052,32 +1052,6 @@ TypeTableEntry *get_fn_type(CodeGen *g, FnTypeId *fn_type_id) {
                 param_di_types[gen_param_index] = gen_type->di_type;
             }
 
-            {
-                // async alloc fn param
-                assert(fn_type_id->async_allocator_type->id == TypeTableEntryIdPointer);
-                TypeTableEntry *struct_type = fn_type_id->async_allocator_type->data.pointer.child_type;
-                TypeStructField *alloc_fn_field = find_struct_type_field(struct_type, buf_create_from_str("allocFn"));
-                assert(alloc_fn_field->type_entry->id == TypeTableEntryIdFn);
-                TypeTableEntry *gen_type = alloc_fn_field->type_entry;
-                gen_param_types[gen_param_index] = gen_type->type_ref;
-                gen_param_index += 1;
-                // after the gen_param_index += 1 because 0 is the return type
-                param_di_types[gen_param_index] = gen_type->di_type;
-            }
-
-            {
-                // async free fn param
-                assert(fn_type_id->async_allocator_type->id == TypeTableEntryIdPointer);
-                TypeTableEntry *struct_type = fn_type_id->async_allocator_type->data.pointer.child_type;
-                TypeStructField *free_fn_field = find_struct_type_field(struct_type, buf_create_from_str("freeFn"));
-                assert(free_fn_field->type_entry->id == TypeTableEntryIdFn);
-                TypeTableEntry *gen_type = free_fn_field->type_entry;
-                gen_param_types[gen_param_index] = gen_type->type_ref;
-                gen_param_index += 1;
-                // after the gen_param_index += 1 because 0 is the return type
-                param_di_types[gen_param_index] = gen_type->di_type;
-            }
-
             {
                 // error code pointer
                 TypeTableEntry *gen_type = get_pointer_to_type(g, g->builtin_types.entry_global_error_set, false);

src/codegen.cpp

@@ -2673,15 +2673,15 @@ static bool get_prefix_arg_err_ret_stack(CodeGen *g, TypeTableEntry *src_return_
 }
 
 static size_t get_async_allocator_arg_index(CodeGen *g, TypeTableEntry *src_return_type) {
-    // 0             1             2     3    4        5
-    // err_ret_stack allocator_ptr alloc free err_code other_args...
+    // 0             1             2        3
+    // err_ret_stack allocator_ptr err_code other_args...
     return get_prefix_arg_err_ret_stack(g, src_return_type) ? 1 : 0;
 }
 
 static size_t get_async_err_code_arg_index(CodeGen *g, TypeTableEntry *src_return_type) {
-    // 0             1             2     3    4        5
-    // err_ret_stack allocator_ptr alloc free err_code other_args...
-    return 3 + get_async_allocator_arg_index(g, src_return_type);
+    // 0             1             2        3
+    // err_ret_stack allocator_ptr err_code other_args...
+    return 1 + get_async_allocator_arg_index(g, src_return_type);
 }
 
 static LLVMValueRef ir_render_call(CodeGen *g, IrExecutable *executable, IrInstructionCall *instruction) {
@@ -2704,8 +2704,8 @@ static LLVMValueRef ir_render_call(CodeGen *g, IrExecutable *executable, IrInstr
     bool first_arg_ret = ret_has_bits && handle_is_ptr(src_return_type) &&
             calling_convention_does_first_arg_return(fn_type->data.fn.fn_type_id.cc);
     bool prefix_arg_err_ret_stack = get_prefix_arg_err_ret_stack(g, src_return_type);
-    // +4 for the async args
-    size_t actual_param_count = instruction->arg_count + (first_arg_ret ? 1 : 0) + (prefix_arg_err_ret_stack ? 1 : 0) + 4;
+    // +2 for the async args
+    size_t actual_param_count = instruction->arg_count + (first_arg_ret ? 1 : 0) + (prefix_arg_err_ret_stack ? 1 : 0) + 2;
     bool is_var_args = fn_type_id->is_var_args;
     LLVMValueRef *gen_param_values = allocate<LLVMValueRef>(actual_param_count);
     size_t gen_param_index = 0;
@@ -2721,12 +2721,6 @@ static LLVMValueRef ir_render_call(CodeGen *g, IrExecutable *executable, IrInstr
         gen_param_values[gen_param_index] = ir_llvm_value(g, instruction->async_allocator);
         gen_param_index += 1;
 
-        gen_param_values[gen_param_index] = ir_llvm_value(g, instruction->alloc_fn);
-        gen_param_index += 1;
-
-        gen_param_values[gen_param_index] = ir_llvm_value(g, instruction->free_fn);
-        gen_param_index += 1;
-
         LLVMValueRef err_val_ptr = LLVMBuildStructGEP(g->builder, instruction->tmp_ptr, err_union_err_index, "");
         LLVMBuildStore(g->builder, LLVMConstNull(g->builtin_types.entry_global_error_set->type_ref), err_val_ptr);
         gen_param_values[gen_param_index] = err_val_ptr;
@@ -3308,15 +3302,7 @@ static LLVMValueRef ir_render_get_implicit_allocator(CodeGen *g, IrExecutable *e
 {
     TypeTableEntry *src_return_type = g->cur_fn->type_entry->data.fn.fn_type_id.return_type;
     size_t allocator_arg_index = get_async_allocator_arg_index(g, src_return_type);
-    switch (instruction->id) {
-        case ImplicitAllocatorIdContext:
-            return LLVMGetParam(g->cur_fn_val, allocator_arg_index + 0);
-        case ImplicitAllocatorIdAlloc:
-            return LLVMGetParam(g->cur_fn_val, allocator_arg_index + 1);
-        case ImplicitAllocatorIdFree:
-            return LLVMGetParam(g->cur_fn_val, allocator_arg_index + 2);
-    }
-    zig_unreachable();
+    return LLVMGetParam(g->cur_fn_val, allocator_arg_index);
 }
 
 static LLVMAtomicOrdering to_LLVMAtomicOrdering(AtomicOrder atomic_order) {