From a4fb1d0b76a6e4e5e980a6839eb318a879635882 Mon Sep 17 00:00:00 2001 From: Stefan Lankes Date: Mon, 27 Jul 2020 23:06:30 +0200 Subject: [PATCH 01/17] adjust remaining targets - fix commit 7dc3886 - previous commit doesn't adjust all targets --- library/std/src/sys/hermit/mod.rs | 2 +- library/std/src/sys/hermit/thread.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/library/std/src/sys/hermit/mod.rs b/library/std/src/sys/hermit/mod.rs index 675b82ceb775f..8eaf07e52d69a 100644 --- a/library/std/src/sys/hermit/mod.rs +++ b/library/std/src/sys/hermit/mod.rs @@ -106,7 +106,7 @@ pub unsafe extern "C" fn runtime_entry( argv: *const *const c_char, env: *const *const c_char, ) -> ! { - use crate::sys::hermit::fast_thread_local::run_dtors; + use crate::sys::hermit::thread_local_dtor::run_dtors; extern "C" { fn main(argc: isize, argv: *const *const c_char) -> i32; } diff --git a/library/std/src/sys/hermit/thread.rs b/library/std/src/sys/hermit/thread.rs index e11afed668728..7bd71e120de40 100644 --- a/library/std/src/sys/hermit/thread.rs +++ b/library/std/src/sys/hermit/thread.rs @@ -4,7 +4,7 @@ use crate::ffi::CStr; use crate::io; use crate::mem; use crate::sys::hermit::abi; -use crate::sys::hermit::fast_thread_local::run_dtors; +use crate::sys::hermit::thread_local_dtor::run_dtors; use crate::time::Duration; pub type Tid = abi::Tid; From e1ef3fa686040a8c9aba34dd954a7ff7227a23ee Mon Sep 17 00:00:00 2001 From: Ivan Tham Date: Tue, 4 Aug 2020 23:46:14 +0800 Subject: [PATCH 02/17] Consistent variable name alloc for raw_vec --- library/alloc/src/raw_vec.rs | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/library/alloc/src/raw_vec.rs b/library/alloc/src/raw_vec.rs index 99ac027bf0b9f..f403035ec406e 100644 --- a/library/alloc/src/raw_vec.rs +++ b/library/alloc/src/raw_vec.rs @@ -203,13 +203,15 @@ impl RawVec { /// /// # Safety /// - /// The `ptr` must be allocated (via the given allocator `a`), and with the given `capacity`. + /// The `ptr` must be allocated (via the given allocator `alloc`), and with the given + /// `capacity`. /// The `capacity` cannot exceed `isize::MAX` for sized types. (only a concern on 32-bit /// systems). ZST vectors may have a capacity up to `usize::MAX`. - /// If the `ptr` and `capacity` come from a `RawVec` created via `a`, then this is guaranteed. + /// If the `ptr` and `capacity` come from a `RawVec` created via `alloc`, then this is + /// guaranteed. #[inline] - pub unsafe fn from_raw_parts_in(ptr: *mut T, capacity: usize, a: A) -> Self { - Self { ptr: unsafe { Unique::new_unchecked(ptr) }, cap: capacity, alloc: a } + pub unsafe fn from_raw_parts_in(ptr: *mut T, capacity: usize, alloc: A) -> Self { + Self { ptr: unsafe { Unique::new_unchecked(ptr) }, cap: capacity, alloc } } /// Gets a raw pointer to the start of the allocation. Note that this is From d243fa109fd22d334a717e4f03bf208ce9c3a9f4 Mon Sep 17 00:00:00 2001 From: Alexis Bourget Date: Tue, 4 Aug 2020 22:35:06 +0200 Subject: [PATCH 03/17] Fix the documentation for move about Fn traits implementations --- library/std/src/keyword_docs.rs | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/library/std/src/keyword_docs.rs b/library/std/src/keyword_docs.rs index c98008688ab4f..93776328290d3 100644 --- a/library/std/src/keyword_docs.rs +++ b/library/std/src/keyword_docs.rs @@ -943,8 +943,12 @@ mod mod_keyword {} /// Capture a [closure]'s environment by value. /// /// `move` converts any variables captured by reference or mutable reference -/// to owned by value variables. The three [`Fn` trait]'s mirror the ways to capture -/// variables, when `move` is used, the closures is represented by the `FnOnce` trait. +/// to owned by value variables. +/// +/// Note: `move` closures may still implement [`Fn`] or [`FnMut`], even though +/// they capture variables by `move`. This is because the traits implemented by +/// a closure type are determined by *what* the closure does with captured +/// values, not *how* it captures them. /// /// ```rust /// let capture = "hello"; From a784729cde2f558bba91984eadf0f152b8a9d288 Mon Sep 17 00:00:00 2001 From: Tim Diekmann Date: Thu, 6 Aug 2020 11:45:54 +0200 Subject: [PATCH 04/17] Add `as_mut_ptr` to `NonNull<[T]>` --- library/core/src/ptr/non_null.rs | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/library/core/src/ptr/non_null.rs b/library/core/src/ptr/non_null.rs index 9f843a570990d..5163b2d9d568b 100644 --- a/library/core/src/ptr/non_null.rs +++ b/library/core/src/ptr/non_null.rs @@ -224,6 +224,24 @@ impl NonNull<[T]> { unsafe { NonNull::new_unchecked(self.as_ptr().as_mut_ptr()) } } + /// Returns a raw pointer to the slice's buffer. + /// + /// # Examples + /// + /// ```rust + /// #![feature(slice_ptr_get, nonnull_slice_from_raw_parts)] + /// use std::ptr::NonNull; + /// + /// let slice: NonNull<[i8]> = NonNull::slice_from_raw_parts(NonNull::dangling(), 3); + /// assert_eq!(slice.as_mut_ptr(), 1 as *mut i8); + /// ``` + #[inline] + #[unstable(feature = "slice_ptr_get", issue = "74265")] + #[rustc_const_unstable(feature = "slice_ptr_get", issue = "74265")] + pub const fn as_mut_ptr(self) -> *mut T { + self.as_non_null_ptr().as_ptr() + } + /// Returns a raw pointer to an element or subslice, without doing bounds /// checking. /// From 06cf40f8a160698aa894507d9c7c9cd29fdbdc66 Mon Sep 17 00:00:00 2001 From: Ivan Tham Date: Sat, 8 Aug 2020 00:48:12 +0800 Subject: [PATCH 05/17] Show multi extension example for Path in doctests --- library/std/src/path.rs | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/library/std/src/path.rs b/library/std/src/path.rs index 392c815ef2803..f26a09398923e 100644 --- a/library/std/src/path.rs +++ b/library/std/src/path.rs @@ -2140,9 +2140,8 @@ impl Path { /// ``` /// use std::path::Path; /// - /// let path = Path::new("foo.rs"); - /// - /// assert_eq!("foo", path.file_stem().unwrap()); + /// assert_eq!("foo", Path::new("foo.rs").file_stem().unwrap()); + /// assert_eq!("foo.tar", Path::new("foo.tar.gz").file_stem().unwrap()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn file_stem(&self) -> Option<&OsStr> { @@ -2166,9 +2165,8 @@ impl Path { /// ``` /// use std::path::Path; /// - /// let path = Path::new("foo.rs"); - /// - /// assert_eq!("rs", path.extension().unwrap()); + /// assert_eq!("rs", Path::new("foo.rs").extension().unwrap()); + /// assert_eq!("gz", Path::new("foo.tar.gz").extension().unwrap()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn extension(&self) -> Option<&OsStr> { From 7e68b7d10a7ce505fd41ebc99bd77276ab093a16 Mon Sep 17 00:00:00 2001 From: strom-und-spiele <53340143+strom-und-spiele@users.noreply.github.com> Date: Fri, 24 Jul 2020 14:15:21 +0200 Subject: [PATCH 06/17] Update E0271.md remove references to non existing code, expand solution suggestions remove unneeded code in solution --- src/librustc_error_codes/error_codes/E0271.md | 43 ++++++------------- 1 file changed, 13 insertions(+), 30 deletions(-) diff --git a/src/librustc_error_codes/error_codes/E0271.md b/src/librustc_error_codes/error_codes/E0271.md index 31334069ed8a4..ddd245b1a2b1b 100644 --- a/src/librustc_error_codes/error_codes/E0271.md +++ b/src/librustc_error_codes/error_codes/E0271.md @@ -5,25 +5,6 @@ Erroneous code example: ```compile_fail,E0271 trait Trait { type AssociatedType; } -fn foo(t: T) where T: Trait { - println!("in foo"); -} - -impl Trait for i8 { type AssociatedType = &'static str; } - -foo(3_i8); -``` - -This is because of a type mismatch between the associated type of some -trait (e.g., `T::Bar`, where `T` implements `trait Quux { type Bar; }`) -and another type `U` that is required to be equal to `T::Bar`, but is not. -Examples follow. - -Here is that same example again, with some explanatory comments: - -```compile_fail,E0271 -trait Trait { type AssociatedType; } - fn foo(t: T) where T: Trait { // ~~~~~~~~ ~~~~~~~~~~~~~~~~~~ // | | @@ -56,11 +37,9 @@ foo(3_i8); // therefore the type-checker complains with this error code. ``` -To avoid those issues, you have to make the types match correctly. -So we can fix the previous examples like this: - +The issue can be resolved by changing the associated type: +1) in the `foo` implementation: ``` -// Basic Example: trait Trait { type AssociatedType; } fn foo(t: T) where T: Trait { @@ -70,13 +49,17 @@ fn foo(t: T) where T: Trait { impl Trait for i8 { type AssociatedType = &'static str; } foo(3_i8); +``` -// For-Loop Example: -let vs = vec![1, 2, 3, 4]; -for v in &vs { - match v { - &1 => {} - _ => {} - } +2) in the `Trait` implementation for `i8`: +``` +trait Trait { type AssociatedType; } + +fn foo(t: T) where T: Trait { + println!("in foo"); } + +impl Trait for i8 { type AssociatedType = u32; } + +foo(3_i8); ``` From a11c27925d607f7e1f9bf5a1306b2f2789e55624 Mon Sep 17 00:00:00 2001 From: Ivan Tham Date: Sat, 8 Aug 2020 17:53:16 +0800 Subject: [PATCH 07/17] Show relative example for Path ancestors --- library/std/src/path.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/library/std/src/path.rs b/library/std/src/path.rs index 392c815ef2803..ba58cd9540ade 100644 --- a/library/std/src/path.rs +++ b/library/std/src/path.rs @@ -1992,6 +1992,13 @@ impl Path { /// assert_eq!(ancestors.next(), Some(Path::new("/foo"))); /// assert_eq!(ancestors.next(), Some(Path::new("/"))); /// assert_eq!(ancestors.next(), None); + /// + /// let mut ancestors = Path::new("../foo/bar").ancestors(); + /// assert_eq!(ancestors.next(), Some(Path::new("../foo/bar"))); + /// assert_eq!(ancestors.next(), Some(Path::new("../foo"))); + /// assert_eq!(ancestors.next(), Some(Path::new(".."))); + /// assert_eq!(ancestors.next(), Some(Path::new(""))); + /// assert_eq!(ancestors.next(), None); /// ``` /// /// [`None`]: ../../std/option/enum.Option.html#variant.None From 6dffd2d18e3bb52ec967abef45f7e524a7f91ad9 Mon Sep 17 00:00:00 2001 From: Ivan Tham Date: Sat, 8 Aug 2020 18:01:34 +0800 Subject: [PATCH 08/17] Separate example for Path strip_prefix --- library/std/src/path.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/library/std/src/path.rs b/library/std/src/path.rs index 392c815ef2803..09bef61f0171d 100644 --- a/library/std/src/path.rs +++ b/library/std/src/path.rs @@ -2053,8 +2053,9 @@ impl Path { /// assert_eq!(path.strip_prefix("/test/"), Ok(Path::new("haha/foo.txt"))); /// assert_eq!(path.strip_prefix("/test/haha/foo.txt"), Ok(Path::new(""))); /// assert_eq!(path.strip_prefix("/test/haha/foo.txt/"), Ok(Path::new(""))); - /// assert_eq!(path.strip_prefix("test").is_ok(), false); - /// assert_eq!(path.strip_prefix("/haha").is_ok(), false); + /// + /// assert!(path.strip_prefix("test").is_err()); + /// assert!(path.strip_prefix("/haha").is_err()); /// /// let prefix = PathBuf::from("/test/"); /// assert_eq!(path.strip_prefix(prefix), Ok(Path::new("haha/foo.txt"))); From 9532b83912e4d74deee587a303359d56e7bc5602 Mon Sep 17 00:00:00 2001 From: Ivan Tham Date: Sat, 8 Aug 2020 18:14:29 +0800 Subject: [PATCH 09/17] Show Path extension example change multi extension --- library/std/src/path.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/library/std/src/path.rs b/library/std/src/path.rs index 392c815ef2803..0815dfd47141f 100644 --- a/library/std/src/path.rs +++ b/library/std/src/path.rs @@ -2247,6 +2247,8 @@ impl Path { /// /// let path = Path::new("foo.tar.gz"); /// assert_eq!(path.with_extension(""), PathBuf::from("foo.tar")); + /// assert_eq!(path.with_extension("xz"), PathBuf::from("foo.tar.xz")); + /// assert_eq!(path.with_extension("").with_extension("txt"), PathBuf::from("foo.txt")); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn with_extension>(&self, extension: S) -> PathBuf { From b3ae88f6bba244e8b372ed0fc20b000b145ddff0 Mon Sep 17 00:00:00 2001 From: Ivan Tham Date: Sat, 8 Aug 2020 18:23:18 +0800 Subject: [PATCH 10/17] Use assert! for Path exists example to check bool --- library/std/src/path.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/std/src/path.rs b/library/std/src/path.rs index 392c815ef2803..26a01f69c9959 100644 --- a/library/std/src/path.rs +++ b/library/std/src/path.rs @@ -2473,7 +2473,7 @@ impl Path { /// /// ```no_run /// use std::path::Path; - /// assert_eq!(Path::new("does_not_exist.txt").exists(), false); + /// assert!(!Path::new("does_not_exist.txt").exists()); /// ``` /// /// # See Also From 4b15b809eb12f674842855676171f6998bc9ca42 Mon Sep 17 00:00:00 2001 From: Ivan Tham Date: Sat, 8 Aug 2020 18:28:55 +0800 Subject: [PATCH 11/17] Remove abmiguity from PathBuf pop example --- library/std/src/path.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/library/std/src/path.rs b/library/std/src/path.rs index 392c815ef2803..f6fa877400ee4 100644 --- a/library/std/src/path.rs +++ b/library/std/src/path.rs @@ -1232,10 +1232,10 @@ impl PathBuf { /// ``` /// use std::path::{Path, PathBuf}; /// - /// let mut p = PathBuf::from("/test/test.rs"); + /// let mut p = PathBuf::from("/spirited/away.rs"); /// /// p.pop(); - /// assert_eq!(Path::new("/test"), p); + /// assert_eq!(Path::new("/spirited"), p); /// p.pop(); /// assert_eq!(Path::new("/"), p); /// ``` From ad6d23777b9ca96b1baf9458bcbe7b2e1527ba40 Mon Sep 17 00:00:00 2001 From: Bastian Kauschke Date: Sat, 8 Aug 2020 13:35:42 +0200 Subject: [PATCH 12/17] fix `min_const_generics` version --- src/librustc_feature/active.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/librustc_feature/active.rs b/src/librustc_feature/active.rs index 077f6cf3ca484..31aba8aba2515 100644 --- a/src/librustc_feature/active.rs +++ b/src/librustc_feature/active.rs @@ -580,7 +580,7 @@ declare_features! ( (active, const_fn_transmute, "1.46.0", Some(53605), None), /// The smallest useful subset of `const_generics`. - (active, min_const_generics, "1.46.0", Some(74878), None), + (active, min_const_generics, "1.47.0", Some(74878), None), // ------------------------------------------------------------------------- // feature-group-end: actual feature gates From c2099b5f2812afaaf980ef2082ab5a5b3cb6a145 Mon Sep 17 00:00:00 2001 From: aticu <15schnic@gmail.com> Date: Fri, 7 Aug 2020 20:58:34 +0200 Subject: [PATCH 13/17] Add safety section to `NonNull::as_*` method docs This basically adds the safety section of `*mut T::as_{ref,mut}` to the same methods on `NonNull` with minor modifications to fit the differences. Part of #48929. --- library/core/src/ptr/non_null.rs | 36 ++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/library/core/src/ptr/non_null.rs b/library/core/src/ptr/non_null.rs index 9f843a570990d..7b3db1692a8ce 100644 --- a/library/core/src/ptr/non_null.rs +++ b/library/core/src/ptr/non_null.rs @@ -117,6 +117,24 @@ impl NonNull { /// The resulting lifetime is bound to self so this behaves "as if" /// it were actually an instance of T that is getting borrowed. If a longer /// (unbound) lifetime is needed, use `&*my_ptr.as_ptr()`. + /// + /// # Safety + /// + /// When calling this method, you have to ensure that all of the following is true: + /// - `self` is properly aligned + /// - `self` must point to an initialized instance of T; in particular, the pointer must be + /// "dereferencable" in the sense defined [here]. + /// + /// This applies even if the result of this method is unused! + /// (The part about being initialized is not yet fully decided, but until + /// it is, the only safe approach is to ensure that they are indeed initialized.) + /// + /// Additionally, the lifetime of `self` does not necessarily reflect the actual + /// lifetime of the data. *You* must enforce Rust's aliasing rules. In particular, + /// for the duration of this lifetime, the memory the pointer points to must not + /// get mutated (except inside `UnsafeCell`). + /// + /// [here]: crate::ptr#safety #[stable(feature = "nonnull", since = "1.25.0")] #[inline] pub unsafe fn as_ref(&self) -> &T { @@ -130,6 +148,24 @@ impl NonNull { /// The resulting lifetime is bound to self so this behaves "as if" /// it were actually an instance of T that is getting borrowed. If a longer /// (unbound) lifetime is needed, use `&mut *my_ptr.as_ptr()`. + /// + /// # Safety + /// + /// When calling this method, you have to ensure that all of the following is true: + /// - `self` is properly aligned + /// - `self` must point to an initialized instance of T; in particular, the pointer must be + /// "dereferenceable" in the sense defined [here]. + /// + /// This applies even if the result of this method is unused! + /// (The part about being initialized is not yet fully decided, but until + /// it is the only safe approach is to ensure that they are indeed initialized.) + /// + /// Additionally, the lifetime of `self` does not necessarily reflect the actual + /// lifetime of the data. *You* must enforce Rust's aliasing rules. In particular, + /// for the duration of this lifetime, the memory this pointer points to must not + /// get accessed (read or written) through any other pointer. + /// + /// [here]: crate::ptr#safety #[stable(feature = "nonnull", since = "1.25.0")] #[inline] pub unsafe fn as_mut(&mut self) -> &mut T { From d8cf9aa6931e33a3bdbe21c41e84a27a03406d1f Mon Sep 17 00:00:00 2001 From: Slanterns Date: Sat, 8 Aug 2020 20:26:56 +0800 Subject: [PATCH 14/17] Use `&` instead of `let ref` in E0502 `ref` on an entire `let` pattern is discouraged, take a reference with `&` instead. --- src/librustc_error_codes/error_codes/E0502.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/librustc_error_codes/error_codes/E0502.md b/src/librustc_error_codes/error_codes/E0502.md index b90c59f580737..dc3ffdfddd9de 100644 --- a/src/librustc_error_codes/error_codes/E0502.md +++ b/src/librustc_error_codes/error_codes/E0502.md @@ -5,7 +5,7 @@ Erroneous code example: ```compile_fail,E0502 fn bar(x: &mut i32) {} fn foo(a: &mut i32) { - let ref y = a; // a is borrowed as immutable. + let y = &a; // a is borrowed as immutable. bar(a); // error: cannot borrow `*a` as mutable because `a` is also borrowed // as immutable println!("{}", y); @@ -19,7 +19,7 @@ variable before trying to access it mutably: fn bar(x: &mut i32) {} fn foo(a: &mut i32) { bar(a); - let ref y = a; // ok! + let y = &a; // ok! println!("{}", y); } ``` From 1cd8dffdae5826931c59329c168ee956800ee6df Mon Sep 17 00:00:00 2001 From: Alexis Bourget Date: Sat, 8 Aug 2020 15:57:17 +0200 Subject: [PATCH 15/17] Add an example about the behaviour of move and Fn* traits --- library/std/src/keyword_docs.rs | 22 +++++++++++++++++----- 1 file changed, 17 insertions(+), 5 deletions(-) diff --git a/library/std/src/keyword_docs.rs b/library/std/src/keyword_docs.rs index 93776328290d3..ff343625a19ed 100644 --- a/library/std/src/keyword_docs.rs +++ b/library/std/src/keyword_docs.rs @@ -945,11 +945,6 @@ mod mod_keyword {} /// `move` converts any variables captured by reference or mutable reference /// to owned by value variables. /// -/// Note: `move` closures may still implement [`Fn`] or [`FnMut`], even though -/// they capture variables by `move`. This is because the traits implemented by -/// a closure type are determined by *what* the closure does with captured -/// values, not *how* it captures them. -/// /// ```rust /// let capture = "hello"; /// let closure = move || { @@ -957,6 +952,23 @@ mod mod_keyword {} /// }; /// ``` /// +/// Note: `move` closures may still implement [`Fn`] or [`FnMut`], even though +/// they capture variables by `move`. This is because the traits implemented by +/// a closure type are determined by *what* the closure does with captured +/// values, not *how* it captures them: +/// +/// ```rust +/// fn create_fn() -> impl Fn() { +/// let text = "Fn".to_owned(); +/// +/// move || println!("This is a: {}", text) +/// } +/// +/// let fn_plain = create_fn(); +/// +/// fn_plain(); +/// ``` +/// /// `move` is often used when [threads] are involved. /// /// ```rust From 259d35011168d68e5adcdaf02ab0a00e2f05c7a4 Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Sat, 8 Aug 2020 13:59:54 +0200 Subject: [PATCH 16/17] Clean up E0750 explanation --- src/librustc_error_codes/error_codes/E0750.md | 22 +++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/src/librustc_error_codes/error_codes/E0750.md b/src/librustc_error_codes/error_codes/E0750.md index e0cf56f716f9d..905e852f8d579 100644 --- a/src/librustc_error_codes/error_codes/E0750.md +++ b/src/librustc_error_codes/error_codes/E0750.md @@ -1,4 +1,18 @@ -Negative impls cannot be default impls. A default impl supplies -default values for the items within to be used by other impls, whereas -a negative impl declares that there are no other impls. These don't -make sense to combine. +A negative impl was made default impl. + +Erroneous code example: + +```compile_fail,E0750 +# #![feature(negative_impls)] +# #![feature(specialization)] +trait MyTrait { + type Foo; +} + +default impl !MyTrait for u32 {} // error! +# fn main() {} +``` + +Negative impls cannot be default impls. A default impl supplies default values +for the items within to be used by other impls, whereas a negative impl declares +that there are no other impls. Combining it does not make sense. From 17db7a4b5ca2f6439d8b8699029c060717e217f8 Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Sat, 8 Aug 2020 14:00:36 +0200 Subject: [PATCH 17/17] Remove E0750 from unchecked error codes --- src/tools/tidy/src/error_codes_check.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/tools/tidy/src/error_codes_check.rs b/src/tools/tidy/src/error_codes_check.rs index 51f135d376161..9c36d853ef78d 100644 --- a/src/tools/tidy/src/error_codes_check.rs +++ b/src/tools/tidy/src/error_codes_check.rs @@ -16,8 +16,7 @@ const EXEMPTED_FROM_TEST: &[&str] = &[ ]; // Some error codes don't have any tests apparently... -const IGNORE_EXPLANATION_CHECK: &[&str] = - &["E0570", "E0601", "E0602", "E0639", "E0729", "E0749", "E0750"]; +const IGNORE_EXPLANATION_CHECK: &[&str] = &["E0570", "E0601", "E0602", "E0639", "E0729", "E0749"]; fn check_error_code_explanation( f: &str,