mirror of
https://github.com/rust-lang/rust
synced 2024-09-15 22:50:55 +00:00
Adjust UI tests for unit_bindings
- Either explicitly annotate `let x: () = expr;` where `x` has unit type, or remove the unit binding to leave only `expr;` instead. - Fix disjoint-capture-in-same-closure test
This commit is contained in:
许杰友 Jieyou Xu (Joe)
parent
37998ab508
commit
edafbaffb2
|
|
@ -6,7 +6,7 @@ fn test_assign() {
|
|||
let y: () = x = 10;
|
||||
assert_eq!(x, 10);
|
||||
assert_eq!(y, ());
|
||||
let mut z = x = 11;
|
||||
let mut z: () = x = 11;
|
||||
assert_eq!(x, 11);
|
||||
assert_eq!(z, ());
|
||||
z = x = 12;
|
||||
|
|
@ -19,7 +19,7 @@ fn test_assign_op() {
|
|||
let y: () = x += 10;
|
||||
assert_eq!(x, 10);
|
||||
assert_eq!(y, ());
|
||||
let mut z = x += 11;
|
||||
let mut z: () = x += 11;
|
||||
assert_eq!(x, 21);
|
||||
assert_eq!(z, ());
|
||||
z = x += 12;
|
||||
|
|
|
|||
|
|
@ -59,8 +59,8 @@ fn tr2(self) -> &'a Self { &A }
|
|||
pub fn use_et4() { assert_forall_tr2(def_et4().mk()); }
|
||||
|
||||
fn main() {
|
||||
let _ = use_et1();
|
||||
let _ = use_et2();
|
||||
let _ = use_et3();
|
||||
let _ = use_et4();
|
||||
use_et1();
|
||||
use_et2();
|
||||
use_et3();
|
||||
use_et4();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -66,8 +66,8 @@ fn tr2(self) -> &'a Self { &A }
|
|||
pub fn use_et4() { assert_forall_tr2(def_et4().mk()); }
|
||||
|
||||
fn main() {
|
||||
let _ = use_et1();
|
||||
let _ = use_et2();
|
||||
let _ = use_et3();
|
||||
let _ = use_et4();
|
||||
use_et1();
|
||||
use_et2();
|
||||
use_et3();
|
||||
use_et4();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -57,8 +57,8 @@ fn tr2(self) -> &'a Self { &A }
|
|||
pub fn use_et4() { assert_forall_tr2(def_et4().mk()); }
|
||||
|
||||
fn main() {
|
||||
let _ = use_et1();
|
||||
let _ = use_et2();
|
||||
let _ = use_et3();
|
||||
let _ = use_et4();
|
||||
use_et1();
|
||||
use_et2();
|
||||
use_et3();
|
||||
use_et4();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -89,8 +89,8 @@ pub fn use_et4() {
|
|||
}
|
||||
|
||||
fn main() {
|
||||
let _ = use_et1();
|
||||
let _ = use_et2();
|
||||
let _ = use_et3();
|
||||
let _ = use_et4();
|
||||
use_et1();
|
||||
use_et2();
|
||||
use_et3();
|
||||
use_et4();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,10 +6,10 @@
|
|||
|
||||
use std::future::{Future, Ready};
|
||||
async fn read() {
|
||||
let _ = connect(&()).await;
|
||||
connect(&()).await;
|
||||
}
|
||||
async fn connect<A: ToSocketAddr>(addr: A) {
|
||||
let _ = addr.to_socket_addr().await;
|
||||
addr.to_socket_addr().await;
|
||||
}
|
||||
pub trait ToSocketAddr {
|
||||
type Future: Future<Output = ()>;
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ async fn handle(&mut self) {
|
|||
let mut info = self.info_result.clone();
|
||||
info.node = Some("bar".into());
|
||||
let element = parse_info(info);
|
||||
let _ = send_element(element).await;
|
||||
send_element(element).await;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ async fn handle(&mut self) {
|
|||
let mut info = self.info_result.clone();
|
||||
info.node = Some("bar".into());
|
||||
let element = parse_info(info);
|
||||
let _ = send_element(element).await;
|
||||
send_element(element).await;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -6,13 +6,13 @@ LL | pub fn foo() -> impl Future + Send {
|
|||
|
|
||||
= help: the trait `Sync` is not implemented for `(dyn Any + Send + 'static)`
|
||||
note: future is not `Send` as this value is used across an await
|
||||
--> $DIR/issue-64130-4-async-move.rs:27:32
|
||||
--> $DIR/issue-64130-4-async-move.rs:27:23
|
||||
|
|
||||
LL | match client.status() {
|
||||
| ------ has type `&Client` which is not `Send`
|
||||
LL | 200 => {
|
||||
LL | let _x = get().await;
|
||||
| ^^^^^ await occurs here, with `client` maybe used later
|
||||
LL | get().await;
|
||||
| ^^^^^ await occurs here, with `client` maybe used later
|
||||
...
|
||||
LL | }
|
||||
| - `client` is later dropped here
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ pub fn foo() -> impl Future + Send {
|
|||
async move {
|
||||
match client.status() {
|
||||
200 => {
|
||||
let _x = get().await;
|
||||
get().await;
|
||||
}
|
||||
_ => (),
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
#![feature(generators)]
|
||||
|
||||
fn main() {
|
||||
let _ = foo();
|
||||
foo();
|
||||
}
|
||||
|
||||
fn foo() {
|
||||
|
|
|
|||
|
|
@ -81,7 +81,7 @@ macro_rules! if_cfg {
|
|||
// check that lints work
|
||||
|
||||
#[allow(non_snake_case)]
|
||||
let FOOBAR = {
|
||||
let FOOBAR: () = {
|
||||
fn SYLADEX() {}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ struct Struct {
|
|||
fn main() {
|
||||
let mut s = Struct { x: 10, y: 10, s: String::new() };
|
||||
|
||||
let mut c = {
|
||||
let mut c = || {
|
||||
s.x += 10;
|
||||
s.y += 42;
|
||||
s.s = String::from("new");
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
|
||||
fn main() {
|
||||
let x = FooImpl::<BarImpl<1>> { phantom: PhantomData };
|
||||
let _ = x.foo::<BarImpl<1>>();
|
||||
x.foo::<BarImpl<1>>();
|
||||
}
|
||||
|
||||
trait Foo<T>
|
||||
|
|
|
|||
|
|
@ -10,5 +10,5 @@ fn f() {}
|
|||
}
|
||||
|
||||
fn main() {
|
||||
let _err = <S as T<0usize>>::f();
|
||||
<S as T<0usize>>::f();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ trait ZeroSized: Sized {
|
|||
impl<T: Sized> ZeroSized for T {
|
||||
const I_AM_ZERO_SIZED: () = [()][std::mem::size_of::<Self>()]; //~ ERROR evaluation of `<u32 as ZeroSized>::I_AM_ZERO_SIZED` failed
|
||||
fn requires_zero_size(self) {
|
||||
let () = Self::I_AM_ZERO_SIZED;
|
||||
Self::I_AM_ZERO_SIZED;
|
||||
println!("requires_zero_size called");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ const fn no_codegen<T>() {
|
|||
if false {
|
||||
// This bad constant is only used in dead code in a no-codegen function... and yet we still
|
||||
// must make sure that the build fails.
|
||||
let _ = PrintName::<T>::VOID; //~ constant
|
||||
PrintName::<T>::VOID; //~ constant
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -5,10 +5,10 @@ LL | const VOID: () = [()][2];
|
|||
| ^^^^^^^ index out of bounds: the length is 1 but the index is 2
|
||||
|
||||
note: erroneous constant used
|
||||
--> $DIR/erroneous-const.rs:13:17
|
||||
--> $DIR/erroneous-const.rs:13:13
|
||||
|
|
||||
LL | let _ = PrintName::<T>::VOID;
|
||||
| ^^^^^^^^^^^^^^^^^^^^
|
||||
LL | PrintName::<T>::VOID;
|
||||
| ^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: aborting due to previous error
|
||||
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ impl<T> PrintName<T> {
|
|||
if false {
|
||||
// This bad constant is only used in dead code in a static initializer... and yet we still
|
||||
// must make sure that the build fails.
|
||||
let _ = PrintName::<i32>::VOID; //~ constant
|
||||
PrintName::<i32>::VOID; //~ constant
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -5,10 +5,10 @@ LL | const VOID: () = [()][2];
|
|||
| ^^^^^^^ index out of bounds: the length is 1 but the index is 2
|
||||
|
||||
note: erroneous constant used
|
||||
--> $DIR/erroneous-const2.rs:13:17
|
||||
--> $DIR/erroneous-const2.rs:13:9
|
||||
|
|
||||
LL | let _ = PrintName::<i32>::VOID;
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^
|
||||
LL | PrintName::<i32>::VOID;
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: aborting due to previous error
|
||||
|
||||
|
|
|
|||
|
|
@ -48,5 +48,5 @@ const fn mk_false() -> bool { false }
|
|||
};
|
||||
|
||||
fn main() {
|
||||
let _y = Y;
|
||||
Y;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,5 +8,5 @@
|
|||
// Ensure that the CTFE engine handles calls to `extern "C"` aborting gracefully
|
||||
|
||||
fn main() {
|
||||
let _ = foo();
|
||||
foo();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,6 +13,6 @@
|
|||
};
|
||||
|
||||
fn main() {
|
||||
let _ = FOO;
|
||||
let _ = FOO2;
|
||||
FOO;
|
||||
FOO2;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,5 +4,5 @@
|
|||
// pretty-expanded FIXME #23616
|
||||
|
||||
pub fn main() {
|
||||
let x = *Box::new(());
|
||||
let x: () = *Box::new(());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,5 +19,5 @@ fn bar() {
|
|||
fn main() {
|
||||
let _x = foo::<_>([1,2]);
|
||||
//[normal]~^ ERROR: type provided when a constant was expected
|
||||
let _y = bar();
|
||||
bar();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -64,7 +64,7 @@ pub fn main() {
|
|||
};
|
||||
assert_eq!(trait_unified_3, ["Yes"]);
|
||||
|
||||
let regular_break = loop {
|
||||
let regular_break: () = loop {
|
||||
if true {
|
||||
break;
|
||||
} else {
|
||||
|
|
@ -73,7 +73,7 @@ pub fn main() {
|
|||
};
|
||||
assert_eq!(regular_break, ());
|
||||
|
||||
let regular_break_2 = loop {
|
||||
let regular_break_2: () = loop {
|
||||
if true {
|
||||
break Default::default();
|
||||
} else {
|
||||
|
|
@ -82,7 +82,7 @@ pub fn main() {
|
|||
};
|
||||
assert_eq!(regular_break_2, ());
|
||||
|
||||
let regular_break_3 = loop {
|
||||
let regular_break_3: () = loop {
|
||||
break if true {
|
||||
Default::default()
|
||||
} else {
|
||||
|
|
@ -91,13 +91,13 @@ pub fn main() {
|
|||
};
|
||||
assert_eq!(regular_break_3, ());
|
||||
|
||||
let regular_break_4 = loop {
|
||||
let regular_break_4: () = loop {
|
||||
break ();
|
||||
break;
|
||||
};
|
||||
assert_eq!(regular_break_4, ());
|
||||
|
||||
let regular_break_5 = loop {
|
||||
let regular_break_5: () = loop {
|
||||
break;
|
||||
break ();
|
||||
};
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ impl<T> F<T> {
|
|||
//~| NOTE: in this expansion of assert!
|
||||
//~| NOTE: the evaluated program panicked
|
||||
}
|
||||
let _ = F::<T>::V;
|
||||
F::<T>::V;
|
||||
}
|
||||
|
||||
fn foo<U>() {
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ fn with<F>(self, f: F) -> Backed<'a, ()>
|
|||
where
|
||||
F: for<'f> FnOnce(<U as Unpack<'f>>::Unpacked) -> (),
|
||||
{
|
||||
let result = f(self.1.unpack());
|
||||
let result: () = f(self.1.unpack());
|
||||
Backed(self.0, result)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -391,7 +391,7 @@ fn main() {
|
|||
let _val = mem::zeroed::<ZeroIsValid>();
|
||||
let _val = mem::uninitialized::<MaybeUninit<bool>>();
|
||||
let _val = mem::uninitialized::<[!; 0]>();
|
||||
let _val = mem::uninitialized::<()>();
|
||||
let _val: () = mem::uninitialized::<()>();
|
||||
let _val = mem::uninitialized::<ZeroSized>();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,8 +18,8 @@ pub fn new() {}
|
|||
fn main() {
|
||||
|
||||
type Ham = foo::bar::baz::Qux;
|
||||
let foo = foo::bar::baz::Qux::new(); // invoke directly
|
||||
let bar = Ham::new(); // invoke via type alias
|
||||
let foo: () = foo::bar::baz::Qux::new(); // invoke directly
|
||||
let bar: () = Ham::new(); // invoke via type alias
|
||||
|
||||
type StringVec = Vec<String>;
|
||||
let sv = StringVec::new();
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ struct S {x:()}
|
|||
|
||||
fn test(slot: &mut Option<Box<dyn FnMut() -> Box<dyn FnMut()>>>) -> () {
|
||||
let a = slot.take();
|
||||
let _a = match a {
|
||||
let _a: () = match a {
|
||||
// `{let .. a(); }` would break
|
||||
Some(mut a) => { let _a = a(); },
|
||||
None => (),
|
||||
|
|
@ -28,7 +28,7 @@ fn not(b: bool) -> bool {
|
|||
|
||||
pub fn main() {
|
||||
// {} would break
|
||||
let _r = {};
|
||||
let _r: () = {};
|
||||
let mut slot = None;
|
||||
// `{ test(...); }` would break
|
||||
let _s : S = S{ x: { test(&mut slot); } };
|
||||
|
|
|
|||
|
|
@ -24,5 +24,5 @@ pub unsafe fn get_attr<'a>(&'a self, name: &str) {
|
|||
|
||||
fn main() {
|
||||
let element = Element { attrs: Vec::new() };
|
||||
let _ = unsafe { element.get_attr("foo") };
|
||||
unsafe { let () = element.get_attr("foo"); };
|
||||
}
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ fn foo() {
|
|||
let cwd = env::current_dir().unwrap();
|
||||
let src = cwd.clone();
|
||||
let summary = File::open(&src.join("SUMMARY.md")).unwrap();
|
||||
let _ = parse_summary(summary, &src);
|
||||
parse_summary(summary, &src);
|
||||
}
|
||||
|
||||
fn main() {}
|
||||
|
|
|
|||
|
|
@ -45,14 +45,14 @@ fn sfn() {}
|
|||
impl_StaticFn!(StaticFnStruct, StaticFnEnum, AliasedStaticFnStruct, AliasedStaticFnEnum);
|
||||
|
||||
fn main() {
|
||||
let _ = ConstStruct::C;
|
||||
let _ = ConstEnum::C;
|
||||
let () = ConstStruct::C;
|
||||
let () = ConstEnum::C;
|
||||
|
||||
StaticFnStruct::sfn();
|
||||
StaticFnEnum::sfn();
|
||||
|
||||
let _ = AliasConstStruct::C;
|
||||
let _ = AliasConstEnum::C;
|
||||
let () = AliasConstStruct::C;
|
||||
let () = AliasConstEnum::C;
|
||||
|
||||
AliasStaticFnStruct::sfn();
|
||||
AliasStaticFnEnum::sfn();
|
||||
|
|
|
|||
|
|
@ -147,7 +147,7 @@ struct Match{f1: i32}
|
|||
#![deny(unsafe_code)]
|
||||
unsafe {} //~ ERROR usage of an `unsafe` block
|
||||
}
|
||||
let block_tail = {
|
||||
let block_tail: () = {
|
||||
#[deny(unsafe_code)]
|
||||
unsafe {} //~ ERROR usage of an `unsafe` block
|
||||
};
|
||||
|
|
|
|||
|
|
@ -172,7 +172,7 @@ struct Match{f1: i32}
|
|||
#![deny(enum_intrinsics_non_enums)]
|
||||
discriminant::<i32>(&123); //~ ERROR the return value of
|
||||
}
|
||||
let block_tail = {
|
||||
let block_tail: () = {
|
||||
#[deny(enum_intrinsics_non_enums)]
|
||||
discriminant::<i32>(&123); //~ ERROR the return value of
|
||||
};
|
||||
|
|
|
|||
|
|
@ -31,5 +31,5 @@ mod foo {
|
|||
|
||||
fn main() {
|
||||
lint_unused_extern_crate3::foo();
|
||||
let y = foo();
|
||||
foo();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -86,5 +86,5 @@ fn main() {
|
|||
let mut b = 4;
|
||||
swap(&mut a, &mut b);
|
||||
test::C.b();
|
||||
let _a = foo();
|
||||
foo();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -74,6 +74,6 @@ fn main() {
|
|||
b: i32,
|
||||
//~^ ERROR unused variable: `b`
|
||||
| {};
|
||||
let _ = a(1, 2);
|
||||
let _ = b(1, 2);
|
||||
a(1, 2);
|
||||
b(1, 2);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -31,15 +31,15 @@ pub trait Unused {
|
|||
mod test2 {
|
||||
use super::*;
|
||||
pub fn func() {
|
||||
let _ = <()>::a();
|
||||
let _ = ().b();
|
||||
<()>::a();
|
||||
().b();
|
||||
test3::inner_func();
|
||||
}
|
||||
mod test3 {
|
||||
use super::*;
|
||||
pub fn inner_func() {
|
||||
let _ = <()>::a();
|
||||
let _ = ().b();
|
||||
<()>::a();
|
||||
().b();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -27,27 +27,27 @@ fn fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result {
|
|||
}
|
||||
|
||||
fn main() {
|
||||
let _print = {
|
||||
let _print: () = {
|
||||
let mutex = Mutex;
|
||||
print!("{}", mutex.lock()) /* no semicolon */
|
||||
};
|
||||
|
||||
let _println = {
|
||||
let _println: () = {
|
||||
let mutex = Mutex;
|
||||
println!("{}", mutex.lock()) /* no semicolon */
|
||||
};
|
||||
|
||||
let _eprint = {
|
||||
let _eprint: () = {
|
||||
let mutex = Mutex;
|
||||
eprint!("{}", mutex.lock()) /* no semicolon */
|
||||
};
|
||||
|
||||
let _eprintln = {
|
||||
let _eprintln: () = {
|
||||
let mutex = Mutex;
|
||||
eprintln!("{}", mutex.lock()) /* no semicolon */
|
||||
};
|
||||
|
||||
let _panic = {
|
||||
let _panic: () = {
|
||||
let mutex = Mutex;
|
||||
panic!("{}", mutex.lock()) /* no semicolon */
|
||||
};
|
||||
|
|
|
|||
|
|
@ -170,8 +170,8 @@ fn format_args() {
|
|||
|
||||
#[test]
|
||||
fn include() {
|
||||
let _ = include!("auxiliary/macro-comma-support.rs");
|
||||
let _ = include!("auxiliary/macro-comma-support.rs",);
|
||||
include!("auxiliary/macro-comma-support.rs");
|
||||
include!("auxiliary/macro-comma-support.rs",);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ pub fn broken<MS>(ms: MS)
|
|||
MS::Item: Into<()>,
|
||||
{
|
||||
// Error: Apparently Balance::new doesn't exist during MIR validation
|
||||
let _ = ImplShoulExist::<MS, ()>::access_fn(ms);
|
||||
ImplShoulExist::<MS, ()>::access_fn(ms);
|
||||
}
|
||||
|
||||
fn main() {}
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ fn may_panic<X>(_: X) { }
|
|||
fn main() {
|
||||
let dyn_trait = make_dyn_trait(&());
|
||||
let storage = vec![()];
|
||||
let _x = may_panic(());
|
||||
may_panic(());
|
||||
let storage_ref = &storage;
|
||||
diff(dyn_trait, storage_ref);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
|
||||
fn foo() {
|
||||
let bar = |_| { };
|
||||
let _ = bar("a");
|
||||
bar("a");
|
||||
}
|
||||
|
||||
fn main() {
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ fn assignment_rev() {
|
|||
}
|
||||
|
||||
fn if_then_else() {
|
||||
let _x = if true {
|
||||
let _x: () = if true {
|
||||
UnitDefault::default()
|
||||
} else {
|
||||
return;
|
||||
|
|
@ -56,7 +56,7 @@ fn if_then_else() {
|
|||
}
|
||||
|
||||
fn if_then_else_rev() {
|
||||
let _x = if true {
|
||||
let _x: () = if true {
|
||||
return;
|
||||
} else {
|
||||
UnitDefault::default()
|
||||
|
|
@ -64,21 +64,21 @@ fn if_then_else_rev() {
|
|||
}
|
||||
|
||||
fn match_arm() {
|
||||
let _x = match Ok(UnitDefault::default()) {
|
||||
let _x: () = match Ok(UnitDefault::default()) {
|
||||
Ok(v) => v,
|
||||
Err(()) => return,
|
||||
};
|
||||
}
|
||||
|
||||
fn match_arm_rev() {
|
||||
let _x = match Ok(UnitDefault::default()) {
|
||||
let _x: () = match Ok(UnitDefault::default()) {
|
||||
Err(()) => return,
|
||||
Ok(v) => v,
|
||||
};
|
||||
}
|
||||
|
||||
fn loop_break() {
|
||||
let _x = loop {
|
||||
let _x: () = loop {
|
||||
if false {
|
||||
break return;
|
||||
} else {
|
||||
|
|
@ -88,7 +88,7 @@ fn loop_break() {
|
|||
}
|
||||
|
||||
fn loop_break_rev() {
|
||||
let _x = loop {
|
||||
let _x: () = loop {
|
||||
if false {
|
||||
break return;
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -4,8 +4,8 @@
|
|||
// check-pass
|
||||
|
||||
fn main() {
|
||||
let x = while false {
|
||||
let x: () = while false {
|
||||
break;
|
||||
};
|
||||
let y = 'l: while break 'l {};
|
||||
let y: () = 'l: while break 'l {};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ fn foo<T: 'static + Debug>(_: T) { }
|
|||
fn bar<'a>() {
|
||||
return;
|
||||
|
||||
let _x = foo::<Vec<_>>(Vec::<&'a u32>::new());
|
||||
foo::<Vec<_>>(Vec::<&'a u32>::new());
|
||||
}
|
||||
|
||||
fn main() {}
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ fn foo<R, S: FnOnce()>(
|
|||
let bar = || {
|
||||
let _ = OnDrop(|| ());
|
||||
};
|
||||
let _ = bar();
|
||||
bar();
|
||||
}
|
||||
|
||||
fn main() {
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ fn foo<R, S: FnOnce()>(
|
|||
let bar = || {
|
||||
bar(|| {})
|
||||
};
|
||||
let _ = bar();
|
||||
bar();
|
||||
}
|
||||
|
||||
fn main() {
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
fn a() {
|
||||
// Here we issue that the "2nd-innermost" return is unreachable,
|
||||
// but we stop there.
|
||||
let x = {return {return {return;}}}; //~ ERROR unreachable
|
||||
let x: () = {return {return {return;}}}; //~ ERROR unreachable
|
||||
}
|
||||
|
||||
fn main() { }
|
||||
|
|
|
|||
|
|
@ -1,11 +1,11 @@
|
|||
error: unreachable expression
|
||||
--> $DIR/expr_return.rs:10:22
|
||||
--> $DIR/expr_return.rs:10:26
|
||||
|
|
||||
LL | let x = {return {return {return;}}};
|
||||
| ^^^^^^^^------^^
|
||||
| | |
|
||||
| | any code following this expression is unreachable
|
||||
| unreachable expression
|
||||
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
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ pub fn internal(&self) {}
|
|||
|
||||
fn shadow_prelude() {
|
||||
// Extern prelude shadows standard library prelude
|
||||
let x = Vec::new(0f32, ()); // OK
|
||||
let x: () = Vec::new(0f32, ()); // OK
|
||||
}
|
||||
|
||||
fn main() {}
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
|
||||
fn check<Clone>(_c: Clone) {
|
||||
fn check2() {
|
||||
let _ = <() as std::clone::Clone>::clone(&());
|
||||
let () = <() as std::clone::Clone>::clone(&());
|
||||
}
|
||||
check2();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
// run-pass
|
||||
// pretty-expanded FIXME #23616
|
||||
|
||||
fn f() { let x: () = (); return x; }
|
||||
fn f() { let x = (); return x; }
|
||||
|
||||
pub fn main() { let _x = f(); }
|
||||
pub fn main() { f(); }
|
||||
|
|
|
|||
|
|
@ -97,5 +97,5 @@ fn main() {
|
|||
#[cfg_attr(something, cfg(nothing))]
|
||||
#[deny(unused_mut)] c: i32,
|
||||
| {};
|
||||
let _ = c(1, 2);
|
||||
c(1, 2);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -116,6 +116,6 @@ fn main() {
|
|||
//~^ ERROR unused variable: `c`
|
||||
#[cfg_attr(something, cfg(nothing))] d: i32,
|
||||
| {};
|
||||
let _ = a(1);
|
||||
let _ = c(1, 2);
|
||||
a(1);
|
||||
c(1, 2);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ fn create(&self) -> my_connection { () }
|
|||
|
||||
pub fn main() {
|
||||
let factory = ();
|
||||
let connection = factory.create();
|
||||
let connection: () = factory.create();
|
||||
let result = connection.read();
|
||||
assert_eq!(result, 43);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ fn main() {
|
|||
let mut a = 0;
|
||||
let () = {
|
||||
let _: Result<(), ()> = try {
|
||||
let _ = Err(())?;
|
||||
let () = Err(())?;
|
||||
return
|
||||
};
|
||||
a += 1;
|
||||
|
|
|
|||
|
|
@ -3,8 +3,8 @@
|
|||
fn main() {
|
||||
let tuple = (((),),);
|
||||
|
||||
let _ = tuple. 0.0; // OK, whitespace
|
||||
let _ = tuple.0. 0; // OK, whitespace
|
||||
let () = tuple. 0.0; // OK, whitespace
|
||||
let () = tuple.0. 0; // OK, whitespace
|
||||
|
||||
let _ = tuple./*special cases*/0.0; // OK, comment
|
||||
let () = tuple./*special cases*/0.0; // OK, comment
|
||||
}
|
||||
|
|
|
|||
|
|
@ -81,7 +81,7 @@ fn angrydome() {
|
|||
break; }
|
||||
}
|
||||
|
||||
fn evil_lincoln() { let _evil = println!("lincoln"); }
|
||||
fn evil_lincoln() { let _evil: () = println!("lincoln"); }
|
||||
|
||||
fn dots() {
|
||||
assert_eq!(String::from(".................................................."),
|
||||
|
|
@ -137,7 +137,7 @@ fn punch_card() -> impl std::fmt::Debug {
|
|||
}
|
||||
|
||||
fn r#match() {
|
||||
let val = match match match match match () {
|
||||
let val: () = match match match match match () {
|
||||
() => ()
|
||||
} {
|
||||
() => ()
|
||||
|
|
@ -166,7 +166,7 @@ fn match_nested_if() {
|
|||
}
|
||||
|
||||
fn monkey_barrel() {
|
||||
let val = ()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=();
|
||||
let val: () = ()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=()=();
|
||||
assert_eq!(val, ());
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue