bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Align multiline messages to their label (add left margin)

Browse source
This commit is contained in:
Esteban Kuber 2021-10-13 13:58:41 +00:00
parent 563db4245b
commit 8f433adf75
12 changed files with 1310 additions and 1297 deletions
Download patch file Download diff file Expand all files Collapse all files

17
compiler/rustc_errors/src/emitter.rs
View file

@ -1266,22 +1266,37 @@ impl EmitterWriter {
} }
self.msg_to_buffer(&mut buffer, msg, max_line_num_len, "note", None); self.msg_to_buffer(&mut buffer, msg, max_line_num_len, "note", None);
} else { } else {
let mut label_width = 0;
// The failure note level itself does not provide any useful diagnostic information // The failure note level itself does not provide any useful diagnostic information
if *level != Level::FailureNote { if *level != Level::FailureNote {
buffer.append(0, level.to_str(), Style::Level(*level)); buffer.append(0, level.to_str(), Style::Level(*level));
label_width += level.to_str().len();
} }
// only render error codes, not lint codes // only render error codes, not lint codes
if let Some(DiagnosticId::Error(ref code)) = *code { if let Some(DiagnosticId::Error(ref code)) = *code {
buffer.append(0, "[", Style::Level(*level)); buffer.append(0, "[", Style::Level(*level));
buffer.append(0, &code, Style::Level(*level)); buffer.append(0, &code, Style::Level(*level));
buffer.append(0, "]", Style::Level(*level)); buffer.append(0, "]", Style::Level(*level));
label_width += 2 + code.len();
} }
let header_style = if is_secondary { Style::HeaderMsg } else { Style::MainHeaderMsg }; let header_style = if is_secondary { Style::HeaderMsg } else { Style::MainHeaderMsg };
if *level != Level::FailureNote { if *level != Level::FailureNote {
buffer.append(0, ": ", header_style); buffer.append(0, ": ", header_style);
label_width += 2;
} }
for &(ref text, _) in msg.iter() { for &(ref text, _) in msg.iter() {
buffer.append(0, &replace_tabs(text), header_style); // Account for newlines to align output to its label.
for (line, text) in replace_tabs(text).lines().enumerate() {
buffer.append(
0 + line,
&format!(
"{}{}",
if line == 0 { String::new() } else { " ".repeat(label_width) },
text
),
header_style,
);
}
} }
} }

18
src/test/ui/attributes/key-value-expansion.stderr
View file

@ -16,15 +16,15 @@ LL | bug!();
= note: this error originates in the macro `bug` (in Nightly builds, run with -Z macro-backtrace for more info) = note: this error originates in the macro `bug` (in Nightly builds, run with -Z macro-backtrace for more info)
error: unexpected token: `{ error: unexpected token: `{
let res = let res =
::alloc::fmt::format(::core::fmt::Arguments::new_v1(&[""], ::alloc::fmt::format(::core::fmt::Arguments::new_v1(&[""],
&match (&"u8",) { &match (&"u8",) {
_args => _args =>
[::core::fmt::ArgumentV1::new(_args.0, [::core::fmt::ArgumentV1::new(_args.0,
::core::fmt::Display::fmt)], ::core::fmt::Display::fmt)],
})); }));
res res
}.as_str()` }.as_str()`
--> $DIR/key-value-expansion.rs:48:23 --> $DIR/key-value-expansion.rs:48:23
| |
LL | doc_comment! {format!("{coor}", coor = stringify!($t1)).as_str()} LL | doc_comment! {format!("{coor}", coor = stringify!($t1)).as_str()}

1
src/test/ui/cmse-nonsecure/cmse-nonsecure-call/params-on-stack.stderr
View file

@ -1,5 +1,4 @@
error: <unknown>:0:0: in function test i32 (i32, i32, i32, i32, i32): call to non-secure function would require passing arguments on stack error: <unknown>:0:0: in function test i32 (i32, i32, i32, i32, i32): call to non-secure function would require passing arguments on stack
error: aborting due to previous error error: aborting due to previous error

1
src/test/ui/cmse-nonsecure/cmse-nonsecure-entry/params-on-stack.stderr
View file

@ -1,5 +1,4 @@
error: <unknown>:0:0: in function entry_function i32 (i32, i32, i32, i32, i32): secure entry function requires arguments on stack error: <unknown>:0:0: in function entry_function i32 (i32, i32, i32, i32, i32): secure entry function requires arguments on stack
error: aborting due to previous error error: aborting due to previous error

634
src/test/ui/layout/debug.stderr
View file

