Move FromStr to core::str

src/compiletest/common.rs

@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::from_str::FromStr;
 use std::fmt;
+use std::str::FromStr;
 use regex::Regex;
 
 #[deriving(Clone, PartialEq)]

src/compiletest/compiletest.rs

@@ -22,7 +22,7 @@ extern crate regex;
 use std::os;
 use std::io;
 use std::io::fs;
-use std::from_str::FromStr;
+use std::str::FromStr;
 use getopts::{optopt, optflag, reqopt};
 use common::Config;
 use common::{Pretty, DebugInfoGdb, DebugInfoLldb, Codegen};

src/compiletest/header.rs

@@ -12,8 +12,6 @@ use common::Config;
 use common;
 use util;
 
-use std::from_str::FromStr;
-
 pub struct TestProps {
     // Lines that should be expected, in order, on standard out
     pub error_patterns: Vec<String> ,
@@ -353,8 +351,8 @@ pub fn gdb_version_to_int(version_string: &str) -> int {
         panic!("{}", error_string);
     }
 
-    let major: int = FromStr::from_str(components[0]).expect(error_string);
-    let minor: int = FromStr::from_str(components[1]).expect(error_string);
+    let major: int = from_str(components[0]).expect(error_string);
+    let minor: int = from_str(components[1]).expect(error_string);
 
     return major * 1000 + minor;
 }
@@ -364,6 +362,6 @@ pub fn lldb_version_to_int(version_string: &str) -> int {
         "Encountered LLDB version string with unexpected format: {}",
         version_string);
     let error_string = error_string.as_slice();
-    let major: int = FromStr::from_str(version_string).expect(error_string);
+    let major: int = from_str(version_string).expect(error_string);
     return major;
 }

src/doc/reference.md

@@ -3108,11 +3108,10 @@ then the expression completes.
 Some examples of call expressions:
 
 ```
-# use std::from_str::FromStr;
 # fn add(x: int, y: int) -> int { 0 }
 
 let x: int = add(1, 2);
-let pi: Option<f32> = FromStr::from_str("3.14");
+let pi: Option<f32> = from_str("3.14");
 ```
 
 ### Lambda expressions

src/libcollections/str.rs

@@ -73,6 +73,7 @@ pub use core::str::{CharSplitsN, AnyLines, MatchIndices, StrSplits};
 pub use core::str::{Utf16CodeUnits, eq_slice, is_utf8, is_utf16, Utf16Items};
 pub use core::str::{Utf16Item, ScalarValue, LoneSurrogate, utf16_items};
 pub use core::str::{truncate_utf16_at_nul, utf8_char_width, CharRange};
+pub use core::str::{FromStr, from_str};
 pub use core::str::{Str, StrPrelude};
 pub use unicode::str::{UnicodeStrPrelude, Words, Graphemes, GraphemeIndices};
 

src/libcollections/string.rs

@@ -25,7 +25,7 @@ use core::raw::Slice as RawSlice;
 use hash;
 use slice::CloneSliceAllocPrelude;
 use str;
-use str::{CharRange, StrAllocating, MaybeOwned, Owned};
+use str::{CharRange, FromStr, StrAllocating, MaybeOwned, Owned};
 use str::Slice as MaybeOwnedSlice; // So many `Slice`s...
 use vec::{DerefVec, Vec, as_vec};
 
@@ -795,6 +795,13 @@ pub fn as_string<'a>(x: &'a str) -> DerefString<'a> {
     DerefString { x: as_vec(x.as_bytes()) }
 }
 
+impl FromStr for String {
+    #[inline]
+    fn from_str(s: &str) -> Option<String> {
+        Some(String::from_str(s))
+    }
+}
+
 /// Unsafe operations
 #[unstable = "waiting on raw module conventions"]
 pub mod raw {

src/libcore/num/f32.rs

@@ -17,7 +17,9 @@
 use intrinsics;
 use mem;
 use num::{FPNormal, FPCategory, FPZero, FPSubnormal, FPInfinite, FPNaN};
-use num::Float;
+use num::{Float, FromStrRadix};
+use num::strconv;
+use str::FromStr;
 use option::Option;
 
 pub const RADIX: uint = 2u;
@@ -424,3 +426,66 @@ impl Float for f32 {
         self * (value / 180.0f32)
     }
 }
+
+#[inline]
+#[allow(missing_docs)]
+#[deprecated="Use `FromStrRadix::from_str_radix(src, 16)`"]
+pub fn from_str_hex(src: &str) -> Option<f32> {
+    strconv::from_str_radix_float(src, 16)
+}
+
+impl FromStr for f32 {
+    /// Convert a string in base 10 to a float.
+    /// Accepts an optional decimal exponent.
+    ///
+    /// This function accepts strings such as
+    ///
+    /// * '3.14'
+    /// * '+3.14', equivalent to '3.14'
+    /// * '-3.14'
+    /// * '2.5E10', or equivalently, '2.5e10'
+    /// * '2.5E-10'
+    /// * '.' (understood as 0)
+    /// * '5.'
+    /// * '.5', or, equivalently,  '0.5'
+    /// * '+inf', 'inf', '-inf', 'NaN'
+    ///
+    /// Leading and trailing whitespace represent an error.
+    ///
+    /// # Arguments
+    ///
+    /// * src - A string
+    ///
+    /// # Return value
+    ///
+    /// `None` if the string did not represent a valid number.  Otherwise,
+    /// `Some(n)` where `n` is the floating-point number represented by `src`.
+    #[inline]
+    fn from_str(src: &str) -> Option<f32> {
+        strconv::from_str_radix_float(src, 10u)
+    }
+}
+
+impl FromStrRadix for f32 {
+    /// Convert a string in a given base to a float.
+    ///
+    /// Due to possible conflicts, this function does **not** accept
+    /// the special values `inf`, `-inf`, `+inf` and `NaN`, **nor**
+    /// does it recognize exponents of any kind.
+    ///
+    /// Leading and trailing whitespace represent an error.
+    ///
+    /// # Arguments
+    ///
+    /// * src - A string
+    /// * radix - The base to use. Must lie in the range [2 .. 36]
+    ///
+    /// # Return value
+    ///
+    /// `None` if the string did not represent a valid number. Otherwise,
+    /// `Some(n)` where `n` is the floating-point number represented by `src`.
+    #[inline]
+    fn from_str_radix(src: &str, radix: uint) -> Option<f32> {
+        strconv::from_str_radix_float(src, radix)
+    }
+}

src/libcore/num/f64.rs

@@ -17,7 +17,9 @@
 use intrinsics;
 use mem;
 use num::{FPNormal, FPCategory, FPZero, FPSubnormal, FPInfinite, FPNaN};
-use num::Float;
+use num::{Float, FromStrRadix};
+use num::strconv;
+use str::FromStr;
 use option::Option;
 
 // FIXME(#5527): These constants should be deprecated once associated
@@ -430,3 +432,61 @@ impl Float for f64 {
         self * (value / 180.0)
     }
 }
+
+#[inline]
+#[allow(missing_docs)]
+#[deprecated="Use `FromStrRadix::from_str_radix(src, 16)`"]
+pub fn from_str_hex(src: &str) -> Option<f64> {
+    strconv::from_str_radix_float(src, 16)
+}
+
+impl FromStr for f64 {
+    /// Convert a string in base 10 to a float.
+    /// Accepts an optional decimal exponent.
+    ///
+    /// This function accepts strings such as:
+    ///
+    /// * '3.14'
+    /// * '-3.14'
+    /// * '2.5E10', or equivalently, '2.5e10'
+    /// * '2.5E-10'
+    /// * '.' (understood as 0)
+    /// * '5.'
+    /// * '.5', or, equivalently,  '0.5'
+    /// * inf', '-inf', 'NaN'
+    ///
+    /// Leading and trailing whitespace represent an error.
+    ///
+    /// # Arguments
+    ///
+    /// * src - A string
+    ///
+    /// # Return value
+    ///
+    /// `none` if the string did not represent a valid number.  Otherwise,
+    /// `Some(n)` where `n` is the floating-point number represented by `src`.
+    #[inline]
+    fn from_str(src: &str) -> Option<f64> {
+        strconv::from_str_radix_float(src, 10u)
+    }
+}
+
+impl FromStrRadix for f64 {
+    /// Convert a string in a given base to a float.
+    ///
+    /// Leading and trailing whitespace represent an error.
+    ///
+    /// # Arguments
+    ///
+    /// * src - A string
+    /// * radix - The base to use. Must lie in the range [2 .. 36]
+    ///
+    /// # Return value
+    ///
+    /// `None` if the string did not represent a valid number. Otherwise,
+    /// `Some(n)` where `n` is the floating-point number represented by `src`.
+    #[inline]
+    fn from_str_radix(src: &str, radix: uint) -> Option<f64> {
+        strconv::from_str_radix_float(src, radix)
+    }
+}

