fix regressed tests and update docs to use "type coercion"

2 files changed, 23 insertions, 21 deletions

diff --git a/src/ir.cpp b/src/ir.cpp
index bf558cb8a2..9225968ce9 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -6339,7 +6339,8 @@ static IrInstruction *ir_gen_var_decl(IrBuilder *irb, Scope *scope, AstNode *nod
         return irb->codegen->invalid_instruction;
 
     if (result_loc_cast != nullptr) {
-        IrInstruction *implicit_cast = ir_build_implicit_cast(irb, scope, node, init_value, result_loc_cast);
+        IrInstruction *implicit_cast = ir_build_implicit_cast(irb, scope, init_value->source_node,
+                init_value, result_loc_cast);
         ir_build_end_expr(irb, scope, node, implicit_cast, &result_loc_var->base);
     }
 
@@ -9610,7 +9611,7 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze *ira, IrInstruction *instruc
     }
 
     ir_add_error(ira, instruction,
-        buf_sprintf("%s value %s cannot be implicitly casted to type '%s'",
+        buf_sprintf("%s value %s cannot be coerced to type '%s'",
             num_lit_str,
             buf_ptr(val_buf),
             buf_ptr(&other_type->name)));
@@ -13065,8 +13066,8 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
     return ira->codegen->invalid_instruction;
 }
 
