fork/rust

git clone https://git.julia.blue/fork/rust

borsAuto merge of #103046 - JanBeh:PR_clarify_cmp_terminology, r=workingjubilee3bcad65fbf6

master
33.9 KiB959 linesraw
1error: fn_abi_of(test) = FnAbi {
2           args: [
3               ArgAbi {
4                   layout: TyAndLayout {
5                       ty: u8,
6                       layout: Layout {
7                           size: Size(1 bytes),
8                           align: AbiAndPrefAlign {
9                               abi: $SOME_ALIGN,
10                               pref: $SOME_ALIGN,
11                           },
12                           abi: Scalar(
13                               Initialized {
14                                   value: Int(
15                                       I8,
16                                       false,
17                                   ),
18                                   valid_range: 0..=255,
19                               },
20                           ),
21                           fields: Primitive,
22                           largest_niche: None,
23                           variants: Single {
24                               index: 0,
25                           },
26                           max_repr_align: None,
27                           unadjusted_abi_align: $SOME_ALIGN,
28                       },
29                   },
30                   mode: Direct(
31                       ArgAttributes {
32                           regular: NoUndef,
33                           arg_ext: None,
34                           pointee_size: Size(0 bytes),
35                           pointee_align: None,
36                       },
37                   ),
38               },
39           ],
40           ret: ArgAbi {
41               layout: TyAndLayout {
42                   ty: bool,
43                   layout: Layout {
44                       size: Size(1 bytes),
45                       align: AbiAndPrefAlign {
46                           abi: $SOME_ALIGN,
47                           pref: $SOME_ALIGN,
48                       },
49                       abi: Scalar(
50                           Initialized {
51                               value: Int(
52                                   I8,
53                                   false,
54                               ),
55                               valid_range: 0..=1,
56                           },
57                       ),
58                       fields: Primitive,
59                       largest_niche: Some(
60                           Niche {
61                               offset: Size(0 bytes),
62                               value: Int(
63                                   I8,
64                                   false,
65                               ),
66                               valid_range: 0..=1,
67                           },
68                       ),
69                       variants: Single {
70                           index: 0,
71                       },
72                       max_repr_align: None,
73                       unadjusted_abi_align: $SOME_ALIGN,
74                   },
75               },
76               mode: Direct(
77                   ArgAttributes {
78                       regular: NoUndef,
79                       arg_ext: Zext,
80                       pointee_size: Size(0 bytes),
81                       pointee_align: None,
82                   },
83               ),
84           },
85           c_variadic: false,
86           fixed_count: 1,
87           conv: Rust,
88           can_unwind: $SOME_BOOL,
89       }
90  --> $DIR/debug.rs:15:1
91   |
92LL | fn test(_x: u8) -> bool { true }
93   | ^^^^^^^^^^^^^^^^^^^^^^^
94
95error: fn_abi_of(TestFnPtr) = FnAbi {
96           args: [
97               ArgAbi {
98                   layout: TyAndLayout {
99                       ty: bool,
100                       layout: Layout {
101                           size: Size(1 bytes),
102                           align: AbiAndPrefAlign {
103                               abi: $SOME_ALIGN,
104                               pref: $SOME_ALIGN,
105                           },
106                           abi: Scalar(
107                               Initialized {
108                                   value: Int(
109                                       I8,
110                                       false,
111                                   ),
112                                   valid_range: 0..=1,
113                               },
114                           ),
115                           fields: Primitive,
116                           largest_niche: Some(
117                               Niche {
118                                   offset: Size(0 bytes),
119                                   value: Int(
120                                       I8,
121                                       false,
122                                   ),
123                                   valid_range: 0..=1,
124                               },
125                           ),
126                           variants: Single {
127                               index: 0,
128                           },
129                           max_repr_align: None,
130                           unadjusted_abi_align: $SOME_ALIGN,
131                       },
132                   },
133                   mode: Direct(
134                       ArgAttributes {
135                           regular: NoUndef,
136                           arg_ext: Zext,
137                           pointee_size: Size(0 bytes),
138                           pointee_align: None,
139                       },
140                   ),
141               },
142           ],
143           ret: ArgAbi {
144               layout: TyAndLayout {
145                   ty: u8,
146                   layout: Layout {
147                       size: Size(1 bytes),
148                       align: AbiAndPrefAlign {
149                           abi: $SOME_ALIGN,
150                           pref: $SOME_ALIGN,
151                       },
152                       abi: Scalar(
153                           Initialized {
154                               value: Int(
155                                   I8,
156                                   false,
157                               ),
158                               valid_range: 0..=255,
159                           },
160                       ),
161                       fields: Primitive,
162                       largest_niche: None,
163                       variants: Single {
164                           index: 0,
165                       },
166                       max_repr_align: None,
167                       unadjusted_abi_align: $SOME_ALIGN,
168                   },
169               },
170               mode: Direct(
171                   ArgAttributes {
172                       regular: NoUndef,
173                       arg_ext: None,
174                       pointee_size: Size(0 bytes),
175                       pointee_align: None,
176                   },
177               ),
178           },
179           c_variadic: false,
180           fixed_count: 1,
181           conv: Rust,
182           can_unwind: $SOME_BOOL,
183       }
184  --> $DIR/debug.rs:18:1
185   |
186LL | type TestFnPtr = fn(bool) -> u8;
187   | ^^^^^^^^^^^^^^
188
189error: fn_abi_of(test_generic) = FnAbi {
190           args: [
191               ArgAbi {
192                   layout: TyAndLayout {
193                       ty: *const T,
194                       layout: Layout {
195                           size: $SOME_SIZE,
196                           align: AbiAndPrefAlign {
197                               abi: $SOME_ALIGN,
198                               pref: $SOME_ALIGN,
199                           },
200                           abi: Scalar(
201                               Initialized {
202                                   value: Pointer(
203                                       AddressSpace(
204                                           0,
205                                       ),
206                                   ),
207                                   valid_range: $FULL,
208                               },
209                           ),
210                           fields: Primitive,
211                           largest_niche: None,
212                           variants: Single {
213                               index: 0,
214                           },
215                           max_repr_align: None,
216                           unadjusted_abi_align: $SOME_ALIGN,
217                       },
218                   },
219                   mode: Direct(
220                       ArgAttributes {
221                           regular: NoUndef,
222                           arg_ext: None,
223                           pointee_size: Size(0 bytes),
224                           pointee_align: None,
225                       },
226                   ),
227               },
228           ],
229           ret: ArgAbi {
230               layout: TyAndLayout {
231                   ty: (),
232                   layout: Layout {
233                       size: Size(0 bytes),
234                       align: AbiAndPrefAlign {
235                           abi: $SOME_ALIGN,
236                           pref: $SOME_ALIGN,
237                       },
238                       abi: Aggregate {
239                           sized: true,
240                       },
241                       fields: Arbitrary {
242                           offsets: [],
243                           memory_index: [],
244                       },
245                       largest_niche: None,
246                       variants: Single {
247                           index: 0,
248                       },
249                       max_repr_align: None,
250                       unadjusted_abi_align: $SOME_ALIGN,
251                   },
252               },
253               mode: Ignore,
254           },
255           c_variadic: false,
256           fixed_count: 1,
257           conv: Rust,
258           can_unwind: $SOME_BOOL,
259       }
260  --> $DIR/debug.rs:21:1
261   |
262LL | fn test_generic<T>(_x: *const T) { }
263   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
264
265error: `#[rustc_abi]` can only be applied to function items, type aliases, and associated functions
266  --> $DIR/debug.rs:24:1
267   |
268LL | const C: () = ();
269   | ^^^^^^^^^^^
270
271error: ABIs are not compatible
272       left ABI = FnAbi {
273           args: [
274               ArgAbi {
275                   layout: TyAndLayout {
276                       ty: u8,
277                       layout: Layout {
278                           size: Size(1 bytes),
279                           align: AbiAndPrefAlign {
280                               abi: $SOME_ALIGN,
281                               pref: $SOME_ALIGN,
282                           },
283                           abi: Scalar(
284                               Initialized {
285                                   value: Int(
286                                       I8,
287                                       false,
288                                   ),
289                                   valid_range: 0..=255,
290                               },
291                           ),
292                           fields: Primitive,
293                           largest_niche: None,
294                           variants: Single {
295                               index: 0,
296                           },
297                           max_repr_align: None,
298                           unadjusted_abi_align: $SOME_ALIGN,
299                       },
300                   },
301                   mode: Direct(
302                       ArgAttributes {
303                           regular: NoUndef,
304                           arg_ext: None,
305                           pointee_size: Size(0 bytes),
306                           pointee_align: None,
307                       },
308                   ),
309               },
310           ],
311           ret: ArgAbi {
312               layout: TyAndLayout {
313                   ty: (),
314                   layout: Layout {
315                       size: Size(0 bytes),
316                       align: AbiAndPrefAlign {
317                           abi: $SOME_ALIGN,
318                           pref: $SOME_ALIGN,
319                       },
320                       abi: Aggregate {
321                           sized: true,
322                       },
323                       fields: Arbitrary {
324                           offsets: [],
325                           memory_index: [],
326                       },
327                       largest_niche: None,
328                       variants: Single {
329                           index: 0,
330                       },
331                       max_repr_align: None,
332                       unadjusted_abi_align: $SOME_ALIGN,
333                   },
334               },
335               mode: Ignore,
336           },
337           c_variadic: false,
338           fixed_count: 1,
339           conv: Rust,
340           can_unwind: $SOME_BOOL,
341       }
342       right ABI = FnAbi {
343           args: [
344               ArgAbi {
345                   layout: TyAndLayout {
346                       ty: u32,
347                       layout: Layout {
348                           size: $SOME_SIZE,
349                           align: AbiAndPrefAlign {
350                               abi: $SOME_ALIGN,
351                               pref: $SOME_ALIGN,
352                           },
353                           abi: Scalar(
354                               Initialized {
355                                   value: Int(
356                                       I32,
357                                       false,
358                                   ),
359                                   valid_range: $FULL,
360                               },
361                           ),
362                           fields: Primitive,
363                           largest_niche: None,
364                           variants: Single {
365                               index: 0,
366                           },
367                           max_repr_align: None,
368                           unadjusted_abi_align: $SOME_ALIGN,
369                       },
370                   },
371                   mode: Direct(
372                       ArgAttributes {
373                           regular: NoUndef,
374                           arg_ext: None,
375                           pointee_size: Size(0 bytes),
376                           pointee_align: None,
377                       },
378                   ),
379               },
380           ],
381           ret: ArgAbi {
382               layout: TyAndLayout {
383                   ty: (),
384                   layout: Layout {
385                       size: Size(0 bytes),
386                       align: AbiAndPrefAlign {
387                           abi: $SOME_ALIGN,
388                           pref: $SOME_ALIGN,
389                       },
390                       abi: Aggregate {
391                           sized: true,
392                       },
393                       fields: Arbitrary {
394                           offsets: [],
395                           memory_index: [],
396                       },
397                       largest_niche: None,
398                       variants: Single {
399                           index: 0,
400                       },
401                       max_repr_align: None,
402                       unadjusted_abi_align: $SOME_ALIGN,
403                   },
404               },
405               mode: Ignore,
406           },
407           c_variadic: false,
408           fixed_count: 1,
409           conv: Rust,
410           can_unwind: $SOME_BOOL,
411       }
412  --> $DIR/debug.rs:40:1
413   |
414LL | type TestAbiNe = (fn(u8), fn(u32));
415   | ^^^^^^^^^^^^^^
416
417error: ABIs are not compatible
418       left ABI = FnAbi {
419           args: [
420               ArgAbi {
421                   layout: TyAndLayout {
422                       ty: [u8; 32],
423                       layout: Layout {
424                           size: Size(32 bytes),
425                           align: AbiAndPrefAlign {
426                               abi: $SOME_ALIGN,
427                               pref: $SOME_ALIGN,
428                           },
429                           abi: Aggregate {
430                               sized: true,
431                           },
432                           fields: Array {
433                               stride: Size(1 bytes),
434                               count: 32,
435                           },
436                           largest_niche: None,
437                           variants: Single {
438                               index: 0,
439                           },
440                           max_repr_align: None,
441                           unadjusted_abi_align: $SOME_ALIGN,
442                       },
443                   },
444                   mode: Indirect {
445                       attrs: ArgAttributes {
446                           regular: NoAlias | NoCapture | NonNull | NoUndef,
447                           arg_ext: None,
448                           pointee_size: Size(32 bytes),
449                           pointee_align: Some(
450                               Align(1 bytes),
451                           ),
452                       },
453                       meta_attrs: None,
454                       on_stack: false,
455                   },
456               },
457           ],
458           ret: ArgAbi {
459               layout: TyAndLayout {
460                   ty: (),
461                   layout: Layout {
462                       size: Size(0 bytes),
463                       align: AbiAndPrefAlign {
464                           abi: $SOME_ALIGN,
465                           pref: $SOME_ALIGN,
466                       },
467                       abi: Aggregate {
468                           sized: true,
469                       },
470                       fields: Arbitrary {
471                           offsets: [],
472                           memory_index: [],
473                       },
474                       largest_niche: None,
475                       variants: Single {
476                           index: 0,
477                       },
478                       max_repr_align: None,
479                       unadjusted_abi_align: $SOME_ALIGN,
480                   },
481               },
482               mode: Ignore,
483           },
484           c_variadic: false,
485           fixed_count: 1,
486           conv: Rust,
487           can_unwind: $SOME_BOOL,
488       }
489       right ABI = FnAbi {
490           args: [
491               ArgAbi {
492                   layout: TyAndLayout {
493                       ty: [u32; 32],
494                       layout: Layout {
495                           size: Size(128 bytes),
496                           align: AbiAndPrefAlign {
497                               abi: $SOME_ALIGN,
498                               pref: $SOME_ALIGN,
499                           },
500                           abi: Aggregate {
501                               sized: true,
502                           },
503                           fields: Array {
504                               stride: Size(4 bytes),
505                               count: 32,
506                           },
507                           largest_niche: None,
508                           variants: Single {
509                               index: 0,
510                           },
511                           max_repr_align: None,
512                           unadjusted_abi_align: $SOME_ALIGN,
513                       },
514                   },
515                   mode: Indirect {
516                       attrs: ArgAttributes {
517                           regular: NoAlias | NoCapture | NonNull | NoUndef,
518                           arg_ext: None,
519                           pointee_size: Size(128 bytes),
520                           pointee_align: Some(
521                               Align(4 bytes),
522                           ),
523                       },
524                       meta_attrs: None,
525                       on_stack: false,
526                   },
527               },
528           ],
529           ret: ArgAbi {
530               layout: TyAndLayout {
531                   ty: (),
532                   layout: Layout {
533                       size: Size(0 bytes),
534                       align: AbiAndPrefAlign {
535                           abi: $SOME_ALIGN,
536                           pref: $SOME_ALIGN,
537                       },
538                       abi: Aggregate {
539                           sized: true,
540                       },
541                       fields: Arbitrary {
542                           offsets: [],
543                           memory_index: [],
544                       },
545                       largest_niche: None,
546                       variants: Single {
547                           index: 0,
548                       },
549                       max_repr_align: None,
550                       unadjusted_abi_align: $SOME_ALIGN,
551                   },
552               },
553               mode: Ignore,
554           },
555           c_variadic: false,
556           fixed_count: 1,
557           conv: Rust,
558           can_unwind: $SOME_BOOL,
559       }
560  --> $DIR/debug.rs:43:1
561   |
562LL | type TestAbiNeLarger = (fn([u8; 32]), fn([u32; 32]));
563   | ^^^^^^^^^^^^^^^^^^^^
564
565error: ABIs are not compatible
566       left ABI = FnAbi {
567           args: [
568               ArgAbi {
569                   layout: TyAndLayout {
570                       ty: f32,
571                       layout: Layout {
572                           size: $SOME_SIZE,
573                           align: AbiAndPrefAlign {
574                               abi: $SOME_ALIGN,
575                               pref: $SOME_ALIGN,
576                           },
577                           abi: Scalar(
578                               Initialized {
579                                   value: F32,
580                                   valid_range: $FULL,
581                               },
582                           ),
583                           fields: Primitive,
584                           largest_niche: None,
585                           variants: Single {
586                               index: 0,
587                           },
588                           max_repr_align: None,
589                           unadjusted_abi_align: $SOME_ALIGN,
590                       },
591                   },
592                   mode: Direct(
593                       ArgAttributes {
594                           regular: NoUndef,
595                           arg_ext: None,
596                           pointee_size: Size(0 bytes),
597                           pointee_align: None,
598                       },
599                   ),
600               },
601           ],
602           ret: ArgAbi {
603               layout: TyAndLayout {
604                   ty: (),
605                   layout: Layout {
606                       size: Size(0 bytes),
607                       align: AbiAndPrefAlign {
608                           abi: $SOME_ALIGN,
609                           pref: $SOME_ALIGN,
610                       },
611                       abi: Aggregate {
612                           sized: true,
613                       },
614                       fields: Arbitrary {
615                           offsets: [],
616                           memory_index: [],
617                       },
618                       largest_niche: None,
619                       variants: Single {
620                           index: 0,
621                       },
622                       max_repr_align: None,
623                       unadjusted_abi_align: $SOME_ALIGN,
624                   },
625               },
626               mode: Ignore,
627           },
628           c_variadic: false,
629           fixed_count: 1,
630           conv: Rust,
631           can_unwind: $SOME_BOOL,
632       }
633       right ABI = FnAbi {
634           args: [
635               ArgAbi {
636                   layout: TyAndLayout {
637                       ty: u32,
638                       layout: Layout {
639                           size: $SOME_SIZE,
640                           align: AbiAndPrefAlign {
641                               abi: $SOME_ALIGN,
642                               pref: $SOME_ALIGN,
643                           },
644                           abi: Scalar(
645                               Initialized {
646                                   value: Int(
647                                       I32,
648                                       false,
649                                   ),
650                                   valid_range: $FULL,
651                               },
652                           ),
653                           fields: Primitive,
654                           largest_niche: None,
655                           variants: Single {
656                               index: 0,
657                           },
658                           max_repr_align: None,
659                           unadjusted_abi_align: $SOME_ALIGN,
660                       },
661                   },
662                   mode: Direct(
663                       ArgAttributes {
664                           regular: NoUndef,
665                           arg_ext: None,
666                           pointee_size: Size(0 bytes),
667                           pointee_align: None,
668                       },
669                   ),
670               },
671           ],
672           ret: ArgAbi {
673               layout: TyAndLayout {
674                   ty: (),
675                   layout: Layout {
676                       size: Size(0 bytes),
677                       align: AbiAndPrefAlign {
678                           abi: $SOME_ALIGN,
679                           pref: $SOME_ALIGN,
680                       },
681                       abi: Aggregate {
682                           sized: true,
683                       },
684                       fields: Arbitrary {
685                           offsets: [],
686                           memory_index: [],
687                       },
688                       largest_niche: None,
689                       variants: Single {
690                           index: 0,
691                       },
692                       max_repr_align: None,
693                       unadjusted_abi_align: $SOME_ALIGN,
694                   },
695               },
696               mode: Ignore,
697           },
698           c_variadic: false,
699           fixed_count: 1,
700           conv: Rust,
701           can_unwind: $SOME_BOOL,
702       }
703  --> $DIR/debug.rs:46:1
704   |
705LL | type TestAbiNeFloat = (fn(f32), fn(u32));
706   | ^^^^^^^^^^^^^^^^^^^
707
708error: ABIs are not compatible
709       left ABI = FnAbi {
710           args: [
711               ArgAbi {
712                   layout: TyAndLayout {
713                       ty: i32,
714                       layout: Layout {
715                           size: $SOME_SIZE,
716                           align: AbiAndPrefAlign {
717                               abi: $SOME_ALIGN,
718                               pref: $SOME_ALIGN,
719                           },
720                           abi: Scalar(
721                               Initialized {
722                                   value: Int(
723                                       I32,
724                                       true,
725                                   ),
726                                   valid_range: $FULL,
727                               },
728                           ),
729                           fields: Primitive,
730                           largest_niche: None,
731                           variants: Single {
732                               index: 0,
733                           },
734                           max_repr_align: None,
735                           unadjusted_abi_align: $SOME_ALIGN,
736                       },
737                   },
738                   mode: Direct(
739                       ArgAttributes {
740                           regular: NoUndef,
741                           arg_ext: None,
742                           pointee_size: Size(0 bytes),
743                           pointee_align: None,
744                       },
745                   ),
746               },
747           ],
748           ret: ArgAbi {
749               layout: TyAndLayout {
750                   ty: (),
751                   layout: Layout {
752                       size: Size(0 bytes),
753                       align: AbiAndPrefAlign {
754                           abi: $SOME_ALIGN,
755                           pref: $SOME_ALIGN,
756                       },
757                       abi: Aggregate {
758                           sized: true,
759                       },
760                       fields: Arbitrary {
761                           offsets: [],
762                           memory_index: [],
763                       },
764                       largest_niche: None,
765                       variants: Single {
766                           index: 0,
767                       },
768                       max_repr_align: None,
769                       unadjusted_abi_align: $SOME_ALIGN,
770                   },
771               },
772               mode: Ignore,
773           },
774           c_variadic: false,
775           fixed_count: 1,
776           conv: Rust,
777           can_unwind: $SOME_BOOL,
778       }
779       right ABI = FnAbi {
780           args: [
781               ArgAbi {
782                   layout: TyAndLayout {
783                       ty: u32,
784                       layout: Layout {
785                           size: $SOME_SIZE,
786                           align: AbiAndPrefAlign {
787                               abi: $SOME_ALIGN,
788                               pref: $SOME_ALIGN,
789                           },
790                           abi: Scalar(
791                               Initialized {
792                                   value: Int(
793                                       I32,
794                                       false,
795                                   ),
796                                   valid_range: $FULL,
797                               },
798                           ),
799                           fields: Primitive,
800                           largest_niche: None,
801                           variants: Single {
802                               index: 0,
803                           },
804                           max_repr_align: None,
805                           unadjusted_abi_align: $SOME_ALIGN,
806                       },
807                   },
808                   mode: Direct(
809                       ArgAttributes {
810                           regular: NoUndef,
811                           arg_ext: None,
812                           pointee_size: Size(0 bytes),
813                           pointee_align: None,
814                       },
815                   ),
816               },
817           ],
818           ret: ArgAbi {
819               layout: TyAndLayout {
820                   ty: (),
821                   layout: Layout {
822                       size: Size(0 bytes),
823                       align: AbiAndPrefAlign {
824                           abi: $SOME_ALIGN,
825                           pref: $SOME_ALIGN,
826                       },
827                       abi: Aggregate {
828                           sized: true,
829                       },
830                       fields: Arbitrary {
831                           offsets: [],
832                           memory_index: [],
833                       },
834                       largest_niche: None,
835                       variants: Single {
836                           index: 0,
837                       },
838                       max_repr_align: None,
839                       unadjusted_abi_align: $SOME_ALIGN,
840                   },
841               },
842               mode: Ignore,
843           },
844           c_variadic: false,
845           fixed_count: 1,
846           conv: Rust,
847           can_unwind: $SOME_BOOL,
848       }
849  --> $DIR/debug.rs:50:1
850   |
851LL | type TestAbiNeSign = (fn(i32), fn(u32));
852   | ^^^^^^^^^^^^^^^^^^
853
854error[E0277]: the size for values of type `str` cannot be known at compilation time
855  --> $DIR/debug.rs:53:46
856   |
857LL | type TestAbiEqNonsense = (fn((str, str)), fn((str, str)));
858   |                                              ^^^^^^^^^^ doesn't have a size known at compile-time
859   |
860   = help: the trait `Sized` is not implemented for `str`
861   = note: only the last element of a tuple may have a dynamically sized type
862
863error: `#[rustc_abi]` can only be applied to function items, type aliases, and associated functions
864  --> $DIR/debug.rs:28:5
865   |
866LL |     const C: () = ();
867   |     ^^^^^^^^^^^
868
869error: fn_abi_of(assoc_test) = FnAbi {
870           args: [
871               ArgAbi {
872                   layout: TyAndLayout {
873                       ty: &S,
874                       layout: Layout {
875                           size: $SOME_SIZE,
876                           align: AbiAndPrefAlign {
877                               abi: $SOME_ALIGN,
878                               pref: $SOME_ALIGN,
879                           },
880                           abi: Scalar(
881                               Initialized {
882                                   value: Pointer(
883                                       AddressSpace(
884                                           0,
885                                       ),
886                                   ),
887                                   valid_range: $NON_NULL,
888                               },
889                           ),
890                           fields: Primitive,
891                           largest_niche: Some(
892                               Niche {
893                                   offset: Size(0 bytes),
894                                   value: Pointer(
895                                       AddressSpace(
896                                           0,
897                                       ),
898                                   ),
899                                   valid_range: $NON_NULL,
900                               },
901                           ),
902                           variants: Single {
903                               index: 0,
904                           },
905                           max_repr_align: None,
906                           unadjusted_abi_align: $SOME_ALIGN,
907                       },
908                   },
909                   mode: Direct(
910                       ArgAttributes {
911                           regular: NoAlias | NonNull | ReadOnly | NoUndef,
912                           arg_ext: None,
913                           pointee_size: Size(2 bytes),
914                           pointee_align: Some(
915                               Align(2 bytes),
916                           ),
917                       },
918                   ),
919               },
920           ],
921           ret: ArgAbi {
922               layout: TyAndLayout {
923                   ty: (),
924                   layout: Layout {
925                       size: Size(0 bytes),
926                       align: AbiAndPrefAlign {
927                           abi: $SOME_ALIGN,
928                           pref: $SOME_ALIGN,
929                       },
930                       abi: Aggregate {
931                           sized: true,
932                       },
933                       fields: Arbitrary {
934                           offsets: [],
935                           memory_index: [],
936                       },
937                       largest_niche: None,
938                       variants: Single {
939                           index: 0,
940                       },
941                       max_repr_align: None,
942                       unadjusted_abi_align: $SOME_ALIGN,
943                   },
944               },
945               mode: Ignore,
946           },
947           c_variadic: false,
948           fixed_count: 1,
949           conv: Rust,
950           can_unwind: $SOME_BOOL,
951       }
952  --> $DIR/debug.rs:33:5
953   |
954LL |     fn assoc_test(&self) { }
955   |     ^^^^^^^^^^^^^^^^^^^^
956
957error: aborting due to 11 previous errors
958
959For more information about this error, try `rustc --explain E0277`.