src/libcore/num/int_macros.rs

@@ -32,4 +32,20 @@ pub const MIN: $T = (-1 as $T) << (BITS - 1);
 #[unstable]
 pub const MAX: $T = !MIN;
 
+#[experimental = "might need to return Result"]
+impl ::str::FromStr for $T {
+    #[inline]
+    fn from_str(s: &str) -> ::option::Option<$T> {
+        ::num::strconv::from_str_radix_int(s, 10)
+    }
+}
+
+#[experimental = "might need to return Result"]
+impl ::num::FromStrRadix for $T {
+    #[inline]
+    fn from_str_radix(s: &str, radix: uint) -> ::option::Option<$T> {
+        ::num::strconv::from_str_radix_int(s, radix)
+    }
+}
+
 ))

src/libcore/num/mod.rs

@@ -27,6 +27,8 @@ use ops::{Add, Sub, Mul, Div, Rem, Neg};
 use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr};
 use option::{Option, Some, None};
 
+pub mod strconv;
+
 /// Simultaneous division and remainder
 #[inline]
 pub fn div_rem<T: Div<T, T> + Rem<T, T>>(x: T, y: T) -> (T, T) {
@@ -1372,6 +1374,18 @@ pub trait Float
     fn to_radians(self) -> Self;
 }
 
+/// A generic trait for converting a string with a radix (base) to a value
+#[experimental = "might need to return Result"]
+pub trait FromStrRadix {
+    fn from_str_radix(str: &str, radix: uint) -> Option<Self>;
+}
+
+/// A utility function that just calls FromStrRadix::from_str_radix.
+#[experimental = "might need to return Result"]
+pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: uint) -> Option<T> {
+    FromStrRadix::from_str_radix(str, radix)
+}
+
 // DEPRECATED
 
 macro_rules! trait_impl {

src/libcore/num/strconv.rs

@@ -0,0 +1,259 @@
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+//
+// ignore-lexer-test FIXME #15679
+
+#![allow(missing_docs)]
+
+use char::Char;
+use iter::Iterator;
+use num;
+use num::{Int, Float};
+use option::{None, Option, Some};
+use str::{from_str, StrPrelude};
+
+pub fn from_str_radix_float<T: Float>(src: &str, radix: uint) -> Option<T> {
+   assert!(radix >= 2 && radix <= 36,
+           "from_str_radix_float: must lie in the range `[2, 36]` - found {}",
+           radix);
+
+    let _0: T = Float::zero();
+    let _1: T = Float::one();
+    let radix_t: T = num::cast(radix as int).unwrap();
+
+    // Special values
+    match src {
+        "inf"   => return Some(Float::infinity()),
+        "-inf"  => return Some(Float::neg_infinity()),
+        "NaN"   => return Some(Float::nan()),
+        _       => {},
+    }
+
+    let (is_positive, src) =  match src.slice_shift_char() {
+        (None, _)        => return None,
+        (Some('-'), "")  => return None,
+        (Some('-'), src) => (false, src),
+        (Some(_), _)     => (true,  src),
+    };
+
+    // The significand to accumulate
+    let mut sig = if is_positive { _0 } else { -_0 };
+    // Necessary to detect overflow
+    let mut prev_sig = sig;
+    let mut cs = src.chars().enumerate();
+    // Exponent prefix and exponent index offset
+    let mut exp_info = None::<(char, uint)>;
+
+    // Parse the integer part of the significand
+    for (i, c) in cs {
+        match c.to_digit(radix) {
+            Some(digit) => {
+                // shift significand one digit left
+                sig = sig * radix_t;
+
+                // add/subtract current digit depending on sign
+                if is_positive {
+                    sig = sig + num::cast(digit as int).unwrap();
+                } else {
+                    sig = sig - num::cast(digit as int).unwrap();
+                }
+
+                // Detect overflow by comparing to last value, except
+                // if we've not seen any non-zero digits.
+                if prev_sig != _0 {
+                    if is_positive && sig <= prev_sig
+                        { return Some(Float::infinity()); }
+                    if !is_positive && sig >= prev_sig
+                        { return Some(Float::neg_infinity()); }
+
+                    // Detect overflow by reversing the shift-and-add process
+                    let digit: T = num::cast(digit as int).unwrap();
+                    if is_positive && (prev_sig != ((sig - digit) / radix_t))
+                        { return Some(Float::infinity()); }
+                    if !is_positive && (prev_sig != ((sig + digit) / radix_t))
+                        { return Some(Float::neg_infinity()); }
+                }
+                prev_sig = sig;
+            },
+            None => match c {
+                'e' | 'E' | 'p' | 'P' => {
+                    exp_info = Some((c, i + 1));
+                    break;  // start of exponent
+                },
+                '.' => {
+                    break;  // start of fractional part
+                },
+                _ => {
+                    return None;
+                },
+            },
+        }
+    }
+
+    // If we are not yet at the exponent parse the fractional
+    // part of the significand
+    if exp_info.is_none() {
+        let mut power = _1;
+        for (i, c) in cs {
+            match c.to_digit(radix) {
+                Some(digit) => {
+                    let digit: T = num::cast(digit).unwrap();
+                    // Decrease power one order of magnitude
+                    power = power / radix_t;
+                    // add/subtract current digit depending on sign
+                    sig = if is_positive {
+                        sig + digit * power
+                    } else {
+                        sig - digit * power
+                    };
+                    // Detect overflow by comparing to last value
+                    if is_positive && sig < prev_sig
+                        { return Some(Float::infinity()); }
+                    if !is_positive && sig > prev_sig
+                        { return Some(Float::neg_infinity()); }
+                    prev_sig = sig;
+                },
+                None => match c {
+                    'e' | 'E' | 'p' | 'P' => {
+                        exp_info = Some((c, i + 1));
+                        break; // start of exponent
+                    },
+                    _ => {
+                        return None; // invalid number
+                    },
+                },
+            }
+        }
+    }
+
+    // Parse and calculate the exponent
+    let exp = match exp_info {
+        Some((c, offset)) => {
+            let base: T = match c {
+                'E' | 'e' if radix == 10 => num::cast(10u).unwrap(),
+                'P' | 'p' if radix == 16 => num::cast(2u).unwrap(),
+                _ => return None,
+            };
+
+            // Parse the exponent as decimal integer
+            let src = src[offset..];
+            let (is_positive, exp) = match src.slice_shift_char() {
+                (Some('-'), src) => (false, from_str::<uint>(src)),
+                (Some('+'), src) => (true,  from_str::<uint>(src)),
+                (Some(_), _)     => (true,  from_str::<uint>(src)),
+                (None, _)        => return None,
+            };
+
+            match (is_positive, exp) {
+                (true,  Some(exp)) => base.powi(exp as i32),
+                (false, Some(exp)) => _1 / base.powi(exp as i32),
+                (_, None)          => return None,
+            }
+        },
+        None => _1, // no exponent
+    };
+
+    Some(sig * exp)
+}
+
+pub fn from_str_radix_int<T: Int>(src: &str, radix: uint) -> Option<T> {
+   assert!(radix >= 2 && radix <= 36,
+           "from_str_radix_int: must lie in the range `[2, 36]` - found {}",
+           radix);
+
+    fn cast<T: Int>(x: uint) -> T {
+        num::cast(x).unwrap()
+    }
+
+    let _0: T = Int::zero();
+    let _1: T = Int::one();
+    let is_signed = _0 > Int::min_value();
+
+    let (is_positive, src) =  match src.slice_shift_char() {
+        (Some('-'), src) if is_signed => (false, src),
+        (Some(_), _) => (true, src),
+        (None, _) => return None,
+    };
+
+    let mut xs = src.chars().map(|c| {
+        c.to_digit(radix).map(cast)
+    });
+    let radix = cast(radix);
+    let mut result = _0;
+
+    if is_positive {
+        for x in xs {
+            let x = match x {
+                Some(x) => x,
+                None => return None,
+            };
+            result = match result.checked_mul(radix) {
+                Some(result) => result,
+                None => return None,
+            };
+            result = match result.checked_add(x) {
+                Some(result) => result,
+                None => return None,
+            };
+        }
+    } else {
+        for x in xs {
+            let x = match x {
+                Some(x) => x,
+                None => return None,
+            };
+            result = match result.checked_mul(radix) {
+                Some(result) => result,
+                None => return None,
+            };
+            result = match result.checked_sub(x) {
+                Some(result) => result,
+                None => return None,
+            };
+        }
+    }
+
+    Some(result)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use option::*;
+    use num::Float;
+
+    #[test]
+    fn from_str_issue7588() {
+        let u : Option<u8> = from_str_radix_int("1000", 10);
+        assert_eq!(u, None);
+        let s : Option<i16> = from_str_radix_int("80000", 10);
+        assert_eq!(s, None);
+        let f : Option<f32> = from_str_radix_float("10000000000000000000000000000000000000000", 10);
+        assert_eq!(f, Some(Float::infinity()))
+        let fe : Option<f32> = from_str_radix_float("1e40", 10);
+        assert_eq!(fe, Some(Float::infinity()))
+    }
+
+    #[test]
+    fn test_from_str_radix_float() {
+        let x1 : Option<f64> = from_str_radix_float("-123.456", 10);
+        assert_eq!(x1, Some(-123.456));
+        let x2 : Option<f32> = from_str_radix_float("123.456", 10);
+        assert_eq!(x2, Some(123.456));
+        let x3 : Option<f32> = from_str_radix_float("-0.0", 10);
+        assert_eq!(x3, Some(-0.0));
+        let x4 : Option<f32> = from_str_radix_float("0.0", 10);
+        assert_eq!(x4, Some(0.0));
+        let x4 : Option<f32> = from_str_radix_float("1.0", 10);
+        assert_eq!(x4, Some(1.0));
+        let x5 : Option<f32> = from_str_radix_float("-1.0", 10);
+        assert_eq!(x5, Some(-1.0));
+    }
+}

src/libcore/num/uint_macros.rs

@@ -23,4 +23,20 @@ pub const MIN: $T = 0 as $T;
 #[unstable]
 pub const MAX: $T = 0 as $T - 1 as $T;
 
+#[experimental = "might need to return Result"]
+impl ::str::FromStr for $T {
+    #[inline]
+    fn from_str(s: &str) -> ::option::Option<$T> {
+        ::num::strconv::from_str_radix_int(s, 10)
+    }
+}
+
+#[experimental = "might need to return Result"]
+impl ::num::FromStrRadix for $T {
+    #[inline]
+    fn from_str_radix(s: &str, radix: uint) -> ::option::Option<$T> {
+        ::num::strconv::from_str_radix_int(s, radix)
+    }
+}
+
 ))

