Skip to content

Commit c1d01b6

Browse files
rust-timerrust-timer
authored
Unrolled build for #153178
Rollup merge of #153178 - sorairolake:feature/try-from-int-error-kind, r=tgross35 Add `TryFromIntError::kind` method and `IntErrorKind::NotAPowerOfTwo` variant - ACP: rust-lang/libs-team#746 - Tracking issue: #153978 This pull request adds `kind` method to [`TryFromIntError`](https://doc.rust-lang.org/core/num/struct.TryFromIntError.html), which outputs the detailed cause of converting an integer failing. This is primarily intended for use in cases where there are multiple causes for failure, such as converting from a large signed integer type to a small signed integer type. At the moment, this method returns [`&IntErrorKind`](https://doc.rust-lang.org/core/num/enum.IntErrorKind.html). This type implements the `Copy` trait and could return `IntErrorKind`, but returns a reference to align with the behavior of [`ParseIntError::kind`](https://doc.rust-lang.org/core/num/struct.ParseIntError.html#method.kind). If it is not necessary to align the behavior of `TryFromIntError::kind` with `ParseIntError::kind`, I'll change this method to return `IntErrorKind`. Before this pull request, `IntErrorKind` was only used by [`ParseIntError`](https://doc.rust-lang.org/core/num/struct.ParseIntError.html), but I changed it to be used by `TryFromIntError` as well, so I updated `IntErrorKind`'s documentation. [`impl TryFrom<usize> for Alignment`](https://doc.rust-lang.org/std/ptr/struct.Alignment.html#impl-TryFrom%3Cusize%3E-for-Alignment) returns `TryFromIntError` as an error if the given value is not a power of two. However, `IntErrorKind` does not have a variant that represents this. So I added the variant `NotAPowerOfTwo` to represent this. For this variant to stabilize, both `try_from_int_error_kind` and `ptr_alignment_type` features must be stabilized.
2 parents f29256d + c35ed1a commit c1d01b6

6 files changed

Lines changed: 126 additions & 32 deletions

File tree

‎library/core/src/convert/num.rs‎

Lines changed: 31 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
use crate::num::TryFromIntError;
1+
use crate::num::{IntErrorKind, TryFromIntError};
22