@ -1,345 +1,345 @@
error: layout_of(E) = Layout { error: layout_of(E) = Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [ offsets: [
Size { Size {
raw: 0, raw: 0,
}, },
], ],
memory_index: [ memory_index: [
0, 0,
], ],
}, },
variants: Multiple { variants: Multiple {
tag: Scalar { tag: Scalar {
value: Int( value: Int(
I32, I32,
false, false,
), ),
valid_range: 0..=0, valid_range: 0..=0,
}, },
tag_encoding: Direct, tag_encoding: Direct,
tag_field: 0, tag_field: 0,
variants: [ variants: [
Layout { Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [], offsets: [],
memory_index: [], memory_index: [],
}, },
variants: Single { variants: Single {
index: 0, index: 0,
}, },
abi: Aggregate { abi: Aggregate {
sized: true, sized: true,
}, },
largest_niche: None, largest_niche: None,
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 0, pow2: 0,
}, },
pref: $PREF_ALIGN, pref: $PREF_ALIGN,
}, },
size: Size { size: Size {
raw: 4, raw: 4,
}, },
}, },
Layout { Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [ offsets: [
Size { Size {
raw: 4, raw: 4,
}, },
Size { Size {
raw: 4, raw: 4,
}, },
Size { Size {
raw: 8, raw: 8,
}, },
], ],
memory_index: [ memory_index: [
0, 0,
1, 1,
2, 2,
], ],
}, },
variants: Single { variants: Single {
index: 1, index: 1,
}, },
abi: Uninhabited, abi: Uninhabited,
largest_niche: None, largest_niche: None,
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 2, pow2: 2,
}, },
pref: $PREF_ALIGN, pref: $PREF_ALIGN,
}, },
size: Size { size: Size {
raw: 12, raw: 12,
}, },
}, },
], ],
}, },
abi: Aggregate { abi: Aggregate {
sized: true, sized: true,
}, },
largest_niche: Some( largest_niche: Some(
Niche { Niche {
offset: Size { offset: Size {
raw: 0, raw: 0,
}, },
scalar: Scalar { scalar: Scalar {
value: Int( value: Int(
I32, I32,
false, false,
), ),
valid_range: 0..=0, valid_range: 0..=0,
}, },
}, },
), ),
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 2, pow2: 2,
}, },
pref: $PREF_ALIGN, pref: $PREF_ALIGN,
}, },
size: Size { size: Size {
raw: 12, raw: 12,
}, },
} }
--> $DIR/debug.rs:6:1 --> $DIR/debug.rs:6:1
| |
LL | enum E { Foo, Bar(!, i32, i32) } LL | enum E { Foo, Bar(!, i32, i32) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: layout_of(S) = Layout { error: layout_of(S) = Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [ offsets: [
Size { Size {
raw: 0, raw: 0,
}, },
Size { Size {
raw: 0, raw: 0,
}, },
Size { Size {
raw: 4, raw: 4,
}, },
], ],
memory_index: [ memory_index: [
1, 1,
0, 0,
2, 2,
], ],
}, },
variants: Single { variants: Single {
index: 0, index: 0,
}, },
abi: ScalarPair( abi: ScalarPair(
Scalar { Scalar {
value: Int( value: Int(
I32, I32,
true, true,
), ),
valid_range: 0..=4294967295, valid_range: 0..=4294967295,
}, },
Scalar { Scalar {
value: Int( value: Int(
I32, I32,
true, true,
), ),
valid_range: 0..=4294967295, valid_range: 0..=4294967295,
}, },
), ),
largest_niche: None, largest_niche: None,
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 2, pow2: 2,
}, },
pref: $PREF_ALIGN, pref: $PREF_ALIGN,
}, },
size: Size { size: Size {
raw: 8, raw: 8,
}, },
} }
--> $DIR/debug.rs:9:1 --> $DIR/debug.rs:9:1
| |
LL | struct S { f1: i32, f2: (), f3: i32 } LL | struct S { f1: i32, f2: (), f3: i32 }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: layout_of(U) = Layout { error: layout_of(U) = Layout {
fields: Union( fields: Union(
2, 2,
), ),
variants: Single { variants: Single {
index: 0, index: 0,
}, },
abi: Aggregate { abi: Aggregate {
sized: true, sized: true,
}, },
largest_niche: None, largest_niche: None,
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 2, pow2: 2,
}, },
pref: $PREF_ALIGN, pref: $PREF_ALIGN,
}, },
size: Size { size: Size {
raw: 8, raw: 8,
}, },
} }
--> $DIR/debug.rs:12:1 --> $DIR/debug.rs:12:1
| |
LL | union U { f1: (i32, i32), f3: i32 } LL | union U { f1: (i32, i32), f3: i32 }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: layout_of(std::result::Result<i32, i32>) = Layout { error: layout_of(std::result::Result<i32, i32>) = Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [ offsets: [
Size { Size {
raw: 0, raw: 0,
}, },
], ],
memory_index: [ memory_index: [
0, 0,
], ],
}, },
variants: Multiple { variants: Multiple {
tag: Scalar { tag: Scalar {
value: Int( value: Int(
I32, I32,
false, false,
), ),
valid_range: 0..=1, valid_range: 0..=1,
}, },
tag_encoding: Direct, tag_encoding: Direct,
tag_field: 0, tag_field: 0,
variants: [ variants: [
Layout { Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [ offsets: [
Size { Size {
raw: 4, raw: 4,
}, },
], ],
memory_index: [ memory_index: [
0, 0,
], ],
}, },
variants: Single { variants: Single {
index: 0, index: 0,
}, },
abi: Aggregate { abi: Aggregate {
sized: true, sized: true,
}, },
largest_niche: None, largest_niche: None,
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 2, pow2: 2,
}, },
pref: $PREF_ALIGN, pref: $PREF_ALIGN,
}, },
size: Size { size: Size {
raw: 8, raw: 8,
}, },
}, },
Layout { Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [ offsets: [
Size { Size {
raw: 4, raw: 4,
}, },
], ],
memory_index: [ memory_index: [
0, 0,
], ],
}, },
variants: Single { variants: Single {
index: 1, index: 1,
}, },
abi: Aggregate { abi: Aggregate {
sized: true, sized: true,
}, },
largest_niche: None, largest_niche: None,
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 2, pow2: 2,
}, },
pref: $PREF_ALIGN, pref: $PREF_ALIGN,
}, },
size: Size { size: Size {
raw: 8, raw: 8,
}, },
}, },
], ],
}, },
abi: ScalarPair( abi: ScalarPair(
Scalar { Scalar {
value: Int( value: Int(
I32, I32,
false, false,
), ),
valid_range: 0..=1, valid_range: 0..=1,
}, },
Scalar { Scalar {
value: Int( value: Int(
I32, I32,
true, true,
), ),
valid_range: 0..=4294967295, valid_range: 0..=4294967295,
}, },
), ),
largest_niche: Some( largest_niche: Some(
Niche { Niche {
offset: Size { offset: Size {
raw: 0, raw: 0,
}, },
scalar: Scalar { scalar: Scalar {
value: Int( value: Int(
I32, I32,
false, false,
), ),
valid_range: 0..=1, valid_range: 0..=1,
}, },
}, },
), ),
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 2, pow2: 2,
}, },
pref: $PREF_ALIGN, pref: $PREF_ALIGN,
}, },
size: Size { size: Size {
raw: 8, raw: 8,
}, },
} }
--> $DIR/debug.rs:15:1 --> $DIR/debug.rs:15:1
| |
LL | type Test = Result<i32, i32>; LL | type Test = Result<i32, i32>;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: layout_of(i32) = Layout { error: layout_of(i32) = Layout {
fields: Primitive, fields: Primitive,
variants: Single { variants: Single {
index: 0, index: 0,
}, },
abi: Scalar( abi: Scalar(
Scalar { Scalar {
value: Int( value: Int(
I32, I32,
true, true,
), ),
valid_range: 0..=4294967295, valid_range: 0..=4294967295,
}, },
), ),
largest_niche: None, largest_niche: None,
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 2, pow2: 2,
}, },
pref: $PREF_ALIGN, pref: $PREF_ALIGN,
}, },
size: Size { size: Size {
raw: 4, raw: 4,
}, },
} }
--> $DIR/debug.rs:18:1 --> $DIR/debug.rs:18:1
| |
LL | type T = impl std::fmt::Debug; LL | type T = impl std::fmt::Debug;

