Commit 804b51b179bf7af689d308a092d1b02e94674570 | zig

author	Andrew Kelley <andrew@ziglang.org> 2020-07-15 01:38:31-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2020-07-15 02:07:30-07:00
log	804b51b179bf7af689d308a092d1b02e94674570
tree	ebc4cb661d0bbe4556de0a1659fc0dab99a8114d
parent	eac628024177434563d348272165d4e3a0a281af

stage2: VarDecl and FnProto take advantage of TrailerFlags API

These AST nodes now have a flags field and then a bunch of optional
trailing objects. The end result is lower memory usage and consequently
better performance. This is part of an ongoing effort to reduce the
amount of memory parsed ASTs take up.

Running `zig fmt` on the std lib:
 * cache-misses: 2,554,321 => 2,534,745
 * instructions: 3,293,220,119 => 3,302,479,874
 * peak memory: 74.0 MiB => 73.0 MiB

Holding the entire std lib AST in memory at the same time:

  93.9 MiB => 88.5 MiB

8 files changed, 662 insertions(+), 428 deletions(-)

lib
- std
  - meta
    trailer_flags.zig
  - zig
    ast.zig
    parse.zig
    parser_test.zig
    render.zig
src-self-hosted
- Module.zig
- translate_c.zig
test
- translate_c.zig

lib/std/meta/trailer_flags.zig+35-7

