copy elision: if-bool with scalar types

```zig
export fn entry() void {
    var c = true;
    var y: i32 = if (c) 1234 else 5678;
}
```

```llvm
define void @entry() #2 !dbg !41 {
Entry:
  %c = alloca i1, align 1
  %y = alloca i32, align 4
  store i1 true, i1* %c, align 1, !dbg !51
  call void @llvm.dbg.declare(metadata i1* %c, metadata !45, metadata !DIExpression()), !dbg !52
  %0 = load i1, i1* %c, align 1, !dbg !53
  br i1 %0, label %Then, label %Else, !dbg !53

Then:                                             ; preds = %Entry
  store i32 1234, i32* %y, align 4, !dbg !54
  br label %EndIf, !dbg !55

Else:                                             ; preds = %Entry
  store i32 5678, i32* %y, align 4, !dbg !56
  br label %EndIf, !dbg !55

EndIf:                                            ; preds = %Else, %Then
  call void @llvm.dbg.declare(metadata i32* %y, metadata !48, metadata !DIExpression()), !dbg !57
  ret void, !dbg !58
}
```

Author: andrewrk

src/all_types.hpp

@@ -2187,6 +2187,7 @@ enum IrInstructionId {
     IrInstructionIdAllocaGen,
     IrInstructionIdAssertNonError,
     IrInstructionIdErrorUnionFieldErrorSet,
+    IrInstructionIdFirstArgResultLoc,
 };
 
 struct IrInstruction {
@@ -3371,6 +3372,13 @@ struct IrInstructionAssertNonError {
     IrInstruction *err_code;
 };
 
+struct IrInstructionFirstArgResultLoc {
+    IrInstruction base;
+
+    IrInstruction *prev_result_loc;
+    IrInstruction *fn_ref;
+};
+
 static const size_t slice_ptr_index = 0;
 static const size_t slice_len_index = 1;
 

src/codegen.cpp

@@ -5241,6 +5241,7 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
         case IrInstructionIdDeclVarSrc:
         case IrInstructionIdAllocaSrc:
         case IrInstructionIdAllocaGen:
+        case IrInstructionIdFirstArgResultLoc:
             zig_unreachable();
 
         case IrInstructionIdDeclVarGen:

src/ir.cpp

@@ -907,6 +907,10 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionErrorUnionFieldE
     return IrInstructionIdErrorUnionFieldErrorSet;
 }
 