820
src/test/ui/layout/hexagon-enum.stderr
View file

@ -1,438 +1,438 @@
error: layout_of(A) = Layout { error: layout_of(A) = Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [ offsets: [
Size { Size {
raw: 0, raw: 0,
}, },
], ],
memory_index: [ memory_index: [
0, 0,
], ],
}, },
variants: Multiple { variants: Multiple {
tag: Scalar { tag: Scalar {
value: Int( value: Int(
I8, I8,
false, false,
), ),
valid_range: 0..=0, valid_range: 0..=0,
}, },
tag_encoding: Direct, tag_encoding: Direct,
tag_field: 0, tag_field: 0,
variants: [ variants: [
Layout { Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [], offsets: [],
memory_index: [], memory_index: [],
}, },
variants: Single { variants: Single {
index: 0, index: 0,
}, },
abi: Aggregate { abi: Aggregate {
sized: true, sized: true,
}, },
largest_niche: None, largest_niche: None,
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 0, pow2: 0,
}, },
pref: Align { pref: Align {
pow2: 0, pow2: 0,
}, },
}, },
size: Size { size: Size {
raw: 1, raw: 1,
}, },
}, },
], ],
}, },
abi: Scalar( abi: Scalar(
Scalar { Scalar {
value: Int( value: Int(
I8, I8,
false, false,
), ),
valid_range: 0..=0, valid_range: 0..=0,
}, },
), ),
largest_niche: Some( largest_niche: Some(
Niche { Niche {
offset: Size { offset: Size {
raw: 0, raw: 0,
}, },
scalar: Scalar { scalar: Scalar {
value: Int( value: Int(
I8, I8,
false, false,
), ),
valid_range: 0..=0, valid_range: 0..=0,
}, },
}, },
), ),
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 0, pow2: 0,
}, },
pref: Align { pref: Align {
pow2: 0, pow2: 0,
}, },
}, },
size: Size { size: Size {
raw: 1, raw: 1,
}, },
} }
--> $DIR/hexagon-enum.rs:16:1 --> $DIR/hexagon-enum.rs:16:1
| |
LL | enum A { Apple } LL | enum A { Apple }
| ^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^
error: layout_of(B) = Layout { error: layout_of(B) = Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [ offsets: [
Size { Size {
raw: 0, raw: 0,
}, },
], ],
memory_index: [ memory_index: [
0, 0,
], ],
}, },
variants: Multiple { variants: Multiple {
tag: Scalar { tag: Scalar {
value: Int( value: Int(
I8, I8,
false, false,
), ),
valid_range: 255..=255, valid_range: 255..=255,
}, },
tag_encoding: Direct, tag_encoding: Direct,
tag_field: 0, tag_field: 0,
variants: [ variants: [
Layout { Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [], offsets: [],
memory_index: [], memory_index: [],
}, },
variants: Single { variants: Single {
index: 0, index: 0,
}, },
abi: Aggregate { abi: Aggregate {
sized: true, sized: true,
}, },
largest_niche: None, largest_niche: None,
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 0, pow2: 0,
}, },
pref: Align { pref: Align {
pow2: 0, pow2: 0,
}, },
}, },
size: Size { size: Size {
raw: 1, raw: 1,
}, },
}, },
], ],
}, },
abi: Scalar( abi: Scalar(
Scalar { Scalar {
value: Int( value: Int(
I8, I8,
false, false,
), ),
valid_range: 255..=255, valid_range: 255..=255,
}, },
), ),
largest_niche: Some( largest_niche: Some(
Niche { Niche {
offset: Size { offset: Size {
raw: 0, raw: 0,
}, },
scalar: Scalar { scalar: Scalar {
value: Int( value: Int(
I8, I8,
false, false,
), ),
valid_range: 255..=255, valid_range: 255..=255,
}, },
}, },
), ),
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 0, pow2: 0,
}, },
pref: Align { pref: Align {
pow2: 0, pow2: 0,
}, },
}, },
size: Size { size: Size {
raw: 1, raw: 1,
}, },
} }
--> $DIR/hexagon-enum.rs:20:1 --> $DIR/hexagon-enum.rs:20:1
| |
LL | enum B { Banana = 255, } LL | enum B { Banana = 255, }
| ^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^
error: layout_of(C) = Layout { error: layout_of(C) = Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [ offsets: [
Size { Size {
raw: 0, raw: 0,
}, },
], ],
memory_index: [ memory_index: [
0, 0,
], ],
}, },
variants: Multiple { variants: Multiple {
tag: Scalar { tag: Scalar {
value: Int( value: Int(
I16, I16,
false, false,
), ),
valid_range: 256..=256, valid_range: 256..=256,
}, },
tag_encoding: Direct, tag_encoding: Direct,
tag_field: 0, tag_field: 0,
variants: [ variants: [
Layout { Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [], offsets: [],
memory_index: [], memory_index: [],
}, },
variants: Single { variants: Single {
index: 0, index: 0,
}, },
abi: Aggregate { abi: Aggregate {
sized: true, sized: true,
}, },
largest_niche: None, largest_niche: None,
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 1, pow2: 1,
}, },
pref: Align { pref: Align {
pow2: 1, pow2: 1,
}, },
}, },
size: Size { size: Size {
raw: 2, raw: 2,
}, },
}, },
], ],
}, },
abi: Scalar( abi: Scalar(
Scalar { Scalar {
value: Int( value: Int(
I16, I16,
false, false,
), ),
valid_range: 256..=256, valid_range: 256..=256,
}, },
), ),
largest_niche: Some( largest_niche: Some(
Niche { Niche {
offset: Size { offset: Size {
raw: 0, raw: 0,
}, },
scalar: Scalar { scalar: Scalar {
value: Int( value: Int(
I16, I16,
false, false,
), ),
valid_range: 256..=256, valid_range: 256..=256,
}, },
}, },
), ),
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 1, pow2: 1,
}, },
pref: Align { pref: Align {
pow2: 1, pow2: 1,
}, },
}, },
size: Size { size: Size {
raw: 2, raw: 2,
}, },
} }
--> $DIR/hexagon-enum.rs:24:1 --> $DIR/hexagon-enum.rs:24:1
| |
LL | enum C { Chaenomeles = 256, } LL | enum C { Chaenomeles = 256, }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: layout_of(P) = Layout { error: layout_of(P) = Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [ offsets: [
Size { Size {
raw: 0, raw: 0,
}, },
], ],
memory_index: [ memory_index: [
0, 0,
], ],
}, },
variants: Multiple { variants: Multiple {
tag: Scalar { tag: Scalar {
value: Int( value: Int(
I32, I32,
false, false,
), ),
valid_range: 268435456..=268435456, valid_range: 268435456..=268435456,
}, },
tag_encoding: Direct, tag_encoding: Direct,
tag_field: 0, tag_field: 0,
variants: [ variants: [
Layout { Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [], offsets: [],
memory_index: [], memory_index: [],
}, },
variants: Single { variants: Single {
index: 0, index: 0,
}, },
abi: Aggregate { abi: Aggregate {
sized: true, sized: true,
}, },
largest_niche: None, largest_niche: None,
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 2, pow2: 2,
}, },
pref: Align { pref: Align {
pow2: 2, pow2: 2,
}, },
}, },
size: Size { size: Size {
raw: 4, raw: 4,
}, },
}, },
], ],
}, },
abi: Scalar( abi: Scalar(
Scalar { Scalar {
value: Int( value: Int(
I32, I32,
false, false,
), ),
valid_range: 268435456..=268435456, valid_range: 268435456..=268435456,
}, },
), ),
largest_niche: Some( largest_niche: Some(
Niche { Niche {
offset: Size { offset: Size {
raw: 0, raw: 0,
}, },
scalar: Scalar { scalar: Scalar {
value: Int( value: Int(
I32, I32,
false, false,
), ),
valid_range: 268435456..=268435456, valid_range: 268435456..=268435456,
}, },
}, },
), ),
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 2, pow2: 2,
}, },
pref: Align { pref: Align {
pow2: 2, pow2: 2,
}, },
}, },
size: Size { size: Size {
raw: 4, raw: 4,
}, },
} }
--> $DIR/hexagon-enum.rs:28:1 --> $DIR/hexagon-enum.rs:28:1
| |
LL | enum P { Peach = 0x1000_0000isize, } LL | enum P { Peach = 0x1000_0000isize, }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: layout_of(T) = Layout { error: layout_of(T) = Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [ offsets: [
Size { Size {
raw: 0, raw: 0,
}, },
], ],
memory_index: [ memory_index: [
0, 0,
], ],
}, },
variants: Multiple { variants: Multiple {
tag: Scalar { tag: Scalar {
value: Int( value: Int(
I32, I32,
true, true,
), ),
valid_range: 2164260864..=2164260864, valid_range: 2164260864..=2164260864,
}, },
tag_encoding: Direct, tag_encoding: Direct,
tag_field: 0, tag_field: 0,
variants: [ variants: [
Layout { Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [], offsets: [],
memory_index: [], memory_index: [],
}, },
variants: Single { variants: Single {
index: 0, index: 0,
}, },
abi: Aggregate { abi: Aggregate {
sized: true, sized: true,
}, },
largest_niche: None, largest_niche: None,
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 2, pow2: 2,
}, },
pref: Align { pref: Align {
pow2: 2, pow2: 2,
}, },
}, },
size: Size { size: Size {
raw: 4, raw: 4,
}, },
}, },
], ],
}, },
abi: Scalar( abi: Scalar(
Scalar { Scalar {
value: Int( value: Int(
I32, I32,
true, true,
), ),
valid_range: 2164260864..=2164260864, valid_range: 2164260864..=2164260864,
}, },
), ),
largest_niche: Some( largest_niche: Some(
Niche { Niche {
offset: Size { offset: Size {
raw: 0, raw: 0,
}, },
scalar: Scalar { scalar: Scalar {
value: Int( value: Int(
I32, I32,
true, true,
), ),
valid_range: 2164260864..=2164260864, valid_range: 2164260864..=2164260864,
}, },
}, },
), ),
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 2, pow2: 2,
}, },
pref: Align { pref: Align {
pow2: 2, pow2: 2,
}, },
}, },
size: Size { size: Size {
raw: 4, raw: 4,
}, },
} }
--> $DIR/hexagon-enum.rs:34:1 --> $DIR/hexagon-enum.rs:34:1
| |
LL | enum T { Tangerine = TANGERINE as isize } LL | enum T { Tangerine = TANGERINE as isize }

