copy elision: implicit cast payload to error union

```zig
export fn entry() void {
    var x: error!Foo = foo();
}
```

```llvm
define void @entry() #2 !dbg !41 {
Entry:
  %x = alloca { i16, %Foo }, align 4
  %0 = getelementptr inbounds { i16, %Foo }, { i16, %Foo }* %x, i32 0, i32 0, !dbg !56
  store i16 0, i16* %0, align 2, !dbg !56
  %1 = getelementptr inbounds { i16, %Foo }, { i16, %Foo }* %x, i32 0, i32 1, !dbg !56
  call fastcc void @foo(%Foo* sret %1), !dbg !57
  call void @llvm.dbg.declare(metadata { i16, %Foo }* %x, metadata !45, metadata !DIExpression()), !dbg !56
  ret void, !dbg !58
}
```

Author: andrewrk

src/codegen.cpp

@@ -5108,6 +5108,16 @@ static LLVMValueRef ir_render_result_optional_payload(CodeGen *g, IrExecutable *
     return LLVMBuildStructGEP(g->builder, prev_result_loc, maybe_child_index, "");
 }
 
+static LLVMValueRef ir_render_result_error_union_payload(CodeGen *g, IrExecutable *executable,
+        IrInstructionResultErrorUnionPayload *instruction)
+{
+    LLVMValueRef prev_result_loc = ir_llvm_value(g, instruction->prev_result_loc);
+    LLVMValueRef err_val_ptr = LLVMBuildStructGEP(g->builder, prev_result_loc, err_union_err_index, "");
+    LLVMTypeRef err_type_ref = g->builtin_types.entry_global_error_set->type_ref;
+    gen_store_untyped(g, LLVMConstInt(err_type_ref, 0, false), err_val_ptr, 0, false);
+    return LLVMBuildStructGEP(g->builder, prev_result_loc, err_union_payload_index, "");
+}
+
 static LLVMValueRef ir_render_assert_non_error(CodeGen *g, IrExecutable *executable,
         IrInstructionAssertNonError *instruction)
 {
@@ -5371,10 +5381,10 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
             return ir_render_result_return(g, executable, (IrInstructionResultReturn *)instruction);
         case IrInstructionIdResultOptionalPayload:
             return ir_render_result_optional_payload(g, executable, (IrInstructionResultOptionalPayload *)instruction);
+        case IrInstructionIdResultErrorUnionPayload:
+            return ir_render_result_error_union_payload(g, executable, (IrInstructionResultErrorUnionPayload *)instruction);
         case IrInstructionIdAssertNonError:
             return ir_render_assert_non_error(g, executable, (IrInstructionAssertNonError *)instruction);
-        case IrInstructionIdResultErrorUnionPayload:
-            zig_panic("TODO");
         case IrInstructionIdResultSliceToBytes:
             zig_panic("TODO");
         case IrInstructionIdResultBytesToSlice:

src/ir.cpp

@@ -2805,6 +2805,17 @@ static IrInstruction *ir_build_result_optional_payload(IrBuilder *irb, Scope *sc
     return &instruction->base;
 }
 
+static IrInstruction *ir_build_result_error_union_payload(IrBuilder *irb, Scope *scope, AstNode *source_node,
+        IrInstruction *prev_result_loc)
+{
+    IrInstructionResultErrorUnionPayload *instruction = ir_build_instruction<IrInstructionResultErrorUnionPayload>(irb, scope, source_node);
+    instruction->prev_result_loc = prev_result_loc;
+
+    ir_ref_instruction(prev_result_loc, irb->current_basic_block);
+
+    return &instruction->base;
+}
+
 static IrInstruction *ir_build_result_return(IrBuilder *irb, Scope *scope, AstNode *source_node) {
     IrInstructionResultReturn *instruction = ir_build_instruction<IrInstructionResultReturn>(irb, scope, source_node);
     return &instruction->base;
@@ -9812,17 +9823,31 @@ static IrInstruction *ir_analyze_result_optional_payload(IrAnalyze *ira, IrInstr
     ZigType *old_ptr_type = result_loc->value.type;
     assert(old_ptr_type->id == ZigTypeIdPointer);
     ZigType *new_ptr_type = get_pointer_to_type_extra(ira->codegen, needed_child_type,
-            old_ptr_type->data.pointer.is_const,
-            old_ptr_type->data.pointer.is_volatile,
-            old_ptr_type->data.pointer.ptr_len,
-            0, 0, 0);
+            false, old_ptr_type->data.pointer.is_volatile, PtrLenSingle, 0, 0, 0);
 
     IrInstruction *result = ir_build_result_optional_payload(&ira->new_irb, result_loc->scope,
             result_loc->source_node, result_loc);
     result->value.type = new_ptr_type;
     return result;
 }
 
+static IrInstruction *ir_analyze_result_error_union_payload(IrAnalyze *ira, IrInstruction *result_loc,
+        ZigType *needed_child_type)
+{
+    if (instr_is_comptime(result_loc)) {
+        zig_panic("TODO comptime ir_analyze_result_error_union_payload");
+    }
+    ZigType *old_ptr_type = result_loc->value.type;
+    assert(old_ptr_type->id == ZigTypeIdPointer);
+    ZigType *new_ptr_type = get_pointer_to_type_extra(ira->codegen, needed_child_type,
+            false, old_ptr_type->data.pointer.is_volatile, PtrLenSingle, 0, 0, 0);
+
+    IrInstruction *result = ir_build_result_error_union_payload(&ira->new_irb, result_loc->scope,
+            result_loc->source_node, result_loc);
+    result->value.type = new_ptr_type;
+    return result;
+}
+
 static IrInstruction *ir_analyze_optional_wrap(IrAnalyze *ira, IrInstruction *source_instr, IrInstruction *value,
         ZigType *wanted_type)
 {
@@ -10787,7 +10812,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
         return ir_analyze_null_to_maybe(ira, source_instr, value, wanted_type);
     }
 
-    // cast from child type of error type to error type
+    // cast from T to E!T
     if (wanted_type->id == ZigTypeIdErrorUnion) {
         if (types_match_const_cast_only(ira, wanted_type->data.error_union.payload_type, actual_type,
             source_node, false).id == ConstCastResultIdOk)
@@ -11127,6 +11152,15 @@ static IrInstruction *ir_implicit_cast_result(IrAnalyze *ira, IrInstruction *res
         }
     }
 
+    // cast from T to E!T
+    if (have_child_type->id == ZigTypeIdErrorUnion) {
+        if (types_match_const_cast_only(ira, have_child_type->data.error_union.payload_type, needed_child_type,
+            source_node, false).id == ConstCastResultIdOk)
+        {
+            return ir_analyze_result_error_union_payload(ira, result_loc, needed_child_type);
+        }
+    }
+
     ErrorMsg *parent_msg = ir_add_error_node(ira, source_node,
         buf_sprintf("expected type '%s', found '%s'",
             buf_ptr(&have_child_type->name),

src/ir_print.cpp

@@ -1332,7 +1332,9 @@ static void ir_print_result_optional_payload(IrPrint *irp, IrInstructionResultOp
 }
 
 static void ir_print_result_error_union_payload(IrPrint *irp, IrInstructionResultErrorUnionPayload *instruction) {
-    fprintf(irp->f, "ResultErrorUnionPayload");
+    fprintf(irp->f, "ResultErrorUnionPayload(");
+    ir_print_other_instruction(irp, instruction->prev_result_loc);
+    fprintf(irp->f, ")");
 }
 
 static void ir_print_result_return(IrPrint *irp, IrInstructionResultReturn *instruction) {