...	...	@@ -33,17 +33,30 @@ pub fn TrailerFlags(comptime Fields: type) type {
33	33	self.bits \|= 1 << field_index;
34	34	}
35	35
36		pub fn init(comptime names: anytype) Self {
	36	/// `fields` is a struct with each field set to an optional value.
	37	/// Missing fields are assumed to be `null`.
	38	/// Only the non-null bits are observed and are used to set the flag bits.
	39	pub fn init(fields: anytype) Self {
37	40	var self: Self = .{ .bits = 0 };
38		inline for (@typeInfo(@TypeOf(names)).Struct.fields) \|field\| {
39		if (@field(names, field.name)) {
40		const field_index = meta.fieldIndex(Fields, field.name).?;
41		self.bits \|= 1 << field_index;
42		}
	41	inline for (@typeInfo(@TypeOf(fields)).Struct.fields) \|field\| {
	42	const opt: ?Field(field.name) = @field(fields, field.name);
	43	const field_index = meta.fieldIndex(Fields, field.name).?;
	44	self.bits \|= @as(Int, @boolToInt(opt != null)) << field_index;
43	45	}
44	46	return self;
45	47	}
46	48
	49	/// `fields` is a struct with each field set to an optional value (same as `init`).
	50	/// Missing fields are assumed to be `null`.
	51	pub fn setMany(self: Self, p: [*]align(@alignOf(Fields)) u8, fields: anytype) void {
	52	inline for (@typeInfo(@TypeOf(fields)).Struct.fields) \|field\| {
	53	const opt: ?Field(field.name) = @field(fields, field.name);
	54	if (opt) \|value\| {
	55	self.set(p, field.name, value);
	56	}
	57	}
	58	}
	59
47	60	pub fn set(
48	61	self: Self,
49	62	p: [*]align(@alignOf(Fields)) u8,
...	...	@@ -54,11 +67,15 @@ pub fn TrailerFlags(comptime Fields: type) type {
54	67	}
55	68
56	69	pub fn ptr(self: Self, p: []align(@alignOf(Fields)) u8, comptime name: []const u8) Field(name) {
	70	if (@sizeOf(Field(name)) == 0)
	71	return undefined;
57	72	const off = self.offset(p, name);
58	73	return @ptrCast(*Field(name), @alignCast(@alignOf(Field(name)), p + off));
59	74	}
60	75
61	76	pub fn ptrConst(self: Self, p: []align(@alignOf(Fields)) const u8, comptime name: []const u8) const Field(name) {
	77	if (@sizeOf(Field(name)) == 0)
	78	return undefined;
62	79	const off = self.offset(p, name);
63	80	return @ptrCast(*const Field(name), @alignCast(@alignOf(Field(name)), p + off));
64	81	}
...	...	@@ -85,6 +102,8 @@ pub fn TrailerFlags(comptime Fields: type) type {
85	102	pub fn sizeInBytes(self: Self) usize {
86	103	var off: usize = 0;
87	104	inline for (@typeInfo(Fields).Struct.fields) \|field, i\| {
	105	if (@sizeOf(field.field_type) == 0)
	106	continue;
88	107	if ((self.bits & (1 << i)) != 0) {
89	108	off = mem.alignForwardGeneric(usize, off, @alignOf(field.field_type));
90	109	off += @sizeOf(field.field_type);
...	...	@@ -103,7 +122,7 @@ test "TrailerFlags" {
103	122	});
104	123	var flags = Flags.init(.{
105	124	.b = true,
106		.c = true,
	125	.c = 1234,
107	126	});
108	127	testing.expect(flags.sizeInBytes() == 16);
109	128	const slice = try testing.allocator.allocAdvanced(u8, 8, flags.sizeInBytes(), .exact);
...	...	@@ -115,4 +134,13 @@ test "TrailerFlags" {
115	134	testing.expect(flags.get(slice.ptr, "a") == null);
116	135	testing.expect(!flags.get(slice.ptr, "b").?);
117	136	testing.expect(flags.get(slice.ptr, "c").? == 12345678);
	137
	138	flags.setMany(slice.ptr, .{
	139	.b = true,
	140	.c = 5678,
	141	});
	142
	143	testing.expect(flags.get(slice.ptr, "a") == null);
	144	testing.expect(flags.get(slice.ptr, "b").?);
	145	testing.expect(flags.get(slice.ptr, "c").? == 5678);
118	146	}

lib/std/zig/ast.zig+159-60

...	...	@@ -675,42 +675,84 @@ pub const Node = struct {
675	675	}
676	676	};
677	677
	678	/// Trailed in memory by possibly many things, with each optional thing
	679	/// determined by a bit in `trailer_flags`.
678	680	pub const VarDecl = struct {
679	681	base: Node = Node{ .id = .VarDecl },
680		doc_comments: ?*DocComment,
681		visib_token: ?TokenIndex,
682		thread_local_token: ?TokenIndex,
683		name_token: TokenIndex,
684		eq_token: ?TokenIndex,
	682	trailer_flags: TrailerFlags,
685	683	mut_token: TokenIndex,
686		comptime_token: ?TokenIndex,
687		extern_export_token: ?TokenIndex,
688		lib_name: ?*Node,
689		type_node: ?*Node,
690		align_node: ?*Node,
691		section_node: ?*Node,
692		init_node: ?*Node,
	684	name_token: TokenIndex,
693	685	semicolon_token: TokenIndex,
694	686
	687	pub const TrailerFlags = std.meta.TrailerFlags(struct {
	688	doc_comments: *DocComment,
	689	visib_token: TokenIndex,
	690	thread_local_token: TokenIndex,
	691	eq_token: TokenIndex,
	692	comptime_token: TokenIndex,
	693	extern_export_token: TokenIndex,
	694	lib_name: *Node,
	695	type_node: *Node,
	696	align_node: *Node,
	697	section_node: *Node,
	698	init_node: *Node,
	699	});
	700
	701	pub const RequiredFields = struct {
	702	mut_token: TokenIndex,
	703	name_token: TokenIndex,
	704	semicolon_token: TokenIndex,
	705	};
	706
	707	pub fn getTrailer(self: *const VarDecl, comptime name: []const u8) ?TrailerFlags.Field(name) {
	708	const trailers_start = @ptrCast([*]const u8, self) + @sizeOf(VarDecl);
	709	return self.trailer_flags.get(trailers_start, name);
	710	}
	711
	712	pub fn setTrailer(self: *VarDecl, comptime name: []const u8, value: TrailerFlags.Field(name)) void {
	713	const trailers_start = @ptrCast([*]u8, self) + @sizeOf(VarDecl);
	714	self.trailer_flags.set(trailers_start, name, value);
	715	}
	716
	717	pub fn create(allocator: mem.Allocator, required: RequiredFields, trailers: anytype) !VarDecl {
	718	const trailer_flags = TrailerFlags.init(trailers);
	719	const bytes = try allocator.alignedAlloc(u8, @alignOf(VarDecl), sizeInBytes(trailer_flags));
	720	const var_decl = @ptrCast(*VarDecl, bytes.ptr);
	721	var_decl.* = .{
	722	.trailer_flags = trailer_flags,
	723	.mut_token = required.mut_token,
	724	.name_token = required.name_token,
	725	.semicolon_token = required.semicolon_token,
	726	};
	727	const trailers_start = bytes.ptr + @sizeOf(VarDecl);
	728	trailer_flags.setMany(trailers_start, trailers);
	729	return var_decl;
	730	}
	731
	732	pub fn destroy(self: VarDecl, allocator: mem.Allocator) void {
	733	const bytes = @ptrCast([*]u8, self)[0..sizeInBytes(self.trailer_flags)];
	734	allocator.free(bytes);
	735	}
	736
695	737	pub fn iterate(self: const VarDecl, index: usize) ?Node {
696	738	var i = index;
697	739
698		if (self.type_node) \|type_node\| {
	740	if (self.getTrailer("type_node")) \|type_node\| {
699	741	if (i < 1) return type_node;
700	742	i -= 1;
701	743	}
702	744
703		if (self.align_node) \|align_node\| {
	745	if (self.getTrailer("align_node")) \|align_node\| {
704	746	if (i < 1) return align_node;
705	747	i -= 1;
706	748	}
707	749
708		if (self.section_node) \|section_node\| {
	750	if (self.getTrailer("section_node")) \|section_node\| {
709	751	if (i < 1) return section_node;
710	752	i -= 1;
711	753	}
712	754
713		if (self.init_node) \|init_node\| {
	755	if (self.getTrailer("init_node")) \|init_node\| {
714	756	if (i < 1) return init_node;
715	757	i -= 1;
716	758	}
...	...	@@ -719,17 +761,21 @@ pub const Node = struct {
719	761	}
720	762
721	763	pub fn firstToken(self: *const VarDecl) TokenIndex {
722		if (self.visib_token) \|visib_token\| return visib_token;
723		if (self.thread_local_token) \|thread_local_token\| return thread_local_token;
724		if (self.comptime_token) \|comptime_token\| return comptime_token;
725		if (self.extern_export_token) \|extern_export_token\| return extern_export_token;
726		assert(self.lib_name == null);
	764	if (self.getTrailer("visib_token")) \|visib_token\| return visib_token;
	765	if (self.getTrailer("thread_local_token")) \|thread_local_token\| return thread_local_token;
	766	if (self.getTrailer("comptime_token")) \|comptime_token\| return comptime_token;
	767	if (self.getTrailer("extern_export_token")) \|extern_export_token\| return extern_export_token;
	768	assert(self.getTrailer("lib_name") == null);
727	769	return self.mut_token;
728	770	}
729	771
730	772	pub fn lastToken(self: *const VarDecl) TokenIndex {
731	773	return self.semicolon_token;
732	774	}
	775
	776	fn sizeInBytes(trailer_flags: TrailerFlags) usize {
	777	return @sizeOf(VarDecl) + trailer_flags.sizeInBytes();
	778	}
733	779	};
734	780
735	781	pub const Use = struct {
...	...	@@ -972,25 +1018,34 @@ pub const Node = struct {
972	1018	};
973	1019
974	1020	/// The params are directly after the FnProto in memory.
975		/// TODO have a flags field for the optional nodes, and have them appended
976		/// before or after the parameters in memory.
	1021	/// Next, each optional thing determined by a bit in `trailer_flags`.
977	1022	pub const FnProto = struct {
978	1023	base: Node = Node{ .id = .FnProto },
979		doc_comments: ?*DocComment,
980		visib_token: ?TokenIndex,
	1024	trailer_flags: TrailerFlags,
981	1025	fn_token: TokenIndex,
982		name_token: ?TokenIndex,
983	1026	params_len: NodeIndex,
984	1027	return_type: ReturnType,
985		var_args_token: ?TokenIndex,
986		extern_export_inline_token: ?TokenIndex,
987		body_node: ?*Node,
988		lib_name: ?*Node, // populated if this is an extern declaration
989		align_expr: ?*Node, // populated if align(A) is present
990		section_expr: ?*Node, // populated if linksection(A) is present
991		callconv_expr: ?*Node, // populated if callconv(A) is present
992		is_extern_prototype: bool = false, // TODO: Remove once extern fn rewriting is
993		is_async: bool = false, // TODO: remove once async fn rewriting is
	1028
	1029	pub const TrailerFlags = std.meta.TrailerFlags(struct {
	1030	doc_comments: *DocComment,
	1031	body_node: *Node,
	1032	lib_name: *Node, // populated if this is an extern declaration
	1033	align_expr: *Node, // populated if align(A) is present
	1034	section_expr: *Node, // populated if linksection(A) is present
	1035	callconv_expr: *Node, // populated if callconv(A) is present
	1036	visib_token: TokenIndex,
	1037	name_token: TokenIndex,
	1038	var_args_token: TokenIndex,
	1039	extern_export_inline_token: TokenIndex,
	1040	is_extern_prototype: void, // TODO: Remove once extern fn rewriting is
	1041	is_async: void, // TODO: remove once async fn rewriting is
	1042	});
	1043
	1044	pub const RequiredFields = struct {
	1045	fn_token: TokenIndex,
	1046	params_len: NodeIndex,
	1047	return_type: ReturnType,
	1048	};
994	1049
995	1050	pub const ReturnType = union(enum) {
996	1051	Explicit: *Node,
...	...	@@ -1007,7 +1062,6 @@ pub const Node = struct {
1007	1062
1008	1063	pub const ParamType = union(enum) {
1009	1064	any_type: *Node,
1010		var_args: TokenIndex,
1011	1065	type_expr: *Node,
1012	1066	};
1013	1067
...	...	@@ -1016,7 +1070,6 @@ pub const Node = struct {
1016	1070
1017	1071	if (i < 1) {
1018	1072	switch (self.param_type) {
1019		.var_args => return null,
1020	1073	.any_type, .type_expr => \|node\| return node,
1021	1074	}
1022	1075	}
...	...	@@ -1030,34 +1083,79 @@ pub const Node = struct {
1030	1083	if (self.noalias_token) \|noalias_token\| return noalias_token;
1031	1084	if (self.name_token) \|name_token\| return name_token;
1032	1085	switch (self.param_type) {
1033		.var_args => \|tok\| return tok,
1034	1086	.any_type, .type_expr => \|node\| return node.firstToken(),
1035	1087	}
1036	1088	}
1037	1089
1038	1090	pub fn lastToken(self: *const ParamDecl) TokenIndex {
1039	1091	switch (self.param_type) {
1040		.var_args => \|tok\| return tok,
1041	1092	.any_type, .type_expr => \|node\| return node.lastToken(),
1042	1093	}
1043	1094	}
1044	1095	};
1045	1096
	1097	/// For debugging purposes.
	1098	pub fn dump(self: *const FnProto) void {
	1099	const trailers_start = @alignCast(
	1100	@alignOf(ParamDecl),
	1101	@ptrCast([]const u8, self) + @sizeOf(FnProto) + @sizeOf(ParamDecl) self.params_len,
	1102	);
	1103	std.debug.print("{} flags: {b} name_token: {} {} params_len: {}\n", .{
	1104	self,
	1105	self.trailer_flags.bits,
	1106	self.getTrailer("name_token"),
	1107	self.trailer_flags.ptrConst(trailers_start, "name_token"),
	1108	self.params_len,
	1109	});
	1110	}
	1111
	1112	pub fn getTrailer(self: *const FnProto, comptime name: []const u8) ?TrailerFlags.Field(name) {
	1113	const trailers_start = @alignCast(
	1114	@alignOf(ParamDecl),
	1115	@ptrCast([]const u8, self) + @sizeOf(FnProto) + @sizeOf(ParamDecl) self.params_len,
	1116	);
	1117	return self.trailer_flags.get(trailers_start, name);
	1118	}
	1119
	1120	pub fn setTrailer(self: *FnProto, comptime name: []const u8, value: TrailerFlags.Field(name)) void {
	1121	const trailers_start = @alignCast(
	1122	@alignOf(ParamDecl),
	1123	@ptrCast([]u8, self) + @sizeOf(FnProto) + @sizeOf(ParamDecl) self.params_len,
	1124	);
	1125	self.trailer_flags.set(trailers_start, name, value);
	1126	}
	1127
1046	1128	/// After this the caller must initialize the params list.
1047		pub fn alloc(allocator: mem.Allocator, params_len: NodeIndex) !FnProto {
1048		const bytes = try allocator.alignedAlloc(u8, @alignOf(FnProto), sizeInBytes(params_len));
1049		return @ptrCast(*FnProto, bytes.ptr);
	1129	pub fn create(allocator: mem.Allocator, required: RequiredFields, trailers: anytype) !FnProto {
	1130	const trailer_flags = TrailerFlags.init(trailers);
	1131	const bytes = try allocator.alignedAlloc(u8, @alignOf(FnProto), sizeInBytes(
	1132	required.params_len,
	1133	trailer_flags,
	1134	));
	1135	const fn_proto = @ptrCast(*FnProto, bytes.ptr);
	1136	fn_proto.* = .{
	1137	.trailer_flags = trailer_flags,
	1138	.fn_token = required.fn_token,
	1139	.params_len = required.params_len,
	1140	.return_type = required.return_type,
	1141	};
	1142	const trailers_start = @alignCast(
	1143	@alignOf(ParamDecl),
	1144	bytes.ptr + @sizeOf(FnProto) + @sizeOf(ParamDecl) * required.params_len,
	1145	);
	1146	trailer_flags.setMany(trailers_start, trailers);
	1147	return fn_proto;
1050	1148	}
1051	1149
1052		pub fn free(self: FnProto, allocator: mem.Allocator) void {
1053		const bytes = @ptrCast([*]u8, self)[0..sizeInBytes(self.params_len)];
	1150	pub fn destroy(self: FnProto, allocator: mem.Allocator) void {
	1151	const bytes = @ptrCast([*]u8, self)[0..sizeInBytes(self.params_len, self.trailer_flags)];
1054	1152	allocator.free(bytes);
1055	1153	}
1056	1154
1057	1155	pub fn iterate(self: const FnProto, index: usize) ?Node {
1058	1156	var i = index;
1059	1157
1060		if (self.lib_name) \|lib_name\| {
	1158	if (self.getTrailer("lib_name")) \|lib_name\| {
1061	1159	if (i < 1) return lib_name;
1062	1160	i -= 1;
1063	1161	}
...	...	@@ -1066,23 +1164,21 @@ pub const Node = struct {
1066	1164	0
1067	1165	else switch (self.paramsConst()[self.params_len - 1].param_type) {
1068	1166	.any_type, .type_expr => self.params_len,
1069		.var_args => self.params_len - 1,
1070	1167	};
1071	1168	if (i < params_len) {
1072	1169	switch (self.paramsConst()[i].param_type) {
1073	1170	.any_type => \|n\| return n,
1074		.var_args => unreachable,
1075	1171	.type_expr => \|n\| return n,
1076	1172	}
1077	1173	}
1078	1174	i -= params_len;
1079	1175
1080		if (self.align_expr) \|align_expr\| {
	1176	if (self.getTrailer("align_expr")) \|align_expr\| {
1081	1177	if (i < 1) return align_expr;
1082	1178	i -= 1;
1083	1179	}
1084	1180
1085		if (self.section_expr) \|section_expr\| {
	1181	if (self.getTrailer("section_expr")) \|section_expr\| {
1086	1182	if (i < 1) return section_expr;
1087	1183	i -= 1;
1088	1184	}
...	...	@@ -1095,7 +1191,7 @@ pub const Node = struct {
1095	1191	.Invalid => {},
1096	1192	}
1097	1193
1098		if (self.body_node) \|body_node\| {
	1194	if (self.getTrailer("body_node")) \|body_node\| {
1099	1195	if (i < 1) return body_node;
1100	1196	i -= 1;
1101	1197	}
...	...	@@ -1104,14 +1200,14 @@ pub const Node = struct {
1104	1200	}
1105	1201
1106	1202	pub fn firstToken(self: *const FnProto) TokenIndex {
1107		if (self.visib_token) \|visib_token\| return visib_token;
1108		if (self.extern_export_inline_token) \|extern_export_inline_token\| return extern_export_inline_token;
1109		assert(self.lib_name == null);
	1203	if (self.getTrailer("visib_token")) \|visib_token\| return visib_token;
	1204	if (self.getTrailer("extern_export_inline_token")) \|extern_export_inline_token\| return extern_export_inline_token;
	1205	assert(self.getTrailer("lib_name") == null);
1110	1206	return self.fn_token;
1111	1207	}
1112	1208
1113	1209	pub fn lastToken(self: *const FnProto) TokenIndex {
1114		if (self.body_node) \|body_node\| return body_node.lastToken();
	1210	if (self.getTrailer("body_node")) \|body_node\| return body_node.lastToken();
1115	1211	switch (self.return_type) {
1116	1212	.Explicit, .InferErrorSet => \|node\| return node.lastToken(),
1117	1213	.Invalid => \|tok\| return tok,
...	...	@@ -1119,17 +1215,17 @@ pub const Node = struct {
1119	1215	}
1120	1216
1121	1217	pub fn params(self: *FnProto) []ParamDecl {
1122		const decls_start = @ptrCast([*]u8, self) + @sizeOf(FnProto);
1123		return @ptrCast([*]ParamDecl, decls_start)[0..self.params_len];
	1218	const params_start = @ptrCast([*]u8, self) + @sizeOf(FnProto);
	1219	return @ptrCast([*]ParamDecl, params_start)[0..self.params_len];
1124	1220	}
1125	1221
1126	1222	pub fn paramsConst(self: *const FnProto) []const ParamDecl {
1127		const decls_start = @ptrCast([*]const u8, self) + @sizeOf(FnProto);
1128		return @ptrCast([*]const ParamDecl, decls_start)[0..self.params_len];
	1223	const params_start = @ptrCast([*]const u8, self) + @sizeOf(FnProto);
	1224	return @ptrCast([*]const ParamDecl, params_start)[0..self.params_len];
1129	1225	}
1130	1226
1131		fn sizeInBytes(params_len: NodeIndex) usize {
1132		return @sizeOf(FnProto) + @sizeOf(ParamDecl) * @as(usize, params_len);
	1227	fn sizeInBytes(params_len: NodeIndex, trailer_flags: TrailerFlags) usize {
	1228	return @sizeOf(FnProto) + @sizeOf(ParamDecl) * @as(usize, params_len) + trailer_flags.sizeInBytes();
1133	1229	}
1134	1230	};
1135	1231
...	...	@@ -2829,6 +2925,9 @@ pub const Node = struct {
2829	2925	}
2830	2926	};
2831	2927
	2928	/// TODO remove from the Node base struct
	2929	/// TODO actually maybe remove entirely in favor of iterating backward from Node.firstToken()
	2930	/// and forwards to find same-line doc comments.
2832	2931	pub const DocComment = struct {
2833	2932	base: Node = Node{ .id = .DocComment },
2834	2933	/// Points to the first doc comment token. API users are expected to iterate over the

lib/std/zig/parse.zig+92-100

...	...	@@ -150,7 +150,7 @@ const Parser = struct {
150	150
151	151	const visib_token = p.eatToken(.Keyword_pub);
152	152
153		if (p.parseTopLevelDecl() catch \|err\| switch (err) {
	153	if (p.parseTopLevelDecl(doc_comments, visib_token) catch \|err\| switch (err) {
154	154	error.OutOfMemory => return error.OutOfMemory,
155	155	error.ParseError => {
156	156	p.findNextContainerMember();
...	...	@@ -160,30 +160,7 @@ const Parser = struct {
160	160	if (field_state == .seen) {
161	161	field_state = .{ .end = visib_token orelse node.firstToken() };
162	162	}
163		switch (node.id) {
164		.FnProto => {
165		node.cast(Node.FnProto).?.doc_comments = doc_comments;
166		node.cast(Node.FnProto).?.visib_token = visib_token;
167		},
168		.VarDecl => {
169		node.cast(Node.VarDecl).?.doc_comments = doc_comments;
170		node.cast(Node.VarDecl).?.visib_token = visib_token;
171		},
172		.Use => {
173		node.cast(Node.Use).?.doc_comments = doc_comments;
174		node.cast(Node.Use).?.visib_token = visib_token;
175		},
176		else => unreachable,
177		}
178	163	try list.append(node);
179		if (try p.parseAppendedDocComment(node.lastToken())) \|appended_comment\| {
180		switch (node.id) {
181		.FnProto => {},
182		.VarDecl => node.cast(Node.VarDecl).?.doc_comments = appended_comment,
183		.Use => node.cast(Node.Use).?.doc_comments = appended_comment,
184		else => unreachable,
185		}
186		}
187	164	continue;
188	165	}
189	166
...	...	@@ -417,7 +394,7 @@ const Parser = struct {
417	394	/// <- (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE? / (KEYWORD_inline / KEYWORD_noinline))? FnProto (SEMICOLON / Block)
418	395	/// / (KEYWORD_export / KEYWORD_extern STRINGLITERALSINGLE?)? KEYWORD_threadlocal? VarDecl
419	396	/// / KEYWORD_usingnamespace Expr SEMICOLON
420		fn parseTopLevelDecl(p: Parser) !?Node {
	397	fn parseTopLevelDecl(p: Parser, doc_comments: ?Node.DocComment, visib_token: ?TokenIndex) !?*Node {
421	398	var lib_name: ?*Node = null;
422	399	const extern_export_inline_token = blk: {
423	400	if (p.eatToken(.Keyword_export)) \|token\| break :blk token;
...	...	@@ -430,20 +407,12 @@ const Parser = struct {
430	407	break :blk null;
431	408	};
432	409
433		if (try p.parseFnProto()) \|node\| {
434		const fn_node = node.cast(Node.FnProto).?;
435		fn_node.*.extern_export_inline_token = extern_export_inline_token;
436		fn_node.*.lib_name = lib_name;
437		if (p.eatToken(.Semicolon)) \|_\| return node;
438
439		if (try p.expectNodeRecoverable(parseBlock, .{
440		// since parseBlock only return error.ParseError on
441		// a missing '}' we can assume this function was
442		// supposed to end here.
443		.ExpectedSemiOrLBrace = .{ .token = p.tok_i },
444		})) \|body_node\| {
445		fn_node.body_node = body_node;
446		}
	410	if (try p.parseFnProto(.top_level, .{
	411	.doc_comments = doc_comments,
	412	.visib_token = visib_token,
	413	.extern_export_inline_token = extern_export_inline_token,
	414	.lib_name = lib_name,
	415	})) \|node\| {
447	416	return node;
448	417	}
449	418
...	...	@@ -460,12 +429,13 @@ const Parser = struct {
460	429
461	430	const thread_local_token = p.eatToken(.Keyword_threadlocal);
462	431
463		if (try p.parseVarDecl()) \|node\| {
464		var var_decl = node.cast(Node.VarDecl).?;
465		var_decl.*.thread_local_token = thread_local_token;
466		var_decl.*.comptime_token = null;
467		var_decl.*.extern_export_token = extern_export_inline_token;
468		var_decl.*.lib_name = lib_name;
	432	if (try p.parseVarDecl(.{
	433	.doc_comments = doc_comments,
	434	.visib_token = visib_token,
	435	.thread_local_token = thread_local_token,
	436	.extern_export_token = extern_export_inline_token,
	437	.lib_name = lib_name,
	438	})) \|node\| {
469	439	return node;
470	440	}
471	441
...	...	@@ -485,21 +455,41 @@ const Parser = struct {
485	455	return error.ParseError;
486	456	}
487	457
488		return p.parseUse();
	458	const use_token = p.eatToken(.Keyword_usingnamespace) orelse return null;
	459	const expr = try p.expectNode(parseExpr, .{
	460	.ExpectedExpr = .{ .token = p.tok_i },
	461	});
	462	const semicolon_token = try p.expectToken(.Semicolon);
	463
	464	const node = try p.arena.allocator.create(Node.Use);
	465	node.* = .{
	466	.doc_comments = doc_comments orelse try p.parseAppendedDocComment(semicolon_token),
	467	.visib_token = visib_token,
	468	.use_token = use_token,
	469	.expr = expr,
	470	.semicolon_token = semicolon_token,
	471	};
	472
	473	return &node.base;
489	474	}
490	475
491	476	/// FnProto <- KEYWORD_fn IDENTIFIER? LPAREN ParamDeclList RPAREN ByteAlign? LinkSection? EXCLAMATIONMARK? (Keyword_anytype / TypeExpr)
492		fn parseFnProto(p: Parser) !?Node {
	477	fn parseFnProto(p: *Parser, level: enum { top_level, as_type }, fields: struct {
	478	doc_comments: ?*Node.DocComment = null,
	479	visib_token: ?TokenIndex = null,
	480	extern_export_inline_token: ?TokenIndex = null,
	481	lib_name: ?*Node = null,
	482	}) !?*Node {
493	483	// TODO: Remove once extern/async fn rewriting is
494		var is_async = false;
495		var is_extern = false;
	484	var is_async: ?void = null;
	485	var is_extern_prototype: ?void = null;
496	486	const cc_token: ?TokenIndex = blk: {
497	487	if (p.eatToken(.Keyword_extern)) \|token\| {
498		is_extern = true;
	488	is_extern_prototype = {};
499	489	break :blk token;
500	490	}
501	491	if (p.eatToken(.Keyword_async)) \|token\| {
502		is_async = true;
	492	is_async = {};
503	493	break :blk token;
504	494	}
505	495	break :blk null;
...	...	@@ -513,6 +503,7 @@ const Parser = struct {
513	503	const lparen = try p.expectToken(.LParen);
514	504	const params = try p.parseParamDeclList();
515	505	defer p.gpa.free(params);
	506	const var_args_token = p.eatToken(.Ellipsis3);
516	507	const rparen = try p.expectToken(.RParen);
517	508	const align_expr = try p.parseByteAlign();
518	509	const section_expr = try p.parseLinkSection();
...	...	@@ -535,37 +526,53 @@ const Parser = struct {
535	526	else
536	527	R{ .Explicit = return_type_expr.? };
537	528
538		const var_args_token = if (params.len > 0) blk: {
539		const param_type = params[params.len - 1].param_type;
540		break :blk if (param_type == .var_args) param_type.var_args else null;
541		} else
542		null;
	529	const body_node: ?*Node = switch (level) {
	530	.top_level => blk: {
	531	if (p.eatToken(.Semicolon)) \|_\| {
	532	break :blk null;
	533	}
	534	break :blk try p.expectNodeRecoverable(parseBlock, .{
	535	// Since parseBlock only return error.ParseError on
	536	// a missing '}' we can assume this function was
	537	// supposed to end here.
	538	.ExpectedSemiOrLBrace = .{ .token = p.tok_i },
	539	});
	540	},
	541	.as_type => null,
	542	};
543	543
544		const fn_proto_node = try Node.FnProto.alloc(&p.arena.allocator, params.len);
545		fn_proto_node.* = .{
546		.doc_comments = null,
547		.visib_token = null,
548		.fn_token = fn_token,
549		.name_token = name_token,
	544	const fn_proto_node = try Node.FnProto.create(&p.arena.allocator, .{
550	545	.params_len = params.len,
	546	.fn_token = fn_token,
551	547	.return_type = return_type,
	548	}, .{
	549	.doc_comments = fields.doc_comments,
	550	.visib_token = fields.visib_token,
	551	.name_token = name_token,
552	552	.var_args_token = var_args_token,
553		.extern_export_inline_token = null,
554		.body_node = null,
555		.lib_name = null,
	553	.extern_export_inline_token = fields.extern_export_inline_token,
	554	.body_node = body_node,
	555	.lib_name = fields.lib_name,
556	556	.align_expr = align_expr,
557	557	.section_expr = section_expr,
558	558	.callconv_expr = callconv_expr,
559		.is_extern_prototype = is_extern,
	559	.is_extern_prototype = is_extern_prototype,
560	560	.is_async = is_async,
561		};
	561	});
562	562	std.mem.copy(Node.FnProto.ParamDecl, fn_proto_node.params(), params);
563	563
564	564	return &fn_proto_node.base;
565	565	}
566	566
567	567	/// VarDecl <- (KEYWORD_const / KEYWORD_var) IDENTIFIER (COLON TypeExpr)? ByteAlign? LinkSection? (EQUAL Expr)? SEMICOLON
568		fn parseVarDecl(p: Parser) !?Node {
	568	fn parseVarDecl(p: *Parser, fields: struct {
	569	doc_comments: ?*Node.DocComment = null,
	570	visib_token: ?TokenIndex = null,
	571	thread_local_token: ?TokenIndex = null,
	572	extern_export_token: ?TokenIndex = null,
	573	lib_name: ?*Node = null,
	574	comptime_token: ?TokenIndex = null,
	575	}) !?*Node {
569	576	const mut_token = p.eatToken(.Keyword_const) orelse
570	577	p.eatToken(.Keyword_var) orelse
571	578	return null;
...	...	@@ -587,23 +594,25 @@ const Parser = struct {
587	594	} else null;
588	595	const semicolon_token = try p.expectToken(.Semicolon);
589	596
590		const node = try p.arena.allocator.create(Node.VarDecl);
591		node.* = .{
592		.doc_comments = null,
593		.visib_token = null,
594		.thread_local_token = null,
	597	const doc_comments = fields.doc_comments orelse try p.parseAppendedDocComment(semicolon_token);
	598
	599	const node = try Node.VarDecl.create(&p.arena.allocator, .{
	600	.mut_token = mut_token,
595	601	.name_token = name_token,
	602	.semicolon_token = semicolon_token,
	603	}, .{
	604	.doc_comments = doc_comments,
	605	.visib_token = fields.visib_token,
	606	.thread_local_token = fields.thread_local_token,
596	607	.eq_token = eq_token,
597		.mut_token = mut_token,
598		.comptime_token = null,
599		.extern_export_token = null,
600		.lib_name = null,
	608	.comptime_token = fields.comptime_token,
	609	.extern_export_token = fields.extern_export_token,
	610	.lib_name = fields.lib_name,
601	611	.type_node = type_node,
602	612	.align_node = align_node,
603	613	.section_node = section_node,
604	614	.init_node = init_node,
605		.semicolon_token = semicolon_token,
606		};
	615	});
607	616	return &node.base;
608	617	}
609	618
...	...	@@ -663,10 +672,9 @@ const Parser = struct {
663	672	fn parseStatement(p: Parser) Error!?Node {
664	673	const comptime_token = p.eatToken(.Keyword_comptime);
665	674
666		const var_decl_node = try p.parseVarDecl();
667		if (var_decl_node) \|node\| {
668		const var_decl = node.cast(Node.VarDecl).?;
669		var_decl.comptime_token = comptime_token;
	675	if (try p.parseVarDecl(.{
	676	.comptime_token = comptime_token,
	677	})) \|node\| {
670	678	return node;
671	679	}
672	680
...	...	@@ -1527,7 +1535,7 @@ const Parser = struct {
1527	1535	if (try p.parseAnonLiteral()) \|node\| return node;
1528	1536	if (try p.parseErrorSetDecl()) \|node\| return node;
1529	1537	if (try p.parseFloatLiteral()) \|node\| return node;
1530		if (try p.parseFnProto()) \|node\| return node;
	1538	if (try p.parseFnProto(.as_type, .{})) \|node\| return node;
1531	1539	if (try p.parseGroupedExpr()) \|node\| return node;
1532	1540	if (try p.parseLabeledTypeExpr()) \|node\| return node;
1533	1541	if (try p.parseIdentifier()) \|node\| return node;
...	...	@@ -2028,7 +2036,6 @@ const Parser = struct {
2028	2036	// TODO cast from tuple to error union is broken
2029	2037	const P = Node.FnProto.ParamDecl.ParamType;
2030	2038	if (try p.parseAnyType()) \|node\| return P{ .any_type = node };
2031		if (p.eatToken(.Ellipsis3)) \|token\| return P{ .var_args = token };
2032	2039	if (try p.parseTypeExpr()) \|node\| return P{ .type_expr = node };
2033	2040	return null;
2034	2041	}
...	...	@@ -3149,21 +3156,6 @@ const Parser = struct {
3149	3156	return &node.base;
3150	3157	}
3151	3158
3152		fn parseUse(p: Parser) !?Node {
3153		const token = p.eatToken(.Keyword_usingnamespace) orelse return null;
3154		const node = try p.arena.allocator.create(Node.Use);
3155		node.* = .{
3156		.doc_comments = null,
3157		.visib_token = null,
3158		.use_token = token,
3159		.expr = try p.expectNode(parseExpr, .{
3160		.ExpectedExpr = .{ .token = p.tok_i },
3161		}),
3162		.semicolon_token = try p.expectToken(.Semicolon),
3163		};
3164		return &node.base;
3165		}
3166
3167	3159	/// IfPrefix Body (KEYWORD_else Payload? Body)?
3168	3160	fn parseIf(p: Parser, bodyParseFn: NodeParseFn) !?Node {
3169	3161	const node = (try p.parseIfPrefix()) orelse return null;

lib/std/zig/parser_test.zig+32-27

...	...	@@ -1,4 +1,32 @@
1		const builtin = @import("builtin");
	1	test "zig fmt: convert var to anytype" {
	2	// TODO remove in next release cycle
	3	try testTransform(
	4	\\pub fn main(
	5	\\ a: var,
	6	\\ bar: var,
	7	\\) void {}
	8	,
	9	\\pub fn main(
	10	\\ a: anytype,
	11	\\ bar: anytype,
	12	\\) void {}
	13	\\
	14	);
	15	}
	16
	17	test "zig fmt: noasync to nosuspend" {
	18	// TODO: remove this
	19	try testTransform(
	20	\\pub fn main() void {
	21	\\ noasync call();
	22	\\}
	23	,
	24	\\pub fn main() void {
	25	\\ nosuspend call();
	26	\\}
	27	\\
	28	);
	29	}
2	30
3	31	test "recovery: top level" {
4	32	try testError(
...	...	@@ -3146,20 +3174,6 @@ test "zig fmt: hexadeciaml float literals with underscore separators" {
3146	3174	);
3147	3175	}
3148	3176
3149		test "zig fmt: noasync to nosuspend" {
3150		// TODO: remove this
3151		try testTransform(
3152		\\pub fn main() void {
3153		\\ noasync call();
3154		\\}
3155		,
3156		\\pub fn main() void {
3157		\\ nosuspend call();
3158		\\}
3159		\\
3160		);
3161		}
3162
3163	3177	test "zig fmt: convert async fn into callconv(.Async)" {
3164	3178	try testTransform(
3165	3179	\\async fn foo() void {}
...	...	@@ -3180,18 +3194,9 @@ test "zig fmt: convert extern fn proto into callconv(.C)" {
3180	3194	);
3181	3195	}
3182	3196
3183		test "zig fmt: convert var to anytype" {
3184		// TODO remove in next release cycle
3185		try testTransform(
3186		\\pub fn main(
3187		\\ a: var,
3188		\\ bar: var,
3189		\\) void {}
3190		,
3191		\\pub fn main(
3192		\\ a: anytype,
3193		\\ bar: anytype,
3194		\\) void {}
	3197	test "zig fmt: C var args" {
	3198	try testCanonical(
	3199	\\pub extern "c" fn printf(format: [*:0]const u8, ...) c_int;
3195	3200	\\
3196	3201	);
3197	3202	}

lib/std/zig/render.zig+52-40

...	...	@@ -227,9 +227,9 @@ fn renderContainerDecl(allocator: mem.Allocator, stream: anytype, tree: ast.Tr
227	227	.FnProto => {
228	228	const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", decl);
229	229
230		try renderDocComments(tree, stream, fn_proto, indent, start_col);
	230	try renderDocComments(tree, stream, fn_proto, fn_proto.getTrailer("doc_comments"), indent, start_col);
231	231
232		if (fn_proto.body_node) \|body_node\| {
	232	if (fn_proto.getTrailer("body_node")) \|body_node\| {
233	233	try renderExpression(allocator, stream, tree, indent, start_col, decl, .Space);
234	234	try renderExpression(allocator, stream, tree, indent, start_col, body_node, space);
235	235	} else {
...	...	@@ -252,14 +252,14 @@ fn renderContainerDecl(allocator: mem.Allocator, stream: anytype, tree: ast.Tr
252	252	.VarDecl => {
253	253	const var_decl = @fieldParentPtr(ast.Node.VarDecl, "base", decl);
254	254
255		try renderDocComments(tree, stream, var_decl, indent, start_col);
	255	try renderDocComments(tree, stream, var_decl, var_decl.getTrailer("doc_comments"), indent, start_col);
256	256	try renderVarDecl(allocator, stream, tree, indent, start_col, var_decl);
257	257	},
258	258
259	259	.TestDecl => {
260	260	const test_decl = @fieldParentPtr(ast.Node.TestDecl, "base", decl);
261	261
262		try renderDocComments(tree, stream, test_decl, indent, start_col);
	262	try renderDocComments(tree, stream, test_decl, test_decl.doc_comments, indent, start_col);
263	263	try renderToken(tree, stream, test_decl.test_token, indent, start_col, .Space);
264	264	try renderExpression(allocator, stream, tree, indent, start_col, test_decl.name, .Space);
265	265	try renderExpression(allocator, stream, tree, indent, start_col, test_decl.body_node, space);
...	...	@@ -268,7 +268,7 @@ fn renderContainerDecl(allocator: mem.Allocator, stream: anytype, tree: ast.Tr
268	268	.ContainerField => {
269	269	const field = @fieldParentPtr(ast.Node.ContainerField, "base", decl);
270	270
271		try renderDocComments(tree, stream, field, indent, start_col);
	271	try renderDocComments(tree, stream, field, field.doc_comments, indent, start_col);
272	272	if (field.comptime_token) \|t\| {
273	273	try renderToken(tree, stream, t, indent, start_col, .Space); // comptime
274	274	}
...	...	@@ -1409,7 +1409,7 @@ fn renderExpression(
1409	1409	.ErrorTag => {
1410	1410	const tag = @fieldParentPtr(ast.Node.ErrorTag, "base", base);
1411	1411
1412		try renderDocComments(tree, stream, tag, indent, start_col);
	1412	try renderDocComments(tree, stream, tag, tag.doc_comments, indent, start_col);
1413	1413	return renderToken(tree, stream, tag.name_token, indent, start_col, space); // name
1414	1414	},
1415	1415
...	...	@@ -1483,23 +1483,23 @@ fn renderExpression(
1483	1483	.FnProto => {
1484	1484	const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", base);
1485	1485
1486		if (fn_proto.visib_token) \|visib_token_index\| {
	1486	if (fn_proto.getTrailer("visib_token")) \|visib_token_index\| {
1487	1487	const visib_token = tree.token_ids[visib_token_index];
1488	1488	assert(visib_token == .Keyword_pub or visib_token == .Keyword_export);
1489	1489
1490	1490	try renderToken(tree, stream, visib_token_index, indent, start_col, Space.Space); // pub
1491	1491	}
1492	1492
1493		if (fn_proto.extern_export_inline_token) \|extern_export_inline_token\| {
1494		if (!fn_proto.is_extern_prototype)
	1493	if (fn_proto.getTrailer("extern_export_inline_token")) \|extern_export_inline_token\| {
	1494	if (fn_proto.getTrailer("is_extern_prototype") == null)
1495	1495	try renderToken(tree, stream, extern_export_inline_token, indent, start_col, Space.Space); // extern/export/inline
1496	1496	}
1497	1497
1498		if (fn_proto.lib_name) \|lib_name\| {
	1498	if (fn_proto.getTrailer("lib_name")) \|lib_name\| {
1499	1499	try renderExpression(allocator, stream, tree, indent, start_col, lib_name, Space.Space);
1500	1500	}
1501	1501
1502		const lparen = if (fn_proto.name_token) \|name_token\| blk: {
	1502	const lparen = if (fn_proto.getTrailer("name_token")) \|name_token\| blk: {
1503	1503	try renderToken(tree, stream, fn_proto.fn_token, indent, start_col, Space.Space); // fn
1504	1504	try renderToken(tree, stream, name_token, indent, start_col, Space.None); // name
1505	1505	break :blk tree.nextToken(name_token);
...	...	@@ -1512,11 +1512,11 @@ fn renderExpression(
1512	1512	const rparen = tree.prevToken(
1513	1513	// the first token for the annotation expressions is the left
1514	1514	// parenthesis, hence the need for two prevToken
1515		if (fn_proto.align_expr) \|align_expr\|
	1515	if (fn_proto.getTrailer("align_expr")) \|align_expr\|
1516	1516	tree.prevToken(tree.prevToken(align_expr.firstToken()))
1517		else if (fn_proto.section_expr) \|section_expr\|
	1517	else if (fn_proto.getTrailer("section_expr")) \|section_expr\|
1518	1518	tree.prevToken(tree.prevToken(section_expr.firstToken()))
1519		else if (fn_proto.callconv_expr) \|callconv_expr\|
	1519	else if (fn_proto.getTrailer("callconv_expr")) \|callconv_expr\|
1520	1520	tree.prevToken(tree.prevToken(callconv_expr.firstToken()))
1521	1521	else switch (fn_proto.return_type) {
1522	1522	.Explicit => \|node\| node.firstToken(),
...	...	@@ -1537,11 +1537,14 @@ fn renderExpression(
1537	1537	for (fn_proto.params()) \|param_decl, i\| {
1538	1538	try renderParamDecl(allocator, stream, tree, indent, start_col, param_decl, Space.None);
1539	1539
1540		if (i + 1 < fn_proto.params_len) {
	1540	if (i + 1 < fn_proto.params_len or fn_proto.getTrailer("var_args_token") != null) {
1541	1541	const comma = tree.nextToken(param_decl.lastToken());
1542	1542	try renderToken(tree, stream, comma, indent, start_col, Space.Space); // ,
1543	1543	}
1544	1544	}
	1545	if (fn_proto.getTrailer("var_args_token")) \|var_args_token\| {
	1546	try renderToken(tree, stream, var_args_token, indent, start_col, Space.None);
	1547	}
1545	1548	} else {
1546	1549	// one param per line
1547	1550	const new_indent = indent + indent_delta;
...	...	@@ -1551,12 +1554,16 @@ fn renderExpression(
1551	1554	try stream.writeByteNTimes(' ', new_indent);
1552	1555	try renderParamDecl(allocator, stream, tree, new_indent, start_col, param_decl, Space.Comma);
1553	1556	}
	1557	if (fn_proto.getTrailer("var_args_token")) \|var_args_token\| {
	1558	try stream.writeByteNTimes(' ', new_indent);
	1559	try renderToken(tree, stream, var_args_token, new_indent, start_col, Space.Comma);
	1560	}
1554	1561	try stream.writeByteNTimes(' ', indent);
1555	1562	}
1556	1563
1557	1564	try renderToken(tree, stream, rparen, indent, start_col, Space.Space); // )
1558	1565
1559		if (fn_proto.align_expr) \|align_expr\| {
	1566	if (fn_proto.getTrailer("align_expr")) \|align_expr\| {
1560	1567	const align_rparen = tree.nextToken(align_expr.lastToken());
1561	1568	const align_lparen = tree.prevToken(align_expr.firstToken());
1562	1569	const align_kw = tree.prevToken(align_lparen);
...	...	@@ -1567,7 +1574,7 @@ fn renderExpression(
1567	1574	try renderToken(tree, stream, align_rparen, indent, start_col, Space.Space); // )
1568	1575	}
1569	1576
1570		if (fn_proto.section_expr) \|section_expr\| {
	1577	if (fn_proto.getTrailer("section_expr")) \|section_expr\| {
1571	1578	const section_rparen = tree.nextToken(section_expr.lastToken());
1572	1579	const section_lparen = tree.prevToken(section_expr.firstToken());
1573	1580	const section_kw = tree.prevToken(section_lparen);
...	...	@@ -1578,7 +1585,7 @@ fn renderExpression(
1578	1585	try renderToken(tree, stream, section_rparen, indent, start_col, Space.Space); // )
1579	1586	}
1580	1587
1581		if (fn_proto.callconv_expr) \|callconv_expr\| {
	1588	if (fn_proto.getTrailer("callconv_expr")) \|callconv_expr\| {
1582	1589	const callconv_rparen = tree.nextToken(callconv_expr.lastToken());
1583	1590	const callconv_lparen = tree.prevToken(callconv_expr.firstToken());
1584	1591	const callconv_kw = tree.prevToken(callconv_lparen);
...	...	@@ -1587,9 +1594,9 @@ fn renderExpression(
1587	1594	try renderToken(tree, stream, callconv_lparen, indent, start_col, Space.None); // (
1588	1595	try renderExpression(allocator, stream, tree, indent, start_col, callconv_expr, Space.None);
1589	1596	try renderToken(tree, stream, callconv_rparen, indent, start_col, Space.Space); // )
1590		} else if (fn_proto.is_extern_prototype) {
	1597	} else if (fn_proto.getTrailer("is_extern_prototype") != null) {
1591	1598	try stream.writeAll("callconv(.C) ");
1592		} else if (fn_proto.is_async) {
	1599	} else if (fn_proto.getTrailer("is_async") != null) {
1593	1600	try stream.writeAll("callconv(.Async) ");
1594	1601	}
1595	1602
...	...	@@ -2177,64 +2184,69 @@ fn renderVarDecl(
2177	2184	start_col: *usize,
2178	2185	var_decl: *ast.Node.VarDecl,
2179	2186	) (@TypeOf(stream).Error \|\| Error)!void {
2180		if (var_decl.visib_token) \|visib_token\| {
	2187	if (var_decl.getTrailer("visib_token")) \|visib_token\| {
2181	2188	try renderToken(tree, stream, visib_token, indent, start_col, Space.Space); // pub
2182	2189	}
2183	2190
2184		if (var_decl.extern_export_token) \|extern_export_token\| {
	2191	if (var_decl.getTrailer("extern_export_token")) \|extern_export_token\| {
2185	2192	try renderToken(tree, stream, extern_export_token, indent, start_col, Space.Space); // extern
2186	2193
2187		if (var_decl.lib_name) \|lib_name\| {
	2194	if (var_decl.getTrailer("lib_name")) \|lib_name\| {
2188	2195	try renderExpression(allocator, stream, tree, indent, start_col, lib_name, Space.Space); // "lib"
2189	2196	}
2190	2197	}
2191	2198
2192		if (var_decl.comptime_token) \|comptime_token\| {
	2199	if (var_decl.getTrailer("comptime_token")) \|comptime_token\| {
2193	2200	try renderToken(tree, stream, comptime_token, indent, start_col, Space.Space); // comptime
2194	2201	}
2195	2202
2196		if (var_decl.thread_local_token) \|thread_local_token\| {
	2203	if (var_decl.getTrailer("thread_local_token")) \|thread_local_token\| {
2197	2204	try renderToken(tree, stream, thread_local_token, indent, start_col, Space.Space); // threadlocal
2198	2205	}
2199	2206	try renderToken(tree, stream, var_decl.mut_token, indent, start_col, Space.Space); // var
2200	2207
2201		const name_space = if (var_decl.type_node == null and (var_decl.align_node != null or
2202		var_decl.section_node != null or var_decl.init_node != null)) Space.Space else Space.None;
	2208	const name_space = if (var_decl.getTrailer("type_node") == null and
	2209	(var_decl.getTrailer("align_node") != null or
	2210	var_decl.getTrailer("section_node") != null or
	2211	var_decl.getTrailer("init_node") != null))
	2212	Space.Space
	2213	else
	2214	Space.None;
2203	2215	try renderToken(tree, stream, var_decl.name_token, indent, start_col, name_space);
2204	2216
2205		if (var_decl.type_node) \|type_node\| {
	2217	if (var_decl.getTrailer("type_node")) \|type_node\| {
2206	2218	try renderToken(tree, stream, tree.nextToken(var_decl.name_token), indent, start_col, Space.Space);
2207		const s = if (var_decl.align_node != null or
2208		var_decl.section_node != null or
2209		var_decl.init_node != null) Space.Space else Space.None;
	2219	const s = if (var_decl.getTrailer("align_node") != null or
	2220	var_decl.getTrailer("section_node") != null or
	2221	var_decl.getTrailer("init_node") != null) Space.Space else Space.None;
2210	2222	try renderExpression(allocator, stream, tree, indent, start_col, type_node, s);
2211	2223	}
2212	2224
2213		if (var_decl.align_node) \|align_node\| {
	2225	if (var_decl.getTrailer("align_node")) \|align_node\| {
2214	2226	const lparen = tree.prevToken(align_node.firstToken());
2215	2227	const align_kw = tree.prevToken(lparen);
2216	2228	const rparen = tree.nextToken(align_node.lastToken());
2217	2229	try renderToken(tree, stream, align_kw, indent, start_col, Space.None); // align
2218	2230	try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
2219	2231	try renderExpression(allocator, stream, tree, indent, start_col, align_node, Space.None);
2220		const s = if (var_decl.section_node != null or var_decl.init_node != null) Space.Space else Space.None;
	2232	const s = if (var_decl.getTrailer("section_node") != null or var_decl.getTrailer("init_node") != null) Space.Space else Space.None;
2221	2233	try renderToken(tree, stream, rparen, indent, start_col, s); // )
2222	2234	}
2223	2235
2224		if (var_decl.section_node) \|section_node\| {
	2236	if (var_decl.getTrailer("section_node")) \|section_node\| {
2225	2237	const lparen = tree.prevToken(section_node.firstToken());
2226	2238	const section_kw = tree.prevToken(lparen);
2227	2239	const rparen = tree.nextToken(section_node.lastToken());
2228	2240	try renderToken(tree, stream, section_kw, indent, start_col, Space.None); // linksection
2229	2241	try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
2230	2242	try renderExpression(allocator, stream, tree, indent, start_col, section_node, Space.None);
2231		const s = if (var_decl.init_node != null) Space.Space else Space.None;
	2243	const s = if (var_decl.getTrailer("init_node") != null) Space.Space else Space.None;
2232	2244	try renderToken(tree, stream, rparen, indent, start_col, s); // )
2233	2245	}
2234	2246
2235		if (var_decl.init_node) \|init_node\| {
	2247	if (var_decl.getTrailer("init_node")) \|init_node\| {
2236	2248	const s = if (init_node.id == .MultilineStringLiteral) Space.None else Space.Space;
2237		try renderToken(tree, stream, var_decl.eq_token.?, indent, start_col, s); // =
	2249	try renderToken(tree, stream, var_decl.getTrailer("eq_token").?, indent, start_col, s); // =
2238	2250	try renderExpression(allocator, stream, tree, indent, start_col, init_node, Space.None);
2239	2251	}
2240	2252
...	...	@@ -2250,7 +2262,7 @@ fn renderParamDecl(
2250	2262	param_decl: ast.Node.FnProto.ParamDecl,
2251	2263	space: Space,
2252	2264	) (@TypeOf(stream).Error \|\| Error)!void {
2253		try renderDocComments(tree, stream, param_decl, indent, start_col);
	2265	try renderDocComments(tree, stream, param_decl, param_decl.doc_comments, indent, start_col);
2254	2266
2255	2267	if (param_decl.comptime_token) \|comptime_token\| {
2256	2268	try renderToken(tree, stream, comptime_token, indent, start_col, Space.Space);
...	...	@@ -2263,7 +2275,6 @@ fn renderParamDecl(
2263	2275	try renderToken(tree, stream, tree.nextToken(name_token), indent, start_col, Space.Space); // :
2264	2276	}
2265	2277	switch (param_decl.param_type) {
2266		.var_args => \|token\| try renderToken(tree, stream, token, indent, start_col, space),
2267	2278	.any_type, .type_expr => \|node\| try renderExpression(allocator, stream, tree, indent, start_col, node, space),
2268	2279	}
2269	2280	}
...	...	@@ -2519,10 +2530,11 @@ fn renderDocComments(
2519	2530	tree: *ast.Tree,
2520	2531	stream: anytype,
2521	2532	node: anytype,
	2533	doc_comments: ?*ast.Node.DocComment,
2522	2534	indent: usize,
2523	2535	start_col: *usize,
2524	2536	) (@TypeOf(stream).Error \|\| Error)!void {
2525		const comment = node.doc_comments orelse return;
	2537	const comment = doc_comments orelse return;
2526	2538	return renderDocCommentsToken(tree, stream, comment, node.firstToken(), indent, start_col);
2527	2539	}
2528	2540

src-self-hosted/Module.zig+12-10

...	...	@@ -1130,7 +1130,7 @@ fn astGenAndAnalyzeDecl(self: Module, decl: Decl) !bool {
1130	1130	};
1131	1131	defer fn_type_scope.instructions.deinit(self.gpa);
1132	1132
1133		const body_node = fn_proto.body_node orelse
	1133	const body_node = fn_proto.getTrailer("body_node") orelse
1134	1134	return self.failTok(&fn_type_scope.base, fn_proto.fn_token, "TODO implement extern functions", .{});
1135	1135
1136	1136	const param_decls = fn_proto.params();
...	...	@@ -1138,21 +1138,23 @@ fn astGenAndAnalyzeDecl(self: Module, decl: Decl) !bool {
1138	1138	for (param_decls) \|param_decl, i\| {
1139	1139	const param_type_node = switch (param_decl.param_type) {
1140	1140	.any_type => \|node\| return self.failNode(&fn_type_scope.base, node, "TODO implement anytype parameter", .{}),
1141		.var_args => \|tok\| return self.failTok(&fn_type_scope.base, tok, "TODO implement var args", .{}),
1142	1141	.type_expr => \|node\| node,
1143	1142	};
1144	1143	param_types[i] = try self.astGenExpr(&fn_type_scope.base, param_type_node);
1145	1144	}
1146		if (fn_proto.lib_name) \|lib_name\| {
	1145	if (fn_proto.getTrailer("var_args_token")) \|var_args_token\| {
	1146	return self.failTok(&fn_type_scope.base, var_args_token, "TODO implement var args", .{});
	1147	}
	1148	if (fn_proto.getTrailer("lib_name")) \|lib_name\| {
1147	1149	return self.failNode(&fn_type_scope.base, lib_name, "TODO implement function library name", .{});
1148	1150	}
1149		if (fn_proto.align_expr) \|align_expr\| {
	1151	if (fn_proto.getTrailer("align_expr")) \|align_expr\| {
1150	1152	return self.failNode(&fn_type_scope.base, align_expr, "TODO implement function align expression", .{});
1151	1153	}
1152		if (fn_proto.section_expr) \|sect_expr\| {
	1154	if (fn_proto.getTrailer("section_expr")) \|sect_expr\| {
1153	1155	return self.failNode(&fn_type_scope.base, sect_expr, "TODO implement function section expression", .{});
1154	1156	}
1155		if (fn_proto.callconv_expr) \|callconv_expr\| {
	1157	if (fn_proto.getTrailer("callconv_expr")) \|callconv_expr\| {
1156	1158	return self.failNode(
1157	1159	&fn_type_scope.base,
1158	1160	callconv_expr,
...	...	@@ -1265,10 +1267,10 @@ fn astGenAndAnalyzeDecl(self: Module, decl: Decl) !bool {
1265	1267	self.bin_file.freeDecl(decl);
1266	1268	}
1267	1269
1268		if (fn_proto.extern_export_inline_token) \|maybe_export_token\| {
	1270	if (fn_proto.getTrailer("extern_export_inline_token")) \|maybe_export_token\| {
1269	1271	if (tree.token_ids[maybe_export_token] == .Keyword_export) {
1270	1272	const export_src = tree.token_locs[maybe_export_token].start;
1271		const name_loc = tree.token_locs[fn_proto.name_token.?];
	1273	const name_loc = tree.token_locs[fn_proto.getTrailer("name_token").?];
1272	1274	const name = tree.tokenSliceLoc(name_loc);
1273	1275	// The scope needs to have the decl in it.
1274	1276	try self.analyzeExport(&block_scope.base, export_src, name, decl);
...	...	@@ -1867,7 +1869,7 @@ fn analyzeRootSrcFile(self: Module, root_scope: Scope.File) !void {
1867	1869	for (decls) \|src_decl, decl_i\| {
1868	1870	if (src_decl.cast(ast.Node.FnProto)) \|fn_proto\| {
1869	1871	// We will create a Decl for it regardless of analysis status.
1870		const name_tok = fn_proto.name_token orelse {
	1872	const name_tok = fn_proto.getTrailer("name_token") orelse {
1871	1873	@panic("TODO missing function name");
1872	1874	};
1873	1875
...	...	@@ -1893,7 +1895,7 @@ fn analyzeRootSrcFile(self: Module, root_scope: Scope.File) !void {
1893	1895	} else {
1894	1896	const new_decl = try self.createNewDecl(&root_scope.base, name, decl_i, name_hash, contents_hash);
1895	1897	root_scope.decls.appendAssumeCapacity(new_decl);
1896		if (fn_proto.extern_export_inline_token) \|maybe_export_token\| {
	1898	if (fn_proto.getTrailer("extern_export_inline_token")) \|maybe_export_token\| {
1897	1899	if (tree.token_ids[maybe_export_token] == .Keyword_export) {
1898	1900	self.work_queue.writeItemAssumeCapacity(.{ .analyze_decl = new_decl });
1899	1901	}

src-self-hosted/translate_c.zig+279-183

...	...	@@ -586,11 +586,7 @@ fn visitFnDecl(c: Context, fn_decl: const ZigClangFunctionDecl) Error!void {
586	586	for (proto_node.params()) \|*param, i\| {
587	587	const param_name = if (param.name_token) \|name_tok\|
588	588	tokenSlice(c, name_tok)
589		else if (param.param_type == .var_args) {
590		assert(i + 1 == proto_node.params_len);
591		proto_node.params_len -= 1;
592		break;
593		} else
	589	else
594	590	return failDecl(c, fn_decl_loc, fn_name, "function {} parameter has no name", .{fn_name});
595	591
596	592	const c_param = ZigClangFunctionDecl_getParamDecl(fn_decl, param_id);
...	...	@@ -602,10 +598,20 @@ fn visitFnDecl(c: Context, fn_decl: const ZigClangFunctionDecl) Error!void {
602	598	if (!is_const) {
603	599	const bare_arg_name = try std.fmt.allocPrint(c.arena, "arg_{}", .{mangled_param_name});
604	600	const arg_name = try block_scope.makeMangledName(c, bare_arg_name);
605		const node = try transCreateNodeVarDecl(c, false, false, mangled_param_name);
606		node.eq_token = try appendToken(c, .Equal, "=");
607		node.init_node = try transCreateNodeIdentifier(c, arg_name);
608		node.semicolon_token = try appendToken(c, .Semicolon, ";");
	601
	602	const mut_tok = try appendToken(c, .Keyword_var, "var");
	603	const name_tok = try appendIdentifier(c, mangled_param_name);
	604	const eq_token = try appendToken(c, .Equal, "=");
	605	const init_node = try transCreateNodeIdentifier(c, arg_name);
	606	const semicolon_token = try appendToken(c, .Semicolon, ";");
	607	const node = try ast.Node.VarDecl.create(c.arena, .{
	608	.mut_token = mut_tok,
	609	.name_token = name_tok,
	610	.semicolon_token = semicolon_token,
	611	}, .{
	612	.eq_token = eq_token,
	613	.init_node = init_node,
	614	});
609	615	try block_scope.statements.append(&node.base);
610	616	param.name_token = try appendIdentifier(c, arg_name);
611	617	_ = try appendToken(c, .Colon, ":");
...	...	@@ -622,7 +628,7 @@ fn visitFnDecl(c: Context, fn_decl: const ZigClangFunctionDecl) Error!void {
622	628	=> return failDecl(c, fn_decl_loc, fn_name, "unable to translate function", .{}),
623	629	};
624	630	const body_node = try block_scope.complete(rp.c);
625		proto_node.body_node = &body_node.base;
	631	proto_node.setTrailer("body_node", &body_node.base);
626	632	return addTopLevelDecl(c, fn_name, &proto_node.base);
627	633	}
628	634
...	...	@@ -725,23 +731,20 @@ fn visitVarDecl(c: Context, var_decl: const ZigClangVarDecl) Error!void {
725	731	break :blk null;
726	732	};
727	733
728		const node = try c.arena.create(ast.Node.VarDecl);
729		node.* = .{
730		.doc_comments = null,
	734	const node = try ast.Node.VarDecl.create(c.arena, .{
	735	.name_token = name_tok,
	736	.mut_token = mut_tok,
	737	.semicolon_token = try appendToken(c, .Semicolon, ";"),
	738	}, .{
731	739	.visib_token = visib_tok,
732	740	.thread_local_token = thread_local_token,
733		.name_token = name_tok,
734	741	.eq_token = eq_tok,
735		.mut_token = mut_tok,
736		.comptime_token = null,
737	742	.extern_export_token = extern_tok,
738		.lib_name = null,
739	743	.type_node = type_node,
740	744	.align_node = align_expr,
741	745	.section_node = linksection_expr,
742	746	.init_node = init_node,
743		.semicolon_token = try appendToken(c, .Semicolon, ";"),
744		};
	747	});
745	748	return addTopLevelDecl(c, checked_name, &node.base);
746	749	}
747	750
...	...	@@ -795,26 +798,41 @@ fn transTypeDef(c: Context, typedef_decl: const ZigClangTypedefNameDecl, top_l
795	798
796	799	_ = try c.decl_table.put(@ptrToInt(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)), checked_name);
797	800	const node = (try transCreateNodeTypedef(rp, typedef_decl, true, checked_name)) orelse return null;
798		try addTopLevelDecl(c, checked_name, &node.base);
	801	try addTopLevelDecl(c, checked_name, node);
799	802	return transCreateNodeIdentifier(c, checked_name);
800	803	}
801	804
802		fn transCreateNodeTypedef(rp: RestorePoint, typedef_decl: const ZigClangTypedefNameDecl, toplevel: bool, checked_name: []const u8) Error!?ast.Node.VarDecl {
803		const node = try transCreateNodeVarDecl(rp.c, toplevel, true, checked_name);
804		node.eq_token = try appendToken(rp.c, .Equal, "=");
805
	805	fn transCreateNodeTypedef(
	806	rp: RestorePoint,
	807	typedef_decl: *const ZigClangTypedefNameDecl,
	808	toplevel: bool,
	809	checked_name: []const u8,
	810	) Error!?*ast.Node {
	811	const visib_tok = if (toplevel) try appendToken(rp.c, .Keyword_pub, "pub") else null;
	812	const mut_tok = try appendToken(rp.c, .Keyword_const, "const");
	813	const name_tok = try appendIdentifier(rp.c, checked_name);
	814	const eq_token = try appendToken(rp.c, .Equal, "=");
806	815	const child_qt = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl);
807	816	const typedef_loc = ZigClangTypedefNameDecl_getLocation(typedef_decl);
808		node.init_node = transQualType(rp, child_qt, typedef_loc) catch \|err\| switch (err) {
	817	const init_node = transQualType(rp, child_qt, typedef_loc) catch \|err\| switch (err) {
809	818	error.UnsupportedType => {
810	819	try failDecl(rp.c, typedef_loc, checked_name, "unable to resolve typedef child type", .{});
811	820	return null;
812	821	},
813	822	error.OutOfMemory => \|e\| return e,
814	823	};
	824	const semicolon_token = try appendToken(rp.c, .Semicolon, ";");
815	825
816		node.semicolon_token = try appendToken(rp.c, .Semicolon, ";");
817		return node;
	826	const node = try ast.Node.VarDecl.create(rp.c.arena, .{
	827	.name_token = name_tok,
	828	.mut_token = mut_tok,
	829	.semicolon_token = semicolon_token,
	830	}, .{
	831	.visib_token = visib_tok,
	832	.eq_token = eq_token,
	833	.init_node = init_node,
	834	});
	835	return &node.base;
818	836	}
819	837
820	838	fn transRecordDecl(c: Context, record_decl: const ZigClangRecordDecl) Error!?*ast.Node {
...	...	@@ -847,12 +865,14 @@ fn transRecordDecl(c: Context, record_decl: const ZigClangRecordDecl) Error!?*
847	865	const name = try std.fmt.allocPrint(c.arena, "{}_{}", .{ container_kind_name, bare_name });
848	866	_ = try c.decl_table.put(@ptrToInt(ZigClangRecordDecl_getCanonicalDecl(record_decl)), name);
849	867
850		const node = try transCreateNodeVarDecl(c, !is_unnamed, true, name);
	868	const visib_tok = if (!is_unnamed) try appendToken(c, .Keyword_pub, "pub") else null;
	869	const mut_tok = try appendToken(c, .Keyword_const, "const");
	870	const name_tok = try appendIdentifier(c, name);
851	871
852		node.eq_token = try appendToken(c, .Equal, "=");
	872	const eq_token = try appendToken(c, .Equal, "=");
853	873
854	874	var semicolon: ast.TokenIndex = undefined;
855		node.init_node = blk: {
	875	const init_node = blk: {
856	876	const rp = makeRestorePoint(c);
857	877	const record_def = ZigClangRecordDecl_getDefinition(record_decl) orelse {
858	878	const opaque = try transCreateNodeOpaqueType(c);
...	...	@@ -959,7 +979,16 @@ fn transRecordDecl(c: Context, record_decl: const ZigClangRecordDecl) Error!?*
959	979	semicolon = try appendToken(c, .Semicolon, ";");
960	980	break :blk &container_node.base;
961	981	};
962		node.semicolon_token = semicolon;
	982
	983	const node = try ast.Node.VarDecl.create(c.arena, .{
	984	.name_token = name_tok,
	985	.mut_token = mut_tok,
	986	.semicolon_token = semicolon,
	987	}, .{
	988	.visib_token = visib_tok,
	989	.eq_token = eq_token,
	990	.init_node = init_node,
	991	});
963	992
964	993	try addTopLevelDecl(c, name, &node.base);
965	994	if (!is_unnamed)
...	...	@@ -982,10 +1011,13 @@ fn transEnumDecl(c: Context, enum_decl: const ZigClangEnumDecl) Error!?*ast.No
982	1011
983	1012	const name = try std.fmt.allocPrint(c.arena, "enum_{}", .{bare_name});
984	1013	_ = try c.decl_table.put(@ptrToInt(ZigClangEnumDecl_getCanonicalDecl(enum_decl)), name);
985		const node = try transCreateNodeVarDecl(c, !is_unnamed, true, name);
986		node.eq_token = try appendToken(c, .Equal, "=");
987	1014
988		node.init_node = if (ZigClangEnumDecl_getDefinition(enum_decl)) \|enum_def\| blk: {
	1015	const visib_tok = if (!is_unnamed) try appendToken(c, .Keyword_pub, "pub") else null;
	1016	const mut_tok = try appendToken(c, .Keyword_const, "const");
	1017	const name_tok = try appendIdentifier(c, name);
	1018	const eq_token = try appendToken(c, .Equal, "=");
	1019
	1020	const init_node = if (ZigClangEnumDecl_getDefinition(enum_decl)) \|enum_def\| blk: {
989	1021	var pure_enum = true;
990	1022	var it = ZigClangEnumDecl_enumerator_begin(enum_def);
991	1023	var end_it = ZigClangEnumDecl_enumerator_end(enum_def);
...	...	@@ -1063,8 +1095,10 @@ fn transEnumDecl(c: Context, enum_decl: const ZigClangEnumDecl) Error!?*ast.No
1063	1095
1064	1096	// In C each enum value is in the global namespace. So we put them there too.
1065	1097	// At this point we can rely on the enum emitting successfully.
1066		const tld_node = try transCreateNodeVarDecl(c, true, true, enum_val_name);
1067		tld_node.eq_token = try appendToken(c, .Equal, "=");
	1098	const tld_visib_tok = try appendToken(c, .Keyword_pub, "pub");
	1099	const tld_mut_tok = try appendToken(c, .Keyword_const, "const");
	1100	const tld_name_tok = try appendIdentifier(c, enum_val_name);
	1101	const tld_eq_token = try appendToken(c, .Equal, "=");
1068	1102	const cast_node = try rp.c.createBuiltinCall("@enumToInt", 1);
1069	1103	const enum_ident = try transCreateNodeIdentifier(c, name);
1070	1104	const period_tok = try appendToken(c, .Period, ".");
...	...	@@ -1078,8 +1112,17 @@ fn transEnumDecl(c: Context, enum_decl: const ZigClangEnumDecl) Error!?*ast.No
1078	1112	};
1079	1113	cast_node.params()[0] = &field_access_node.base;
1080	1114	cast_node.rparen_token = try appendToken(rp.c, .RParen, ")");
1081		tld_node.init_node = &cast_node.base;
1082		tld_node.semicolon_token = try appendToken(c, .Semicolon, ";");
	1115	const tld_init_node = &cast_node.base;
	1116	const tld_semicolon_token = try appendToken(c, .Semicolon, ";");
	1117	const tld_node = try ast.Node.VarDecl.create(c.arena, .{
	1118	.name_token = tld_name_tok,
	1119	.mut_token = tld_mut_tok,
	1120	.semicolon_token = tld_semicolon_token,
	1121	}, .{
	1122	.visib_token = tld_visib_tok,
	1123	.eq_token = tld_eq_token,
	1124	.init_node = tld_init_node,
	1125	});
1083	1126	try addTopLevelDecl(c, field_name, &tld_node.base);
1084	1127	}
1085	1128	// make non exhaustive
...	...	@@ -1109,7 +1152,16 @@ fn transEnumDecl(c: Context, enum_decl: const ZigClangEnumDecl) Error!?*ast.No
1109	1152	} else
1110	1153	try transCreateNodeOpaqueType(c);
1111	1154
1112		node.semicolon_token = try appendToken(c, .Semicolon, ";");
	1155	const semicolon_token = try appendToken(c, .Semicolon, ";");
	1156	const node = try ast.Node.VarDecl.create(c.arena, .{
	1157	.name_token = name_tok,
	1158	.mut_token = mut_tok,
	1159	.semicolon_token = semicolon_token,
	1160	}, .{
	1161	.visib_token = visib_tok,
	1162	.eq_token = eq_token,
	1163	.init_node = init_node,
	1164	});
1113	1165
1114	1166	try addTopLevelDecl(c, name, &node.base);
1115	1167	if (!is_unnamed)
...	...	@@ -1118,10 +1170,22 @@ fn transEnumDecl(c: Context, enum_decl: const ZigClangEnumDecl) Error!?*ast.No
1118	1170	}
1119	1171
1120	1172	fn createAlias(c: *Context, alias: anytype) !void {
1121		const node = try transCreateNodeVarDecl(c, true, true, alias.alias);
1122		node.eq_token = try appendToken(c, .Equal, "=");
1123		node.init_node = try transCreateNodeIdentifier(c, alias.name);
1124		node.semicolon_token = try appendToken(c, .Semicolon, ";");
	1173	const visib_tok = try appendToken(c, .Keyword_pub, "pub");
	1174	const mut_tok = try appendToken(c, .Keyword_const, "const");
	1175	const name_tok = try appendIdentifier(c, alias.alias);
	1176	const eq_token = try appendToken(c, .Equal, "=");
	1177	const init_node = try transCreateNodeIdentifier(c, alias.name);
	1178	const semicolon_token = try appendToken(c, .Semicolon, ";");
	1179
	1180	const node = try ast.Node.VarDecl.create(c.arena, .{
	1181	.name_token = name_tok,
	1182	.mut_token = mut_tok,
	1183	.semicolon_token = semicolon_token,
	1184	}, .{
	1185	.visib_token = visib_tok,
	1186	.eq_token = eq_token,
	1187	.init_node = init_node,
	1188	});
1125	1189	return addTopLevelDecl(c, alias.alias, &node.base);
1126	1190	}
1127	1191
...	...	@@ -1461,13 +1525,17 @@ fn transDeclStmtOne(
1461	1525	@ptrCast(*const ZigClangNamedDecl, var_decl),
1462	1526	));
1463	1527	const mangled_name = try block_scope.makeMangledName(c, name);
1464		const node = try transCreateNodeVarDecl(c, false, ZigClangQualType_isConstQualified(qual_type), mangled_name);
	1528	const mut_tok = if (ZigClangQualType_isConstQualified(qual_type))
	1529	try appendToken(c, .Keyword_const, "const")
	1530	else
	1531	try appendToken(c, .Keyword_var, "var");
	1532	const name_tok = try appendIdentifier(c, mangled_name);
1465	1533
1466	1534	_ = try appendToken(c, .Colon, ":");
1467	1535	const loc = ZigClangDecl_getLocation(decl);
1468		node.type_node = try transQualType(rp, qual_type, loc);
	1536	const type_node = try transQualType(rp, qual_type, loc);
1469	1537
1470		node.eq_token = try appendToken(c, .Equal, "=");
	1538	const eq_token = try appendToken(c, .Equal, "=");
1471	1539	var init_node = if (ZigClangVarDecl_getInit(var_decl)) \|expr\|
1472	1540	try transExprCoercing(rp, scope, expr, .used, .r_value)
1473	1541	else
...	...	@@ -1478,8 +1546,17 @@ fn transDeclStmtOne(
1478	1546	builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")");
1479	1547	init_node = &builtin_node.base;
1480	1548	}
1481		node.init_node = init_node;
1482		node.semicolon_token = try appendToken(c, .Semicolon, ";");
	1549	const semicolon_token = try appendToken(c, .Semicolon, ";");
	1550	const node = try ast.Node.VarDecl.create(c.arena, .{
	1551	.name_token = name_tok,
	1552	.mut_token = mut_tok,
	1553	.semicolon_token = semicolon_token,
	1554	}, .{
	1555	.thread_local_token = thread_local_token,
	1556	.eq_token = eq_token,
	1557	.type_node = type_node,
	1558	.init_node = init_node,
	1559	});
1483	1560	return &node.base;
1484	1561	},
1485	1562	.Typedef => {
...	...	@@ -1494,7 +1571,7 @@ fn transDeclStmtOne(
1494	1571	const mangled_name = try block_scope.makeMangledName(c, name);
1495	1572	const node = (try transCreateNodeTypedef(rp, typedef_decl, false, mangled_name)) orelse
1496	1573	return error.UnsupportedTranslation;
1497		return &node.base;
	1574	return node;
1498	1575	},
1499	1576	else => \|kind\| return revertAndWarn(
1500	1577	rp,
...	...	@@ -3105,12 +3182,21 @@ fn transCreatePreCrement(
3105	3182	defer block_scope.deinit();
3106	3183	const ref = try block_scope.makeMangledName(rp.c, "ref");
3107	3184
3108		const node = try transCreateNodeVarDecl(rp.c, false, true, ref);
3109		node.eq_token = try appendToken(rp.c, .Equal, "=");
	3185	const mut_tok = try appendToken(rp.c, .Keyword_const, "const");
	3186	const name_tok = try appendIdentifier(rp.c, ref);
	3187	const eq_token = try appendToken(rp.c, .Equal, "=");
3110	3188	const rhs_node = try transCreateNodeSimplePrefixOp(rp.c, .AddressOf, .Ampersand, "&");
3111	3189	rhs_node.rhs = try transExpr(rp, scope, op_expr, .used, .r_value);
3112		node.init_node = &rhs_node.base;
3113		node.semicolon_token = try appendToken(rp.c, .Semicolon, ";");
	3190	const init_node = &rhs_node.base;
	3191	const semicolon_token = try appendToken(rp.c, .Semicolon, ";");
	3192	const node = try ast.Node.VarDecl.create(rp.c.arena, .{
	3193	.name_token = name_tok,
	3194	.mut_token = mut_tok,
	3195	.semicolon_token = semicolon_token,
	3196	}, .{
	3197	.eq_token = eq_token,
	3198	.init_node = init_node,
	3199	});
3114	3200	try block_scope.statements.append(&node.base);
3115	3201
3116	3202	const lhs_node = try transCreateNodeIdentifier(rp.c, ref);
...	...	@@ -3171,12 +3257,21 @@ fn transCreatePostCrement(
3171	3257	defer block_scope.deinit();
3172	3258	const ref = try block_scope.makeMangledName(rp.c, "ref");
3173	3259
3174		const node = try transCreateNodeVarDecl(rp.c, false, true, ref);
3175		node.eq_token = try appendToken(rp.c, .Equal, "=");
	3260	const mut_tok = try appendToken(rp.c, .Keyword_const, "const");
	3261	const name_tok = try appendIdentifier(rp.c, ref);
	3262	const eq_token = try appendToken(rp.c, .Equal, "=");
3176	3263	const rhs_node = try transCreateNodeSimplePrefixOp(rp.c, .AddressOf, .Ampersand, "&");
3177	3264	rhs_node.rhs = try transExpr(rp, scope, op_expr, .used, .r_value);
3178		node.init_node = &rhs_node.base;
3179		node.semicolon_token = try appendToken(rp.c, .Semicolon, ";");
	3265	const init_node = &rhs_node.base;
	3266	const semicolon_token = try appendToken(rp.c, .Semicolon, ";");
	3267	const node = try ast.Node.VarDecl.create(rp.c.arena, .{
	3268	.name_token = name_tok,
	3269	.mut_token = mut_tok,
	3270	.semicolon_token = semicolon_token,
	3271	}, .{
	3272	.eq_token = eq_token,
	3273	.init_node = init_node,
	3274	});
3180	3275	try block_scope.statements.append(&node.base);
3181	3276
3182	3277	const lhs_node = try transCreateNodeIdentifier(rp.c, ref);
...	...	@@ -3184,10 +3279,19 @@ fn transCreatePostCrement(
3184	3279	_ = try appendToken(rp.c, .Semicolon, ";");
3185	3280
3186	3281	const tmp = try block_scope.makeMangledName(rp.c, "tmp");
3187		const tmp_node = try transCreateNodeVarDecl(rp.c, false, true, tmp);
3188		tmp_node.eq_token = try appendToken(rp.c, .Equal, "=");
3189		tmp_node.init_node = ref_node;
3190		tmp_node.semicolon_token = try appendToken(rp.c, .Semicolon, ";");
	3282	const tmp_mut_tok = try appendToken(rp.c, .Keyword_const, "const");
	3283	const tmp_name_tok = try appendIdentifier(rp.c, tmp);
	3284	const tmp_eq_token = try appendToken(rp.c, .Equal, "=");
	3285	const tmp_init_node = ref_node;
	3286	const tmp_semicolon_token = try appendToken(rp.c, .Semicolon, ";");
	3287	const tmp_node = try ast.Node.VarDecl.create(rp.c.arena, .{
	3288	.name_token = tmp_name_tok,
	3289	.mut_token = tmp_mut_tok,
	3290	.semicolon_token = semicolon_token,
	3291	}, .{
	3292	.eq_token = tmp_eq_token,
	3293	.init_node = tmp_init_node,
	3294	});
3191	3295	try block_scope.statements.append(&tmp_node.base);
3192	3296
3193	3297	const token = try appendToken(rp.c, op_tok_id, bytes);
...	...	@@ -3325,12 +3429,21 @@ fn transCreateCompoundAssign(
3325	3429	defer block_scope.deinit();
3326	3430	const ref = try block_scope.makeMangledName(rp.c, "ref");
3327	3431
3328		const node = try transCreateNodeVarDecl(rp.c, false, true, ref);
3329		node.eq_token = try appendToken(rp.c, .Equal, "=");
	3432	const mut_tok = try appendToken(rp.c, .Keyword_const, "const");
	3433	const name_tok = try appendIdentifier(rp.c, ref);
	3434	const eq_token = try appendToken(rp.c, .Equal, "=");
3330	3435	const addr_node = try transCreateNodeSimplePrefixOp(rp.c, .AddressOf, .Ampersand, "&");
3331	3436	addr_node.rhs = try transExpr(rp, scope, lhs, .used, .l_value);
3332		node.init_node = &addr_node.base;
3333		node.semicolon_token = try appendToken(rp.c, .Semicolon, ";");
	3437	const init_node = &addr_node.base;
	3438	const semicolon_token = try appendToken(rp.c, .Semicolon, ";");
	3439	const node = try ast.Node.VarDecl.create(rp.c.arena, .{
	3440	.name_token = name_tok,
	3441	.mut_token = mut_tok,
	3442	.semicolon_token = semicolon_token,
	3443	}, .{
	3444	.eq_token = eq_token,
	3445	.init_node = init_node,
	3446	});
3334	3447	try block_scope.statements.append(&node.base);
3335	3448
3336	3449	const lhs_node = try transCreateNodeIdentifier(rp.c, ref);
...	...	@@ -3375,8 +3488,8 @@ fn transCreateCompoundAssign(
3375	3488	const rhs_bin = try transCreateNodeInfixOp(rp, scope, ref_node, bin_op, bin_token, rhs_node, .used, false);
3376	3489	_ = try appendToken(rp.c, .Semicolon, ";");
3377	3490
3378		const eq_token = try appendToken(rp.c, .Equal, "=");
3379		const assign = try transCreateNodeInfixOp(rp, scope, ref_node, .Assign, eq_token, rhs_bin, .used, false);
	3491	const ass_eq_token = try appendToken(rp.c, .Equal, "=");
	3492	const assign = try transCreateNodeInfixOp(rp, scope, ref_node, .Assign, ass_eq_token, rhs_bin, .used, false);
3380	3493	try block_scope.statements.append(assign);
3381	3494	}
3382	3495
...	...	@@ -3494,10 +3607,19 @@ fn transBinaryConditionalOperator(rp: RestorePoint, scope: Scope, stmt: const
3494	3607	defer block_scope.deinit();
3495	3608
3496	3609	const mangled_name = try block_scope.makeMangledName(rp.c, "cond_temp");
3497		const tmp_var = try transCreateNodeVarDecl(rp.c, false, true, mangled_name);
3498		tmp_var.eq_token = try appendToken(rp.c, .Equal, "=");
3499		tmp_var.init_node = try transExpr(rp, &block_scope.base, cond_expr, .used, .r_value);
3500		tmp_var.semicolon_token = try appendToken(rp.c, .Semicolon, ";");
	3610	const mut_tok = try appendToken(rp.c, .Keyword_const, "const");
	3611	const name_tok = try appendIdentifier(rp.c, mangled_name);
	3612	const eq_token = try appendToken(rp.c, .Equal, "=");
	3613	const init_node = try transExpr(rp, &block_scope.base, cond_expr, .used, .r_value);
	3614	const semicolon_token = try appendToken(rp.c, .Semicolon, ";");
	3615	const tmp_var = try ast.Node.VarDecl.create(rp.c.arena, .{
	3616	.name_token = name_tok,
	3617	.mut_token = mut_tok,
	3618	.semicolon_token = semicolon_token,
	3619	}, .{
	3620	.eq_token = eq_token,
	3621	.init_node = init_node,
	3622	});
3501	3623	try block_scope.statements.append(&tmp_var.base);
3502	3624
3503	3625	const break_node = try transCreateNodeBreakToken(rp.c, block_scope.label);
...	...	@@ -3932,9 +4054,9 @@ fn transCreateNodeAssign(
3932	4054	defer block_scope.deinit();
3933	4055
3934	4056	const tmp = try block_scope.makeMangledName(rp.c, "tmp");
3935
3936		const node = try transCreateNodeVarDecl(rp.c, false, true, tmp);
3937		node.eq_token = try appendToken(rp.c, .Equal, "=");
	4057	const mut_tok = try appendToken(rp.c, .Keyword_const, "const");
	4058	const name_tok = try appendIdentifier(rp.c, tmp);
	4059	const eq_token = try appendToken(rp.c, .Equal, "=");
3938	4060	var rhs_node = try transExpr(rp, &block_scope.base, rhs, .used, .r_value);
3939	4061	if (!exprIsBooleanType(lhs) and isBoolRes(rhs_node)) {
3940	4062	const builtin_node = try rp.c.createBuiltinCall("@boolToInt", 1);
...	...	@@ -3942,16 +4064,24 @@ fn transCreateNodeAssign(
3942	4064	builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")");
3943	4065	rhs_node = &builtin_node.base;
3944	4066	}
3945		node.init_node = rhs_node;
3946		node.semicolon_token = try appendToken(rp.c, .Semicolon, ";");
	4067	const init_node = rhs_node;
	4068	const semicolon_token = try appendToken(rp.c, .Semicolon, ";");
	4069	const node = try ast.Node.VarDecl.create(rp.c.arena, .{
	4070	.name_token = name_tok,
	4071	.mut_token = mut_tok,
	4072	.semicolon_token = semicolon_token,
	4073	}, .{
	4074	.eq_token = eq_token,
	4075	.init_node = init_node,
	4076	});
3947	4077	try block_scope.statements.append(&node.base);
3948	4078
3949	4079	const lhs_node = try transExpr(rp, &block_scope.base, lhs, .used, .l_value);
3950		const eq_token = try appendToken(rp.c, .Equal, "=");
	4080	const lhs_eq_token = try appendToken(rp.c, .Equal, "=");
3951	4081	const ident = try transCreateNodeIdentifier(rp.c, tmp);
3952	4082	_ = try appendToken(rp.c, .Semicolon, ";");
3953	4083
3954		const assign = try transCreateNodeInfixOp(rp, &block_scope.base, lhs_node, .Assign, eq_token, ident, .used, false);
	4084	const assign = try transCreateNodeInfixOp(rp, &block_scope.base, lhs_node, .Assign, lhs_eq_token, ident, .used, false);
3955	4085	try block_scope.statements.append(assign);
3956	4086
3957	4087	const break_node = try transCreateNodeBreak(rp.c, label_name);
...	...	@@ -4232,28 +4362,10 @@ fn transCreateNodeMacroFn(c: Context, name: []const u8, ref: ast.Node, proto_a
4232	4362
4233	4363	_ = try appendToken(c, .RParen, ")");
4234	4364
4235		const fn_proto = try ast.Node.FnProto.alloc(c.arena, fn_params.items.len);
4236		fn_proto.* = .{
4237		.doc_comments = null,
4238		.visib_token = pub_tok,
4239		.fn_token = fn_tok,
4240		.name_token = name_tok,
4241		.params_len = fn_params.items.len,
4242		.return_type = proto_alias.return_type,
4243		.var_args_token = null,
4244		.extern_export_inline_token = inline_tok,
4245		.body_node = null,
4246		.lib_name = null,
4247		.align_expr = null,
4248		.section_expr = null,
4249		.callconv_expr = null,
4250		};
4251		mem.copy(ast.Node.FnProto.ParamDecl, fn_proto.params(), fn_params.items);
4252
4253	4365	const block_lbrace = try appendToken(c, .LBrace, "{");
4254	4366
4255	4367	const return_expr = try transCreateNodeReturnExpr(c);
4256		const unwrap_expr = try transCreateNodeUnwrapNull(c, ref.cast(ast.Node.VarDecl).?.init_node.?);
	4368	const unwrap_expr = try transCreateNodeUnwrapNull(c, ref.cast(ast.Node.VarDecl).?.getTrailer("init_node").?);
4257	4369
4258	4370	const call_expr = try c.createCall(unwrap_expr, fn_params.items.len);
4259	4371	const call_params = call_expr.params();
...	...	@@ -4277,7 +4389,18 @@ fn transCreateNodeMacroFn(c: Context, name: []const u8, ref: ast.Node, proto_a
4277	4389	.rbrace = try appendToken(c, .RBrace, "}"),
4278	4390	};
4279	4391	block.statements()[0] = &return_expr.base;
4280		fn_proto.body_node = &block.base;
	4392
	4393	const fn_proto = try ast.Node.FnProto.create(c.arena, .{
	4394	.params_len = fn_params.items.len,
	4395	.fn_token = fn_tok,
	4396	.return_type = proto_alias.return_type,
	4397	}, .{
	4398	.visib_token = pub_tok,
	4399	.name_token = name_tok,
	4400	.extern_export_inline_token = inline_tok,
	4401	.body_node = &block.base,
	4402	});
	4403	mem.copy(ast.Node.FnProto.ParamDecl, fn_proto.params(), fn_params.items);
4281	4404	return &fn_proto.base;
4282	4405	}
4283	4406
...	...	@@ -4356,31 +4479,6 @@ fn transCreateNodeBreak(c: Context, label: ?[]const u8) !ast.Node.ControlFlowE
4356	4479	return node;
4357	4480	}
4358	4481
4359		fn transCreateNodeVarDecl(c: Context, is_pub: bool, is_const: bool, name: []const u8) !ast.Node.VarDecl {
4360		const visib_tok = if (is_pub) try appendToken(c, .Keyword_pub, "pub") else null;
4361		const mut_tok = if (is_const) try appendToken(c, .Keyword_const, "const") else try appendToken(c, .Keyword_var, "var");
4362		const name_tok = try appendIdentifier(c, name);
4363
4364		const node = try c.arena.create(ast.Node.VarDecl);
4365		node.* = .{
4366		.doc_comments = null,
4367		.visib_token = visib_tok,
4368		.thread_local_token = null,
4369		.name_token = name_tok,
4370		.eq_token = undefined,
4371		.mut_token = mut_tok,
4372		.comptime_token = null,
4373		.extern_export_token = null,
4374		.lib_name = null,
4375		.type_node = null,
4376		.align_node = null,
4377		.section_node = null,
4378		.init_node = null,
4379		.semicolon_token = undefined,
4380		};
4381		return node;
4382		}
4383
4384	4482	fn transCreateNodeWhile(c: Context) !ast.Node.While {
4385	4483	const while_tok = try appendToken(c, .Keyword_while, "while");
4386	4484	_ = try appendToken(c, .LParen, "(");
...	...	@@ -4782,19 +4880,12 @@ fn finishTransFnProto(
4782	4880	}
4783	4881	}
4784	4882
4785		if (is_var_args) {
	4883	const var_args_token: ?ast.TokenIndex = if (is_var_args) blk: {
4786	4884	if (param_count > 0) {
4787	4885	_ = try appendToken(rp.c, .Comma, ",");
4788	4886	}
4789
4790		fn_params.addOneAssumeCapacity().* = .{
4791		.doc_comments = null,
4792		.comptime_token = null,
4793		.noalias_token = null,
4794		.name_token = null,
4795		.param_type = .{ .var_args = try appendToken(rp.c, .Ellipsis3, "...") },
4796		};
4797		}
	4887	break :blk try appendToken(rp.c, .Ellipsis3, "...");
	4888	} else null;
4798	4889
4799	4890	const rparen_tok = try appendToken(rp.c, .RParen, ")");
4800	4891
...	...	@@ -4860,22 +4951,31 @@ fn finishTransFnProto(
4860	4951	}
4861	4952	};
4862	4953
4863		const fn_proto = try ast.Node.FnProto.alloc(rp.c.arena, fn_params.items.len);
4864		fn_proto.* = .{
4865		.doc_comments = null,
4866		.visib_token = pub_tok,
4867		.fn_token = fn_tok,
4868		.name_token = name_tok,
	4954	// We need to reserve an undefined (but non-null) body node to set later.
	4955	var body_node: ?*ast.Node = null;
	4956	if (fn_decl_context) \|ctx\| {
	4957	if (ctx.has_body) {
	4958	// TODO: we should be able to use undefined here but
	4959	// it causes a bug. This is undefined without zig language
	4960	// being aware of it.
	4961	body_node = @intToPtr(*ast.Node, 0x08);
	4962	}
	4963	}
	4964
	4965	const fn_proto = try ast.Node.FnProto.create(rp.c.arena, .{
4869	4966	.params_len = fn_params.items.len,
4870	4967	.return_type = .{ .Explicit = return_type_node },
4871		.var_args_token = null, // TODO this field is broken in the AST data model
	4968	.fn_token = fn_tok,
	4969	}, .{
	4970	.visib_token = pub_tok,
	4971	.name_token = name_tok,
4872	4972	.extern_export_inline_token = extern_export_inline_tok,
4873		.body_node = null,
4874		.lib_name = null,
4875	4973	.align_expr = align_expr,
4876	4974	.section_expr = linksection_expr,
4877	4975	.callconv_expr = callconv_expr,
4878		};
	4976	.body_node = body_node,
	4977	.var_args_token = var_args_token,
	4978	});
4879	4979	mem.copy(ast.Node.FnProto.ParamDecl, fn_proto.params(), fn_params.items);
4880	4980	return fn_proto;
4881	4981	}
...	...	@@ -4923,23 +5023,15 @@ pub fn failDecl(c: *Context, loc: ZigClangSourceLocation, name: []const u8, comp
4923	5023	};
4924	5024	call_node.params()[0] = &msg_node.base;
4925	5025
4926		const var_decl_node = try c.arena.create(ast.Node.VarDecl);
4927		var_decl_node.* = .{
4928		.doc_comments = null,
4929		.visib_token = pub_tok,
4930		.thread_local_token = null,
	5026	const var_decl_node = try ast.Node.VarDecl.create(c.arena, .{
4931	5027	.name_token = name_tok,
4932		.eq_token = eq_tok,
4933	5028	.mut_token = const_tok,
4934		.comptime_token = null,
4935		.extern_export_token = null,
4936		.lib_name = null,
4937		.type_node = null,
4938		.align_node = null,
4939		.section_node = null,
4940		.init_node = &call_node.base,
4941	5029	.semicolon_token = semi_tok,
4942		};
	5030	}, .{
	5031	.visib_token = pub_tok,
	5032	.eq_token = eq_tok,
	5033	.init_node = &call_node.base,
	5034	});
4943	5035	try addTopLevelDecl(c, name, &var_decl_node.base);
4944	5036	}
4945	5037
...	...	@@ -5132,10 +5224,12 @@ fn transPreprocessorEntities(c: Context, unit: ZigClangASTUnit) Error!void {
5132	5224	fn transMacroDefine(c: Context, it: CTokenList.Iterator, source: []const u8, name: []const u8, source_loc: ZigClangSourceLocation) ParseError!void {
5133	5225	const scope = &c.global_scope.base;
5134	5226
5135		const node = try transCreateNodeVarDecl(c, true, true, name);
5136		node.eq_token = try appendToken(c, .Equal, "=");
	5227	const visib_tok = try appendToken(c, .Keyword_pub, "pub");
	5228	const mut_tok = try appendToken(c, .Keyword_const, "const");
	5229	const name_tok = try appendIdentifier(c, name);
	5230	const eq_token = try appendToken(c, .Equal, "=");
5137	5231
5138		node.init_node = try parseCExpr(c, it, source, source_loc, scope);
	5232	const init_node = try parseCExpr(c, it, source, source_loc, scope);
5139	5233	const last = it.next().?;
5140	5234	if (last.id != .Eof and last.id != .Nl)
5141	5235	return failDecl(
...	...	@@ -5146,7 +5240,16 @@ fn transMacroDefine(c: Context, it: CTokenList.Iterator, source: []const u8, n
5146	5240	.{@tagName(last.id)},
5147	5241	);
5148	5242
5149		node.semicolon_token = try appendToken(c, .Semicolon, ";");
	5243	const semicolon_token = try appendToken(c, .Semicolon, ";");
	5244	const node = try ast.Node.VarDecl.create(c.arena, .{
	5245	.name_token = name_tok,
	5246	.mut_token = mut_tok,
	5247	.semicolon_token = semicolon_token,
	5248	}, .{
	5249	.visib_token = visib_tok,
	5250	.eq_token = eq_token,
	5251	.init_node = init_node,
	5252	});
5150	5253	_ = try c.global_scope.macro_table.put(name, &node.base);
5151	5254	}
5152	5255
...	...	@@ -5223,24 +5326,6 @@ fn transMacroFnDefine(c: Context, it: CTokenList.Iterator, source: []const u8,
5223	5326
5224	5327	const type_of = try c.createBuiltinCall("@TypeOf", 1);
5225	5328
5226		const fn_proto = try ast.Node.FnProto.alloc(c.arena, fn_params.items.len);
5227		fn_proto.* = .{
5228		.visib_token = pub_tok,
5229		.extern_export_inline_token = inline_tok,
5230		.fn_token = fn_tok,
5231		.name_token = name_tok,
5232		.params_len = fn_params.items.len,
5233		.return_type = .{ .Explicit = &type_of.base },
5234		.doc_comments = null,
5235		.var_args_token = null,
5236		.body_node = null,
5237		.lib_name = null,
5238		.align_expr = null,
5239		.section_expr = null,
5240		.callconv_expr = null,
5241		};
5242		mem.copy(ast.Node.FnProto.ParamDecl, fn_proto.params(), fn_params.items);
5243
5244	5329	const return_expr = try transCreateNodeReturnExpr(c);
5245	5330	const expr = try parseCExpr(c, it, source, source_loc, scope);
5246	5331	const last = it.next().?;
...	...	@@ -5266,7 +5351,18 @@ fn transMacroFnDefine(c: Context, it: CTokenList.Iterator, source: []const u8,
5266	5351
5267	5352	try block_scope.statements.append(&return_expr.base);
5268	5353	const block_node = try block_scope.complete(c);
5269		fn_proto.body_node = &block_node.base;
	5354	const fn_proto = try ast.Node.FnProto.create(c.arena, .{
	5355	.fn_token = fn_tok,
	5356	.params_len = fn_params.items.len,
	5357	.return_type = .{ .Explicit = &type_of.base },
	5358	}, .{
	5359	.visib_token = pub_tok,
	5360	.extern_export_inline_token = inline_tok,
	5361	.name_token = name_tok,
	5362	.body_node = &block_node.base,
	5363	});
	5364	mem.copy(ast.Node.FnProto.ParamDecl, fn_proto.params(), fn_params.items);
	5365
5270	5366	_ = try c.global_scope.macro_table.put(name, &fn_proto.base);
5271	5367	}
5272	5368
...	...	@@ -6030,7 +6126,7 @@ fn getContainer(c: Context, node: ast.Node) ?*ast.Node {
6030	6126	const ident = node.cast(ast.Node.Identifier).?;
6031	6127	if (c.global_scope.sym_table.get(tokenSlice(c, ident.token))) \|value\| {
6032	6128	if (value.cast(ast.Node.VarDecl)) \|var_decl\|
6033		return getContainer(c, var_decl.init_node.?);
	6129	return getContainer(c, var_decl.getTrailer("init_node").?);
6034	6130	}
6035	6131	},
6036	6132
...	...	@@ -6060,7 +6156,7 @@ fn getContainerTypeOf(c: Context, ref: ast.Node) ?*ast.Node {
6060	6156	if (ref.cast(ast.Node.Identifier)) \|ident\| {
6061	6157	if (c.global_scope.sym_table.get(tokenSlice(c, ident.token))) \|value\| {
6062	6158	if (value.cast(ast.Node.VarDecl)) \|var_decl\| {
6063		if (var_decl.type_node) \|ty\|
	6159	if (var_decl.getTrailer("type_node")) \|ty\|
6064	6160	return getContainer(c, ty);
6065	6161	}
6066	6162	}
...	...	@@ -6084,7 +6180,7 @@ fn getContainerTypeOf(c: Context, ref: ast.Node) ?*ast.Node {
6084	6180	}
6085	6181
6086	6182	fn getFnProto(c: Context, ref: ast.Node) ?*ast.Node.FnProto {
6087		const init = if (ref.cast(ast.Node.VarDecl)) \|v\| v.init_node.? else return null;
	6183	const init = if (ref.cast(ast.Node.VarDecl)) \|v\| v.getTrailer("init_node").? else return null;
6088	6184	if (getContainerTypeOf(c, init)) \|ty_node\| {
6089	6185	if (ty_node.cast(ast.Node.OptionalType)) \|prefix\| {
6090	6186	if (prefix.rhs.cast(ast.Node.FnProto)) \|fn_proto\| {

test/translate_c.zig+1-1

...	...	@@ -2797,7 +2797,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
2797	2797	\\pub fn a() callconv(.C) void {}
2798	2798	\\pub fn b() callconv(.C) void {}
2799	2799	\\pub export fn c() void {}
2800		\\pub fn foo() callconv(.C) void {}
	2800	\\pub fn foo(...) callconv(.C) void {}
2801	2801	});
2802	2802
2803	2803	cases.add("casting away const and volatile",