From: Ethan Brierley Date: Mon, 26 Oct 2020 18:14:12 +0000 (+0000) Subject: Apply suggested changes X-Git-Url: https://git.lizzy.rs/?a=commitdiff_plain;h=ad2d93da1f051970555a8be0baa8e6277b3a06c1;p=rust.git Apply suggested changes --- diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs index 37bc1a305b2..fa885ce2e7c 100644 --- a/compiler/rustc_middle/src/lib.rs +++ b/compiler/rustc_middle/src/lib.rs @@ -46,6 +46,7 @@ #![feature(crate_visibility_modifier)] #![feature(associated_type_bounds)] #![feature(rustc_attrs)] +#![feature(int_error_matching)] #![recursion_limit = "512"] #[macro_use] diff --git a/compiler/rustc_middle/src/middle/limits.rs b/compiler/rustc_middle/src/middle/limits.rs index e0d171fa771..9ff2b7f08fe 100644 --- a/compiler/rustc_middle/src/middle/limits.rs +++ b/compiler/rustc_middle/src/middle/limits.rs @@ -50,8 +50,10 @@ fn update_limit( let error_str = match e.kind() { IntErrorKind::PosOverflow => "`limit` is too large", IntErrorKind::Empty => "`limit` must be a non-negative integer", - IntErrorKind::InvalidDigit(_) => "not a valid integer", - IntErrorKind::NegOverflow => bug!("`limit` should never underflow"), + IntErrorKind::InvalidDigit => "not a valid integer", + IntErrorKind::NegOverflow => { + bug!("`limit` should never negatively underflow") + } IntErrorKind::Zero => bug!("zero is a valid `limit`"), kind => bug!("unimplemented IntErrorKind variant: {:?}", kind), }; diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs index 63ca6e517d2..d67ad30e123 100644 --- a/library/core/src/lib.rs +++ b/library/core/src/lib.rs @@ -151,6 +151,7 @@ #![feature(slice_ptr_get)] #![feature(no_niche)] // rust-lang/rust#68303 #![feature(unsafe_block_in_unsafe_fn)] +#![feature(int_error_matching)] #![deny(unsafe_op_in_unsafe_fn)] #[prelude_import] diff --git a/library/core/src/num/error.rs b/library/core/src/num/error.rs index e1684719ab4..9d8c8c86291 100644 --- a/library/core/src/num/error.rs +++ b/library/core/src/num/error.rs @@ -77,20 +77,26 @@ pub struct ParseIntError { /// # Example /// /// ``` +/// #![feature(int_error_matching)] +/// /// # fn main() { /// if let Err(e) = i32::from_str_radix("a12", 10) { /// println!("Failed conversion to i32: {:?}", e.kind()); /// } /// # } /// ``` -#[stable(feature = "int_error_matching", since = "1.47.0")] +#[unstable( + feature = "int_error_matching", + reason = "it can be useful to match errors when making error messages \ + for integer parsing", + issue = "22639" +)] #[derive(Debug, Clone, PartialEq, Eq)] #[non_exhaustive] pub enum IntErrorKind { /// Value being parsed is empty. /// /// Among other causes, this variant will be constructed when parsing an empty string. - #[stable(feature = "int_error_matching", since = "1.47.0")] Empty, /// Contains an invalid digit in its context. /// @@ -99,25 +105,26 @@ pub enum IntErrorKind { /// /// This variant is also constructed when a `+` or `-` is misplaced within a string /// either on its own or in the middle of a number. - #[stable(feature = "int_error_matching", since = "1.47.0")] - InvalidDigit(#[stable(feature = "int_error_matching", since = "1.47.0")] char), + InvalidDigit, /// Integer is too large to store in target integer type. - #[stable(feature = "int_error_matching", since = "1.47.0")] PosOverflow, /// Integer is too small to store in target integer type. - #[stable(feature = "int_error_matching", since = "1.47.0")] NegOverflow, /// Value was Zero /// /// This variant will be emitted when the parsing string has a value of zero, which /// would be illegal for non-zero types. - #[stable(feature = "int_error_matching", since = "1.47.0")] Zero, } impl ParseIntError { /// Outputs the detailed cause of parsing an integer failing. - #[stable(feature = "int_error_matching", since = "1.47.0")] + #[unstable( + feature = "int_error_matching", + reason = "it can be useful to match errors when making error messages \ + for integer parsing", + issue = "22639" + )] pub fn kind(&self) -> &IntErrorKind { &self.kind } @@ -131,7 +138,7 @@ pub fn kind(&self) -> &IntErrorKind { pub fn __description(&self) -> &str { match self.kind { IntErrorKind::Empty => "cannot parse integer from empty string", - IntErrorKind::InvalidDigit(_) => "invalid digit found in string", + IntErrorKind::InvalidDigit => "invalid digit found in string", IntErrorKind::PosOverflow => "number too large to fit in target type", IntErrorKind::NegOverflow => "number too small to fit in target type", IntErrorKind::Zero => "number would be zero for non-zero type", diff --git a/library/core/src/num/mod.rs b/library/core/src/num/mod.rs index fd00a072d89..71448a622c0 100644 --- a/library/core/src/num/mod.rs +++ b/library/core/src/num/mod.rs @@ -63,7 +63,12 @@ macro_rules! doc_comment { #[stable(feature = "try_from", since = "1.34.0")] pub use error::TryFromIntError; -#[stable(feature = "int_error_matching", since = "1.47.0")] +#[unstable( + feature = "int_error_matching", + reason = "it can be useful to match errors when making error messages \ + for integer parsing", + issue = "22639" +)] pub use error::IntErrorKind; macro_rules! usize_isize_to_xe_bytes_doc { @@ -831,7 +836,7 @@ fn from_str_radix(src: &str, radix: u32) -> Result { - return Err(PIE { kind: InvalidDigit(src[0] as char) }); + return Err(PIE { kind: InvalidDigit }); } b'+' => (true, &src[1..]), b'-' if is_signed_ty => (false, &src[1..]), @@ -844,7 +849,7 @@ fn from_str_radix(src: &str, radix: u32) -> Result x, - None => return Err(PIE { kind: InvalidDigit(c as char) }), + None => return Err(PIE { kind: InvalidDigit }), }; result = match result.checked_mul(radix) { Some(result) => result, @@ -860,7 +865,7 @@ fn from_str_radix(src: &str, radix: u32) -> Result x, - None => return Err(PIE { kind: InvalidDigit(c as char) }), + None => return Err(PIE { kind: InvalidDigit }), }; result = match result.checked_mul(radix) { Some(result) => result, diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs index c128691fa75..d8b36beb3e0 100644 --- a/library/core/tests/lib.rs +++ b/library/core/tests/lib.rs @@ -37,6 +37,7 @@ #![feature(try_trait)] #![feature(slice_internals)] #![feature(slice_partition_dedup)] +#![feature(int_error_matching)] #![feature(array_value_iter)] #![feature(iter_partition_in_place)] #![feature(iter_is_partitioned)] diff --git a/library/core/tests/nonzero.rs b/library/core/tests/nonzero.rs index 949d4ea32f0..fb1293c99bb 100644 --- a/library/core/tests/nonzero.rs +++ b/library/core/tests/nonzero.rs @@ -131,7 +131,7 @@ fn test_from_str() { assert_eq!("0".parse::().err().map(|e| e.kind().clone()), Some(IntErrorKind::Zero)); assert_eq!( "-1".parse::().err().map(|e| e.kind().clone()), - Some(IntErrorKind::InvalidDigit('-')) + Some(IntErrorKind::InvalidDigit) ); assert_eq!( "-129".parse::().err().map(|e| e.kind().clone()), diff --git a/library/core/tests/num/mod.rs b/library/core/tests/num/mod.rs index 12e52252278..7c25c32fb40 100644 --- a/library/core/tests/num/mod.rs +++ b/library/core/tests/num/mod.rs @@ -118,14 +118,14 @@ fn test_leading_plus() { #[test] fn test_invalid() { - test_parse::("--129", Err(IntErrorKind::InvalidDigit('-'))); - test_parse::("++129", Err(IntErrorKind::InvalidDigit('+'))); - test_parse::("Съешь", Err(IntErrorKind::InvalidDigit('Ð'))); - test_parse::("123Hello", Err(IntErrorKind::InvalidDigit('H'))); - test_parse::("--", Err(IntErrorKind::InvalidDigit('-'))); - test_parse::("-", Err(IntErrorKind::InvalidDigit('-'))); - test_parse::("+", Err(IntErrorKind::InvalidDigit('+'))); - test_parse::("-1", Err(IntErrorKind::InvalidDigit('-'))); + test_parse::("--129", Err(IntErrorKind::InvalidDigit)); + test_parse::("++129", Err(IntErrorKind::InvalidDigit)); + test_parse::("Съешь", Err(IntErrorKind::InvalidDigit)); + test_parse::("123Hello", Err(IntErrorKind::InvalidDigit)); + test_parse::("--", Err(IntErrorKind::InvalidDigit)); + test_parse::("-", Err(IntErrorKind::InvalidDigit)); + test_parse::("+", Err(IntErrorKind::InvalidDigit)); + test_parse::("-1", Err(IntErrorKind::InvalidDigit)); } #[test] diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs index fa23229066c..ac0075ad129 100644 --- a/library/std/src/lib.rs +++ b/library/std/src/lib.rs @@ -264,6 +264,7 @@ #![feature(global_asm)] #![feature(hashmap_internals)] #![feature(int_error_internals)] +#![feature(int_error_matching)] #![feature(integer_atomics)] #![feature(into_future)] #![feature(lang_items)] diff --git a/library/std/src/num.rs b/library/std/src/num.rs index ac3b055cdb0..0f1c5962685 100644 --- a/library/std/src/num.rs +++ b/library/std/src/num.rs @@ -22,7 +22,12 @@ #[stable(feature = "nonzero", since = "1.28.0")] pub use core::num::{NonZeroU128, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize}; -#[stable(feature = "int_error_matching", since = "1.47.0")] +#[unstable( + feature = "int_error_matching", + reason = "it can be useful to match errors when making error messages \ + for integer parsing", + issue = "22639" +)] pub use core::num::IntErrorKind; #[cfg(test)]