mirror of
https://github.com/rust-lang/rust.git
synced 2025-02-03 02:23:20 +00:00
64ea8eb1a9
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.
960 lines
34 KiB
Plaintext
960 lines
34 KiB
Plaintext
error: fn_abi_of(test) = FnAbi {
|
|
args: [
|
|
ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: u8,
|
|
layout: Layout {
|
|
size: Size(1 bytes),
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Scalar(
|
|
Initialized {
|
|
value: Int(
|
|
I8,
|
|
false,
|
|
),
|
|
valid_range: 0..=255,
|
|
},
|
|
),
|
|
fields: Primitive,
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Direct(
|
|
ArgAttributes {
|
|
regular: NoUndef,
|
|
arg_ext: None,
|
|
pointee_size: Size(0 bytes),
|
|
pointee_align: None,
|
|
},
|
|
),
|
|
},
|
|
],
|
|
ret: ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: bool,
|
|
layout: Layout {
|
|
size: Size(1 bytes),
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Scalar(
|
|
Initialized {
|
|
value: Int(
|
|
I8,
|
|
false,
|
|
),
|
|
valid_range: 0..=1,
|
|
},
|
|
),
|
|
fields: Primitive,
|
|
largest_niche: Some(
|
|
Niche {
|
|
offset: Size(0 bytes),
|
|
value: Int(
|
|
I8,
|
|
false,
|
|
),
|
|
valid_range: 0..=1,
|
|
},
|
|
),
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Direct(
|
|
ArgAttributes {
|
|
regular: NoUndef,
|
|
arg_ext: Zext,
|
|
pointee_size: Size(0 bytes),
|
|
pointee_align: None,
|
|
},
|
|
),
|
|
},
|
|
c_variadic: false,
|
|
fixed_count: 1,
|
|
conv: Rust,
|
|
can_unwind: $SOME_BOOL,
|
|
}
|
|
--> $DIR/debug.rs:16:1
|
|
|
|
|
LL | fn test(_x: u8) -> bool { true }
|
|
| ^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
error: fn_abi_of(TestFnPtr) = FnAbi {
|
|
args: [
|
|
ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: bool,
|
|
layout: Layout {
|
|
size: Size(1 bytes),
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Scalar(
|
|
Initialized {
|
|
value: Int(
|
|
I8,
|
|
false,
|
|
),
|
|
valid_range: 0..=1,
|
|
},
|
|
),
|
|
fields: Primitive,
|
|
largest_niche: Some(
|
|
Niche {
|
|
offset: Size(0 bytes),
|
|
value: Int(
|
|
I8,
|
|
false,
|
|
),
|
|
valid_range: 0..=1,
|
|
},
|
|
),
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Direct(
|
|
ArgAttributes {
|
|
regular: NoUndef,
|
|
arg_ext: Zext,
|
|
pointee_size: Size(0 bytes),
|
|
pointee_align: None,
|
|
},
|
|
),
|
|
},
|
|
],
|
|
ret: ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: u8,
|
|
layout: Layout {
|
|
size: Size(1 bytes),
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Scalar(
|
|
Initialized {
|
|
value: Int(
|
|
I8,
|
|
false,
|
|
),
|
|
valid_range: 0..=255,
|
|
},
|
|
),
|
|
fields: Primitive,
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Direct(
|
|
ArgAttributes {
|
|
regular: NoUndef,
|
|
arg_ext: None,
|
|
pointee_size: Size(0 bytes),
|
|
pointee_align: None,
|
|
},
|
|
),
|
|
},
|
|
c_variadic: false,
|
|
fixed_count: 1,
|
|
conv: Rust,
|
|
can_unwind: $SOME_BOOL,
|
|
}
|
|
--> $DIR/debug.rs:19:1
|
|
|
|
|
LL | type TestFnPtr = fn(bool) -> u8;
|
|
| ^^^^^^^^^^^^^^
|
|
|
|
error: fn_abi_of(test_generic) = FnAbi {
|
|
args: [
|
|
ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: *const T/#0,
|
|
layout: Layout {
|
|
size: $SOME_SIZE,
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Scalar(
|
|
Initialized {
|
|
value: Pointer(
|
|
AddressSpace(
|
|
0,
|
|
),
|
|
),
|
|
valid_range: $FULL,
|
|
},
|
|
),
|
|
fields: Primitive,
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Direct(
|
|
ArgAttributes {
|
|
regular: NoUndef,
|
|
arg_ext: None,
|
|
pointee_size: Size(0 bytes),
|
|
pointee_align: None,
|
|
},
|
|
),
|
|
},
|
|
],
|
|
ret: ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: (),
|
|
layout: Layout {
|
|
size: Size(0 bytes),
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Aggregate {
|
|
sized: true,
|
|
},
|
|
fields: Arbitrary {
|
|
offsets: [],
|
|
memory_index: [],
|
|
},
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Ignore,
|
|
},
|
|
c_variadic: false,
|
|
fixed_count: 1,
|
|
conv: Rust,
|
|
can_unwind: $SOME_BOOL,
|
|
}
|
|
--> $DIR/debug.rs:22:1
|
|
|
|
|
LL | fn test_generic<T>(_x: *const T) { }
|
|
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
error: `#[rustc_abi]` can only be applied to function items, type aliases, and associated functions
|
|
--> $DIR/debug.rs:25:1
|
|
|
|
|
LL | const C: () = ();
|
|
| ^^^^^^^^^^^
|
|
|
|
error: ABIs are not compatible
|
|
left ABI = FnAbi {
|
|
args: [
|
|
ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: u8,
|
|
layout: Layout {
|
|
size: Size(1 bytes),
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Scalar(
|
|
Initialized {
|
|
value: Int(
|
|
I8,
|
|
false,
|
|
),
|
|
valid_range: 0..=255,
|
|
},
|
|
),
|
|
fields: Primitive,
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Direct(
|
|
ArgAttributes {
|
|
regular: NoUndef,
|
|
arg_ext: None,
|
|
pointee_size: Size(0 bytes),
|
|
pointee_align: None,
|
|
},
|
|
),
|
|
},
|
|
],
|
|
ret: ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: (),
|
|
layout: Layout {
|
|
size: Size(0 bytes),
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Aggregate {
|
|
sized: true,
|
|
},
|
|
fields: Arbitrary {
|
|
offsets: [],
|
|
memory_index: [],
|
|
},
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Ignore,
|
|
},
|
|
c_variadic: false,
|
|
fixed_count: 1,
|
|
conv: Rust,
|
|
can_unwind: $SOME_BOOL,
|
|
}
|
|
right ABI = FnAbi {
|
|
args: [
|
|
ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: u32,
|
|
layout: Layout {
|
|
size: $SOME_SIZE,
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Scalar(
|
|
Initialized {
|
|
value: Int(
|
|
I32,
|
|
false,
|
|
),
|
|
valid_range: $FULL,
|
|
},
|
|
),
|
|
fields: Primitive,
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Direct(
|
|
ArgAttributes {
|
|
regular: NoUndef,
|
|
arg_ext: None,
|
|
pointee_size: Size(0 bytes),
|
|
pointee_align: None,
|
|
},
|
|
),
|
|
},
|
|
],
|
|
ret: ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: (),
|
|
layout: Layout {
|
|
size: Size(0 bytes),
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Aggregate {
|
|
sized: true,
|
|
},
|
|
fields: Arbitrary {
|
|
offsets: [],
|
|
memory_index: [],
|
|
},
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Ignore,
|
|
},
|
|
c_variadic: false,
|
|
fixed_count: 1,
|
|
conv: Rust,
|
|
can_unwind: $SOME_BOOL,
|
|
}
|
|
--> $DIR/debug.rs:41:1
|
|
|
|
|
LL | type TestAbiNe = (fn(u8), fn(u32));
|
|
| ^^^^^^^^^^^^^^
|
|
|
|
error: ABIs are not compatible
|
|
left ABI = FnAbi {
|
|
args: [
|
|
ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: [u8; Const { ty: usize, kind: Leaf(0x0...20) }],
|
|
layout: Layout {
|
|
size: Size(32 bytes),
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Aggregate {
|
|
sized: true,
|
|
},
|
|
fields: Array {
|
|
stride: Size(1 bytes),
|
|
count: 32,
|
|
},
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Indirect {
|
|
attrs: ArgAttributes {
|
|
regular: NoAlias | NoCapture | NonNull | NoUndef,
|
|
arg_ext: None,
|
|
pointee_size: Size(32 bytes),
|
|
pointee_align: Some(
|
|
Align(1 bytes),
|
|
),
|
|
},
|
|
extra_attrs: None,
|
|
on_stack: false,
|
|
},
|
|
},
|
|
],
|
|
ret: ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: (),
|
|
layout: Layout {
|
|
size: Size(0 bytes),
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Aggregate {
|
|
sized: true,
|
|
},
|
|
fields: Arbitrary {
|
|
offsets: [],
|
|
memory_index: [],
|
|
},
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Ignore,
|
|
},
|
|
c_variadic: false,
|
|
fixed_count: 1,
|
|
conv: Rust,
|
|
can_unwind: $SOME_BOOL,
|
|
}
|
|
right ABI = FnAbi {
|
|
args: [
|
|
ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: [u32; Const { ty: usize, kind: Leaf(0x0...20) }],
|
|
layout: Layout {
|
|
size: Size(128 bytes),
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Aggregate {
|
|
sized: true,
|
|
},
|
|
fields: Array {
|
|
stride: Size(4 bytes),
|
|
count: 32,
|
|
},
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Indirect {
|
|
attrs: ArgAttributes {
|
|
regular: NoAlias | NoCapture | NonNull | NoUndef,
|
|
arg_ext: None,
|
|
pointee_size: Size(128 bytes),
|
|
pointee_align: Some(
|
|
Align(4 bytes),
|
|
),
|
|
},
|
|
extra_attrs: None,
|
|
on_stack: false,
|
|
},
|
|
},
|
|
],
|
|
ret: ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: (),
|
|
layout: Layout {
|
|
size: Size(0 bytes),
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Aggregate {
|
|
sized: true,
|
|
},
|
|
fields: Arbitrary {
|
|
offsets: [],
|
|
memory_index: [],
|
|
},
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Ignore,
|
|
},
|
|
c_variadic: false,
|
|
fixed_count: 1,
|
|
conv: Rust,
|
|
can_unwind: $SOME_BOOL,
|
|
}
|
|
--> $DIR/debug.rs:44:1
|
|
|
|
|
LL | type TestAbiNeLarger = (fn([u8; 32]), fn([u32; 32]));
|
|
| ^^^^^^^^^^^^^^^^^^^^
|
|
|
|
error: ABIs are not compatible
|
|
left ABI = FnAbi {
|
|
args: [
|
|
ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: f32,
|
|
layout: Layout {
|
|
size: $SOME_SIZE,
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Scalar(
|
|
Initialized {
|
|
value: F32,
|
|
valid_range: $FULL,
|
|
},
|
|
),
|
|
fields: Primitive,
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Direct(
|
|
ArgAttributes {
|
|
regular: NoUndef,
|
|
arg_ext: None,
|
|
pointee_size: Size(0 bytes),
|
|
pointee_align: None,
|
|
},
|
|
),
|
|
},
|
|
],
|
|
ret: ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: (),
|
|
layout: Layout {
|
|
size: Size(0 bytes),
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Aggregate {
|
|
sized: true,
|
|
},
|
|
fields: Arbitrary {
|
|
offsets: [],
|
|
memory_index: [],
|
|
},
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Ignore,
|
|
},
|
|
c_variadic: false,
|
|
fixed_count: 1,
|
|
conv: Rust,
|
|
can_unwind: $SOME_BOOL,
|
|
}
|
|
right ABI = FnAbi {
|
|
args: [
|
|
ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: u32,
|
|
layout: Layout {
|
|
size: $SOME_SIZE,
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Scalar(
|
|
Initialized {
|
|
value: Int(
|
|
I32,
|
|
false,
|
|
),
|
|
valid_range: $FULL,
|
|
},
|
|
),
|
|
fields: Primitive,
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Direct(
|
|
ArgAttributes {
|
|
regular: NoUndef,
|
|
arg_ext: None,
|
|
pointee_size: Size(0 bytes),
|
|
pointee_align: None,
|
|
},
|
|
),
|
|
},
|
|
],
|
|
ret: ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: (),
|
|
layout: Layout {
|
|
size: Size(0 bytes),
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Aggregate {
|
|
sized: true,
|
|
},
|
|
fields: Arbitrary {
|
|
offsets: [],
|
|
memory_index: [],
|
|
},
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Ignore,
|
|
},
|
|
c_variadic: false,
|
|
fixed_count: 1,
|
|
conv: Rust,
|
|
can_unwind: $SOME_BOOL,
|
|
}
|
|
--> $DIR/debug.rs:47:1
|
|
|
|
|
LL | type TestAbiNeFloat = (fn(f32), fn(u32));
|
|
| ^^^^^^^^^^^^^^^^^^^
|
|
|
|
error: ABIs are not compatible
|
|
left ABI = FnAbi {
|
|
args: [
|
|
ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: i32,
|
|
layout: Layout {
|
|
size: $SOME_SIZE,
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Scalar(
|
|
Initialized {
|
|
value: Int(
|
|
I32,
|
|
true,
|
|
),
|
|
valid_range: $FULL,
|
|
},
|
|
),
|
|
fields: Primitive,
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Direct(
|
|
ArgAttributes {
|
|
regular: NoUndef,
|
|
arg_ext: None,
|
|
pointee_size: Size(0 bytes),
|
|
pointee_align: None,
|
|
},
|
|
),
|
|
},
|
|
],
|
|
ret: ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: (),
|
|
layout: Layout {
|
|
size: Size(0 bytes),
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Aggregate {
|
|
sized: true,
|
|
},
|
|
fields: Arbitrary {
|
|
offsets: [],
|
|
memory_index: [],
|
|
},
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Ignore,
|
|
},
|
|
c_variadic: false,
|
|
fixed_count: 1,
|
|
conv: Rust,
|
|
can_unwind: $SOME_BOOL,
|
|
}
|
|
right ABI = FnAbi {
|
|
args: [
|
|
ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: u32,
|
|
layout: Layout {
|
|
size: $SOME_SIZE,
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Scalar(
|
|
Initialized {
|
|
value: Int(
|
|
I32,
|
|
false,
|
|
),
|
|
valid_range: $FULL,
|
|
},
|
|
),
|
|
fields: Primitive,
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Direct(
|
|
ArgAttributes {
|
|
regular: NoUndef,
|
|
arg_ext: None,
|
|
pointee_size: Size(0 bytes),
|
|
pointee_align: None,
|
|
},
|
|
),
|
|
},
|
|
],
|
|
ret: ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: (),
|
|
layout: Layout {
|
|
size: Size(0 bytes),
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Aggregate {
|
|
sized: true,
|
|
},
|
|
fields: Arbitrary {
|
|
offsets: [],
|
|
memory_index: [],
|
|
},
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Ignore,
|
|
},
|
|
c_variadic: false,
|
|
fixed_count: 1,
|
|
conv: Rust,
|
|
can_unwind: $SOME_BOOL,
|
|
}
|
|
--> $DIR/debug.rs:51:1
|
|
|
|
|
LL | type TestAbiNeSign = (fn(i32), fn(u32));
|
|
| ^^^^^^^^^^^^^^^^^^
|
|
|
|
error[E0277]: the size for values of type `str` cannot be known at compilation time
|
|
--> $DIR/debug.rs:54:46
|
|
|
|
|
LL | type TestAbiEqNonsense = (fn((str, str)), fn((str, str)));
|
|
| ^^^^^^^^^^ doesn't have a size known at compile-time
|
|
|
|
|
= help: the trait `Sized` is not implemented for `str`
|
|
= note: only the last element of a tuple may have a dynamically sized type
|
|
|
|
error: `#[rustc_abi]` can only be applied to function items, type aliases, and associated functions
|
|
--> $DIR/debug.rs:29:5
|
|
|
|
|
LL | const C: () = ();
|
|
| ^^^^^^^^^^^
|
|
|
|
error: fn_abi_of(assoc_test) = FnAbi {
|
|
args: [
|
|
ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: &ReErased Adt(S, []),
|
|
layout: Layout {
|
|
size: $SOME_SIZE,
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Scalar(
|
|
Initialized {
|
|
value: Pointer(
|
|
AddressSpace(
|
|
0,
|
|
),
|
|
),
|
|
valid_range: $NON_NULL,
|
|
},
|
|
),
|
|
fields: Primitive,
|
|
largest_niche: Some(
|
|
Niche {
|
|
offset: Size(0 bytes),
|
|
value: Pointer(
|
|
AddressSpace(
|
|
0,
|
|
),
|
|
),
|
|
valid_range: $NON_NULL,
|
|
},
|
|
),
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Direct(
|
|
ArgAttributes {
|
|
regular: NoAlias | NonNull | ReadOnly | NoUndef,
|
|
arg_ext: None,
|
|
pointee_size: Size(2 bytes),
|
|
pointee_align: Some(
|
|
Align(2 bytes),
|
|
),
|
|
},
|
|
),
|
|
},
|
|
],
|
|
ret: ArgAbi {
|
|
layout: TyAndLayout {
|
|
ty: (),
|
|
layout: Layout {
|
|
size: Size(0 bytes),
|
|
align: AbiAndPrefAlign {
|
|
abi: $SOME_ALIGN,
|
|
pref: $SOME_ALIGN,
|
|
},
|
|
abi: Aggregate {
|
|
sized: true,
|
|
},
|
|
fields: Arbitrary {
|
|
offsets: [],
|
|
memory_index: [],
|
|
},
|
|
largest_niche: None,
|
|
variants: Single {
|
|
index: 0,
|
|
},
|
|
max_repr_align: None,
|
|
unadjusted_abi_align: $SOME_ALIGN,
|
|
},
|
|
},
|
|
mode: Ignore,
|
|
},
|
|
c_variadic: false,
|
|
fixed_count: 1,
|
|
conv: Rust,
|
|
can_unwind: $SOME_BOOL,
|
|
}
|
|
--> $DIR/debug.rs:34:5
|
|
|
|
|
LL | fn assoc_test(&self) { }
|
|
| ^^^^^^^^^^^^^^^^^^^^
|
|
|
|
error: aborting due to 11 previous errors
|
|
|
|
For more information about this error, try `rustc --explain E0277`.
|