authorgravatar for mlugg@mlugg.co.ukMatthew Lugg <mlugg@mlugg.co.uk> 2025-02-06 22:19:25+00:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2025-02-06 22:19:25+00:00
log43e52ec5c5a2267791cb2aaaf37f3f84dbe29d25
treef161e86b9ae7f9c2b764345782db302373eee908
parentb0ed602d5d9358128471588f00a073f2545809fa
parent5d935e1137ade5450e504ce9bc6bbf32301b0dfd
signaturebadge-check Signed by PGP key B5690EEEBB952194

Merge pull request #22777 from mlugg/some-bugs

Fix a bunch of frontend bugs

19 files changed, 395 insertions(+), 74 deletions(-)

lib/std/zig/AstGen.zig+5-1
...@@ -920,7 +920,10 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE...@@ -920,7 +920,10 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE
920 const cursor = maybeAdvanceSourceCursorToMainToken(gz, node);920 const cursor = maybeAdvanceSourceCursorToMainToken(gz, node);
921 const start = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .usize_type } }, full.ast.start);921 const start = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .usize_type } }, full.ast.start);
922 const end = if (full.ast.end != 0) try expr(gz, scope, .{ .rl = .{ .coerced_ty = .usize_type } }, full.ast.end) else .none;922 const end = if (full.ast.end != 0) try expr(gz, scope, .{ .rl = .{ .coerced_ty = .usize_type } }, full.ast.end) else .none;
923 const sentinel = if (full.ast.sentinel != 0) try expr(gz, scope, .{ .rl = .none }, full.ast.sentinel) else .none;923 const sentinel = if (full.ast.sentinel != 0) s: {
924 const sentinel_ty = try gz.addUnNode(.slice_sentinel_ty, lhs, node);
925 break :s try expr(gz, scope, .{ .rl = .{ .coerced_ty = sentinel_ty } }, full.ast.sentinel);
926 } else .none;
924 try emitDbgStmt(gz, cursor);927 try emitDbgStmt(gz, cursor);
925 if (sentinel != .none) {928 if (sentinel != .none) {
926 const result = try gz.addPlNode(.slice_sentinel, node, Zir.Inst.SliceSentinel{929 const result = try gz.addPlNode(.slice_sentinel, node, Zir.Inst.SliceSentinel{
...@@ -2855,6 +2858,7 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As...@@ -2855,6 +2858,7 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As
2855 .slice_end,2858 .slice_end,
2856 .slice_sentinel,2859 .slice_sentinel,
2857 .slice_length,2860 .slice_length,
2861 .slice_sentinel_ty,
2858 .import,2862 .import,
2859 .switch_block,2863 .switch_block,
2860 .switch_block_ref,2864 .switch_block_ref,
lib/std/zig/Zir.zig+8
...@@ -599,6 +599,10 @@ pub const Inst = struct {...@@ -599,6 +599,10 @@ pub const Inst = struct {
599 /// Returns a pointer to the subslice.599 /// Returns a pointer to the subslice.
600 /// Uses the `pl_node` field. AST node is the slice syntax. Payload is `SliceLength`.600 /// Uses the `pl_node` field. AST node is the slice syntax. Payload is `SliceLength`.
601 slice_length,601 slice_length,
602 /// Given a value which is a pointer to the LHS of a slice operation, return the sentinel
603 /// type, used as the result type of the slice sentinel (i.e. `s` in `lhs[a..b :s]`).
604 /// Uses the `un_node` field. AST node is the slice syntax. Operand is `lhs`.
605 slice_sentinel_ty,
602 /// Same as `store` except provides a source location.606 /// Same as `store` except provides a source location.
603 /// Uses the `pl_node` union field. Payload is `Bin`.607 /// Uses the `pl_node` union field. Payload is `Bin`.
604 store_node,608 store_node,
...@@ -1185,6 +1189,7 @@ pub const Inst = struct {...@@ -1185,6 +1189,7 @@ pub const Inst = struct {
1185 .slice_end,1189 .slice_end,
1186 .slice_sentinel,1190 .slice_sentinel,
1187 .slice_length,1191 .slice_length,
1192 .slice_sentinel_ty,
1188 .import,1193 .import,
1189 .typeof_log2_int_type,1194 .typeof_log2_int_type,
1190 .resolve_inferred_alloc,1195 .resolve_inferred_alloc,
...@@ -1472,6 +1477,7 @@ pub const Inst = struct {...@@ -1472,6 +1477,7 @@ pub const Inst = struct {
1472 .slice_end,1477 .slice_end,
1473 .slice_sentinel,1478 .slice_sentinel,
1474 .slice_length,1479 .slice_length,
1480 .slice_sentinel_ty,
1475 .import,1481 .import,
1476 .typeof_log2_int_type,1482 .typeof_log2_int_type,
1477 .switch_block,1483 .switch_block,
...@@ -1702,6 +1708,7 @@ pub const Inst = struct {...@@ -1702,6 +1708,7 @@ pub const Inst = struct {
1702 .slice_end = .pl_node,1708 .slice_end = .pl_node,
1703 .slice_sentinel = .pl_node,1709 .slice_sentinel = .pl_node,
1704 .slice_length = .pl_node,1710 .slice_length = .pl_node,
1711 .slice_sentinel_ty = .un_node,
1705 .store_node = .pl_node,1712 .store_node = .pl_node,
1706 .store_to_inferred_ptr = .pl_node,1713 .store_to_inferred_ptr = .pl_node,
1707 .str = .str,1714 .str = .str,
...@@ -4162,6 +4169,7 @@ fn findTrackableInner(...@@ -4162,6 +4169,7 @@ fn findTrackableInner(
4162 .slice_end,4169 .slice_end,
4163 .slice_sentinel,4170 .slice_sentinel,
4164 .slice_length,4171 .slice_length,
4172 .slice_sentinel_ty,
4165 .store_node,4173 .store_node,
4166 .store_to_inferred_ptr,4174 .store_to_inferred_ptr,
4167 .str,4175 .str,
src/Compilation.zig+6-4
...@@ -2196,6 +2196,8 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {...@@ -2196,6 +2196,8 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
21962196
2197 zcu.compile_log_text.shrinkAndFree(gpa, 0);2197 zcu.compile_log_text.shrinkAndFree(gpa, 0);
21982198
2199 zcu.skip_analysis_errors = false;
2200
2199 // Make sure std.zig is inside the import_table. We unconditionally need2201 // Make sure std.zig is inside the import_table. We unconditionally need
2200 // it for start.zig.2202 // it for start.zig.
2201 const std_mod = zcu.std_mod;2203 const std_mod = zcu.std_mod;
...@@ -3208,7 +3210,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {...@@ -3208,7 +3210,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {
3208 });3210 });
3209 }3211 }
32103212
3211 if (comp.zcu) |zcu| {3213 if (comp.zcu) |zcu| zcu_errors: {
3212 for (zcu.failed_files.keys(), zcu.failed_files.values()) |file, error_msg| {3214 for (zcu.failed_files.keys(), zcu.failed_files.values()) |file, error_msg| {
3213 if (error_msg) |msg| {3215 if (error_msg) |msg| {
3214 try addModuleErrorMsg(zcu, &bundle, msg.*);3216 try addModuleErrorMsg(zcu, &bundle, msg.*);
...@@ -3225,6 +3227,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {...@@ -3225,6 +3227,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {
3225 }3227 }
3226 }3228 }
3227 }3229 }
3230 if (zcu.skip_analysis_errors) break :zcu_errors;
3228 var sorted_failed_analysis: std.AutoArrayHashMapUnmanaged(InternPool.AnalUnit, *Zcu.ErrorMsg).DataList.Slice = s: {3231 var sorted_failed_analysis: std.AutoArrayHashMapUnmanaged(InternPool.AnalUnit, *Zcu.ErrorMsg).DataList.Slice = s: {
3229 const SortOrder = struct {3232 const SortOrder = struct {
3230 zcu: *Zcu,3233 zcu: *Zcu,
...@@ -3360,7 +3363,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {...@@ -3360,7 +3363,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {
3360 try comp.link_diags.addMessagesToBundle(&bundle, comp.bin_file);3363 try comp.link_diags.addMessagesToBundle(&bundle, comp.bin_file);
33613364
3362 if (comp.zcu) |zcu| {3365 if (comp.zcu) |zcu| {
3363 if (bundle.root_list.items.len == 0 and zcu.compile_log_sources.count() != 0) {3366 if (!zcu.skip_analysis_errors and bundle.root_list.items.len == 0 and zcu.compile_log_sources.count() != 0) {
3364 const values = zcu.compile_log_sources.values();3367 const values = zcu.compile_log_sources.values();
3365 // First one will be the error; subsequent ones will be notes.3368 // First one will be the error; subsequent ones will be notes.
3366 const src_loc = values[0].src();3369 const src_loc = values[0].src();
...@@ -3861,10 +3864,9 @@ fn performAllTheWorkInner(...@@ -3861,10 +3864,9 @@ fn performAllTheWorkInner(
3861 // We give up right now! No updating of ZIR refs, no nothing. The idea is that this prevents3864 // We give up right now! No updating of ZIR refs, no nothing. The idea is that this prevents
3862 // us from invalidating lots of incremental dependencies due to files with e.g. parse errors.3865 // us from invalidating lots of incremental dependencies due to files with e.g. parse errors.
3863 // However, this means our analysis data is invalid, so we want to omit all analysis errors.3866 // However, this means our analysis data is invalid, so we want to omit all analysis errors.
3864 // To do that, let's just clear the analysis roots!
38653867
3866 assert(zcu.failed_files.count() > 0); // we will get an error3868 assert(zcu.failed_files.count() > 0); // we will get an error
3867 zcu.analysis_roots.clear(); // no analysis happened3869 zcu.skip_analysis_errors = true;
3868 return;3870 return;
3869 }3871 }
38703872
src/InternPool.zig+1-1
...@@ -4011,7 +4011,7 @@ pub const LoadedStructType = struct {...@@ -4011,7 +4011,7 @@ pub const LoadedStructType = struct {
40114011
4012 pub fn haveFieldTypes(s: LoadedStructType, ip: *const InternPool) bool {4012 pub fn haveFieldTypes(s: LoadedStructType, ip: *const InternPool) bool {
4013 const types = s.field_types.get(ip);4013 const types = s.field_types.get(ip);
4014 return types.len == 0 or types[0] != .none;4014 return types.len == 0 or types[types.len - 1] != .none;
4015 }4015 }
40164016
4017 pub fn haveFieldInits(s: LoadedStructType, ip: *const InternPool) bool {4017 pub fn haveFieldInits(s: LoadedStructType, ip: *const InternPool) bool {
src/Sema.zig+171-65
...@@ -504,7 +504,17 @@ pub const Block = struct {...@@ -504,7 +504,17 @@ pub const Block = struct {
504 };504 };
505 }505 }
506506
507 pub fn wantSafety(block: *const Block) bool {507 fn wantSafeTypes(block: *const Block) bool {
508 return block.want_safety orelse switch (block.sema.pt.zcu.optimizeMode()) {
509 .Debug => true,
510 .ReleaseSafe => true,
511 .ReleaseFast => false,
512 .ReleaseSmall => false,
513 };
514 }
515
516 fn wantSafety(block: *const Block) bool {
517 if (block.isComptime()) return false; // runtime safety checks are pointless in comptime blocks
508 return block.want_safety orelse switch (block.sema.pt.zcu.optimizeMode()) {518 return block.want_safety orelse switch (block.sema.pt.zcu.optimizeMode()) {
509 .Debug => true,519 .Debug => true,
510 .ReleaseSafe => true,520 .ReleaseSafe => true,
...@@ -1197,6 +1207,7 @@ fn analyzeBodyInner(...@@ -1197,6 +1207,7 @@ fn analyzeBodyInner(
1197 .slice_sentinel => try sema.zirSliceSentinel(block, inst),1207 .slice_sentinel => try sema.zirSliceSentinel(block, inst),
1198 .slice_start => try sema.zirSliceStart(block, inst),1208 .slice_start => try sema.zirSliceStart(block, inst),
1199 .slice_length => try sema.zirSliceLength(block, inst),1209 .slice_length => try sema.zirSliceLength(block, inst),
1210 .slice_sentinel_ty => try sema.zirSliceSentinelTy(block, inst),
1200 .str => try sema.zirStr(inst),1211 .str => try sema.zirStr(inst),
1201 .switch_block => try sema.zirSwitchBlock(block, inst, false),1212 .switch_block => try sema.zirSwitchBlock(block, inst, false),
1202 .switch_block_ref => try sema.zirSwitchBlock(block, inst, true),1213 .switch_block_ref => try sema.zirSwitchBlock(block, inst, true),
...@@ -3293,7 +3304,7 @@ fn zirUnionDecl(...@@ -3293,7 +3304,7 @@ fn zirUnionDecl(
3293 .tagged3304 .tagged
3294 else if (small.layout != .auto)3305 else if (small.layout != .auto)
3295 .none3306 .none
3296 else switch (block.wantSafety()) {3307 else switch (block.wantSafeTypes()) {
3297 true => .safety,3308 true => .safety,
3298 false => .none,3309 false => .none,
3299 },3310 },
...@@ -9144,6 +9155,7 @@ fn zirErrUnionCode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro...@@ -9144,6 +9155,7 @@ fn zirErrUnionCode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
9144 return sema.analyzeErrUnionCode(block, src, operand);9155 return sema.analyzeErrUnionCode(block, src, operand);
9145}9156}
91469157
9158/// If `operand` is comptime-known, asserts that it is an error value rather than a payload value.
9147fn analyzeErrUnionCode(sema: *Sema, block: *Block, src: LazySrcLoc, operand: Air.Inst.Ref) CompileError!Air.Inst.Ref {9159fn analyzeErrUnionCode(sema: *Sema, block: *Block, src: LazySrcLoc, operand: Air.Inst.Ref) CompileError!Air.Inst.Ref {
9148 const pt = sema.pt;9160 const pt = sema.pt;
9149 const zcu = pt.zcu;9161 const zcu = pt.zcu;
...@@ -10753,6 +10765,46 @@ fn zirSliceLength(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError...@@ -10753,6 +10765,46 @@ fn zirSliceLength(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
10753 return sema.analyzeSlice(block, src, array_ptr, start, len, sentinel, sentinel_src, ptr_src, start_src, end_src, true);10765 return sema.analyzeSlice(block, src, array_ptr, start, len, sentinel, sentinel_src, ptr_src, start_src, end_src, true);
10754}10766}
1075510767
10768fn zirSliceSentinelTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
10769 const tracy = trace(@src());
10770 defer tracy.end();
10771
10772 const pt = sema.pt;
10773 const zcu = pt.zcu;
10774
10775 const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
10776
10777 const src = block.nodeOffset(inst_data.src_node);
10778 const ptr_src = block.src(.{ .node_offset_slice_ptr = inst_data.src_node });
10779 const sentinel_src = block.src(.{ .node_offset_slice_sentinel = inst_data.src_node });
10780
10781 // This is like the logic in `analyzeSlice`; since we've evaluated the LHS as an lvalue, we will
10782 // have a double pointer if it was already a pointer.
10783
10784 const lhs_ptr_ty = sema.typeOf(try sema.resolveInst(inst_data.operand));
10785 const lhs_ty = switch (lhs_ptr_ty.zigTypeTag(zcu)) {
10786 .pointer => lhs_ptr_ty.childType(zcu),
10787 else => return sema.fail(block, ptr_src, "expected pointer, found '{}'", .{lhs_ptr_ty.fmt(pt)}),
10788 };
10789
10790 const sentinel_ty: Type = switch (lhs_ty.zigTypeTag(zcu)) {
10791 .array => lhs_ty.childType(zcu),
10792 .pointer => switch (lhs_ty.ptrSize(zcu)) {
10793 .many, .c, .slice => lhs_ty.childType(zcu),
10794 .one => s: {
10795 const lhs_elem_ty = lhs_ty.childType(zcu);
10796 break :s switch (lhs_elem_ty.zigTypeTag(zcu)) {
10797 .array => lhs_elem_ty.childType(zcu), // array element type
10798 else => return sema.fail(block, sentinel_src, "slice of single-item pointer cannot have sentinel", .{}),
10799 };
10800 },
10801 },
10802 else => return sema.fail(block, src, "slice of non-array type '{}'", .{lhs_ty.fmt(pt)}),
10803 };
10804
10805 return Air.internedToRef(sentinel_ty.toIntern());
10806}
10807
10756/// Holds common data used when analyzing or resolving switch prong bodies,10808/// Holds common data used when analyzing or resolving switch prong bodies,
10757/// including setting up captures.10809/// including setting up captures.
10758const SwitchProngAnalysis = struct {10810const SwitchProngAnalysis = struct {
...@@ -17558,10 +17610,16 @@ fn analyzeCmp(...@@ -17558,10 +17610,16 @@ fn analyzeCmp(
17558 return sema.cmpNumeric(block, src, lhs, rhs, op, lhs_src, rhs_src);17610 return sema.cmpNumeric(block, src, lhs, rhs, op, lhs_src, rhs_src);
17559 }17611 }
17560 if (is_equality_cmp and lhs_ty.zigTypeTag(zcu) == .error_union and rhs_ty.zigTypeTag(zcu) == .error_set) {17612 if (is_equality_cmp and lhs_ty.zigTypeTag(zcu) == .error_union and rhs_ty.zigTypeTag(zcu) == .error_set) {
17613 if (try sema.resolveDefinedValue(block, lhs_src, lhs)) |lhs_val| {
17614 if (lhs_val.errorUnionIsPayload(zcu)) return .bool_false;
17615 }
17561 const casted_lhs = try sema.analyzeErrUnionCode(block, lhs_src, lhs);17616 const casted_lhs = try sema.analyzeErrUnionCode(block, lhs_src, lhs);
17562 return sema.cmpSelf(block, src, casted_lhs, rhs, op, lhs_src, rhs_src);17617 return sema.cmpSelf(block, src, casted_lhs, rhs, op, lhs_src, rhs_src);
17563 }17618 }
17564 if (is_equality_cmp and lhs_ty.zigTypeTag(zcu) == .error_set and rhs_ty.zigTypeTag(zcu) == .error_union) {17619 if (is_equality_cmp and lhs_ty.zigTypeTag(zcu) == .error_set and rhs_ty.zigTypeTag(zcu) == .error_union) {
17620 if (try sema.resolveDefinedValue(block, rhs_src, rhs)) |rhs_val| {
17621 if (rhs_val.errorUnionIsPayload(zcu)) return .bool_false;
17622 }
17565 const casted_rhs = try sema.analyzeErrUnionCode(block, rhs_src, rhs);17623 const casted_rhs = try sema.analyzeErrUnionCode(block, rhs_src, rhs);
17566 return sema.cmpSelf(block, src, lhs, casted_rhs, op, lhs_src, rhs_src);17624 return sema.cmpSelf(block, src, lhs, casted_rhs, op, lhs_src, rhs_src);
17567 }17625 }
...@@ -18087,10 +18145,16 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai...@@ -18087,10 +18145,16 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1808718145
18088 const ret_ty_opt = try pt.intern(.{ .opt = .{18146 const ret_ty_opt = try pt.intern(.{ .opt = .{
18089 .ty = try pt.intern(.{ .opt_type = .type_type }),18147 .ty = try pt.intern(.{ .opt_type = .type_type }),
18090 .val = if (func_ty_info.return_type == .generic_poison_type)18148 .val = opt_val: {
18091 .none18149 const ret_ty: Type = .fromInterned(func_ty_info.return_type);
18092 else18150 if (ret_ty.toIntern() == .generic_poison_type) break :opt_val .none;
18093 func_ty_info.return_type,18151 if (ret_ty.zigTypeTag(zcu) == .error_union) {
18152 if (ret_ty.errorUnionPayload(zcu).toIntern() == .generic_poison_type) {
18153 break :opt_val .none;
18154 }
18155 }
18156 break :opt_val ret_ty.toIntern();
18157 },
18094 } });18158 } });
1809518159
18096 const callconv_ty = try sema.getBuiltinType(src, .CallingConvention);18160 const callconv_ty = try sema.getBuiltinType(src, .CallingConvention);
...@@ -21401,7 +21465,7 @@ fn zirTagName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air...@@ -21401,7 +21465,7 @@ fn zirTagName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
21401 try operand_ty.resolveLayout(pt);21465 try operand_ty.resolveLayout(pt);
21402 const enum_ty = switch (operand_ty.zigTypeTag(zcu)) {21466 const enum_ty = switch (operand_ty.zigTypeTag(zcu)) {
21403 .enum_literal => {21467 .enum_literal => {
21404 const val = try sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, operand, undefined);21468 const val = (try sema.resolveDefinedValue(block, operand_src, operand)).?;
21405 const tag_name = ip.indexToKey(val.toIntern()).enum_literal;21469 const tag_name = ip.indexToKey(val.toIntern()).enum_literal;
21406 return sema.addNullTerminatedStrLit(tag_name);21470 return sema.addNullTerminatedStrLit(tag_name);
21407 },21471 },
...@@ -22171,7 +22235,7 @@ fn reifyUnion(...@@ -22171,7 +22235,7 @@ fn reifyUnion(
22171 .tagged22235 .tagged
22172 else if (layout != .auto)22236 else if (layout != .auto)
22173 .none22237 .none
22174 else switch (block.wantSafety()) {22238 else switch (block.wantSafeTypes()) {
22175 true => .safety,22239 true => .safety,
22176 false => .none,22240 false => .none,
22177 },22241 },
...@@ -23117,11 +23181,12 @@ fn zirErrorCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData...@@ -23117,11 +23181,12 @@ fn zirErrorCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData
23117 const extra = sema.code.extraData(Zir.Inst.BinNode, extended.operand).data;23181 const extra = sema.code.extraData(Zir.Inst.BinNode, extended.operand).data;
23118 const src = block.nodeOffset(extra.node);23182 const src = block.nodeOffset(extra.node);
23119 const operand_src = block.builtinCallArgSrc(extra.node, 0);23183 const operand_src = block.builtinCallArgSrc(extra.node, 0);
23120 const base_dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_opt, "@errorCast");23184 const dest_ty = try sema.resolveDestType(block, src, extra.lhs, .remove_opt, "@errorCast");
23121 const operand = try sema.resolveInst(extra.rhs);23185 const operand = try sema.resolveInst(extra.rhs);
23122 const base_operand_ty = sema.typeOf(operand);23186 const operand_ty = sema.typeOf(operand);
23123 const dest_tag = base_dest_ty.zigTypeTag(zcu);23187
23124 const operand_tag = base_operand_ty.zigTypeTag(zcu);23188 const dest_tag = dest_ty.zigTypeTag(zcu);
23189 const operand_tag = operand_ty.zigTypeTag(zcu);
2312523190
23126 if (dest_tag != .error_set and dest_tag != .error_union) {23191 if (dest_tag != .error_set and dest_tag != .error_union) {
23127 return sema.fail(block, src, "expected error set or error union type, found '{s}'", .{@tagName(dest_tag)});23192 return sema.fail(block, src, "expected error set or error union type, found '{s}'", .{@tagName(dest_tag)});
...@@ -23133,107 +23198,133 @@ fn zirErrorCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData...@@ -23133,107 +23198,133 @@ fn zirErrorCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData
23133 return sema.fail(block, src, "cannot cast an error union type to error set", .{});23198 return sema.fail(block, src, "cannot cast an error union type to error set", .{});
23134 }23199 }
23135 if (dest_tag == .error_union and operand_tag == .error_union and23200 if (dest_tag == .error_union and operand_tag == .error_union and
23136 base_dest_ty.errorUnionPayload(zcu).toIntern() != base_operand_ty.errorUnionPayload(zcu).toIntern())23201 dest_ty.errorUnionPayload(zcu).toIntern() != operand_ty.errorUnionPayload(zcu).toIntern())
23137 {23202 {
23138 return sema.failWithOwnedErrorMsg(block, msg: {23203 return sema.failWithOwnedErrorMsg(block, msg: {
23139 const msg = try sema.errMsg(src, "payload types of error unions must match", .{});23204 const msg = try sema.errMsg(src, "payload types of error unions must match", .{});
23140 errdefer msg.destroy(sema.gpa);23205 errdefer msg.destroy(sema.gpa);
23141 const dest_ty = base_dest_ty.errorUnionPayload(zcu);23206 const dest_payload_ty = dest_ty.errorUnionPayload(zcu);
23142 const operand_ty = base_operand_ty.errorUnionPayload(zcu);23207 const operand_payload_ty = operand_ty.errorUnionPayload(zcu);
23143 try sema.errNote(src, msg, "destination payload is '{}'", .{dest_ty.fmt(pt)});23208 try sema.errNote(src, msg, "destination payload is '{}'", .{dest_payload_ty.fmt(pt)});
23144 try sema.errNote(src, msg, "operand payload is '{}'", .{operand_ty.fmt(pt)});23209 try sema.errNote(src, msg, "operand payload is '{}'", .{operand_payload_ty.fmt(pt)});
23145 try addDeclaredHereNote(sema, msg, dest_ty);23210 try addDeclaredHereNote(sema, msg, dest_ty);
23146 try addDeclaredHereNote(sema, msg, operand_ty);23211 try addDeclaredHereNote(sema, msg, operand_ty);
23147 break :msg msg;23212 break :msg msg;
23148 });23213 });
23149 }23214 }
23150 const dest_ty = if (dest_tag == .error_union) base_dest_ty.errorUnionSet(zcu) else base_dest_ty;23215 const dest_err_ty = switch (dest_tag) {
23151 const operand_ty = if (operand_tag == .error_union) base_operand_ty.errorUnionSet(zcu) else base_operand_ty;23216 .error_union => dest_ty.errorUnionSet(zcu),
2315223217 .error_set => dest_ty,
23153 // operand must be defined since it can be an invalid error value23218 else => unreachable,
23154 const maybe_operand_val = try sema.resolveDefinedValue(block, operand_src, operand);23219 };
23220 const operand_err_ty = switch (operand_tag) {
23221 .error_union => operand_ty.errorUnionSet(zcu),
23222 .error_set => operand_ty,
23223 else => unreachable,
23224 };
2315523225
23156 const disjoint = disjoint: {23226 const disjoint = disjoint: {
23157 // Try avoiding resolving inferred error sets if we can23227 // Try avoiding resolving inferred error sets if we can
23158 if (!dest_ty.isAnyError(zcu) and dest_ty.errorSetIsEmpty(zcu)) break :disjoint true;23228 if (!dest_err_ty.isAnyError(zcu) and dest_err_ty.errorSetIsEmpty(zcu)) break :disjoint true;
23159 if (!operand_ty.isAnyError(zcu) and operand_ty.errorSetIsEmpty(zcu)) break :disjoint true;23229 if (!operand_err_ty.isAnyError(zcu) and operand_err_ty.errorSetIsEmpty(zcu)) break :disjoint true;
23160 if (dest_ty.isAnyError(zcu)) break :disjoint false;23230 if (dest_err_ty.isAnyError(zcu)) break :disjoint false;
23161 if (operand_ty.isAnyError(zcu)) break :disjoint false;23231 if (operand_err_ty.isAnyError(zcu)) break :disjoint false;
23162 const dest_err_names = dest_ty.errorSetNames(zcu);23232 const dest_err_names = dest_err_ty.errorSetNames(zcu);
23163 for (0..dest_err_names.len) |dest_err_index| {23233 for (0..dest_err_names.len) |dest_err_index| {
23164 if (Type.errorSetHasFieldIp(ip, operand_ty.toIntern(), dest_err_names.get(ip)[dest_err_index]))23234 if (Type.errorSetHasFieldIp(ip, operand_err_ty.toIntern(), dest_err_names.get(ip)[dest_err_index]))
23165 break :disjoint false;23235 break :disjoint false;
23166 }23236 }
2316723237
23168 if (!ip.isInferredErrorSetType(dest_ty.toIntern()) and23238 if (!ip.isInferredErrorSetType(dest_err_ty.toIntern()) and
23169 !ip.isInferredErrorSetType(operand_ty.toIntern()))23239 !ip.isInferredErrorSetType(operand_err_ty.toIntern()))
23170 {23240 {
23171 break :disjoint true;23241 break :disjoint true;
23172 }23242 }
2317323243
23174 _ = try sema.resolveInferredErrorSetTy(block, src, dest_ty.toIntern());23244 _ = try sema.resolveInferredErrorSetTy(block, src, dest_err_ty.toIntern());
23175 _ = try sema.resolveInferredErrorSetTy(block, operand_src, operand_ty.toIntern());23245 _ = try sema.resolveInferredErrorSetTy(block, operand_src, operand_err_ty.toIntern());
23176 for (0..dest_err_names.len) |dest_err_index| {23246 for (0..dest_err_names.len) |dest_err_index| {
23177 if (Type.errorSetHasFieldIp(ip, operand_ty.toIntern(), dest_err_names.get(ip)[dest_err_index]))23247 if (Type.errorSetHasFieldIp(ip, operand_err_ty.toIntern(), dest_err_names.get(ip)[dest_err_index]))
23178 break :disjoint false;23248 break :disjoint false;
23179 }23249 }
2318023250
23181 break :disjoint true;23251 break :disjoint true;
23182 };23252 };
23183 if (disjoint and dest_tag != .error_union) {23253 if (disjoint and !(operand_tag == .error_union and dest_tag == .error_union)) {
23184 return sema.fail(block, src, "error sets '{}' and '{}' have no common errors", .{23254 return sema.fail(block, src, "error sets '{}' and '{}' have no common errors", .{
23185 operand_ty.fmt(pt), dest_ty.fmt(pt),23255 operand_err_ty.fmt(pt), dest_err_ty.fmt(pt),
23186 });23256 });
23187 }23257 }
2318823258
23189 if (maybe_operand_val) |val| {23259 // operand must be defined since it can be an invalid error value
23190 if (!dest_ty.isAnyError(zcu)) check: {23260 if (try sema.resolveDefinedValue(block, operand_src, operand)) |operand_val| {
23191 const operand_val = zcu.intern_pool.indexToKey(val.toIntern());23261 const err_name: InternPool.NullTerminatedString = switch (operand_tag) {
23192 var error_name: InternPool.NullTerminatedString = undefined;23262 .error_set => ip.indexToKey(operand_val.toIntern()).err.name,
23193 if (operand_tag == .error_union) {23263 .error_union => switch (ip.indexToKey(operand_val.toIntern()).error_union.val) {
23194 if (operand_val.error_union.val != .err_name) break :check;23264 .err_name => |name| name,
23195 error_name = operand_val.error_union.val.err_name;23265 .payload => |payload_val| {
23196 } else {23266 assert(dest_tag == .error_union); // should be guaranteed from the type checks above
23197 error_name = operand_val.err.name;23267 return sema.coerce(block, dest_ty, Air.internedToRef(payload_val), operand_src);
23198 }23268 },
23199 if (!Type.errorSetHasFieldIp(ip, dest_ty.toIntern(), error_name)) {23269 },
23200 return sema.fail(block, src, "'error.{}' not a member of error set '{}'", .{23270 else => unreachable,
23201 error_name.fmt(ip), dest_ty.fmt(pt),23271 };
23202 });23272
23203 }23273 if (!dest_err_ty.isAnyError(zcu) and !Type.errorSetHasFieldIp(ip, dest_err_ty.toIntern(), err_name)) {
23274 return sema.fail(block, src, "'error.{}' not a member of error set '{}'", .{
23275 err_name.fmt(ip), dest_err_ty.fmt(pt),
23276 });
23204 }23277 }
2320523278
23206 return Air.internedToRef((try pt.getCoerced(val, base_dest_ty)).toIntern());23279 return Air.internedToRef(try pt.intern(switch (dest_tag) {
23280 .error_set => .{ .err = .{
23281 .ty = dest_ty.toIntern(),
23282 .name = err_name,
23283 } },
23284 .error_union => .{ .error_union = .{
23285 .ty = dest_ty.toIntern(),
23286 .val = .{ .err_name = err_name },
23287 } },
23288 else => unreachable,
23289 }));
23207 }23290 }
2320823291
23209 try sema.requireRuntimeBlock(block, src, operand_src);
23210 const err_int_ty = try pt.errorIntType();23292 const err_int_ty = try pt.errorIntType();
23211 if (block.wantSafety() and !dest_ty.isAnyError(zcu) and23293 if (block.wantSafety() and !dest_err_ty.isAnyError(zcu) and
23212 dest_ty.toIntern() != .adhoc_inferred_error_set_type and23294 dest_err_ty.toIntern() != .adhoc_inferred_error_set_type and
23213 zcu.backendSupportsFeature(.error_set_has_value))23295 zcu.backendSupportsFeature(.error_set_has_value))
23214 {23296 {
23215 if (dest_tag == .error_union) {23297 const err_code_inst = switch (operand_tag) {
23216 const err_code = try sema.analyzeErrUnionCode(block, operand_src, operand);23298 .error_set => operand,
23217 const err_int = try block.addBitCast(err_int_ty, err_code);23299 .error_union => try block.addTyOp(.unwrap_errunion_err, operand_err_ty, operand),
23218 const zero_err = try pt.intRef(try pt.errorIntType(), 0);23300 else => unreachable,
23301 };
23302 const err_int_inst = try block.addBitCast(err_int_ty, err_code_inst);
2321923303
23220 const is_zero = try block.addBinOp(.cmp_eq, err_int, zero_err);23304 if (dest_tag == .error_union) {
23305 const zero_err = try pt.intRef(err_int_ty, 0);
23306 const is_zero = try block.addBinOp(.cmp_eq, err_int_inst, zero_err);
23221 if (disjoint) {23307 if (disjoint) {
23222 // Error must be zero.23308 // Error must be zero.
23223 try sema.addSafetyCheck(block, src, is_zero, .invalid_error_code);23309 try sema.addSafetyCheck(block, src, is_zero, .invalid_error_code);
23224 } else {23310 } else {
23225 // Error must be in destination set or zero.23311 // Error must be in destination set or zero.
23226 const has_value = try block.addTyOp(.error_set_has_value, dest_ty, err_code);23312 const has_value = try block.addTyOp(.error_set_has_value, dest_err_ty, err_int_inst);
23227 const ok = try block.addBinOp(.bool_or, has_value, is_zero);23313 const ok = try block.addBinOp(.bool_or, has_value, is_zero);
23228 try sema.addSafetyCheck(block, src, ok, .invalid_error_code);23314 try sema.addSafetyCheck(block, src, ok, .invalid_error_code);
23229 }23315 }
23230 } else {23316 } else {
23231 const err_int_inst = try block.addBitCast(err_int_ty, operand);23317 const ok = try block.addTyOp(.error_set_has_value, dest_err_ty, err_int_inst);
23232 const ok = try block.addTyOp(.error_set_has_value, dest_ty, err_int_inst);
23233 try sema.addSafetyCheck(block, src, ok, .invalid_error_code);23318 try sema.addSafetyCheck(block, src, ok, .invalid_error_code);
23234 }23319 }
23235 }23320 }
23236 return block.addBitCast(base_dest_ty, operand);23321
23322 if (operand_tag == .error_set and dest_tag == .error_union) {
23323 const err_val = try block.addBitCast(dest_err_ty, operand);
23324 return block.addTyOp(.wrap_errunion_err, dest_ty, err_val);
23325 } else {
23326 return block.addBitCast(dest_ty, operand);
23327 }
23237}23328}
2323823329
23239fn zirPtrCastFull(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref {23330fn zirPtrCastFull(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref {
...@@ -28952,6 +29043,7 @@ fn elemValArray(...@@ -28952,6 +29043,7 @@ fn elemValArray(
28952 }29043 }
2895329044
28954 try sema.validateRuntimeElemAccess(block, elem_index_src, elem_ty, array_ty, array_src);29045 try sema.validateRuntimeElemAccess(block, elem_index_src, elem_ty, array_ty, array_src);
29046 try sema.validateRuntimeValue(block, array_src, array);
2895529047
28956 if (oob_safety and block.wantSafety()) {29048 if (oob_safety and block.wantSafety()) {
28957 // Runtime check is only needed if unable to comptime check.29049 // Runtime check is only needed if unable to comptime check.
...@@ -29016,6 +29108,7 @@ fn elemPtrArray(...@@ -29016,6 +29108,7 @@ fn elemPtrArray(
2901629108
29017 if (!init) {29109 if (!init) {
29018 try sema.validateRuntimeElemAccess(block, elem_index_src, array_ty.elemType2(zcu), array_ty, array_ptr_src);29110 try sema.validateRuntimeElemAccess(block, elem_index_src, array_ty.elemType2(zcu), array_ty, array_ptr_src);
29111 try sema.validateRuntimeValue(block, array_ptr_src, array_ptr);
29019 }29112 }
2902029113
29021 // Runtime check is only needed if unable to comptime check.29114 // Runtime check is only needed if unable to comptime check.
...@@ -29073,6 +29166,7 @@ fn elemValSlice(...@@ -29073,6 +29166,7 @@ fn elemValSlice(
29073 }29166 }
2907429167
29075 try sema.validateRuntimeElemAccess(block, elem_index_src, elem_ty, slice_ty, slice_src);29168 try sema.validateRuntimeElemAccess(block, elem_index_src, elem_ty, slice_ty, slice_src);
29169 try sema.validateRuntimeValue(block, slice_src, slice);
2907629170
29077 if (oob_safety and block.wantSafety()) {29171 if (oob_safety and block.wantSafety()) {
29078 const len_inst = if (maybe_slice_val) |slice_val|29172 const len_inst = if (maybe_slice_val) |slice_val|
...@@ -29129,6 +29223,7 @@ fn elemPtrSlice(...@@ -29129,6 +29223,7 @@ fn elemPtrSlice(
29129 }29223 }
2913029224
29131 try sema.validateRuntimeElemAccess(block, elem_index_src, elem_ptr_ty, slice_ty, slice_src);29225 try sema.validateRuntimeElemAccess(block, elem_index_src, elem_ptr_ty, slice_ty, slice_src);
29226 try sema.validateRuntimeValue(block, slice_src, slice);
2913229227
29133 if (oob_safety and block.wantSafety()) {29228 if (oob_safety and block.wantSafety()) {
29134 const len_inst = len: {29229 const len_inst = len: {
...@@ -33889,6 +33984,17 @@ fn resolvePeerTypes(...@@ -33889,6 +33984,17 @@ fn resolvePeerTypes(
33889 else => {},33984 else => {},
33890 }33985 }
3389133986
33987 // Fast path: check if everything has the same type to bypass the main PTR logic.
33988 same_type: {
33989 const ty = sema.typeOf(instructions[0]);
33990 for (instructions[1..]) |inst| {
33991 if (sema.typeOf(inst).toIntern() != ty.toIntern()) {
33992 break :same_type;
33993 }
33994 }
33995 return ty;
33996 }
33997
33892 const peer_tys = try sema.arena.alloc(?Type, instructions.len);33998 const peer_tys = try sema.arena.alloc(?Type, instructions.len);
33893 const peer_vals = try sema.arena.alloc(?Value, instructions.len);33999 const peer_vals = try sema.arena.alloc(?Value, instructions.len);
3389434000
...@@ -34562,14 +34668,14 @@ fn resolvePeerTypesInner(...@@ -34562,14 +34668,14 @@ fn resolvePeerTypesInner(
34562 }34668 }
34563 // Clear existing sentinel34669 // Clear existing sentinel
34564 ptr_info.sentinel = .none;34670 ptr_info.sentinel = .none;
34565 switch (ip.indexToKey(ptr_info.child)) {34671 if (ptr_info.flags.size == .one) switch (ip.indexToKey(ptr_info.child)) {
34566 .array_type => |array_type| ptr_info.child = (try pt.arrayType(.{34672 .array_type => |array_type| ptr_info.child = (try pt.arrayType(.{
34567 .len = array_type.len,34673 .len = array_type.len,
34568 .child = array_type.child,34674 .child = array_type.child,
34569 .sentinel = .none,34675 .sentinel = .none,
34570 })).toIntern(),34676 })).toIntern(),
34571 else => {},34677 else => {},
34572 }34678 };
34573 }34679 }
3457434680
34575 opt_ptr_info = ptr_info;34681 opt_ptr_info = ptr_info;
src/Zcu.zig+2
...@@ -181,6 +181,8 @@ analysis_roots: std.BoundedArray(*Package.Module, 3) = .{},...@@ -181,6 +181,8 @@ analysis_roots: std.BoundedArray(*Package.Module, 3) = .{},
181/// Allocated into `gpa`.181/// Allocated into `gpa`.
182resolved_references: ?std.AutoHashMapUnmanaged(AnalUnit, ?ResolvedReference) = null,182resolved_references: ?std.AutoHashMapUnmanaged(AnalUnit, ?ResolvedReference) = null,
183183
184skip_analysis_errors: bool = false,
185
184stage1_flags: packed struct {186stage1_flags: packed struct {
185 have_winmain: bool = false,187 have_winmain: bool = false,
186 have_wwinmain: bool = false,188 have_wwinmain: bool = false,
src/print_zir.zig+1
...@@ -208,6 +208,7 @@ const Writer = struct {...@@ -208,6 +208,7 @@ const Writer = struct {
208 .anyframe_type,208 .anyframe_type,
209 .bit_not,209 .bit_not,
210 .bool_not,210 .bool_not,
211 .slice_sentinel_ty,
211 .negate,212 .negate,
212 .negate_wrap,213 .negate_wrap,
213 .load,214 .load,
test/behavior/cast.zig+16
...@@ -2649,3 +2649,19 @@ test "bitcast vector" {...@@ -2649,3 +2649,19 @@ test "bitcast vector" {
2649 const bigsum: u32x8 = @bitCast(zerox32);2649 const bigsum: u32x8 = @bitCast(zerox32);
2650 try std.testing.expectEqual(0, @reduce(.Add, bigsum));2650 try std.testing.expectEqual(0, @reduce(.Add, bigsum));
2651}2651}
2652
2653test "peer type resolution: slice of sentinel-terminated array" {
2654 var f: bool = undefined;
2655 f = false;
2656
2657 const a: [][2:0]u8 = &.{};
2658 const b: []const [2:0]u8 = &.{.{ 10, 20 }};
2659
2660 const result = if (f) a else b;
2661
2662 comptime assert(@TypeOf(result) == []const [2:0]u8);
2663 try expect(result.len == 1);
2664 try expect(result[0].len == 2);
2665 try expect(result[0][0] == 10);
2666 try expect(result[0][1] == 20);
2667}
test/behavior/error.zig+29-3
...@@ -1060,9 +1060,24 @@ test "errorCast to adhoc inferred error set" {...@@ -1060,9 +1060,24 @@ test "errorCast to adhoc inferred error set" {
1060 try std.testing.expect((try S.baz()) == 1234);1060 try std.testing.expect((try S.baz()) == 1234);
1061}1061}
10621062
1063test "errorCast from error sets to error unions" {1063test "@errorCast from error set to error union" {
1064 const err_union: Set1!void = @errorCast(error.A);1064 const S = struct {
1065 try expectError(error.A, err_union);1065 fn doTheTest(set: error{ A, B }) error{A}!i32 {
1066 return @errorCast(set);
1067 }
1068 };
1069 try expectError(error.A, S.doTheTest(error.A));
1070 try expectError(error.A, comptime S.doTheTest(error.A));
1071}
1072
1073test "@errorCast from error union to error union" {
1074 const S = struct {
1075 fn doTheTest(set: error{ A, B }!i32) error{A}!i32 {
1076 return @errorCast(set);
1077 }
1078 };
1079 try expectError(error.A, S.doTheTest(error.A));
1080 try expectError(error.A, comptime S.doTheTest(error.A));
1066}1081}
10671082
1068test "result location initialization of error union with OPV payload" {1083test "result location initialization of error union with OPV payload" {
...@@ -1100,3 +1115,14 @@ test "return error union with i65" {...@@ -1100,3 +1115,14 @@ test "return error union with i65" {
1100fn add(x: i65, y: i65) anyerror!i65 {1115fn add(x: i65, y: i65) anyerror!i65 {
1101 return x + y;1116 return x + y;
1102}1117}
1118
1119test "compare error union to error set" {
1120 const S = struct {
1121 fn doTheTest(val: error{Foo}!i32) !void {
1122 if (error.Foo == val) return error.Unexpected;
1123 if (val == error.Foo) return error.Unexpected;
1124 }
1125 };
1126 try S.doTheTest(0);
1127 try comptime S.doTheTest(0);
1128}
test/behavior/eval.zig+11
...@@ -1751,3 +1751,14 @@ test "comptime labeled block implicit exit" {...@@ -1751,3 +1751,14 @@ test "comptime labeled block implicit exit" {
1751 };1751 };
1752 comptime assert(result == {});1752 comptime assert(result == {});
1753}1753}
1754
1755test "comptime block has intermediate runtime-known values" {
1756 const arr: [2]u8 = .{ 1, 2 };
1757
1758 var idx: usize = undefined;
1759 idx = 0;
1760
1761 comptime {
1762 _ = arr[idx];
1763 }
1764}
test/behavior/fn.zig+17
...@@ -711,3 +711,20 @@ test "inline call propagates comptime-known argument to generic parameter and re...@@ -711,3 +711,20 @@ test "inline call propagates comptime-known argument to generic parameter and re
711 try expect(a1 == 12340);711 try expect(a1 == 12340);
712 try expect(b1 == 12340);712 try expect(b1 == 12340);
713}713}
714
715test "inline function return type is evaluated at comptime" {
716 const S = struct {
717 inline fn assertComptimeAndRet(x: anytype) @TypeOf(x) {
718 if (!@inComptime()) comptime unreachable;
719 return x;
720 }
721
722 inline fn foo(val: anytype) assertComptimeAndRet(u16) {
723 return val;
724 }
725 };
726
727 const result = S.foo(123);
728 comptime assert(@TypeOf(result) == u16);
729 try expect(result == 123);
730}
test/behavior/generics.zig+16
...@@ -589,3 +589,19 @@ comptime {...@@ -589,3 +589,19 @@ comptime {
589 // should override the result of the previous analysis.589 // should override the result of the previous analysis.
590 for (0..2) |_| _ = fn (void) void;590 for (0..2) |_| _ = fn (void) void;
591}591}
592
593test "generic parameter resolves to comptime-only type but is not marked comptime" {
594 const S = struct {
595 fn foo(comptime T: type, rt_false: bool, func: fn (T) void) T {
596 if (rt_false) _ = foo(T, rt_false, func);
597 return 123;
598 }
599 fn bar(_: u8) void {}
600 };
601
602 const rt_result = S.foo(u8, false, S.bar);
603 try expect(rt_result == 123);
604
605 const ct_result = comptime S.foo(u8, false, S.bar);
606 comptime std.debug.assert(ct_result == 123);
607}
test/behavior/slice.zig+13
...@@ -1037,3 +1037,16 @@ test "peer slices keep abi alignment with empty struct" {...@@ -1037,3 +1037,16 @@ test "peer slices keep abi alignment with empty struct" {
1037 comptime assert(@TypeOf(slice) == []const u32);1037 comptime assert(@TypeOf(slice) == []const u32);
1038 try expect(slice.len == 0);1038 try expect(slice.len == 0);
1039}1039}
1040
1041test "sentinel expression in slice operation has result type" {
1042 const sentinel = std.math.maxInt(u16);
1043
1044 const arr: [3]u16 = .{ 1, 2, sentinel };
1045 const slice = arr[0..2 :@intCast(sentinel)];
1046
1047 comptime assert(@TypeOf(slice) == *const [2:sentinel]u16);
1048 comptime assert(slice[2] == sentinel);
1049 comptime assert(slice.len == 2);
1050 comptime assert(slice[0] == 1);
1051 comptime assert(slice[1] == 2);
1052}
test/behavior/type_info.zig+9
...@@ -675,3 +675,12 @@ test "@typeInfo only contains pub decls" {...@@ -675,3 +675,12 @@ test "@typeInfo only contains pub decls" {
675 try std.testing.expectEqualStrings("Enum", decls[0].name);675 try std.testing.expectEqualStrings("Enum", decls[0].name);
676 try std.testing.expectEqualStrings("Struct", decls[1].name);676 try std.testing.expectEqualStrings("Struct", decls[1].name);
677}677}
678
679test "@typeInfo function with generic return type and inferred error set" {
680 const S = struct {
681 fn testFn(comptime T: type) !T {}
682 };
683
684 const ret_ty = @typeInfo(@TypeOf(S.testFn)).@"fn".return_type;
685 comptime assert(ret_ty == null);
686}
test/behavior/union.zig+16
...@@ -2322,3 +2322,19 @@ test "assign global tagged union" {...@@ -2322,3 +2322,19 @@ test "assign global tagged union" {
2322 try expect(U.global == .b);2322 try expect(U.global == .b);
2323 try expect(U.global.b == 123456);2323 try expect(U.global.b == 123456);
2324}2324}
2325
2326test "set mutable union by switching on same union" {
2327 const U = union(enum) {
2328 foo,
2329 bar: usize,
2330 };
2331
2332 var val: U = .foo;
2333 val = switch (val) {
2334 .foo => .{ .bar = 2 },
2335 .bar => .foo,
2336 };
2337
2338 try expect(val == .bar);
2339 try expect(val.bar == 2);
2340}
test/cases/compile_errors/for_comptime_array_pointer.zig created+12
...@@ -0,0 +1,12 @@
1export fn foo() void {
2 comptime var elems: [3]u32 = undefined;
3 for (&elems) |*elem| {
4 _ = elem;
5 }
6}
7
8// error
9//
10// :3:10: error: runtime value contains reference to comptime var
11// :3:10: note: comptime var pointers are not available at runtime
12// :2:34: note: 'runtime_value' points to comptime var declared here
test/cases/compile_errors/struct_depends_on_itself_via_non_initial_field.zig created+12
...@@ -0,0 +1,12 @@
1const A = struct {
2 a: u8,
3 bytes: [@sizeOf(A)]u8,
4};
5
6comptime {
7 _ = A;
8}
9
10// error
11//
12// :1:11: error: struct 'tmp.A' depends on itself
test/cases/compile_errors/tagName_on_undef_enum_literal.zig created+8
...@@ -0,0 +1,8 @@
1comptime {
2 const undef: @Type(.enum_literal) = undefined;
3 _ = @tagName(undef);
4}
5
6// error
7//
8// :3:18: error: use of undefined value here causes undefined behavior
test/incremental/analysis_error_and_syntax_error created+42
...@@ -0,0 +1,42 @@
1#target=x86_64-linux-selfhosted
2#target=x86_64-linux-cbe
3#target=x86_64-windows-cbe
4#target=wasm32-wasi-selfhosted
5#update=initial version
6#file=main.zig
7pub fn main() !void {
8 @compileError("uh oh");
9}
10#expect_error=main.zig:2:5: error: uh oh
11
12#update=add parse error
13#file=main.zig
14pub fn main() !void {
15 @compileError("uh oh");
16#expect_error=main.zig:3:1: error: expected statement, found 'EOF'
17
18#update=fix parse error
19#file=main.zig
20pub fn main() !void {
21 @compileError("uh oh");
22}
23#expect_error=main.zig:2:5: error: uh oh
24
25#update=add parse error again
26#file=main.zig
27pub fn main() !void {
28 @compileError("uh oh");
29#expect_error=main.zig:3:1: error: expected statement, found 'EOF'
30
31#update=comment @compileError call
32#file=main.zig
33pub fn main() !void {
34 //@compileError("uh oh");
35#expect_error=main.zig:3:1: error: expected statement, found 'EOF'
36
37#update=fix parse error again
38#file=main.zig
39pub fn main() !void {
40 //@compileError("uh oh");
41}
42#expect_stdout=""