std: Remove deprecated functionality from 1.5

This is a standard "clean out libstd" commit which removes all 1.5-and-before
deprecated functionality as it's now all been deprecated for at least one entire
cycle.

11 files changed, 2 insertions, 612 deletions

diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index 959b6a97c5c..f063c6b0676 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -4750,87 +4750,3 @@ impl<T> ExactSizeIterator for Once<T> {
 pub fn once<T>(value: T) -> Once<T> {
     Once { inner: Some(value).into_iter() }
 }
-
-/// Functions for lexicographical ordering of sequences.
-///
-/// Lexicographical ordering through `<`, `<=`, `>=`, `>` requires
-/// that the elements implement both `PartialEq` and `PartialOrd`.
-///
-/// If two sequences are equal up until the point where one ends,
-/// the shorter sequence compares less.
-#[rustc_deprecated(since = "1.4.0", reason = "use the equivalent methods on `Iterator` instead")]
-#[unstable(feature = "iter_order_deprecated", reason = "needs review and revision",
-           issue = "27737")]
-pub mod order {
-    use cmp;
-    use cmp::{Eq, Ord, PartialOrd, PartialEq};
-    use option::Option;
-    use super::Iterator;
-
-    /// Compare `a` and `b` for equality using `Eq`
-    pub fn equals<A, L, R>(a: L, b: R) -> bool where
-        A: Eq,
-        L: Iterator<Item=A>,
-        R: Iterator<Item=A>,
-    {
-        a.eq(b)
-    }
-
-    /// Order `a` and `b` lexicographically using `Ord`
-    pub fn cmp<A, L, R>(a: L, b: R) -> cmp::Ordering where
-        A: Ord,
-        L: Iterator<Item=A>,
-        R: Iterator<Item=A>,
-    {
-        a.cmp(b)
-    }
-
-    /// Order `a` and `b` lexicographically using `PartialOrd`
-    pub fn partial_cmp<L: Iterator, R: Iterator>(a: L, b: R) -> Option<cmp::Ordering> where
-        L::Item: PartialOrd<R::Item>
-    {
-        a.partial_cmp(b)
-    }
-
-    /// Compare `a` and `b` for equality (Using partial equality, `PartialEq`)
-    pub fn eq<L: Iterator, R: Iterator>(a: L, b: R) -> bool where
-        L::Item: PartialEq<R::Item>,
-    {
-        a.eq(b)
-    }
-
-    /// Compares `a` and `b` for nonequality (Using partial equality, `PartialEq`)
-    pub fn ne<L: Iterator, R: Iterator>(a: L, b: R) -> bool where
-        L::Item: PartialEq<R::Item>,
-    {
-        a.ne(b)
-    }
-
-    /// Returns `a` < `b` lexicographically (Using partial order, `PartialOrd`)
-    pub fn lt<L: Iterator, R: Iterator>(a: L, b: R) -> bool where
-        L::Item: PartialOrd<R::Item>,
-    {
-        a.lt(b)
-    }
-
-    /// Returns `a` <= `b` lexicographically (Using partial order, `PartialOrd`)
-    pub fn le<L: Iterator, R: Iterator>(a: L, b: R) -> bool where
-        L::Item: PartialOrd<R::Item>,
-    {
-        a.le(b)
-    }
-
-    /// Returns `a` > `b` lexicographically (Using partial order, `PartialOrd`)
-    pub fn gt<L: Iterator, R: Iterator>(a: L, b: R) -> bool where
-        L::Item: PartialOrd<R::Item>,
-    {
-        a.gt(b)
-    }
-
-    /// Returns `a` >= `b` lexicographically (Using partial order, `PartialOrd`)
-    pub fn ge<L: Iterator, R: Iterator>(a: L, b: R) -> bool where
-        L::Item: PartialOrd<R::Item>,
-    {
-        a.ge(b)
-    }
-}
diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs
index 86f2e3bcec3..454e2b02b1c 100644
--- a/src/libcore/lib.rs
+++ b/src/libcore/lib.rs
@@ -153,12 +153,6 @@ pub mod option;
 pub mod raw;
 pub mod result;
 
-#[cfg(stage0)]
-#[path = "simd_old.rs"]
-pub mod simd;
-#[cfg(not(stage0))]
-pub mod simd;
-
 pub mod slice;
 pub mod str;
 pub mod hash;
