authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-11-24 15:17:55-05:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-11-24 15:17:55-05:00
log44b1dc6db856e1d77ccf12c754351bda0c53804c
tree4ea04ef8043575caab9fb1ff8db0d5c677493ea7
parent4c7b52503b064b8be2f2afd4152311aff1941d92
signaturelock-open Commit is signed but in an unrecognized format.

add type coercion: [:x]T to [*:x]T

3 files changed, 260 insertions(+), 159 deletions(-)

lib/std/special/test_runner.zig+1-1
......@@ -36,7 +36,7 @@ pub fn main() anyerror!void {
3636 }
3737 root_node.end();
3838 if (ok_count == test_fn_list.len) {
39 std.debug.warn("All tests passed.\n");
39 std.debug.warn("All {} tests passed.\n", ok_count);
4040 } else {
4141 std.debug.warn("{} passed; {} skipped.\n", ok_count, skip_count);
4242 }
src/ir.cpp+206-158
......@@ -188,7 +188,8 @@ struct ConstCastPtrSentinel {
188188static IrInstruction *ir_gen_node(IrBuilder *irb, AstNode *node, Scope *scope);
189189static IrInstruction *ir_gen_node_extra(IrBuilder *irb, AstNode *node, Scope *scope, LVal lval,
190190 ResultLoc *result_loc);
191static IrInstruction *ir_implicit_cast(IrAnalyze *ira, IrInstruction *value, ZigType *expected_type);
191static IrInstruction *ir_implicit_cast(IrAnalyze *ira, IrInstruction *source_instr,
192 IrInstruction *value, ZigType *expected_type);
192193static IrInstruction *ir_get_deref(IrAnalyze *ira, IrInstruction *source_instruction, IrInstruction *ptr,
193194 ResultLoc *result_loc);
194195static ErrorMsg *exec_add_error_node(CodeGen *codegen, IrExecutable *exec, AstNode *source_node, Buf *msg);
......@@ -11717,7 +11718,7 @@ static IrInstruction *ir_analyze_optional_wrap(IrAnalyze *ira, IrInstruction *so
1171711718
1171811719 if (instr_is_comptime(value)) {
1171911720 ZigType *payload_type = wanted_type->data.maybe.child_type;
11720 IrInstruction *casted_payload = ir_implicit_cast(ira, value, payload_type);
11721 IrInstruction *casted_payload = ir_implicit_cast(ira, source_instr, value, payload_type);
1172111722 if (type_is_invalid(casted_payload->value.type))
1172211723 return ira->codegen->invalid_instruction;
1172311724
......@@ -11760,7 +11761,7 @@ static IrInstruction *ir_analyze_err_wrap_payload(IrAnalyze *ira, IrInstruction
1176011761 ZigType *payload_type = wanted_type->data.error_union.payload_type;
1176111762 ZigType *err_set_type = wanted_type->data.error_union.err_set_type;
1176211763 if (instr_is_comptime(value)) {
11763 IrInstruction *casted_payload = ir_implicit_cast(ira, value, payload_type);
11764 IrInstruction *casted_payload = ir_implicit_cast(ira, source_instr, value, payload_type);
1176411765 if (type_is_invalid(casted_payload->value.type))
1176511766 return ira->codegen->invalid_instruction;
1176611767
......@@ -11880,7 +11881,7 @@ static IrInstruction *ir_analyze_err_wrap_code(IrAnalyze *ira, IrInstruction *so
1188011881{
1188111882 assert(wanted_type->id == ZigTypeIdErrorUnion);
1188211883
11883 IrInstruction *casted_value = ir_implicit_cast(ira, value, wanted_type->data.error_union.err_set_type);
11884 IrInstruction *casted_value = ir_implicit_cast(ira, source_instr, value, wanted_type->data.error_union.err_set_type);
1188411885
1188511886 if (instr_is_comptime(casted_value)) {
1188611887 ConstExprValue *val = ir_resolve_const(ira, casted_value, UndefBad);
......@@ -12065,7 +12066,7 @@ static IrInstruction *ir_analyze_enum_to_int(IrAnalyze *ira, IrInstruction *sour
1206512066 enum_type = ir_resolve_union_tag_type(ira, target, target->value.type);
1206612067 if (type_is_invalid(enum_type))
1206712068 return ira->codegen->invalid_instruction;
12068 enum_target = ir_implicit_cast(ira, target, enum_type);
12069 enum_target = ir_implicit_cast(ira, source_instr, target, enum_type);
1206912070 if (type_is_invalid(enum_target->value.type))
1207012071 return ira->codegen->invalid_instruction;
1207112072 } else if (target->value.type->id == ZigTypeIdEnum) {
......@@ -12161,7 +12162,7 @@ static IrInstruction *ir_analyze_enum_to_union(IrAnalyze *ira, IrInstruction *so
1216112162 if ((err = type_resolve(ira->codegen, wanted_type, ResolveStatusZeroBitsKnown)))
1216212163 return ira->codegen->invalid_instruction;
1216312164
12164 IrInstruction *target = ir_implicit_cast(ira, uncasted_target, wanted_type->data.unionation.tag_type);
12165 IrInstruction *target = ir_implicit_cast(ira, source_instr, uncasted_target, wanted_type->data.unionation.tag_type);
1216512166 if (type_is_invalid(target->value.type))
1216612167 return ira->codegen->invalid_instruction;
1216712168
......@@ -12824,8 +12825,55 @@ static IrInstruction *ir_analyze_struct_literal_to_union(IrAnalyze *ira, IrInstr
1282412825 return ira->codegen->invalid_instruction;
1282512826}
1282612827
12828// Add a compile error and return ErrorSemanticAnalyzeFail if the pointer alignment does not work,
12829// otherwise return ErrorNone. Does not emit any instructions.
12830// Assumes that the pointer types have element types with the same ABI alignment. Avoids resolving the
12831// pointer types' alignments if both of the pointer types are ABI aligned.
12832static Error ir_cast_ptr_align(IrAnalyze *ira, IrInstruction *source_instr, ZigType *dest_ptr_type,
12833 ZigType *src_ptr_type, AstNode *src_source_node)
12834{
12835 Error err;
12836
12837 ir_assert(dest_ptr_type->id == ZigTypeIdPointer, source_instr);
12838 ir_assert(src_ptr_type->id == ZigTypeIdPointer, source_instr);
12839
12840 if (dest_ptr_type->data.pointer.explicit_alignment == 0 &&
12841 src_ptr_type->data.pointer.explicit_alignment == 0)
12842 {
12843 return ErrorNone;
12844 }
12845
12846 if ((err = type_resolve(ira->codegen, dest_ptr_type->data.pointer.child_type, ResolveStatusAlignmentKnown)))
12847 return ErrorSemanticAnalyzeFail;
12848
12849 if ((err = type_resolve(ira->codegen, src_ptr_type->data.pointer.child_type, ResolveStatusAlignmentKnown)))
12850 return ErrorSemanticAnalyzeFail;
12851
12852 uint32_t wanted_align = get_ptr_align(ira->codegen, dest_ptr_type);
12853 uint32_t actual_align = get_ptr_align(ira->codegen, src_ptr_type);
12854 if (wanted_align > actual_align) {
12855 ErrorMsg *msg = ir_add_error(ira, source_instr, buf_sprintf("cast increases pointer alignment"));
12856 add_error_note(ira->codegen, msg, src_source_node,
12857 buf_sprintf("'%s' has alignment %" PRIu32, buf_ptr(&src_ptr_type->name), actual_align));
12858 add_error_note(ira->codegen, msg, source_instr->source_node,
12859 buf_sprintf("'%s' has alignment %" PRIu32, buf_ptr(&dest_ptr_type->name), wanted_align));
12860 return ErrorSemanticAnalyzeFail;
12861 }
12862
12863 return ErrorNone;
12864}
12865
12866static IrInstruction *ir_analyze_struct_value_field_value(IrAnalyze *ira, IrInstruction *source_instr,
12867 IrInstruction *struct_operand, TypeStructField *field)
12868{
12869 IrInstruction *struct_ptr = ir_get_ref(ira, source_instr, struct_operand, true, false);
12870 IrInstruction *field_ptr = ir_analyze_struct_field_ptr(ira, source_instr, field, struct_ptr,
12871 struct_operand->value.type, false);
12872 return ir_get_deref(ira, source_instr, field_ptr, nullptr);
12873}
12874
1282712875static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_instr,
12828 ZigType *wanted_type, IrInstruction *value, ResultLoc *result_loc)
12876 ZigType *wanted_type, IrInstruction *value)
1282912877{
1283012878 Error err;
1283112879 ZigType *actual_type = value->value.type;
......@@ -12871,12 +12919,12 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1287112919 if (types_match_const_cast_only(ira, wanted_child_type, actual_type, source_node,
1287212920 false).id == ConstCastResultIdOk)
1287312921 {
12874 return ir_analyze_optional_wrap(ira, source_instr, value, wanted_type, result_loc);
12922 return ir_analyze_optional_wrap(ira, source_instr, value, wanted_type, nullptr);
1287512923 } else if (actual_type->id == ZigTypeIdComptimeInt ||
1287612924 actual_type->id == ZigTypeIdComptimeFloat)
1287712925 {
1287812926 if (ir_num_lit_fits_in_other_type(ira, value, wanted_child_type, true)) {
12879 return ir_analyze_optional_wrap(ira, source_instr, value, wanted_type, result_loc);
12927 return ir_analyze_optional_wrap(ira, source_instr, value, wanted_type, nullptr);
1288012928 } else {
1288112929 return ira->codegen->invalid_instruction;
1288212930 }
......@@ -12900,7 +12948,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1290012948 wanted_child_type);
1290112949 if (type_is_invalid(cast1->value.type))
1290212950 return ira->codegen->invalid_instruction;
12903 return ir_analyze_optional_wrap(ira, source_instr, cast1, wanted_type, result_loc);
12951 return ir_analyze_optional_wrap(ira, source_instr, cast1, wanted_type, nullptr);
1290412952 }
1290512953 }
1290612954 }
......@@ -12910,12 +12958,12 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1291012958 if (types_match_const_cast_only(ira, wanted_type->data.error_union.payload_type, actual_type,
1291112959 source_node, false).id == ConstCastResultIdOk)
1291212960 {
12913 return ir_analyze_err_wrap_payload(ira, source_instr, value, wanted_type, result_loc);
12961 return ir_analyze_err_wrap_payload(ira, source_instr, value, wanted_type, nullptr);
1291412962 } else if (actual_type->id == ZigTypeIdComptimeInt ||
1291512963 actual_type->id == ZigTypeIdComptimeFloat)
1291612964 {
1291712965 if (ir_num_lit_fits_in_other_type(ira, value, wanted_type->data.error_union.payload_type, true)) {
12918 return ir_analyze_err_wrap_payload(ira, source_instr, value, wanted_type, result_loc);
12966 return ir_analyze_err_wrap_payload(ira, source_instr, value, wanted_type, nullptr);
1291912967 } else {
1292012968 return ira->codegen->invalid_instruction;
1292112969 }
......@@ -12933,11 +12981,11 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1293312981 actual_type->id == ZigTypeIdComptimeInt ||
1293412982 actual_type->id == ZigTypeIdComptimeFloat)
1293512983 {
12936 IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.error_union.payload_type, value, nullptr);
12984 IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.error_union.payload_type, value);
1293712985 if (type_is_invalid(cast1->value.type))
1293812986 return ira->codegen->invalid_instruction;
1293912987
12940 IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1, result_loc);
12988 IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1);
1294112989 if (type_is_invalid(cast2->value.type))
1294212990 return ira->codegen->invalid_instruction;
1294312991
......@@ -13019,7 +13067,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1301913067 types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type,
1302013068 source_node, false).id == ConstCastResultIdOk)
1302113069 {
13022 return ir_analyze_array_to_slice(ira, source_instr, value, wanted_type, result_loc);
13070 return ir_analyze_array_to_slice(ira, source_instr, value, wanted_type, nullptr);
1302313071 }
1302413072 }
1302513073
......@@ -13036,11 +13084,11 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1303613084 types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type,
1303713085 source_node, false).id == ConstCastResultIdOk)
1303813086 {
13039 IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.maybe.child_type, value, nullptr);
13087 IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.maybe.child_type, value);
1304013088 if (type_is_invalid(cast1->value.type))
1304113089 return ira->codegen->invalid_instruction;
1304213090
13043 IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1, result_loc);
13091 IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1);
1304413092 if (type_is_invalid(cast2->value.type))
1304513093 return ira->codegen->invalid_instruction;
1304613094
......@@ -13055,11 +13103,11 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1305513103 actual_type->data.pointer.ptr_len == PtrLenSingle &&
1305613104 actual_type->data.pointer.child_type->id == ZigTypeIdArray)
1305713105 {
13058 IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.maybe.child_type, value, nullptr);
13106 IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.maybe.child_type, value);
1305913107 if (type_is_invalid(cast1->value.type))
1306013108 return ira->codegen->invalid_instruction;
1306113109
13062 IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1, result_loc);
13110 IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1);
1306313111 if (type_is_invalid(cast2->value.type))
1306413112 return ira->codegen->invalid_instruction;
1306513113
......@@ -13136,17 +13184,17 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1313613184 }
1313713185 if (ok_align) {
1313813186 if (wanted_type->id == ZigTypeIdErrorUnion) {
13139 IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, slice_type, value, nullptr);
13187 IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, slice_type, value);
1314013188 if (type_is_invalid(cast1->value.type))
1314113189 return ira->codegen->invalid_instruction;
1314213190
13143 IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1, result_loc);
13191 IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1);
1314413192 if (type_is_invalid(cast2->value.type))
1314513193 return ira->codegen->invalid_instruction;
1314613194
1314713195 return cast2;
1314813196 } else {
13149 return ir_resolve_ptr_of_array_to_slice(ira, source_instr, value, slice_type, result_loc);
13197 return ir_resolve_ptr_of_array_to_slice(ira, source_instr, value, slice_type, nullptr);
1315013198 }
1315113199 }
1315213200 }
......@@ -13187,7 +13235,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1318713235 ok_align = get_ptr_align(ira->codegen, actual_type) >= get_ptr_align(ira->codegen, slice_ptr_type);
1318813236 }
1318913237 if (ok_align) {
13190 return ir_resolve_ptr_of_array_to_slice(ira, source_instr, value, slice_type, result_loc);
13238 return ir_resolve_ptr_of_array_to_slice(ira, source_instr, value, slice_type, nullptr);
1319113239 }
1319213240 }
1319313241 }
......@@ -13243,11 +13291,11 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1324313291 types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type,
1324413292 source_node, false).id == ConstCastResultIdOk)
1324513293 {
13246 IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.error_union.payload_type, value, nullptr);
13294 IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.error_union.payload_type, value);
1324713295 if (type_is_invalid(cast1->value.type))
1324813296 return ira->codegen->invalid_instruction;
1324913297
13250 IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1, result_loc);
13298 IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1);
1325113299 if (type_is_invalid(cast2->value.type))
1325213300 return ira->codegen->invalid_instruction;
1325313301
......@@ -13259,7 +13307,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1325913307 if (wanted_type->id == ZigTypeIdErrorUnion &&
1326013308 actual_type->id == ZigTypeIdErrorSet)
1326113309 {
13262 return ir_analyze_err_wrap_code(ira, source_instr, value, wanted_type, result_loc);
13310 return ir_analyze_err_wrap_code(ira, source_instr, value, wanted_type, nullptr);
1326313311 }
1326413312
1326513313 // cast from typed number to integer or float literal.
......@@ -13285,7 +13333,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1328513333 if (result == ira->codegen->invalid_instruction)
1328613334 return result;
1328713335
13288 return ir_analyze_optional_wrap(ira, result, value, wanted_type, result_loc);
13336 return ir_analyze_optional_wrap(ira, result, value, wanted_type, nullptr);
1328913337 }
1329013338
1329113339 // cast from enum literal to error union when payload is an enum
......@@ -13296,7 +13344,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1329613344 if (result == ira->codegen->invalid_instruction)
1329713345 return result;
1329813346
13299 return ir_analyze_err_wrap_payload(ira, result, value, wanted_type, result_loc);
13347 return ir_analyze_err_wrap_payload(ira, result, value, wanted_type, nullptr);
1330013348 }
1330113349
1330213350 // cast from union to the enum type of the union
......@@ -13326,35 +13374,39 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1332613374 types_match_const_cast_only(ira, array_type->data.array.child_type,
1332713375 actual_type->data.pointer.child_type, source_node,
1332813376 !wanted_type->data.pointer.is_const).id == ConstCastResultIdOk &&
13329 // This should be the job of `types_match_const_cast_only`
13330 // but `types_match_const_cast_only` only gets info for child_types
13331 ((wanted_type->data.pointer.is_const && actual_type->data.pointer.is_const) ||
13332 !actual_type->data.pointer.is_const))
13377 // `types_match_const_cast_only` only gets info for child_types
13378 (!wanted_type->data.pointer.is_const || actual_type->data.pointer.is_const) &&
13379 (!wanted_type->data.pointer.is_volatile || actual_type->data.pointer.is_volatile))
1333313380 {
13334 if ((err = type_resolve(ira->codegen, wanted_type->data.pointer.child_type,
13335 ResolveStatusAlignmentKnown)))
13336 {
13337 return ira->codegen->invalid_instruction;
13338 }
13339 if ((err = type_resolve(ira->codegen, actual_type->data.pointer.child_type,
13340 ResolveStatusAlignmentKnown)))
13341 {
13342 return ira->codegen->invalid_instruction;
13343 }
13344 uint32_t wanted_align = get_ptr_align(ira->codegen, wanted_type);
13345 uint32_t actual_align = get_ptr_align(ira->codegen, actual_type);
13346 if (wanted_align > actual_align) {
13347 ErrorMsg *msg = ir_add_error(ira, source_instr, buf_sprintf("cast increases pointer alignment"));
13348 add_error_note(ira->codegen, msg, value->source_node,
13349 buf_sprintf("'%s' has alignment %" PRIu32, buf_ptr(&actual_type->name), actual_align));
13350 add_error_note(ira->codegen, msg, source_instr->source_node,
13351 buf_sprintf("'%s' has alignment %" PRIu32, buf_ptr(&wanted_type->name), wanted_align));
13381 if ((err = ir_cast_ptr_align(ira, source_instr, wanted_type, actual_type, value->source_node)))
1335213382 return ira->codegen->invalid_instruction;
13353 }
13383
1335413384 return ir_analyze_ptr_to_array(ira, source_instr, value, wanted_type);
1335513385 }
1335613386 }
1335713387
13388 // [:x]T to [*:x]T
13389 // [:x]T to [*c]T
13390 if (wanted_type->id == ZigTypeIdPointer && is_slice(actual_type) &&
13391 ((wanted_type->data.pointer.ptr_len == PtrLenUnknown && wanted_type->data.pointer.sentinel != nullptr) ||
13392 wanted_type->data.pointer.ptr_len == PtrLenC))
13393 {
13394 ZigType *slice_ptr_type = resolve_struct_field_type(ira->codegen,
13395 actual_type->data.structure.fields[slice_ptr_index]);
13396 if (types_match_const_cast_only(ira, wanted_type->data.pointer.child_type,
13397 slice_ptr_type->data.pointer.child_type, source_node,
13398 !wanted_type->data.pointer.is_const).id == ConstCastResultIdOk &&
13399 (slice_ptr_type->data.pointer.sentinel != nullptr &&
13400 (wanted_type->data.pointer.ptr_len == PtrLenC ||
13401 const_values_equal(ira->codegen, wanted_type->data.pointer.sentinel,
13402 slice_ptr_type->data.pointer.sentinel))))
13403 {
13404 TypeStructField *ptr_field = actual_type->data.structure.fields[slice_ptr_index];
13405 IrInstruction *slice_ptr = ir_analyze_struct_value_field_value(ira, source_instr, value, ptr_field);
13406 return ir_implicit_cast(ira, source_instr, slice_ptr, wanted_type);
13407 }
13408 }
13409
1335813410 // cast from *T and [*]T to *c_void and ?*c_void
1335913411 // but don't do it if the actual type is a double pointer
1336013412 if (is_pointery_and_elem_is_not_pointery(actual_type)) {
......@@ -13393,7 +13445,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1339313445 types_match_const_cast_only(ira, wanted_type->data.array.child_type,
1339413446 actual_type->data.vector.elem_type, source_node, false).id == ConstCastResultIdOk)
1339513447 {
13396 return ir_analyze_vector_to_array(ira, source_instr, value, wanted_type, result_loc);
13448 return ir_analyze_vector_to_array(ira, source_instr, value, wanted_type, nullptr);
1339713449 }
1339813450
1339913451 // cast from [N]T to @Vector(N, T)
......@@ -13454,8 +13506,8 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1345413506 return ira->codegen->invalid_instruction;
1345513507}
1345613508
13457static IrInstruction *ir_implicit_cast_with_result(IrAnalyze *ira, IrInstruction *source_instr,
13458 IrInstruction *value, ZigType *expected_type, ResultLoc *result_loc)
13509static IrInstruction *ir_implicit_cast(IrAnalyze *ira, IrInstruction *source_instr,
13510 IrInstruction *value, ZigType *expected_type)
1345913511{
1346013512 assert(value);
1346113513 assert(value != ira->codegen->invalid_instruction);
......@@ -13469,11 +13521,7 @@ static IrInstruction *ir_implicit_cast_with_result(IrAnalyze *ira, IrInstruction
1346913521 if (value->value.type->id == ZigTypeIdUnreachable)
1347013522 return value;
1347113523
13472 return ir_analyze_cast(ira, source_instr, expected_type, value, result_loc);
13473}
13474
13475static IrInstruction *ir_implicit_cast(IrAnalyze *ira, IrInstruction *value, ZigType *expected_type) {
13476 return ir_implicit_cast_with_result(ira, value, value, expected_type, nullptr);
13524 return ir_analyze_cast(ira, source_instr, expected_type, value);
1347713525}
1347813526
1347913527static IrInstruction *ir_get_deref(IrAnalyze *ira, IrInstruction *source_instruction, IrInstruction *ptr,
......@@ -13611,7 +13659,7 @@ static bool ir_resolve_align(IrAnalyze *ira, IrInstruction *value, ZigType *elem
1361113659 }
1361213660 }
1361313661
13614 IrInstruction *casted_value = ir_implicit_cast(ira, value, get_align_amt_type(ira->codegen));
13662 IrInstruction *casted_value = ir_implicit_cast(ira, value, value, get_align_amt_type(ira->codegen));
1361513663 if (type_is_invalid(casted_value->value.type))
1361613664 return false;
1361713665
......@@ -13623,7 +13671,7 @@ static bool ir_resolve_unsigned(IrAnalyze *ira, IrInstruction *value, ZigType *i
1362313671 if (type_is_invalid(value->value.type))
1362413672 return false;
1362513673
13626 IrInstruction *casted_value = ir_implicit_cast(ira, value, int_type);
13674 IrInstruction *casted_value = ir_implicit_cast(ira, value, value, int_type);
1362713675 if (type_is_invalid(casted_value->value.type))
1362813676 return false;
1362913677
......@@ -13643,7 +13691,7 @@ static bool ir_resolve_bool(IrAnalyze *ira, IrInstruction *value, bool *out) {
1364313691 if (type_is_invalid(value->value.type))
1364413692 return false;
1364513693
13646 IrInstruction *casted_value = ir_implicit_cast(ira, value, ira->codegen->builtin_types.entry_bool);
13694 IrInstruction *casted_value = ir_implicit_cast(ira, value, value, ira->codegen->builtin_types.entry_bool);
1364713695 if (type_is_invalid(casted_value->value.type))
1364813696 return false;
1364913697
......@@ -13671,7 +13719,7 @@ static bool ir_resolve_atomic_order(IrAnalyze *ira, IrInstruction *value, Atomic
1367113719 assert(atomic_order_val->type->id == ZigTypeIdMetaType);
1367213720 ZigType *atomic_order_type = atomic_order_val->data.x_type;
1367313721
13674 IrInstruction *casted_value = ir_implicit_cast(ira, value, atomic_order_type);
13722 IrInstruction *casted_value = ir_implicit_cast(ira, value, value, atomic_order_type);
1367513723 if (type_is_invalid(casted_value->value.type))
1367613724 return false;
1367713725
......@@ -13691,7 +13739,7 @@ static bool ir_resolve_atomic_rmw_op(IrAnalyze *ira, IrInstruction *value, Atomi
1369113739 assert(atomic_rmw_op_val->type->id == ZigTypeIdMetaType);
1369213740 ZigType *atomic_rmw_op_type = atomic_rmw_op_val->data.x_type;
1369313741
13694 IrInstruction *casted_value = ir_implicit_cast(ira, value, atomic_rmw_op_type);
13742 IrInstruction *casted_value = ir_implicit_cast(ira, value, value, atomic_rmw_op_type);
1369513743 if (type_is_invalid(casted_value->value.type))
1369613744 return false;
1369713745
......@@ -13711,7 +13759,7 @@ static bool ir_resolve_global_linkage(IrAnalyze *ira, IrInstruction *value, Glob
1371113759 assert(global_linkage_val->type->id == ZigTypeIdMetaType);
1371213760 ZigType *global_linkage_type = global_linkage_val->data.x_type;
1371313761
13714 IrInstruction *casted_value = ir_implicit_cast(ira, value, global_linkage_type);
13762 IrInstruction *casted_value = ir_implicit_cast(ira, value, value, global_linkage_type);
1371513763 if (type_is_invalid(casted_value->value.type))
1371613764 return false;
1371713765
......@@ -13731,7 +13779,7 @@ static bool ir_resolve_float_mode(IrAnalyze *ira, IrInstruction *value, FloatMod
1373113779 assert(float_mode_val->type->id == ZigTypeIdMetaType);
1373213780 ZigType *float_mode_type = float_mode_val->data.x_type;
1373313781
13734 IrInstruction *casted_value = ir_implicit_cast(ira, value, float_mode_type);
13782 IrInstruction *casted_value = ir_implicit_cast(ira, value, value, float_mode_type);
1373513783 if (type_is_invalid(casted_value->value.type))
1373613784 return false;
1373713785
......@@ -13750,7 +13798,7 @@ static Buf *ir_resolve_str(IrAnalyze *ira, IrInstruction *value) {
1375013798 ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
1375113799 true, false, PtrLenUnknown, 0, 0, 0, false);
1375213800 ZigType *str_type = get_slice_type(ira->codegen, ptr_type);
13753 IrInstruction *casted_value = ir_implicit_cast(ira, value, str_type);
13801 IrInstruction *casted_value = ir_implicit_cast(ira, value, value, str_type);
1375413802 if (type_is_invalid(casted_value->value.type))
1375513803 return nullptr;
1375613804
......@@ -13814,7 +13862,7 @@ static IrInstruction *ir_analyze_instruction_return(IrAnalyze *ira, IrInstructio
1381413862 return ir_finish_anal(ira, result);
1381513863 }
1381613864
13817 IrInstruction *casted_operand = ir_implicit_cast(ira, operand, ira->explicit_return_type);
13865 IrInstruction *casted_operand = ir_implicit_cast(ira, &instruction->base, operand, ira->explicit_return_type);
1381813866 if (type_is_invalid(casted_operand->value.type)) {
1381913867 AstNode *source_node = ira->explicit_return_type_source_node;
1382013868 if (source_node != nullptr) {
......@@ -13856,11 +13904,11 @@ static IrInstruction *ir_analyze_bin_op_bool(IrAnalyze *ira, IrInstructionBinOp
1385613904
1385713905 ZigType *bool_type = ira->codegen->builtin_types.entry_bool;
1385813906
13859 IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, bool_type);
13907 IrInstruction *casted_op1 = ir_implicit_cast(ira, &bin_op_instruction->base, op1, bool_type);
1386013908 if (casted_op1 == ira->codegen->invalid_instruction)
1386113909 return ira->codegen->invalid_instruction;
1386213910
13863 IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, bool_type);
13911 IrInstruction *casted_op2 = ir_implicit_cast(ira, &bin_op_instruction->base, op2, bool_type);
1386413912 if (casted_op2 == ira->codegen->invalid_instruction)
1386513913 return ira->codegen->invalid_instruction;
1386613914
......@@ -14129,11 +14177,11 @@ static IrInstruction *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *
1412914177 ZigType *tag_type = union_val->value.type->data.unionation.tag_type;
1413014178 assert(tag_type != nullptr);
1413114179
14132 IrInstruction *casted_union = ir_implicit_cast(ira, union_val, tag_type);
14180 IrInstruction *casted_union = ir_implicit_cast(ira, &bin_op_instruction->base, union_val, tag_type);
1413314181 if (type_is_invalid(casted_union->value.type))
1413414182 return ira->codegen->invalid_instruction;
1413514183
14136 IrInstruction *casted_val = ir_implicit_cast(ira, enum_val, tag_type);
14184 IrInstruction *casted_val = ir_implicit_cast(ira, &bin_op_instruction->base, enum_val, tag_type);
1413714185 if (type_is_invalid(casted_val->value.type))
1413814186 return ira->codegen->invalid_instruction;
1413914187
......@@ -14296,11 +14344,11 @@ static IrInstruction *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *
1429614344 return ira->codegen->invalid_instruction;
1429714345 }
1429814346
14299 IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, resolved_type);
14347 IrInstruction *casted_op1 = ir_implicit_cast(ira, &bin_op_instruction->base, op1, resolved_type);
1430014348 if (casted_op1 == ira->codegen->invalid_instruction)
1430114349 return ira->codegen->invalid_instruction;
1430214350
14303 IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, resolved_type);
14351 IrInstruction *casted_op2 = ir_implicit_cast(ira, &bin_op_instruction->base, op2, resolved_type);
1430414352 if (casted_op2 == ira->codegen->invalid_instruction)
1430514353 return ira->codegen->invalid_instruction;
1430614354
......@@ -14648,7 +14696,7 @@ static IrInstruction *ir_analyze_math_op(IrAnalyze *ira, IrInstruction *source_i
1464814696 return ira->codegen->invalid_instruction;
1464914697 }
1465014698 }
14651 return ir_implicit_cast(ira, result_instruction, type_entry);
14699 return ir_implicit_cast(ira, source_instr, result_instruction, type_entry);
1465214700}
1465314701
1465414702static IrInstruction *ir_analyze_bit_shift(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
......@@ -14713,7 +14761,7 @@ static IrInstruction *ir_analyze_bit_shift(IrAnalyze *ira, IrInstructionBinOp *b
1471314761 }
1471414762 }
1471514763
14716 casted_op2 = ir_implicit_cast(ira, op2, shift_amt_type);
14764 casted_op2 = ir_implicit_cast(ira, &bin_op_instruction->base, op2, shift_amt_type);
1471714765 if (casted_op2 == ira->codegen->invalid_instruction)
1471814766 return ira->codegen->invalid_instruction;
1471914767 }
......@@ -14822,7 +14870,7 @@ static IrInstruction *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp
1482214870
1482314871 // look for pointer math
1482414872 if (is_pointer_arithmetic_allowed(op1->value.type, op_id)) {
14825 IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, ira->codegen->builtin_types.entry_usize);
14873 IrInstruction *casted_op2 = ir_implicit_cast(ira, &instruction->base, op2, ira->codegen->builtin_types.entry_usize);
1482614874 if (type_is_invalid(casted_op2->value.type))
1482714875 return ira->codegen->invalid_instruction;
1482814876
......@@ -14958,7 +15006,7 @@ static IrInstruction *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp
1495815006 ok = bigint_cmp(&rem_result, &mod_result) == CmpEQ;
1495915007 }
1496015008 } else {
14961 IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, resolved_type);
15009 IrInstruction *casted_op2 = ir_implicit_cast(ira, &instruction->base, op2, resolved_type);
1496215010 if (casted_op2 == ira->codegen->invalid_instruction)
1496315011 return ira->codegen->invalid_instruction;
1496415012
......@@ -15022,11 +15070,11 @@ static IrInstruction *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp
1502215070 }
1502315071 }
1502415072
15025 IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, resolved_type);
15073 IrInstruction *casted_op1 = ir_implicit_cast(ira, &instruction->base, op1, resolved_type);
1502615074 if (casted_op1 == ira->codegen->invalid_instruction)
1502715075 return ira->codegen->invalid_instruction;
1502815076
15029 IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, resolved_type);
15077 IrInstruction *casted_op2 = ir_implicit_cast(ira, &instruction->base, op2, resolved_type);
1503015078 if (casted_op2 == ira->codegen->invalid_instruction)
1503115079 return ira->codegen->invalid_instruction;
1503215080
......@@ -16239,7 +16287,7 @@ static IrInstruction *ir_resolve_result_raw(IrAnalyze *ira, IrInstruction *suspe
1623916287 // In this case we can pointer cast the result location.
1624016288 IrInstruction *casted_value;
1624116289 if (value != nullptr) {
16242 casted_value = ir_implicit_cast(ira, value, dest_type);
16290 casted_value = ir_implicit_cast(ira, value, value, dest_type);
1624316291 } else {
1624416292 casted_value = nullptr;
1624516293 }
......@@ -16530,7 +16578,7 @@ static IrInstruction *get_async_call_result_loc(IrAnalyze *ira, IrInstructionCal
1653016578 // Result location will be inside the async frame.
1653116579 return nullptr;
1653216580 }
16533 return ir_implicit_cast(ira, ret_ptr_uncasted, get_pointer_to_type(ira->codegen, fn_ret_type, false));
16581 return ir_implicit_cast(ira, ret_ptr_uncasted, ret_ptr_uncasted, get_pointer_to_type(ira->codegen, fn_ret_type, false));
1653416582}
1653516583
1653616584static IrInstruction *ir_analyze_async_call(IrAnalyze *ira, IrInstructionCallSrc *call_instruction, ZigFn *fn_entry,
......@@ -16567,7 +16615,7 @@ static IrInstruction *ir_analyze_async_call(IrAnalyze *ira, IrInstructionCallSrc
1656716615 if (type_is_invalid(result_loc->value.type) || instr_is_unreachable(result_loc)) {
1656816616 return result_loc;
1656916617 }
16570 result_loc = ir_implicit_cast(ira, result_loc, get_pointer_to_type(ira->codegen, frame_type, false));
16618 result_loc = ir_implicit_cast(ira, &call_instruction->base, result_loc, get_pointer_to_type(ira->codegen, frame_type, false));
1657116619 if (type_is_invalid(result_loc->value.type))
1657216620 return ira->codegen->invalid_instruction;
1657316621 return &ir_build_call_gen(ira, &call_instruction->base, fn_entry, fn_ref, arg_count,
......@@ -16588,7 +16636,7 @@ static bool ir_analyze_fn_call_inline_arg(IrAnalyze *ira, AstNode *fn_proto_node
1658816636 if (type_is_invalid(param_type))
1658916637 return false;
1659016638
16591 casted_arg = ir_implicit_cast(ira, arg, param_type);
16639 casted_arg = ir_implicit_cast(ira, arg, arg, param_type);
1659216640 if (type_is_invalid(casted_arg->value.type))
1659316641 return false;
1659416642 } else {
......@@ -16628,7 +16676,7 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze *ira, AstNode *fn_proto_nod
1662816676 if (type_is_invalid(param_type))
1662916677 return false;
1663016678
16631 casted_arg = ir_implicit_cast(ira, arg, param_type);
16679 casted_arg = ir_implicit_cast(ira, arg, arg, param_type);
1663216680 if (type_is_invalid(casted_arg->value.type))
1663316681 return false;
1663416682 } else {
......@@ -16869,7 +16917,7 @@ static IrInstruction *ir_analyze_store_ptr(IrAnalyze *ira, IrInstruction *source
1686916917 }
1687016918
1687116919 ZigType *child_type = ptr->value.type->data.pointer.child_type;
16872 IrInstruction *value = ir_implicit_cast(ira, uncasted_value, child_type);
16920 IrInstruction *value = ir_implicit_cast(ira, uncasted_value, uncasted_value, child_type);
1687316921 if (value == ira->codegen->invalid_instruction)
1687416922 return ira->codegen->invalid_instruction;
1687516923
......@@ -16986,13 +17034,13 @@ static IrInstruction *analyze_casted_new_stack(IrAnalyze *ira, IrInstructionCall
1698617034 {
1698717035 ZigType *needed_frame_type = get_pointer_to_type(ira->codegen,
1698817036 get_fn_frame_type(ira->codegen, fn_entry), false);
16989 return ir_implicit_cast(ira, new_stack, needed_frame_type);
17037 return ir_implicit_cast(ira, &call_instruction->base, new_stack, needed_frame_type);
1699017038 } else {
1699117039 ZigType *u8_ptr = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
1699217040 false, false, PtrLenUnknown, target_fn_align(ira->codegen->zig_target), 0, 0, false);
1699317041 ZigType *u8_slice = get_slice_type(ira->codegen, u8_ptr);
1699417042 ira->codegen->need_frame_size_prefix_data = true;
16995 return ir_implicit_cast(ira, new_stack, u8_slice);
17043 return ir_implicit_cast(ira, &call_instruction->base, new_stack, u8_slice);
1699617044 }
1699717045}
1699817046
......@@ -17466,7 +17514,7 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCallSrc *c
1746617514 return ira->codegen->invalid_instruction;
1746717515 }
1746817516
17469 IrInstruction *casted_arg = ir_implicit_cast(ira, first_arg, param_type);
17517 IrInstruction *casted_arg = ir_implicit_cast(ira, first_arg, first_arg, param_type);
1747017518 if (type_is_invalid(casted_arg->value.type))
1747117519 return ira->codegen->invalid_instruction;
1747217520
......@@ -17501,7 +17549,7 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCallSrc *c
1750117549 ZigType *param_type = fn_type_id->param_info[next_arg_index].type;
1750217550 if (type_is_invalid(param_type))
1750317551 return ira->codegen->invalid_instruction;
17504 casted_arg = ir_implicit_cast(ira, arg_tuple_arg, param_type);
17552 casted_arg = ir_implicit_cast(ira, arg_tuple_arg, arg_tuple_arg, param_type);
1750517553 if (type_is_invalid(casted_arg->value.type))
1750617554 return ira->codegen->invalid_instruction;
1750717555 } else {
......@@ -17517,7 +17565,7 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCallSrc *c
1751717565 ZigType *param_type = fn_type_id->param_info[next_arg_index].type;
1751817566 if (type_is_invalid(param_type))
1751917567 return ira->codegen->invalid_instruction;
17520 casted_arg = ir_implicit_cast(ira, old_arg, param_type);
17568 casted_arg = ir_implicit_cast(ira, old_arg, old_arg, param_type);
1752117569 if (type_is_invalid(casted_arg->value.type))
1752217570 return ira->codegen->invalid_instruction;
1752317571 } else {
......@@ -17949,7 +17997,7 @@ static IrInstruction *ir_analyze_instruction_cond_br(IrAnalyze *ira, IrInstructi
1794917997 return ir_unreach_error(ira);
1795017998
1795117999 ZigType *bool_type = ira->codegen->builtin_types.entry_bool;
17952 IrInstruction *casted_condition = ir_implicit_cast(ira, condition, bool_type);
18000 IrInstruction *casted_condition = ir_implicit_cast(ira, &cond_br_instruction->base, condition, bool_type);
1795318001 if (type_is_invalid(casted_condition->value.type))
1795418002 return ir_unreach_error(ira);
1795518003
......@@ -18199,7 +18247,7 @@ skip_resolve_peer_types:
1819918247 ir_assert(predecessor->instruction_list.length != 0, &phi_instruction->base);
1820018248 IrInstruction *branch_instruction = predecessor->instruction_list.pop();
1820118249 ir_set_cursor_at_end(&ira->new_irb, predecessor);
18202 IrInstruction *casted_value = ir_implicit_cast(ira, new_value, resolved_type);
18250 IrInstruction *casted_value = ir_implicit_cast(ira, new_value, new_value, resolved_type);
1820318251 if (type_is_invalid(casted_value->value.type)) {
1820418252 return ira->codegen->invalid_instruction;
1820518253 }
......@@ -18385,7 +18433,7 @@ static IrInstruction *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstruct
1838518433 array_type->data.structure.resolve_status == ResolveStatusBeingInferred)
1838618434 {
1838718435 ZigType *usize = ira->codegen->builtin_types.entry_usize;
18388 IrInstruction *casted_elem_index = ir_implicit_cast(ira, elem_index, usize);
18436 IrInstruction *casted_elem_index = ir_implicit_cast(ira, elem_index, elem_index, usize);
1838918437 if (casted_elem_index == ira->codegen->invalid_instruction)
1839018438 return ira->codegen->invalid_instruction;
1839118439 ir_assert(instr_is_comptime(casted_elem_index), &elem_ptr_instruction->base);
......@@ -18400,7 +18448,7 @@ static IrInstruction *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstruct
1840018448 }
1840118449
1840218450 ZigType *usize = ira->codegen->builtin_types.entry_usize;
18403 IrInstruction *casted_elem_index = ir_implicit_cast(ira, elem_index, usize);
18451 IrInstruction *casted_elem_index = ir_implicit_cast(ira, elem_index, elem_index, usize);
1840418452 if (casted_elem_index == ira->codegen->invalid_instruction)
1840518453 return ira->codegen->invalid_instruction;
1840618454
......@@ -19759,7 +19807,7 @@ static IrInstruction *ir_analyze_instruction_array_type(IrAnalyze *ira,
1975919807 IrInstruction *uncasted_sentinel = array_type_instruction->sentinel->child;
1976019808 if (type_is_invalid(uncasted_sentinel->value.type))
1976119809 return ira->codegen->invalid_instruction;
19762 IrInstruction *sentinel = ir_implicit_cast(ira, uncasted_sentinel, child_type);
19810 IrInstruction *sentinel = ir_implicit_cast(ira, &array_type_instruction->base, uncasted_sentinel, child_type);
1976319811 if (type_is_invalid(sentinel->value.type))
1976419812 return ira->codegen->invalid_instruction;
1976519813 sentinel_val = ir_resolve_const(ira, sentinel, UndefBad);
......@@ -20033,7 +20081,7 @@ static IrInstruction *ir_analyze_instruction_ctz(IrAnalyze *ira, IrInstructionCt
2003320081 if (type_is_invalid(int_type))
2003420082 return ira->codegen->invalid_instruction;
2003520083
20036 IrInstruction *op = ir_implicit_cast(ira, instruction->op->child, int_type);
20084 IrInstruction *op = ir_implicit_cast(ira, &instruction->base, instruction->op->child, int_type);
2003720085 if (type_is_invalid(op->value.type))
2003820086 return ira->codegen->invalid_instruction;
2003920087
......@@ -20062,7 +20110,7 @@ static IrInstruction *ir_analyze_instruction_clz(IrAnalyze *ira, IrInstructionCl
2006220110 if (type_is_invalid(int_type))
2006320111 return ira->codegen->invalid_instruction;
2006420112
20065 IrInstruction *op = ir_implicit_cast(ira, instruction->op->child, int_type);
20113 IrInstruction *op = ir_implicit_cast(ira, &instruction->base, instruction->op->child, int_type);
2006620114 if (type_is_invalid(op->value.type))
2006720115 return ira->codegen->invalid_instruction;
2006820116
......@@ -20091,7 +20139,7 @@ static IrInstruction *ir_analyze_instruction_pop_count(IrAnalyze *ira, IrInstruc
2009120139 if (type_is_invalid(int_type))
2009220140 return ira->codegen->invalid_instruction;
2009320141
20094 IrInstruction *op = ir_implicit_cast(ira, instruction->op->child, int_type);
20142 IrInstruction *op = ir_implicit_cast(ira, &instruction->base, instruction->op->child, int_type);
2009520143 if (type_is_invalid(op->value.type))
2009620144 return ira->codegen->invalid_instruction;
2009720145
......@@ -20201,7 +20249,7 @@ static IrInstruction *ir_analyze_instruction_switch_br(IrAnalyze *ira,
2020120249 return ir_unreach_error(ira);
2020220250 }
2020320251
20204 IrInstruction *casted_case_value = ir_implicit_cast(ira, case_value, target_value->value.type);
20252 IrInstruction *casted_case_value = ir_implicit_cast(ira, case_value, case_value, target_value->value.type);
2020520253 if (type_is_invalid(casted_case_value->value.type))
2020620254 return ir_unreach_error(ira);
2020720255
......@@ -20251,7 +20299,7 @@ static IrInstruction *ir_analyze_instruction_switch_br(IrAnalyze *ira,
2025120299 continue;
2025220300 }
2025320301
20254 IrInstruction *casted_new_value = ir_implicit_cast(ira, new_value, target_value->value.type);
20302 IrInstruction *casted_new_value = ir_implicit_cast(ira, new_value, new_value, target_value->value.type);
2025520303 if (type_is_invalid(casted_new_value->value.type))
2025620304 continue;
2025720305
......@@ -20421,7 +20469,7 @@ static IrInstruction *ir_analyze_instruction_switch_var(IrAnalyze *ira, IrInstru
2042120469 if (type_is_invalid(first_prong_value->value.type))
2042220470 return ira->codegen->invalid_instruction;
2042320471
20424 IrInstruction *first_casted_prong_value = ir_implicit_cast(ira, first_prong_value, enum_type);
20472 IrInstruction *first_casted_prong_value = ir_implicit_cast(ira, &instruction->base, first_prong_value, enum_type);
2042520473 if (type_is_invalid(first_casted_prong_value->value.type))
2042620474 return ira->codegen->invalid_instruction;
2042720475
......@@ -20437,7 +20485,7 @@ static IrInstruction *ir_analyze_instruction_switch_var(IrAnalyze *ira, IrInstru
2043720485 if (type_is_invalid(this_prong_inst->value.type))
2043820486 return ira->codegen->invalid_instruction;
2043920487
20440 IrInstruction *this_casted_prong_value = ir_implicit_cast(ira, this_prong_inst, enum_type);
20488 IrInstruction *this_casted_prong_value = ir_implicit_cast(ira, &instruction->base, this_prong_inst, enum_type);
2044120489 if (type_is_invalid(this_casted_prong_value->value.type))
2044220490 return ira->codegen->invalid_instruction;
2044320491
......@@ -21057,7 +21105,7 @@ static IrInstruction *ir_analyze_instruction_err_name(IrAnalyze *ira, IrInstruct
2105721105 if (type_is_invalid(value->value.type))
2105821106 return ira->codegen->invalid_instruction;
2105921107
21060 IrInstruction *casted_value = ir_implicit_cast(ira, value, ira->codegen->builtin_types.entry_global_error_set);
21108 IrInstruction *casted_value = ir_implicit_cast(ira, &instruction->base, value, ira->codegen->builtin_types.entry_global_error_set);
2106121109 if (type_is_invalid(casted_value->value.type))
2106221110 return ira->codegen->invalid_instruction;
2106321111
......@@ -21165,7 +21213,7 @@ static IrInstruction *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,
2116521213 field_ptr->value.type->data.pointer.is_volatile,
2116621214 PtrLenSingle,
2116721215 field_ptr_align, 0, 0, false);
21168 IrInstruction *casted_field_ptr = ir_implicit_cast(ira, field_ptr, field_ptr_type);
21216 IrInstruction *casted_field_ptr = ir_implicit_cast(ira, &instruction->base, field_ptr, field_ptr_type);
2116921217 if (type_is_invalid(casted_field_ptr->value.type))
2117021218 return ira->codegen->invalid_instruction;
2117121219
......@@ -22309,7 +22357,7 @@ static Error get_const_field_sentinel(IrAnalyze *ira, IrInstruction *source_inst
2230922357{
2231022358 ConstExprValue *field_val = get_const_field(ira, struct_value, name, field_index);
2231122359 IrInstruction *field_inst = ir_const(ira, source_instr, field_val->type);
22312 IrInstruction *casted_field_inst = ir_implicit_cast(ira, field_inst,
22360 IrInstruction *casted_field_inst = ir_implicit_cast(ira, source_instr, field_inst,
2231322361 get_optional_type(ira->codegen, elem_type));
2231422362 if (type_is_invalid(casted_field_inst->value.type))
2231522363 return ErrorSemanticAnalyzeFail;
......@@ -22456,7 +22504,7 @@ static IrInstruction *ir_analyze_instruction_type(IrAnalyze *ira, IrInstructionT
2245622504 if (type_is_invalid(type_info_ir->value.type))
2245722505 return ira->codegen->invalid_instruction;
2245822506
22459 IrInstruction *casted_ir = ir_implicit_cast(ira, type_info_ir, ir_type_info_get_type(ira, nullptr, nullptr));
22507 IrInstruction *casted_ir = ir_implicit_cast(ira, &instruction->base, type_info_ir, ir_type_info_get_type(ira, nullptr, nullptr));
2246022508 if (type_is_invalid(casted_ir->value.type))
2246122509 return ira->codegen->invalid_instruction;
2246222510
......@@ -22817,7 +22865,7 @@ static IrInstruction *ir_analyze_instruction_cmpxchg(IrAnalyze *ira, IrInstructi
2281722865
2281822866 // TODO let this be volatile
2281922867 ZigType *ptr_type = get_pointer_to_type(ira->codegen, operand_type, false);
22820 IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr, ptr_type);
22868 IrInstruction *casted_ptr = ir_implicit_cast(ira, &instruction->base, ptr, ptr_type);
2282122869 if (type_is_invalid(casted_ptr->value.type))
2282222870 return ira->codegen->invalid_instruction;
2282322871
......@@ -22845,11 +22893,11 @@ static IrInstruction *ir_analyze_instruction_cmpxchg(IrAnalyze *ira, IrInstructi
2284522893 if (!ir_resolve_atomic_order(ira, failure_order_value, &failure_order))
2284622894 return ira->codegen->invalid_instruction;
2284722895
22848 IrInstruction *casted_cmp_value = ir_implicit_cast(ira, cmp_value, operand_type);
22896 IrInstruction *casted_cmp_value = ir_implicit_cast(ira, &instruction->base, cmp_value, operand_type);
2284922897 if (type_is_invalid(casted_cmp_value->value.type))
2285022898 return ira->codegen->invalid_instruction;
2285122899
22852 IrInstruction *casted_new_value = ir_implicit_cast(ira, new_value, operand_type);
22900 IrInstruction *casted_new_value = ir_implicit_cast(ira, &instruction->base, new_value, operand_type);
2285322901 if (type_is_invalid(casted_new_value->value.type))
2285422902 return ira->codegen->invalid_instruction;
2285522903
......@@ -22943,7 +22991,7 @@ static IrInstruction *ir_analyze_instruction_truncate(IrAnalyze *ira, IrInstruct
2294322991 }
2294422992
2294522993 if (dest_type->id == ZigTypeIdComptimeInt) {
22946 return ir_implicit_cast(ira, target, dest_type);
22994 return ir_implicit_cast(ira, &instruction->base, target, dest_type);
2294722995 }
2294822996
2294922997 if (instr_is_comptime(target)) {
......@@ -23000,7 +23048,7 @@ static IrInstruction *ir_analyze_instruction_int_cast(IrAnalyze *ira, IrInstruct
2300023048 }
2300123049
2300223050 if (instr_is_comptime(target)) {
23003 return ir_implicit_cast(ira, target, dest_type);
23051 return ir_implicit_cast(ira, &instruction->base, target, dest_type);
2300423052 }
2300523053
2300623054 if (dest_type->id == ZigTypeIdComptimeInt) {
......@@ -23128,7 +23176,7 @@ static IrInstruction *ir_analyze_instruction_from_bytes(IrAnalyze *ira, IrInstru
2312823176 src_ptr_align, 0, 0, false);
2312923177 ZigType *u8_slice = get_slice_type(ira->codegen, u8_ptr);
2313023178
23131 IrInstruction *casted_value = ir_implicit_cast(ira, target, u8_slice);
23179 IrInstruction *casted_value = ir_implicit_cast(ira, &instruction->base, target, u8_slice);
2313223180 if (type_is_invalid(casted_value->value.type))
2313323181 return ira->codegen->invalid_instruction;
2313423182
......@@ -23277,7 +23325,7 @@ static IrInstruction *ir_analyze_instruction_float_to_int(IrAnalyze *ira, IrInst
2327723325 return ira->codegen->invalid_instruction;
2327823326
2327923327 if (target->value.type->id == ZigTypeIdComptimeInt) {
23280 return ir_implicit_cast(ira, target, dest_type);
23328 return ir_implicit_cast(ira, &instruction->base, target, dest_type);
2328123329 }
2328223330
2328323331 if (target->value.type->id != ZigTypeIdFloat && target->value.type->id != ZigTypeIdComptimeFloat) {
......@@ -23298,7 +23346,7 @@ static IrInstruction *ir_analyze_instruction_err_to_int(IrAnalyze *ira, IrInstru
2329823346 if (target->value.type->id == ZigTypeIdErrorSet) {
2329923347 casted_target = target;
2330023348 } else {
23301 casted_target = ir_implicit_cast(ira, target, ira->codegen->builtin_types.entry_global_error_set);
23349 casted_target = ir_implicit_cast(ira, &instruction->base, target, ira->codegen->builtin_types.entry_global_error_set);
2330223350 if (type_is_invalid(casted_target->value.type))
2330323351 return ira->codegen->invalid_instruction;
2330423352 }
......@@ -23311,7 +23359,7 @@ static IrInstruction *ir_analyze_instruction_int_to_err(IrAnalyze *ira, IrInstru
2331123359 if (type_is_invalid(target->value.type))
2331223360 return ira->codegen->invalid_instruction;
2331323361
23314 IrInstruction *casted_target = ir_implicit_cast(ira, target, ira->codegen->err_tag_type);
23362 IrInstruction *casted_target = ir_implicit_cast(ira, &instruction->base, target, ira->codegen->err_tag_type);
2331523363 if (type_is_invalid(casted_target->value.type))
2331623364 return ira->codegen->invalid_instruction;
2331723365
......@@ -23386,7 +23434,7 @@ static IrInstruction *ir_analyze_shuffle_vector(IrAnalyze *ira, IrInstruction *s
2338623434 buf_ptr(&mask->value.type->name)));
2338723435 return ira->codegen->invalid_instruction;
2338823436 }
23389 mask = ir_implicit_cast(ira, mask, get_vector_type(ira->codegen, len_mask,
23437 mask = ir_implicit_cast(ira, source_instr, mask, get_vector_type(ira->codegen, len_mask,
2339023438 ira->codegen->builtin_types.entry_i32));
2339123439 if (type_is_invalid(mask->value.type))
2339223440 return ira->codegen->invalid_instruction;
......@@ -23429,7 +23477,7 @@ static IrInstruction *ir_analyze_shuffle_vector(IrAnalyze *ira, IrInstruction *s
2342923477 len_a = len_b;
2343023478 a = ir_const_undef(ira, a, get_vector_type(ira->codegen, len_a, scalar_type));
2343123479 } else {
23432 a = ir_implicit_cast(ira, a, get_vector_type(ira->codegen, len_a, scalar_type));
23480 a = ir_implicit_cast(ira, source_instr, a, get_vector_type(ira->codegen, len_a, scalar_type));
2343323481 if (type_is_invalid(a->value.type))
2343423482 return ira->codegen->invalid_instruction;
2343523483 }
......@@ -23438,7 +23486,7 @@ static IrInstruction *ir_analyze_shuffle_vector(IrAnalyze *ira, IrInstruction *s
2343823486 len_b = len_a;
2343923487 b = ir_const_undef(ira, b, get_vector_type(ira->codegen, len_b, scalar_type));
2344023488 } else {
23441 b = ir_implicit_cast(ira, b, get_vector_type(ira->codegen, len_b, scalar_type));
23489 b = ir_implicit_cast(ira, source_instr, b, get_vector_type(ira->codegen, len_b, scalar_type));
2344223490 if (type_is_invalid(b->value.type))
2344323491 return ira->codegen->invalid_instruction;
2344423492 }
......@@ -23614,7 +23662,7 @@ static IrInstruction *ir_analyze_instruction_bool_not(IrAnalyze *ira, IrInstruct
2361423662
2361523663 ZigType *bool_type = ira->codegen->builtin_types.entry_bool;
2361623664
23617 IrInstruction *casted_value = ir_implicit_cast(ira, value, bool_type);
23665 IrInstruction *casted_value = ir_implicit_cast(ira, &instruction->base, value, bool_type);
2361823666 if (type_is_invalid(casted_value->value.type))
2361923667 return ira->codegen->invalid_instruction;
2362023668
......@@ -23663,15 +23711,15 @@ static IrInstruction *ir_analyze_instruction_memset(IrAnalyze *ira, IrInstructio
2366323711 ZigType *u8_ptr = get_pointer_to_type_extra(ira->codegen, u8, false, dest_is_volatile,
2366423712 PtrLenUnknown, dest_align, 0, 0, false);
2366523713
23666 IrInstruction *casted_dest_ptr = ir_implicit_cast(ira, dest_ptr, u8_ptr);
23714 IrInstruction *casted_dest_ptr = ir_implicit_cast(ira, &instruction->base, dest_ptr, u8_ptr);
2366723715 if (type_is_invalid(casted_dest_ptr->value.type))
2366823716 return ira->codegen->invalid_instruction;
2366923717
23670 IrInstruction *casted_byte = ir_implicit_cast(ira, byte_value, u8);
23718 IrInstruction *casted_byte = ir_implicit_cast(ira, &instruction->base, byte_value, u8);
2367123719 if (type_is_invalid(casted_byte->value.type))
2367223720 return ira->codegen->invalid_instruction;
2367323721
23674 IrInstruction *casted_count = ir_implicit_cast(ira, count_value, usize);
23722 IrInstruction *casted_count = ir_implicit_cast(ira, &instruction->base, count_value, usize);
2367523723 if (type_is_invalid(casted_count->value.type))
2367623724 return ira->codegen->invalid_instruction;
2367723725
......@@ -23798,15 +23846,15 @@ static IrInstruction *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructio
2379823846 ZigType *u8_ptr_const = get_pointer_to_type_extra(ira->codegen, u8, true, src_is_volatile,
2379923847 PtrLenUnknown, src_align, 0, 0, false);
2380023848
23801 IrInstruction *casted_dest_ptr = ir_implicit_cast(ira, dest_ptr, u8_ptr_mut);
23849 IrInstruction *casted_dest_ptr = ir_implicit_cast(ira, &instruction->base, dest_ptr, u8_ptr_mut);
2380223850 if (type_is_invalid(casted_dest_ptr->value.type))
2380323851 return ira->codegen->invalid_instruction;
2380423852
23805 IrInstruction *casted_src_ptr = ir_implicit_cast(ira, src_ptr, u8_ptr_const);
23853 IrInstruction *casted_src_ptr = ir_implicit_cast(ira, &instruction->base, src_ptr, u8_ptr_const);
2380623854 if (type_is_invalid(casted_src_ptr->value.type))
2380723855 return ira->codegen->invalid_instruction;
2380823856
23809 IrInstruction *casted_count = ir_implicit_cast(ira, count_value, usize);
23857 IrInstruction *casted_count = ir_implicit_cast(ira, &instruction->base, count_value, usize);
2381023858 if (type_is_invalid(casted_count->value.type))
2381123859 return ira->codegen->invalid_instruction;
2381223860
......@@ -23946,7 +23994,7 @@ static IrInstruction *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstruction
2394623994 return ira->codegen->invalid_instruction;
2394723995
2394823996 ZigType *usize = ira->codegen->builtin_types.entry_usize;
23949 IrInstruction *casted_start = ir_implicit_cast(ira, start, usize);
23997 IrInstruction *casted_start = ir_implicit_cast(ira, &instruction->base, start, usize);
2395023998 if (type_is_invalid(casted_start->value.type))
2395123999 return ira->codegen->invalid_instruction;
2395224000
......@@ -23955,7 +24003,7 @@ static IrInstruction *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstruction
2395524003 end = instruction->end->child;
2395624004 if (type_is_invalid(end->value.type))
2395724005 return ira->codegen->invalid_instruction;
23958 end = ir_implicit_cast(ira, end, usize);
24006 end = ir_implicit_cast(ira, &instruction->base, end, usize);
2395924007 if (type_is_invalid(end->value.type))
2396024008 return ira->codegen->invalid_instruction;
2396124009 } else {
......@@ -24526,7 +24574,7 @@ static IrInstruction *ir_analyze_instruction_overflow_op(IrAnalyze *ira, IrInstr
2452624574 if (type_is_invalid(op1->value.type))
2452724575 return ira->codegen->invalid_instruction;
2452824576
24529 IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, dest_type);
24577 IrInstruction *casted_op1 = ir_implicit_cast(ira, &instruction->base, op1, dest_type);
2453024578 if (type_is_invalid(casted_op1->value.type))
2453124579 return ira->codegen->invalid_instruction;
2453224580
......@@ -24538,9 +24586,9 @@ static IrInstruction *ir_analyze_instruction_overflow_op(IrAnalyze *ira, IrInstr
2453824586 if (instruction->op == IrOverflowOpShl) {
2453924587 ZigType *shift_amt_type = get_smallest_unsigned_int_type(ira->codegen,
2454024588 dest_type->data.integral.bit_count - 1);
24541 casted_op2 = ir_implicit_cast(ira, op2, shift_amt_type);
24589 casted_op2 = ir_implicit_cast(ira, &instruction->base, op2, shift_amt_type);
2454224590 } else {
24543 casted_op2 = ir_implicit_cast(ira, op2, dest_type);
24591 casted_op2 = ir_implicit_cast(ira, &instruction->base, op2, dest_type);
2454424592 }
2454524593 if (type_is_invalid(casted_op2->value.type))
2454624594 return ira->codegen->invalid_instruction;
......@@ -24562,7 +24610,7 @@ static IrInstruction *ir_analyze_instruction_overflow_op(IrAnalyze *ira, IrInstr
2456224610 expected_ptr_type = get_pointer_to_type(ira->codegen, dest_type, false);
2456324611 }
2456424612
24565 IrInstruction *casted_result_ptr = ir_implicit_cast(ira, result_ptr, expected_ptr_type);
24613 IrInstruction *casted_result_ptr = ir_implicit_cast(ira, &instruction->base, result_ptr, expected_ptr_type);
2456624614 if (type_is_invalid(casted_result_ptr->value.type))
2456724615 return ira->codegen->invalid_instruction;
2456824616
......@@ -24672,7 +24720,7 @@ static IrInstruction *ir_analyze_instruction_mul_add(IrAnalyze *ira, IrInstructi
2467224720 if (type_is_invalid(op1->value.type))
2467324721 return ira->codegen->invalid_instruction;
2467424722
24675 IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, expr_type);
24723 IrInstruction *casted_op1 = ir_implicit_cast(ira, &instruction->base, op1, expr_type);
2467624724 if (type_is_invalid(casted_op1->value.type))
2467724725 return ira->codegen->invalid_instruction;
2467824726
......@@ -24680,7 +24728,7 @@ static IrInstruction *ir_analyze_instruction_mul_add(IrAnalyze *ira, IrInstructi
2468024728 if (type_is_invalid(op2->value.type))
2468124729 return ira->codegen->invalid_instruction;
2468224730
24683 IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, expr_type);
24731 IrInstruction *casted_op2 = ir_implicit_cast(ira, &instruction->base, op2, expr_type);
2468424732 if (type_is_invalid(casted_op2->value.type))
2468524733 return ira->codegen->invalid_instruction;
2468624734
......@@ -24688,7 +24736,7 @@ static IrInstruction *ir_analyze_instruction_mul_add(IrAnalyze *ira, IrInstructi
2468824736 if (type_is_invalid(op3->value.type))
2468924737 return ira->codegen->invalid_instruction;
2469024738
24691 IrInstruction *casted_op3 = ir_implicit_cast(ira, op3, expr_type);
24739 IrInstruction *casted_op3 = ir_implicit_cast(ira, &instruction->base, op3, expr_type);
2469224740 if (type_is_invalid(casted_op3->value.type))
2469324741 return ira->codegen->invalid_instruction;
2469424742
......@@ -25060,14 +25108,14 @@ static IrInstruction *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
2506025108 IrInstruction *start_value_uncasted = range->start->child;
2506125109 if (type_is_invalid(start_value_uncasted->value.type))
2506225110 return ira->codegen->invalid_instruction;
25063 IrInstruction *start_value = ir_implicit_cast(ira, start_value_uncasted, switch_type);
25111 IrInstruction *start_value = ir_implicit_cast(ira, &instruction->base, start_value_uncasted, switch_type);
2506425112 if (type_is_invalid(start_value->value.type))
2506525113 return ira->codegen->invalid_instruction;
2506625114
2506725115 IrInstruction *end_value_uncasted = range->end->child;
2506825116 if (type_is_invalid(end_value_uncasted->value.type))
2506925117 return ira->codegen->invalid_instruction;
25070 IrInstruction *end_value = ir_implicit_cast(ira, end_value_uncasted, switch_type);
25118 IrInstruction *end_value = ir_implicit_cast(ira, &instruction->base, end_value_uncasted, switch_type);
2507125119 if (type_is_invalid(end_value->value.type))
2507225120 return ira->codegen->invalid_instruction;
2507325121
......@@ -25124,14 +25172,14 @@ static IrInstruction *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
2512425172 IrInstruction *start_value_uncasted = range->start->child;
2512525173 if (type_is_invalid(start_value_uncasted->value.type))
2512625174 return ira->codegen->invalid_instruction;
25127 IrInstruction *start_value = ir_implicit_cast(ira, start_value_uncasted, switch_type);
25175 IrInstruction *start_value = ir_implicit_cast(ira, &instruction->base, start_value_uncasted, switch_type);
2512825176 if (type_is_invalid(start_value->value.type))
2512925177 return ira->codegen->invalid_instruction;
2513025178
2513125179 IrInstruction *end_value_uncasted = range->end->child;
2513225180 if (type_is_invalid(end_value_uncasted->value.type))
2513325181 return ira->codegen->invalid_instruction;
25134 IrInstruction *end_value = ir_implicit_cast(ira, end_value_uncasted, switch_type);
25182 IrInstruction *end_value = ir_implicit_cast(ira, &instruction->base, end_value_uncasted, switch_type);
2513525183 if (type_is_invalid(end_value->value.type))
2513625184 return ira->codegen->invalid_instruction;
2513725185
......@@ -25182,14 +25230,14 @@ static IrInstruction *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
2518225230 IrInstruction *start_value = range->start->child;
2518325231 if (type_is_invalid(start_value->value.type))
2518425232 return ira->codegen->invalid_instruction;
25185 IrInstruction *casted_start_value = ir_implicit_cast(ira, start_value, switch_type);
25233 IrInstruction *casted_start_value = ir_implicit_cast(ira, &instruction->base, start_value, switch_type);
2518625234 if (type_is_invalid(casted_start_value->value.type))
2518725235 return ira->codegen->invalid_instruction;
2518825236
2518925237 IrInstruction *end_value = range->end->child;
2519025238 if (type_is_invalid(end_value->value.type))
2519125239 return ira->codegen->invalid_instruction;
25192 IrInstruction *casted_end_value = ir_implicit_cast(ira, end_value, switch_type);
25240 IrInstruction *casted_end_value = ir_implicit_cast(ira, &instruction->base, end_value, switch_type);
2519325241 if (type_is_invalid(casted_end_value->value.type))
2519425242 return ira->codegen->invalid_instruction;
2519525243
......@@ -25229,7 +25277,7 @@ static IrInstruction *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
2522925277
2523025278 IrInstruction *value = range->start->child;
2523125279
25232 IrInstruction *casted_value = ir_implicit_cast(ira, value, switch_type);
25280 IrInstruction *casted_value = ir_implicit_cast(ira, &instruction->base, value, switch_type);
2523325281 if (type_is_invalid(casted_value->value.type))
2523425282 return ira->codegen->invalid_instruction;
2523525283
......@@ -25290,7 +25338,7 @@ static IrInstruction *ir_analyze_instruction_panic(IrAnalyze *ira, IrInstruction
2529025338 ZigType *u8_ptr_type = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
2529125339 true, false, PtrLenUnknown, 0, 0, 0, false);
2529225340 ZigType *str_type = get_slice_type(ira->codegen, u8_ptr_type);
25293 IrInstruction *casted_msg = ir_implicit_cast(ira, msg, str_type);
25341 IrInstruction *casted_msg = ir_implicit_cast(ira, &instruction->base, msg, str_type);
2529425342 if (type_is_invalid(casted_msg->value.type))
2529525343 return ir_unreach_error(ira);
2529625344
......@@ -25900,7 +25948,7 @@ static IrInstruction *ir_analyze_int_to_ptr(IrAnalyze *ira, IrInstruction *sourc
2590025948 ir_assert(get_src_ptr_type(ptr_type) != nullptr, source_instr);
2590125949 ir_assert(type_has_bits(ptr_type), source_instr);
2590225950
25903 IrInstruction *casted_int = ir_implicit_cast(ira, target, ira->codegen->builtin_types.entry_usize);
25951 IrInstruction *casted_int = ir_implicit_cast(ira, source_instr, target, ira->codegen->builtin_types.entry_usize);
2590425952 if (type_is_invalid(casted_int->value.type))
2590525953 return ira->codegen->invalid_instruction;
2590625954
......@@ -26259,7 +26307,7 @@ static IrInstruction *ir_analyze_instruction_atomic_rmw(IrAnalyze *ira, IrInstru
2625926307
2626026308 // TODO let this be volatile
2626126309 ZigType *ptr_type = get_pointer_to_type(ira->codegen, operand_type, false);
26262 IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr_inst, ptr_type);
26310 IrInstruction *casted_ptr = ir_implicit_cast(ira, &instruction->base, ptr_inst, ptr_type);
2626326311 if (type_is_invalid(casted_ptr->value.type))
2626426312 return ira->codegen->invalid_instruction;
2626526313
......@@ -26282,7 +26330,7 @@ static IrInstruction *ir_analyze_instruction_atomic_rmw(IrAnalyze *ira, IrInstru
2628226330 if (type_is_invalid(operand->value.type))
2628326331 return ira->codegen->invalid_instruction;
2628426332
26285 IrInstruction *casted_operand = ir_implicit_cast(ira, operand, operand_type);
26333 IrInstruction *casted_operand = ir_implicit_cast(ira, &instruction->base, operand, operand_type);
2628626334 if (type_is_invalid(casted_operand->value.type))
2628726335 return ira->codegen->invalid_instruction;
2628826336
......@@ -26321,7 +26369,7 @@ static IrInstruction *ir_analyze_instruction_atomic_load(IrAnalyze *ira, IrInstr
2632126369 return ira->codegen->invalid_instruction;
2632226370
2632326371 ZigType *ptr_type = get_pointer_to_type(ira->codegen, operand_type, true);
26324 IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr_inst, ptr_type);
26372 IrInstruction *casted_ptr = ir_implicit_cast(ira, &instruction->base, ptr_inst, ptr_type);
2632526373 if (type_is_invalid(casted_ptr->value.type))
2632626374 return ira->codegen->invalid_instruction;
2632726375
......@@ -26362,7 +26410,7 @@ static IrInstruction *ir_analyze_instruction_atomic_store(IrAnalyze *ira, IrInst
2636226410 return ira->codegen->invalid_instruction;
2636326411
2636426412 ZigType *ptr_type = get_pointer_to_type(ira->codegen, operand_type, false);
26365 IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr_inst, ptr_type);
26413 IrInstruction *casted_ptr = ir_implicit_cast(ira, &instruction->base, ptr_inst, ptr_type);
2636626414 if (type_is_invalid(casted_ptr->value.type))
2636726415 return ira->codegen->invalid_instruction;
2636826416
......@@ -26370,7 +26418,7 @@ static IrInstruction *ir_analyze_instruction_atomic_store(IrAnalyze *ira, IrInst
2637026418 if (type_is_invalid(value->value.type))
2637126419 return ira->codegen->invalid_instruction;
2637226420
26373 IrInstruction *casted_value = ir_implicit_cast(ira, value, operand_type);
26421 IrInstruction *casted_value = ir_implicit_cast(ira, &instruction->base, value, operand_type);
2637426422 if (type_is_invalid(casted_value->value.type))
2637526423 return ira->codegen->invalid_instruction;
2637626424
......@@ -26609,7 +26657,7 @@ static IrInstruction *ir_analyze_instruction_float_op(IrAnalyze *ira, IrInstruct
2660926657 if (type_is_invalid(op1->value.type))
2661026658 return ira->codegen->invalid_instruction;
2661126659
26612 IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, float_type);
26660 IrInstruction *casted_op1 = ir_implicit_cast(ira, &instruction->base, op1, float_type);
2661326661 if (type_is_invalid(casted_op1->value.type))
2661426662 return ira->codegen->invalid_instruction;
2661526663
......@@ -26685,7 +26733,7 @@ static IrInstruction *ir_analyze_instruction_bswap(IrAnalyze *ira, IrInstruction
2668526733 bool is_vector = (vector_len != UINT32_MAX);
2668626734 ZigType *op_type = is_vector ? get_vector_type(ira->codegen, vector_len, int_type) : int_type;
2668726735
26688 IrInstruction *op = ir_implicit_cast(ira, uncasted_op, op_type);
26736 IrInstruction *op = ir_implicit_cast(ira, &instruction->base, uncasted_op, op_type);
2668926737 if (type_is_invalid(op->value.type))
2669026738 return ira->codegen->invalid_instruction;
2669126739
......@@ -26750,7 +26798,7 @@ static IrInstruction *ir_analyze_instruction_bit_reverse(IrAnalyze *ira, IrInstr
2675026798 if (type_is_invalid(int_type))
2675126799 return ira->codegen->invalid_instruction;
2675226800
26753 IrInstruction *op = ir_implicit_cast(ira, instruction->op->child, int_type);
26801 IrInstruction *op = ir_implicit_cast(ira, &instruction->base, instruction->op->child, int_type);
2675426802 if (type_is_invalid(op->value.type))
2675526803 return ira->codegen->invalid_instruction;
2675626804
......@@ -26831,7 +26879,7 @@ static IrInstruction *ir_analyze_instruction_int_to_enum(IrAnalyze *ira, IrInstr
2683126879 if (type_is_invalid(target->value.type))
2683226880 return ira->codegen->invalid_instruction;
2683326881
26834 IrInstruction *casted_target = ir_implicit_cast(ira, target, tag_type);
26882 IrInstruction *casted_target = ir_implicit_cast(ira, &instruction->base, target, tag_type);
2683526883 if (type_is_invalid(casted_target->value.type))
2683626884 return ira->codegen->invalid_instruction;
2683726885
......@@ -26950,7 +26998,7 @@ static IrInstruction *ir_analyze_instruction_implicit_cast(IrAnalyze *ira, IrIns
2695026998 ZigType *dest_type = ir_resolve_type(ira, instruction->result_loc_cast->base.source_instruction->child);
2695126999 if (type_is_invalid(dest_type))
2695227000 return ira->codegen->invalid_instruction;
26953 return ir_implicit_cast_with_result(ira, &instruction->base, operand, dest_type, nullptr);
27001 return ir_implicit_cast(ira, &instruction->base, operand, dest_type);
2695427002}
2695527003
2695627004static IrInstruction *ir_analyze_instruction_bit_cast_src(IrAnalyze *ira, IrInstructionBitCastSrc *instruction) {
......@@ -27063,7 +27111,7 @@ static IrInstruction *analyze_frame_ptr_to_anyframe_T(IrAnalyze *ira, IrInstruct
2706327111 }
2706427112
2706527113 ZigType *any_frame_type = get_any_frame_type(ira->codegen, result_type);
27066 IrInstruction *casted_frame = ir_implicit_cast(ira, frame, any_frame_type);
27114 IrInstruction *casted_frame = ir_implicit_cast(ira, source_instr, frame, any_frame_type);
2706727115 if (type_is_invalid(casted_frame->value.type))
2706827116 return ira->codegen->invalid_instruction;
2706927117
......@@ -27127,7 +27175,7 @@ static IrInstruction *ir_analyze_instruction_resume(IrAnalyze *ira, IrInstructio
2712727175 }
2712827176
2712927177 ZigType *any_frame_type = get_any_frame_type(ira->codegen, nullptr);
27130 IrInstruction *casted_frame = ir_implicit_cast(ira, frame, any_frame_type);
27178 IrInstruction *casted_frame = ir_implicit_cast(ira, &instruction->base, frame, any_frame_type);
2713127179 if (type_is_invalid(casted_frame->value.type))
2713227180 return ira->codegen->invalid_instruction;
2713327181
......@@ -27979,7 +28027,7 @@ static Error ir_resolve_lazy_raw(AstNode *source_node, ConstExprValue *val) {
2797928027 if (lazy_slice_type->sentinel != nullptr) {
2798028028 if (type_is_invalid(lazy_slice_type->sentinel->value.type))
2798128029 return ErrorSemanticAnalyzeFail;
27982 IrInstruction *sentinel = ir_implicit_cast(ira, lazy_slice_type->sentinel, elem_type);
28030 IrInstruction *sentinel = ir_implicit_cast(ira, lazy_slice_type->sentinel, lazy_slice_type->sentinel, elem_type);
2798328031 if (type_is_invalid(sentinel->value.type))
2798428032 return ErrorSemanticAnalyzeFail;
2798528033 sentinel_val = ir_resolve_const(ira, sentinel, UndefBad);
......@@ -28057,7 +28105,7 @@ static Error ir_resolve_lazy_raw(AstNode *source_node, ConstExprValue *val) {
2805728105 if (lazy_ptr_type->sentinel != nullptr) {
2805828106 if (type_is_invalid(lazy_ptr_type->sentinel->value.type))
2805928107 return ErrorSemanticAnalyzeFail;
28060 IrInstruction *sentinel = ir_implicit_cast(ira, lazy_ptr_type->sentinel, elem_type);
28108 IrInstruction *sentinel = ir_implicit_cast(ira, lazy_ptr_type->sentinel, lazy_ptr_type->sentinel, elem_type);
2806128109 if (type_is_invalid(sentinel->value.type))
2806228110 return ErrorSemanticAnalyzeFail;
2806328111 sentinel_val = ir_resolve_const(ira, sentinel, UndefBad);
test/stage1/behavior/cast.zig+53
......@@ -621,3 +621,56 @@ test "peer resolution of string literals" {
621621 S.doTheTest(.b);
622622 comptime S.doTheTest(.b);
623623}
624
625test "type coercion related to sentinel-termination" {
626 const S = struct {
627 fn doTheTest() void {
628 // [:x]T to []T
629 {
630 var array = [4:0]i32{1,2,3,4};
631 var slice: [:0]i32 = &array;
632 var dest: []i32 = slice;
633 expect(mem.eql(i32, dest, &[_]i32{1,2,3,4}));
634 }
635
636 // [*:x]T to [*]T
637 {
638 var array = [4:99]i32{1,2,3,4};
639 var dest: [*]i32 = &array;
640 expect(dest[0] == 1);
641 expect(dest[1] == 2);
642 expect(dest[2] == 3);
643 expect(dest[3] == 4);
644 expect(dest[4] == 99);
645 }
646
647 // [N:x]T to [N]T
648 {
649 var array = [4:0]i32{1,2,3,4};
650 var dest: [4]i32 = array;
651 expect(mem.eql(i32, dest, &[_]i32{1,2,3,4}));
652 }
653
654 // *[N:x]T to *[N]T
655 {
656 var array = [4:0]i32{1,2,3,4};
657 var dest: *[4]i32 = &array;
658 expect(mem.eql(i32, dest, &[_]i32{1,2,3,4}));
659 }
660
661 // [:x]T to [*:x]T
662 {
663 var array = [4:0]i32{1,2,3,4};
664 var slice: [:0]i32 = &array;
665 var dest: [*:0]i32 = slice;
666 expect(dest[0] == 1);
667 expect(dest[1] == 2);
668 expect(dest[2] == 3);
669 expect(dest[3] == 4);
670 expect(dest[4] == 0);
671 }
672 }
673 };
674 S.doTheTest();
675 comptime S.doTheTest();
676}