authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-07-11 20:45:27-04:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2022-07-11 20:45:27-04:00
log7d2e14267985df0226a5deee96d0c17c94bf6eb2
tree7ed0b99d42c983c1ed2246d0094600a9425c65c0
parentdc815e5e8f194a03988624a6bf7e739ddfe0d3b4
parent20d4f7213dde1ffabe0880bbee46a1de44d586fc
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #12044 from Vexu/stage2-compile-errors

Sema: add detailed error notes to `coerceInMemoryAllowed`

60 files changed, 1072 insertions(+), 401 deletions(-)

lib/std/zig.zig+4
...@@ -49,6 +49,10 @@ pub const Loc = struct {...@@ -49,6 +49,10 @@ pub const Loc = struct {
49 column: usize,49 column: usize,
50 /// Does not include the trailing newline.50 /// Does not include the trailing newline.
51 source_line: []const u8,51 source_line: []const u8,
52
53 pub fn eql(a: Loc, b: Loc) bool {
54 return a.line == b.line and a.column == b.column and std.mem.eql(u8, a.source_line, b.source_line);
55 }
52};56};
5357
54pub fn findLineColumn(source: []const u8, byte_offset: usize) Loc {58pub fn findLineColumn(source: []const u8, byte_offset: usize) Loc {
src/Compilation.zig+23-24
...@@ -526,6 +526,9 @@ pub const AllErrors = struct {...@@ -526,6 +526,9 @@ pub const AllErrors = struct {
526 Message.HashContext,526 Message.HashContext,
527 std.hash_map.default_max_load_percentage,527 std.hash_map.default_max_load_percentage,
528 ).init(allocator);528 ).init(allocator);
529 const err_source = try module_err_msg.src_loc.file_scope.getSource(module.gpa);
530 const err_byte_offset = try module_err_msg.src_loc.byteOffset(module.gpa);
531 const err_loc = std.zig.findLineColumn(err_source.bytes, err_byte_offset);
529532
530 for (module_err_msg.notes) |module_note| {533 for (module_err_msg.notes) |module_note| {
531 const source = try module_note.src_loc.file_scope.getSource(module.gpa);534 const source = try module_note.src_loc.file_scope.getSource(module.gpa);
...@@ -540,7 +543,7 @@ pub const AllErrors = struct {...@@ -540,7 +543,7 @@ pub const AllErrors = struct {
540 .byte_offset = byte_offset,543 .byte_offset = byte_offset,
541 .line = @intCast(u32, loc.line),544 .line = @intCast(u32, loc.line),
542 .column = @intCast(u32, loc.column),545 .column = @intCast(u32, loc.column),
543 .source_line = try allocator.dupe(u8, loc.source_line),546 .source_line = if (err_loc.eql(loc)) null else try allocator.dupe(u8, loc.source_line),
544 },547 },
545 };548 };
546 const gop = try seen_notes.getOrPut(note);549 const gop = try seen_notes.getOrPut(note);
...@@ -558,19 +561,16 @@ pub const AllErrors = struct {...@@ -558,19 +561,16 @@ pub const AllErrors = struct {
558 });561 });
559 return;562 return;
560 }563 }
561 const source = try module_err_msg.src_loc.file_scope.getSource(module.gpa);
562 const byte_offset = try module_err_msg.src_loc.byteOffset(module.gpa);
563 const loc = std.zig.findLineColumn(source.bytes, byte_offset);
564 const file_path = try module_err_msg.src_loc.file_scope.fullPath(allocator);564 const file_path = try module_err_msg.src_loc.file_scope.fullPath(allocator);
565 try errors.append(.{565 try errors.append(.{
566 .src = .{566 .src = .{
567 .src_path = file_path,567 .src_path = file_path,
568 .msg = try allocator.dupe(u8, module_err_msg.msg),568 .msg = try allocator.dupe(u8, module_err_msg.msg),
569 .byte_offset = byte_offset,569 .byte_offset = err_byte_offset,
570 .line = @intCast(u32, loc.line),570 .line = @intCast(u32, err_loc.line),
571 .column = @intCast(u32, loc.column),571 .column = @intCast(u32, err_loc.column),
572 .notes = notes_buf[0..note_i],572 .notes = notes_buf[0..note_i],
573 .source_line = try allocator.dupe(u8, loc.source_line),573 .source_line = try allocator.dupe(u8, err_loc.source_line),
574 },574 },
575 });575 });
576 }576 }
...@@ -593,6 +593,16 @@ pub const AllErrors = struct {...@@ -593,6 +593,16 @@ pub const AllErrors = struct {
593 while (item_i < items_len) : (item_i += 1) {593 while (item_i < items_len) : (item_i += 1) {
594 const item = file.zir.extraData(Zir.Inst.CompileErrors.Item, extra_index);594 const item = file.zir.extraData(Zir.Inst.CompileErrors.Item, extra_index);
595 extra_index = item.end;595 extra_index = item.end;
596 const err_byte_offset = blk: {
597 const token_starts = file.tree.tokens.items(.start);
598 if (item.data.node != 0) {
599 const main_tokens = file.tree.nodes.items(.main_token);
600 const main_token = main_tokens[item.data.node];
601 break :blk token_starts[main_token];
602 }
603 break :blk token_starts[item.data.token] + item.data.byte_offset;
604 };
605 const err_loc = std.zig.findLineColumn(file.source, err_byte_offset);
596606
597 var notes: []Message = &[0]Message{};607 var notes: []Message = &[0]Message{};
598 if (item.data.notes != 0) {608 if (item.data.notes != 0) {
...@@ -621,33 +631,22 @@ pub const AllErrors = struct {...@@ -621,33 +631,22 @@ pub const AllErrors = struct {
621 .line = @intCast(u32, loc.line),631 .line = @intCast(u32, loc.line),
622 .column = @intCast(u32, loc.column),632 .column = @intCast(u32, loc.column),
623 .notes = &.{}, // TODO rework this function to be recursive633 .notes = &.{}, // TODO rework this function to be recursive
624 .source_line = try arena.dupe(u8, loc.source_line),634 .source_line = if (loc.eql(err_loc)) null else try arena.dupe(u8, loc.source_line),
625 },635 },
626 };636 };
627 }637 }
628 }638 }
629639
630 const msg = file.zir.nullTerminatedString(item.data.msg);640 const msg = file.zir.nullTerminatedString(item.data.msg);
631 const byte_offset = blk: {
632 const token_starts = file.tree.tokens.items(.start);
633 if (item.data.node != 0) {
634 const main_tokens = file.tree.nodes.items(.main_token);
635 const main_token = main_tokens[item.data.node];
636 break :blk token_starts[main_token];
637 }
638 break :blk token_starts[item.data.token] + item.data.byte_offset;
639 };
640 const loc = std.zig.findLineColumn(file.source, byte_offset);
641
642 try errors.append(.{641 try errors.append(.{
643 .src = .{642 .src = .{
644 .src_path = try file.fullPath(arena),643 .src_path = try file.fullPath(arena),
645 .msg = try arena.dupe(u8, msg),644 .msg = try arena.dupe(u8, msg),
646 .byte_offset = byte_offset,645 .byte_offset = err_byte_offset,
647 .line = @intCast(u32, loc.line),646 .line = @intCast(u32, err_loc.line),
648 .column = @intCast(u32, loc.column),647 .column = @intCast(u32, err_loc.column),
649 .notes = notes,648 .notes = notes,
650 .source_line = try arena.dupe(u8, loc.source_line),649 .source_line = try arena.dupe(u8, err_loc.source_line),
651 },650 },
652 });651 });
653 }652 }
src/Sema.zig+684-95
...@@ -2749,7 +2749,15 @@ fn ensureResultUsed(...@@ -2749,7 +2749,15 @@ fn ensureResultUsed(
2749 const operand_ty = sema.typeOf(operand);2749 const operand_ty = sema.typeOf(operand);
2750 switch (operand_ty.zigTypeTag()) {2750 switch (operand_ty.zigTypeTag()) {
2751 .Void, .NoReturn => return,2751 .Void, .NoReturn => return,
2752 .ErrorSet, .ErrorUnion => return sema.fail(block, src, "error is ignored. consider using `try`, `catch`, or `if`", .{}),2752 .ErrorSet, .ErrorUnion => {
2753 const msg = msg: {
2754 const msg = try sema.errMsg(block, src, "error is ignored", .{});
2755 errdefer msg.destroy(sema.gpa);
2756 try sema.errNote(block, src, msg, "consider using `try`, `catch`, or `if`", .{});
2757 break :msg msg;
2758 };
2759 return sema.failWithOwnedErrorMsg(block, msg);
2760 },
2753 else => return sema.fail(block, src, "expression value is ignored", .{}),2761 else => return sema.fail(block, src, "expression value is ignored", .{}),
2754 }2762 }
2755}2763}
...@@ -2763,7 +2771,15 @@ fn zirEnsureResultNonError(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com...@@ -2763,7 +2771,15 @@ fn zirEnsureResultNonError(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
2763 const src = inst_data.src();2771 const src = inst_data.src();
2764 const operand_ty = sema.typeOf(operand);2772 const operand_ty = sema.typeOf(operand);
2765 switch (operand_ty.zigTypeTag()) {2773 switch (operand_ty.zigTypeTag()) {
2766 .ErrorSet, .ErrorUnion => return sema.fail(block, src, "error is discarded. consider using `try`, `catch`, or `if`", .{}),2774 .ErrorSet, .ErrorUnion => {
2775 const msg = msg: {
2776 const msg = try sema.errMsg(block, src, "error is discarded", .{});
2777 errdefer msg.destroy(sema.gpa);
2778 try sema.errNote(block, src, msg, "consider using `try`, `catch`, or `if`", .{});
2779 break :msg msg;
2780 };
2781 return sema.failWithOwnedErrorMsg(block, msg);
2782 },
2767 else => return,2783 else => return,
2768 }2784 }
2769}2785}
...@@ -4119,23 +4135,24 @@ fn zirStoreNode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!v...@@ -4119,23 +4135,24 @@ fn zirStoreNode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!v
4119 const ptr = try sema.resolveInst(extra.lhs);4135 const ptr = try sema.resolveInst(extra.lhs);
4120 const operand = try sema.resolveInst(extra.rhs);4136 const operand = try sema.resolveInst(extra.rhs);
41214137
4138 const is_ret = if (Zir.refToIndex(extra.lhs)) |ptr_index|
4139 zir_tags[ptr_index] == .ret_ptr
4140 else
4141 false;
4142
4122 // Check for the possibility of this pattern:4143 // Check for the possibility of this pattern:
4123 // %a = ret_ptr4144 // %a = ret_ptr
4124 // %b = store(%a, %c)4145 // %b = store(%a, %c)
4125 // Where %c is an error union or error set. In such case we need to add4146 // Where %c is an error union or error set. In such case we need to add
4126 // to the current function's inferred error set, if any.4147 // to the current function's inferred error set, if any.
4127 if ((sema.typeOf(operand).zigTypeTag() == .ErrorUnion or4148 if (is_ret and (sema.typeOf(operand).zigTypeTag() == .ErrorUnion or
4128 sema.typeOf(operand).zigTypeTag() == .ErrorSet) and4149 sema.typeOf(operand).zigTypeTag() == .ErrorSet) and
4129 sema.fn_ret_ty.zigTypeTag() == .ErrorUnion)4150 sema.fn_ret_ty.zigTypeTag() == .ErrorUnion)
4130 {4151 {
4131 if (Zir.refToIndex(extra.lhs)) |ptr_index| {4152 try sema.addToInferredErrorSet(operand);
4132 if (zir_tags[ptr_index] == .ret_ptr) {
4133 try sema.addToInferredErrorSet(operand);
4134 }
4135 }
4136 }4153 }
41374154
4138 return sema.storePtr(block, src, ptr, operand);4155 return sema.storePtr2(block, src, ptr, src, operand, src, if (is_ret) .ret_ptr else .store);
4139}4156}
41404157
4141fn zirParamType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {4158fn zirParamType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
...@@ -5534,7 +5551,7 @@ fn analyzeCall(...@@ -5534,7 +5551,7 @@ fn analyzeCall(
5534 try sema.resolveBody(&child_block, fn_info.ret_ty_body, module_fn.zir_body_inst)5551 try sema.resolveBody(&child_block, fn_info.ret_ty_body, module_fn.zir_body_inst)
5535 else5552 else
5536 try sema.resolveInst(fn_info.ret_ty_ref);5553 try sema.resolveInst(fn_info.ret_ty_ref);
5537 const ret_ty_src = func_src; // TODO better source location5554 const ret_ty_src: LazySrcLoc = .{ .node_offset_fn_type_ret_ty = 0 };
5538 const bare_return_type = try sema.analyzeAsType(&child_block, ret_ty_src, ret_ty_inst);5555 const bare_return_type = try sema.analyzeAsType(&child_block, ret_ty_src, ret_ty_inst);
5539 // Create a fresh inferred error set type for inline/comptime calls.5556 // Create a fresh inferred error set type for inline/comptime calls.
5540 const fn_ret_ty = blk: {5557 const fn_ret_ty = blk: {
...@@ -6876,7 +6893,7 @@ fn zirFunc(...@@ -6876,7 +6893,7 @@ fn zirFunc(
6876 const inst_data = sema.code.instructions.items(.data)[inst].pl_node;6893 const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
6877 const extra = sema.code.extraData(Zir.Inst.Func, inst_data.payload_index);6894 const extra = sema.code.extraData(Zir.Inst.Func, inst_data.payload_index);
6878 const target = sema.mod.getTarget();6895 const target = sema.mod.getTarget();
6879 const ret_ty_src = inst_data.src(); // TODO better source location6896 const ret_ty_src: LazySrcLoc = .{ .node_offset_fn_type_ret_ty = inst_data.src_node };
68806897
6881 var extra_index = extra.end;6898 var extra_index = extra.end;
68826899
...@@ -7458,13 +7475,20 @@ fn analyzeAs(...@@ -7458,13 +7475,20 @@ fn analyzeAs(
7458 zir_dest_type: Zir.Inst.Ref,7475 zir_dest_type: Zir.Inst.Ref,
7459 zir_operand: Zir.Inst.Ref,7476 zir_operand: Zir.Inst.Ref,
7460) CompileError!Air.Inst.Ref {7477) CompileError!Air.Inst.Ref {
7478 const is_ret = if (Zir.refToIndex(zir_dest_type)) |ptr_index|
7479 sema.code.instructions.items(.tag)[ptr_index] == .ret_type
7480 else
7481 false;
7461 const dest_ty = try sema.resolveType(block, src, zir_dest_type);7482 const dest_ty = try sema.resolveType(block, src, zir_dest_type);
7462 const operand = try sema.resolveInst(zir_operand);7483 const operand = try sema.resolveInst(zir_operand);
7463 if (dest_ty.tag() == .var_args_param) return operand;7484 if (dest_ty.tag() == .var_args_param) return operand;
7464 if (dest_ty.zigTypeTag() == .NoReturn) {7485 if (dest_ty.zigTypeTag() == .NoReturn) {
7465 return sema.fail(block, src, "cannot cast to noreturn", .{});7486 return sema.fail(block, src, "cannot cast to noreturn", .{});
7466 }7487 }
7467 return sema.coerce(block, dest_ty, operand, src);7488 return sema.coerceExtra(block, dest_ty, operand, src, true, is_ret) catch |err| switch (err) {
7489 error.NotCoercible => unreachable,
7490 else => |e| return e,
7491 };
7468}7492}
74697493
7470fn zirPtrToInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {7494fn zirPtrToInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
...@@ -13647,7 +13671,10 @@ fn analyzeRet(...@@ -13647,7 +13671,10 @@ fn analyzeRet(
13647 if (sema.fn_ret_ty.zigTypeTag() == .ErrorUnion) {13671 if (sema.fn_ret_ty.zigTypeTag() == .ErrorUnion) {
13648 try sema.addToInferredErrorSet(uncasted_operand);13672 try sema.addToInferredErrorSet(uncasted_operand);
13649 }13673 }
13650 const operand = try sema.coerce(block, sema.fn_ret_ty, uncasted_operand, src);13674 const operand = sema.coerceExtra(block, sema.fn_ret_ty, uncasted_operand, src, true, true) catch |err| switch (err) {
13675 error.NotCoercible => unreachable,
13676 else => |e| return e,
13677 };
1365113678
13652 if (block.inlining) |inlining| {13679 if (block.inlining) |inlining| {
13653 if (block.is_comptime) {13680 if (block.is_comptime) {
...@@ -19993,6 +20020,27 @@ fn coerce(...@@ -19993,6 +20020,27 @@ fn coerce(
19993 inst: Air.Inst.Ref,20020 inst: Air.Inst.Ref,
19994 inst_src: LazySrcLoc,20021 inst_src: LazySrcLoc,
19995) CompileError!Air.Inst.Ref {20022) CompileError!Air.Inst.Ref {
20023 return sema.coerceExtra(block, dest_ty_unresolved, inst, inst_src, true, false) catch |err| switch (err) {
20024 error.NotCoercible => unreachable,
20025 else => |e| return e,
20026 };
20027}
20028
20029const CoersionError = CompileError || error{
20030 /// When coerce is called recursively, this error should be returned instead of using `fail`
20031 /// to ensure correct types in compile errors.
20032 NotCoercible,
20033};
20034
20035fn coerceExtra(
20036 sema: *Sema,
20037 block: *Block,
20038 dest_ty_unresolved: Type,
20039 inst: Air.Inst.Ref,
20040 inst_src: LazySrcLoc,
20041 report_err: bool,
20042 is_ret: bool,
20043) CoersionError!Air.Inst.Ref {
19996 switch (dest_ty_unresolved.tag()) {20044 switch (dest_ty_unresolved.tag()) {
19997 .var_args_param => return sema.coerceVarArgParam(block, inst, inst_src),20045 .var_args_param => return sema.coerceVarArgParam(block, inst, inst_src),
19998 .generic_poison => return inst,20046 .generic_poison => return inst,
...@@ -20009,7 +20057,7 @@ fn coerce(...@@ -20009,7 +20057,7 @@ fn coerce(
20009 const arena = sema.arena;20057 const arena = sema.arena;
20010 const maybe_inst_val = try sema.resolveMaybeUndefVal(block, inst_src, inst);20058 const maybe_inst_val = try sema.resolveMaybeUndefVal(block, inst_src, inst);
2001120059
20012 const in_memory_result = try sema.coerceInMemoryAllowed(block, dest_ty, inst_ty, false, target, dest_ty_src, inst_src);20060 var in_memory_result = try sema.coerceInMemoryAllowed(block, dest_ty, inst_ty, false, target, dest_ty_src, inst_src);
20013 if (in_memory_result == .ok) {20061 if (in_memory_result == .ok) {
20014 if (maybe_inst_val) |val| {20062 if (maybe_inst_val) |val| {
20015 // Keep the comptime Value representation; take the new type.20063 // Keep the comptime Value representation; take the new type.
...@@ -20022,7 +20070,7 @@ fn coerce(...@@ -20022,7 +20070,7 @@ fn coerce(
20022 const is_undef = if (maybe_inst_val) |val| val.isUndef() else false;20070 const is_undef = if (maybe_inst_val) |val| val.isUndef() else false;
2002320071
20024 switch (dest_ty.zigTypeTag()) {20072 switch (dest_ty.zigTypeTag()) {
20025 .Optional => {20073 .Optional => optional: {
20026 // undefined sets the optional bit also to undefined.20074 // undefined sets the optional bit also to undefined.
20027 if (is_undef) {20075 if (is_undef) {
20028 return sema.addConstUndef(dest_ty);20076 return sema.addConstUndef(dest_ty);
...@@ -20043,10 +20091,19 @@ fn coerce(...@@ -20043,10 +20091,19 @@ fn coerce(
2004320091
20044 // T to ?T20092 // T to ?T
20045 const child_type = try dest_ty.optionalChildAlloc(sema.arena);20093 const child_type = try dest_ty.optionalChildAlloc(sema.arena);
20046 const intermediate = try sema.coerce(block, child_type, inst, inst_src);20094 const intermediate = sema.coerceExtra(block, child_type, inst, inst_src, false, is_ret) catch |err| switch (err) {
20047 return sema.wrapOptional(block, dest_ty, intermediate, inst_src);20095 error.NotCoercible => {
20096 if (in_memory_result == .no_match) {
20097 // Try to give more useful notes
20098 in_memory_result = try sema.coerceInMemoryAllowed(block, child_type, inst_ty, false, target, dest_ty_src, inst_src);
20099 }
20100 break :optional;
20101 },
20102 else => |e| return e,
20103 };
20104 return try sema.wrapOptional(block, dest_ty, intermediate, inst_src);
20048 },20105 },
20049 .Pointer => {20106 .Pointer => pointer: {
20050 const dest_info = dest_ty.ptrInfo().data;20107 const dest_info = dest_ty.ptrInfo().data;
2005120108
20052 // Function body to function pointer.20109 // Function body to function pointer.
...@@ -20071,7 +20128,7 @@ fn coerce(...@@ -20071,7 +20128,7 @@ fn coerce(
20071 if (inst_ty.ptrAddressSpace() != dest_info.@"addrspace") break :single_item;20128 if (inst_ty.ptrAddressSpace() != dest_info.@"addrspace") break :single_item;
20072 switch (try sema.coerceInMemoryAllowed(block, array_elem_ty, ptr_elem_ty, dest_is_mut, target, dest_ty_src, inst_src)) {20129 switch (try sema.coerceInMemoryAllowed(block, array_elem_ty, ptr_elem_ty, dest_is_mut, target, dest_ty_src, inst_src)) {
20073 .ok => {},20130 .ok => {},
20074 .no_match => break :single_item,20131 else => break :single_item,
20075 }20132 }
20076 return sema.coerceCompatiblePtrs(block, dest_ty, inst, inst_src);20133 return sema.coerceCompatiblePtrs(block, dest_ty, inst, inst_src);
20077 }20134 }
...@@ -20091,7 +20148,7 @@ fn coerce(...@@ -20091,7 +20148,7 @@ fn coerce(
20091 const dst_elem_type = dest_info.pointee_type;20148 const dst_elem_type = dest_info.pointee_type;
20092 switch (try sema.coerceInMemoryAllowed(block, dst_elem_type, array_elem_type, dest_is_mut, target, dest_ty_src, inst_src)) {20149 switch (try sema.coerceInMemoryAllowed(block, dst_elem_type, array_elem_type, dest_is_mut, target, dest_ty_src, inst_src)) {
20093 .ok => {},20150 .ok => {},
20094 .no_match => break :src_array_ptr,20151 else => break :src_array_ptr,
20095 }20152 }
2009620153
20097 switch (dest_info.size) {20154 switch (dest_info.size) {
...@@ -20130,7 +20187,7 @@ fn coerce(...@@ -20130,7 +20187,7 @@ fn coerce(
20130 const dst_elem_type = dest_info.pointee_type;20187 const dst_elem_type = dest_info.pointee_type;
20131 switch (try sema.coerceInMemoryAllowed(block, dst_elem_type, src_elem_ty, dest_is_mut, target, dest_ty_src, inst_src)) {20188 switch (try sema.coerceInMemoryAllowed(block, dst_elem_type, src_elem_ty, dest_is_mut, target, dest_ty_src, inst_src)) {
20132 .ok => {},20189 .ok => {},
20133 .no_match => break :src_c_ptr,20190 else => break :src_c_ptr,
20134 }20191 }
20135 // TODO add safety check for null pointer20192 // TODO add safety check for null pointer
20136 return sema.coerceCompatiblePtrs(block, dest_ty, inst, inst_src);20193 return sema.coerceCompatiblePtrs(block, dest_ty, inst, inst_src);
...@@ -20151,16 +20208,26 @@ fn coerce(...@@ -20151,16 +20208,26 @@ fn coerce(
20151 return sema.addConstant(dest_ty, Value.@"null");20208 return sema.addConstant(dest_ty, Value.@"null");
20152 },20209 },
20153 .ComptimeInt => {20210 .ComptimeInt => {
20154 const addr = try sema.coerce(block, Type.usize, inst, inst_src);20211 const addr = sema.coerceExtra(block, Type.usize, inst, inst_src, false, is_ret) catch |err| switch (err) {
20155 return sema.coerceCompatiblePtrs(block, dest_ty, addr, inst_src);20212 error.NotCoercible => break :pointer,
20213 else => |e| return e,
20214 };
20215 return try sema.coerceCompatiblePtrs(block, dest_ty, addr, inst_src);
20156 },20216 },
20157 .Int => {20217 .Int => {
20158 const ptr_size_ty = switch (inst_ty.intInfo(target).signedness) {20218 const ptr_size_ty = switch (inst_ty.intInfo(target).signedness) {
20159 .signed => Type.isize,20219 .signed => Type.isize,
20160 .unsigned => Type.usize,20220 .unsigned => Type.usize,
20161 };20221 };
20162 const addr = try sema.coerce(block, ptr_size_ty, inst, inst_src);20222 const addr = sema.coerceExtra(block, ptr_size_ty, inst, inst_src, false, is_ret) catch |err| switch (err) {
20163 return sema.coerceCompatiblePtrs(block, dest_ty, addr, inst_src);20223 error.NotCoercible => {
20224 // Try to give more useful notes
20225 in_memory_result = try sema.coerceInMemoryAllowed(block, ptr_size_ty, inst_ty, false, target, dest_ty_src, inst_src);
20226 break :pointer;
20227 },
20228 else => |e| return e,
20229 };
20230 return try sema.coerceCompatiblePtrs(block, dest_ty, addr, inst_src);
20164 },20231 },
20165 .Pointer => p: {20232 .Pointer => p: {
20166 const inst_info = inst_ty.ptrInfo().data;20233 const inst_info = inst_ty.ptrInfo().data;
...@@ -20174,7 +20241,7 @@ fn coerce(...@@ -20174,7 +20241,7 @@ fn coerce(
20174 inst_src,20241 inst_src,
20175 )) {20242 )) {
20176 .ok => {},20243 .ok => {},
20177 .no_match => break :p,20244 else => break :p,
20178 }20245 }
20179 if (inst_info.size == .Slice) {20246 if (inst_info.size == .Slice) {
20180 if (dest_info.sentinel == null or inst_info.sentinel == null or20247 if (dest_info.sentinel == null or inst_info.sentinel == null or
...@@ -20264,7 +20331,7 @@ fn coerce(...@@ -20264,7 +20331,7 @@ fn coerce(
20264 inst_src,20331 inst_src,
20265 )) {20332 )) {
20266 .ok => {},20333 .ok => {},
20267 .no_match => break :p,20334 else => break :p,
20268 }20335 }
2026920336
20270 if (dest_info.sentinel == null or inst_info.sentinel == null or20337 if (dest_info.sentinel == null or inst_info.sentinel == null or
...@@ -20295,6 +20362,7 @@ fn coerce(...@@ -20295,6 +20362,7 @@ fn coerce(
20295 if (try sema.resolveDefinedValue(block, inst_src, inst)) |val| {20362 if (try sema.resolveDefinedValue(block, inst_src, inst)) |val| {
20296 // comptime known integer to other number20363 // comptime known integer to other number
20297 if (!(try sema.intFitsInType(block, inst_src, val, dest_ty, null))) {20364 if (!(try sema.intFitsInType(block, inst_src, val, dest_ty, null))) {
20365 if (!report_err) return error.NotCoercible;
20298 return sema.fail(block, inst_src, "type '{}' cannot represent integer value '{}'", .{ dest_ty.fmt(sema.mod), val.fmtValue(inst_ty, sema.mod) });20366 return sema.fail(block, inst_src, "type '{}' cannot represent integer value '{}'", .{ dest_ty.fmt(sema.mod), val.fmtValue(inst_ty, sema.mod) });
20299 }20367 }
20300 return try sema.addConstant(dest_ty, val);20368 return try sema.addConstant(dest_ty, val);
...@@ -20496,14 +20564,396 @@ fn coerce(...@@ -20496,14 +20564,396 @@ fn coerce(
20496 return sema.addConstUndef(dest_ty);20564 return sema.addConstUndef(dest_ty);
20497 }20565 }
2049820566
20499 return sema.fail(block, inst_src, "expected type '{}', found '{}'", .{ dest_ty.fmt(sema.mod), inst_ty.fmt(sema.mod) });20567 if (!report_err) return error.NotCoercible;
20568
20569 if (is_ret and dest_ty.zigTypeTag() == .NoReturn) {
20570 const msg = msg: {
20571 const msg = try sema.errMsg(block, inst_src, "function declared 'noreturn' returns", .{});
20572 errdefer msg.destroy(sema.gpa);
20573
20574 const ret_ty_src: LazySrcLoc = .{ .node_offset_fn_type_ret_ty = 0 };
20575 const src_decl = sema.mod.declPtr(sema.func.?.owner_decl);
20576 try sema.mod.errNoteNonLazy(ret_ty_src.toSrcLoc(src_decl), msg, "'noreturn' declared here", .{});
20577 break :msg msg;
20578 };
20579 return sema.failWithOwnedErrorMsg(block, msg);
20580 }
20581
20582 const msg = msg: {
20583 const msg = try sema.errMsg(block, inst_src, "expected type '{}', found '{}'", .{ dest_ty.fmt(sema.mod), inst_ty.fmt(sema.mod) });
20584 errdefer msg.destroy(sema.gpa);
20585
20586 // E!T to T
20587 if (inst_ty.zigTypeTag() == .ErrorUnion and
20588 (try sema.coerceInMemoryAllowed(block, inst_ty.errorUnionPayload(), dest_ty, false, target, dest_ty_src, inst_src)) == .ok)
20589 {
20590 try sema.errNote(block, inst_src, msg, "cannot convert error union to payload type", .{});
20591 try sema.errNote(block, inst_src, msg, "consider using `try`, `catch`, or `if`", .{});
20592 }
20593
20594 // ?T to T
20595 var buf: Type.Payload.ElemType = undefined;
20596 if (inst_ty.zigTypeTag() == .Optional and
20597 (try sema.coerceInMemoryAllowed(block, inst_ty.optionalChild(&buf), dest_ty, false, target, dest_ty_src, inst_src)) == .ok)
20598 {
20599 try sema.errNote(block, inst_src, msg, "cannot convert optional to payload type", .{});
20600 try sema.errNote(block, inst_src, msg, "consider using `.?`, `orelse`, or `if`", .{});
20601 }
20602
20603 try in_memory_result.report(sema, block, inst_src, msg);
20604
20605 // Add notes about function return type
20606 if (is_ret and sema.mod.test_functions.get(sema.func.?.owner_decl) == null) {
20607 const ret_ty_src: LazySrcLoc = .{ .node_offset_fn_type_ret_ty = 0 };
20608 const src_decl = sema.mod.declPtr(sema.func.?.owner_decl);
20609 if (inst_ty.isError() and !dest_ty.isError()) {
20610 try sema.mod.errNoteNonLazy(ret_ty_src.toSrcLoc(src_decl), msg, "function cannot return an error", .{});
20611 } else {
20612 try sema.mod.errNoteNonLazy(ret_ty_src.toSrcLoc(src_decl), msg, "function return type declared here", .{});
20613 }
20614 }
20615
20616 // TODO maybe add "cannot store an error in type '{}'" note
20617
20618 break :msg msg;
20619 };
20620 return sema.failWithOwnedErrorMsg(block, msg);
20500}20621}
2050120622
20502const InMemoryCoercionResult = enum {20623const InMemoryCoercionResult = union(enum) {
20503 ok,20624 ok,
20504 no_match,20625 no_match: Pair,
20626 int_not_coercible: Int,
20627 error_union_payload: PairAndChild,
20628 array_len: IntPair,
20629 array_sentinel: Sentinel,
20630 array_elem: PairAndChild,
20631 vector_len: IntPair,
20632 vector_elem: PairAndChild,
20633 optional_shape: Pair,
20634 optional_child: PairAndChild,
20635 from_anyerror,
20636 missing_error: []const []const u8,
20637 /// true if wanted is var args
20638 fn_var_args: bool,
20639 /// true if wanted is generic
20640 fn_generic: bool,
20641 fn_param_count: IntPair,
20642 fn_param_noalias: IntPair,
20643 fn_param_comptime: ComptimeParam,
20644 fn_param: Param,
20645 fn_cc: CC,
20646 fn_return_type: PairAndChild,
20647 ptr_child: PairAndChild,
20648 ptr_addrspace: AddressSpace,
20649 ptr_sentinel: Sentinel,
20650 ptr_size: Size,
20651 ptr_qualifiers: Qualifiers,
20652 ptr_allowzero: Pair,
20653 ptr_bit_range: BitRange,
20654 ptr_alignment: IntPair,
20655
20656 const Pair = struct {
20657 actual: Type,
20658 wanted: Type,
20659 };
20660
20661 const PairAndChild = struct {
20662 child: *InMemoryCoercionResult,
20663 actual: Type,
20664 wanted: Type,
20665 };
20666
20667 const Param = struct {
20668 child: *InMemoryCoercionResult,
20669 actual: Type,
20670 wanted: Type,
20671 index: u64,
20672 };
20673
20674 const ComptimeParam = struct {
20675 index: u64,
20676 wanted: bool,
20677 };
20678
20679 const Sentinel = struct {
20680 // unreachable_value indicates no sentinel
20681 actual: Value,
20682 wanted: Value,
20683 ty: Type,
20684 };
20685
20686 const Int = struct {
20687 actual_signedness: std.builtin.Signedness,
20688 wanted_signedness: std.builtin.Signedness,
20689 actual_bits: u16,
20690 wanted_bits: u16,
20691 };
20692
20693 const IntPair = struct {
20694 actual: u64,
20695 wanted: u64,
20696 };
20697
20698 const Size = struct {
20699 actual: std.builtin.Type.Pointer.Size,
20700 wanted: std.builtin.Type.Pointer.Size,
20701 };
20702
20703 const Qualifiers = struct {
20704 actual_const: bool,
20705 wanted_const: bool,
20706 actual_volatile: bool,
20707 wanted_volatile: bool,
20708 };
20709
20710 const AddressSpace = struct {
20711 actual: std.builtin.AddressSpace,
20712 wanted: std.builtin.AddressSpace,
20713 };
20714
20715 const CC = struct {
20716 actual: std.builtin.CallingConvention,
20717 wanted: std.builtin.CallingConvention,
20718 };
20719
20720 const BitRange = struct {
20721 actual_host: u16,
20722 wanted_host: u16,
20723 actual_offset: u16,
20724 wanted_offset: u16,
20725 };
20726
20727 fn dupe(child: *const InMemoryCoercionResult, arena: Allocator) !*InMemoryCoercionResult {
20728 const res = try arena.create(InMemoryCoercionResult);
20729 res.* = child.*;
20730 return res;
20731 }
20732
20733 fn report(res: *const InMemoryCoercionResult, sema: *Sema, block: *Block, src: LazySrcLoc, msg: *Module.ErrorMsg) !void {
20734 var cur = res;
20735 while (true) switch (cur.*) {
20736 .ok => unreachable,
20737 .no_match => |types| {
20738 try sema.addDeclaredHereNote(msg, types.wanted);
20739 try sema.addDeclaredHereNote(msg, types.actual);
20740 break;
20741 },
20742 .int_not_coercible => |int| {
20743 try sema.errNote(block, src, msg, "{s} {d}-bit int cannot represent all possible {s} {d}-bit values", .{
20744 @tagName(int.wanted_signedness), int.wanted_bits, @tagName(int.actual_signedness), int.actual_bits,
20745 });
20746 break;
20747 },
20748 .error_union_payload => |pair| {
20749 try sema.errNote(block, src, msg, "error union payload '{}' cannot cast into error union payload '{}'", .{
20750 pair.actual.fmt(sema.mod), pair.wanted.fmt(sema.mod),
20751 });
20752 cur = pair.child;
20753 },
20754 .array_len => |lens| {
20755 try sema.errNote(block, src, msg, "array of length {d} cannot cast into an array of length {d}", .{
20756 lens.actual, lens.wanted,
20757 });
20758 break;
20759 },
20760 .array_sentinel => |sentinel| {
20761 if (sentinel.actual.tag() != .unreachable_value) {
20762 try sema.errNote(block, src, msg, "array sentinel '{}' cannot cast into array sentinel '{}'", .{
20763 sentinel.actual.fmtValue(sentinel.ty, sema.mod), sentinel.wanted.fmtValue(sentinel.ty, sema.mod),
20764 });
20765 } else {
20766 try sema.errNote(block, src, msg, "destination array requires '{}' sentinel", .{
20767 sentinel.wanted.fmtValue(sentinel.ty, sema.mod),
20768 });
20769 }
20770 break;
20771 },
20772 .array_elem => |pair| {
20773 try sema.errNote(block, src, msg, "array element type '{}' cannot cast into array element type '{}'", .{
20774 pair.actual.fmt(sema.mod), pair.wanted.fmt(sema.mod),
20775 });
20776 cur = pair.child;
20777 },
20778 .vector_len => |lens| {
20779 try sema.errNote(block, src, msg, "vector of length {d} cannot cast into a vector of length {d}", .{
20780 lens.actual, lens.wanted,
20781 });
20782 break;
20783 },
20784 .vector_elem => |pair| {
20785 try sema.errNote(block, src, msg, "vector element type '{}' cannot cast into vector element type '{}'", .{
20786 pair.actual.fmt(sema.mod), pair.wanted.fmt(sema.mod),
20787 });
20788 cur = pair.child;
20789 },
20790 .optional_shape => |pair| {
20791 var buf_actual: Type.Payload.ElemType = undefined;
20792 var buf_wanted: Type.Payload.ElemType = undefined;
20793 try sema.errNote(block, src, msg, "optional type child '{}' cannot cast into optional type child '{}'", .{
20794 pair.actual.optionalChild(&buf_actual).fmt(sema.mod), pair.wanted.optionalChild(&buf_wanted).fmt(sema.mod),
20795 });
20796 break;
20797 },
20798 .optional_child => |pair| {
20799 try sema.errNote(block, src, msg, "optional type child '{}' cannot cast into optional type child '{}'", .{
20800 pair.actual.fmt(sema.mod), pair.wanted.fmt(sema.mod),
20801 });
20802 cur = pair.child;
20803 },
20804 .from_anyerror => {
20805 try sema.errNote(block, src, msg, "global error set cannot cast into a smaller set", .{});
20806 break;
20807 },
20808 .missing_error => |missing_errors| {
20809 for (missing_errors) |err| {
20810 try sema.errNote(block, src, msg, "'error.{s}' not a member of destination error set", .{err});
20811 }
20812 break;
20813 },
20814 .fn_var_args => |wanted_var_args| {
20815 if (wanted_var_args) {
20816 try sema.errNote(block, src, msg, "non-variadic function cannot cast into a variadic function", .{});
20817 } else {
20818 try sema.errNote(block, src, msg, "variadic function cannot cast into a non-variadic function", .{});
20819 }
20820 break;
20821 },
20822 .fn_generic => |wanted_generic| {
20823 if (wanted_generic) {
20824 try sema.errNote(block, src, msg, "non-generic function cannot cast into a generic function", .{});
20825 } else {
20826 try sema.errNote(block, src, msg, "generic function cannot cast into a non-generic function", .{});
20827 }
20828 break;
20829 },
20830 .fn_param_count => |lens| {
20831 try sema.errNote(block, src, msg, "function with {d} parameters cannot cast into a function with {d} parameters", .{
20832 lens.actual, lens.wanted,
20833 });
20834 break;
20835 },
20836 .fn_param_noalias => |param| {
20837 var index: u6 = 0;
20838 var actual_noalias = false;
20839 while (true) : (index += 1) {
20840 if (param.actual << index != param.wanted << index) {
20841 actual_noalias = (param.actual << index) == (1 << 31);
20842 }
20843 }
20844 if (!actual_noalias) {
20845 try sema.errNote(block, src, msg, "regular paramter {d} cannot cast into a noalias paramter", .{index});
20846 } else {
20847 try sema.errNote(block, src, msg, "noalias paramter {d} cannot cast into a regular paramter", .{index});
20848 }
20849 break;
20850 },
20851 .fn_param_comptime => |param| {
20852 if (param.wanted) {
20853 try sema.errNote(block, src, msg, "non-comptime paramter {d} cannot cast into a comptime paramter", .{param.index});
20854 } else {
20855 try sema.errNote(block, src, msg, "comptime paramter {d} cannot cast into a non-comptime paramter", .{param.index});
20856 }
20857 break;
20858 },
20859 .fn_param => |param| {
20860 try sema.errNote(block, src, msg, "parameter {d} '{}' cannot cast into '{}'", .{
20861 param.index, param.actual.fmt(sema.mod), param.wanted.fmt(sema.mod),
20862 });
20863 cur = param.child;
20864 },
20865 .fn_cc => |cc| {
20866 try sema.errNote(block, src, msg, "calling convention {s} cannot cast into calling convention {s}", .{ @tagName(cc.actual), @tagName(cc.wanted) });
20867 break;
20868 },
20869 .fn_return_type => |pair| {
20870 try sema.errNote(block, src, msg, "return type '{}' cannot cast into return type '{}'", .{
20871 pair.actual.fmt(sema.mod), pair.wanted.fmt(sema.mod),
20872 });
20873 cur = pair.child;
20874 },
20875 .ptr_child => |pair| {
20876 try sema.errNote(block, src, msg, "pointer type child '{}' cannot cast into pointer type child '{}'", .{
20877 pair.actual.fmt(sema.mod), pair.wanted.fmt(sema.mod),
20878 });
20879 cur = pair.child;
20880 },
20881 .ptr_addrspace => |@"addrspace"| {
20882 try sema.errNote(block, src, msg, "address space '{s}' cannot cast into address space '{s}'", .{ @tagName(@"addrspace".actual), @tagName(@"addrspace".wanted) });
20883 break;
20884 },
20885 .ptr_sentinel => |sentinel| {
20886 if (sentinel.actual.tag() != .unreachable_value) {
20887 try sema.errNote(block, src, msg, "pointer sentinel '{}' cannot cast into pointer sentinel '{}'", .{
20888 sentinel.actual.fmtValue(sentinel.ty, sema.mod), sentinel.wanted.fmtValue(sentinel.ty, sema.mod),
20889 });
20890 } else {
20891 try sema.errNote(block, src, msg, "destination pointer requires '{}' sentinel", .{
20892 sentinel.wanted.fmtValue(sentinel.ty, sema.mod),
20893 });
20894 }
20895 break;
20896 },
20897 .ptr_size => |size| {
20898 try sema.errNote(block, src, msg, "a {s} pointer cannot cast into a {s} pointer", .{ pointerSizeString(size.actual), pointerSizeString(size.wanted) });
20899 break;
20900 },
20901 .ptr_qualifiers => |qualifiers| {
20902 const ok_const = !qualifiers.actual_const or qualifiers.wanted_const;
20903 const ok_volatile = !qualifiers.actual_volatile or qualifiers.wanted_volatile;
20904 if (!ok_const) {
20905 try sema.errNote(block, src, msg, "cast discards const qualifier", .{});
20906 } else if (!ok_volatile) {
20907 try sema.errNote(block, src, msg, "cast discards volatile qualifier", .{});
20908 }
20909 break;
20910 },
20911 .ptr_allowzero => |pair| {
20912 const wanted_allow_zero = pair.wanted.ptrAllowsZero();
20913 const actual_allow_zero = pair.actual.ptrAllowsZero();
20914 if (actual_allow_zero and !wanted_allow_zero) {
20915 try sema.errNote(block, src, msg, "'{}' could have null values which are illegal in type '{}'", .{
20916 pair.actual.fmt(sema.mod), pair.wanted.fmt(sema.mod),
20917 });
20918 } else {
20919 try sema.errNote(block, src, msg, "mutable '{}' allows illegal null values stored to type '{}'", .{
20920 pair.actual.fmt(sema.mod), pair.wanted.fmt(sema.mod),
20921 });
20922 }
20923 break;
20924 },
20925 .ptr_bit_range => |bit_range| {
20926 if (bit_range.actual_host != bit_range.wanted_host) {
20927 try sema.errNote(block, src, msg, "pointer host size '{}' cannot cast into pointer host size '{}'", .{
20928 bit_range.actual_host, bit_range.wanted_host,
20929 });
20930 }
20931 if (bit_range.actual_offset != bit_range.wanted_offset) {
20932 try sema.errNote(block, src, msg, "pointer bit offset '{}' cannot cast into pointer bit offset '{}'", .{
20933 bit_range.actual_offset, bit_range.wanted_offset,
20934 });
20935 }
20936 break;
20937 },
20938 .ptr_alignment => |pair| {
20939 try sema.errNote(block, src, msg, "pointer alignment '{}' cannot cast into pointer alignment '{}'", .{
20940 pair.actual, pair.wanted,
20941 });
20942 break;
20943 },
20944 };
20945 }
20505};20946};
2050620947
20948fn pointerSizeString(size: std.builtin.Type.Pointer.Size) []const u8 {
20949 return switch (size) {
20950 .One => "single",
20951 .Many => "many",
20952 .C => "C",
20953 .Slice => unreachable,
20954 };
20955}
20956
20507/// If pointers have the same representation in runtime memory, a bitcast AIR instruction20957/// If pointers have the same representation in runtime memory, a bitcast AIR instruction
20508/// may be used for the coercion.20958/// may be used for the coercion.
20509/// * `const` attribute can be gained20959/// * `const` attribute can be gained
...@@ -20513,8 +20963,6 @@ const InMemoryCoercionResult = enum {...@@ -20513,8 +20963,6 @@ const InMemoryCoercionResult = enum {
20513/// * bit offset attributes must match exactly20963/// * bit offset attributes must match exactly
20514/// * `*`/`[*]` must match exactly, but `[*c]` matches either one20964/// * `*`/`[*]` must match exactly, but `[*c]` matches either one
20515/// * sentinel-terminated pointers can coerce into `[*]`20965/// * sentinel-terminated pointers can coerce into `[*]`
20516/// TODO improve this function to report recursive compile errors like it does in stage1.
20517/// look at the function types_match_const_cast_only
20518fn coerceInMemoryAllowed(20966fn coerceInMemoryAllowed(
20519 sema: *Sema,20967 sema: *Sema,
20520 block: *Block,20968 block: *Block,
...@@ -20532,11 +20980,25 @@ fn coerceInMemoryAllowed(...@@ -20532,11 +20980,25 @@ fn coerceInMemoryAllowed(
20532 if (dest_ty.zigTypeTag() == .Int and src_ty.zigTypeTag() == .Int) {20980 if (dest_ty.zigTypeTag() == .Int and src_ty.zigTypeTag() == .Int) {
20533 const dest_info = dest_ty.intInfo(target);20981 const dest_info = dest_ty.intInfo(target);
20534 const src_info = src_ty.intInfo(target);20982 const src_info = src_ty.intInfo(target);
20983
20535 if (dest_info.signedness == src_info.signedness and20984 if (dest_info.signedness == src_info.signedness and
20536 dest_info.bits == src_info.bits)20985 dest_info.bits == src_info.bits)
20537 {20986 {
20538 return .ok;20987 return .ok;
20539 }20988 }
20989
20990 if ((src_info.signedness == dest_info.signedness and dest_info.bits < src_info.bits) or
20991 // small enough unsigned ints can get casted to large enough signed ints
20992 (dest_info.signedness == .signed and (src_info.signedness == .unsigned or dest_info.bits <= src_info.bits)) or
20993 (dest_info.signedness == .unsigned and src_info.signedness == .signed))
20994 {
20995 return InMemoryCoercionResult{ .int_not_coercible = .{
20996 .actual_signedness = src_info.signedness,
20997 .wanted_signedness = dest_info.signedness,
20998 .actual_bits = src_info.bits,
20999 .wanted_bits = dest_info.bits,
21000 } };
21001 }
20540 }21002 }
2054121003
20542 // Differently-named floats with the same number of bits.21004 // Differently-named floats with the same number of bits.
...@@ -20574,9 +21036,15 @@ fn coerceInMemoryAllowed(...@@ -20574,9 +21036,15 @@ fn coerceInMemoryAllowed(
2057421036
20575 // Error Unions21037 // Error Unions
20576 if (dest_tag == .ErrorUnion and src_tag == .ErrorUnion) {21038 if (dest_tag == .ErrorUnion and src_tag == .ErrorUnion) {
20577 const child = try sema.coerceInMemoryAllowed(block, dest_ty.errorUnionPayload(), src_ty.errorUnionPayload(), dest_is_mut, target, dest_src, src_src);21039 const dest_payload = dest_ty.errorUnionPayload();
20578 if (child == .no_match) {21040 const src_payload = src_ty.errorUnionPayload();
20579 return child;21041 const child = try sema.coerceInMemoryAllowed(block, dest_payload, src_payload, dest_is_mut, target, dest_src, src_src);
21042 if (child != .ok) {
21043 return InMemoryCoercionResult{ .error_union_payload = .{
21044 .child = try child.dupe(sema.arena),
21045 .actual = src_payload,
21046 .wanted = dest_payload,
21047 } };
20580 }21048 }
20581 return try sema.coerceInMemoryAllowed(block, dest_ty.errorUnionSet(), src_ty.errorUnionSet(), dest_is_mut, target, dest_src, src_src);21049 return try sema.coerceInMemoryAllowed(block, dest_ty.errorUnionSet(), src_ty.errorUnionSet(), dest_is_mut, target, dest_src, src_src);
20582 }21050 }
...@@ -20587,57 +21055,89 @@ fn coerceInMemoryAllowed(...@@ -20587,57 +21055,89 @@ fn coerceInMemoryAllowed(
20587 }21055 }
2058821056
20589 // Arrays21057 // Arrays
20590 if (dest_tag == .Array and src_tag == .Array) arrays: {21058 if (dest_tag == .Array and src_tag == .Array) {
20591 const dest_info = dest_ty.arrayInfo();21059 const dest_info = dest_ty.arrayInfo();
20592 const src_info = src_ty.arrayInfo();21060 const src_info = src_ty.arrayInfo();
20593 if (dest_info.len != src_info.len) break :arrays;21061 if (dest_info.len != src_info.len) {
21062 return InMemoryCoercionResult{ .array_len = .{
21063 .actual = src_info.len,
21064 .wanted = dest_info.len,
21065 } };
21066 }
2059421067
20595 const child = try sema.coerceInMemoryAllowed(block, dest_info.elem_type, src_info.elem_type, dest_is_mut, target, dest_src, src_src);21068 const child = try sema.coerceInMemoryAllowed(block, dest_info.elem_type, src_info.elem_type, dest_is_mut, target, dest_src, src_src);
20596 if (child == .no_match) {21069 if (child != .ok) {
20597 return child;21070 return InMemoryCoercionResult{ .array_elem = .{
21071 .child = try child.dupe(sema.arena),
21072 .actual = src_info.elem_type,
21073 .wanted = dest_info.elem_type,
21074 } };
20598 }21075 }
20599 const ok_sent = dest_info.sentinel == null or21076 const ok_sent = dest_info.sentinel == null or
20600 (src_info.sentinel != null and21077 (src_info.sentinel != null and
20601 dest_info.sentinel.?.eql(src_info.sentinel.?, dest_info.elem_type, sema.mod));21078 dest_info.sentinel.?.eql(src_info.sentinel.?, dest_info.elem_type, sema.mod));
20602 if (!ok_sent) {21079 if (!ok_sent) {
20603 return .no_match;21080 return InMemoryCoercionResult{ .array_sentinel = .{
21081 .actual = src_info.sentinel orelse Value.initTag(.unreachable_value),
21082 .wanted = dest_info.sentinel orelse Value.initTag(.unreachable_value),
21083 .ty = dest_info.elem_type,
21084 } };
20604 }21085 }
20605 return .ok;21086 return .ok;
20606 }21087 }
2060721088
20608 // Vectors21089 // Vectors
20609 if (dest_tag == .Vector and src_tag == .Vector) vectors: {21090 if (dest_tag == .Vector and src_tag == .Vector) {
20610 const dest_len = dest_ty.vectorLen();21091 const dest_len = dest_ty.vectorLen();
20611 const src_len = src_ty.vectorLen();21092 const src_len = src_ty.vectorLen();
20612 if (dest_len != src_len) break :vectors;21093 if (dest_len != src_len) {
21094 return InMemoryCoercionResult{ .vector_len = .{
21095 .actual = src_len,
21096 .wanted = dest_len,
21097 } };
21098 }
2061321099
20614 const dest_elem_ty = dest_ty.scalarType();21100 const dest_elem_ty = dest_ty.scalarType();
20615 const src_elem_ty = src_ty.scalarType();21101 const src_elem_ty = src_ty.scalarType();
20616 const child = try sema.coerceInMemoryAllowed(block, dest_elem_ty, src_elem_ty, dest_is_mut, target, dest_src, src_src);21102 const child = try sema.coerceInMemoryAllowed(block, dest_elem_ty, src_elem_ty, dest_is_mut, target, dest_src, src_src);
20617 if (child == .no_match) break :vectors;21103 if (child != .ok) {
21104 return InMemoryCoercionResult{ .vector_elem = .{
21105 .child = try child.dupe(sema.arena),
21106 .actual = src_elem_ty,
21107 .wanted = dest_elem_ty,
21108 } };
21109 }
2061821110
20619 return .ok;21111 return .ok;
20620 }21112 }
2062121113
20622 // Optionals21114 // Optionals
20623 if (dest_tag == .Optional and src_tag == .Optional) optionals: {21115 if (dest_tag == .Optional and src_tag == .Optional) {
20624 if ((maybe_dest_ptr_ty != null) != (maybe_src_ptr_ty != null)) {21116 if ((maybe_dest_ptr_ty != null) != (maybe_src_ptr_ty != null)) {
20625 // TODO "optional type child '{}' cannot cast into optional type '{}'"21117 return InMemoryCoercionResult{ .optional_shape = .{
20626 return .no_match;21118 .actual = src_ty,
21119 .wanted = dest_ty,
21120 } };
20627 }21121 }
20628 const dest_child_type = dest_ty.optionalChild(&dest_buf);21122 const dest_child_type = dest_ty.optionalChild(&dest_buf);
20629 const src_child_type = src_ty.optionalChild(&src_buf);21123 const src_child_type = src_ty.optionalChild(&src_buf);
2063021124
20631 const child = try sema.coerceInMemoryAllowed(block, dest_child_type, src_child_type, dest_is_mut, target, dest_src, src_src);21125 const child = try sema.coerceInMemoryAllowed(block, dest_child_type, src_child_type, dest_is_mut, target, dest_src, src_src);
20632 if (child == .no_match) {21126 if (child != .ok) {
20633 // TODO "optional type child '{}' cannot cast into optional type child '{}'"21127 return InMemoryCoercionResult{ .optional_child = .{
20634 break :optionals;21128 .child = try child.dupe(sema.arena),
21129 .actual = src_child_type,
21130 .wanted = dest_child_type,
21131 } };
20635 }21132 }
2063621133
20637 return .ok;21134 return .ok;
20638 }21135 }
2063921136
20640 return .no_match;21137 return InMemoryCoercionResult{ .no_match = .{
21138 .actual = dest_ty,
21139 .wanted = src_ty,
21140 } };
20641}21141}
2064221142
20643fn coerceInMemoryAllowedErrorSets(21143fn coerceInMemoryAllowedErrorSets(
...@@ -20704,6 +21204,9 @@ fn coerceInMemoryAllowedErrorSets(...@@ -20704,6 +21204,9 @@ fn coerceInMemoryAllowedErrorSets(
20704 }21204 }
20705 }21205 }
2070621206
21207 var missing_error_buf = std.ArrayList([]const u8).init(sema.gpa);
21208 defer missing_error_buf.deinit();
21209
20707 switch (src_ty.tag()) {21210 switch (src_ty.tag()) {
20708 .error_set_inferred => {21211 .error_set_inferred => {
20709 const src_data = src_ty.castTag(.error_set_inferred).?.data;21212 const src_data = src_ty.castTag(.error_set_inferred).?.data;
...@@ -20712,15 +21215,21 @@ fn coerceInMemoryAllowedErrorSets(...@@ -20712,15 +21215,21 @@ fn coerceInMemoryAllowedErrorSets(
20712 // src anyerror status might have changed after the resolution.21215 // src anyerror status might have changed after the resolution.
20713 if (src_ty.isAnyError()) {21216 if (src_ty.isAnyError()) {
20714 // dest_ty.isAnyError() == true is already checked for at this point.21217 // dest_ty.isAnyError() == true is already checked for at this point.
20715 return .no_match;21218 return .from_anyerror;
20716 }21219 }
2071721220
20718 for (src_data.errors.keys()) |key| {21221 for (src_data.errors.keys()) |key| {
20719 if (!dest_ty.errorSetHasField(key)) {21222 if (!dest_ty.errorSetHasField(key)) {
20720 return .no_match;21223 try missing_error_buf.append(key);
20721 }21224 }
20722 }21225 }
2072321226
21227 if (missing_error_buf.items.len != 0) {
21228 return InMemoryCoercionResult{
21229 .missing_error = try sema.arena.dupe([]const u8, missing_error_buf.items),
21230 };
21231 }
21232
20724 return .ok;21233 return .ok;
20725 },21234 },
20726 .error_set_single => {21235 .error_set_single => {
...@@ -20728,37 +21237,52 @@ fn coerceInMemoryAllowedErrorSets(...@@ -20728,37 +21237,52 @@ fn coerceInMemoryAllowedErrorSets(
20728 if (dest_ty.errorSetHasField(name)) {21237 if (dest_ty.errorSetHasField(name)) {
20729 return .ok;21238 return .ok;
20730 }21239 }
21240 const list = try sema.arena.alloc([]const u8, 1);
21241 list[0] = name;
21242 return InMemoryCoercionResult{ .missing_error = list };
20731 },21243 },
20732 .error_set_merged => {21244 .error_set_merged => {
20733 const names = src_ty.castTag(.error_set_merged).?.data.keys();21245 const names = src_ty.castTag(.error_set_merged).?.data.keys();
20734 for (names) |name| {21246 for (names) |name| {
20735 if (!dest_ty.errorSetHasField(name)) {21247 if (!dest_ty.errorSetHasField(name)) {
20736 return .no_match;21248 try missing_error_buf.append(name);
20737 }21249 }
20738 }21250 }
2073921251
21252 if (missing_error_buf.items.len != 0) {
21253 return InMemoryCoercionResult{
21254 .missing_error = try sema.arena.dupe([]const u8, missing_error_buf.items),
21255 };
21256 }
21257
20740 return .ok;21258 return .ok;
20741 },21259 },
20742 .error_set => {21260 .error_set => {
20743 const names = src_ty.castTag(.error_set).?.data.names.keys();21261 const names = src_ty.castTag(.error_set).?.data.names.keys();
20744 for (names) |name| {21262 for (names) |name| {
20745 if (!dest_ty.errorSetHasField(name)) {21263 if (!dest_ty.errorSetHasField(name)) {
20746 return .no_match;21264 try missing_error_buf.append(name);
20747 }21265 }
20748 }21266 }
2074921267
21268 if (missing_error_buf.items.len != 0) {
21269 return InMemoryCoercionResult{
21270 .missing_error = try sema.arena.dupe([]const u8, missing_error_buf.items),
21271 };
21272 }
21273
20750 return .ok;21274 return .ok;
20751 },21275 },
20752 .anyerror => switch (dest_ty.tag()) {21276 .anyerror => switch (dest_ty.tag()) {
20753 .error_set_inferred => return .no_match, // Caught by dest.isAnyError() above.21277 .error_set_inferred => unreachable, // Caught by dest_ty.isAnyError() above.
20754 .error_set_single, .error_set_merged, .error_set => {},21278 .error_set_single, .error_set_merged, .error_set => return .from_anyerror,
20755 .anyerror => unreachable, // Filtered out above.21279 .anyerror => unreachable, // Filtered out above.
20756 else => unreachable,21280 else => unreachable,
20757 },21281 },
20758 else => unreachable,21282 else => unreachable,
20759 }21283 }
2076021284
20761 return .no_match;21285 unreachable;
20762}21286}
2076321287
20764fn coerceInMemoryAllowedFns(21288fn coerceInMemoryAllowedFns(
...@@ -20774,44 +21298,67 @@ fn coerceInMemoryAllowedFns(...@@ -20774,44 +21298,67 @@ fn coerceInMemoryAllowedFns(
20774 const src_info = src_ty.fnInfo();21298 const src_info = src_ty.fnInfo();
2077521299
20776 if (dest_info.is_var_args != src_info.is_var_args) {21300 if (dest_info.is_var_args != src_info.is_var_args) {
20777 return .no_match;21301 return InMemoryCoercionResult{ .fn_var_args = dest_info.is_var_args };
20778 }21302 }
2077921303
20780 if (dest_info.is_generic != src_info.is_generic) {21304 if (dest_info.is_generic != src_info.is_generic) {
20781 return .no_match;21305 return InMemoryCoercionResult{ .fn_generic = dest_info.is_generic };
21306 }
21307
21308 if (dest_info.cc != src_info.cc) {
21309 return InMemoryCoercionResult{ .fn_cc = .{
21310 .actual = src_info.cc,
21311 .wanted = dest_info.cc,
21312 } };
20782 }21313 }
2078321314
20784 if (!src_info.return_type.isNoReturn()) {21315 if (!src_info.return_type.isNoReturn()) {
20785 const rt = try sema.coerceInMemoryAllowed(block, dest_info.return_type, src_info.return_type, false, target, dest_src, src_src);21316 const rt = try sema.coerceInMemoryAllowed(block, dest_info.return_type, src_info.return_type, false, target, dest_src, src_src);
20786 if (rt == .no_match) {21317 if (rt != .ok) {
20787 return rt;21318 return InMemoryCoercionResult{ .fn_return_type = .{
21319 .child = try rt.dupe(sema.arena),
21320 .actual = src_info.return_type,
21321 .wanted = dest_info.return_type,
21322 } };
20788 }21323 }
20789 }21324 }
2079021325
20791 if (dest_info.param_types.len != src_info.param_types.len) {21326 if (dest_info.param_types.len != src_info.param_types.len) {
20792 return .no_match;21327 return InMemoryCoercionResult{ .fn_param_count = .{
21328 .actual = dest_info.param_types.len,
21329 .wanted = dest_info.param_types.len,
21330 } };
21331 }
21332
21333 if (dest_info.noalias_bits != src_info.noalias_bits) {
21334 return InMemoryCoercionResult{ .fn_param_noalias = .{
21335 .actual = dest_info.noalias_bits,
21336 .wanted = dest_info.noalias_bits,
21337 } };
20793 }21338 }
2079421339
20795 for (dest_info.param_types) |dest_param_ty, i| {21340 for (dest_info.param_types) |dest_param_ty, i| {
20796 const src_param_ty = src_info.param_types[i];21341 const src_param_ty = src_info.param_types[i];
2079721342
20798 if (dest_info.comptime_params[i] != src_info.comptime_params[i]) {21343 if (dest_info.comptime_params[i] != src_info.comptime_params[i]) {
20799 return .no_match;21344 return InMemoryCoercionResult{ .fn_param_comptime = .{
21345 .index = i,
21346 .wanted = dest_info.comptime_params[i],
21347 } };
20800 }21348 }
2080121349
20802 // TODO: noalias
20803
20804 // Note: Cast direction is reversed here.21350 // Note: Cast direction is reversed here.
20805 const param = try sema.coerceInMemoryAllowed(block, src_param_ty, dest_param_ty, false, target, dest_src, src_src);21351 const param = try sema.coerceInMemoryAllowed(block, src_param_ty, dest_param_ty, false, target, dest_src, src_src);
20806 if (param == .no_match) {21352 if (param != .ok) {
20807 return param;21353 return InMemoryCoercionResult{ .fn_param = .{
21354 .child = try param.dupe(sema.arena),
21355 .actual = src_param_ty,
21356 .wanted = dest_param_ty,
21357 .index = i,
21358 } };
20808 }21359 }
20809 }21360 }
2081021361
20811 if (dest_info.cc != src_info.cc) {
20812 return .no_match;
20813 }
20814
20815 return .ok;21362 return .ok;
20816}21363}
2081721364
...@@ -20830,26 +21377,13 @@ fn coerceInMemoryAllowedPtrs(...@@ -20830,26 +21377,13 @@ fn coerceInMemoryAllowedPtrs(
20830 const dest_info = dest_ptr_ty.ptrInfo().data;21377 const dest_info = dest_ptr_ty.ptrInfo().data;
20831 const src_info = src_ptr_ty.ptrInfo().data;21378 const src_info = src_ptr_ty.ptrInfo().data;
2083221379
20833 const child = try sema.coerceInMemoryAllowed(block, dest_info.pointee_type, src_info.pointee_type, dest_info.mutable, target, dest_src, src_src);
20834 if (child == .no_match) {
20835 return child;
20836 }
20837
20838 if (dest_info.@"addrspace" != src_info.@"addrspace") {
20839 return .no_match;
20840 }
20841
20842 const ok_sent = dest_info.sentinel == null or src_info.size == .C or
20843 (src_info.sentinel != null and
20844 dest_info.sentinel.?.eql(src_info.sentinel.?, dest_info.pointee_type, sema.mod));
20845 if (!ok_sent) {
20846 return .no_match;
20847 }
20848
20849 const ok_ptr_size = src_info.size == dest_info.size or21380 const ok_ptr_size = src_info.size == dest_info.size or
20850 src_info.size == .C or dest_info.size == .C;21381 src_info.size == .C or dest_info.size == .C;
20851 if (!ok_ptr_size) {21382 if (!ok_ptr_size) {
20852 return .no_match;21383 return InMemoryCoercionResult{ .ptr_size = .{
21384 .actual = src_info.size,
21385 .wanted = dest_info.size,
21386 } };
20853 }21387 }
2085421388
20855 const ok_cv_qualifiers =21389 const ok_cv_qualifiers =
...@@ -20857,7 +21391,28 @@ fn coerceInMemoryAllowedPtrs(...@@ -20857,7 +21391,28 @@ fn coerceInMemoryAllowedPtrs(
20857 (!src_info.@"volatile" or dest_info.@"volatile");21391 (!src_info.@"volatile" or dest_info.@"volatile");
2085821392
20859 if (!ok_cv_qualifiers) {21393 if (!ok_cv_qualifiers) {
20860 return .no_match;21394 return InMemoryCoercionResult{ .ptr_qualifiers = .{
21395 .actual_const = !src_info.mutable,
21396 .wanted_const = !dest_info.mutable,
21397 .actual_volatile = src_info.@"volatile",
21398 .wanted_volatile = dest_info.@"volatile",
21399 } };
21400 }
21401
21402 if (dest_info.@"addrspace" != src_info.@"addrspace") {
21403 return InMemoryCoercionResult{ .ptr_addrspace = .{
21404 .actual = src_info.@"addrspace",
21405 .wanted = dest_info.@"addrspace",
21406 } };
21407 }
21408
21409 const child = try sema.coerceInMemoryAllowed(block, dest_info.pointee_type, src_info.pointee_type, dest_info.mutable, target, dest_src, src_src);
21410 if (child != .ok) {
21411 return InMemoryCoercionResult{ .ptr_child = .{
21412 .child = try child.dupe(sema.arena),
21413 .actual = src_info.pointee_type,
21414 .wanted = dest_info.pointee_type,
21415 } };
20861 }21416 }
2086221417
20863 const dest_allow_zero = dest_ty.ptrAllowsZero();21418 const dest_allow_zero = dest_ty.ptrAllowsZero();
...@@ -20867,13 +21422,32 @@ fn coerceInMemoryAllowedPtrs(...@@ -20867,13 +21422,32 @@ fn coerceInMemoryAllowedPtrs(
20867 (src_allow_zero or !dest_is_mut)) or21422 (src_allow_zero or !dest_is_mut)) or
20868 (!dest_allow_zero and !src_allow_zero);21423 (!dest_allow_zero and !src_allow_zero);
20869 if (!ok_allows_zero) {21424 if (!ok_allows_zero) {
20870 return .no_match;21425 return InMemoryCoercionResult{ .ptr_allowzero = .{
21426 .actual = src_ty,
21427 .wanted = dest_ty,
21428 } };
20871 }21429 }
2087221430
20873 if (src_info.host_size != dest_info.host_size or21431 if (src_info.host_size != dest_info.host_size or
20874 src_info.bit_offset != dest_info.bit_offset)21432 src_info.bit_offset != dest_info.bit_offset)
20875 {21433 {
20876 return .no_match;21434 return InMemoryCoercionResult{ .ptr_bit_range = .{
21435 .actual_host = src_info.host_size,
21436 .wanted_host = dest_info.host_size,
21437 .actual_offset = src_info.bit_offset,
21438 .wanted_offset = dest_info.bit_offset,
21439 } };
21440 }
21441
21442 const ok_sent = dest_info.sentinel == null or src_info.size == .C or
21443 (src_info.sentinel != null and
21444 dest_info.sentinel.?.eql(src_info.sentinel.?, dest_info.pointee_type, sema.mod));
21445 if (!ok_sent) {
21446 return InMemoryCoercionResult{ .ptr_sentinel = .{
21447 .actual = src_info.sentinel orelse Value.initTag(.unreachable_value),
21448 .wanted = dest_info.sentinel orelse Value.initTag(.unreachable_value),
21449 .ty = dest_info.pointee_type,
21450 } };
20877 }21451 }
2087821452
20879 // If both pointers have alignment 0, it means they both want ABI alignment.21453 // If both pointers have alignment 0, it means they both want ABI alignment.
...@@ -20898,7 +21472,10 @@ fn coerceInMemoryAllowedPtrs(...@@ -20898,7 +21472,10 @@ fn coerceInMemoryAllowedPtrs(
20898 dest_info.pointee_type.abiAlignment(target);21472 dest_info.pointee_type.abiAlignment(target);
2089921473
20900 if (dest_align > src_align) {21474 if (dest_align > src_align) {
20901 return .no_match;21475 return InMemoryCoercionResult{ .ptr_alignment = .{
21476 .actual = src_align,
21477 .wanted = dest_align,
21478 } };
20902 }21479 }
2090321480
20904 break :alignment;21481 break :alignment;
...@@ -20974,6 +21551,8 @@ fn storePtr2(...@@ -20974,6 +21551,8 @@ fn storePtr2(
20974 // TODO do the same thing for anon structs as for tuples above.21551 // TODO do the same thing for anon structs as for tuples above.
20975 // However, beware of the need to handle missing/extra fields.21552 // However, beware of the need to handle missing/extra fields.
2097621553
21554 const is_ret = air_tag == .ret_ptr;
21555
20977 // Detect if we are storing an array operand to a bitcasted vector pointer.21556 // Detect if we are storing an array operand to a bitcasted vector pointer.
20978 // If so, we instead reach through the bitcasted pointer to the vector pointer,21557 // If so, we instead reach through the bitcasted pointer to the vector pointer,
20979 // bitcast the array operand to a vector, and then lower this as a store of21558 // bitcast the array operand to a vector, and then lower this as a store of
...@@ -20982,12 +21561,18 @@ fn storePtr2(...@@ -20982,12 +21561,18 @@ fn storePtr2(
20982 // https://github.com/ziglang/zig/issues/1115421561 // https://github.com/ziglang/zig/issues/11154
20983 if (sema.obtainBitCastedVectorPtr(ptr)) |vector_ptr| {21562 if (sema.obtainBitCastedVectorPtr(ptr)) |vector_ptr| {
20984 const vector_ty = sema.typeOf(vector_ptr).childType();21563 const vector_ty = sema.typeOf(vector_ptr).childType();
20985 const vector = try sema.coerce(block, vector_ty, uncasted_operand, operand_src);21564 const vector = sema.coerceExtra(block, vector_ty, uncasted_operand, operand_src, true, is_ret) catch |err| switch (err) {
21565 error.NotCoercible => unreachable,
21566 else => |e| return e,
21567 };
20986 try sema.storePtr2(block, src, vector_ptr, ptr_src, vector, operand_src, .store);21568 try sema.storePtr2(block, src, vector_ptr, ptr_src, vector, operand_src, .store);
20987 return;21569 return;
20988 }21570 }
2098921571
20990 const operand = try sema.coerce(block, elem_ty, uncasted_operand, operand_src);21572 const operand = sema.coerceExtra(block, elem_ty, uncasted_operand, operand_src, true, is_ret) catch |err| switch (err) {
21573 error.NotCoercible => unreachable,
21574 else => |e| return e,
21575 };
20991 const maybe_operand_val = try sema.resolveMaybeUndefVal(block, operand_src, operand);21576 const maybe_operand_val = try sema.resolveMaybeUndefVal(block, operand_src, operand);
2099221577
20993 const runtime_src = if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| rs: {21578 const runtime_src = if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| rs: {
...@@ -21017,7 +21602,11 @@ fn storePtr2(...@@ -21017,7 +21602,11 @@ fn storePtr2(
2101721602
21018 try sema.requireRuntimeBlock(block, runtime_src);21603 try sema.requireRuntimeBlock(block, runtime_src);
21019 try sema.queueFullTypeResolution(elem_ty);21604 try sema.queueFullTypeResolution(elem_ty);
21020 _ = try block.addBinOp(air_tag, ptr, operand);21605 if (is_ret) {
21606 _ = try block.addBinOp(.store, ptr, operand);
21607 } else {
21608 _ = try block.addBinOp(air_tag, ptr, operand);
21609 }
21021}21610}
2102221611
21023/// Traverse an arbitrary number of bitcasted pointers and return the underyling vector21612/// Traverse an arbitrary number of bitcasted pointers and return the underyling vector
test/cases/aarch64-macos/hello_world_with_updates.1.zig+2-1
...@@ -2,4 +2,5 @@ pub export fn main() noreturn {}...@@ -2,4 +2,5 @@ pub export fn main() noreturn {}
22
3// error3// error
4//4//
5// :1:32: error: expected type 'noreturn', found 'void'5// :1:32: error: function declared 'noreturn' returns
6// :1:22: note: 'noreturn' declared here
test/cases/compile_errors/address_of_number_literal.zig+2
...@@ -8,3 +8,5 @@ export fn entry() usize { return @sizeOf(@TypeOf(&foo)); }...@@ -8,3 +8,5 @@ export fn entry() usize { return @sizeOf(@TypeOf(&foo)); }
8// target=native8// target=native
9//9//
10// :3:30: error: expected type '*const i32', found '*const comptime_int'10// :3:30: error: expected type '*const i32', found '*const comptime_int'
11// :3:30: note: pointer type child 'comptime_int' cannot cast into pointer type child 'i32'
12// :3:10: note: function return type declared here
test/cases/compile_errors/any_typed_null_to_any_typed_optional.zig+5-5
...@@ -1,11 +1,11 @@...@@ -1,11 +1,11 @@
1pub fn main() void {1pub export fn entry() void {
2 var a: ?*anyopaque = undefined;2 var a: ?*anyopaque = undefined;
3 a = @as(?usize, null);3 a = @as(?usize, null);
4}4}
55
6// error6// error
7// output_mode=Exe7// backend=stage2
8// backend=stage2,llvm8// target=native
9// target=x86_64-linux,x86_64-macos
10//9//
11// :3:21: error: expected type '*anyopaque', found '?usize'10// :3:21: error: expected type '?*anyopaque', found '?usize'
11// :3:21: note: optional type child 'usize' cannot cast into optional type child '*anyopaque'
test/cases/compile_errors/assigning_to_struct_or_union_fields_that_are_not_optionals_with_a_function_that_returns_an_optional.zig created+23
...@@ -0,0 +1,23 @@
1fn maybe(is: bool) ?u8 {
2 if (is) return @as(u8, 10) else return null;
3}
4const U = union {
5 Ye: u8,
6};
7const S = struct {
8 num: u8,
9};
10export fn entry() void {
11 var u = U{ .Ye = maybe(false) };
12 var s = S{ .num = maybe(false) };
13 _ = u;
14 _ = s;
15}
16
17// error
18// backend=stage2
19// target=native
20//
21// :11:27: error: expected type 'u8', found '?u8'
22// :11:27: note: cannot convert optional to payload type
23// :11:27: note: consider using `.?`, `orelse`, or `if`
test/cases/compile_errors/attempted_implicit_cast_from_const_T_to_array_len_1_T.zig created+14
...@@ -0,0 +1,14 @@
1export fn entry(byte: u8) void {
2 const w: i32 = 1234;
3 var x: *const i32 = &w;
4 var y: *[1]i32 = x;
5 y[0] += 1;
6 _ = byte;
7}
8
9// error
10// backend=stage2
11// target=native
12//
13// :4:22: error: expected type '*[1]i32', found '*const i32'
14// :4:22: note: cast discards const qualifier
test/cases/compile_errors/cast_between_optional_T_where_T_is_not_a_pointer.zig created+26
...@@ -0,0 +1,26 @@
1pub const fnty1 = ?*const fn (i8) void;
2pub const fnty2 = ?*const fn (u64) void;
3export fn entry1() void {
4 var a: fnty1 = undefined;
5 var b: fnty2 = undefined;
6 a = b;
7}
8
9pub const fnty3 = ?*const fn (u63) void;
10export fn entry2() void {
11 var a: fnty3 = undefined;
12 var b: fnty2 = undefined;
13 a = b;
14}
15
16// error
17// backend=stage2
18// target=native
19//
20// :6:9: error: expected type '?*const fn(i8) void', found '?*const fn(u64) void'
21// :6:9: note: pointer type child 'fn(u64) void' cannot cast into pointer type child 'fn(i8) void'
22// :6:9: note: parameter 0 'u64' cannot cast into 'i8'
23// :6:9: note: unsigned 64-bit int cannot represent all possible signed 8-bit values
24// :13:9: error: expected type '?*const fn(u63) void', found '?*const fn(u64) void'
25// :13:9: note: pointer type child 'fn(u64) void' cannot cast into pointer type child 'fn(u63) void'
26// :13:9: note: parameter 0 'u64' cannot cast into 'u63'
test/cases/compile_errors/cast_error_union_of_global_error_set_to_error_union_of_smaller_error_set.zig created+15
...@@ -0,0 +1,15 @@
1const SmallErrorSet = error{A};
2export fn entry() void {
3 var x: SmallErrorSet!i32 = foo();
4 _ = x;
5}
6fn foo() anyerror!i32 {
7 return error.B;
8}
9
10// error
11// backend=stage2
12// target=native
13//
14// :3:35: error: expected type 'error{A}!i32', found 'anyerror!i32'
15// :3:35: note: global error set cannot cast into a smaller set
test/cases/compile_errors/cast_global_error_set_to_error_set.zig created+15
...@@ -0,0 +1,15 @@
1const SmallErrorSet = error{A};
2export fn entry() void {
3 var x: SmallErrorSet = foo();
4 _ = x;
5}
6fn foo() anyerror {
7 return error.B;
8}
9
10// error
11// backend=stage2
12// target=native
13//
14// :3:31: error: expected type 'error{A}', found 'anyerror'
15// :3:31: note: global error set cannot cast into a smaller set
test/cases/compile_errors/casting_bit_offset_pointer_to_regular_pointer.zig+2
...@@ -19,3 +19,5 @@ export fn entry() usize { return @sizeOf(@TypeOf(&foo)); }...@@ -19,3 +19,5 @@ export fn entry() usize { return @sizeOf(@TypeOf(&foo)); }
19// target=native19// target=native
20//20//
21// :8:15: error: expected type '*const u3', found '*align(0:3:1) const u3'21// :8:15: error: expected type '*const u3', found '*align(0:3:1) const u3'
22// :8:15: note: pointer host size '1' cannot cast into pointer host size '0'
23// :8:15: note: pointer bit offset '3' cannot cast into pointer bit offset '0'
test/cases/compile_errors/discarding_error_value.zig+2-1
...@@ -9,4 +9,5 @@ fn foo() !void {...@@ -9,4 +9,5 @@ fn foo() !void {
9// backend=stage29// backend=stage2
10// target=native10// target=native
11//11//
12// :2:12: error: error is discarded. consider using `try`, `catch`, or `if`12// :2:12: error: error is discarded
13// :2:12: note: consider using `try`, `catch`, or `if`
test/cases/compile_errors/dont_implicit_cast_double_pointer_to_anyopaque.zig+1
...@@ -11,3 +11,4 @@ export fn entry() void {...@@ -11,3 +11,4 @@ export fn entry() void {
11// target=native11// target=native
12//12//
13// :5:28: error: expected type '*anyopaque', found '**u32'13// :5:28: error: expected type '*anyopaque', found '**u32'
14// :5:28: note: pointer type child '*u32' cannot cast into pointer type child 'anyopaque'
test/cases/compile_errors/error_note_for_function_parameter_incompatibility.zig created+13
...@@ -0,0 +1,13 @@
1fn do_the_thing(func: *const fn (arg: i32) void) void { _ = func; }
2fn bar(arg: bool) void { _ = arg; }
3export fn entry() void {
4 do_the_thing(bar);
5}
6
7// error
8// backend=stage2
9// target=native
10//
11// :4:17: error: expected type '*const fn(i32) void', found '*const fn(bool) void'
12// :4:17: note: pointer type child 'fn(bool) void' cannot cast into pointer type child 'fn(i32) void'
13// :4:17: note: parameter 0 'bool' cannot cast into 'i32'
test/cases/compile_errors/ignored_deferred_function_call.zig+2-1
...@@ -7,4 +7,5 @@ fn bar() anyerror!i32 { return 0; }...@@ -7,4 +7,5 @@ fn bar() anyerror!i32 { return 0; }
7// backend=stage27// backend=stage2
8// target=native8// target=native
9//9//
10// :2:14: error: error is ignored. consider using `try`, `catch`, or `if`10// :2:14: error: error is ignored
11// :2:14: note: consider using `try`, `catch`, or `if`
test/cases/compile_errors/ignored_expression_in_while_continuation.zig+6-3
...@@ -17,6 +17,9 @@ fn bad() anyerror!void {...@@ -17,6 +17,9 @@ fn bad() anyerror!void {
17// backend=stage217// backend=stage2
18// target=native18// target=native
19//19//
20// :2:24: error: error is ignored. consider using `try`, `catch`, or `if`20// :2:24: error: error is ignored
21// :6:25: error: error is ignored. consider using `try`, `catch`, or `if`21// :2:24: note: consider using `try`, `catch`, or `if`
22// :10:25: error: error is ignored. consider using `try`, `catch`, or `if`22// :6:25: error: error is ignored
23// :6:25: note: consider using `try`, `catch`, or `if`
24// :10:25: error: error is ignored
25// :10:25: note: consider using `try`, `catch`, or `if`
test/cases/compile_errors/implicit_cast_of_error_set_not_a_subset.zig created+16
...@@ -0,0 +1,16 @@
1const Set1 = error{A, B};
2const Set2 = error{A, C};
3export fn entry() void {
4 foo(Set1.B);
5}
6fn foo(set1: Set1) void {
7 var x: Set2 = set1;
8 _ = x;
9}
10
11// error
12// backend=stage2
13// target=native
14//
15// :7:19: error: expected type 'error{A,C}', found 'error{A,B}'
16// :7:19: note: 'error.B' not a member of destination error set
test/cases/compile_errors/implicit_cast_to_c_ptr_from_int.zig created+15
...@@ -0,0 +1,15 @@
1const std = @import("std");
2export fn entry1() void {
3 _ = @as([*c]u8, @as(u65, std.math.maxInt(u65)));
4}
5export fn entry2() void {
6 _ = @as([*c]u8, std.math.maxInt(u65));
7}
8
9// error
10// backend=stage2
11// target=native
12//
13// :3:21: error: expected type '[*c]u8', found 'u65'
14// :3:21: note: unsigned 64-bit int cannot represent all possible unsigned 65-bit values
15// :6:36: error: expected type '[*c]u8', found 'comptime_int'
test/cases/compile_errors/implicit_casting_C_pointers_which_would_mess_up_null_semantics.zig created+26
...@@ -0,0 +1,26 @@
1export fn entry() void {
2 var slice: []const u8 = "aoeu";
3 const opt_many_ptr: [*]const u8 = slice.ptr;
4 var ptr_opt_many_ptr = &opt_many_ptr;
5 var c_ptr: [*c]const [*c]const u8 = ptr_opt_many_ptr;
6 ptr_opt_many_ptr = c_ptr;
7}
8export fn entry2() void {
9 var buf: [4]u8 = "aoeu".*;
10 var slice: []u8 = &buf;
11 var opt_many_ptr: [*]u8 = slice.ptr;
12 var ptr_opt_many_ptr = &opt_many_ptr;
13 var c_ptr: [*c][*c]const u8 = ptr_opt_many_ptr;
14 _ = c_ptr;
15}
16
17// error
18// backend=stage2
19// target=native
20//
21// :6:24: error: expected type '*const [*]const u8', found '[*c]const [*c]const u8'
22// :6:24: note: pointer type child '[*c]const u8' cannot cast into pointer type child '[*]const u8'
23// :6:24: note: '[*c]const u8' could have null values which are illegal in type '[*]const u8'
24// :13:35: error: expected type '[*c][*c]const u8', found '*[*]u8'
25// :13:35: note: pointer type child '[*]u8' cannot cast into pointer type child '[*c]const u8'
26// :13:35: note: mutable '[*]u8' allows illegal null values stored to type '[*c]const u8'
test/cases/compile_errors/implicitly_casting_enum_to_tag_type.zig+1
...@@ -15,3 +15,4 @@ export fn entry() void {...@@ -15,3 +15,4 @@ export fn entry() void {
15// target=native15// target=native
16//16//
17// :9:22: error: expected type 'u2', found 'tmp.Small'17// :9:22: error: expected type 'u2', found 'tmp.Small'
18// :1:15: note: enum declared here
test/cases/compile_errors/incompatible_sentinels.zig created+31
...@@ -0,0 +1,31 @@
1// Note: One of the error messages here is backwards. It would be nice to fix, but that's not
2// going to stop me from merging this branch which fixes a bunch of other stuff.
3export fn entry1(ptr: [*:255]u8) [*:0]u8 {
4 return ptr;
5}
6export fn entry2(ptr: [*]u8) [*:0]u8 {
7 return ptr;
8}
9export fn entry3() void {
10 var array: [2:0]u8 = [_:255]u8{ 1, 2 };
11 _ = array;
12}
13export fn entry4() void {
14 var array: [2:0]u8 = [_]u8{ 1, 2 };
15 _ = array;
16}
17
18// error
19// backend=stage2
20// target=native
21//
22// :4:12: error: expected type '[*:0]u8', found '[*:255]u8'
23// :4:12: note: pointer sentinel '255' cannot cast into pointer sentinel '0'
24// :3:35: note: function return type declared here
25// :7:12: error: expected type '[*:0]u8', found '[*]u8'
26// :7:12: note: destination pointer requires '0' sentinel
27// :6:31: note: function return type declared here
28// :10:35: error: expected type '[2:0]u8', found '[2:255]u8'
29// :10:35: note: array sentinel '255' cannot cast into array sentinel '0'
30// :14:31: error: expected type '[2:0]u8', found '[2]u8'
31// :14:31: note: destination array requires '0' sentinel
test/cases/compile_errors/incorrect_return_type.zig+3
...@@ -19,3 +19,6 @@...@@ -19,3 +19,6 @@
19// target=native19// target=native
20//20//
21// :8:16: error: expected type 'tmp.A', found 'tmp.B'21// :8:16: error: expected type 'tmp.A', found 'tmp.B'
22// :10:12: note: struct declared here
23// :4:12: note: struct declared here
24// :7:11: note: function return type declared here
test/cases/compile_errors/invalid_address_space_coercion.zig+2
...@@ -11,3 +11,5 @@ pub fn main() void {...@@ -11,3 +11,5 @@ pub fn main() void {
11// target=x86_64-linux,x86_64-macos11// target=x86_64-linux,x86_64-macos
12//12//
13// :2:12: error: expected type '*i32', found '*addrspace(.gs) i32'13// :2:12: error: expected type '*i32', found '*addrspace(.gs) i32'
14// :2:12: note: address space 'gs' cannot cast into address space 'generic'
15// :1:34: note: function return type declared here
test/cases/compile_errors/invalid_cast_from_integral_type_to_enum.zig+1
...@@ -15,3 +15,4 @@ fn foo(x: usize) void {...@@ -15,3 +15,4 @@ fn foo(x: usize) void {
15// target=native15// target=native
16//16//
17// :9:10: error: expected type 'usize', found 'tmp.E'17// :9:10: error: expected type 'usize', found 'tmp.E'
18// :1:11: note: enum declared here
test/cases/compile_errors/invalid_pointer_keeps_address_space_when_taking_address_of_dereference.zig+2
...@@ -11,3 +11,5 @@ pub fn main() void {...@@ -11,3 +11,5 @@ pub fn main() void {
11// target=x86_64-linux,x86_64-macos11// target=x86_64-linux,x86_64-macos
12//12//
13// :2:12: error: expected type '*i32', found '*addrspace(.gs) i32'13// :2:12: error: expected type '*i32', found '*addrspace(.gs) i32'
14// :2:12: note: address space 'gs' cannot cast into address space 'generic'
15// :1:34: note: function return type declared here
test/cases/compile_errors/issue_5618_coercion_of_optional_anyopaque_to_anyopaque_must_fail.zig created+14
...@@ -0,0 +1,14 @@
1export fn foo() void {
2 var u: ?*anyopaque = null;
3 var v: *anyopaque = undefined;
4 v = u;
5}
6
7// error
8// backend=stage2
9// target=native
10//
11// :4:9: error: expected type '*anyopaque', found '?*anyopaque'
12// :4:9: note: cannot convert optional to payload type
13// :4:9: note: consider using `.?`, `orelse`, or `if`
14// :4:9: note: '?*anyopaque' could have null values which are illegal in type '*anyopaque'
test/cases/compile_errors/not_an_enum_type.zig+1
...@@ -17,3 +17,4 @@ const ExpectedVarDeclOrFn = struct {};...@@ -17,3 +17,4 @@ const ExpectedVarDeclOrFn = struct {};
17// target=native17// target=native
18//18//
19// :4:9: error: expected type '@typeInfo(tmp.Error).Union.tag_type.?', found 'type'19// :4:9: error: expected type '@typeInfo(tmp.Error).Union.tag_type.?', found 'type'
20// :8:1: note: enum declared here
test/cases/compile_errors/passing_a_not-aligned-enough_pointer_to_cmpxchg.zig+1
...@@ -10,3 +10,4 @@ export fn entry() bool {...@@ -10,3 +10,4 @@ export fn entry() bool {
10// target=native10// target=native
11//11//
12// :4:31: error: expected type '*i32', found '*align(1) i32'12// :4:31: error: expected type '*i32', found '*align(1) i32'
13// :4:31: note: pointer alignment '1' cannot cast into pointer alignment '4'
test/cases/compile_errors/pointer_with_different_address_spaces.zig+2
...@@ -11,3 +11,5 @@ export fn entry2() void {...@@ -11,3 +11,5 @@ export fn entry2() void {
11// target=x86_64-linux,x86_64-macos11// target=x86_64-linux,x86_64-macos
12//12//
13// :2:12: error: expected type '*addrspace(.fs) i32', found '*addrspace(.gs) i32'13// :2:12: error: expected type '*addrspace(.fs) i32', found '*addrspace(.gs) i32'
14// :2:12: note: address space 'gs' cannot cast into address space 'fs'
15// :1:34: note: function return type declared here
test/cases/compile_errors/pointers_with_different_address_spaces.zig+2
...@@ -11,3 +11,5 @@ pub fn main() void {...@@ -11,3 +11,5 @@ pub fn main() void {
11// target=x86_64-linux,x86_64-macos11// target=x86_64-linux,x86_64-macos
12//12//
13// :2:13: error: expected type '*i32', found '*addrspace(.gs) i32'13// :2:13: error: expected type '*i32', found '*addrspace(.gs) i32'
14// :2:13: note: address space 'gs' cannot cast into address space 'generic'
15// :1:35: note: function return type declared here
test/cases/compile_errors/regression_test_2980_base_type_u32_is_not_type_checked_properly_when_assigning_a_value_within_a_struct.zig created+23
...@@ -0,0 +1,23 @@
1const Foo = struct {
2 ptr: ?*usize,
3 uval: u32,
4};
5fn get_uval(x: u32) !u32 {
6 _ = x;
7 return error.NotFound;
8}
9export fn entry() void {
10 const afoo = Foo{
11 .ptr = null,
12 .uval = get_uval(42),
13 };
14 _ = afoo;
15}
16
17// error
18// backend=stage2
19// target=native
20//
21// :12:25: error: expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(tmp.get_uval)).Fn.return_type.?).ErrorUnion.error_set!u32'
22// :12:25: note: cannot convert error union to payload type
23// :12:25: note: consider using `try`, `catch`, or `if`
test/cases/compile_errors/result_location_incompatibility_mismatching_handle_is_ptr.zig created+20
...@@ -0,0 +1,20 @@
1export fn entry() void {
2 var damn = Container{
3 .not_optional = getOptional(),
4 };
5 _ = damn;
6}
7pub fn getOptional() ?i32 {
8 return 0;
9}
10pub const Container = struct {
11 not_optional: i32,
12};
13
14// error
15// backend=stage2
16// target=native
17//
18// :3:36: error: expected type 'i32', found '?i32'
19// :3:36: note: cannot convert optional to payload type
20// :3:36: note: consider using `.?`, `orelse`, or `if`
test/cases/compile_errors/result_location_incompatibility_mismatching_handle_is_ptr_generic_call.zig created+20
...@@ -0,0 +1,20 @@
1export fn entry() void {
2 var damn = Container{
3 .not_optional = getOptional(i32),
4 };
5 _ = damn;
6}
7pub fn getOptional(comptime T: type) ?T {
8 return 0;
9}
10pub const Container = struct {
11 not_optional: i32,
12};
13
14// error
15// backend=stage2
16// target=native
17//
18// :3:36: error: expected type 'i32', found '?i32'
19// :3:36: note: cannot convert optional to payload type
20// :3:36: note: consider using `.?`, `orelse`, or `if`
test/cases/compile_errors/shifting_RHS_is_log2_of_LHS_int_bit_width.zig+1
...@@ -7,3 +7,4 @@ export fn entry(x: u8, y: u8) u8 {...@@ -7,3 +7,4 @@ export fn entry(x: u8, y: u8) u8 {
7// target=native7// target=native
8//8//
9// :2:17: error: expected type 'u3', found 'u8'9// :2:17: error: expected type 'u3', found 'u8'
10// :2:17: note: unsigned 3-bit int cannot represent all possible unsigned 8-bit values
test/cases/compile_errors/slice_sentinel_mismatch-2.zig created+13
...@@ -0,0 +1,13 @@
1fn foo() [:0]u8 {
2 var x: []u8 = undefined;
3 return x;
4}
5comptime { _ = foo; }
6
7// error
8// backend=stage2
9// target=native
10//
11// :3:12: error: expected type '[:0]u8', found '[]u8'
12// :3:12: note: destination pointer requires '0' sentinel
13// :1:10: note: function return type declared here
test/cases/compile_errors/stage1/obj/assigning_to_struct_or_union_fields_that_are_not_optionals_with_a_function_that_returns_an_optional.zig deleted-21
...@@ -1,21 +0,0 @@
1fn maybe(is: bool) ?u8 {
2 if (is) return @as(u8, 10) else return null;
3}
4const U = union {
5 Ye: u8,
6};
7const S = struct {
8 num: u8,
9};
10export fn entry() void {
11 var u = U{ .Ye = maybe(false) };
12 var s = S{ .num = maybe(false) };
13 _ = u;
14 _ = s;
15}
16
17// error
18// backend=stage1
19// target=native
20//
21// tmp.zig:11:27: error: cannot convert optional to payload type. consider using `.?`, `orelse`, or `if`. expected type 'u8', found '?u8'
test/cases/compile_errors/stage1/obj/attempted_implicit_cast_from_const_T_to_array_len_1_T.zig deleted-14
...@@ -1,14 +0,0 @@
1export fn entry(byte: u8) void {
2 const w: i32 = 1234;
3 var x: *const i32 = &w;
4 var y: *[1]i32 = x;
5 y[0] += 1;
6 _ = byte;
7}
8
9// error
10// backend=stage1
11// target=native
12//
13// tmp.zig:4:22: error: expected type '*[1]i32', found '*const i32'
14// tmp.zig:4:22: note: cast discards const qualifier
test/cases/compile_errors/stage1/obj/cast_error_union_of_global_error_set_to_error_union_of_smaller_error_set.zig deleted-16
...@@ -1,16 +0,0 @@
1const SmallErrorSet = error{A};
2export fn entry() void {
3 var x: SmallErrorSet!i32 = foo();
4 _ = x;
5}
6fn foo() anyerror!i32 {
7 return error.B;
8}
9
10// error
11// backend=stage1
12// target=native
13//
14// tmp.zig:3:35: error: expected type 'SmallErrorSet!i32', found 'anyerror!i32'
15// tmp.zig:3:35: note: error set 'anyerror' cannot cast into error set 'SmallErrorSet'
16// tmp.zig:3:35: note: cannot cast global error set into smaller set
test/cases/compile_errors/stage1/obj/cast_global_error_set_to_error_set.zig deleted-15
...@@ -1,15 +0,0 @@
1const SmallErrorSet = error{A};
2export fn entry() void {
3 var x: SmallErrorSet = foo();
4 _ = x;
5}
6fn foo() anyerror {
7 return error.B;
8}
9
10// error
11// backend=stage1
12// target=native
13//
14// tmp.zig:3:31: error: expected type 'SmallErrorSet', found 'anyerror'
15// tmp.zig:3:31: note: cannot cast global error set into smaller set
test/cases/compile_errors/stage1/obj/error_note_for_function_parameter_incompatibility.zig deleted-12
...@@ -1,12 +0,0 @@
1fn do_the_thing(func: fn (arg: i32) void) void { _ = func; }
2fn bar(arg: bool) void { _ = arg; }
3export fn entry() void {
4 do_the_thing(bar);
5}
6
7// error
8// backend=stage1
9// target=native
10//
11// tmp.zig:4:18: error: expected type 'fn(i32) void', found 'fn(bool) void
12// tmp.zig:4:18: note: parameter 0: 'bool' cannot cast into 'i32'
test/cases/compile_errors/stage1/obj/implicit_cast_of_error_set_not_a_subset.zig deleted-16
...@@ -1,16 +0,0 @@
1const Set1 = error{A, B};
2const Set2 = error{A, C};
3export fn entry() void {
4 foo(Set1.B);
5}
6fn foo(set1: Set1) void {
7 var x: Set2 = set1;
8 _ = x;
9}
10
11// error
12// backend=stage1
13// target=native
14//
15// tmp.zig:7:19: error: expected type 'Set2', found 'Set1'
16// tmp.zig:1:23: note: 'error.B' not a member of destination error set
test/cases/compile_errors/stage1/obj/implicit_casting_C_pointers_which_would_mess_up_null_semantics.zig deleted-26
...@@ -1,26 +0,0 @@
1export fn entry() void {
2 var slice: []const u8 = "aoeu";
3 const opt_many_ptr: [*]const u8 = slice.ptr;
4 var ptr_opt_many_ptr = &opt_many_ptr;
5 var c_ptr: [*c]const [*c]const u8 = ptr_opt_many_ptr;
6 ptr_opt_many_ptr = c_ptr;
7}
8export fn entry2() void {
9 var buf: [4]u8 = "aoeu".*;
10 var slice: []u8 = &buf;
11 var opt_many_ptr: [*]u8 = slice.ptr;
12 var ptr_opt_many_ptr = &opt_many_ptr;
13 var c_ptr: [*c][*c]const u8 = ptr_opt_many_ptr;
14 _ = c_ptr;
15}
16
17// error
18// backend=stage1
19// target=native
20//
21// tmp.zig:6:24: error: expected type '*const [*]const u8', found '[*c]const [*c]const u8'
22// tmp.zig:6:24: note: pointer type child '[*c]const u8' cannot cast into pointer type child '[*]const u8'
23// tmp.zig:6:24: note: '[*c]const u8' could have null values which are illegal in type '[*]const u8'
24// tmp.zig:13:35: error: expected type '[*c][*c]const u8', found '*[*]u8'
25// tmp.zig:13:35: note: pointer type child '[*]u8' cannot cast into pointer type child '[*c]const u8'
26// tmp.zig:13:35: note: mutable '[*c]const u8' allows illegal null values stored to type '[*]u8'
test/cases/compile_errors/stage1/obj/incompatible_sentinels.zig deleted-29
...@@ -1,29 +0,0 @@
1// Note: One of the error messages here is backwards. It would be nice to fix, but that's not
2// going to stop me from merging this branch which fixes a bunch of other stuff.
3export fn entry1(ptr: [*:255]u8) [*:0]u8 {
4 return ptr;
5}
6export fn entry2(ptr: [*]u8) [*:0]u8 {
7 return ptr;
8}
9export fn entry3() void {
10 var array: [2:0]u8 = [_:255]u8{ 1, 2 };
11 _ = array;
12}
13export fn entry4() void {
14 var array: [2:0]u8 = [_]u8{ 1, 2 };
15 _ = array;
16}
17
18// error
19// backend=stage1
20// target=native
21//
22// tmp.zig:4:12: error: expected type '[*:0]u8', found '[*:255]u8'
23// tmp.zig:4:12: note: destination pointer requires a terminating '0' sentinel, but source pointer has a terminating '255' sentinel
24// tmp.zig:7:12: error: expected type '[*:0]u8', found '[*]u8'
25// tmp.zig:7:12: note: destination pointer requires a terminating '0' sentinel
26// tmp.zig:10:35: error: expected type '[2:255]u8', found '[2:0]u8'
27// tmp.zig:10:35: note: destination array requires a terminating '255' sentinel, but source array has a terminating '0' sentinel
28// tmp.zig:14:31: error: expected type '[2:0]u8', found '[2]u8'
29// tmp.zig:14:31: note: destination array requires a terminating '0' sentinel
test/cases/compile_errors/stage1/obj/issue_5618_coercion_of_optional_anyopaque_to_anyopaque_must_fail.zig deleted-11
...@@ -1,11 +0,0 @@
1export fn foo() void {
2 var u: ?*anyopaque = null;
3 var v: *anyopaque = undefined;
4 v = u;
5}
6
7// error
8// backend=stage1
9// target=native
10//
11// tmp.zig:4:9: error: cannot convert optional to payload type. consider using `.?`, `orelse`, or `if`. expected type '*anyopaque', found '?*anyopaque'
test/cases/compile_errors/stage1/obj/regression_test_2980_base_type_u32_is_not_type_checked_properly_when_assigning_a_value_within_a_struct.zig deleted-21
...@@ -1,21 +0,0 @@
1const Foo = struct {
2 ptr: ?*usize,
3 uval: u32,
4};
5fn get_uval(x: u32) !u32 {
6 _ = x;
7 return error.NotFound;
8}
9export fn entry() void {
10 const afoo = Foo{
11 .ptr = null,
12 .uval = get_uval(42),
13 };
14 _ = afoo;
15}
16
17// error
18// backend=stage1
19// target=native
20//
21// tmp.zig:12:25: error: cannot convert error union to payload type. consider using `try`, `catch`, or `if`. expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(get_uval)).Fn.return_type.?).ErrorUnion.error_set!u32'
test/cases/compile_errors/stage1/obj/result_location_incompatibility_mismatching_handle_is_ptr.zig deleted-18
...@@ -1,18 +0,0 @@
1export fn entry() void {
2 var damn = Container{
3 .not_optional = getOptional(),
4 };
5 _ = damn;
6}
7pub fn getOptional() ?i32 {
8 return 0;
9}
10pub const Container = struct {
11 not_optional: i32,
12};
13
14// error
15// backend=stage1
16// target=native
17//
18// tmp.zig:3:36: error: cannot convert optional to payload type. consider using `.?`, `orelse`, or `if`. expected type 'i32', found '?i32'
test/cases/compile_errors/stage1/obj/result_location_incompatibility_mismatching_handle_is_ptr_generic_call.zig deleted-18
...@@ -1,18 +0,0 @@
1export fn entry() void {
2 var damn = Container{
3 .not_optional = getOptional(i32),
4 };
5 _ = damn;
6}
7pub fn getOptional(comptime T: type) ?T {
8 return 0;
9}
10pub const Container = struct {
11 not_optional: i32,
12};
13
14// error
15// backend=stage1
16// target=native
17//
18// tmp.zig:3:36: error: cannot convert optional to payload type. consider using `.?`, `orelse`, or `if`. expected type 'i32', found '?i32'
test/cases/compile_errors/stage1/obj/slice_sentinel_mismatch-2.zig deleted-12
...@@ -1,12 +0,0 @@
1fn foo() [:0]u8 {
2 var x: []u8 = undefined;
3 return x;
4}
5comptime { _ = foo; }
6
7// error
8// backend=stage1
9// target=native
10//
11// tmp.zig:3:12: error: expected type '[:0]u8', found '[]u8'
12// tmp.zig:3:12: note: destination pointer requires a terminating '0' sentinel
test/cases/compile_errors/stage1/obj/type_checking_function_pointers.zig deleted-13
...@@ -1,13 +0,0 @@
1fn a(b: fn (*const u8) void) void {
2 b('a');
3}
4fn c(d: u8) void {_ = d;}
5export fn entry() void {
6 a(c);
7}
8
9// error
10// backend=stage1
11// target=native
12//
13// tmp.zig:6:7: error: expected type 'fn(*const u8) void', found 'fn(u8) void'
test/cases/compile_errors/stage1/test/cast_between_optional_T_where_T_is_not_a_pointer.zig deleted-15
...@@ -1,15 +0,0 @@
1pub const fnty1 = ?fn (i8) void;
2pub const fnty2 = ?fn (u64) void;
3export fn entry() void {
4 var a: fnty1 = undefined;
5 var b: fnty2 = undefined;
6 a = b;
7}
8
9// error
10// backend=stage1
11// target=native
12// is_test=1
13//
14// tmp.zig:6:9: error: expected type '?fn(i8) void', found '?fn(u64) void'
15// tmp.zig:6:9: note: optional type child 'fn(u64) void' cannot cast into optional type child 'fn(i8) void'
test/cases/compile_errors/stage1/test/helpful_return_type_error_message.zig+12-10
...@@ -16,15 +16,17 @@ export fn quux() u32 {...@@ -16,15 +16,17 @@ export fn quux() u32 {
16}16}
1717
18// error18// error
19// backend=stage119// backend=stage2
20// target=native20// target=native
21// is_test=1
22//21//
23// tmp.zig:2:17: error: expected type 'u32', found 'error{Ohno}'22// :2:18: error: expected type 'u32', found 'error{Ohno}'
24// tmp.zig:1:17: note: function cannot return an error23// :1:17: note: function cannot return an error
25// tmp.zig:8:5: error: expected type 'void', found '@typeInfo(@typeInfo(@TypeOf(bar)).Fn.return_type.?).ErrorUnion.error_set'24// :8:5: error: expected type 'void', found '@typeInfo(@typeInfo(@TypeOf(tmp.bar)).Fn.return_type.?).ErrorUnion.error_set'
26// tmp.zig:7:17: note: function cannot return an error25// :7:17: note: function cannot return an error
27// tmp.zig:11:15: error: cannot convert error union to payload type. consider using `try`, `catch`, or `if`. expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(bar)).Fn.return_type.?).ErrorUnion.error_set!u32'26// :11:15: error: expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(tmp.bar)).Fn.return_type.?).ErrorUnion.error_set!u32'
28// tmp.zig:10:17: note: function cannot return an error27// :10:17: note: function cannot return an error
29// tmp.zig:15:14: error: cannot convert error union to payload type. consider using `try`, `catch`, or `if`. expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(bar)).Fn.return_type.?).ErrorUnion.error_set!u32'28// :11:15: note: cannot convert error union to payload type
30// tmp.zig:14:5: note: cannot store an error in type 'u32'29// :11:15: note: consider using `try`, `catch`, or `if`
30// :15:14: error: expected type 'u32', found '@typeInfo(@typeInfo(@TypeOf(tmp.bar)).Fn.return_type.?).ErrorUnion.error_set!u32'
31// :15:14: note: cannot convert error union to payload type
32// :15:14: note: consider using `try`, `catch`, or `if`
test/cases/compile_errors/try_in_function_with_non_error_return_type.zig+1
...@@ -8,3 +8,4 @@ fn something() anyerror!void { }...@@ -8,3 +8,4 @@ fn something() anyerror!void { }
8// target=native8// target=native
9//9//
10// :2:5: error: expected type 'void', found 'anyerror'10// :2:5: error: expected type 'void', found 'anyerror'
11// :1:15: note: function cannot return an error
test/cases/compile_errors/type_checking_function_pointers.zig created+15
...@@ -0,0 +1,15 @@
1fn a(b: *const fn (*const u8) void) void {
2 _ = b;
3}
4fn c(d: u8) void {_ = d;}
5export fn entry() void {
6 a(c);
7}
8
9// error
10// backend=stage2
11// target=native
12//
13// :6:6: error: expected type '*const fn(*const u8) void', found '*const fn(u8) void'
14// :6:6: note: pointer type child 'fn(u8) void' cannot cast into pointer type child 'fn(*const u8) void'
15// :6:6: note: parameter 0 'u8' cannot cast into '*const u8'
test/cases/compile_errors/type_mismatch_in_C_prototype_with_varargs.zig+3-1
...@@ -10,4 +10,6 @@ export fn main() void {...@@ -10,4 +10,6 @@ export fn main() void {
10// backend=stage210// backend=stage2
11// target=native11// target=native
12//12//
13// :5:22: error: expected type 'fn([*c]u8, ...) callconv(.C) void', found 'fn([*:0]u8, ...) callconv(.C) void'13// :5:22: error: expected type '?fn([*c]u8, ...) callconv(.C) void', found 'fn([*:0]u8, ...) callconv(.C) void'
14// :5:22: note: parameter 0 '[*:0]u8' cannot cast into '[*c]u8'
15// :5:22: note: '[*c]u8' could have null values which are illegal in type '[*:0]u8'
test/cases/compile_errors/unreachable_with_return.zig+2-1
...@@ -5,4 +5,5 @@ export fn entry() void { a(); }...@@ -5,4 +5,5 @@ export fn entry() void { a(); }
5// backend=stage25// backend=stage2
6// target=native6// target=native
7//7//
8// :1:18: error: expected type 'noreturn', found 'void'8// :1:18: error: function declared 'noreturn' returns
9// :1:8: note: 'noreturn' declared here
test/cases/compile_errors/variable_has_wrong_type.zig+1
...@@ -8,3 +8,4 @@ export fn f() i32 {...@@ -8,3 +8,4 @@ export fn f() i32 {
8// target=native8// target=native
9//9//
10// :3:12: error: expected type 'i32', found '*const [1:0]u8'10// :3:12: error: expected type 'i32', found '*const [1:0]u8'
11// :1:15: note: function return type declared here
test/cases/compile_errors/wrong_type_for_reify_type.zig+1
...@@ -7,3 +7,4 @@ export fn entry() void {...@@ -7,3 +7,4 @@ export fn entry() void {
7// target=native7// target=native
8//8//
9// :2:15: error: expected type 'builtin.Type', found 'comptime_int'9// :2:15: error: expected type 'builtin.Type', found 'comptime_int'
10// :?:?: note: union declared here
test/cases/x86_64-linux/hello_world_with_updates.1.zig+2-1
...@@ -2,4 +2,5 @@ pub export fn _start() noreturn {}...@@ -2,4 +2,5 @@ pub export fn _start() noreturn {}
22
3// error3// error
4//4//
5// :1:34: error: expected type 'noreturn', found 'void'5// :1:34: error: function declared 'noreturn' returns
6// :1:24: note: 'noreturn' declared here
test/cases/x86_64-macos/hello_world_with_updates.1.zig+2-1
...@@ -2,4 +2,5 @@ pub export fn main() noreturn {}...@@ -2,4 +2,5 @@ pub export fn main() noreturn {}
22
3// error3// error
4//4//
5// :1:32: error: expected type 'noreturn', found 'void'5// :1:32: error: function declared 'noreturn' returns
6// :1:22: note: 'noreturn' declared here