parent
936b32a514
commit
a9779df188
|
@ -20,18 +20,19 @@
|
||||||
//! - Impl the `As*` traits for reference-to-reference conversions
|
//! - Impl the `As*` traits for reference-to-reference conversions
|
||||||
//! - Impl the `Into` trait when you want to consume the value in the conversion
|
//! - Impl the `Into` trait when you want to consume the value in the conversion
|
||||||
//! - The `From` trait is the most flexible, useful for value _and_ reference conversions
|
//! - The `From` trait is the most flexible, useful for value _and_ reference conversions
|
||||||
|
//! - The `TryFrom` and `TryInto` traits behave like `From` and `Into`, but allow for the
|
||||||
|
//! conversion to fail
|
||||||
//!
|
//!
|
||||||
//! As a library author, you should prefer implementing `From<T>` rather than
|
//! As a library author, you should prefer implementing `From<T>` or `TryFrom<T>` rather than
|
||||||
//! `Into<U>`, as `From` provides greater flexibility and offers an equivalent `Into`
|
//! `Into<U>` or `TryInto<U>`, as `From` and `TryFrom` provide greater flexibility and offer
|
||||||
//! implementation for free, thanks to a blanket implementation in the standard library.
|
//! equivalent `Into` or `TryInto` implementations for free, thanks to a blanket implementation
|
||||||
//!
|
//! in the standard library.
|
||||||
//! **Note: these traits must not fail**. If the conversion can fail, you must use a dedicated
|
|
||||||
//! method which returns an `Option<T>` or a `Result<T, E>`.
|
|
||||||
//!
|
//!
|
||||||
//! # Generic impl
|
//! # Generic impl
|
||||||
//!
|
//!
|
||||||
//! - `AsRef` and `AsMut` auto-dereference if the inner type is a reference
|
//! - `AsRef` and `AsMut` auto-dereference if the inner type is a reference
|
||||||
//! - `From<U> for T` implies `Into<T> for U`
|
//! - `From<U> for T` implies `Into<T> for U`
|
||||||
|
//! - `TryFrom<U> for T` implies `TryInto<T> for U`
|
||||||
//! - `From` and `Into` are reflexive, which means that all types can `into()`
|
//! - `From` and `Into` are reflexive, which means that all types can `into()`
|
||||||
//! themselves and `from()` themselves
|
//! themselves and `from()` themselves
|
||||||
//!
|
//!
|
||||||
|
@ -40,6 +41,7 @@
|
||||||
#![stable(feature = "rust1", since = "1.0.0")]
|
#![stable(feature = "rust1", since = "1.0.0")]
|
||||||
|
|
||||||
use marker::Sized;
|
use marker::Sized;
|
||||||
|
use result::Result;
|
||||||
|
|
||||||
/// A cheap, reference-to-reference conversion.
|
/// A cheap, reference-to-reference conversion.
|
||||||
///
|
///
|
||||||
|
@ -98,8 +100,8 @@ pub trait AsMut<T: ?Sized> {
|
||||||
|
|
||||||
/// A conversion that consumes `self`, which may or may not be expensive.
|
/// A conversion that consumes `self`, which may or may not be expensive.
|
||||||
///
|
///
|
||||||
/// **Note: this trait must not fail**. If the conversion can fail, use a dedicated method which
|
/// **Note: this trait must not fail**. If the conversion can fail, use `TryInto` or a dedicated
|
||||||
/// returns an `Option<T>` or a `Result<T, E>`.
|
/// method which returns an `Option<T>` or a `Result<T, E>`.
|
||||||
///
|
///
|
||||||
/// Library authors should not directly implement this trait, but should prefer implementing
|
/// Library authors should not directly implement this trait, but should prefer implementing
|
||||||
/// the `From` trait, which offers greater flexibility and provides an equivalent `Into`
|
/// the `From` trait, which offers greater flexibility and provides an equivalent `Into`
|
||||||
|
@ -133,8 +135,8 @@ pub trait Into<T>: Sized {
|
||||||
|
|
||||||
/// Construct `Self` via a conversion.
|
/// Construct `Self` via a conversion.
|
||||||
///
|
///
|
||||||
/// **Note: this trait must not fail**. If the conversion can fail, use a dedicated method which
|
/// **Note: this trait must not fail**. If the conversion can fail, use `TryFrom` or a dedicated
|
||||||
/// returns an `Option<T>` or a `Result<T, E>`.
|
/// method which returns an `Option<T>` or a `Result<T, E>`.
|
||||||
///
|
///
|
||||||
/// # Examples
|
/// # Examples
|
||||||
///
|
///
|
||||||
|
@ -158,6 +160,30 @@ pub trait From<T>: Sized {
|
||||||
fn from(T) -> Self;
|
fn from(T) -> Self;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// An attempted conversion that consumes `self`, which may or may not be expensive.
|
||||||
|
///
|
||||||
|
/// Library authors should not directly implement this trait, but should prefer implementing
|
||||||
|
/// the `TryFrom` trait, which offers greater flexibility and provides an equivalent `TryInto`
|
||||||
|
/// implementation for free, thanks to a blanket implementation in the standard library.
|
||||||
|
#[unstable(feature = "try_from", issue = "33417")]
|
||||||
|
pub trait TryInto<T>: Sized {
|
||||||
|
/// The type returned in the event of a conversion error.
|
||||||
|
type Err;
|
||||||
|
|
||||||
|
/// Performs the conversion.
|
||||||
|
fn try_into(self) -> Result<T, Self::Err>;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Attempt to construct `Self` via a conversion.
|
||||||
|
#[unstable(feature = "try_from", issue = "33417")]
|
||||||
|
pub trait TryFrom<T>: Sized {
|
||||||
|
/// The type returned in the event of a conversion error.
|
||||||
|
type Err;
|
||||||
|
|
||||||
|
/// Performs the conversion.
|
||||||
|
fn try_from(T) -> Result<Self, Self::Err>;
|
||||||
|
}
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
////////////////////////////////////////////////////////////////////////////////
|
||||||
// GENERIC IMPLS
|
// GENERIC IMPLS
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
////////////////////////////////////////////////////////////////////////////////
|
||||||
|
@ -216,6 +242,17 @@ impl<T> From<T> for T {
|
||||||
fn from(t: T) -> T { t }
|
fn from(t: T) -> T { t }
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// TryFrom implies TryInto
|
||||||
|
#[unstable(feature = "try_from", issue = "33417")]
|
||||||
|
impl<T, U> TryInto<U> for T where U: TryFrom<T> {
|
||||||
|
type Err = U::Err;
|
||||||
|
|
||||||
|
fn try_into(self) -> Result<U, U::Err> {
|
||||||
|
U::try_from(self)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
////////////////////////////////////////////////////////////////////////////////
|
||||||
// CONCRETE IMPLS
|
// CONCRETE IMPLS
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
////////////////////////////////////////////////////////////////////////////////
|
||||||
|
|
|
@ -15,7 +15,7 @@
|
||||||
|
|
||||||
use char::CharExt;
|
use char::CharExt;
|
||||||
use cmp::PartialOrd;
|
use cmp::PartialOrd;
|
||||||
use convert::From;
|
use convert::{From, TryFrom};
|
||||||
use fmt;
|
use fmt;
|
||||||
use intrinsics;
|
use intrinsics;
|
||||||
use marker::{Copy, Sized};
|
use marker::{Copy, Sized};
|
||||||
|
@ -2341,9 +2341,101 @@ macro_rules! from_str_radix_int_impl {
|
||||||
}
|
}
|
||||||
from_str_radix_int_impl! { isize i8 i16 i32 i64 usize u8 u16 u32 u64 }
|
from_str_radix_int_impl! { isize i8 i16 i32 i64 usize u8 u16 u32 u64 }
|
||||||
|
|
||||||
|
/// The error type returned when a checked integral type conversion fails.
|
||||||
|
#[unstable(feature = "try_from", issue = "33417")]
|
||||||
|
#[derive(Debug, Copy, Clone)]
|
||||||
|
pub struct TryFromIntError(());
|
||||||
|
|
||||||
|
impl TryFromIntError {
|
||||||
|
#[unstable(feature = "int_error_internals",
|
||||||
|
reason = "available through Error trait and this method should \
|
||||||
|
not be exposed publicly",
|
||||||
|
issue = "0")]
|
||||||
|
#[doc(hidden)]
|
||||||
|
pub fn __description(&self) -> &str {
|
||||||
|
"out of range integral type conversion attempted"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[unstable(feature = "try_from", issue = "33417")]
|
||||||
|
impl fmt::Display for TryFromIntError {
|
||||||
|
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
||||||
|
self.__description().fmt(fmt)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! same_sign_from_int_impl {
|
||||||
|
($storage:ty, $target:ty, $($source:ty),*) => {$(
|
||||||
|
#[stable(feature = "rust1", since = "1.0.0")]
|
||||||
|
impl TryFrom<$source> for $target {
|
||||||
|
type Err = TryFromIntError;
|
||||||
|
|
||||||
|
fn try_from(u: $source) -> Result<$target, TryFromIntError> {
|
||||||
|
let min = <$target as FromStrRadixHelper>::min_value() as $storage;
|
||||||
|
let max = <$target as FromStrRadixHelper>::max_value() as $storage;
|
||||||
|
if u as $storage < min || u as $storage > max {
|
||||||
|
Err(TryFromIntError(()))
|
||||||
|
} else {
|
||||||
|
Ok(u as $target)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
)*}
|
||||||
|
}
|
||||||
|
|
||||||
|
same_sign_from_int_impl!(u64, u8, u8, u16, u32, u64, usize);
|
||||||
|
same_sign_from_int_impl!(i64, i8, i8, i16, i32, i64, isize);
|
||||||
|
same_sign_from_int_impl!(u64, u16, u8, u16, u32, u64, usize);
|
||||||
|
same_sign_from_int_impl!(i64, i16, i8, i16, i32, i64, isize);
|
||||||
|
same_sign_from_int_impl!(u64, u32, u8, u16, u32, u64, usize);
|
||||||
|
same_sign_from_int_impl!(i64, i32, i8, i16, i32, i64, isize);
|
||||||
|
same_sign_from_int_impl!(u64, u64, u8, u16, u32, u64, usize);
|
||||||
|
same_sign_from_int_impl!(i64, i64, i8, i16, i32, i64, isize);
|
||||||
|
same_sign_from_int_impl!(u64, usize, u8, u16, u32, u64, usize);
|
||||||
|
same_sign_from_int_impl!(i64, isize, i8, i16, i32, i64, isize);
|
||||||
|
|
||||||
|
macro_rules! cross_sign_from_int_impl {
|
||||||
|
($unsigned:ty, $($signed:ty),*) => {$(
|
||||||
|
#[stable(feature = "rust1", since = "1.0.0")]
|
||||||
|
impl TryFrom<$unsigned> for $signed {
|
||||||
|
type Err = TryFromIntError;
|
||||||
|
|
||||||
|
fn try_from(u: $unsigned) -> Result<$signed, TryFromIntError> {
|
||||||
|
let max = <$signed as FromStrRadixHelper>::max_value() as u64;
|
||||||
|
if u as u64 > max {
|
||||||
|
Err(TryFromIntError(()))
|
||||||
|
} else {
|
||||||
|
Ok(u as $signed)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[stable(feature = "rust1", since = "1.0.0")]
|
||||||
|
impl TryFrom<$signed> for $unsigned {
|
||||||
|
type Err = TryFromIntError;
|
||||||
|
|
||||||
|
fn try_from(u: $signed) -> Result<$unsigned, TryFromIntError> {
|
||||||
|
let max = <$unsigned as FromStrRadixHelper>::max_value() as u64;
|
||||||
|
if u < 0 || u as u64 > max {
|
||||||
|
Err(TryFromIntError(()))
|
||||||
|
} else {
|
||||||
|
Ok(u as $unsigned)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
)*}
|
||||||
|
}
|
||||||
|
|
||||||
|
cross_sign_from_int_impl!(u8, i8, i16, i32, i64, isize);
|
||||||
|
cross_sign_from_int_impl!(u16, i8, i16, i32, i64, isize);
|
||||||
|
cross_sign_from_int_impl!(u32, i8, i16, i32, i64, isize);
|
||||||
|
cross_sign_from_int_impl!(u64, i8, i16, i32, i64, isize);
|
||||||
|
cross_sign_from_int_impl!(usize, i8, i16, i32, i64, isize);
|
||||||
|
|
||||||
#[doc(hidden)]
|
#[doc(hidden)]
|
||||||
trait FromStrRadixHelper: PartialOrd + Copy {
|
trait FromStrRadixHelper: PartialOrd + Copy {
|
||||||
fn min_value() -> Self;
|
fn min_value() -> Self;
|
||||||
|
fn max_value() -> Self;
|
||||||
fn from_u32(u: u32) -> Self;
|
fn from_u32(u: u32) -> Self;
|
||||||
fn checked_mul(&self, other: u32) -> Option<Self>;
|
fn checked_mul(&self, other: u32) -> Option<Self>;
|
||||||
fn checked_sub(&self, other: u32) -> Option<Self>;
|
fn checked_sub(&self, other: u32) -> Option<Self>;
|
||||||
|
@ -2353,6 +2445,7 @@ trait FromStrRadixHelper: PartialOrd + Copy {
|
||||||
macro_rules! doit {
|
macro_rules! doit {
|
||||||
($($t:ty)*) => ($(impl FromStrRadixHelper for $t {
|
($($t:ty)*) => ($(impl FromStrRadixHelper for $t {
|
||||||
fn min_value() -> Self { Self::min_value() }
|
fn min_value() -> Self { Self::min_value() }
|
||||||
|
fn max_value() -> Self { Self::max_value() }
|
||||||
fn from_u32(u: u32) -> Self { u as Self }
|
fn from_u32(u: u32) -> Self { u as Self }
|
||||||
fn checked_mul(&self, other: u32) -> Option<Self> {
|
fn checked_mul(&self, other: u32) -> Option<Self> {
|
||||||
Self::checked_mul(*self, other as Self)
|
Self::checked_mul(*self, other as Self)
|
||||||
|
|
|
@ -34,6 +34,7 @@
|
||||||
#![feature(unboxed_closures)]
|
#![feature(unboxed_closures)]
|
||||||
#![feature(unicode)]
|
#![feature(unicode)]
|
||||||
#![feature(unique)]
|
#![feature(unique)]
|
||||||
|
#![feature(try_from)]
|
||||||
|
|
||||||
extern crate core;
|
extern crate core;
|
||||||
extern crate test;
|
extern crate test;
|
||||||
|
|
|
@ -8,10 +8,14 @@
|
||||||
// option. This file may not be copied, modified, or distributed
|
// option. This file may not be copied, modified, or distributed
|
||||||
// except according to those terms.
|
// except according to those terms.
|
||||||
|
|
||||||
|
use core::convert::TryFrom;
|
||||||
use core::cmp::PartialEq;
|
use core::cmp::PartialEq;
|
||||||
use core::fmt::Debug;
|
use core::fmt::Debug;
|
||||||
use core::ops::{Add, Sub, Mul, Div, Rem};
|
|
||||||
use core::marker::Copy;
|
use core::marker::Copy;
|
||||||
|
use core::num::Float;
|
||||||
|
use core::ops::{Add, Sub, Mul, Div, Rem};
|
||||||
|
use core::option::Option;
|
||||||
|
use core::option::Option::{Some, None};
|
||||||
|
|
||||||
#[macro_use]
|
#[macro_use]
|
||||||
mod int_macros;
|
mod int_macros;
|
||||||
|
@ -48,169 +52,318 @@ pub fn test_num<T>(ten: T, two: T) where
|
||||||
assert_eq!(ten.rem(two), ten % two);
|
assert_eq!(ten.rem(two), ten % two);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(test)]
|
#[test]
|
||||||
mod tests {
|
fn from_str_issue7588() {
|
||||||
use core::option::Option;
|
let u : Option<u8> = u8::from_str_radix("1000", 10).ok();
|
||||||
use core::option::Option::{Some, None};
|
assert_eq!(u, None);
|
||||||
use core::num::Float;
|
let s : Option<i16> = i16::from_str_radix("80000", 10).ok();
|
||||||
|
assert_eq!(s, None);
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn from_str_issue7588() {
|
fn test_int_from_str_overflow() {
|
||||||
let u : Option<u8> = u8::from_str_radix("1000", 10).ok();
|
let mut i8_val: i8 = 127;
|
||||||
assert_eq!(u, None);
|
assert_eq!("127".parse::<i8>().ok(), Some(i8_val));
|
||||||
let s : Option<i16> = i16::from_str_radix("80000", 10).ok();
|
assert_eq!("128".parse::<i8>().ok(), None);
|
||||||
assert_eq!(s, None);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
i8_val = i8_val.wrapping_add(1);
|
||||||
fn test_int_from_str_overflow() {
|
assert_eq!("-128".parse::<i8>().ok(), Some(i8_val));
|
||||||
let mut i8_val: i8 = 127;
|
assert_eq!("-129".parse::<i8>().ok(), None);
|
||||||
assert_eq!("127".parse::<i8>().ok(), Some(i8_val));
|
|
||||||
assert_eq!("128".parse::<i8>().ok(), None);
|
|
||||||
|
|
||||||
i8_val = i8_val.wrapping_add(1);
|
let mut i16_val: i16 = 32_767;
|
||||||
assert_eq!("-128".parse::<i8>().ok(), Some(i8_val));
|
assert_eq!("32767".parse::<i16>().ok(), Some(i16_val));
|
||||||
assert_eq!("-129".parse::<i8>().ok(), None);
|
assert_eq!("32768".parse::<i16>().ok(), None);
|
||||||
|
|
||||||
let mut i16_val: i16 = 32_767;
|
i16_val = i16_val.wrapping_add(1);
|
||||||
assert_eq!("32767".parse::<i16>().ok(), Some(i16_val));
|
assert_eq!("-32768".parse::<i16>().ok(), Some(i16_val));
|
||||||
assert_eq!("32768".parse::<i16>().ok(), None);
|
assert_eq!("-32769".parse::<i16>().ok(), None);
|
||||||
|
|
||||||
i16_val = i16_val.wrapping_add(1);
|
let mut i32_val: i32 = 2_147_483_647;
|
||||||
assert_eq!("-32768".parse::<i16>().ok(), Some(i16_val));
|
assert_eq!("2147483647".parse::<i32>().ok(), Some(i32_val));
|
||||||
assert_eq!("-32769".parse::<i16>().ok(), None);
|
assert_eq!("2147483648".parse::<i32>().ok(), None);
|
||||||
|
|
||||||
let mut i32_val: i32 = 2_147_483_647;
|
i32_val = i32_val.wrapping_add(1);
|
||||||
assert_eq!("2147483647".parse::<i32>().ok(), Some(i32_val));
|
assert_eq!("-2147483648".parse::<i32>().ok(), Some(i32_val));
|
||||||
assert_eq!("2147483648".parse::<i32>().ok(), None);
|
assert_eq!("-2147483649".parse::<i32>().ok(), None);
|
||||||
|
|
||||||
i32_val = i32_val.wrapping_add(1);
|
let mut i64_val: i64 = 9_223_372_036_854_775_807;
|
||||||
assert_eq!("-2147483648".parse::<i32>().ok(), Some(i32_val));
|
assert_eq!("9223372036854775807".parse::<i64>().ok(), Some(i64_val));
|
||||||
assert_eq!("-2147483649".parse::<i32>().ok(), None);
|
assert_eq!("9223372036854775808".parse::<i64>().ok(), None);
|
||||||
|
|
||||||
let mut i64_val: i64 = 9_223_372_036_854_775_807;
|
i64_val = i64_val.wrapping_add(1);
|
||||||
assert_eq!("9223372036854775807".parse::<i64>().ok(), Some(i64_val));
|
assert_eq!("-9223372036854775808".parse::<i64>().ok(), Some(i64_val));
|
||||||
assert_eq!("9223372036854775808".parse::<i64>().ok(), None);
|
assert_eq!("-9223372036854775809".parse::<i64>().ok(), None);
|
||||||
|
}
|
||||||
|
|
||||||
i64_val = i64_val.wrapping_add(1);
|
#[test]
|
||||||
assert_eq!("-9223372036854775808".parse::<i64>().ok(), Some(i64_val));
|
fn test_leading_plus() {
|
||||||
assert_eq!("-9223372036854775809".parse::<i64>().ok(), None);
|
assert_eq!("+127".parse::<u8>().ok(), Some(127));
|
||||||
}
|
assert_eq!("+9223372036854775807".parse::<i64>().ok(), Some(9223372036854775807));
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_leading_plus() {
|
fn test_invalid() {
|
||||||
assert_eq!("+127".parse::<u8>().ok(), Some(127));
|
assert_eq!("--129".parse::<i8>().ok(), None);
|
||||||
assert_eq!("+9223372036854775807".parse::<i64>().ok(), Some(9223372036854775807));
|
assert_eq!("++129".parse::<i8>().ok(), None);
|
||||||
}
|
assert_eq!("Съешь".parse::<u8>().ok(), None);
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_invalid() {
|
fn test_empty() {
|
||||||
assert_eq!("--129".parse::<i8>().ok(), None);
|
assert_eq!("-".parse::<i8>().ok(), None);
|
||||||
assert_eq!("++129".parse::<i8>().ok(), None);
|
assert_eq!("+".parse::<i8>().ok(), None);
|
||||||
assert_eq!("Съешь".parse::<u8>().ok(), None);
|
assert_eq!("".parse::<u8>().ok(), None);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
macro_rules! test_impl_from {
|
||||||
fn test_empty() {
|
($fn_name: ident, $Small: ty, $Large: ty) => {
|
||||||
assert_eq!("-".parse::<i8>().ok(), None);
|
#[test]
|
||||||
assert_eq!("+".parse::<i8>().ok(), None);
|
fn $fn_name() {
|
||||||
assert_eq!("".parse::<u8>().ok(), None);
|
let small_max = <$Small>::max_value();
|
||||||
}
|
let small_min = <$Small>::min_value();
|
||||||
|
let large_max: $Large = small_max.into();
|
||||||
macro_rules! test_impl_from {
|
let large_min: $Large = small_min.into();
|
||||||
($fn_name: ident, $Small: ty, $Large: ty) => {
|
assert_eq!(large_max as $Small, small_max);
|
||||||
#[test]
|
assert_eq!(large_min as $Small, small_min);
|
||||||
fn $fn_name() {
|
|
||||||
let small_max = <$Small>::max_value();
|
|
||||||
let small_min = <$Small>::min_value();
|
|
||||||
let large_max: $Large = small_max.into();
|
|
||||||
let large_min: $Large = small_min.into();
|
|
||||||
assert_eq!(large_max as $Small, small_max);
|
|
||||||
assert_eq!(large_min as $Small, small_min);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// Unsigned -> Unsigned
|
// Unsigned -> Unsigned
|
||||||
test_impl_from! { test_u8u16, u8, u16 }
|
test_impl_from! { test_u8u16, u8, u16 }
|
||||||
test_impl_from! { test_u8u32, u8, u32 }
|
test_impl_from! { test_u8u32, u8, u32 }
|
||||||
test_impl_from! { test_u8u64, u8, u64 }
|
test_impl_from! { test_u8u64, u8, u64 }
|
||||||
test_impl_from! { test_u8usize, u8, usize }
|
test_impl_from! { test_u8usize, u8, usize }
|
||||||
test_impl_from! { test_u16u32, u16, u32 }
|
test_impl_from! { test_u16u32, u16, u32 }
|
||||||
test_impl_from! { test_u16u64, u16, u64 }
|
test_impl_from! { test_u16u64, u16, u64 }
|
||||||
test_impl_from! { test_u32u64, u32, u64 }
|
test_impl_from! { test_u32u64, u32, u64 }
|
||||||
|
|
||||||
// Signed -> Signed
|
// Signed -> Signed
|
||||||
test_impl_from! { test_i8i16, i8, i16 }
|
test_impl_from! { test_i8i16, i8, i16 }
|
||||||
test_impl_from! { test_i8i32, i8, i32 }
|
test_impl_from! { test_i8i32, i8, i32 }
|
||||||
test_impl_from! { test_i8i64, i8, i64 }
|
test_impl_from! { test_i8i64, i8, i64 }
|
||||||
test_impl_from! { test_i8isize, i8, isize }
|
test_impl_from! { test_i8isize, i8, isize }
|
||||||
test_impl_from! { test_i16i32, i16, i32 }
|
test_impl_from! { test_i16i32, i16, i32 }
|
||||||
test_impl_from! { test_i16i64, i16, i64 }
|
test_impl_from! { test_i16i64, i16, i64 }
|
||||||
test_impl_from! { test_i32i64, i32, i64 }
|
test_impl_from! { test_i32i64, i32, i64 }
|
||||||
|
|
||||||
// Unsigned -> Signed
|
// Unsigned -> Signed
|
||||||
test_impl_from! { test_u8i16, u8, i16 }
|
test_impl_from! { test_u8i16, u8, i16 }
|
||||||
test_impl_from! { test_u8i32, u8, i32 }
|
test_impl_from! { test_u8i32, u8, i32 }
|
||||||
test_impl_from! { test_u8i64, u8, i64 }
|
test_impl_from! { test_u8i64, u8, i64 }
|
||||||
test_impl_from! { test_u16i32, u16, i32 }
|
test_impl_from! { test_u16i32, u16, i32 }
|
||||||
test_impl_from! { test_u16i64, u16, i64 }
|
test_impl_from! { test_u16i64, u16, i64 }
|
||||||
test_impl_from! { test_u32i64, u32, i64 }
|
test_impl_from! { test_u32i64, u32, i64 }
|
||||||
|
|
||||||
// Signed -> Float
|
// Signed -> Float
|
||||||
test_impl_from! { test_i8f32, i8, f32 }
|
test_impl_from! { test_i8f32, i8, f32 }
|
||||||
test_impl_from! { test_i8f64, i8, f64 }
|
test_impl_from! { test_i8f64, i8, f64 }
|
||||||
test_impl_from! { test_i16f32, i16, f32 }
|
test_impl_from! { test_i16f32, i16, f32 }
|
||||||
test_impl_from! { test_i16f64, i16, f64 }
|
test_impl_from! { test_i16f64, i16, f64 }
|
||||||
test_impl_from! { test_i32f64, i32, f64 }
|
test_impl_from! { test_i32f64, i32, f64 }
|
||||||
|
|
||||||
// Unsigned -> Float
|
// Unsigned -> Float
|
||||||
test_impl_from! { test_u8f32, u8, f32 }
|
test_impl_from! { test_u8f32, u8, f32 }
|
||||||
test_impl_from! { test_u8f64, u8, f64 }
|
test_impl_from! { test_u8f64, u8, f64 }
|
||||||
test_impl_from! { test_u16f32, u16, f32 }
|
test_impl_from! { test_u16f32, u16, f32 }
|
||||||
test_impl_from! { test_u16f64, u16, f64 }
|
test_impl_from! { test_u16f64, u16, f64 }
|
||||||
test_impl_from! { test_u32f64, u32, f64 }
|
test_impl_from! { test_u32f64, u32, f64 }
|
||||||
|
|
||||||
// Float -> Float
|
// Float -> Float
|
||||||
#[test]
|
#[test]
|
||||||
fn test_f32f64() {
|
fn test_f32f64() {
|
||||||
use core::f32;
|
use core::f32;
|
||||||
|
|
||||||
let max: f64 = f32::MAX.into();
|
let max: f64 = f32::MAX.into();
|
||||||
assert_eq!(max as f32, f32::MAX);
|
assert_eq!(max as f32, f32::MAX);
|
||||||
assert!(max.is_normal());
|
assert!(max.is_normal());
|
||||||
|
|
||||||
let min: f64 = f32::MIN.into();
|
let min: f64 = f32::MIN.into();
|
||||||
assert_eq!(min as f32, f32::MIN);
|
assert_eq!(min as f32, f32::MIN);
|
||||||
assert!(min.is_normal());
|
assert!(min.is_normal());
|
||||||
|
|
||||||
let min_positive: f64 = f32::MIN_POSITIVE.into();
|
let min_positive: f64 = f32::MIN_POSITIVE.into();
|
||||||
assert_eq!(min_positive as f32, f32::MIN_POSITIVE);
|
assert_eq!(min_positive as f32, f32::MIN_POSITIVE);
|
||||||
assert!(min_positive.is_normal());
|
assert!(min_positive.is_normal());
|
||||||
|
|
||||||
let epsilon: f64 = f32::EPSILON.into();
|
let epsilon: f64 = f32::EPSILON.into();
|
||||||
assert_eq!(epsilon as f32, f32::EPSILON);
|
assert_eq!(epsilon as f32, f32::EPSILON);
|
||||||
assert!(epsilon.is_normal());
|
assert!(epsilon.is_normal());
|
||||||
|
|
||||||
let zero: f64 = (0.0f32).into();
|
let zero: f64 = (0.0f32).into();
|
||||||
assert_eq!(zero as f32, 0.0f32);
|
assert_eq!(zero as f32, 0.0f32);
|
||||||
assert!(zero.is_sign_positive());
|
assert!(zero.is_sign_positive());
|
||||||
|
|
||||||
let neg_zero: f64 = (-0.0f32).into();
|
let neg_zero: f64 = (-0.0f32).into();
|
||||||
assert_eq!(neg_zero as f32, -0.0f32);
|
assert_eq!(neg_zero as f32, -0.0f32);
|
||||||
assert!(neg_zero.is_sign_negative());
|
assert!(neg_zero.is_sign_negative());
|
||||||
|
|
||||||
let infinity: f64 = f32::INFINITY.into();
|
let infinity: f64 = f32::INFINITY.into();
|
||||||
assert_eq!(infinity as f32, f32::INFINITY);
|
assert_eq!(infinity as f32, f32::INFINITY);
|
||||||
assert!(infinity.is_infinite());
|
assert!(infinity.is_infinite());
|
||||||
assert!(infinity.is_sign_positive());
|
assert!(infinity.is_sign_positive());
|
||||||
|
|
||||||
let neg_infinity: f64 = f32::NEG_INFINITY.into();
|
let neg_infinity: f64 = f32::NEG_INFINITY.into();
|
||||||
assert_eq!(neg_infinity as f32, f32::NEG_INFINITY);
|
assert_eq!(neg_infinity as f32, f32::NEG_INFINITY);
|
||||||
assert!(neg_infinity.is_infinite());
|
assert!(neg_infinity.is_infinite());
|
||||||
assert!(neg_infinity.is_sign_negative());
|
assert!(neg_infinity.is_sign_negative());
|
||||||
|
|
||||||
let nan: f64 = f32::NAN.into();
|
let nan: f64 = f32::NAN.into();
|
||||||
assert!(nan.is_nan());
|
assert!(nan.is_nan());
|
||||||
|
}
|
||||||
|
|
||||||
|
macro_rules! test_impl_try_from_always_ok {
|
||||||
|
($fn_name:ident, $source:ty, $target: ty) => {
|
||||||
|
#[test]
|
||||||
|
fn $fn_name() {
|
||||||
|
let max = <$source>::max_value();
|
||||||
|
let min = <$source>::min_value();
|
||||||
|
let zero: $source = 0;
|
||||||
|
assert_eq!(<$target as TryFrom<$source>>::try_from(max).unwrap(),
|
||||||
|
max as $target);
|
||||||
|
assert_eq!(<$target as TryFrom<$source>>::try_from(min).unwrap(),
|
||||||
|
min as $target);
|
||||||
|
assert_eq!(<$target as TryFrom<$source>>::try_from(zero).unwrap(),
|
||||||
|
zero as $target);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
test_impl_try_from_always_ok! { test_try_u8u8, u8, u8 }
|
||||||
|
test_impl_try_from_always_ok! { test_try_u8u16, u8, u16 }
|
||||||
|
test_impl_try_from_always_ok! { test_try_u8u32, u8, u32 }
|
||||||
|
test_impl_try_from_always_ok! { test_try_u8u64, u8, u64 }
|
||||||
|
test_impl_try_from_always_ok! { test_try_u8i16, u8, i16 }
|
||||||
|
test_impl_try_from_always_ok! { test_try_u8i32, u8, i32 }
|
||||||
|
test_impl_try_from_always_ok! { test_try_u8i64, u8, i64 }
|
||||||
|
|
||||||
|
test_impl_try_from_always_ok! { test_try_u16u16, u16, u16 }
|
||||||
|
test_impl_try_from_always_ok! { test_try_u16u32, u16, u32 }
|
||||||
|
test_impl_try_from_always_ok! { test_try_u16u64, u16, u64 }
|
||||||
|
test_impl_try_from_always_ok! { test_try_u16i32, u16, i32 }
|
||||||
|
test_impl_try_from_always_ok! { test_try_u16i64, u16, i64 }
|
||||||
|
|
||||||
|
test_impl_try_from_always_ok! { test_try_u32u32, u32, u32 }
|
||||||
|
test_impl_try_from_always_ok! { test_try_u32u64, u32, u64 }
|
||||||
|
test_impl_try_from_always_ok! { test_try_u32i64, u32, i64 }
|
||||||
|
|
||||||
|
test_impl_try_from_always_ok! { test_try_u64u64, u64, u64 }
|
||||||
|
|
||||||
|
test_impl_try_from_always_ok! { test_try_i8i8, i8, i8 }
|
||||||
|
test_impl_try_from_always_ok! { test_try_i8i16, i8, i16 }
|
||||||
|
test_impl_try_from_always_ok! { test_try_i8i32, i8, i32 }
|
||||||
|
test_impl_try_from_always_ok! { test_try_i8i64, i8, i64 }
|
||||||
|
|
||||||
|
test_impl_try_from_always_ok! { test_try_i16i16, i16, i16 }
|
||||||
|
test_impl_try_from_always_ok! { test_try_i16i32, i16, i32 }
|
||||||
|
test_impl_try_from_always_ok! { test_try_i16i64, i16, i64 }
|
||||||
|
|
||||||
|
test_impl_try_from_always_ok! { test_try_i32i32, i32, i32 }
|
||||||
|
test_impl_try_from_always_ok! { test_try_i32i64, i32, i64 }
|
||||||
|
|
||||||
|
test_impl_try_from_always_ok! { test_try_i64i64, i64, i64 }
|
||||||
|
|
||||||
|
macro_rules! test_impl_try_from_signed_to_unsigned_upper_ok {
|
||||||
|
($fn_name:ident, $source:ty, $target:ty) => {
|
||||||
|
#[test]
|
||||||
|
fn $fn_name() {
|
||||||
|
let max = <$source>::max_value();
|
||||||
|
let min = <$source>::min_value();
|
||||||
|
let zero: $source = 0;
|
||||||
|
let neg_one: $source = -1;
|
||||||
|
assert_eq!(<$target as TryFrom<$source>>::try_from(max).unwrap(),
|
||||||
|
max as $target);
|
||||||
|
assert!(<$target as TryFrom<$source>>::try_from(min).is_err());
|
||||||
|
assert_eq!(<$target as TryFrom<$source>>::try_from(zero).unwrap(),
|
||||||
|
zero as $target);
|
||||||
|
assert!(<$target as TryFrom<$source>>::try_from(neg_one).is_err());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
test_impl_try_from_signed_to_unsigned_upper_ok! { test_try_i8u8, i8, u8 }
|
||||||
|
test_impl_try_from_signed_to_unsigned_upper_ok! { test_try_i8u16, i8, u16 }
|
||||||
|
test_impl_try_from_signed_to_unsigned_upper_ok! { test_try_i8u32, i8, u32 }
|
||||||
|
test_impl_try_from_signed_to_unsigned_upper_ok! { test_try_i8u64, i8, u64 }
|
||||||
|
|
||||||
|
test_impl_try_from_signed_to_unsigned_upper_ok! { test_try_i16u16, i16, u16 }
|
||||||
|
test_impl_try_from_signed_to_unsigned_upper_ok! { test_try_i16u32, i16, u32 }
|
||||||
|
test_impl_try_from_signed_to_unsigned_upper_ok! { test_try_i16u64, i16, u64 }
|
||||||
|
|
||||||
|
test_impl_try_from_signed_to_unsigned_upper_ok! { test_try_i32u32, i32, u32 }
|
||||||
|
test_impl_try_from_signed_to_unsigned_upper_ok! { test_try_i32u64, i32, u64 }
|
||||||
|
|
||||||
|
test_impl_try_from_signed_to_unsigned_upper_ok! { test_try_i64u64, i64, u64 }
|
||||||
|
|
||||||
|
macro_rules! test_impl_try_from_unsigned_to_signed_upper_err {
|
||||||
|
($fn_name:ident, $source:ty, $target:ty) => {
|
||||||
|
#[test]
|
||||||
|
fn $fn_name() {
|
||||||
|
let max = <$source>::max_value();
|
||||||
|
let min = <$source>::min_value();
|
||||||
|
let zero: $source = 0;
|
||||||
|
assert!(<$target as TryFrom<$source>>::try_from(max).is_err());
|
||||||
|
assert_eq!(<$target as TryFrom<$source>>::try_from(min).unwrap(),
|
||||||
|
min as $target);
|
||||||
|
assert_eq!(<$target as TryFrom<$source>>::try_from(zero).unwrap(),
|
||||||
|
zero as $target);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
test_impl_try_from_unsigned_to_signed_upper_err! { test_try_u8i8, u8, i8 }
|
||||||
|
|
||||||
|
test_impl_try_from_unsigned_to_signed_upper_err! { test_try_u16i8, u16, i8 }
|
||||||
|
test_impl_try_from_unsigned_to_signed_upper_err! { test_try_u16i16, u16, i16 }
|
||||||
|
|
||||||
|
test_impl_try_from_unsigned_to_signed_upper_err! { test_try_u32i8, u32, i8 }
|
||||||
|
test_impl_try_from_unsigned_to_signed_upper_err! { test_try_u32i16, u32, i16 }
|
||||||
|
test_impl_try_from_unsigned_to_signed_upper_err! { test_try_u32i32, u32, i32 }
|
||||||
|
|
||||||
|
test_impl_try_from_unsigned_to_signed_upper_err! { test_try_u64i8, u64, i8 }
|
||||||
|
test_impl_try_from_unsigned_to_signed_upper_err! { test_try_u64i16, u64, i16 }
|
||||||
|
test_impl_try_from_unsigned_to_signed_upper_err! { test_try_u64i32, u64, i32 }
|
||||||
|
test_impl_try_from_unsigned_to_signed_upper_err! { test_try_u64i64, u64, i64 }
|
||||||
|
|
||||||
|
macro_rules! test_impl_try_from_same_sign_err {
|
||||||
|
($fn_name:ident, $source:ty, $target:ty) => {
|
||||||
|
#[test]
|
||||||
|
fn $fn_name() {
|
||||||
|
let max = <$source>::max_value();
|
||||||
|
let min = <$source>::min_value();
|
||||||
|
let zero: $source = 0;
|
||||||
|
let t_max = <$target>::max_value();
|
||||||
|
let t_min = <$target>::min_value();
|
||||||
|
assert!(<$target as TryFrom<$source>>::try_from(max).is_err());
|
||||||
|
if min != 0 {
|
||||||
|
assert!(<$target as TryFrom<$source>>::try_from(min).is_err());
|
||||||
|
}
|
||||||
|
assert_eq!(<$target as TryFrom<$source>>::try_from(zero).unwrap(),
|
||||||
|
zero as $target);
|
||||||
|
assert_eq!(<$target as TryFrom<$source>>::try_from(t_max as $source)
|
||||||
|
.unwrap(),
|
||||||
|
t_max as $target);
|
||||||
|
assert_eq!(<$target as TryFrom<$source>>::try_from(t_min as $source)
|
||||||
|
.unwrap(),
|
||||||
|
t_min as $target);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
test_impl_try_from_same_sign_err! { test_try_u16u8, u16, u8 }
|
||||||
|
|
||||||
|
test_impl_try_from_same_sign_err! { test_try_u32u8, u32, u8 }
|
||||||
|
test_impl_try_from_same_sign_err! { test_try_u32u16, u32, u16 }
|
||||||
|
|
||||||
|
test_impl_try_from_same_sign_err! { test_try_u64u8, u64, u8 }
|
||||||
|
test_impl_try_from_same_sign_err! { test_try_u64u16, u64, u16 }
|
||||||
|
test_impl_try_from_same_sign_err! { test_try_u64u32, u64, u32 }
|
||||||
|
|
||||||
|
test_impl_try_from_same_sign_err! { test_try_i16i8, i16, i8 }
|
||||||
|
|
||||||
|
test_impl_try_from_same_sign_err! { test_try_i32i8, i32, i8 }
|
||||||
|
test_impl_try_from_same_sign_err! { test_try_i32i16, i32, i16 }
|
||||||
|
|
||||||
|
test_impl_try_from_same_sign_err! { test_try_i64i8, i64, i8 }
|
||||||
|
test_impl_try_from_same_sign_err! { test_try_i64i16, i64, i16 }
|
||||||
|
test_impl_try_from_same_sign_err! { test_try_i64i32, i64, i32 }
|
||||||
|
|
|
@ -159,6 +159,13 @@ impl Error for num::ParseIntError {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[unstable(feature = "try_from", issue = "33417")]
|
||||||
|
impl Error for num::TryFromIntError {
|
||||||
|
fn description(&self) -> &str {
|
||||||
|
self.__description()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
#[stable(feature = "rust1", since = "1.0.0")]
|
#[stable(feature = "rust1", since = "1.0.0")]
|
||||||
impl Error for num::ParseFloatError {
|
impl Error for num::ParseFloatError {
|
||||||
fn description(&self) -> &str {
|
fn description(&self) -> &str {
|
||||||
|
|
|
@ -270,6 +270,7 @@
|
||||||
#![feature(vec_push_all)]
|
#![feature(vec_push_all)]
|
||||||
#![feature(zero_one)]
|
#![feature(zero_one)]
|
||||||
#![feature(question_mark)]
|
#![feature(question_mark)]
|
||||||
|
#![feature(try_from)]
|
||||||
|
|
||||||
// Issue# 30592: Systematically use alloc_system during stage0 since jemalloc
|
// Issue# 30592: Systematically use alloc_system during stage0 since jemalloc
|
||||||
// might be unavailable or disabled
|
// might be unavailable or disabled
|
||||||
|
|
|
@ -19,7 +19,7 @@
|
||||||
#[stable(feature = "rust1", since = "1.0.0")]
|
#[stable(feature = "rust1", since = "1.0.0")]
|
||||||
pub use core::num::{Zero, One};
|
pub use core::num::{Zero, One};
|
||||||
#[stable(feature = "rust1", since = "1.0.0")]
|
#[stable(feature = "rust1", since = "1.0.0")]
|
||||||
pub use core::num::{FpCategory, ParseIntError, ParseFloatError};
|
pub use core::num::{FpCategory, ParseIntError, ParseFloatError, TryFromIntError};
|
||||||
#[stable(feature = "rust1", since = "1.0.0")]
|
#[stable(feature = "rust1", since = "1.0.0")]
|
||||||
pub use core::num::Wrapping;
|
pub use core::num::Wrapping;
|
||||||
|
|
||||||
|
|
Loading…
Reference in New Issue