-static IrInstruction *ir_implicit_cast_with_result(IrAnalyze *ira, IrInstruction *value, ZigType *expected_type,
-        ResultLoc *result_loc)
+static IrInstruction *ir_implicit_cast_with_result(IrAnalyze *ira, IrInstruction *source_instr,
+        IrInstruction *value, ZigType *expected_type, ResultLoc *result_loc)
 {
     assert(value);
     assert(value != ira->codegen->invalid_instruction);
@@ -13080,11 +13081,11 @@ static IrInstruction *ir_implicit_cast_with_result(IrAnalyze *ira, IrInstruction
     if (value->value.type->id == ZigTypeIdUnreachable)
         return value;
 
-    return ir_analyze_cast(ira, value, expected_type, value, result_loc);
+    return ir_analyze_cast(ira, source_instr, expected_type, value, result_loc);
 }
 
 static IrInstruction *ir_implicit_cast(IrAnalyze *ira, IrInstruction *value, ZigType *expected_type) {
-    return ir_implicit_cast_with_result(ira, value, expected_type, nullptr);
+    return ir_implicit_cast_with_result(ira, value, value, expected_type, nullptr);
 }
 
 static IrInstruction *ir_get_deref(IrAnalyze *ira, IrInstruction *source_instruction, IrInstruction *ptr,
@@ -26068,7 +26069,7 @@ static IrInstruction *ir_analyze_instruction_implicit_cast(IrAnalyze *ira, IrIns
     ZigType *dest_type = ir_resolve_type(ira, instruction->result_loc_cast->base.source_instruction->child);
     if (type_is_invalid(dest_type))
         return ira->codegen->invalid_instruction;
-    return ir_implicit_cast(ira, operand, dest_type);
+    return ir_implicit_cast_with_result(ira, &instruction->base, operand, dest_type, nullptr);
 }
 
 static IrInstruction *ir_analyze_instruction_bit_cast_src(IrAnalyze *ira, IrInstructionBitCastSrc *instruction) {
diff --git a/src/translate_c.cpp b/src/translate_c.cpp
index 6765bf45fb..2214dc7d54 100644
--- a/src/translate_c.cpp
+++ b/src/translate_c.cpp
@@ -221,6 +221,15 @@ static AstNode *trans_create_node_opaque(Context *c) {
     return trans_create_node_builtin_fn_call_str(c, "OpaqueType");
 }
 
+static AstNode *trans_create_node_cast(Context *c, AstNode *dest_type, AstNode *operand) {
+    AstNode *node = trans_create_node(c, NodeTypeFnCallExpr);
+    node->data.fn_call_expr.fn_ref_expr = trans_create_node_symbol(c, buf_create_from_str("as"));
+    node->data.fn_call_expr.modifier = CallModifierBuiltin;
+    node->data.fn_call_expr.params.append(dest_type);
+    node->data.fn_call_expr.params.append(operand);
+    return node;
+}
+
 static AstNode *trans_create_node_fn_call_1(Context *c, AstNode *fn_ref_expr, AstNode *arg1) {
     AstNode *node = trans_create_node(c, NodeTypeFnCallExpr);
     node->data.fn_call_expr.fn_ref_expr = fn_ref_expr;
@@ -337,14 +346,6 @@ static AstNode *trans_create_node_unsigned(Context *c, uint64_t x) {
     return trans_create_node_unsigned_negative(c, x, false);
 }
 
-static AstNode *trans_create_node_cast(Context *c, AstNode *dest, AstNode *src) {
-    AstNode *node = trans_create_node(c, NodeTypeFnCallExpr);
-    node->data.fn_call_expr.fn_ref_expr = dest;
-    node->data.fn_call_expr.params.resize(1);
-    node->data.fn_call_expr.params.items[0] = src;
-    return node;
-}
-
 static AstNode *trans_create_node_unsigned_negative_type(Context *c, uint64_t x, bool is_negative,
         const char *type_name)
 {
@@ -701,7 +702,7 @@ static AstNode* trans_c_cast(Context *c, ZigClangSourceLocation source_location,
     if (c_is_unsigned_integer(c, dest_type) && qual_type_is_ptr(src_type)) {
         AstNode *addr_node = trans_create_node_builtin_fn_call_str(c, "ptrToInt");
         addr_node->data.fn_call_expr.params.append(expr);
-        return trans_create_node_fn_call_1(c, trans_qual_type(c, dest_type, source_location), addr_node);
+        return trans_create_node_cast(c, trans_qual_type(c, dest_type, source_location), addr_node);
     }
     if (c_is_unsigned_integer(c, src_type) && qual_type_is_ptr(dest_type)) {
         AstNode *ptr_node = trans_create_node_builtin_fn_call_str(c, "intToPtr");
@@ -712,7 +713,7 @@ static AstNode* trans_c_cast(Context *c, ZigClangSourceLocation source_location,
     // TODO: maybe widen to increase size
     // TODO: maybe bitcast to change sign
     // TODO: maybe truncate to reduce size
-    return trans_create_node_fn_call_1(c, trans_qual_type(c, dest_type, source_location), expr);
+    return trans_create_node_cast(c, trans_qual_type(c, dest_type, source_location), expr);
 }
 
 static bool c_is_signed_integer(Context *c, ZigClangQualType qt) {
@@ -1527,7 +1528,7 @@ static AstNode *trans_create_shift_op(Context *c, TransScope *scope, ZigClangQua
 
     AstNode *rhs = trans_expr(c, ResultUsedYes, scope, rhs_expr, TransRValue);
     if (rhs == nullptr) return nullptr;
-    AstNode *coerced_rhs = trans_create_node_fn_call_1(c, rhs_type, rhs);
+    AstNode *coerced_rhs = trans_create_node_cast(c, rhs_type, rhs);
 
     return trans_create_node_bin_op(c, lhs, bin_op, coerced_rhs);
 }
@@ -1702,7 +1703,7 @@ static AstNode *trans_create_compound_assign_shift(Context *c, ResultUsed result
 
         AstNode *rhs = trans_expr(c, ResultUsedYes, scope, ZigClangCompoundAssignOperator_getRHS(stmt), TransRValue);
         if (rhs == nullptr) return nullptr;
-        AstNode *coerced_rhs = trans_create_node_fn_call_1(c, rhs_type, rhs);
+        AstNode *coerced_rhs = trans_create_node_cast(c, rhs_type, rhs);
 
         return trans_create_node_bin_op(c, lhs, assign_op, coerced_rhs);
     } else {
@@ -1733,7 +1734,7 @@ static AstNode *trans_create_compound_assign_shift(Context *c, ResultUsed result
 
         AstNode *rhs = trans_expr(c, ResultUsedYes, &child_scope->base, ZigClangCompoundAssignOperator_getRHS(stmt), TransRValue);
         if (rhs == nullptr) return nullptr;
-        AstNode *coerced_rhs = trans_create_node_fn_call_1(c, rhs_type, rhs);
+        AstNode *coerced_rhs = trans_create_node_cast(c, rhs_type, rhs);
 
         // operation_type(*_ref)
         AstNode *operation_type_cast = trans_c_cast(c, rhs_location,
@@ -2684,7 +2685,7 @@ static AstNode *to_enum_zero_cmp(Context *c, AstNode *expr, AstNode *enum_type)
 
     // @TagType(Enum)(0)
     AstNode *zero = trans_create_node_unsigned_negative(c, 0, false);
-    AstNode *casted_zero = trans_create_node_fn_call_1(c, tag_type, zero);
+    AstNode *casted_zero = trans_create_node_cast(c, tag_type, zero);
 
     // @bitCast(Enum, @TagType(Enum)(0))
     AstNode *bitcast = trans_create_node_builtin_fn_call_str(c, "bitCast");