diff options
Diffstat (limited to 'tests')
12 files changed, 489 insertions, 19 deletions
diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff new file mode 100644 index 00000000000..50189d192ce --- /dev/null +++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff @@ -0,0 +1,123 @@ +- // MIR for `main` before GVN ++ // MIR for `main` after GVN + + fn main() -> () { + let mut _0: (); + let _1: std::alloc::Layout; + let mut _2: std::option::Option<std::alloc::Layout>; + let mut _3: *mut u8; + let mut _4: *mut [u8]; + let mut _5: std::ptr::NonNull<[u8]>; + let mut _6: std::result::Result<std::ptr::NonNull<[u8]>, std::alloc::AllocError>; + let mut _7: &std::alloc::Global; + let mut _8: std::alloc::Layout; + scope 1 { + debug layout => _1; + let mut _9: &std::alloc::Global; + scope 2 { + debug ptr => _3; + } + scope 5 (inlined <std::alloc::Global as Allocator>::allocate) { + debug self => _9; + debug layout => _1; + } + scope 6 (inlined #[track_caller] Result::<NonNull<[u8]>, std::alloc::AllocError>::unwrap) { + debug self => _6; + let mut _12: isize; + let _13: std::alloc::AllocError; + let mut _14: !; + let _15: &str; + let mut _16: &dyn std::fmt::Debug; + let mut _17: &std::alloc::AllocError; + scope 7 { + debug t => _5; + } + scope 8 { + debug e => const std::alloc::AllocError; + } + } + scope 9 (inlined NonNull::<[u8]>::as_ptr) { + debug self => _5; + let mut _18: *const [u8]; + } + } + scope 3 (inlined #[track_caller] Option::<Layout>::unwrap) { + debug self => _2; + let mut _10: isize; + let mut _11: !; + scope 4 { + debug val => _1; + } + } + + bb0: { + StorageLive(_2); +- _2 = Option::<Layout>::None; ++ _2 = const Option::<Layout>::None; + StorageLive(_10); + _10 = const 0_isize; + switchInt(const 0_isize) -> [0: bb1, 1: bb3, otherwise: bb2]; + } + + bb1: { + _11 = core::panicking::panic(const "called `Option::unwrap()` on a `None` value") -> unwind unreachable; + } + + bb2: { + unreachable; + } + + bb3: { +- _1 = move ((_2 as Some).0: std::alloc::Layout); ++ _1 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): ptr::alignment::AlignmentEnum32) }}; + StorageDead(_10); + StorageDead(_2); + StorageLive(_3); + StorageLive(_4); + StorageLive(_5); + StorageLive(_6); + _9 = const _; +- _6 = std::alloc::Global::alloc_impl(_9, _1, const false) -> [return: bb4, unwind unreachable]; ++ _6 = std::alloc::Global::alloc_impl(const {ALLOC1: &std::alloc::Global}, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): ptr::alignment::AlignmentEnum32) }}, const false) -> [return: bb4, unwind unreachable]; + } + + bb4: { + StorageLive(_12); + StorageLive(_15); + _12 = discriminant(_6); + switchInt(move _12) -> [0: bb6, 1: bb5, otherwise: bb2]; + } + + bb5: { + _15 = const "called `Result::unwrap()` on an `Err` value"; + StorageLive(_16); + StorageLive(_17); + _17 = &_13; + _16 = move _17 as &dyn std::fmt::Debug (PointerCoercion(Unsize)); + StorageDead(_17); + _14 = result::unwrap_failed(move _15, move _16) -> unwind unreachable; + } + + bb6: { + _5 = move ((_6 as Ok).0: std::ptr::NonNull<[u8]>); + StorageDead(_15); + StorageDead(_12); + StorageDead(_6); + StorageLive(_18); + _18 = (_5.0: *const [u8]); + _4 = move _18 as *mut [u8] (PtrToPtr); + StorageDead(_18); + StorageDead(_5); + _3 = move _4 as *mut u8 (PtrToPtr); + StorageDead(_4); + StorageDead(_3); + return; + } + } ++ ++ ALLOC0 (size: 8, align: 4) { ++ 00 00 00 00 __ __ __ __ │ ....░░░░ ++ } ++ ++ ALLOC1 (size: 0, align: 1) {} + diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff new file mode 100644 index 00000000000..6966762a1b8 --- /dev/null +++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff @@ -0,0 +1,92 @@ +- // MIR for `main` before GVN ++ // MIR for `main` after GVN + + fn main() -> () { + let mut _0: (); + let _1: std::alloc::Layout; + let mut _2: std::option::Option<std::alloc::Layout>; + let mut _3: *mut u8; + let mut _4: *mut [u8]; + let mut _5: std::ptr::NonNull<[u8]>; + let mut _6: std::result::Result<std::ptr::NonNull<[u8]>, std::alloc::AllocError>; + let mut _7: &std::alloc::Global; + let mut _8: std::alloc::Layout; + scope 1 { + debug layout => _1; + let mut _9: &std::alloc::Global; + scope 2 { + debug ptr => _3; + } + scope 5 (inlined <std::alloc::Global as Allocator>::allocate) { + debug self => _9; + debug layout => _1; + } + scope 6 (inlined NonNull::<[u8]>::as_ptr) { + debug self => _5; + let mut _12: *const [u8]; + } + } + scope 3 (inlined #[track_caller] Option::<Layout>::unwrap) { + debug self => _2; + let mut _10: isize; + let mut _11: !; + scope 4 { + debug val => _1; + } + } + + bb0: { + StorageLive(_2); +- _2 = Option::<Layout>::None; ++ _2 = const Option::<Layout>::None; + StorageLive(_10); + _10 = const 0_isize; + switchInt(const 0_isize) -> [0: bb2, 1: bb4, otherwise: bb3]; + } + + bb1: { + StorageDead(_6); + StorageLive(_12); + _12 = (_5.0: *const [u8]); + _4 = move _12 as *mut [u8] (PtrToPtr); + StorageDead(_12); + StorageDead(_5); + _3 = move _4 as *mut u8 (PtrToPtr); + StorageDead(_4); + StorageDead(_3); + return; + } + + bb2: { + _11 = core::panicking::panic(const "called `Option::unwrap()` on a `None` value") -> unwind continue; + } + + bb3: { + unreachable; + } + + bb4: { +- _1 = move ((_2 as Some).0: std::alloc::Layout); ++ _1 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): ptr::alignment::AlignmentEnum32) }}; + StorageDead(_10); + StorageDead(_2); + StorageLive(_3); + StorageLive(_4); + StorageLive(_5); + StorageLive(_6); + _9 = const _; +- _6 = std::alloc::Global::alloc_impl(_9, _1, const false) -> [return: bb5, unwind continue]; ++ _6 = std::alloc::Global::alloc_impl(const {ALLOC1: &std::alloc::Global}, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): ptr::alignment::AlignmentEnum32) }}, const false) -> [return: bb5, unwind continue]; + } + + bb5: { + _5 = Result::<NonNull<[u8]>, std::alloc::AllocError>::unwrap(move _6) -> [return: bb1, unwind continue]; + } + } ++ ++ ALLOC0 (size: 8, align: 4) { ++ 00 00 00 00 __ __ __ __ │ ....░░░░ ++ } ++ ++ ALLOC1 (size: 0, align: 1) {} + diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff new file mode 100644 index 00000000000..08a185bad9c --- /dev/null +++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff @@ -0,0 +1,123 @@ +- // MIR for `main` before GVN ++ // MIR for `main` after GVN + + fn main() -> () { + let mut _0: (); + let _1: std::alloc::Layout; + let mut _2: std::option::Option<std::alloc::Layout>; + let mut _3: *mut u8; + let mut _4: *mut [u8]; + let mut _5: std::ptr::NonNull<[u8]>; + let mut _6: std::result::Result<std::ptr::NonNull<[u8]>, std::alloc::AllocError>; + let mut _7: &std::alloc::Global; + let mut _8: std::alloc::Layout; + scope 1 { + debug layout => _1; + let mut _9: &std::alloc::Global; + scope 2 { + debug ptr => _3; + } + scope 5 (inlined <std::alloc::Global as Allocator>::allocate) { + debug self => _9; + debug layout => _1; + } + scope 6 (inlined #[track_caller] Result::<NonNull<[u8]>, std::alloc::AllocError>::unwrap) { + debug self => _6; + let mut _12: isize; + let _13: std::alloc::AllocError; + let mut _14: !; + let _15: &str; + let mut _16: &dyn std::fmt::Debug; + let mut _17: &std::alloc::AllocError; + scope 7 { + debug t => _5; + } + scope 8 { + debug e => const std::alloc::AllocError; + } + } + scope 9 (inlined NonNull::<[u8]>::as_ptr) { + debug self => _5; + let mut _18: *const [u8]; + } + } + scope 3 (inlined #[track_caller] Option::<Layout>::unwrap) { + debug self => _2; + let mut _10: isize; + let mut _11: !; + scope 4 { + debug val => _1; + } + } + + bb0: { + StorageLive(_2); +- _2 = Option::<Layout>::None; ++ _2 = const Option::<Layout>::None; + StorageLive(_10); + _10 = const 0_isize; + switchInt(const 0_isize) -> [0: bb1, 1: bb3, otherwise: bb2]; + } + + bb1: { + _11 = core::panicking::panic(const "called `Option::unwrap()` on a `None` value") -> unwind unreachable; + } + + bb2: { + unreachable; + } + + bb3: { +- _1 = move ((_2 as Some).0: std::alloc::Layout); ++ _1 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): ptr::alignment::AlignmentEnum64) }}; + StorageDead(_10); + StorageDead(_2); + StorageLive(_3); + StorageLive(_4); + StorageLive(_5); + StorageLive(_6); + _9 = const _; +- _6 = std::alloc::Global::alloc_impl(_9, _1, const false) -> [return: bb4, unwind unreachable]; ++ _6 = std::alloc::Global::alloc_impl(const {ALLOC1: &std::alloc::Global}, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): ptr::alignment::AlignmentEnum64) }}, const false) -> [return: bb4, unwind unreachable]; + } + + bb4: { + StorageLive(_12); + StorageLive(_15); + _12 = discriminant(_6); + switchInt(move _12) -> [0: bb6, 1: bb5, otherwise: bb2]; + } + + bb5: { + _15 = const "called `Result::unwrap()` on an `Err` value"; + StorageLive(_16); + StorageLive(_17); + _17 = &_13; + _16 = move _17 as &dyn std::fmt::Debug (PointerCoercion(Unsize)); + StorageDead(_17); + _14 = result::unwrap_failed(move _15, move _16) -> unwind unreachable; + } + + bb6: { + _5 = move ((_6 as Ok).0: std::ptr::NonNull<[u8]>); + StorageDead(_15); + StorageDead(_12); + StorageDead(_6); + StorageLive(_18); + _18 = (_5.0: *const [u8]); + _4 = move _18 as *mut [u8] (PtrToPtr); + StorageDead(_18); + StorageDead(_5); + _3 = move _4 as *mut u8 (PtrToPtr); + StorageDead(_4); + StorageDead(_3); + return; + } + } ++ ++ ALLOC0 (size: 16, align: 8) { ++ 00 00 00 00 00 00 00 00 __ __ __ __ __ __ __ __ │ ........░░░░░░░░ ++ } ++ ++ ALLOC1 (size: 0, align: 1) {} + diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff new file mode 100644 index 00000000000..6501cb85e8a --- /dev/null +++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff @@ -0,0 +1,92 @@ +- // MIR for `main` before GVN ++ // MIR for `main` after GVN + + fn main() -> () { + let mut _0: (); + let _1: std::alloc::Layout; + let mut _2: std::option::Option<std::alloc::Layout>; + let mut _3: *mut u8; + let mut _4: *mut [u8]; + let mut _5: std::ptr::NonNull<[u8]>; + let mut _6: std::result::Result<std::ptr::NonNull<[u8]>, std::alloc::AllocError>; + let mut _7: &std::alloc::Global; + let mut _8: std::alloc::Layout; + scope 1 { + debug layout => _1; + let mut _9: &std::alloc::Global; + scope 2 { + debug ptr => _3; + } + scope 5 (inlined <std::alloc::Global as Allocator>::allocate) { + debug self => _9; + debug layout => _1; + } + scope 6 (inlined NonNull::<[u8]>::as_ptr) { + debug self => _5; + let mut _12: *const [u8]; + } + } + scope 3 (inlined #[track_caller] Option::<Layout>::unwrap) { + debug self => _2; + let mut _10: isize; + let mut _11: !; + scope 4 { + debug val => _1; + } + } + + bb0: { + StorageLive(_2); +- _2 = Option::<Layout>::None; ++ _2 = const Option::<Layout>::None; + StorageLive(_10); + _10 = const 0_isize; + switchInt(const 0_isize) -> [0: bb2, 1: bb4, otherwise: bb3]; + } + + bb1: { + StorageDead(_6); + StorageLive(_12); + _12 = (_5.0: *const [u8]); + _4 = move _12 as *mut [u8] (PtrToPtr); + StorageDead(_12); + StorageDead(_5); + _3 = move _4 as *mut u8 (PtrToPtr); + StorageDead(_4); + StorageDead(_3); + return; + } + + bb2: { + _11 = core::panicking::panic(const "called `Option::unwrap()` on a `None` value") -> unwind continue; + } + + bb3: { + unreachable; + } + + bb4: { +- _1 = move ((_2 as Some).0: std::alloc::Layout); ++ _1 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): ptr::alignment::AlignmentEnum64) }}; + StorageDead(_10); + StorageDead(_2); + StorageLive(_3); + StorageLive(_4); + StorageLive(_5); + StorageLive(_6); + _9 = const _; +- _6 = std::alloc::Global::alloc_impl(_9, _1, const false) -> [return: bb5, unwind continue]; ++ _6 = std::alloc::Global::alloc_impl(const {ALLOC1: &std::alloc::Global}, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): ptr::alignment::AlignmentEnum64) }}, const false) -> [return: bb5, unwind continue]; + } + + bb5: { + _5 = Result::<NonNull<[u8]>, std::alloc::AllocError>::unwrap(move _6) -> [return: bb1, unwind continue]; + } + } ++ ++ ALLOC0 (size: 16, align: 8) { ++ 00 00 00 00 00 00 00 00 __ __ __ __ __ __ __ __ │ ........░░░░░░░░ ++ } ++ ++ ALLOC1 (size: 0, align: 1) {} + diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.rs b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.rs new file mode 100644 index 00000000000..c92424f2983 --- /dev/null +++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.rs @@ -0,0 +1,15 @@ +// Verify that we do not ICE when printing an invalid constant. +// EMIT_MIR_FOR_EACH_BIT_WIDTH +// EMIT_MIR_FOR_EACH_PANIC_STRATEGY + +#![feature(allocator_api)] + +use std::alloc::{Allocator, Global, Layout}; + +// EMIT_MIR issue_117368_print_invalid_constant.main.GVN.diff +fn main() { + // CHECK-LABEL: fn main( + // CHECK: debug layout => const Layout + let layout: Layout = None.unwrap(); + let ptr: *mut u8 = Global.allocate(layout).unwrap().as_ptr() as _; +} diff --git a/tests/ui/mismatched_types/recovered-block.rs b/tests/ui/mismatched_types/recovered-block.rs index b230b47d35d..a91bbe7083b 100644 --- a/tests/ui/mismatched_types/recovered-block.rs +++ b/tests/ui/mismatched_types/recovered-block.rs @@ -12,10 +12,4 @@ pub fn foo() -> Foo { } //~^^ ERROR missing `struct` for struct definition -pub fn bar() -> Foo { - fn - Foo { text: "".to_string() } -} -//~^^ ERROR expected one of `(` or `<`, found `{` - fn main() {} diff --git a/tests/ui/mismatched_types/recovered-block.stderr b/tests/ui/mismatched_types/recovered-block.stderr index f275321abe5..88d62545656 100644 --- a/tests/ui/mismatched_types/recovered-block.stderr +++ b/tests/ui/mismatched_types/recovered-block.stderr @@ -9,11 +9,5 @@ help: add `struct` here to parse `Foo` as a public struct LL | pub struct Foo { text } | ++++++ -error: expected one of `(` or `<`, found `{` - --> $DIR/recovered-block.rs:17:9 - | -LL | Foo { text: "".to_string() } - | ^ expected one of `(` or `<` - -error: aborting due to 2 previous errors +error: aborting due to previous error diff --git a/tests/ui/parser/issues/issue-108109-fn-missing-params.fixed b/tests/ui/parser/issues/issue-108109-fn-missing-params.fixed new file mode 100644 index 00000000000..b819aa810cb --- /dev/null +++ b/tests/ui/parser/issues/issue-108109-fn-missing-params.fixed @@ -0,0 +1,9 @@ +// run-rustfix + +pub fn missing() -> () {} +//~^ ERROR missing parameters for function definition + +pub fn missing2() {} +//~^ ERROR missing parameters for function definition + +fn main() {} diff --git a/tests/ui/parser/issues/issue-108109-fn-missing-params.rs b/tests/ui/parser/issues/issue-108109-fn-missing-params.rs new file mode 100644 index 00000000000..01efe728081 --- /dev/null +++ b/tests/ui/parser/issues/issue-108109-fn-missing-params.rs @@ -0,0 +1,9 @@ +// run-rustfix + +pub fn missing -> () {} +//~^ ERROR missing parameters for function definition + +pub fn missing2 {} +//~^ ERROR missing parameters for function definition + +fn main() {} diff --git a/tests/ui/parser/issues/issue-108109-fn-missing-params.stderr b/tests/ui/parser/issues/issue-108109-fn-missing-params.stderr new file mode 100644 index 00000000000..86d3449cc33 --- /dev/null +++ b/tests/ui/parser/issues/issue-108109-fn-missing-params.stderr @@ -0,0 +1,14 @@ +error: missing parameters for function definition + --> $DIR/issue-108109-fn-missing-params.rs:3:15 + | +LL | pub fn missing -> () {} + | ^ help: add a parameter list + +error: missing parameters for function definition + --> $DIR/issue-108109-fn-missing-params.rs:6:16 + | +LL | pub fn missing2 {} + | ^ help: add a parameter list + +error: aborting due to 2 previous errors + diff --git a/tests/ui/parser/removed-syntax-fn-sigil.rs b/tests/ui/parser/removed-syntax-fn-sigil.rs index 725843429c0..d55a032d1f2 100644 --- a/tests/ui/parser/removed-syntax-fn-sigil.rs +++ b/tests/ui/parser/removed-syntax-fn-sigil.rs @@ -1,3 +1,4 @@ fn main() { - let x: fn~() = || (); //~ ERROR expected `(`, found `~` + let x: fn~() = || (); //~ ERROR missing parameters for function definition + //~| ERROR expected one of `->`, `;`, or `=`, found `~` } diff --git a/tests/ui/parser/removed-syntax-fn-sigil.stderr b/tests/ui/parser/removed-syntax-fn-sigil.stderr index 196a5af4729..0d377416700 100644 --- a/tests/ui/parser/removed-syntax-fn-sigil.stderr +++ b/tests/ui/parser/removed-syntax-fn-sigil.stderr @@ -1,10 +1,14 @@ -error: expected `(`, found `~` +error: missing parameters for function definition --> $DIR/removed-syntax-fn-sigil.rs:2:14 | LL | let x: fn~() = || (); - | - ^ expected `(` - | | - | while parsing the type for `x` + | ^ help: add a parameter list -error: aborting due to previous error +error: expected one of `->`, `;`, or `=`, found `~` + --> $DIR/removed-syntax-fn-sigil.rs:2:14 + | +LL | let x: fn~() = || (); + | ^ expected one of `->`, `;`, or `=` + +error: aborting due to 2 previous errors |