diff options
Diffstat (limited to 'tests/ui/reachable')
66 files changed, 1372 insertions, 0 deletions
diff --git a/tests/ui/reachable/README.md b/tests/ui/reachable/README.md new file mode 100644 index 000000000..8bed5fba7 --- /dev/null +++ b/tests/ui/reachable/README.md @@ -0,0 +1,7 @@ +A variety of tests around reachability. These tests in general check +two things: + +- that we get unreachable code warnings in reasonable locations; +- that we permit coercions **into** `!` from expressions which + diverge, where an expression "diverges" if it must execute some + subexpression of type `!`, or it has type `!` itself. diff --git a/tests/ui/reachable/auxiliary/issue-11225-1.rs b/tests/ui/reachable/auxiliary/issue-11225-1.rs new file mode 100644 index 000000000..2c6f899a0 --- /dev/null +++ b/tests/ui/reachable/auxiliary/issue-11225-1.rs @@ -0,0 +1,18 @@ +mod inner { + pub trait Trait { + fn f(&self) { f(); } + fn f_ufcs(&self) { f_ufcs(); } + } + + impl Trait for isize {} + + fn f() {} + fn f_ufcs() {} +} + +pub fn foo<T: inner::Trait>(t: T) { + t.f(); +} +pub fn foo_ufcs<T: inner::Trait>(t: T) { + T::f_ufcs(&t); +} diff --git a/tests/ui/reachable/auxiliary/issue-11225-2.rs b/tests/ui/reachable/auxiliary/issue-11225-2.rs new file mode 100644 index 000000000..4381f0a4e --- /dev/null +++ b/tests/ui/reachable/auxiliary/issue-11225-2.rs @@ -0,0 +1,28 @@ +use inner::Trait; + +mod inner { + pub struct Foo; + pub trait Trait { + fn f(&self); + fn f_ufcs(&self); + } + + impl Trait for Foo { + fn f(&self) { } + fn f_ufcs(&self) { } + } +} + +pub trait Outer { + fn foo<T: Trait>(&self, t: T) { t.f(); } + fn foo_ufcs<T: Trait>(&self, t: T) { T::f(&t); } +} + +impl Outer for isize {} + +pub fn foo<T: Outer>(t: T) { + t.foo(inner::Foo); +} +pub fn foo_ufcs<T: Outer>(t: T) { + T::foo_ufcs(&t, inner::Foo) +} diff --git a/tests/ui/reachable/auxiliary/issue-11225-3.rs b/tests/ui/reachable/auxiliary/issue-11225-3.rs new file mode 100644 index 000000000..266e42a10 --- /dev/null +++ b/tests/ui/reachable/auxiliary/issue-11225-3.rs @@ -0,0 +1,28 @@ +trait PrivateTrait { + fn private_trait_method(&self); + fn private_trait_method_ufcs(&self); +} + +struct PrivateStruct; + +impl PrivateStruct { + fn private_inherent_method(&self) { } + fn private_inherent_method_ufcs(&self) { } +} + +impl PrivateTrait for PrivateStruct { + fn private_trait_method(&self) { } + fn private_trait_method_ufcs(&self) { } +} + +#[inline] +pub fn public_inlinable_function() { + PrivateStruct.private_trait_method(); + PrivateStruct.private_inherent_method(); +} + +#[inline] +pub fn public_inlinable_function_ufcs() { + PrivateStruct::private_trait_method(&PrivateStruct); + PrivateStruct::private_inherent_method(&PrivateStruct); +} diff --git a/tests/ui/reachable/auxiliary/unreachable_variant.rs b/tests/ui/reachable/auxiliary/unreachable_variant.rs new file mode 100644 index 000000000..4e94a4b5e --- /dev/null +++ b/tests/ui/reachable/auxiliary/unreachable_variant.rs @@ -0,0 +1,5 @@ +mod super_sekrit { + pub enum sooper_sekrit { + quux, baz + } +} diff --git a/tests/ui/reachable/expr_add.rs b/tests/ui/reachable/expr_add.rs new file mode 100644 index 000000000..b45e5daf4 --- /dev/null +++ b/tests/ui/reachable/expr_add.rs @@ -0,0 +1,18 @@ +#![feature(never_type)] +#![allow(unused_variables)] +#![deny(unreachable_code)] + +use std::ops; + +struct Foo; + +impl ops::Add<!> for Foo { + type Output = !; + fn add(self, rhs: !) -> ! { + unimplemented!() + } +} + +fn main() { + let x = Foo + return; //~ ERROR unreachable +} diff --git a/tests/ui/reachable/expr_add.stderr b/tests/ui/reachable/expr_add.stderr new file mode 100644 index 000000000..692bd20f5 --- /dev/null +++ b/tests/ui/reachable/expr_add.stderr @@ -0,0 +1,17 @@ +error: unreachable expression + --> $DIR/expr_add.rs:17:13 + | +LL | let x = Foo + return; + | ^^^^^^------ + | | | + | | any code following this expression is unreachable + | unreachable expression + | +note: the lint level is defined here + --> $DIR/expr_add.rs:3:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + diff --git a/tests/ui/reachable/expr_again.rs b/tests/ui/reachable/expr_again.rs new file mode 100644 index 000000000..604932133 --- /dev/null +++ b/tests/ui/reachable/expr_again.rs @@ -0,0 +1,11 @@ +#![allow(unused_variables)] + +#![deny(unreachable_code)] + +fn main() { + let x = loop { + continue; + println!("hi"); + //~^ ERROR unreachable statement + }; +} diff --git a/tests/ui/reachable/expr_again.stderr b/tests/ui/reachable/expr_again.stderr new file mode 100644 index 000000000..a3c54e135 --- /dev/null +++ b/tests/ui/reachable/expr_again.stderr @@ -0,0 +1,17 @@ +error: unreachable statement + --> $DIR/expr_again.rs:8:9 + | +LL | continue; + | -------- any code following this expression is unreachable +LL | println!("hi"); + | ^^^^^^^^^^^^^^ unreachable statement + | +note: the lint level is defined here + --> $DIR/expr_again.rs:3:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: aborting due to previous error + diff --git a/tests/ui/reachable/expr_andand.rs b/tests/ui/reachable/expr_andand.rs new file mode 100644 index 000000000..d37eb0a3b --- /dev/null +++ b/tests/ui/reachable/expr_andand.rs @@ -0,0 +1,13 @@ +// build-pass (FIXME(62277): could be check-pass?) + +#![allow(unused_variables)] +#![allow(dead_code)] +#![deny(unreachable_code)] + +fn foo() { + // No error here. + let x = false && (return); + println!("I am not dead."); +} + +fn main() { } diff --git a/tests/ui/reachable/expr_array.rs b/tests/ui/reachable/expr_array.rs new file mode 100644 index 000000000..e6bdb9705 --- /dev/null +++ b/tests/ui/reachable/expr_array.rs @@ -0,0 +1,17 @@ +#![allow(unused_variables)] +#![allow(unused_assignments)] +#![allow(dead_code)] +#![deny(unreachable_code)] +#![feature(type_ascription)] + +fn a() { + // the `22` is unreachable: + let x: [usize; 2] = [return, 22]; //~ ERROR unreachable +} + +fn b() { + // the array is unreachable: + let x: [usize; 2] = [22, return]; //~ ERROR unreachable +} + +fn main() { } diff --git a/tests/ui/reachable/expr_array.stderr b/tests/ui/reachable/expr_array.stderr new file mode 100644 index 000000000..e144d7184 --- /dev/null +++ b/tests/ui/reachable/expr_array.stderr @@ -0,0 +1,25 @@ +error: unreachable expression + --> $DIR/expr_array.rs:9:34 + | +LL | let x: [usize; 2] = [return, 22]; + | ------ ^^ unreachable expression + | | + | any code following this expression is unreachable + | +note: the lint level is defined here + --> $DIR/expr_array.rs:4:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error: unreachable expression + --> $DIR/expr_array.rs:14:25 + | +LL | let x: [usize; 2] = [22, return]; + | ^^^^^------^ + | | | + | | any code following this expression is unreachable + | unreachable expression + +error: aborting due to 2 previous errors + diff --git a/tests/ui/reachable/expr_assign.rs b/tests/ui/reachable/expr_assign.rs new file mode 100644 index 000000000..e547f75e2 --- /dev/null +++ b/tests/ui/reachable/expr_assign.rs @@ -0,0 +1,29 @@ +#![feature(never_type)] +#![allow(unused_variables)] +#![allow(unused_assignments)] +#![allow(dead_code)] +#![deny(unreachable_code)] + +fn foo() { + // No error here. + let x; + x = return; //~ ERROR unreachable +} + +fn bar() { + use std::ptr; + let p: *mut ! = ptr::null_mut::<!>(); + unsafe { + // Here we consider the `return` unreachable because + // "evaluating" the `*p` has type `!`. This is somewhat + // dubious, I suppose. + *p = return; //~ ERROR unreachable + } +} + +fn baz() { + let mut i = 0; + *{return; &mut i} = 22; //~ ERROR unreachable +} + +fn main() { } diff --git a/tests/ui/reachable/expr_assign.stderr b/tests/ui/reachable/expr_assign.stderr new file mode 100644 index 000000000..c51156b3f --- /dev/null +++ b/tests/ui/reachable/expr_assign.stderr @@ -0,0 +1,33 @@ +error: unreachable expression + --> $DIR/expr_assign.rs:10:5 + | +LL | x = return; + | ^^^^------ + | | | + | | any code following this expression is unreachable + | unreachable expression + | +note: the lint level is defined here + --> $DIR/expr_assign.rs:5:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error: unreachable expression + --> $DIR/expr_assign.rs:20:14 + | +LL | *p = return; + | -- ^^^^^^ unreachable expression + | | + | any code following this expression is unreachable + +error: unreachable expression + --> $DIR/expr_assign.rs:26:15 + | +LL | *{return; &mut i} = 22; + | ------ ^^^^^^ unreachable expression + | | + | any code following this expression is unreachable + +error: aborting due to 3 previous errors + diff --git a/tests/ui/reachable/expr_block.rs b/tests/ui/reachable/expr_block.rs new file mode 100644 index 000000000..136bccce8 --- /dev/null +++ b/tests/ui/reachable/expr_block.rs @@ -0,0 +1,31 @@ +#![allow(unused_variables)] +#![allow(unused_assignments)] +#![allow(dead_code)] +#![deny(unreachable_code)] + +fn a() { + // Here the tail expression is considered unreachable: + let x = { + return; + 22 //~ ERROR unreachable + }; +} + +fn b() { + // Here the `x` assignment is considered unreachable, not the block: + let x = { + return; + }; +} + +fn c() { + // Here the `println!` is unreachable: + let x = { + return; + println!("foo"); + //~^ ERROR unreachable statement + 22 + }; +} + +fn main() { } diff --git a/tests/ui/reachable/expr_block.stderr b/tests/ui/reachable/expr_block.stderr new file mode 100644 index 000000000..d5f248a24 --- /dev/null +++ b/tests/ui/reachable/expr_block.stderr @@ -0,0 +1,26 @@ +error: unreachable expression + --> $DIR/expr_block.rs:10:9 + | +LL | return; + | ------ any code following this expression is unreachable +LL | 22 + | ^^ unreachable expression + | +note: the lint level is defined here + --> $DIR/expr_block.rs:4:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error: unreachable statement + --> $DIR/expr_block.rs:25:9 + | +LL | return; + | ------ any code following this expression is unreachable +LL | println!("foo"); + | ^^^^^^^^^^^^^^^ unreachable statement + | + = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: aborting due to 2 previous errors + diff --git a/tests/ui/reachable/expr_box.rs b/tests/ui/reachable/expr_box.rs new file mode 100644 index 000000000..00328ea01 --- /dev/null +++ b/tests/ui/reachable/expr_box.rs @@ -0,0 +1,8 @@ +#![feature(box_syntax)] +#![allow(unused_variables)] +#![deny(unreachable_code)] + +fn main() { + let x = box return; //~ ERROR unreachable + println!("hi"); +} diff --git a/tests/ui/reachable/expr_box.stderr b/tests/ui/reachable/expr_box.stderr new file mode 100644 index 000000000..ea6472cbe --- /dev/null +++ b/tests/ui/reachable/expr_box.stderr @@ -0,0 +1,17 @@ +error: unreachable expression + --> $DIR/expr_box.rs:6:13 + | +LL | let x = box return; + | ^^^^------ + | | | + | | any code following this expression is unreachable + | unreachable expression + | +note: the lint level is defined here + --> $DIR/expr_box.rs:3:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + diff --git a/tests/ui/reachable/expr_call.rs b/tests/ui/reachable/expr_call.rs new file mode 100644 index 000000000..1eaa96c3c --- /dev/null +++ b/tests/ui/reachable/expr_call.rs @@ -0,0 +1,21 @@ +#![feature(never_type)] +#![allow(unused_variables)] +#![allow(unused_assignments)] +#![allow(dead_code)] +#![deny(unreachable_code)] + +fn foo(x: !, y: usize) { } + +fn bar(x: !) { } + +fn a() { + // the `22` is unreachable: + foo(return, 22); //~ ERROR unreachable +} + +fn b() { + // the call is unreachable: + bar(return); //~ ERROR unreachable +} + +fn main() { } diff --git a/tests/ui/reachable/expr_call.stderr b/tests/ui/reachable/expr_call.stderr new file mode 100644 index 000000000..a5ad9a329 --- /dev/null +++ b/tests/ui/reachable/expr_call.stderr @@ -0,0 +1,24 @@ +error: unreachable expression + --> $DIR/expr_call.rs:13:17 + | +LL | foo(return, 22); + | ------ ^^ unreachable expression + | | + | any code following this expression is unreachable + | +note: the lint level is defined here + --> $DIR/expr_call.rs:5:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error: unreachable call + --> $DIR/expr_call.rs:18:5 + | +LL | bar(return); + | ^^^ ------ any code following this expression is unreachable + | | + | unreachable call + +error: aborting due to 2 previous errors + diff --git a/tests/ui/reachable/expr_cast.rs b/tests/ui/reachable/expr_cast.rs new file mode 100644 index 000000000..e8e477ea4 --- /dev/null +++ b/tests/ui/reachable/expr_cast.rs @@ -0,0 +1,13 @@ +#![allow(unused_variables)] +#![allow(unused_assignments)] +#![allow(dead_code)] +#![deny(unreachable_code)] +#![feature(never_type, type_ascription)] + +fn a() { + // the cast is unreachable: + let x = {return} as !; //~ ERROR unreachable + //~| ERROR non-primitive cast +} + +fn main() { } diff --git a/tests/ui/reachable/expr_cast.stderr b/tests/ui/reachable/expr_cast.stderr new file mode 100644 index 000000000..6643f1784 --- /dev/null +++ b/tests/ui/reachable/expr_cast.stderr @@ -0,0 +1,24 @@ +error: unreachable expression + --> $DIR/expr_cast.rs:9:13 + | +LL | let x = {return} as !; + | ^------^^^^^^ + | || + | |any code following this expression is unreachable + | unreachable expression + | +note: the lint level is defined here + --> $DIR/expr_cast.rs:4:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error[E0605]: non-primitive cast: `()` as `!` + --> $DIR/expr_cast.rs:9:13 + | +LL | let x = {return} as !; + | ^^^^^^^^^^^^^ an `as` expression can only be used to convert between primitive types or to coerce to a specific trait object + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0605`. diff --git a/tests/ui/reachable/expr_if.rs b/tests/ui/reachable/expr_if.rs new file mode 100644 index 000000000..3c04eaf48 --- /dev/null +++ b/tests/ui/reachable/expr_if.rs @@ -0,0 +1,31 @@ +#![allow(unused_variables)] +#![allow(unused_assignments)] +#![allow(dead_code)] +#![deny(unreachable_code)] + +fn foo() { + if {return} { //~ ERROR unreachable block in `if` + println!("Hello, world!"); + } +} + +fn bar() { + if {true} { + return; + } + println!("I am not dead."); +} + +fn baz() { + if {true} { + return; + } else { + return; + } + // As the next action to be taken after the if arms, we should + // report the `println!` as unreachable: + println!("But I am."); + //~^ ERROR unreachable statement +} + +fn main() { } diff --git a/tests/ui/reachable/expr_if.stderr b/tests/ui/reachable/expr_if.stderr new file mode 100644 index 000000000..ebd0b5a3e --- /dev/null +++ b/tests/ui/reachable/expr_if.stderr @@ -0,0 +1,30 @@ +error: unreachable block in `if` or `while` expression + --> $DIR/expr_if.rs:7:17 + | +LL | if {return} { + | _________------__^ + | | | + | | any code following this expression is unreachable +LL | | println!("Hello, world!"); +LL | | } + | |_____^ unreachable block in `if` or `while` expression + | +note: the lint level is defined here + --> $DIR/expr_if.rs:4:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error: unreachable statement + --> $DIR/expr_if.rs:27:5 + | +LL | return; + | ------ any code following this expression is unreachable +... +LL | println!("But I am."); + | ^^^^^^^^^^^^^^^^^^^^^ unreachable statement + | + = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: aborting due to 2 previous errors + diff --git a/tests/ui/reachable/expr_loop.rs b/tests/ui/reachable/expr_loop.rs new file mode 100644 index 000000000..7eab6f7bb --- /dev/null +++ b/tests/ui/reachable/expr_loop.rs @@ -0,0 +1,36 @@ +#![allow(unused_variables)] +#![allow(unused_assignments)] +#![allow(dead_code)] +#![deny(unreachable_code)] + +fn a() { + loop { return; } + println!("I am dead."); + //~^ ERROR unreachable statement +} + +fn b() { + loop { + break; + } + println!("I am not dead."); +} + +fn c() { + loop { return; } + println!("I am dead."); + //~^ ERROR unreachable statement +} + +fn d() { + 'outer: loop { loop { break 'outer; } } + println!("I am not dead."); +} + +fn e() { + loop { 'middle: loop { loop { break 'middle; } } } + println!("I am dead."); + //~^ ERROR unreachable statement +} + +fn main() { } diff --git a/tests/ui/reachable/expr_loop.stderr b/tests/ui/reachable/expr_loop.stderr new file mode 100644 index 000000000..918584686 --- /dev/null +++ b/tests/ui/reachable/expr_loop.stderr @@ -0,0 +1,37 @@ +error: unreachable statement + --> $DIR/expr_loop.rs:8:5 + | +LL | loop { return; } + | ------ any code following this expression is unreachable +LL | println!("I am dead."); + | ^^^^^^^^^^^^^^^^^^^^^^ unreachable statement + | +note: the lint level is defined here + --> $DIR/expr_loop.rs:4:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: unreachable statement + --> $DIR/expr_loop.rs:21:5 + | +LL | loop { return; } + | ------ any code following this expression is unreachable +LL | println!("I am dead."); + | ^^^^^^^^^^^^^^^^^^^^^^ unreachable statement + | + = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: unreachable statement + --> $DIR/expr_loop.rs:32:5 + | +LL | loop { 'middle: loop { loop { break 'middle; } } } + | -------------------------------------------------- any code following this expression is unreachable +LL | println!("I am dead."); + | ^^^^^^^^^^^^^^^^^^^^^^ unreachable statement + | + = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: aborting due to 3 previous errors + diff --git a/tests/ui/reachable/expr_match.rs b/tests/ui/reachable/expr_match.rs new file mode 100644 index 000000000..2fd26b54e --- /dev/null +++ b/tests/ui/reachable/expr_match.rs @@ -0,0 +1,39 @@ +#![allow(unused_variables)] +#![allow(unused_assignments)] +#![allow(dead_code)] +#![deny(unreachable_code)] + +fn b() { + match () { () => return } + println!("I am dead"); + //~^ ERROR unreachable statement +} + +fn c() { + match () { () if false => return, () => () } + println!("I am not dead"); +} + +fn d() { + match () { () if false => return, () => return } + println!("I am dead"); + //~^ ERROR unreachable statement +} + +fn e() { + // Here the compiler fails to figure out that the `println` is dead. + match () { () if return => (), () => return } + println!("I am dead"); +} + +fn f() { + match Some(()) { None => (), Some(()) => return } + println!("I am not dead"); +} + +fn g() { + match Some(()) { None => return, Some(()) => () } + println!("I am not dead"); +} + +fn main() { } diff --git a/tests/ui/reachable/expr_match.stderr b/tests/ui/reachable/expr_match.stderr new file mode 100644 index 000000000..d15208609 --- /dev/null +++ b/tests/ui/reachable/expr_match.stderr @@ -0,0 +1,27 @@ +error: unreachable statement + --> $DIR/expr_match.rs:8:5 + | +LL | match () { () => return } + | ------------------------- any code following this `match` expression is unreachable, as all arms diverge +LL | println!("I am dead"); + | ^^^^^^^^^^^^^^^^^^^^^ unreachable statement + | +note: the lint level is defined here + --> $DIR/expr_match.rs:4:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: unreachable statement + --> $DIR/expr_match.rs:19:5 + | +LL | match () { () if false => return, () => return } + | ------------------------------------------------ any code following this `match` expression is unreachable, as all arms diverge +LL | println!("I am dead"); + | ^^^^^^^^^^^^^^^^^^^^^ unreachable statement + | + = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: aborting due to 2 previous errors + diff --git a/tests/ui/reachable/expr_method.rs b/tests/ui/reachable/expr_method.rs new file mode 100644 index 000000000..d917df05b --- /dev/null +++ b/tests/ui/reachable/expr_method.rs @@ -0,0 +1,24 @@ +#![feature(never_type)] +#![allow(unused_variables)] +#![allow(unused_assignments)] +#![allow(dead_code)] +#![deny(unreachable_code)] + +struct Foo; + +impl Foo { + fn foo(&self, x: !, y: usize) { } + fn bar(&self, x: !) { } +} + +fn a() { + // the `22` is unreachable: + Foo.foo(return, 22); //~ ERROR unreachable +} + +fn b() { + // the call is unreachable: + Foo.bar(return); //~ ERROR unreachable +} + +fn main() { } diff --git a/tests/ui/reachable/expr_method.stderr b/tests/ui/reachable/expr_method.stderr new file mode 100644 index 000000000..41c3b8a39 --- /dev/null +++ b/tests/ui/reachable/expr_method.stderr @@ -0,0 +1,24 @@ +error: unreachable expression + --> $DIR/expr_method.rs:16:21 + | +LL | Foo.foo(return, 22); + | ------ ^^ unreachable expression + | | + | any code following this expression is unreachable + | +note: the lint level is defined here + --> $DIR/expr_method.rs:5:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error: unreachable call + --> $DIR/expr_method.rs:21:9 + | +LL | Foo.bar(return); + | ^^^ ------ any code following this expression is unreachable + | | + | unreachable call + +error: aborting due to 2 previous errors + diff --git a/tests/ui/reachable/expr_oror.rs b/tests/ui/reachable/expr_oror.rs new file mode 100644 index 000000000..e95062de4 --- /dev/null +++ b/tests/ui/reachable/expr_oror.rs @@ -0,0 +1,12 @@ +// build-pass (FIXME(62277): could be check-pass?) + +#![allow(unused_variables)] +#![allow(dead_code)] +#![deny(unreachable_code)] + +fn foo() { + let x = false || (return); + println!("I am not dead."); +} + +fn main() { } diff --git a/tests/ui/reachable/expr_repeat.rs b/tests/ui/reachable/expr_repeat.rs new file mode 100644 index 000000000..0fd13c6cb --- /dev/null +++ b/tests/ui/reachable/expr_repeat.rs @@ -0,0 +1,12 @@ +#![allow(unused_variables)] +#![allow(unused_assignments)] +#![allow(dead_code)] +#![deny(unreachable_code)] +#![feature(type_ascription)] + +fn a() { + // the repeat is unreachable: + let x: [usize; 2] = [return; 2]; //~ ERROR unreachable +} + +fn main() { } diff --git a/tests/ui/reachable/expr_repeat.stderr b/tests/ui/reachable/expr_repeat.stderr new file mode 100644 index 000000000..defa87046 --- /dev/null +++ b/tests/ui/reachable/expr_repeat.stderr @@ -0,0 +1,17 @@ +error: unreachable expression + --> $DIR/expr_repeat.rs:9:25 + | +LL | let x: [usize; 2] = [return; 2]; + | ^------^^^^ + | || + | |any code following this expression is unreachable + | unreachable expression + | +note: the lint level is defined here + --> $DIR/expr_repeat.rs:4:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + diff --git a/tests/ui/reachable/expr_return.rs b/tests/ui/reachable/expr_return.rs new file mode 100644 index 000000000..0fc43f450 --- /dev/null +++ b/tests/ui/reachable/expr_return.rs @@ -0,0 +1,13 @@ +#![allow(unused_variables)] +#![allow(unused_assignments)] +#![allow(dead_code)] +#![deny(unreachable_code)] +#![feature(type_ascription)] + +fn a() { + // Here we issue that the "2nd-innermost" return is unreachable, + // but we stop there. + let x = {return {return {return;}}}; //~ ERROR unreachable +} + +fn main() { } diff --git a/tests/ui/reachable/expr_return.stderr b/tests/ui/reachable/expr_return.stderr new file mode 100644 index 000000000..e1bef80ae --- /dev/null +++ b/tests/ui/reachable/expr_return.stderr @@ -0,0 +1,17 @@ +error: unreachable expression + --> $DIR/expr_return.rs:10:22 + | +LL | let x = {return {return {return;}}}; + | ^^^^^^^^------^^ + | | | + | | any code following this expression is unreachable + | unreachable expression + | +note: the lint level is defined here + --> $DIR/expr_return.rs:4:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + diff --git a/tests/ui/reachable/expr_return_in_macro.rs b/tests/ui/reachable/expr_return_in_macro.rs new file mode 100644 index 000000000..4e57618bf --- /dev/null +++ b/tests/ui/reachable/expr_return_in_macro.rs @@ -0,0 +1,15 @@ +// Tests that we generate nice error messages +// when an expression is unreachble due to control +// flow inside of a macro expansion. +#![deny(unreachable_code)] + +macro_rules! early_return { + () => { + return () + } +} + +fn main() { + return early_return!(); + //~^ ERROR unreachable expression +} diff --git a/tests/ui/reachable/expr_return_in_macro.stderr b/tests/ui/reachable/expr_return_in_macro.stderr new file mode 100644 index 000000000..3c562a7ee --- /dev/null +++ b/tests/ui/reachable/expr_return_in_macro.stderr @@ -0,0 +1,17 @@ +error: unreachable expression + --> $DIR/expr_return_in_macro.rs:13:5 + | +LL | return () + | --------- any code following this expression is unreachable +... +LL | return early_return!(); + | ^^^^^^^^^^^^^^^^^^^^^^ unreachable expression + | +note: the lint level is defined here + --> $DIR/expr_return_in_macro.rs:4:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + diff --git a/tests/ui/reachable/expr_struct.rs b/tests/ui/reachable/expr_struct.rs new file mode 100644 index 000000000..31ab40582 --- /dev/null +++ b/tests/ui/reachable/expr_struct.rs @@ -0,0 +1,32 @@ +#![allow(unused_variables)] +#![allow(unused_assignments)] +#![allow(dead_code)] +#![deny(unreachable_code)] +#![feature(type_ascription)] + +struct Foo { + a: usize, + b: usize, +} + +fn a() { + // struct expr is unreachable: + let x = Foo { a: 22, b: 33, ..return }; //~ ERROR unreachable +} + +fn b() { + // the `33` is unreachable: + let x = Foo { a: return, b: 33, ..return }; //~ ERROR unreachable +} + +fn c() { + // the `..return` is unreachable: + let x = Foo { a: 22, b: return, ..return }; //~ ERROR unreachable +} + +fn d() { + // the struct expr is unreachable: + let x = Foo { a: 22, b: return }; //~ ERROR unreachable +} + +fn main() { } diff --git a/tests/ui/reachable/expr_struct.stderr b/tests/ui/reachable/expr_struct.stderr new file mode 100644 index 000000000..36b070456 --- /dev/null +++ b/tests/ui/reachable/expr_struct.stderr @@ -0,0 +1,42 @@ +error: unreachable expression + --> $DIR/expr_struct.rs:14:13 + | +LL | let x = Foo { a: 22, b: 33, ..return }; + | ^^^^^^^^^^^^^^^^^^^^^^------^^ + | | | + | | any code following this expression is unreachable + | unreachable expression + | +note: the lint level is defined here + --> $DIR/expr_struct.rs:4:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error: unreachable expression + --> $DIR/expr_struct.rs:19:33 + | +LL | let x = Foo { a: return, b: 33, ..return }; + | ------ ^^ unreachable expression + | | + | any code following this expression is unreachable + +error: unreachable expression + --> $DIR/expr_struct.rs:24:39 + | +LL | let x = Foo { a: 22, b: return, ..return }; + | ------ ^^^^^^ unreachable expression + | | + | any code following this expression is unreachable + +error: unreachable expression + --> $DIR/expr_struct.rs:29:13 + | +LL | let x = Foo { a: 22, b: return }; + | ^^^^^^^^^^^^^^^^------^^ + | | | + | | any code following this expression is unreachable + | unreachable expression + +error: aborting due to 4 previous errors + diff --git a/tests/ui/reachable/expr_tup.rs b/tests/ui/reachable/expr_tup.rs new file mode 100644 index 000000000..90d4382e2 --- /dev/null +++ b/tests/ui/reachable/expr_tup.rs @@ -0,0 +1,17 @@ +#![allow(unused_variables)] +#![allow(unused_assignments)] +#![allow(dead_code)] +#![deny(unreachable_code)] +#![feature(type_ascription)] + +fn a() { + // the `2` is unreachable: + let x: (usize, usize) = (return, 2); //~ ERROR unreachable +} + +fn b() { + // the tuple is unreachable: + let x: (usize, usize) = (2, return); //~ ERROR unreachable +} + +fn main() { } diff --git a/tests/ui/reachable/expr_tup.stderr b/tests/ui/reachable/expr_tup.stderr new file mode 100644 index 000000000..5ea6bf4ab --- /dev/null +++ b/tests/ui/reachable/expr_tup.stderr @@ -0,0 +1,25 @@ +error: unreachable expression + --> $DIR/expr_tup.rs:9:38 + | +LL | let x: (usize, usize) = (return, 2); + | ------ ^ unreachable expression + | | + | any code following this expression is unreachable + | +note: the lint level is defined here + --> $DIR/expr_tup.rs:4:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error: unreachable expression + --> $DIR/expr_tup.rs:14:29 + | +LL | let x: (usize, usize) = (2, return); + | ^^^^------^ + | | | + | | any code following this expression is unreachable + | unreachable expression + +error: aborting due to 2 previous errors + diff --git a/tests/ui/reachable/expr_type.rs b/tests/ui/reachable/expr_type.rs new file mode 100644 index 000000000..1ceb2f859 --- /dev/null +++ b/tests/ui/reachable/expr_type.rs @@ -0,0 +1,12 @@ +#![allow(unused_variables)] +#![allow(unused_assignments)] +#![allow(dead_code)] +#![deny(unreachable_code)] +#![feature(never_type, type_ascription)] + +fn a() { + // the cast is unreachable: + let x = type_ascribe!({return}, !); //~ ERROR unreachable +} + +fn main() { } diff --git a/tests/ui/reachable/expr_type.stderr b/tests/ui/reachable/expr_type.stderr new file mode 100644 index 000000000..3cb4a32e0 --- /dev/null +++ b/tests/ui/reachable/expr_type.stderr @@ -0,0 +1,17 @@ +error: unreachable expression + --> $DIR/expr_type.rs:9:13 + | +LL | let x = type_ascribe!({return}, !); + | ^^^^^^^^^^^^^^^------^^^^^ + | | | + | | any code following this expression is unreachable + | unreachable expression + | +note: the lint level is defined here + --> $DIR/expr_type.rs:4:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + diff --git a/tests/ui/reachable/expr_unary.rs b/tests/ui/reachable/expr_unary.rs new file mode 100644 index 000000000..190c7447d --- /dev/null +++ b/tests/ui/reachable/expr_unary.rs @@ -0,0 +1,12 @@ +#![feature(never_type)] +#![allow(unused_variables)] +#![allow(unused_assignments)] +#![allow(dead_code)] +#![deny(unreachable_code)] + +fn foo() { + let x: ! = * { return; }; //~ ERROR unreachable + //~| ERROR type `!` cannot be dereferenced +} + +fn main() { } diff --git a/tests/ui/reachable/expr_unary.stderr b/tests/ui/reachable/expr_unary.stderr new file mode 100644 index 000000000..0a763087c --- /dev/null +++ b/tests/ui/reachable/expr_unary.stderr @@ -0,0 +1,24 @@ +error[E0614]: type `!` cannot be dereferenced + --> $DIR/expr_unary.rs:8:16 + | +LL | let x: ! = * { return; }; + | ^^^^^^^^^^^^^ + +error: unreachable expression + --> $DIR/expr_unary.rs:8:16 + | +LL | let x: ! = * { return; }; + | ^^^^------^^^ + | | | + | | any code following this expression is unreachable + | unreachable expression + | +note: the lint level is defined here + --> $DIR/expr_unary.rs:5:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0614`. diff --git a/tests/ui/reachable/expr_while.rs b/tests/ui/reachable/expr_while.rs new file mode 100644 index 000000000..5005f3833 --- /dev/null +++ b/tests/ui/reachable/expr_while.rs @@ -0,0 +1,29 @@ +#![allow(unused_variables)] +#![allow(unused_assignments)] +#![allow(dead_code)] +#![deny(unreachable_code)] + +fn foo() { + while {return} { + //~^ ERROR unreachable block in `if` + println!("Hello, world!"); + } +} + +fn bar() { + while {true} { + return; + } + println!("I am not dead."); +} + +fn baz() { + // Here, we cite the `while` loop as dead. + while {return} { + //~^ ERROR unreachable block in `if` + println!("I am dead."); + } + println!("I am, too."); +} + +fn main() { } diff --git a/tests/ui/reachable/expr_while.stderr b/tests/ui/reachable/expr_while.stderr new file mode 100644 index 000000000..b1859f619 --- /dev/null +++ b/tests/ui/reachable/expr_while.stderr @@ -0,0 +1,32 @@ +error: unreachable block in `if` or `while` expression + --> $DIR/expr_while.rs:7:20 + | +LL | while {return} { + | ____________------__^ + | | | + | | any code following this expression is unreachable +LL | | +LL | | println!("Hello, world!"); +LL | | } + | |_____^ unreachable block in `if` or `while` expression + | +note: the lint level is defined here + --> $DIR/expr_while.rs:4:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error: unreachable block in `if` or `while` expression + --> $DIR/expr_while.rs:22:20 + | +LL | while {return} { + | ____________------__^ + | | | + | | any code following this expression is unreachable +LL | | +LL | | println!("I am dead."); +LL | | } + | |_____^ unreachable block in `if` or `while` expression + +error: aborting due to 2 previous errors + diff --git a/tests/ui/reachable/issue-11225-1.rs b/tests/ui/reachable/issue-11225-1.rs new file mode 100644 index 000000000..d1f2ea5e7 --- /dev/null +++ b/tests/ui/reachable/issue-11225-1.rs @@ -0,0 +1,11 @@ +// run-pass +// aux-build:issue-11225-1.rs + +// pretty-expanded FIXME #23616 + +extern crate issue_11225_1 as foo; + +pub fn main() { + foo::foo(1); + foo::foo_ufcs(1); +} diff --git a/tests/ui/reachable/issue-11225-2.rs b/tests/ui/reachable/issue-11225-2.rs new file mode 100644 index 000000000..d41c75443 --- /dev/null +++ b/tests/ui/reachable/issue-11225-2.rs @@ -0,0 +1,11 @@ +// run-pass +// aux-build:issue-11225-2.rs + +// pretty-expanded FIXME #23616 + +extern crate issue_11225_2 as foo; + +pub fn main() { + foo::foo(1); + foo::foo_ufcs(1); +} diff --git a/tests/ui/reachable/issue-11225-3.rs b/tests/ui/reachable/issue-11225-3.rs new file mode 100644 index 000000000..e69496baa --- /dev/null +++ b/tests/ui/reachable/issue-11225-3.rs @@ -0,0 +1,11 @@ +// run-pass +// aux-build:issue-11225-3.rs + +// pretty-expanded FIXME #23616 + +extern crate issue_11225_3; + +pub fn main() { + issue_11225_3::public_inlinable_function(); + issue_11225_3::public_inlinable_function_ufcs(); +} diff --git a/tests/ui/reachable/unreachable-arm.rs b/tests/ui/reachable/unreachable-arm.rs new file mode 100644 index 000000000..3277bf0d5 --- /dev/null +++ b/tests/ui/reachable/unreachable-arm.rs @@ -0,0 +1,14 @@ +#![feature(box_patterns)] + +#![allow(dead_code)] +#![deny(unreachable_patterns)] + +enum Foo { A(Box<Foo>, isize), B(usize), } + +fn main() { + match Foo::B(1) { + Foo::B(_) | Foo::A(box _, 1) => { } + Foo::A(_, 1) => { } //~ ERROR unreachable pattern + _ => { } + } +} diff --git a/tests/ui/reachable/unreachable-arm.stderr b/tests/ui/reachable/unreachable-arm.stderr new file mode 100644 index 000000000..1cbea8288 --- /dev/null +++ b/tests/ui/reachable/unreachable-arm.stderr @@ -0,0 +1,14 @@ +error: unreachable pattern + --> $DIR/unreachable-arm.rs:11:9 + | +LL | Foo::A(_, 1) => { } + | ^^^^^^^^^^^^ + | +note: the lint level is defined here + --> $DIR/unreachable-arm.rs:4:9 + | +LL | #![deny(unreachable_patterns)] + | ^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + diff --git a/tests/ui/reachable/unreachable-code-ret.rs b/tests/ui/reachable/unreachable-code-ret.rs new file mode 100644 index 000000000..fad35794f --- /dev/null +++ b/tests/ui/reachable/unreachable-code-ret.rs @@ -0,0 +1,8 @@ +// error-pattern: unreachable statement + +#![deny(unreachable_code)] + +fn main() { + return; + println!("Paul is dead"); +} diff --git a/tests/ui/reachable/unreachable-code-ret.stderr b/tests/ui/reachable/unreachable-code-ret.stderr new file mode 100644 index 000000000..263a1b5a9 --- /dev/null +++ b/tests/ui/reachable/unreachable-code-ret.stderr @@ -0,0 +1,17 @@ +error: unreachable statement + --> $DIR/unreachable-code-ret.rs:7:5 + | +LL | return; + | ------ any code following this expression is unreachable +LL | println!("Paul is dead"); + | ^^^^^^^^^^^^^^^^^^^^^^^^ unreachable statement + | +note: the lint level is defined here + --> $DIR/unreachable-code-ret.rs:3:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info) + +error: aborting due to previous error + diff --git a/tests/ui/reachable/unreachable-code.rs b/tests/ui/reachable/unreachable-code.rs new file mode 100644 index 000000000..ad0dc8a8b --- /dev/null +++ b/tests/ui/reachable/unreachable-code.rs @@ -0,0 +1,8 @@ +#![deny(unreachable_code)] +#![allow(unused_variables)] + +fn main() { + loop{} + + let a = 3; //~ ERROR: unreachable statement +} diff --git a/tests/ui/reachable/unreachable-code.stderr b/tests/ui/reachable/unreachable-code.stderr new file mode 100644 index 000000000..cb1b760c2 --- /dev/null +++ b/tests/ui/reachable/unreachable-code.stderr @@ -0,0 +1,17 @@ +error: unreachable statement + --> $DIR/unreachable-code.rs:7:3 + | +LL | loop{} + | ------ any code following this expression is unreachable +LL | +LL | let a = 3; + | ^^^^^^^^^^ unreachable statement + | +note: the lint level is defined here + --> $DIR/unreachable-code.rs:1:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + diff --git a/tests/ui/reachable/unreachable-in-call.rs b/tests/ui/reachable/unreachable-in-call.rs new file mode 100644 index 000000000..dd94e79f4 --- /dev/null +++ b/tests/ui/reachable/unreachable-in-call.rs @@ -0,0 +1,22 @@ +#![allow(dead_code)] +#![deny(unreachable_code)] + +fn diverge() -> ! { panic!() } + +fn get_u8() -> u8 { + 1 +} +fn call(_: u8, _: u8) { + +} +fn diverge_first() { + call(diverge(), + get_u8()); //~ ERROR unreachable expression +} +fn diverge_second() { + call( //~ ERROR unreachable call + get_u8(), + diverge()); +} + +fn main() {} diff --git a/tests/ui/reachable/unreachable-in-call.stderr b/tests/ui/reachable/unreachable-in-call.stderr new file mode 100644 index 000000000..cdfa79bf8 --- /dev/null +++ b/tests/ui/reachable/unreachable-in-call.stderr @@ -0,0 +1,25 @@ +error: unreachable expression + --> $DIR/unreachable-in-call.rs:14:10 + | +LL | call(diverge(), + | --------- any code following this expression is unreachable +LL | get_u8()); + | ^^^^^^^^ unreachable expression + | +note: the lint level is defined here + --> $DIR/unreachable-in-call.rs:2:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error: unreachable call + --> $DIR/unreachable-in-call.rs:17:5 + | +LL | call( + | ^^^^ unreachable call +LL | get_u8(), +LL | diverge()); + | --------- any code following this expression is unreachable + +error: aborting due to 2 previous errors + diff --git a/tests/ui/reachable/unreachable-loop-patterns.rs b/tests/ui/reachable/unreachable-loop-patterns.rs new file mode 100644 index 000000000..e9cef5f47 --- /dev/null +++ b/tests/ui/reachable/unreachable-loop-patterns.rs @@ -0,0 +1,20 @@ +#![feature(never_type, never_type_fallback)] +#![feature(exhaustive_patterns)] + +#![allow(unreachable_code)] +#![deny(unreachable_patterns)] + +enum Void {} + +impl Iterator for Void { + type Item = Void; + + fn next(&mut self) -> Option<Void> { + None + } +} + +fn main() { + for _ in unimplemented!() as Void {} + //~^ ERROR unreachable pattern +} diff --git a/tests/ui/reachable/unreachable-loop-patterns.stderr b/tests/ui/reachable/unreachable-loop-patterns.stderr new file mode 100644 index 000000000..80ffa5d73 --- /dev/null +++ b/tests/ui/reachable/unreachable-loop-patterns.stderr @@ -0,0 +1,14 @@ +error: unreachable pattern + --> $DIR/unreachable-loop-patterns.rs:18:9 + | +LL | for _ in unimplemented!() as Void {} + | ^ + | +note: the lint level is defined here + --> $DIR/unreachable-loop-patterns.rs:5:9 + | +LL | #![deny(unreachable_patterns)] + | ^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + diff --git a/tests/ui/reachable/unreachable-try-pattern.rs b/tests/ui/reachable/unreachable-try-pattern.rs new file mode 100644 index 000000000..23360e73f --- /dev/null +++ b/tests/ui/reachable/unreachable-try-pattern.rs @@ -0,0 +1,41 @@ +// check-pass +#![feature(never_type, exhaustive_patterns)] +#![warn(unreachable_code)] +#![warn(unreachable_patterns)] + +enum Void {} + +impl From<Void> for i32 { + fn from(v: Void) -> i32 { + match v {} + } +} + +fn bar(x: Result<!, i32>) -> Result<u32, i32> { + x? +} + +fn foo(x: Result<!, i32>) -> Result<u32, i32> { + let y = (match x { Ok(n) => Ok(n as u32), Err(e) => Err(e) })?; + //~^ WARN unreachable pattern + //~| WARN unreachable expression + Ok(y) +} + +fn qux(x: Result<u32, Void>) -> Result<u32, i32> { + Ok(x?) +} + +fn vom(x: Result<u32, Void>) -> Result<u32, i32> { + let y = (match x { Ok(n) => Ok(n), Err(e) => Err(e) })?; + //~^ WARN unreachable pattern + Ok(y) +} + + +fn main() { + let _ = bar(Err(123)); + let _ = foo(Err(123)); + let _ = qux(Ok(123)); + let _ = vom(Ok(123)); +} diff --git a/tests/ui/reachable/unreachable-try-pattern.stderr b/tests/ui/reachable/unreachable-try-pattern.stderr new file mode 100644 index 000000000..8f3e23119 --- /dev/null +++ b/tests/ui/reachable/unreachable-try-pattern.stderr @@ -0,0 +1,35 @@ +warning: unreachable expression + --> $DIR/unreachable-try-pattern.rs:19:36 + | +LL | let y = (match x { Ok(n) => Ok(n as u32), Err(e) => Err(e) })?; + | -^^^^^^^ + | | + | unreachable expression + | any code following this expression is unreachable + | +note: the lint level is defined here + --> $DIR/unreachable-try-pattern.rs:3:9 + | +LL | #![warn(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +warning: unreachable pattern + --> $DIR/unreachable-try-pattern.rs:19:24 + | +LL | let y = (match x { Ok(n) => Ok(n as u32), Err(e) => Err(e) })?; + | ^^^^^ + | +note: the lint level is defined here + --> $DIR/unreachable-try-pattern.rs:4:9 + | +LL | #![warn(unreachable_patterns)] + | ^^^^^^^^^^^^^^^^^^^^ + +warning: unreachable pattern + --> $DIR/unreachable-try-pattern.rs:30:40 + | +LL | let y = (match x { Ok(n) => Ok(n), Err(e) => Err(e) })?; + | ^^^^^^ + +warning: 3 warnings emitted + diff --git a/tests/ui/reachable/unreachable-variant.rs b/tests/ui/reachable/unreachable-variant.rs new file mode 100644 index 000000000..008c2d476 --- /dev/null +++ b/tests/ui/reachable/unreachable-variant.rs @@ -0,0 +1,7 @@ +// aux-build:unreachable_variant.rs + +extern crate unreachable_variant as other; + +fn main() { + let _x = other::super_sekrit::sooper_sekrit::baz; //~ ERROR is private +} diff --git a/tests/ui/reachable/unreachable-variant.stderr b/tests/ui/reachable/unreachable-variant.stderr new file mode 100644 index 000000000..6c27a2756 --- /dev/null +++ b/tests/ui/reachable/unreachable-variant.stderr @@ -0,0 +1,15 @@ +error[E0603]: module `super_sekrit` is private + --> $DIR/unreachable-variant.rs:6:21 + | +LL | let _x = other::super_sekrit::sooper_sekrit::baz; + | ^^^^^^^^^^^^ private module + | +note: the module `super_sekrit` is defined here + --> $DIR/auxiliary/unreachable_variant.rs:1:1 + | +LL | mod super_sekrit { + | ^^^^^^^^^^^^^^^^ + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0603`. diff --git a/tests/ui/reachable/unwarned-match-on-never.rs b/tests/ui/reachable/unwarned-match-on-never.rs new file mode 100644 index 000000000..71f8fe3a7 --- /dev/null +++ b/tests/ui/reachable/unwarned-match-on-never.rs @@ -0,0 +1,24 @@ +#![deny(unreachable_code)] +#![allow(dead_code)] + +#![feature(never_type)] + +fn foo(x: !) -> bool { + // Explicit matches on the never type are unwarned. + match x {} + // But matches in unreachable code are warned. + match x {} //~ ERROR unreachable expression +} + +fn bar() { + match (return) { + () => () //~ ERROR unreachable arm + } +} + +fn main() { + return; + match () { //~ ERROR unreachable expression + () => (), + } +} diff --git a/tests/ui/reachable/unwarned-match-on-never.stderr b/tests/ui/reachable/unwarned-match-on-never.stderr new file mode 100644 index 000000000..a296d2a05 --- /dev/null +++ b/tests/ui/reachable/unwarned-match-on-never.stderr @@ -0,0 +1,35 @@ +error: unreachable expression + --> $DIR/unwarned-match-on-never.rs:10:5 + | +LL | match x {} + | - any code following this expression is unreachable +LL | // But matches in unreachable code are warned. +LL | match x {} + | ^^^^^^^^^^ unreachable expression + | +note: the lint level is defined here + --> $DIR/unwarned-match-on-never.rs:1:9 + | +LL | #![deny(unreachable_code)] + | ^^^^^^^^^^^^^^^^ + +error: unreachable arm + --> $DIR/unwarned-match-on-never.rs:15:15 + | +LL | match (return) { + | -------- any code following this expression is unreachable +LL | () => () + | ^^ unreachable arm + +error: unreachable expression + --> $DIR/unwarned-match-on-never.rs:21:5 + | +LL | return; + | ------ any code following this expression is unreachable +LL | / match () { +LL | | () => (), +LL | | } + | |_____^ unreachable expression + +error: aborting due to 3 previous errors + |