src/libcore/prelude.rs

@@ -41,6 +41,7 @@ pub use ops::{Fn, FnMut, FnOnce};
 // Reexported functions
 pub use iter::{range, repeat};
 pub use mem::drop;
+pub use str::from_str;
 
 // Reexported types and traits
 

src/libcore/str.rs

@@ -31,6 +31,42 @@ use raw::Repr;
 use slice::{mod, SlicePrelude};
 use uint;
 
+/// A trait to abstract the idea of creating a new instance of a type from a
+/// string.
+#[experimental = "might need to return Result"]
+pub trait FromStr {
+    /// Parses a string `s` to return an optional value of this type. If the
+    /// string is ill-formatted, the None is returned.
+    fn from_str(s: &str) -> Option<Self>;
+}
+
+/// A utility function that just calls FromStr::from_str
+pub fn from_str<A: FromStr>(s: &str) -> Option<A> {
+    FromStr::from_str(s)
+}
+
+impl FromStr for bool {
+    /// Parse a `bool` from a string.
+    ///
+    /// Yields an `Option<bool>`, because `s` may or may not actually be parseable.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// assert_eq!(from_str::<bool>("true"), Some(true));
+    /// assert_eq!(from_str::<bool>("false"), Some(false));
+    /// assert_eq!(from_str::<bool>("not even a boolean"), None);
+    /// ```
+    #[inline]
+    fn from_str(s: &str) -> Option<bool> {
+        match s {
+            "true"  => Some(true),
+            "false" => Some(false),
+            _       => None,
+        }
+    }
+}
+
 /*
 Section: Creating a string
 */

src/libcoretest/num/int_macros.rs

@@ -15,7 +15,8 @@ macro_rules! int_module (($T:ty, $T_i:ident) => (
 mod tests {
     use core::$T_i::*;
     use core::int;
-    use core::num::{Int, SignedInt};
+    use core::num::{FromStrRadix, Int, SignedInt};
+    use core::str::from_str;
     use num;
 
     #[test]
@@ -156,6 +157,49 @@ mod tests {
         assert!(5i.checked_div(0) == None);
         assert!(int::MIN.checked_div(-1) == None);
     }
+
+    #[test]
+    fn test_from_str() {
+        assert_eq!(from_str::<$T>("0"), Some(0 as $T));
+        assert_eq!(from_str::<$T>("3"), Some(3 as $T));
+        assert_eq!(from_str::<$T>("10"), Some(10 as $T));
+        assert_eq!(from_str::<i32>("123456789"), Some(123456789 as i32));
+        assert_eq!(from_str::<$T>("00100"), Some(100 as $T));
+
+        assert_eq!(from_str::<$T>("-1"), Some(-1 as $T));
+        assert_eq!(from_str::<$T>("-3"), Some(-3 as $T));
+        assert_eq!(from_str::<$T>("-10"), Some(-10 as $T));
+        assert_eq!(from_str::<i32>("-123456789"), Some(-123456789 as i32));
+        assert_eq!(from_str::<$T>("-00100"), Some(-100 as $T));
+
+        assert_eq!(from_str::<$T>(""), None);
+        assert_eq!(from_str::<$T>(" "), None);
+        assert_eq!(from_str::<$T>("x"), None);
+    }
+
+    #[test]
+    fn test_from_str_radix() {
+        assert_eq!(FromStrRadix::from_str_radix("123", 10), Some(123 as $T));
+        assert_eq!(FromStrRadix::from_str_radix("1001", 2), Some(9 as $T));
+        assert_eq!(FromStrRadix::from_str_radix("123", 8), Some(83 as $T));
+        assert_eq!(FromStrRadix::from_str_radix("123", 16), Some(291 as i32));
+        assert_eq!(FromStrRadix::from_str_radix("ffff", 16), Some(65535 as i32));
+        assert_eq!(FromStrRadix::from_str_radix("FFFF", 16), Some(65535 as i32));
+        assert_eq!(FromStrRadix::from_str_radix("z", 36), Some(35 as $T));
+        assert_eq!(FromStrRadix::from_str_radix("Z", 36), Some(35 as $T));
+
+        assert_eq!(FromStrRadix::from_str_radix("-123", 10), Some(-123 as $T));
+        assert_eq!(FromStrRadix::from_str_radix("-1001", 2), Some(-9 as $T));
+        assert_eq!(FromStrRadix::from_str_radix("-123", 8), Some(-83 as $T));
+        assert_eq!(FromStrRadix::from_str_radix("-123", 16), Some(-291 as i32));
+        assert_eq!(FromStrRadix::from_str_radix("-ffff", 16), Some(-65535 as i32));
+        assert_eq!(FromStrRadix::from_str_radix("-FFFF", 16), Some(-65535 as i32));
+        assert_eq!(FromStrRadix::from_str_radix("-z", 36), Some(-35 as $T));
+        assert_eq!(FromStrRadix::from_str_radix("-Z", 36), Some(-35 as $T));
+
+        assert_eq!(FromStrRadix::from_str_radix("Z", 35), None::<$T>);
+        assert_eq!(FromStrRadix::from_str_radix("-9", 2), None::<$T>);
+    }
 }
 
 ))