diff --git a/src/libcore/num/f32.rs b/src/libcore/num/f32.rs
index 359d15640f9..8af1022acdf 100644
--- a/src/libcore/num/f32.rs
+++ b/src/libcore/num/f32.rs
@@ -15,11 +15,9 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-use prelude::v1::*;
-
 use intrinsics;
 use mem;
-use num::{Float, ParseFloatError};
+use num::Float;
 use num::FpCategory as Fp;
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -163,8 +161,6 @@ impl Float for f32 {
     #[inline]
     fn one() -> f32 { 1.0 }
 
-    from_str_radix_float_impl! { f32 }
-
     /// Returns `true` if the number is NaN.
     #[inline]
     fn is_nan(self) -> bool { self != self }
diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs
index 1a6acc5f4ab..9486e4337bf 100644
--- a/src/libcore/num/f64.rs
+++ b/src/libcore/num/f64.rs
@@ -15,12 +15,10 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-use prelude::v1::*;
-
 use intrinsics;
 use mem;
 use num::FpCategory as Fp;
-use num::{Float, ParseFloatError};
+use num::Float;
 
 #[stable(feature = "rust1", since = "1.0.0")]
 #[allow(missing_docs)]
@@ -163,8 +161,6 @@ impl Float for f64 {
     #[inline]
     fn one() -> f64 { 1.0 }
 
-    from_str_radix_float_impl! { f64 }
-
     /// Returns `true` if the number is NaN.
     #[inline]
     fn is_nan(self) -> bool { self != self }
diff --git a/src/libcore/num/float_macros.rs b/src/libcore/num/float_macros.rs
index 88c3b756793..b3adef53dab 100644
--- a/src/libcore/num/float_macros.rs
+++ b/src/libcore/num/float_macros.rs
@@ -18,144 +18,3 @@ macro_rules! assert_approx_eq {
                 "{} is not approximately equal to {}", *a, *b);
     })
 }
