Commit 8b7539bd9554d25599ccff6f0e9ea79aa051946b | zig

author	Andrew Kelley <andrew@ziglang.org> 2020-10-08 15:47:45-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2020-10-08 15:47:45-07:00
log	8b7539bd9554d25599ccff6f0e9ea79aa051946b
tree	9157fafcbe37f904346fd73042be1d1d299d4da2
parent	b5a36f676b1fd69f195d9f1eb6e35f3eb2f15946
parent	b02341d6f58e0b8a87fc2ab589dcfd85e5dc96cd

Merge remote-tracking branch 'origin/master' into llvm11

Conflicts:
  src/clang.zig

Master branch renamed an enum; this branch gave it an explicit tag type
and explicitly initialized values. This commit combines the changes
together.

45 files changed, 2689 insertions(+), 1445 deletions(-)

doc
- docgen.zig
- langref.html.in
lib
- std
  - builtin.zig
  - c.zig
  - crypto
    aes.zig
    aes
    aesni.zig
    armcrypto.zig
    ghash.zig
  - event.zig
  - event
    loop.zig
    wait_group.zig
  - fmt.zig
  - math.zig
  - os
    linux
    bpf
    kern.zig
    uefi.zig
    uefi
    protocols
    hii.zig
    windows
    bits.zig
    ws2_32.zig
  - zig
    ast.zig
    parse.zig
    render.zig
    tokenizer.zig
src
test
- compile_errors.zig
- gen_h.zig
- stage1
  - behavior
    misc.zig
    type.zig
    type_info.zig
  - c_abi
    cfuncs.c
    main.zig
- translate_c.zig
tools
- update_clang_options.zig

doc/docgen.zig+1

...	@@ -808,6 +808,7 @@ fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: anytype, source_token:	...	@@ -808,6 +808,7 @@ fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: anytype, source_token:
808	.Keyword_noalias,	808	.Keyword_noalias,
809	.Keyword_noinline,	809	.Keyword_noinline,
810	.Keyword_nosuspend,	810	.Keyword_nosuspend,
		811	.Keyword_opaque,
811	.Keyword_or,	812	.Keyword_or,
812	.Keyword_orelse,	813	.Keyword_orelse,
813	.Keyword_packed,	814	.Keyword_packed,

doc/langref.html.in+11-9

lib/std/builtin.zig+7-2

...	@@ -151,7 +151,6 @@ pub const Mode = enum {	...	@@ -151,7 +151,6 @@ pub const Mode = enum {
151	pub const CallingConvention = enum {	151	pub const CallingConvention = enum {
152	Unspecified,	152	Unspecified,
153	C,	153	C,
154	Cold,
155	Naked,	154	Naked,
156	Async,	155	Async,
157	Interrupt,	156	Interrupt,
...	@@ -199,7 +198,7 @@ pub const TypeInfo = union(enum) {	...	@@ -199,7 +198,7 @@ pub const TypeInfo = union(enum) {
199	Union: Union,	198	Union: Union,
200	Fn: Fn,	199	Fn: Fn,
201	BoundFn: Fn,	200	BoundFn: Fn,
202	Opaque: void,	201	Opaque: Opaque,
203	Frame: Frame,	202	Frame: Frame,
204	AnyFrame: AnyFrame,	203	AnyFrame: AnyFrame,
205	Vector: Vector,	204	Vector: Vector,
...	@@ -360,6 +359,12 @@ pub const TypeInfo = union(enum) {	...	@@ -360,6 +359,12 @@ pub const TypeInfo = union(enum) {
360	args: []const FnArg,	359	args: []const FnArg,
361	};	360	};
362		361
		362	/// This data structure is used by the Zig language code generation and
		363	/// therefore must be kept in sync with the compiler implementation.
		364	pub const Opaque = struct {
		365	decls: []const Declaration,
		366	};
		367
363	/// This data structure is used by the Zig language code generation and	368	/// This data structure is used by the Zig language code generation and
364	/// therefore must be kept in sync with the compiler implementation.	369	/// therefore must be kept in sync with the compiler implementation.
365	pub const Frame = struct {	370	pub const Frame = struct {

lib/std/c.zig+2-2

...	@@ -329,8 +329,8 @@ pub extern "c" fn pthread_cond_signal(cond: *pthread_cond_t) c_int;	...	@@ -329,8 +329,8 @@ pub extern "c" fn pthread_cond_signal(cond: *pthread_cond_t) c_int;
329	pub extern "c" fn pthread_cond_broadcast(cond: *pthread_cond_t) c_int;	329	pub extern "c" fn pthread_cond_broadcast(cond: *pthread_cond_t) c_int;
330	pub extern "c" fn pthread_cond_destroy(cond: *pthread_cond_t) c_int;	330	pub extern "c" fn pthread_cond_destroy(cond: *pthread_cond_t) c_int;
331		331
332	pub const pthread_t = *@Type(.Opaque);	332	pub const pthread_t = *opaque {};
333	pub const FILE = @Type(.Opaque);	333	pub const FILE = opaque {};
334		334
335	pub extern "c" fn dlopen(path: [:0]const u8, mode: c_int) ?c_void;	335	pub extern "c" fn dlopen(path: [:0]const u8, mode: c_int) ?c_void;
336	pub extern "c" fn dlclose(handle: *c_void) c_int;	336	pub extern "c" fn dlclose(handle: *c_void) c_int;

lib/std/crypto/aes.zig+9-1

...	@@ -10,7 +10,15 @@ const builtin = std.builtin;	...	@@ -10,7 +10,15 @@ const builtin = std.builtin;
10		10
11	const has_aesni = comptime std.Target.x86.featureSetHas(std.Target.current.cpu.features, .aes);	11	const has_aesni = comptime std.Target.x86.featureSetHas(std.Target.current.cpu.features, .aes);
12	const has_avx = comptime std.Target.x86.featureSetHas(std.Target.current.cpu.features, .avx);	12	const has_avx = comptime std.Target.x86.featureSetHas(std.Target.current.cpu.features, .avx);
13	const impl = if (std.Target.current.cpu.arch == .x86_64 and has_aesni and has_avx) @import("aes/aesni.zig") else @import("aes/soft.zig");	13	const has_armaes = comptime std.Target.aarch64.featureSetHas(std.Target.current.cpu.features, .aes);
		14	const impl = if (std.Target.current.cpu.arch == .x86_64 and has_aesni and has_avx) impl: {
		15	break :impl @import("aes/aesni.zig");
		16	} else if (std.Target.current.cpu.arch == .aarch64 and has_armaes)
		17	impl: {
		18	break :impl @import("aes/armcrypto.zig");
		19	} else impl: {
		20	break :impl @import("aes/soft.zig");
		21	};
14		22
15	pub const Block = impl.Block;	23	pub const Block = impl.Block;
16	pub const AESEncryptCtx = impl.AESEncryptCtx;	24	pub const AESEncryptCtx = impl.AESEncryptCtx;

lib/std/crypto/aes/aesni.zig-1

...	@@ -3,7 +3,6 @@	...	@@ -3,7 +3,6 @@
3	// This file is part of [zig](https://ziglang.org/), which is MIT licensed.	3	// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
4	// The MIT license requires this copyright notice to be included in all copies	4	// The MIT license requires this copyright notice to be included in all copies
5	// and substantial portions of the software.	5	// and substantial portions of the software.
6	// Based on Go stdlib implementation
7		6
8	const std = @import("../../std.zig");	7	const std = @import("../../std.zig");
9	const mem = std.mem;	8	const mem = std.mem;

lib/std/crypto/aes/armcrypto.zig created+490

...	@@ -0,0 +1,490 @@
1	// SPDX-License-Identifier: MIT
2	// Copyright (c) 2015-2020 Zig Contributors
3	// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
4	// The MIT license requires this copyright notice to be included in all copies
5	// and substantial portions of the software.
6
7	const std = @import("../../std.zig");
8	const mem = std.mem;
9	const debug = std.debug;
10	const Vector = std.meta.Vector;
11
12	const BlockVec = Vector(2, u64);
13
14	/// A single AES block.
15	pub const Block = struct {
16	pub const block_size: usize = 16;
17
18	/// Internal representation of a block.
19	repr: BlockVec,
20
21	/// Convert a byte sequence into an internal representation.
22	pub inline fn fromBytes(bytes: *const [16]u8) Block {
23	const repr = mem.bytesToValue(BlockVec, bytes);
24	return Block{ .repr = repr };
25	}
26
27	/// Convert the internal representation of a block into a byte sequence.
28	pub inline fn toBytes(block: Block) [16]u8 {
29	return mem.toBytes(block.repr);
30	}
31
32	/// XOR the block with a byte sequence.
33	pub inline fn xorBytes(block: Block, bytes: *const [16]u8) [16]u8 {
34	const x = block.repr ^ fromBytes(bytes).repr;
35	return mem.toBytes(x);
36	}
37
38	const zero = Vector(2, u64){ 0, 0 };
39
40	/// Encrypt a block with a round key.
41	pub inline fn encrypt(block: Block, round_key: Block) Block {
42	return Block{
43	.repr = asm (
44	\\ mov %[out].16b, %[in].16b
45	\\ aese %[out].16b, %[zero].16b
46	\\ aesmc %[out].16b, %[out].16b
47	\\ eor %[out].16b, %[out].16b, %[rk].16b
48	: [out] "=&x" (-> BlockVec)
49	: [in] "x" (block.repr),
50	[rk] "x" (round_key.repr),
51	[zero] "x" (zero)
52	),
53	};
54	}
55
56	/// Encrypt a block with the last round key.
57	pub inline fn encryptLast(block: Block, round_key: Block) Block {
58	return Block{
59	.repr = asm (
60	\\ mov %[out].16b, %[in].16b
61	\\ aese %[out].16b, %[zero].16b
62	\\ eor %[out].16b, %[out].16b, %[rk].16b
63	: [out] "=&x" (-> BlockVec)
64	: [in] "x" (block.repr),
65	[rk] "x" (round_key.repr),
66	[zero] "x" (zero)
67	),
68	};
69	}
70
71	/// Decrypt a block with a round key.
72	pub inline fn decrypt(block: Block, inv_round_key: Block) Block {
73	return Block{
74	.repr = asm (
75	\\ mov %[out].16b, %[in].16b
76	\\ aesd %[out].16b, %[zero].16b
77	\\ aesimc %[out].16b, %[out].16b
78	\\ eor %[out].16b, %[out].16b, %[rk].16b
79	: [out] "=&x" (-> BlockVec)
80	: [in] "x" (block.repr),
81	[rk] "x" (inv_round_key.repr),
82	[zero] "x" (zero)
83	),
84	};
85	}
86
87	/// Decrypt a block with the last round key.
88	pub inline fn decryptLast(block: Block, inv_round_key: Block) Block {
89	return Block{
90	.repr = asm (
91	\\ mov %[out].16b, %[in].16b
92	\\ aesd %[out].16b, %[zero].16b
93	\\ eor %[out].16b, %[out].16b, %[rk].16b
94	: [out] "=&x" (-> BlockVec)
95	: [in] "x" (block.repr),
96	[rk] "x" (inv_round_key.repr),
97	[zero] "x" (zero)
98	),
99	};
100	}
101
102	/// Apply the bitwise XOR operation to the content of two blocks.
103	pub inline fn xorBlocks(block1: Block, block2: Block) Block {
104	return Block{ .repr = block1.repr ^ block2.repr };
105	}
106
107	/// Apply the bitwise AND operation to the content of two blocks.
108	pub inline fn andBlocks(block1: Block, block2: Block) Block {
109	return Block{ .repr = block1.repr & block2.repr };
110	}
111
112	/// Apply the bitwise OR operation to the content of two blocks.
113	pub inline fn orBlocks(block1: Block, block2: Block) Block {
114	return Block{ .repr = block1.repr \| block2.repr };
115	}
116
117	/// Perform operations on multiple blocks in parallel.
118	pub const parallel = struct {
119	/// The recommended number of AES encryption/decryption to perform in parallel for the chosen implementation.
120	pub const optimal_parallel_blocks = 8;
121
122	/// Encrypt multiple blocks in parallel, each their own round key.
123	pub inline fn encryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block {
124	comptime var i = 0;
125	var out: [count]Block = undefined;
126	inline while (i < count) : (i += 1) {
127	out[i] = blocks[i].encrypt(round_keys[i]);
128	}
129	return out;
130	}
131
132	/// Decrypt multiple blocks in parallel, each their own round key.
133	pub inline fn decryptParallel(comptime count: usize, blocks: [count]Block, round_keys: [count]Block) [count]Block {
134	comptime var i = 0;
135	var out: [count]Block = undefined;
136	inline while (i < count) : (i += 1) {
137	out[i] = blocks[i].decrypt(round_keys[i]);
138	}
139	return out;
140	}
141
142	/// Encrypt multple blocks in parallel with the same round key.
143	pub inline fn encryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
144	comptime var i = 0;
145	var out: [count]Block = undefined;
146	inline while (i < count) : (i += 1) {
147	out[i] = blocks[i].encrypt(round_key);
148	}
149	return out;
150	}
151
152	/// Decrypt multple blocks in parallel with the same round key.
153	pub inline fn decryptWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
154	comptime var i = 0;
155	var out: [count]Block = undefined;
156	inline while (i < count) : (i += 1) {
157	out[i] = blocks[i].decrypt(round_key);
158	}
159	return out;
160	}
161
162	/// Encrypt multple blocks in parallel with the same last round key.
163	pub inline fn encryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
164	comptime var i = 0;
165	var out: [count]Block = undefined;
166	inline while (i < count) : (i += 1) {
167	out[i] = blocks[i].encryptLast(round_key);
168	}
169	return out;
170	}
171
172	/// Decrypt multple blocks in parallel with the same last round key.
173	pub inline fn decryptLastWide(comptime count: usize, blocks: [count]Block, round_key: Block) [count]Block {
174	comptime var i = 0;
175	var out: [count]Block = undefined;
176	inline while (i < count) : (i += 1) {
177	out[i] = blocks[i].decryptLast(round_key);
178	}
179	return out;
180	}
181	};
182	};
183
184	fn KeySchedule(comptime AES: type) type {
185	std.debug.assert(AES.rounds == 10 or AES.rounds == 14);
186	const rounds = AES.rounds;
187
188	return struct {
189	const Self = @This();
190
191	const zero = Vector(2, u64){ 0, 0 };
192	const mask1 = @Vector(16, u8){ 13, 14, 15, 12, 13, 14, 15, 12, 13, 14, 15, 12, 13, 14, 15, 12 };
193	const mask2 = @Vector(16, u8){ 12, 13, 14, 15, 12, 13, 14, 15, 12, 13, 14, 15, 12, 13, 14, 15 };
194
195	round_keys: [rounds + 1]Block,
196
197	fn drc128(comptime rc: u8, t: BlockVec) BlockVec {
198	var v1: BlockVec = undefined;
199	var v2: BlockVec = undefined;
200	var v3: BlockVec = undefined;
201	var v4: BlockVec = undefined;
202
203	return asm (
204	\\ movi %[v2].4s, %[rc]
205	\\ tbl %[v4].16b, {%[t].16b}, %[mask].16b
206	\\ ext %[r].16b, %[zero].16b, %[t].16b, #12
207	\\ aese %[v4].16b, %[zero].16b
208	\\ eor %[v2].16b, %[r].16b, %[v2].16b
209	\\ ext %[r].16b, %[zero].16b, %[r].16b, #12
210	\\ eor %[v1].16b, %[v2].16b, %[t].16b
211	\\ ext %[v3].16b, %[zero].16b, %[r].16b, #12
212	\\ eor %[v1].16b, %[v1].16b, %[r].16b
213	\\ eor %[r].16b, %[v1].16b, %[v3].16b
214	\\ eor %[r].16b, %[r].16b, %[v4].16b
215	: [r] "=&x" (-> BlockVec),
216	[v1] "=&x" (v1),
217	[v2] "=&x" (v2),
218	[v3] "=&x" (v3),
219	[v4] "=&x" (v4)
220	: [rc] "N" (rc),
221	[t] "x" (t),
222	[zero] "x" (zero),
223	[mask] "x" (mask1)
224	);
225	}
226
227	fn drc256(comptime second: bool, comptime rc: u8, t: BlockVec, tx: BlockVec) BlockVec {
228	var v1: BlockVec = undefined;
229	var v2: BlockVec = undefined;
230	var v3: BlockVec = undefined;
231	var v4: BlockVec = undefined;
232
233	return asm (
234	\\ movi %[v2].4s, %[rc]
235	\\ tbl %[v4].16b, {%[t].16b}, %[mask].16b
236	\\ ext %[r].16b, %[zero].16b, %[tx].16b, #12
237	\\ aese %[v4].16b, %[zero].16b
238	\\ eor %[v1].16b, %[tx].16b, %[r].16b
239	\\ ext %[r].16b, %[zero].16b, %[r].16b, #12
240	\\ eor %[v1].16b, %[v1].16b, %[r].16b
241	\\ ext %[v3].16b, %[zero].16b, %[r].16b, #12
242	\\ eor %[v1].16b, %[v1].16b, %[v2].16b
243	\\ eor %[v1].16b, %[v1].16b, %[v3].16b
244	\\ eor %[r].16b, %[v1].16b, %[v4].16b
245	: [r] "=&x" (-> BlockVec),
246	[v1] "=&x" (v1),
247	[v2] "=&x" (v2),
248	[v3] "=&x" (v3),
249	[v4] "=&x" (v4)
250	: [rc] "N" (if (second) @as(u8, 0) else rc),
251	[t] "x" (t),
252	[tx] "x" (tx),
253	[zero] "x" (zero),
254	[mask] "x" (if (second) mask2 else mask1)
255	);
256	}
257
258	fn expand128(t1: *Block) Self {
259	var round_keys: [11]Block = undefined;
260	const rcs = [_]u8{ 1, 2, 4, 8, 16, 32, 64, 128, 27, 54 };
261	inline for (rcs) \|rc, round\| {
262	round_keys[round] = t1.*;
263	t1.repr = drc128(rc, t1.repr);
264	}
265	round_keys[rcs.len] = t1.*;
266	return Self{ .round_keys = round_keys };
267	}
268
269	fn expand256(t1: Block, t2: Block) Self {
270	var round_keys: [15]Block = undefined;
271	const rcs = [_]u8{ 1, 2, 4, 8, 16, 32 };
272	round_keys[0] = t1.*;
273	inline for (rcs) \|rc, round\| {
274	round_keys[round * 2 + 1] = t2.*;
275	t1.repr = drc256(false, rc, t2.repr, t1.repr);
276	round_keys[round * 2 + 2] = t1.*;
277	t2.repr = drc256(true, rc, t1.repr, t2.repr);
278	}
279	round_keys[rcs.len * 2 + 1] = t2.*;
280	t1.repr = drc256(false, 64, t2.repr, t1.repr);
281	round_keys[rcs.len * 2 + 2] = t1.*;
282	return Self{ .round_keys = round_keys };
283	}
284
285	/// Invert the key schedule.
286	pub fn invert(key_schedule: Self) Self {
287	const round_keys = &key_schedule.round_keys;
288	var inv_round_keys: [rounds + 1]Block = undefined;
289	inv_round_keys[0] = round_keys[rounds];
290	comptime var i = 1;
291	inline while (i < rounds) : (i += 1) {
292	inv_round_keys[i] = Block{
293	.repr = asm (
294	\\ aesimc %[inv_rk].16b, %[rk].16b
295	: [inv_rk] "=x" (-> BlockVec)
296	: [rk] "x" (round_keys[rounds - i].repr)
297	),
298	};
299	}
300	inv_round_keys[rounds] = round_keys[0];
301	return Self{ .round_keys = inv_round_keys };
302	}
303	};
304	}
305
306	/// A context to perform encryption using the standard AES key schedule.
307	pub fn AESEncryptCtx(comptime AES: type) type {
308	std.debug.assert(AES.key_bits == 128 or AES.key_bits == 256);
309	const rounds = AES.rounds;
310
311	return struct {
312	const Self = @This();
313	pub const block = AES.block;
314	pub const block_size = block.block_size;
315	key_schedule: KeySchedule(AES),
316
317	/// Create a new encryption context with the given key.
318	pub fn init(key: [AES.key_bits / 8]u8) Self {
319	var t1 = Block.fromBytes(key[0..16]);
320	const key_schedule = if (AES.key_bits == 128) ks: {
321	break :ks KeySchedule(AES).expand128(&t1);
322	} else ks: {
323	var t2 = Block.fromBytes(key[16..32]);
324	break :ks KeySchedule(AES).expand256(&t1, &t2);
325	};
326	return Self{
327	.key_schedule = key_schedule,
328	};
329	}
330
331	/// Encrypt a single block.
332	pub fn encrypt(ctx: Self, dst: [16]u8, src: const [16]u8) void {
333	const round_keys = ctx.key_schedule.round_keys;
334	var t = Block.fromBytes(src).xorBlocks(round_keys[0]);
335	comptime var i = 1;
336	inline while (i < rounds) : (i += 1) {
337	t = t.encrypt(round_keys[i]);
338	}
339	t = t.encryptLast(round_keys[rounds]);
340	dst.* = t.toBytes();
341	}
342
343	/// Encrypt+XOR a single block.
344	pub fn xor(ctx: Self, dst: [16]u8, src: const [16]u8, counter: [16]u8) void {
345	const round_keys = ctx.key_schedule.round_keys;
346	var t = Block.fromBytes(&counter).xorBlocks(round_keys[0]);
347	comptime var i = 1;
348	inline while (i < rounds) : (i += 1) {
349	t = t.encrypt(round_keys[i]);
350	}
351	t = t.encryptLast(round_keys[rounds]);
352	dst.* = t.xorBytes(src);
353	}
354
355	/// Encrypt multiple blocks, possibly leveraging parallelization.
356	pub fn encryptWide(ctx: Self, comptime count: usize, dst: [16 count]u8, src: const [16 count]u8) void {
357	const round_keys = ctx.key_schedule.round_keys;
358	var ts: [count]Block = undefined;
359	comptime var j = 0;
360	inline while (j < count) : (j += 1) {
361	ts[j] = Block.fromBytes(src[j * 16 .. j * 16 + 16][0..16]).xorBlocks(round_keys[0]);
362	}
363	comptime var i = 1;
364	inline while (i < rounds) : (i += 1) {
365	ts = Block.parallel.encryptWide(count, ts, round_keys[i]);
366	}
367	i = 1;
368	inline while (i < count) : (i += 1) {
369	ts = Block.parallel.encryptLastWide(count, ts, round_keys[i]);
370	}
371	j = 0;
372	inline while (j < count) : (j += 1) {
373	dst[16 * j .. 16 * j + 16].* = ts[j].toBytes();
374	}
375	}
376
377	/// Encrypt+XOR multiple blocks, possibly leveraging parallelization.
378	pub fn xorWide(ctx: Self, comptime count: usize, dst: [16 count]u8, src: const [16 count]u8, counters: [16 * count]u8) void {
379	const round_keys = ctx.key_schedule.round_keys;
380	var ts: [count]Block = undefined;
381	comptime var j = 0;
382	inline while (j < count) : (j += 1) {
383	ts[j] = Block.fromBytes(counters[j * 16 .. j * 16 + 16][0..16]).xorBlocks(round_keys[0]);
384	}
385	comptime var i = 1;
386	inline while (i < rounds) : (i += 1) {
387	ts = Block.parallel.encryptWide(count, ts, round_keys[i]);
388	}
389	ts = Block.parallel.encryptLastWide(count, ts, round_keys[i]);
390	j = 0;
391	inline while (j < count) : (j += 1) {
392	dst[16 * j .. 16 * j + 16].* = ts[j].xorBytes(src[16 * j .. 16 * j + 16]);
393	}
394	}
395	};
396	}
397
398	/// A context to perform decryption using the standard AES key schedule.
399	pub fn AESDecryptCtx(comptime AES: type) type {
400	std.debug.assert(AES.key_bits == 128 or AES.key_bits == 256);
401	const rounds = AES.rounds;
402
403	return struct {
404	const Self = @This();
405	pub const block = AES.block;
406	pub const block_size = block.block_size;
407	key_schedule: KeySchedule(AES),
408
409	/// Create a decryption context from an existing encryption context.
410	pub fn initFromEnc(ctx: AESEncryptCtx(AES)) Self {
411	return Self{
412	.key_schedule = ctx.key_schedule.invert(),
413	};
414	}
415
416	/// Create a new decryption context with the given key.
417	pub fn init(key: [AES.key_bits / 8]u8) Self {
418	const enc_ctx = AESEncryptCtx(AES).init(key);
419	return initFromEnc(enc_ctx);
420	}
421
422	/// Decrypt a single block.
423	pub fn decrypt(ctx: Self, dst: [16]u8, src: const [16]u8) void {
424	const inv_round_keys = ctx.key_schedule.round_keys;
425	var t = Block.fromBytes(src).xorBlocks(inv_round_keys[0]);
426	comptime var i = 1;
427	inline while (i < rounds) : (i += 1) {
428	t = t.decrypt(inv_round_keys[i]);
429	}
430	t = t.decryptLast(inv_round_keys[rounds]);
431	dst.* = t.toBytes();
432	}
433
434	/// Decrypt multiple blocks, possibly leveraging parallelization.
435	pub fn decryptWide(ctx: Self, comptime count: usize, dst: [16 count]u8, src: const [16 count]u8) void {
436	const inv_round_keys = ctx.key_schedule.round_keys;
437	var ts: [count]Block = undefined;
438	comptime var j = 0;
439	inline while (j < count) : (j += 1) {
440	ts[j] = Block.fromBytes(src[j * 16 .. j * 16 + 16][0..16]).xorBlocks(inv_round_keys[0]);
441	}
442	comptime var i = 1;
443	inline while (i < rounds) : (i += 1) {
444	ts = Block.parallel.decryptWide(count, ts, inv_round_keys[i]);
445	}
446	i = 1;
447	inline while (i < count) : (i += 1) {
448	ts = Block.parallel.decryptLastWide(count, ts, inv_round_keys[i]);
449	}
450	j = 0;
451	inline while (j < count) : (j += 1) {
452	dst[16 * j .. 16 * j + 16].* = ts[j].toBytes();
453	}
454	}
455	};
456	}
457
458	/// AES-128 with the standard key schedule.
459	pub const AES128 = struct {
460	pub const key_bits: usize = 128;
461	pub const rounds = ((key_bits - 64) / 32 + 8);
462	pub const block = Block;
463
464	/// Create a new context for encryption.
465	pub fn initEnc(key: [key_bits / 8]u8) AESEncryptCtx(AES128) {
466	return AESEncryptCtx(AES128).init(key);
467	}
468
469	/// Create a new context for decryption.
470	pub fn initDec(key: [key_bits / 8]u8) AESDecryptCtx(AES128) {
471	return AESDecryptCtx(AES128).init(key);
472	}
473	};
474
475	/// AES-256 with the standard key schedule.
476	pub const AES256 = struct {
477	pub const key_bits: usize = 256;
478	pub const rounds = ((key_bits - 64) / 32 + 8);
479	pub const block = Block;
480
481	/// Create a new context for encryption.
482	pub fn initEnc(key: [key_bits / 8]u8) AESEncryptCtx(AES256) {
483	return AESEncryptCtx(AES256).init(key);
484	}
485
486	/// Create a new context for decryption.
487	pub fn initDec(key: [key_bits / 8]u8) AESDecryptCtx(AES256) {
488	return AESDecryptCtx(AES256).init(key);
489	}
490	};

lib/std/crypto/ghash.zig+19-1

...	@@ -105,6 +105,17 @@ pub const Ghash = struct {	...	@@ -105,6 +105,17 @@ pub const Ghash = struct {
105	return product[0];	105	return product[0];
106	}	106	}
107		107
		108	inline fn clmul_pmull(x: u64, y: u64) u64 {
		109	const Vector = std.meta.Vector;
		110	const product = asm (
		111	\\ pmull %[out].1q, %[x].1d, %[y].1d
		112	: [out] "=w" (-> Vector(2, u64))
		113	: [x] "w" (@bitCast(Vector(2, u64), @as(u128, x))),
		114	[y] "w" (@bitCast(Vector(2, u64), @as(u128, y)))
		115	);
		116	return product[0];
		117	}
		118
108	fn clmul_soft(x: u64, y: u64) u64 {	119	fn clmul_soft(x: u64, y: u64) u64 {
109	const x0 = x & 0x1111111111111111;	120	const x0 = x & 0x1111111111111111;
110	const x1 = x & 0x2222222222222222;	121	const x1 = x & 0x2222222222222222;
...	@@ -127,7 +138,14 @@ pub const Ghash = struct {	...	@@ -127,7 +138,14 @@ pub const Ghash = struct {
127		138
128	const has_pclmul = comptime std.Target.x86.featureSetHas(std.Target.current.cpu.features, .pclmul);	139	const has_pclmul = comptime std.Target.x86.featureSetHas(std.Target.current.cpu.features, .pclmul);
129	const has_avx = comptime std.Target.x86.featureSetHas(std.Target.current.cpu.features, .avx);	140	const has_avx = comptime std.Target.x86.featureSetHas(std.Target.current.cpu.features, .avx);
130	const clmul = if (std.Target.current.cpu.arch == .x86_64 and has_pclmul and has_avx) clmul_pclmul else clmul_soft;	141	const has_armaes = comptime std.Target.aarch64.featureSetHas(std.Target.current.cpu.features, .aes);
		142	const clmul = if (std.Target.current.cpu.arch == .x86_64 and has_pclmul and has_avx) impl: {
		143	break :impl clmul_pclmul;
		144	} else if (std.Target.current.cpu.arch == .aarch64 and has_armaes) impl: {
		145	break :impl clmul_pmull;
		146	} else impl: {
		147	break :impl clmul_soft;
		148	};
131		149
132	fn blocks(st: *Ghash, msg: []const u8) void {	150	fn blocks(st: *Ghash, msg: []const u8) void {
133	assert(msg.len % 16 == 0); // GHASH blocks() expects full blocks	151	assert(msg.len % 16 == 0); // GHASH blocks() expects full blocks

lib/std/event.zig+2

...	@@ -12,6 +12,7 @@ pub const Locked = @import("event/locked.zig").Locked;	...	@@ -12,6 +12,7 @@ pub const Locked = @import("event/locked.zig").Locked;
12	pub const RwLock = @import("event/rwlock.zig").RwLock;	12	pub const RwLock = @import("event/rwlock.zig").RwLock;
13	pub const RwLocked = @import("event/rwlocked.zig").RwLocked;	13	pub const RwLocked = @import("event/rwlocked.zig").RwLocked;
14	pub const Loop = @import("event/loop.zig").Loop;	14	pub const Loop = @import("event/loop.zig").Loop;
		15	pub const WaitGroup = @import("event/WaitGroup.zig").WaitGroup;
15		16
16	test "import event tests" {	17	test "import event tests" {
17	_ = @import("event/channel.zig");	18	_ = @import("event/channel.zig");
...	@@ -23,4 +24,5 @@ test "import event tests" {	...	@@ -23,4 +24,5 @@ test "import event tests" {
23	_ = @import("event/rwlock.zig");	24	_ = @import("event/rwlock.zig");
24	_ = @import("event/rwlocked.zig");	25	_ = @import("event/rwlocked.zig");
25	_ = @import("event/loop.zig");	26	_ = @import("event/loop.zig");
		27	_ = @import("event/wait_group.zig");
26	}	28	}

lib/std/event/loop.zig+2

 @@ -660,9 +660,11 @@ pub const Loop = struct {
         const Wrapper = struct {
             const Args = @TypeOf(args);
             fn run(func_args: Args, loop: *Loop, allocator: *mem.Allocator) void {
+                loop.beginOneEvent();
                 loop.yield();
                 const result = @call(.{}, func, func_args);
                 suspend {
+                    loop.finishOneEvent();
                     allocator.destroy(@frame());
                 }
             }

lib/std/event/wait_group.zig created+120

...	@@ -0,0 +1,120 @@
1	// SPDX-License-Identifier: MIT
2	// Copyright (c) 2015-2020 Zig Contributors
3	// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
4	// The MIT license requires this copyright notice to be included in all copies
5	// and substantial portions of the software.
6	const std = @import("../std.zig");
7	const builtin = @import("builtin");
8	const Loop = std.event.Loop;
9
10	/// A WaitGroup keeps track and waits for a group of async tasks to finish.
11	/// Call `begin` when creating new tasks, and have tasks call `finish` when done.
12	/// You can provide a count for both operations to perform them in bulk.
13	/// Call `wait` to suspend until all tasks are completed.
14	/// Multiple waiters are supported.
15	///
16	/// WaitGroup is an instance of WaitGroupGeneric, which takes in a bitsize
17	/// for the internal counter. WaitGroup defaults to a `usize` counter.
18	/// It's also possible to define a max value for the counter so that
19	/// `begin` will return error.Overflow when the limit is reached, even
20	/// if the integer type has not has not overflowed.
21	/// By default `max_value` is set to std.math.maxInt(CounterType).
22	pub const WaitGroup = WaitGroupGeneric(std.meta.bitCount(usize));
23
24	pub fn WaitGroupGeneric(comptime counter_size: u16) type {
25	const CounterType = std.meta.Int(false, counter_size);
26
27	const global_event_loop = Loop.instance orelse
28	@compileError("std.event.WaitGroup currently only works with event-based I/O");
29
30	return struct {
31	counter: CounterType = 0,
32	max_counter: CounterType = std.math.maxInt(CounterType),
33	mutex: std.Mutex = .{},
34	waiters: ?*Waiter = null,
35	const Waiter = struct {
36	next: ?*Waiter,
37	tail: *Waiter,
38	node: Loop.NextTickNode,
39	};
40
41	const Self = @This();
42	pub fn begin(self: *Self, count: CounterType) error{Overflow}!void {
43	const held = self.mutex.acquire();
44	defer held.release();
45
46	const new_counter = try std.math.add(CounterType, self.counter, count);
47	if (new_counter > self.max_counter) return error.Overflow;
48	self.counter = new_counter;
49	}
50
51	pub fn finish(self: *Self, count: CounterType) void {
52	var waiters = blk: {
53	const held = self.mutex.acquire();
54	defer held.release();
55	self.counter = std.math.sub(CounterType, self.counter, count) catch unreachable;
56	if (self.counter == 0) {
57	const temp = self.waiters;
58	self.waiters = null;
59	break :blk temp;
60	}
61	break :blk null;
62	};
63
64	// We don't need to hold the lock to reschedule any potential waiter.
65	while (waiters) \|w\| {
66	const temp_w = w;
67	waiters = w.next;
68	global_event_loop.onNextTick(&temp_w.node);
69	}
70	}
71
72	pub fn wait(self: *Self) void {
73	const held = self.mutex.acquire();
74
75	if (self.counter == 0) {
76	held.release();
77	return;
78	}
79
80	var self_waiter: Waiter = undefined;
81	self_waiter.node.data = @frame();
82	if (self.waiters) \|head\| {
83	head.tail.next = &self_waiter;
84	head.tail = &self_waiter;
85	} else {
86	self.waiters = &self_waiter;
87	self_waiter.tail = &self_waiter;
88	self_waiter.next = null;
89	}
90	suspend {
91	held.release();
92	}
93	}
94	};
95	}
96
97	test "basic WaitGroup usage" {
98	if (!std.io.is_async) return error.SkipZigTest;
99
100	// TODO https://github.com/ziglang/zig/issues/1908
101	if (builtin.single_threaded) return error.SkipZigTest;
102
103	// TODO https://github.com/ziglang/zig/issues/3251
104	if (builtin.os.tag == .freebsd) return error.SkipZigTest;
105
106	var initial_wg = WaitGroup{};
107	var final_wg = WaitGroup{};
108
109	try initial_wg.begin(1);
110	try final_wg.begin(1);
111	var task_frame = async task(&initial_wg, &final_wg);
112	initial_wg.finish(1);
113	final_wg.wait();
114	await task_frame;
115	}
116
117	fn task(wg_i: WaitGroup, wg_f: WaitGroup) void {
118	wg_i.wait();
119	wg_f.finish(1);
120	}

lib/std/fmt.zig+5-2

 @@ -1181,13 +1181,16 @@ fn bufPrintIntToSlice(buf: []u8, value: anytype, base: u8, uppercase: bool, opti
     return buf[0..formatIntBuf(buf, value, base, uppercase, options)];
 }
-pub fn comptimePrint(comptime fmt: []const u8, args: anytype) *const [count(fmt, args)]u8 {
+pub fn comptimePrint(comptime fmt: []const u8, args: anytype) *const [count(fmt, args):0]u8 {
-    comptime var buf: [count(fmt, args)]u8 = undefined;
+    comptime var buf: [count(fmt, args):0]u8 = undefined;
     _ = bufPrint(&buf, fmt, args) catch unreachable;
+    buf[buf.len] = 0;
     return &buf;
 }
 test "comptimePrint" {
+    @setEvalBranchQuota(2000);
+    std.testing.expectEqual(*const [3:0]u8, @TypeOf(comptime comptimePrint("{}", .{100})));
     std.testing.expectEqualSlices(u8, "100", comptime comptimePrint("{}", .{100}));
 }

lib/std/math.zig+12-1

...	@@ -110,7 +110,12 @@ pub fn approxEq(comptime T: type, x: T, y: T, epsilon: T) bool {	...	@@ -110,7 +110,12 @@ pub fn approxEq(comptime T: type, x: T, y: T, epsilon: T) bool {
110	}	110	}
111		111
112	pub fn doNotOptimizeAway(value: anytype) void {	112	pub fn doNotOptimizeAway(value: anytype) void {
113	mem.doNotOptimizeAway(value);	113	// TODO: use @declareSideEffect() when it is available.
		114	// https://github.com/ziglang/zig/issues/6168
		115	const T = @TypeOf(value);
		116	var x: T = undefined;
		117	const p = @ptrCast(*volatile T, &x);
		118	p.* = x;
114	}	119	}
115		120
116	pub fn raiseInvalid() void {	121	pub fn raiseInvalid() void {
...	@@ -1131,3 +1136,9 @@ test "compare between signed and unsigned" {	...	@@ -1131,3 +1136,9 @@ test "compare between signed and unsigned" {
1131	testing.expect(!compare(@as(u8, 255), .eq, @as(i8, -1)));	1136	testing.expect(!compare(@as(u8, 255), .eq, @as(i8, -1)));
1132	testing.expect(compare(@as(u8, 1), .eq, @as(u8, 1)));	1137	testing.expect(compare(@as(u8, 1), .eq, @as(u8, 1)));
1133	}	1138	}
		1139
		1140	test "math.comptime" {
		1141	comptime const v = sin(@as(f32, 1)) + ln(@as(f32, 5));
		1142	testing.expect(v == sin(@as(f32, 1)) + ln(@as(f32, 5)));
		1143	}
		1144

lib/std/os/linux/bpf/kern.zig+25-25

...	@@ -12,28 +12,28 @@ const in_bpf_program = switch (std.builtin.arch) {	...	@@ -12,28 +12,28 @@ const in_bpf_program = switch (std.builtin.arch) {
12		12
13	pub const helpers = if (in_bpf_program) @import("helpers.zig") else struct {};	13	pub const helpers = if (in_bpf_program) @import("helpers.zig") else struct {};
14		14
15	pub const BpfSock = @Type(.Opaque);	15	pub const BpfSock = opaque {};
16	pub const BpfSockAddr = @Type(.Opaque);	16	pub const BpfSockAddr = opaque {};
17	pub const FibLookup = @Type(.Opaque);	17	pub const FibLookup = opaque {};
18	pub const MapDef = @Type(.Opaque);	18	pub const MapDef = opaque {};
19	pub const PerfEventData = @Type(.Opaque);	19	pub const PerfEventData = opaque {};
20	pub const PerfEventValue = @Type(.Opaque);	20	pub const PerfEventValue = opaque {};
21	pub const PidNsInfo = @Type(.Opaque);	21	pub const PidNsInfo = opaque {};
22	pub const SeqFile = @Type(.Opaque);	22	pub const SeqFile = opaque {};
23	pub const SkBuff = @Type(.Opaque);	23	pub const SkBuff = opaque {};
24	pub const SkMsgMd = @Type(.Opaque);	24	pub const SkMsgMd = opaque {};
25	pub const SkReusePortMd = @Type(.Opaque);	25	pub const SkReusePortMd = opaque {};
26	pub const Sock = @Type(.Opaque);	26	pub const Sock = opaque {};
27	pub const SockAddr = @Type(.Opaque);	27	pub const SockAddr = opaque {};
28	pub const SockOps = @Type(.Opaque);	28	pub const SockOps = opaque {};
29	pub const SockTuple = @Type(.Opaque);	29	pub const SockTuple = opaque {};
30	pub const SpinLock = @Type(.Opaque);	30	pub const SpinLock = opaque {};
31	pub const SysCtl = @Type(.Opaque);	31	pub const SysCtl = opaque {};
32	pub const Tcp6Sock = @Type(.Opaque);	32	pub const Tcp6Sock = opaque {};
33	pub const TcpRequestSock = @Type(.Opaque);	33	pub const TcpRequestSock = opaque {};
34	pub const TcpSock = @Type(.Opaque);	34	pub const TcpSock = opaque {};
35	pub const TcpTimewaitSock = @Type(.Opaque);	35	pub const TcpTimewaitSock = opaque {};
36	pub const TunnelKey = @Type(.Opaque);	36	pub const TunnelKey = opaque {};
37	pub const Udp6Sock = @Type(.Opaque);	37	pub const Udp6Sock = opaque {};
38	pub const XdpMd = @Type(.Opaque);	38	pub const XdpMd = opaque {};
39	pub const XfrmState = @Type(.Opaque);	39	pub const XfrmState = opaque {};

lib/std/os/uefi.zig+3-3

...	@@ -17,7 +17,7 @@ pub var handle: Handle = undefined;	...	@@ -17,7 +17,7 @@ pub var handle: Handle = undefined;
17	pub var system_table: *tables.SystemTable = undefined;	17	pub var system_table: *tables.SystemTable = undefined;
18		18
19	/// A handle to an event structure.	19	/// A handle to an event structure.
20	pub const Event = *@Type(.Opaque);	20	pub const Event = *opaque {};
21		21
22	/// GUIDs must be align(8)	22	/// GUIDs must be align(8)
23	pub const Guid = extern struct {	23	pub const Guid = extern struct {
...	@@ -51,7 +51,7 @@ pub const Guid = extern struct {	...	@@ -51,7 +51,7 @@ pub const Guid = extern struct {
51	};	51	};
52		52
53	/// An EFI Handle represents a collection of related interfaces.	53	/// An EFI Handle represents a collection of related interfaces.
54	pub const Handle = *@Type(.Opaque);	54	pub const Handle = *opaque {};
55		55
56	/// This structure represents time information.	56	/// This structure represents time information.
57	pub const Time = extern struct {	57	pub const Time = extern struct {
...	@@ -108,4 +108,4 @@ pub const TimeCapabilities = extern struct {	...	@@ -108,4 +108,4 @@ pub const TimeCapabilities = extern struct {
108	};	108	};
109		109
110	/// File Handle as specified in the EFI Shell Spec	110	/// File Handle as specified in the EFI Shell Spec
111	pub const FileHandle = *@Type(.Opaque);	111	pub const FileHandle = *opaque {};

lib/std/os/uefi/protocols/hii.zig+1-1

...	@@ -6,7 +6,7 @@	...	@@ -6,7 +6,7 @@
6	const uefi = @import("std").os.uefi;	6	const uefi = @import("std").os.uefi;
7	const Guid = uefi.Guid;	7	const Guid = uefi.Guid;
8		8
9	pub const HIIHandle = *@Type(.Opaque);	9	pub const HIIHandle = *opaque {};
10		10
11	/// The header found at the start of each package.	11	/// The header found at the start of each package.
12	pub const HIIPackageHeader = packed struct {	12	pub const HIIPackageHeader = packed struct {

lib/std/os/windows/bits.zig+15-15

...	@@ -32,16 +32,16 @@ pub const UCHAR = u8;	...	@@ -32,16 +32,16 @@ pub const UCHAR = u8;
32	pub const FLOAT = f32;	32	pub const FLOAT = f32;
33	pub const HANDLE = *c_void;	33	pub const HANDLE = *c_void;
34	pub const HCRYPTPROV = ULONG_PTR;	34	pub const HCRYPTPROV = ULONG_PTR;
35	pub const HBRUSH = *@Type(.Opaque);	35	pub const HBRUSH = *opaque {};
36	pub const HCURSOR = *@Type(.Opaque);	36	pub const HCURSOR = *opaque {};
37	pub const HICON = *@Type(.Opaque);	37	pub const HICON = *opaque {};
38	pub const HINSTANCE = *@Type(.Opaque);	38	pub const HINSTANCE = *opaque {};
39	pub const HMENU = *@Type(.Opaque);	39	pub const HMENU = *opaque {};
40	pub const HMODULE = *@Type(.Opaque);	40	pub const HMODULE = *opaque {};
41	pub const HWND = *@Type(.Opaque);	41	pub const HWND = *opaque {};
42	pub const HDC = *@Type(.Opaque);	42	pub const HDC = *opaque {};
43	pub const HGLRC = *@Type(.Opaque);	43	pub const HGLRC = *opaque {};
44	pub const FARPROC = *@Type(.Opaque);	44	pub const FARPROC = *opaque {};
45	pub const INT = c_int;	45	pub const INT = c_int;
46	pub const LPBYTE = *BYTE;	46	pub const LPBYTE = *BYTE;
47	pub const LPCH = *CHAR;	47	pub const LPCH = *CHAR;
...	@@ -81,7 +81,7 @@ pub const WPARAM = usize;	...	@@ -81,7 +81,7 @@ pub const WPARAM = usize;
81	pub const LPARAM = ?*c_void;	81	pub const LPARAM = ?*c_void;
82	pub const LRESULT = ?*c_void;	82	pub const LRESULT = ?*c_void;
83		83
84	pub const va_list = *@Type(.Opaque);	84	pub const va_list = *opaque {};
85		85
86	pub const TRUE = 1;	86	pub const TRUE = 1;
87	pub const FALSE = 0;	87	pub const FALSE = 0;
...	@@ -1175,10 +1175,10 @@ pub const UNICODE_STRING = extern struct {	...	@@ -1175,10 +1175,10 @@ pub const UNICODE_STRING = extern struct {
1175	Buffer: [*]WCHAR,	1175	Buffer: [*]WCHAR,
1176	};	1176	};
1177		1177
1178	const ACTIVATION_CONTEXT_DATA = @Type(.Opaque);	1178	const ACTIVATION_CONTEXT_DATA = opaque {};
1179	const ASSEMBLY_STORAGE_MAP = @Type(.Opaque);	1179	const ASSEMBLY_STORAGE_MAP = opaque {};
1180	const FLS_CALLBACK_INFO = @Type(.Opaque);	1180	const FLS_CALLBACK_INFO = opaque {};
1181	const RTL_BITMAP = @Type(.Opaque);	1181	const RTL_BITMAP = opaque {};
1182	pub const PRTL_BITMAP = *RTL_BITMAP;	1182	pub const PRTL_BITMAP = *RTL_BITMAP;
1183	const KAFFINITY = usize;	1183	const KAFFINITY = usize;
1184		1184

lib/std/os/windows/ws2_32.zig+1-1

...	@@ -5,7 +5,7 @@	...	@@ -5,7 +5,7 @@
5	// and substantial portions of the software.	5	// and substantial portions of the software.
6	usingnamespace @import("bits.zig");	6	usingnamespace @import("bits.zig");
7		7
8	pub const SOCKET = *@Type(.Opaque);	8	pub const SOCKET = *opaque {};
9	pub const INVALID_SOCKET = @intToPtr(SOCKET, ~@as(usize, 0));	9	pub const INVALID_SOCKET = @intToPtr(SOCKET, ~@as(usize, 0));
10	pub const SOCKET_ERROR = -1;	10	pub const SOCKET_ERROR = -1;
11		11

lib/std/zig/ast.zig+1-1

...	@@ -288,7 +288,7 @@ pub const Error = union(enum) {	...	@@ -288,7 +288,7 @@ pub const Error = union(enum) {
288	pub const ExpectedVarDecl = SingleTokenError("Expected variable declaration, found '{}'");	288	pub const ExpectedVarDecl = SingleTokenError("Expected variable declaration, found '{}'");
289	pub const ExpectedFn = SingleTokenError("Expected function, found '{}'");	289	pub const ExpectedFn = SingleTokenError("Expected function, found '{}'");
290	pub const ExpectedReturnType = SingleTokenError("Expected 'var' or return type expression, found '{}'");	290	pub const ExpectedReturnType = SingleTokenError("Expected 'var' or return type expression, found '{}'");
291	pub const ExpectedAggregateKw = SingleTokenError("Expected '" ++ Token.Id.Keyword_struct.symbol() ++ "', '" ++ Token.Id.Keyword_union.symbol() ++ "', or '" ++ Token.Id.Keyword_enum.symbol() ++ "', found '{}'");	291	pub const ExpectedAggregateKw = SingleTokenError("Expected '" ++ Token.Id.Keyword_struct.symbol() ++ "', '" ++ Token.Id.Keyword_union.symbol() ++ "', '" ++ Token.Id.Keyword_enum.symbol() ++ "', or '" ++ Token.Id.Keyword_opaque.symbol() ++ "', found '{}'");
292	pub const ExpectedEqOrSemi = SingleTokenError("Expected '=' or ';', found '{}'");	292	pub const ExpectedEqOrSemi = SingleTokenError("Expected '=' or ';', found '{}'");
293	pub const ExpectedSemiOrLBrace = SingleTokenError("Expected ';' or '{{', found '{}'");	293	pub const ExpectedSemiOrLBrace = SingleTokenError("Expected ';' or '{{', found '{}'");
294	pub const ExpectedSemiOrElse = SingleTokenError("Expected ';' or 'else', found '{}'");	294	pub const ExpectedSemiOrElse = SingleTokenError("Expected ';' or 'else', found '{}'");

lib/std/zig/parse.zig+2-1

 @@ -2896,11 +2896,12 @@ const Parser = struct {
     ///     <- KEYWORD_struct
     ///      / KEYWORD_enum (LPAREN Expr RPAREN)?
     ///      / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)?
+    ///      / KEYWORD_opaque
     fn parseContainerDeclType(p: *Parser) !?ContainerDeclType {
         const kind_token = p.nextToken();
         const init_arg_expr = switch (p.token_ids[kind_token]) {
-            .Keyword_struct => Node.ContainerDecl.InitArg{ .None = {} },
+            .Keyword_struct, .Keyword_opaque => Node.ContainerDecl.InitArg{ .None = {} },
             .Keyword_enum => blk: {
                 if (p.eatToken(.LParen) != null) {
                     const expr = try p.expectNode(parseExpr, .{

lib/std/zig/render.zig+13-1

...	@@ -1492,7 +1492,19 @@ fn renderExpression(	...	@@ -1492,7 +1492,19 @@ fn renderExpression(
1492		1492
1493	// TODO remove after 0.7.0 release	1493	// TODO remove after 0.7.0 release
1494	if (mem.eql(u8, tree.tokenSlice(builtin_call.builtin_token), "@OpaqueType"))	1494	if (mem.eql(u8, tree.tokenSlice(builtin_call.builtin_token), "@OpaqueType"))
1495	return ais.writer().writeAll("@Type(.Opaque)");	1495	return ais.writer().writeAll("opaque {}");
		1496
		1497	// TODO remove after 0.7.0 release
		1498	{
		1499	const params = builtin_call.paramsConst();
		1500	if (mem.eql(u8, tree.tokenSlice(builtin_call.builtin_token), "@Type") and
		1501	params.len == 1)
		1502	{
		1503	if (params[0].castTag(.EnumLiteral)) \|enum_literal\|
		1504	if (mem.eql(u8, tree.tokenSlice(enum_literal.name), "Opaque"))
		1505	return ais.writer().writeAll("opaque {}");
		1506	}
		1507	}
1496		1508
1497	try renderToken(tree, ais, builtin_call.builtin_token, Space.None); // @name	1509	try renderToken(tree, ais, builtin_call.builtin_token, Space.None); // @name
1498		1510

lib/std/zig/tokenizer.zig+3

...	@@ -47,6 +47,7 @@ pub const Token = struct {	...	@@ -47,6 +47,7 @@ pub const Token = struct {
47	.{ "noinline", .Keyword_noinline },	47	.{ "noinline", .Keyword_noinline },
48	.{ "nosuspend", .Keyword_nosuspend },	48	.{ "nosuspend", .Keyword_nosuspend },
49	.{ "null", .Keyword_null },	49	.{ "null", .Keyword_null },
		50	.{ "opaque", .Keyword_opaque },
50	.{ "or", .Keyword_or },	51	.{ "or", .Keyword_or },
51	.{ "orelse", .Keyword_orelse },	52	.{ "orelse", .Keyword_orelse },
52	.{ "packed", .Keyword_packed },	53	.{ "packed", .Keyword_packed },
...	@@ -173,6 +174,7 @@ pub const Token = struct {	...	@@ -173,6 +174,7 @@ pub const Token = struct {
173	Keyword_noinline,	174	Keyword_noinline,
174	Keyword_nosuspend,	175	Keyword_nosuspend,
175	Keyword_null,	176	Keyword_null,
		177	Keyword_opaque,
176	Keyword_or,	178	Keyword_or,
177	Keyword_orelse,	179	Keyword_orelse,
178	Keyword_packed,	180	Keyword_packed,
...	@@ -296,6 +298,7 @@ pub const Token = struct {	...	@@ -296,6 +298,7 @@ pub const Token = struct {
296	.Keyword_noinline => "noinline",	298	.Keyword_noinline => "noinline",
297	.Keyword_nosuspend => "nosuspend",	299	.Keyword_nosuspend => "nosuspend",
298	.Keyword_null => "null",	300	.Keyword_null => "null",
		301	.Keyword_opaque => "opaque",
299	.Keyword_or => "or",	302	.Keyword_or => "or",
300	.Keyword_orelse => "orelse",	303	.Keyword_orelse => "orelse",
301	.Keyword_packed => "packed",	304	.Keyword_packed => "packed",

src/clang.zig+929-521

...	@@ -1,91 +1,901 @@	...	@@ -1,91 +1,901 @@
1	const builtin = @import("builtin");	1	pub const builtin = @import("builtin");
2		2
3	pub const struct_ZigClangConditionalOperator = @Type(.Opaque);	3	pub const SourceLocation = extern struct {
4	pub const struct_ZigClangBinaryConditionalOperator = @Type(.Opaque);	4	ID: c_uint,
5	pub const struct_ZigClangAbstractConditionalOperator = @Type(.Opaque);	5
6	pub const struct_ZigClangAPInt = @Type(.Opaque);	6	pub const eq = ZigClangSourceLocation_eq;
7	pub const struct_ZigClangAPSInt = @Type(.Opaque);	7	extern fn ZigClangSourceLocation_eq(a: SourceLocation, b: SourceLocation) bool;
8	pub const struct_ZigClangAPFloat = @Type(.Opaque);	8	};
9	pub const struct_ZigClangASTContext = @Type(.Opaque);	9
10	pub const struct_ZigClangASTUnit = @Type(.Opaque);	10	pub const QualType = extern struct {
11	pub const struct_ZigClangArraySubscriptExpr = @Type(.Opaque);	11	ptr: ?*c_void,
12	pub const struct_ZigClangArrayType = @Type(.Opaque);	12
13	pub const struct_ZigClangAttributedType = @Type(.Opaque);	13	pub const getCanonicalType = ZigClangQualType_getCanonicalType;
14	pub const struct_ZigClangBinaryOperator = @Type(.Opaque);	14	extern fn ZigClangQualType_getCanonicalType(QualType) QualType;
15	pub const struct_ZigClangBreakStmt = @Type(.Opaque);	15
16	pub const struct_ZigClangBuiltinType = @Type(.Opaque);	16	pub const getTypePtr = ZigClangQualType_getTypePtr;
17	pub const struct_ZigClangCStyleCastExpr = @Type(.Opaque);	17	extern fn ZigClangQualType_getTypePtr(QualType) *const Type;
18	pub const struct_ZigClangCallExpr = @Type(.Opaque);	18
19	pub const struct_ZigClangCaseStmt = @Type(.Opaque);	19	pub const getTypeClass = ZigClangQualType_getTypeClass;
20	pub const struct_ZigClangCompoundAssignOperator = @Type(.Opaque);	20	extern fn ZigClangQualType_getTypeClass(QualType) TypeClass;
21	pub const struct_ZigClangCompoundStmt = @Type(.Opaque);	21
22	pub const struct_ZigClangConstantArrayType = @Type(.Opaque);	22	pub const addConst = ZigClangQualType_addConst;
23	pub const struct_ZigClangContinueStmt = @Type(.Opaque);	23	extern fn ZigClangQualType_addConst(*QualType) void;
24	pub const struct_ZigClangDecayedType = @Type(.Opaque);	24
25	pub const ZigClangDecl = @Type(.Opaque);	25	pub const eq = ZigClangQualType_eq;
26	pub const struct_ZigClangDeclRefExpr = @Type(.Opaque);	26	extern fn ZigClangQualType_eq(QualType, arg1: QualType) bool;
27	pub const struct_ZigClangDeclStmt = @Type(.Opaque);	27
28	pub const struct_ZigClangDefaultStmt = @Type(.Opaque);	28	pub const isConstQualified = ZigClangQualType_isConstQualified;
29	pub const struct_ZigClangDiagnosticOptions = @Type(.Opaque);	29	extern fn ZigClangQualType_isConstQualified(QualType) bool;
30	pub const struct_ZigClangDiagnosticsEngine = @Type(.Opaque);	30
31	pub const struct_ZigClangDoStmt = @Type(.Opaque);	31	pub const isVolatileQualified = ZigClangQualType_isVolatileQualified;
32	pub const struct_ZigClangElaboratedType = @Type(.Opaque);	32	extern fn ZigClangQualType_isVolatileQualified(QualType) bool;
33	pub const struct_ZigClangEnumConstantDecl = @Type(.Opaque);	33
34	pub const struct_ZigClangEnumDecl = @Type(.Opaque);	34	pub const isRestrictQualified = ZigClangQualType_isRestrictQualified;
35	pub const struct_ZigClangEnumType = @Type(.Opaque);	35	extern fn ZigClangQualType_isRestrictQualified(QualType) bool;
36	pub const struct_ZigClangExpr = @Type(.Opaque);	36	};
37	pub const struct_ZigClangFieldDecl = @Type(.Opaque);	37
38	pub const struct_ZigClangFileID = @Type(.Opaque);	38	pub const APValueLValueBase = extern struct {
39	pub const struct_ZigClangForStmt = @Type(.Opaque);	39	Ptr: ?*c_void,
40	pub const struct_ZigClangFullSourceLoc = @Type(.Opaque);	40	CallIndex: c_uint,
41	pub const struct_ZigClangFunctionDecl = @Type(.Opaque);	41	Version: c_uint,
42	pub const struct_ZigClangFunctionProtoType = @Type(.Opaque);	42
43	pub const struct_ZigClangIfStmt = @Type(.Opaque);	43	pub const dyn_cast_Expr = ZigClangAPValueLValueBase_dyn_cast_Expr;
44	pub const struct_ZigClangImplicitCastExpr = @Type(.Opaque);	44	extern fn ZigClangAPValueLValueBase_dyn_cast_Expr(APValueLValueBase) ?*const Expr;
45	pub const struct_ZigClangIncompleteArrayType = @Type(.Opaque);	45	};
46	pub const struct_ZigClangIntegerLiteral = @Type(.Opaque);	46
47	pub const struct_ZigClangMacroDefinitionRecord = @Type(.Opaque);	47	pub const APValueKind = extern enum {
48	pub const struct_ZigClangMacroExpansion = @Type(.Opaque);	48	None,
49	pub const struct_ZigClangMacroQualifiedType = @Type(.Opaque);	49	Indeterminate,
50	pub const struct_ZigClangMemberExpr = @Type(.Opaque);	50	Int,
51	pub const struct_ZigClangNamedDecl = @Type(.Opaque);	51	Float,
52	pub const struct_ZigClangNone = @Type(.Opaque);	52	FixedPoint,
53	pub const struct_ZigClangOpaqueValueExpr = @Type(.Opaque);	53	ComplexInt,
54	pub const struct_ZigClangPCHContainerOperations = @Type(.Opaque);	54	ComplexFloat,
55	pub const struct_ZigClangParenExpr = @Type(.Opaque);	55	LValue,
56	pub const struct_ZigClangParenType = @Type(.Opaque);	56	Vector,
57	pub const struct_ZigClangParmVarDecl = @Type(.Opaque);	57	Array,
58	pub const struct_ZigClangPointerType = @Type(.Opaque);	58	Struct,
59	pub const struct_ZigClangPreprocessedEntity = @Type(.Opaque);	59	Union,
60	pub const struct_ZigClangRecordDecl = @Type(.Opaque);	60	MemberPointer,
61	pub const struct_ZigClangRecordType = @Type(.Opaque);	61	AddrLabelDiff,
62	pub const struct_ZigClangReturnStmt = @Type(.Opaque);	62	};
63	pub const struct_ZigClangSkipFunctionBodiesScope = @Type(.Opaque);	63
64	pub const struct_ZigClangSourceManager = @Type(.Opaque);	64	pub const APValue = extern struct {
65	pub const struct_ZigClangSourceRange = @Type(.Opaque);	65	Kind: APValueKind,
66	pub const ZigClangStmt = @Type(.Opaque);	66	Data: if (builtin.os.tag == .windows and builtin.abi == .msvc) [52]u8 else [68]u8,
67	pub const struct_ZigClangStringLiteral = @Type(.Opaque);	67
68	pub const struct_ZigClangStringRef = @Type(.Opaque);	68	pub const getKind = ZigClangAPValue_getKind;
69	pub const struct_ZigClangSwitchStmt = @Type(.Opaque);	69	extern fn ZigClangAPValue_getKind(*const APValue) APValueKind;
70	pub const struct_ZigClangTagDecl = @Type(.Opaque);	70
71	pub const struct_ZigClangType = @Type(.Opaque);	71	pub const getInt = ZigClangAPValue_getInt;
72	pub const struct_ZigClangTypedefNameDecl = @Type(.Opaque);	72	extern fn ZigClangAPValue_getInt(const APValue) const APSInt;
73	pub const struct_ZigClangTypedefType = @Type(.Opaque);	73
74	pub const struct_ZigClangUnaryExprOrTypeTraitExpr = @Type(.Opaque);	74	pub const getArrayInitializedElts = ZigClangAPValue_getArrayInitializedElts;
75	pub const struct_ZigClangUnaryOperator = @Type(.Opaque);	75	extern fn ZigClangAPValue_getArrayInitializedElts(*const APValue) c_uint;
76	pub const struct_ZigClangValueDecl = @Type(.Opaque);	76
77	pub const struct_ZigClangVarDecl = @Type(.Opaque);	77	pub const getArraySize = ZigClangAPValue_getArraySize;
78	pub const struct_ZigClangWhileStmt = @Type(.Opaque);	78	extern fn ZigClangAPValue_getArraySize(*const APValue) c_uint;
79	pub const struct_ZigClangFunctionType = @Type(.Opaque);	79
80	pub const struct_ZigClangPredefinedExpr = @Type(.Opaque);	80	pub const getLValueBase = ZigClangAPValue_getLValueBase;
81	pub const struct_ZigClangInitListExpr = @Type(.Opaque);	81	extern fn ZigClangAPValue_getLValueBase(*const APValue) APValueLValueBase;
82	pub const ZigClangPreprocessingRecord = @Type(.Opaque);	82	};
83	pub const ZigClangFloatingLiteral = @Type(.Opaque);	83
84	pub const ZigClangConstantExpr = @Type(.Opaque);	84	pub const ExprEvalResult = extern struct {
85	pub const ZigClangCharacterLiteral = @Type(.Opaque);	85	HasSideEffects: bool,
86	pub const ZigClangStmtExpr = @Type(.Opaque);	86	HasUndefinedBehavior: bool,
87		87	SmallVectorImpl: ?*c_void,
88	pub const ZigClangBO = extern enum {	88	Val: APValue,
		89	};
		90
		91	pub const AbstractConditionalOperator = opaque {
		92	pub const getCond = ZigClangAbstractConditionalOperator_getCond;
		93	extern fn ZigClangAbstractConditionalOperator_getCond(const AbstractConditionalOperator) const Expr;
		94
		95	pub const getTrueExpr = ZigClangAbstractConditionalOperator_getTrueExpr;
		96	extern fn ZigClangAbstractConditionalOperator_getTrueExpr(const AbstractConditionalOperator) const Expr;
		97
		98	pub const getFalseExpr = ZigClangAbstractConditionalOperator_getFalseExpr;
		99	extern fn ZigClangAbstractConditionalOperator_getFalseExpr(const AbstractConditionalOperator) const Expr;
		100	};
		101
		102	pub const APFloat = opaque {
		103	pub const toString = ZigClangAPFloat_toString;
		104	extern fn ZigClangAPFloat_toString(const APFloat, precision: c_uint, maxPadding: c_uint, truncateZero: bool) [:0]const u8;
		105	};
		106
		107	pub const APInt = opaque {
		108	pub const getLimitedValue = ZigClangAPInt_getLimitedValue;
		109	extern fn ZigClangAPInt_getLimitedValue(*const APInt, limit: u64) u64;
		110	};
		111
		112	pub const APSInt = opaque {
		113	pub const isSigned = ZigClangAPSInt_isSigned;
		114	extern fn ZigClangAPSInt_isSigned(*const APSInt) bool;
		115
		116	pub const isNegative = ZigClangAPSInt_isNegative;
		117	extern fn ZigClangAPSInt_isNegative(*const APSInt) bool;
		118
		119	pub const negate = ZigClangAPSInt_negate;
		120	extern fn ZigClangAPSInt_negate(const APSInt) const APSInt;
		121
		122	pub const free = ZigClangAPSInt_free;
		123	extern fn ZigClangAPSInt_free(*const APSInt) void;
		124
		125	pub const getRawData = ZigClangAPSInt_getRawData;
		126	extern fn ZigClangAPSInt_getRawData(const APSInt) [:0]const u64;
		127
		128	pub const getNumWords = ZigClangAPSInt_getNumWords;
		129	extern fn ZigClangAPSInt_getNumWords(*const APSInt) c_uint;
		130	};
		131
		132	pub const ASTContext = opaque {
		133	pub const getPointerType = ZigClangASTContext_getPointerType;
		134	extern fn ZigClangASTContext_getPointerType(*const ASTContext, T: QualType) QualType;
		135	};
		136
		137	pub const ASTUnit = opaque {
		138	pub const delete = ZigClangASTUnit_delete;
		139	extern fn ZigClangASTUnit_delete(*ASTUnit) void;
		140
		141	pub const getASTContext = ZigClangASTUnit_getASTContext;
		142	extern fn ZigClangASTUnit_getASTContext(ASTUnit) ASTContext;
		143
		144	pub const getSourceManager = ZigClangASTUnit_getSourceManager;
		145	extern fn ZigClangASTUnit_getSourceManager(ASTUnit) SourceManager;
		146
		147	pub const visitLocalTopLevelDecls = ZigClangASTUnit_visitLocalTopLevelDecls;
		148	extern fn ZigClangASTUnit_visitLocalTopLevelDecls(ASTUnit, context: ?c_void, Fn: ?fn (?c_void, const Decl) callconv(.C) bool) bool;
		149
		150	pub const getLocalPreprocessingEntities_begin = ZigClangASTUnit_getLocalPreprocessingEntities_begin;
		151	extern fn ZigClangASTUnit_getLocalPreprocessingEntities_begin(*ASTUnit) PreprocessingRecord.iterator;
		152
		153	pub const getLocalPreprocessingEntities_end = ZigClangASTUnit_getLocalPreprocessingEntities_end;
		154	extern fn ZigClangASTUnit_getLocalPreprocessingEntities_end(*ASTUnit) PreprocessingRecord.iterator;
		155	};
		156
		157	pub const ArraySubscriptExpr = opaque {
		158	pub const getBase = ZigClangArraySubscriptExpr_getBase;
		159	extern fn ZigClangArraySubscriptExpr_getBase(const ArraySubscriptExpr) const Expr;
		160
		161	pub const getIdx = ZigClangArraySubscriptExpr_getIdx;
		162	extern fn ZigClangArraySubscriptExpr_getIdx(const ArraySubscriptExpr) const Expr;
		163	};
		164
		165	pub const ArrayType = opaque {
		166	pub const getElementType = ZigClangArrayType_getElementType;
		167	extern fn ZigClangArrayType_getElementType(*const ArrayType) QualType;
		168	};
		169
		170	pub const AttributedType = opaque {
		171	pub const getEquivalentType = ZigClangAttributedType_getEquivalentType;
		172	extern fn ZigClangAttributedType_getEquivalentType(*const AttributedType) QualType;
		173	};
		174
		175	pub const BinaryOperator = opaque {
		176	pub const getOpcode = ZigClangBinaryOperator_getOpcode;
		177	extern fn ZigClangBinaryOperator_getOpcode(*const BinaryOperator) BO;
		178
		179	pub const getBeginLoc = ZigClangBinaryOperator_getBeginLoc;
		180	extern fn ZigClangBinaryOperator_getBeginLoc(*const BinaryOperator) SourceLocation;
		181
		182	pub const getLHS = ZigClangBinaryOperator_getLHS;
		183	extern fn ZigClangBinaryOperator_getLHS(const BinaryOperator) const Expr;
		184
		185	pub const getRHS = ZigClangBinaryOperator_getRHS;
		186	extern fn ZigClangBinaryOperator_getRHS(const BinaryOperator) const Expr;
		187
		188	pub const getType = ZigClangBinaryOperator_getType;
		189	extern fn ZigClangBinaryOperator_getType(*const BinaryOperator) QualType;
		190	};
		191
		192	pub const BinaryConditionalOperator = opaque {};
		193
		194	pub const BreakStmt = opaque {};
		195
		196	pub const BuiltinType = opaque {
		197	pub const getKind = ZigClangBuiltinType_getKind;
		198	extern fn ZigClangBuiltinType_getKind(*const BuiltinType) BuiltinTypeKind;
		199	};
		200
		201	pub const CStyleCastExpr = opaque {
		202	pub const getBeginLoc = ZigClangCStyleCastExpr_getBeginLoc;
		203	extern fn ZigClangCStyleCastExpr_getBeginLoc(*const CStyleCastExpr) SourceLocation;
		204
		205	pub const getSubExpr = ZigClangCStyleCastExpr_getSubExpr;
		206	extern fn ZigClangCStyleCastExpr_getSubExpr(const CStyleCastExpr) const Expr;
		207
		208	pub const getType = ZigClangCStyleCastExpr_getType;
		209	extern fn ZigClangCStyleCastExpr_getType(*const CStyleCastExpr) QualType;
		210	};
		211
		212	pub const CallExpr = opaque {
		213	pub const getCallee = ZigClangCallExpr_getCallee;
		214	extern fn ZigClangCallExpr_getCallee(const CallExpr) const Expr;
		215
		216	pub const getNumArgs = ZigClangCallExpr_getNumArgs;
		217	extern fn ZigClangCallExpr_getNumArgs(*const CallExpr) c_uint;
		218
		219	pub const getArgs = ZigClangCallExpr_getArgs;
		220	extern fn ZigClangCallExpr_getArgs(const CallExpr) []const *const Expr;
		221	};
		222
		223	pub const CaseStmt = opaque {
		224	pub const getLHS = ZigClangCaseStmt_getLHS;
		225	extern fn ZigClangCaseStmt_getLHS(const CaseStmt) const Expr;
		226
		227	pub const getRHS = ZigClangCaseStmt_getRHS;
		228	extern fn ZigClangCaseStmt_getRHS(const CaseStmt) ?const Expr;
		229
		230	pub const getBeginLoc = ZigClangCaseStmt_getBeginLoc;
		231	extern fn ZigClangCaseStmt_getBeginLoc(*const CaseStmt) SourceLocation;
		232
		233	pub const getSubStmt = ZigClangCaseStmt_getSubStmt;
		234	extern fn ZigClangCaseStmt_getSubStmt(const CaseStmt) const Stmt;
		235	};
		236
		237	pub const CharacterLiteral = opaque {
		238	pub const getBeginLoc = ZigClangCharacterLiteral_getBeginLoc;
		239	extern fn ZigClangCharacterLiteral_getBeginLoc(*const CharacterLiteral) SourceLocation;
		240
		241	pub const getKind = ZigClangCharacterLiteral_getKind;
		242	extern fn ZigClangCharacterLiteral_getKind(*const CharacterLiteral) CharacterLiteral_CharacterKind;
		243
		244	pub const getValue = ZigClangCharacterLiteral_getValue;
		245	extern fn ZigClangCharacterLiteral_getValue(*const CharacterLiteral) c_uint;
		246	};
		247
		248	pub const CompoundAssignOperator = opaque {
		249	pub const getType = ZigClangCompoundAssignOperator_getType;
		250	extern fn ZigClangCompoundAssignOperator_getType(*const CompoundAssignOperator) QualType;
		251
		252	pub const getComputationLHSType = ZigClangCompoundAssignOperator_getComputationLHSType;
		253	extern fn ZigClangCompoundAssignOperator_getComputationLHSType(*const CompoundAssignOperator) QualType;
		254
		255	pub const getComputationResultType = ZigClangCompoundAssignOperator_getComputationResultType;
		256	extern fn ZigClangCompoundAssignOperator_getComputationResultType(*const CompoundAssignOperator) QualType;
		257
		258	pub const getBeginLoc = ZigClangCompoundAssignOperator_getBeginLoc;
		259	extern fn ZigClangCompoundAssignOperator_getBeginLoc(*const CompoundAssignOperator) SourceLocation;
		260
		261	pub const getOpcode = ZigClangCompoundAssignOperator_getOpcode;
		262	extern fn ZigClangCompoundAssignOperator_getOpcode(*const CompoundAssignOperator) BO;
		263
		264	pub const getLHS = ZigClangCompoundAssignOperator_getLHS;
		265	extern fn ZigClangCompoundAssignOperator_getLHS(const CompoundAssignOperator) const Expr;
		266
		267	pub const getRHS = ZigClangCompoundAssignOperator_getRHS;
		268	extern fn ZigClangCompoundAssignOperator_getRHS(const CompoundAssignOperator) const Expr;
		269	};
		270
		271	pub const CompoundStmt = opaque {
		272	pub const body_begin = ZigClangCompoundStmt_body_begin;
		273	extern fn ZigClangCompoundStmt_body_begin(*const CompoundStmt) const_body_iterator;
		274
		275	pub const body_end = ZigClangCompoundStmt_body_end;
		276	extern fn ZigClangCompoundStmt_body_end(*const CompoundStmt) const_body_iterator;
		277
		278	pub const const_body_iterator = []const Stmt;
		279	};
		280
		281	pub const ConditionalOperator = opaque {};
		282
		283	pub const ConstantArrayType = opaque {
		284	pub const getElementType = ZigClangConstantArrayType_getElementType;
		285	extern fn ZigClangConstantArrayType_getElementType(*const ConstantArrayType) QualType;
		286
		287	pub const getSize = ZigClangConstantArrayType_getSize;
		288	extern fn ZigClangConstantArrayType_getSize(const ConstantArrayType) const APInt;
		289	};
		290
		291	pub const ConstantExpr = opaque {};
		292
		293	pub const ContinueStmt = opaque {};
		294
		295	pub const DecayedType = opaque {
		296	pub const getDecayedType = ZigClangDecayedType_getDecayedType;
		297	extern fn ZigClangDecayedType_getDecayedType(*const DecayedType) QualType;
		298	};
		299
		300	pub const Decl = opaque {
		301	pub const getLocation = ZigClangDecl_getLocation;
		302	extern fn ZigClangDecl_getLocation(*const Decl) SourceLocation;
		303
		304	pub const castToNamedDecl = ZigClangDecl_castToNamedDecl;
		305	extern fn ZigClangDecl_castToNamedDecl(decl: const Decl) ?const NamedDecl;
		306
		307	pub const getKind = ZigClangDecl_getKind;
		308	extern fn ZigClangDecl_getKind(decl: *const Decl) DeclKind;
		309
		310	pub const getDeclKindName = ZigClangDecl_getDeclKindName;
		311	extern fn ZigClangDecl_getDeclKindName(decl: const Decl) [:0]const u8;
		312	};
		313
		314	pub const DeclRefExpr = opaque {
		315	pub const getDecl = ZigClangDeclRefExpr_getDecl;
		316	extern fn ZigClangDeclRefExpr_getDecl(const DeclRefExpr) const ValueDecl;
		317
		318	pub const getFoundDecl = ZigClangDeclRefExpr_getFoundDecl;
		319	extern fn ZigClangDeclRefExpr_getFoundDecl(const DeclRefExpr) const NamedDecl;
		320	};
		321
		322	pub const DeclStmt = opaque {
		323	pub const decl_begin = ZigClangDeclStmt_decl_begin;
		324	extern fn ZigClangDeclStmt_decl_begin(*const DeclStmt) const_decl_iterator;
		325
		326	pub const decl_end = ZigClangDeclStmt_decl_end;
		327	extern fn ZigClangDeclStmt_decl_end(*const DeclStmt) const_decl_iterator;
		328
		329	pub const const_decl_iterator = []const Decl;
		330	};
		331
		332	pub const DefaultStmt = opaque {
		333	pub const getSubStmt = ZigClangDefaultStmt_getSubStmt;
		334	extern fn ZigClangDefaultStmt_getSubStmt(const DefaultStmt) const Stmt;
		335	};
		336
		337	pub const DiagnosticOptions = opaque {};
		338
		339	pub const DiagnosticsEngine = opaque {};
		340
		341	pub const DoStmt = opaque {
		342	pub const getCond = ZigClangDoStmt_getCond;
		343	extern fn ZigClangDoStmt_getCond(const DoStmt) const Expr;
		344
		345	pub const getBody = ZigClangDoStmt_getBody;
		346	extern fn ZigClangDoStmt_getBody(const DoStmt) const Stmt;
		347	};
		348
		349	pub const ElaboratedType = opaque {
		350	pub const getNamedType = ZigClangElaboratedType_getNamedType;
		351	extern fn ZigClangElaboratedType_getNamedType(*const ElaboratedType) QualType;
		352	};
		353
		354	pub const EnumConstantDecl = opaque {
		355	pub const getInitExpr = ZigClangEnumConstantDecl_getInitExpr;
		356	extern fn ZigClangEnumConstantDecl_getInitExpr(const EnumConstantDecl) ?const Expr;
		357
		358	pub const getInitVal = ZigClangEnumConstantDecl_getInitVal;
		359	extern fn ZigClangEnumConstantDecl_getInitVal(const EnumConstantDecl) const APSInt;
		360	};
		361
		362	pub const EnumDecl = opaque {
		363	pub const getCanonicalDecl = ZigClangEnumDecl_getCanonicalDecl;
		364	extern fn ZigClangEnumDecl_getCanonicalDecl(const EnumDecl) ?const TagDecl;
		365
		366	pub const getIntegerType = ZigClangEnumDecl_getIntegerType;
		367	extern fn ZigClangEnumDecl_getIntegerType(*const EnumDecl) QualType;
		368
		369	pub const getDefinition = ZigClangEnumDecl_getDefinition;
		370	extern fn ZigClangEnumDecl_getDefinition(const EnumDecl) ?const EnumDecl;
		371
		372	pub const getLocation = ZigClangEnumDecl_getLocation;
		373	extern fn ZigClangEnumDecl_getLocation(*const EnumDecl) SourceLocation;
		374
		375	pub const enumerator_begin = ZigClangEnumDecl_enumerator_begin;
		376	extern fn ZigClangEnumDecl_enumerator_begin(*const EnumDecl) enumerator_iterator;
		377
		378	pub const enumerator_end = ZigClangEnumDecl_enumerator_end;
		379	extern fn ZigClangEnumDecl_enumerator_end(*const EnumDecl) enumerator_iterator;
		380
		381	pub const enumerator_iterator = extern struct {
		382	ptr: *c_void,
		383
		384	pub const next = ZigClangEnumDecl_enumerator_iterator_next;
		385	extern fn ZigClangEnumDecl_enumerator_iterator_next(enumerator_iterator) enumerator_iterator;
		386
		387	pub const deref = ZigClangEnumDecl_enumerator_iterator_deref;
		388	extern fn ZigClangEnumDecl_enumerator_iterator_deref(enumerator_iterator) *const EnumConstantDecl;
		389
		390	pub const neq = ZigClangEnumDecl_enumerator_iterator_neq;
		391	extern fn ZigClangEnumDecl_enumerator_iterator_neq(enumerator_iterator, enumerator_iterator) bool;
		392	};
		393	};
		394
		395	pub const EnumType = opaque {
		396	pub const getDecl = ZigClangEnumType_getDecl;
		397	extern fn ZigClangEnumType_getDecl(const EnumType) const EnumDecl;
		398	};
		399
		400	pub const Expr = opaque {
		401	pub const getStmtClass = ZigClangExpr_getStmtClass;
		402	extern fn ZigClangExpr_getStmtClass(*const Expr) StmtClass;
		403
		404	pub const getType = ZigClangExpr_getType;
		405	extern fn ZigClangExpr_getType(*const Expr) QualType;
		406
		407	pub const getBeginLoc = ZigClangExpr_getBeginLoc;
		408	extern fn ZigClangExpr_getBeginLoc(*const Expr) SourceLocation;
		409
		410	pub const EvaluateAsConstantExpr = ZigClangExpr_EvaluateAsConstantExpr;
		411	extern fn ZigClangExpr_EvaluateAsConstantExpr(const Expr, ExprEvalResult, Expr_ConstExprUsage, *const ASTContext) bool;
		412	};
		413
		414	pub const FieldDecl = opaque {
		415	pub const getCanonicalDecl = ZigClangFieldDecl_getCanonicalDecl;
		416	extern fn ZigClangFieldDecl_getCanonicalDecl(const FieldDecl) ?const FieldDecl;
		417
		418	pub const getAlignedAttribute = ZigClangFieldDecl_getAlignedAttribute;
		419	extern fn ZigClangFieldDecl_getAlignedAttribute(const FieldDecl, const ASTContext) c_uint;
		420
		421	pub const isAnonymousStructOrUnion = ZigClangFieldDecl_isAnonymousStructOrUnion;
		422	extern fn ZigClangFieldDecl_isAnonymousStructOrUnion(*const FieldDecl) bool;
		423
		424	pub const isBitField = ZigClangFieldDecl_isBitField;
		425	extern fn ZigClangFieldDecl_isBitField(*const FieldDecl) bool;
		426
		427	pub const getType = ZigClangFieldDecl_getType;
		428	extern fn ZigClangFieldDecl_getType(*const FieldDecl) QualType;
		429
		430	pub const getLocation = ZigClangFieldDecl_getLocation;
		431	extern fn ZigClangFieldDecl_getLocation(*const FieldDecl) SourceLocation;
		432	};
		433
		434	pub const FileID = opaque {};
		435
		436	pub const FloatingLiteral = opaque {
		437	pub const getValueAsApproximateDouble = ZigClangAPFloat_getValueAsApproximateDouble;
		438	extern fn ZigClangAPFloat_getValueAsApproximateDouble(*const FloatingLiteral) f64;
		439	};
		440
		441	pub const ForStmt = opaque {
		442	pub const getInit = ZigClangForStmt_getInit;
		443	extern fn ZigClangForStmt_getInit(const ForStmt) ?const Stmt;
		444
		445	pub const getCond = ZigClangForStmt_getCond;
		446	extern fn ZigClangForStmt_getCond(const ForStmt) ?const Expr;
		447
		448	pub const getInc = ZigClangForStmt_getInc;
		449	extern fn ZigClangForStmt_getInc(const ForStmt) ?const Expr;
		450
		451	pub const getBody = ZigClangForStmt_getBody;
		452	extern fn ZigClangForStmt_getBody(const ForStmt) const Stmt;
		453	};
		454
		455	pub const FullSourceLoc = opaque {};
		456
		457	pub const FunctionDecl = opaque {
		458	pub const getType = ZigClangFunctionDecl_getType;
		459	extern fn ZigClangFunctionDecl_getType(*const FunctionDecl) QualType;
		460
		461	pub const getLocation = ZigClangFunctionDecl_getLocation;
		462	extern fn ZigClangFunctionDecl_getLocation(*const FunctionDecl) SourceLocation;
		463
		464	pub const hasBody = ZigClangFunctionDecl_hasBody;
		465	extern fn ZigClangFunctionDecl_hasBody(*const FunctionDecl) bool;
		466
		467	pub const getStorageClass = ZigClangFunctionDecl_getStorageClass;
		468	extern fn ZigClangFunctionDecl_getStorageClass(*const FunctionDecl) StorageClass;
		469
		470	pub const getParamDecl = ZigClangFunctionDecl_getParamDecl;
		471	extern fn ZigClangFunctionDecl_getParamDecl(const FunctionDecl, i: c_uint) const ParmVarDecl;
		472
		473	pub const getBody = ZigClangFunctionDecl_getBody;
		474	extern fn ZigClangFunctionDecl_getBody(const FunctionDecl) const Stmt;
		475
		476	pub const doesDeclarationForceExternallyVisibleDefinition = ZigClangFunctionDecl_doesDeclarationForceExternallyVisibleDefinition;
		477	extern fn ZigClangFunctionDecl_doesDeclarationForceExternallyVisibleDefinition(*const FunctionDecl) bool;
		478
		479	pub const isThisDeclarationADefinition = ZigClangFunctionDecl_isThisDeclarationADefinition;
		480	extern fn ZigClangFunctionDecl_isThisDeclarationADefinition(*const FunctionDecl) bool;
		481
		482	pub const doesThisDeclarationHaveABody = ZigClangFunctionDecl_doesThisDeclarationHaveABody;
		483	extern fn ZigClangFunctionDecl_doesThisDeclarationHaveABody(*const FunctionDecl) bool;
		484
		485	pub const isInlineSpecified = ZigClangFunctionDecl_isInlineSpecified;
		486	extern fn ZigClangFunctionDecl_isInlineSpecified(*const FunctionDecl) bool;
		487
		488	pub const isDefined = ZigClangFunctionDecl_isDefined;
		489	extern fn ZigClangFunctionDecl_isDefined(*const FunctionDecl) bool;
		490
		491	pub const getDefinition = ZigClangFunctionDecl_getDefinition;
		492	extern fn ZigClangFunctionDecl_getDefinition(const FunctionDecl) ?const FunctionDecl;
		493
		494	pub const getSectionAttribute = ZigClangFunctionDecl_getSectionAttribute;
		495	extern fn ZigClangFunctionDecl_getSectionAttribute(const FunctionDecl, len: usize) ?[*]const u8;
		496
		497	pub const getCanonicalDecl = ZigClangFunctionDecl_getCanonicalDecl;
		498	extern fn ZigClangFunctionDecl_getCanonicalDecl(const FunctionDecl) ?const FunctionDecl;
		499
		500	pub const getAlignedAttribute = ZigClangFunctionDecl_getAlignedAttribute;
		501	extern fn ZigClangFunctionDecl_getAlignedAttribute(const FunctionDecl, const ASTContext) c_uint;
		502	};
		503
		504	pub const FunctionProtoType = opaque {
		505	pub const isVariadic = ZigClangFunctionProtoType_isVariadic;
		506	extern fn ZigClangFunctionProtoType_isVariadic(*const FunctionProtoType) bool;
		507
		508	pub const getNumParams = ZigClangFunctionProtoType_getNumParams;
		509	extern fn ZigClangFunctionProtoType_getNumParams(*const FunctionProtoType) c_uint;
		510
		511	pub const getParamType = ZigClangFunctionProtoType_getParamType;
		512	extern fn ZigClangFunctionProtoType_getParamType(*const FunctionProtoType, i: c_uint) QualType;
		513
		514	pub const getReturnType = ZigClangFunctionProtoType_getReturnType;
		515	extern fn ZigClangFunctionProtoType_getReturnType(*const FunctionProtoType) QualType;
		516	};
		517
		518	pub const FunctionType = opaque {
		519	pub const getNoReturnAttr = ZigClangFunctionType_getNoReturnAttr;
		520	extern fn ZigClangFunctionType_getNoReturnAttr(*const FunctionType) bool;
		521
		522	pub const getCallConv = ZigClangFunctionType_getCallConv;
		523	extern fn ZigClangFunctionType_getCallConv(*const FunctionType) CallingConv;
		524
		525	pub const getReturnType = ZigClangFunctionType_getReturnType;
		526	extern fn ZigClangFunctionType_getReturnType(*const FunctionType) QualType;
		527	};
		528
		529	pub const IfStmt = opaque {
		530	pub const getThen = ZigClangIfStmt_getThen;
		531	extern fn ZigClangIfStmt_getThen(const IfStmt) const Stmt;
		532
		533	pub const getElse = ZigClangIfStmt_getElse;
		534	extern fn ZigClangIfStmt_getElse(const IfStmt) ?const Stmt;
		535
		536	pub const getCond = ZigClangIfStmt_getCond;
		537	extern fn ZigClangIfStmt_getCond(const IfStmt) const Stmt;
		538	};
		539
		540	pub const ImplicitCastExpr = opaque {
		541	pub const getBeginLoc = ZigClangImplicitCastExpr_getBeginLoc;
		542	extern fn ZigClangImplicitCastExpr_getBeginLoc(*const ImplicitCastExpr) SourceLocation;
		543
		544	pub const getCastKind = ZigClangImplicitCastExpr_getCastKind;
		545	extern fn ZigClangImplicitCastExpr_getCastKind(*const ImplicitCastExpr) CK;
		546
		547	pub const getSubExpr = ZigClangImplicitCastExpr_getSubExpr;
		548	extern fn ZigClangImplicitCastExpr_getSubExpr(const ImplicitCastExpr) const Expr;
		549	};
		550
		551	pub const IncompleteArrayType = opaque {
		552	pub const getElementType = ZigClangIncompleteArrayType_getElementType;
		553	extern fn ZigClangIncompleteArrayType_getElementType(*const IncompleteArrayType) QualType;
		554	};
		555
		556	pub const IntegerLiteral = opaque {
		557	pub const EvaluateAsInt = ZigClangIntegerLiteral_EvaluateAsInt;
		558	extern fn ZigClangIntegerLiteral_EvaluateAsInt(const IntegerLiteral, ExprEvalResult, *const ASTContext) bool;
		559
		560	pub const getBeginLoc = ZigClangIntegerLiteral_getBeginLoc;
		561	extern fn ZigClangIntegerLiteral_getBeginLoc(*const IntegerLiteral) SourceLocation;
		562
		563	pub const isZero = ZigClangIntegerLiteral_isZero;
		564	extern fn ZigClangIntegerLiteral_isZero(const IntegerLiteral, bool, *const ASTContext) bool;
		565	};
		566
		567	pub const MacroDefinitionRecord = opaque {
		568	pub const getName_getNameStart = ZigClangMacroDefinitionRecord_getName_getNameStart;
		569	extern fn ZigClangMacroDefinitionRecord_getName_getNameStart(const MacroDefinitionRecord) [:0]const u8;
		570
		571	pub const getSourceRange_getBegin = ZigClangMacroDefinitionRecord_getSourceRange_getBegin;
		572	extern fn ZigClangMacroDefinitionRecord_getSourceRange_getBegin(*const MacroDefinitionRecord) SourceLocation;
		573
		574	pub const getSourceRange_getEnd = ZigClangMacroDefinitionRecord_getSourceRange_getEnd;
		575	extern fn ZigClangMacroDefinitionRecord_getSourceRange_getEnd(*const MacroDefinitionRecord) SourceLocation;
		576	};
		577
		578	pub const MacroQualifiedType = opaque {
		579	pub const getModifiedType = ZigClangMacroQualifiedType_getModifiedType;
		580	extern fn ZigClangMacroQualifiedType_getModifiedType(*const MacroQualifiedType) QualType;
		581	};
		582
		583	pub const MemberExpr = opaque {
		584	pub const getBase = ZigClangMemberExpr_getBase;
		585	extern fn ZigClangMemberExpr_getBase(const MemberExpr) const Expr;
		586
		587	pub const isArrow = ZigClangMemberExpr_isArrow;
		588	extern fn ZigClangMemberExpr_isArrow(*const MemberExpr) bool;
		589
		590	pub const getMemberDecl = ZigClangMemberExpr_getMemberDecl;
		591	extern fn ZigClangMemberExpr_getMemberDecl(const MemberExpr) const ValueDecl;
		592	};
		593
		594	pub const NamedDecl = opaque {
		595	pub const getName_bytes_begin = ZigClangNamedDecl_getName_bytes_begin;
		596	extern fn ZigClangNamedDecl_getName_bytes_begin(decl: const NamedDecl) [:0]const u8;
		597	};
		598
		599	pub const None = opaque {};
		600
		601	pub const OpaqueValueExpr = opaque {
		602	pub const getSourceExpr = ZigClangOpaqueValueExpr_getSourceExpr;
		603	extern fn ZigClangOpaqueValueExpr_getSourceExpr(const OpaqueValueExpr) ?const Expr;
		604	};
		605
		606	pub const PCHContainerOperations = opaque {};
		607
		608	pub const ParenExpr = opaque {
		609	pub const getSubExpr = ZigClangParenExpr_getSubExpr;
		610	extern fn ZigClangParenExpr_getSubExpr(const ParenExpr) const Expr;
		611	};
		612
		613	pub const ParenType = opaque {
		614	pub const getInnerType = ZigClangParenType_getInnerType;
		615	extern fn ZigClangParenType_getInnerType(*const ParenType) QualType;
		616	};
		617
		618	pub const ParmVarDecl = opaque {
		619	pub const getOriginalType = ZigClangParmVarDecl_getOriginalType;
		620	extern fn ZigClangParmVarDecl_getOriginalType(*const ParmVarDecl) QualType;
		621	};
		622
		623	pub const PointerType = opaque {};
		624
		625	pub const PredefinedExpr = opaque {
		626	pub const getFunctionName = ZigClangPredefinedExpr_getFunctionName;
		627	extern fn ZigClangPredefinedExpr_getFunctionName(const PredefinedExpr) const StringLiteral;
		628	};
		629
		630	pub const PreprocessedEntity = opaque {
		631	pub const getKind = ZigClangPreprocessedEntity_getKind;
		632	extern fn ZigClangPreprocessedEntity_getKind(*const PreprocessedEntity) PreprocessedEntity_EntityKind;
		633	};
		634
		635	pub const PreprocessingRecord = opaque {
		636	pub const iterator = extern struct {
		637	I: c_int,
		638	Self: *PreprocessingRecord,
		639
		640	pub const deref = ZigClangPreprocessingRecord_iterator_deref;
		641	extern fn ZigClangPreprocessingRecord_iterator_deref(iterator) *PreprocessedEntity;
		642	};
		643	};
		644
		645	pub const RecordDecl = opaque {
		646	pub const getCanonicalDecl = ZigClangRecordDecl_getCanonicalDecl;
		647	extern fn ZigClangRecordDecl_getCanonicalDecl(const RecordDecl) ?const TagDecl;
		648
		649	pub const isUnion = ZigClangRecordDecl_isUnion;
		650	extern fn ZigClangRecordDecl_isUnion(*const RecordDecl) bool;
		651
		652	pub const isStruct = ZigClangRecordDecl_isStruct;
		653	extern fn ZigClangRecordDecl_isStruct(*const RecordDecl) bool;
		654
		655	pub const isAnonymousStructOrUnion = ZigClangRecordDecl_isAnonymousStructOrUnion;
		656	extern fn ZigClangRecordDecl_isAnonymousStructOrUnion(record_decl: ?*const RecordDecl) bool;
		657
		658	pub const getPackedAttribute = ZigClangRecordDecl_getPackedAttribute;
		659	extern fn ZigClangRecordDecl_getPackedAttribute(*const RecordDecl) bool;
		660
		661	pub const getDefinition = ZigClangRecordDecl_getDefinition;
		662	extern fn ZigClangRecordDecl_getDefinition(const RecordDecl) ?const RecordDecl;
		663
		664	pub const getLocation = ZigClangRecordDecl_getLocation;
		665	extern fn ZigClangRecordDecl_getLocation(*const RecordDecl) SourceLocation;
		666
		667	pub const field_begin = ZigClangRecordDecl_field_begin;
		668	extern fn ZigClangRecordDecl_field_begin(*const RecordDecl) field_iterator;
		669
		670	pub const field_end = ZigClangRecordDecl_field_end;
		671	extern fn ZigClangRecordDecl_field_end(*const RecordDecl) field_iterator;
		672
		673	pub const field_iterator = extern struct {
		674	ptr: *c_void,
		675
		676	pub const next = ZigClangRecordDecl_field_iterator_next;
		677	extern fn ZigClangRecordDecl_field_iterator_next(field_iterator) field_iterator;
		678
		679	pub const deref = ZigClangRecordDecl_field_iterator_deref;
		680	extern fn ZigClangRecordDecl_field_iterator_deref(field_iterator) *const FieldDecl;
		681
		682	pub const neq = ZigClangRecordDecl_field_iterator_neq;
		683	extern fn ZigClangRecordDecl_field_iterator_neq(field_iterator, field_iterator) bool;
		684	};
		685	};
		686
		687	pub const RecordType = opaque {
		688	pub const getDecl = ZigClangRecordType_getDecl;
		689	extern fn ZigClangRecordType_getDecl(const RecordType) const RecordDecl;
		690	};
		691
		692	pub const ReturnStmt = opaque {
		693	pub const getRetValue = ZigClangReturnStmt_getRetValue;
		694	extern fn ZigClangReturnStmt_getRetValue(const ReturnStmt) ?const Expr;
		695	};
		696
		697	pub const SkipFunctionBodiesScope = opaque {};
		698
		699	pub const SourceManager = opaque {
		700	pub const getSpellingLoc = ZigClangSourceManager_getSpellingLoc;
		701	extern fn ZigClangSourceManager_getSpellingLoc(*const SourceManager, Loc: SourceLocation) SourceLocation;
		702
		703	pub const getFilename = ZigClangSourceManager_getFilename;
		704	extern fn ZigClangSourceManager_getFilename(const SourceManager, SpellingLoc: SourceLocation) ?[:0]const u8;
		705
		706	pub const getSpellingLineNumber = ZigClangSourceManager_getSpellingLineNumber;
		707	extern fn ZigClangSourceManager_getSpellingLineNumber(*const SourceManager, Loc: SourceLocation) c_uint;
		708
		709	pub const getSpellingColumnNumber = ZigClangSourceManager_getSpellingColumnNumber;
		710	extern fn ZigClangSourceManager_getSpellingColumnNumber(*const SourceManager, Loc: SourceLocation) c_uint;
		711
		712	pub const getCharacterData = ZigClangSourceManager_getCharacterData;
		713	extern fn ZigClangSourceManager_getCharacterData(const SourceManager, SL: SourceLocation) [:0]const u8;
		714	};
		715
		716	pub const SourceRange = opaque {};
		717
		718	pub const Stmt = opaque {
		719	pub const getBeginLoc = ZigClangStmt_getBeginLoc;
		720	extern fn ZigClangStmt_getBeginLoc(*const Stmt) SourceLocation;
		721
		722	pub const getStmtClass = ZigClangStmt_getStmtClass;
		723	extern fn ZigClangStmt_getStmtClass(*const Stmt) StmtClass;
		724
		725	pub const classof_Expr = ZigClangStmt_classof_Expr;
		726	extern fn ZigClangStmt_classof_Expr(*const Stmt) bool;
		727	};
		728
		729	pub const StmtExpr = opaque {
		730	pub const getSubStmt = ZigClangStmtExpr_getSubStmt;
		731	extern fn ZigClangStmtExpr_getSubStmt(const StmtExpr) const CompoundStmt;
		732	};
		733
		734	pub const StringLiteral = opaque {
		735	pub const getKind = ZigClangStringLiteral_getKind;
		736	extern fn ZigClangStringLiteral_getKind(*const StringLiteral) StringLiteral_StringKind;
		737
		738	pub const getString_bytes_begin_size = ZigClangStringLiteral_getString_bytes_begin_size;
		739	extern fn ZigClangStringLiteral_getString_bytes_begin_size(const StringLiteral, usize) [*]const u8;
		740	};
		741
		742	pub const StringRef = opaque {};
		743
		744	pub const SwitchStmt = opaque {
		745	pub const getConditionVariableDeclStmt = ZigClangSwitchStmt_getConditionVariableDeclStmt;
		746	extern fn ZigClangSwitchStmt_getConditionVariableDeclStmt(const SwitchStmt) ?const DeclStmt;
		747
		748	pub const getCond = ZigClangSwitchStmt_getCond;
		749	extern fn ZigClangSwitchStmt_getCond(const SwitchStmt) const Expr;
		750
		751	pub const getBody = ZigClangSwitchStmt_getBody;
		752	extern fn ZigClangSwitchStmt_getBody(const SwitchStmt) const Stmt;
		753
		754	pub const isAllEnumCasesCovered = ZigClangSwitchStmt_isAllEnumCasesCovered;
		755	extern fn ZigClangSwitchStmt_isAllEnumCasesCovered(*const SwitchStmt) bool;
		756	};
		757
		758	pub const TagDecl = opaque {
		759	pub const isThisDeclarationADefinition = ZigClangTagDecl_isThisDeclarationADefinition;
		760	extern fn ZigClangTagDecl_isThisDeclarationADefinition(*const TagDecl) bool;
		761	};
		762
		763	pub const Type = opaque {
		764	pub const getTypeClass = ZigClangType_getTypeClass;
		765	extern fn ZigClangType_getTypeClass(*const Type) TypeClass;
		766
		767	pub const getPointeeType = ZigClangType_getPointeeType;
		768	extern fn ZigClangType_getPointeeType(*const Type) QualType;
		769
		770	pub const isVoidType = ZigClangType_isVoidType;
		771	extern fn ZigClangType_isVoidType(*const Type) bool;
		772
		773	pub const isConstantArrayType = ZigClangType_isConstantArrayType;
		774	extern fn ZigClangType_isConstantArrayType(*const Type) bool;
		775
		776	pub const isRecordType = ZigClangType_isRecordType;
		777	extern fn ZigClangType_isRecordType(*const Type) bool;
		778
		779	pub const isIncompleteOrZeroLengthArrayType = ZigClangType_isIncompleteOrZeroLengthArrayType;
		780	extern fn ZigClangType_isIncompleteOrZeroLengthArrayType(const Type, const ASTContext) bool;
		781
		782	pub const isArrayType = ZigClangType_isArrayType;
		783	extern fn ZigClangType_isArrayType(*const Type) bool;
		784
		785	pub const isBooleanType = ZigClangType_isBooleanType;
		786	extern fn ZigClangType_isBooleanType(*const Type) bool;
		787
		788	pub const getTypeClassName = ZigClangType_getTypeClassName;
		789	extern fn ZigClangType_getTypeClassName(const Type) [:0]const u8;
		790
		791	pub const getAsArrayTypeUnsafe = ZigClangType_getAsArrayTypeUnsafe;
		792	extern fn ZigClangType_getAsArrayTypeUnsafe(const Type) const ArrayType;
		793
		794	pub const getAsRecordType = ZigClangType_getAsRecordType;
		795	extern fn ZigClangType_getAsRecordType(const Type) ?const RecordType;
		796
		797	pub const getAsUnionType = ZigClangType_getAsUnionType;
		798	extern fn ZigClangType_getAsUnionType(const Type) ?const RecordType;
		799	};
		800
		801	pub const TypedefNameDecl = opaque {
		802	pub const getUnderlyingType = ZigClangTypedefNameDecl_getUnderlyingType;
		803	extern fn ZigClangTypedefNameDecl_getUnderlyingType(*const TypedefNameDecl) QualType;
		804
		805	pub const getCanonicalDecl = ZigClangTypedefNameDecl_getCanonicalDecl;
		806	extern fn ZigClangTypedefNameDecl_getCanonicalDecl(const TypedefNameDecl) ?const TypedefNameDecl;
		807
		808	pub const getLocation = ZigClangTypedefNameDecl_getLocation;
		809	extern fn ZigClangTypedefNameDecl_getLocation(*const TypedefNameDecl) SourceLocation;
		810	};
		811
		812	pub const TypedefType = opaque {
		813	pub const getDecl = ZigClangTypedefType_getDecl;
		814	extern fn ZigClangTypedefType_getDecl(const TypedefType) const TypedefNameDecl;
		815	};
		816
		817	pub const UnaryExprOrTypeTraitExpr = opaque {
		818	pub const getTypeOfArgument = ZigClangUnaryExprOrTypeTraitExpr_getTypeOfArgument;
		819	extern fn ZigClangUnaryExprOrTypeTraitExpr_getTypeOfArgument(*const UnaryExprOrTypeTraitExpr) QualType;
		820
		821	pub const getBeginLoc = ZigClangUnaryExprOrTypeTraitExpr_getBeginLoc;
		822	extern fn ZigClangUnaryExprOrTypeTraitExpr_getBeginLoc(*const UnaryExprOrTypeTraitExpr) SourceLocation;
		823
		824	pub const getKind = ZigClangUnaryExprOrTypeTraitExpr_getKind;
		825	extern fn ZigClangUnaryExprOrTypeTraitExpr_getKind(*const UnaryExprOrTypeTraitExpr) UnaryExprOrTypeTrait_Kind;
		826	};
		827
		828	pub const UnaryOperator = opaque {
		829	pub const getOpcode = ZigClangUnaryOperator_getOpcode;
		830	extern fn ZigClangUnaryOperator_getOpcode(*const UnaryOperator) UO;
		831
		832	pub const getType = ZigClangUnaryOperator_getType;
		833	extern fn ZigClangUnaryOperator_getType(*const UnaryOperator) QualType;
		834
		835	pub const getSubExpr = ZigClangUnaryOperator_getSubExpr;
		836	extern fn ZigClangUnaryOperator_getSubExpr(const UnaryOperator) const Expr;
		837
		838	pub const getBeginLoc = ZigClangUnaryOperator_getBeginLoc;
		839	extern fn ZigClangUnaryOperator_getBeginLoc(*const UnaryOperator) SourceLocation;
		840	};
		841
		842	pub const ValueDecl = opaque {};
		843
		844	pub const VarDecl = opaque {
		845	pub const getLocation = ZigClangVarDecl_getLocation;
		846	extern fn ZigClangVarDecl_getLocation(*const VarDecl) SourceLocation;
		847
		848	pub const hasInit = ZigClangVarDecl_hasInit;
		849	extern fn ZigClangVarDecl_hasInit(*const VarDecl) bool;
		850
		851	pub const getStorageClass = ZigClangVarDecl_getStorageClass;
		852	extern fn ZigClangVarDecl_getStorageClass(*const VarDecl) StorageClass;
		853
		854	pub const getType = ZigClangVarDecl_getType;
		855	extern fn ZigClangVarDecl_getType(*const VarDecl) QualType;
		856
		857	pub const getInit = ZigClangVarDecl_getInit;
		858	extern fn ZigClangVarDecl_getInit(const VarDecl) ?const Expr;
		859
		860	pub const getTLSKind = ZigClangVarDecl_getTLSKind;
		861	extern fn ZigClangVarDecl_getTLSKind(*const VarDecl) VarDecl_TLSKind;
		862
		863	pub const getCanonicalDecl = ZigClangVarDecl_getCanonicalDecl;
		864	extern fn ZigClangVarDecl_getCanonicalDecl(const VarDecl) ?const VarDecl;
		865
		866	pub const getSectionAttribute = ZigClangVarDecl_getSectionAttribute;
		867	extern fn ZigClangVarDecl_getSectionAttribute(const VarDecl, len: usize) ?[*]const u8;
		868
		869	pub const getAlignedAttribute = ZigClangVarDecl_getAlignedAttribute;
		870	extern fn ZigClangVarDecl_getAlignedAttribute(const VarDecl, const ASTContext) c_uint;
		871
		872	pub const getTypeSourceInfo_getType = ZigClangVarDecl_getTypeSourceInfo_getType;
		873	extern fn ZigClangVarDecl_getTypeSourceInfo_getType(*const VarDecl) QualType;
		874	};
		875
		876	pub const WhileStmt = opaque {
		877	pub const getCond = ZigClangWhileStmt_getCond;
		878	extern fn ZigClangWhileStmt_getCond(const WhileStmt) const Expr;
		879
		880	pub const getBody = ZigClangWhileStmt_getBody;
		881	extern fn ZigClangWhileStmt_getBody(const WhileStmt) const Stmt;
		882	};
		883
		884	pub const InitListExpr = opaque {
		885	pub const getInit = ZigClangInitListExpr_getInit;
		886	extern fn ZigClangInitListExpr_getInit(const InitListExpr, i: c_uint) const Expr;
		887
		888	pub const getArrayFiller = ZigClangInitListExpr_getArrayFiller;
		889	extern fn ZigClangInitListExpr_getArrayFiller(const InitListExpr) const Expr;
		890
		891	pub const getNumInits = ZigClangInitListExpr_getNumInits;
		892	extern fn ZigClangInitListExpr_getNumInits(*const InitListExpr) c_uint;
		893
		894	pub const getInitializedFieldInUnion = ZigClangInitListExpr_getInitializedFieldInUnion;
		895	extern fn ZigClangInitListExpr_getInitializedFieldInUnion(const InitListExpr) ?FieldDecl;
		896	};
		897
		898	pub const BO = extern enum {
89	PtrMemD,	899	PtrMemD,
90	PtrMemI,	900	PtrMemI,
91	Mul,	901	Mul,
...	@@ -121,7 +931,7 @@ pub const ZigClangBO = extern enum {	...	@@ -121,7 +931,7 @@ pub const ZigClangBO = extern enum {
121	Comma,	931	Comma,
122	};	932	};
123		933
124	pub const ZigClangUO = extern enum {	934	pub const UO = extern enum {
125	PostInc,	935	PostInc,
126	PostDec,	936	PostDec,
127	PreInc,	937	PreInc,
...	@@ -138,7 +948,7 @@ pub const ZigClangUO = extern enum {	...	@@ -138,7 +948,7 @@ pub const ZigClangUO = extern enum {
138	Coawait,	948	Coawait,
139	};	949	};
140		950
141	pub const ZigClangTypeClass = extern enum {	951	pub const TypeClass = extern enum {
142	Adjusted,	952	Adjusted,
143	Decayed,	953	Decayed,
144	ConstantArray,	954	ConstantArray,
...	@@ -193,7 +1003,7 @@ pub const ZigClangTypeClass = extern enum {	...	@@ -193,7 +1003,7 @@ pub const ZigClangTypeClass = extern enum {
193	ExtVector,	1003	ExtVector,
194	};	1004	};
195		1005
196	const ZigClangStmtClass = extern enum {	1006	const StmtClass = extern enum {
197	NoStmtClass,	1007	NoStmtClass,
198	GCCAsmStmtClass,	1008	GCCAsmStmtClass,
199	MSAsmStmtClass,	1009	MSAsmStmtClass,
...	@@ -410,7 +1220,7 @@ const ZigClangStmtClass = extern enum {	...	@@ -410,7 +1220,7 @@ const ZigClangStmtClass = extern enum {
410	WhileStmtClass,	1220	WhileStmtClass,
411	};	1221	};
412		1222
413	pub const ZigClangCK = extern enum {	1223	pub const CK = extern enum {
414	Dependent,	1224	Dependent,
415	BitCast,	1225	BitCast,
416	LValueBitCast,	1226	LValueBitCast,
...	@@ -475,24 +1285,7 @@ pub const ZigClangCK = extern enum {	...	@@ -475,24 +1285,7 @@ pub const ZigClangCK = extern enum {
475	IntToOCLSampler,	1285	IntToOCLSampler,
476	};	1286	};
477		1287
478	pub const ZigClangAPValueKind = extern enum {	1288	pub const DeclKind = extern enum {
479	None,
480	Indeterminate,
481	Int,
482	Float,
483	FixedPoint,
484	ComplexInt,
485	ComplexFloat,
486	LValue,
487	Vector,
488	Array,
489	Struct,
490	Union,
491	MemberPointer,
492	AddrLabelDiff,
493	};
494
495	pub const ZigClangDeclKind = extern enum {
496	AccessSpec,	1289	AccessSpec,
497	Block,	1290	Block,
498	Captured,	1291	Captured,
...	@@ -575,7 +1368,7 @@ pub const ZigClangDeclKind = extern enum {	...	@@ -575,7 +1368,7 @@ pub const ZigClangDeclKind = extern enum {
575	TranslationUnit,	1368	TranslationUnit,
576	};	1369	};
577		1370
578	pub const ZigClangBuiltinTypeKind = extern enum {	1371	pub const BuiltinTypeKind = extern enum {
579	OCLImage1dRO,	1372	OCLImage1dRO,
580	OCLImage1dArrayRO,	1373	OCLImage1dArrayRO,
581	OCLImage1dBufferRO,	1374	OCLImage1dBufferRO,
...	@@ -747,7 +1540,7 @@ pub const ZigClangBuiltinTypeKind = extern enum {	...	@@ -747,7 +1540,7 @@ pub const ZigClangBuiltinTypeKind = extern enum {
747	OMPIterator,	1540	OMPIterator,
748	};	1541	};
749		1542
750	pub const ZigClangCallingConv = extern enum {	1543	pub const CallingConv = extern enum {
751	C,	1544	C,
752	X86StdCall,	1545	X86StdCall,
753	X86FastCall,	1546	X86FastCall,
...	@@ -768,7 +1561,7 @@ pub const ZigClangCallingConv = extern enum {	...	@@ -768,7 +1561,7 @@ pub const ZigClangCallingConv = extern enum {
768	AArch64VectorCall,	1561	AArch64VectorCall,
769	};	1562	};
770		1563
771	pub const ZigClangStorageClass = extern enum {	1564	pub const StorageClass = extern enum {
772	None,	1565	None,
773	Extern,	1566	Extern,
774	Static,	1567	Static,
...	@@ -777,7 +1570,7 @@ pub const ZigClangStorageClass = extern enum {	...	@@ -777,7 +1570,7 @@ pub const ZigClangStorageClass = extern enum {
777	Register,	1570	Register,
778	};	1571	};
779		1572
780	pub const ZigClangAPFloat_roundingMode = extern enum(i8) {	1573	pub const APFloat_roundingMode = extern enum(i8) {
781	TowardZero = 0,	1574	TowardZero = 0,
782	NearestTiesToEven = 1,	1575	NearestTiesToEven = 1,
783	TowardPositive = 2,	1576	TowardPositive = 2,
...	@@ -787,7 +1580,7 @@ pub const ZigClangAPFloat_roundingMode = extern enum(i8) {	...	@@ -787,7 +1580,7 @@ pub const ZigClangAPFloat_roundingMode = extern enum(i8) {
787	Invalid = -1,	1580	Invalid = -1,
788	};	1581	};
789		1582
790	pub const ZigClangStringLiteral_StringKind = extern enum {	1583	pub const StringLiteral_StringKind = extern enum {
791	Ascii,	1584	Ascii,
792	Wide,	1585	Wide,
793	UTF8,	1586	UTF8,
...	@@ -795,7 +1588,7 @@ pub const ZigClangStringLiteral_StringKind = extern enum {	...	@@ -795,7 +1588,7 @@ pub const ZigClangStringLiteral_StringKind = extern enum {
795	UTF32,	1588	UTF32,
796	};	1589	};
797		1590
798	pub const ZigClangCharacterLiteral_CharacterKind = extern enum {	1591	pub const CharacterLiteral_CharacterKind = extern enum {
799	Ascii,	1592	Ascii,
800	Wide,	1593	Wide,
801	UTF8,	1594	UTF8,
...	@@ -803,32 +1596,35 @@ pub const ZigClangCharacterLiteral_CharacterKind = extern enum {	...	@@ -803,32 +1596,35 @@ pub const ZigClangCharacterLiteral_CharacterKind = extern enum {
803	UTF32,	1596	UTF32,
804	};	1597	};
805		1598
806	pub const ZigClangRecordDecl_field_iterator = extern struct {	1599	pub const VarDecl_TLSKind = extern enum {
807	opaque: *c_void,	1600	None,
808	};	1601	Static,
809		1602	Dynamic,
810	pub const ZigClangEnumDecl_enumerator_iterator = extern struct {
811	opaque: *c_void,
812	};	1603	};
813		1604
814	pub const ZigClangPreprocessingRecord_iterator = extern struct {	1605	pub const ElaboratedTypeKeyword = extern enum {
815	I: c_int,	1606	Struct,
816	Self: *ZigClangPreprocessingRecord,	1607	Interface,
		1608	Union,
		1609	Class,
		1610	Enum,
		1611	Typename,
		1612	None,
817	};	1613	};
818		1614
819	pub const ZigClangPreprocessedEntity_EntityKind = extern enum {	1615	pub const PreprocessedEntity_EntityKind = extern enum {
820	InvalidKind,	1616	InvalidKind,
821	MacroExpansionKind,	1617	MacroExpansionKind,
822	MacroDefinitionKind,	1618	MacroDefinitionKind,
823	InclusionDirectiveKind,	1619	InclusionDirectiveKind,
824	};	1620	};
825		1621
826	pub const ZigClangExpr_ConstExprUsage = extern enum {	1622	pub const Expr_ConstExprUsage = extern enum {
827	EvaluateForCodeGen,	1623	EvaluateForCodeGen,
828	EvaluateForMangling,	1624	EvaluateForMangling,
829	};	1625	};
830		1626
831	pub const ZigClangUnaryExprOrTypeTrait_Kind = extern enum {	1627	pub const UnaryExprOrTypeTrait_Kind = extern enum {
832	SizeOf,	1628	SizeOf,
833	AlignOf,	1629	AlignOf,
834	VecStep,	1630	VecStep,
...	@@ -836,211 +1632,6 @@ pub const ZigClangUnaryExprOrTypeTrait_Kind = extern enum {	...	@@ -836,211 +1632,6 @@ pub const ZigClangUnaryExprOrTypeTrait_Kind = extern enum {
836	PreferredAlignOf,	1632	PreferredAlignOf,
837	};	1633	};
838		1634
839	pub extern fn ZigClangSourceManager_getSpellingLoc(self: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) struct_ZigClangSourceLocation;
840	pub extern fn ZigClangSourceManager_getFilename(self: const struct_ZigClangSourceManager, SpellingLoc: struct_ZigClangSourceLocation) ?[:0]const u8;
841	pub extern fn ZigClangSourceManager_getSpellingLineNumber(self: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) c_uint;
842	pub extern fn ZigClangSourceManager_getSpellingColumnNumber(self: ?*const struct_ZigClangSourceManager, Loc: struct_ZigClangSourceLocation) c_uint;
843	pub extern fn ZigClangSourceManager_getCharacterData(self: ?const struct_ZigClangSourceManager, SL: struct_ZigClangSourceLocation) [:0]const u8;
844	pub extern fn ZigClangASTContext_getPointerType(self: ?*const struct_ZigClangASTContext, T: struct_ZigClangQualType) struct_ZigClangQualType;
845	pub extern fn ZigClangASTUnit_getASTContext(self: ?struct_ZigClangASTUnit) ?struct_ZigClangASTContext;
846	pub extern fn ZigClangASTUnit_getSourceManager(self: struct_ZigClangASTUnit) struct_ZigClangSourceManager;
847	pub extern fn ZigClangASTUnit_visitLocalTopLevelDecls(self: struct_ZigClangASTUnit, context: ?c_void, Fn: ?fn (?c_void, const ZigClangDecl) callconv(.C) bool) bool;
848	pub extern fn ZigClangRecordType_getDecl(record_ty: ?const struct_ZigClangRecordType) const struct_ZigClangRecordDecl;
849	pub extern fn ZigClangTagDecl_isThisDeclarationADefinition(self: *const ZigClangTagDecl) bool;
850	pub extern fn ZigClangEnumType_getDecl(record_ty: ?const struct_ZigClangEnumType) const struct_ZigClangEnumDecl;
851	pub extern fn ZigClangRecordDecl_getCanonicalDecl(record_decl: ?const struct_ZigClangRecordDecl) ?const struct_ZigClangTagDecl;
852	pub extern fn ZigClangFieldDecl_getCanonicalDecl(field_decl: ?const struct_ZigClangFieldDecl) ?const struct_ZigClangFieldDecl;
853	pub extern fn ZigClangFieldDecl_getAlignedAttribute(field_decl: ?const struct_ZigClangFieldDecl, const ZigClangASTContext) c_uint;
854	pub extern fn ZigClangEnumDecl_getCanonicalDecl(self: ?const struct_ZigClangEnumDecl) ?const struct_ZigClangTagDecl;
855	pub extern fn ZigClangTypedefNameDecl_getCanonicalDecl(self: ?const struct_ZigClangTypedefNameDecl) ?const struct_ZigClangTypedefNameDecl;
856	pub extern fn ZigClangFunctionDecl_getCanonicalDecl(self: ?const struct_ZigClangFunctionDecl) ?const struct_ZigClangFunctionDecl;
857	pub extern fn ZigClangParmVarDecl_getOriginalType(self: ?*const struct_ZigClangParmVarDecl) struct_ZigClangQualType;
858	pub extern fn ZigClangVarDecl_getCanonicalDecl(self: ?const struct_ZigClangVarDecl) ?const struct_ZigClangVarDecl;
859	pub extern fn ZigClangVarDecl_getSectionAttribute(self: const ZigClangVarDecl, len: usize) ?[*]const u8;
860	pub extern fn ZigClangFunctionDecl_getAlignedAttribute(self: const ZigClangFunctionDecl, const ZigClangASTContext) c_uint;
861	pub extern fn ZigClangVarDecl_getAlignedAttribute(self: const ZigClangVarDecl, const ZigClangASTContext) c_uint;
862	pub extern fn ZigClangRecordDecl_getPackedAttribute(self: ?*const struct_ZigClangRecordDecl) bool;
863	pub extern fn ZigClangRecordDecl_getDefinition(self: ?const struct_ZigClangRecordDecl) ?const struct_ZigClangRecordDecl;
864	pub extern fn ZigClangEnumDecl_getDefinition(self: ?const struct_ZigClangEnumDecl) ?const struct_ZigClangEnumDecl;
865	pub extern fn ZigClangRecordDecl_getLocation(self: ?*const struct_ZigClangRecordDecl) struct_ZigClangSourceLocation;
866	pub extern fn ZigClangEnumDecl_getLocation(self: ?*const struct_ZigClangEnumDecl) struct_ZigClangSourceLocation;
867	pub extern fn ZigClangTypedefNameDecl_getLocation(self: ?*const struct_ZigClangTypedefNameDecl) struct_ZigClangSourceLocation;
868	pub extern fn ZigClangDecl_getLocation(self: *const ZigClangDecl) ZigClangSourceLocation;
869	pub extern fn ZigClangRecordDecl_isUnion(record_decl: ?*const struct_ZigClangRecordDecl) bool;
870	pub extern fn ZigClangRecordDecl_isStruct(record_decl: ?*const struct_ZigClangRecordDecl) bool;
871	pub extern fn ZigClangRecordDecl_isAnonymousStructOrUnion(record_decl: ?*const struct_ZigClangRecordDecl) bool;
872	pub extern fn ZigClangRecordDecl_field_begin(*const struct_ZigClangRecordDecl) ZigClangRecordDecl_field_iterator;
873	pub extern fn ZigClangRecordDecl_field_end(*const struct_ZigClangRecordDecl) ZigClangRecordDecl_field_iterator;
874	pub extern fn ZigClangRecordDecl_field_iterator_next(ZigClangRecordDecl_field_iterator) ZigClangRecordDecl_field_iterator;
875	pub extern fn ZigClangRecordDecl_field_iterator_deref(ZigClangRecordDecl_field_iterator) *const struct_ZigClangFieldDecl;
876	pub extern fn ZigClangRecordDecl_field_iterator_neq(ZigClangRecordDecl_field_iterator, ZigClangRecordDecl_field_iterator) bool;
877	pub extern fn ZigClangEnumDecl_getIntegerType(self: ?*const struct_ZigClangEnumDecl) struct_ZigClangQualType;
878	pub extern fn ZigClangEnumDecl_enumerator_begin(*const ZigClangEnumDecl) ZigClangEnumDecl_enumerator_iterator;
879	pub extern fn ZigClangEnumDecl_enumerator_end(*const ZigClangEnumDecl) ZigClangEnumDecl_enumerator_iterator;
880	pub extern fn ZigClangEnumDecl_enumerator_iterator_next(ZigClangEnumDecl_enumerator_iterator) ZigClangEnumDecl_enumerator_iterator;
881	pub extern fn ZigClangEnumDecl_enumerator_iterator_deref(ZigClangEnumDecl_enumerator_iterator) *const ZigClangEnumConstantDecl;
882	pub extern fn ZigClangEnumDecl_enumerator_iterator_neq(ZigClangEnumDecl_enumerator_iterator, ZigClangEnumDecl_enumerator_iterator) bool;
883	pub extern fn ZigClangDecl_castToNamedDecl(decl: const ZigClangDecl) ?const ZigClangNamedDecl;
884	pub extern fn ZigClangNamedDecl_getName_bytes_begin(decl: ?const struct_ZigClangNamedDecl) [:0]const u8;
885	pub extern fn ZigClangSourceLocation_eq(a: struct_ZigClangSourceLocation, b: struct_ZigClangSourceLocation) bool;
886	pub extern fn ZigClangTypedefType_getDecl(self: ?const struct_ZigClangTypedefType) const struct_ZigClangTypedefNameDecl;
887	pub extern fn ZigClangTypedefNameDecl_getUnderlyingType(self: ?*const struct_ZigClangTypedefNameDecl) struct_ZigClangQualType;
888	pub extern fn ZigClangQualType_getCanonicalType(self: struct_ZigClangQualType) struct_ZigClangQualType;
889	pub extern fn ZigClangQualType_getTypeClass(self: struct_ZigClangQualType) ZigClangTypeClass;
890	pub extern fn ZigClangQualType_getTypePtr(self: struct_ZigClangQualType) *const struct_ZigClangType;
891	pub extern fn ZigClangQualType_addConst(self: *struct_ZigClangQualType) void;
892	pub extern fn ZigClangQualType_eq(self: struct_ZigClangQualType, arg1: struct_ZigClangQualType) bool;
893	pub extern fn ZigClangQualType_isConstQualified(self: struct_ZigClangQualType) bool;
894	pub extern fn ZigClangQualType_isVolatileQualified(self: struct_ZigClangQualType) bool;
895	pub extern fn ZigClangQualType_isRestrictQualified(self: struct_ZigClangQualType) bool;
896	pub extern fn ZigClangType_getTypeClass(self: ?*const struct_ZigClangType) ZigClangTypeClass;
897	pub extern fn ZigClangType_getPointeeType(self: ?*const struct_ZigClangType) struct_ZigClangQualType;
898	pub extern fn ZigClangType_isVoidType(self: ?*const struct_ZigClangType) bool;
899	pub extern fn ZigClangType_isConstantArrayType(self: ?*const struct_ZigClangType) bool;
900	pub extern fn ZigClangType_isRecordType(self: ?*const struct_ZigClangType) bool;
901	pub extern fn ZigClangType_isIncompleteOrZeroLengthArrayType(self: ?const struct_ZigClangType, const ZigClangASTContext) bool;
902	pub extern fn ZigClangType_isArrayType(self: ?*const struct_ZigClangType) bool;
903	pub extern fn ZigClangType_isBooleanType(self: ?*const struct_ZigClangType) bool;
904	pub extern fn ZigClangType_getTypeClassName(self: const struct_ZigClangType) [:0]const u8;
905	pub extern fn ZigClangType_getAsArrayTypeUnsafe(self: const ZigClangType) const ZigClangArrayType;
906	pub extern fn ZigClangType_getAsRecordType(self: const ZigClangType) ?const ZigClangRecordType;
907	pub extern fn ZigClangType_getAsUnionType(self: const ZigClangType) ?const ZigClangRecordType;
908	pub extern fn ZigClangStmt_getBeginLoc(self: *const ZigClangStmt) struct_ZigClangSourceLocation;
909	pub extern fn ZigClangStmt_getStmtClass(self: ?*const ZigClangStmt) ZigClangStmtClass;
910	pub extern fn ZigClangStmt_classof_Expr(self: ?*const ZigClangStmt) bool;
911	pub extern fn ZigClangExpr_getStmtClass(self: *const struct_ZigClangExpr) ZigClangStmtClass;
912	pub extern fn ZigClangExpr_getType(self: *const struct_ZigClangExpr) struct_ZigClangQualType;
913	pub extern fn ZigClangExpr_getBeginLoc(self: *const struct_ZigClangExpr) struct_ZigClangSourceLocation;
914	pub extern fn ZigClangInitListExpr_getInit(self: ?const struct_ZigClangInitListExpr, i: c_uint) const ZigClangExpr;
915	pub extern fn ZigClangInitListExpr_getArrayFiller(self: ?const struct_ZigClangInitListExpr) const ZigClangExpr;
916	pub extern fn ZigClangInitListExpr_getNumInits(self: ?*const struct_ZigClangInitListExpr) c_uint;
917	pub extern fn ZigClangInitListExpr_getInitializedFieldInUnion(self: ?const struct_ZigClangInitListExpr) ?ZigClangFieldDecl;
918	pub extern fn ZigClangAPValue_getKind(self: ?*const struct_ZigClangAPValue) ZigClangAPValueKind;
919	pub extern fn ZigClangAPValue_getInt(self: ?const struct_ZigClangAPValue) const struct_ZigClangAPSInt;
920	pub extern fn ZigClangAPValue_getArrayInitializedElts(self: ?*const struct_ZigClangAPValue) c_uint;
921	pub extern fn ZigClangAPValue_getArraySize(self: ?*const struct_ZigClangAPValue) c_uint;
922	pub extern fn ZigClangAPValue_getLValueBase(self: ?*const struct_ZigClangAPValue) struct_ZigClangAPValueLValueBase;
923	pub extern fn ZigClangAPSInt_isSigned(self: *const struct_ZigClangAPSInt) bool;
924	pub extern fn ZigClangAPSInt_isNegative(self: *const struct_ZigClangAPSInt) bool;
925	pub extern fn ZigClangAPSInt_negate(self: const struct_ZigClangAPSInt) const struct_ZigClangAPSInt;
926	pub extern fn ZigClangAPSInt_free(self: *const struct_ZigClangAPSInt) void;
927	pub extern fn ZigClangAPSInt_getRawData(self: const struct_ZigClangAPSInt) [:0]const u64;
928	pub extern fn ZigClangAPSInt_getNumWords(self: *const struct_ZigClangAPSInt) c_uint;
929
930	pub extern fn ZigClangAPInt_getLimitedValue(self: *const struct_ZigClangAPInt, limit: u64) u64;
931	pub extern fn ZigClangAPValueLValueBase_dyn_cast_Expr(self: struct_ZigClangAPValueLValueBase) ?*const struct_ZigClangExpr;
932	pub extern fn ZigClangASTUnit_delete(self: ?*struct_ZigClangASTUnit) void;
933
934	pub extern fn ZigClangFunctionDecl_getType(self: *const ZigClangFunctionDecl) struct_ZigClangQualType;
935	pub extern fn ZigClangFunctionDecl_getLocation(self: *const ZigClangFunctionDecl) struct_ZigClangSourceLocation;
936	pub extern fn ZigClangFunctionDecl_hasBody(self: *const ZigClangFunctionDecl) bool;
937	pub extern fn ZigClangFunctionDecl_getStorageClass(self: *const ZigClangFunctionDecl) ZigClangStorageClass;
938	pub extern fn ZigClangFunctionDecl_getParamDecl(self: const ZigClangFunctionDecl, i: c_uint) const struct_ZigClangParmVarDecl;
939	pub extern fn ZigClangFunctionDecl_getBody(self: const ZigClangFunctionDecl) const ZigClangStmt;
940	pub extern fn ZigClangFunctionDecl_doesDeclarationForceExternallyVisibleDefinition(self: *const ZigClangFunctionDecl) bool;
941	pub extern fn ZigClangFunctionDecl_isThisDeclarationADefinition(self: *const ZigClangFunctionDecl) bool;
942	pub extern fn ZigClangFunctionDecl_doesThisDeclarationHaveABody(self: *const ZigClangFunctionDecl) bool;
943	pub extern fn ZigClangFunctionDecl_isInlineSpecified(self: *const ZigClangFunctionDecl) bool;
944	pub extern fn ZigClangFunctionDecl_isDefined(self: *const ZigClangFunctionDecl) bool;
945	pub extern fn ZigClangFunctionDecl_getDefinition(self: const ZigClangFunctionDecl) ?const struct_ZigClangFunctionDecl;
946	pub extern fn ZigClangFunctionDecl_getSectionAttribute(self: const ZigClangFunctionDecl, len: usize) ?[*]const u8;
947
948	pub extern fn ZigClangBuiltinType_getKind(self: *const struct_ZigClangBuiltinType) ZigClangBuiltinTypeKind;
949
950	pub extern fn ZigClangFunctionType_getNoReturnAttr(self: *const ZigClangFunctionType) bool;
951	pub extern fn ZigClangFunctionType_getCallConv(self: *const ZigClangFunctionType) ZigClangCallingConv;
952	pub extern fn ZigClangFunctionType_getReturnType(self: *const ZigClangFunctionType) ZigClangQualType;
953
954	pub extern fn ZigClangFunctionProtoType_isVariadic(self: *const struct_ZigClangFunctionProtoType) bool;
955	pub extern fn ZigClangFunctionProtoType_getNumParams(self: *const struct_ZigClangFunctionProtoType) c_uint;
956	pub extern fn ZigClangFunctionProtoType_getParamType(self: *const struct_ZigClangFunctionProtoType, i: c_uint) ZigClangQualType;
957	pub extern fn ZigClangFunctionProtoType_getReturnType(self: *const ZigClangFunctionProtoType) ZigClangQualType;
958
959	pub const ZigClangSourceLocation = struct_ZigClangSourceLocation;
960	pub const ZigClangQualType = struct_ZigClangQualType;
961	pub const ZigClangConditionalOperator = struct_ZigClangConditionalOperator;
962	pub const ZigClangBinaryConditionalOperator = struct_ZigClangBinaryConditionalOperator;
963	pub const ZigClangAbstractConditionalOperator = struct_ZigClangAbstractConditionalOperator;
964	pub const ZigClangAPValueLValueBase = struct_ZigClangAPValueLValueBase;
965	pub const ZigClangAPValue = struct_ZigClangAPValue;
966	pub const ZigClangAPSInt = struct_ZigClangAPSInt;
967	pub const ZigClangAPFloat = struct_ZigClangAPFloat;
968	pub const ZigClangASTContext = struct_ZigClangASTContext;
969	pub const ZigClangASTUnit = struct_ZigClangASTUnit;
970	pub const ZigClangArraySubscriptExpr = struct_ZigClangArraySubscriptExpr;
971	pub const ZigClangArrayType = struct_ZigClangArrayType;
972	pub const ZigClangAttributedType = struct_ZigClangAttributedType;
973	pub const ZigClangBinaryOperator = struct_ZigClangBinaryOperator;
974	pub const ZigClangBreakStmt = struct_ZigClangBreakStmt;
975	pub const ZigClangBuiltinType = struct_ZigClangBuiltinType;
976	pub const ZigClangCStyleCastExpr = struct_ZigClangCStyleCastExpr;
977	pub const ZigClangCallExpr = struct_ZigClangCallExpr;
978	pub const ZigClangCaseStmt = struct_ZigClangCaseStmt;
979	pub const ZigClangCompoundAssignOperator = struct_ZigClangCompoundAssignOperator;
980	pub const ZigClangCompoundStmt = struct_ZigClangCompoundStmt;
981	pub const ZigClangConstantArrayType = struct_ZigClangConstantArrayType;
982	pub const ZigClangContinueStmt = struct_ZigClangContinueStmt;
983	pub const ZigClangDecayedType = struct_ZigClangDecayedType;
984	pub const ZigClangDeclRefExpr = struct_ZigClangDeclRefExpr;
985	pub const ZigClangDeclStmt = struct_ZigClangDeclStmt;
986	pub const ZigClangDefaultStmt = struct_ZigClangDefaultStmt;
987	pub const ZigClangDiagnosticOptions = struct_ZigClangDiagnosticOptions;
988	pub const ZigClangDiagnosticsEngine = struct_ZigClangDiagnosticsEngine;
989	pub const ZigClangDoStmt = struct_ZigClangDoStmt;
990	pub const ZigClangElaboratedType = struct_ZigClangElaboratedType;
991	pub const ZigClangEnumConstantDecl = struct_ZigClangEnumConstantDecl;
992	pub const ZigClangEnumDecl = struct_ZigClangEnumDecl;
993	pub const ZigClangEnumType = struct_ZigClangEnumType;
994	pub const ZigClangExpr = struct_ZigClangExpr;
995	pub const ZigClangFieldDecl = struct_ZigClangFieldDecl;
996	pub const ZigClangFileID = struct_ZigClangFileID;
997	pub const ZigClangForStmt = struct_ZigClangForStmt;
998	pub const ZigClangFullSourceLoc = struct_ZigClangFullSourceLoc;
999	pub const ZigClangFunctionDecl = struct_ZigClangFunctionDecl;
1000	pub const ZigClangFunctionProtoType = struct_ZigClangFunctionProtoType;
1001	pub const ZigClangIfStmt = struct_ZigClangIfStmt;
1002	pub const ZigClangImplicitCastExpr = struct_ZigClangImplicitCastExpr;
1003	pub const ZigClangIncompleteArrayType = struct_ZigClangIncompleteArrayType;
1004	pub const ZigClangIntegerLiteral = struct_ZigClangIntegerLiteral;
1005	pub const ZigClangMacroDefinitionRecord = struct_ZigClangMacroDefinitionRecord;
1006	pub const ZigClangMacroExpansion = struct_ZigClangMacroExpansion;
1007	pub const ZigClangMacroQualifiedType = struct_ZigClangMacroQualifiedType;
1008	pub const ZigClangMemberExpr = struct_ZigClangMemberExpr;
1009	pub const ZigClangNamedDecl = struct_ZigClangNamedDecl;
1010	pub const ZigClangNone = struct_ZigClangNone;
1011	pub const ZigClangOpaqueValueExpr = struct_ZigClangOpaqueValueExpr;
1012	pub const ZigClangPCHContainerOperations = struct_ZigClangPCHContainerOperations;
1013	pub const ZigClangParenExpr = struct_ZigClangParenExpr;
1014	pub const ZigClangParenType = struct_ZigClangParenType;
1015	pub const ZigClangParmVarDecl = struct_ZigClangParmVarDecl;
1016	pub const ZigClangPointerType = struct_ZigClangPointerType;
1017	pub const ZigClangPreprocessedEntity = struct_ZigClangPreprocessedEntity;
1018	pub const ZigClangRecordDecl = struct_ZigClangRecordDecl;
1019	pub const ZigClangRecordType = struct_ZigClangRecordType;
1020	pub const ZigClangReturnStmt = struct_ZigClangReturnStmt;
1021	pub const ZigClangSkipFunctionBodiesScope = struct_ZigClangSkipFunctionBodiesScope;
1022	pub const ZigClangSourceManager = struct_ZigClangSourceManager;
1023	pub const ZigClangSourceRange = struct_ZigClangSourceRange;
1024	pub const ZigClangStringLiteral = struct_ZigClangStringLiteral;
1025	pub const ZigClangStringRef = struct_ZigClangStringRef;
1026	pub const ZigClangSwitchStmt = struct_ZigClangSwitchStmt;
1027	pub const ZigClangTagDecl = struct_ZigClangTagDecl;
1028	pub const ZigClangType = struct_ZigClangType;
1029	pub const ZigClangTypedefNameDecl = struct_ZigClangTypedefNameDecl;
1030	pub const ZigClangTypedefType = struct_ZigClangTypedefType;
1031	pub const ZigClangUnaryExprOrTypeTraitExpr = struct_ZigClangUnaryExprOrTypeTraitExpr;
1032	pub const ZigClangUnaryOperator = struct_ZigClangUnaryOperator;
1033	pub const ZigClangValueDecl = struct_ZigClangValueDecl;
1034	pub const ZigClangVarDecl = struct_ZigClangVarDecl;
1035	pub const ZigClangWhileStmt = struct_ZigClangWhileStmt;
1036	pub const ZigClangFunctionType = struct_ZigClangFunctionType;
1037	pub const ZigClangPredefinedExpr = struct_ZigClangPredefinedExpr;
1038	pub const ZigClangInitListExpr = struct_ZigClangInitListExpr;
1039
1040	pub const struct_ZigClangSourceLocation = extern struct {
1041	ID: c_uint,
1042	};
1043
1044	pub const Stage2ErrorMsg = extern struct {	1635	pub const Stage2ErrorMsg = extern struct {
1045	filename_ptr: ?[*]const u8,	1636	filename_ptr: ?[*]const u8,
1046	filename_len: usize,	1637	filename_len: usize,
...	@@ -1054,199 +1645,16 @@ pub const Stage2ErrorMsg = extern struct {	...	@@ -1054,199 +1645,16 @@ pub const Stage2ErrorMsg = extern struct {
1054	column: c_uint,	1645	column: c_uint,
1055	// byte offset into source	1646	// byte offset into source
1056	offset: c_uint,	1647	offset: c_uint,
1057	};
1058		1648
1059	pub const struct_ZigClangQualType = extern struct {	1649	pub const delete = ZigClangErrorMsg_delete;
1060	ptr: ?*c_void,	1650	extern fn ZigClangErrorMsg_delete(ptr: [*]Stage2ErrorMsg, len: usize) void;
1061	};	1651	};
1062		1652
1063	pub const struct_ZigClangAPValueLValueBase = extern struct {	1653	pub const LoadFromCommandLine = ZigClangLoadFromCommandLine;
1064	Ptr: ?*c_void,	1654	extern fn ZigClangLoadFromCommandLine(
1065	CallIndex: c_uint,
1066	Version: c_uint,
1067	};
1068
1069	pub extern fn ZigClangErrorMsg_delete(ptr: [*]Stage2ErrorMsg, len: usize) void;
1070
1071	pub extern fn ZigClangLoadFromCommandLine(
1072	args_begin: []?[]const u8,	1655	args_begin: []?[]const u8,
1073	args_end: []?[]const u8,	1656	args_end: []?[]const u8,
1074	errors_ptr: []Stage2ErrorMsg,	1657	errors_ptr: []Stage2ErrorMsg,
1075	errors_len: *usize,	1658	errors_len: *usize,
1076	resources_path: [*:0]const u8,	1659	resources_path: [*:0]const u8,
1077	) ?*ZigClangASTUnit;	1660	) ?*ASTUnit;
1078
1079	pub extern fn ZigClangDecl_getKind(decl: *const ZigClangDecl) ZigClangDeclKind;
1080	pub extern fn ZigClangDecl_getDeclKindName(decl: const ZigClangDecl) [:0]const u8;
1081
1082	pub const ZigClangCompoundStmt_const_body_iterator = []const ZigClangStmt;
1083
1084	pub extern fn ZigClangCompoundStmt_body_begin(self: *const ZigClangCompoundStmt) ZigClangCompoundStmt_const_body_iterator;
1085	pub extern fn ZigClangCompoundStmt_body_end(self: *const ZigClangCompoundStmt) ZigClangCompoundStmt_const_body_iterator;
1086
1087	pub const ZigClangDeclStmt_const_decl_iterator = []const ZigClangDecl;
1088
1089	pub extern fn ZigClangDeclStmt_decl_begin(self: *const ZigClangDeclStmt) ZigClangDeclStmt_const_decl_iterator;
1090	pub extern fn ZigClangDeclStmt_decl_end(self: *const ZigClangDeclStmt) ZigClangDeclStmt_const_decl_iterator;
1091
1092	pub extern fn ZigClangVarDecl_getLocation(self: *const struct_ZigClangVarDecl) ZigClangSourceLocation;
1093	pub extern fn ZigClangVarDecl_hasInit(self: *const struct_ZigClangVarDecl) bool;
1094	pub extern fn ZigClangVarDecl_getStorageClass(self: *const ZigClangVarDecl) ZigClangStorageClass;
1095	pub extern fn ZigClangVarDecl_getType(self: ?*const struct_ZigClangVarDecl) struct_ZigClangQualType;
1096	pub extern fn ZigClangVarDecl_getInit(const ZigClangVarDecl) ?const ZigClangExpr;
1097	pub extern fn ZigClangVarDecl_getTLSKind(self: ?*const struct_ZigClangVarDecl) ZigClangVarDecl_TLSKind;
1098	pub const ZigClangVarDecl_TLSKind = extern enum {
1099	None,
1100	Static,
1101	Dynamic,
1102	};
1103
1104	pub extern fn ZigClangImplicitCastExpr_getBeginLoc(*const ZigClangImplicitCastExpr) ZigClangSourceLocation;
1105	pub extern fn ZigClangImplicitCastExpr_getCastKind(*const ZigClangImplicitCastExpr) ZigClangCK;
1106	pub extern fn ZigClangImplicitCastExpr_getSubExpr(const ZigClangImplicitCastExpr) const ZigClangExpr;
1107
1108	pub extern fn ZigClangArrayType_getElementType(*const ZigClangArrayType) ZigClangQualType;
1109	pub extern fn ZigClangIncompleteArrayType_getElementType(*const ZigClangIncompleteArrayType) ZigClangQualType;
1110
1111	pub extern fn ZigClangConstantArrayType_getElementType(self: *const struct_ZigClangConstantArrayType) ZigClangQualType;
1112	pub extern fn ZigClangConstantArrayType_getSize(self: const struct_ZigClangConstantArrayType) const struct_ZigClangAPInt;
1113	pub extern fn ZigClangDeclRefExpr_getDecl(const ZigClangDeclRefExpr) const ZigClangValueDecl;
1114	pub extern fn ZigClangDeclRefExpr_getFoundDecl(const ZigClangDeclRefExpr) const ZigClangNamedDecl;
1115
1116	pub extern fn ZigClangParenType_getInnerType(*const ZigClangParenType) ZigClangQualType;
1117
1118	pub extern fn ZigClangElaboratedType_getNamedType(*const ZigClangElaboratedType) ZigClangQualType;
1119
1120	pub extern fn ZigClangAttributedType_getEquivalentType(*const ZigClangAttributedType) ZigClangQualType;
1121
1122	pub extern fn ZigClangMacroQualifiedType_getModifiedType(*const ZigClangMacroQualifiedType) ZigClangQualType;
1123
1124	pub extern fn ZigClangCStyleCastExpr_getBeginLoc(*const ZigClangCStyleCastExpr) ZigClangSourceLocation;
1125	pub extern fn ZigClangCStyleCastExpr_getSubExpr(const ZigClangCStyleCastExpr) const ZigClangExpr;
1126	pub extern fn ZigClangCStyleCastExpr_getType(*const ZigClangCStyleCastExpr) ZigClangQualType;
1127
1128	pub const ZigClangExprEvalResult = struct_ZigClangExprEvalResult;
1129	pub const struct_ZigClangExprEvalResult = extern struct {
1130	HasSideEffects: bool,
1131	HasUndefinedBehavior: bool,
1132	SmallVectorImpl: ?*c_void,
1133	Val: ZigClangAPValue,
1134	};
1135
1136	pub const struct_ZigClangAPValue = extern struct {
1137	Kind: ZigClangAPValueKind,
1138	Data: if (builtin.os.tag == .windows and builtin.abi == .msvc) [52]u8 else [68]u8,
1139	};
1140	pub extern fn ZigClangVarDecl_getTypeSourceInfo_getType(self: *const struct_ZigClangVarDecl) struct_ZigClangQualType;
1141
1142	pub extern fn ZigClangIntegerLiteral_EvaluateAsInt(const ZigClangIntegerLiteral, ZigClangExprEvalResult, *const ZigClangASTContext) bool;
1143	pub extern fn ZigClangIntegerLiteral_getBeginLoc(*const ZigClangIntegerLiteral) ZigClangSourceLocation;
1144	pub extern fn ZigClangIntegerLiteral_isZero(const ZigClangIntegerLiteral, bool, *const ZigClangASTContext) bool;
1145
1146	pub extern fn ZigClangReturnStmt_getRetValue(const ZigClangReturnStmt) ?const ZigClangExpr;
1147
1148	pub extern fn ZigClangBinaryOperator_getOpcode(*const ZigClangBinaryOperator) ZigClangBO;
1149	pub extern fn ZigClangBinaryOperator_getBeginLoc(*const ZigClangBinaryOperator) ZigClangSourceLocation;
1150	pub extern fn ZigClangBinaryOperator_getLHS(const ZigClangBinaryOperator) const ZigClangExpr;
1151	pub extern fn ZigClangBinaryOperator_getRHS(const ZigClangBinaryOperator) const ZigClangExpr;
1152	pub extern fn ZigClangBinaryOperator_getType(*const ZigClangBinaryOperator) ZigClangQualType;
1153
1154	pub extern fn ZigClangDecayedType_getDecayedType(*const ZigClangDecayedType) ZigClangQualType;
1155
1156	pub extern fn ZigClangStringLiteral_getKind(*const ZigClangStringLiteral) ZigClangStringLiteral_StringKind;
1157	pub extern fn ZigClangStringLiteral_getString_bytes_begin_size(const ZigClangStringLiteral, usize) [*]const u8;
1158
1159	pub extern fn ZigClangParenExpr_getSubExpr(const ZigClangParenExpr) const ZigClangExpr;
1160
1161	pub extern fn ZigClangFieldDecl_isAnonymousStructOrUnion(*const struct_ZigClangFieldDecl) bool;
1162	pub extern fn ZigClangFieldDecl_isBitField(*const struct_ZigClangFieldDecl) bool;
1163	pub extern fn ZigClangFieldDecl_getType(*const struct_ZigClangFieldDecl) struct_ZigClangQualType;
1164	pub extern fn ZigClangFieldDecl_getLocation(*const struct_ZigClangFieldDecl) struct_ZigClangSourceLocation;
1165
1166	pub extern fn ZigClangEnumConstantDecl_getInitExpr(const ZigClangEnumConstantDecl) ?const ZigClangExpr;
1167	pub extern fn ZigClangEnumConstantDecl_getInitVal(const ZigClangEnumConstantDecl) const ZigClangAPSInt;
1168
1169	pub extern fn ZigClangASTUnit_getLocalPreprocessingEntities_begin(*ZigClangASTUnit) ZigClangPreprocessingRecord_iterator;
1170	pub extern fn ZigClangASTUnit_getLocalPreprocessingEntities_end(*ZigClangASTUnit) ZigClangPreprocessingRecord_iterator;
1171	pub extern fn ZigClangPreprocessingRecord_iterator_deref(ZigClangPreprocessingRecord_iterator) *ZigClangPreprocessedEntity;
1172	pub extern fn ZigClangPreprocessedEntity_getKind(*const ZigClangPreprocessedEntity) ZigClangPreprocessedEntity_EntityKind;
1173
1174	pub extern fn ZigClangMacroDefinitionRecord_getName_getNameStart(const ZigClangMacroDefinitionRecord) [:0]const u8;
1175	pub extern fn ZigClangMacroDefinitionRecord_getSourceRange_getBegin(*const ZigClangMacroDefinitionRecord) ZigClangSourceLocation;
1176	pub extern fn ZigClangMacroDefinitionRecord_getSourceRange_getEnd(*const ZigClangMacroDefinitionRecord) ZigClangSourceLocation;
1177
1178	pub extern fn ZigClangMacroExpansion_getDefinition(const ZigClangMacroExpansion) const ZigClangMacroDefinitionRecord;
1179
1180	pub extern fn ZigClangIfStmt_getThen(const ZigClangIfStmt) const ZigClangStmt;
1181	pub extern fn ZigClangIfStmt_getElse(const ZigClangIfStmt) ?const ZigClangStmt;
1182	pub extern fn ZigClangIfStmt_getCond(const ZigClangIfStmt) const ZigClangStmt;
1183
1184	pub extern fn ZigClangWhileStmt_getCond(const ZigClangWhileStmt) const ZigClangExpr;
1185	pub extern fn ZigClangWhileStmt_getBody(const ZigClangWhileStmt) const ZigClangStmt;
1186
1187	pub extern fn ZigClangDoStmt_getCond(const ZigClangDoStmt) const ZigClangExpr;
1188	pub extern fn ZigClangDoStmt_getBody(const ZigClangDoStmt) const ZigClangStmt;
1189
1190	pub extern fn ZigClangForStmt_getInit(const ZigClangForStmt) ?const ZigClangStmt;
1191	pub extern fn ZigClangForStmt_getCond(const ZigClangForStmt) ?const ZigClangExpr;
1192	pub extern fn ZigClangForStmt_getInc(const ZigClangForStmt) ?const ZigClangExpr;
1193	pub extern fn ZigClangForStmt_getBody(const ZigClangForStmt) const ZigClangStmt;
1194
1195	pub extern fn ZigClangAPFloat_toString(self: const ZigClangAPFloat, precision: c_uint, maxPadding: c_uint, truncateZero: bool) [:0]const u8;
1196	pub extern fn ZigClangAPFloat_getValueAsApproximateDouble(*const ZigClangFloatingLiteral) f64;
1197
1198	pub extern fn ZigClangAbstractConditionalOperator_getCond(const ZigClangAbstractConditionalOperator) const ZigClangExpr;
1199	pub extern fn ZigClangAbstractConditionalOperator_getTrueExpr(const ZigClangAbstractConditionalOperator) const ZigClangExpr;
1200	pub extern fn ZigClangAbstractConditionalOperator_getFalseExpr(const ZigClangAbstractConditionalOperator) const ZigClangExpr;
1201
1202	pub extern fn ZigClangSwitchStmt_getConditionVariableDeclStmt(const ZigClangSwitchStmt) ?const ZigClangDeclStmt;
1203	pub extern fn ZigClangSwitchStmt_getCond(const ZigClangSwitchStmt) const ZigClangExpr;
1204	pub extern fn ZigClangSwitchStmt_getBody(const ZigClangSwitchStmt) const ZigClangStmt;
1205	pub extern fn ZigClangSwitchStmt_isAllEnumCasesCovered(*const ZigClangSwitchStmt) bool;
1206
1207	pub extern fn ZigClangCaseStmt_getLHS(const ZigClangCaseStmt) const ZigClangExpr;
1208	pub extern fn ZigClangCaseStmt_getRHS(const ZigClangCaseStmt) ?const ZigClangExpr;
1209	pub extern fn ZigClangCaseStmt_getBeginLoc(*const ZigClangCaseStmt) ZigClangSourceLocation;
1210	pub extern fn ZigClangCaseStmt_getSubStmt(const ZigClangCaseStmt) const ZigClangStmt;
1211
1212	pub extern fn ZigClangDefaultStmt_getSubStmt(const ZigClangDefaultStmt) const ZigClangStmt;
1213
1214	pub extern fn ZigClangExpr_EvaluateAsConstantExpr(const ZigClangExpr, ZigClangExprEvalResult, ZigClangExpr_ConstExprUsage, *const ZigClangASTContext) bool;
1215
1216	pub extern fn ZigClangPredefinedExpr_getFunctionName(const ZigClangPredefinedExpr) const ZigClangStringLiteral;
1217
1218	pub extern fn ZigClangCharacterLiteral_getBeginLoc(*const ZigClangCharacterLiteral) ZigClangSourceLocation;
1219	pub extern fn ZigClangCharacterLiteral_getKind(*const ZigClangCharacterLiteral) ZigClangCharacterLiteral_CharacterKind;
1220	pub extern fn ZigClangCharacterLiteral_getValue(*const ZigClangCharacterLiteral) c_uint;
1221
1222	pub extern fn ZigClangStmtExpr_getSubStmt(const ZigClangStmtExpr) const ZigClangCompoundStmt;
1223
1224	pub extern fn ZigClangMemberExpr_getBase(const ZigClangMemberExpr) const ZigClangExpr;
1225	pub extern fn ZigClangMemberExpr_isArrow(*const ZigClangMemberExpr) bool;
1226	pub extern fn ZigClangMemberExpr_getMemberDecl(const ZigClangMemberExpr) const ZigClangValueDecl;
1227
1228	pub extern fn ZigClangArraySubscriptExpr_getBase(const ZigClangArraySubscriptExpr) const ZigClangExpr;
1229	pub extern fn ZigClangArraySubscriptExpr_getIdx(const ZigClangArraySubscriptExpr) const ZigClangExpr;
1230
1231	pub extern fn ZigClangCallExpr_getCallee(const ZigClangCallExpr) const ZigClangExpr;
1232	pub extern fn ZigClangCallExpr_getNumArgs(*const ZigClangCallExpr) c_uint;
1233	pub extern fn ZigClangCallExpr_getArgs(const ZigClangCallExpr) []const *const ZigClangExpr;
1234
1235	pub extern fn ZigClangUnaryExprOrTypeTraitExpr_getTypeOfArgument(*const ZigClangUnaryExprOrTypeTraitExpr) ZigClangQualType;
1236	pub extern fn ZigClangUnaryExprOrTypeTraitExpr_getBeginLoc(*const ZigClangUnaryExprOrTypeTraitExpr) ZigClangSourceLocation;
1237	pub extern fn ZigClangUnaryExprOrTypeTraitExpr_getKind(*const ZigClangUnaryExprOrTypeTraitExpr) ZigClangUnaryExprOrTypeTrait_Kind;
1238
1239	pub extern fn ZigClangUnaryOperator_getOpcode(*const ZigClangUnaryOperator) ZigClangUO;
1240	pub extern fn ZigClangUnaryOperator_getType(*const ZigClangUnaryOperator) ZigClangQualType;
1241	pub extern fn ZigClangUnaryOperator_getSubExpr(const ZigClangUnaryOperator) const ZigClangExpr;
1242	pub extern fn ZigClangUnaryOperator_getBeginLoc(*const ZigClangUnaryOperator) ZigClangSourceLocation;
1243
1244	pub extern fn ZigClangOpaqueValueExpr_getSourceExpr(const ZigClangOpaqueValueExpr) ?const ZigClangExpr;
1245
1246	pub extern fn ZigClangCompoundAssignOperator_getType(*const ZigClangCompoundAssignOperator) ZigClangQualType;
1247	pub extern fn ZigClangCompoundAssignOperator_getComputationLHSType(*const ZigClangCompoundAssignOperator) ZigClangQualType;
1248	pub extern fn ZigClangCompoundAssignOperator_getComputationResultType(*const ZigClangCompoundAssignOperator) ZigClangQualType;
1249	pub extern fn ZigClangCompoundAssignOperator_getBeginLoc(*const ZigClangCompoundAssignOperator) ZigClangSourceLocation;
1250	pub extern fn ZigClangCompoundAssignOperator_getOpcode(*const ZigClangCompoundAssignOperator) ZigClangBO;
1251	pub extern fn ZigClangCompoundAssignOperator_getLHS(const ZigClangCompoundAssignOperator) const ZigClangExpr;
1252	pub extern fn ZigClangCompoundAssignOperator_getRHS(const ZigClangCompoundAssignOperator) const ZigClangExpr;

src/clang_options_data.zig+34-6

 @@ -76,8 +76,22 @@ flagpd1("M"),
     .psl = false,
 },
 flagpd1("Mach"),
-flagpd1("O0"),
+.{
-flagpd1("O4"),
+    .name = "O0",
+    .syntax = .flag,
+    .zig_equivalent = .optimize,
+    .pd1 = true,
+    .pd2 = false,
+    .psl = false,
+},
+.{
+    .name = "O4",
+    .syntax = .flag,
+    .zig_equivalent = .optimize,
+    .pd1 = true,
+    .pd2 = false,
+    .psl = false,
+},
 .{
     .name = "O",
     .syntax = .flag,
 @@ -2186,7 +2200,7 @@ flagpd1("fcuda-rdc"),
 .{
     .name = "Os",
     .syntax = .flag,
-    .zig_equivalent = .other,
+    .zig_equivalent = .optimize,
     .pd1 = true,
     .pd2 = false,
     .psl = true,
 @@ -3377,7 +3391,14 @@ flagpd1("fxray-link-deps"),
 flagpd1("fzero-initialized-in-bss"),
 flagpd1("fzvector"),
 flagpd1("g0"),
-flagpd1("g1"),
+.{
+    .name = "g1",
+    .syntax = .flag,
+    .zig_equivalent = .debug,
+    .pd1 = true,
+    .pd2 = false,
+    .psl = false,
+},
 flagpd1("g2"),
 flagpd1("g3"),
 .{
 @@ -3410,7 +3431,14 @@ flagpd1("ggdb3"),
 flagpd1("ggnu-pubnames"),
 flagpd1("ginline-line-tables"),
 flagpd1("gline-directives-only"),
-flagpd1("gline-tables-only"),
+.{
+    .name = "gline-tables-only",
+    .syntax = .flag,
+    .zig_equivalent = .debug,
+    .pd1 = true,
+    .pd2 = false,
+    .psl = false,
+},
 flagpd1("glldb"),
 flagpd1("gmlt"),
 flagpd1("gmodules"),
 @@ -5535,7 +5563,7 @@ jspd1("iquote"),
 joinpd1("weak-l"),
 .{
     .name = "Ofast",
-    .syntax = .joined,
+    .syntax = .flag,
     .zig_equivalent = .optimize,
     .pd1 = true,
     .pd2 = false,

src/link/MachO.zig-21

...	@@ -287,9 +287,6 @@ pub fn flushModule(self: MachO, comp: Compilation) !void {	...	@@ -287,9 +287,6 @@ pub fn flushModule(self: MachO, comp: Compilation) !void {
287	}	287	}
288	const cmd = &self.load_commands.items[self.dylinker_cmd_index.?].Dylinker;	288	const cmd = &self.load_commands.items[self.dylinker_cmd_index.?].Dylinker;
289	off += cmd.name;	289	off += cmd.name;
290	const padding = cmd.cmdsize - @sizeOf(macho.dylinker_command);
291	log.debug("writing LC_LOAD_DYLINKER padding of size {} at 0x{x}\n", .{ padding, off });
292	try self.addPadding(padding, off);
293	log.debug("writing LC_LOAD_DYLINKER path to dyld at 0x{x}\n", .{off});	290	log.debug("writing LC_LOAD_DYLINKER path to dyld at 0x{x}\n", .{off});
294	try self.base.file.?.pwriteAll(mem.spanZ(DEFAULT_DYLD_PATH), off);	291	try self.base.file.?.pwriteAll(mem.spanZ(DEFAULT_DYLD_PATH), off);
295	}	292	}
...	@@ -302,9 +299,6 @@ pub fn flushModule(self: MachO, comp: Compilation) !void {	...	@@ -302,9 +299,6 @@ pub fn flushModule(self: MachO, comp: Compilation) !void {
302	}	299	}
303	const cmd = &self.load_commands.items[self.libsystem_cmd_index.?].Dylib;	300	const cmd = &self.load_commands.items[self.libsystem_cmd_index.?].Dylib;
304	off += cmd.dylib.name;	301	off += cmd.dylib.name;
305	const padding = cmd.cmdsize - @sizeOf(macho.dylib_command);
306	log.debug("writing LC_LOAD_DYLIB padding of size {} at 0x{x}\n", .{ padding, off });
307	try self.addPadding(padding, off);
308	log.debug("writing LC_LOAD_DYLIB path to libSystem at 0x{x}\n", .{off});	302	log.debug("writing LC_LOAD_DYLIB path to libSystem at 0x{x}\n", .{off});
309	try self.base.file.?.pwriteAll(mem.spanZ(LIB_SYSTEM_PATH), off);	303	try self.base.file.?.pwriteAll(mem.spanZ(LIB_SYSTEM_PATH), off);
310	}	304	}
...	@@ -1264,21 +1258,6 @@ fn updateString(self: *MachO, old_str_off: u32, new_name: []const u8) !u32 {	...	@@ -1264,21 +1258,6 @@ fn updateString(self: *MachO, old_str_off: u32, new_name: []const u8) !u32 {
1264	return self.makeString(new_name);	1258	return self.makeString(new_name);
1265	}	1259	}
1266		1260
1267	/// TODO This should not heap allocate, instead it should utilize a fixed size, statically allocated
1268	/// global const array. You could even use pwritev to write the same buffer multiple times with only
1269	/// 1 syscall if you needed to, for example, write 8192 bytes using a buffer of only 4096 bytes.
1270	/// This size parameter should probably be a usize not u64.
1271	fn addPadding(self: *MachO, size: u64, file_offset: u64) !void {
1272	if (size == 0) return;
1273
1274	const buf = try self.base.allocator.alloc(u8, @intCast(usize, size));
1275	defer self.base.allocator.free(buf);
1276
1277	mem.set(u8, buf[0..], 0);
1278
1279	try self.base.file.?.pwriteAll(buf, file_offset);
1280	}
1281
1282	fn detectAllocCollision(self: *MachO, start: u64, size: u64) ?u64 {	1261	fn detectAllocCollision(self: *MachO, start: u64, size: u64) ?u64 {
1283	const hdr_size: u64 = @sizeOf(macho.mach_header_64);	1262	const hdr_size: u64 = @sizeOf(macho.mach_header_64);
1284	if (start < hdr_size) return hdr_size;	1263	if (start < hdr_size) return hdr_size;

src/main.zig+17-7

 @@ -992,15 +992,20 @@ fn buildOutputType(
                     },
                     .optimize => {
                         // Alright, what release mode do they want?
-                        if (mem.eql(u8, it.only_arg, "Os")) {
+                        const level = if (it.only_arg.len >= 1 and it.only_arg[0] == 'O') it.only_arg[1..] else it.only_arg;
+                        if (mem.eql(u8, level, "s") or
+                            mem.eql(u8, level, "z"))
+                        {
                             optimize_mode = .ReleaseSmall;
-                        } else if (mem.eql(u8, it.only_arg, "O2") or
+                        } else if (mem.eql(u8, level, "1") or
-                            mem.eql(u8, it.only_arg, "O3") or
+                            mem.eql(u8, level, "2") or
-                            mem.eql(u8, it.only_arg, "O4"))
+                            mem.eql(u8, level, "3") or
+                            mem.eql(u8, level, "4") or
+                            mem.eql(u8, level, "fast"))
                         {
                             optimize_mode = .ReleaseFast;
-                        } else if (mem.eql(u8, it.only_arg, "Og") or
+                        } else if (mem.eql(u8, level, "g") or
-                            mem.eql(u8, it.only_arg, "O0"))
+                            mem.eql(u8, level, "0"))
                         {
                             optimize_mode = .Debug;
                         } else {
 @@ -1009,8 +1014,13 @@ fn buildOutputType(
                     },
                     .debug => {
                         strip = false;
-                        if (mem.eql(u8, it.only_arg, "-g")) {
+                        if (mem.eql(u8, it.only_arg, "g")) {
                             // We handled with strip = false above.
+                        } else if (mem.eql(u8, it.only_arg, "g1") or
+                            mem.eql(u8, it.only_arg, "gline-tables-only"))
+                        {
+                            // We handled with strip = false above. but we also want reduced debug info.
+                            try clang_argv.append("-gline-tables-only");
                         } else {
                             try clang_argv.appendSlice(it.other_args);
                         }

src/stage1/all_types.hpp+4-1

...	@@ -72,7 +72,6 @@ enum PtrLen {	...	@@ -72,7 +72,6 @@ enum PtrLen {
72	enum CallingConvention {	72	enum CallingConvention {
73	CallingConventionUnspecified,	73	CallingConventionUnspecified,
74	CallingConventionC,	74	CallingConventionC,
75	CallingConventionCold,
76	CallingConventionNaked,	75	CallingConventionNaked,
77	CallingConventionAsync,	76	CallingConventionAsync,
78	CallingConventionInterrupt,	77	CallingConventionInterrupt,
...	@@ -1054,6 +1053,7 @@ enum ContainerKind {	...	@@ -1054,6 +1053,7 @@ enum ContainerKind {
1054	ContainerKindStruct,	1053	ContainerKindStruct,
1055	ContainerKindEnum,	1054	ContainerKindEnum,
1056	ContainerKindUnion,	1055	ContainerKindUnion,
		1056	ContainerKindOpaque,
1057	};	1057	};
1058		1058
1059	enum ContainerLayout {	1059	enum ContainerLayout {
...	@@ -1571,7 +1571,10 @@ enum OnePossibleValue {	...	@@ -1571,7 +1571,10 @@ enum OnePossibleValue {
1571	};	1571	};
1572		1572
1573	struct ZigTypeOpaque {	1573	struct ZigTypeOpaque {
		1574	AstNode *decl_node;
1574	Buf *bare_name;	1575	Buf *bare_name;
		1576
		1577	ScopeDecls *decls_scope;
1575	};	1578	};
1576		1579
1577	struct ZigTypeFnFrame {	1580	struct ZigTypeFnFrame {

src/stage1/analyze.cpp+81-35

 @@ -86,14 +86,18 @@ ZigType *new_type_table_entry(ZigTypeId id) {
 }
 static ScopeDecls **get_container_scope_ptr(ZigType *type_entry) {
-    if (type_entry->id == ZigTypeIdStruct) {
+    switch (type_entry->id) {
-        return &type_entry->data.structure.decls_scope;
+        case ZigTypeIdStruct:
-    } else if (type_entry->id == ZigTypeIdEnum) {
+            return &type_entry->data.structure.decls_scope;
-        return &type_entry->data.enumeration.decls_scope;
+        case ZigTypeIdEnum:
-    } else if (type_entry->id == ZigTypeIdUnion) {
+            return &type_entry->data.enumeration.decls_scope;
-        return &type_entry->data.unionation.decls_scope;
+        case ZigTypeIdUnion:
+            return &type_entry->data.unionation.decls_scope;
+        case ZigTypeIdOpaque:
+            return &type_entry->data.opaque.decls_scope;
+        default:
+            zig_unreachable();
     }
-    zig_unreachable();
 }
 static ScopeExpr *find_expr_scope(Scope *scope) {
 @@ -912,13 +916,17 @@ ZigType *get_opaque_type(CodeGen *g, Scope *scope, AstNode *source_node, const c
     ZigType *import = scope ? get_scope_import(scope) : nullptr;
     unsigned line = source_node ? (unsigned)(source_node->line + 1) : 0;
+    // Note: duplicated in get_partial_container_type
     entry->llvm_type = LLVMInt8Type();
     entry->llvm_di_type = ZigLLVMCreateDebugForwardDeclType(g->dbuilder,
         ZigLLVMTag_DW_structure_type(), full_name,
         import ? ZigLLVMFileToScope(import->data.structure.root_struct->di_file) : nullptr,
         import ? import->data.structure.root_struct->di_file : nullptr,
         line);
+    entry->data.opaque.decl_node = source_node;
     entry->data.opaque.bare_name = bare_name;
+    entry->data.opaque.decls_scope = create_decls_scope(
+        g, source_node, scope, entry, import, &entry->name);
     // The actual size is unknown, but the value must not be 0 because that
     // is how type_has_bits is determined.
 @@ -949,7 +957,6 @@ const char *calling_convention_name(CallingConvention cc) {
     switch (cc) {
         case CallingConventionUnspecified: return "Unspecified";
         case CallingConventionC: return "C";
-        case CallingConventionCold: return "Cold";
         case CallingConventionNaked: return "Naked";
         case CallingConventionAsync: return "Async";
         case CallingConventionInterrupt: return "Interrupt";
 @@ -971,7 +978,6 @@ bool calling_convention_allows_zig_types(CallingConvention cc) {
         case CallingConventionAsync:
             return true;
         case CallingConventionC:
-        case CallingConventionCold:
         case CallingConventionNaked:
         case CallingConventionInterrupt:
         case CallingConventionSignal:
 @@ -1080,6 +1086,8 @@ static ZigTypeId container_to_type(ContainerKind kind) {
             return ZigTypeIdEnum;
         case ContainerKindUnion:
             return ZigTypeIdUnion;
+        case ContainerKindOpaque:
+            return ZigTypeIdOpaque;
     }
     zig_unreachable();
 }
 @@ -1121,6 +1129,22 @@ ZigType *get_partial_container_type(CodeGen *g, Scope *scope, ContainerKind kind
             entry->data.unionation.decl_node = decl_node;
             entry->data.unionation.layout = layout;
             break;
+        case ContainerKindOpaque: {
+            ZigType *import = scope ? get_scope_import(scope) : nullptr;
+            unsigned line = decl_node ? (unsigned)(decl_node->line + 1) : 0;
+            // Note: duplicated in get_opaque_type
+            entry->llvm_type = LLVMInt8Type();
+            entry->llvm_di_type = ZigLLVMCreateDebugForwardDeclType(g->dbuilder,
+                ZigLLVMTag_DW_structure_type(), full_name,
+                import ? ZigLLVMFileToScope(import->data.structure.root_struct->di_file) : nullptr,
+                import ? import->data.structure.root_struct->di_file : nullptr,
+                line);
+            entry->data.opaque.decl_node = decl_node;
+            entry->abi_size = SIZE_MAX;
+            entry->size_in_bits = SIZE_MAX;
+            entry->abi_align = 1;
+            break;
+        }
     }
     buf_init_from_str(&entry->name, full_name);
 @@ -1730,7 +1754,7 @@ static Error emit_error_unless_type_allowed_in_packed_union(CodeGen *g, ZigType
     return emit_error_unless_type_allowed_in_packed_container(g, type_entry, source_node, "union");
 }
-Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, bool *result) {
+Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, ExternPosition position, bool *result) {
     Error err;
     switch (type_entry->id) {
         case ZigTypeIdInvalid:
 @@ -1749,8 +1773,10 @@ Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, bool *result) {
         case ZigTypeIdAnyFrame:
             *result = false;
             return ErrorNone;
-        case ZigTypeIdOpaque:
         case ZigTypeIdUnreachable:
+            *result = position == ExternPositionFunctionReturn;
+            return ErrorNone;
+        case ZigTypeIdOpaque:
         case ZigTypeIdBool:
             *result = true;
             return ErrorNone;
 @@ -1768,23 +1794,27 @@ Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, bool *result) {
                     return ErrorNone;
             }
         case ZigTypeIdVector:
-            return type_allowed_in_extern(g, type_entry->data.vector.elem_type, result);
+            return type_allowed_in_extern(g, type_entry->data.vector.elem_type, ExternPositionOther, result);
         case ZigTypeIdFloat:
             *result = true;
             return ErrorNone;
         case ZigTypeIdArray:
-            return type_allowed_in_extern(g, type_entry->data.array.child_type, result);
+            if ((err = type_allowed_in_extern(g, type_entry->data.array.child_type, ExternPositionOther, result)))
+                return err;
+            *result = *result &&
+                position != ExternPositionFunctionParameter &&
+                position != ExternPositionFunctionReturn;
+            return ErrorNone;
         case ZigTypeIdFn:
             *result = !calling_convention_allows_zig_types(type_entry->data.fn.fn_type_id.cc);
             return ErrorNone;
         case ZigTypeIdPointer:
             if ((err = type_resolve(g, type_entry, ResolveStatusZeroBitsKnown)))
                 return err;
-            if (!type_has_bits(g, type_entry)) {
+            bool has_bits;
-                *result = false;
+            if ((err = type_has_bits2(g, type_entry, &has_bits)))
-                return ErrorNone;
+                return err;
-            }
+            *result = has_bits;
-            *result = true;
             return ErrorNone;
         case ZigTypeIdStruct:
             *result = type_entry->data.structure.layout == ContainerLayoutExtern ||
 @@ -1796,23 +1826,24 @@ Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, bool *result) {
                 *result = false;
                 return ErrorNone;
             }
-            if (!type_is_nonnull_ptr(g, child_type)) {
+            bool is_nonnull_ptr;
+            if ((err = type_is_nonnull_ptr2(g, child_type, &is_nonnull_ptr)))
+                return err;
+            if (!is_nonnull_ptr) {
                 *result = false;
                 return ErrorNone;
             }
-            return type_allowed_in_extern(g, child_type, result);
+            return type_allowed_in_extern(g, child_type, ExternPositionOther, result);
         }
         case ZigTypeIdEnum: {
             if ((err = type_resolve(g, type_entry, ResolveStatusZeroBitsKnown)))
                 return err;
             ZigType *tag_int_type = type_entry->data.enumeration.tag_int_type;
-            if (type_entry->data.enumeration.has_explicit_tag_type) {
+            if (type_entry->data.enumeration.has_explicit_tag_type)
-                return type_allowed_in_extern(g, tag_int_type, result);
+                return type_allowed_in_extern(g, tag_int_type, position, result);
-            } else {
+            *result = type_entry->data.enumeration.layout == ContainerLayoutExtern ||
-                *result = type_entry->data.enumeration.layout == ContainerLayoutExtern ||
+                type_entry->data.enumeration.layout == ContainerLayoutPacked;
-                    type_entry->data.enumeration.layout == ContainerLayoutPacked;
+            return ErrorNone;
-                return ErrorNone;
-            }
         }
         case ZigTypeIdUnion:
             *result = type_entry->data.unionation.layout == ContainerLayoutExtern ||
 @@ -1909,7 +1940,7 @@ static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_sc
         if (!calling_convention_allows_zig_types(fn_type_id.cc)) {
             bool ok_type;
-            if ((err = type_allowed_in_extern(g, type_entry, &ok_type)))
+            if ((err = type_allowed_in_extern(g, type_entry, ExternPositionFunctionParameter, &ok_type)))
                 return g->builtin_types.entry_invalid;
             if (!ok_type) {
                 add_node_error(g, param_node->data.param_decl.type,
 @@ -2014,7 +2045,7 @@ static ZigType *analyze_fn_type(CodeGen *g, AstNode *proto_node, Scope *child_sc
         if ((err = type_resolve(g, fn_type_id.return_type, ResolveStatusSizeKnown)))
             return g->builtin_types.entry_invalid;
         bool ok_type;
-        if ((err = type_allowed_in_extern(g, fn_type_id.return_type, &ok_type)))
+        if ((err = type_allowed_in_extern(g, fn_type_id.return_type, ExternPositionFunctionReturn, &ok_type)))
             return g->builtin_types.entry_invalid;
         if (!ok_type) {
             add_node_error(g, fn_proto->return_type,
 @@ -2333,7 +2364,7 @@ static Error resolve_struct_type(CodeGen *g, ZigType *struct_type) {
         if (struct_type->data.structure.layout == ContainerLayoutExtern) {
             bool ok_type;
-            if ((err = type_allowed_in_extern(g, field_type, &ok_type))) {
+            if ((err = type_allowed_in_extern(g, field_type, ExternPositionOther, &ok_type))) {
                 struct_type->data.structure.resolve_status = ResolveStatusInvalid;
                 return ErrorSemanticAnalyzeFail;
             }
 @@ -2588,7 +2619,7 @@ static Error type_is_valid_extern_enum_tag(CodeGen *g, ZigType *ty, bool *result
     // signed char, a signed integer or an unsigned one. But GCC/Clang allow
     // other integral types as a compiler extension so let's accomodate them
     // aswell.
-    return type_allowed_in_extern(g, ty, result);
+    return type_allowed_in_extern(g, ty, ExternPositionOther, result);
 }
 static Error resolve_enum_zero_bits(CodeGen *g, ZigType *enum_type) {
 @@ -3430,6 +3461,21 @@ static Error resolve_union_zero_bits(CodeGen *g, ZigType *union_type) {
     return ErrorNone;
 }
+static Error resolve_opaque_type(CodeGen *g, ZigType *opaque_type) {
+    Error err = ErrorNone;
+    AstNode *container_node = opaque_type->data.opaque.decl_node;
+    if (container_node != nullptr) {
+        assert(container_node->type == NodeTypeContainerDecl);
+        AstNodeContainerDecl *container_decl = &container_node->data.container_decl;
+        for (size_t i = 0; i < container_decl->fields.length; i++) {
+            AstNode *field_node = container_decl->fields.items[i];
+            add_node_error(g, field_node, buf_create_from_str("opaque types cannot have fields"));
+            err = ErrorSemanticAnalyzeFail;
+        }
+    }
+    return err;
+}
 void append_namespace_qualification(CodeGen *g, Buf *buf, ZigType *container_type) {
     if (g->root_import == container_type || buf_len(&container_type->name) == 0) return;
     buf_append_buf(buf, &container_type->name);
 @@ -3603,7 +3649,6 @@ static void resolve_decl_fn(CodeGen *g, TldFn *tld_fn) {
                     tld_fn->base.resolution = TldResolutionInvalid;
                     return;
                 case CallingConventionC:
-                case CallingConventionCold:
                 case CallingConventionNaked:
                 case CallingConventionInterrupt:
                 case CallingConventionSignal:
 @@ -3896,6 +3941,8 @@ static Error resolve_decl_container(CodeGen *g, TldContainer *tld_container) {
             return resolve_enum_zero_bits(g, tld_container->type_entry);
         case ZigTypeIdUnion:
             return resolve_union_type(g, tld_container->type_entry);
+        case ZigTypeIdOpaque:
+            return resolve_opaque_type(g, tld_container->type_entry);
         default:
             zig_unreachable();
     }
 @@ -4462,6 +4509,7 @@ bool is_container(ZigType *type_entry) {
             return type_entry->data.structure.special != StructSpecialSlice;
         case ZigTypeIdEnum:
         case ZigTypeIdUnion:
+        case ZigTypeIdOpaque:
             return true;
         case ZigTypeIdPointer:
         case ZigTypeIdMetaType:
 @@ -4481,7 +4529,6 @@ bool is_container(ZigType *type_entry) {
         case ZigTypeIdErrorSet:
         case ZigTypeIdFn:
         case ZigTypeIdBoundFn:
-        case ZigTypeIdOpaque:
         case ZigTypeIdVector:
         case ZigTypeIdFnFrame:
         case ZigTypeIdAnyFrame:
 @@ -8168,6 +8215,7 @@ const char *container_string(ContainerKind kind) {
         case ContainerKindEnum: return "enum";
         case ContainerKindStruct: return "struct";
         case ContainerKindUnion: return "union";
+        case ContainerKindOpaque: return "opaque";
     }
     zig_unreachable();
 }
 @@ -8186,8 +8234,6 @@ Buf *type_bare_name(ZigType *type_entry) {
         return &type_entry->name;
     } else if (is_container(type_entry)) {
         return get_container_scope(type_entry)->bare_name;
-    } else if (type_entry->id == ZigTypeIdOpaque) {
-        return type_entry->data.opaque.bare_name;
     } else {
         return &type_entry->name;
     }

src/stage1/analyze.hpp+7-1

 @@ -50,7 +50,13 @@ bool handle_is_ptr(CodeGen *g, ZigType *type_entry);
 bool type_has_bits(CodeGen *g, ZigType *type_entry);
 Error type_has_bits2(CodeGen *g, ZigType *type_entry, bool *result);
-Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, bool *result);
+enum ExternPosition {
+    ExternPositionFunctionParameter,
+    ExternPositionFunctionReturn,
+    ExternPositionOther, // array element, struct field, optional element, etc
+};
+Error type_allowed_in_extern(CodeGen *g, ZigType *type_entry, ExternPosition position, bool *result);
 bool ptr_allows_addr_zero(ZigType *ptr_type);
 // Deprecated, use `type_is_nonnull_ptr2`

src/stage1/codegen.cpp+12-20

 @@ -161,12 +161,6 @@ static ZigLLVM_CallingConv get_llvm_cc(CodeGen *g, CallingConvention cc) {
             return ZigLLVM_Fast;
         case CallingConventionC:
             return ZigLLVM_C;
-        case CallingConventionCold:
-            if ((g->zig_target->arch == ZigLLVM_x86 ||
-                 g->zig_target->arch == ZigLLVM_x86_64) &&
-                g->zig_target->os != OsWindows)
-                return ZigLLVM_Cold;
-            return ZigLLVM_C;
         case CallingConventionNaked:
             zig_unreachable();
         case CallingConventionStdcall:
 @@ -340,7 +334,6 @@ static bool cc_want_sret_attr(CallingConvention cc) {
         case CallingConventionNaked:
             zig_unreachable();
         case CallingConventionC:
-        case CallingConventionCold:
         case CallingConventionInterrupt:
         case CallingConventionSignal:
         case CallingConventionStdcall:
 @@ -449,7 +442,7 @@ static LLVMValueRef make_fn_llvm_value(CodeGen *g, ZigFn *fn) {
         ZigLLVMFunctionSetCallingConv(llvm_fn, get_llvm_cc(g, cc));
     }
-    bool want_cold = fn->is_cold || cc == CallingConventionCold;
+    bool want_cold = fn->is_cold;
     if (want_cold) {
         ZigLLVMAddFunctionAttrCold(llvm_fn);
     }
 @@ -8819,18 +8812,17 @@ Buf *codegen_generate_builtin_source(CodeGen *g) {
     static_assert(CallingConventionUnspecified == 0, "");
     static_assert(CallingConventionC == 1, "");
-    static_assert(CallingConventionCold == 2, "");
+    static_assert(CallingConventionNaked == 2, "");
-    static_assert(CallingConventionNaked == 3, "");
+    static_assert(CallingConventionAsync == 3, "");
-    static_assert(CallingConventionAsync == 4, "");
+    static_assert(CallingConventionInterrupt == 4, "");
-    static_assert(CallingConventionInterrupt == 5, "");
+    static_assert(CallingConventionSignal == 5, "");
-    static_assert(CallingConventionSignal == 6, "");
+    static_assert(CallingConventionStdcall == 6, "");
-    static_assert(CallingConventionStdcall == 7, "");
+    static_assert(CallingConventionFastcall == 7, "");
-    static_assert(CallingConventionFastcall == 8, "");
+    static_assert(CallingConventionVectorcall == 8, "");
-    static_assert(CallingConventionVectorcall == 9, "");
+    static_assert(CallingConventionThiscall == 9, "");
-    static_assert(CallingConventionThiscall == 10, "");
+    static_assert(CallingConventionAPCS == 10, "");
-    static_assert(CallingConventionAPCS == 11, "");
+    static_assert(CallingConventionAAPCS == 11, "");
-    static_assert(CallingConventionAAPCS == 12, "");
+    static_assert(CallingConventionAAPCSVFP == 12, "");
-    static_assert(CallingConventionAAPCSVFP == 13, "");
     static_assert(FnInlineAuto == 0, "");
     static_assert(FnInlineAlways == 1, "");

src/stage1/ir.cpp+45-7

 @@ -18917,7 +18917,6 @@ static IrInstGen *ir_analyze_instruction_export(IrAnalyze *ira, IrInstSrcExport
                     add_error_note(ira->codegen, msg, fn_entry->proto_node, buf_sprintf("declared here"));
                 } break;
                 case CallingConventionC:
-                case CallingConventionCold:
                 case CallingConventionNaked:
                 case CallingConventionInterrupt:
                 case CallingConventionSignal:
 @@ -18965,7 +18964,7 @@ static IrInstGen *ir_analyze_instruction_export(IrAnalyze *ira, IrInstSrcExport
             break;
         case ZigTypeIdArray: {
             bool ok_type;
-            if ((err = type_allowed_in_extern(ira->codegen, target->value->type->data.array.child_type, &ok_type)))
+            if ((err = type_allowed_in_extern(ira->codegen, target->value->type->data.array.child_type, ExternPositionOther, &ok_type)))
                 return ira->codegen->invalid_inst_gen;
             if (!ok_type) {
 @@ -20103,7 +20102,7 @@ static IrInstGen *ir_analyze_store_ptr(IrAnalyze *ira, IrInst* source_instr,
         if (uncasted_value->value->type->id == ZigTypeIdErrorUnion ||
             uncasted_value->value->type->id == ZigTypeIdErrorSet)
         {
-            ir_add_error(ira, source_instr, buf_sprintf("error is discarded"));
+            ir_add_error(ira, source_instr, buf_sprintf("error is discarded. consider using `try`, `catch`, or `if`"));
             return ira->codegen->invalid_inst_gen;
         }
         return ir_const_void(ira, source_instr);
 @@ -22388,6 +22387,8 @@ static IrInstGen *ir_analyze_container_member_access_inner(IrAnalyze *ira,
         prefix_name = "enum ";
     } else if (bare_struct_type->id == ZigTypeIdUnion) {
         prefix_name = "union ";
+    } else if (bare_struct_type->id == ZigTypeIdOpaque) {
+        prefix_name = "opaque type ";
     } else {
         prefix_name = "";
     }
 @@ -22588,7 +22589,7 @@ static IrInstGen *ir_analyze_container_field_ptr(IrAnalyze *ira, Buf *field_name
         }
     }
-    if (bare_type->id == ZigTypeIdEnum) {
+    if (bare_type->id == ZigTypeIdEnum || bare_type->id == ZigTypeIdOpaque) {
         return ir_analyze_container_member_access_inner(ira, bare_type, field_name,
             source_instr, container_ptr, container_ptr_src, container_type);
     }
 @@ -25184,7 +25185,6 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
         case ZigTypeIdEnumLiteral:
         case ZigTypeIdUndefined:
         case ZigTypeIdNull:
-        case ZigTypeIdOpaque:
             result = ira->codegen->intern.for_void();
             break;
         case ZigTypeIdInt:
 @@ -25738,6 +25738,25 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
                 if ((err = ir_make_type_info_value(ira, source_instr, fn_type, &result)))
                     return err;
+                break;
+            }
+        case ZigTypeIdOpaque:
+            {
+                result = ira->codegen->pass1_arena->create<ZigValue>();
+                result->special = ConstValSpecialStatic;
+                result->type = ir_type_info_get_type(ira, "Opaque", nullptr);
+                ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 1);
+                result->data.x_struct.fields = fields;
+                // decls: []TypeInfo.Declaration
+                ensure_field_index(result->type, "decls", 0);
+                if ((err = ir_make_type_info_decls(ira, source_instr, fields[0],
+                            type_entry->data.opaque.decls_scope, false)))
+                {
+                    return err;
+                }
                 break;
             }
         case ZigTypeIdFnFrame:
 @@ -26045,6 +26064,21 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInst *source_instr, ZigTypeI
             return get_error_union_type(ira->codegen, err_set_type, payload_type);
         }
         case ZigTypeIdOpaque: {
+            assert(payload->special == ConstValSpecialStatic);
+            assert(payload->type == ir_type_info_get_type(ira, "Opaque", nullptr));
+            ZigValue *decls_value = get_const_field(ira, source_instr->source_node, payload, "decls", 0);
+            if (decls_value == nullptr)
+                return ira->codegen->invalid_inst_gen->value->type;
+            assert(decls_value->special == ConstValSpecialStatic);
+            assert(is_slice(decls_value->type));
+            ZigValue *decls_len_value = decls_value->data.x_struct.fields[slice_len_index];
+            size_t decls_len = bigint_as_usize(&decls_len_value->data.x_bigint);
+            if (decls_len != 0) {
+                ir_add_error(ira, source_instr, buf_create_from_str("TypeInfo.Struct.decls must be empty for @Type"));
+                return ira->codegen->invalid_inst_gen->value->type;
+            }
             Buf *bare_name = buf_alloc();
             Buf *full_name = get_anon_type_name(ira->codegen,
                 ira->old_irb.exec, "opaque", source_instr->scope, source_instr->source_node, bare_name);
 @@ -29493,7 +29527,11 @@ static IrInstGen *ir_analyze_instruction_check_statement_is_void(IrAnalyze *ira,
         return ira->codegen->invalid_inst_gen;
     if (statement_type->id != ZigTypeIdVoid && statement_type->id != ZigTypeIdUnreachable) {
-        ir_add_error(ira, &instruction->base.base, buf_sprintf("expression value is ignored"));
+        if(statement_type->id == ZigTypeIdErrorUnion || statement_type->id == ZigTypeIdErrorSet) {
+            ir_add_error(ira, &instruction->base.base, buf_sprintf("error is ignored. consider using `try`, `catch`, or `if`"));
+        }else{
+            ir_add_error(ira, &instruction->base.base, buf_sprintf("expression value is ignored"));
+        }
     }
     return ir_const_void(ira, &instruction->base.base);
 @@ -32708,7 +32746,7 @@ static Error ir_resolve_lazy_raw(AstNode *source_node, ZigValue *val) {
                 return ErrorSemanticAnalyzeFail;
             } else if (lazy_ptr_type->ptr_len == PtrLenC) {
                 bool ok_type;
-                if ((err = type_allowed_in_extern(ira->codegen, elem_type, &ok_type)))
+                if ((err = type_allowed_in_extern(ira->codegen, elem_type, ExternPositionOther, &ok_type)))
                     return err;
                 if (!ok_type) {
                     ir_add_error(ira, &lazy_ptr_type->elem_type->base,

src/stage1/parser.cpp+9

 @@ -2920,6 +2920,7 @@ static AstNode *ast_parse_container_decl_auto(ParseContext *pc) {
 //     <- KEYWORD_struct
 //      / KEYWORD_enum (LPAREN Expr RPAREN)?
 //      / KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)?
+//      / KEYWORD_opaque
 static AstNode *ast_parse_container_decl_type(ParseContext *pc) {
     Token *first = eat_token_if(pc, TokenIdKeywordStruct);
     if (first != nullptr) {
 @@ -2929,6 +2930,14 @@ static AstNode *ast_parse_container_decl_type(ParseContext *pc) {
         return res;
     }
+    first = eat_token_if(pc, TokenIdKeywordOpaque);
+    if (first != nullptr) {
+        AstNode *res = ast_create_node(pc, NodeTypeContainerDecl, first);
+        res->data.container_decl.init_arg_expr = nullptr;
+        res->data.container_decl.kind = ContainerKindOpaque;
+        return res;
+    }
     first = eat_token_if(pc, TokenIdKeywordEnum);
     if (first != nullptr) {
         AstNode *init_arg_expr = nullptr;

src/stage1/tokenizer.cpp+2

src/stage1/tokenizer.hpp+1

...	@@ -81,6 +81,7 @@ enum TokenId {	...	@@ -81,6 +81,7 @@ enum TokenId {
81	TokenIdKeywordNoAlias,	81	TokenIdKeywordNoAlias,
82	TokenIdKeywordNoSuspend,	82	TokenIdKeywordNoSuspend,
83	TokenIdKeywordNull,	83	TokenIdKeywordNull,
		84	TokenIdKeywordOpaque,
84	TokenIdKeywordOr,	85	TokenIdKeywordOr,
85	TokenIdKeywordOrElse,	86	TokenIdKeywordOrElse,
86	TokenIdKeywordPacked,	87	TokenIdKeywordPacked,

src/translate_c.zig+682-682

 @@ -5,7 +5,7 @@ const std = @import("std");
 const assert = std.debug.assert;
 const ast = std.zig.ast;
 const Token = std.zig.Token;
-usingnamespace @import("clang.zig");
+const clang = @import("clang.zig");
 const ctok = std.c.tokenizer;
 const CToken = std.c.Token;
 const mem = std.mem;
 @@ -13,7 +13,7 @@ const math = std.math;
 const CallingConvention = std.builtin.CallingConvention;
-pub const ClangErrMsg = Stage2ErrorMsg;
+pub const ClangErrMsg = clang.Stage2ErrorMsg;
 pub const Error = error{OutOfMemory};
 const TypeError = Error || error{UnsupportedType};
 @@ -259,11 +259,11 @@ pub const Context = struct {
     errors: std.ArrayListUnmanaged(ast.Error),
     source_buffer: *std.ArrayList(u8),
     err: Error,
-    source_manager: *ZigClangSourceManager,
+    source_manager: *clang.SourceManager,
     decl_table: DeclTable,
     alias_list: AliasList,
     global_scope: *Scope.Root,
-    clang_context: *ZigClangASTContext,
+    clang_context: *clang.ASTContext,
     mangle_count: u32 = 0,
     root_decls: std.ArrayListUnmanaged(*ast.Node),
 @@ -284,13 +284,13 @@ pub const Context = struct {
     }
     /// Convert a clang source location to a file:line:column string
-    fn locStr(c: *Context, loc: ZigClangSourceLocation) ![]u8 {
+    fn locStr(c: *Context, loc: clang.SourceLocation) ![]u8 {
-        const spelling_loc = ZigClangSourceManager_getSpellingLoc(c.source_manager, loc);
+        const spelling_loc = c.source_manager.getSpellingLoc(loc);
-        const filename_c = ZigClangSourceManager_getFilename(c.source_manager, spelling_loc);
+        const filename_c = c.source_manager.getFilename(spelling_loc);
         const filename = if (filename_c) |s| try c.str(s) else @as([]const u8, "(no file)");
-        const line = ZigClangSourceManager_getSpellingLineNumber(c.source_manager, spelling_loc);
+        const line = c.source_manager.getSpellingLineNumber(spelling_loc);
-        const column = ZigClangSourceManager_getSpellingColumnNumber(c.source_manager, spelling_loc);
+        const column = c.source_manager.getSpellingColumnNumber(spelling_loc);
         return std.fmt.allocPrint(c.arena, "{}:{}:{}", .{ filename, line, column });
     }
 @@ -336,7 +336,7 @@ pub fn translate(
     errors: *[]ClangErrMsg,
     resources_path: [*:0]const u8,
 ) !*ast.Tree {
-    const ast_unit = ZigClangLoadFromCommandLine(
+    const ast_unit = clang.LoadFromCommandLine(
         args_begin,
         args_end,
         &errors.ptr,
 @@ -346,7 +346,7 @@ pub fn translate(
         if (errors.len == 0) return error.ASTUnitFailure;
         return error.SemanticAnalyzeFail;
     };
-    defer ZigClangASTUnit_delete(ast_unit);
+    defer ast_unit.delete();
     var source_buffer = std.ArrayList(u8).init(gpa);
     defer source_buffer.deinit();
 @@ -360,12 +360,12 @@ pub fn translate(
         .gpa = gpa,
         .arena = &arena.allocator,
         .source_buffer = &source_buffer,
-        .source_manager = ZigClangASTUnit_getSourceManager(ast_unit),
+        .source_manager = ast_unit.getSourceManager(),
         .err = undefined,
         .decl_table = DeclTable.init(gpa),
         .alias_list = AliasList.init(gpa),
         .global_scope = try arena.allocator.create(Scope.Root),
-        .clang_context = ZigClangASTUnit_getASTContext(ast_unit).?,
+        .clang_context = ast_unit.getASTContext(),
         .global_names = std.StringArrayHashMap(void).init(gpa),
         .token_ids = .{},
         .token_locs = .{},
 @@ -383,7 +383,7 @@ pub fn translate(
     try prepopulateGlobalNameTable(ast_unit, &context);
-    if (!ZigClangASTUnit_visitLocalTopLevelDecls(ast_unit, &context, declVisitorC)) {
+    if (!ast_unit.visitLocalTopLevelDecls(&context, declVisitorC)) {
         return context.err;
     }
 @@ -421,21 +421,21 @@ pub fn translate(
     return tree;
 }
-fn prepopulateGlobalNameTable(ast_unit: *ZigClangASTUnit, c: *Context) !void {
+fn prepopulateGlobalNameTable(ast_unit: *clang.ASTUnit, c: *Context) !void {
-    if (!ZigClangASTUnit_visitLocalTopLevelDecls(ast_unit, c, declVisitorNamesOnlyC)) {
+    if (!ast_unit.visitLocalTopLevelDecls(c, declVisitorNamesOnlyC)) {
         return c.err;
     }
     // TODO if we see #undef, delete it from the table
-    var it = ZigClangASTUnit_getLocalPreprocessingEntities_begin(ast_unit);
+    var it = ast_unit.getLocalPreprocessingEntities_begin();
-    const it_end = ZigClangASTUnit_getLocalPreprocessingEntities_end(ast_unit);
+    const it_end = ast_unit.getLocalPreprocessingEntities_end();
     while (it.I != it_end.I) : (it.I += 1) {
-        const entity = ZigClangPreprocessingRecord_iterator_deref(it);
+        const entity = it.deref();
-        switch (ZigClangPreprocessedEntity_getKind(entity)) {
+        switch (entity.getKind()) {
             .MacroDefinitionKind => {
-                const macro = @ptrCast(*ZigClangMacroDefinitionRecord, entity);
+                const macro = @ptrCast(*clang.MacroDefinitionRecord, entity);
-                const raw_name = ZigClangMacroDefinitionRecord_getName_getNameStart(macro);
+                const raw_name = macro.getName_getNameStart();
                 const name = try c.str(raw_name);
                 _ = try c.global_names.put(name, {});
             },
 @@ -444,7 +444,7 @@ fn prepopulateGlobalNameTable(ast_unit: *ZigClangASTUnit, c: *Context) !void {
     }
 }
-fn declVisitorNamesOnlyC(context: ?*c_void, decl: *const ZigClangDecl) callconv(.C) bool {
+fn declVisitorNamesOnlyC(context: ?*c_void, decl: *const clang.Decl) callconv(.C) bool {
     const c = @ptrCast(*Context, @alignCast(@alignOf(Context), context));
     declVisitorNamesOnly(c, decl) catch |err| {
         c.err = err;
 @@ -453,7 +453,7 @@ fn declVisitorNamesOnlyC(context: ?*c_void, decl: *const ZigClangDecl) callconv(
     return true;
 }
-fn declVisitorC(context: ?*c_void, decl: *const ZigClangDecl) callconv(.C) bool {
+fn declVisitorC(context: ?*c_void, decl: *const clang.Decl) callconv(.C) bool {
     const c = @ptrCast(*Context, @alignCast(@alignOf(Context), context));
     declVisitor(c, decl) catch |err| {
         c.err = err;
 @@ -462,61 +462,61 @@ fn declVisitorC(context: ?*c_void, decl: *const ZigClangDecl) callconv(.C) bool
     return true;
 }
-fn declVisitorNamesOnly(c: *Context, decl: *const ZigClangDecl) Error!void {
+fn declVisitorNamesOnly(c: *Context, decl: *const clang.Decl) Error!void {
-    if (ZigClangDecl_castToNamedDecl(decl)) |named_decl| {
+    if (decl.castToNamedDecl()) |named_decl| {
-        const decl_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(named_decl));
+        const decl_name = try c.str(named_decl.getName_bytes_begin());
         _ = try c.global_names.put(decl_name, {});
     }
 }
-fn declVisitor(c: *Context, decl: *const ZigClangDecl) Error!void {
+fn declVisitor(c: *Context, decl: *const clang.Decl) Error!void {
-    switch (ZigClangDecl_getKind(decl)) {
+    switch (decl.getKind()) {
         .Function => {
-            return visitFnDecl(c, @ptrCast(*const ZigClangFunctionDecl, decl));
+            return visitFnDecl(c, @ptrCast(*const clang.FunctionDecl, decl));
         },
         .Typedef => {
-            _ = try transTypeDef(c, @ptrCast(*const ZigClangTypedefNameDecl, decl), true);
+            _ = try transTypeDef(c, @ptrCast(*const clang.TypedefNameDecl, decl), true);
         },
         .Enum => {
-            _ = try transEnumDecl(c, @ptrCast(*const ZigClangEnumDecl, decl));
+            _ = try transEnumDecl(c, @ptrCast(*const clang.EnumDecl, decl));
         },
         .Record => {
-            _ = try transRecordDecl(c, @ptrCast(*const ZigClangRecordDecl, decl));
+            _ = try transRecordDecl(c, @ptrCast(*const clang.RecordDecl, decl));
         },
         .Var => {
-            return visitVarDecl(c, @ptrCast(*const ZigClangVarDecl, decl), null);
+            return visitVarDecl(c, @ptrCast(*const clang.VarDecl, decl), null);
         },
         .Empty => {
             // Do nothing
         },
         else => {
-            const decl_name = try c.str(ZigClangDecl_getDeclKindName(decl));
+            const decl_name = try c.str(decl.getDeclKindName());
-            try emitWarning(c, ZigClangDecl_getLocation(decl), "ignoring {} declaration", .{decl_name});
+            try emitWarning(c, decl.getLocation(), "ignoring {} declaration", .{decl_name});
         },
     }
 }
-fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
+fn visitFnDecl(c: *Context, fn_decl: *const clang.FunctionDecl) Error!void {
-    const fn_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, fn_decl)));
+    const fn_name = try c.str(@ptrCast(*const clang.NamedDecl, fn_decl).getName_bytes_begin());
     if (c.global_scope.sym_table.contains(fn_name))
         return; // Avoid processing this decl twice
     // Skip this declaration if a proper definition exists
-    if (!ZigClangFunctionDecl_isThisDeclarationADefinition(fn_decl)) {
+    if (!fn_decl.isThisDeclarationADefinition()) {
-        if (ZigClangFunctionDecl_getDefinition(fn_decl)) |def|
+        if (fn_decl.getDefinition()) |def|
             return visitFnDecl(c, def);
     }
     const rp = makeRestorePoint(c);
-    const fn_decl_loc = ZigClangFunctionDecl_getLocation(fn_decl);
+    const fn_decl_loc = fn_decl.getLocation();
-    const has_body = ZigClangFunctionDecl_hasBody(fn_decl);
+    const has_body = fn_decl.hasBody();
-    const storage_class = ZigClangFunctionDecl_getStorageClass(fn_decl);
+    const storage_class = fn_decl.getStorageClass();
     const decl_ctx = FnDeclContext{
         .fn_name = fn_name,
         .has_body = has_body,
         .storage_class = storage_class,
         .is_export = switch (storage_class) {
-            .None => has_body and !ZigClangFunctionDecl_isInlineSpecified(fn_decl),
+            .None => has_body and !fn_decl.isInlineSpecified(),
             .Extern, .Static => false,
             .PrivateExtern => return failDecl(c, fn_decl_loc, fn_name, "unsupported storage class: private extern", .{}),
             .Auto => unreachable, // Not legal on functions
 @@ -524,27 +524,27 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
         },
     };
-    var fn_qt = ZigClangFunctionDecl_getType(fn_decl);
+    var fn_qt = fn_decl.getType();
     const fn_type = while (true) {
-        const fn_type = ZigClangQualType_getTypePtr(fn_qt);
+        const fn_type = fn_qt.getTypePtr();
-        switch (ZigClangType_getTypeClass(fn_type)) {
+        switch (fn_type.getTypeClass()) {
             .Attributed => {
-                const attr_type = @ptrCast(*const ZigClangAttributedType, fn_type);
+                const attr_type = @ptrCast(*const clang.AttributedType, fn_type);
-                fn_qt = ZigClangAttributedType_getEquivalentType(attr_type);
+                fn_qt = attr_type.getEquivalentType();
             },
             .Paren => {
-                const paren_type = @ptrCast(*const ZigClangParenType, fn_type);
+                const paren_type = @ptrCast(*const clang.ParenType, fn_type);
-                fn_qt = ZigClangParenType_getInnerType(paren_type);
+                fn_qt = paren_type.getInnerType();
             },
             else => break fn_type,
         }
     } else unreachable;
-    const proto_node = switch (ZigClangType_getTypeClass(fn_type)) {
+    const proto_node = switch (fn_type.getTypeClass()) {
         .FunctionProto => blk: {
-            const fn_proto_type = @ptrCast(*const ZigClangFunctionProtoType, fn_type);
+            const fn_proto_type = @ptrCast(*const clang.FunctionProtoType, fn_type);
             break :blk transFnProto(rp, fn_decl, fn_proto_type, fn_decl_loc, decl_ctx, true) catch |err| switch (err) {
                 error.UnsupportedType => {
                     return failDecl(c, fn_decl_loc, fn_name, "unable to resolve prototype of function", .{});
 @@ -553,7 +553,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
             };
         },
         .FunctionNoProto => blk: {
-            const fn_no_proto_type = @ptrCast(*const ZigClangFunctionType, fn_type);
+            const fn_no_proto_type = @ptrCast(*const clang.FunctionType, fn_type);
             break :blk transFnNoProto(rp, fn_no_proto_type, fn_decl_loc, decl_ctx, true) catch |err| switch (err) {
                 error.UnsupportedType => {
                     return failDecl(c, fn_decl_loc, fn_name, "unable to resolve prototype of function", .{});
 @@ -561,7 +561,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
                 error.OutOfMemory => |e| return e,
             };
         },
-        else => return failDecl(c, fn_decl_loc, fn_name, "unable to resolve function type {}", .{ZigClangType_getTypeClass(fn_type)}),
+        else => return failDecl(c, fn_decl_loc, fn_name, "unable to resolve function type {}", .{fn_type.getTypeClass()}),
     };
     if (!decl_ctx.has_body) {
 @@ -570,7 +570,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
     }
     // actual function definition with body
-    const body_stmt = ZigClangFunctionDecl_getBody(fn_decl);
+    const body_stmt = fn_decl.getBody();
     var block_scope = try Scope.Block.init(rp.c, &c.global_scope.base, false);
     defer block_scope.deinit();
     var scope = &block_scope.base;
 @@ -582,9 +582,9 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
         else
             return failDecl(c, fn_decl_loc, fn_name, "function {} parameter has no name", .{fn_name});
-        const c_param = ZigClangFunctionDecl_getParamDecl(fn_decl, param_id);
+        const c_param = fn_decl.getParamDecl(param_id);
-        const qual_type = ZigClangParmVarDecl_getOriginalType(c_param);
+        const qual_type = c_param.getOriginalType();
-        const is_const = ZigClangQualType_isConstQualified(qual_type);
+        const is_const = qual_type.isConstQualified();
         const mangled_param_name = try block_scope.makeMangledName(c, param_name);
 @@ -613,7 +613,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
         param_id += 1;
     }
-    const casted_body = @ptrCast(*const ZigClangCompoundStmt, body_stmt);
+    const casted_body = @ptrCast(*const clang.CompoundStmt, body_stmt);
     transCompoundStmtInline(rp, &block_scope.base, casted_body, &block_scope) catch |err| switch (err) {
         error.OutOfMemory => |e| return e,
         error.UnsupportedTranslation,
 @@ -622,10 +622,10 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
     };
     // add return statement if the function didn't have one
     blk: {
-        const fn_ty = @ptrCast(*const ZigClangFunctionType, fn_type);
+        const fn_ty = @ptrCast(*const clang.FunctionType, fn_type);
-        if (ZigClangFunctionType_getNoReturnAttr(fn_ty)) break :blk;
+        if (fn_ty.getNoReturnAttr()) break :blk;
-        const return_qt = ZigClangFunctionType_getReturnType(fn_ty);
+        const return_qt = fn_ty.getReturnType();
         if (isCVoid(return_qt)) break :blk;
         if (block_scope.statements.items.len > 0) {
 @@ -649,7 +649,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
             .ltoken = try appendToken(rp.c, .Keyword_return, "return"),
             .tag = .Return,
         }, .{
-            .rhs = transZeroInitExpr(rp, scope, fn_decl_loc, ZigClangQualType_getTypePtr(return_qt)) catch |err| switch (err) {
+            .rhs = transZeroInitExpr(rp, scope, fn_decl_loc, return_qt.getTypePtr()) catch |err| switch (err) {
                 error.OutOfMemory => |e| return e,
                 error.UnsupportedTranslation,
                 error.UnsupportedType,
 @@ -666,14 +666,14 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
 }
 /// if mangled_name is not null, this var decl was declared in a block scope.
-fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[]const u8) Error!void {
+fn visitVarDecl(c: *Context, var_decl: *const clang.VarDecl, mangled_name: ?[]const u8) Error!void {
-    const var_name = mangled_name orelse try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, var_decl)));
+    const var_name = mangled_name orelse try c.str(@ptrCast(*const clang.NamedDecl, var_decl).getName_bytes_begin());
     if (c.global_scope.sym_table.contains(var_name))
         return; // Avoid processing this decl twice
     const rp = makeRestorePoint(c);
     const visib_tok = if (mangled_name) |_| null else try appendToken(c, .Keyword_pub, "pub");
-    const thread_local_token = if (ZigClangVarDecl_getTLSKind(var_decl) == .None)
+    const thread_local_token = if (var_decl.getTLSKind() == .None)
         null
     else
         try appendToken(c, .Keyword_threadlocal, "threadlocal");
 @@ -683,12 +683,12 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[]
     // TODO https://github.com/ziglang/zig/issues/3756
     // TODO https://github.com/ziglang/zig/issues/1802
     const checked_name = if (isZigPrimitiveType(var_name)) try std.fmt.allocPrint(c.arena, "{}_{}", .{ var_name, c.getMangle() }) else var_name;
-    const var_decl_loc = ZigClangVarDecl_getLocation(var_decl);
+    const var_decl_loc = var_decl.getLocation();
-    const qual_type = ZigClangVarDecl_getTypeSourceInfo_getType(var_decl);
+    const qual_type = var_decl.getTypeSourceInfo_getType();
-    const storage_class = ZigClangVarDecl_getStorageClass(var_decl);
+    const storage_class = var_decl.getStorageClass();
-    const is_const = ZigClangQualType_isConstQualified(qual_type);
+    const is_const = qual_type.isConstQualified();
-    const has_init = ZigClangVarDecl_hasInit(var_decl);
+    const has_init = var_decl.hasInit();
     // In C extern variables with initializers behave like Zig exports.
     // extern int foo = 2;
 @@ -725,7 +725,7 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[]
     // with the variable type.
     if (has_init) {
         eq_tok = try appendToken(c, .Equal, "=");
-        init_node = if (ZigClangVarDecl_getInit(var_decl)) |expr|
+        init_node = if (var_decl.getInit()) |expr|
             transExprCoercing(rp, &c.global_scope.base, expr, .used, .r_value) catch |err| switch (err) {
                 error.UnsupportedTranslation,
                 error.UnsupportedType,
 @@ -758,7 +758,7 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[]
     const linksection_expr = blk: {
         var str_len: usize = undefined;
-        if (ZigClangVarDecl_getSectionAttribute(var_decl, &str_len)) |str_ptr| {
+        if (var_decl.getSectionAttribute(&str_len)) |str_ptr| {
             _ = try appendToken(rp.c, .Keyword_linksection, "linksection");
             _ = try appendToken(rp.c, .LParen, "(");
             const expr = try transCreateNodeStringLiteral(
 @@ -773,7 +773,7 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[]
     };
     const align_expr = blk: {
-        const alignment = ZigClangVarDecl_getAlignedAttribute(var_decl, rp.c.clang_context);
+        const alignment = var_decl.getAlignedAttribute(rp.c.clang_context);
         if (alignment != 0) {
             _ = try appendToken(rp.c, .Keyword_align, "align");
             _ = try appendToken(rp.c, .LParen, "(");
 @@ -803,8 +803,8 @@ fn visitVarDecl(c: *Context, var_decl: *const ZigClangVarDecl, mangled_name: ?[]
     return addTopLevelDecl(c, checked_name, &node.base);
 }
-fn transTypeDefAsBuiltin(c: *Context, typedef_decl: *const ZigClangTypedefNameDecl, builtin_name: []const u8) !*ast.Node {
+fn transTypeDefAsBuiltin(c: *Context, typedef_decl: *const clang.TypedefNameDecl, builtin_name: []const u8) !*ast.Node {
-    _ = try c.decl_table.put(@ptrToInt(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)), builtin_name);
+    _ = try c.decl_table.put(@ptrToInt(typedef_decl.getCanonicalDecl()), builtin_name);
     return transCreateNodeIdentifier(c, builtin_name);
 }
 @@ -833,12 +833,12 @@ fn checkForBuiltinTypedef(checked_name: []const u8) ?[]const u8 {
     return null;
 }
-fn transTypeDef(c: *Context, typedef_decl: *const ZigClangTypedefNameDecl, top_level_visit: bool) Error!?*ast.Node {
+fn transTypeDef(c: *Context, typedef_decl: *const clang.TypedefNameDecl, top_level_visit: bool) Error!?*ast.Node {
-    if (c.decl_table.get(@ptrToInt(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)))) |name|
+    if (c.decl_table.get(@ptrToInt(typedef_decl.getCanonicalDecl()))) |name|
         return transCreateNodeIdentifier(c, name); // Avoid processing this decl twice
     const rp = makeRestorePoint(c);
-    const typedef_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, typedef_decl)));
+    const typedef_name = try c.str(@ptrCast(*const clang.NamedDecl, typedef_decl).getName_bytes_begin());
     // TODO https://github.com/ziglang/zig/issues/3756
     // TODO https://github.com/ziglang/zig/issues/1802
 @@ -851,7 +851,7 @@ fn transTypeDef(c: *Context, typedef_decl: *const ZigClangTypedefNameDecl, top_l
         return transCreateNodeIdentifier(c, checked_name);
     }
-    _ = try c.decl_table.put(@ptrToInt(ZigClangTypedefNameDecl_getCanonicalDecl(typedef_decl)), checked_name);
+    _ = try c.decl_table.put(@ptrToInt(typedef_decl.getCanonicalDecl()), checked_name);
     const node = (try transCreateNodeTypedef(rp, typedef_decl, true, checked_name)) orelse return null;
     try addTopLevelDecl(c, checked_name, node);
     return transCreateNodeIdentifier(c, checked_name);
 @@ -859,7 +859,7 @@ fn transTypeDef(c: *Context, typedef_decl: *const ZigClangTypedefNameDecl, top_l
 fn transCreateNodeTypedef(
     rp: RestorePoint,
-    typedef_decl: *const ZigClangTypedefNameDecl,
+    typedef_decl: *const clang.TypedefNameDecl,
     toplevel: bool,
     checked_name: []const u8,
 ) Error!?*ast.Node {
 @@ -867,8 +867,8 @@ fn transCreateNodeTypedef(
     const mut_tok = try appendToken(rp.c, .Keyword_const, "const");
     const name_tok = try appendIdentifier(rp.c, checked_name);
     const eq_token = try appendToken(rp.c, .Equal, "=");
-    const child_qt = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl);
+    const child_qt = typedef_decl.getUnderlyingType();
-    const typedef_loc = ZigClangTypedefNameDecl_getLocation(typedef_decl);
+    const typedef_loc = typedef_decl.getLocation();
     const init_node = transQualType(rp, child_qt, typedef_loc) catch |err| switch (err) {
         error.UnsupportedType => {
             try failDecl(rp.c, typedef_loc, checked_name, "unable to resolve typedef child type", .{});
 @@ -890,12 +890,12 @@ fn transCreateNodeTypedef(
     return &node.base;
 }
-fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*ast.Node {
+fn transRecordDecl(c: *Context, record_decl: *const clang.RecordDecl) Error!?*ast.Node {
-    if (c.decl_table.get(@ptrToInt(ZigClangRecordDecl_getCanonicalDecl(record_decl)))) |name|
+    if (c.decl_table.get(@ptrToInt(record_decl.getCanonicalDecl()))) |name|
         return try transCreateNodeIdentifier(c, name); // Avoid processing this decl twice
-    const record_loc = ZigClangRecordDecl_getLocation(record_decl);
+    const record_loc = record_decl.getLocation();
-    var bare_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, record_decl)));
+    var bare_name = try c.str(@ptrCast(*const clang.NamedDecl, record_decl).getName_bytes_begin());
     var is_unnamed = false;
     // Record declarations such as `struct {...} x` have no name but they're not
     // anonymous hence here isAnonymousStructOrUnion is not needed
 @@ -906,10 +906,10 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
     var container_kind_name: []const u8 = undefined;
     var container_kind: std.zig.Token.Id = undefined;
-    if (ZigClangRecordDecl_isUnion(record_decl)) {
+    if (record_decl.isUnion()) {
         container_kind_name = "union";
         container_kind = .Keyword_union;
-    } else if (ZigClangRecordDecl_isStruct(record_decl)) {
+    } else if (record_decl.isStruct()) {
         container_kind_name = "struct";
         container_kind = .Keyword_struct;
     } else {
 @@ -918,7 +918,7 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
     }
     const name = try std.fmt.allocPrint(c.arena, "{}_{}", .{ container_kind_name, bare_name });
-    _ = try c.decl_table.put(@ptrToInt(ZigClangRecordDecl_getCanonicalDecl(record_decl)), name);
+    _ = try c.decl_table.put(@ptrToInt(record_decl.getCanonicalDecl()), name);
     const visib_tok = if (!is_unnamed) try appendToken(c, .Keyword_pub, "pub") else null;
     const mut_tok = try appendToken(c, .Keyword_const, "const");
 @@ -929,13 +929,13 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
     var semicolon: ast.TokenIndex = undefined;
     const init_node = blk: {
         const rp = makeRestorePoint(c);
-        const record_def = ZigClangRecordDecl_getDefinition(record_decl) orelse {
+        const record_def = record_decl.getDefinition() orelse {
-            const opaque = try transCreateNodeOpaqueType(c);
+            const opaque_type = try transCreateNodeOpaqueType(c);
             semicolon = try appendToken(c, .Semicolon, ";");
-            break :blk opaque;
+            break :blk opaque_type;
         };
-        const layout_tok = try if (ZigClangRecordDecl_getPackedAttribute(record_decl))
+        const layout_tok = try if (record_decl.getPackedAttribute())
             appendToken(c, .Keyword_packed, "packed")
         else
             appendToken(c, .Keyword_extern, "extern");
 @@ -946,30 +946,30 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
         defer fields_and_decls.deinit();
         var unnamed_field_count: u32 = 0;
-        var it = ZigClangRecordDecl_field_begin(record_def);
+        var it = record_def.field_begin();
-        const end_it = ZigClangRecordDecl_field_end(record_def);
+        const end_it = record_def.field_end();
-        while (ZigClangRecordDecl_field_iterator_neq(it, end_it)) : (it = ZigClangRecordDecl_field_iterator_next(it)) {
+        while (it.neq(end_it)) : (it = it.next()) {
-            const field_decl = ZigClangRecordDecl_field_iterator_deref(it);
+            const field_decl = it.deref();
-            const field_loc = ZigClangFieldDecl_getLocation(field_decl);
+            const field_loc = field_decl.getLocation();
-            const field_qt = ZigClangFieldDecl_getType(field_decl);
+            const field_qt = field_decl.getType();
-            if (ZigClangFieldDecl_isBitField(field_decl)) {
+            if (field_decl.isBitField()) {
-                const opaque = try transCreateNodeOpaqueType(c);
+                const opaque_type = try transCreateNodeOpaqueType(c);
                 semicolon = try appendToken(c, .Semicolon, ";");
                 try emitWarning(c, field_loc, "{} demoted to opaque type - has bitfield", .{container_kind_name});
-                break :blk opaque;
+                break :blk opaque_type;
             }
-            if (ZigClangType_isIncompleteOrZeroLengthArrayType(qualTypeCanon(field_qt), c.clang_context)) {
+            if (qualTypeCanon(field_qt).isIncompleteOrZeroLengthArrayType(c.clang_context)) {
-                const opaque = try transCreateNodeOpaqueType(c);
+                const opaque_type = try transCreateNodeOpaqueType(c);
                 semicolon = try appendToken(c, .Semicolon, ";");
                 try emitWarning(c, field_loc, "{} demoted to opaque type - has variable length array", .{container_kind_name});
-                break :blk opaque;
+                break :blk opaque_type;
             }
             var is_anon = false;
-            var raw_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, field_decl)));
+            var raw_name = try c.str(@ptrCast(*const clang.NamedDecl, field_decl).getName_bytes_begin());
-            if (ZigClangFieldDecl_isAnonymousStructOrUnion(field_decl) or raw_name.len == 0) {
+            if (field_decl.isAnonymousStructOrUnion() or raw_name.len == 0) {
                 // Context.getMangle() is not used here because doing so causes unpredictable field names for anonymous fields.
                 raw_name = try std.fmt.allocPrint(c.arena, "unnamed_{}", .{unnamed_field_count});
                 unnamed_field_count += 1;
 @@ -979,16 +979,16 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
             _ = try appendToken(c, .Colon, ":");
             const field_type = transQualType(rp, field_qt, field_loc) catch |err| switch (err) {
                 error.UnsupportedType => {
-                    const opaque = try transCreateNodeOpaqueType(c);
+                    const opaque_type = try transCreateNodeOpaqueType(c);
                     semicolon = try appendToken(c, .Semicolon, ";");
                     try emitWarning(c, record_loc, "{} demoted to opaque type - unable to translate type of field {}", .{ container_kind_name, raw_name });
-                    break :blk opaque;
+                    break :blk opaque_type;
                 },
                 else => |e| return e,
             };
             const align_expr = blk_2: {
-                const alignment = ZigClangFieldDecl_getAlignedAttribute(field_decl, rp.c.clang_context);
+                const alignment = field_decl.getAlignedAttribute(rp.c.clang_context);
                 if (alignment != 0) {
                     _ = try appendToken(rp.c, .Keyword_align, "align");
                     _ = try appendToken(rp.c, .LParen, "(");
 @@ -1013,7 +1013,7 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
             if (is_anon) {
                 _ = try c.decl_table.put(
-                    @ptrToInt(ZigClangFieldDecl_getCanonicalDecl(field_decl)),
+                    @ptrToInt(field_decl.getCanonicalDecl()),
                     raw_name,
                 );
             }
 @@ -1051,13 +1051,13 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
     return transCreateNodeIdentifier(c, name);
 }
-fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.Node {
+fn transEnumDecl(c: *Context, enum_decl: *const clang.EnumDecl) Error!?*ast.Node {
-    if (c.decl_table.get(@ptrToInt(ZigClangEnumDecl_getCanonicalDecl(enum_decl)))) |name|
+    if (c.decl_table.get(@ptrToInt(enum_decl.getCanonicalDecl()))) |name|
         return try transCreateNodeIdentifier(c, name); // Avoid processing this decl twice
     const rp = makeRestorePoint(c);
-    const enum_loc = ZigClangEnumDecl_getLocation(enum_decl);
+    const enum_loc = enum_decl.getLocation();
-    var bare_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, enum_decl)));
+    var bare_name = try c.str(@ptrCast(*const clang.NamedDecl, enum_decl).getName_bytes_begin());
     var is_unnamed = false;
     if (bare_name.len == 0) {
         bare_name = try std.fmt.allocPrint(c.arena, "unnamed_{}", .{c.getMangle()});
 @@ -1065,20 +1065,20 @@ fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.No
     }
     const name = try std.fmt.allocPrint(c.arena, "enum_{}", .{bare_name});
-    _ = try c.decl_table.put(@ptrToInt(ZigClangEnumDecl_getCanonicalDecl(enum_decl)), name);
+    _ = try c.decl_table.put(@ptrToInt(enum_decl.getCanonicalDecl()), name);
     const visib_tok = if (!is_unnamed) try appendToken(c, .Keyword_pub, "pub") else null;
     const mut_tok = try appendToken(c, .Keyword_const, "const");
     const name_tok = try appendIdentifier(c, name);
     const eq_token = try appendToken(c, .Equal, "=");
-    const init_node = if (ZigClangEnumDecl_getDefinition(enum_decl)) |enum_def| blk: {
+    const init_node = if (enum_decl.getDefinition()) |enum_def| blk: {
         var pure_enum = true;
-        var it = ZigClangEnumDecl_enumerator_begin(enum_def);
+        var it = enum_def.enumerator_begin();
-        var end_it = ZigClangEnumDecl_enumerator_end(enum_def);
+        var end_it = enum_def.enumerator_end();
-        while (ZigClangEnumDecl_enumerator_iterator_neq(it, end_it)) : (it = ZigClangEnumDecl_enumerator_iterator_next(it)) {
+        while (it.neq(end_it)) : (it = it.next()) {
-            const enum_const = ZigClangEnumDecl_enumerator_iterator_deref(it);
+            const enum_const = it.deref();
-            if (ZigClangEnumConstantDecl_getInitExpr(enum_const)) |_| {
+            if (enum_const.getInitExpr()) |_| {
                 pure_enum = false;
                 break;
             }
 @@ -1090,7 +1090,7 @@ fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.No
         var fields_and_decls = std.ArrayList(*ast.Node).init(c.gpa);
         defer fields_and_decls.deinit();
-        const int_type = ZigClangEnumDecl_getIntegerType(enum_decl);
+        const int_type = enum_decl.getIntegerType();
         // The underlying type may be null in case of forward-declared enum
         // types, while that's not ISO-C compliant many compilers allow this and
         // default to the usual integer type used for all the enums.
 @@ -1115,12 +1115,12 @@ fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.No
         const lbrace_token = try appendToken(c, .LBrace, "{");
-        it = ZigClangEnumDecl_enumerator_begin(enum_def);
+        it = enum_def.enumerator_begin();
-        end_it = ZigClangEnumDecl_enumerator_end(enum_def);
+        end_it = enum_def.enumerator_end();
-        while (ZigClangEnumDecl_enumerator_iterator_neq(it, end_it)) : (it = ZigClangEnumDecl_enumerator_iterator_next(it)) {
+        while (it.neq(end_it)) : (it = it.next()) {
-            const enum_const = ZigClangEnumDecl_enumerator_iterator_deref(it);
+            const enum_const = it.deref();
-            const enum_val_name = try c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, enum_const)));
+            const enum_val_name = try c.str(@ptrCast(*const clang.NamedDecl, enum_const).getName_bytes_begin());
             const field_name = if (!is_unnamed and mem.startsWith(u8, enum_val_name, bare_name))
                 enum_val_name[bare_name.len..]
 @@ -1131,7 +1131,7 @@ fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.No
             const int_node = if (!pure_enum) blk_2: {
                 _ = try appendToken(c, .Colon, "=");
-                break :blk_2 try transCreateNodeAPInt(c, ZigClangEnumConstantDecl_getInitVal(enum_const));
+                break :blk_2 try transCreateNodeAPInt(c, enum_const.getInitVal());
             } else
                 null;
 @@ -1257,23 +1257,23 @@ const LRValue = enum {
 fn transStmt(
     rp: RestorePoint,
     scope: *Scope,
-    stmt: *const ZigClangStmt,
+    stmt: *const clang.Stmt,
     result_used: ResultUsed,
     lrvalue: LRValue,
 ) TransError!*ast.Node {
-    const sc = ZigClangStmt_getStmtClass(stmt);
+    const sc = stmt.getStmtClass();
     switch (sc) {
-        .BinaryOperatorClass => return transBinaryOperator(rp, scope, @ptrCast(*const ZigClangBinaryOperator, stmt), result_used),
+        .BinaryOperatorClass => return transBinaryOperator(rp, scope, @ptrCast(*const clang.BinaryOperator, stmt), result_used),
-        .CompoundStmtClass => return transCompoundStmt(rp, scope, @ptrCast(*const ZigClangCompoundStmt, stmt)),
+        .CompoundStmtClass => return transCompoundStmt(rp, scope, @ptrCast(*const clang.CompoundStmt, stmt)),
-        .CStyleCastExprClass => return transCStyleCastExprClass(rp, scope, @ptrCast(*const ZigClangCStyleCastExpr, stmt), result_used, lrvalue),
+        .CStyleCastExprClass => return transCStyleCastExprClass(rp, scope, @ptrCast(*const clang.CStyleCastExpr, stmt), result_used, lrvalue),
-        .DeclStmtClass => return transDeclStmt(rp, scope, @ptrCast(*const ZigClangDeclStmt, stmt)),
+        .DeclStmtClass => return transDeclStmt(rp, scope, @ptrCast(*const clang.DeclStmt, stmt)),
-        .DeclRefExprClass => return transDeclRefExpr(rp, scope, @ptrCast(*const ZigClangDeclRefExpr, stmt), lrvalue),
+        .DeclRefExprClass => return transDeclRefExpr(rp, scope, @ptrCast(*const clang.DeclRefExpr, stmt), lrvalue),
-        .ImplicitCastExprClass => return transImplicitCastExpr(rp, scope, @ptrCast(*const ZigClangImplicitCastExpr, stmt), result_used),
+        .ImplicitCastExprClass => return transImplicitCastExpr(rp, scope, @ptrCast(*const clang.ImplicitCastExpr, stmt), result_used),
-        .IntegerLiteralClass => return transIntegerLiteral(rp, scope, @ptrCast(*const ZigClangIntegerLiteral, stmt), result_used, .with_as),
+        .IntegerLiteralClass => return transIntegerLiteral(rp, scope, @ptrCast(*const clang.IntegerLiteral, stmt), result_used, .with_as),
-        .ReturnStmtClass => return transReturnStmt(rp, scope, @ptrCast(*const ZigClangReturnStmt, stmt)),
+        .ReturnStmtClass => return transReturnStmt(rp, scope, @ptrCast(*const clang.ReturnStmt, stmt)),
-        .StringLiteralClass => return transStringLiteral(rp, scope, @ptrCast(*const ZigClangStringLiteral, stmt), result_used),
+        .StringLiteralClass => return transStringLiteral(rp, scope, @ptrCast(*const clang.StringLiteral, stmt), result_used),
         .ParenExprClass => {
-            const expr = try transExpr(rp, scope, ZigClangParenExpr_getSubExpr(@ptrCast(*const ZigClangParenExpr, stmt)), .used, lrvalue);
+            const expr = try transExpr(rp, scope, @ptrCast(*const clang.ParenExpr, stmt).getSubExpr(), .used, lrvalue);
             if (expr.tag == .GroupedExpression) return maybeSuppressResult(rp, scope, result_used, expr);
             const node = try rp.c.arena.create(ast.Node.GroupedExpression);
             node.* = .{
 @@ -1283,11 +1283,11 @@ fn transStmt(
             };
             return maybeSuppressResult(rp, scope, result_used, &node.base);
         },
-        .InitListExprClass => return transInitListExpr(rp, scope, @ptrCast(*const ZigClangInitListExpr, stmt), result_used),
+        .InitListExprClass => return transInitListExpr(rp, scope, @ptrCast(*const clang.InitListExpr, stmt), result_used),
-        .ImplicitValueInitExprClass => return transImplicitValueInitExpr(rp, scope, @ptrCast(*const ZigClangExpr, stmt), result_used),
+        .ImplicitValueInitExprClass => return transImplicitValueInitExpr(rp, scope, @ptrCast(*const clang.Expr, stmt), result_used),
-        .IfStmtClass => return transIfStmt(rp, scope, @ptrCast(*const ZigClangIfStmt, stmt)),
+        .IfStmtClass => return transIfStmt(rp, scope, @ptrCast(*const clang.IfStmt, stmt)),
-        .WhileStmtClass => return transWhileLoop(rp, scope, @ptrCast(*const ZigClangWhileStmt, stmt)),
+        .WhileStmtClass => return transWhileLoop(rp, scope, @ptrCast(*const clang.WhileStmt, stmt)),
-        .DoStmtClass => return transDoWhileLoop(rp, scope, @ptrCast(*const ZigClangDoStmt, stmt)),
+        .DoStmtClass => return transDoWhileLoop(rp, scope, @ptrCast(*const clang.DoStmt, stmt)),
         .NullStmtClass => {
             const block = try rp.c.createBlock(0);
             block.rbrace = try appendToken(rp.c, .RBrace, "}");
 @@ -1295,29 +1295,29 @@ fn transStmt(
         },
         .ContinueStmtClass => return try transCreateNodeContinue(rp.c),
         .BreakStmtClass => return transBreak(rp, scope),
-        .ForStmtClass => return transForLoop(rp, scope, @ptrCast(*const ZigClangForStmt, stmt)),
+        .ForStmtClass => return transForLoop(rp, scope, @ptrCast(*const clang.ForStmt, stmt)),
-        .FloatingLiteralClass => return transFloatingLiteral(rp, scope, @ptrCast(*const ZigClangFloatingLiteral, stmt), result_used),
+        .FloatingLiteralClass => return transFloatingLiteral(rp, scope, @ptrCast(*const clang.FloatingLiteral, stmt), result_used),
         .ConditionalOperatorClass => {
-            return transConditionalOperator(rp, scope, @ptrCast(*const ZigClangConditionalOperator, stmt), result_used);
+            return transConditionalOperator(rp, scope, @ptrCast(*const clang.ConditionalOperator, stmt), result_used);
         },
         .BinaryConditionalOperatorClass => {
-            return transBinaryConditionalOperator(rp, scope, @ptrCast(*const ZigClangBinaryConditionalOperator, stmt), result_used);
+            return transBinaryConditionalOperator(rp, scope, @ptrCast(*const clang.BinaryConditionalOperator, stmt), result_used);
         },
-        .SwitchStmtClass => return transSwitch(rp, scope, @ptrCast(*const ZigClangSwitchStmt, stmt)),
+        .SwitchStmtClass => return transSwitch(rp, scope, @ptrCast(*const clang.SwitchStmt, stmt)),
-        .CaseStmtClass => return transCase(rp, scope, @ptrCast(*const ZigClangCaseStmt, stmt)),
+        .CaseStmtClass => return transCase(rp, scope, @ptrCast(*const clang.CaseStmt, stmt)),
-        .DefaultStmtClass => return transDefault(rp, scope, @ptrCast(*const ZigClangDefaultStmt, stmt)),
+        .DefaultStmtClass => return transDefault(rp, scope, @ptrCast(*const clang.DefaultStmt, stmt)),
-        .ConstantExprClass => return transConstantExpr(rp, scope, @ptrCast(*const ZigClangExpr, stmt), result_used),
+        .ConstantExprClass => return transConstantExpr(rp, scope, @ptrCast(*const clang.Expr, stmt), result_used),
-        .PredefinedExprClass => return transPredefinedExpr(rp, scope, @ptrCast(*const ZigClangPredefinedExpr, stmt), result_used),
+        .PredefinedExprClass => return transPredefinedExpr(rp, scope, @ptrCast(*const clang.PredefinedExpr, stmt), result_used),
-        .CharacterLiteralClass => return transCharLiteral(rp, scope, @ptrCast(*const ZigClangCharacterLiteral, stmt), result_used, .with_as),
+        .CharacterLiteralClass => return transCharLiteral(rp, scope, @ptrCast(*const clang.CharacterLiteral, stmt), result_used, .with_as),
-        .StmtExprClass => return transStmtExpr(rp, scope, @ptrCast(*const ZigClangStmtExpr, stmt), result_used),
+        .StmtExprClass => return transStmtExpr(rp, scope, @ptrCast(*const clang.StmtExpr, stmt), result_used),
-        .MemberExprClass => return transMemberExpr(rp, scope, @ptrCast(*const ZigClangMemberExpr, stmt), result_used),
+        .MemberExprClass => return transMemberExpr(rp, scope, @ptrCast(*const clang.MemberExpr, stmt), result_used),
-        .ArraySubscriptExprClass => return transArrayAccess(rp, scope, @ptrCast(*const ZigClangArraySubscriptExpr, stmt), result_used),
+        .ArraySubscriptExprClass => return transArrayAccess(rp, scope, @ptrCast(*const clang.ArraySubscriptExpr, stmt), result_used),
-        .CallExprClass => return transCallExpr(rp, scope, @ptrCast(*const ZigClangCallExpr, stmt), result_used),
+        .CallExprClass => return transCallExpr(rp, scope, @ptrCast(*const clang.CallExpr, stmt), result_used),
-        .UnaryExprOrTypeTraitExprClass => return transUnaryExprOrTypeTraitExpr(rp, scope, @ptrCast(*const ZigClangUnaryExprOrTypeTraitExpr, stmt), result_used),
+        .UnaryExprOrTypeTraitExprClass => return transUnaryExprOrTypeTraitExpr(rp, scope, @ptrCast(*const clang.UnaryExprOrTypeTraitExpr, stmt), result_used),
-        .UnaryOperatorClass => return transUnaryOperator(rp, scope, @ptrCast(*const ZigClangUnaryOperator, stmt), result_used),
+        .UnaryOperatorClass => return transUnaryOperator(rp, scope, @ptrCast(*const clang.UnaryOperator, stmt), result_used),
-        .CompoundAssignOperatorClass => return transCompoundAssignOperator(rp, scope, @ptrCast(*const ZigClangCompoundAssignOperator, stmt), result_used),
+        .CompoundAssignOperatorClass => return transCompoundAssignOperator(rp, scope, @ptrCast(*const clang.CompoundAssignOperator, stmt), result_used),
         .OpaqueValueExprClass => {
-            const source_expr = ZigClangOpaqueValueExpr_getSourceExpr(@ptrCast(*const ZigClangOpaqueValueExpr, stmt)).?;
+            const source_expr = @ptrCast(*const clang.OpaqueValueExpr, stmt).getSourceExpr().?;
             const expr = try transExpr(rp, scope, source_expr, .used, lrvalue);
             if (expr.tag == .GroupedExpression) return maybeSuppressResult(rp, scope, result_used, expr);
             const node = try rp.c.arena.create(ast.Node.GroupedExpression);
 @@ -1332,7 +1332,7 @@ fn transStmt(
             return revertAndWarn(
                 rp,
                 error.UnsupportedTranslation,
-                ZigClangStmt_getBeginLoc(stmt),
+                stmt.getBeginLoc(),
                 "TODO implement translation of stmt class {}",
                 .{@tagName(sc)},
             );
 @@ -1343,24 +1343,24 @@ fn transStmt(
 fn transBinaryOperator(
     rp: RestorePoint,
     scope: *Scope,
-    stmt: *const ZigClangBinaryOperator,
+    stmt: *const clang.BinaryOperator,
     result_used: ResultUsed,
 ) TransError!*ast.Node {
-    const op = ZigClangBinaryOperator_getOpcode(stmt);
+    const op = stmt.getOpcode();
-    const qt = ZigClangBinaryOperator_getType(stmt);
+    const qt = stmt.getType();
     var op_token: ast.TokenIndex = undefined;
     var op_id: ast.Node.Tag = undefined;
     switch (op) {
-        .Assign => return try transCreateNodeAssign(rp, scope, result_used, ZigClangBinaryOperator_getLHS(stmt), ZigClangBinaryOperator_getRHS(stmt)),
+        .Assign => return try transCreateNodeAssign(rp, scope, result_used, stmt.getLHS(), stmt.getRHS()),
         .Comma => {
             const block_scope = try scope.findBlockScope(rp.c);
             const expr = block_scope.base.parent == scope;
             const lparen = if (expr) try appendToken(rp.c, .LParen, "(") else undefined;
-            const lhs = try transExpr(rp, &block_scope.base, ZigClangBinaryOperator_getLHS(stmt), .unused, .r_value);
+            const lhs = try transExpr(rp, &block_scope.base, stmt.getLHS(), .unused, .r_value);
             try block_scope.statements.append(lhs);
-            const rhs = try transExpr(rp, &block_scope.base, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value);
+            const rhs = try transExpr(rp, &block_scope.base, stmt.getRHS(), .used, .r_value);
             if (expr) {
                 _ = try appendToken(rp.c, .Semicolon, ";");
                 const break_node = try transCreateNodeBreak(rp.c, block_scope.label, rhs);
 @@ -1382,9 +1382,9 @@ fn transBinaryOperator(
             if (cIsSignedInteger(qt)) {
                 // signed integer division uses @divTrunc
                 const div_trunc_node = try rp.c.createBuiltinCall("@divTrunc", 2);
-                div_trunc_node.params()[0] = try transExpr(rp, scope, ZigClangBinaryOperator_getLHS(stmt), .used, .l_value);
+                div_trunc_node.params()[0] = try transExpr(rp, scope, stmt.getLHS(), .used, .l_value);
                 _ = try appendToken(rp.c, .Comma, ",");
-                const rhs = try transExpr(rp, scope, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value);
+                const rhs = try transExpr(rp, scope, stmt.getRHS(), .used, .r_value);
                 div_trunc_node.params()[1] = rhs;
                 div_trunc_node.rparen_token = try appendToken(rp.c, .RParen, ")");
                 return maybeSuppressResult(rp, scope, result_used, &div_trunc_node.base);
 @@ -1394,9 +1394,9 @@ fn transBinaryOperator(
             if (cIsSignedInteger(qt)) {
                 // signed integer division uses @rem
                 const rem_node = try rp.c.createBuiltinCall("@rem", 2);
-                rem_node.params()[0] = try transExpr(rp, scope, ZigClangBinaryOperator_getLHS(stmt), .used, .l_value);
+                rem_node.params()[0] = try transExpr(rp, scope, stmt.getLHS(), .used, .l_value);
                 _ = try appendToken(rp.c, .Comma, ",");
-                const rhs = try transExpr(rp, scope, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value);
+                const rhs = try transExpr(rp, scope, stmt.getRHS(), .used, .r_value);
                 rem_node.params()[1] = rhs;
                 rem_node.rparen_token = try appendToken(rp.c, .RParen, ")");
                 return maybeSuppressResult(rp, scope, result_used, &rem_node.base);
 @@ -1420,7 +1420,7 @@ fn transBinaryOperator(
         },
         else => {},
     }
-    const lhs_node = try transExpr(rp, scope, ZigClangBinaryOperator_getLHS(stmt), .used, .l_value);
+    const lhs_node = try transExpr(rp, scope, stmt.getLHS(), .used, .l_value);
     switch (op) {
         .Add => {
             if (cIsUnsignedInteger(qt)) {
 @@ -1498,7 +1498,7 @@ fn transBinaryOperator(
         else => unreachable,
     }
-    const rhs_node = try transExpr(rp, scope, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value);
+    const rhs_node = try transExpr(rp, scope, stmt.getRHS(), .used, .r_value);
     const lhs = if (isBoolRes(lhs_node)) init: {
         const cast_node = try rp.c.createBuiltinCall("@boolToInt", 1);
 @@ -1520,18 +1520,18 @@ fn transBinaryOperator(
 fn transCompoundStmtInline(
     rp: RestorePoint,
     parent_scope: *Scope,
-    stmt: *const ZigClangCompoundStmt,
+    stmt: *const clang.CompoundStmt,
     block: *Scope.Block,
 ) TransError!void {
-    var it = ZigClangCompoundStmt_body_begin(stmt);
+    var it = stmt.body_begin();
-    const end_it = ZigClangCompoundStmt_body_end(stmt);
+    const end_it = stmt.body_end();
     while (it != end_it) : (it += 1) {
         const result = try transStmt(rp, parent_scope, it[0], .unused, .r_value);
         try block.statements.append(result);
     }
 }
-fn transCompoundStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCompoundStmt) TransError!*ast.Node {
+fn transCompoundStmt(rp: RestorePoint, scope: *Scope, stmt: *const clang.CompoundStmt) TransError!*ast.Node {
     var block_scope = try Scope.Block.init(rp.c, scope, false);
     defer block_scope.deinit();
     try transCompoundStmtInline(rp, &block_scope.base, stmt, &block_scope);
 @@ -1541,17 +1541,17 @@ fn transCompoundStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCompo
 fn transCStyleCastExprClass(
     rp: RestorePoint,
     scope: *Scope,
-    stmt: *const ZigClangCStyleCastExpr,
+    stmt: *const clang.CStyleCastExpr,
     result_used: ResultUsed,
     lrvalue: LRValue,
 ) TransError!*ast.Node {
-    const sub_expr = ZigClangCStyleCastExpr_getSubExpr(stmt);
+    const sub_expr = stmt.getSubExpr();
     const cast_node = (try transCCast(
         rp,
         scope,
-        ZigClangCStyleCastExpr_getBeginLoc(stmt),
+        stmt.getBeginLoc(),
-        ZigClangCStyleCastExpr_getType(stmt),
+        stmt.getType(),
-        ZigClangExpr_getType(sub_expr),
+        sub_expr.getType(),
         try transExpr(rp, scope, sub_expr, .used, lrvalue),
     ));
     return maybeSuppressResult(rp, scope, result_used, cast_node);
 @@ -1560,22 +1560,20 @@ fn transCStyleCastExprClass(
 fn transDeclStmtOne(
     rp: RestorePoint,
     scope: *Scope,
-    decl: *const ZigClangDecl,
+    decl: *const clang.Decl,
     block_scope: *Scope.Block,
 ) TransError!*ast.Node {
     const c = rp.c;
-    switch (ZigClangDecl_getKind(decl)) {
+    switch (decl.getKind()) {
         .Var => {
-            const var_decl = @ptrCast(*const ZigClangVarDecl, decl);
+            const var_decl = @ptrCast(*const clang.VarDecl, decl);
-            const qual_type = ZigClangVarDecl_getTypeSourceInfo_getType(var_decl);
+            const qual_type = var_decl.getTypeSourceInfo_getType();
-            const name = try c.str(ZigClangNamedDecl_getName_bytes_begin(
+            const name = try c.str(@ptrCast(*const clang.NamedDecl, var_decl).getName_bytes_begin());
-                @ptrCast(*const ZigClangNamedDecl, var_decl),
-            ));
             const mangled_name = try block_scope.makeMangledName(c, name);
-            switch (ZigClangVarDecl_getStorageClass(var_decl)) {
+            switch (var_decl.getStorageClass()) {
                 .Extern, .Static => {
                     // This is actually a global variable, put it in the global scope and reference it.
                     // `_ = mangled_name;`
 @@ -1585,18 +1583,18 @@ fn transDeclStmtOne(
                 else => {},
             }
-            const mut_tok = if (ZigClangQualType_isConstQualified(qual_type))
+            const mut_tok = if (qual_type.isConstQualified())
                 try appendToken(c, .Keyword_const, "const")
             else
                 try appendToken(c, .Keyword_var, "var");
             const name_tok = try appendIdentifier(c, mangled_name);
             _ = try appendToken(c, .Colon, ":");
-            const loc = ZigClangDecl_getLocation(decl);
+            const loc = decl.getLocation();
             const type_node = try transQualType(rp, qual_type, loc);
             const eq_token = try appendToken(c, .Equal, "=");
-            var init_node = if (ZigClangVarDecl_getInit(var_decl)) |expr|
+            var init_node = if (var_decl.getInit()) |expr|
                 try transExprCoercing(rp, scope, expr, .used, .r_value)
             else
                 try transCreateNodeUndefinedLiteral(c);
 @@ -1619,13 +1617,11 @@ fn transDeclStmtOne(
             return &node.base;
         },
         .Typedef => {
-            const typedef_decl = @ptrCast(*const ZigClangTypedefNameDecl, decl);
+            const typedef_decl = @ptrCast(*const clang.TypedefNameDecl, decl);
-            const name = try c.str(ZigClangNamedDecl_getName_bytes_begin(
+            const name = try c.str(@ptrCast(*const clang.NamedDecl, typedef_decl).getName_bytes_begin());
-                @ptrCast(*const ZigClangNamedDecl, typedef_decl),
-            ));
-            const underlying_qual = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl);
+            const underlying_qual = typedef_decl.getUnderlyingType();
-            const underlying_type = ZigClangQualType_getTypePtr(underlying_qual);
+            const underlying_type = underlying_qual.getTypePtr();
             const mangled_name = try block_scope.makeMangledName(c, name);
             const node = (try transCreateNodeTypedef(rp, typedef_decl, false, mangled_name)) orelse
 @@ -1635,18 +1631,18 @@ fn transDeclStmtOne(
         else => |kind| return revertAndWarn(
             rp,
             error.UnsupportedTranslation,
-            ZigClangDecl_getLocation(decl),
+            decl.getLocation(),
             "TODO implement translation of DeclStmt kind {}",
             .{@tagName(kind)},
         ),
     }
 }
-fn transDeclStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangDeclStmt) TransError!*ast.Node {
+fn transDeclStmt(rp: RestorePoint, scope: *Scope, stmt: *const clang.DeclStmt) TransError!*ast.Node {
     const block_scope = scope.findBlockScope(rp.c) catch unreachable;
-    var it = ZigClangDeclStmt_decl_begin(stmt);
+    var it = stmt.decl_begin();
-    const end_it = ZigClangDeclStmt_decl_end(stmt);
+    const end_it = stmt.decl_end();
     assert(it != end_it);
     while (true) : (it += 1) {
         const node = try transDeclStmtOne(rp, scope, it[0], block_scope);
 @@ -1663,11 +1659,11 @@ fn transDeclStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangDeclStmt)
 fn transDeclRefExpr(
     rp: RestorePoint,
     scope: *Scope,
-    expr: *const ZigClangDeclRefExpr,
+    expr: *const clang.DeclRefExpr,
     lrvalue: LRValue,
 ) TransError!*ast.Node {
-    const value_decl = ZigClangDeclRefExpr_getDecl(expr);
+    const value_decl = expr.getDecl();
-    const name = try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, value_decl)));
+    const name = try rp.c.str(@ptrCast(*const clang.NamedDecl, value_decl).getName_bytes_begin());
     const mangled_name = scope.getAlias(name);
     return transCreateNodeIdentifier(rp.c, mangled_name);
 }
 @@ -1675,17 +1671,17 @@ fn transDeclRefExpr(
 fn transImplicitCastExpr(
     rp: RestorePoint,
     scope: *Scope,
-    expr: *const ZigClangImplicitCastExpr,
+    expr: *const clang.ImplicitCastExpr,
     result_used: ResultUsed,
 ) TransError!*ast.Node {
     const c = rp.c;
-    const sub_expr = ZigClangImplicitCastExpr_getSubExpr(expr);
+    const sub_expr = expr.getSubExpr();
-    const dest_type = getExprQualType(c, @ptrCast(*const ZigClangExpr, expr));
+    const dest_type = getExprQualType(c, @ptrCast(*const clang.Expr, expr));
     const src_type = getExprQualType(c, sub_expr);
-    switch (ZigClangImplicitCastExpr_getCastKind(expr)) {
+    switch (expr.getCastKind()) {
         .BitCast, .FloatingCast, .FloatingToIntegral, .IntegralToFloating, .IntegralCast, .PointerToIntegral, .IntegralToPointer => {
             const sub_expr_node = try transExpr(rp, scope, sub_expr, .used, .r_value);
-            return try transCCast(rp, scope, ZigClangImplicitCastExpr_getBeginLoc(expr), dest_type, src_type, sub_expr_node);
+            return try transCCast(rp, scope, expr.getBeginLoc(), dest_type, src_type, sub_expr_node);
         },
         .LValueToRValue, .NoOp, .FunctionToPointerDecay => {
             const sub_expr_node = try transExpr(rp, scope, sub_expr, .used, .r_value);
 @@ -1730,7 +1726,7 @@ fn transImplicitCastExpr(
         else => |kind| return revertAndWarn(
             rp,
             error.UnsupportedTranslation,
-            ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, expr)),
+            @ptrCast(*const clang.Stmt, expr).getBeginLoc(),
             "TODO implement translation of CastKind {}",
             .{@tagName(kind)},
         ),
 @@ -1740,15 +1736,15 @@ fn transImplicitCastExpr(
 fn transBoolExpr(
     rp: RestorePoint,
     scope: *Scope,
-    expr: *const ZigClangExpr,
+    expr: *const clang.Expr,
     used: ResultUsed,
     lrvalue: LRValue,
     grouped: bool,
 ) TransError!*ast.Node {
-    if (ZigClangStmt_getStmtClass(@ptrCast(*const ZigClangStmt, expr)) == .IntegerLiteralClass) {
+    if (@ptrCast(*const clang.Stmt, expr).getStmtClass() == .IntegerLiteralClass) {
         var is_zero: bool = undefined;
-        if (!ZigClangIntegerLiteral_isZero(@ptrCast(*const ZigClangIntegerLiteral, expr), &is_zero, rp.c.clang_context)) {
+        if (!(@ptrCast(*const clang.IntegerLiteral, expr).isZero(&is_zero, rp.c.clang_context))) {
-            return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangExpr_getBeginLoc(expr), "invalid integer literal", .{});
+            return revertAndWarn(rp, error.UnsupportedTranslation, expr.getBeginLoc(), "invalid integer literal", .{});
         }
         return try transCreateNodeBoolLiteral(rp.c, !is_zero);
     }
 @@ -1769,8 +1765,8 @@ fn transBoolExpr(
         return res;
     }
-    const ty = ZigClangQualType_getTypePtr(getExprQualType(rp.c, expr));
+    const ty = getExprQualType(rp.c, expr).getTypePtr();
-    const node = try finishBoolExpr(rp, scope, ZigClangExpr_getBeginLoc(expr), ty, res, used);
+    const node = try finishBoolExpr(rp, scope, expr.getBeginLoc(), ty, res, used);
     if (grouped) {
         const rparen = try appendToken(rp.c, .RParen, ")");
 @@ -1786,16 +1782,16 @@ fn transBoolExpr(
     }
 }
-fn exprIsBooleanType(expr: *const ZigClangExpr) bool {
+fn exprIsBooleanType(expr: *const clang.Expr) bool {
-    return qualTypeIsBoolean(ZigClangExpr_getType(expr));
+    return qualTypeIsBoolean(expr.getType());
 }
-fn exprIsStringLiteral(expr: *const ZigClangExpr) bool {
+fn exprIsStringLiteral(expr: *const clang.Expr) bool {
-    switch (ZigClangExpr_getStmtClass(expr)) {
+    switch (expr.getStmtClass()) {
         .StringLiteralClass => return true,
         .PredefinedExprClass => return true,
         .UnaryOperatorClass => {
-            const op_expr = ZigClangUnaryOperator_getSubExpr(@ptrCast(*const ZigClangUnaryOperator, expr));
+            const op_expr = @ptrCast(*const clang.UnaryOperator, expr).getSubExpr();
             return exprIsStringLiteral(op_expr);
         },
         else => return false,
 @@ -1825,16 +1821,16 @@ fn isBoolRes(res: *ast.Node) bool {
 fn finishBoolExpr(
     rp: RestorePoint,
     scope: *Scope,
-    loc: ZigClangSourceLocation,
+    loc: clang.SourceLocation,
-    ty: *const ZigClangType,
+    ty: *const clang.Type,
     node: *ast.Node,
     used: ResultUsed,
 ) TransError!*ast.Node {
-    switch (ZigClangType_getTypeClass(ty)) {
+    switch (ty.getTypeClass()) {
         .Builtin => {
-            const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty);
+            const builtin_ty = @ptrCast(*const clang.BuiltinType, ty);
-            switch (ZigClangBuiltinType_getKind(builtin_ty)) {
+            switch (builtin_ty.getKind()) {
                 .Bool => return node,
                 .Char_U,
                 .UChar,
 @@ -1879,10 +1875,10 @@ fn finishBoolExpr(
             return transCreateNodeInfixOp(rp, scope, node, .BangEqual, op_token, rhs_node, used, false);
         },
         .Typedef => {
-            const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty);
+            const typedef_ty = @ptrCast(*const clang.TypedefType, ty);
-            const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty);
+            const typedef_decl = typedef_ty.getDecl();
-            const underlying_type = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl);
+            const underlying_type = typedef_decl.getUnderlyingType();
-            return finishBoolExpr(rp, scope, loc, ZigClangQualType_getTypePtr(underlying_type), node, used);
+            return finishBoolExpr(rp, scope, loc, underlying_type.getTypePtr(), node, used);
         },
         .Enum => {
             const op_token = try appendToken(rp.c, .BangEqual, "!=");
 @@ -1890,9 +1886,9 @@ fn finishBoolExpr(
             return transCreateNodeInfixOp(rp, scope, node, .BangEqual, op_token, rhs_node, used, false);
         },
         .Elaborated => {
-            const elaborated_ty = @ptrCast(*const ZigClangElaboratedType, ty);
+            const elaborated_ty = @ptrCast(*const clang.ElaboratedType, ty);
-            const named_type = ZigClangElaboratedType_getNamedType(elaborated_ty);
+            const named_type = elaborated_ty.getNamedType();
-            return finishBoolExpr(rp, scope, loc, ZigClangQualType_getTypePtr(named_type), node, used);
+            return finishBoolExpr(rp, scope, loc, named_type.getTypePtr(), node, used);
         },
         else => {},
     }
 @@ -1906,18 +1902,18 @@ const SuppressCast = enum {
 fn transIntegerLiteral(
     rp: RestorePoint,
     scope: *Scope,
-    expr: *const ZigClangIntegerLiteral,
+    expr: *const clang.IntegerLiteral,
     result_used: ResultUsed,
     suppress_as: SuppressCast,
 ) TransError!*ast.Node {
-    var eval_result: ZigClangExprEvalResult = undefined;
+    var eval_result: clang.ExprEvalResult = undefined;
-    if (!ZigClangIntegerLiteral_EvaluateAsInt(expr, &eval_result, rp.c.clang_context)) {
+    if (!expr.EvaluateAsInt(&eval_result, rp.c.clang_context)) {
-        const loc = ZigClangIntegerLiteral_getBeginLoc(expr);
+        const loc = expr.getBeginLoc();
         return revertAndWarn(rp, error.UnsupportedTranslation, loc, "invalid integer literal", .{});
     }
     if (suppress_as == .no_as) {
-        const int_lit_node = try transCreateNodeAPInt(rp.c, ZigClangAPValue_getInt(&eval_result.Val));
+        const int_lit_node = try transCreateNodeAPInt(rp.c, eval_result.Val.getInt());
         return maybeSuppressResult(rp, scope, result_used, int_lit_node);
     }
 @@ -1932,12 +1928,12 @@ fn transIntegerLiteral(
     // But the first step is to be correct, and the next step is to make the output more elegant.
     // @as(T, x)
-    const expr_base = @ptrCast(*const ZigClangExpr, expr);
+    const expr_base = @ptrCast(*const clang.Expr, expr);
     const as_node = try rp.c.createBuiltinCall("@as", 2);
-    const ty_node = try transQualType(rp, ZigClangExpr_getType(expr_base), ZigClangExpr_getBeginLoc(expr_base));
+    const ty_node = try transQualType(rp, expr_base.getType(), expr_base.getBeginLoc());
     as_node.params()[0] = ty_node;
     _ = try appendToken(rp.c, .Comma, ",");
-    as_node.params()[1] = try transCreateNodeAPInt(rp.c, ZigClangAPValue_getInt(&eval_result.Val));
+    as_node.params()[1] = try transCreateNodeAPInt(rp.c, eval_result.Val.getInt());
     as_node.rparen_token = try appendToken(rp.c, .RParen, ")");
     return maybeSuppressResult(rp, scope, result_used, &as_node.base);
 @@ -1946,10 +1942,10 @@ fn transIntegerLiteral(
 fn transReturnStmt(
     rp: RestorePoint,
     scope: *Scope,
-    expr: *const ZigClangReturnStmt,
+    expr: *const clang.ReturnStmt,
 ) TransError!*ast.Node {
     const return_kw = try appendToken(rp.c, .Keyword_return, "return");
-    const rhs: ?*ast.Node = if (ZigClangReturnStmt_getRetValue(expr)) |val_expr|
+    const rhs: ?*ast.Node = if (expr.getRetValue()) |val_expr|
         try transExprCoercing(rp, scope, val_expr, .used, .r_value)
     else
         null;
 @@ -1966,14 +1962,14 @@ fn transReturnStmt(
 fn transStringLiteral(
     rp: RestorePoint,
     scope: *Scope,
-    stmt: *const ZigClangStringLiteral,
+    stmt: *const clang.StringLiteral,
     result_used: ResultUsed,
 ) TransError!*ast.Node {
-    const kind = ZigClangStringLiteral_getKind(stmt);
+    const kind = stmt.getKind();
     switch (kind) {
         .Ascii, .UTF8 => {
             var len: usize = undefined;
-            const bytes_ptr = ZigClangStringLiteral_getString_bytes_begin_size(stmt, &len);
+            const bytes_ptr = stmt.getString_bytes_begin_size(&len);
             const str = bytes_ptr[0..len];
             var char_buf: [4]u8 = undefined;
 @@ -1996,7 +1992,7 @@ fn transStringLiteral(
         .UTF16, .UTF32, .Wide => return revertAndWarn(
             rp,
             error.UnsupportedTranslation,
-            ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)),
+            @ptrCast(*const clang.Stmt, stmt).getBeginLoc(),
             "TODO: support string literal kind {}",
             .{kind},
         ),
 @@ -2041,13 +2037,13 @@ fn escapeChar(c: u8, char_buf: *[4]u8) []const u8 {
 fn transCCast(
     rp: RestorePoint,
     scope: *Scope,
-    loc: ZigClangSourceLocation,
+    loc: clang.SourceLocation,
-    dst_type: ZigClangQualType,
+    dst_type: clang.QualType,
-    src_type: ZigClangQualType,
+    src_type: clang.QualType,
     expr: *ast.Node,
 ) !*ast.Node {
-    if (ZigClangType_isVoidType(qualTypeCanon(dst_type))) return expr;
+    if (qualTypeCanon(dst_type).isVoidType()) return expr;
-    if (ZigClangQualType_eq(dst_type, src_type)) return expr;
+    if (dst_type.eq(src_type)) return expr;
     if (qualTypeIsPtr(dst_type) and qualTypeIsPtr(src_type))
         return transCPtrCast(rp, loc, dst_type, src_type, expr);
     if (cIsInteger(dst_type) and cIsInteger(src_type)) {
 @@ -2134,9 +2130,7 @@ fn transCCast(
         builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")");
         return &builtin_node.base;
     }
-    if (ZigClangType_isBooleanType(qualTypeCanon(src_type)) and
+    if (qualTypeIsBoolean(src_type) and !qualTypeIsBoolean(dst_type)) {
-        !ZigClangType_isBooleanType(qualTypeCanon(dst_type)))
-    {
         // @boolToInt returns either a comptime_int or a u1
         const builtin_node = try rp.c.createBuiltinCall("@boolToInt", 1);
         builtin_node.params()[0] = expr;
 @@ -2166,7 +2160,7 @@ fn transCCast(
         return &cast_node.base;
     }
-    if (ZigClangQualType_getTypeClass(ZigClangQualType_getCanonicalType(dst_type)) == .Enum) {
+    if (dst_type.getCanonicalType().getTypeClass() == .Enum) {
         const builtin_node = try rp.c.createBuiltinCall("@intToEnum", 2);
         builtin_node.params()[0] = try transQualType(rp, dst_type, loc);
         _ = try appendToken(rp.c, .Comma, ",");
 @@ -2174,8 +2168,8 @@ fn transCCast(
         builtin_node.rparen_token = try appendToken(rp.c, .RParen, ")");
         return &builtin_node.base;
     }
-    if (ZigClangQualType_getTypeClass(ZigClangQualType_getCanonicalType(src_type)) == .Enum and
+    if (src_type.getCanonicalType().getTypeClass() == .Enum and
-        ZigClangQualType_getTypeClass(ZigClangQualType_getCanonicalType(dst_type)) != .Enum)
+        dst_type.getCanonicalType().getTypeClass() != .Enum)
     {
         const builtin_node = try rp.c.createBuiltinCall("@enumToInt", 1);
         builtin_node.params()[0] = expr;
 @@ -2193,11 +2187,11 @@ fn transCCast(
 fn transExpr(
     rp: RestorePoint,
     scope: *Scope,
-    expr: *const ZigClangExpr,
+    expr: *const clang.Expr,
     used: ResultUsed,
     lrvalue: LRValue,
 ) TransError!*ast.Node {
-    return transStmt(rp, scope, @ptrCast(*const ZigClangStmt, expr), used, lrvalue);
+    return transStmt(rp, scope, @ptrCast(*const clang.Stmt, expr), used, lrvalue);
 }
 /// Same as `transExpr` but with the knowledge that the operand will be type coerced, and therefore
 @@ -2205,21 +2199,21 @@ fn transExpr(
 fn transExprCoercing(
     rp: RestorePoint,
     scope: *Scope,
-    expr: *const ZigClangExpr,
+    expr: *const clang.Expr,
     used: ResultUsed,
     lrvalue: LRValue,
 ) TransError!*ast.Node {
-    switch (ZigClangStmt_getStmtClass(@ptrCast(*const ZigClangStmt, expr))) {
+    switch (@ptrCast(*const clang.Stmt, expr).getStmtClass()) {
         .IntegerLiteralClass => {
-            return transIntegerLiteral(rp, scope, @ptrCast(*const ZigClangIntegerLiteral, expr), .used, .no_as);
+            return transIntegerLiteral(rp, scope, @ptrCast(*const clang.IntegerLiteral, expr), .used, .no_as);
         },
         .CharacterLiteralClass => {
-            return transCharLiteral(rp, scope, @ptrCast(*const ZigClangCharacterLiteral, expr), .used, .no_as);
+            return transCharLiteral(rp, scope, @ptrCast(*const clang.CharacterLiteral, expr), .used, .no_as);
         },
         .UnaryOperatorClass => {
-            const un_expr = @ptrCast(*const ZigClangUnaryOperator, expr);
+            const un_expr = @ptrCast(*const clang.UnaryOperator, expr);
-            if (ZigClangUnaryOperator_getOpcode(un_expr) == .Extension) {
+            if (un_expr.getOpcode() == .Extension) {
-                return transExprCoercing(rp, scope, ZigClangUnaryOperator_getSubExpr(un_expr), used, lrvalue);
+                return transExprCoercing(rp, scope, un_expr.getSubExpr(), used, lrvalue);
             }
         },
         else => {},
 @@ -2230,51 +2224,51 @@ fn transExprCoercing(
 fn transInitListExprRecord(
     rp: RestorePoint,
     scope: *Scope,
-    loc: ZigClangSourceLocation,
+    loc: clang.SourceLocation,
-    expr: *const ZigClangInitListExpr,
+    expr: *const clang.InitListExpr,
-    ty: *const ZigClangType,
+    ty: *const clang.Type,
     used: ResultUsed,
 ) TransError!*ast.Node {
     var is_union_type = false;
     // Unions and Structs are both represented as RecordDecl
-    const record_ty = ZigClangType_getAsRecordType(ty) orelse
+    const record_ty = ty.getAsRecordType() orelse
         blk: {
         is_union_type = true;
-        break :blk ZigClangType_getAsUnionType(ty);
+        break :blk ty.getAsUnionType();
     } orelse unreachable;
-    const record_decl = ZigClangRecordType_getDecl(record_ty);
+    const record_decl = record_ty.getDecl();
-    const record_def = ZigClangRecordDecl_getDefinition(record_decl) orelse
+    const record_def = record_decl.getDefinition() orelse
         unreachable;
     const ty_node = try transType(rp, ty, loc);
-    const init_count = ZigClangInitListExpr_getNumInits(expr);
+    const init_count = expr.getNumInits();
     var field_inits = std.ArrayList(*ast.Node).init(rp.c.gpa);
     defer field_inits.deinit();
     _ = try appendToken(rp.c, .LBrace, "{");
     var init_i: c_uint = 0;
-    var it = ZigClangRecordDecl_field_begin(record_def);
+    var it = record_def.field_begin();
-    const end_it = ZigClangRecordDecl_field_end(record_def);
+    const end_it = record_def.field_end();
-    while (ZigClangRecordDecl_field_iterator_neq(it, end_it)) : (it = ZigClangRecordDecl_field_iterator_next(it)) {
+    while (it.neq(end_it)) : (it = it.next()) {
-        const field_decl = ZigClangRecordDecl_field_iterator_deref(it);
+        const field_decl = it.deref();
         // The initializer for a union type has a single entry only
-        if (is_union_type and field_decl != ZigClangInitListExpr_getInitializedFieldInUnion(expr)) {
+        if (is_union_type and field_decl != expr.getInitializedFieldInUnion()) {
             continue;
         }
         assert(init_i < init_count);
-        const elem_expr = ZigClangInitListExpr_getInit(expr, init_i);
+        const elem_expr = expr.getInit(init_i);
         init_i += 1;
         // Generate the field assignment expression:
         //     .field_name = expr
         const period_tok = try appendToken(rp.c, .Period, ".");
-        var raw_name = try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, field_decl)));
+        var raw_name = try rp.c.str(@ptrCast(*const clang.NamedDecl, field_decl).getName_bytes_begin());
-        if (ZigClangFieldDecl_isAnonymousStructOrUnion(field_decl)) {
+        if (field_decl.isAnonymousStructOrUnion()) {
-            const name = rp.c.decl_table.get(@ptrToInt(ZigClangFieldDecl_getCanonicalDecl(field_decl))).?;
+            const name = rp.c.decl_table.get(@ptrToInt(field_decl.getCanonicalDecl())).?;
             raw_name = try mem.dupe(rp.c.arena, u8, name);
         }
         const field_name_tok = try appendIdentifier(rp.c, raw_name);
 @@ -2304,8 +2298,8 @@ fn transInitListExprRecord(
 fn transCreateNodeArrayType(
     rp: RestorePoint,
-    source_loc: ZigClangSourceLocation,
+    source_loc: clang.SourceLocation,
-    ty: *const ZigClangType,
+    ty: *const clang.Type,
     len: anytype,
 ) !*ast.Node {
     const node = try rp.c.arena.create(ast.Node.ArrayType);
 @@ -2323,18 +2317,18 @@ fn transCreateNodeArrayType(
 fn transInitListExprArray(
     rp: RestorePoint,
     scope: *Scope,
-    loc: ZigClangSourceLocation,
+    loc: clang.SourceLocation,
-    expr: *const ZigClangInitListExpr,
+    expr: *const clang.InitListExpr,
-    ty: *const ZigClangType,
+    ty: *const clang.Type,
     used: ResultUsed,
 ) TransError!*ast.Node {
-    const arr_type = ZigClangType_getAsArrayTypeUnsafe(ty);
+    const arr_type = ty.getAsArrayTypeUnsafe();
-    const child_qt = ZigClangArrayType_getElementType(arr_type);
+    const child_qt = arr_type.getElementType();
-    const init_count = ZigClangInitListExpr_getNumInits(expr);
+    const init_count = expr.getNumInits();
-    assert(ZigClangType_isConstantArrayType(@ptrCast(*const ZigClangType, arr_type)));
+    assert(@ptrCast(*const clang.Type, arr_type).isConstantArrayType());
-    const const_arr_ty = @ptrCast(*const ZigClangConstantArrayType, arr_type);
+    const const_arr_ty = @ptrCast(*const clang.ConstantArrayType, arr_type);
-    const size_ap_int = ZigClangConstantArrayType_getSize(const_arr_ty);
+    const size_ap_int = const_arr_ty.getSize();
-    const all_count = ZigClangAPInt_getLimitedValue(size_ap_int, math.maxInt(usize));
+    const all_count = size_ap_int.getLimitedValue(math.maxInt(usize));
     const leftover_count = all_count - init_count;
     var init_node: *ast.Node.ArrayInitializer = undefined;
 @@ -2343,7 +2337,7 @@ fn transInitListExprArray(
         const ty_node = try transCreateNodeArrayType(
             rp,
             loc,
-            ZigClangQualType_getTypePtr(child_qt),
+            child_qt.getTypePtr(),
             init_count,
         );
         _ = try appendToken(rp.c, .LBrace, "{");
 @@ -2357,7 +2351,7 @@ fn transInitListExprArray(
         var i: c_uint = 0;
         while (i < init_count) : (i += 1) {
-            const elem_expr = ZigClangInitListExpr_getInit(expr, i);
+            const elem_expr = expr.getInit(i);
             init_list[i] = try transExpr(rp, scope, elem_expr, .used, .r_value);
             _ = try appendToken(rp.c, .Comma, ",");
         }
 @@ -2368,7 +2362,7 @@ fn transInitListExprArray(
         cat_tok = try appendToken(rp.c, .PlusPlus, "++");
     }
-    const ty_node = try transCreateNodeArrayType(rp, loc, ZigClangQualType_getTypePtr(child_qt), 1);
+    const ty_node = try transCreateNodeArrayType(rp, loc, child_qt.getTypePtr(), 1);
     _ = try appendToken(rp.c, .LBrace, "{");
     const filler_init_node = try ast.Node.ArrayInitializer.alloc(rp.c.arena, 1);
     filler_init_node.* = .{
 @@ -2376,7 +2370,7 @@ fn transInitListExprArray(
         .rtoken = undefined,
         .list_len = 1,
     };
-    const filler_val_expr = ZigClangInitListExpr_getArrayFiller(expr);
+    const filler_val_expr = expr.getArrayFiller();
     filler_init_node.list()[0] = try transExpr(rp, scope, filler_val_expr, .used, .r_value);
     filler_init_node.rtoken = try appendToken(rp.c, .RBrace, "}");
 @@ -2411,14 +2405,14 @@ fn transInitListExprArray(
 fn transInitListExpr(
     rp: RestorePoint,
     scope: *Scope,
-    expr: *const ZigClangInitListExpr,
+    expr: *const clang.InitListExpr,
     used: ResultUsed,
 ) TransError!*ast.Node {
-    const qt = getExprQualType(rp.c, @ptrCast(*const ZigClangExpr, expr));
+    const qt = getExprQualType(rp.c, @ptrCast(*const clang.Expr, expr));
-    var qual_type = ZigClangQualType_getTypePtr(qt);
+    var qual_type = qt.getTypePtr();
-    const source_loc = ZigClangExpr_getBeginLoc(@ptrCast(*const ZigClangExpr, expr));
+    const source_loc = @ptrCast(*const clang.Expr, expr).getBeginLoc();
-    if (ZigClangType_isRecordType(qual_type)) {
+    if (qual_type.isRecordType()) {
         return transInitListExprRecord(
             rp,
             scope,
 @@ -2427,7 +2421,7 @@ fn transInitListExpr(
             qual_type,
             used,
         );
-    } else if (ZigClangType_isArrayType(qual_type)) {
+    } else if (qual_type.isArrayType()) {
         return transInitListExprArray(
             rp,
             scope,
 @@ -2437,7 +2431,7 @@ fn transInitListExpr(
             used,
         );
     } else {
-        const type_name = rp.c.str(ZigClangType_getTypeClassName(qual_type));
+        const type_name = rp.c.str(qual_type.getTypeClassName());
         return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported initlist type: '{}'", .{type_name});
     }
 }
 @@ -2445,13 +2439,13 @@ fn transInitListExpr(
 fn transZeroInitExpr(
     rp: RestorePoint,
     scope: *Scope,
-    source_loc: ZigClangSourceLocation,
+    source_loc: clang.SourceLocation,
-    ty: *const ZigClangType,
+    ty: *const clang.Type,
 ) TransError!*ast.Node {
-    switch (ZigClangType_getTypeClass(ty)) {
+    switch (ty.getTypeClass()) {
         .Builtin => {
-            const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty);
+            const builtin_ty = @ptrCast(*const clang.BuiltinType, ty);
-            switch (ZigClangBuiltinType_getKind(builtin_ty)) {
+            switch (builtin_ty.getKind()) {
                 .Bool => return try transCreateNodeBoolLiteral(rp.c, false),
                 .Char_U,
                 .UChar,
 @@ -2479,15 +2473,13 @@ fn transZeroInitExpr(
         },
         .Pointer => return transCreateNodeNullLiteral(rp.c),
         .Typedef => {
-            const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty);
+            const typedef_ty = @ptrCast(*const clang.TypedefType, ty);
-            const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty);
+            const typedef_decl = typedef_ty.getDecl();
             return transZeroInitExpr(
                 rp,
                 scope,
                 source_loc,
-                ZigClangQualType_getTypePtr(
+                typedef_decl.getUnderlyingType().getTypePtr(),
-                    ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl),
-                ),
             );
         },
         else => {},
 @@ -2499,19 +2491,19 @@ fn transZeroInitExpr(
 fn transImplicitValueInitExpr(
     rp: RestorePoint,
     scope: *Scope,
-    expr: *const ZigClangExpr,
+    expr: *const clang.Expr,
     used: ResultUsed,
 ) TransError!*ast.Node {
-    const source_loc = ZigClangExpr_getBeginLoc(expr);
+    const source_loc = expr.getBeginLoc();
     const qt = getExprQualType(rp.c, expr);
-    const ty = ZigClangQualType_getTypePtr(qt);
+    const ty = qt.getTypePtr();
     return transZeroInitExpr(rp, scope, source_loc, ty);
 }
 fn transIfStmt(
     rp: RestorePoint,
     scope: *Scope,
-    stmt: *const ZigClangIfStmt,
+    stmt: *const clang.IfStmt,
 ) TransError!*ast.Node {
     // if (c) t
     // if (c) t else e
 @@ -2524,13 +2516,13 @@ fn transIfStmt(
         },
     };
     defer cond_scope.deinit();
-    const cond_expr = @ptrCast(*const ZigClangExpr, ZigClangIfStmt_getCond(stmt));
+    const cond_expr = @ptrCast(*const clang.Expr, stmt.getCond());
     if_node.condition = try transBoolExpr(rp, &cond_scope.base, cond_expr, .used, .r_value, false);
     _ = try appendToken(rp.c, .RParen, ")");
-    if_node.body = try transStmt(rp, scope, ZigClangIfStmt_getThen(stmt), .unused, .r_value);
+    if_node.body = try transStmt(rp, scope, stmt.getThen(), .unused, .r_value);
-    if (ZigClangIfStmt_getElse(stmt)) |expr| {
+    if (stmt.getElse()) |expr| {
         if_node.@"else" = try transCreateNodeElse(rp.c);
         if_node.@"else".?.body = try transStmt(rp, scope, expr, .unused, .r_value);
     }
 @@ -2541,7 +2533,7 @@ fn transIfStmt(
 fn transWhileLoop(
     rp: RestorePoint,
     scope: *Scope,
-    stmt: *const ZigClangWhileStmt,
+    stmt: *const clang.WhileStmt,
 ) TransError!*ast.Node {
     const while_node = try transCreateNodeWhile(rp.c);
 @@ -2552,7 +2544,7 @@ fn transWhileLoop(
         },
     };
     defer cond_scope.deinit();
-    const cond_expr = @ptrCast(*const ZigClangExpr, ZigClangWhileStmt_getCond(stmt));
+    const cond_expr = @ptrCast(*const clang.Expr, stmt.getCond());
     while_node.condition = try transBoolExpr(rp, &cond_scope.base, cond_expr, .used, .r_value, false);
     _ = try appendToken(rp.c, .RParen, ")");
 @@ -2560,7 +2552,7 @@ fn transWhileLoop(
         .parent = scope,
         .id = .Loop,
     };
-    while_node.body = try transStmt(rp, &loop_scope, ZigClangWhileStmt_getBody(stmt), .unused, .r_value);
+    while_node.body = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value);
     _ = try appendToken(rp.c, .Semicolon, ";");
     return &while_node.base;
 }
 @@ -2568,7 +2560,7 @@ fn transWhileLoop(
 fn transDoWhileLoop(
     rp: RestorePoint,
     scope: *Scope,
-    stmt: *const ZigClangDoStmt,
+    stmt: *const clang.DoStmt,
 ) TransError!*ast.Node {
     const while_node = try transCreateNodeWhile(rp.c);
 @@ -2590,13 +2582,13 @@ fn transDoWhileLoop(
     };
     defer cond_scope.deinit();
     const prefix_op = try transCreateNodeSimplePrefixOp(rp.c, .BoolNot, .Bang, "!");
-    prefix_op.rhs = try transBoolExpr(rp, &cond_scope.base, @ptrCast(*const ZigClangExpr, ZigClangDoStmt_getCond(stmt)), .used, .r_value, true);
+    prefix_op.rhs = try transBoolExpr(rp, &cond_scope.base, @ptrCast(*const clang.Expr, stmt.getCond()), .used, .r_value, true);
     _ = try appendToken(rp.c, .RParen, ")");
     if_node.condition = &prefix_op.base;
     if_node.body = &(try transCreateNodeBreak(rp.c, null, null)).base;
     _ = try appendToken(rp.c, .Semicolon, ";");
-    const body_node = if (ZigClangStmt_getStmtClass(ZigClangDoStmt_getBody(stmt)) == .CompoundStmtClass) blk: {
+    const body_node = if (stmt.getBody().getStmtClass() == .CompoundStmtClass) blk: {
         // there's already a block in C, so we'll append our condition to it.
         // c: do {
         // c:   a;
 @@ -2607,7 +2599,7 @@ fn transDoWhileLoop(
         // zig:   b;
         // zig:   if (!cond) break;
         // zig: }
-        const node = try transStmt(rp, &loop_scope, ZigClangDoStmt_getBody(stmt), .unused, .r_value);
+        const node = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value);
         break :blk node.castTag(.Block).?;
     } else blk: {
         // the C statement is without a block, so we need to create a block to contain it.
 @@ -2621,7 +2613,7 @@ fn transDoWhileLoop(
         new = true;
         const block = try rp.c.createBlock(2);
         block.statements_len = 1; // over-allocated so we can add another below
-        block.statements()[0] = try transStmt(rp, &loop_scope, ZigClangDoStmt_getBody(stmt), .unused, .r_value);
+        block.statements()[0] = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value);
         break :blk block;
     };
 @@ -2637,7 +2629,7 @@ fn transDoWhileLoop(
 fn transForLoop(
     rp: RestorePoint,
     scope: *Scope,
-    stmt: *const ZigClangForStmt,
+    stmt: *const clang.ForStmt,
 ) TransError!*ast.Node {
     var loop_scope = Scope{
         .parent = scope,
 @@ -2647,7 +2639,7 @@ fn transForLoop(
     var block_scope: ?Scope.Block = null;
     defer if (block_scope) |*bs| bs.deinit();
-    if (ZigClangForStmt_getInit(stmt)) |init| {
+    if (stmt.getInit()) |init| {
         block_scope = try Scope.Block.init(rp.c, scope, false);
         loop_scope.parent = &block_scope.?.base;
         const init_node = try transStmt(rp, &block_scope.?.base, init, .unused, .r_value);
 @@ -2662,20 +2654,20 @@ fn transForLoop(
     defer cond_scope.deinit();
     const while_node = try transCreateNodeWhile(rp.c);
-    while_node.condition = if (ZigClangForStmt_getCond(stmt)) |cond|
+    while_node.condition = if (stmt.getCond()) |cond|
         try transBoolExpr(rp, &cond_scope.base, cond, .used, .r_value, false)
     else
         try transCreateNodeBoolLiteral(rp.c, true);
     _ = try appendToken(rp.c, .RParen, ")");
-    if (ZigClangForStmt_getInc(stmt)) |incr| {
+    if (stmt.getInc()) |incr| {
         _ = try appendToken(rp.c, .Colon, ":");
         _ = try appendToken(rp.c, .LParen, "(");
         while_node.continue_expr = try transExpr(rp, &cond_scope.base, incr, .unused, .r_value);
         _ = try appendToken(rp.c, .RParen, ")");
     }
-    while_node.body = try transStmt(rp, &loop_scope, ZigClangForStmt_getBody(stmt), .unused, .r_value);
+    while_node.body = try transStmt(rp, &loop_scope, stmt.getBody(), .unused, .r_value);
     if (block_scope) |*bs| {
         try bs.statements.append(&while_node.base);
         return try bs.complete(rp.c);
 @@ -2685,21 +2677,21 @@ fn transForLoop(
     }
 }
-fn getSwitchCaseCount(stmt: *const ZigClangSwitchStmt) usize {
+fn getSwitchCaseCount(stmt: *const clang.SwitchStmt) usize {
-    const body = ZigClangSwitchStmt_getBody(stmt);
+    const body = stmt.getBody();
-    assert(ZigClangStmt_getStmtClass(body) == .CompoundStmtClass);
+    assert(body.getStmtClass() == .CompoundStmtClass);
-    const comp = @ptrCast(*const ZigClangCompoundStmt, body);
+    const comp = @ptrCast(*const clang.CompoundStmt, body);
     // TODO https://github.com/ziglang/zig/issues/1738
-    // return ZigClangCompoundStmt_body_end(comp) - ZigClangCompoundStmt_body_begin(comp);
+    // return comp.body_end() - comp.body_begin();
-    const start_addr = @ptrToInt(ZigClangCompoundStmt_body_begin(comp));
+    const start_addr = @ptrToInt(comp.body_begin());
-    const end_addr = @ptrToInt(ZigClangCompoundStmt_body_end(comp));
+    const end_addr = @ptrToInt(comp.body_end());
-    return (end_addr - start_addr) / @sizeOf(*ZigClangStmt);
+    return (end_addr - start_addr) / @sizeOf(*clang.Stmt);
 }
 fn transSwitch(
     rp: RestorePoint,
     scope: *Scope,
-    stmt: *const ZigClangSwitchStmt,
+    stmt: *const clang.SwitchStmt,
 ) TransError!*ast.Node {
     const switch_tok = try appendToken(rp.c, .Keyword_switch, "switch");
     _ = try appendToken(rp.c, .LParen, "(");
 @@ -2713,7 +2705,7 @@ fn transSwitch(
         },
     };
     defer cond_scope.deinit();
-    const switch_expr = try transExpr(rp, &cond_scope.base, ZigClangSwitchStmt_getCond(stmt), .used, .r_value);
+    const switch_expr = try transExpr(rp, &cond_scope.base, stmt.getCond(), .used, .r_value);
     _ = try appendToken(rp.c, .RParen, ")");
     _ = try appendToken(rp.c, .LBrace, "{");
     // reserve +1 case in case there is no default case
 @@ -2748,7 +2740,7 @@ fn transSwitch(
     switch_scope.pending_block = try Scope.Block.init(rp.c, scope, false);
     try switch_scope.pending_block.statements.append(&switch_node.base);
-    const last = try transStmt(rp, &block_scope.base, ZigClangSwitchStmt_getBody(stmt), .unused, .r_value);
+    const last = try transStmt(rp, &block_scope.base, stmt.getBody(), .unused, .r_value);
     _ = try appendToken(rp.c, .Semicolon, ";");
     // take all pending statements
 @@ -2776,7 +2768,7 @@ fn transSwitch(
         _ = try appendToken(rp.c, .Comma, ",");
         if (switch_scope.case_index >= switch_scope.cases.len)
-            return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)), "TODO complex switch cases", .{});
+            return revertAndWarn(rp, error.UnsupportedTranslation, @ptrCast(*const clang.Stmt, stmt).getBeginLoc(), "TODO complex switch cases", .{});
         switch_scope.cases[switch_scope.case_index] = &else_prong.base;
         switch_scope.case_index += 1;
     }
 @@ -2792,15 +2784,15 @@ fn transSwitch(
 fn transCase(
     rp: RestorePoint,
     scope: *Scope,
-    stmt: *const ZigClangCaseStmt,
+    stmt: *const clang.CaseStmt,
 ) TransError!*ast.Node {
     const block_scope = scope.findBlockScope(rp.c) catch unreachable;
     const switch_scope = scope.getSwitch();
     const label = try block_scope.makeMangledName(rp.c, "case");
     _ = try appendToken(rp.c, .Semicolon, ";");
-    const expr = if (ZigClangCaseStmt_getRHS(stmt)) |rhs| blk: {
+    const expr = if (stmt.getRHS()) |rhs| blk: {
-        const lhs_node = try transExpr(rp, scope, ZigClangCaseStmt_getLHS(stmt), .used, .r_value);
+        const lhs_node = try transExpr(rp, scope, stmt.getLHS(), .used, .r_value);
         const ellips = try appendToken(rp.c, .Ellipsis3, "...");
         const rhs_node = try transExpr(rp, scope, rhs, .used, .r_value);
 @@ -2813,7 +2805,7 @@ fn transCase(
         };
         break :blk &node.base;
     } else
-        try transExpr(rp, scope, ZigClangCaseStmt_getLHS(stmt), .used, .r_value);
+        try transExpr(rp, scope, stmt.getLHS(), .used, .r_value);
     const switch_prong = try transCreateNodeSwitchCase(rp.c, expr);
     switch_prong.expr = blk: {
 @@ -2823,7 +2815,7 @@ fn transCase(
     _ = try appendToken(rp.c, .Comma, ",");
     if (switch_scope.case_index >= switch_scope.cases.len)
-        return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)), "TODO complex switch cases", .{});
+        return revertAndWarn(rp, error.UnsupportedTranslation, @ptrCast(*const clang.Stmt, stmt).getBeginLoc(), "TODO complex switch cases", .{});
     switch_scope.cases[switch_scope.case_index] = &switch_prong.base;
     switch_scope.case_index += 1;
 @@ -2840,13 +2832,13 @@ fn transCase(
     try switch_scope.pending_block.statements.append(pending_node);
-    return transStmt(rp, scope, ZigClangCaseStmt_getSubStmt(stmt), .unused, .r_value);
+    return transStmt(rp, scope, stmt.getSubStmt(), .unused, .r_value);
 }
 fn transDefault(
     rp: RestorePoint,
     scope: *Scope,
-    stmt: *const ZigClangDefaultStmt,
+    stmt: *const clang.DefaultStmt,
 ) TransError!*ast.Node {
     const block_scope = scope.findBlockScope(rp.c) catch unreachable;
     const switch_scope = scope.getSwitch();
 @@ -2861,7 +2853,7 @@ fn transDefault(
     _ = try appendToken(rp.c, .Comma, ",");
     if (switch_scope.case_index >= switch_scope.cases.len)
-        return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)), "TODO complex switch cases", .{});
+        return revertAndWarn(rp, error.UnsupportedTranslation, @ptrCast(*const clang.Stmt, stmt).getBeginLoc(), "TODO complex switch cases", .{});
     switch_scope.cases[switch_scope.case_index] = &else_prong.base;
     switch_scope.case_index += 1;
 @@ -2877,26 +2869,26 @@ fn transDefault(
     switch_scope.pending_block = try Scope.Block.init(rp.c, scope, false);
     try switch_scope.pending_block.statements.append(pending_node);
-    return transStmt(rp, scope, ZigClangDefaultStmt_getSubStmt(stmt), .unused, .r_value);
+    return transStmt(rp, scope, stmt.getSubStmt(), .unused, .r_value);
 }
-fn transConstantExpr(rp: RestorePoint, scope: *Scope, expr: *const ZigClangExpr, used: ResultUsed) TransError!*ast.Node {
+fn transConstantExpr(rp: RestorePoint, scope: *Scope, expr: *const clang.Expr, used: ResultUsed) TransError!*ast.Node {
-    var result: ZigClangExprEvalResult = undefined;
+    var result: clang.ExprEvalResult = undefined;
-    if (!ZigClangExpr_EvaluateAsConstantExpr(expr, &result, .EvaluateForCodeGen, rp.c.clang_context))
+    if (!expr.EvaluateAsConstantExpr(&result, .EvaluateForCodeGen, rp.c.clang_context))
-        return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangExpr_getBeginLoc(expr), "invalid constant expression", .{});
+        return revertAndWarn(rp, error.UnsupportedTranslation, expr.getBeginLoc(), "invalid constant expression", .{});
     var val_node: ?*ast.Node = null;
-    switch (ZigClangAPValue_getKind(&result.Val)) {
+    switch (result.Val.getKind()) {
         .Int => {
             // See comment in `transIntegerLiteral` for why this code is here.
             // @as(T, x)
-            const expr_base = @ptrCast(*const ZigClangExpr, expr);
+            const expr_base = @ptrCast(*const clang.Expr, expr);
             const as_node = try rp.c.createBuiltinCall("@as", 2);
-            const ty_node = try transQualType(rp, ZigClangExpr_getType(expr_base), ZigClangExpr_getBeginLoc(expr_base));
+            const ty_node = try transQualType(rp, expr_base.getType(), expr_base.getBeginLoc());
             as_node.params()[0] = ty_node;
             _ = try appendToken(rp.c, .Comma, ",");
-            const int_lit_node = try transCreateNodeAPInt(rp.c, ZigClangAPValue_getInt(&result.Val));
+            const int_lit_node = try transCreateNodeAPInt(rp.c, result.Val.getInt());
             as_node.params()[1] = int_lit_node;
             as_node.rparen_token = try appendToken(rp.c, .RParen, ")");
 @@ -2904,26 +2896,26 @@ fn transConstantExpr(rp: RestorePoint, scope: *Scope, expr: *const ZigClangExpr,
             return maybeSuppressResult(rp, scope, used, &as_node.base);
         },
         else => {
-            return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangExpr_getBeginLoc(expr), "unsupported constant expression kind", .{});
+            return revertAndWarn(rp, error.UnsupportedTranslation, expr.getBeginLoc(), "unsupported constant expression kind", .{});
         },
     }
 }
-fn transPredefinedExpr(rp: RestorePoint, scope: *Scope, expr: *const ZigClangPredefinedExpr, used: ResultUsed) TransError!*ast.Node {
+fn transPredefinedExpr(rp: RestorePoint, scope: *Scope, expr: *const clang.PredefinedExpr, used: ResultUsed) TransError!*ast.Node {
-    return transStringLiteral(rp, scope, ZigClangPredefinedExpr_getFunctionName(expr), used);
+    return transStringLiteral(rp, scope, expr.getFunctionName(), used);
 }
 fn transCharLiteral(
     rp: RestorePoint,
     scope: *Scope,
-    stmt: *const ZigClangCharacterLiteral,
+    stmt: *const clang.CharacterLiteral,
     result_used: ResultUsed,
     suppress_as: SuppressCast,
 ) TransError!*ast.Node {
-    const kind = ZigClangCharacterLiteral_getKind(stmt);
+    const kind = stmt.getKind();
     const int_lit_node = switch (kind) {
         .Ascii, .UTF8 => blk: {
-            const val = ZigClangCharacterLiteral_getValue(stmt);
+            const val = stmt.getValue();
             if (kind == .Ascii) {
                 // C has a somewhat obscure feature called multi-character character
                 // constant
 @@ -2942,7 +2934,7 @@ fn transCharLiteral(
         .UTF16, .UTF32, .Wide => return revertAndWarn(
             rp,
             error.UnsupportedTranslation,
-            ZigClangStmt_getBeginLoc(@ptrCast(*const ZigClangStmt, stmt)),
+            @ptrCast(*const clang.Stmt, stmt).getBeginLoc(),
             "TODO: support character literal kind {}",
             .{kind},
         ),
 @@ -2952,9 +2944,9 @@ fn transCharLiteral(
     }
     // See comment in `transIntegerLiteral` for why this code is here.
     // @as(T, x)
-    const expr_base = @ptrCast(*const ZigClangExpr, stmt);
+    const expr_base = @ptrCast(*const clang.Expr, stmt);
     const as_node = try rp.c.createBuiltinCall("@as", 2);
-    const ty_node = try transQualType(rp, ZigClangExpr_getType(expr_base), ZigClangExpr_getBeginLoc(expr_base));
+    const ty_node = try transQualType(rp, expr_base.getType(), expr_base.getBeginLoc());
     as_node.params()[0] = ty_node;
     _ = try appendToken(rp.c, .Comma, ",");
     as_node.params()[1] = int_lit_node;
 @@ -2963,8 +2955,8 @@ fn transCharLiteral(
     return maybeSuppressResult(rp, scope, result_used, &as_node.base);
 }
-fn transStmtExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangStmtExpr, used: ResultUsed) TransError!*ast.Node {
+fn transStmtExpr(rp: RestorePoint, scope: *Scope, stmt: *const clang.StmtExpr, used: ResultUsed) TransError!*ast.Node {
-    const comp = ZigClangStmtExpr_getSubStmt(stmt);
+    const comp = stmt.getSubStmt();
     if (used == .unused) {
         return transCompoundStmt(rp, scope, comp);
     }
 @@ -2972,8 +2964,8 @@ fn transStmtExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangStmtExpr,
     var block_scope = try Scope.Block.init(rp.c, scope, true);
     defer block_scope.deinit();
-    var it = ZigClangCompoundStmt_body_begin(comp);
+    var it = comp.body_begin();
-    const end_it = ZigClangCompoundStmt_body_end(comp);
+    const end_it = comp.body_end();
     while (it != end_it - 1) : (it += 1) {
         const result = try transStmt(rp, &block_scope.base, it[0], .unused, .r_value);
         try block_scope.statements.append(result);
 @@ -2996,43 +2988,43 @@ fn transStmtExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangStmtExpr,
     return maybeSuppressResult(rp, scope, used, &grouped_expr.base);
 }
-fn transMemberExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangMemberExpr, result_used: ResultUsed) TransError!*ast.Node {
+fn transMemberExpr(rp: RestorePoint, scope: *Scope, stmt: *const clang.MemberExpr, result_used: ResultUsed) TransError!*ast.Node {
-    var container_node = try transExpr(rp, scope, ZigClangMemberExpr_getBase(stmt), .used, .r_value);
+    var container_node = try transExpr(rp, scope, stmt.getBase(), .used, .r_value);
-    if (ZigClangMemberExpr_isArrow(stmt)) {
+    if (stmt.isArrow()) {
         container_node = try transCreateNodePtrDeref(rp.c, container_node);
     }
-    const member_decl = ZigClangMemberExpr_getMemberDecl(stmt);
+    const member_decl = stmt.getMemberDecl();
     const name = blk: {
-        const decl_kind = ZigClangDecl_getKind(@ptrCast(*const ZigClangDecl, member_decl));
+        const decl_kind = @ptrCast(*const clang.Decl, member_decl).getKind();
         // If we're referring to a anonymous struct/enum find the bogus name
         // we've assigned to it during the RecordDecl translation
         if (decl_kind == .Field) {
-            const field_decl = @ptrCast(*const struct_ZigClangFieldDecl, member_decl);
+            const field_decl = @ptrCast(*const clang.FieldDecl, member_decl);
-            if (ZigClangFieldDecl_isAnonymousStructOrUnion(field_decl)) {
+            if (field_decl.isAnonymousStructOrUnion()) {
-                const name = rp.c.decl_table.get(@ptrToInt(ZigClangFieldDecl_getCanonicalDecl(field_decl))).?;
+                const name = rp.c.decl_table.get(@ptrToInt(field_decl.getCanonicalDecl())).?;
                 break :blk try mem.dupe(rp.c.arena, u8, name);
             }
         }
-        const decl = @ptrCast(*const ZigClangNamedDecl, member_decl);
+        const decl = @ptrCast(*const clang.NamedDecl, member_decl);
-        break :blk try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(decl));
+        break :blk try rp.c.str(decl.getName_bytes_begin());
     };
     const node = try transCreateNodeFieldAccess(rp.c, container_node, name);
     return maybeSuppressResult(rp, scope, result_used, node);
 }
-fn transArrayAccess(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangArraySubscriptExpr, result_used: ResultUsed) TransError!*ast.Node {
+fn transArrayAccess(rp: RestorePoint, scope: *Scope, stmt: *const clang.ArraySubscriptExpr, result_used: ResultUsed) TransError!*ast.Node {
-    var base_stmt = ZigClangArraySubscriptExpr_getBase(stmt);
+    var base_stmt = stmt.getBase();
     // Unwrap the base statement if it's an array decayed to a bare pointer type
     // so that we index the array itself
-    if (ZigClangStmt_getStmtClass(@ptrCast(*const ZigClangStmt, base_stmt)) == .ImplicitCastExprClass) {
+    if (@ptrCast(*const clang.Stmt, base_stmt).getStmtClass() == .ImplicitCastExprClass) {
-        const implicit_cast = @ptrCast(*const ZigClangImplicitCastExpr, base_stmt);
+        const implicit_cast = @ptrCast(*const clang.ImplicitCastExpr, base_stmt);
-        if (ZigClangImplicitCastExpr_getCastKind(implicit_cast) == .ArrayToPointerDecay) {
+        if (implicit_cast.getCastKind() == .ArrayToPointerDecay) {
-            base_stmt = ZigClangImplicitCastExpr_getSubExpr(implicit_cast);
+            base_stmt = implicit_cast.getSubExpr();
         }
     }
 @@ -3040,7 +3032,7 @@ fn transArrayAccess(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangArrayS
     const node = try transCreateNodeArrayAccess(rp.c, container_node);
     // cast if the index is long long or signed
-    const subscr_expr = ZigClangArraySubscriptExpr_getIdx(stmt);
+    const subscr_expr = stmt.getIdx();
     const qt = getExprQualType(rp.c, subscr_expr);
     const is_longlong = cIsLongLongInteger(qt);
     const is_signed = cIsSignedInteger(qt);
 @@ -3062,23 +3054,23 @@ fn transArrayAccess(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangArrayS
     return maybeSuppressResult(rp, scope, result_used, &node.base);
 }
-fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCallExpr, result_used: ResultUsed) TransError!*ast.Node {
+fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const clang.CallExpr, result_used: ResultUsed) TransError!*ast.Node {
-    const callee = ZigClangCallExpr_getCallee(stmt);
+    const callee = stmt.getCallee();
     var raw_fn_expr = try transExpr(rp, scope, callee, .used, .r_value);
     var is_ptr = false;
-    const fn_ty = qualTypeGetFnProto(ZigClangExpr_getType(callee), &is_ptr);
+    const fn_ty = qualTypeGetFnProto(callee.getType(), &is_ptr);
     const fn_expr = if (is_ptr and fn_ty != null) blk: {
-        if (ZigClangExpr_getStmtClass(callee) == .ImplicitCastExprClass) {
+        if (callee.getStmtClass() == .ImplicitCastExprClass) {
-            const implicit_cast = @ptrCast(*const ZigClangImplicitCastExpr, callee);
+            const implicit_cast = @ptrCast(*const clang.ImplicitCastExpr, callee);
-            if (ZigClangImplicitCastExpr_getCastKind(implicit_cast) == .FunctionToPointerDecay) {
+            if (implicit_cast.getCastKind() == .FunctionToPointerDecay) {
-                const subexpr = ZigClangImplicitCastExpr_getSubExpr(implicit_cast);
+                const subexpr = implicit_cast.getSubExpr();
-                if (ZigClangExpr_getStmtClass(subexpr) == .DeclRefExprClass) {
+                if (subexpr.getStmtClass() == .DeclRefExprClass) {
-                    const decl_ref = @ptrCast(*const ZigClangDeclRefExpr, subexpr);
+                    const decl_ref = @ptrCast(*const clang.DeclRefExpr, subexpr);
-                    const named_decl = ZigClangDeclRefExpr_getFoundDecl(decl_ref);
+                    const named_decl = decl_ref.getFoundDecl();
-                    if (ZigClangDecl_getKind(@ptrCast(*const ZigClangDecl, named_decl)) == .Function) {
+                    if (@ptrCast(*const clang.Decl, named_decl).getKind() == .Function) {
                         break :blk raw_fn_expr;
                     }
                 }
 @@ -3088,11 +3080,11 @@ fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCallExpr,
     } else
         raw_fn_expr;
-    const num_args = ZigClangCallExpr_getNumArgs(stmt);
+    const num_args = stmt.getNumArgs();
     const node = try rp.c.createCall(fn_expr, num_args);
     const call_params = node.params();
-    const args = ZigClangCallExpr_getArgs(stmt);
+    const args = stmt.getArgs();
     var i: usize = 0;
     while (i < num_args) : (i += 1) {
         if (i != 0) {
 @@ -3103,9 +3095,9 @@ fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCallExpr,
     node.rtoken = try appendToken(rp.c, .RParen, ")");
     if (fn_ty) |ty| {
-        const canon = ZigClangQualType_getCanonicalType(ty.getReturnType());
+        const canon = ty.getReturnType().getCanonicalType();
-        const ret_ty = ZigClangQualType_getTypePtr(canon);
+        const ret_ty = canon.getTypePtr();
-        if (ZigClangType_isVoidType(ret_ty)) {
+        if (ret_ty.isVoidType()) {
             _ = try appendToken(rp.c, .Semicolon, ";");
             return &node.base;
         }
 @@ -3115,32 +3107,32 @@ fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCallExpr,
 }
 const ClangFunctionType = union(enum) {
-    Proto: *const ZigClangFunctionProtoType,
+    Proto: *const clang.FunctionProtoType,
-    NoProto: *const ZigClangFunctionType,
+    NoProto: *const clang.FunctionType,
-    fn getReturnType(self: @This()) ZigClangQualType {
+    fn getReturnType(self: @This()) clang.QualType {
         switch (@as(@TagType(@This()), self)) {
-            .Proto => return ZigClangFunctionProtoType_getReturnType(self.Proto),
+            .Proto => return self.Proto.getReturnType(),
-            .NoProto => return ZigClangFunctionType_getReturnType(self.NoProto),
+            .NoProto => return self.NoProto.getReturnType(),
         }
     }
 };
-fn qualTypeGetFnProto(qt: ZigClangQualType, is_ptr: *bool) ?ClangFunctionType {
+fn qualTypeGetFnProto(qt: clang.QualType, is_ptr: *bool) ?ClangFunctionType {
-    const canon = ZigClangQualType_getCanonicalType(qt);
+    const canon = qt.getCanonicalType();
-    var ty = ZigClangQualType_getTypePtr(canon);
+    var ty = canon.getTypePtr();
     is_ptr.* = false;
-    if (ZigClangType_getTypeClass(ty) == .Pointer) {
+    if (ty.getTypeClass() == .Pointer) {
         is_ptr.* = true;
-        const child_qt = ZigClangType_getPointeeType(ty);
+        const child_qt = ty.getPointeeType();
-        ty = ZigClangQualType_getTypePtr(child_qt);
+        ty = child_qt.getTypePtr();
     }
-    if (ZigClangType_getTypeClass(ty) == .FunctionProto) {
+    if (ty.getTypeClass() == .FunctionProto) {
-        return ClangFunctionType{ .Proto = @ptrCast(*const ZigClangFunctionProtoType, ty) };
+        return ClangFunctionType{ .Proto = @ptrCast(*const clang.FunctionProtoType, ty) };
     }
-    if (ZigClangType_getTypeClass(ty) == .FunctionNoProto) {
+    if (ty.getTypeClass() == .FunctionNoProto) {
-        return ClangFunctionType{ .NoProto = @ptrCast(*const ZigClangFunctionType, ty) };
+        return ClangFunctionType{ .NoProto = @ptrCast(*const clang.FunctionType, ty) };
     }
     return null;
 }
 @@ -3148,17 +3140,17 @@ fn qualTypeGetFnProto(qt: ZigClangQualType, is_ptr: *bool) ?ClangFunctionType {
 fn transUnaryExprOrTypeTraitExpr(
     rp: RestorePoint,
     scope: *Scope,
-    stmt: *const ZigClangUnaryExprOrTypeTraitExpr,
+    stmt: *const clang.UnaryExprOrTypeTraitExpr,
     result_used: ResultUsed,
 ) TransError!*ast.Node {
-    const loc = ZigClangUnaryExprOrTypeTraitExpr_getBeginLoc(stmt);
+    const loc = stmt.getBeginLoc();
     const type_node = try transQualType(
         rp,
-        ZigClangUnaryExprOrTypeTraitExpr_getTypeOfArgument(stmt),
+        stmt.getTypeOfArgument(),
         loc,
     );
-    const kind = ZigClangUnaryExprOrTypeTraitExpr_getKind(stmt);
+    const kind = stmt.getKind();
     const kind_str = switch (kind) {
         .SizeOf => "@sizeOf",
         .AlignOf => "@alignOf",
 @@ -3180,7 +3172,7 @@ fn transUnaryExprOrTypeTraitExpr(
     return maybeSuppressResult(rp, scope, result_used, &builtin_node.base);
 }
-fn qualTypeHasWrappingOverflow(qt: ZigClangQualType) bool {
+fn qualTypeHasWrappingOverflow(qt: clang.QualType) bool {
     if (cIsUnsignedInteger(qt)) {
         // unsigned integer overflow wraps around.
         return true;
 @@ -3190,22 +3182,22 @@ fn qualTypeHasWrappingOverflow(qt: ZigClangQualType) bool {
     }
 }
-fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangUnaryOperator, used: ResultUsed) TransError!*ast.Node {
+fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.UnaryOperator, used: ResultUsed) TransError!*ast.Node {
-    const op_expr = ZigClangUnaryOperator_getSubExpr(stmt);
+    const op_expr = stmt.getSubExpr();
-    switch (ZigClangUnaryOperator_getOpcode(stmt)) {
+    switch (stmt.getOpcode()) {
-        .PostInc => if (qualTypeHasWrappingOverflow(ZigClangUnaryOperator_getType(stmt)))
+        .PostInc => if (qualTypeHasWrappingOverflow(stmt.getType()))
             return transCreatePostCrement(rp, scope, stmt, .AssignAddWrap, .PlusPercentEqual, "+%=", used)
         else
             return transCreatePostCrement(rp, scope, stmt, .AssignAdd, .PlusEqual, "+=", used),
-        .PostDec => if (qualTypeHasWrappingOverflow(ZigClangUnaryOperator_getType(stmt)))
+        .PostDec => if (qualTypeHasWrappingOverflow(stmt.getType()))
             return transCreatePostCrement(rp, scope, stmt, .AssignSubWrap, .MinusPercentEqual, "-%=", used)
         else
             return transCreatePostCrement(rp, scope, stmt, .AssignSub, .MinusEqual, "-=", used),
-        .PreInc => if (qualTypeHasWrappingOverflow(ZigClangUnaryOperator_getType(stmt)))
+        .PreInc => if (qualTypeHasWrappingOverflow(stmt.getType()))
             return transCreatePreCrement(rp, scope, stmt, .AssignAddWrap, .PlusPercentEqual, "+%=", used)
         else
             return transCreatePreCrement(rp, scope, stmt, .AssignAdd, .PlusEqual, "+=", used),
-        .PreDec => if (qualTypeHasWrappingOverflow(ZigClangUnaryOperator_getType(stmt)))
+        .PreDec => if (qualTypeHasWrappingOverflow(stmt.getType()))
             return transCreatePreCrement(rp, scope, stmt, .AssignSubWrap, .MinusPercentEqual, "-%=", used)
         else
             return transCreatePreCrement(rp, scope, stmt, .AssignSub, .MinusEqual, "-=", used),
 @@ -3217,7 +3209,7 @@ fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangUnar
         .Deref => {
             const value_node = try transExpr(rp, scope, op_expr, used, .r_value);
             var is_ptr = false;
-            const fn_ty = qualTypeGetFnProto(ZigClangExpr_getType(op_expr), &is_ptr);
+            const fn_ty = qualTypeGetFnProto(op_expr.getType(), &is_ptr);
             if (fn_ty != null and is_ptr)
                 return value_node;
             const unwrapped = try transCreateNodeUnwrapNull(rp.c, value_node);
 @@ -3225,18 +3217,18 @@ fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangUnar
         },
         .Plus => return transExpr(rp, scope, op_expr, used, .r_value),
         .Minus => {
-            if (!qualTypeHasWrappingOverflow(ZigClangExpr_getType(op_expr))) {
+            if (!qualTypeHasWrappingOverflow(op_expr.getType())) {
                 const op_node = try transCreateNodeSimplePrefixOp(rp.c, .Negation, .Minus, "-");
                 op_node.rhs = try transExpr(rp, scope, op_expr, .used, .r_value);
                 return &op_node.base;
-            } else if (cIsUnsignedInteger(ZigClangExpr_getType(op_expr))) {
+            } else if (cIsUnsignedInteger(op_expr.getType())) {
                 // we gotta emit 0 -% x
                 const zero = try transCreateNodeInt(rp.c, 0);
                 const token = try appendToken(rp.c, .MinusPercent, "-%");
                 const expr = try transExpr(rp, scope, op_expr, .used, .r_value);
                 return transCreateNodeInfixOp(rp, scope, zero, .SubWrap, token, expr, used, true);
             } else
-                return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangUnaryOperator_getBeginLoc(stmt), "C negation with non float non integer", .{});
+                return revertAndWarn(rp, error.UnsupportedTranslation, stmt.getBeginLoc(), "C negation with non float non integer", .{});
         },
         .Not => {
             const op_node = try transCreateNodeSimplePrefixOp(rp.c, .BitNot, .Tilde, "~");
 @@ -3249,22 +3241,22 @@ fn transUnaryOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangUnar
             return &op_node.base;
         },
         .Extension => {
-            return transExpr(rp, scope, ZigClangUnaryOperator_getSubExpr(stmt), used, .l_value);
+            return transExpr(rp, scope, stmt.getSubExpr(), used, .l_value);
         },
-        else => return revertAndWarn(rp, error.UnsupportedTranslation, ZigClangUnaryOperator_getBeginLoc(stmt), "unsupported C translation {}", .{ZigClangUnaryOperator_getOpcode(stmt)}),
+        else => return revertAndWarn(rp, error.UnsupportedTranslation, stmt.getBeginLoc(), "unsupported C translation {}", .{stmt.getOpcode()}),
     }
 }
 fn transCreatePreCrement(
     rp: RestorePoint,
     scope: *Scope,
-    stmt: *const ZigClangUnaryOperator,
+    stmt: *const clang.UnaryOperator,
     op: ast.Node.Tag,
     op_tok_id: std.zig.Token.Id,
     bytes: []const u8,
     used: ResultUsed,
 ) TransError!*ast.Node {
-    const op_expr = ZigClangUnaryOperator_getSubExpr(stmt);
+    const op_expr = stmt.getSubExpr();
     if (used == .unused) {
         // common case
 @@ -3331,13 +3323,13 @@ fn transCreatePreCrement(
 fn transCreatePostCrement(
     rp: RestorePoint,
     scope: *Scope,
-    stmt: *const ZigClangUnaryOperator,
+    stmt: *const clang.UnaryOperator,
     op: ast.Node.Tag,
     op_tok_id: std.zig.Token.Id,
     bytes: []const u8,
     used: ResultUsed,
 ) TransError!*ast.Node {
-    const op_expr = ZigClangUnaryOperator_getSubExpr(stmt);
+    const op_expr = stmt.getSubExpr();
     if (used == .unused) {
         // common case
 @@ -3422,17 +3414,17 @@ fn transCreatePostCrement(
     return &grouped_expr.base;
 }
-fn transCompoundAssignOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCompoundAssignOperator, used: ResultUsed) TransError!*ast.Node {
+fn transCompoundAssignOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.CompoundAssignOperator, used: ResultUsed) TransError!*ast.Node {
-    switch (ZigClangCompoundAssignOperator_getOpcode(stmt)) {
+    switch (stmt.getOpcode()) {
-        .MulAssign => if (qualTypeHasWrappingOverflow(ZigClangCompoundAssignOperator_getType(stmt)))
+        .MulAssign => if (qualTypeHasWrappingOverflow(stmt.getType()))
             return transCreateCompoundAssign(rp, scope, stmt, .AssignMulWrap, .AsteriskPercentEqual, "*%=", .MulWrap, .AsteriskPercent, "*%", used)
         else
             return transCreateCompoundAssign(rp, scope, stmt, .AssignMul, .AsteriskEqual, "*=", .Mul, .Asterisk, "*", used),
-        .AddAssign => if (qualTypeHasWrappingOverflow(ZigClangCompoundAssignOperator_getType(stmt)))
+        .AddAssign => if (qualTypeHasWrappingOverflow(stmt.getType()))
             return transCreateCompoundAssign(rp, scope, stmt, .AssignAddWrap, .PlusPercentEqual, "+%=", .AddWrap, .PlusPercent, "+%", used)
         else
             return transCreateCompoundAssign(rp, scope, stmt, .AssignAdd, .PlusEqual, "+=", .Add, .Plus, "+", used),
-        .SubAssign => if (qualTypeHasWrappingOverflow(ZigClangCompoundAssignOperator_getType(stmt)))
+        .SubAssign => if (qualTypeHasWrappingOverflow(stmt.getType()))
             return transCreateCompoundAssign(rp, scope, stmt, .AssignSubWrap, .MinusPercentEqual, "-%=", .SubWrap, .MinusPercent, "-%", used)
         else
             return transCreateCompoundAssign(rp, scope, stmt, .AssignSub, .MinusPercentEqual, "-=", .Sub, .Minus, "-", used),
 @@ -3446,9 +3438,9 @@ fn transCompoundAssignOperator(rp: RestorePoint, scope: *Scope, stmt: *const Zig
         else => return revertAndWarn(
             rp,
             error.UnsupportedTranslation,
-            ZigClangCompoundAssignOperator_getBeginLoc(stmt),
+            stmt.getBeginLoc(),
             "unsupported C translation {}",
-            .{ZigClangCompoundAssignOperator_getOpcode(stmt)},
+            .{stmt.getOpcode()},
         ),
     }
 }
 @@ -3456,7 +3448,7 @@ fn transCompoundAssignOperator(rp: RestorePoint, scope: *Scope, stmt: *const Zig
 fn transCreateCompoundAssign(
     rp: RestorePoint,
     scope: *Scope,
-    stmt: *const ZigClangCompoundAssignOperator,
+    stmt: *const clang.CompoundAssignOperator,
     assign_op: ast.Node.Tag,
     assign_tok_id: std.zig.Token.Id,
     assign_bytes: []const u8,
 @@ -3468,9 +3460,9 @@ fn transCreateCompoundAssign(
     const is_shift = bin_op == .BitShiftLeft or bin_op == .BitShiftRight;
     const is_div = bin_op == .Div;
     const is_mod = bin_op == .Mod;
-    const lhs = ZigClangCompoundAssignOperator_getLHS(stmt);
+    const lhs = stmt.getLHS();
-    const rhs = ZigClangCompoundAssignOperator_getRHS(stmt);
+    const rhs = stmt.getRHS();
-    const loc = ZigClangCompoundAssignOperator_getBeginLoc(stmt);
+    const loc = stmt.getBeginLoc();
     const lhs_qt = getExprQualType(rp.c, lhs);
     const rhs_qt = getExprQualType(rp.c, rhs);
     const is_signed = cIsSignedInteger(lhs_qt);
 @@ -3615,20 +3607,20 @@ fn transCreateCompoundAssign(
 fn transCPtrCast(
     rp: RestorePoint,
-    loc: ZigClangSourceLocation,
+    loc: clang.SourceLocation,
-    dst_type: ZigClangQualType,
+    dst_type: clang.QualType,
-    src_type: ZigClangQualType,
+    src_type: clang.QualType,
     expr: *ast.Node,
 ) !*ast.Node {
-    const ty = ZigClangQualType_getTypePtr(dst_type);
+    const ty = dst_type.getTypePtr();
-    const child_type = ZigClangType_getPointeeType(ty);
+    const child_type = ty.getPointeeType();
-    const src_ty = ZigClangQualType_getTypePtr(src_type);
+    const src_ty = src_type.getTypePtr();
-    const src_child_type = ZigClangType_getPointeeType(src_ty);
+    const src_child_type = src_ty.getPointeeType();
-    if ((ZigClangQualType_isConstQualified(src_child_type) and
+    if ((src_child_type.isConstQualified() and
-        !ZigClangQualType_isConstQualified(child_type)) or
+        !child_type.isConstQualified()) or
-        (ZigClangQualType_isVolatileQualified(src_child_type) and
+        (src_child_type.isVolatileQualified() and
-        !ZigClangQualType_isVolatileQualified(child_type)))
+        !child_type.isVolatileQualified()))
     {
         // Casting away const or volatile requires us to use @intToPtr
         const inttoptr_node = try rp.c.createBuiltinCall("@intToPtr", 2);
 @@ -3651,7 +3643,7 @@ fn transCPtrCast(
         ptrcast_node.params()[0] = dst_type_node;
         _ = try appendToken(rp.c, .Comma, ",");
-        if (ZigClangType_isVoidType(qualTypeCanon(child_type))) {
+        if (qualTypeCanon(child_type).isVoidType()) {
             // void has 1-byte alignment, so @alignCast is not needed
             ptrcast_node.params()[1] = expr;
         } else if (typeIsOpaque(rp.c, qualTypeCanon(child_type), loc)) {
 @@ -3691,9 +3683,9 @@ fn transBreak(rp: RestorePoint, scope: *Scope) TransError!*ast.Node {
     return &br.base;
 }
-fn transFloatingLiteral(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangFloatingLiteral, used: ResultUsed) TransError!*ast.Node {
+fn transFloatingLiteral(rp: RestorePoint, scope: *Scope, stmt: *const clang.FloatingLiteral, used: ResultUsed) TransError!*ast.Node {
     // TODO use something more accurate
-    const dbl = ZigClangAPFloat_getValueAsApproximateDouble(stmt);
+    const dbl = stmt.getValueAsApproximateDouble();
     const node = try rp.c.arena.create(ast.Node.OneToken);
     node.* = .{
         .base = .{ .tag = .FloatLiteral },
 @@ -3702,13 +3694,13 @@ fn transFloatingLiteral(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangFl
     return maybeSuppressResult(rp, scope, used, &node.base);
 }
-fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangBinaryConditionalOperator, used: ResultUsed) TransError!*ast.Node {
+fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.BinaryConditionalOperator, used: ResultUsed) TransError!*ast.Node {
     // GNU extension of the ternary operator where the middle expression is
     // omitted, the conditition itself is returned if it evaluates to true
-    const casted_stmt = @ptrCast(*const ZigClangAbstractConditionalOperator, stmt);
+    const casted_stmt = @ptrCast(*const clang.AbstractConditionalOperator, stmt);
-    const cond_expr = ZigClangAbstractConditionalOperator_getCond(casted_stmt);
+    const cond_expr = casted_stmt.getCond();
-    const true_expr = ZigClangAbstractConditionalOperator_getTrueExpr(casted_stmt);
+    const true_expr = casted_stmt.getTrueExpr();
-    const false_expr = ZigClangAbstractConditionalOperator_getFalseExpr(casted_stmt);
+    const false_expr = casted_stmt.getFalseExpr();
     // c:   (cond_expr)?:(false_expr)
     // zig: (blk: {
 @@ -3748,8 +3740,8 @@ fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const
     defer cond_scope.deinit();
     const tmp_var_node = try transCreateNodeIdentifier(rp.c, mangled_name);
-    const ty = ZigClangQualType_getTypePtr(getExprQualType(rp.c, cond_expr));
+    const ty = getExprQualType(rp.c, cond_expr).getTypePtr();
-    const cond_node = try finishBoolExpr(rp, &cond_scope.base, ZigClangExpr_getBeginLoc(cond_expr), ty, tmp_var_node, used);
+    const cond_node = try finishBoolExpr(rp, &cond_scope.base, cond_expr.getBeginLoc(), ty, tmp_var_node, used);
     if_node.condition = cond_node;
     _ = try appendToken(rp.c, .RParen, ")");
 @@ -3772,7 +3764,7 @@ fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const
     return maybeSuppressResult(rp, scope, used, &grouped_expr.base);
 }
-fn transConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangConditionalOperator, used: ResultUsed) TransError!*ast.Node {
+fn transConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const clang.ConditionalOperator, used: ResultUsed) TransError!*ast.Node {
     const grouped = scope.id == .Condition;
     const lparen = if (grouped) try appendToken(rp.c, .LParen, "(") else undefined;
     const if_node = try transCreateNodeIf(rp.c);
 @@ -3784,10 +3776,10 @@ fn transConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const ZigCla
     };
     defer cond_scope.deinit();
-    const casted_stmt = @ptrCast(*const ZigClangAbstractConditionalOperator, stmt);
+    const casted_stmt = @ptrCast(*const clang.AbstractConditionalOperator, stmt);
-    const cond_expr = ZigClangAbstractConditionalOperator_getCond(casted_stmt);
+    const cond_expr = casted_stmt.getCond();
-    const true_expr = ZigClangAbstractConditionalOperator_getTrueExpr(casted_stmt);
+    const true_expr = casted_stmt.getTrueExpr();
-    const false_expr = ZigClangAbstractConditionalOperator_getFalseExpr(casted_stmt);
+    const false_expr = casted_stmt.getFalseExpr();
     if_node.condition = try transBoolExpr(rp, &cond_scope.base, cond_expr, .used, .r_value, false);
     _ = try appendToken(rp.c, .RParen, ")");
 @@ -3845,22 +3837,22 @@ fn addTopLevelDecl(c: *Context, name: []const u8, decl_node: *ast.Node) !void {
     _ = try c.global_scope.sym_table.put(name, decl_node);
 }
-fn transQualType(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigClangSourceLocation) TypeError!*ast.Node {
+fn transQualType(rp: RestorePoint, qt: clang.QualType, source_loc: clang.SourceLocation) TypeError!*ast.Node {
-    return transType(rp, ZigClangQualType_getTypePtr(qt), source_loc);
+    return transType(rp, qt.getTypePtr(), source_loc);
 }
 /// Produces a Zig AST node by translating a Clang QualType, respecting the width, but modifying the signed-ness.
 /// Asserts the type is an integer.
-fn transQualTypeIntWidthOf(c: *Context, ty: ZigClangQualType, is_signed: bool) TypeError!*ast.Node {
+fn transQualTypeIntWidthOf(c: *Context, ty: clang.QualType, is_signed: bool) TypeError!*ast.Node {
     return transTypeIntWidthOf(c, qualTypeCanon(ty), is_signed);
 }
 /// Produces a Zig AST node by translating a Clang Type, respecting the width, but modifying the signed-ness.
 /// Asserts the type is an integer.
-fn transTypeIntWidthOf(c: *Context, ty: *const ZigClangType, is_signed: bool) TypeError!*ast.Node {
+fn transTypeIntWidthOf(c: *Context, ty: *const clang.Type, is_signed: bool) TypeError!*ast.Node {
-    assert(ZigClangType_getTypeClass(ty) == .Builtin);
+    assert(ty.getTypeClass() == .Builtin);
-    const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty);
+    const builtin_ty = @ptrCast(*const clang.BuiltinType, ty);
-    return transCreateNodeIdentifier(c, switch (ZigClangBuiltinType_getKind(builtin_ty)) {
+    return transCreateNodeIdentifier(c, switch (builtin_ty.getKind()) {
         .Char_U, .Char_S, .UChar, .SChar, .Char8 => if (is_signed) "i8" else "u8",
         .UShort, .Short => if (is_signed) "c_short" else "c_ushort",
         .UInt, .Int => if (is_signed) "c_int" else "c_uint",
 @@ -3873,30 +3865,30 @@ fn transTypeIntWidthOf(c: *Context, ty: *const ZigClangType, is_signed: bool) Ty
     });
 }
-fn isCBuiltinType(qt: ZigClangQualType, kind: ZigClangBuiltinTypeKind) bool {
+fn isCBuiltinType(qt: clang.QualType, kind: clang.BuiltinTypeKind) bool {
     const c_type = qualTypeCanon(qt);
-    if (ZigClangType_getTypeClass(c_type) != .Builtin)
+    if (c_type.getTypeClass() != .Builtin)
         return false;
-    const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type);
+    const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type);
-    return ZigClangBuiltinType_getKind(builtin_ty) == kind;
+    return builtin_ty.getKind() == kind;
 }
-fn qualTypeIsPtr(qt: ZigClangQualType) bool {
+fn qualTypeIsPtr(qt: clang.QualType) bool {
-    return ZigClangType_getTypeClass(qualTypeCanon(qt)) == .Pointer;
+    return qualTypeCanon(qt).getTypeClass() == .Pointer;
 }
-fn qualTypeIsBoolean(qt: ZigClangQualType) bool {
+fn qualTypeIsBoolean(qt: clang.QualType) bool {
-    return ZigClangType_isBooleanType(qualTypeCanon(qt));
+    return qualTypeCanon(qt).isBooleanType();
 }
-fn qualTypeIntBitWidth(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigClangSourceLocation) !u32 {
+fn qualTypeIntBitWidth(rp: RestorePoint, qt: clang.QualType, source_loc: clang.SourceLocation) !u32 {
-    const ty = ZigClangQualType_getTypePtr(qt);
+    const ty = qt.getTypePtr();
-    switch (ZigClangType_getTypeClass(ty)) {
+    switch (ty.getTypeClass()) {
         .Builtin => {
-            const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty);
+            const builtin_ty = @ptrCast(*const clang.BuiltinType, ty);
-            switch (ZigClangBuiltinType_getKind(builtin_ty)) {
+            switch (builtin_ty.getKind()) {
                 .Char_U,
                 .UChar,
                 .Char_S,
 @@ -3911,9 +3903,9 @@ fn qualTypeIntBitWidth(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigCl
             unreachable;
         },
         .Typedef => {
-            const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty);
+            const typedef_ty = @ptrCast(*const clang.TypedefType, ty);
-            const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty);
+            const typedef_decl = typedef_ty.getDecl();
-            const type_name = try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, typedef_decl)));
+            const type_name = try rp.c.str(@ptrCast(*const clang.NamedDecl, typedef_decl).getName_bytes_begin());
             if (mem.eql(u8, type_name, "uint8_t") or mem.eql(u8, type_name, "int8_t")) {
                 return 8;
 @@ -3933,7 +3925,7 @@ fn qualTypeIntBitWidth(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigCl
     unreachable;
 }
-fn qualTypeToLog2IntRef(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigClangSourceLocation) !*ast.Node {
+fn qualTypeToLog2IntRef(rp: RestorePoint, qt: clang.QualType, source_loc: clang.SourceLocation) !*ast.Node {
     const int_bit_width = try qualTypeIntBitWidth(rp, qt, source_loc);
     if (int_bit_width != 0) {
 @@ -3980,83 +3972,83 @@ fn qualTypeToLog2IntRef(rp: RestorePoint, qt: ZigClangQualType, source_loc: ZigC
     return &log2int_fn_call.base;
 }
-fn qualTypeChildIsFnProto(qt: ZigClangQualType) bool {
+fn qualTypeChildIsFnProto(qt: clang.QualType) bool {
     const ty = qualTypeCanon(qt);
-    switch (ZigClangType_getTypeClass(ty)) {
+    switch (ty.getTypeClass()) {
         .FunctionProto, .FunctionNoProto => return true,
         else => return false,
     }
 }
-fn qualTypeCanon(qt: ZigClangQualType) *const ZigClangType {
+fn qualTypeCanon(qt: clang.QualType) *const clang.Type {
-    const canon = ZigClangQualType_getCanonicalType(qt);
+    const canon = qt.getCanonicalType();
-    return ZigClangQualType_getTypePtr(canon);
+    return canon.getTypePtr();
 }
-fn getExprQualType(c: *Context, expr: *const ZigClangExpr) ZigClangQualType {
+fn getExprQualType(c: *Context, expr: *const clang.Expr) clang.QualType {
     blk: {
         // If this is a C `char *`, turn it into a `const char *`
-        if (ZigClangExpr_getStmtClass(expr) != .ImplicitCastExprClass) break :blk;
+        if (expr.getStmtClass() != .ImplicitCastExprClass) break :blk;
-        const cast_expr = @ptrCast(*const ZigClangImplicitCastExpr, expr);
+        const cast_expr = @ptrCast(*const clang.ImplicitCastExpr, expr);
-        if (ZigClangImplicitCastExpr_getCastKind(cast_expr) != .ArrayToPointerDecay) break :blk;
+        if (cast_expr.getCastKind() != .ArrayToPointerDecay) break :blk;
-        const sub_expr = ZigClangImplicitCastExpr_getSubExpr(cast_expr);
+        const sub_expr = cast_expr.getSubExpr();
-        if (ZigClangExpr_getStmtClass(sub_expr) != .StringLiteralClass) break :blk;
+        if (sub_expr.getStmtClass() != .StringLiteralClass) break :blk;
-        const array_qt = ZigClangExpr_getType(sub_expr);
+        const array_qt = sub_expr.getType();
-        const array_type = @ptrCast(*const ZigClangArrayType, ZigClangQualType_getTypePtr(array_qt));
+        const array_type = @ptrCast(*const clang.ArrayType, array_qt.getTypePtr());
-        var pointee_qt = ZigClangArrayType_getElementType(array_type);
+        var pointee_qt = array_type.getElementType();
-        ZigClangQualType_addConst(&pointee_qt);
+        pointee_qt.addConst();
-        return ZigClangASTContext_getPointerType(c.clang_context, pointee_qt);
+        return c.clang_context.getPointerType(pointee_qt);
     }
-    return ZigClangExpr_getType(expr);
+    return expr.getType();
 }
-fn typeIsOpaque(c: *Context, ty: *const ZigClangType, loc: ZigClangSourceLocation) bool {
+fn typeIsOpaque(c: *Context, ty: *const clang.Type, loc: clang.SourceLocation) bool {
-    switch (ZigClangType_getTypeClass(ty)) {
+    switch (ty.getTypeClass()) {
         .Builtin => {
-            const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty);
+            const builtin_ty = @ptrCast(*const clang.BuiltinType, ty);
-            return ZigClangBuiltinType_getKind(builtin_ty) == .Void;
+            return builtin_ty.getKind() == .Void;
         },
         .Record => {
-            const record_ty = @ptrCast(*const ZigClangRecordType, ty);
+            const record_ty = @ptrCast(*const clang.RecordType, ty);
-            const record_decl = ZigClangRecordType_getDecl(record_ty);
+            const record_decl = record_ty.getDecl();
-            const record_def = ZigClangRecordDecl_getDefinition(record_decl) orelse
+            const record_def = record_decl.getDefinition() orelse
                 return true;
-            var it = ZigClangRecordDecl_field_begin(record_def);
+            var it = record_def.field_begin();
-            const end_it = ZigClangRecordDecl_field_end(record_def);
+            const end_it = record_def.field_end();
-            while (ZigClangRecordDecl_field_iterator_neq(it, end_it)) : (it = ZigClangRecordDecl_field_iterator_next(it)) {
+            while (it.neq(end_it)) : (it = it.next()) {
-                const field_decl = ZigClangRecordDecl_field_iterator_deref(it);
+                const field_decl = it.deref();
-                if (ZigClangFieldDecl_isBitField(field_decl)) {
+                if (field_decl.isBitField()) {
                     return true;
                 }
             }
             return false;
         },
         .Elaborated => {
-            const elaborated_ty = @ptrCast(*const ZigClangElaboratedType, ty);
+            const elaborated_ty = @ptrCast(*const clang.ElaboratedType, ty);
-            const qt = ZigClangElaboratedType_getNamedType(elaborated_ty);
+            const qt = elaborated_ty.getNamedType();
-            return typeIsOpaque(c, ZigClangQualType_getTypePtr(qt), loc);
+            return typeIsOpaque(c, qt.getTypePtr(), loc);
         },
         .Typedef => {
-            const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty);
+            const typedef_ty = @ptrCast(*const clang.TypedefType, ty);
-            const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty);
+            const typedef_decl = typedef_ty.getDecl();
-            const underlying_type = ZigClangTypedefNameDecl_getUnderlyingType(typedef_decl);
+            const underlying_type = typedef_decl.getUnderlyingType();
-            return typeIsOpaque(c, ZigClangQualType_getTypePtr(underlying_type), loc);
+            return typeIsOpaque(c, underlying_type.getTypePtr(), loc);
         },
         else => return false,
     }
 }
-fn cIsInteger(qt: ZigClangQualType) bool {
+fn cIsInteger(qt: clang.QualType) bool {
     return cIsSignedInteger(qt) or cIsUnsignedInteger(qt);
 }
-fn cIsUnsignedInteger(qt: ZigClangQualType) bool {
+fn cIsUnsignedInteger(qt: clang.QualType) bool {
     const c_type = qualTypeCanon(qt);
-    if (ZigClangType_getTypeClass(c_type) != .Builtin) return false;
+    if (c_type.getTypeClass() != .Builtin) return false;
-    const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type);
+    const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type);
-    return switch (ZigClangBuiltinType_getKind(builtin_ty)) {
+    return switch (builtin_ty.getKind()) {
         .Char_U,
         .UChar,
         .Char_S,
 @@ -4071,11 +4063,11 @@ fn cIsUnsignedInteger(qt: ZigClangQualType) bool {
     };
 }
-fn cIntTypeToIndex(qt: ZigClangQualType) u8 {
+fn cIntTypeToIndex(qt: clang.QualType) u8 {
     const c_type = qualTypeCanon(qt);
-    assert(ZigClangType_getTypeClass(c_type) == .Builtin);
+    assert(c_type.getTypeClass() == .Builtin);
-    const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type);
+    const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type);
-    return switch (ZigClangBuiltinType_getKind(builtin_ty)) {
+    return switch (builtin_ty.getKind()) {
         .Bool, .Char_U, .Char_S, .UChar, .SChar, .Char8 => 1,
         .WChar_U, .WChar_S => 2,
         .UShort, .Short, .Char16 => 3,
 @@ -4087,17 +4079,17 @@ fn cIntTypeToIndex(qt: ZigClangQualType) u8 {
     };
 }
-fn cIntTypeCmp(a: ZigClangQualType, b: ZigClangQualType) math.Order {
+fn cIntTypeCmp(a: clang.QualType, b: clang.QualType) math.Order {
     const a_index = cIntTypeToIndex(a);
     const b_index = cIntTypeToIndex(b);
     return math.order(a_index, b_index);
 }
-fn cIsSignedInteger(qt: ZigClangQualType) bool {
+fn cIsSignedInteger(qt: clang.QualType) bool {
     const c_type = qualTypeCanon(qt);
-    if (ZigClangType_getTypeClass(c_type) != .Builtin) return false;
+    if (c_type.getTypeClass() != .Builtin) return false;
-    const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type);
+    const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type);
-    return switch (ZigClangBuiltinType_getKind(builtin_ty)) {
+    return switch (builtin_ty.getKind()) {
         .SChar,
         .Short,
         .Int,
 @@ -4110,11 +4102,11 @@ fn cIsSignedInteger(qt: ZigClangQualType) bool {
     };
 }
-fn cIsFloating(qt: ZigClangQualType) bool {
+fn cIsFloating(qt: clang.QualType) bool {
     const c_type = qualTypeCanon(qt);
-    if (ZigClangType_getTypeClass(c_type) != .Builtin) return false;
+    if (c_type.getTypeClass() != .Builtin) return false;
-    const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type);
+    const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type);
-    return switch (ZigClangBuiltinType_getKind(builtin_ty)) {
+    return switch (builtin_ty.getKind()) {
         .Float,
         .Double,
         .Float128,
 @@ -4124,11 +4116,11 @@ fn cIsFloating(qt: ZigClangQualType) bool {
     };
 }
-fn cIsLongLongInteger(qt: ZigClangQualType) bool {
+fn cIsLongLongInteger(qt: clang.QualType) bool {
     const c_type = qualTypeCanon(qt);
-    if (ZigClangType_getTypeClass(c_type) != .Builtin) return false;
+    if (c_type.getTypeClass() != .Builtin) return false;
-    const builtin_ty = @ptrCast(*const ZigClangBuiltinType, c_type);
+    const builtin_ty = @ptrCast(*const clang.BuiltinType, c_type);
-    return switch (ZigClangBuiltinType_getKind(builtin_ty)) {
+    return switch (builtin_ty.getKind()) {
         .LongLong, .ULongLong, .Int128, .UInt128 => true,
         else => false,
     };
 @@ -4137,8 +4129,8 @@ fn transCreateNodeAssign(
     rp: RestorePoint,
     scope: *Scope,
     result_used: ResultUsed,
-    lhs: *const ZigClangExpr,
+    lhs: *const clang.Expr,
-    rhs: *const ZigClangExpr,
+    rhs: *const clang.Expr,
 ) !*ast.Node {
     // common case
     // c:   lhs = rhs
 @@ -4273,19 +4265,19 @@ fn transCreateNodeInfixOp(
 fn transCreateNodeBoolInfixOp(
     rp: RestorePoint,
     scope: *Scope,
-    stmt: *const ZigClangBinaryOperator,
+    stmt: *const clang.BinaryOperator,
     op: ast.Node.Tag,
     used: ResultUsed,
     grouped: bool,
 ) !*ast.Node {
     std.debug.assert(op == .BoolAnd or op == .BoolOr);
-    const lhs_hode = try transBoolExpr(rp, scope, ZigClangBinaryOperator_getLHS(stmt), .used, .l_value, true);
+    const lhs_hode = try transBoolExpr(rp, scope, stmt.getLHS(), .used, .l_value, true);
     const op_token = if (op == .BoolAnd)
         try appendToken(rp.c, .Keyword_and, "and")
     else
         try appendToken(rp.c, .Keyword_or, "or");
-    const rhs = try transBoolExpr(rp, scope, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value, true);
+    const rhs = try transBoolExpr(rp, scope, stmt.getRHS(), .used, .r_value, true);
     return transCreateNodeInfixOp(
         rp,
 @@ -4334,21 +4326,21 @@ fn transCreateNodePtrType(
     return node;
 }
-fn transCreateNodeAPInt(c: *Context, int: *const ZigClangAPSInt) !*ast.Node {
+fn transCreateNodeAPInt(c: *Context, int: *const clang.APSInt) !*ast.Node {
-    const num_limbs = math.cast(usize, ZigClangAPSInt_getNumWords(int)) catch |err| switch (err) {
+    const num_limbs = math.cast(usize, int.getNumWords()) catch |err| switch (err) {
         error.Overflow => return error.OutOfMemory,
     };
     var aps_int = int;
-    const is_negative = ZigClangAPSInt_isSigned(int) and ZigClangAPSInt_isNegative(int);
+    const is_negative = int.isSigned() and int.isNegative();
-    if (is_negative) aps_int = ZigClangAPSInt_negate(aps_int);
+    if (is_negative) aps_int = aps_int.negate();
     defer if (is_negative) {
-        ZigClangAPSInt_free(aps_int);
+        aps_int.free();
     };
     const limbs = try c.arena.alloc(math.big.Limb, num_limbs);
     defer c.arena.free(limbs);
-    const data = ZigClangAPSInt_getRawData(aps_int);
+    const data = aps_int.getRawData();
     switch (@sizeOf(math.big.Limb)) {
         8 => {
             var i: usize = 0;
 @@ -4438,10 +4430,18 @@ fn transCreateNodeFloat(c: *Context, int: anytype) !*ast.Node {
 }
 fn transCreateNodeOpaqueType(c: *Context) !*ast.Node {
-    const call_node = try c.createBuiltinCall("@Type", 1);
+    const container_tok = try appendToken(c, .Keyword_opaque, "opaque");
-    call_node.params()[0] = try transCreateNodeEnumLiteral(c, "Opaque");
+    const lbrace_token = try appendToken(c, .LBrace, "{");
-    call_node.rparen_token = try appendToken(c, .RParen, ")");
+    const container_node = try ast.Node.ContainerDecl.alloc(c.arena, 0);
-    return &call_node.base;
+    container_node.* = .{
+        .kind_token = container_tok,
+        .layout_token = null,
+        .lbrace_token = lbrace_token,
+        .rbrace_token = try appendToken(c, .RBrace, "}"),
+        .fields_and_decls_len = 0,
+        .init_arg_expr = .None,
+    };
+    return &container_node.base;
 }
 fn transCreateNodeMacroFn(c: *Context, name: []const u8, ref: *ast.Node, proto_alias: *ast.Node.FnProto) !*ast.Node {
 @@ -4689,23 +4689,23 @@ fn transCreateNodeSwitchElse(c: *Context) !*ast.Node {
 fn transCreateNodeShiftOp(
     rp: RestorePoint,
     scope: *Scope,
-    stmt: *const ZigClangBinaryOperator,
+    stmt: *const clang.BinaryOperator,
     op: ast.Node.Tag,
     op_tok_id: std.zig.Token.Id,
     bytes: []const u8,
 ) !*ast.Node {
     std.debug.assert(op == .BitShiftLeft or op == .BitShiftRight);
-    const lhs_expr = ZigClangBinaryOperator_getLHS(stmt);
+    const lhs_expr = stmt.getLHS();
-    const rhs_expr = ZigClangBinaryOperator_getRHS(stmt);
+    const rhs_expr = stmt.getRHS();
-    const rhs_location = ZigClangExpr_getBeginLoc(rhs_expr);
+    const rhs_location = rhs_expr.getBeginLoc();
     // lhs >> @as(u5, rh)
     const lhs = try transExpr(rp, scope, lhs_expr, .used, .l_value);
     const op_token = try appendToken(rp.c, op_tok_id, bytes);
     const cast_node = try rp.c.createBuiltinCall("@intCast", 2);
-    const rhs_type = try qualTypeToLog2IntRef(rp, ZigClangBinaryOperator_getType(stmt), rhs_location);
+    const rhs_type = try qualTypeToLog2IntRef(rp, stmt.getType(), rhs_location);
     cast_node.params()[0] = rhs_type;
     _ = try appendToken(rp.c, .Comma, ",");
     const rhs = try transExprCoercing(rp, scope, rhs_expr, .used, .r_value);
 @@ -4764,11 +4764,11 @@ fn makeRestorePoint(c: *Context) RestorePoint {
     };
 }
-fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSourceLocation) TypeError!*ast.Node {
+fn transType(rp: RestorePoint, ty: *const clang.Type, source_loc: clang.SourceLocation) TypeError!*ast.Node {
-    switch (ZigClangType_getTypeClass(ty)) {
+    switch (ty.getTypeClass()) {
         .Builtin => {
-            const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty);
+            const builtin_ty = @ptrCast(*const clang.BuiltinType, ty);
-            return transCreateNodeIdentifier(rp.c, switch (ZigClangBuiltinType_getKind(builtin_ty)) {
+            return transCreateNodeIdentifier(rp.c, switch (builtin_ty.getKind()) {
                 .Void => "c_void",
                 .Bool => "bool",
                 .Char_U, .UChar, .Char_S, .Char8 => "u8",
 @@ -4792,32 +4792,32 @@ fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSour
             });
         },
         .FunctionProto => {
-            const fn_proto_ty = @ptrCast(*const ZigClangFunctionProtoType, ty);
+            const fn_proto_ty = @ptrCast(*const clang.FunctionProtoType, ty);
             const fn_proto = try transFnProto(rp, null, fn_proto_ty, source_loc, null, false);
             return &fn_proto.base;
         },
         .FunctionNoProto => {
-            const fn_no_proto_ty = @ptrCast(*const ZigClangFunctionType, ty);
+            const fn_no_proto_ty = @ptrCast(*const clang.FunctionType, ty);
             const fn_proto = try transFnNoProto(rp, fn_no_proto_ty, source_loc, null, false);
             return &fn_proto.base;
         },
         .Paren => {
-            const paren_ty = @ptrCast(*const ZigClangParenType, ty);
+            const paren_ty = @ptrCast(*const clang.ParenType, ty);
-            return transQualType(rp, ZigClangParenType_getInnerType(paren_ty), source_loc);
+            return transQualType(rp, paren_ty.getInnerType(), source_loc);
         },
         .Pointer => {
-            const child_qt = ZigClangType_getPointeeType(ty);
+            const child_qt = ty.getPointeeType();
             if (qualTypeChildIsFnProto(child_qt)) {
                 const optional_node = try transCreateNodeSimplePrefixOp(rp.c, .OptionalType, .QuestionMark, "?");
                 optional_node.rhs = try transQualType(rp, child_qt, source_loc);
                 return &optional_node.base;
             }
-            if (typeIsOpaque(rp.c, ZigClangQualType_getTypePtr(child_qt), source_loc)) {
+            if (typeIsOpaque(rp.c, child_qt.getTypePtr(), source_loc)) {
                 const optional_node = try transCreateNodeSimplePrefixOp(rp.c, .OptionalType, .QuestionMark, "?");
                 const pointer_node = try transCreateNodePtrType(
                     rp.c,
-                    ZigClangQualType_isConstQualified(child_qt),
+                    child_qt.isConstQualified(),
-                    ZigClangQualType_isVolatileQualified(child_qt),
+                    child_qt.isVolatileQualified(),
                     .Asterisk,
                 );
                 optional_node.rhs = &pointer_node.base;
 @@ -4826,83 +4826,83 @@ fn transType(rp: RestorePoint, ty: *const ZigClangType, source_loc: ZigClangSour
             }
             const pointer_node = try transCreateNodePtrType(
                 rp.c,
-                ZigClangQualType_isConstQualified(child_qt),
+                child_qt.isConstQualified(),
-                ZigClangQualType_isVolatileQualified(child_qt),
+                child_qt.isVolatileQualified(),
                 .Identifier,
             );
             pointer_node.rhs = try transQualType(rp, child_qt, source_loc);
             return &pointer_node.base;
         },
         .ConstantArray => {
-            const const_arr_ty = @ptrCast(*const ZigClangConstantArrayType, ty);
+            const const_arr_ty = @ptrCast(*const clang.ConstantArrayType, ty);
-            const size_ap_int = ZigClangConstantArrayType_getSize(const_arr_ty);
+            const size_ap_int = const_arr_ty.getSize();
-            const size = ZigClangAPInt_getLimitedValue(size_ap_int, math.maxInt(usize));
+            const size = size_ap_int.getLimitedValue(math.maxInt(usize));
-            const elem_ty = ZigClangQualType_getTypePtr(ZigClangConstantArrayType_getElementType(const_arr_ty));
+            const elem_ty = const_arr_ty.getElementType().getTypePtr();
             return try transCreateNodeArrayType(rp, source_loc, elem_ty, size);
         },
         .IncompleteArray => {
-            const incomplete_array_ty = @ptrCast(*const ZigClangIncompleteArrayType, ty);
+            const incomplete_array_ty = @ptrCast(*const clang.IncompleteArrayType, ty);
-            const child_qt = ZigClangIncompleteArrayType_getElementType(incomplete_array_ty);
+            const child_qt = incomplete_array_ty.getElementType();
             var node = try transCreateNodePtrType(
                 rp.c,
-                ZigClangQualType_isConstQualified(child_qt),
+                child_qt.isConstQualified(),
-                ZigClangQualType_isVolatileQualified(child_qt),
+                child_qt.isVolatileQualified(),
                 .Identifier,
             );
             node.rhs = try transQualType(rp, child_qt, source_loc);
             return &node.base;
         },
         .Typedef => {
-            const typedef_ty = @ptrCast(*const ZigClangTypedefType, ty);
+            const typedef_ty = @ptrCast(*const clang.TypedefType, ty);
-            const typedef_decl = ZigClangTypedefType_getDecl(typedef_ty);
+            const typedef_decl = typedef_ty.getDecl();
             return (try transTypeDef(rp.c, typedef_decl, false)) orelse
                 revertAndWarn(rp, error.UnsupportedType, source_loc, "unable to translate typedef declaration", .{});
         },
         .Record => {
-            const record_ty = @ptrCast(*const ZigClangRecordType, ty);
+            const record_ty = @ptrCast(*const clang.RecordType, ty);
-            const record_decl = ZigClangRecordType_getDecl(record_ty);
+            const record_decl = record_ty.getDecl();
             return (try transRecordDecl(rp.c, record_decl)) orelse
                 revertAndWarn(rp, error.UnsupportedType, source_loc, "unable to resolve record declaration", .{});
         },
         .Enum => {
-            const enum_ty = @ptrCast(*const ZigClangEnumType, ty);
+            const enum_ty = @ptrCast(*const clang.EnumType, ty);
-            const enum_decl = ZigClangEnumType_getDecl(enum_ty);
+            const enum_decl = enum_ty.getDecl();
             return (try transEnumDecl(rp.c, enum_decl)) orelse
                 revertAndWarn(rp, error.UnsupportedType, source_loc, "unable to translate enum declaration", .{});
         },
         .Elaborated => {
-            const elaborated_ty = @ptrCast(*const ZigClangElaboratedType, ty);
+            const elaborated_ty = @ptrCast(*const clang.ElaboratedType, ty);
-            return transQualType(rp, ZigClangElaboratedType_getNamedType(elaborated_ty), source_loc);
+            return transQualType(rp, elaborated_ty.getNamedType(), source_loc);
         },
         .Decayed => {
-            const decayed_ty = @ptrCast(*const ZigClangDecayedType, ty);
+            const decayed_ty = @ptrCast(*const clang.DecayedType, ty);
-            return transQualType(rp, ZigClangDecayedType_getDecayedType(decayed_ty), source_loc);
+            return transQualType(rp, decayed_ty.getDecayedType(), source_loc);
         },
         .Attributed => {
-            const attributed_ty = @ptrCast(*const ZigClangAttributedType, ty);
+            const attributed_ty = @ptrCast(*const clang.AttributedType, ty);
-            return transQualType(rp, ZigClangAttributedType_getEquivalentType(attributed_ty), source_loc);
+            return transQualType(rp, attributed_ty.getEquivalentType(), source_loc);
         },
         .MacroQualified => {
-            const macroqualified_ty = @ptrCast(*const ZigClangMacroQualifiedType, ty);
+            const macroqualified_ty = @ptrCast(*const clang.MacroQualifiedType, ty);
-            return transQualType(rp, ZigClangMacroQualifiedType_getModifiedType(macroqualified_ty), source_loc);
+            return transQualType(rp, macroqualified_ty.getModifiedType(), source_loc);
         },
         else => {
-            const type_name = rp.c.str(ZigClangType_getTypeClassName(ty));
+            const type_name = rp.c.str(ty.getTypeClassName());
             return revertAndWarn(rp, error.UnsupportedType, source_loc, "unsupported type: '{}'", .{type_name});
         },
     }
 }
-fn isCVoid(qt: ZigClangQualType) bool {
+fn isCVoid(qt: clang.QualType) bool {
-    const ty = ZigClangQualType_getTypePtr(qt);
+    const ty = qt.getTypePtr();
-    if (ZigClangType_getTypeClass(ty) == .Builtin) {
+    if (ty.getTypeClass() == .Builtin) {
-        const builtin_ty = @ptrCast(*const ZigClangBuiltinType, ty);
+        const builtin_ty = @ptrCast(*const clang.BuiltinType, ty);
-        return ZigClangBuiltinType_getKind(builtin_ty) == .Void;
+        return builtin_ty.getKind() == .Void;
     }
     return false;
 }
 @@ -4910,16 +4910,16 @@ fn isCVoid(qt: ZigClangQualType) bool {
 const FnDeclContext = struct {
     fn_name: []const u8,
     has_body: bool,
-    storage_class: ZigClangStorageClass,
+    storage_class: clang.StorageClass,
     is_export: bool,
 };
 fn transCC(
     rp: RestorePoint,
-    fn_ty: *const ZigClangFunctionType,
+    fn_ty: *const clang.FunctionType,
-    source_loc: ZigClangSourceLocation,
+    source_loc: clang.SourceLocation,
 ) !CallingConvention {
-    const clang_cc = ZigClangFunctionType_getCallConv(fn_ty);
+    const clang_cc = fn_ty.getCallConv();
     switch (clang_cc) {
         .C => return CallingConvention.C,
         .X86StdCall => return CallingConvention.Stdcall,
 @@ -4940,22 +4940,22 @@ fn transCC(
 fn transFnProto(
     rp: RestorePoint,
-    fn_decl: ?*const ZigClangFunctionDecl,
+    fn_decl: ?*const clang.FunctionDecl,
-    fn_proto_ty: *const ZigClangFunctionProtoType,
+    fn_proto_ty: *const clang.FunctionProtoType,
-    source_loc: ZigClangSourceLocation,
+    source_loc: clang.SourceLocation,
     fn_decl_context: ?FnDeclContext,
     is_pub: bool,
 ) !*ast.Node.FnProto {
-    const fn_ty = @ptrCast(*const ZigClangFunctionType, fn_proto_ty);
+    const fn_ty = @ptrCast(*const clang.FunctionType, fn_proto_ty);
     const cc = try transCC(rp, fn_ty, source_loc);
-    const is_var_args = ZigClangFunctionProtoType_isVariadic(fn_proto_ty);
+    const is_var_args = fn_proto_ty.isVariadic();
     return finishTransFnProto(rp, fn_decl, fn_proto_ty, fn_ty, source_loc, fn_decl_context, is_var_args, cc, is_pub);
 }
 fn transFnNoProto(
     rp: RestorePoint,
-    fn_ty: *const ZigClangFunctionType,
+    fn_ty: *const clang.FunctionType,
-    source_loc: ZigClangSourceLocation,
+    source_loc: clang.SourceLocation,
     fn_decl_context: ?FnDeclContext,
     is_pub: bool,
 ) !*ast.Node.FnProto {
 @@ -4966,10 +4966,10 @@ fn transFnNoProto(
 fn finishTransFnProto(
     rp: RestorePoint,
-    fn_decl: ?*const ZigClangFunctionDecl,
+    fn_decl: ?*const clang.FunctionDecl,
-    fn_proto_ty: ?*const ZigClangFunctionProtoType,
+    fn_proto_ty: ?*const clang.FunctionProtoType,
-    fn_ty: *const ZigClangFunctionType,
+    fn_ty: *const clang.FunctionType,
-    source_loc: ZigClangSourceLocation,
+    source_loc: clang.SourceLocation,
     fn_decl_context: ?FnDeclContext,
     is_var_args: bool,
     cc: CallingConvention,
 @@ -4995,19 +4995,19 @@ fn finishTransFnProto(
     var fn_params = std.ArrayList(ast.Node.FnProto.ParamDecl).init(rp.c.gpa);
     defer fn_params.deinit();
-    const param_count: usize = if (fn_proto_ty != null) ZigClangFunctionProtoType_getNumParams(fn_proto_ty.?) else 0;
+    const param_count: usize = if (fn_proto_ty != null) fn_proto_ty.?.getNumParams() else 0;
     try fn_params.ensureCapacity(param_count + 1); // +1 for possible var args node
     var i: usize = 0;
     while (i < param_count) : (i += 1) {
-        const param_qt = ZigClangFunctionProtoType_getParamType(fn_proto_ty.?, @intCast(c_uint, i));
+        const param_qt = fn_proto_ty.?.getParamType(@intCast(c_uint, i));
-        const noalias_tok = if (ZigClangQualType_isRestrictQualified(param_qt)) try appendToken(rp.c, .Keyword_noalias, "noalias") else null;
+        const noalias_tok = if (param_qt.isRestrictQualified()) try appendToken(rp.c, .Keyword_noalias, "noalias") else null;
         const param_name_tok: ?ast.TokenIndex = blk: {
             if (fn_decl) |decl| {
-                const param = ZigClangFunctionDecl_getParamDecl(decl, @intCast(c_uint, i));
+                const param = decl.getParamDecl(@intCast(c_uint, i));
-                const param_name: []const u8 = try rp.c.str(ZigClangNamedDecl_getName_bytes_begin(@ptrCast(*const ZigClangNamedDecl, param)));
+                const param_name: []const u8 = try rp.c.str(@ptrCast(*const clang.NamedDecl, param).getName_bytes_begin());
                 if (param_name.len < 1)
                     break :blk null;
 @@ -5045,7 +5045,7 @@ fn finishTransFnProto(
     const linksection_expr = blk: {
         if (fn_decl) |decl| {
             var str_len: usize = undefined;
-            if (ZigClangFunctionDecl_getSectionAttribute(decl, &str_len)) |str_ptr| {
+            if (decl.getSectionAttribute(&str_len)) |str_ptr| {
                 _ = try appendToken(rp.c, .Keyword_linksection, "linksection");
                 _ = try appendToken(rp.c, .LParen, "(");
                 const expr = try transCreateNodeStringLiteral(
 @@ -5062,7 +5062,7 @@ fn finishTransFnProto(
     const align_expr = blk: {
         if (fn_decl) |decl| {
-            const alignment = ZigClangFunctionDecl_getAlignedAttribute(decl, rp.c.clang_context);
+            const alignment = decl.getAlignedAttribute(rp.c.clang_context);
             if (alignment != 0) {
                 _ = try appendToken(rp.c, .Keyword_align, "align");
                 _ = try appendToken(rp.c, .LParen, "(");
 @@ -5085,10 +5085,10 @@ fn finishTransFnProto(
     };
     const return_type_node = blk: {
-        if (ZigClangFunctionType_getNoReturnAttr(fn_ty)) {
+        if (fn_ty.getNoReturnAttr()) {
             break :blk try transCreateNodeIdentifier(rp.c, "noreturn");
         } else {
-            const return_qt = ZigClangFunctionType_getReturnType(fn_ty);
+            const return_qt = fn_ty.getReturnType();
             if (isCVoid(return_qt)) {
                 // convert primitive c_void to actual void (only for return type)
                 break :blk try transCreateNodeIdentifier(rp.c, "void");
 @@ -5136,7 +5136,7 @@ fn finishTransFnProto(
 fn revertAndWarn(
     rp: RestorePoint,
     err: anytype,
-    source_loc: ZigClangSourceLocation,
+    source_loc: clang.SourceLocation,
     comptime format: []const u8,
     args: anytype,
 ) (@TypeOf(err) || error{OutOfMemory}) {
 @@ -5145,12 +5145,12 @@ fn revertAndWarn(
     return err;
 }
-fn emitWarning(c: *Context, loc: ZigClangSourceLocation, comptime format: []const u8, args: anytype) !void {
+fn emitWarning(c: *Context, loc: clang.SourceLocation, comptime format: []const u8, args: anytype) !void {
     const args_prefix = .{c.locStr(loc)};
     _ = try appendTokenFmt(c, .LineComment, "// {}: warning: " ++ format, args_prefix ++ args);
 }
-pub fn failDecl(c: *Context, loc: ZigClangSourceLocation, name: []const u8, comptime format: []const u8, args: anytype) !void {
+pub fn failDecl(c: *Context, loc: clang.SourceLocation, name: []const u8, comptime format: []const u8, args: anytype) !void {
     // pub const name = @compileError(msg);
     const pub_tok = try appendToken(c, .Keyword_pub, "pub");
     const const_tok = try appendToken(c, .Keyword_const, "const");
 @@ -5287,14 +5287,14 @@ fn transCreateNodeIdentifierUnchecked(c: *Context, name: []const u8) !*ast.Node
 }
 pub fn freeErrors(errors: []ClangErrMsg) void {
-    ZigClangErrorMsg_delete(errors.ptr, errors.len);
+    errors.ptr.delete(errors.len);
 }
 const MacroCtx = struct {
     source: []const u8,
     list: []const CToken,
     i: usize = 0,
-    loc: ZigClangSourceLocation,
+    loc: clang.SourceLocation,
     name: []const u8,
     fn peek(self: *MacroCtx) ?CToken.Id {
 @@ -5318,22 +5318,22 @@ const MacroCtx = struct {
     }
 };
-fn transPreprocessorEntities(c: *Context, unit: *ZigClangASTUnit) Error!void {
+fn transPreprocessorEntities(c: *Context, unit: *clang.ASTUnit) Error!void {
     // TODO if we see #undef, delete it from the table
-    var it = ZigClangASTUnit_getLocalPreprocessingEntities_begin(unit);
+    var it = unit.getLocalPreprocessingEntities_begin();
-    const it_end = ZigClangASTUnit_getLocalPreprocessingEntities_end(unit);
+    const it_end = unit.getLocalPreprocessingEntities_end();
     var tok_list = std.ArrayList(CToken).init(c.gpa);
     defer tok_list.deinit();
     const scope = c.global_scope;
     while (it.I != it_end.I) : (it.I += 1) {
-        const entity = ZigClangPreprocessingRecord_iterator_deref(it);
+        const entity = it.deref();
         tok_list.items.len = 0;
-        switch (ZigClangPreprocessedEntity_getKind(entity)) {
+        switch (entity.getKind()) {
             .MacroDefinitionKind => {
-                const macro = @ptrCast(*ZigClangMacroDefinitionRecord, entity);
+                const macro = @ptrCast(*clang.MacroDefinitionRecord, entity);
-                const raw_name = ZigClangMacroDefinitionRecord_getName_getNameStart(macro);
+                const raw_name = macro.getName_getNameStart();
-                const begin_loc = ZigClangMacroDefinitionRecord_getSourceRange_getBegin(macro);
+                const begin_loc = macro.getSourceRange_getBegin();
                 const name = try c.str(raw_name);
                 // TODO https://github.com/ziglang/zig/issues/3756
 @@ -5343,7 +5343,7 @@ fn transPreprocessorEntities(c: *Context, unit: *ZigClangASTUnit) Error!void {
                     continue;
                 }
-                const begin_c = ZigClangSourceManager_getCharacterData(c.source_manager, begin_loc);
+                const begin_c = c.source_manager.getCharacterData(begin_loc);
                 const slice = begin_c[0..mem.len(begin_c)];
                 var tokenizer = std.c.Tokenizer{

src/zig_clang.h+2-1

 @@ -68,16 +68,17 @@ struct ZigClangExprEvalResult {
     ZigClangAPValue Val;
 };
+struct ZigClangAbstractConditionalOperator;
 struct ZigClangAPFloat;
 struct ZigClangAPInt;
 struct ZigClangAPSInt;
-struct ZigClangAPValue;
 struct ZigClangASTContext;
 struct ZigClangASTUnit;
 struct ZigClangArraySubscriptExpr;
 struct ZigClangArrayType;
 struct ZigClangAttributedType;
 struct ZigClangBinaryOperator;
+struct ZigClangBinaryConditionalOperator;
 struct ZigClangBreakStmt;
 struct ZigClangBuiltinType;
 struct ZigClangCStyleCastExpr;

test/compile_errors.zig+55-32

 @@ -2,6 +2,19 @@ const tests = @import("tests.zig");
 const std = @import("std");
 pub fn addCases(cases: *tests.CompileErrorContext) void {
+    cases.add("array in c exported function",
+        \\export fn zig_array(x: [10]u8) void {
+        \\    expect(std.mem.eql(u8, &x, "1234567890"));
+        \\}
+        \\
+        \\export fn zig_return_array() [10]u8 {
+        \\    return "1234567890".*;
+        \\}
+    , &[_][]const u8{
+        "tmp.zig:1:24: error: parameter of type '[10]u8' not allowed in function with calling convention 'C'",
+        "tmp.zig:5:30: error: return type '[10]u8' not allowed in function with calling convention 'C'",
+    });
     cases.add("@Type for exhaustive enum with undefined tag type",
         \\const TypeInfo = @import("builtin").TypeInfo;
         \\const Tag = @Type(.{
 @@ -125,6 +138,31 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:15:23: error: enum field missing: 'arst'",
         "tmp.zig:27:24: note: referenced here",
     });
+    cases.add("field access of opaque type",
+        \\const MyType = opaque {};
+        \\
+        \\export fn entry() bool {
+        \\    var x: i32 = 1;
+        \\    return bar(@ptrCast(*MyType, &x));
+        \\}
+        \\
+        \\fn bar(x: *MyType) bool {
+        \\    return x.blah;
+        \\}
+    , &[_][]const u8{
+        "tmp.zig:9:13: error: no member named 'blah' in opaque type 'MyType'",
+    });
+    cases.add("opaque type with field",
+        \\const Opaque = opaque { foo: i32 };
+        \\export fn entry() void {
+        \\    const foo: ?*Opaque = null;
+        \\}
+    , &[_][]const u8{
+        "tmp.zig:1:25: error: opaque types cannot have fields",
+    });
     cases.add("@Type(.Fn) with is_generic = true",
         \\const Foo = @Type(.{
         \\    .Fn = .{
 @@ -180,7 +218,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\        .layout = .Auto,
         \\        .tag_type = null,
         \\        .fields = &[_]TypeInfo.UnionField{
-        \\            .{ .name = "foo", .field_type = @Type(.Opaque), .alignment = 1 },
+        \\            .{ .name = "foo", .field_type = opaque {}, .alignment = 1 },
         \\        },
         \\        .decls = &[_]TypeInfo.Declaration{},
         \\    },
 @@ -2287,7 +2325,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    return error.OutOfMemory;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:12: error: error is discarded",
+        "tmp.zig:2:12: error: error is discarded. consider using `try`, `catch`, or `if`",
     });
     cases.add("volatile on global assembly",
 @@ -2338,9 +2376,9 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    return error.Bad;
         \\}
     , &[_][]const u8{
-        "tmp.zig:2:24: error: expression value is ignored",
+        "tmp.zig:2:24: error: error is ignored. consider using `try`, `catch`, or `if`",
-        "tmp.zig:6:25: error: expression value is ignored",
+        "tmp.zig:6:25: error: error is ignored. consider using `try`, `catch`, or `if`",
-        "tmp.zig:10:25: error: expression value is ignored",
+        "tmp.zig:10:25: error: error is ignored. consider using `try`, `catch`, or `if`",
     });
     cases.add("empty while loop body",
 @@ -2613,7 +2651,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     });
     cases.add("directly embedding opaque type in struct and union",
-        \\const O = @Type(.Opaque);
+        \\const O = opaque {};
         \\const Foo = struct {
         \\    o: O,
         \\};
 @@ -2628,7 +2666,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\    var bar: Bar = undefined;
         \\}
         \\export fn c() void {
-        \\    var baz: *@Type(.Opaque) = undefined;
+        \\    var baz: *opaque {} = undefined;
         \\    const qux = .{baz.*};
         \\}
     , &[_][]const u8{
 @@ -3592,7 +3630,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     });
     cases.add("unknown length pointer to opaque",
-        \\export const T = [*]@Type(.Opaque);
+        \\export const T = [*]opaque {};
     , &[_][]const u8{
         "tmp.zig:1:21: error: unknown-length pointer to opaque",
     });
 @@ -6236,7 +6274,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\}
         \\fn bar() anyerror!i32 { return 0; }
     , &[_][]const u8{
-        "tmp.zig:2:14: error: expression value is ignored",
+        "tmp.zig:2:14: error: error is ignored. consider using `try`, `catch`, or `if`",
     });
     cases.add("dereference an array",
 @@ -6827,8 +6865,8 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:2:31: error: index 2 outside array of size 2",
     });
-    cases.add("wrong pointer coerced to pointer to @Type(.Opaque)",
+    cases.add("wrong pointer coerced to pointer to opaque {}",
-        \\const Derp = @Type(.Opaque);
+        \\const Derp = opaque {};
         \\extern fn bar(d: *Derp) void;
         \\export fn foo() void {
         \\    var x = @as(u8, 1);
 @@ -6854,8 +6892,8 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry5() void {
         \\   var d = null;
         \\}
-        \\export fn entry6(opaque: *Opaque) void {
+        \\export fn entry6(opaque_: *Opaque) void {
-        \\   var e = opaque.*;
+        \\   var e = opaque_.*;
         \\}
         \\export fn entry7() void {
         \\   var f = i32;
 @@ -6866,7 +6904,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         \\export fn entry9() void {
         \\   var z: noreturn = return;
         \\}
-        \\const Opaque = @Type(.Opaque);
+        \\const Opaque = opaque {};
         \\const Foo = struct {
         \\    fn bar(self: *const Foo) void {}
         \\};
 @@ -7019,21 +7057,6 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
         "tmp.zig:37:29: error: cannot store runtime value in compile time variable",
     });
-    cases.add("field access of opaque type",
-        \\const MyType = @Type(.Opaque);
-        \\
-        \\export fn entry() bool {
-        \\    var x: i32 = 1;
-        \\    return bar(@ptrCast(*MyType, &x));
-        \\}
-        \\
-        \\fn bar(x: *MyType) bool {
-        \\    return x.blah;
-        \\}
-    , &[_][]const u8{
-        "tmp.zig:9:13: error: type '*MyType' does not support field access",
-    });
     cases.add("invalid legacy unicode escape",
         \\export fn entry() void {
         \\    const a = '\U1234';
 @@ -7623,7 +7646,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     });
     cases.add("function returning opaque type",
-        \\const FooType = @Type(.Opaque);
+        \\const FooType = opaque {};
         \\export fn bar() !FooType {
         \\    return error.InvalidValue;
         \\}
 @@ -7641,7 +7664,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     });
     cases.add("generic function returning opaque type",
-        \\const FooType = @Type(.Opaque);
+        \\const FooType = opaque {};
         \\fn generic(comptime T: type) !T {
         \\    return undefined;
         \\}
 @@ -7665,7 +7688,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
     });
     cases.add("function parameter is opaque",
-        \\const FooType = @Type(.Opaque);
+        \\const FooType = opaque {};
         \\export fn entry1() void {
         \\    const someFuncPtr: fn (FooType) void = undefined;
         \\}

test/gen_h.zig+1-1

...	@@ -74,7 +74,7 @@ pub fn addCases(cases: *tests.GenHContext) void {	...	@@ -74,7 +74,7 @@ pub fn addCases(cases: *tests.GenHContext) void {
74	});	74	});
75		75
76	cases.add("declare opaque type",	76	cases.add("declare opaque type",
77	\\const Foo = @Type(.Opaque);	77	\\const Foo = opaque {};
78	\\	78	\\
79	\\export fn entry(foo: ?*Foo) void { }	79	\\export fn entry(foo: ?*Foo) void { }
80	, &[_][]const u8{	80	, &[_][]const u8{

test/stage1/behavior/misc.zig+3-3

...	@@ -438,8 +438,8 @@ export fn writeToVRam() void {	...	@@ -438,8 +438,8 @@ export fn writeToVRam() void {
438	vram[0] = 'X';	438	vram[0] = 'X';
439	}	439	}
440		440
441	const OpaqueA = @Type(.Opaque);	441	const OpaqueA = opaque {};
442	const OpaqueB = @Type(.Opaque);	442	const OpaqueB = opaque {};
443	test "opaque types" {	443	test "opaque types" {
444	expect(OpaqueA != OpaqueB);	444	expect(OpaqueA != OpaqueB);
445	expect(mem.eql(u8, @typeName(OpaqueA), "OpaqueA"));	445	expect(mem.eql(u8, @typeName(OpaqueA), "OpaqueA"));
...	@@ -704,7 +704,7 @@ test "auto created variables have correct alignment" {	...	@@ -704,7 +704,7 @@ test "auto created variables have correct alignment" {
704	comptime expect(S.foo("\x7a\x7a\x7a\x7a") == 0x7a7a7a7a);	704	comptime expect(S.foo("\x7a\x7a\x7a\x7a") == 0x7a7a7a7a);
705	}	705	}
706		706
707	extern var opaque_extern_var: @Type(.Opaque);	707	extern var opaque_extern_var: opaque {};
708	var var_to_export: u32 = 42;	708	var var_to_export: u32 = 42;
709	test "extern variable with non-pointer opaque type" {	709	test "extern variable with non-pointer opaque type" {
710	@export(var_to_export, .{ .name = "opaque_extern_var" });	710	@export(var_to_export, .{ .name = "opaque_extern_var" });

test/stage1/behavior/type.zig+11-2

...	@@ -190,8 +190,17 @@ test "Type.ErrorUnion" {	...	@@ -190,8 +190,17 @@ test "Type.ErrorUnion" {
190	}	190	}
191		191
192	test "Type.Opaque" {	192	test "Type.Opaque" {
193	testing.expect(@Type(.Opaque) != @Type(.Opaque));	193	const Opaque = @Type(.{
194	testing.expect(@typeInfo(@Type(.Opaque)) == .Opaque);	194	.Opaque = .{
		195	.decls = &[_]TypeInfo.Declaration{},
		196	},
		197	});
		198	testing.expect(Opaque != opaque {});
		199	testing.expectEqualSlices(
		200	TypeInfo.Declaration,
		201	&[_]TypeInfo.Declaration{},
		202	@typeInfo(Opaque).Opaque.decls,
		203	);
195	}	204	}
196		205
197	test "Type.Vector" {	206	test "Type.Vector" {

test/stage1/behavior/type_info.zig+16-1

...	@@ -199,7 +199,7 @@ fn testUnion() void {	...	@@ -199,7 +199,7 @@ fn testUnion() void {
199	expect(typeinfo_info.Union.tag_type.? == TypeId);	199	expect(typeinfo_info.Union.tag_type.? == TypeId);
200	expect(typeinfo_info.Union.fields.len == 25);	200	expect(typeinfo_info.Union.fields.len == 25);
201	expect(typeinfo_info.Union.fields[4].field_type == @TypeOf(@typeInfo(u8).Int));	201	expect(typeinfo_info.Union.fields[4].field_type == @TypeOf(@typeInfo(u8).Int));
202	expect(typeinfo_info.Union.decls.len == 21);	202	expect(typeinfo_info.Union.decls.len == 22);
203		203
204	const TestNoTagUnion = union {	204	const TestNoTagUnion = union {
205	Foo: void,	205	Foo: void,
...	@@ -265,6 +265,21 @@ const TestStruct = packed struct {	...	@@ -265,6 +265,21 @@ const TestStruct = packed struct {
265	const Self = @This();	265	const Self = @This();
266	};	266	};
267		267
		268	test "type info: opaque info" {
		269	testOpaque();
		270	comptime testOpaque();
		271	}
		272
		273	fn testOpaque() void {
		274	const Foo = opaque {
		275	const A = 1;
		276	fn b() void {}
		277	};
		278
		279	const foo_info = @typeInfo(Foo);
		280	expect(foo_info.Opaque.decls.len == 2);
		281	}
		282
268	test "type info: function type info" {	283	test "type info: function type info" {
269	// wasm doesn't support align attributes on functions	284	// wasm doesn't support align attributes on functions
270	if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest;	285	if (builtin.arch == .wasm32 or builtin.arch == .wasm64) return error.SkipZigTest;

test/stage1/c_abi/cfuncs.c-18

...	@@ -28,8 +28,6 @@ void zig_ptr(void *);	...	@@ -28,8 +28,6 @@ void zig_ptr(void *);
28		28
29	void zig_bool(bool);	29	void zig_bool(bool);
30		30
31	void zig_array(uint8_t[10]);
32
33	struct BigStruct {	31	struct BigStruct {
34	uint64_t a;	32	uint64_t a;
35	uint64_t b;	33	uint64_t b;
...	@@ -97,9 +95,6 @@ void run_c_tests(void) {	...	@@ -97,9 +95,6 @@ void run_c_tests(void) {
97		95
98	zig_bool(true);	96	zig_bool(true);
99		97
100	uint8_t array[10] = {'1', '2', '3', '4', '5', '6', '7', '8', '9', '0'};
101	zig_array(array);
102
103	{	98	{
104	struct BigStruct s = {1, 2, 3, 4, 5};	99	struct BigStruct s = {1, 2, 3, 4, 5};
105	zig_big_struct(s);	100	zig_big_struct(s);
...	@@ -190,19 +185,6 @@ void c_five_floats(float a, float b, float c, float d, float e) {	...	@@ -190,19 +185,6 @@ void c_five_floats(float a, float b, float c, float d, float e) {
190	assert_or_panic(e == 5.0);	185	assert_or_panic(e == 5.0);
191	}	186	}
192		187
193	void c_array(uint8_t x[10]) {
194	assert_or_panic(x[0] == '1');
195	assert_or_panic(x[1] == '2');
196	assert_or_panic(x[2] == '3');
197	assert_or_panic(x[3] == '4');
198	assert_or_panic(x[4] == '5');
199	assert_or_panic(x[5] == '6');
200	assert_or_panic(x[6] == '7');
201	assert_or_panic(x[7] == '8');
202	assert_or_panic(x[8] == '9');
203	assert_or_panic(x[9] == '0');
204	}
205
206	void c_big_struct(struct BigStruct x) {	188	void c_big_struct(struct BigStruct x) {
207	assert_or_panic(x.a == 1);	189	assert_or_panic(x.a == 1);
208	assert_or_panic(x.b == 2);	190	assert_or_panic(x.b == 2);

test/stage1/c_abi/main.zig-11

...	@@ -116,17 +116,6 @@ export fn zig_bool(x: bool) void {	...	@@ -116,17 +116,6 @@ export fn zig_bool(x: bool) void {
116	expect(x);	116	expect(x);
117	}	117	}
118		118
119	extern fn c_array([10]u8) void;
120
121	test "C ABI array" {
122	var array: [10]u8 = "1234567890".*;
123	c_array(array);
124	}
125
126	export fn zig_array(x: [10]u8) void {
127	expect(std.mem.eql(u8, &x, "1234567890"));
128	}
129
130	const BigStruct = extern struct {	119	const BigStruct = extern struct {
131	a: u64,	120	a: u64,
132	b: u64,	121	b: u64,

test/translate_c.zig+7-7

...	@@ -137,9 +137,9 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -137,9 +137,9 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
137	\\struct foo { int x; int y[]; };	137	\\struct foo { int x; int y[]; };
138	\\struct bar { int x; int y[0]; };	138	\\struct bar { int x; int y[0]; };
139	, &[_][]const u8{	139	, &[_][]const u8{
140	\\pub const struct_foo = @Type(.Opaque);	140	\\pub const struct_foo = opaque {};
141	,	141	,
142	\\pub const struct_bar = @Type(.Opaque);	142	\\pub const struct_bar = opaque {};
143	});	143	});
144		144
145	cases.add("nested loops without blocks",	145	cases.add("nested loops without blocks",
...	@@ -207,7 +207,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -207,7 +207,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
207	\\pub const struct_arcan_shmif_page = //	207	\\pub const struct_arcan_shmif_page = //
208	,	208	,
209	\\warning: unsupported type: 'Atomic'	209	\\warning: unsupported type: 'Atomic'
210	\\ @Type(.Opaque); //	210	\\ opaque {}; //
211	,	211	,
212	\\ warning: struct demoted to opaque type - unable to translate type of field abufused	212	\\ warning: struct demoted to opaque type - unable to translate type of field abufused
213	, // TODO should be `addr: *struct_arcan_shmif_page`	213	, // TODO should be `addr: *struct_arcan_shmif_page`
...	@@ -386,8 +386,8 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -386,8 +386,8 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
386	\\ struct opaque_2 cast = (struct opaque_2 )opaque;	386	\\ struct opaque_2 cast = (struct opaque_2 )opaque;
387	\\}	387	\\}
388	, &[_][]const u8{	388	, &[_][]const u8{
389	\\pub const struct_opaque = @Type(.Opaque);	389	\\pub const struct_opaque = opaque {};
390	\\pub const struct_opaque_2 = @Type(.Opaque);	390	\\pub const struct_opaque_2 = opaque {};
391	\\pub export fn function(arg_opaque_1: ?*struct_opaque) void {	391	\\pub export fn function(arg_opaque_1: ?*struct_opaque) void {
392	\\ var opaque_1 = arg_opaque_1;	392	\\ var opaque_1 = arg_opaque_1;
393	\\ var cast: ?struct_opaque_2 = @ptrCast(?struct_opaque_2, opaque_1);	393	\\ var cast: ?struct_opaque_2 = @ptrCast(?struct_opaque_2, opaque_1);
...	@@ -628,7 +628,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -628,7 +628,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
628	\\ struct Foo *foo;	628	\\ struct Foo *foo;
629	\\};	629	\\};
630	, &[_][]const u8{	630	, &[_][]const u8{
631	\\pub const struct_Foo = @Type(.Opaque);	631	\\pub const struct_Foo = opaque {};
632	,	632	,
633	\\pub const struct_Bar = extern struct {	633	\\pub const struct_Bar = extern struct {
634	\\ foo: ?*struct_Foo,	634	\\ foo: ?*struct_Foo,
...	@@ -705,7 +705,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -705,7 +705,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
705	\\struct Foo;	705	\\struct Foo;
706	\\struct Foo some_func(struct Foo foo, int x);	706	\\struct Foo some_func(struct Foo foo, int x);
707	, &[_][]const u8{	707	, &[_][]const u8{
708	\\pub const struct_Foo = @Type(.Opaque);	708	\\pub const struct_Foo = opaque {};
709	,	709	,
710	\\pub extern fn some_func(foo: ?struct_Foo, x: c_int) ?struct_Foo;	710	\\pub extern fn some_func(foo: ?struct_Foo, x: c_int) ?struct_Foo;
711	,	711	,

tools/update_clang_options.zig+27-1

 @@ -130,6 +130,10 @@ const known_options = [_]KnownOpt{
         .name = "assemble",
         .ident = "asm_only",
     },
+    .{
+        .name = "O0",
+        .ident = "optimize",
+    },
     .{
         .name = "O1",
         .ident = "optimize",
 @@ -138,10 +142,20 @@ const known_options = [_]KnownOpt{
         .name = "O2",
         .ident = "optimize",
     },
+    // O3 is only detected from the joined "-O" option
+    .{
+        .name = "O4",
+        .ident = "optimize",
+    },
     .{
         .name = "Og",
         .ident = "optimize",
     },
+    .{
+        .name = "Os",
+        .ident = "optimize",
+    },
+    // Oz is only detected from the joined "-O" option
     .{
         .name = "O",
         .ident = "optimize",
 @@ -154,6 +168,14 @@ const known_options = [_]KnownOpt{
         .name = "optimize",
         .ident = "optimize",
     },
+    .{
+        .name = "g1",
+        .ident = "debug",
+    },
+    .{
+        .name = "gline-tables-only",
+        .ident = "debug",
+    },
     .{
         .name = "g",
         .ident = "debug",
 @@ -390,6 +412,10 @@ pub fn main() anyerror!void {
             // the only way.
             try stdout.print("flagpsl(\"{}\"),\n", .{name});
         } else if (knownOption(name)) |ident| {
+            // Workaround the fact that in 'Options.td'  -Ofast is listed as 'joined'
+            const final_syntax = if (std.mem.eql(u8, name, "Ofast")) .flag else syntax;
             try stdout.print(
                 \\.{{
                 \\    .name = "{}",
 @@ -400,7 +426,7 @@ pub fn main() anyerror!void {
                 \\    .psl = {},
                 \\}},
                 \\
-            , .{ name, syntax, ident, pd1, pd2, pslash });
+            , .{ name, final_syntax, ident, pd1, pd2, pslash });
         } else if (pd1 and !pd2 and !pslash and syntax == .flag) {
             try stdout.print("flagpd1(\"{}\"),\n", .{name});
         } else if (!pd1 and !pd2 and pslash and syntax == .flag) {

...	@@ -1988,7 +1988,7 @@ test "null terminated array" {	...	@@ -1988,7 +1988,7 @@ test "null terminated array" {
1988	<li>Supports slice syntax: {#syntax#}ptr[start..end]{#endsyntax#}</li>	1988	<li>Supports slice syntax: {#syntax#}ptr[start..end]{#endsyntax#}</li>
1989	<li>Supports pointer arithmetic: {#syntax#}ptr + x{#endsyntax#}, {#syntax#}ptr - x{#endsyntax#}</li>	1989	<li>Supports pointer arithmetic: {#syntax#}ptr + x{#endsyntax#}, {#syntax#}ptr - x{#endsyntax#}</li>
1990	<li>{#syntax#}T{#endsyntax#} must have a known size, which means that it cannot be	1990	<li>{#syntax#}T{#endsyntax#} must have a known size, which means that it cannot be
1991	{#syntax#}c_void{#endsyntax#} or any other {#link\|opaque type\|Opaque Types#}.</li>	1991	{#syntax#}c_void{#endsyntax#} or any other {#link\|opaque type\|opaque#}.</li>
1992	</ul>	1992	</ul>
1993	</li>	1993	</li>
1994	</ul>	1994	</ul>
...	@@ -5545,7 +5545,7 @@ test "turn HashMap into a set with void" {	...	@@ -5545,7 +5545,7 @@ test "turn HashMap into a set with void" {
5545	</p>	5545	</p>
5546	<p>	5546	<p>
5547	{#syntax#}void{#endsyntax#} is distinct from {#syntax#}c_void{#endsyntax#}, which is defined like this:	5547	{#syntax#}void{#endsyntax#} is distinct from {#syntax#}c_void{#endsyntax#}, which is defined like this:
5548	{#syntax#}pub const c_void = @Type(.Opaque);{#endsyntax#}.	5548	{#syntax#}pub const c_void = opaque {};{#endsyntax#}.
5549	{#syntax#}void{#endsyntax#} has a known size of 0 bytes, and {#syntax#}c_void{#endsyntax#} has an unknown, but non-zero, size.	5549	{#syntax#}void{#endsyntax#} has a known size of 0 bytes, and {#syntax#}c_void{#endsyntax#} has an unknown, but non-zero, size.
5550	</p>	5550	</p>
5551	<p>	5551	<p>
...	@@ -8471,7 +8471,7 @@ test "integer truncation" {	...	@@ -8471,7 +8471,7 @@ test "integer truncation" {
8471	<li>{#link\|Error Set Type#}</li>	8471	<li>{#link\|Error Set Type#}</li>
8472	<li>{#link\|Error Union Type#}</li>	8472	<li>{#link\|Error Union Type#}</li>
8473	<li>{#link\|Vectors#}</li>	8473	<li>{#link\|Vectors#}</li>
8474	<li>{#link\|Opaque Types#}</li>	8474	<li>{#link\|opaque#}</li>
8475	<li>{#link\|@Frame#}</li>	8475	<li>{#link\|@Frame#}</li>
8476	<li>{#syntax#}anyframe{#endsyntax#}</li>	8476	<li>{#syntax#}anyframe{#endsyntax#}</li>
8477	<li>{#link\|struct#}</li>	8477	<li>{#link\|struct#}</li>
...	@@ -8547,17 +8547,18 @@ fn foo(comptime T: type, ptr: *T) T {	...	@@ -8547,17 +8547,18 @@ fn foo(comptime T: type, ptr: *T) T {
8547	{#header_close#}	8547	{#header_close#}
8548	{#header_close#}	8548	{#header_close#}
8549		8549
8550	{#header_open\|Opaque Types#}	8550	{#header_open\|opaque#}
8551	<p>	8551	<p>
8552	{#syntax#}@Type(.Opaque){#endsyntax#} creates a new type with an unknown (but non-zero) size and alignment.	8552	{#syntax#}opaque {}{#endsyntax#} declares a new type with an unknown (but non-zero) size and alignment.
		8553	It can have declarations like structs, unions, or enums.
8553	</p>	8554	</p>
8554	<p>	8555	<p>
8555	This is typically used for type safety when interacting with C code that does not expose struct details.	8556	This is typically used for type safety when interacting with C code that does not expose struct details.
8556	Example:	8557	Example:
8557	</p>	8558	</p>
8558	{#code_begin\|test_err\|expected type 'Derp', found 'Wat'#}	8559	{#code_begin\|test_err\|expected type 'Derp', found 'Wat'#}
8559	const Derp = @Type(.Opaque);	8560	const Derp = opaque {};
8560	const Wat = @Type(.Opaque);	8561	const Wat = opaque {};
8561		8562
8562	extern fn bar(d: *Derp) void;	8563	extern fn bar(d: *Derp) void;
8563	fn foo(w: *Wat) callconv(.C) void {	8564	fn foo(w: *Wat) callconv(.C) void {
...	@@ -11193,7 +11194,7 @@ PtrTypeStart	...	@@ -11193,7 +11194,7 @@ PtrTypeStart
11193	ContainerDeclAuto <- ContainerDeclType LBRACE ContainerMembers RBRACE	11194	ContainerDeclAuto <- ContainerDeclType LBRACE ContainerMembers RBRACE
11194		11195
11195	ContainerDeclType	11196	ContainerDeclType
11196	<- (KEYWORD_struct / KEYWORD_enum) (LPAREN Expr RPAREN)?	11197	<- (KEYWORD_struct / KEYWORD_enum / KEYWORD_opaque) (LPAREN Expr RPAREN)?
11197	/ KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)?	11198	/ KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)?
11198		11199
11199	# Alignment	11200	# Alignment
...	@@ -11340,6 +11341,7 @@ KEYWORD_inline <- 'inline' end_of_word	...	@@ -11340,6 +11341,7 @@ KEYWORD_inline <- 'inline' end_of_word
11340	KEYWORD_noalias <- 'noalias' end_of_word	11341	KEYWORD_noalias <- 'noalias' end_of_word
11341	KEYWORD_nosuspend <- 'nosuspend' end_of_word	11342	KEYWORD_nosuspend <- 'nosuspend' end_of_word
11342	KEYWORD_null <- 'null' end_of_word	11343	KEYWORD_null <- 'null' end_of_word
		11344	KEYWORD_opaque <- 'opaque' end_of_word
11343	KEYWORD_or <- 'or' end_of_word	11345	KEYWORD_or <- 'or' end_of_word
11344	KEYWORD_orelse <- 'orelse' end_of_word	11346	KEYWORD_orelse <- 'orelse' end_of_word
11345	KEYWORD_packed <- 'packed' end_of_word	11347	KEYWORD_packed <- 'packed' end_of_word
...	@@ -11368,7 +11370,7 @@ keyword <- KEYWORD_align / KEYWORD_and / KEYWORD_anyframe / KEYWORD_anytype	...	@@ -11368,7 +11370,7 @@ keyword <- KEYWORD_align / KEYWORD_and / KEYWORD_anyframe / KEYWORD_anytype
11368	/ KEYWORD_defer / KEYWORD_else / KEYWORD_enum / KEYWORD_errdefer	11370	/ KEYWORD_defer / KEYWORD_else / KEYWORD_enum / KEYWORD_errdefer
11369	/ KEYWORD_error / KEYWORD_export / KEYWORD_extern / KEYWORD_false	11371	/ KEYWORD_error / KEYWORD_export / KEYWORD_extern / KEYWORD_false
11370	/ KEYWORD_fn / KEYWORD_for / KEYWORD_if / KEYWORD_inline	11372	/ KEYWORD_fn / KEYWORD_for / KEYWORD_if / KEYWORD_inline
11371	/ KEYWORD_noalias / KEYWORD_null / KEYWORD_or	11373	/ KEYWORD_noalias / KEYWORD_null / KEYWORD_opaque / KEYWORD_or
11372	/ KEYWORD_orelse / KEYWORD_packed / KEYWORD_pub	11374	/ KEYWORD_orelse / KEYWORD_packed / KEYWORD_pub
11373	/ KEYWORD_resume / KEYWORD_return / KEYWORD_linksection	11375	/ KEYWORD_resume / KEYWORD_return / KEYWORD_linksection
11374	/ KEYWORD_struct / KEYWORD_suspend	11376	/ KEYWORD_struct / KEYWORD_suspend

...	@@ -133,6 +133,7 @@ static const struct ZigKeyword zig_keywords[] = {	...	@@ -133,6 +133,7 @@ static const struct ZigKeyword zig_keywords[] = {
133	{"noinline", TokenIdKeywordNoInline},	133	{"noinline", TokenIdKeywordNoInline},
134	{"nosuspend", TokenIdKeywordNoSuspend},	134	{"nosuspend", TokenIdKeywordNoSuspend},
135	{"null", TokenIdKeywordNull},	135	{"null", TokenIdKeywordNull},
		136	{"opaque", TokenIdKeywordOpaque},
136	{"or", TokenIdKeywordOr},	137	{"or", TokenIdKeywordOr},
137	{"orelse", TokenIdKeywordOrElse},	138	{"orelse", TokenIdKeywordOrElse},
138	{"packed", TokenIdKeywordPacked},	139	{"packed", TokenIdKeywordPacked},
...	@@ -1595,6 +1596,7 @@ const char * token_name(TokenId id) {	...	@@ -1595,6 +1596,7 @@ const char * token_name(TokenId id) {
1595	case TokenIdKeywordNoInline: return "noinline";	1596	case TokenIdKeywordNoInline: return "noinline";
1596	case TokenIdKeywordNoSuspend: return "nosuspend";	1597	case TokenIdKeywordNoSuspend: return "nosuspend";
1597	case TokenIdKeywordNull: return "null";	1598	case TokenIdKeywordNull: return "null";
		1599	case TokenIdKeywordOpaque: return "opaque";
1598	case TokenIdKeywordOr: return "or";	1600	case TokenIdKeywordOr: return "or";
1599	case TokenIdKeywordOrElse: return "orelse";	1601	case TokenIdKeywordOrElse: return "orelse";
1600	case TokenIdKeywordPacked: return "packed";	1602	case TokenIdKeywordPacked: return "packed";