src/libcoretest/num/mod.rs

@@ -45,3 +45,73 @@ pub fn test_num<T>(ten: T, two: T) where
     assert_eq!(ten.div(&two),  ten / two);
     assert_eq!(ten.rem(&two),  ten % two);
 }
+
+#[cfg(test)]
+mod test {
+    use core::option::{Option, Some, None};
+    use core::num::Float;
+    use core::num::from_str_radix;
+
+    #[test]
+    fn from_str_issue7588() {
+        let u : Option<u8> = from_str_radix("1000", 10);
+        assert_eq!(u, None);
+        let s : Option<i16> = from_str_radix("80000", 10);
+        assert_eq!(s, None);
+        let f : Option<f32> = from_str_radix("10000000000000000000000000000000000000000", 10);
+        assert_eq!(f, Some(Float::infinity()))
+        let fe : Option<f32> = from_str_radix("1e40", 10);
+        assert_eq!(fe, Some(Float::infinity()))
+    }
+
+    #[test]
+    fn test_from_str_radix_float() {
+        let x1 : Option<f64> = from_str_radix("-123.456", 10);
+        assert_eq!(x1, Some(-123.456));
+        let x2 : Option<f32> = from_str_radix("123.456", 10);
+        assert_eq!(x2, Some(123.456));
+        let x3 : Option<f32> = from_str_radix("-0.0", 10);
+        assert_eq!(x3, Some(-0.0));
+        let x4 : Option<f32> = from_str_radix("0.0", 10);
+        assert_eq!(x4, Some(0.0));
+        let x4 : Option<f32> = from_str_radix("1.0", 10);
+        assert_eq!(x4, Some(1.0));
+        let x5 : Option<f32> = from_str_radix("-1.0", 10);
+        assert_eq!(x5, Some(-1.0));
+    }
+
+    #[test]
+    fn test_int_from_str_overflow() {
+        let mut i8_val: i8 = 127_i8;
+        assert_eq!(from_str::<i8>("127"), Some(i8_val));
+        assert_eq!(from_str::<i8>("128"), None);
+
+        i8_val += 1 as i8;
+        assert_eq!(from_str::<i8>("-128"), Some(i8_val));
+        assert_eq!(from_str::<i8>("-129"), None);
+
+        let mut i16_val: i16 = 32_767_i16;
+        assert_eq!(from_str::<i16>("32767"), Some(i16_val));
+        assert_eq!(from_str::<i16>("32768"), None);
+
+        i16_val += 1 as i16;
+        assert_eq!(from_str::<i16>("-32768"), Some(i16_val));
+        assert_eq!(from_str::<i16>("-32769"), None);
+
+        let mut i32_val: i32 = 2_147_483_647_i32;
+        assert_eq!(from_str::<i32>("2147483647"), Some(i32_val));
+        assert_eq!(from_str::<i32>("2147483648"), None);
+
+        i32_val += 1 as i32;
+        assert_eq!(from_str::<i32>("-2147483648"), Some(i32_val));
+        assert_eq!(from_str::<i32>("-2147483649"), None);
+
+        let mut i64_val: i64 = 9_223_372_036_854_775_807_i64;
+        assert_eq!(from_str::<i64>("9223372036854775807"), Some(i64_val));
+        assert_eq!(from_str::<i64>("9223372036854775808"), None);
+
+        i64_val += 1 as i64;
+        assert_eq!(from_str::<i64>("-9223372036854775808"), Some(i64_val));
+        assert_eq!(from_str::<i64>("-9223372036854775809"), None);
+    }
+}

src/libcoretest/str.rs