-
-macro_rules! from_str_radix_float_impl {
-    ($T:ty) => {
-        fn from_str_radix(src: &str, radix: u32)
-                          -> Result<$T, ParseFloatError> {
-            use num::dec2flt::{pfe_empty, pfe_invalid};
-
-            // Special values
-            match src {
-                "inf"   => return Ok(Float::infinity()),
-                "-inf"  => return Ok(Float::neg_infinity()),
-                "NaN"   => return Ok(Float::nan()),
-                _       => {},
-            }
-
-            let (is_positive, src) =  match src.slice_shift_char() {
-                None             => return Err(pfe_empty()),
-                Some(('-', ""))  => return Err(pfe_empty()),
-                Some(('-', src)) => (false, src),
-                Some((_, _))     => (true,  src),
-            };
-
-            // The significand to accumulate
-            let mut sig = if is_positive { 0.0 } else { -0.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, usize)>;
-
-            // Parse the integer part of the significand
-            for (i, c) in cs.by_ref() {
-                match c.to_digit(radix) {
-                    Some(digit) => {
-                        // shift significand one digit left
-                        sig = sig * (radix as $T);
-
-                        // add/subtract current digit depending on sign
-                        if is_positive {
-                            sig = sig + ((digit as isize) as $T);
-                        } else {
-                            sig = sig - ((digit as isize) as $T);
-                        }
-
-                        // Detect overflow by comparing to last value, except
-                        // if we've not seen any non-zero digits.
-                        if prev_sig != 0.0 {
-                            if is_positive && sig <= prev_sig
-                                { return Ok(Float::infinity()); }
-                            if !is_positive && sig >= prev_sig
-                                { return Ok(Float::neg_infinity()); }
-
-                            // Detect overflow by reversing the shift-and-add process
-                            if is_positive && (prev_sig != (sig - digit as $T) / radix as $T)
-                                { return Ok(Float::infinity()); }
-                            if !is_positive && (prev_sig != (sig + digit as $T) / radix as $T)
-                                { return Ok(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 Err(pfe_invalid())
-                        },
-                    },
-                }
-            }
-
-            // If we are not yet at the exponent parse the fractional
-            // part of the significand
-            if exp_info.is_none() {
-                let mut power = 1.0;
-                for (i, c) in cs.by_ref() {
-                    match c.to_digit(radix) {
-                        Some(digit) => {
-                            // Decrease power one order of magnitude
-                            power = power / (radix as $T);
-                            // add/subtract current digit depending on sign
-                            sig = if is_positive {
-                                sig + (digit as $T) * power
-                            } else {
-                                sig - (digit as $T) * power
-                            };
-                            // Detect overflow by comparing to last value
-                            if is_positive && sig < prev_sig
-                                { return Ok(Float::infinity()); }
-                            if !is_positive && sig > prev_sig
-                                { return Ok(Float::neg_infinity()); }
-                            prev_sig = sig;
-                        },
-                        None => match c {
-                            'e' | 'E' | 'p' | 'P' => {
-                                exp_info = Some((c, i + 1));
-                                break; // start of exponent
-                            },
-                            _ => {
-                                return Err(pfe_invalid())
-                            },
-                        },
-                    }
-                }
-            }
-
-            // Parse and calculate the exponent
-            let exp = match exp_info {
-                Some((c, offset)) => {
-                    let base = match c {
-                        'E' | 'e' if radix == 10 => 10.0,
-                        'P' | 'p' if radix == 16 => 2.0,
-                        _ => return Err(pfe_invalid()),
-                    };
-
-                    // Parse the exponent as decimal integer
-                    let src = &src[offset..];
-                    let (is_positive, exp) = match src.slice_shift_char() {
-                        Some(('-', src)) => (false, src.parse::<usize>()),
-                        Some(('+', src)) => (true,  src.parse::<usize>()),
-                        Some((_, _))     => (true,  src.parse::<usize>()),
-                        None             => return Err(pfe_invalid()),
-                    };
-
-                    match (is_positive, exp) {
-                        (true,  Ok(exp)) => base.powi(exp as i32),
-                        (false, Ok(exp)) => 1.0 / base.powi(exp as i32),
-                        (_, Err(_))      => return Err(pfe_invalid()),
-                    }
-                },
-                None => 1.0, // no exponent
-            };
-
-            Ok(sig * exp)
-        }
-    }
-}
diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs
index e1e5c01adb7..4f3c1256709 100644
--- a/src/libcore/num/mod.rs
+++ b/src/libcore/num/mod.rs
@@ -1771,12 +1771,6 @@ pub trait Float: Sized {
     #[unstable(feature = "float_extras", reason = "needs removal",
                issue = "27752")]
     fn one() -> Self;
-    /// Parses the string `s` with the radix `r` as a float.
-    #[unstable(feature = "float_from_str_radix", reason = "recently moved API",
-               issue = "27736")]
-    #[rustc_deprecated(since = "1.4.0",
-                 reason = "unclear how useful or correct this is")]
-    fn from_str_radix(s: &str, r: u32) -> Result<Self, ParseFloatError>;
 
     /// Returns true if this value is NaN and false otherwise.
     #[stable(feature = "core", since = "1.6.0")]
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index 209cebeaf1b..a1a434ba919 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -154,7 +154,6 @@ use mem;
 use ops::FnOnce;
 use result::Result::{Ok, Err};
 use result::Result;
-use slice;
 
 // Note that this is not a lang item per se, but it has a hidden dependency on
 // `Iterator`, which is one. The compiler assumes that the `next` method of
@@ -269,42 +268,6 @@ impl<T> Option<T> {
         }
     }
 
-    /// Converts from `Option<T>` to `&mut [T]` (without copying)
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(as_slice)]
-    /// # #![allow(deprecated)]
-    ///
-    /// let mut x = Some("Diamonds");
-    /// {
-    ///     let v = x.as_mut_slice();
-    ///     assert!(v == ["Diamonds"]);
-    ///     v[0] = "Dirt";
-    ///     assert!(v == ["Dirt"]);
-    /// }
-    /// assert_eq!(x, Some("Dirt"));
-    /// ```
-    #[inline]
-    #[unstable(feature = "as_slice",
-               reason = "waiting for mut conventions",
-               issue = "27776")]
-    #[rustc_deprecated(since = "1.4.0", reason = "niche API, unclear of usefulness")]
-    #[allow(deprecated)]
-    pub fn as_mut_slice(&mut self) -> &mut [T] {
-        match *self {
-            Some(ref mut x) => {
-                let result: &mut [T] = slice::mut_ref_slice(x);
-                result
-            }
-            None => {
-                let result: &mut [T] = &mut [];
-                result
-            }
-        }
-    }
-
     /////////////////////////////////////////////////////////////////////////
     // Getting to contained values
     /////////////////////////////////////////////////////////////////////////