+static constexpr IrInstructionId ir_instruction_id(IrInstructionFirstArgResultLoc *) {
+    return IrInstructionIdFirstArgResultLoc;
+}
+
 template<typename T>
 static T *ir_create_instruction(IrBuilder *irb, Scope *scope, AstNode *source_node) {
     T *special_instruction = allocate<T>(1);
@@ -2936,6 +2940,19 @@ static IrInstruction *ir_build_error_union_field_error_set(IrBuilder *irb, Scope
     return &instruction->base;
 }
 
+static IrInstruction *ir_build_first_arg_result_loc(IrBuilder *irb, Scope *scope, AstNode *source_node,
+        IrInstruction *prev_result_loc, IrInstruction *fn_ref)
+{
+    IrInstructionFirstArgResultLoc *instruction = ir_build_instruction<IrInstructionFirstArgResultLoc>(irb, scope, source_node);
+    instruction->prev_result_loc = prev_result_loc;
+    instruction->fn_ref = fn_ref;
+
+    ir_ref_instruction(prev_result_loc, irb->current_basic_block);
+    ir_ref_instruction(fn_ref, irb->current_basic_block);
+
+    return &instruction->base;
+}
+
 static void ir_count_defers(IrBuilder *irb, Scope *inner_scope, Scope *outer_scope, size_t *results) {
     results[ReturnKindUnconditional] = 0;
     results[ReturnKindError] = 0;
@@ -4969,16 +4986,31 @@ static IrInstruction *ir_gen_fn_call(IrBuilder *irb, Scope *scope, AstNode *node
     if (fn_ref == irb->codegen->invalid_instruction)
         return fn_ref;
 
+    // In pass 1, we can't tell the difference between a function call with a single argument
+    // and an implicit cast. So if there is only one argument, we emit a special instruction.
     size_t arg_count = node->data.fn_call_expr.params.length;
     IrInstruction **args = allocate<IrInstruction*>(arg_count);
+    bool is_async = node->data.fn_call_expr.is_async;
+    if (arg_count == 1 && !is_async) {
+        AstNode *arg_node = node->data.fn_call_expr.params.at(0);
+        IrInstruction *arg_result_loc = ir_build_first_arg_result_loc(irb, scope, arg_node, result_loc, fn_ref);
+        args[0] = ir_gen_node(irb, arg_node, scope, LValNone, arg_result_loc);
+        if (args[0] == irb->codegen->invalid_instruction)
+            return irb->codegen->invalid_instruction;
+        // In the analysis, this call instruction will be a simple LoadPtr instruction if
+        // it turns out to be an implicit cast.
+        IrInstruction *fn_call = ir_build_call(irb, scope, node, nullptr, fn_ref, arg_count, args, false,
+                FnInlineAuto, false, nullptr, nullptr, result_loc);
+        return ir_lval_wrap(irb, scope, fn_call, lval);
+    }
+
     for (size_t i = 0; i < arg_count; i += 1) {
         AstNode *arg_node = node->data.fn_call_expr.params.at(i);
         args[i] = ir_gen_node(irb, arg_node, scope, LValNone, nullptr);
         if (args[i] == irb->codegen->invalid_instruction)
             return args[i];
     }
 
-    bool is_async = node->data.fn_call_expr.is_async;
     IrInstruction *async_allocator = nullptr;
     if (is_async) {
         if (node->data.fn_call_expr.async_allocator) {
@@ -13989,6 +14021,7 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call
 }
 
 static IrInstruction *ir_analyze_instruction_call(IrAnalyze *ira, IrInstructionCall *call_instruction) {
+    Error err;
     IrInstruction *fn_ref = call_instruction->fn_ref->child;
     if (type_is_invalid(fn_ref->value.type))
         return ira->codegen->invalid_instruction;
@@ -14010,12 +14043,18 @@ static IrInstruction *ir_analyze_instruction_call(IrAnalyze *ira, IrInstructionC
                 return ira->codegen->invalid_instruction;
             }
 
-            IrInstruction *arg = call_instruction->args[0]->child;
+            // This is handled with the result location mechanism. So all we need to do here is
+            // a LoadPtr on the result location.
+            IrInstruction *result_loc = call_instruction->result_loc->child;
+            if (type_is_invalid(result_loc->value.type))
+                return ira->codegen->invalid_instruction;
+            if ((err = resolve_possible_alloca_inference(ira, result_loc, dest_type)))
+                return ira->codegen->invalid_instruction;
 
-            IrInstruction *cast_instruction = ir_analyze_cast(ira, &call_instruction->base, dest_type, arg);
-            if (type_is_invalid(cast_instruction->value.type))
+            IrInstruction *deref = ir_get_deref(ira, &call_instruction->base, result_loc);
+            if (type_is_invalid(deref->value.type))
                 return ira->codegen->invalid_instruction;
-            return ir_finish_anal(ira, cast_instruction);
+            return ir_finish_anal(ira, deref);
         } else if (fn_ref->value.type->id == ZigTypeIdFn) {
             ZigFn *fn_table_entry = ir_resolve_fn(ira, fn_ref);
             if (fn_table_entry == nullptr)
@@ -21357,6 +21396,47 @@ static IrInstruction *ir_analyze_instruction_alloca(IrAnalyze *ira, IrInstructio
     return &result->base;
 }
 
+static IrInstruction *ir_analyze_instruction_first_arg_result_loc(IrAnalyze *ira,
+        IrInstructionFirstArgResultLoc *instruction)
+{
+    Error err;
+
+    IrInstruction *fn_ref = instruction->fn_ref->child;
+    if (type_is_invalid(fn_ref->value.type))
+        return ira->codegen->invalid_instruction;
+
+    if (fn_ref->value.type->id == ZigTypeIdMetaType) {
+        // Result of this instruction should be the implicitly casted result location.
+
+        ZigType *dest_type = ir_resolve_type(ira, fn_ref);
+        if (type_is_invalid(dest_type))
+            return ira->codegen->invalid_instruction;
+
+        IrInstruction *new_result_loc = ir_implicit_cast_result(ira, instruction->prev_result_loc->child,
+                dest_type);
+        if (type_is_invalid(new_result_loc->value.type))
+            return ira->codegen->invalid_instruction;
+        return new_result_loc;
+    }
+
+    // Result of this instruction should be the result location for the first argument of the function call.
+    // This means it should be a stack allocation.
+    IrInstructionAllocaGen *result = ir_create_alloca_gen(&ira->new_irb, instruction->base.scope,
+            instruction->base.source_node, 0, "");
+
+    assert(fn_ref->value.type->id == ZigTypeIdFn);
+    ZigType *param_type = fn_ref->value.type->data.fn.fn_type_id.param_info[0].type;
+    if (type_is_invalid(param_type))
+        return ira->codegen->invalid_instruction;
+    if ((err = resolve_alloca_inference(ira, result, param_type)))
+        return ira->codegen->invalid_instruction;
+    ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
+    if (fn_entry != nullptr) {
+        fn_entry->alloca_list.append(result);
+    }
+    return &result->base;
+}
+
 static IrInstruction *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstruction *instruction) {
     switch (instruction->id) {
         case IrInstructionIdInvalid:
@@ -21650,6 +21730,8 @@ static IrInstruction *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstructio
             return ir_analyze_instruction_alloca(ira, (IrInstructionAllocaSrc *)instruction);
         case IrInstructionIdErrorUnionFieldErrorSet:
             return ir_analyze_instruction_error_union_field_error_set(ira, (IrInstructionErrorUnionFieldErrorSet *)instruction);
+        case IrInstructionIdFirstArgResultLoc:
+            return ir_analyze_instruction_first_arg_result_loc(ira, (IrInstructionFirstArgResultLoc *)instruction);
         case IrInstructionIdResultBytesToSlice:
             zig_panic("TODO");
         case IrInstructionIdResultSliceToBytes:
@@ -21887,6 +21969,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {
         case IrInstructionIdAllocaSrc:
         case IrInstructionIdAllocaGen:
         case IrInstructionIdErrorUnionFieldErrorSet:
+        case IrInstructionIdFirstArgResultLoc:
             return false;
 
         case IrInstructionIdLoadPtr:

src/ir_print.cpp

@@ -1399,6 +1399,14 @@ static void ir_print_error_union_field_error_set(IrPrint *irp, IrInstructionErro
     fprintf(irp->f, ")");
 }
 
+static void ir_print_first_arg_result_loc(IrPrint *irp, IrInstructionFirstArgResultLoc *instruction) {
+    fprintf(irp->f, "FirstArgResultLoc(prev_result=");
+    ir_print_other_instruction(irp, instruction->prev_result_loc);
+    fprintf(irp->f, ",fn=");
+    ir_print_other_instruction(irp, instruction->fn_ref);
+    fprintf(irp->f, ")");
+}
+
 static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction) {
     ir_print_prefix(irp, instruction);
     switch (instruction->id) {
@@ -1863,6 +1871,9 @@ static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction) {
         case IrInstructionIdErrorUnionFieldErrorSet:
             ir_print_error_union_field_error_set(irp, (IrInstructionErrorUnionFieldErrorSet *)instruction);
             break;
+        case IrInstructionIdFirstArgResultLoc:
+            ir_print_first_arg_result_loc(irp, (IrInstructionFirstArgResultLoc *)instruction);
+            break;
     }
     fprintf(irp->f, "\n");
 }