| error: fn_abi_of(test) = FnAbi { |
| args: [ |
| ArgAbi { |
| layout: TyAndLayout { |
| ty: u8, |
| layout: Layout { |
| size: Size(1 bytes), |
| align: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Scalar( |
| Initialized { |
| value: Int( |
| I8, |
| false, |
| ), |
| valid_range: 0..=255, |
| }, |
| ), |
| fields: Primitive, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| mode: Direct( |
| ArgAttributes { |
| regular: NoUndef, |
| arg_ext: Zext, |
| pointee_size: Size(0 bytes), |
| pointee_align: None, |
| }, |
| ), |
| }, |
| ], |
| ret: ArgAbi { |
| layout: TyAndLayout { |
| ty: bool, |
| layout: Layout { |
| size: Size(1 bytes), |
| align: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: 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, |
| }, |
| ), |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| 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:27:1 |
| | |
| LL | fn test(_x: u8) -> bool { |
| | ^^^^^^^^^^^^^^^^^^^^^^^ |
| |
| error: fn_abi_of(TestFnPtr) = FnAbi { |
| args: [ |
| ArgAbi { |
| layout: TyAndLayout { |
| ty: bool, |
| layout: Layout { |
| size: Size(1 bytes), |
| align: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: 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, |
| }, |
| ), |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| 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: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Scalar( |
| Initialized { |
| value: Int( |
| I8, |
| false, |
| ), |
| valid_range: 0..=255, |
| }, |
| ), |
| fields: Primitive, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| 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:33:1 |
| | |
| LL | type TestFnPtr = fn(bool) -> u8; |
| | ^^^^^^^^^^^^^^ |
| |
| error: fn_abi_of(test_generic) = FnAbi { |
| args: [ |
| ArgAbi { |
| layout: TyAndLayout { |
| ty: *const T, |
| layout: Layout { |
| size: $SOME_SIZE, |
| align: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Scalar( |
| Initialized { |
| value: Pointer( |
| AddressSpace( |
| 0, |
| ), |
| ), |
| valid_range: $FULL, |
| }, |
| ), |
| fields: Primitive, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| 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: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Memory { |
| sized: true, |
| }, |
| fields: Arbitrary { |
| offsets: [], |
| memory_index: [], |
| }, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| mode: Ignore, |
| }, |
| c_variadic: false, |
| fixed_count: 1, |
| conv: Rust, |
| can_unwind: $SOME_BOOL, |
| } |
| --> $DIR/debug.rs:36: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:39: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: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Scalar( |
| Initialized { |
| value: Int( |
| I8, |
| false, |
| ), |
| valid_range: 0..=255, |
| }, |
| ), |
| fields: Primitive, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| mode: Direct( |
| ArgAttributes { |
| regular: NoUndef, |
| arg_ext: Zext, |
| pointee_size: Size(0 bytes), |
| pointee_align: None, |
| }, |
| ), |
| }, |
| ], |
| ret: ArgAbi { |
| layout: TyAndLayout { |
| ty: (), |
| layout: Layout { |
| size: Size(0 bytes), |
| align: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Memory { |
| sized: true, |
| }, |
| fields: Arbitrary { |
| offsets: [], |
| memory_index: [], |
| }, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| 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: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Scalar( |
| Initialized { |
| value: Int( |
| I32, |
| false, |
| ), |
| valid_range: $FULL, |
| }, |
| ), |
| fields: Primitive, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| mode: Direct( |
| ArgAttributes { |
| regular: NoUndef, |
| arg_ext: Sext, |
| pointee_size: Size(0 bytes), |
| pointee_align: None, |
| }, |
| ), |
| }, |
| ], |
| ret: ArgAbi { |
| layout: TyAndLayout { |
| ty: (), |
| layout: Layout { |
| size: Size(0 bytes), |
| align: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Memory { |
| sized: true, |
| }, |
| fields: Arbitrary { |
| offsets: [], |
| memory_index: [], |
| }, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| mode: Ignore, |
| }, |
| c_variadic: false, |
| fixed_count: 1, |
| conv: Rust, |
| can_unwind: $SOME_BOOL, |
| } |
| --> $DIR/debug.rs:55:1 |
| | |
| LL | type TestAbiNe = (fn(u8), fn(u32)); |
| | ^^^^^^^^^^^^^^ |
| |
| error: ABIs are not compatible |
| left ABI = FnAbi { |
| args: [ |
| ArgAbi { |
| layout: TyAndLayout { |
| ty: [u8; 32], |
| layout: Layout { |
| size: Size(32 bytes), |
| align: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Memory { |
| sized: true, |
| }, |
| fields: Array { |
| stride: Size(1 bytes), |
| count: 32, |
| }, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| mode: Indirect { |
| attrs: ArgAttributes { |
| regular: NoAlias | NoCapture | NonNull | NoUndef, |
| arg_ext: None, |
| pointee_size: Size(32 bytes), |
| pointee_align: Some( |
| Align(1 bytes), |
| ), |
| }, |
| meta_attrs: None, |
| on_stack: false, |
| }, |
| }, |
| ], |
| ret: ArgAbi { |
| layout: TyAndLayout { |
| ty: (), |
| layout: Layout { |
| size: Size(0 bytes), |
| align: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Memory { |
| sized: true, |
| }, |
| fields: Arbitrary { |
| offsets: [], |
| memory_index: [], |
| }, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| mode: Ignore, |
| }, |
| c_variadic: false, |
| fixed_count: 1, |
| conv: Rust, |
| can_unwind: $SOME_BOOL, |
| } |
| right ABI = FnAbi { |
| args: [ |
| ArgAbi { |
| layout: TyAndLayout { |
| ty: [u32; 32], |
| layout: Layout { |
| size: Size(128 bytes), |
| align: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Memory { |
| sized: true, |
| }, |
| fields: Array { |
| stride: Size(4 bytes), |
| count: 32, |
| }, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| mode: Indirect { |
| attrs: ArgAttributes { |
| regular: NoAlias | NoCapture | NonNull | NoUndef, |
| arg_ext: None, |
| pointee_size: Size(128 bytes), |
| pointee_align: Some( |
| Align(4 bytes), |
| ), |
| }, |
| meta_attrs: None, |
| on_stack: false, |
| }, |
| }, |
| ], |
| ret: ArgAbi { |
| layout: TyAndLayout { |
| ty: (), |
| layout: Layout { |
| size: Size(0 bytes), |
| align: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Memory { |
| sized: true, |
| }, |
| fields: Arbitrary { |
| offsets: [], |
| memory_index: [], |
| }, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| mode: Ignore, |
| }, |
| c_variadic: false, |
| fixed_count: 1, |
| conv: Rust, |
| can_unwind: $SOME_BOOL, |
| } |
| --> $DIR/debug.rs:58: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: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Scalar( |
| Initialized { |
| value: Float( |
| F32, |
| ), |
| valid_range: $FULL, |
| }, |
| ), |
| fields: Primitive, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| 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: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Memory { |
| sized: true, |
| }, |
| fields: Arbitrary { |
| offsets: [], |
| memory_index: [], |
| }, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| 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: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Scalar( |
| Initialized { |
| value: Int( |
| I32, |
| false, |
| ), |
| valid_range: $FULL, |
| }, |
| ), |
| fields: Primitive, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| mode: Direct( |
| ArgAttributes { |
| regular: NoUndef, |
| arg_ext: Sext, |
| pointee_size: Size(0 bytes), |
| pointee_align: None, |
| }, |
| ), |
| }, |
| ], |
| ret: ArgAbi { |
| layout: TyAndLayout { |
| ty: (), |
| layout: Layout { |
| size: Size(0 bytes), |
| align: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Memory { |
| sized: true, |
| }, |
| fields: Arbitrary { |
| offsets: [], |
| memory_index: [], |
| }, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| mode: Ignore, |
| }, |
| c_variadic: false, |
| fixed_count: 1, |
| conv: Rust, |
| can_unwind: $SOME_BOOL, |
| } |
| --> $DIR/debug.rs:61: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: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Scalar( |
| Initialized { |
| value: Int( |
| I32, |
| true, |
| ), |
| valid_range: $FULL, |
| }, |
| ), |
| fields: Primitive, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| mode: Direct( |
| ArgAttributes { |
| regular: NoUndef, |
| arg_ext: Sext, |
| pointee_size: Size(0 bytes), |
| pointee_align: None, |
| }, |
| ), |
| }, |
| ], |
| ret: ArgAbi { |
| layout: TyAndLayout { |
| ty: (), |
| layout: Layout { |
| size: Size(0 bytes), |
| align: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Memory { |
| sized: true, |
| }, |
| fields: Arbitrary { |
| offsets: [], |
| memory_index: [], |
| }, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| 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: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Scalar( |
| Initialized { |
| value: Int( |
| I32, |
| false, |
| ), |
| valid_range: $FULL, |
| }, |
| ), |
| fields: Primitive, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| mode: Direct( |
| ArgAttributes { |
| regular: NoUndef, |
| arg_ext: Sext, |
| pointee_size: Size(0 bytes), |
| pointee_align: None, |
| }, |
| ), |
| }, |
| ], |
| ret: ArgAbi { |
| layout: TyAndLayout { |
| ty: (), |
| layout: Layout { |
| size: Size(0 bytes), |
| align: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Memory { |
| sized: true, |
| }, |
| fields: Arbitrary { |
| offsets: [], |
| memory_index: [], |
| }, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| mode: Ignore, |
| }, |
| c_variadic: false, |
| fixed_count: 1, |
| conv: Rust, |
| can_unwind: $SOME_BOOL, |
| } |
| --> $DIR/debug.rs:65: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:68: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: unrecognized argument |
| --> $DIR/debug.rs:70:13 |
| | |
| LL | #[rustc_abi("assert_eq")] |
| | ^^^^^^^^^^^ |
| |
| error: `#[rustc_abi]` can only be applied to function items, type aliases, and associated functions |
| --> $DIR/debug.rs:43:5 |
| | |
| LL | const C: () = (); |
| | ^^^^^^^^^^^ |
| |
| error: fn_abi_of(assoc_test) = FnAbi { |
| args: [ |
| ArgAbi { |
| layout: TyAndLayout { |
| ty: &S, |
| layout: Layout { |
| size: $SOME_SIZE, |
| align: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: 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, |
| }, |
| ), |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| 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: AbiAlign { |
| abi: $SOME_ALIGN, |
| }, |
| backend_repr: Memory { |
| sized: true, |
| }, |
| fields: Arbitrary { |
| offsets: [], |
| memory_index: [], |
| }, |
| largest_niche: None, |
| uninhabited: false, |
| variants: Single { |
| index: 0, |
| }, |
| max_repr_align: None, |
| unadjusted_abi_align: $SOME_ALIGN, |
| randomization_seed: $SEED, |
| }, |
| }, |
| mode: Ignore, |
| }, |
| c_variadic: false, |
| fixed_count: 1, |
| conv: Rust, |
| can_unwind: $SOME_BOOL, |
| } |
| --> $DIR/debug.rs:48:5 |
| | |
| LL | fn assoc_test(&self) {} |
| | ^^^^^^^^^^^^^^^^^^^^ |
| |
| error: aborting due to 12 previous errors |
| |
| For more information about this error, try `rustc --explain E0277`. |
