master
1const expect = @import("std").testing.expect;
2const builtin = @import("builtin");
3
4test "@fieldParentPtr struct" {
5 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
6 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
7
8 const C = struct {
9 a: bool = true,
10 b: f32 = 3.14,
11 c: struct { u8 } = .{42},
12 d: i32 = 12345,
13 };
14
15 {
16 const c: C = .{ .a = false };
17 const pcf = &c.a;
18 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
19 try expect(pc == &c);
20 }
21 {
22 const c: C = .{ .a = false };
23 const pcf = &c.a;
24 var pc: *const C = undefined;
25 pc = @alignCast(@fieldParentPtr("a", pcf));
26 try expect(pc == &c);
27 }
28 {
29 const c: C = .{ .a = false };
30 var pcf: @TypeOf(&c.a) = undefined;
31 pcf = &c.a;
32 var pc: *const C = undefined;
33 pc = @alignCast(@fieldParentPtr("a", pcf));
34 try expect(pc == &c);
35 }
36 {
37 var c: C = undefined;
38 c = .{ .a = false };
39 var pcf: @TypeOf(&c.a) = undefined;
40 pcf = &c.a;
41 var pc: *C = undefined;
42 pc = @alignCast(@fieldParentPtr("a", pcf));
43 try expect(pc == &c);
44 }
45
46 {
47 const c: C = .{ .b = 666.667 };
48 const pcf = &c.b;
49 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
50 try expect(pc == &c);
51 }
52 {
53 const c: C = .{ .b = 666.667 };
54 const pcf = &c.b;
55 var pc: *const C = undefined;
56 pc = @alignCast(@fieldParentPtr("b", pcf));
57 try expect(pc == &c);
58 }
59 {
60 const c: C = .{ .b = 666.667 };
61 var pcf: @TypeOf(&c.b) = undefined;
62 pcf = &c.b;
63 var pc: *const C = undefined;
64 pc = @alignCast(@fieldParentPtr("b", pcf));
65 try expect(pc == &c);
66 }
67 {
68 var c: C = undefined;
69 c = .{ .b = 666.667 };
70 var pcf: @TypeOf(&c.b) = undefined;
71 pcf = &c.b;
72 var pc: *C = undefined;
73 pc = @alignCast(@fieldParentPtr("b", pcf));
74 try expect(pc == &c);
75 }
76
77 {
78 const c: C = .{ .c = .{255} };
79 const pcf = &c.c;
80 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
81 try expect(pc == &c);
82 }
83 {
84 const c: C = .{ .c = .{255} };
85 const pcf = &c.c;
86 var pc: *const C = undefined;
87 pc = @alignCast(@fieldParentPtr("c", pcf));
88 try expect(pc == &c);
89 }
90 {
91 const c: C = .{ .c = .{255} };
92 var pcf: @TypeOf(&c.c) = undefined;
93 pcf = &c.c;
94 var pc: *const C = undefined;
95 pc = @alignCast(@fieldParentPtr("c", pcf));
96 try expect(pc == &c);
97 }
98 {
99 var c: C = undefined;
100 c = .{ .c = .{255} };
101 var pcf: @TypeOf(&c.c) = undefined;
102 pcf = &c.c;
103 var pc: *C = undefined;
104 pc = @alignCast(@fieldParentPtr("c", pcf));
105 try expect(pc == &c);
106 }
107
108 {
109 const c: C = .{ .d = -1111111111 };
110 const pcf = &c.d;
111 const pc: *const C = @alignCast(@fieldParentPtr("d", pcf));
112 try expect(pc == &c);
113 }
114 {
115 const c: C = .{ .d = -1111111111 };
116 const pcf = &c.d;
117 var pc: *const C = undefined;
118 pc = @alignCast(@fieldParentPtr("d", pcf));
119 try expect(pc == &c);
120 }
121 {
122 const c: C = .{ .d = -1111111111 };
123 var pcf: @TypeOf(&c.d) = undefined;
124 pcf = &c.d;
125 var pc: *const C = undefined;
126 pc = @alignCast(@fieldParentPtr("d", pcf));
127 try expect(pc == &c);
128 }
129 {
130 var c: C = undefined;
131 c = .{ .d = -1111111111 };
132 var pcf: @TypeOf(&c.d) = undefined;
133 pcf = &c.d;
134 var pc: *C = undefined;
135 pc = @alignCast(@fieldParentPtr("d", pcf));
136 try expect(pc == &c);
137 }
138}
139
140test "@fieldParentPtr extern struct" {
141 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
142 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
143
144 const C = extern struct {
145 a: bool = true,
146 b: f32 = 3.14,
147 c: extern struct { x: u8 } = .{ .x = 42 },
148 d: i32 = 12345,
149 };
150
151 {
152 const c: C = .{ .a = false };
153 const pcf = &c.a;
154 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
155 try expect(pc == &c);
156 }
157 {
158 const c: C = .{ .a = false };
159 const pcf = &c.a;
160 var pc: *const C = undefined;
161 pc = @alignCast(@fieldParentPtr("a", pcf));
162 try expect(pc == &c);
163 }
164 {
165 const c: C = .{ .a = false };
166 var pcf: @TypeOf(&c.a) = undefined;
167 pcf = &c.a;
168 var pc: *const C = undefined;
169 pc = @alignCast(@fieldParentPtr("a", pcf));
170 try expect(pc == &c);
171 }
172 {
173 var c: C = undefined;
174 c = .{ .a = false };
175 var pcf: @TypeOf(&c.a) = undefined;
176 pcf = &c.a;
177 var pc: *C = undefined;
178 pc = @alignCast(@fieldParentPtr("a", pcf));
179 try expect(pc == &c);
180 }
181
182 {
183 const c: C = .{ .b = 666.667 };
184 const pcf = &c.b;
185 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
186 try expect(pc == &c);
187 }
188 {
189 const c: C = .{ .b = 666.667 };
190 const pcf = &c.b;
191 var pc: *const C = undefined;
192 pc = @alignCast(@fieldParentPtr("b", pcf));
193 try expect(pc == &c);
194 }
195 {
196 const c: C = .{ .b = 666.667 };
197 var pcf: @TypeOf(&c.b) = undefined;
198 pcf = &c.b;
199 var pc: *const C = undefined;
200 pc = @alignCast(@fieldParentPtr("b", pcf));
201 try expect(pc == &c);
202 }
203 {
204 var c: C = undefined;
205 c = .{ .b = 666.667 };
206 var pcf: @TypeOf(&c.b) = undefined;
207 pcf = &c.b;
208 var pc: *C = undefined;
209 pc = @alignCast(@fieldParentPtr("b", pcf));
210 try expect(pc == &c);
211 }
212
213 {
214 const c: C = .{ .c = .{ .x = 255 } };
215 const pcf = &c.c;
216 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
217 try expect(pc == &c);
218 }
219 {
220 const c: C = .{ .c = .{ .x = 255 } };
221 const pcf = &c.c;
222 var pc: *const C = undefined;
223 pc = @alignCast(@fieldParentPtr("c", pcf));
224 try expect(pc == &c);
225 }
226 {
227 const c: C = .{ .c = .{ .x = 255 } };
228 var pcf: @TypeOf(&c.c) = undefined;
229 pcf = &c.c;
230 var pc: *const C = undefined;
231 pc = @alignCast(@fieldParentPtr("c", pcf));
232 try expect(pc == &c);
233 }
234 {
235 var c: C = undefined;
236 c = .{ .c = .{ .x = 255 } };
237 var pcf: @TypeOf(&c.c) = undefined;
238 pcf = &c.c;
239 var pc: *C = undefined;
240 pc = @alignCast(@fieldParentPtr("c", pcf));
241 try expect(pc == &c);
242 }
243
244 {
245 const c: C = .{ .d = -1111111111 };
246 const pcf = &c.d;
247 const pc: *const C = @alignCast(@fieldParentPtr("d", pcf));
248 try expect(pc == &c);
249 }
250 {
251 const c: C = .{ .d = -1111111111 };
252 const pcf = &c.d;
253 var pc: *const C = undefined;
254 pc = @alignCast(@fieldParentPtr("d", pcf));
255 try expect(pc == &c);
256 }
257 {
258 const c: C = .{ .d = -1111111111 };
259 var pcf: @TypeOf(&c.d) = undefined;
260 pcf = &c.d;
261 var pc: *const C = undefined;
262 pc = @alignCast(@fieldParentPtr("d", pcf));
263 try expect(pc == &c);
264 }
265 {
266 var c: C = undefined;
267 c = .{ .d = -1111111111 };
268 var pcf: @TypeOf(&c.d) = undefined;
269 pcf = &c.d;
270 var pc: *C = undefined;
271 pc = @alignCast(@fieldParentPtr("d", pcf));
272 try expect(pc == &c);
273 }
274}
275
276test "@fieldParentPtr extern struct first zero-bit field" {
277 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
278 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
279
280 const C = extern struct {
281 a: u0 = 0,
282 b: f32 = 3.14,
283 c: i32 = 12345,
284 };
285
286 {
287 const c: C = .{ .a = 0 };
288 const pcf = &c.a;
289 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
290 try expect(pc == &c);
291 }
292 {
293 const c: C = .{ .a = 0 };
294 const pcf = &c.a;
295 var pc: *const C = undefined;
296 pc = @alignCast(@fieldParentPtr("a", pcf));
297 try expect(pc == &c);
298 }
299 {
300 const c: C = .{ .a = 0 };
301 var pcf: @TypeOf(&c.a) = undefined;
302 pcf = &c.a;
303 var pc: *const C = undefined;
304 pc = @alignCast(@fieldParentPtr("a", pcf));
305 try expect(pc == &c);
306 }
307 {
308 var c: C = undefined;
309 c = .{ .a = 0 };
310 var pcf: @TypeOf(&c.a) = undefined;
311 pcf = &c.a;
312 var pc: *C = undefined;
313 pc = @alignCast(@fieldParentPtr("a", pcf));
314 try expect(pc == &c);
315 }
316
317 {
318 const c: C = .{ .b = 666.667 };
319 const pcf = &c.b;
320 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
321 try expect(pc == &c);
322 }
323 {
324 const c: C = .{ .b = 666.667 };
325 const pcf = &c.b;
326 var pc: *const C = undefined;
327 pc = @alignCast(@fieldParentPtr("b", pcf));
328 try expect(pc == &c);
329 }
330 {
331 const c: C = .{ .b = 666.667 };
332 var pcf: @TypeOf(&c.b) = undefined;
333 pcf = &c.b;
334 var pc: *const C = undefined;
335 pc = @alignCast(@fieldParentPtr("b", pcf));
336 try expect(pc == &c);
337 }
338 {
339 var c: C = undefined;
340 c = .{ .b = 666.667 };
341 var pcf: @TypeOf(&c.b) = undefined;
342 pcf = &c.b;
343 var pc: *C = undefined;
344 pc = @alignCast(@fieldParentPtr("b", pcf));
345 try expect(pc == &c);
346 }
347
348 {
349 const c: C = .{ .c = -1111111111 };
350 const pcf = &c.c;
351 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
352 try expect(pc == &c);
353 }
354 {
355 const c: C = .{ .c = -1111111111 };
356 const pcf = &c.c;
357 var pc: *const C = undefined;
358 pc = @alignCast(@fieldParentPtr("c", pcf));
359 try expect(pc == &c);
360 }
361 {
362 const c: C = .{ .c = -1111111111 };
363 var pcf: @TypeOf(&c.c) = undefined;
364 pcf = &c.c;
365 var pc: *const C = undefined;
366 pc = @alignCast(@fieldParentPtr("c", pcf));
367 try expect(pc == &c);
368 }
369 {
370 var c: C = undefined;
371 c = .{ .c = -1111111111 };
372 var pcf: @TypeOf(&c.c) = undefined;
373 pcf = &c.c;
374 var pc: *C = undefined;
375 pc = @alignCast(@fieldParentPtr("c", pcf));
376 try expect(pc == &c);
377 }
378}
379
380test "@fieldParentPtr extern struct middle zero-bit field" {
381 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
382 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
383
384 const C = extern struct {
385 a: f32 = 3.14,
386 b: u0 = 0,
387 c: i32 = 12345,
388 };
389
390 {
391 const c: C = .{ .a = 666.667 };
392 const pcf = &c.a;
393 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
394 try expect(pc == &c);
395 }
396 {
397 const c: C = .{ .a = 666.667 };
398 const pcf = &c.a;
399 var pc: *const C = undefined;
400 pc = @alignCast(@fieldParentPtr("a", pcf));
401 try expect(pc == &c);
402 }
403 {
404 const c: C = .{ .a = 666.667 };
405 var pcf: @TypeOf(&c.a) = undefined;
406 pcf = &c.a;
407 var pc: *const C = undefined;
408 pc = @alignCast(@fieldParentPtr("a", pcf));
409 try expect(pc == &c);
410 }
411 {
412 var c: C = undefined;
413 c = .{ .a = 666.667 };
414 var pcf: @TypeOf(&c.a) = undefined;
415 pcf = &c.a;
416 var pc: *C = undefined;
417 pc = @alignCast(@fieldParentPtr("a", pcf));
418 try expect(pc == &c);
419 }
420
421 {
422 const c: C = .{ .b = 0 };
423 const pcf = &c.b;
424 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
425 try expect(pc == &c);
426 }
427 {
428 const c: C = .{ .b = 0 };
429 const pcf = &c.b;
430 var pc: *const C = undefined;
431 pc = @alignCast(@fieldParentPtr("b", pcf));
432 try expect(pc == &c);
433 }
434 {
435 const c: C = .{ .b = 0 };
436 var pcf: @TypeOf(&c.b) = undefined;
437 pcf = &c.b;
438 var pc: *const C = undefined;
439 pc = @alignCast(@fieldParentPtr("b", pcf));
440 try expect(pc == &c);
441 }
442 {
443 var c: C = undefined;
444 c = .{ .b = 0 };
445 var pcf: @TypeOf(&c.b) = undefined;
446 pcf = &c.b;
447 var pc: *C = undefined;
448 pc = @alignCast(@fieldParentPtr("b", pcf));
449 try expect(pc == &c);
450 }
451
452 {
453 const c: C = .{ .c = -1111111111 };
454 const pcf = &c.c;
455 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
456 try expect(pc == &c);
457 }
458 {
459 const c: C = .{ .c = -1111111111 };
460 const pcf = &c.c;
461 var pc: *const C = undefined;
462 pc = @alignCast(@fieldParentPtr("c", pcf));
463 try expect(pc == &c);
464 }
465 {
466 const c: C = .{ .c = -1111111111 };
467 var pcf: @TypeOf(&c.c) = undefined;
468 pcf = &c.c;
469 var pc: *const C = undefined;
470 pc = @alignCast(@fieldParentPtr("c", pcf));
471 try expect(pc == &c);
472 }
473 {
474 var c: C = undefined;
475 c = .{ .c = -1111111111 };
476 var pcf: @TypeOf(&c.c) = undefined;
477 pcf = &c.c;
478 var pc: *C = undefined;
479 pc = @alignCast(@fieldParentPtr("c", pcf));
480 try expect(pc == &c);
481 }
482}
483
484test "@fieldParentPtr extern struct last zero-bit field" {
485 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
486 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
487
488 const C = extern struct {
489 a: f32 = 3.14,
490 b: i32 = 12345,
491 c: u0 = 0,
492 };
493
494 {
495 const c: C = .{ .a = 666.667 };
496 const pcf = &c.a;
497 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
498 try expect(pc == &c);
499 }
500 {
501 const c: C = .{ .a = 666.667 };
502 const pcf = &c.a;
503 var pc: *const C = undefined;
504 pc = @alignCast(@fieldParentPtr("a", pcf));
505 try expect(pc == &c);
506 }
507 {
508 const c: C = .{ .a = 666.667 };
509 var pcf: @TypeOf(&c.a) = undefined;
510 pcf = &c.a;
511 var pc: *const C = undefined;
512 pc = @alignCast(@fieldParentPtr("a", pcf));
513 try expect(pc == &c);
514 }
515 {
516 var c: C = undefined;
517 c = .{ .a = 666.667 };
518 var pcf: @TypeOf(&c.a) = undefined;
519 pcf = &c.a;
520 var pc: *C = undefined;
521 pc = @alignCast(@fieldParentPtr("a", pcf));
522 try expect(pc == &c);
523 }
524
525 {
526 const c: C = .{ .b = -1111111111 };
527 const pcf = &c.b;
528 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
529 try expect(pc == &c);
530 }
531 {
532 const c: C = .{ .b = -1111111111 };
533 const pcf = &c.b;
534 var pc: *const C = undefined;
535 pc = @alignCast(@fieldParentPtr("b", pcf));
536 try expect(pc == &c);
537 }
538 {
539 const c: C = .{ .b = -1111111111 };
540 var pcf: @TypeOf(&c.b) = undefined;
541 pcf = &c.b;
542 var pc: *const C = undefined;
543 pc = @alignCast(@fieldParentPtr("b", pcf));
544 try expect(pc == &c);
545 }
546 {
547 var c: C = undefined;
548 c = .{ .b = -1111111111 };
549 var pcf: @TypeOf(&c.b) = undefined;
550 pcf = &c.b;
551 var pc: *C = undefined;
552 pc = @alignCast(@fieldParentPtr("b", pcf));
553 try expect(pc == &c);
554 }
555
556 {
557 const c: C = .{ .c = 0 };
558 const pcf = &c.c;
559 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
560 try expect(pc == &c);
561 }
562 {
563 const c: C = .{ .c = 0 };
564 const pcf = &c.c;
565 var pc: *const C = undefined;
566 pc = @alignCast(@fieldParentPtr("c", pcf));
567 try expect(pc == &c);
568 }
569 {
570 const c: C = .{ .c = 0 };
571 var pcf: @TypeOf(&c.c) = undefined;
572 pcf = &c.c;
573 var pc: *const C = undefined;
574 pc = @alignCast(@fieldParentPtr("c", pcf));
575 try expect(pc == &c);
576 }
577 {
578 var c: C = undefined;
579 c = .{ .c = 0 };
580 var pcf: @TypeOf(&c.c) = undefined;
581 pcf = &c.c;
582 var pc: *C = undefined;
583 pc = @alignCast(@fieldParentPtr("c", pcf));
584 try expect(pc == &c);
585 }
586}
587
588test "@fieldParentPtr unaligned packed struct" {
589 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
590 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
591 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
592 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
593 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
594 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
595
596 const C = packed struct {
597 a: bool = true,
598 b: f32 = 3.14,
599 c: packed struct { x: u8 } = .{ .x = 42 },
600 d: i32 = 12345,
601 };
602
603 {
604 const c: C = .{ .a = false };
605 const pcf = &c.a;
606 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
607 try expect(pc == &c);
608 }
609 {
610 const c: C = .{ .a = false };
611 const pcf = &c.a;
612 var pc: *const C = undefined;
613 pc = @alignCast(@fieldParentPtr("a", pcf));
614 try expect(pc == &c);
615 }
616 {
617 const c: C = .{ .a = false };
618 var pcf: @TypeOf(&c.a) = undefined;
619 pcf = &c.a;
620 var pc: *const C = undefined;
621 pc = @alignCast(@fieldParentPtr("a", pcf));
622 try expect(pc == &c);
623 }
624 {
625 var c: C = undefined;
626 c = .{ .a = false };
627 var pcf: @TypeOf(&c.a) = undefined;
628 pcf = &c.a;
629 var pc: *C = undefined;
630 pc = @alignCast(@fieldParentPtr("a", pcf));
631 try expect(pc == &c);
632 }
633
634 {
635 const c: C = .{ .b = 666.667 };
636 const pcf = &c.b;
637 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
638 try expect(pc == &c);
639 }
640 {
641 const c: C = .{ .b = 666.667 };
642 const pcf = &c.b;
643 var pc: *const C = undefined;
644 pc = @alignCast(@fieldParentPtr("b", pcf));
645 try expect(pc == &c);
646 }
647 {
648 const c: C = .{ .b = 666.667 };
649 var pcf: @TypeOf(&c.b) = undefined;
650 pcf = &c.b;
651 var pc: *const C = undefined;
652 pc = @alignCast(@fieldParentPtr("b", pcf));
653 try expect(pc == &c);
654 }
655 {
656 var c: C = undefined;
657 c = .{ .b = 666.667 };
658 var pcf: @TypeOf(&c.b) = undefined;
659 pcf = &c.b;
660 var pc: *C = undefined;
661 pc = @alignCast(@fieldParentPtr("b", pcf));
662 try expect(pc == &c);
663 }
664
665 {
666 const c: C = .{ .c = .{ .x = 255 } };
667 const pcf = &c.c;
668 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
669 try expect(pc == &c);
670 }
671 {
672 const c: C = .{ .c = .{ .x = 255 } };
673 const pcf = &c.c;
674 var pc: *const C = undefined;
675 pc = @alignCast(@fieldParentPtr("c", pcf));
676 try expect(pc == &c);
677 }
678 {
679 const c: C = .{ .c = .{ .x = 255 } };
680 var pcf: @TypeOf(&c.c) = undefined;
681 pcf = &c.c;
682 var pc: *const C = undefined;
683 pc = @alignCast(@fieldParentPtr("c", pcf));
684 try expect(pc == &c);
685 }
686 {
687 var c: C = undefined;
688 c = .{ .c = .{ .x = 255 } };
689 var pcf: @TypeOf(&c.c) = undefined;
690 pcf = &c.c;
691 var pc: *C = undefined;
692 pc = @alignCast(@fieldParentPtr("c", pcf));
693 try expect(pc == &c);
694 }
695
696 {
697 const c: C = .{ .d = -1111111111 };
698 const pcf = &c.d;
699 const pc: *const C = @alignCast(@fieldParentPtr("d", pcf));
700 try expect(pc == &c);
701 }
702 {
703 const c: C = .{ .d = -1111111111 };
704 const pcf = &c.d;
705 var pc: *const C = undefined;
706 pc = @alignCast(@fieldParentPtr("d", pcf));
707 try expect(pc == &c);
708 }
709 {
710 const c: C = .{ .d = -1111111111 };
711 var pcf: @TypeOf(&c.d) = undefined;
712 pcf = &c.d;
713 var pc: *const C = undefined;
714 pc = @alignCast(@fieldParentPtr("d", pcf));
715 try expect(pc == &c);
716 }
717 {
718 var c: C = undefined;
719 c = .{ .d = -1111111111 };
720 var pcf: @TypeOf(&c.d) = undefined;
721 pcf = &c.d;
722 var pc: *C = undefined;
723 pc = @alignCast(@fieldParentPtr("d", pcf));
724 try expect(pc == &c);
725 }
726}
727
728test "@fieldParentPtr aligned packed struct" {
729 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
730 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
731 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
732 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
733 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
734 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
735
736 const C = packed struct {
737 a: f32 = 3.14,
738 b: i32 = 12345,
739 c: packed struct { x: u8 } = .{ .x = 42 },
740 d: bool = true,
741 };
742
743 {
744 const c: C = .{ .a = 666.667 };
745 const pcf = &c.a;
746 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
747 try expect(pc == &c);
748 }
749 {
750 const c: C = .{ .a = 666.667 };
751 const pcf = &c.a;
752 var pc: *const C = undefined;
753 pc = @alignCast(@fieldParentPtr("a", pcf));
754 try expect(pc == &c);
755 }
756 {
757 const c: C = .{ .a = 666.667 };
758 var pcf: @TypeOf(&c.a) = undefined;
759 pcf = &c.a;
760 var pc: *const C = undefined;
761 pc = @alignCast(@fieldParentPtr("a", pcf));
762 try expect(pc == &c);
763 }
764 {
765 var c: C = undefined;
766 c = .{ .a = 666.667 };
767 var pcf: @TypeOf(&c.a) = undefined;
768 pcf = &c.a;
769 var pc: *C = undefined;
770 pc = @alignCast(@fieldParentPtr("a", pcf));
771 try expect(pc == &c);
772 }
773
774 {
775 const c: C = .{ .b = -1111111111 };
776 const pcf = &c.b;
777 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
778 try expect(pc == &c);
779 }
780 {
781 const c: C = .{ .b = -1111111111 };
782 const pcf = &c.b;
783 var pc: *const C = undefined;
784 pc = @alignCast(@fieldParentPtr("b", pcf));
785 try expect(pc == &c);
786 }
787 {
788 const c: C = .{ .b = -1111111111 };
789 var pcf: @TypeOf(&c.b) = undefined;
790 pcf = &c.b;
791 var pc: *const C = undefined;
792 pc = @alignCast(@fieldParentPtr("b", pcf));
793 try expect(pc == &c);
794 }
795 {
796 var c: C = undefined;
797 c = .{ .b = -1111111111 };
798 var pcf: @TypeOf(&c.b) = undefined;
799 pcf = &c.b;
800 var pc: *C = undefined;
801 pc = @alignCast(@fieldParentPtr("b", pcf));
802 try expect(pc == &c);
803 }
804
805 {
806 const c: C = .{ .c = .{ .x = 255 } };
807 const pcf = &c.c;
808 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
809 try expect(pc == &c);
810 }
811 {
812 const c: C = .{ .c = .{ .x = 255 } };
813 const pcf = &c.c;
814 var pc: *const C = undefined;
815 pc = @alignCast(@fieldParentPtr("c", pcf));
816 try expect(pc == &c);
817 }
818 {
819 const c: C = .{ .c = .{ .x = 255 } };
820 var pcf: @TypeOf(&c.c) = undefined;
821 pcf = &c.c;
822 var pc: *const C = undefined;
823 pc = @alignCast(@fieldParentPtr("c", pcf));
824 try expect(pc == &c);
825 }
826 {
827 var c: C = undefined;
828 c = .{ .c = .{ .x = 255 } };
829 var pcf: @TypeOf(&c.c) = undefined;
830 pcf = &c.c;
831 var pc: *C = undefined;
832 pc = @alignCast(@fieldParentPtr("c", pcf));
833 try expect(pc == &c);
834 }
835
836 {
837 const c: C = .{ .d = false };
838 const pcf = &c.d;
839 const pc: *const C = @alignCast(@fieldParentPtr("d", pcf));
840 try expect(pc == &c);
841 }
842 {
843 const c: C = .{ .d = false };
844 const pcf = &c.d;
845 var pc: *const C = undefined;
846 pc = @alignCast(@fieldParentPtr("d", pcf));
847 try expect(pc == &c);
848 }
849 {
850 const c: C = .{ .d = false };
851 var pcf: @TypeOf(&c.d) = undefined;
852 pcf = &c.d;
853 var pc: *const C = undefined;
854 pc = @alignCast(@fieldParentPtr("d", pcf));
855 try expect(pc == &c);
856 }
857 {
858 var c: C = undefined;
859 c = .{ .d = false };
860 var pcf: @TypeOf(&c.d) = undefined;
861 pcf = &c.d;
862 var pc: *C = undefined;
863 pc = @alignCast(@fieldParentPtr("d", pcf));
864 try expect(pc == &c);
865 }
866}
867
868test "@fieldParentPtr nested packed struct" {
869 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
870 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
871 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
872 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
873
874 {
875 const C = packed struct {
876 a: u8,
877 b: packed struct {
878 a: u8,
879 b: packed struct {
880 a: u8,
881 },
882 },
883 };
884
885 {
886 const c: C = .{ .a = 0, .b = .{ .a = 0, .b = .{ .a = 0 } } };
887 const pcbba = &c.b.b.a;
888 const pcbb: @TypeOf(&c.b.b) = @alignCast(@fieldParentPtr("a", pcbba));
889 try expect(pcbb == &c.b.b);
890 const pcb: @TypeOf(&c.b) = @alignCast(@fieldParentPtr("b", pcbb));
891 try expect(pcb == &c.b);
892 const pc: *const C = @alignCast(@fieldParentPtr("b", pcb));
893 try expect(pc == &c);
894 }
895
896 {
897 var c: C = undefined;
898 c = .{ .a = 0, .b = .{ .a = 0, .b = .{ .a = 0 } } };
899 var pcbba: @TypeOf(&c.b.b.a) = undefined;
900 pcbba = &c.b.b.a;
901 var pcbb: @TypeOf(&c.b.b) = undefined;
902 pcbb = @alignCast(@fieldParentPtr("a", pcbba));
903 try expect(pcbb == &c.b.b);
904 var pcb: @TypeOf(&c.b) = undefined;
905 pcb = @alignCast(@fieldParentPtr("b", pcbb));
906 try expect(pcb == &c.b);
907 var pc: *C = undefined;
908 pc = @alignCast(@fieldParentPtr("b", pcb));
909 try expect(pc == &c);
910 }
911 }
912
913 {
914 const C = packed struct {
915 a: u8,
916 b: packed struct {
917 a: u9,
918 b: packed struct {
919 a: u8,
920 },
921 },
922 };
923
924 {
925 const c: C = .{ .a = 0, .b = .{ .a = 0, .b = .{ .a = 0 } } };
926 const pcbba = &c.b.b.a;
927 const pcbb: @TypeOf(&c.b.b) = @alignCast(@fieldParentPtr("a", pcbba));
928 try expect(pcbb == &c.b.b);
929 const pcb: @TypeOf(&c.b) = @alignCast(@fieldParentPtr("b", pcbb));
930 try expect(pcb == &c.b);
931 const pc: *const C = @alignCast(@fieldParentPtr("b", pcb));
932 try expect(pc == &c);
933 }
934
935 {
936 var c: C = undefined;
937 c = .{ .a = 0, .b = .{ .a = 0, .b = .{ .a = 0 } } };
938 var pcbba: @TypeOf(&c.b.b.a) = undefined;
939 pcbba = &c.b.b.a;
940 var pcbb: @TypeOf(&c.b.b) = undefined;
941 pcbb = @alignCast(@fieldParentPtr("a", pcbba));
942 try expect(pcbb == &c.b.b);
943 var pcb: @TypeOf(&c.b) = undefined;
944 pcb = @alignCast(@fieldParentPtr("b", pcbb));
945 try expect(pcb == &c.b);
946 var pc: *C = undefined;
947 pc = @alignCast(@fieldParentPtr("b", pcb));
948 try expect(pc == &c);
949 }
950 }
951
952 {
953 const C = packed struct {
954 a: u9,
955 b: packed struct {
956 a: u7,
957 b: packed struct {
958 a: u8,
959 },
960 },
961 };
962
963 {
964 const c: C = .{ .a = 0, .b = .{ .a = 0, .b = .{ .a = 0 } } };
965 const pcbba = &c.b.b.a;
966 const pcbb: @TypeOf(&c.b.b) = @alignCast(@fieldParentPtr("a", pcbba));
967 try expect(pcbb == &c.b.b);
968 const pcb: @TypeOf(&c.b) = @alignCast(@fieldParentPtr("b", pcbb));
969 try expect(pcb == &c.b);
970 const pc: *const C = @alignCast(@fieldParentPtr("b", pcb));
971 try expect(pc == &c);
972 }
973
974 {
975 var c: C = undefined;
976 c = .{ .a = 0, .b = .{ .a = 0, .b = .{ .a = 0 } } };
977 var pcbba: @TypeOf(&c.b.b.a) = undefined;
978 pcbba = &c.b.b.a;
979 var pcbb: @TypeOf(&c.b.b) = undefined;
980 pcbb = @alignCast(@fieldParentPtr("a", pcbba));
981 try expect(pcbb == &c.b.b);
982 var pcb: @TypeOf(&c.b) = undefined;
983 pcb = @alignCast(@fieldParentPtr("b", pcbb));
984 try expect(pcb == &c.b);
985 var pc: *C = undefined;
986 pc = @alignCast(@fieldParentPtr("b", pcb));
987 try expect(pc == &c);
988 }
989 }
990
991 {
992 const C = packed struct {
993 a: u9,
994 b: packed struct {
995 a: u8,
996 b: packed struct {
997 a: u8,
998 },
999 },
1000 };
1001
1002 {
1003 const c: C = .{ .a = 0, .b = .{ .a = 0, .b = .{ .a = 0 } } };
1004 const pcbba = &c.b.b.a;
1005 const pcbb: @TypeOf(&c.b.b) = @alignCast(@fieldParentPtr("a", pcbba));
1006 try expect(pcbb == &c.b.b);
1007 const pcb: @TypeOf(&c.b) = @alignCast(@fieldParentPtr("b", pcbb));
1008 try expect(pcb == &c.b);
1009 const pc: *const C = @alignCast(@fieldParentPtr("b", pcb));
1010 try expect(pc == &c);
1011 }
1012
1013 {
1014 var c: C = undefined;
1015 c = .{ .a = 0, .b = .{ .a = 0, .b = .{ .a = 0 } } };
1016 var pcbba: @TypeOf(&c.b.b.a) = undefined;
1017 pcbba = &c.b.b.a;
1018 var pcbb: @TypeOf(&c.b.b) = undefined;
1019 pcbb = @alignCast(@fieldParentPtr("a", pcbba));
1020 try expect(pcbb == &c.b.b);
1021 var pcb: @TypeOf(&c.b) = undefined;
1022 pcb = @alignCast(@fieldParentPtr("b", pcbb));
1023 try expect(pcb == &c.b);
1024 var pc: *C = undefined;
1025 pc = @alignCast(@fieldParentPtr("b", pcb));
1026 try expect(pc == &c);
1027 }
1028 }
1029}
1030
1031test "@fieldParentPtr packed struct first zero-bit field" {
1032 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1033 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1034 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1035 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1036
1037 const C = packed struct {
1038 a: u0 = 0,
1039 b: f32 = 3.14,
1040 c: i32 = 12345,
1041 };
1042
1043 {
1044 const c: C = .{ .a = 0 };
1045 const pcf = &c.a;
1046 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
1047 try expect(pc == &c);
1048 }
1049 {
1050 const c: C = .{ .a = 0 };
1051 const pcf = &c.a;
1052 var pc: *const C = undefined;
1053 pc = @alignCast(@fieldParentPtr("a", pcf));
1054 try expect(pc == &c);
1055 }
1056 {
1057 const c: C = .{ .a = 0 };
1058 var pcf: @TypeOf(&c.a) = undefined;
1059 pcf = &c.a;
1060 var pc: *const C = undefined;
1061 pc = @alignCast(@fieldParentPtr("a", pcf));
1062 try expect(pc == &c);
1063 }
1064 {
1065 var c: C = undefined;
1066 c = .{ .a = 0 };
1067 var pcf: @TypeOf(&c.a) = undefined;
1068 pcf = &c.a;
1069 var pc: *C = undefined;
1070 pc = @alignCast(@fieldParentPtr("a", pcf));
1071 try expect(pc == &c);
1072 }
1073
1074 {
1075 const c: C = .{ .b = 666.667 };
1076 const pcf = &c.b;
1077 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
1078 try expect(pc == &c);
1079 }
1080 {
1081 const c: C = .{ .b = 666.667 };
1082 const pcf = &c.b;
1083 var pc: *const C = undefined;
1084 pc = @alignCast(@fieldParentPtr("b", pcf));
1085 try expect(pc == &c);
1086 }
1087 {
1088 const c: C = .{ .b = 666.667 };
1089 var pcf: @TypeOf(&c.b) = undefined;
1090 pcf = &c.b;
1091 var pc: *const C = undefined;
1092 pc = @alignCast(@fieldParentPtr("b", pcf));
1093 try expect(pc == &c);
1094 }
1095 {
1096 var c: C = undefined;
1097 c = .{ .b = 666.667 };
1098 var pcf: @TypeOf(&c.b) = undefined;
1099 pcf = &c.b;
1100 var pc: *C = undefined;
1101 pc = @alignCast(@fieldParentPtr("b", pcf));
1102 try expect(pc == &c);
1103 }
1104
1105 {
1106 const c: C = .{ .c = -1111111111 };
1107 const pcf = &c.c;
1108 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
1109 try expect(pc == &c);
1110 }
1111 {
1112 const c: C = .{ .c = -1111111111 };
1113 const pcf = &c.c;
1114 var pc: *const C = undefined;
1115 pc = @alignCast(@fieldParentPtr("c", pcf));
1116 try expect(pc == &c);
1117 }
1118 {
1119 const c: C = .{ .c = -1111111111 };
1120 var pcf: @TypeOf(&c.c) = undefined;
1121 pcf = &c.c;
1122 var pc: *const C = undefined;
1123 pc = @alignCast(@fieldParentPtr("c", pcf));
1124 try expect(pc == &c);
1125 }
1126 {
1127 var c: C = undefined;
1128 c = .{ .c = -1111111111 };
1129 var pcf: @TypeOf(&c.c) = undefined;
1130 pcf = &c.c;
1131 var pc: *C = undefined;
1132 pc = @alignCast(@fieldParentPtr("c", pcf));
1133 try expect(pc == &c);
1134 }
1135}
1136
1137test "@fieldParentPtr packed struct middle zero-bit field" {
1138 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1139 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1140 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1141 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1142
1143 const C = packed struct {
1144 a: f32 = 3.14,
1145 b: u0 = 0,
1146 c: i32 = 12345,
1147 };
1148
1149 {
1150 const c: C = .{ .a = 666.667 };
1151 const pcf = &c.a;
1152 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
1153 try expect(pc == &c);
1154 }
1155 {
1156 const c: C = .{ .a = 666.667 };
1157 const pcf = &c.a;
1158 var pc: *const C = undefined;
1159 pc = @alignCast(@fieldParentPtr("a", pcf));
1160 try expect(pc == &c);
1161 }
1162 {
1163 const c: C = .{ .a = 666.667 };
1164 var pcf: @TypeOf(&c.a) = undefined;
1165 pcf = &c.a;
1166 var pc: *const C = undefined;
1167 pc = @alignCast(@fieldParentPtr("a", pcf));
1168 try expect(pc == &c);
1169 }
1170 {
1171 var c: C = undefined;
1172 c = .{ .a = 666.667 };
1173 var pcf: @TypeOf(&c.a) = undefined;
1174 pcf = &c.a;
1175 var pc: *C = undefined;
1176 pc = @alignCast(@fieldParentPtr("a", pcf));
1177 try expect(pc == &c);
1178 }
1179
1180 {
1181 const c: C = .{ .b = 0 };
1182 const pcf = &c.b;
1183 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
1184 try expect(pc == &c);
1185 }
1186 {
1187 const c: C = .{ .b = 0 };
1188 const pcf = &c.b;
1189 var pc: *const C = undefined;
1190 pc = @alignCast(@fieldParentPtr("b", pcf));
1191 try expect(pc == &c);
1192 }
1193 {
1194 const c: C = .{ .b = 0 };
1195 var pcf: @TypeOf(&c.b) = undefined;
1196 pcf = &c.b;
1197 var pc: *const C = undefined;
1198 pc = @alignCast(@fieldParentPtr("b", pcf));
1199 try expect(pc == &c);
1200 }
1201 {
1202 var c: C = undefined;
1203 c = .{ .b = 0 };
1204 var pcf: @TypeOf(&c.b) = undefined;
1205 pcf = &c.b;
1206 var pc: *C = undefined;
1207 pc = @alignCast(@fieldParentPtr("b", pcf));
1208 try expect(pc == &c);
1209 }
1210
1211 {
1212 const c: C = .{ .c = -1111111111 };
1213 const pcf = &c.c;
1214 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
1215 try expect(pc == &c);
1216 }
1217 {
1218 const c: C = .{ .c = -1111111111 };
1219 const pcf = &c.c;
1220 var pc: *const C = undefined;
1221 pc = @alignCast(@fieldParentPtr("c", pcf));
1222 try expect(pc == &c);
1223 }
1224 {
1225 const c: C = .{ .c = -1111111111 };
1226 var pcf: @TypeOf(&c.c) = undefined;
1227 pcf = &c.c;
1228 var pc: *const C = undefined;
1229 pc = @alignCast(@fieldParentPtr("c", pcf));
1230 try expect(pc == &c);
1231 }
1232 {
1233 var c: C = undefined;
1234 c = .{ .c = -1111111111 };
1235 var pcf: @TypeOf(&c.c) = undefined;
1236 pcf = &c.c;
1237 var pc: *C = undefined;
1238 pc = @alignCast(@fieldParentPtr("c", pcf));
1239 try expect(pc == &c);
1240 }
1241}
1242
1243test "@fieldParentPtr packed struct last zero-bit field" {
1244 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1245 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1246 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1247 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1248
1249 const C = packed struct {
1250 a: f32 = 3.14,
1251 b: i32 = 12345,
1252 c: u0 = 0,
1253 };
1254
1255 {
1256 const c: C = .{ .a = 666.667 };
1257 const pcf = &c.a;
1258 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
1259 try expect(pc == &c);
1260 }
1261 {
1262 const c: C = .{ .a = 666.667 };
1263 const pcf = &c.a;
1264 var pc: *const C = undefined;
1265 pc = @alignCast(@fieldParentPtr("a", pcf));
1266 try expect(pc == &c);
1267 }
1268 {
1269 const c: C = .{ .a = 666.667 };
1270 var pcf: @TypeOf(&c.a) = undefined;
1271 pcf = &c.a;
1272 var pc: *const C = undefined;
1273 pc = @alignCast(@fieldParentPtr("a", pcf));
1274 try expect(pc == &c);
1275 }
1276 {
1277 var c: C = undefined;
1278 c = .{ .a = 666.667 };
1279 var pcf: @TypeOf(&c.a) = undefined;
1280 pcf = &c.a;
1281 var pc: *C = undefined;
1282 pc = @alignCast(@fieldParentPtr("a", pcf));
1283 try expect(pc == &c);
1284 }
1285
1286 {
1287 const c: C = .{ .b = -1111111111 };
1288 const pcf = &c.b;
1289 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
1290 try expect(pc == &c);
1291 }
1292 {
1293 const c: C = .{ .b = -1111111111 };
1294 const pcf = &c.b;
1295 var pc: *const C = undefined;
1296 pc = @alignCast(@fieldParentPtr("b", pcf));
1297 try expect(pc == &c);
1298 }
1299 {
1300 const c: C = .{ .b = -1111111111 };
1301 var pcf: @TypeOf(&c.b) = undefined;
1302 pcf = &c.b;
1303 var pc: *const C = undefined;
1304 pc = @alignCast(@fieldParentPtr("b", pcf));
1305 try expect(pc == &c);
1306 }
1307 {
1308 var c: C = undefined;
1309 c = .{ .b = -1111111111 };
1310 var pcf: @TypeOf(&c.b) = undefined;
1311 pcf = &c.b;
1312 var pc: *C = undefined;
1313 pc = @alignCast(@fieldParentPtr("b", pcf));
1314 try expect(pc == &c);
1315 }
1316
1317 {
1318 const c: C = .{ .c = 0 };
1319 const pcf = &c.c;
1320 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
1321 try expect(pc == &c);
1322 }
1323 {
1324 const c: C = .{ .c = 0 };
1325 const pcf = &c.c;
1326 var pc: *const C = undefined;
1327 pc = @alignCast(@fieldParentPtr("c", pcf));
1328 try expect(pc == &c);
1329 }
1330 {
1331 const c: C = .{ .c = 0 };
1332 var pcf: @TypeOf(&c.c) = undefined;
1333 pcf = &c.c;
1334 var pc: *const C = undefined;
1335 pc = @alignCast(@fieldParentPtr("c", pcf));
1336 try expect(pc == &c);
1337 }
1338 {
1339 var c: C = undefined;
1340 c = .{ .c = 0 };
1341 var pcf: @TypeOf(&c.c) = undefined;
1342 pcf = &c.c;
1343 var pc: *C = undefined;
1344 pc = @alignCast(@fieldParentPtr("c", pcf));
1345 try expect(pc == &c);
1346 }
1347}
1348
1349test "@fieldParentPtr tagged union" {
1350 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1351 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1352
1353 const C = union(enum) {
1354 a: bool,
1355 b: f32,
1356 c: struct { u8 },
1357 d: i32,
1358 };
1359
1360 {
1361 const c: C = .{ .a = false };
1362 const pcf = &c.a;
1363 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
1364 try expect(pc == &c);
1365 }
1366 {
1367 const c: C = .{ .a = false };
1368 const pcf = &c.a;
1369 var pc: *const C = undefined;
1370 pc = @alignCast(@fieldParentPtr("a", pcf));
1371 try expect(pc == &c);
1372 }
1373 {
1374 const c: C = .{ .a = false };
1375 var pcf: @TypeOf(&c.a) = undefined;
1376 pcf = &c.a;
1377 var pc: *const C = undefined;
1378 pc = @alignCast(@fieldParentPtr("a", pcf));
1379 try expect(pc == &c);
1380 }
1381 {
1382 var c: C = undefined;
1383 c = .{ .a = false };
1384 var pcf: @TypeOf(&c.a) = undefined;
1385 pcf = &c.a;
1386 var pc: *C = undefined;
1387 pc = @alignCast(@fieldParentPtr("a", pcf));
1388 try expect(pc == &c);
1389 }
1390
1391 {
1392 const c: C = .{ .b = 0 };
1393 const pcf = &c.b;
1394 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
1395 try expect(pc == &c);
1396 }
1397 {
1398 const c: C = .{ .b = 0 };
1399 const pcf = &c.b;
1400 var pc: *const C = undefined;
1401 pc = @alignCast(@fieldParentPtr("b", pcf));
1402 try expect(pc == &c);
1403 }
1404 {
1405 const c: C = .{ .b = 0 };
1406 var pcf: @TypeOf(&c.b) = undefined;
1407 pcf = &c.b;
1408 var pc: *const C = undefined;
1409 pc = @alignCast(@fieldParentPtr("b", pcf));
1410 try expect(pc == &c);
1411 }
1412 {
1413 var c: C = undefined;
1414 c = .{ .b = 0 };
1415 var pcf: @TypeOf(&c.b) = undefined;
1416 pcf = &c.b;
1417 var pc: *C = undefined;
1418 pc = @alignCast(@fieldParentPtr("b", pcf));
1419 try expect(pc == &c);
1420 }
1421
1422 {
1423 const c: C = .{ .c = .{255} };
1424 const pcf = &c.c;
1425 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
1426 try expect(pc == &c);
1427 }
1428 {
1429 const c: C = .{ .c = .{255} };
1430 const pcf = &c.c;
1431 var pc: *const C = undefined;
1432 pc = @alignCast(@fieldParentPtr("c", pcf));
1433 try expect(pc == &c);
1434 }
1435 {
1436 const c: C = .{ .c = .{255} };
1437 var pcf: @TypeOf(&c.c) = undefined;
1438 pcf = &c.c;
1439 var pc: *const C = undefined;
1440 pc = @alignCast(@fieldParentPtr("c", pcf));
1441 try expect(pc == &c);
1442 }
1443 {
1444 var c: C = undefined;
1445 c = .{ .c = .{255} };
1446 var pcf: @TypeOf(&c.c) = undefined;
1447 pcf = &c.c;
1448 var pc: *C = undefined;
1449 pc = @alignCast(@fieldParentPtr("c", pcf));
1450 try expect(pc == &c);
1451 }
1452
1453 {
1454 const c: C = .{ .d = -1111111111 };
1455 const pcf = &c.d;
1456 const pc: *const C = @alignCast(@fieldParentPtr("d", pcf));
1457 try expect(pc == &c);
1458 }
1459 {
1460 const c: C = .{ .d = -1111111111 };
1461 const pcf = &c.d;
1462 var pc: *const C = undefined;
1463 pc = @alignCast(@fieldParentPtr("d", pcf));
1464 try expect(pc == &c);
1465 }
1466 {
1467 const c: C = .{ .d = -1111111111 };
1468 var pcf: @TypeOf(&c.d) = undefined;
1469 pcf = &c.d;
1470 var pc: *const C = undefined;
1471 pc = @alignCast(@fieldParentPtr("d", pcf));
1472 try expect(pc == &c);
1473 }
1474 {
1475 var c: C = undefined;
1476 c = .{ .d = -1111111111 };
1477 var pcf: @TypeOf(&c.d) = undefined;
1478 pcf = &c.d;
1479 var pc: *C = undefined;
1480 pc = @alignCast(@fieldParentPtr("d", pcf));
1481 try expect(pc == &c);
1482 }
1483}
1484
1485test "@fieldParentPtr untagged union" {
1486 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1487 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1488
1489 const C = union {
1490 a: bool,
1491 b: f32,
1492 c: struct { u8 },
1493 d: i32,
1494 };
1495
1496 {
1497 const c: C = .{ .a = false };
1498 const pcf = &c.a;
1499 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
1500 try expect(pc == &c);
1501 }
1502 {
1503 const c: C = .{ .a = false };
1504 const pcf = &c.a;
1505 var pc: *const C = undefined;
1506 pc = @alignCast(@fieldParentPtr("a", pcf));
1507 try expect(pc == &c);
1508 }
1509 {
1510 const c: C = .{ .a = false };
1511 var pcf: @TypeOf(&c.a) = undefined;
1512 pcf = &c.a;
1513 var pc: *const C = undefined;
1514 pc = @alignCast(@fieldParentPtr("a", pcf));
1515 try expect(pc == &c);
1516 }
1517 {
1518 var c: C = undefined;
1519 c = .{ .a = false };
1520 var pcf: @TypeOf(&c.a) = undefined;
1521 pcf = &c.a;
1522 var pc: *C = undefined;
1523 pc = @alignCast(@fieldParentPtr("a", pcf));
1524 try expect(pc == &c);
1525 }
1526
1527 {
1528 const c: C = .{ .b = 0 };
1529 const pcf = &c.b;
1530 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
1531 try expect(pc == &c);
1532 }
1533 {
1534 const c: C = .{ .b = 0 };
1535 const pcf = &c.b;
1536 var pc: *const C = undefined;
1537 pc = @alignCast(@fieldParentPtr("b", pcf));
1538 try expect(pc == &c);
1539 }
1540 {
1541 const c: C = .{ .b = 0 };
1542 var pcf: @TypeOf(&c.b) = undefined;
1543 pcf = &c.b;
1544 var pc: *const C = undefined;
1545 pc = @alignCast(@fieldParentPtr("b", pcf));
1546 try expect(pc == &c);
1547 }
1548 {
1549 var c: C = undefined;
1550 c = .{ .b = 0 };
1551 var pcf: @TypeOf(&c.b) = undefined;
1552 pcf = &c.b;
1553 var pc: *C = undefined;
1554 pc = @alignCast(@fieldParentPtr("b", pcf));
1555 try expect(pc == &c);
1556 }
1557
1558 {
1559 const c: C = .{ .c = .{255} };
1560 const pcf = &c.c;
1561 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
1562 try expect(pc == &c);
1563 }
1564 {
1565 const c: C = .{ .c = .{255} };
1566 const pcf = &c.c;
1567 var pc: *const C = undefined;
1568 pc = @alignCast(@fieldParentPtr("c", pcf));
1569 try expect(pc == &c);
1570 }
1571 {
1572 const c: C = .{ .c = .{255} };
1573 var pcf: @TypeOf(&c.c) = undefined;
1574 pcf = &c.c;
1575 var pc: *const C = undefined;
1576 pc = @alignCast(@fieldParentPtr("c", pcf));
1577 try expect(pc == &c);
1578 }
1579 {
1580 var c: C = undefined;
1581 c = .{ .c = .{255} };
1582 var pcf: @TypeOf(&c.c) = undefined;
1583 pcf = &c.c;
1584 var pc: *C = undefined;
1585 pc = @alignCast(@fieldParentPtr("c", pcf));
1586 try expect(pc == &c);
1587 }
1588
1589 {
1590 const c: C = .{ .d = -1111111111 };
1591 const pcf = &c.d;
1592 const pc: *const C = @alignCast(@fieldParentPtr("d", pcf));
1593 try expect(pc == &c);
1594 }
1595 {
1596 const c: C = .{ .d = -1111111111 };
1597 const pcf = &c.d;
1598 var pc: *const C = undefined;
1599 pc = @alignCast(@fieldParentPtr("d", pcf));
1600 try expect(pc == &c);
1601 }
1602 {
1603 const c: C = .{ .d = -1111111111 };
1604 var pcf: @TypeOf(&c.d) = undefined;
1605 pcf = &c.d;
1606 var pc: *const C = undefined;
1607 pc = @alignCast(@fieldParentPtr("d", pcf));
1608 try expect(pc == &c);
1609 }
1610 {
1611 var c: C = undefined;
1612 c = .{ .d = -1111111111 };
1613 var pcf: @TypeOf(&c.d) = undefined;
1614 pcf = &c.d;
1615 var pc: *C = undefined;
1616 pc = @alignCast(@fieldParentPtr("d", pcf));
1617 try expect(pc == &c);
1618 }
1619}
1620
1621test "@fieldParentPtr extern union" {
1622 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
1623 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1624 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1625
1626 const C = extern union {
1627 a: bool,
1628 b: f32,
1629 c: extern struct { x: u8 },
1630 d: i32,
1631 };
1632
1633 {
1634 const c: C = .{ .a = false };
1635 const pcf = &c.a;
1636 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
1637 try expect(pc == &c);
1638 }
1639 {
1640 const c: C = .{ .a = false };
1641 const pcf = &c.a;
1642 var pc: *const C = undefined;
1643 pc = @alignCast(@fieldParentPtr("a", pcf));
1644 try expect(pc == &c);
1645 }
1646 {
1647 const c: C = .{ .a = false };
1648 var pcf: @TypeOf(&c.a) = undefined;
1649 pcf = &c.a;
1650 var pc: *const C = undefined;
1651 pc = @alignCast(@fieldParentPtr("a", pcf));
1652 try expect(pc == &c);
1653 }
1654 {
1655 var c: C = undefined;
1656 c = .{ .a = false };
1657 var pcf: @TypeOf(&c.a) = undefined;
1658 pcf = &c.a;
1659 var pc: *C = undefined;
1660 pc = @alignCast(@fieldParentPtr("a", pcf));
1661 try expect(pc == &c);
1662 }
1663
1664 {
1665 const c: C = .{ .b = 0 };
1666 const pcf = &c.b;
1667 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
1668 try expect(pc == &c);
1669 }
1670 {
1671 const c: C = .{ .b = 0 };
1672 const pcf = &c.b;
1673 var pc: *const C = undefined;
1674 pc = @alignCast(@fieldParentPtr("b", pcf));
1675 try expect(pc == &c);
1676 }
1677 {
1678 const c: C = .{ .b = 0 };
1679 var pcf: @TypeOf(&c.b) = undefined;
1680 pcf = &c.b;
1681 var pc: *const C = undefined;
1682 pc = @alignCast(@fieldParentPtr("b", pcf));
1683 try expect(pc == &c);
1684 }
1685 {
1686 var c: C = undefined;
1687 c = .{ .b = 0 };
1688 var pcf: @TypeOf(&c.b) = undefined;
1689 pcf = &c.b;
1690 var pc: *C = undefined;
1691 pc = @alignCast(@fieldParentPtr("b", pcf));
1692 try expect(pc == &c);
1693 }
1694
1695 {
1696 const c: C = .{ .c = .{ .x = 255 } };
1697 const pcf = &c.c;
1698 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
1699 try expect(pc == &c);
1700 }
1701 {
1702 const c: C = .{ .c = .{ .x = 255 } };
1703 const pcf = &c.c;
1704 var pc: *const C = undefined;
1705 pc = @alignCast(@fieldParentPtr("c", pcf));
1706 try expect(pc == &c);
1707 }
1708 {
1709 const c: C = .{ .c = .{ .x = 255 } };
1710 var pcf: @TypeOf(&c.c) = undefined;
1711 pcf = &c.c;
1712 var pc: *const C = undefined;
1713 pc = @alignCast(@fieldParentPtr("c", pcf));
1714 try expect(pc == &c);
1715 }
1716 {
1717 var c: C = undefined;
1718 c = .{ .c = .{ .x = 255 } };
1719 var pcf: @TypeOf(&c.c) = undefined;
1720 pcf = &c.c;
1721 var pc: *C = undefined;
1722 pc = @alignCast(@fieldParentPtr("c", pcf));
1723 try expect(pc == &c);
1724 }
1725
1726 {
1727 const c: C = .{ .d = -1111111111 };
1728 const pcf = &c.d;
1729 const pc: *const C = @alignCast(@fieldParentPtr("d", pcf));
1730 try expect(pc == &c);
1731 }
1732 {
1733 const c: C = .{ .d = -1111111111 };
1734 const pcf = &c.d;
1735 var pc: *const C = undefined;
1736 pc = @alignCast(@fieldParentPtr("d", pcf));
1737 try expect(pc == &c);
1738 }
1739 {
1740 const c: C = .{ .d = -1111111111 };
1741 var pcf: @TypeOf(&c.d) = undefined;
1742 pcf = &c.d;
1743 var pc: *const C = undefined;
1744 pc = @alignCast(@fieldParentPtr("d", pcf));
1745 try expect(pc == &c);
1746 }
1747 {
1748 var c: C = undefined;
1749 c = .{ .d = -1111111111 };
1750 var pcf: @TypeOf(&c.d) = undefined;
1751 pcf = &c.d;
1752 var pc: *C = undefined;
1753 pc = @alignCast(@fieldParentPtr("d", pcf));
1754 try expect(pc == &c);
1755 }
1756}
1757
1758test "@fieldParentPtr packed union" {
1759 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1760 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1761 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1762 if (builtin.target.cpu.arch.endian() == .big) return error.SkipZigTest; // TODO
1763
1764 const C = packed union {
1765 a: packed struct(u32) {
1766 a: bool,
1767 b: u31 = 0,
1768 },
1769 b: f32,
1770 c: packed struct(u32) {
1771 x: u8,
1772 b: u24 = 0,
1773 },
1774 d: i32,
1775 };
1776
1777 {
1778 const c: C = .{ .a = .{ .a = false } };
1779 const pcf = &c.a;
1780 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
1781 try expect(pc == &c);
1782 }
1783 {
1784 const c: C = .{ .a = .{ .a = false } };
1785 const pcf = &c.a;
1786 var pc: *const C = undefined;
1787 pc = @alignCast(@fieldParentPtr("a", pcf));
1788 try expect(pc == &c);
1789 }
1790 {
1791 const c: C = .{ .a = .{ .a = false } };
1792 var pcf: @TypeOf(&c.a) = undefined;
1793 pcf = &c.a;
1794 var pc: *const C = undefined;
1795 pc = @alignCast(@fieldParentPtr("a", pcf));
1796 try expect(pc == &c);
1797 }
1798 {
1799 var c: C = undefined;
1800 c = .{ .a = .{ .a = false } };
1801 var pcf: @TypeOf(&c.a) = undefined;
1802 pcf = &c.a;
1803 var pc: *C = undefined;
1804 pc = @alignCast(@fieldParentPtr("a", pcf));
1805 try expect(pc == &c);
1806 }
1807
1808 {
1809 const c: C = .{ .b = 0 };
1810 const pcf = &c.b;
1811 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
1812 try expect(pc == &c);
1813 }
1814 {
1815 const c: C = .{ .b = 0 };
1816 const pcf = &c.b;
1817 var pc: *const C = undefined;
1818 pc = @alignCast(@fieldParentPtr("b", pcf));
1819 try expect(pc == &c);
1820 }
1821 {
1822 const c: C = .{ .b = 0 };
1823 var pcf: @TypeOf(&c.b) = undefined;
1824 pcf = &c.b;
1825 var pc: *const C = undefined;
1826 pc = @alignCast(@fieldParentPtr("b", pcf));
1827 try expect(pc == &c);
1828 }
1829 {
1830 var c: C = undefined;
1831 c = .{ .b = 0 };
1832 var pcf: @TypeOf(&c.b) = undefined;
1833 pcf = &c.b;
1834 var pc: *C = undefined;
1835 pc = @alignCast(@fieldParentPtr("b", pcf));
1836 try expect(pc == &c);
1837 }
1838
1839 {
1840 const c: C = .{ .c = .{ .x = 255 } };
1841 const pcf = &c.c;
1842 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
1843 try expect(pc == &c);
1844 }
1845 {
1846 const c: C = .{ .c = .{ .x = 255 } };
1847 const pcf = &c.c;
1848 var pc: *const C = undefined;
1849 pc = @alignCast(@fieldParentPtr("c", pcf));
1850 try expect(pc == &c);
1851 }
1852 {
1853 const c: C = .{ .c = .{ .x = 255 } };
1854 var pcf: @TypeOf(&c.c) = undefined;
1855 pcf = &c.c;
1856 var pc: *const C = undefined;
1857 pc = @alignCast(@fieldParentPtr("c", pcf));
1858 try expect(pc == &c);
1859 }
1860 {
1861 var c: C = undefined;
1862 c = .{ .c = .{ .x = 255 } };
1863 var pcf: @TypeOf(&c.c) = undefined;
1864 pcf = &c.c;
1865 var pc: *C = undefined;
1866 pc = @alignCast(@fieldParentPtr("c", pcf));
1867 try expect(pc == &c);
1868 }
1869
1870 {
1871 const c: C = .{ .d = -1111111111 };
1872 const pcf = &c.d;
1873 const pc: *const C = @alignCast(@fieldParentPtr("d", pcf));
1874 try expect(pc == &c);
1875 }
1876 {
1877 const c: C = .{ .d = -1111111111 };
1878 const pcf = &c.d;
1879 var pc: *const C = undefined;
1880 pc = @alignCast(@fieldParentPtr("d", pcf));
1881 try expect(pc == &c);
1882 }
1883 {
1884 const c: C = .{ .d = -1111111111 };
1885 var pcf: @TypeOf(&c.d) = undefined;
1886 pcf = &c.d;
1887 var pc: *const C = undefined;
1888 pc = @alignCast(@fieldParentPtr("d", pcf));
1889 try expect(pc == &c);
1890 }
1891 {
1892 var c: C = undefined;
1893 c = .{ .d = -1111111111 };
1894 var pcf: @TypeOf(&c.d) = undefined;
1895 pcf = &c.d;
1896 var pc: *C = undefined;
1897 pc = @alignCast(@fieldParentPtr("d", pcf));
1898 try expect(pc == &c);
1899 }
1900}
1901
1902test "@fieldParentPtr tagged union all zero-bit fields" {
1903 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1904 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1905 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1906
1907 const C = union(enum) {
1908 a: u0,
1909 b: i0,
1910 };
1911
1912 {
1913 const c: C = .{ .a = 0 };
1914 const pcf = &c.a;
1915 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
1916 try expect(pc == &c);
1917 }
1918 {
1919 const c: C = .{ .a = 0 };
1920 const pcf = &c.a;
1921 var pc: *const C = undefined;
1922 pc = @alignCast(@fieldParentPtr("a", pcf));
1923 try expect(pc == &c);
1924 }
1925 {
1926 const c: C = .{ .a = 0 };
1927 var pcf: @TypeOf(&c.a) = undefined;
1928 pcf = &c.a;
1929 var pc: *const C = undefined;
1930 pc = @alignCast(@fieldParentPtr("a", pcf));
1931 try expect(pc == &c);
1932 }
1933 {
1934 var c: C = undefined;
1935 c = .{ .a = 0 };
1936 var pcf: @TypeOf(&c.a) = undefined;
1937 pcf = &c.a;
1938 var pc: *C = undefined;
1939 pc = @alignCast(@fieldParentPtr("a", pcf));
1940 try expect(pc == &c);
1941 }
1942
1943 {
1944 const c: C = .{ .b = 0 };
1945 const pcf = &c.b;
1946 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
1947 try expect(pc == &c);
1948 }
1949 {
1950 const c: C = .{ .b = 0 };
1951 const pcf = &c.b;
1952 var pc: *const C = undefined;
1953 pc = @alignCast(@fieldParentPtr("b", pcf));
1954 try expect(pc == &c);
1955 }
1956 {
1957 const c: C = .{ .b = 0 };
1958 var pcf: @TypeOf(&c.b) = undefined;
1959 pcf = &c.b;
1960 var pc: *const C = undefined;
1961 pc = @alignCast(@fieldParentPtr("b", pcf));
1962 try expect(pc == &c);
1963 }
1964 {
1965 var c: C = undefined;
1966 c = .{ .b = 0 };
1967 var pcf: @TypeOf(&c.b) = undefined;
1968 pcf = &c.b;
1969 var pc: *C = undefined;
1970 pc = @alignCast(@fieldParentPtr("b", pcf));
1971 try expect(pc == &c);
1972 }
1973}