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_llvm) return error.SkipZigTest;
590 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
591 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
592 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
593
594 const C = packed struct {
595 a: bool = true,
596 b: f32 = 3.14,
597 c: packed struct { x: u8 } = .{ .x = 42 },
598 d: i32 = 12345,
599 };
600
601 {
602 const c: C = .{ .a = false };
603 const pcf = &c.a;
604 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
605 try expect(pc == &c);
606 }
607 {
608 const c: C = .{ .a = false };
609 const pcf = &c.a;
610 var pc: *const C = undefined;
611 pc = @alignCast(@fieldParentPtr("a", pcf));
612 try expect(pc == &c);
613 }
614 {
615 const c: C = .{ .a = false };
616 var pcf: @TypeOf(&c.a) = undefined;
617 pcf = &c.a;
618 var pc: *const C = undefined;
619 pc = @alignCast(@fieldParentPtr("a", pcf));
620 try expect(pc == &c);
621 }
622 {
623 var c: C = undefined;
624 c = .{ .a = false };
625 var pcf: @TypeOf(&c.a) = undefined;
626 pcf = &c.a;
627 var pc: *C = undefined;
628 pc = @alignCast(@fieldParentPtr("a", pcf));
629 try expect(pc == &c);
630 }
631
632 {
633 const c: C = .{ .b = 666.667 };
634 const pcf = &c.b;
635 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
636 try expect(pc == &c);
637 }
638 {
639 const c: C = .{ .b = 666.667 };
640 const pcf = &c.b;
641 var pc: *const C = undefined;
642 pc = @alignCast(@fieldParentPtr("b", pcf));
643 try expect(pc == &c);
644 }
645 {
646 const c: C = .{ .b = 666.667 };
647 var pcf: @TypeOf(&c.b) = undefined;
648 pcf = &c.b;
649 var pc: *const C = undefined;
650 pc = @alignCast(@fieldParentPtr("b", pcf));
651 try expect(pc == &c);
652 }
653 {
654 var c: C = undefined;
655 c = .{ .b = 666.667 };
656 var pcf: @TypeOf(&c.b) = undefined;
657 pcf = &c.b;
658 var pc: *C = undefined;
659 pc = @alignCast(@fieldParentPtr("b", pcf));
660 try expect(pc == &c);
661 }
662
663 {
664 const c: C = .{ .c = .{ .x = 255 } };
665 const pcf = &c.c;
666 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
667 try expect(pc == &c);
668 }
669 {
670 const c: C = .{ .c = .{ .x = 255 } };
671 const pcf = &c.c;
672 var pc: *const C = undefined;
673 pc = @alignCast(@fieldParentPtr("c", pcf));
674 try expect(pc == &c);
675 }
676 {
677 const c: C = .{ .c = .{ .x = 255 } };
678 var pcf: @TypeOf(&c.c) = undefined;
679 pcf = &c.c;
680 var pc: *const C = undefined;
681 pc = @alignCast(@fieldParentPtr("c", pcf));
682 try expect(pc == &c);
683 }
684 {
685 var c: C = undefined;
686 c = .{ .c = .{ .x = 255 } };
687 var pcf: @TypeOf(&c.c) = undefined;
688 pcf = &c.c;
689 var pc: *C = undefined;
690 pc = @alignCast(@fieldParentPtr("c", pcf));
691 try expect(pc == &c);
692 }
693
694 {
695 const c: C = .{ .d = -1111111111 };
696 const pcf = &c.d;
697 const pc: *const C = @alignCast(@fieldParentPtr("d", pcf));
698 try expect(pc == &c);
699 }
700 {
701 const c: C = .{ .d = -1111111111 };
702 const pcf = &c.d;
703 var pc: *const C = undefined;
704 pc = @alignCast(@fieldParentPtr("d", pcf));
705 try expect(pc == &c);
706 }
707 {
708 const c: C = .{ .d = -1111111111 };
709 var pcf: @TypeOf(&c.d) = undefined;
710 pcf = &c.d;
711 var pc: *const C = undefined;
712 pc = @alignCast(@fieldParentPtr("d", pcf));
713 try expect(pc == &c);
714 }
715 {
716 var c: C = undefined;
717 c = .{ .d = -1111111111 };
718 var pcf: @TypeOf(&c.d) = undefined;
719 pcf = &c.d;
720 var pc: *C = undefined;
721 pc = @alignCast(@fieldParentPtr("d", pcf));
722 try expect(pc == &c);
723 }
724}
725
726test "@fieldParentPtr aligned packed struct" {
727 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
728 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
729 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
730 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
731
732 const C = packed struct {
733 a: f32 = 3.14,
734 b: i32 = 12345,
735 c: packed struct { x: u8 } = .{ .x = 42 },
736 d: bool = true,
737 };
738
739 {
740 const c: C = .{ .a = 666.667 };
741 const pcf = &c.a;
742 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
743 try expect(pc == &c);
744 }
745 {
746 const c: C = .{ .a = 666.667 };
747 const pcf = &c.a;
748 var pc: *const C = undefined;
749 pc = @alignCast(@fieldParentPtr("a", pcf));
750 try expect(pc == &c);
751 }
752 {
753 const c: C = .{ .a = 666.667 };
754 var pcf: @TypeOf(&c.a) = undefined;
755 pcf = &c.a;
756 var pc: *const C = undefined;
757 pc = @alignCast(@fieldParentPtr("a", pcf));
758 try expect(pc == &c);
759 }
760 {
761 var c: C = undefined;
762 c = .{ .a = 666.667 };
763 var pcf: @TypeOf(&c.a) = undefined;
764 pcf = &c.a;
765 var pc: *C = undefined;
766 pc = @alignCast(@fieldParentPtr("a", pcf));
767 try expect(pc == &c);
768 }
769
770 {
771 const c: C = .{ .b = -1111111111 };
772 const pcf = &c.b;
773 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
774 try expect(pc == &c);
775 }
776 {
777 const c: C = .{ .b = -1111111111 };
778 const pcf = &c.b;
779 var pc: *const C = undefined;
780 pc = @alignCast(@fieldParentPtr("b", pcf));
781 try expect(pc == &c);
782 }
783 {
784 const c: C = .{ .b = -1111111111 };
785 var pcf: @TypeOf(&c.b) = undefined;
786 pcf = &c.b;
787 var pc: *const C = undefined;
788 pc = @alignCast(@fieldParentPtr("b", pcf));
789 try expect(pc == &c);
790 }
791 {
792 var c: C = undefined;
793 c = .{ .b = -1111111111 };
794 var pcf: @TypeOf(&c.b) = undefined;
795 pcf = &c.b;
796 var pc: *C = undefined;
797 pc = @alignCast(@fieldParentPtr("b", pcf));
798 try expect(pc == &c);
799 }
800
801 {
802 const c: C = .{ .c = .{ .x = 255 } };
803 const pcf = &c.c;
804 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
805 try expect(pc == &c);
806 }
807 {
808 const c: C = .{ .c = .{ .x = 255 } };
809 const pcf = &c.c;
810 var pc: *const C = undefined;
811 pc = @alignCast(@fieldParentPtr("c", pcf));
812 try expect(pc == &c);
813 }
814 {
815 const c: C = .{ .c = .{ .x = 255 } };
816 var pcf: @TypeOf(&c.c) = undefined;
817 pcf = &c.c;
818 var pc: *const C = undefined;
819 pc = @alignCast(@fieldParentPtr("c", pcf));
820 try expect(pc == &c);
821 }
822 {
823 var c: C = undefined;
824 c = .{ .c = .{ .x = 255 } };
825 var pcf: @TypeOf(&c.c) = undefined;
826 pcf = &c.c;
827 var pc: *C = undefined;
828 pc = @alignCast(@fieldParentPtr("c", pcf));
829 try expect(pc == &c);
830 }
831
832 {
833 const c: C = .{ .d = false };
834 const pcf = &c.d;
835 const pc: *const C = @alignCast(@fieldParentPtr("d", pcf));
836 try expect(pc == &c);
837 }
838 {
839 const c: C = .{ .d = false };
840 const pcf = &c.d;
841 var pc: *const C = undefined;
842 pc = @alignCast(@fieldParentPtr("d", pcf));
843 try expect(pc == &c);
844 }
845 {
846 const c: C = .{ .d = false };
847 var pcf: @TypeOf(&c.d) = undefined;
848 pcf = &c.d;
849 var pc: *const C = undefined;
850 pc = @alignCast(@fieldParentPtr("d", pcf));
851 try expect(pc == &c);
852 }
853 {
854 var c: C = undefined;
855 c = .{ .d = false };
856 var pcf: @TypeOf(&c.d) = undefined;
857 pcf = &c.d;
858 var pc: *C = undefined;
859 pc = @alignCast(@fieldParentPtr("d", pcf));
860 try expect(pc == &c);
861 }
862}
863
864test "@fieldParentPtr nested packed struct" {
865 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
866 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
867 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
868 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
869
870 {
871 const C = packed struct {
872 a: u8,
873 b: packed struct {
874 a: u8,
875 b: packed struct {
876 a: u8,
877 },
878 },
879 };
880
881 {
882 const c: C = .{ .a = 0, .b = .{ .a = 0, .b = .{ .a = 0 } } };
883 const pcbba = &c.b.b.a;
884 const pcbb: @TypeOf(&c.b.b) = @alignCast(@fieldParentPtr("a", pcbba));
885 try expect(pcbb == &c.b.b);
886 const pcb: @TypeOf(&c.b) = @alignCast(@fieldParentPtr("b", pcbb));
887 try expect(pcb == &c.b);
888 const pc: *const C = @alignCast(@fieldParentPtr("b", pcb));
889 try expect(pc == &c);
890 }
891
892 {
893 var c: C = undefined;
894 c = .{ .a = 0, .b = .{ .a = 0, .b = .{ .a = 0 } } };
895 var pcbba: @TypeOf(&c.b.b.a) = undefined;
896 pcbba = &c.b.b.a;
897 var pcbb: @TypeOf(&c.b.b) = undefined;
898 pcbb = @alignCast(@fieldParentPtr("a", pcbba));
899 try expect(pcbb == &c.b.b);
900 var pcb: @TypeOf(&c.b) = undefined;
901 pcb = @alignCast(@fieldParentPtr("b", pcbb));
902 try expect(pcb == &c.b);
903 var pc: *C = undefined;
904 pc = @alignCast(@fieldParentPtr("b", pcb));
905 try expect(pc == &c);
906 }
907 }
908
909 {
910 const C = packed struct {
911 a: u8,
912 b: packed struct {
913 a: u9,
914 b: packed struct {
915 a: u8,
916 },
917 },
918 };
919
920 {
921 const c: C = .{ .a = 0, .b = .{ .a = 0, .b = .{ .a = 0 } } };
922 const pcbba = &c.b.b.a;
923 const pcbb: @TypeOf(&c.b.b) = @alignCast(@fieldParentPtr("a", pcbba));
924 try expect(pcbb == &c.b.b);
925 const pcb: @TypeOf(&c.b) = @alignCast(@fieldParentPtr("b", pcbb));
926 try expect(pcb == &c.b);
927 const pc: *const C = @alignCast(@fieldParentPtr("b", pcb));
928 try expect(pc == &c);
929 }
930
931 {
932 var c: C = undefined;
933 c = .{ .a = 0, .b = .{ .a = 0, .b = .{ .a = 0 } } };
934 var pcbba: @TypeOf(&c.b.b.a) = undefined;
935 pcbba = &c.b.b.a;
936 var pcbb: @TypeOf(&c.b.b) = undefined;
937 pcbb = @alignCast(@fieldParentPtr("a", pcbba));
938 try expect(pcbb == &c.b.b);
939 var pcb: @TypeOf(&c.b) = undefined;
940 pcb = @alignCast(@fieldParentPtr("b", pcbb));
941 try expect(pcb == &c.b);
942 var pc: *C = undefined;
943 pc = @alignCast(@fieldParentPtr("b", pcb));
944 try expect(pc == &c);
945 }
946 }
947
948 {
949 const C = packed struct {
950 a: u9,
951 b: packed struct {
952 a: u7,
953 b: packed struct {
954 a: u8,
955 },
956 },
957 };
958
959 {
960 const c: C = .{ .a = 0, .b = .{ .a = 0, .b = .{ .a = 0 } } };
961 const pcbba = &c.b.b.a;
962 const pcbb: @TypeOf(&c.b.b) = @alignCast(@fieldParentPtr("a", pcbba));
963 try expect(pcbb == &c.b.b);
964 const pcb: @TypeOf(&c.b) = @alignCast(@fieldParentPtr("b", pcbb));
965 try expect(pcb == &c.b);
966 const pc: *const C = @alignCast(@fieldParentPtr("b", pcb));
967 try expect(pc == &c);
968 }
969
970 {
971 var c: C = undefined;
972 c = .{ .a = 0, .b = .{ .a = 0, .b = .{ .a = 0 } } };
973 var pcbba: @TypeOf(&c.b.b.a) = undefined;
974 pcbba = &c.b.b.a;
975 var pcbb: @TypeOf(&c.b.b) = undefined;
976 pcbb = @alignCast(@fieldParentPtr("a", pcbba));
977 try expect(pcbb == &c.b.b);
978 var pcb: @TypeOf(&c.b) = undefined;
979 pcb = @alignCast(@fieldParentPtr("b", pcbb));
980 try expect(pcb == &c.b);
981 var pc: *C = undefined;
982 pc = @alignCast(@fieldParentPtr("b", pcb));
983 try expect(pc == &c);
984 }
985 }
986
987 {
988 const C = packed struct {
989 a: u9,
990 b: packed struct {
991 a: u8,
992 b: packed struct {
993 a: u8,
994 },
995 },
996 };
997
998 {
999 const c: C = .{ .a = 0, .b = .{ .a = 0, .b = .{ .a = 0 } } };
1000 const pcbba = &c.b.b.a;
1001 const pcbb: @TypeOf(&c.b.b) = @alignCast(@fieldParentPtr("a", pcbba));
1002 try expect(pcbb == &c.b.b);
1003 const pcb: @TypeOf(&c.b) = @alignCast(@fieldParentPtr("b", pcbb));
1004 try expect(pcb == &c.b);
1005 const pc: *const C = @alignCast(@fieldParentPtr("b", pcb));
1006 try expect(pc == &c);
1007 }
1008
1009 {
1010 var c: C = undefined;
1011 c = .{ .a = 0, .b = .{ .a = 0, .b = .{ .a = 0 } } };
1012 var pcbba: @TypeOf(&c.b.b.a) = undefined;
1013 pcbba = &c.b.b.a;
1014 var pcbb: @TypeOf(&c.b.b) = undefined;
1015 pcbb = @alignCast(@fieldParentPtr("a", pcbba));
1016 try expect(pcbb == &c.b.b);
1017 var pcb: @TypeOf(&c.b) = undefined;
1018 pcb = @alignCast(@fieldParentPtr("b", pcbb));
1019 try expect(pcb == &c.b);
1020 var pc: *C = undefined;
1021 pc = @alignCast(@fieldParentPtr("b", pcb));
1022 try expect(pc == &c);
1023 }
1024 }
1025}
1026
1027test "@fieldParentPtr packed struct first zero-bit field" {
1028 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1029 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1030 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1031 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1032
1033 const C = packed struct {
1034 a: u0 = 0,
1035 b: f32 = 3.14,
1036 c: i32 = 12345,
1037 };
1038
1039 {
1040 const c: C = .{ .a = 0 };
1041 const pcf = &c.a;
1042 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
1043 try expect(pc == &c);
1044 }
1045 {
1046 const c: C = .{ .a = 0 };
1047 const pcf = &c.a;
1048 var pc: *const C = undefined;
1049 pc = @alignCast(@fieldParentPtr("a", pcf));
1050 try expect(pc == &c);
1051 }
1052 {
1053 const c: C = .{ .a = 0 };
1054 var pcf: @TypeOf(&c.a) = undefined;
1055 pcf = &c.a;
1056 var pc: *const C = undefined;
1057 pc = @alignCast(@fieldParentPtr("a", pcf));
1058 try expect(pc == &c);
1059 }
1060 {
1061 var c: C = undefined;
1062 c = .{ .a = 0 };
1063 var pcf: @TypeOf(&c.a) = undefined;
1064 pcf = &c.a;
1065 var pc: *C = undefined;
1066 pc = @alignCast(@fieldParentPtr("a", pcf));
1067 try expect(pc == &c);
1068 }
1069
1070 {
1071 const c: C = .{ .b = 666.667 };
1072 const pcf = &c.b;
1073 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
1074 try expect(pc == &c);
1075 }
1076 {
1077 const c: C = .{ .b = 666.667 };
1078 const pcf = &c.b;
1079 var pc: *const C = undefined;
1080 pc = @alignCast(@fieldParentPtr("b", pcf));
1081 try expect(pc == &c);
1082 }
1083 {
1084 const c: C = .{ .b = 666.667 };
1085 var pcf: @TypeOf(&c.b) = undefined;
1086 pcf = &c.b;
1087 var pc: *const C = undefined;
1088 pc = @alignCast(@fieldParentPtr("b", pcf));
1089 try expect(pc == &c);
1090 }
1091 {
1092 var c: C = undefined;
1093 c = .{ .b = 666.667 };
1094 var pcf: @TypeOf(&c.b) = undefined;
1095 pcf = &c.b;
1096 var pc: *C = undefined;
1097 pc = @alignCast(@fieldParentPtr("b", pcf));
1098 try expect(pc == &c);
1099 }
1100
1101 {
1102 const c: C = .{ .c = -1111111111 };
1103 const pcf = &c.c;
1104 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
1105 try expect(pc == &c);
1106 }
1107 {
1108 const c: C = .{ .c = -1111111111 };
1109 const pcf = &c.c;
1110 var pc: *const C = undefined;
1111 pc = @alignCast(@fieldParentPtr("c", pcf));
1112 try expect(pc == &c);
1113 }
1114 {
1115 const c: C = .{ .c = -1111111111 };
1116 var pcf: @TypeOf(&c.c) = undefined;
1117 pcf = &c.c;
1118 var pc: *const C = undefined;
1119 pc = @alignCast(@fieldParentPtr("c", pcf));
1120 try expect(pc == &c);
1121 }
1122 {
1123 var c: C = undefined;
1124 c = .{ .c = -1111111111 };
1125 var pcf: @TypeOf(&c.c) = undefined;
1126 pcf = &c.c;
1127 var pc: *C = undefined;
1128 pc = @alignCast(@fieldParentPtr("c", pcf));
1129 try expect(pc == &c);
1130 }
1131}
1132
1133test "@fieldParentPtr packed struct middle zero-bit field" {
1134 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1135 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1136 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1137 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1138
1139 const C = packed struct {
1140 a: f32 = 3.14,
1141 b: u0 = 0,
1142 c: i32 = 12345,
1143 };
1144
1145 {
1146 const c: C = .{ .a = 666.667 };
1147 const pcf = &c.a;
1148 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
1149 try expect(pc == &c);
1150 }
1151 {
1152 const c: C = .{ .a = 666.667 };
1153 const pcf = &c.a;
1154 var pc: *const C = undefined;
1155 pc = @alignCast(@fieldParentPtr("a", pcf));
1156 try expect(pc == &c);
1157 }
1158 {
1159 const c: C = .{ .a = 666.667 };
1160 var pcf: @TypeOf(&c.a) = undefined;
1161 pcf = &c.a;
1162 var pc: *const C = undefined;
1163 pc = @alignCast(@fieldParentPtr("a", pcf));
1164 try expect(pc == &c);
1165 }
1166 {
1167 var c: C = undefined;
1168 c = .{ .a = 666.667 };
1169 var pcf: @TypeOf(&c.a) = undefined;
1170 pcf = &c.a;
1171 var pc: *C = undefined;
1172 pc = @alignCast(@fieldParentPtr("a", pcf));
1173 try expect(pc == &c);
1174 }
1175
1176 {
1177 const c: C = .{ .b = 0 };
1178 const pcf = &c.b;
1179 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
1180 try expect(pc == &c);
1181 }
1182 {
1183 const c: C = .{ .b = 0 };
1184 const pcf = &c.b;
1185 var pc: *const C = undefined;
1186 pc = @alignCast(@fieldParentPtr("b", pcf));
1187 try expect(pc == &c);
1188 }
1189 {
1190 const c: C = .{ .b = 0 };
1191 var pcf: @TypeOf(&c.b) = undefined;
1192 pcf = &c.b;
1193 var pc: *const C = undefined;
1194 pc = @alignCast(@fieldParentPtr("b", pcf));
1195 try expect(pc == &c);
1196 }
1197 {
1198 var c: C = undefined;
1199 c = .{ .b = 0 };
1200 var pcf: @TypeOf(&c.b) = undefined;
1201 pcf = &c.b;
1202 var pc: *C = undefined;
1203 pc = @alignCast(@fieldParentPtr("b", pcf));
1204 try expect(pc == &c);
1205 }
1206
1207 {
1208 const c: C = .{ .c = -1111111111 };
1209 const pcf = &c.c;
1210 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
1211 try expect(pc == &c);
1212 }
1213 {
1214 const c: C = .{ .c = -1111111111 };
1215 const pcf = &c.c;
1216 var pc: *const C = undefined;
1217 pc = @alignCast(@fieldParentPtr("c", pcf));
1218 try expect(pc == &c);
1219 }
1220 {
1221 const c: C = .{ .c = -1111111111 };
1222 var pcf: @TypeOf(&c.c) = undefined;
1223 pcf = &c.c;
1224 var pc: *const C = undefined;
1225 pc = @alignCast(@fieldParentPtr("c", pcf));
1226 try expect(pc == &c);
1227 }
1228 {
1229 var c: C = undefined;
1230 c = .{ .c = -1111111111 };
1231 var pcf: @TypeOf(&c.c) = undefined;
1232 pcf = &c.c;
1233 var pc: *C = undefined;
1234 pc = @alignCast(@fieldParentPtr("c", pcf));
1235 try expect(pc == &c);
1236 }
1237}
1238
1239test "@fieldParentPtr packed struct last zero-bit field" {
1240 if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
1241 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1242 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1243 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1244
1245 const C = packed struct {
1246 a: f32 = 3.14,
1247 b: i32 = 12345,
1248 c: u0 = 0,
1249 };
1250
1251 {
1252 const c: C = .{ .a = 666.667 };
1253 const pcf = &c.a;
1254 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
1255 try expect(pc == &c);
1256 }
1257 {
1258 const c: C = .{ .a = 666.667 };
1259 const pcf = &c.a;
1260 var pc: *const C = undefined;
1261 pc = @alignCast(@fieldParentPtr("a", pcf));
1262 try expect(pc == &c);
1263 }
1264 {
1265 const c: C = .{ .a = 666.667 };
1266 var pcf: @TypeOf(&c.a) = undefined;
1267 pcf = &c.a;
1268 var pc: *const C = undefined;
1269 pc = @alignCast(@fieldParentPtr("a", pcf));
1270 try expect(pc == &c);
1271 }
1272 {
1273 var c: C = undefined;
1274 c = .{ .a = 666.667 };
1275 var pcf: @TypeOf(&c.a) = undefined;
1276 pcf = &c.a;
1277 var pc: *C = undefined;
1278 pc = @alignCast(@fieldParentPtr("a", pcf));
1279 try expect(pc == &c);
1280 }
1281
1282 {
1283 const c: C = .{ .b = -1111111111 };
1284 const pcf = &c.b;
1285 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
1286 try expect(pc == &c);
1287 }
1288 {
1289 const c: C = .{ .b = -1111111111 };
1290 const pcf = &c.b;
1291 var pc: *const C = undefined;
1292 pc = @alignCast(@fieldParentPtr("b", pcf));
1293 try expect(pc == &c);
1294 }
1295 {
1296 const c: C = .{ .b = -1111111111 };
1297 var pcf: @TypeOf(&c.b) = undefined;
1298 pcf = &c.b;
1299 var pc: *const C = undefined;
1300 pc = @alignCast(@fieldParentPtr("b", pcf));
1301 try expect(pc == &c);
1302 }
1303 {
1304 var c: C = undefined;
1305 c = .{ .b = -1111111111 };
1306 var pcf: @TypeOf(&c.b) = undefined;
1307 pcf = &c.b;
1308 var pc: *C = undefined;
1309 pc = @alignCast(@fieldParentPtr("b", pcf));
1310 try expect(pc == &c);
1311 }
1312
1313 {
1314 const c: C = .{ .c = 0 };
1315 const pcf = &c.c;
1316 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
1317 try expect(pc == &c);
1318 }
1319 {
1320 const c: C = .{ .c = 0 };
1321 const pcf = &c.c;
1322 var pc: *const C = undefined;
1323 pc = @alignCast(@fieldParentPtr("c", pcf));
1324 try expect(pc == &c);
1325 }
1326 {
1327 const c: C = .{ .c = 0 };
1328 var pcf: @TypeOf(&c.c) = undefined;
1329 pcf = &c.c;
1330 var pc: *const C = undefined;
1331 pc = @alignCast(@fieldParentPtr("c", pcf));
1332 try expect(pc == &c);
1333 }
1334 {
1335 var c: C = undefined;
1336 c = .{ .c = 0 };
1337 var pcf: @TypeOf(&c.c) = undefined;
1338 pcf = &c.c;
1339 var pc: *C = undefined;
1340 pc = @alignCast(@fieldParentPtr("c", pcf));
1341 try expect(pc == &c);
1342 }
1343}
1344
1345test "@fieldParentPtr tagged union" {
1346 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1347 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1348
1349 const C = union(enum) {
1350 a: bool,
1351 b: f32,
1352 c: struct { u8 },
1353 d: i32,
1354 };
1355
1356 {
1357 const c: C = .{ .a = false };
1358 const pcf = &c.a;
1359 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
1360 try expect(pc == &c);
1361 }
1362 {
1363 const c: C = .{ .a = false };
1364 const pcf = &c.a;
1365 var pc: *const C = undefined;
1366 pc = @alignCast(@fieldParentPtr("a", pcf));
1367 try expect(pc == &c);
1368 }
1369 {
1370 const c: C = .{ .a = false };
1371 var pcf: @TypeOf(&c.a) = undefined;
1372 pcf = &c.a;
1373 var pc: *const C = undefined;
1374 pc = @alignCast(@fieldParentPtr("a", pcf));
1375 try expect(pc == &c);
1376 }
1377 {
1378 var c: C = undefined;
1379 c = .{ .a = false };
1380 var pcf: @TypeOf(&c.a) = undefined;
1381 pcf = &c.a;
1382 var pc: *C = undefined;
1383 pc = @alignCast(@fieldParentPtr("a", pcf));
1384 try expect(pc == &c);
1385 }
1386
1387 {
1388 const c: C = .{ .b = 0 };
1389 const pcf = &c.b;
1390 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
1391 try expect(pc == &c);
1392 }
1393 {
1394 const c: C = .{ .b = 0 };
1395 const pcf = &c.b;
1396 var pc: *const C = undefined;
1397 pc = @alignCast(@fieldParentPtr("b", pcf));
1398 try expect(pc == &c);
1399 }
1400 {
1401 const c: C = .{ .b = 0 };
1402 var pcf: @TypeOf(&c.b) = undefined;
1403 pcf = &c.b;
1404 var pc: *const C = undefined;
1405 pc = @alignCast(@fieldParentPtr("b", pcf));
1406 try expect(pc == &c);
1407 }
1408 {
1409 var c: C = undefined;
1410 c = .{ .b = 0 };
1411 var pcf: @TypeOf(&c.b) = undefined;
1412 pcf = &c.b;
1413 var pc: *C = undefined;
1414 pc = @alignCast(@fieldParentPtr("b", pcf));
1415 try expect(pc == &c);
1416 }
1417
1418 {
1419 const c: C = .{ .c = .{255} };
1420 const pcf = &c.c;
1421 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
1422 try expect(pc == &c);
1423 }
1424 {
1425 const c: C = .{ .c = .{255} };
1426 const pcf = &c.c;
1427 var pc: *const C = undefined;
1428 pc = @alignCast(@fieldParentPtr("c", pcf));
1429 try expect(pc == &c);
1430 }
1431 {
1432 const c: C = .{ .c = .{255} };
1433 var pcf: @TypeOf(&c.c) = undefined;
1434 pcf = &c.c;
1435 var pc: *const C = undefined;
1436 pc = @alignCast(@fieldParentPtr("c", pcf));
1437 try expect(pc == &c);
1438 }
1439 {
1440 var c: C = undefined;
1441 c = .{ .c = .{255} };
1442 var pcf: @TypeOf(&c.c) = undefined;
1443 pcf = &c.c;
1444 var pc: *C = undefined;
1445 pc = @alignCast(@fieldParentPtr("c", pcf));
1446 try expect(pc == &c);
1447 }
1448
1449 {
1450 const c: C = .{ .d = -1111111111 };
1451 const pcf = &c.d;
1452 const pc: *const C = @alignCast(@fieldParentPtr("d", pcf));
1453 try expect(pc == &c);
1454 }
1455 {
1456 const c: C = .{ .d = -1111111111 };
1457 const pcf = &c.d;
1458 var pc: *const C = undefined;
1459 pc = @alignCast(@fieldParentPtr("d", pcf));
1460 try expect(pc == &c);
1461 }
1462 {
1463 const c: C = .{ .d = -1111111111 };
1464 var pcf: @TypeOf(&c.d) = undefined;
1465 pcf = &c.d;
1466 var pc: *const C = undefined;
1467 pc = @alignCast(@fieldParentPtr("d", pcf));
1468 try expect(pc == &c);
1469 }
1470 {
1471 var c: C = undefined;
1472 c = .{ .d = -1111111111 };
1473 var pcf: @TypeOf(&c.d) = undefined;
1474 pcf = &c.d;
1475 var pc: *C = undefined;
1476 pc = @alignCast(@fieldParentPtr("d", pcf));
1477 try expect(pc == &c);
1478 }
1479}
1480
1481test "@fieldParentPtr untagged union" {
1482 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1483 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1484
1485 const C = union {
1486 a: bool,
1487 b: f32,
1488 c: struct { u8 },
1489 d: i32,
1490 };
1491
1492 {
1493 const c: C = .{ .a = false };
1494 const pcf = &c.a;
1495 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
1496 try expect(pc == &c);
1497 }
1498 {
1499 const c: C = .{ .a = false };
1500 const pcf = &c.a;
1501 var pc: *const C = undefined;
1502 pc = @alignCast(@fieldParentPtr("a", pcf));
1503 try expect(pc == &c);
1504 }
1505 {
1506 const c: C = .{ .a = false };
1507 var pcf: @TypeOf(&c.a) = undefined;
1508 pcf = &c.a;
1509 var pc: *const C = undefined;
1510 pc = @alignCast(@fieldParentPtr("a", pcf));
1511 try expect(pc == &c);
1512 }
1513 {
1514 var c: C = undefined;
1515 c = .{ .a = false };
1516 var pcf: @TypeOf(&c.a) = undefined;
1517 pcf = &c.a;
1518 var pc: *C = undefined;
1519 pc = @alignCast(@fieldParentPtr("a", pcf));
1520 try expect(pc == &c);
1521 }
1522
1523 {
1524 const c: C = .{ .b = 0 };
1525 const pcf = &c.b;
1526 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
1527 try expect(pc == &c);
1528 }
1529 {
1530 const c: C = .{ .b = 0 };
1531 const pcf = &c.b;
1532 var pc: *const C = undefined;
1533 pc = @alignCast(@fieldParentPtr("b", pcf));
1534 try expect(pc == &c);
1535 }
1536 {
1537 const c: C = .{ .b = 0 };
1538 var pcf: @TypeOf(&c.b) = undefined;
1539 pcf = &c.b;
1540 var pc: *const C = undefined;
1541 pc = @alignCast(@fieldParentPtr("b", pcf));
1542 try expect(pc == &c);
1543 }
1544 {
1545 var c: C = undefined;
1546 c = .{ .b = 0 };
1547 var pcf: @TypeOf(&c.b) = undefined;
1548 pcf = &c.b;
1549 var pc: *C = undefined;
1550 pc = @alignCast(@fieldParentPtr("b", pcf));
1551 try expect(pc == &c);
1552 }
1553
1554 {
1555 const c: C = .{ .c = .{255} };
1556 const pcf = &c.c;
1557 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
1558 try expect(pc == &c);
1559 }
1560 {
1561 const c: C = .{ .c = .{255} };
1562 const pcf = &c.c;
1563 var pc: *const C = undefined;
1564 pc = @alignCast(@fieldParentPtr("c", pcf));
1565 try expect(pc == &c);
1566 }
1567 {
1568 const c: C = .{ .c = .{255} };
1569 var pcf: @TypeOf(&c.c) = undefined;
1570 pcf = &c.c;
1571 var pc: *const C = undefined;
1572 pc = @alignCast(@fieldParentPtr("c", pcf));
1573 try expect(pc == &c);
1574 }
1575 {
1576 var c: C = undefined;
1577 c = .{ .c = .{255} };
1578 var pcf: @TypeOf(&c.c) = undefined;
1579 pcf = &c.c;
1580 var pc: *C = undefined;
1581 pc = @alignCast(@fieldParentPtr("c", pcf));
1582 try expect(pc == &c);
1583 }
1584
1585 {
1586 const c: C = .{ .d = -1111111111 };
1587 const pcf = &c.d;
1588 const pc: *const C = @alignCast(@fieldParentPtr("d", pcf));
1589 try expect(pc == &c);
1590 }
1591 {
1592 const c: C = .{ .d = -1111111111 };
1593 const pcf = &c.d;
1594 var pc: *const C = undefined;
1595 pc = @alignCast(@fieldParentPtr("d", pcf));
1596 try expect(pc == &c);
1597 }
1598 {
1599 const c: C = .{ .d = -1111111111 };
1600 var pcf: @TypeOf(&c.d) = undefined;
1601 pcf = &c.d;
1602 var pc: *const C = undefined;
1603 pc = @alignCast(@fieldParentPtr("d", pcf));
1604 try expect(pc == &c);
1605 }
1606 {
1607 var c: C = undefined;
1608 c = .{ .d = -1111111111 };
1609 var pcf: @TypeOf(&c.d) = undefined;
1610 pcf = &c.d;
1611 var pc: *C = undefined;
1612 pc = @alignCast(@fieldParentPtr("d", pcf));
1613 try expect(pc == &c);
1614 }
1615}
1616
1617test "@fieldParentPtr extern union" {
1618 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
1619 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1620 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1621
1622 const C = extern union {
1623 a: bool,
1624 b: f32,
1625 c: extern struct { x: u8 },
1626 d: i32,
1627 };
1628
1629 {
1630 const c: C = .{ .a = false };
1631 const pcf = &c.a;
1632 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
1633 try expect(pc == &c);
1634 }
1635 {
1636 const c: C = .{ .a = false };
1637 const pcf = &c.a;
1638 var pc: *const C = undefined;
1639 pc = @alignCast(@fieldParentPtr("a", pcf));
1640 try expect(pc == &c);
1641 }
1642 {
1643 const c: C = .{ .a = false };
1644 var pcf: @TypeOf(&c.a) = undefined;
1645 pcf = &c.a;
1646 var pc: *const C = undefined;
1647 pc = @alignCast(@fieldParentPtr("a", pcf));
1648 try expect(pc == &c);
1649 }
1650 {
1651 var c: C = undefined;
1652 c = .{ .a = false };
1653 var pcf: @TypeOf(&c.a) = undefined;
1654 pcf = &c.a;
1655 var pc: *C = undefined;
1656 pc = @alignCast(@fieldParentPtr("a", pcf));
1657 try expect(pc == &c);
1658 }
1659
1660 {
1661 const c: C = .{ .b = 0 };
1662 const pcf = &c.b;
1663 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
1664 try expect(pc == &c);
1665 }
1666 {
1667 const c: C = .{ .b = 0 };
1668 const pcf = &c.b;
1669 var pc: *const C = undefined;
1670 pc = @alignCast(@fieldParentPtr("b", pcf));
1671 try expect(pc == &c);
1672 }
1673 {
1674 const c: C = .{ .b = 0 };
1675 var pcf: @TypeOf(&c.b) = undefined;
1676 pcf = &c.b;
1677 var pc: *const C = undefined;
1678 pc = @alignCast(@fieldParentPtr("b", pcf));
1679 try expect(pc == &c);
1680 }
1681 {
1682 var c: C = undefined;
1683 c = .{ .b = 0 };
1684 var pcf: @TypeOf(&c.b) = undefined;
1685 pcf = &c.b;
1686 var pc: *C = undefined;
1687 pc = @alignCast(@fieldParentPtr("b", pcf));
1688 try expect(pc == &c);
1689 }
1690
1691 {
1692 const c: C = .{ .c = .{ .x = 255 } };
1693 const pcf = &c.c;
1694 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
1695 try expect(pc == &c);
1696 }
1697 {
1698 const c: C = .{ .c = .{ .x = 255 } };
1699 const pcf = &c.c;
1700 var pc: *const C = undefined;
1701 pc = @alignCast(@fieldParentPtr("c", pcf));
1702 try expect(pc == &c);
1703 }
1704 {
1705 const c: C = .{ .c = .{ .x = 255 } };
1706 var pcf: @TypeOf(&c.c) = undefined;
1707 pcf = &c.c;
1708 var pc: *const C = undefined;
1709 pc = @alignCast(@fieldParentPtr("c", pcf));
1710 try expect(pc == &c);
1711 }
1712 {
1713 var c: C = undefined;
1714 c = .{ .c = .{ .x = 255 } };
1715 var pcf: @TypeOf(&c.c) = undefined;
1716 pcf = &c.c;
1717 var pc: *C = undefined;
1718 pc = @alignCast(@fieldParentPtr("c", pcf));
1719 try expect(pc == &c);
1720 }
1721
1722 {
1723 const c: C = .{ .d = -1111111111 };
1724 const pcf = &c.d;
1725 const pc: *const C = @alignCast(@fieldParentPtr("d", pcf));
1726 try expect(pc == &c);
1727 }
1728 {
1729 const c: C = .{ .d = -1111111111 };
1730 const pcf = &c.d;
1731 var pc: *const C = undefined;
1732 pc = @alignCast(@fieldParentPtr("d", pcf));
1733 try expect(pc == &c);
1734 }
1735 {
1736 const c: C = .{ .d = -1111111111 };
1737 var pcf: @TypeOf(&c.d) = undefined;
1738 pcf = &c.d;
1739 var pc: *const C = undefined;
1740 pc = @alignCast(@fieldParentPtr("d", pcf));
1741 try expect(pc == &c);
1742 }
1743 {
1744 var c: C = undefined;
1745 c = .{ .d = -1111111111 };
1746 var pcf: @TypeOf(&c.d) = undefined;
1747 pcf = &c.d;
1748 var pc: *C = undefined;
1749 pc = @alignCast(@fieldParentPtr("d", pcf));
1750 try expect(pc == &c);
1751 }
1752}
1753
1754test "@fieldParentPtr packed union" {
1755 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1756 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1757 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1758
1759 const C = packed union {
1760 a: packed struct(u32) {
1761 a: bool,
1762 b: u31 = 0,
1763 },
1764 b: f32,
1765 c: packed struct(u32) {
1766 x: u8,
1767 b: u24 = 0,
1768 },
1769 d: i32,
1770 };
1771
1772 {
1773 const c: C = .{ .a = .{ .a = false } };
1774 const pcf = &c.a;
1775 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
1776 try expect(pc == &c);
1777 }
1778 {
1779 const c: C = .{ .a = .{ .a = false } };
1780 const pcf = &c.a;
1781 var pc: *const C = undefined;
1782 pc = @alignCast(@fieldParentPtr("a", pcf));
1783 try expect(pc == &c);
1784 }
1785 {
1786 const c: C = .{ .a = .{ .a = false } };
1787 var pcf: @TypeOf(&c.a) = undefined;
1788 pcf = &c.a;
1789 var pc: *const C = undefined;
1790 pc = @alignCast(@fieldParentPtr("a", pcf));
1791 try expect(pc == &c);
1792 }
1793 {
1794 var c: C = undefined;
1795 c = .{ .a = .{ .a = false } };
1796 var pcf: @TypeOf(&c.a) = undefined;
1797 pcf = &c.a;
1798 var pc: *C = undefined;
1799 pc = @alignCast(@fieldParentPtr("a", pcf));
1800 try expect(pc == &c);
1801 }
1802
1803 {
1804 const c: C = .{ .b = 0 };
1805 const pcf = &c.b;
1806 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
1807 try expect(pc == &c);
1808 }
1809 {
1810 const c: C = .{ .b = 0 };
1811 const pcf = &c.b;
1812 var pc: *const C = undefined;
1813 pc = @alignCast(@fieldParentPtr("b", pcf));
1814 try expect(pc == &c);
1815 }
1816 {
1817 const c: C = .{ .b = 0 };
1818 var pcf: @TypeOf(&c.b) = undefined;
1819 pcf = &c.b;
1820 var pc: *const C = undefined;
1821 pc = @alignCast(@fieldParentPtr("b", pcf));
1822 try expect(pc == &c);
1823 }
1824 {
1825 var c: C = undefined;
1826 c = .{ .b = 0 };
1827 var pcf: @TypeOf(&c.b) = undefined;
1828 pcf = &c.b;
1829 var pc: *C = undefined;
1830 pc = @alignCast(@fieldParentPtr("b", pcf));
1831 try expect(pc == &c);
1832 }
1833
1834 {
1835 const c: C = .{ .c = .{ .x = 255 } };
1836 const pcf = &c.c;
1837 const pc: *const C = @alignCast(@fieldParentPtr("c", pcf));
1838 try expect(pc == &c);
1839 }
1840 {
1841 const c: C = .{ .c = .{ .x = 255 } };
1842 const pcf = &c.c;
1843 var pc: *const C = undefined;
1844 pc = @alignCast(@fieldParentPtr("c", pcf));
1845 try expect(pc == &c);
1846 }
1847 {
1848 const c: C = .{ .c = .{ .x = 255 } };
1849 var pcf: @TypeOf(&c.c) = undefined;
1850 pcf = &c.c;
1851 var pc: *const C = undefined;
1852 pc = @alignCast(@fieldParentPtr("c", pcf));
1853 try expect(pc == &c);
1854 }
1855 {
1856 var c: C = undefined;
1857 c = .{ .c = .{ .x = 255 } };
1858 var pcf: @TypeOf(&c.c) = undefined;
1859 pcf = &c.c;
1860 var pc: *C = undefined;
1861 pc = @alignCast(@fieldParentPtr("c", pcf));
1862 try expect(pc == &c);
1863 }
1864
1865 {
1866 const c: C = .{ .d = -1111111111 };
1867 const pcf = &c.d;
1868 const pc: *const C = @alignCast(@fieldParentPtr("d", pcf));
1869 try expect(pc == &c);
1870 }
1871 {
1872 const c: C = .{ .d = -1111111111 };
1873 const pcf = &c.d;
1874 var pc: *const C = undefined;
1875 pc = @alignCast(@fieldParentPtr("d", pcf));
1876 try expect(pc == &c);
1877 }
1878 {
1879 const c: C = .{ .d = -1111111111 };
1880 var pcf: @TypeOf(&c.d) = undefined;
1881 pcf = &c.d;
1882 var pc: *const C = undefined;
1883 pc = @alignCast(@fieldParentPtr("d", pcf));
1884 try expect(pc == &c);
1885 }
1886 {
1887 var c: C = undefined;
1888 c = .{ .d = -1111111111 };
1889 var pcf: @TypeOf(&c.d) = undefined;
1890 pcf = &c.d;
1891 var pc: *C = undefined;
1892 pc = @alignCast(@fieldParentPtr("d", pcf));
1893 try expect(pc == &c);
1894 }
1895}
1896
1897test "@fieldParentPtr tagged union all zero-bit fields" {
1898 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
1899 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
1900
1901 const C = union(enum) {
1902 a: u0,
1903 b: void,
1904 };
1905
1906 {
1907 const c: C = .{ .a = 0 };
1908 const pcf = &c.a;
1909 const pc: *const C = @alignCast(@fieldParentPtr("a", pcf));
1910 try expect(pc == &c);
1911 }
1912 {
1913 const c: C = .{ .a = 0 };
1914 const pcf = &c.a;
1915 var pc: *const C = undefined;
1916 pc = @alignCast(@fieldParentPtr("a", pcf));
1917 try expect(pc == &c);
1918 }
1919 {
1920 const c: C = .{ .a = 0 };
1921 var pcf: @TypeOf(&c.a) = undefined;
1922 pcf = &c.a;
1923 var pc: *const C = undefined;
1924 pc = @alignCast(@fieldParentPtr("a", pcf));
1925 try expect(pc == &c);
1926 }
1927 {
1928 var c: C = undefined;
1929 c = .{ .a = 0 };
1930 var pcf: @TypeOf(&c.a) = undefined;
1931 pcf = &c.a;
1932 var pc: *C = undefined;
1933 pc = @alignCast(@fieldParentPtr("a", pcf));
1934 try expect(pc == &c);
1935 }
1936
1937 {
1938 const c: C = .{ .b = {} };
1939 const pcf = &c.b;
1940 const pc: *const C = @alignCast(@fieldParentPtr("b", pcf));
1941 try expect(pc == &c);
1942 }
1943 {
1944 const c: C = .{ .b = {} };
1945 const pcf = &c.b;
1946 var pc: *const C = undefined;
1947 pc = @alignCast(@fieldParentPtr("b", pcf));
1948 try expect(pc == &c);
1949 }
1950 {
1951 const c: C = .{ .b = {} };
1952 var pcf: @TypeOf(&c.b) = undefined;
1953 pcf = &c.b;
1954 var pc: *const C = undefined;
1955 pc = @alignCast(@fieldParentPtr("b", pcf));
1956 try expect(pc == &c);
1957 }
1958 {
1959 var c: C = undefined;
1960 c = .{ .b = {} };
1961 var pcf: @TypeOf(&c.b) = undefined;
1962 pcf = &c.b;
1963 var pc: *C = undefined;
1964 pc = @alignCast(@fieldParentPtr("b", pcf));
1965 try expect(pc == &c);
1966 }
1967}