@@ -690,22 +653,6 @@ impl<T> Option<T> {
     pub fn take(&mut self) -> Option<T> {
         mem::replace(self, None)
     }
-
-    /// Converts from `Option<T>` to `&[T]` (without copying)
-    #[inline]
-    #[unstable(feature = "as_slice", reason = "unsure of the utility here",
-               issue = "27776")]
-    #[rustc_deprecated(since = "1.4.0", reason = "niche API, unclear of usefulness")]
-    #[allow(deprecated)]
-    pub fn as_slice(&self) -> &[T] {
-        match *self {
-            Some(ref x) => slice::ref_slice(x),
-            None => {
-                let result: &[_] = &[];
-                result
-            }
-        }
-    }
 }
 
 impl<'a, T: Clone> Option<&'a T> {
diff --git a/src/libcore/result.rs b/src/libcore/result.rs
index 37c40f96b0f..40285586118 100644
--- a/src/libcore/result.rs
+++ b/src/libcore/result.rs
@@ -240,7 +240,6 @@ use fmt;
 use iter::{Iterator, DoubleEndedIterator, FromIterator, ExactSizeIterator, IntoIterator};
 use ops::FnOnce;
 use option::Option::{self, None, Some};
-use slice;
 
 /// `Result` is a type that represents either success (`Ok`) or failure (`Err`).
 ///
@@ -406,58 +405,6 @@ impl<T, E> Result<T, E> {
         }
     }
 
-    /// Converts from `Result<T, E>` to `&[T]` (without copying)
-    #[inline]
-    #[unstable(feature = "as_slice", reason = "unsure of the utility here",
-               issue = "27776")]
-    #[rustc_deprecated(since = "1.4.0", reason = "niche API, unclear of usefulness")]
-    #[allow(deprecated)]
-    pub fn as_slice(&self) -> &[T] {
-        match *self {
-            Ok(ref x) => slice::ref_slice(x),
-            Err(_) => {
-                // work around lack of implicit coercion from fixed-size array to slice
-                let emp: &[_] = &[];
-                emp
-            }
-        }
-    }
-
-    /// Converts from `Result<T, E>` to `&mut [T]` (without copying)
-    ///
-    /// ```
-    /// #![feature(as_slice)]
-    /// # #![allow(deprecated)]
-    ///
-    /// let mut x: Result<&str, u32> = Ok("Gold");
-    /// {
-    ///     let v = x.as_mut_slice();
-    ///     assert!(v == ["Gold"]);
-    ///     v[0] = "Silver";
-    ///     assert!(v == ["Silver"]);
-    /// }
-    /// assert_eq!(x, Ok("Silver"));
-    ///
-    /// let mut x: Result<&str, u32> = Err(45);
-    /// assert!(x.as_mut_slice().is_empty());
-    /// ```
-    #[inline]
-    #[unstable(feature = "as_slice",
-               reason = "waiting for mut conventions",
-               issue = "27776")]
-    #[rustc_deprecated(since = "1.4.0", reason = "niche API, unclear of usefulness")]
-    #[allow(deprecated)]
-    pub fn as_mut_slice(&mut self) -> &mut [T] {
-        match *self {
-            Ok(ref mut x) => slice::mut_ref_slice(x),
-            Err(_) => {
-                // work around lack of implicit coercion from fixed-size array to slice
-                let emp: &mut [_] = &mut [];
-                emp
-            }
-        }
-    }
-
     /////////////////////////////////////////////////////////////////////////
     // Transforming contained values
     /////////////////////////////////////////////////////////////////////////
