From d5d1ee86bb72730a77abfcab3a38c1a5d1b757bf Mon Sep 17 00:00:00 2001 From: Philipp Hansch Date: Sat, 20 Apr 2019 13:45:46 +0200 Subject: [PATCH 1/4] Deny rust_2018_idioms globally --- src/bootstrap/bin/rustc.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/bootstrap/bin/rustc.rs b/src/bootstrap/bin/rustc.rs index a8f0d24ce63db..50d170b8a8844 100644 --- a/src/bootstrap/bin/rustc.rs +++ b/src/bootstrap/bin/rustc.rs @@ -308,6 +308,7 @@ fn main() { { cmd.arg("-Dwarnings"); cmd.arg("-Dbare_trait_objects"); + cmd.arg("-Drust_2018_idioms"); } if verbose > 1 { From 110a73d6c60eab76ce39426eb29cd1d016f6539c Mon Sep 17 00:00:00 2001 From: Philipp Hansch Date: Sat, 20 Apr 2019 16:05:25 +0200 Subject: [PATCH 2/4] Deny rust_2018_idioms in liballoc tests --- src/liballoc/tests/cow_str.rs | 24 ++++++++++++------------ src/liballoc/tests/lib.rs | 1 + src/liballoc/tests/string.rs | 4 ++-- 3 files changed, 15 insertions(+), 14 deletions(-) diff --git a/src/liballoc/tests/cow_str.rs b/src/liballoc/tests/cow_str.rs index eb6adb159b0fd..6f357eda9b83b 100644 --- a/src/liballoc/tests/cow_str.rs +++ b/src/liballoc/tests/cow_str.rs @@ -7,9 +7,9 @@ fn check_cow_add_cow() { let borrowed2 = Cow::Borrowed("World!"); let borrow_empty = Cow::Borrowed(""); - let owned1: Cow = Cow::Owned(String::from("Hi, ")); - let owned2: Cow = Cow::Owned(String::from("Rustaceans!")); - let owned_empty: Cow = Cow::Owned(String::new()); + let owned1: Cow<'_, str> = Cow::Owned(String::from("Hi, ")); + let owned2: Cow<'_, str> = Cow::Owned(String::from("Rustaceans!")); + let owned_empty: Cow<'_, str> = Cow::Owned(String::new()); assert_eq!("Hello, World!", borrowed1.clone() + borrowed2.clone()); assert_eq!("Hello, Rustaceans!", borrowed1.clone() + owned2.clone()); @@ -36,8 +36,8 @@ fn check_cow_add_str() { let borrowed = Cow::Borrowed("Hello, "); let borrow_empty = Cow::Borrowed(""); - let owned: Cow = Cow::Owned(String::from("Hi, ")); - let owned_empty: Cow = Cow::Owned(String::new()); + let owned: Cow<'_, str> = Cow::Owned(String::from("Hi, ")); + let owned_empty: Cow<'_, str> = Cow::Owned(String::new()); assert_eq!("Hello, World!", borrowed.clone() + "World!"); @@ -60,9 +60,9 @@ fn check_cow_add_assign_cow() { let borrowed2 = Cow::Borrowed("World!"); let borrow_empty = Cow::Borrowed(""); - let mut owned1: Cow = Cow::Owned(String::from("Hi, ")); - let owned2: Cow = Cow::Owned(String::from("Rustaceans!")); - let owned_empty: Cow = Cow::Owned(String::new()); + let mut owned1: Cow<'_, str> = Cow::Owned(String::from("Hi, ")); + let owned2: Cow<'_, str> = Cow::Owned(String::from("Rustaceans!")); + let owned_empty: Cow<'_, str> = Cow::Owned(String::new()); let mut s = borrowed1.clone(); s += borrow_empty.clone(); @@ -101,8 +101,8 @@ fn check_cow_add_assign_str() { let mut borrowed = Cow::Borrowed("Hello, "); let borrow_empty = Cow::Borrowed(""); - let mut owned: Cow = Cow::Owned(String::from("Hi, ")); - let owned_empty: Cow = Cow::Owned(String::new()); + let mut owned: Cow<'_, str> = Cow::Owned(String::from("Hi, ")); + let owned_empty: Cow<'_, str> = Cow::Owned(String::new()); let mut s = borrowed.clone(); s += ""; @@ -132,10 +132,10 @@ fn check_cow_add_assign_str() { #[test] fn check_cow_clone_from() { - let mut c1: Cow = Cow::Owned(String::with_capacity(25)); + let mut c1: Cow<'_, str> = Cow::Owned(String::with_capacity(25)); let s: String = "hi".to_string(); assert!(s.capacity() < 25); - let c2: Cow = Cow::Owned(s); + let c2: Cow<'_, str> = Cow::Owned(s); c1.clone_from(&c2); assert!(c1.into_owned().capacity() >= 25); } diff --git a/src/liballoc/tests/lib.rs b/src/liballoc/tests/lib.rs index 90921b6af9f34..b736750c57601 100644 --- a/src/liballoc/tests/lib.rs +++ b/src/liballoc/tests/lib.rs @@ -7,6 +7,7 @@ #![feature(try_reserve)] #![feature(unboxed_closures)] #![feature(vecdeque_rotate)] +#![deny(rust_2018_idioms)] use std::hash::{Hash, Hasher}; use std::collections::hash_map::DefaultHasher; diff --git a/src/liballoc/tests/string.rs b/src/liballoc/tests/string.rs index 7e75b8c4f28c8..765210e5aa6b3 100644 --- a/src/liballoc/tests/string.rs +++ b/src/liballoc/tests/string.rs @@ -54,11 +54,11 @@ fn test_from_utf8() { #[test] fn test_from_utf8_lossy() { let xs = b"hello"; - let ys: Cow = "hello".into_cow(); + let ys: Cow<'_, str> = "hello".into_cow(); assert_eq!(String::from_utf8_lossy(xs), ys); let xs = "ศไทย中华Việt Nam".as_bytes(); - let ys: Cow = "ศไทย中华Việt Nam".into_cow(); + let ys: Cow<'_, str> = "ศไทย中华Việt Nam".into_cow(); assert_eq!(String::from_utf8_lossy(xs), ys); let xs = b"Hello\xC2 There\xFF Goodbye"; From c9ae68812f97fbe8d0b6f06580a747f3c2eda64a Mon Sep 17 00:00:00 2001 From: Philipp Hansch Date: Sat, 20 Apr 2019 18:44:29 +0200 Subject: [PATCH 3/4] Deny rust_2018_idioms in libcore tests --- src/libcore/tests/cell.rs | 20 ++++++------- src/libcore/tests/fmt/builders.rs | 50 +++++++++++++++---------------- src/libcore/tests/iter.rs | 4 +-- src/libcore/tests/lib.rs | 2 +- 4 files changed, 38 insertions(+), 38 deletions(-) diff --git a/src/libcore/tests/cell.rs b/src/libcore/tests/cell.rs index 7bd7d1874101a..4dfd884d2377c 100644 --- a/src/libcore/tests/cell.rs +++ b/src/libcore/tests/cell.rs @@ -139,11 +139,11 @@ fn ref_clone_updates_flag() { fn ref_map_does_not_update_flag() { let x = RefCell::new(Some(5)); { - let b1: Ref> = x.borrow(); + let b1: Ref<'_, Option> = x.borrow(); assert!(x.try_borrow().is_ok()); assert!(x.try_borrow_mut().is_err()); { - let b2: Ref = Ref::map(b1, |o| o.as_ref().unwrap()); + let b2: Ref<'_, u32> = Ref::map(b1, |o| o.as_ref().unwrap()); assert_eq!(*b2, 5); assert!(x.try_borrow().is_ok()); assert!(x.try_borrow_mut().is_err()); @@ -217,12 +217,12 @@ fn ref_mut_map_split() { fn ref_map_accessor() { struct X(RefCell<(u32, char)>); impl X { - fn accessor(&self) -> Ref { + fn accessor(&self) -> Ref<'_, u32> { Ref::map(self.0.borrow(), |tuple| &tuple.0) } } let x = X(RefCell::new((7, 'z'))); - let d: Ref = x.accessor(); + let d: Ref<'_, u32> = x.accessor(); assert_eq!(*d, 7); } @@ -230,13 +230,13 @@ fn ref_map_accessor() { fn ref_mut_map_accessor() { struct X(RefCell<(u32, char)>); impl X { - fn accessor(&self) -> RefMut { + fn accessor(&self) -> RefMut<'_, u32> { RefMut::map(self.0.borrow_mut(), |tuple| &mut tuple.0) } } let x = X(RefCell::new((7, 'z'))); { - let mut d: RefMut = x.accessor(); + let mut d: RefMut<'_ ,u32> = x.accessor(); assert_eq!(*d, 7); *d += 1; } @@ -333,16 +333,16 @@ fn refcell_unsized() { fn refcell_ref_coercion() { let cell: RefCell<[i32; 3]> = RefCell::new([1, 2, 3]); { - let mut cellref: RefMut<[i32; 3]> = cell.borrow_mut(); + let mut cellref: RefMut<'_, [i32; 3]> = cell.borrow_mut(); cellref[0] = 4; - let mut coerced: RefMut<[i32]> = cellref; + let mut coerced: RefMut<'_, [i32]> = cellref; coerced[2] = 5; } { let comp: &mut [i32] = &mut [4, 2, 5]; - let cellref: Ref<[i32; 3]> = cell.borrow(); + let cellref: Ref<'_, [i32; 3]> = cell.borrow(); assert_eq!(&*cellref, comp); - let coerced: Ref<[i32]> = cellref; + let coerced: Ref<'_, [i32]> = cellref; assert_eq!(&*coerced, comp); } } diff --git a/src/libcore/tests/fmt/builders.rs b/src/libcore/tests/fmt/builders.rs index e4b75fe1fa265..62fe09c5eb32c 100644 --- a/src/libcore/tests/fmt/builders.rs +++ b/src/libcore/tests/fmt/builders.rs @@ -6,7 +6,7 @@ mod debug_struct { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_struct("Foo").finish() } } @@ -20,7 +20,7 @@ mod debug_struct { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_struct("Foo") .field("bar", &true) .finish() @@ -40,7 +40,7 @@ mod debug_struct { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_struct("Foo") .field("bar", &true) .field("baz", &format_args!("{}/{}", 10, 20)) @@ -62,7 +62,7 @@ mod debug_struct { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_struct("Foo") .field("bar", &true) .field("baz", &format_args!("{}/{}", 10, 20)) @@ -73,7 +73,7 @@ mod debug_struct { struct Bar; impl fmt::Debug for Bar { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_struct("Bar") .field("foo", &Foo) .field("hello", &"world") @@ -103,7 +103,7 @@ mod debug_tuple { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_tuple("Foo").finish() } } @@ -117,7 +117,7 @@ mod debug_tuple { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_tuple("Foo") .field(&true) .finish() @@ -137,7 +137,7 @@ mod debug_tuple { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_tuple("Foo") .field(&true) .field(&format_args!("{}/{}", 10, 20)) @@ -159,7 +159,7 @@ mod debug_tuple { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_tuple("Foo") .field(&true) .field(&format_args!("{}/{}", 10, 20)) @@ -170,7 +170,7 @@ mod debug_tuple { struct Bar; impl fmt::Debug for Bar { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_tuple("Bar") .field(&Foo) .field(&"world") @@ -200,7 +200,7 @@ mod debug_map { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_map().finish() } } @@ -214,7 +214,7 @@ mod debug_map { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_map() .entry(&"bar", &true) .finish() @@ -234,7 +234,7 @@ mod debug_map { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_map() .entry(&"bar", &true) .entry(&10, &format_args!("{}/{}", 10, 20)) @@ -256,7 +256,7 @@ mod debug_map { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_map() .entry(&"bar", &true) .entry(&10, &format_args!("{}/{}", 10, 20)) @@ -267,7 +267,7 @@ mod debug_map { struct Bar; impl fmt::Debug for Bar { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_map() .entry(&"foo", &Foo) .entry(&Foo, &"world") @@ -301,7 +301,7 @@ mod debug_set { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_set().finish() } } @@ -315,7 +315,7 @@ mod debug_set { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_set() .entry(&true) .finish() @@ -335,7 +335,7 @@ mod debug_set { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_set() .entry(&true) .entry(&format_args!("{}/{}", 10, 20)) @@ -357,7 +357,7 @@ mod debug_set { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_set() .entry(&true) .entry(&format_args!("{}/{}", 10, 20)) @@ -368,7 +368,7 @@ mod debug_set { struct Bar; impl fmt::Debug for Bar { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_set() .entry(&Foo) .entry(&"world") @@ -398,7 +398,7 @@ mod debug_list { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_list().finish() } } @@ -412,7 +412,7 @@ mod debug_list { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_list() .entry(&true) .finish() @@ -432,7 +432,7 @@ mod debug_list { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_list() .entry(&true) .entry(&format_args!("{}/{}", 10, 20)) @@ -454,7 +454,7 @@ mod debug_list { struct Foo; impl fmt::Debug for Foo { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_list() .entry(&true) .entry(&format_args!("{}/{}", 10, 20)) @@ -465,7 +465,7 @@ mod debug_list { struct Bar; impl fmt::Debug for Bar { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt.debug_list() .entry(&Foo) .entry(&"world") diff --git a/src/libcore/tests/iter.rs b/src/libcore/tests/iter.rs index 5247331fba24f..7dfb1adad9eed 100644 --- a/src/libcore/tests/iter.rs +++ b/src/libcore/tests/iter.rs @@ -567,12 +567,12 @@ fn test_iterator_peekable_fold() { /// This is an iterator that follows the Iterator contract, /// but it is not fused. After having returned None once, it will start /// producing elements if .next() is called again. -pub struct CycleIter<'a, T: 'a> { +pub struct CycleIter<'a, T> { index: usize, data: &'a [T], } -pub fn cycle(data: &[T]) -> CycleIter { +pub fn cycle(data: &[T]) -> CycleIter<'_, T> { CycleIter { index: 0, data, diff --git a/src/libcore/tests/lib.rs b/src/libcore/tests/lib.rs index fcdeb57f482a9..2e4a8a15d2088 100644 --- a/src/libcore/tests/lib.rs +++ b/src/libcore/tests/lib.rs @@ -32,8 +32,8 @@ #![feature(slice_partition_dedup)] #![feature(copy_within)] #![feature(int_error_matching)] +#![deny(rust_2018_idioms)] -extern crate core; extern crate test; mod any; From 8e5555909c1c425241ff3733efaa50986a124623 Mon Sep 17 00:00:00 2001 From: Philipp Hansch Date: Sun, 21 Apr 2019 10:52:12 +0200 Subject: [PATCH 4/4] Allow unused_extern_crates for rustc_libserialize --- src/libserialize/tests/json.rs | 1 + src/libserialize/tests/opaque.rs | 1 + 2 files changed, 2 insertions(+) diff --git a/src/libserialize/tests/json.rs b/src/libserialize/tests/json.rs index 3fb6bda679bc1..0fe3d4cfd6297 100644 --- a/src/libserialize/tests/json.rs +++ b/src/libserialize/tests/json.rs @@ -1,3 +1,4 @@ +#[allow(unused_extern_crates)] extern crate serialize as rustc_serialize; use rustc_serialize::{Encodable, Decodable}; diff --git a/src/libserialize/tests/opaque.rs b/src/libserialize/tests/opaque.rs index fff6fc69e7842..62a8f25124439 100644 --- a/src/libserialize/tests/opaque.rs +++ b/src/libserialize/tests/opaque.rs @@ -1,3 +1,4 @@ +#[allow(unused_extern_crates)] extern crate serialize as rustc_serialize; use rustc_serialize::{Encodable, Decodable};