@@ -8,6 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#[test]
+fn test_bool_from_str() {
+    assert_eq!(from_str::<bool>("true"), Some(true));
+    assert_eq!(from_str::<bool>("false"), Some(false));
+    assert_eq!(from_str::<bool>("not even a boolean"), None);
+}
+
 fn check_contains_all_substrings(s: &str) {
     assert!(s.contains(""));
     for i in range(0, s.len()) {

src/libregex/re.rs

@@ -10,7 +10,6 @@
 
 use std::collections::HashMap;
 use std::fmt;
-use std::from_str::from_str;
 use std::str::{MaybeOwned, Owned, Slice};
 
 use compile::Program;

src/librustc/driver/config.rs

@@ -334,8 +334,7 @@ macro_rules! cgoptions(
         }
 
         fn parse_uint(slot: &mut uint, v: Option<&str>) -> bool {
-            use std::from_str::FromStr;
-            match v.and_then(FromStr::from_str) {
+            match v.and_then(from_str) {
                 Some(i) => { *slot = i; true },
                 None => false
             }

src/librustc/driver/pretty.rs

@@ -31,8 +31,8 @@ use syntax::print::{pp, pprust};
 use graphviz as dot;
 
 use std::io::{mod, MemReader};
-use std::from_str::FromStr;
 use std::option;
+use std::str::FromStr;
 use arena::TypedArena;
 
 #[deriving(PartialEq, Show)]

src/libserialize/json.rs

@@ -200,7 +200,7 @@ use std::{char, f64, fmt, io, num, str};
 use std::io::MemWriter;
 use std::mem::{swap, transmute};
 use std::num::{Float, FPNaN, FPInfinite, Int};
-use std::str::ScalarValue;
+use std::str::{FromStr, ScalarValue};
 use std::string;
 use std::vec::Vec;
 use std::ops;
@@ -1988,7 +1988,7 @@ macro_rules! read_primitive {
                 String(s) => {
                     // re: #12967.. a type w/ numeric keys (ie HashMap<uint, V> etc)
                     // is going to have a string here, as per JSON spec.
-                    match std::from_str::from_str(s.as_slice()) {
+                    match std::str::from_str(s.as_slice()) {
                         Some(f) => Ok(f),
                         None => Err(ExpectedError("Number".to_string(), s)),
                     }
@@ -2027,7 +2027,7 @@ impl ::Decoder<DecoderError> for Decoder {
             String(s) => {
                 // re: #12967.. a type w/ numeric keys (ie HashMap<uint, V> etc)
                 // is going to have a string here, as per JSON spec.
-                match std::from_str::from_str(s.as_slice()) {
+                match std::str::from_str(s.as_slice()) {
                     Some(f) => Ok(f),
                     None => Err(ExpectedError("Number".to_string(), s)),
                 }
@@ -2395,7 +2395,7 @@ impl fmt::Show for Json {
     }
 }
 
-impl std::from_str::FromStr for Json {
+impl FromStr for Json {
     fn from_str(s: &str) -> Option<Json> {
         from_str(s).ok()
     }
@@ -2480,7 +2480,7 @@ mod tests {
     #[test]
     fn test_from_str_trait() {
         let s = "null";
-        assert!(::std::from_str::from_str::<Json>(s).unwrap() == from_str(s).unwrap());
+        assert!(::std::str::from_str::<Json>(s).unwrap() == from_str(s).unwrap());
     }
 
     #[test]

src/libstd/from_str.rs

@@ -1,71 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! The `FromStr` trait for types that can be created from strings
-
-#![experimental]
-
-use option::{Option, Some, None};
-use string::String;
-
-/// A trait to abstract the idea of creating a new instance of a type from a
-/// string.
-#[experimental = "might need to return Result"]
-pub trait FromStr {
-    /// Parses a string `s` to return an optional value of this type. If the
-    /// string is ill-formatted, the None is returned.
-    fn from_str(s: &str) -> Option<Self>;
-}
-
-/// A utility function that just calls FromStr::from_str
-pub fn from_str<A: FromStr>(s: &str) -> Option<A> {
-    FromStr::from_str(s)
-}
-
-impl FromStr for bool {
-    /// Parse a `bool` from a string.
-    ///
-    /// Yields an `Option<bool>`, because `s` may or may not actually be parseable.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// assert_eq!(from_str::<bool>("true"), Some(true));
-    /// assert_eq!(from_str::<bool>("false"), Some(false));
-    /// assert_eq!(from_str::<bool>("not even a boolean"), None);
-    /// ```
-    #[inline]
-    fn from_str(s: &str) -> Option<bool> {
-        match s {
-            "true"  => Some(true),
-            "false" => Some(false),
-            _       => None,
-        }
-    }
-}
-
-impl FromStr for String {
-    #[inline]
-    fn from_str(s: &str) -> Option<String> {
-        Some(String::from_str(s))
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use prelude::*;
-
-    #[test]
-    fn test_bool_from_str() {
-        assert_eq!(from_str::<bool>("true"), Some(true));
-        assert_eq!(from_str::<bool>("false"), Some(false));
-        assert_eq!(from_str::<bool>("not even a boolean"), None);
-    }
-}

src/libstd/io/net/ip.rs

@@ -16,13 +16,12 @@
 #![allow(missing_docs)]
 
 use fmt;
-use from_str::FromStr;
 use io::{mod, IoResult, IoError};
 use io::net;
 use iter::Iterator;
 use option::{Option, None, Some};
 use result::{Ok, Err};
-use str::StrPrelude;
+use str::{FromStr, StrPrelude};
 use slice::{CloneSlicePrelude, SlicePrelude};
 use vec::Vec;
 
@@ -540,7 +539,7 @@ impl<'a> ToSocketAddr for &'a str {
 mod test {
     use prelude::*;
     use super::*;
-    use from_str::FromStr;
+    use str::FromStr;
 
     #[test]
     fn test_from_str_ipv4() {

src/libstd/lib.rs

@@ -54,7 +54,7 @@
 //!
 //! For converting to strings use the [`format!`](fmt/index.html)
 //! macro, and for converting from strings use the
-//! [`FromStr`](from_str/index.html) trait.
+//! [`FromStr`](str/trait.FromStr.html) trait.
 //!
 //! ## Platform abstractions
 //!
@@ -219,7 +219,6 @@ pub mod time;
 /* Common traits */
 
 pub mod error;
-pub mod from_str;
 pub mod num;
 pub mod to_string;
 

src/libstd/num/f32.rs

@@ -17,12 +17,10 @@
 
 use prelude::*;
 
-use from_str::FromStr;
 use intrinsics;
 use libc::c_int;
 use num::{Float, FloatMath};
 use num::strconv;
-use num;
 
 pub use core::f32::{RADIX, MANTISSA_DIGITS, DIGITS, EPSILON, MIN_VALUE};
 pub use core::f32::{MIN_POS_VALUE, MAX_VALUE, MIN_EXP, MAX_EXP, MIN_10_EXP};
@@ -339,68 +337,6 @@ pub fn to_str_exp_digits(num: f32, dig: uint, upper: bool) -> String {
     r
 }
 
-#[inline]
-#[deprecated="Use `FromStrRadix::from_str_radix(src, 16)`"]
-pub fn from_str_hex(src: &str) -> Option<f32> {
-    strconv::from_str_radix_float(src, 16)
-}
-
-impl FromStr for f32 {
-    /// Convert a string in base 10 to a float.
-    /// Accepts an optional decimal exponent.
-    ///
-    /// This function accepts strings such as
-    ///
-    /// * '3.14'
-    /// * '+3.14', equivalent to '3.14'
-    /// * '-3.14'
-    /// * '2.5E10', or equivalently, '2.5e10'
-    /// * '2.5E-10'
-    /// * '.' (understood as 0)
-    /// * '5.'
-    /// * '.5', or, equivalently,  '0.5'
-    /// * '+inf', 'inf', '-inf', 'NaN'
-    ///
-    /// Leading and trailing whitespace represent an error.
-    ///
-    /// # Arguments
-    ///
-    /// * src - A string
-    ///
-    /// # Return value
-    ///
-    /// `None` if the string did not represent a valid number.  Otherwise,
-    /// `Some(n)` where `n` is the floating-point number represented by `src`.
-    #[inline]
-    fn from_str(src: &str) -> Option<f32> {
-        strconv::from_str_radix_float(src, 10u)
-    }
-}
-
-impl num::FromStrRadix for f32 {
-    /// Convert a string in a given base to a float.
-    ///
-    /// Due to possible conflicts, this function does **not** accept
-    /// the special values `inf`, `-inf`, `+inf` and `NaN`, **nor**
-    /// does it recognize exponents of any kind.
-    ///
-    /// Leading and trailing whitespace represent an error.
-    ///
-    /// # Arguments
-    ///
-    /// * src - A string
-    /// * radix - The base to use. Must lie in the range [2 .. 36]
-    ///
-    /// # Return value
-    ///
-    /// `None` if the string did not represent a valid number. Otherwise,
-    /// `Some(n)` where `n` is the floating-point number represented by `src`.
-    #[inline]
-    fn from_str_radix(src: &str, radix: uint) -> Option<f32> {
-        strconv::from_str_radix_float(src, radix)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use f32::*;

src/libstd/num/f64.rs

@@ -16,12 +16,10 @@
 
 use prelude::*;
 
-use from_str::FromStr;
 use intrinsics;
 use libc::c_int;
 use num::{Float, FloatMath};
 use num::strconv;
-use num;
 
 pub use core::f64::{RADIX, MANTISSA_DIGITS, DIGITS, EPSILON, MIN_VALUE};
 pub use core::f64::{MIN_POS_VALUE, MAX_VALUE, MIN_EXP, MAX_EXP, MIN_10_EXP};
@@ -347,63 +345,6 @@ pub fn to_str_exp_digits(num: f64, dig: uint, upper: bool) -> String {
     r
 }
 
-#[inline]
-#[deprecated="Use `FromStrRadix::from_str_radix(src, 16)`"]
-pub fn from_str_hex(src: &str) -> Option<f64> {
-    strconv::from_str_radix_float(src, 16)
-}
-
-impl FromStr for f64 {
-    /// Convert a string in base 10 to a float.
-    /// Accepts an optional decimal exponent.
-    ///
-    /// This function accepts strings such as:
-    ///
-    /// * '3.14'
-    /// * '-3.14'
-    /// * '2.5E10', or equivalently, '2.5e10'
-    /// * '2.5E-10'
-    /// * '.' (understood as 0)
-    /// * '5.'
-    /// * '.5', or, equivalently,  '0.5'
-    /// * inf', '-inf', 'NaN'
-    ///
-    /// Leading and trailing whitespace represent an error.
-    ///
-    /// # Arguments
-    ///
-    /// * src - A string
-    ///
-    /// # Return value
-    ///
-    /// `none` if the string did not represent a valid number.  Otherwise,
-    /// `Some(n)` where `n` is the floating-point number represented by `src`.
-    #[inline]
-    fn from_str(src: &str) -> Option<f64> {
-        strconv::from_str_radix_float(src, 10u)
-    }
-}
-
-impl num::FromStrRadix for f64 {
-    /// Convert a string in a given base to a float.
-    ///
-    /// Leading and trailing whitespace represent an error.
-    ///
-    /// # Arguments
-    ///
-    /// * src - A string
-    /// * radix - The base to use. Must lie in the range [2 .. 36]
-    ///
-    /// # Return value
-    ///
-    /// `None` if the string did not represent a valid number. Otherwise,
-    /// `Some(n)` where `n` is the floating-point number represented by `src`.
-    #[inline]
-    fn from_str_radix(src: &str, radix: uint) -> Option<f64> {
-        strconv::from_str_radix_float(src, radix)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use f64::*;

src/libstd/num/i16.rs

@@ -13,11 +13,6 @@
 #![unstable]
 #![doc(primitive = "i16")]
 
-use from_str::FromStr;
-use num::FromStrRadix;
-use num::strconv;
-use option::Option;
-
 pub use core::i16::{BITS, BYTES, MIN, MAX};
 
 int_module!(i16)

src/libstd/num/i32.rs

@@ -13,11 +13,6 @@
 #![unstable]
 #![doc(primitive = "i32")]
 
-use from_str::FromStr;
-use num::FromStrRadix;
-use num::strconv;
-use option::Option;
-
 pub use core::i32::{BITS, BYTES, MIN, MAX};
 
 int_module!(i32)

src/libstd/num/i64.rs

@@ -13,11 +13,6 @@
 #![unstable]
 #![doc(primitive = "i64")]
 
-use from_str::FromStr;
-use num::FromStrRadix;
-use num::strconv;
-use option::Option;
-
 pub use core::i64::{BITS, BYTES, MIN, MAX};
 
 int_module!(i64)

src/libstd/num/i8.rs

@@ -13,11 +13,6 @@
 #![unstable]
 #![doc(primitive = "i8")]
 
-use from_str::FromStr;
-use num::FromStrRadix;
-use num::strconv;
-use option::Option;
-
 pub use core::i8::{BITS, BYTES, MIN, MAX};
 
 int_module!(i8)

src/libstd/num/int.rs

@@ -13,11 +13,6 @@
 #![unstable]
 #![doc(primitive = "int")]
 
-use from_str::FromStr;
-use num::FromStrRadix;
-use num::strconv;
-use option::Option;
-
 pub use core::int::{BITS, BYTES, MIN, MAX};
 
 int_module!(int)

src/libstd/num/int_macros.rs

@@ -14,131 +14,4 @@
 
 macro_rules! int_module (($T:ty) => (
 
-#[experimental = "might need to return Result"]
-impl FromStr for $T {
-    #[inline]
-    fn from_str(s: &str) -> Option<$T> {
-        strconv::from_str_radix_int(s, 10)
-    }
-}
-
-#[experimental = "might need to return Result"]
-impl FromStrRadix for $T {
-    #[inline]
-    fn from_str_radix(s: &str, radix: uint) -> Option<$T> {
-        strconv::from_str_radix_int(s, radix)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use prelude::*;
-    use num::FromStrRadix;
-
-    #[test]
-    fn test_from_str() {
-        assert_eq!(from_str::<$T>("0"), Some(0 as $T));
-        assert_eq!(from_str::<$T>("3"), Some(3 as $T));
-        assert_eq!(from_str::<$T>("10"), Some(10 as $T));
-        assert_eq!(from_str::<i32>("123456789"), Some(123456789 as i32));
-        assert_eq!(from_str::<$T>("00100"), Some(100 as $T));
-
-        assert_eq!(from_str::<$T>("-1"), Some(-1 as $T));
-        assert_eq!(from_str::<$T>("-3"), Some(-3 as $T));
-        assert_eq!(from_str::<$T>("-10"), Some(-10 as $T));
-        assert_eq!(from_str::<i32>("-123456789"), Some(-123456789 as i32));
-        assert_eq!(from_str::<$T>("-00100"), Some(-100 as $T));
-
-        assert_eq!(from_str::<$T>(""), None);
-        assert_eq!(from_str::<$T>(" "), None);
-        assert_eq!(from_str::<$T>("x"), None);
-    }
-
-    #[test]
-    fn test_from_str_radix() {
-        assert_eq!(FromStrRadix::from_str_radix("123", 10), Some(123 as $T));
-        assert_eq!(FromStrRadix::from_str_radix("1001", 2), Some(9 as $T));
-        assert_eq!(FromStrRadix::from_str_radix("123", 8), Some(83 as $T));
-        assert_eq!(FromStrRadix::from_str_radix("123", 16), Some(291 as i32));
-        assert_eq!(FromStrRadix::from_str_radix("ffff", 16), Some(65535 as i32));
-        assert_eq!(FromStrRadix::from_str_radix("FFFF", 16), Some(65535 as i32));
-        assert_eq!(FromStrRadix::from_str_radix("z", 36), Some(35 as $T));
-        assert_eq!(FromStrRadix::from_str_radix("Z", 36), Some(35 as $T));
-
-        assert_eq!(FromStrRadix::from_str_radix("-123", 10), Some(-123 as $T));
-        assert_eq!(FromStrRadix::from_str_radix("-1001", 2), Some(-9 as $T));
-        assert_eq!(FromStrRadix::from_str_radix("-123", 8), Some(-83 as $T));
-        assert_eq!(FromStrRadix::from_str_radix("-123", 16), Some(-291 as i32));
-        assert_eq!(FromStrRadix::from_str_radix("-ffff", 16), Some(-65535 as i32));
-        assert_eq!(FromStrRadix::from_str_radix("-FFFF", 16), Some(-65535 as i32));
-        assert_eq!(FromStrRadix::from_str_radix("-z", 36), Some(-35 as $T));
-        assert_eq!(FromStrRadix::from_str_radix("-Z", 36), Some(-35 as $T));
-
-        assert_eq!(FromStrRadix::from_str_radix("Z", 35), None::<$T>);
-        assert_eq!(FromStrRadix::from_str_radix("-9", 2), None::<$T>);
-    }
-
-    #[test]
-    fn test_int_to_str_overflow() {
-        let mut i8_val: i8 = 127_i8;
-        assert_eq!(i8_val.to_string(), "127".to_string());
-
-        i8_val += 1 as i8;
-        assert_eq!(i8_val.to_string(), "-128".to_string());
-
-        let mut i16_val: i16 = 32_767_i16;
-        assert_eq!(i16_val.to_string(), "32767".to_string());
-
-        i16_val += 1 as i16;
-        assert_eq!(i16_val.to_string(), "-32768".to_string());
-
-        let mut i32_val: i32 = 2_147_483_647_i32;
-        assert_eq!(i32_val.to_string(), "2147483647".to_string());
-
-        i32_val += 1 as i32;
-        assert_eq!(i32_val.to_string(), "-2147483648".to_string());
-
-        let mut i64_val: i64 = 9_223_372_036_854_775_807_i64;
-        assert_eq!(i64_val.to_string(), "9223372036854775807".to_string());
-
-        i64_val += 1 as i64;
-        assert_eq!(i64_val.to_string(), "-9223372036854775808".to_string());
-    }
-
-    #[test]
-    fn test_int_from_str_overflow() {
-        let mut i8_val: i8 = 127_i8;
-        assert_eq!(from_str::<i8>("127"), Some(i8_val));
-        assert_eq!(from_str::<i8>("128"), None);
-
-        i8_val += 1 as i8;
-        assert_eq!(from_str::<i8>("-128"), Some(i8_val));
-        assert_eq!(from_str::<i8>("-129"), None);
-
-        let mut i16_val: i16 = 32_767_i16;
-        assert_eq!(from_str::<i16>("32767"), Some(i16_val));
-        assert_eq!(from_str::<i16>("32768"), None);
-
-        i16_val += 1 as i16;
-        assert_eq!(from_str::<i16>("-32768"), Some(i16_val));
-        assert_eq!(from_str::<i16>("-32769"), None);
-
-        let mut i32_val: i32 = 2_147_483_647_i32;
-        assert_eq!(from_str::<i32>("2147483647"), Some(i32_val));
-        assert_eq!(from_str::<i32>("2147483648"), None);
-
-        i32_val += 1 as i32;
-        assert_eq!(from_str::<i32>("-2147483648"), Some(i32_val));
-        assert_eq!(from_str::<i32>("-2147483649"), None);
-
-        let mut i64_val: i64 = 9_223_372_036_854_775_807_i64;
-        assert_eq!(from_str::<i64>("9223372036854775807"), Some(i64_val));
-        assert_eq!(from_str::<i64>("9223372036854775808"), None);
-
-        i64_val += 1 as i64;
-        assert_eq!(from_str::<i64>("-9223372036854775808"), Some(i64_val));
-        assert_eq!(from_str::<i64>("-9223372036854775809"), None);
-    }
-}
-
 ))

src/libstd/num/mod.rs

@@ -16,8 +16,6 @@
 #![experimental]
 #![allow(missing_docs)]
 
-use option::Option;
-
 #[cfg(test)] use cmp::PartialEq;
 #[cfg(test)] use fmt::Show;
 #[cfg(test)] use ops::{Add, Sub, Mul, Div, Rem};
@@ -31,6 +29,7 @@ pub use core::num::{checked_next_power_of_two};
 pub use core::num::{from_int, from_i8, from_i16, from_i32, from_i64};
 pub use core::num::{from_uint, from_u8, from_u16, from_u32, from_u64};
 pub use core::num::{from_f32, from_f64};
+pub use core::num::{FromStrRadix, from_str_radix};
 pub use core::num::{FPCategory, FPNaN, FPInfinite, FPZero, FPSubnormal};
 pub use core::num::{FPNormal, Float};
 
@@ -115,18 +114,6 @@ pub trait FloatMath: Float {
     fn atanh(self) -> Self;
 }
 
-/// A generic trait for converting a string with a radix (base) to a value
-#[experimental = "might need to return Result"]
-pub trait FromStrRadix {
-    fn from_str_radix(str: &str, radix: uint) -> Option<Self>;
-}
-
-/// A utility function that just calls FromStrRadix::from_str_radix.
-#[experimental = "might need to return Result"]
-pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: uint) -> Option<T> {
-    FromStrRadix::from_str_radix(str, radix)
-}
-
 // DEPRECATED
 
 #[deprecated = "Use `FloatMath::abs_sub`"]

src/libstd/num/strconv.rs

@@ -13,12 +13,8 @@
 #![allow(missing_docs)]
 
 use char;
-use char::Char;
-use from_str::from_str;
-use iter::Iterator;
 use num;
 use num::{Int, Float, FPNaN, FPInfinite, ToPrimitive};
-use option::{None, Option, Some};
 use slice::{SlicePrelude, CloneSliceAllocPrelude};
 use str::StrPrelude;
 use string::String;
@@ -425,242 +421,35 @@ pub fn float_to_str_common<T: Float>(
 static DIGIT_P_RADIX: uint = ('p' as uint) - ('a' as uint) + 11u;
 static DIGIT_E_RADIX: uint = ('e' as uint) - ('a' as uint) + 11u;
 
-pub fn from_str_radix_float<T: Float>(src: &str, radix: uint) -> Option<T> {
-   assert!(radix >= 2 && radix <= 36,
-           "from_str_radix_float: must lie in the range `[2, 36]` - found {}",
-           radix);
-
-    let _0: T = Float::zero();
-    let _1: T = Float::one();
-    let radix_t: T = num::cast(radix as int).unwrap();
-
-    // Special values
-    match src {
-        "inf"   => return Some(Float::infinity()),
-        "-inf"  => return Some(Float::neg_infinity()),
-        "NaN"   => return Some(Float::nan()),
-        _       => {},
-    }
-
-    let (is_positive, src) =  match src.slice_shift_char() {
-        (None, _)        => return None,
-        (Some('-'), "")  => return None,
-        (Some('-'), src) => (false, src),
-        (Some(_), _)     => (true,  src),
-    };
-
-    // The significand to accumulate
-    let mut sig = if is_positive { _0 } else { -_0 };
-    // Necessary to detect overflow
-    let mut prev_sig = sig;
-    let mut cs = src.chars().enumerate();
-    // Exponent prefix and exponent index offset
-    let mut exp_info = None::<(char, uint)>;
-
-    // Parse the integer part of the significand
-    for (i, c) in cs {
-        match c.to_digit(radix) {
-            Some(digit) => {
-                // shift significand one digit left
-                sig = sig * radix_t;
-
-                // add/subtract current digit depending on sign
-                if is_positive {
-                    sig = sig + num::cast(digit as int).unwrap();
-                } else {
-                    sig = sig - num::cast(digit as int).unwrap();
-                }
-
-                // Detect overflow by comparing to last value, except
-                // if we've not seen any non-zero digits.
-                if prev_sig != _0 {
-                    if is_positive && sig <= prev_sig
-                        { return Some(Float::infinity()); }
-                    if !is_positive && sig >= prev_sig
-                        { return Some(Float::neg_infinity()); }
-
-                    // Detect overflow by reversing the shift-and-add process
-                    let digit: T = num::cast(digit as int).unwrap();
-                    if is_positive && (prev_sig != ((sig - digit) / radix_t))
-                        { return Some(Float::infinity()); }
-                    if !is_positive && (prev_sig != ((sig + digit) / radix_t))
-                        { return Some(Float::neg_infinity()); }
-                }
-                prev_sig = sig;
-            },
-            None => match c {
-                'e' | 'E' | 'p' | 'P' => {
-                    exp_info = Some((c, i + 1));
-                    break;  // start of exponent
-                },
-                '.' => {
-                    break;  // start of fractional part
-                },
-                _ => {
-                    return None;
-                },
-            },
-        }
-    }
-
-    // If we are not yet at the exponent parse the fractional
-    // part of the significand
-    if exp_info.is_none() {
-        let mut power = _1;
-        for (i, c) in cs {
-            match c.to_digit(radix) {
-                Some(digit) => {
-                    let digit: T = num::cast(digit).unwrap();
-                    // Decrease power one order of magnitude
-                    power = power / radix_t;
-                    // add/subtract current digit depending on sign
-                    sig = if is_positive {
-                        sig + digit * power
-                    } else {
-                        sig - digit * power
-                    };
-                    // Detect overflow by comparing to last value
-                    if is_positive && sig < prev_sig
-                        { return Some(Float::infinity()); }
-                    if !is_positive && sig > prev_sig
-                        { return Some(Float::neg_infinity()); }
-                    prev_sig = sig;
-                },
-                None => match c {
-                    'e' | 'E' | 'p' | 'P' => {
-                        exp_info = Some((c, i + 1));
-                        break; // start of exponent
-                    },
-                    _ => {
-                        return None; // invalid number
-                    },
-                },
-            }
-        }
-    }
-
-    // Parse and calculate the exponent
-    let exp = match exp_info {
-        Some((c, offset)) => {
-            let base: T = match c {
-                'E' | 'e' if radix == 10 => num::cast(10u).unwrap(),
-                'P' | 'p' if radix == 16 => num::cast(2u).unwrap(),
-                _ => return None,
-            };
-
-            // Parse the exponent as decimal integer
-            let src = src[offset..];
-            let (is_positive, exp) = match src.slice_shift_char() {
-                (Some('-'), src) => (false, from_str::<uint>(src)),
-                (Some('+'), src) => (true,  from_str::<uint>(src)),
-                (Some(_), _)     => (true,  from_str::<uint>(src)),
-                (None, _)        => return None,
-            };
-
-            match (is_positive, exp) {
-                (true,  Some(exp)) => base.powi(exp as i32),
-                (false, Some(exp)) => _1 / base.powi(exp as i32),
-                (_, None)          => return None,
-            }
-        },
-        None => _1, // no exponent
-    };
-
-    Some(sig * exp)
-}
-
-pub fn from_str_radix_int<T: Int>(src: &str, radix: uint) -> Option<T> {
-   assert!(radix >= 2 && radix <= 36,
-           "from_str_radix_int: must lie in the range `[2, 36]` - found {}",
-           radix);
-
-    fn cast<T: Int>(x: uint) -> T {
-        num::cast(x).unwrap()
-    }
-
-    let _0: T = Int::zero();
-    let _1: T = Int::one();
-    let is_signed = _0 > Int::min_value();
-
-    let (is_positive, src) =  match src.slice_shift_char() {
-        (Some('-'), src) if is_signed => (false, src),
-        (Some(_), _) => (true, src),
-        (None, _) => return None,
-    };
-
-    let mut xs = src.chars().map(|c| {
-        c.to_digit(radix).map(cast)
-    });
-    let radix = cast(radix);
-    let mut result = _0;
-
-    if is_positive {
-        for x in xs {
-            let x = match x {
-                Some(x) => x,
-                None => return None,
-            };
-            result = match result.checked_mul(radix) {
-                Some(result) => result,
-                None => return None,
-            };
-            result = match result.checked_add(x) {
-                Some(result) => result,
-                None => return None,
-            };
-        }
-    } else {
-        for x in xs {
-            let x = match x {
-                Some(x) => x,
-                None => return None,
-            };
-            result = match result.checked_mul(radix) {
-                Some(result) => result,
-                None => return None,
-            };
-            result = match result.checked_sub(x) {
-                Some(result) => result,
-                None => return None,
-            };
-        }
-    }
-
-    Some(result)
-}
-
 #[cfg(test)]
-mod test {
-    use super::*;
-    use option::*;
-    use num::Float;
+mod tests {
+    use to_string::ToString;
 
     #[test]
-    fn from_str_issue7588() {
-        let u : Option<u8> = from_str_radix_int("1000", 10);
-        assert_eq!(u, None);
-        let s : Option<i16> = from_str_radix_int("80000", 10);
-        assert_eq!(s, None);
-        let f : Option<f32> = from_str_radix_float("10000000000000000000000000000000000000000", 10);
-        assert_eq!(f, Some(Float::infinity()))
-        let fe : Option<f32> = from_str_radix_float("1e40", 10);
-        assert_eq!(fe, Some(Float::infinity()))
-    }
+    fn test_int_to_str_overflow() {
+        let mut i8_val: i8 = 127_i8;
+        assert_eq!(i8_val.to_string(), "127".to_string());
 
-    #[test]
-    fn test_from_str_radix_float() {
-        let x1 : Option<f64> = from_str_radix_float("-123.456", 10);
-        assert_eq!(x1, Some(-123.456));
-        let x2 : Option<f32> = from_str_radix_float("123.456", 10);
-        assert_eq!(x2, Some(123.456));
-        let x3 : Option<f32> = from_str_radix_float("-0.0", 10);
-        assert_eq!(x3, Some(-0.0));
-        let x4 : Option<f32> = from_str_radix_float("0.0", 10);
-        assert_eq!(x4, Some(0.0));
-        let x4 : Option<f32> = from_str_radix_float("1.0", 10);
-        assert_eq!(x4, Some(1.0));
-        let x5 : Option<f32> = from_str_radix_float("-1.0", 10);
-        assert_eq!(x5, Some(-1.0));
+        i8_val += 1 as i8;
+        assert_eq!(i8_val.to_string(), "-128".to_string());
+
+        let mut i16_val: i16 = 32_767_i16;
+        assert_eq!(i16_val.to_string(), "32767".to_string());
+
+        i16_val += 1 as i16;
+        assert_eq!(i16_val.to_string(), "-32768".to_string());
+
+        let mut i32_val: i32 = 2_147_483_647_i32;
+        assert_eq!(i32_val.to_string(), "2147483647".to_string());
+
+        i32_val += 1 as i32;
+        assert_eq!(i32_val.to_string(), "-2147483648".to_string());
+
+        let mut i64_val: i64 = 9_223_372_036_854_775_807_i64;
+        assert_eq!(i64_val.to_string(), "9223372036854775807".to_string());
+
+        i64_val += 1 as i64;
+        assert_eq!(i64_val.to_string(), "-9223372036854775808".to_string());
     }
 }
 

src/libstd/num/u16.rs

@@ -13,11 +13,6 @@
 #![unstable]
 #![doc(primitive = "u16")]
 
-use from_str::FromStr;
-use num::FromStrRadix;
-use num::strconv;
-use option::Option;
-
 pub use core::u16::{BITS, BYTES, MIN, MAX};
 
 uint_module!(u16)

src/libstd/num/u32.rs

@@ -13,11 +13,6 @@
 #![unstable]
 #![doc(primitive = "u32")]
 
-use from_str::FromStr;
-use num::FromStrRadix;
-use num::strconv;
-use option::Option;
-
 pub use core::u32::{BITS, BYTES, MIN, MAX};
 
 uint_module!(u32)

src/libstd/num/u64.rs

@@ -13,11 +13,6 @@
 #![unstable]
 #![doc(primitive = "u64")]
 
-use from_str::FromStr;
-use num::FromStrRadix;
-use num::strconv;
-use option::Option;
-
 pub use core::u64::{BITS, BYTES, MIN, MAX};
 
 uint_module!(u64)

src/libstd/num/u8.rs

@@ -13,11 +13,6 @@
 #![unstable]
 #![doc(primitive = "u8")]
 
-use from_str::FromStr;
-use num::FromStrRadix;
-use num::strconv;
-use option::Option;
-
 pub use core::u8::{BITS, BYTES, MIN, MAX};
 
 uint_module!(u8)

src/libstd/num/uint.rs

@@ -13,11 +13,6 @@
 #![unstable]
 #![doc(primitive = "uint")]
 
-use from_str::FromStr;
-use num::FromStrRadix;
-use num::strconv;
-use option::Option;
-
 pub use core::uint::{BITS, BYTES, MIN, MAX};
 
 uint_module!(uint)

src/libstd/num/uint_macros.rs

@@ -15,22 +15,6 @@
 
 macro_rules! uint_module (($T:ty) => (
 
-#[experimental = "might need to return Result"]
-impl FromStr for $T {
-    #[inline]
-    fn from_str(s: &str) -> Option<$T> {
-        strconv::from_str_radix_int(s, 10)
-    }
-}
-
-#[experimental = "might need to return Result"]
-impl FromStrRadix for $T {
-    #[inline]
-    fn from_str_radix(s: &str, radix: uint) -> Option<$T> {
-        strconv::from_str_radix_int(s, radix)
-    }
-}
-
 // String conversion functions and impl num -> str
 
 /// Convert to a string as a byte slice in a given base.

src/libstd/path/posix.rs

@@ -13,12 +13,11 @@
 use c_str::{CString, ToCStr};
 use clone::Clone;
 use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
-use from_str::FromStr;
 use hash;
 use io::Writer;
 use iter::{DoubleEndedIterator, AdditiveIterator, Extend, Iterator, Map};
 use option::{Option, None, Some};
-use str::Str;
+use str::{FromStr, Str};
 use str;
 use slice::{CloneSliceAllocPrelude, Splits, AsSlice, VectorVector,
             PartialEqSlicePrelude, SlicePrelude};

src/libstd/path/windows.rs

@@ -16,14 +16,13 @@ use ascii::AsciiCast;
 use c_str::{CString, ToCStr};
 use clone::Clone;
 use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
-use from_str::FromStr;
 use hash;
 use io::Writer;
 use iter::{AdditiveIterator, DoubleEndedIterator, Extend, Iterator, Map};
 use mem;
 use option::{Option, Some, None};
 use slice::{AsSlice, SlicePrelude};
-use str::{CharSplits, Str, StrAllocating, StrVector, StrPrelude};
+use str::{CharSplits, FromStr, Str, StrAllocating, StrVector, StrPrelude};
 use string::String;
 use unicode::char::UnicodeChar;
 use vec::Vec;

src/libstd/prelude.rs

@@ -50,9 +50,9 @@
 #[doc(no_inline)] pub use ops::{Fn, FnMut, FnOnce};
 
 // Reexported functions
-#[doc(no_inline)] pub use from_str::from_str;
 #[doc(no_inline)] pub use iter::{range, repeat};
 #[doc(no_inline)] pub use mem::drop;
+#[doc(no_inline)] pub use str::from_str;
 
 // Reexported types and traits
 

src/libstd/rt/backtrace.rs

@@ -12,13 +12,12 @@
 
 #![allow(non_camel_case_types)]
 
-use from_str::from_str;
 use io::{IoResult, Writer};
 use iter::Iterator;
 use option::{Some, None};
 use os;
 use result::{Ok, Err};
-use str::StrPrelude;
+use str::{StrPrelude, from_str};
 use sync::atomic;
 use unicode::char::UnicodeChar;
 

src/libstd/rt/util.rs

@@ -8,12 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use from_str::FromStr;
-use from_str::from_str;
 use libc::uintptr_t;
 use option::{Some, None, Option};
 use os;
-use str::Str;
+use str::{FromStr, from_str, Str};
 use sync::atomic;
 
 /// Dynamically inquire about whether we're running under V.

src/libtest/lib.rs

@@ -53,13 +53,13 @@ use std::cmp;
 use std::f64;
 use std::fmt::Show;
 use std::fmt;
-use std::from_str::FromStr;
 use std::io::fs::PathExtensions;
 use std::io::stdio::StdWriter;
 use std::io::{File, ChanReader, ChanWriter};
 use std::io;
 use std::num::{Float, FloatMath, Int};
 use std::os;
+use std::str::FromStr;
 use std::string::String;
 use std::task::TaskBuilder;
 use std::time::Duration;