diff --git a/src/libcore/simd.rs b/src/libcore/simd.rs
deleted file mode 100644
index 697f96ddefb..00000000000
--- a/src/libcore/simd.rs
+++ /dev/null
@@ -1,143 +0,0 @@
-// Copyright 2013 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.
-
-//! SIMD vectors.
-//!
-//! These types can be used for accessing basic SIMD operations. Currently
-//! comparison operators are not implemented. To use SSE3+, you must enable
-//! the features, like `-C target-feature=sse3,sse4.1,sse4.2`, or a more
-//! specific `target-cpu`. No other SIMD intrinsics or high-level wrappers are
-//! provided beyond this module.
-//!
-//! # Stability Note
-//!
-//! These are all experimental. The interface may change entirely, without
-//! warning.
-
-#![unstable(feature = "core_simd",
-            reason = "needs an RFC to flesh out the design",
-            issue = "27731")]
-#![rustc_deprecated(since = "1.3.0",
-              reason = "use the external `simd` crate instead")]
-
-#![allow(non_camel_case_types)]
-#![allow(missing_docs)]
-#![allow(deprecated)]
-
-use ops::{Add, Sub, Mul, Div, Shl, Shr, BitAnd, BitOr, BitXor};
-
-// FIXME(stage0): the contents of macro can be inlined.
-// ABIs are verified as valid as soon as they are parsed, i.e. before
-// `cfg` stripping. The `platform-intrinsic` ABI is new, so stage0
-// doesn't know about it, but it still errors out when it hits it
-// (despite this being in a `cfg(not(stage0))` module).
-macro_rules! argh {
-    () => {
-        extern "platform-intrinsic" {
-            fn simd_add<T>(x: T, y: T) -> T;
-            fn simd_sub<T>(x: T, y: T) -> T;
-            fn simd_mul<T>(x: T, y: T) -> T;
-            fn simd_div<T>(x: T, y: T) -> T;
-            fn simd_shl<T>(x: T, y: T) -> T;
-            fn simd_shr<T>(x: T, y: T) -> T;
-            fn simd_and<T>(x: T, y: T) -> T;
-            fn simd_or<T>(x: T, y: T) -> T;
-            fn simd_xor<T>(x: T, y: T) -> T;
-        }
-    }
-}
-argh!();
-
-#[repr(simd)]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct i8x16(pub i8, pub i8, pub i8, pub i8,
-                 pub i8, pub i8, pub i8, pub i8,
-                 pub i8, pub i8, pub i8, pub i8,
-                 pub i8, pub i8, pub i8, pub i8);
-
-#[repr(simd)]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct i16x8(pub i16, pub i16, pub i16, pub i16,
-                 pub i16, pub i16, pub i16, pub i16);
-
-#[repr(simd)]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct i32x4(pub i32, pub i32, pub i32, pub i32);
-
-#[repr(simd)]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct i64x2(pub i64, pub i64);
-
-#[repr(simd)]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct u8x16(pub u8, pub u8, pub u8, pub u8,
-                 pub u8, pub u8, pub u8, pub u8,
-                 pub u8, pub u8, pub u8, pub u8,
-                 pub u8, pub u8, pub u8, pub u8);
-
-#[repr(simd)]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct u16x8(pub u16, pub u16, pub u16, pub u16,
-                 pub u16, pub u16, pub u16, pub u16);
-
-#[repr(simd)]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct u32x4(pub u32, pub u32, pub u32, pub u32);
-
-#[repr(simd)]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct u64x2(pub u64, pub u64);
-
-#[repr(simd)]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct f32x4(pub f32, pub f32, pub f32, pub f32);
-
-#[repr(simd)]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct f64x2(pub f64, pub f64);
-
-macro_rules! impl_traits {
-    ($($trayt: ident, $method: ident, $func: ident: $($ty: ty),*;)*) => {
-        $($(
-            impl $trayt<$ty> for $ty {
-                type Output = Self;
-                fn $method(self, other: Self) -> Self {
-                    unsafe {
-                        $func(self, other)
-                    }
-                }
-            }
-            )*)*
-    }
-}
-
-impl_traits! {
-    Add, add, simd_add: u8x16, u16x8, u32x4, u64x2, i8x16, i16x8, i32x4, i64x2, f32x4, f64x2;
-    Sub, sub, simd_sub: u8x16, u16x8, u32x4, u64x2, i8x16, i16x8, i32x4, i64x2, f32x4, f64x2;
-    Mul, mul, simd_mul: u8x16, u16x8, u32x4, u64x2, i8x16, i16x8, i32x4, i64x2, f32x4, f64x2;
-
-    Div, div, simd_div: f32x4, f64x2;
-
-    Shl, shl, simd_shl: u8x16, u16x8, u32x4, u64x2, i8x16, i16x8, i32x4, i64x2;
-    Shr, shr, simd_shr: u8x16, u16x8, u32x4, u64x2, i8x16, i16x8, i32x4, i64x2;
-    BitAnd, bitand, simd_and: u8x16, u16x8, u32x4, u64x2, i8x16, i16x8, i32x4, i64x2;
-    BitOr, bitor, simd_or: u8x16, u16x8, u32x4, u64x2, i8x16, i16x8, i32x4, i64x2;
-    BitXor, bitxor, simd_xor: u8x16, u16x8, u32x4, u64x2, i8x16, i16x8, i32x4, i64x2;
-}
diff --git a/src/libcore/simd_old.rs b/src/libcore/simd_old.rs
deleted file mode 100644
index 7ecd08bea35..00000000000
--- a/src/libcore/simd_old.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright 2013 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.
-
-//! SIMD vectors.
-//!
-//! These types can be used for accessing basic SIMD operations. Each of them
-//! implements the standard arithmetic operator traits (Add, Sub, Mul, Div,
-//! Rem, Shl, Shr) through compiler magic, rather than explicitly. Currently
-//! comparison operators are not implemented. To use SSE3+, you must enable
-//! the features, like `-C target-feature=sse3,sse4.1,sse4.2`, or a more
-//! specific `target-cpu`. No other SIMD intrinsics or high-level wrappers are
-//! provided beyond this module.
-//!
-//! ```rust
-//! # #![feature(core_simd)]
-//! fn main() {
-//!     use std::simd::f32x4;
-//!     let a = f32x4(40.0, 41.0, 42.0, 43.0);
-//!     let b = f32x4(1.0, 1.1, 3.4, 9.8);
-//!     println!("{:?}", a + b);
-//! }
-//! ```
-//!
-//! # Stability Note
-//!
-//! These are all experimental. The interface may change entirely, without
-//! warning.
-
-#![unstable(feature = "core_simd",
-            reason = "needs an RFC to flesh out the design")]
-
-#![allow(non_camel_case_types)]
-#![allow(missing_docs)]
-
-#[simd]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct i8x16(pub i8, pub i8, pub i8, pub i8,
-                 pub i8, pub i8, pub i8, pub i8,
-                 pub i8, pub i8, pub i8, pub i8,
-                 pub i8, pub i8, pub i8, pub i8);
-
-#[simd]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct i16x8(pub i16, pub i16, pub i16, pub i16,
-                 pub i16, pub i16, pub i16, pub i16);
-
-#[simd]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct i32x4(pub i32, pub i32, pub i32, pub i32);
-
-#[simd]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct i64x2(pub i64, pub i64);
-
-#[simd]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct u8x16(pub u8, pub u8, pub u8, pub u8,
-                 pub u8, pub u8, pub u8, pub u8,
-                 pub u8, pub u8, pub u8, pub u8,
-                 pub u8, pub u8, pub u8, pub u8);
-
-#[simd]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct u16x8(pub u16, pub u16, pub u16, pub u16,
-                 pub u16, pub u16, pub u16, pub u16);
-
-#[simd]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct u32x4(pub u32, pub u32, pub u32, pub u32);
-
-#[simd]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct u64x2(pub u64, pub u64);
-
-#[simd]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct f32x4(pub f32, pub f32, pub f32, pub f32);
-
-#[simd]
-#[derive(Copy, Clone, Debug)]
-#[repr(C)]
-pub struct f64x2(pub f64, pub f64);
diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index 70175086147..b17fac4d771 100644
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -1380,24 +1380,6 @@ impl<'a, T> ExactSizeIterator for ChunksMut<'a, T> {}
 // Free functions
 //
 
-/// Converts a reference to A into a slice of length 1 (without copying).
-#[unstable(feature = "ref_slice", issue = "27774")]
-#[rustc_deprecated(since = "1.5.0", reason = "unclear whether belongs in libstd")]
-pub fn ref_slice<A>(s: &A) -> &[A] {
-    unsafe {
-        from_raw_parts(s, 1)
-    }
-}
-
-/// Converts a reference to A into a slice of length 1 (without copying).
-#[unstable(feature = "ref_slice", issue = "27774")]
-#[rustc_deprecated(since = "1.5.0", reason = "unclear whether belongs in libstd")]
-pub fn mut_ref_slice<A>(s: &mut A) -> &mut [A] {
-    unsafe {
-        from_raw_parts_mut(s, 1)
-    }
-}
-
 /// Forms a slice from a pointer and a length.
 ///
 /// The `len` argument is the number of **elements**, not the number of bytes.