Commit 6413c1bf213eb18165142e99f49d63c5f713d287 | zig

author	Andrew Kelley <andrew@ziglang.org> 2026-10-09 20:18:17+02:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-10-09 15:51:58-07:00
log	6413c1bf213eb18165142e99f49d63c5f713d287
tree	f1da2ce5cb3e76ce47d7bf53a0013856e03fe446
parent	4ae62410d232d36f1ef72532d59d87cc1485ef76

Merge pull request 'AstGen: fix fuzzed bugs' (#35526) from gooncreeper/zig:astgen-fuzzing-2 into master

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/35526
Reviewed-by: Andrew Kelley <andrew@ziglang.org>

9 files changed, 211 insertions(+), 132 deletions(-)

lib
- std
  - zig
    AstGen.zig
test
- cases

lib/std/zig/AstGen.zig+81-72

 @@ -1460,6 +1460,7 @@ fn arrayInitExpr(
                 mem.eql(u8, tree.tokenSlice(tree.nodeMainToken(array_type.ast.elem_count)), "_"))
             {
                 const len_inst = try gz.addInt(array_init.ast.elements.len);
+                const saved_cursor = astgen.saveSourceCursor();
                 const elem_type = try typeExpr(gz, scope, array_type.ast.elem_type);
                 if (array_type.ast.sentinel == .none) {
                     const array_type_inst = try gz.addPlNode(.array_type, type_expr, Zir.Inst.Bin{
 @@ -1468,6 +1469,7 @@ fn arrayInitExpr(
                     });
                     break :inst .{ array_type_inst, elem_type };
                 } else {
+                    astgen.restoreSourceCursor(saved_cursor);
                     const sentinel_node = array_type.ast.sentinel.unwrap().?;
                     const sentinel = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = elem_type } }, sentinel_node, .array_sentinel);
                     const array_type_inst = try gz.addPlNode(
 @@ -1729,6 +1731,7 @@ fn structInitExpr(
             mem.eql(u8, tree.tokenSlice(tree.nodeMainToken(array_type.ast.elem_count)), "_");
         if (struct_init.ast.fields.len == 0) {
             if (is_inferred_array_len) {
+                const saved_cursor = astgen.saveSourceCursor();
                 const elem_type = try typeExpr(gz, scope, array_type.ast.elem_type);
                 const array_type_inst = if (array_type.ast.sentinel == .none) blk: {
                     break :blk try gz.addPlNode(.array_type, type_expr, Zir.Inst.Bin{
 @@ -1736,6 +1739,7 @@ fn structInitExpr(
                         .rhs = elem_type,
                     });
                 } else blk: {
+                    astgen.restoreSourceCursor(saved_cursor);
                     const sentinel_node = array_type.ast.sentinel.unwrap().?;
                     const sentinel = try comptimeExpr(gz, scope, .{ .rl = .{ .ty = elem_type } }, sentinel_node, .array_sentinel);
                     break :blk try gz.addPlNode(
 @@ -3135,6 +3139,11 @@ fn varDecl(
         return astgen.failTok(tree.nodeMainToken(section_node), "cannot set section of local variable '{s}'", .{ident_name_raw});
     }
+    const type_inst: Zir.Inst.Ref = if (var_decl.ast.type_node.unwrap()) |type_node|
+        try typeExpr(gz, scope, type_node)
+    else
+        .none;
     const align_inst: Zir.Inst.Ref = if (var_decl.ast.align_node.unwrap()) |align_node|
         try comptimeExpr(gz, scope, coerced_align_ri, align_node, .@"align")
     else
 @@ -3155,8 +3164,8 @@ fn varDecl(
             if (align_inst == .none and
                 !astgen.nodes_need_rl.contains(node))
             {
-                const result_info: ResultInfo = if (var_decl.ast.type_node.unwrap()) |type_node| .{
+                const result_info: ResultInfo = if (type_inst != .none) .{
-                    .rl = .{ .ty = try typeExpr(gz, scope, type_node) },
+                    .rl = .{ .ty = type_inst },
                     .ctx = .const_init,
                 } else .{ .rl = .none, .ctx = .const_init };
                 const init_inst: Zir.Inst.Ref = try nameStratExpr(gz, scope, result_info, init_node, .dbg_var) orelse
 @@ -3185,8 +3194,7 @@ fn varDecl(
             const is_comptime = gz.is_comptime or
                 tree.nodeTag(init_node) == .@"comptime";
-            const init_rl: ResultInfo.Loc = if (var_decl.ast.type_node.unwrap()) |type_node| init_rl: {
+            const init_rl: ResultInfo.Loc = if (type_inst != .none) init_rl: {
-                const type_inst = try typeExpr(gz, scope, type_node);
                 if (align_inst == .none) {
                     break :init_rl .{ .ptr = .{ .inst = try gz.addUnNode(.alloc, type_inst, node) } };
                 } else {
 @@ -3254,8 +3262,7 @@ fn varDecl(
             if (var_decl.comptime_token != null and gz.is_comptime)
                 return astgen.failTok(var_decl.comptime_token.?, "'comptime var' is redundant in comptime scope", .{});
             const is_comptime = var_decl.comptime_token != null or gz.is_comptime;
-            const alloc: Zir.Inst.Ref, const resolve_inferred: bool, const result_info: ResultInfo = if (var_decl.ast.type_node.unwrap()) |type_node| a: {
+            const alloc: Zir.Inst.Ref, const resolve_inferred: bool, const result_info: ResultInfo = if (type_inst != .none) a: {
-                const type_inst = try typeExpr(gz, scope, type_node);
                 const alloc = alloc: {
                     if (align_inst == .none) {
                         const tag: Zir.Inst.Tag = if (is_comptime)
 @@ -3433,6 +3440,7 @@ fn assignDestructureMaybeDecls(
     const is_comptime = full.comptime_token != null or gz.is_comptime;
     const value_is_comptime = tree.nodeTag(full.ast.value_expr) == .@"comptime";
+    const saved_cursor = astgen.saveSourceCursor();
     // When declaring consts via a destructure, we always use a result pointer.
     // This avoids the need to create tuple types, and is also likely easier to
     // optimize, since it's a bit tricky for the optimizer to "split up" the
 @@ -3482,14 +3490,18 @@ fn assignDestructureMaybeDecls(
                 // We also mark `const`s as comptime if the RHS is definitely comptime-known.
                 const this_variable_comptime = is_comptime or (is_const and value_is_comptime);
+                const type_inst = if (full_var_decl.ast.type_node.unwrap()) |type_node|
+                    try typeExpr(gz, scope, type_node)
+                else
+                    .none;
                 const align_inst: Zir.Inst.Ref = if (full_var_decl.ast.align_node.unwrap()) |align_node|
                     try comptimeExpr(gz, scope, coerced_align_ri, align_node, .@"align")
                 else
                     .none;
-                if (full_var_decl.ast.type_node.unwrap()) |type_node| {
+                if (type_inst != .none) {
                     // Typed alloc
-                    const type_inst = try typeExpr(gz, scope, type_node);
                     const ptr = if (align_inst == .none) ptr: {
                         const tag: Zir.Inst.Tag = if (this_variable_comptime)
                             .alloc_comptime_mut
 @@ -3556,6 +3568,7 @@ fn assignDestructureMaybeDecls(
     if (any_lvalue_expr) {
         // At least one variable was an lvalue expr. Iterate again in order to
         // evaluate the lvalues from within the possible block_comptime.
+        astgen.restoreSourceCursor(saved_cursor);
         for (rl_components, full.ast.variables) |*variable_rl, variable_node| {
             if (variable_rl.* != .typed_ptr) continue;
             switch (tree.nodeTag(variable_node)) {
 @@ -3889,7 +3902,9 @@ fn arrayTypeSentinel(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.
         return astgen.failNode(len_node, "unable to infer array size", .{});
     }
     const len = try reachableExprComptime(gz, scope, .{ .rl = .{ .coerced_ty = .usize_type } }, len_node, node, .array_length);
+    const saved_cursor = astgen.saveSourceCursor();
     const elem_type = try typeExpr(gz, scope, extra.elem_type);
+    astgen.restoreSourceCursor(saved_cursor);
     const sentinel = try reachableExprComptime(gz, scope, .{ .rl = .{ .coerced_ty = elem_type } }, extra.sentinel, node, .array_sentinel);
     const result = try gz.addPlNode(.array_type_sentinel, node, Zir.Inst.ArrayTypeSentinel{
 @@ -4061,43 +4076,41 @@ fn fnDecl(
         // We include a function *type*, not a value.
         const type_inst = try fnProtoExprInner(&type_gz, &type_gz.base, .{ .rl = .none }, decl_node, fn_proto, true);
         _ = try type_gz.addBreakWithSrcNode(.break_inline, decl_inst, type_inst, decl_node);
+        astgen.restoreSourceCursor(saved_cursor);
     }
     var align_gz = type_gz.makeSubBlock(scope);
     defer align_gz.unstack();
     if (fn_proto.ast.align_expr.unwrap()) |align_expr| {
-        astgen.restoreSourceCursor(saved_cursor);
         const inst = try expr(&align_gz, &align_gz.base, coerced_align_ri, align_expr);
         _ = try align_gz.addBreakWithSrcNode(.break_inline, decl_inst, inst, decl_node);
     }
-    var linksection_gz = align_gz.makeSubBlock(scope);
+    var addrspace_gz = align_gz.makeSubBlock(scope);
-    defer linksection_gz.unstack();
-    if (fn_proto.ast.section_expr.unwrap()) |section_expr| {
-        astgen.restoreSourceCursor(saved_cursor);
-        const inst = try expr(&linksection_gz, &linksection_gz.base, coerced_linksection_ri, section_expr);
-        _ = try linksection_gz.addBreakWithSrcNode(.break_inline, decl_inst, inst, decl_node);
-    }
-    var addrspace_gz = linksection_gz.makeSubBlock(scope);
     defer addrspace_gz.unstack();
     if (fn_proto.ast.addrspace_expr.unwrap()) |addrspace_expr| {
-        astgen.restoreSourceCursor(saved_cursor);
         const addrspace_ty = try addrspace_gz.addStdLangValue(addrspace_expr, .address_space);
         const inst = try expr(&addrspace_gz, &addrspace_gz.base, .{ .rl = .{ .coerced_ty = addrspace_ty } }, addrspace_expr);
         _ = try addrspace_gz.addBreakWithSrcNode(.break_inline, decl_inst, inst, decl_node);
     }
-    var value_gz = addrspace_gz.makeSubBlock(scope);
+    var linksection_gz = addrspace_gz.makeSubBlock(scope);
+    defer linksection_gz.unstack();
+    if (fn_proto.ast.section_expr.unwrap()) |section_expr| {
+        const inst = try expr(&linksection_gz, &linksection_gz.base, coerced_linksection_ri, section_expr);
+        _ = try linksection_gz.addBreakWithSrcNode(.break_inline, decl_inst, inst, decl_node);
+    }
+    var value_gz = linksection_gz.makeSubBlock(scope);
     defer value_gz.unstack();
     if (!is_extern) {
         // We include a function *value*, not a type.
         astgen.restoreSourceCursor(saved_cursor);
-        try astgen.fnDeclInner(&value_gz, &value_gz.base, saved_cursor, decl_inst, decl_node, body_node.unwrap().?, fn_proto);
+        try astgen.fnDeclInner(&value_gz, &value_gz.base, decl_inst, decl_node, body_node.unwrap().?, fn_proto);
     }
     // *Now* we can incorporate the full source code into the hasher.
 @@ -4119,8 +4132,8 @@ fn fnDecl(
         .type_gz = &type_gz,
         .align_gz = &align_gz,
-        .linksection_gz = &linksection_gz,
         .addrspace_gz = &addrspace_gz,
+        .linksection_gz = &linksection_gz,
         .value_gz = &value_gz,
     });
 }
 @@ -4129,7 +4142,6 @@ fn fnDeclInner(
     astgen: *AstGen,
     decl_gz: *GenZir,
     scope: *Scope,
-    saved_cursor: SourceCursor,
     decl_inst: Zir.Inst.Index,
     decl_node: Ast.Node.Index,
     body_node: Ast.Node.Index,
 @@ -4266,27 +4278,6 @@ fn fnDeclInner(
     // instructions inside the expression blocks for cc and ret_ty to use the function
     // instruction as the body to break from.
-    var ret_gz = decl_gz.makeSubBlock(params_scope);
-    defer ret_gz.unstack();
-    any_param_used = false; // we will check this later
-    const ret_ref: Zir.Inst.Ref = inst: {
-        // Parameters are in scope for the return type, so we use `params_scope` here.
-        // The calling convention will not have parameters in scope, so we'll just use `scope`.
-        // See #22263 for a proposal to solve the inconsistency here.
-        const inst = try fullBodyExpr(&ret_gz, params_scope, coerced_type_ri, fn_proto.ast.return_type.unwrap().?, .normal);
-        if (ret_gz.instructionsSlice().len == 0) {
-            // In this case we will send a len=0 body which can be encoded more efficiently.
-            break :inst inst;
-        }
-        _ = try ret_gz.addBreak(.break_inline, @fromBackingInt(@intCast(0)), inst);
-        break :inst inst;
-    };
-    const ret_body_param_refs = try astgen.fetchRemoveRefEntries(param_insts.items);
-    const ret_ty_is_generic = any_param_used;
-    // We're jumping back in source, so restore the cursor.
-    astgen.restoreSourceCursor(saved_cursor);
     var cc_gz = decl_gz.makeSubBlock(scope);
     defer cc_gz.unstack();
     const cc_ref: Zir.Inst.Ref = blk: {
 @@ -4312,6 +4303,24 @@ fn fnDeclInner(
         }
     };
+    var ret_gz = decl_gz.makeSubBlock(params_scope);
+    defer ret_gz.unstack();
+    any_param_used = false; // we will check this later
+    const ret_ref: Zir.Inst.Ref = inst: {
+        // Parameters are in scope for the return type, so we use `params_scope` here.
+        // The calling convention will not have parameters in scope, so we'll just use `scope`.
+        // See #22263 for a proposal to solve the inconsistency here.
+        const inst = try fullBodyExpr(&ret_gz, params_scope, coerced_type_ri, fn_proto.ast.return_type.unwrap().?, .normal);
+        if (ret_gz.instructionsSlice().len == 0) {
+            // In this case we will send a len=0 body which can be encoded more efficiently.
+            break :inst inst;
+        }
+        _ = try ret_gz.addBreak(.break_inline, @fromBackingInt(@intCast(0)), inst);
+        break :inst inst;
+    };
+    const ret_body_param_refs = try astgen.fetchRemoveRefEntries(param_insts.items);
+    const ret_ty_is_generic = any_param_used;
     var body_gz: GenZir = .{
         .is_comptime = false,
         .src_baseline = fn_proto.ast.proto_node,
 @@ -4490,14 +4499,6 @@ fn globalVarDecl(
         _ = try align_gz.addBreakWithSrcNode(.break_inline, decl_inst, align_inst, node);
     }
-    var linksection_gz = type_gz.makeSubBlock(scope);
-    defer linksection_gz.unstack();
-    if (var_decl.ast.section_node.unwrap()) |section_node| {
-        const linksection_inst = try expr(&linksection_gz, &linksection_gz.base, coerced_linksection_ri, section_node);
-        _ = try linksection_gz.addBreakWithSrcNode(.break_inline, decl_inst, linksection_inst, node);
-    }
     var addrspace_gz = type_gz.makeSubBlock(scope);
     defer addrspace_gz.unstack();
 @@ -4507,6 +4508,14 @@ fn globalVarDecl(
         _ = try addrspace_gz.addBreakWithSrcNode(.break_inline, decl_inst, addrspace_inst, node);
     }
+    var linksection_gz = type_gz.makeSubBlock(scope);
+    defer linksection_gz.unstack();
+    if (var_decl.ast.section_node.unwrap()) |section_node| {
+        const linksection_inst = try expr(&linksection_gz, &linksection_gz.base, coerced_linksection_ri, section_node);
+        _ = try linksection_gz.addBreakWithSrcNode(.break_inline, decl_inst, linksection_inst, node);
+    }
     var init_gz = type_gz.makeSubBlock(scope);
     defer init_gz.unstack();
 @@ -4536,8 +4545,8 @@ fn globalVarDecl(
         .type_gz = &type_gz,
         .align_gz = &align_gz,
-        .linksection_gz = &linksection_gz,
         .addrspace_gz = &addrspace_gz,
+        .linksection_gz = &linksection_gz,
         .value_gz = &init_gz,
     });
 }
 @@ -4599,8 +4608,8 @@ fn comptimeDecl(
         .linkage = .normal,
         .type_gz = &dummy_gz,
         .align_gz = &dummy_gz,
-        .linksection_gz = &dummy_gz,
         .addrspace_gz = &dummy_gz,
+        .linksection_gz = &dummy_gz,
         .value_gz = &comptime_gz,
     });
 }
 @@ -7734,10 +7743,6 @@ fn switchExpr(
         };
         if (capture != .none) assert(any_has_payload_capture);
-        if (is_err_switch) {
-            assert(!any_payload_is_ref); // should have failed by now
-            assert(!any_has_tag_capture); // should have failed by now
-        }
         prong_body: {
             scratch_scope.instructions_top = parent_gz.instructions.items.len;
 @@ -7844,6 +7849,10 @@ fn switchExpr(
             }
         }
     }
+    if (is_err_switch) {
+        assert(!any_payload_is_ref); // should have failed by now
+        assert(!any_has_tag_capture); // should have failed by now
+    }
     assert(scalar_case_index + multi_case_index + @intFromBool(has_else) == case_nodes.len);
     assert(multi_items_infos_start + multi_item_offset == bodies_start);
 @@ -11527,8 +11536,8 @@ const GenZir = struct {
     /// Must be called with the following stack set up:
     ///  * gz (bottom)
-    ///  * ret_gz
     ///  * cc_gz
+    ///  * ret_gz
     ///  * body_gz (top)
     /// Unstacks all of those except for `gz`.
     fn addFunc(
 @@ -11575,16 +11584,16 @@ const GenZir = struct {
                 stacked_gz = body_gz;
                 break :body body;
             } else &.{};
-            const cc_body: []const Zir.Inst.Index = if (args.cc_gz) |cc_gz| body: {
-                const cc_body = cc_gz.instructionsSliceUptoOpt(stacked_gz);
-                stacked_gz = cc_gz;
-                break :body cc_body;
-            } else &.{};
             const ret_body: []const Zir.Inst.Index = if (args.ret_gz) |ret_gz| body: {
                 const ret_body = ret_gz.instructionsSliceUptoOpt(stacked_gz);
                 stacked_gz = ret_gz;
                 break :body ret_body;
             } else &.{};
+            const cc_body: []const Zir.Inst.Index = if (args.cc_gz) |cc_gz| body: {
+                const cc_body = cc_gz.instructionsSliceUptoOpt(stacked_gz);
+                stacked_gz = cc_gz;
+                break :body cc_body;
+            } else &.{};
             break :bodies .{ body, cc_body, ret_body };
         };
 @@ -11725,8 +11734,8 @@ const GenZir = struct {
         // Order is important when unstacking.
         if (args.body_gz) |body_gz| body_gz.unstack();
-        if (args.cc_gz) |cc_gz| cc_gz.unstack();
         if (args.ret_gz) |ret_gz| ret_gz.unstack();
+        if (args.cc_gz) |cc_gz| cc_gz.unstack();
         astgen.instructions.appendAssumeCapacity(.{
             .tag = tag,
 @@ -13502,10 +13511,10 @@ fn setDeclaration(
         /// Must be stacked on `type_gz`.
         align_gz: *GenZir,
         /// Must be stacked on `align_gz`.
-        linksection_gz: *GenZir,
-        /// Must be stacked on `linksection_gz`.
         addrspace_gz: *GenZir,
-        /// Must be stacked on `addrspace_gz` and have nothing stacked on top of it.
+        /// Must be stacked on `addrspace_gz`.
+        linksection_gz: *GenZir,
+        /// Must be stacked on `linksection_gz` and have nothing stacked on top of it.
         value_gz: *GenZir,
     },
 ) !void {
 @@ -13513,9 +13522,9 @@ fn setDeclaration(
     const gpa = astgen.gpa;
     const type_body = args.type_gz.instructionsSliceUpto(args.align_gz);
-    const align_body = args.align_gz.instructionsSliceUpto(args.linksection_gz);
+    const align_body = args.align_gz.instructionsSliceUpto(args.addrspace_gz);
-    const linksection_body = args.linksection_gz.instructionsSliceUpto(args.addrspace_gz);
+    const addrspace_body = args.addrspace_gz.instructionsSliceUpto(args.linksection_gz);
-    const addrspace_body = args.addrspace_gz.instructionsSliceUpto(args.value_gz);
+    const linksection_body = args.linksection_gz.instructionsSliceUpto(args.value_gz);
     const value_body = args.value_gz.instructionsSlice();
     const has_name = args.name != .empty;

test/cases/array_sentinel_cursor.zig created+14

...	@@ -0,0 +1,14 @@
1	fn s() usize {
2	return 64;
3	}
4
5	fn T() type {
6	return u64;
7	}
8
9	const Array = [64:s()]T();
10	const empty = [_:s()]T(){};
11	const items = [_:s()]T(){100};
12
13	// compile
14	// output_mode=Obj

test/cases/compile_errors/error_set_cannot_capture_by_reference.zig deleted-13

...	@@ -1,13 +0,0 @@
1	export fn entry() void {
2	const err: error{Foo} = error.Foo;
3
4	switch (err) {
5	error.Foo => \|*foo\| {
6	foo catch {};
7	},
8	}
9	}
10
11	// error
12	//
13	// :5:23: error: error set cannot be captured by reference

test/cases/compile_errors/switch_capture_error_by_ref.zig deleted-25

...	@@ -1,25 +0,0 @@
1	export fn entry1() void {
2	switch (@as(anyerror, error.MyError)) {
3	error.MyError, error.MyOtherError => \|*err\| _ = err,
4	else => {},
5	}
6	}
7
8	export fn entry2() void {
9	switch (@as(anyerror, error.MyError)) {
10	inline error.MyError, error.MyOtherError => \|*err\| _ = err,
11	else => {},
12	}
13	}
14
15	export fn entry3() void {
16	switch (@as(anyerror, error.MyError)) {
17	else => \|*err\| _ = err,
18	}
19	}
20
21	// error
22	//
23	// :3:47: error: error set cannot be captured by reference
24	// :10:54: error: error set cannot be captured by reference
25	// :17:18: error: error set cannot be captured by reference

test/cases/compile_errors/switch_on_error_bad_captures_astgen.zig created+37

...	@@ -0,0 +1,37 @@
1	const Error = error {OutOfMemory, ReadFailed};
2	const result: Error!u64 = error.OutOfMemory;
3
4	test {
5	_ = result catch \|err\| switch (err) {
6	error.ReadFailed => 2,
7	error.OutOfMemory => \|*val\| 1,
8	};
9	}
10
11	test {
12	_ = result catch \|err\| switch (err) {
13	error.ReadFailed => 2,
14	error.OutOfMemory => \|_, tag\| 1,
15	};
16	}
17
18	test {
19	_ = if (result) \|n\| n else \|err\| switch (err) {
20	error.ReadFailed => 2,
21	error.OutOfMemory => \|*val\| 1,
22	};
23	}
24
25	test {
26	_ = if (result) \|n\| n else \|err\| switch (err) {
27	error.ReadFailed => 2,
28	error.OutOfMemory => \|_, tag\| 1,
29	};
30	}
31
32	// error
33	//
34	// :7:32: error: error set cannot be captured by reference
35	// :14:34: error: cannot capture tag of error union
36	// :21:32: error: error set cannot be captured by reference
37	// :28:34: error: cannot capture tag of error union

test/cases/compile_errors/switch_on_error_bad_captures_sema.zig created+21

...	@@ -0,0 +1,21 @@
1	const Error = error{ OutOfMemory, ReadFailed };
2	const err: Error = error.OutOfMemory;
3
4	export fn a() void {
5	_ = switch (err) {
6	error.ReadFailed => 2,
7	error.OutOfMemory => \|val\| @intFromError(val.),
8	};
9	}
10
11	export fn b() void {
12	_ = switch (err) {
13	error.ReadFailed => 2,
14	error.OutOfMemory => \|_, tag\| @intFromEnum(tag),
15	};
16	}
17
18	// error
19	//
20	// :7:31: error: error set cannot be captured by reference
21	// :14:34: error: cannot capture tag of non-union type 'error{OutOfMemory,ReadFailed}'

test/cases/compile_errors/switch_on_error_with_capture_by_reference.zig deleted-22

...	@@ -1,22 +0,0 @@
1	comptime {
2	const e: error{Foo}!u32 = error.Foo;
3	e catch \|err\| switch (err) {
4	error.Foo => \|*foo\| {
5	foo catch {};
6	},
7	};
8	}
9
10	comptime {
11	const e: error{Foo}!u32 = error.Foo;
12	if (e) {} else \|err\| switch (err) {
13	error.Foo => \|*foo\| {
14	foo catch {};
15	},
16	}
17	}
18
19	// error
20	//
21	// :4:24: error: error set cannot be captured by reference
22	// :13:24: error: error set cannot be captured by reference

test/cases/decl_qualifier_cursor.zig created+45

...	@@ -0,0 +1,45 @@
1	const lang = @import("std").lang;
2
3	fn al() comptime_int {
4	return 16;
5	}
6
7	fn as() lang.AddressSpace {
8	return .generic;
9	}
10
11	fn ls() []const u8 {
12	return "text";
13	}
14
15	fn cc() lang.CallingConvention {
16	return .c;
17	}
18
19	fn rv() type {
20	return void;
21	}
22
23	extern var a: u64 align(al()) addrspace(as()) linksection(ls());
24	extern fn b() align(al()) addrspace(as()) linksection(ls()) callconv(cc()) rv();
25	// Intentionally not `export` so it is never analyzed since the qualifiers are
26	// not valid for all targets. The main point of this test is checking that Zir
27	// generation is done correctly for these, so the above is not an issue.
28	fn c() align(al()) addrspace(as()) linksection(ls()) callconv(cc()) rv() {
29	const v: struct {
30	x: u32,
31	y: u32,
32	} align(al()) = undefined;
33	const ta: u64, const tb: struct {
34	x: u32,
35	y: u32,
36	} align(al()) = .{ 0, .{ .x = 10, .y = 20 } };
37	_ = v;
38	_ = a;
39	_ = b;
40	_ = ta;
41	_ = tb;
42	}
43
44	// compile
45	// output_mode=Obj

test/cases/tuple_assign_cursor.zig created+13

...	@@ -0,0 +1,13 @@
1	fn T() type {
2	return u64;
3	}
4
5	test {
6	struct {
7	var a: u64 = 0;
8	}.a, const b: T() = .{ 1, 2 };
9	_ = b;
10	}
11
12	// compile
13	// output_mode=Obj