820
src/test/ui/layout/thumb-enum.stderr
View file

@ -1,438 +1,438 @@
error: layout_of(A) = Layout { error: layout_of(A) = Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [ offsets: [
Size { Size {
raw: 0, raw: 0,
}, },
], ],
memory_index: [ memory_index: [
0, 0,
], ],
}, },
variants: Multiple { variants: Multiple {
tag: Scalar { tag: Scalar {
value: Int( value: Int(
I8, I8,
false, false,
), ),
valid_range: 0..=0, valid_range: 0..=0,
}, },
tag_encoding: Direct, tag_encoding: Direct,
tag_field: 0, tag_field: 0,
variants: [ variants: [
Layout { Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [], offsets: [],
memory_index: [], memory_index: [],
}, },
variants: Single { variants: Single {
index: 0, index: 0,
}, },
abi: Aggregate { abi: Aggregate {
sized: true, sized: true,
}, },
largest_niche: None, largest_niche: None,
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 0, pow2: 0,
}, },
pref: Align { pref: Align {
pow2: 2, pow2: 2,
}, },
}, },
size: Size { size: Size {
raw: 1, raw: 1,
}, },
}, },
], ],
}, },
abi: Scalar( abi: Scalar(
Scalar { Scalar {
value: Int( value: Int(
I8, I8,
false, false,
), ),
valid_range: 0..=0, valid_range: 0..=0,
}, },
), ),
largest_niche: Some( largest_niche: Some(
Niche { Niche {
offset: Size { offset: Size {
raw: 0, raw: 0,
}, },
scalar: Scalar { scalar: Scalar {
value: Int( value: Int(
I8, I8,
false, false,
), ),
valid_range: 0..=0, valid_range: 0..=0,
}, },
}, },
), ),
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 0, pow2: 0,
}, },
pref: Align { pref: Align {
pow2: 2, pow2: 2,
}, },
}, },
size: Size { size: Size {
raw: 1, raw: 1,
}, },
} }
--> $DIR/thumb-enum.rs:16:1 --> $DIR/thumb-enum.rs:16:1
| |
LL | enum A { Apple } LL | enum A { Apple }
| ^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^
error: layout_of(B) = Layout { error: layout_of(B) = Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [ offsets: [
Size { Size {
raw: 0, raw: 0,
}, },
], ],
memory_index: [ memory_index: [
0, 0,
], ],
}, },
variants: Multiple { variants: Multiple {
tag: Scalar { tag: Scalar {
value: Int( value: Int(
I8, I8,
false, false,
), ),
valid_range: 255..=255, valid_range: 255..=255,
}, },
tag_encoding: Direct, tag_encoding: Direct,
tag_field: 0, tag_field: 0,
variants: [ variants: [
Layout { Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [], offsets: [],
memory_index: [], memory_index: [],
}, },
variants: Single { variants: Single {
index: 0, index: 0,
}, },
abi: Aggregate { abi: Aggregate {
sized: true, sized: true,
}, },
largest_niche: None, largest_niche: None,
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 0, pow2: 0,
}, },
pref: Align { pref: Align {
pow2: 2, pow2: 2,
}, },
}, },
size: Size { size: Size {
raw: 1, raw: 1,
}, },
}, },
], ],
}, },
abi: Scalar( abi: Scalar(
Scalar { Scalar {
value: Int( value: Int(
I8, I8,
false, false,
), ),
valid_range: 255..=255, valid_range: 255..=255,
}, },
), ),
largest_niche: Some( largest_niche: Some(
Niche { Niche {
offset: Size { offset: Size {
raw: 0, raw: 0,
}, },
scalar: Scalar { scalar: Scalar {
value: Int( value: Int(
I8, I8,
false, false,
), ),
valid_range: 255..=255, valid_range: 255..=255,
}, },
}, },
), ),
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 0, pow2: 0,
}, },
pref: Align { pref: Align {
pow2: 2, pow2: 2,
}, },
}, },
size: Size { size: Size {
raw: 1, raw: 1,
}, },
} }
--> $DIR/thumb-enum.rs:20:1 --> $DIR/thumb-enum.rs:20:1
| |
LL | enum B { Banana = 255, } LL | enum B { Banana = 255, }
| ^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^
error: layout_of(C) = Layout { error: layout_of(C) = Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [ offsets: [
Size { Size {
raw: 0, raw: 0,
}, },
], ],
memory_index: [ memory_index: [
0, 0,
], ],
}, },
variants: Multiple { variants: Multiple {
tag: Scalar { tag: Scalar {
value: Int( value: Int(
I16, I16,
false, false,
), ),
valid_range: 256..=256, valid_range: 256..=256,
}, },
tag_encoding: Direct, tag_encoding: Direct,
tag_field: 0, tag_field: 0,
variants: [ variants: [
Layout { Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [], offsets: [],
memory_index: [], memory_index: [],
}, },
variants: Single { variants: Single {
index: 0, index: 0,
}, },
abi: Aggregate { abi: Aggregate {
sized: true, sized: true,
}, },
largest_niche: None, largest_niche: None,
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 1, pow2: 1,
}, },
pref: Align { pref: Align {
pow2: 2, pow2: 2,
}, },
}, },
size: Size { size: Size {
raw: 2, raw: 2,
}, },
}, },
], ],
}, },
abi: Scalar( abi: Scalar(
Scalar { Scalar {
value: Int( value: Int(
I16, I16,
false, false,
), ),
valid_range: 256..=256, valid_range: 256..=256,
}, },
), ),
largest_niche: Some( largest_niche: Some(
Niche { Niche {
offset: Size { offset: Size {
raw: 0, raw: 0,
}, },
scalar: Scalar { scalar: Scalar {
value: Int( value: Int(
I16, I16,
false, false,
), ),
valid_range: 256..=256, valid_range: 256..=256,
}, },
}, },
), ),
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 1, pow2: 1,
}, },
pref: Align { pref: Align {
pow2: 2, pow2: 2,
}, },
}, },
size: Size { size: Size {
raw: 2, raw: 2,
}, },
} }
--> $DIR/thumb-enum.rs:24:1 --> $DIR/thumb-enum.rs:24:1
| |
LL | enum C { Chaenomeles = 256, } LL | enum C { Chaenomeles = 256, }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: layout_of(P) = Layout { error: layout_of(P) = Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [ offsets: [
Size { Size {
raw: 0, raw: 0,
}, },
], ],
memory_index: [ memory_index: [
0, 0,
], ],
}, },
variants: Multiple { variants: Multiple {
tag: Scalar { tag: Scalar {
value: Int( value: Int(
I32, I32,
false, false,
), ),
valid_range: 268435456..=268435456, valid_range: 268435456..=268435456,
}, },
tag_encoding: Direct, tag_encoding: Direct,
tag_field: 0, tag_field: 0,
variants: [ variants: [
Layout { Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [], offsets: [],
memory_index: [], memory_index: [],
}, },
variants: Single { variants: Single {
index: 0, index: 0,
}, },
abi: Aggregate { abi: Aggregate {
sized: true, sized: true,
}, },
largest_niche: None, largest_niche: None,
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 2, pow2: 2,
}, },
pref: Align { pref: Align {
pow2: 2, pow2: 2,
}, },
}, },
size: Size { size: Size {
raw: 4, raw: 4,
}, },
}, },
], ],
}, },
abi: Scalar( abi: Scalar(
Scalar { Scalar {
value: Int( value: Int(
I32, I32,
false, false,
), ),
valid_range: 268435456..=268435456, valid_range: 268435456..=268435456,
}, },
), ),
largest_niche: Some( largest_niche: Some(
Niche { Niche {
offset: Size { offset: Size {
raw: 0, raw: 0,
}, },
scalar: Scalar { scalar: Scalar {
value: Int( value: Int(
I32, I32,
false, false,
), ),
valid_range: 268435456..=268435456, valid_range: 268435456..=268435456,
}, },
}, },
), ),
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 2, pow2: 2,
}, },
pref: Align { pref: Align {
pow2: 2, pow2: 2,
}, },
}, },
size: Size { size: Size {
raw: 4, raw: 4,
}, },
} }
--> $DIR/thumb-enum.rs:28:1 --> $DIR/thumb-enum.rs:28:1
| |
LL | enum P { Peach = 0x1000_0000isize, } LL | enum P { Peach = 0x1000_0000isize, }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: layout_of(T) = Layout { error: layout_of(T) = Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [ offsets: [
Size { Size {
raw: 0, raw: 0,
}, },
], ],
memory_index: [ memory_index: [
0, 0,
], ],
}, },
variants: Multiple { variants: Multiple {
tag: Scalar { tag: Scalar {
value: Int( value: Int(
I32, I32,
true, true,
), ),
valid_range: 2164260864..=2164260864, valid_range: 2164260864..=2164260864,
}, },
tag_encoding: Direct, tag_encoding: Direct,
tag_field: 0, tag_field: 0,
variants: [ variants: [
Layout { Layout {
fields: Arbitrary { fields: Arbitrary {
offsets: [], offsets: [],
memory_index: [], memory_index: [],
}, },
variants: Single { variants: Single {
index: 0, index: 0,
}, },
abi: Aggregate { abi: Aggregate {
sized: true, sized: true,
}, },
largest_niche: None, largest_niche: None,
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 2, pow2: 2,
}, },
pref: Align { pref: Align {
pow2: 2, pow2: 2,
}, },
}, },
size: Size { size: Size {
raw: 4, raw: 4,
}, },
}, },
], ],
}, },
abi: Scalar( abi: Scalar(
Scalar { Scalar {
value: Int( value: Int(
I32, I32,
true, true,
), ),
valid_range: 2164260864..=2164260864, valid_range: 2164260864..=2164260864,
}, },
), ),
largest_niche: Some( largest_niche: Some(
Niche { Niche {
offset: Size { offset: Size {
raw: 0, raw: 0,
}, },
scalar: Scalar { scalar: Scalar {
value: Int( value: Int(
I32, I32,
true, true,
), ),
valid_range: 2164260864..=2164260864, valid_range: 2164260864..=2164260864,
}, },
}, },
), ),
align: AbiAndPrefAlign { align: AbiAndPrefAlign {
abi: Align { abi: Align {
pow2: 2, pow2: 2,
}, },
pref: Align { pref: Align {
pow2: 2, pow2: 2,
}, },
}, },
size: Size { size: Size {
raw: 4, raw: 4,
}, },
} }
--> $DIR/thumb-enum.rs:34:1 --> $DIR/thumb-enum.rs:34:1
| |
LL | enum T { Tangerine = TANGERINE as isize } LL | enum T { Tangerine = TANGERINE as isize }