33
mod private {
44
/// This trait being unreachable from outside the crate
@@ -278,7 +278,7 @@ macro_rules! impl_try_from_lower_bounded {
278278
if u >= 0 {
279279
Ok(u as Self)
280280
} else {
281-
Err(TryFromIntError(()))
281+
Err(TryFromIntError(IntErrorKind::NegOverflow))
282282
}
283283
}
284284
}
@@ -299,7 +299,7 @@ macro_rules! impl_try_from_upper_bounded {
299299
#[inline]
300300
fn try_from(u: $source) -> Result<Self, Self::Error> {
301301
if u > (Self::MAX as $source) {
302-
Err(TryFromIntError(()))
302+
Err(TryFromIntError(IntErrorKind::PosOverflow))
303303
} else {
304304
Ok(u as Self)
305305
}
@@ -323,8 +323,10 @@ macro_rules! impl_try_from_both_bounded {
323323
fn try_from(u: $source) -> Result<Self, Self::Error> {
324324
let min = Self::MIN as $source;
325325
let max = Self::MAX as $source;
326-
if u < min || u > max {
327-
Err(TryFromIntError(()))
326+
if u < min {
327+
Err(TryFromIntError(IntErrorKind::NegOverflow))
328+
} else if u > max {
329+
Err(TryFromIntError(IntErrorKind::PosOverflow))
328330
} else {
329331
Ok(u as Self)
330332
}
@@ -335,7 +337,7 @@ macro_rules! impl_try_from_both_bounded {
335337

336338
/// Implement `TryFrom<integer>` for `bool`
337339
macro_rules! impl_try_from_integer_for_bool {
338-
($($int:ty)+) => {$(
340+
($signedness:ident $($int:ty)+) => {$(
339341
#[stable(feature = "bool_try_from_int", since = "1.95.0")]
340342
#[rustc_const_unstable(feature = "const_convert", issue = "143773")]
341343
impl const TryFrom<$int> for bool {
@@ -355,10 +357,23 @@ macro_rules! impl_try_from_integer_for_bool {
355357
/// ```
356358
#[inline]
357359
fn try_from(i: $int) -> Result<Self, Self::Error> {
358-
match i {
359-
0 => Ok(false),
360-
1 => Ok(true),
361-
_ => Err(TryFromIntError(())),
360+
sign_dependent_expr!{
361+
$signedness ?
362+
if signed {
363+
match i {
364+
0 => Ok(false),
365+
1 => Ok(true),
366+
..0 => Err(TryFromIntError(IntErrorKind::NegOverflow)),
367+
2.. => Err(TryFromIntError(IntErrorKind::PosOverflow)),
368+
}
369+
}
370+
if unsigned {
371+
match i {
372+
0 => Ok(false),
373+
1 => Ok(true),
374+
2.. => Err(TryFromIntError(IntErrorKind::PosOverflow)),
375+
}
376+
}
362377
}
363378
}
364379
}
@@ -372,8 +387,8 @@ macro_rules! rev {
372387
}
373388

374389
// integer -> bool
375-
impl_try_from_integer_for_bool!(u128 u64 u32 u16 u8);
376-
impl_try_from_integer_for_bool!(i128 i64 i32 i16 i8);
390+
impl_try_from_integer_for_bool!(unsigned u128 u64 u32 u16 u8);
391+
impl_try_from_integer_for_bool!(signed i128 i64 i32 i16 i8);
377392

378393
// unsigned integer -> unsigned integer
379394
impl_try_from_upper_bounded!(u16 => u8);
@@ -411,7 +426,7 @@ impl_try_from_lower_bounded!(isize => usize);
411426

412427
#[cfg(target_pointer_width = "16")]
413428
mod ptr_try_from_impls {
414-
use super::TryFromIntError;
429+
use super::{IntErrorKind, TryFromIntError};
415430

416431
impl_try_from_upper_bounded!(usize => u8);
417432
impl_try_from_unbounded!(usize => u16, u32, u64, u128);
@@ -433,7 +448,7 @@ mod ptr_try_from_impls {
433448

434449
#[cfg(target_pointer_width = "32")]
435450
mod ptr_try_from_impls {
436-
use super::TryFromIntError;
451+
use super::{IntErrorKind, TryFromIntError};
437452

438453
impl_try_from_upper_bounded!(usize => u8, u16);
439454
impl_try_from_unbounded!(usize => u32, u64, u128);
@@ -458,7 +473,7 @@ mod ptr_try_from_impls {
458473

459474
#[cfg(target_pointer_width = "64")]
460475
mod ptr_try_from_impls {
461-
use super::TryFromIntError;
476+
use super::{IntErrorKind, TryFromIntError};
462477

463478
impl_try_from_upper_bounded!(usize => u8, u16, u32);
464479
impl_try_from_unbounded!(usize => u64, u128);
@@ -556,7 +571,7 @@ macro_rules! impl_nonzero_int_try_from_int {
556571
#[doc = concat!("to <code>[NonZero]\\<[", stringify!($Int), "]></code>.")]
557572
#[inline]
558573
fn try_from(value: $Int) -> Result<Self, Self::Error> {
559-
Self::new(value).ok_or(TryFromIntError(()))
574+
Self::new(value).ok_or(TryFromIntError(IntErrorKind::Zero))
560575
}
561576
}
562577
};

‎library/core/src/mem/alignment.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -281,7 +281,7 @@ impl const TryFrom<usize> for Alignment {
281281

282282
#[inline]
283283
fn try_from(align: usize) -> Result<Alignment, Self::Error> {
284-
Self::new(align).ok_or(num::TryFromIntError(()))
284+
Self::new(align).ok_or(num::TryFromIntError(num::IntErrorKind::NotAPowerOfTwo))
285285
}
286286
}
287287

‎library/core/src/num/error.rs‎

Lines changed: 24 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,16 @@ use crate::fmt;
77
/// The error type returned when a checked integral type conversion fails.
88
#[stable(feature = "try_from", since = "1.34.0")]
99
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
10-
pub struct TryFromIntError(pub(crate) ());
10+
pub struct TryFromIntError(pub(crate) IntErrorKind);
11+
12+
impl TryFromIntError {
13+
/// Outputs the detailed cause of converting an integer failing.
14+
#[must_use]
15+
#[unstable(feature = "try_from_int_error_kind", issue = "153978")]
16+
pub const fn kind(&self) -> &IntErrorKind {
17+
&self.0
18+
}
19+
}
1120

1221
#[stable(feature = "try_from", since = "1.34.0")]
1322
impl fmt::Display for TryFromIntError {
@@ -66,7 +75,8 @@ pub struct ParseIntError {
6675
pub(super) kind: IntErrorKind,
6776
}
6877

69-
/// Enum to store the various types of errors that can cause parsing an integer to fail.
78+
/// Enum to store the various types of errors that can cause parsing or converting an
79+
/// integer to fail.
7080
///
7181
/// # Example
7282
///
@@ -103,10 +113,19 @@ pub enum IntErrorKind {
103113
NegOverflow,
104114
/// Value was Zero
105115
///
106-
/// This variant will be emitted when the parsing string has a value of zero, which
107-
/// would be illegal for non-zero types.
116+
/// This variant will be emitted when the parsing string or the converting integer
117+
/// has a value of zero, which would be illegal for non-zero types.
108118
#[stable(feature = "int_error_matching", since = "1.55.0")]
109119
Zero,
120+
/// Value is not a power of two.
121+
///
122+
/// This variant will be emitted when converting an integer that is not a power of
123+
/// two. This is required in some cases such as constructing an [`Alignment`].
124+
///
125+
/// [`Alignment`]: core::ptr::Alignment "ptr::Alignment"
126+
#[unstable(feature = "try_from_int_error_kind", issue = "153978")]
127+
// Also, #[unstable(feature = "ptr_alignment_type", issue = "102070")]
128+
NotAPowerOfTwo,
110129
}
111130

112131
impl ParseIntError {
@@ -128,6 +147,7 @@ impl fmt::Display for ParseIntError {
128147
IntErrorKind::PosOverflow => "number too large to fit in target type",
129148
IntErrorKind::NegOverflow => "number too small to fit in target type",
130149
IntErrorKind::Zero => "number would be zero for non-zero type",
150+
IntErrorKind::NotAPowerOfTwo => "number is not a power of two",
131151
}
132152
.fmt(f)
133153
}

‎library/coretests/tests/lib.rs‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -117,6 +117,7 @@
117117
#![feature(trusted_random_access)]
118118
#![feature(try_blocks)]
119119
#![feature(try_find)]
120+
#![feature(try_from_int_error_kind)]
120121
#![feature(try_trait_v2)]
121122
#![feature(type_info)]
122123
#![feature(uint_carryless_mul)]

‎library/coretests/tests/nonzero.rs‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -282,11 +282,11 @@ fn test_nonzero_from_int_on_success() {
282282

283283
#[test]
284284
fn test_nonzero_from_int_on_err() {
285-
assert!(NonZero::<u8>::try_from(0).is_err());
286-
assert!(NonZero::<u32>::try_from(0).is_err());
285+
assert_eq!(NonZero::<u8>::try_from(0).unwrap_err().kind(), &IntErrorKind::Zero);
286+
assert_eq!(NonZero::<u32>::try_from(0).unwrap_err().kind(), &IntErrorKind::Zero);
287287

288-
assert!(NonZero::<i8>::try_from(0).is_err());
289-
assert!(NonZero::<i32>::try_from(0).is_err());
288+
assert_eq!(NonZero::<i8>::try_from(0).unwrap_err().kind(), &IntErrorKind::Zero);
289+
assert_eq!(NonZero::<i32>::try_from(0).unwrap_err().kind(), &IntErrorKind::Zero);
290290
}
291291

292292
#[test]

‎library/coretests/tests/num/mod.rs‎

Lines changed: 65 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -374,6 +374,43 @@ fn test_f32f64() {
374374
assert!(nan.is_nan());
375375
}
376376

377+
/// Conversions where $source can be represented as bool.
378+
macro_rules! test_impl_try_from_integer_to_bool {
379+
($fn_name:ident, $source:ty) => {
380+
#[test]
381+
fn $fn_name() {
382+
let max: $source = <$source>::MAX;
383+
let min: $source = <$source>::MIN;
384+
let zero: $source = 0;
385+
let one: $source = 1;
386+
let two: $source = 2;
387+
assert_eq!(bool::try_from(max).unwrap_err().kind(), &IntErrorKind::PosOverflow);
388+
if min != 0 {
389+
assert_eq!(bool::try_from(min).unwrap_err().kind(), &IntErrorKind::NegOverflow);
390+
assert_eq!(
391+
bool::try_from(zero - 1).unwrap_err().kind(),
392+
&IntErrorKind::NegOverflow
393+
);
394+
}
395+
assert_eq!(bool::try_from(zero).unwrap(), false);
396+
assert_eq!(bool::try_from(one).unwrap(), true);
397+
assert_eq!(bool::try_from(two).unwrap_err().kind(), &IntErrorKind::PosOverflow);
398+
}
399+
};
400+
}
401+
402+
test_impl_try_from_integer_to_bool! { test_try_u8bool, u8 }
403+
test_impl_try_from_integer_to_bool! { test_try_u16bool, u16 }
404+
test_impl_try_from_integer_to_bool! { test_try_u32bool, u32 }
405+
test_impl_try_from_integer_to_bool! { test_try_u64bool, u64 }
406+
test_impl_try_from_integer_to_bool! { test_try_u128bool, u128 }
407+
408+
test_impl_try_from_integer_to_bool! { test_try_i8bool, i8 }
409+
test_impl_try_from_integer_to_bool! { test_try_i16bool, i16 }
410+
test_impl_try_from_integer_to_bool! { test_try_i32bool, i32 }
411+
test_impl_try_from_integer_to_bool! { test_try_i64bool, i64 }
412+
test_impl_try_from_integer_to_bool! { test_try_i128bool, i128 }
413+
377414
/// Conversions where the full width of $source can be represented as $target
378415
macro_rules! test_impl_try_from_always_ok {
379416
($fn_name:ident, $source:ty, $target: ty) => {
@@ -497,9 +534,15 @@ macro_rules! test_impl_try_from_signed_to_unsigned_upper_ok {
497534
let zero: $source = 0;
498535
let neg_one: $source = -1;
499536
assert_eq!(<$target as TryFrom<$source>>::try_from(max).unwrap(), max as $target);
500-
assert!(<$target as TryFrom<$source>>::try_from(min).is_err());
537+
assert_eq!(
538+
<$target as TryFrom<$source>>::try_from(min).unwrap_err().kind(),
539+
&IntErrorKind::NegOverflow
540+
);
501541
assert_eq!(<$target as TryFrom<$source>>::try_from(zero).unwrap(), zero as $target);
502-
assert!(<$target as TryFrom<$source>>::try_from(neg_one).is_err());
542+
assert_eq!(
543+
<$target as TryFrom<$source>>::try_from(neg_one).unwrap_err().kind(),
544+
&IntErrorKind::NegOverflow
545+
);
503546
}
504547
};
505548
}
@@ -560,7 +603,10 @@ macro_rules! test_impl_try_from_unsigned_to_signed_upper_err {
560603
let max = <$source>::MAX;
561604
let min = <$source>::MIN;
562605
let zero: $source = 0;
563-
assert!(<$target as TryFrom<$source>>::try_from(max).is_err());
606+
assert_eq!(
607+
<$target as TryFrom<$source>>::try_from(max).unwrap_err().kind(),
608+
&IntErrorKind::PosOverflow
609+
);
564610
assert_eq!(<$target as TryFrom<$source>>::try_from(min).unwrap(), min as $target);
565611
assert_eq!(<$target as TryFrom<$source>>::try_from(zero).unwrap(), zero as $target);
566612
}
@@ -623,9 +669,15 @@ macro_rules! test_impl_try_from_same_sign_err {
623669
let zero: $source = 0;
624670
let t_max = <$target>::MAX;
625671
let t_min = <$target>::MIN;
626-
assert!(<$target as TryFrom<$source>>::try_from(max).is_err());
672+
assert_eq!(
673+
<$target as TryFrom<$source>>::try_from(max).unwrap_err().kind(),
674+
&IntErrorKind::PosOverflow
675+
);
627676
if min != 0 {
628-
assert!(<$target as TryFrom<$source>>::try_from(min).is_err());
677+
assert_eq!(
678+
<$target as TryFrom<$source>>::try_from(min).unwrap_err().kind(),
679+
&IntErrorKind::NegOverflow
680+
);
629681
}
630682
assert_eq!(<$target as TryFrom<$source>>::try_from(zero).unwrap(), zero as $target);
631683
assert_eq!(
@@ -712,8 +764,14 @@ macro_rules! test_impl_try_from_signed_to_unsigned_err {
712764
let zero: $source = 0;
713765
let t_max = <$target>::MAX;
714766
let t_min = <$target>::MIN;
715-
assert!(<$target as TryFrom<$source>>::try_from(max).is_err());
716-
assert!(<$target as TryFrom<$source>>::try_from(min).is_err());
767+
assert_eq!(
768+
<$target as TryFrom<$source>>::try_from(max).unwrap_err().kind(),
769+
&IntErrorKind::PosOverflow
770+
);
771+
assert_eq!(
772+
<$target as TryFrom<$source>>::try_from(min).unwrap_err().kind(),
773+
&IntErrorKind::NegOverflow
774+
);
717775
assert_eq!(<$target as TryFrom<$source>>::try_from(zero).unwrap(), zero as $target);
718776
assert_eq!(
719777
<$target as TryFrom<$source>>::try_from(t_max as $source).unwrap(),

0 commit comments

Comments
 (0)