mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
2b2c0f9886
rust/tests/ui/layout/zero-sized-array-enum-niche.stderr

451 lines
15 KiB
Plaintext
Raw Normal View History

Disentangle `Debug` and `Display` for `Ty`. The `Debug` impl for `Ty` just calls the `Display` impl for `Ty`. This is surprising and annoying. In particular, it means `Debug` doesn't show as much information as `Debug` for `TyKind` does. And `Debug` is used in some user-facing error messages, which seems bad. This commit changes the `Debug` impl for `Ty` to call the `Debug` impl for `TyKind`. It also does a number of follow-up changes to preserve existing output, many of which involve inserting `with_no_trimmed_paths!` calls. It also adds `Display` impls for `UserType` and `Canonical`. Some tests have changes to expected output: - Those that use the `rustc_abi(debug)` attribute. - Those that use the `EMIT_MIR` annotation. In each case the output is slightly uglier than before. This isn't ideal, but it's pretty weird (particularly for the attribute) that the output is using `Debug` in the first place. They're fairly obscure attributes (I hadn't heard of them) so I'm not worried by this. For `async-is-unwindsafe.stderr`, there is one line that now lacks a full path. This is a consistency improvement, because all the other mentions of `Context` in this test lack a path.
2023-09-07 00:14:40 -05:00
error: layout_of(Result<[u32; 0], bool>) = Layout {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
size: Size(4 bytes),
align: AbiAndPrefAlign {
abi: Align(4 bytes),
pref: $PREF_ALIGN,
},
abi: Aggregate {
sized: true,
},
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
fields: Arbitrary {
offsets: [
Size(0 bytes),
],
memory_index: [
0,
],
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
largest_niche: Some(
Niche {
offset: Size(0 bytes),
value: Int(
I8,
false,
),
valid_range: 0..=1,
},
),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
variants: Multiple {
tag: Initialized {
value: Int(
I8,
false,
),
valid_range: 0..=1,
},
tag_encoding: Direct,
tag_field: 0,
variants: [
Layout {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
size: Size(4 bytes),
align: AbiAndPrefAlign {
abi: Align(4 bytes),
pref: $PREF_ALIGN,
},
abi: Aggregate {
sized: true,
},
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
fields: Arbitrary {
offsets: [
Size(4 bytes),
],
memory_index: [
0,
],
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
largest_niche: None,
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
variants: Single {
index: 0,
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(4 bytes),
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
},
Layout {
size: Size(2 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
align: AbiAndPrefAlign {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Align(1 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
pref: $PREF_ALIGN,
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Aggregate {
sized: true,
},
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
fields: Arbitrary {
offsets: [
Size(1 bytes),
],
memory_index: [
0,
],
},
largest_niche: Some(
Niche {
offset: Size(1 bytes),
value: Int(
I8,
false,
),
valid_range: 0..=1,
},
),
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
variants: Single {
index: 1,
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(1 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
},
],
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(4 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
}
--> $DIR/zero-sized-array-enum-niche.rs:13:1
|
LL | type AlignedResult = Result<[u32; 0], bool>;
| ^^^^^^^^^^^^^^^^^^
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
error: layout_of(MultipleAlignments) = Layout {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
size: Size(4 bytes),
align: AbiAndPrefAlign {
abi: Align(4 bytes),
pref: $PREF_ALIGN,
},
abi: Aggregate {
sized: true,
},
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
fields: Arbitrary {
offsets: [
Size(0 bytes),
],
memory_index: [
0,
],
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
largest_niche: Some(
Niche {
offset: Size(0 bytes),
value: Int(
I8,
false,
),
valid_range: 0..=2,
},
),
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
variants: Multiple {
tag: Initialized {
value: Int(
I8,
false,
),
valid_range: 0..=2,
},
tag_encoding: Direct,
tag_field: 0,
variants: [
Layout {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
size: Size(2 bytes),
align: AbiAndPrefAlign {
abi: Align(2 bytes),
pref: $PREF_ALIGN,
},
abi: Aggregate {
sized: true,
},
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
fields: Arbitrary {
offsets: [
Size(2 bytes),
],
memory_index: [
0,
],
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
largest_niche: None,
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
variants: Single {
index: 0,
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(2 bytes),
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
},
Layout {
size: Size(4 bytes),
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
align: AbiAndPrefAlign {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Align(4 bytes),
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
pref: $PREF_ALIGN,
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Aggregate {
sized: true,
},
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
fields: Arbitrary {
offsets: [
Size(4 bytes),
],
memory_index: [
0,
],
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
largest_niche: None,
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
variants: Single {
index: 1,
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(4 bytes),
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
},
Layout {
size: Size(2 bytes),
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
align: AbiAndPrefAlign {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Align(1 bytes),
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
pref: $PREF_ALIGN,
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Aggregate {
sized: true,
},
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
fields: Arbitrary {
offsets: [
Size(1 bytes),
],
memory_index: [
0,
],
},
largest_niche: Some(
Niche {
offset: Size(1 bytes),
value: Int(
I8,
false,
),
valid_range: 0..=1,
},
),
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
variants: Single {
index: 2,
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(1 bytes),
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
},
],
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(4 bytes),
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
}
--> $DIR/zero-sized-array-enum-niche.rs:21:1
|
LL | enum MultipleAlignments {
| ^^^^^^^^^^^^^^^^^^^^^^^
Disentangle `Debug` and `Display` for `Ty`. The `Debug` impl for `Ty` just calls the `Display` impl for `Ty`. This is surprising and annoying. In particular, it means `Debug` doesn't show as much information as `Debug` for `TyKind` does. And `Debug` is used in some user-facing error messages, which seems bad. This commit changes the `Debug` impl for `Ty` to call the `Debug` impl for `TyKind`. It also does a number of follow-up changes to preserve existing output, many of which involve inserting `with_no_trimmed_paths!` calls. It also adds `Display` impls for `UserType` and `Canonical`. Some tests have changes to expected output: - Those that use the `rustc_abi(debug)` attribute. - Those that use the `EMIT_MIR` annotation. In each case the output is slightly uglier than before. This isn't ideal, but it's pretty weird (particularly for the attribute) that the output is using `Debug` in the first place. They're fairly obscure attributes (I hadn't heard of them) so I'm not worried by this. For `async-is-unwindsafe.stderr`, there is one line that now lacks a full path. This is a consistency improvement, because all the other mentions of `Context` in this test lack a path.
2023-09-07 00:14:40 -05:00
error: layout_of(Result<[u32; 0], Packed<NonZeroU16>>) = Layout {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
size: Size(4 bytes),
align: AbiAndPrefAlign {
abi: Align(4 bytes),
pref: $PREF_ALIGN,
},
abi: Aggregate {
sized: true,
},
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
fields: Arbitrary {
offsets: [
Size(0 bytes),
],
memory_index: [
0,
],
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
largest_niche: Some(
Niche {
offset: Size(0 bytes),
value: Int(
I8,
false,
),
valid_range: 0..=1,
},
),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
variants: Multiple {
tag: Initialized {
value: Int(
I8,
false,
),
valid_range: 0..=1,
},
tag_encoding: Direct,
tag_field: 0,
variants: [
Layout {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
size: Size(4 bytes),
align: AbiAndPrefAlign {
abi: Align(4 bytes),
pref: $PREF_ALIGN,
},
abi: Aggregate {
sized: true,
},
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
fields: Arbitrary {
offsets: [
Size(4 bytes),
],
memory_index: [
0,
],
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
largest_niche: None,
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
variants: Single {
index: 0,
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(4 bytes),
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
},
Layout {
size: Size(3 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
align: AbiAndPrefAlign {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Align(1 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
pref: $PREF_ALIGN,
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Aggregate {
sized: true,
},
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
fields: Arbitrary {
offsets: [
Size(1 bytes),
],
memory_index: [
0,
],
},
largest_niche: Some(
Niche {
offset: Size(1 bytes),
value: Int(
I16,
false,
),
valid_range: 1..=65535,
},
),
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
variants: Single {
index: 1,
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(1 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
},
],
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(4 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
}
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
--> $DIR/zero-sized-array-enum-niche.rs:37:1
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
|
LL | type NicheLosesToTagged = Result<[u32; 0], Packed<std::num::NonZeroU16>>;
| ^^^^^^^^^^^^^^^^^^^^^^^
Disentangle `Debug` and `Display` for `Ty`. The `Debug` impl for `Ty` just calls the `Display` impl for `Ty`. This is surprising and annoying. In particular, it means `Debug` doesn't show as much information as `Debug` for `TyKind` does. And `Debug` is used in some user-facing error messages, which seems bad. This commit changes the `Debug` impl for `Ty` to call the `Debug` impl for `TyKind`. It also does a number of follow-up changes to preserve existing output, many of which involve inserting `with_no_trimmed_paths!` calls. It also adds `Display` impls for `UserType` and `Canonical`. Some tests have changes to expected output: - Those that use the `rustc_abi(debug)` attribute. - Those that use the `EMIT_MIR` annotation. In each case the output is slightly uglier than before. This isn't ideal, but it's pretty weird (particularly for the attribute) that the output is using `Debug` in the first place. They're fairly obscure attributes (I hadn't heard of them) so I'm not worried by this. For `async-is-unwindsafe.stderr`, there is one line that now lacks a full path. This is a consistency improvement, because all the other mentions of `Context` in this test lack a path.
2023-09-07 00:14:40 -05:00
error: layout_of(Result<[u32; 0], Packed<U16IsZero>>) = Layout {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
size: Size(4 bytes),
align: AbiAndPrefAlign {
abi: Align(4 bytes),
pref: $PREF_ALIGN,
},
abi: Aggregate {
sized: true,
},
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
fields: Arbitrary {
offsets: [
Size(0 bytes),
],
memory_index: [
0,
],
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
largest_niche: Some(
Niche {
offset: Size(0 bytes),
value: Int(
I16,
false,
),
valid_range: 0..=1,
},
),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
variants: Multiple {
tag: Initialized {
value: Int(
I16,
false,
),
valid_range: 0..=1,
},
tag_encoding: Niche {
Change name of "dataful" variant to "untagged" This is in anticipation of a new enum layout, in which the niche optimization may be applied even when multiple variants have data.
2022-08-24 20:14:23 -05:00
untagged_variant: 1,
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
niche_variants: 0..=0,
niche_start: 1,
},
tag_field: 0,
variants: [
Layout {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
size: Size(0 bytes),
align: AbiAndPrefAlign {
abi: Align(4 bytes),
pref: $PREF_ALIGN,
},
abi: Aggregate {
sized: true,
},
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
fields: Arbitrary {
offsets: [
Size(0 bytes),
],
memory_index: [
0,
],
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
largest_niche: None,
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
variants: Single {
index: 0,
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(4 bytes),
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
},
Layout {
size: Size(2 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
align: AbiAndPrefAlign {
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Align(1 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
pref: $PREF_ALIGN,
},
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
abi: Aggregate {
sized: true,
},
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
fields: Arbitrary {
offsets: [
Size(0 bytes),
],
memory_index: [
0,
],
},
largest_niche: Some(
Niche {
offset: Size(0 bytes),
value: Int(
I16,
false,
),
valid_range: 0..=0,
},
),
reorder fields in Laout debug output
2022-07-30 20:39:15 -05:00
variants: Single {
index: 1,
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(1 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
},
],
},
i686-windows: make requested alignment > 4 special case apply transitively
2023-07-14 16:48:13 -05:00
max_repr_align: None,
aarch64-linux: properly handle 128bit aligned aggregates
2023-06-14 21:39:11 -05:00
unadjusted_abi_align: Align(4 bytes),
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
}
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
--> $DIR/zero-sized-array-enum-niche.rs:44:1
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
|
LL | type NicheWinsOverTagged = Result<[u32; 0], Packed<U16IsZero>>;
| ^^^^^^^^^^^^^^^^^^^^^^^^
Test another enum niche with multiple ZST alignments
2022-07-30 13:54:15 -05:00
error: aborting due to 4 previous errors
Fix the size of niche enums with ZST alignment For enums with an aligned ZST variant, like `[T; 0]`, the niche layout was not computing a sufficient size to be consistent with alignment. Now we pad that size up to the alignment, and also make sure to only use the niche variant's ABI when the size and alignment still match.
2022-07-30 12:45:48 -05:00
Reference in New Issue Copy Permalink