30
src/test/ui/traits/vtable/vtable-diamond.stderr
View file

@ -1,13 +1,13 @@
error: vtable entries for `<S as D>`: [ error: vtable entries for `<S as D>`: [
MetadataDropInPlace, MetadataDropInPlace,
MetadataSize, MetadataSize,
MetadataAlign, MetadataAlign,
Method(<S as A>::foo_a), Method(<S as A>::foo_a),
Method(<S as B>::foo_b), Method(<S as B>::foo_b),
Method(<S as C>::foo_c), Method(<S as C>::foo_c),
TraitVPtr(<S as C>), TraitVPtr(<S as C>),
Method(<S as D>::foo_d), Method(<S as D>::foo_d),
] ]
--> $DIR/vtable-diamond.rs:21:1 --> $DIR/vtable-diamond.rs:21:1
| |
LL | / trait D: B + C { LL | / trait D: B + C {
@ -17,12 +17,12 @@ LL | | }
| |_^ | |_^
error: vtable entries for `<S as C>`: [ error: vtable entries for `<S as C>`: [
MetadataDropInPlace, MetadataDropInPlace,
MetadataSize, MetadataSize,
MetadataAlign, MetadataAlign,
Method(<S as A>::foo_a), Method(<S as A>::foo_a),
Method(<S as C>::foo_c), Method(<S as C>::foo_c),
] ]
--> $DIR/vtable-diamond.rs:15:1 --> $DIR/vtable-diamond.rs:15:1
| |
LL | / trait C: A { LL | / trait C: A {

208
src/test/ui/traits/vtable/vtable-multi-level.stderr
View file

@ -1,34 +1,34 @@
error: vtable entries for `<S as O>`: [ error: vtable entries for `<S as O>`: [
MetadataDropInPlace, MetadataDropInPlace,
MetadataSize, MetadataSize,
MetadataAlign, MetadataAlign,
Method(<S as A>::foo_a), Method(<S as A>::foo_a),
Method(<S as B>::foo_b), Method(<S as B>::foo_b),
TraitVPtr(<S as B>), TraitVPtr(<S as B>),
Method(<S as C>::foo_c), Method(<S as C>::foo_c),
Method(<S as D>::foo_d), Method(<S as D>::foo_d),
TraitVPtr(<S as D>), TraitVPtr(<S as D>),
Method(<S as E>::foo_e), Method(<S as E>::foo_e),
TraitVPtr(<S as E>), TraitVPtr(<S as E>),
Method(<S as F>::foo_f), Method(<S as F>::foo_f),
TraitVPtr(<S as F>), TraitVPtr(<S as F>),
Method(<S as G>::foo_g), Method(<S as G>::foo_g),
Method(<S as H>::foo_h), Method(<S as H>::foo_h),
TraitVPtr(<S as H>), TraitVPtr(<S as H>),
Method(<S as I>::foo_i), Method(<S as I>::foo_i),
TraitVPtr(<S as I>), TraitVPtr(<S as I>),
Method(<S as J>::foo_j), Method(<S as J>::foo_j),
TraitVPtr(<S as J>), TraitVPtr(<S as J>),
Method(<S as K>::foo_k), Method(<S as K>::foo_k),
TraitVPtr(<S as K>), TraitVPtr(<S as K>),
Method(<S as L>::foo_l), Method(<S as L>::foo_l),
TraitVPtr(<S as L>), TraitVPtr(<S as L>),
Method(<S as M>::foo_m), Method(<S as M>::foo_m),
TraitVPtr(<S as M>), TraitVPtr(<S as M>),
Method(<S as N>::foo_n), Method(<S as N>::foo_n),
TraitVPtr(<S as N>), TraitVPtr(<S as N>),
Method(<S as O>::foo_o), Method(<S as O>::foo_o),
] ]
--> $DIR/vtable-multi-level.rs:95:1 --> $DIR/vtable-multi-level.rs:95:1
| |
LL | / trait O: G + N { LL | / trait O: G + N {
@ -38,11 +38,11 @@ LL | | }
| |_^ | |_^
error: vtable entries for `<S as B>`: [ error: vtable entries for `<S as B>`: [
MetadataDropInPlace, MetadataDropInPlace,
MetadataSize, MetadataSize,
MetadataAlign, MetadataAlign,
Method(<S as B>::foo_b), Method(<S as B>::foo_b),
] ]
--> $DIR/vtable-multi-level.rs:19:1 --> $DIR/vtable-multi-level.rs:19:1
| |
LL | / trait B { LL | / trait B {
@ -52,11 +52,11 @@ LL | | }
| |_^ | |_^
error: vtable entries for `<S as D>`: [ error: vtable entries for `<S as D>`: [
MetadataDropInPlace, MetadataDropInPlace,
MetadataSize, MetadataSize,
MetadataAlign, MetadataAlign,
Method(<S as D>::foo_d), Method(<S as D>::foo_d),
] ]
--> $DIR/vtable-multi-level.rs:30:1 --> $DIR/vtable-multi-level.rs:30:1
| |
LL | / trait D { LL | / trait D {
@ -66,11 +66,11 @@ LL | | }
| |_^ | |_^
error: vtable entries for `<S as E>`: [ error: vtable entries for `<S as E>`: [
MetadataDropInPlace, MetadataDropInPlace,
MetadataSize, MetadataSize,
MetadataAlign, MetadataAlign,
Method(<S as E>::foo_e), Method(<S as E>::foo_e),
] ]
--> $DIR/vtable-multi-level.rs:36:1 --> $DIR/vtable-multi-level.rs:36:1
| |
LL | / trait E { LL | / trait E {
@ -80,14 +80,14 @@ LL | | }
| |_^ | |_^
error: vtable entries for `<S as F>`: [ error: vtable entries for `<S as F>`: [
MetadataDropInPlace, MetadataDropInPlace,
MetadataSize, MetadataSize,
MetadataAlign, MetadataAlign,
Method(<S as D>::foo_d), Method(<S as D>::foo_d),
Method(<S as E>::foo_e), Method(<S as E>::foo_e),
TraitVPtr(<S as E>), TraitVPtr(<S as E>),
Method(<S as F>::foo_f), Method(<S as F>::foo_f),
] ]
--> $DIR/vtable-multi-level.rs:42:1 --> $DIR/vtable-multi-level.rs:42:1
| |
LL | / trait F: D + E { LL | / trait F: D + E {
@ -97,11 +97,11 @@ LL | | }
| |_^ | |_^
error: vtable entries for `<S as H>`: [ error: vtable entries for `<S as H>`: [
MetadataDropInPlace, MetadataDropInPlace,
MetadataSize, MetadataSize,
MetadataAlign, MetadataAlign,
Method(<S as H>::foo_h), Method(<S as H>::foo_h),
] ]
--> $DIR/vtable-multi-level.rs:53:1 --> $DIR/vtable-multi-level.rs:53:1
| |
LL | / trait H { LL | / trait H {
@ -111,11 +111,11 @@ LL | | }
| |_^ | |_^
error: vtable entries for `<S as I>`: [ error: vtable entries for `<S as I>`: [
MetadataDropInPlace, MetadataDropInPlace,
MetadataSize, MetadataSize,
MetadataAlign, MetadataAlign,
Method(<S as I>::foo_i), Method(<S as I>::foo_i),
] ]
--> $DIR/vtable-multi-level.rs:59:1 --> $DIR/vtable-multi-level.rs:59:1
| |
LL | / trait I { LL | / trait I {
@ -125,14 +125,14 @@ LL | | }
| |_^ | |_^
error: vtable entries for `<S as J>`: [ error: vtable entries for `<S as J>`: [
MetadataDropInPlace, MetadataDropInPlace,
MetadataSize, MetadataSize,
MetadataAlign, MetadataAlign,
Method(<S as H>::foo_h), Method(<S as H>::foo_h),
Method(<S as I>::foo_i), Method(<S as I>::foo_i),
TraitVPtr(<S as I>), TraitVPtr(<S as I>),
Method(<S as J>::foo_j), Method(<S as J>::foo_j),
] ]
--> $DIR/vtable-multi-level.rs:65:1 --> $DIR/vtable-multi-level.rs:65:1
| |
LL | / trait J: H + I { LL | / trait J: H + I {
@ -142,11 +142,11 @@ LL | | }
| |_^ | |_^
error: vtable entries for `<S as K>`: [ error: vtable entries for `<S as K>`: [
MetadataDropInPlace, MetadataDropInPlace,
MetadataSize, MetadataSize,
MetadataAlign, MetadataAlign,
Method(<S as K>::foo_k), Method(<S as K>::foo_k),
] ]
--> $DIR/vtable-multi-level.rs:71:1 --> $DIR/vtable-multi-level.rs:71:1
| |
LL | / trait K { LL | / trait K {
@ -156,11 +156,11 @@ LL | | }
| |_^ | |_^
error: vtable entries for `<S as L>`: [ error: vtable entries for `<S as L>`: [
MetadataDropInPlace, MetadataDropInPlace,
MetadataSize, MetadataSize,
MetadataAlign, MetadataAlign,
Method(<S as L>::foo_l), Method(<S as L>::foo_l),
] ]
--> $DIR/vtable-multi-level.rs:77:1 --> $DIR/vtable-multi-level.rs:77:1
| |
LL | / trait L { LL | / trait L {
@ -170,14 +170,14 @@ LL | | }
| |_^ | |_^
error: vtable entries for `<S as M>`: [ error: vtable entries for `<S as M>`: [
MetadataDropInPlace, MetadataDropInPlace,
MetadataSize, MetadataSize,
MetadataAlign, MetadataAlign,
Method(<S as K>::foo_k), Method(<S as K>::foo_k),
Method(<S as L>::foo_l), Method(<S as L>::foo_l),
TraitVPtr(<S as L>), TraitVPtr(<S as L>),
Method(<S as M>::foo_m), Method(<S as M>::foo_m),
] ]
--> $DIR/vtable-multi-level.rs:83:1 --> $DIR/vtable-multi-level.rs:83:1
| |
LL | / trait M: K + L { LL | / trait M: K + L {
@ -187,21 +187,21 @@ LL | | }
| |_^ | |_^
error: vtable entries for `<S as N>`: [ error: vtable entries for `<S as N>`: [
MetadataDropInPlace, MetadataDropInPlace,
MetadataSize, MetadataSize,
MetadataAlign, MetadataAlign,
Method(<S as H>::foo_h), Method(<S as H>::foo_h),
Method(<S as I>::foo_i), Method(<S as I>::foo_i),
TraitVPtr(<S as I>), TraitVPtr(<S as I>),
Method(<S as J>::foo_j), Method(<S as J>::foo_j),
Method(<S as K>::foo_k), Method(<S as K>::foo_k),
TraitVPtr(<S as K>), TraitVPtr(<S as K>),
Method(<S as L>::foo_l), Method(<S as L>::foo_l),
TraitVPtr(<S as L>), TraitVPtr(<S as L>),
Method(<S as M>::foo_m), Method(<S as M>::foo_m),
TraitVPtr(<S as M>), TraitVPtr(<S as M>),
Method(<S as N>::foo_n), Method(<S as N>::foo_n),
] ]
--> $DIR/vtable-multi-level.rs:89:1 --> $DIR/vtable-multi-level.rs:89:1
| |
LL | / trait N: J + M { LL | / trait N: J + M {

26
src/test/ui/traits/vtable/vtable-multiple.stderr
View file

@ -1,12 +1,12 @@
error: vtable entries for `<S as C>`: [ error: vtable entries for `<S as C>`: [
MetadataDropInPlace, MetadataDropInPlace,
MetadataSize, MetadataSize,
MetadataAlign, MetadataAlign,
Method(<S as A>::foo_a), Method(<S as A>::foo_a),
Method(<S as B>::foo_b), Method(<S as B>::foo_b),
TraitVPtr(<S as B>), TraitVPtr(<S as B>),
Method(<S as C>::foo_c), Method(<S as C>::foo_c),
] ]
--> $DIR/vtable-multiple.rs:16:1 --> $DIR/vtable-multiple.rs:16:1
| |
LL | / trait C: A + B { LL | / trait C: A + B {
@ -16,11 +16,11 @@ LL | | }
| |_^ | |_^
error: vtable entries for `<S as B>`: [ error: vtable entries for `<S as B>`: [
MetadataDropInPlace, MetadataDropInPlace,
MetadataSize, MetadataSize,
MetadataAlign, MetadataAlign,
Method(<S as B>::foo_b), Method(<S as B>::foo_b),
] ]
--> $DIR/vtable-multiple.rs:10:1 --> $DIR/vtable-multiple.rs:10:1
| |
LL | / trait B { LL | / trait B {

16
src/test/ui/traits/vtable/vtable-non-object-safe.stderr
View file

@ -1,12 +1,12 @@
error: vtable entries for `<std::vec::IntoIter<u8> as A>`: [ error: vtable entries for `<std::vec::IntoIter<u8> as A>`: [
MetadataDropInPlace, MetadataDropInPlace,
MetadataSize, MetadataSize,
MetadataAlign, MetadataAlign,
Method(<std::vec::IntoIter<u8> as Iterator>::next), Method(<std::vec::IntoIter<u8> as Iterator>::next),
Method(<std::vec::IntoIter<u8> as Iterator>::size_hint), Method(<std::vec::IntoIter<u8> as Iterator>::size_hint),
Method(<std::vec::IntoIter<u8> as Iterator>::advance_by), Method(<std::vec::IntoIter<u8> as Iterator>::advance_by),
Method(<std::vec::IntoIter<u8> as Iterator>::nth), Method(<std::vec::IntoIter<u8> as Iterator>::nth),
] ]
--> $DIR/vtable-non-object-safe.rs:8:1 --> $DIR/vtable-non-object-safe.rs:8:1
| |
LL | trait A: Iterator {} LL | trait A: Iterator {}

16
src/test/ui/traits/vtable/vtable-vacant.stderr
View file

@ -1,12 +1,12 @@
error: vtable entries for `<S as B>`: [ error: vtable entries for `<S as B>`: [
MetadataDropInPlace, MetadataDropInPlace,
MetadataSize, MetadataSize,
MetadataAlign, MetadataAlign,
Method(<S as A>::foo_a1), Method(<S as A>::foo_a1),
Vacant, Vacant,
Method(<S as B>::foo_b1), Method(<S as B>::foo_b1),
Vacant, Vacant,
] ]
--> $DIR/vtable-vacant.rs:15:1 --> $DIR/vtable-vacant.rs:15:1
| |
LL | / trait B: A { LL | / trait B: A {