diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs
index 0a486ef0305..1e5e3ebdb34 100644
--- a/src/compiletest/compiletest.rs
+++ b/src/compiletest/compiletest.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 #![crate_type = "bin"]
-#![feature(phase)]
+#![feature(phase, slicing_syntax)]
 
 #![deny(warnings)]
 
diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs
index b48ccfc4374..2182bc89516 100644
--- a/src/compiletest/runtest.rs
+++ b/src/compiletest/runtest.rs
@@ -874,7 +874,7 @@ fn check_error_patterns(props: &TestProps,
     if done { return; }
 
     let missing_patterns =
-        props.error_patterns.slice(next_err_idx, props.error_patterns.len());
+        props.error_patterns[next_err_idx..];
     if missing_patterns.len() == 1u {
         fatal_proc_rec(format!("error pattern '{}' not found!",
                               missing_patterns[0]).as_slice(),
diff --git a/src/doc/reference.md b/src/doc/reference.md
index 3da3d4c5807..c3b61f6435c 100644
--- a/src/doc/reference.md
+++ b/src/doc/reference.md
@@ -3828,7 +3828,7 @@ type signature of `print`, and the cast expression in `main`.
 Within the body of an item that has type parameter declarations, the names of
 its type parameters are types:
 
-```
+```ignore
 fn map<A: Clone, B: Clone>(f: |A| -> B, xs: &[A]) -> Vec<B> {
     if xs.len() == 0 {
        return vec![];
diff --git a/src/libcollections/bitv.rs b/src/libcollections/bitv.rs
index 60c9dfcff18..9f26c098013 100644
--- a/src/libcollections/bitv.rs
+++ b/src/libcollections/bitv.rs
@@ -194,7 +194,7 @@ impl Bitv {
         if start > self.storage.len() {
             start = self.storage.len();
         }
-        let mut iter = self.storage.slice_from(start).iter();
+        let mut iter = self.storage[start..].iter();
         MaskWords {
           next_word: iter.next(),
           iter: iter,
diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs
index 8b9a0ec796e..4d0aaf83907 100644
--- a/src/libcollections/lib.rs
+++ b/src/libcollections/lib.rs
@@ -19,8 +19,9 @@
        html_root_url = "http://doc.rust-lang.org/master/",
        html_playground_url = "http://play.rust-lang.org/")]
 
+#![allow(unknown_features)]
 #![feature(macro_rules, managed_boxes, default_type_params, phase, globs)]
-#![feature(unsafe_destructor, import_shadowing)]
+#![feature(unsafe_destructor, import_shadowing, slicing_syntax)]
 #![no_std]
 
 #[phase(plugin, link)] extern crate core;
diff --git a/src/libcollections/ringbuf.rs b/src/libcollections/ringbuf.rs
index 02c8af2c470..0e1c39535be 100644
--- a/src/libcollections/ringbuf.rs
+++ b/src/libcollections/ringbuf.rs
@@ -271,7 +271,7 @@ impl<T> RingBuf<T> {
     ///     *num = *num - 2;
     /// }
     /// let b: &[_] = &[&mut 3, &mut 1, &mut 2];
-    /// assert_eq!(buf.iter_mut().collect::<Vec<&mut int>>().as_slice(), b);
+    /// assert_eq!(buf.iter_mut().collect::<Vec<&mut int>>()[], b);
     /// ```
     pub fn iter_mut<'a>(&'a mut self) -> MutItems<'a, T> {
         let start_index = raw_index(self.lo, self.elts.len(), 0);
@@ -291,7 +291,7 @@ impl<T> RingBuf<T> {
         } else {
             // Items to iterate goes from start_index to end_index:
             let (empty, elts) = self.elts.split_at_mut(0);
-            let remaining1 = elts.slice_mut(start_index, end_index);
+            let remaining1 = elts[mut start_index..end_index];
             MutItems { remaining1: remaining1,
                                  remaining2: empty,
                                  nelts: self.nelts }
diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs
index 45489bbf84e..253375aabe8 100644
--- a/src/libcollections/slice.rs
+++ b/src/libcollections/slice.rs
@@ -44,15 +44,20 @@
 //!
 //! A number of traits add methods that allow you to accomplish tasks with slices.
 //! These traits include `ImmutableSlice`, which is defined for `&[T]` types,
-//! and `MutableSlice`, defined for `&mut [T]` types.
+//! `MutableSlice`, defined for `&mut [T]` types, and `Slice` and `SliceMut`
+//! which are defined for `[T]`.
 //!
-//! An example is the method `.slice(a, b)` that returns an immutable "view" into
-//! a `Vec` or another slice from the index interval `[a, b)`:
+//! An example is the `slice` method which enables slicing syntax `[a..b]` that
+//! returns an immutable "view" into a `Vec` or another slice from the index
+//! interval `[a, b)`:
 //!
 //! ```rust
-//! let numbers = [0i, 1i, 2i];
-//! let last_numbers = numbers.slice(1, 3);
-//! // last_numbers is now &[1i, 2i]
+//! #![feature(slicing_syntax)]
+//! fn main() {
+//!     let numbers = [0i, 1i, 2i];
+//!     let last_numbers = numbers[1..3];
+//!     // last_numbers is now &[1i, 2i]
+//! }
 //! ```
 //!
 //! ## Implementations of other traits
@@ -610,7 +615,7 @@ impl<'a,T> MutableSliceAllocating<'a, T> for &'a mut [T] {
 
     #[inline]
     fn move_from(self, mut src: Vec<T>, start: uint, end: uint) -> uint {
-        for (a, b) in self.iter_mut().zip(src.slice_mut(start, end).iter_mut()) {
+        for (a, b) in self.iter_mut().zip(src[mut start..end].iter_mut()) {
             mem::swap(a, b);
         }
         cmp::min(self.len(), end-start)
@@ -702,7 +707,7 @@ impl<'a, T: Ord> MutableOrdSlice<T> for &'a mut [T] {
         self.swap(j, i-1);
 
         // Step 4: Reverse the (previously) weakly decreasing part
-        self.slice_from_mut(i).reverse();
+        self[mut i..].reverse();
 
         true
     }
@@ -723,7 +728,7 @@ impl<'a, T: Ord> MutableOrdSlice<T> for &'a mut [T] {
         }
 
         // Step 2: Reverse the weakly increasing part
-        self.slice_from_mut(i).reverse();
+        self[mut i..].reverse();
 
         // Step 3: Find the rightmost element equal to or bigger than the pivot (i-1)
         let mut j = self.len() - 1;
@@ -990,7 +995,7 @@ mod tests {
     fn test_slice() {
         // Test fixed length vector.
         let vec_fixed = [1i, 2, 3, 4];
-        let v_a = vec_fixed.slice(1u, vec_fixed.len()).to_vec();
+        let v_a = vec_fixed[1u..vec_fixed.len()].to_vec();
         assert_eq!(v_a.len(), 3u);
         let v_a = v_a.as_slice();
         assert_eq!(v_a[0], 2);
@@ -998,8 +1003,8 @@ mod tests {
         assert_eq!(v_a[2], 4);
 
         // Test on stack.
-        let vec_stack = &[1i, 2, 3];
-        let v_b = vec_stack.slice(1u, 3u).to_vec();
+        let vec_stack: &[_] = &[1i, 2, 3];
+        let v_b = vec_stack[1u..3u].to_vec();
         assert_eq!(v_b.len(), 2u);
         let v_b = v_b.as_slice();
         assert_eq!(v_b[0], 2);
@@ -1007,7 +1012,7 @@ mod tests {
 
         // Test `Box<[T]>`
         let vec_unique = vec![1i, 2, 3, 4, 5, 6];
-        let v_d = vec_unique.slice(1u, 6u).to_vec();
+        let v_d = vec_unique[1u..6u].to_vec();
         assert_eq!(v_d.len(), 5u);
         let v_d = v_d.as_slice();
         assert_eq!(v_d[0], 2);
@@ -1020,21 +1025,21 @@ mod tests {
     #[test]
     fn test_slice_from() {
         let vec: &[int] = &[1, 2, 3, 4];
-        assert_eq!(vec.slice_from(0), vec);
+        assert_eq!(vec[0..], vec);
         let b: &[int] = &[3, 4];
-        assert_eq!(vec.slice_from(2), b);
+        assert_eq!(vec[2..], b);
         let b: &[int] = &[];
-        assert_eq!(vec.slice_from(4), b);
+        assert_eq!(vec[4..], b);
     }
 
     #[test]
     fn test_slice_to() {
         let vec: &[int] = &[1, 2, 3, 4];
-        assert_eq!(vec.slice_to(4), vec);
+        assert_eq!(vec[..4], vec);
         let b: &[int] = &[1, 2];
-        assert_eq!(vec.slice_to(2), b);
+        assert_eq!(vec[..2], b);
         let b: &[int] = &[];
-        assert_eq!(vec.slice_to(0), b);
+        assert_eq!(vec[..0], b);
     }
 
 
@@ -1975,7 +1980,7 @@ mod tests {
         assert!(a == [7i,2,3,4]);
         let mut a = [1i,2,3,4,5];
         let b = vec![5i,6,7,8,9,0];
-        assert_eq!(a.slice_mut(2,4).move_from(b,1,6), 2);
+        assert_eq!(a[mut 2..4].move_from(b,1,6), 2);
         assert!(a == [1i,2,6,7,5]);
     }
 
@@ -1995,7 +2000,7 @@ mod tests {
     #[test]
     fn test_reverse_part() {
         let mut values = [1i,2,3,4,5];
-        values.slice_mut(1, 4).reverse();
+        values[mut 1..4].reverse();
         assert!(values == [1,4,3,2,5]);
     }
 
@@ -2042,9 +2047,9 @@ mod tests {
     fn test_bytes_set_memory() {
         use slice::bytes::MutableByteVector;
         let mut values = [1u8,2,3,4,5];
-        values.slice_mut(0,5).set_memory(0xAB);
+        values[mut 0..5].set_memory(0xAB);
         assert!(values == [0xAB, 0xAB, 0xAB, 0xAB, 0xAB]);
-        values.slice_mut(2,4).set_memory(0xFF);
+        values[mut 2..4].set_memory(0xFF);
         assert!(values == [0xAB, 0xAB, 0xFF, 0xFF, 0xAB]);
     }
 
@@ -2070,12 +2075,18 @@ mod tests {
         let mut values = [1u8,2,3,4,5];
         {
             let (left, right) = values.split_at_mut(2);
-            assert!(left.slice(0, left.len()) == [1, 2]);
+            {
+                let left: &[_] = left;
+                assert!(left[0..left.len()] == [1, 2]);
+            }
             for p in left.iter_mut() {
                 *p += 1;
             }
 
-            assert!(right.slice(0, right.len()) == [3, 4, 5]);
+            {
+                let right: &[_] = right;
+                assert!(right[0..right.len()] == [3, 4, 5]);
+            }
             for p in right.iter_mut() {
                 *p += 2;
             }
@@ -2099,7 +2110,7 @@ mod tests {
         }
         assert_eq!(cnt, 3);
 
-        for f in v.slice(1, 3).iter() {
+        for f in v[1..3].iter() {
             assert!(*f == Foo);
             cnt += 1;
         }
diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
index d198e948ac8..11bda25fee5 100644
--- a/src/libcollections/str.rs
+++ b/src/libcollections/str.rs
@@ -1680,7 +1680,7 @@ mod tests {
         let mut bytes = [0u8, ..4];
         for c in range(0u32, 0x110000).filter_map(|c| ::core::char::from_u32(c)) {
             let len = c.encode_utf8(bytes).unwrap_or(0);
-            let s = ::core::str::from_utf8(bytes.slice_to(len)).unwrap();
+            let s = ::core::str::from_utf8(bytes[..len]).unwrap();
             if Some(c) != s.chars().next() {
                 fail!("character {:x}={} does not decode correctly", c as u32, c);
             }
@@ -1692,7 +1692,7 @@ mod tests {
         let mut bytes = [0u8, ..4];
         for c in range(0u32, 0x110000).filter_map(|c| ::core::char::from_u32(c)) {
             let len = c.encode_utf8(bytes).unwrap_or(0);
-            let s = ::core::str::from_utf8(bytes.slice_to(len)).unwrap();
+            let s = ::core::str::from_utf8(bytes[..len]).unwrap();
             if Some(c) != s.chars().rev().next() {
                 fail!("character {:x}={} does not decode correctly", c as u32, c);
             }
diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs
index d6adbd30264..1032a504330 100644
--- a/src/libcollections/string.rs
+++ b/src/libcollections/string.rs
@@ -160,7 +160,7 @@ impl String {
 
         if i > 0 {
             unsafe {
-                res.as_mut_vec().push_all(v.slice_to(i))
+                res.as_mut_vec().push_all(v[..i])
             };
         }
 
@@ -177,7 +177,7 @@ impl String {
             macro_rules! error(() => ({
                 unsafe {
                     if subseqidx != i_ {
-                        res.as_mut_vec().push_all(v.slice(subseqidx, i_));
+                        res.as_mut_vec().push_all(v[subseqidx..i_]);
                     }
                     subseqidx = i;
                     res.as_mut_vec().push_all(REPLACEMENT);
@@ -246,7 +246,7 @@ impl String {
         }
         if subseqidx < total {
             unsafe {
-                res.as_mut_vec().push_all(v.slice(subseqidx, total))
+                res.as_mut_vec().push_all(v[subseqidx..total])
             };
         }
         Owned(res.into_string())
@@ -927,6 +927,7 @@ impl<S: Str> Add<S, String> for String {
     }
 }
 
+#[cfg(stage0)]
 impl ops::Slice<uint, str> for String {
     #[inline]
     fn as_slice_<'a>(&'a self) -> &'a str {
@@ -949,6 +950,34 @@ impl ops::Slice<uint, str> for String {
     }
 }
 
+#[cfg(not(stage0))]
+#[inline]
+fn str_to_slice<'a, U: Str>(this: &'a U) -> &'a str {
+    this.as_slice()
+}
+#[cfg(not(stage0))]
+impl ops::Slice<uint, str> for String {
+    #[inline]
+    fn as_slice<'a>(&'a self) -> &'a str {
+        str_to_slice(self)
+    }
+
+    #[inline]
+    fn slice_from<'a>(&'a self, from: &uint) -> &'a str {
+        self[][*from..]
+    }
+
+    #[inline]
+    fn slice_to<'a>(&'a self, to: &uint) -> &'a str {
+        self[][..*to]
+    }
+
+    #[inline]
+    fn slice<'a>(&'a self, from: &uint, to: &uint) -> &'a str {
+        self[][*from..*to]
+    }
+}
+
 /// Unsafe operations
 #[unstable = "waiting on raw module conventions"]
 pub mod raw {
diff --git a/src/libcollections/trie.rs b/src/libcollections/trie.rs
index e9981790f7d..9bfc8e08d8d 100644
--- a/src/libcollections/trie.rs
+++ b/src/libcollections/trie.rs
@@ -24,6 +24,7 @@ use core::fmt;
 use core::fmt::Show;
 use core::mem::zeroed;
 use core::mem;
+use core::ops::{Slice,SliceMut};
 use core::uint;
 use core::iter;
 use std::hash::{Writer, Hash};
@@ -378,7 +379,7 @@ macro_rules! bound {
                         }
                     };
                     // push to the stack.
-                    it.stack[it.length] = children.$slice_from(slice_idx).$iter();
+                    it.stack[it.length] = children.$slice_from(&slice_idx).$iter();
                     it.length += 1;
                     if ret { return it }
                 })
@@ -388,6 +389,15 @@ macro_rules! bound {
 
 impl<T> TrieMap<T> {
     // If `upper` is true then returns upper_bound else returns lower_bound.
+    #[cfg(stage0)]
+    #[inline]
+    fn bound<'a>(&'a self, key: uint, upper: bool) -> Entries<'a, T> {
+        bound!(Entries, self = self,
+               key = key, is_upper = upper,
+               slice_from = slice_from_, iter = iter,
+               mutability = )
+    }
+    #[cfg(not(stage0))]
     #[inline]
     fn bound<'a>(&'a self, key: uint, upper: bool) -> Entries<'a, T> {
         bound!(Entries, self = self,
@@ -430,6 +440,15 @@ impl<T> TrieMap<T> {
         self.bound(key, true)
     }
     // If `upper` is true then returns upper_bound else returns lower_bound.
+    #[cfg(stage0)]
+    #[inline]
+    fn bound_mut<'a>(&'a mut self, key: uint, upper: bool) -> MutEntries<'a, T> {
+        bound!(MutEntries, self = self,
+               key = key, is_upper = upper,
+               slice_from = slice_from_mut_, iter = iter_mut,
+               mutability = mut)
+    }
+    #[cfg(not(stage0))]
     #[inline]
     fn bound_mut<'a>(&'a mut self, key: uint, upper: bool) -> MutEntries<'a, T> {
         bound!(MutEntries, self = self,
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index 280fbdeffa2..9dc122cfc7d 100644
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -24,6 +24,7 @@ use core::num;
 use core::ops;
 use core::ptr;
 use core::raw::Slice as RawSlice;
+use core::slice::Slice as SliceSlice;
 use core::uint;
 
 use {Mutable, MutableSeq};
@@ -438,7 +439,7 @@ impl<T:Clone> Clone for Vec<T> {
 
         // self.len <= other.len due to the truncate above, so the
         // slice here is always in-bounds.
-        let slice = other.slice_from(self.len());
+        let slice = other[self.len()..];
         self.push_all(slice);
     }
 }
@@ -460,6 +461,37 @@ impl<T> Index<uint,T> for Vec<T> {
     }
 }*/
 
+// Annoying helper function because there are two Slice::as_slice functions in
+// scope.
+#[cfg(not(stage0))]
+#[inline]
+fn slice_to_slice<'a, T, U: Slice<T>>(this: &'a U) -> &'a [T] {
+    this.as_slice()
+}
+
+
+#[cfg(not(stage0))]
+impl<T> ops::Slice<uint, [T]> for Vec<T> {
+    #[inline]
+    fn as_slice<'a>(&'a self) -> &'a [T] {
+        slice_to_slice(self)
+    }
+
+    #[inline]
+    fn slice_from<'a>(&'a self, start: &uint) -> &'a [T] {
+        slice_to_slice(self).slice_from(start)
+    }
+
+    #[inline]
+    fn slice_to<'a>(&'a self, end: &uint) -> &'a [T] {
+        slice_to_slice(self).slice_to(end)
+    }
+    #[inline]
+    fn slice<'a>(&'a self, start: &uint, end: &uint) -> &'a [T] {
+        slice_to_slice(self).slice(start, end)
+    }
+}
+#[cfg(stage0)]
 impl<T> ops::Slice<uint, [T]> for Vec<T> {
     #[inline]
     fn as_slice_<'a>(&'a self) -> &'a [T] {
@@ -481,6 +513,28 @@ impl<T> ops::Slice<uint, [T]> for Vec<T> {
     }
 }
 
+#[cfg(not(stage0))]
+impl<T> ops::SliceMut<uint, [T]> for Vec<T> {
+    #[inline]
+    fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] {
+        self.as_mut_slice()
+    }
+
+    #[inline]
+    fn slice_from_mut<'a>(&'a mut self, start: &uint) -> &'a mut [T] {
+        self.as_mut_slice().slice_from_mut(start)
+    }
+
+    #[inline]
+    fn slice_to_mut<'a>(&'a mut self, end: &uint) -> &'a mut [T] {
+        self.as_mut_slice().slice_to_mut(end)
+    }
+    #[inline]
+    fn slice_mut<'a>(&'a mut self, start: &uint, end: &uint) -> &'a mut [T] {
+        self.as_mut_slice().slice_mut(start, end)
+    }
+}
+#[cfg(stage0)]
 impl<T> ops::SliceMut<uint, [T]> for Vec<T> {
     #[inline]
     fn as_mut_slice_<'a>(&'a mut self) -> &'a mut [T] {
@@ -928,11 +982,11 @@ impl<T> Vec<T> {
     ///
     /// ```
     /// let vec = vec![1i, 2, 3, 4];
-    /// assert!(vec.slice(0, 2) == [1, 2]);
+    /// assert!(vec[0..2] == [1, 2]);
     /// ```
     #[inline]
     pub fn slice<'a>(&'a self, start: uint, end: uint) -> &'a [T] {
-        self.as_slice().slice(start, end)
+        self[start..end]
     }
 
     /// Returns a slice containing all but the first element of the vector.
@@ -949,7 +1003,7 @@ impl<T> Vec<T> {
     /// ```
     #[inline]
     pub fn tail<'a>(&'a self) -> &'a [T] {
-        self.as_slice().tail()
+        self[].tail()
     }
 
     /// Returns all but the first `n' elements of a vector.
@@ -968,7 +1022,7 @@ impl<T> Vec<T> {
     #[inline]
     #[deprecated = "use slice_from"]
     pub fn tailn<'a>(&'a self, n: uint) -> &'a [T] {
-        self.as_slice().slice_from(n)
+        self[n..]
     }
 
     /// Returns a reference to the last element of a vector, or `None` if it is
@@ -982,7 +1036,7 @@ impl<T> Vec<T> {
     /// ```
     #[inline]
     pub fn last<'a>(&'a self) -> Option<&'a T> {
-        self.as_slice().last()
+        self[].last()
     }
 
     /// Deprecated: use `last_mut`.
@@ -1176,10 +1230,10 @@ impl<T> Vec<T> {
     }
 
     /// Deprecated: use `slice_mut`.
-    #[deprecated = "use slice_mut"]
+    #[deprecated = "use slice_from"]
     pub fn mut_slice<'a>(&'a mut self, start: uint, end: uint)
                          -> &'a mut [T] {
-        self.slice_mut(start, end)
+        self[mut start..end]
     }
 
     /// Returns a mutable slice of `self` between `start` and `end`.
@@ -1193,18 +1247,18 @@ impl<T> Vec<T> {
     ///
     /// ```
     /// let mut vec = vec![1i, 2, 3, 4];
-    /// assert!(vec.slice_mut(0, 2) == [1, 2]);
+    /// assert!(vec[mut 0..2] == [1, 2]);
     /// ```
     #[inline]
     pub fn slice_mut<'a>(&'a mut self, start: uint, end: uint)
                          -> &'a mut [T] {
-        self.as_mut_slice().slice_mut(start, end)
+        self[mut start..end]
     }
 
     /// Deprecated: use "slice_from_mut".
     #[deprecated = "use slice_from_mut"]
     pub fn mut_slice_from<'a>(&'a mut self, start: uint) -> &'a mut [T] {
-        self.slice_from_mut(start)
+        self[mut start..]
     }
 
     /// Returns a mutable slice of `self` from `start` to the end of the `Vec`.
@@ -1217,17 +1271,17 @@ impl<T> Vec<T> {
     ///
     /// ```
     /// let mut vec = vec![1i, 2, 3, 4];
-    /// assert!(vec.slice_from_mut(2) == [3, 4]);
+    /// assert!(vec[mut 2..] == [3, 4]);
     /// ```
     #[inline]
     pub fn slice_from_mut<'a>(&'a mut self, start: uint) -> &'a mut [T] {
-        self.as_mut_slice().slice_from_mut(start)
+        self[mut start..]
     }
 
     /// Deprecated: use `slice_to_mut`.
     #[deprecated = "use slice_to_mut"]
     pub fn mut_slice_to<'a>(&'a mut self, end: uint) -> &'a mut [T] {
-        self.slice_to_mut(end)
+        self[mut ..end]
     }
 
     /// Returns a mutable slice of `self` from the start of the `Vec` to `end`.
@@ -1240,11 +1294,11 @@ impl<T> Vec<T> {
     ///
     /// ```
     /// let mut vec = vec![1i, 2, 3, 4];
-    /// assert!(vec.slice_to_mut(2) == [1, 2]);
+    /// assert!(vec[mut ..2] == [1, 2]);
     /// ```
     #[inline]
     pub fn slice_to_mut<'a>(&'a mut self, end: uint) -> &'a mut [T] {
-        self.as_mut_slice().slice_to_mut(end)
+        self[mut ..end]
     }
 
     /// Deprecated: use `split_at_mut`.
@@ -1289,7 +1343,7 @@ impl<T> Vec<T> {
     /// ```
     #[inline]
     pub fn split_at_mut<'a>(&'a mut self, mid: uint) -> (&'a mut [T], &'a mut [T]) {
-        self.as_mut_slice().split_at_mut(mid)
+        self[mut].split_at_mut(mid)
     }
 
     /// Reverses the order of elements in a vector, in place.
@@ -1303,7 +1357,7 @@ impl<T> Vec<T> {
     /// ```
     #[inline]
     pub fn reverse(&mut self) {
-        self.as_mut_slice().reverse()
+        self[mut].reverse()
     }
 
     /// Returns a slice of `self` from `start` to the end of the vec.
@@ -1316,11 +1370,11 @@ impl<T> Vec<T> {
     ///
     /// ```
     /// let vec = vec![1i, 2, 3];
-    /// assert!(vec.slice_from(1) == [2, 3]);
+    /// assert!(vec[1..] == [2, 3]);
     /// ```
     #[inline]
     pub fn slice_from<'a>(&'a self, start: uint) -> &'a [T] {
-        self.as_slice().slice_from(start)
+        self[start..]
     }
 
     /// Returns a slice of self from the start of the vec to `end`.
@@ -1333,11 +1387,11 @@ impl<T> Vec<T> {
     ///
     /// ```
     /// let vec = vec![1i, 2, 3, 4];
-    /// assert!(vec.slice_to(2) == [1, 2]);
+    /// assert!(vec[..2] == [1, 2]);
     /// ```
     #[inline]
     pub fn slice_to<'a>(&'a self, end: uint) -> &'a [T] {
-        self.as_slice().slice_to(end)
+        self[..end]
     }
 
     /// Returns a slice containing all but the last element of the vector.
@@ -1354,7 +1408,7 @@ impl<T> Vec<T> {
     /// ```
     #[inline]
     pub fn init<'a>(&'a self) -> &'a [T] {
-        self.slice(0, self.len() - 1)
+        self[0..self.len() - 1]
     }
 
 
@@ -2212,12 +2266,18 @@ mod tests {
         let mut values = Vec::from_slice([1u8,2,3,4,5]);
         {
             let (left, right) = values.split_at_mut(2);
-            assert!(left.slice(0, left.len()) == [1, 2]);
+            {
+                let left: &[_] = left;
+                assert!(left[0..left.len()] == [1, 2]);
+            }
             for p in left.iter_mut() {
                 *p += 1;
             }
 
-            assert!(right.slice(0, right.len()) == [3, 4, 5]);
+            {
+                let right: &[_] = right;
+                assert!(right[0..right.len()] == [3, 4, 5]);
+            }
             for p in right.iter_mut() {
                 *p += 2;
             }
diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs
index 92ef0c281f2..343ab7cfd28 100644
--- a/src/libcore/fmt/float.rs
+++ b/src/libcore/fmt/float.rs
@@ -17,7 +17,7 @@ use iter::{range, DoubleEndedIterator};
 use num::{Float, FPNaN, FPInfinite, ToPrimitive, Primitive};
 use num::{Zero, One, cast};
 use result::Ok;
-use slice::{ImmutableSlice, MutableSlice};
+use slice::MutableSlice;
 use slice;
 use str::StrSlice;
 
@@ -173,7 +173,7 @@ pub fn float_to_str_bytes_common<T: Primitive + Float, U>(
         _ => ()
     }
 
-    buf.slice_to_mut(end).reverse();
+    buf[mut ..end].reverse();
 
     // Remember start of the fractional digits.
     // Points one beyond end of buf if none get generated,
@@ -310,7 +310,7 @@ pub fn float_to_str_bytes_common<T: Primitive + Float, U>(
 
             impl<'a> fmt::FormatWriter for Filler<'a> {
                 fn write(&mut self, bytes: &[u8]) -> fmt::Result {
-                    slice::bytes::copy_memory(self.buf.slice_from_mut(*self.end),
+                    slice::bytes::copy_memory(self.buf[mut *self.end..],
                                               bytes);
                     *self.end += bytes.len();
                     Ok(())
@@ -328,5 +328,5 @@ pub fn float_to_str_bytes_common<T: Primitive + Float, U>(
         }
     }
 
-    f(buf.slice_to(end))
+    f(buf[..end])
 }
diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 7bab59960b0..28ee522346f 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -423,7 +423,7 @@ impl<'a> Formatter<'a> {
             for c in sign.into_iter() {
                 let mut b = [0, ..4];
                 let n = c.encode_utf8(b).unwrap_or(0);
-                try!(f.buf.write(b.slice_to(n)));
+                try!(f.buf.write(b[..n]));
             }
             if prefixed { f.buf.write(prefix.as_bytes()) }
             else { Ok(()) }
@@ -530,13 +530,13 @@ impl<'a> Formatter<'a> {
         let len = self.fill.encode_utf8(fill).unwrap_or(0);
 
         for _ in range(0, pre_pad) {
-            try!(self.buf.write(fill.slice_to(len)));
+            try!(self.buf.write(fill[..len]));
         }
 
         try!(f(self));
 
         for _ in range(0, post_pad) {
-            try!(self.buf.write(fill.slice_to(len)));
+            try!(self.buf.write(fill[..len]));
         }
 
         Ok(())
@@ -611,7 +611,7 @@ impl Char for char {
 
         let mut utf8 = [0u8, ..4];
         let amt = self.encode_utf8(utf8).unwrap_or(0);
-        let s: &str = unsafe { mem::transmute(utf8.slice_to(amt)) };
+        let s: &str = unsafe { mem::transmute(utf8[..amt]) };
         secret_string(&s, f)
     }
 }
diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs
index afcd0d1d645..e57c4999483 100644
--- a/src/libcore/fmt/num.rs
+++ b/src/libcore/fmt/num.rs
@@ -18,7 +18,7 @@ use collections::Collection;
 use fmt;
 use iter::DoubleEndedIterator;
 use num::{Int, cast, zero};
-use slice::{ImmutableSlice, MutableSlice};
+use slice::{MutableSlice};
 
 /// A type that represents a specific radix
 #[doc(hidden)]
@@ -60,7 +60,7 @@ trait GenericRadix {
                 if x == zero() { break; }                 // No more digits left to accumulate.
             }
         }
-        f.pad_integral(is_positive, self.prefix(), buf.slice_from(curr))
+        f.pad_integral(is_positive, self.prefix(), buf[curr..])
     }
 }
 
diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs
index 7e2ea492d4c..4890dc2bb73 100644
--- a/src/libcore/lib.rs
+++ b/src/libcore/lib.rs
@@ -57,8 +57,9 @@
        html_playground_url = "http://play.rust-lang.org/")]
 
 #![no_std]
+#![allow(unknown_features)]
 #![feature(globs, intrinsics, lang_items, macro_rules, managed_boxes, phase)]
-#![feature(simd, unsafe_destructor)]
+#![feature(simd, unsafe_destructor, slicing_syntax)]
 #![deny(missing_doc)]
 
 mod macros;
diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs
index ad0f128a02e..422c496995b 100644
--- a/src/libcore/ops.rs
+++ b/src/libcore/ops.rs
@@ -684,23 +684,23 @@ pub trait IndexMut<Index, Result> {
  * A trivial implementation of `Slice`. When `Foo[..Foo]` happens, it ends up
  * calling `slice_to`, and therefore, `main` prints `Slicing!`.
  *
- * ```
+ * ```ignore
  * struct Foo;
  *
  * impl ::core::ops::Slice<Foo, Foo> for Foo {
- *     fn as_slice_<'a>(&'a self) -> &'a Foo {
+ *     fn as_slice<'a>(&'a self) -> &'a Foo {
  *         println!("Slicing!");
  *         self
  *     }
- *     fn slice_from_<'a>(&'a self, from: &Foo) -> &'a Foo {
+ *     fn slice_from<'a>(&'a self, from: &Foo) -> &'a Foo {
  *         println!("Slicing!");
  *         self
  *     }
- *     fn slice_to_<'a>(&'a self, to: &Foo) -> &'a Foo {
+ *     fn slice_to<'a>(&'a self, to: &Foo) -> &'a Foo {
  *         println!("Slicing!");
  *         self
  *     }
- *     fn slice_<'a>(&'a self, from: &Foo, to: &Foo) -> &'a Foo {
+ *     fn slice<'a>(&'a self, from: &Foo, to: &Foo) -> &'a Foo {
  *         println!("Slicing!");
  *         self
  *     }
@@ -711,7 +711,22 @@ pub trait IndexMut<Index, Result> {
  * }
  * ```
  */
-// FIXME(#17273) remove the postscript _s
+#[cfg(not(stage0))]
+#[lang="slice"]
+pub trait Slice<Idx, Sized? Result> for Sized? {
+    /// The method for the slicing operation foo[]
+    fn as_slice<'a>(&'a self) -> &'a Result;
+    /// The method for the slicing operation foo[from..]
+    fn slice_from<'a>(&'a self, from: &Idx) -> &'a Result;
+    /// The method for the slicing operation foo[..to]
+    fn slice_to<'a>(&'a self, to: &Idx) -> &'a Result;
+    /// The method for the slicing operation foo[from..to]
+    fn slice<'a>(&'a self, from: &Idx, to: &Idx) -> &'a Result;
+}
+/**
+ *
+ */
+#[cfg(stage0)]
 #[lang="slice"]
 pub trait Slice<Idx, Sized? Result> for Sized? {
     /// The method for the slicing operation foo[]
@@ -734,34 +749,49 @@ pub trait Slice<Idx, Sized? Result> for Sized? {
  * A trivial implementation of `SliceMut`. When `Foo[Foo..]` happens, it ends up
  * calling `slice_from_mut`, and therefore, `main` prints `Slicing!`.
  *
- * ```
+ * ```ignore
  * struct Foo;
  *
  * impl ::core::ops::SliceMut<Foo, Foo> for Foo {
- *     fn as_mut_slice_<'a>(&'a mut self) -> &'a mut Foo {
+ *     fn as_mut_slice<'a>(&'a mut self) -> &'a mut Foo {
  *         println!("Slicing!");
  *         self
  *     }
- *     fn slice_from_mut_<'a>(&'a mut self, from: &Foo) -> &'a mut Foo {
+ *     fn slice_from_mut<'a>(&'a mut self, from: &Foo) -> &'a mut Foo {
  *         println!("Slicing!");
  *         self
  *     }
- *     fn slice_to_mut_<'a>(&'a mut self, to: &Foo) -> &'a mut Foo {
+ *     fn slice_to_mut<'a>(&'a mut self, to: &Foo) -> &'a mut Foo {
  *         println!("Slicing!");
  *         self
  *     }
- *     fn slice_mut_<'a>(&'a mut self, from: &Foo, to: &Foo) -> &'a mut Foo {
+ *     fn slice_mut<'a>(&'a mut self, from: &Foo, to: &Foo) -> &'a mut Foo {
  *         println!("Slicing!");
  *         self
  *     }
  * }
  *
- * fn main() {
+ * pub fn main() {
  *     Foo[mut Foo..];
  * }
  * ```
  */
-// FIXME(#17273) remove the postscript _s
+#[cfg(not(stage0))]
+#[lang="slice_mut"]
+pub trait SliceMut<Idx, Sized? Result> for Sized? {
+    /// The method for the slicing operation foo[]
+    fn as_mut_slice<'a>(&'a mut self) -> &'a mut Result;
+    /// The method for the slicing operation foo[from..]
+    fn slice_from_mut<'a>(&'a mut self, from: &Idx) -> &'a mut Result;
+    /// The method for the slicing operation foo[..to]
+    fn slice_to_mut<'a>(&'a mut self, to: &Idx) -> &'a mut Result;
+    /// The method for the slicing operation foo[from..to]
+    fn slice_mut<'a>(&'a mut self, from: &Idx, to: &Idx) -> &'a mut Result;
+}
+/**
+ *
+ */
+#[cfg(stage0)]
 #[lang="slice_mut"]
 pub trait SliceMut<Idx, Sized? Result> for Sized? {
     /// The method for the slicing operation foo[mut]
@@ -773,6 +803,7 @@ pub trait SliceMut<Idx, Sized? Result> for Sized? {
     /// The method for the slicing operation foo[mut from..to]
     fn slice_mut_<'a>(&'a mut self, from: &Idx, to: &Idx) -> &'a mut Result;
 }
+
 /**
  *
  * The `Deref` trait is used to specify the functionality of dereferencing
diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index 1a00107a216..a8becb315b2 100644
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -61,31 +61,6 @@ use raw::Slice as RawSlice;
 /// Extension methods for immutable slices.
 #[unstable = "may merge with other traits; region parameter may disappear"]
 pub trait ImmutableSlice<'a, T> {
-    /// Returns a subslice spanning the interval [`start`, `end`).
-    ///
-    /// Fails when the end of the new slice lies beyond the end of the
-    /// original slice (i.e. when `end > self.len()`) or when `start > end`.
-    ///
-    /// Slicing with `start` equal to `end` yields an empty slice.
-    #[unstable = "waiting on final error conventions"]
-    fn slice(&self, start: uint, end: uint) -> &'a [T];
-
-    /// Returns a subslice from `start` to the end of the slice.
-    ///
-    /// Fails when `start` is strictly greater than the length of the original slice.
-    ///
-    /// Slicing from `self.len()` yields an empty slice.
-    #[unstable = "waiting on final error conventions"]
-    fn slice_from(&self, start: uint) -> &'a [T];
-
-    /// Returns a subslice from the start of the slice to `end`.
-    ///
-    /// Fails when `end` is strictly greater than the length of the original slice.
-    ///
-    /// Slicing to `0` yields an empty slice.
-    #[unstable = "waiting on final error conventions"]
-    fn slice_to(&self, end: uint) -> &'a [T];
-
     /// Divides one slice into two at an index.
     ///
     /// The first will contain all indices from `[0, mid)` (excluding
@@ -240,7 +215,7 @@ pub trait ImmutableSlice<'a, T> {
      * ```ignore
      *     if self.len() == 0 { return None }
      *     let head = &self[0];
-     *     *self = self.slice_from(1);
+     *     *self = self[1..];
      *     Some(head)
      * ```
      *
@@ -259,7 +234,7 @@ pub trait ImmutableSlice<'a, T> {
      * ```ignore
      *     if self.len() == 0 { return None; }
      *     let tail = &self[self.len() - 1];
-     *     *self = self.slice_to(self.len() - 1);
+     *     *self = self[..self.len() - 1];
      *     Some(tail)
      * ```
      *
@@ -271,31 +246,9 @@ pub trait ImmutableSlice<'a, T> {
 
 #[unstable]
 impl<'a,T> ImmutableSlice<'a, T> for &'a [T] {
-    #[inline]
-    fn slice(&self, start: uint, end: uint) -> &'a [T] {
-        assert!(start <= end);
-        assert!(end <= self.len());
-        unsafe {
-            transmute(RawSlice {
-                    data: self.as_ptr().offset(start as int),
-                    len: (end - start)
-                })
-        }
-    }
-
-    #[inline]
-    fn slice_from(&self, start: uint) -> &'a [T] {
-        self.slice(start, self.len())
-    }
-
-    #[inline]
-    fn slice_to(&self, end: uint) -> &'a [T] {
-        self.slice(0, end)
-    }
-
     #[inline]
     fn split_at(&self, mid: uint) -> (&'a [T], &'a [T]) {
-        (self.slice(0, mid), self.slice(mid, self.len()))
+        ((*self)[..mid], (*self)[mid..])
     }
 
     #[inline]
@@ -364,21 +317,21 @@ impl<'a,T> ImmutableSlice<'a, T> for &'a [T] {
     }
 
     #[inline]
-    fn tail(&self) -> &'a [T] { self.slice(1, self.len()) }
+    fn tail(&self) -> &'a [T] { (*self)[1..] }
 
     #[inline]
     #[deprecated = "use slice_from"]
-    fn tailn(&self, n: uint) -> &'a [T] { self.slice(n, self.len()) }
+    fn tailn(&self, n: uint) -> &'a [T] { (*self)[n..] }
 
     #[inline]
     fn init(&self) -> &'a [T] {
-        self.slice(0, self.len() - 1)
+        (*self)[..self.len() - 1]
     }
 
     #[inline]
     #[deprecated = "use slice_to but note the arguments are different"]
     fn initn(&self, n: uint) -> &'a [T] {
-        self.slice(0, self.len() - n)
+        (*self)[..self.len() - n]
     }
 
     #[inline]
@@ -464,6 +417,35 @@ impl<'a,T> ImmutableSlice<'a, T> for &'a [T] {
     }
 }
 
+#[cfg(not(stage0))]
+impl<T> ops::Slice<uint, [T]> for [T] {
+    #[inline]
+    fn as_slice<'a>(&'a self) -> &'a [T] {
+        self
+    }
+
+    #[inline]
+    fn slice_from<'a>(&'a self, start: &uint) -> &'a [T] {
+        self.slice(start, &self.len())
+    }
+
+    #[inline]
+    fn slice_to<'a>(&'a self, end: &uint) -> &'a [T] {
+        self.slice(&0, end)
+    }
+    #[inline]
+    fn slice<'a>(&'a self, start: &uint, end: &uint) -> &'a [T] {
+        assert!(*start <= *end);
+        assert!(*end <= self.len());
+        unsafe {
+            transmute(RawSlice {
+                    data: self.as_ptr().offset(*start as int),
+                    len: (*end - *start)
+                })
+        }
+    }
+}
+#[cfg(stage0)]
 impl<T> ops::Slice<uint, [T]> for [T] {
     #[inline]
     fn as_slice_<'a>(&'a self) -> &'a [T] {
@@ -491,7 +473,36 @@ impl<T> ops::Slice<uint, [T]> for [T] {
         }
     }
 }
+#[cfg(not(stage0))]
+impl<T> ops::SliceMut<uint, [T]> for [T] {
+    #[inline]
+    fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] {
+        self
+    }
 
+    #[inline]
+    fn slice_from_mut<'a>(&'a mut self, start: &uint) -> &'a mut [T] {
+        let len = &self.len();
+        self.slice_mut(start, len)
+    }
+
+    #[inline]
+    fn slice_to_mut<'a>(&'a mut self, end: &uint) -> &'a mut [T] {
+        self.slice_mut(&0, end)
+    }
+    #[inline]
+    fn slice_mut<'a>(&'a mut self, start: &uint, end: &uint) -> &'a mut [T] {
+        assert!(*start <= *end);
+        assert!(*end <= self.len());
+        unsafe {
+            transmute(RawSlice {
+                    data: self.as_ptr().offset(*start as int),
+                    len: (*end - *start)
+                })
+        }
+    }
+}
+#[cfg(stage0)]
 impl<T> ops::SliceMut<uint, [T]> for [T] {
     #[inline]
     fn as_mut_slice_<'a>(&'a mut self) -> &'a mut [T] {
@@ -533,49 +544,6 @@ pub trait MutableSlice<'a, T> {
     /// Primarily intended for getting a &mut [T] from a [T, ..N].
     fn as_mut_slice(self) -> &'a mut [T];
 
-    /// Deprecated: use `slice_mut`.
-    #[deprecated = "use slice_mut"]
-    fn mut_slice(self, start: uint, end: uint) -> &'a mut [T] {
-        self.slice_mut(start, end)
-    }
-
-    /// Returns a mutable subslice spanning the interval [`start`, `end`).
-    ///
-    /// Fails when the end of the new slice lies beyond the end of the
-    /// original slice (i.e. when `end > self.len()`) or when `start > end`.
-    ///
-    /// Slicing with `start` equal to `end` yields an empty slice.
-    #[unstable = "waiting on final error conventions"]
-    fn slice_mut(self, start: uint, end: uint) -> &'a mut [T];
-
-    /// Deprecated: use `slice_from_mut`.
-    #[deprecated = "use slice_from_mut"]
-    fn mut_slice_from(self, start: uint) -> &'a mut [T] {
-        self.slice_from_mut(start)
-    }
-
-    /// Returns a mutable subslice from `start` to the end of the slice.
-    ///
-    /// Fails when `start` is strictly greater than the length of the original slice.
-    ///
-    /// Slicing from `self.len()` yields an empty slice.
-    #[unstable = "waiting on final error conventions"]
-    fn slice_from_mut(self, start: uint) -> &'a mut [T];
-
-    /// Deprecated: use `slice_to_mut`.
-    #[deprecated = "use slice_to_mut"]
-    fn mut_slice_to(self, end: uint) -> &'a mut [T] {
-        self.slice_to_mut(end)
-    }
-
-    /// Returns a mutable subslice from the start of the slice to `end`.
-    ///
-    /// Fails when `end` is strictly greater than the length of the original slice.
-    ///
-    /// Slicing to `0` yields an empty slice.
-    #[unstable = "waiting on final error conventions"]
-    fn slice_to_mut(self, end: uint) -> &'a mut [T];
-
     /// Deprecated: use `iter_mut`.
     #[deprecated = "use iter_mut"]
     fn mut_iter(self) -> MutItems<'a, T> {
@@ -659,7 +627,7 @@ pub trait MutableSlice<'a, T> {
      * ```ignore
      *     if self.len() == 0 { return None; }
      *     let head = &mut self[0];
-     *     *self = self.slice_from_mut(1);
+     *     *self = self[mut 1..];
      *     Some(head)
      * ```
      *
@@ -678,7 +646,7 @@ pub trait MutableSlice<'a, T> {
      * ```ignore
      *     if self.len() == 0 { return None; }
      *     let tail = &mut self[self.len() - 1];
-     *     *self = self.slice_to_mut(self.len() - 1);
+     *     *self = self[mut ..self.len() - 1];
      *     Some(tail)
      * ```
      *
@@ -803,34 +771,11 @@ impl<'a,T> MutableSlice<'a, T> for &'a mut [T] {
     #[inline]
     fn as_mut_slice(self) -> &'a mut [T] { self }
 
-    fn slice_mut(self, start: uint, end: uint) -> &'a mut [T] {
-        assert!(start <= end);
-        assert!(end <= self.len());
-        unsafe {
-            transmute(RawSlice {
-                    data: self.as_mut_ptr().offset(start as int) as *const T,
-                    len: (end - start)
-                })
-        }
-    }
-
-    #[inline]
-    fn slice_from_mut(self, start: uint) -> &'a mut [T] {
-        let len = self.len();
-        self.slice_mut(start, len)
-    }
-
-    #[inline]
-    fn slice_to_mut(self, end: uint) -> &'a mut [T] {
-        self.slice_mut(0, end)
-    }
-
     #[inline]
     fn split_at_mut(self, mid: uint) -> (&'a mut [T], &'a mut [T]) {
         unsafe {
-            let len = self.len();
             let self2: &'a mut [T] = mem::transmute_copy(&self);
-            (self.slice_mut(0, mid), self2.slice_mut(mid, len))
+            (self[mut ..mid], self2[mut mid..])
         }
     }
 
@@ -867,13 +812,13 @@ impl<'a,T> MutableSlice<'a, T> for &'a mut [T] {
     #[inline]
     fn tail_mut(self) -> &'a mut [T] {
         let len = self.len();
-        self.slice_mut(1, len)
+        self[mut 1..len]
     }
 
     #[inline]
     fn init_mut(self) -> &'a mut [T] {
         let len = self.len();
-        self.slice_mut(0, len - 1)
+        self[mut 0..len - 1]
     }
 
     #[inline]
@@ -1020,13 +965,13 @@ impl<'a,T:PartialEq> ImmutablePartialEqSlice<T> for &'a [T] {
     #[inline]
     fn starts_with(&self, needle: &[T]) -> bool {
         let n = needle.len();
-        self.len() >= n && needle == self.slice_to(n)
+        self.len() >= n && needle == (*self)[..n]
     }
 
     #[inline]
     fn ends_with(&self, needle: &[T]) -> bool {
         let (m, n) = (self.len(), needle.len());
-        m >= n && needle == self.slice_from(m - n)
+        m >= n && needle == (*self)[m-n..]
     }
 }
 
@@ -1299,8 +1244,8 @@ impl<'a, T> Iterator<&'a [T]> for Splits<'a, T> {
         match self.v.iter().position(|x| (self.pred)(x)) {
             None => self.finish(),
             Some(idx) => {
-                let ret = Some(self.v.slice(0, idx));
-                self.v = self.v.slice(idx + 1, self.v.len());
+                let ret = Some(self.v[..idx]);
+                self.v = self.v[idx + 1..];
                 ret
             }
         }
@@ -1325,8 +1270,8 @@ impl<'a, T> DoubleEndedIterator<&'a [T]> for Splits<'a, T> {
         match self.v.iter().rposition(|x| (self.pred)(x)) {
             None => self.finish(),
             Some(idx) => {
-                let ret = Some(self.v.slice(idx + 1, self.v.len()));
-                self.v = self.v.slice(0, idx);
+                let ret = Some(self.v[idx + 1..]);
+                self.v = self.v[..idx];
                 ret
             }
         }
@@ -1376,7 +1321,7 @@ impl<'a, T> Iterator<&'a mut [T]> for MutSplits<'a, T> {
             Some(idx) => {
                 let tmp = mem::replace(&mut self.v, &mut []);
                 let (head, tail) = tmp.split_at_mut(idx);
-                self.v = tail.slice_from_mut(1);
+                self.v = tail[mut 1..];
                 Some(head)
             }
         }
@@ -1410,7 +1355,7 @@ impl<'a, T> DoubleEndedIterator<&'a mut [T]> for MutSplits<'a, T> {
                 let tmp = mem::replace(&mut self.v, &mut []);
                 let (head, tail) = tmp.split_at_mut(idx);
                 self.v = head;
-                Some(tail.slice_from_mut(1))
+                Some(tail[mut 1..])
             }
         }
     }
@@ -1458,8 +1403,8 @@ impl<'a, T> Iterator<&'a [T]> for Windows<'a, T> {
         if self.size > self.v.len() {
             None
         } else {
-            let ret = Some(self.v.slice(0, self.size));
-            self.v = self.v.slice(1, self.v.len());
+            let ret = Some(self.v[..self.size]);
+            self.v = self.v[1..];
             ret
         }
     }
@@ -1543,7 +1488,7 @@ impl<'a, T> RandomAccessIterator<&'a [T]> for Chunks<'a, T> {
             let mut hi = lo + self.size;
             if hi < lo || hi > self.v.len() { hi = self.v.len(); }
 
-            Some(self.v.slice(lo, hi))
+            Some(self.v[lo..hi])
         } else {
             None
         }
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index fd7c63a6b32..1c20d364bf8 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -30,7 +30,7 @@ use iter::range;
 use num::{CheckedMul, Saturating};
 use option::{Option, None, Some};
 use raw::Repr;
-use slice::{ImmutableSlice, MutableSlice};
+use slice::ImmutableSlice;
 use slice;
 use uint;
 
@@ -393,7 +393,7 @@ impl NaiveSearcher {
 
     fn next(&mut self, haystack: &[u8], needle: &[u8]) -> Option<(uint, uint)> {
         while self.position + needle.len() <= haystack.len() {
-            if haystack.slice(self.position, self.position + needle.len()) == needle {
+            if haystack[self.position .. self.position + needle.len()] == needle {
                 let match_pos = self.position;
                 self.position += needle.len(); // add 1 for all matches
                 return Some((match_pos, match_pos + needle.len()));
@@ -514,10 +514,10 @@ impl TwoWaySearcher {
         //
         // What's going on is we have some critical factorization (u, v) of the
         // needle, and we want to determine whether u is a suffix of
-        // v.slice_to(period). If it is, we use "Algorithm CP1". Otherwise we use
+        // v[..period]. If it is, we use "Algorithm CP1". Otherwise we use
         // "Algorithm CP2", which is optimized for when the period of the needle
         // is large.
-        if needle.slice_to(crit_pos) == needle.slice(period, period + crit_pos) {
+        if needle[..crit_pos] == needle[period.. period + crit_pos] {
             TwoWaySearcher {
                 crit_pos: crit_pos,
                 period: period,
@@ -741,7 +741,7 @@ impl<'a> Iterator<u16> for Utf16CodeUnits<'a> {
 
         let mut buf = [0u16, ..2];
         self.chars.next().map(|ch| {
-            let n = ch.encode_utf16(buf.as_mut_slice()).unwrap_or(0);
+            let n = ch.encode_utf16(buf[mut]).unwrap_or(0);
             if n == 2 { self.extra = buf[1]; }
             buf[0]
         })
@@ -1007,7 +1007,7 @@ pub fn utf16_items<'a>(v: &'a [u16]) -> Utf16Items<'a> {
 pub fn truncate_utf16_at_nul<'a>(v: &'a [u16]) -> &'a [u16] {
     match v.iter().position(|c| *c == 0) {
         // don't include the 0
-        Some(i) => v.slice_to(i),
+        Some(i) => v[..i],
         None => v
     }
 }
@@ -1164,6 +1164,7 @@ pub mod traits {
         fn equiv(&self, other: &S) -> bool { eq_slice(*self, other.as_slice()) }
     }
 
+    #[cfg(stage0)]
     impl ops::Slice<uint, str> for str {
         #[inline]
         fn as_slice_<'a>(&'a self) -> &'a str {
@@ -1172,17 +1173,39 @@ pub mod traits {
 
         #[inline]
         fn slice_from_<'a>(&'a self, from: &uint) -> &'a str {
-            self.slice_from(*from)
+            super::slice_from_impl(&self, *from)
         }
 
         #[inline]
         fn slice_to_<'a>(&'a self, to: &uint) -> &'a str {
-            self.slice_to(*to)
+            super::slice_to_impl(&self, *to)
         }
 
         #[inline]
         fn slice_<'a>(&'a self, from: &uint, to: &uint) -> &'a str {
-            self.slice(*from, *to)
+            super::slice_impl(&self, *from, *to)
+        }
+    }
+    #[cfg(not(stage0))]
+    impl ops::Slice<uint, str> for str {
+        #[inline]
+        fn as_slice<'a>(&'a self) -> &'a str {
+            self
+        }
+
+        #[inline]
+        fn slice_from<'a>(&'a self, from: &uint) -> &'a str {
+            super::slice_from_impl(&self, *from)
+        }
+
+        #[inline]
+        fn slice_to<'a>(&'a self, to: &uint) -> &'a str {
+            super::slice_to_impl(&self, *to)
+        }
+
+        #[inline]
+        fn slice<'a>(&'a self, from: &uint, to: &uint) -> &'a str {
+            super::slice_impl(&self, *from, *to)
         }
     }
 }
@@ -1835,6 +1858,38 @@ fn slice_error_fail(s: &str, begin: uint, end: uint) -> ! {
           begin, end, s);
 }
 
+#[inline]
+fn slice_impl<'a>(this: &&'a str, begin: uint, end: uint) -> &'a str {
+    // is_char_boundary checks that the index is in [0, .len()]
+    if begin <= end &&
+       this.is_char_boundary(begin) &&
+       this.is_char_boundary(end) {
+        unsafe { raw::slice_unchecked(*this, begin, end) }
+    } else {
+        slice_error_fail(*this, begin, end)
+    }
+}
+
+#[inline]
+fn slice_from_impl<'a>(this: &&'a str, begin: uint) -> &'a str {
+    // is_char_boundary checks that the index is in [0, .len()]
+    if this.is_char_boundary(begin) {
+        unsafe { raw::slice_unchecked(*this, begin, this.len()) }
+    } else {
+        slice_error_fail(*this, begin, this.len())
+    }
+}
+
+#[inline]
+fn slice_to_impl<'a>(this: &&'a str, end: uint) -> &'a str {
+    // is_char_boundary checks that the index is in [0, .len()]
+    if this.is_char_boundary(end) {
+        unsafe { raw::slice_unchecked(*this, 0, end) }
+    } else {
+        slice_error_fail(*this, 0, end)
+    }
+}
+
 impl<'a> StrSlice<'a> for &'a str {
     #[inline]
     fn contains<'a>(&self, needle: &'a str) -> bool {
@@ -1938,34 +1993,17 @@ impl<'a> StrSlice<'a> for &'a str {
 
     #[inline]
     fn slice(&self, begin: uint, end: uint) -> &'a str {
-        // is_char_boundary checks that the index is in [0, .len()]
-        if begin <= end &&
-           self.is_char_boundary(begin) &&
-           self.is_char_boundary(end) {
-            unsafe { raw::slice_unchecked(*self, begin, end) }
-        } else {
-            slice_error_fail(*self, begin, end)
-        }
+        slice_impl(self, begin, end)
     }
 
     #[inline]
     fn slice_from(&self, begin: uint) -> &'a str {
-        // is_char_boundary checks that the index is in [0, .len()]
-        if self.is_char_boundary(begin) {
-            unsafe { raw::slice_unchecked(*self, begin, self.len()) }
-        } else {
-            slice_error_fail(*self, begin, self.len())
-        }
+        slice_from_impl(self, begin)
     }
 
     #[inline]
     fn slice_to(&self, end: uint) -> &'a str {
-        // is_char_boundary checks that the index is in [0, .len()]
-        if self.is_char_boundary(end) {
-            unsafe { raw::slice_unchecked(*self, 0, end) }
-        } else {
-            slice_error_fail(*self, 0, end)
-        }
+        slice_to_impl(self, end)
     }
 
     fn slice_chars(&self, begin: uint, end: uint) -> &'a str {
@@ -1994,13 +2032,13 @@ impl<'a> StrSlice<'a> for &'a str {
     #[inline]
     fn starts_with<'a>(&self, needle: &'a str) -> bool {
         let n = needle.len();
-        self.len() >= n && needle.as_bytes() == self.as_bytes().slice_to(n)
+        self.len() >= n && needle.as_bytes() == self.as_bytes()[..n]
     }
 
     #[inline]
     fn ends_with(&self, needle: &str) -> bool {
         let (m, n) = (self.len(), needle.len());
-        m >= n && needle.as_bytes() == self.as_bytes().slice_from(m - n)
+        m >= n && needle.as_bytes() == self.as_bytes()[m-n..]
     }
 
     #[inline]
diff --git a/src/libcoretest/char.rs b/src/libcoretest/char.rs
index 8c3f4706a3c..9628d7950b5 100644
--- a/src/libcoretest/char.rs
+++ b/src/libcoretest/char.rs
@@ -174,7 +174,7 @@ fn test_encode_utf8() {
     fn check(input: char, expect: &[u8]) {
         let mut buf = [0u8, ..4];
         let n = input.encode_utf8(buf.as_mut_slice()).unwrap_or(0);
-        assert_eq!(buf.slice_to(n), expect);
+        assert_eq!(buf[..n], expect);
     }
 
     check('x', [0x78]);
@@ -188,7 +188,7 @@ fn test_encode_utf16() {
     fn check(input: char, expect: &[u16]) {
         let mut buf = [0u16, ..2];
         let n = input.encode_utf16(buf.as_mut_slice()).unwrap_or(0);
-        assert_eq!(buf.slice_to(n), expect);
+        assert_eq!(buf[..n], expect);
     }
 
     check('x', [0x0078]);
diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs
index 1aaea192162..e84c8947967 100644
--- a/src/libcoretest/iter.rs
+++ b/src/libcoretest/iter.rs
@@ -13,6 +13,7 @@ use core::iter::order::*;
 use core::uint;
 use core::cmp;
 use core::num;
+use core::ops::Slice;
 
 use test::Bencher;
 
@@ -228,7 +229,7 @@ fn test_inspect() {
                .collect::<Vec<uint>>();
 
     assert_eq!(n, xs.len());
-    assert_eq!(xs.as_slice(), ys.as_slice());
+    assert_eq!(xs[], ys[]);
 }
 
 #[test]
@@ -268,7 +269,7 @@ fn test_cycle() {
 
 #[test]
 fn test_iterator_nth() {
-    let v = &[0i, 1, 2, 3, 4];
+    let v: &[_] = &[0i, 1, 2, 3, 4];
     for i in range(0u, v.len()) {
         assert_eq!(v.iter().nth(i).unwrap(), &v[i]);
     }
@@ -277,55 +278,55 @@ fn test_iterator_nth() {
 
 #[test]
 fn test_iterator_last() {
-    let v = &[0i, 1, 2, 3, 4];
+    let v: &[_] = &[0i, 1, 2, 3, 4];
     assert_eq!(v.iter().last().unwrap(), &4);
-    assert_eq!(v.slice(0, 1).iter().last().unwrap(), &0);
+    assert_eq!(v[0..1].iter().last().unwrap(), &0);
 }
 
 #[test]
 fn test_iterator_len() {
-    let v = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    assert_eq!(v.slice(0, 4).iter().count(), 4);
-    assert_eq!(v.slice(0, 10).iter().count(), 10);
-    assert_eq!(v.slice(0, 0).iter().count(), 0);
+    let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    assert_eq!(v[0..4].iter().count(), 4);
+    assert_eq!(v[0..10].iter().count(), 10);
+    assert_eq!(v[0..0].iter().count(), 0);
 }
 
 #[test]
 fn test_iterator_sum() {
-    let v = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    assert_eq!(v.slice(0, 4).iter().map(|&x| x).sum(), 6);
+    let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    assert_eq!(v[0..4].iter().map(|&x| x).sum(), 6);
     assert_eq!(v.iter().map(|&x| x).sum(), 55);
-    assert_eq!(v.slice(0, 0).iter().map(|&x| x).sum(), 0);
+    assert_eq!(v[0..0].iter().map(|&x| x).sum(), 0);
 }
 
 #[test]
 fn test_iterator_product() {
-    let v = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    assert_eq!(v.slice(0, 4).iter().map(|&x| x).product(), 0);
-    assert_eq!(v.slice(1, 5).iter().map(|&x| x).product(), 24);
-    assert_eq!(v.slice(0, 0).iter().map(|&x| x).product(), 1);
+    let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    assert_eq!(v[0..4].iter().map(|&x| x).product(), 0);
+    assert_eq!(v[1..5].iter().map(|&x| x).product(), 24);
+    assert_eq!(v[0..0].iter().map(|&x| x).product(), 1);
 }
 
 #[test]
 fn test_iterator_max() {
-    let v = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    assert_eq!(v.slice(0, 4).iter().map(|&x| x).max(), Some(3));
+    let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    assert_eq!(v[0..4].iter().map(|&x| x).max(), Some(3));
     assert_eq!(v.iter().map(|&x| x).max(), Some(10));
-    assert_eq!(v.slice(0, 0).iter().map(|&x| x).max(), None);
+    assert_eq!(v[0..0].iter().map(|&x| x).max(), None);
 }
 
 #[test]
 fn test_iterator_min() {
-    let v = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    assert_eq!(v.slice(0, 4).iter().map(|&x| x).min(), Some(0));
+    let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    assert_eq!(v[0..4].iter().map(|&x| x).min(), Some(0));
     assert_eq!(v.iter().map(|&x| x).min(), Some(0));
-    assert_eq!(v.slice(0, 0).iter().map(|&x| x).min(), None);
+    assert_eq!(v[0..0].iter().map(|&x| x).min(), None);
 }
 
 #[test]
 fn test_iterator_size_hint() {
     let c = count(0i, 1);
-    let v = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+    let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9];
     let v2 = &[10i, 11, 12];
     let vi = v.iter();
 
@@ -372,7 +373,7 @@ fn test_all() {
     assert!(v.iter().all(|&x| x < 10));
     assert!(!v.iter().all(|&x| x % 2 == 0));
     assert!(!v.iter().all(|&x| x > 100));
-    assert!(v.slice(0, 0).iter().all(|_| fail!()));
+    assert!(v.slice(&0, &0).iter().all(|_| fail!()));
 }
 
 #[test]
@@ -381,7 +382,7 @@ fn test_any() {
     assert!(v.iter().any(|&x| x < 10));
     assert!(v.iter().any(|&x| x % 2 == 0));
     assert!(!v.iter().any(|&x| x > 100));
-    assert!(!v.slice(0, 0).iter().any(|_| fail!()));
+    assert!(!v.slice(&0, &0).iter().any(|_| fail!()));
 }
 
 #[test]
@@ -566,7 +567,7 @@ fn check_randacc_iter<A: PartialEq, T: Clone + RandomAccessIterator<A>>(a: T, le
 fn test_double_ended_flat_map() {
     let u = [0u,1];
     let v = [5u,6,7,8];
-    let mut it = u.iter().flat_map(|x| v.slice(*x, v.len()).iter());
+    let mut it = u.iter().flat_map(|x| v[*x..v.len()].iter());
     assert_eq!(it.next_back().unwrap(), &8);
     assert_eq!(it.next().unwrap(),      &5);
     assert_eq!(it.next_back().unwrap(), &7);
diff --git a/src/libcoretest/lib.rs b/src/libcoretest/lib.rs
index 7866d2f4a11..5f31ed35f1b 100644
--- a/src/libcoretest/lib.rs
+++ b/src/libcoretest/lib.rs
@@ -7,7 +7,7 @@
 // <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.
-#![feature(globs, unsafe_destructor, macro_rules)]
+#![feature(globs, unsafe_destructor, macro_rules, slicing_syntax)]
 
 extern crate core;
 extern crate test;
diff --git a/src/libnative/io/net.rs b/src/libnative/io/net.rs
index 419748b75c3..aa2b1a6f14e 100644
--- a/src/libnative/io/net.rs
+++ b/src/libnative/io/net.rs
@@ -1012,7 +1012,7 @@ pub fn write<T>(fd: sock_t,
             // Also as with read(), we use MSG_DONTWAIT to guard ourselves
             // against unforeseen circumstances.
             let _guard = lock();
-            let ptr = buf.slice_from(written).as_ptr();
+            let ptr = buf[written..].as_ptr();
             let len = buf.len() - written;
             match retry(|| write(deadline.is_some(), ptr, len)) {
                 -1 if util::wouldblock() => {}
diff --git a/src/libnative/io/pipe_windows.rs b/src/libnative/io/pipe_windows.rs
index 2de9cd9a41c..5475de6d7e1 100644
--- a/src/libnative/io/pipe_windows.rs
+++ b/src/libnative/io/pipe_windows.rs
@@ -448,7 +448,7 @@ impl rtio::RtioPipe for UnixStream {
             }
             let ret = unsafe {
                 libc::WriteFile(self.handle(),
-                                buf.slice_from(offset).as_ptr() as libc::LPVOID,
+                                buf[offset..].as_ptr() as libc::LPVOID,
                                 (buf.len() - offset) as libc::DWORD,
                                 &mut bytes_written,
                                 &mut overlapped)
diff --git a/src/libnative/lib.rs b/src/libnative/lib.rs
index 267ff3d2a81..5def99d8ef3 100644
--- a/src/libnative/lib.rs
+++ b/src/libnative/lib.rs
@@ -57,7 +57,8 @@
 
 #![deny(unused_result, unused_must_use)]
 #![allow(non_camel_case_types, deprecated)]
-#![feature(default_type_params, lang_items)]
+#![allow(unknown_features)]
+#![feature(default_type_params, lang_items, slicing_syntax)]
 
 // NB this crate explicitly does *not* allow glob imports, please seriously
 //    consider whether they're needed before adding that feature here (the
diff --git a/src/libnum/bigint.rs b/src/libnum/bigint.rs
index efa3402073f..c5722419f3e 100644
--- a/src/libnum/bigint.rs
+++ b/src/libnum/bigint.rs
@@ -735,7 +735,7 @@ impl BigUint {
         let mut power: BigUint  = One::one();
         loop {
             let start = cmp::max(end, unit_len) - unit_len;
-            match uint::parse_bytes(buf.slice(start, end), radix) {
+            match uint::parse_bytes(buf[start..end], radix) {
                 Some(d) => {
                     let d: Option<BigUint> = FromPrimitive::from_uint(d);
                     match d {
@@ -1406,7 +1406,7 @@ impl BigInt {
             sign  = Minus;
             start = 1;
         }
-        return BigUint::parse_bytes(buf.slice(start, buf.len()), radix)
+        return BigUint::parse_bytes(buf[start..], radix)
             .map(|bu| BigInt::from_biguint(sign, bu));
     }
 
diff --git a/src/libnum/lib.rs b/src/libnum/lib.rs
index 17071d22dee..fa41cf37112 100644
--- a/src/libnum/lib.rs
+++ b/src/libnum/lib.rs
@@ -43,7 +43,8 @@
 //!
 //! [newt]: https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method
 
-#![feature(macro_rules)]
+#![allow(unknown_features)]
+#![feature(macro_rules, slicing_syntax)]
 #![feature(default_type_params)]
 
 #![crate_name = "num"]
diff --git a/src/librand/lib.rs b/src/librand/lib.rs
index f8a775478f1..c65e55690c7 100644
--- a/src/librand/lib.rs
+++ b/src/librand/lib.rs
@@ -228,7 +228,7 @@ pub trait Rng {
     /// let choices = [1i, 2, 4, 8, 16, 32];
     /// let mut rng = task_rng();
     /// println!("{}", rng.choose(choices));
-    /// assert_eq!(rng.choose(choices.slice_to(0)), None);
+    /// assert_eq!(rng.choose(choices[..0]), None);
     /// ```
     fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> {
         if values.is_empty() {
diff --git a/src/librbml/io.rs b/src/librbml/io.rs
index 648aa866814..8917151609f 100644
--- a/src/librbml/io.rs
+++ b/src/librbml/io.rs
@@ -94,7 +94,7 @@ impl Writer for SeekableMemWriter {
             // there (left), and what will be appended on the end (right)
             let cap = self.buf.len() - self.pos;
             let (left, right) = if cap <= buf.len() {
-                (buf.slice_to(cap), buf.slice_from(cap))
+                (buf[..cap], buf[cap..])
             } else {
                 let result: (_, &[_]) = (buf, &[]);
                 result
@@ -102,7 +102,7 @@ impl Writer for SeekableMemWriter {
 
             // Do the necessary writes
             if left.len() > 0 {
-                slice::bytes::copy_memory(self.buf.slice_from_mut(self.pos), left);
+                slice::bytes::copy_memory(self.buf[mut self.pos..], left);
             }
             if right.len() > 0 {
                 self.buf.push_all(right);
diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs
index 6171a9946b6..7480cf320cf 100644
--- a/src/librbml/lib.rs
+++ b/src/librbml/lib.rs
@@ -24,7 +24,8 @@
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/master/",
        html_playground_url = "http://play.rust-lang.org/")]
-#![feature(macro_rules, phase)]
+#![allow(unknown_features)]
+#![feature(macro_rules, phase, slicing_syntax)]
 #![allow(missing_doc)]
 
 extern crate serialize;
@@ -54,7 +55,7 @@ impl<'doc> Doc<'doc> {
     }
 
     pub fn as_str_slice<'a>(&'a self) -> &'a str {
-        str::from_utf8(self.data.slice(self.start, self.end)).unwrap()
+        str::from_utf8(self.data[self.start..self.end]).unwrap()
     }
 
     pub fn as_str(&self) -> String {
@@ -280,7 +281,7 @@ pub mod reader {
     }
 
     pub fn with_doc_data<'a, T>(d: Doc<'a>, f: |x: &'a [u8]| -> T) -> T {
-        f(d.data.slice(d.start, d.end))
+        f(d.data[d.start..d.end])
     }
 
 
diff --git a/src/libregex/compile.rs b/src/libregex/compile.rs
index c3e195af6f9..a32dfcf5d2a 100644
--- a/src/libregex/compile.rs
+++ b/src/libregex/compile.rs
@@ -102,7 +102,7 @@ impl Program {
         // This is a bit hacky since we have to skip over the initial
         // 'Save' instruction.
         let mut pre = String::with_capacity(5);
-        for inst in c.insts.slice_from(1).iter() {
+        for inst in c.insts[1..].iter() {
             match *inst {
                 OneChar(c, FLAG_EMPTY) => pre.push(c),
                 _ => break
diff --git a/src/libregex/lib.rs b/src/libregex/lib.rs
index 9ff65fe3e2a..fdfd8c1eae2 100644
--- a/src/libregex/lib.rs
+++ b/src/libregex/lib.rs
@@ -368,7 +368,8 @@
        html_root_url = "http://doc.rust-lang.org/master/",
        html_playground_url = "http://play.rust-lang.org/")]
 
-#![feature(macro_rules, phase)]
+#![allow(unknown_features)]
+#![feature(macro_rules, phase, slicing_syntax)]
 #![deny(missing_doc)]
 
 #[cfg(test)]
diff --git a/src/libregex/parse.rs b/src/libregex/parse.rs
index 7f4289b128a..bf576432631 100644
--- a/src/libregex/parse.rs
+++ b/src/libregex/parse.rs
@@ -511,7 +511,7 @@ impl<'a> Parser<'a> {
         self.chari = closer;
         let greed = try!(self.get_next_greedy());
         let inner = String::from_chars(
-            self.chars.as_slice().slice(start + 1, closer));
+            self.chars[start+1..closer]);
 
         // Parse the min and max values from the regex.
         let (mut min, mut max): (uint, Option<uint>);
@@ -944,7 +944,7 @@ impl<'a> Parser<'a> {
     }
 
     fn slice(&self, start: uint, end: uint) -> String {
-        String::from_chars(self.chars.as_slice().slice(start, end))
+        String::from_chars(self.chars[start..end])
     }
 }
 
diff --git a/src/libregex/test/tests.rs b/src/libregex/test/tests.rs
index 48065992bb0..088425c0888 100644
--- a/src/libregex/test/tests.rs
+++ b/src/libregex/test/tests.rs
@@ -130,7 +130,7 @@ macro_rules! mat(
             // actual capture groups to match test set.
             let (sexpect, mut sgot) = (expected.as_slice(), got.as_slice());
             if sgot.len() > sexpect.len() {
-                sgot = sgot.slice(0, sexpect.len())
+                sgot = sgot[0..sexpect.len()]
             }
             if sexpect != sgot {
                 fail!("For RE '{}' against '{}', expected '{}' but got '{}'",
diff --git a/src/libregex/vm.rs b/src/libregex/vm.rs
index 085975580b7..0a4dca9125a 100644
--- a/src/libregex/vm.rs
+++ b/src/libregex/vm.rs
@@ -145,7 +145,7 @@ impl<'r, 't> Nfa<'r, 't> {
                 // out early.
                 if self.prog.prefix.len() > 0 && clist.size == 0 {
                     let needle = self.prog.prefix.as_slice().as_bytes();
-                    let haystack = self.input.as_bytes().slice_from(self.ic);
+                    let haystack = self.input.as_bytes()[self.ic..];
                     match find_prefix(needle, haystack) {
                         None => break,
                         Some(i) => {
diff --git a/src/libregex_macros/lib.rs b/src/libregex_macros/lib.rs
index cc6a8e27cda..3535038b6a5 100644
--- a/src/libregex_macros/lib.rs
+++ b/src/libregex_macros/lib.rs
@@ -550,7 +550,7 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str,
         } else {
             quote_expr!(self.cx,
                 if clist.size == 0 {
-                    let haystack = self.input.as_bytes().slice_from(self.ic);
+                    let haystack = self.input.as_bytes()[self.ic..];
                     match find_prefix(prefix_bytes, haystack) {
                         None => break,
                         Some(i) => {
diff --git a/src/librustc/back/lto.rs b/src/librustc/back/lto.rs
index cd425b5fec1..58db79f41ca 100644
--- a/src/librustc/back/lto.rs
+++ b/src/librustc/back/lto.rs
@@ -89,9 +89,9 @@ pub fn run(sess: &session::Session, llmod: ModuleRef,
                     if version == 1 {
                         // The only version existing so far
                         let data_size = extract_compressed_bytecode_size_v1(bc_encoded);
-                        let compressed_data = bc_encoded.slice(
-                            link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET,
-                            link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET + data_size as uint);
+                        let compressed_data = bc_encoded[
+                            link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET..
+                            link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET + data_size as uint];
 
                         match flate::inflate_bytes(compressed_data) {
                             Some(inflated) => inflated,
@@ -188,7 +188,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef,
 fn is_versioned_bytecode_format(bc: &[u8]) -> bool {
     let magic_id_byte_count = link::RLIB_BYTECODE_OBJECT_MAGIC.len();
     return bc.len() > magic_id_byte_count &&
-           bc.slice(0, magic_id_byte_count) == link::RLIB_BYTECODE_OBJECT_MAGIC;
+           bc[..magic_id_byte_count] == link::RLIB_BYTECODE_OBJECT_MAGIC;
 }
 
 fn extract_bytecode_format_version(bc: &[u8]) -> u32 {
@@ -200,8 +200,8 @@ fn extract_compressed_bytecode_size_v1(bc: &[u8]) -> u64 {
 }
 
 fn read_from_le_bytes<T: Int>(bytes: &[u8], position_in_bytes: uint) -> T {
-    let byte_data = bytes.slice(position_in_bytes,
-                                position_in_bytes + mem::size_of::<T>());
+    let byte_data = bytes[position_in_bytes..
+                          position_in_bytes + mem::size_of::<T>()];
     let data = unsafe {
         *(byte_data.as_ptr() as *const T)
     };
diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs
index be3867eaba2..478aa6d9805 100644
--- a/src/librustc/lib.rs
+++ b/src/librustc/lib.rs
@@ -29,8 +29,9 @@ This API is completely unstable and subject to change.
       html_root_url = "http://doc.rust-lang.org/master/")]
 
 #![allow(deprecated)]
+#![allow(unknown_features)]
 #![feature(macro_rules, globs, struct_variant, quote)]
-#![feature(default_type_params, phase, unsafe_destructor)]
+#![feature(default_type_params, phase, unsafe_destructor, slicing_syntax)]
 
 #![feature(rustc_diagnostic_macros)]
 #![feature(import_shadowing)]
diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs
index 6d4407f96a7..58d0f132e06 100644
--- a/src/librustc/metadata/decoder.rs
+++ b/src/librustc/metadata/decoder.rs
@@ -70,7 +70,7 @@ fn lookup_hash<'a>(d: rbml::Doc<'a>, eq_fn: |&[u8]| -> bool,
     let mut ret = None;
     reader::tagged_docs(tagged_doc.doc, belt, |elt| {
         let pos = u64_from_be_bytes(elt.data, elt.start, 4) as uint;
-        if eq_fn(elt.data.slice(elt.start + 4, elt.end)) {
+        if eq_fn(elt.data[elt.start + 4 .. elt.end]) {
             ret = Some(reader::doc_at(d.data, pos).unwrap().doc);
             false
         } else {
@@ -84,7 +84,7 @@ pub fn maybe_find_item<'a>(item_id: ast::NodeId,
                            items: rbml::Doc<'a>) -> Option<rbml::Doc<'a>> {
     fn eq_item(bytes: &[u8], item_id: ast::NodeId) -> bool {
         return u64_from_be_bytes(
-            bytes.slice(0u, 4u), 0u, 4u) as ast::NodeId
+            bytes[0u..4u], 0u, 4u) as ast::NodeId
             == item_id;
     }
     lookup_hash(items,
diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs
index d319559044c..ce5494ef477 100644
--- a/src/librustc/metadata/tydecode.rs
+++ b/src/librustc/metadata/tydecode.rs
@@ -91,7 +91,7 @@ fn scan<R>(st: &mut PState, is_last: |char| -> bool, op: |&[u8]| -> R) -> R {
     }
     let end_pos = st.pos;
     st.pos += 1;
-    return op(st.data.slice(start_pos, end_pos));
+    return op(st.data[start_pos..end_pos]);
 }
 
 pub fn parse_ident(st: &mut PState, last: char) -> ast::Ident {
@@ -599,8 +599,8 @@ pub fn parse_def_id(buf: &[u8]) -> ast::DefId {
         fail!();
     }
 
-    let crate_part = buf.slice(0u, colon_idx);
-    let def_part = buf.slice(colon_idx + 1u, len);
+    let crate_part = buf[0u..colon_idx];
+    let def_part = buf[colon_idx + 1u..len];
 
     let crate_num = match uint::parse_bytes(crate_part, 10u) {
        Some(cn) => cn as ast::CrateNum,
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
index de9125ec449..bef63ec3153 100644
--- a/src/librustc/middle/check_match.rs
+++ b/src/librustc/middle/check_match.rs
@@ -870,7 +870,7 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
             None
         }
     };
-    head.map(|head| head.append(r.slice_to(col)).append(r.slice_from(col + 1)))
+    head.map(|head| head.append(r[..col]).append(r[col + 1..]))
 }
 
 fn check_local(cx: &mut MatchCheckCtxt, loc: &Local) {
diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs
index 42a98be0fb8..6ead2445b8d 100644
--- a/src/librustc/middle/resolve.rs
+++ b/src/librustc/middle/resolve.rs
@@ -4014,7 +4014,7 @@ impl<'a> Resolver<'a> {
         for (i, rib) in ribs.iter().enumerate().rev() {
             match rib.bindings.find_copy(&name) {
                 Some(def_like) => {
-                    return self.upvarify(ribs.slice_from(i + 1), def_like, span);
+                    return self.upvarify(ribs[i + 1..], def_like, span);
                 }
                 None => {
                     // Continue.
diff --git a/src/librustc/middle/save/mod.rs b/src/librustc/middle/save/mod.rs
index c956c2d2b00..504273f2090 100644
--- a/src/librustc/middle/save/mod.rs
+++ b/src/librustc/middle/save/mod.rs
@@ -193,7 +193,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
         if len <= 2 {
             return;
         }
-        let sub_paths = sub_paths.slice(0, len-2);
+        let sub_paths = sub_paths[..len-2];
         for &(ref span, ref qualname) in sub_paths.iter() {
             self.fmt.sub_mod_ref_str(path.span,
                                      *span,
diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs
index 68d0bb2d8b4..3ec8d079df4 100644
--- a/src/librustc/middle/trans/_match.rs
+++ b/src/librustc/middle/trans/_match.rs
@@ -473,7 +473,7 @@ fn enter_default<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     // Collect all of the matches that can match against anything.
     enter_match(bcx, dm, m, col, val, |pats| {
         if pat_is_binding_or_wild(dm, &*pats[col]) {
-            Some(Vec::from_slice(pats.slice_to(col)).append(pats.slice_from(col + 1)))
+            Some(Vec::from_slice(pats[..col]).append(pats[col + 1..]))
         } else {
             None
         }
@@ -949,7 +949,7 @@ fn compile_submatch<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                 bcx = compile_guard(bcx,
                                     &**guard_expr,
                                     m[0].data,
-                                    m.slice(1, m.len()),
+                                    m[1..m.len()],
                                     vals,
                                     chk,
                                     has_genuine_default);
@@ -988,7 +988,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
     let tcx = bcx.tcx();
     let dm = &tcx.def_map;
 
-    let vals_left = Vec::from_slice(vals.slice(0u, col)).append(vals.slice(col + 1u, vals.len()));
+    let vals_left = Vec::from_slice(vals[0u..col]).append(vals[col + 1u..vals.len()]);
     let ccx = bcx.fcx.ccx;
 
     // Find a real id (we're adding placeholder wildcard patterns, but
diff --git a/src/librustc/middle/trans/builder.rs b/src/librustc/middle/trans/builder.rs
index e95f640b448..f58241d6777 100644
--- a/src/librustc/middle/trans/builder.rs
+++ b/src/librustc/middle/trans/builder.rs
@@ -550,7 +550,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             for (small_vec_e, &ix) in small_vec.iter_mut().zip(ixs.iter()) {
                 *small_vec_e = C_i32(self.ccx, ix as i32);
             }
-            self.inbounds_gep(base, small_vec.slice(0, ixs.len()))
+            self.inbounds_gep(base, small_vec[..ixs.len()])
         } else {
             let v = ixs.iter().map(|i| C_i32(self.ccx, *i as i32)).collect::<Vec<ValueRef>>();
             self.count_insn("gepi");
diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs
index aada90d260e..dc328833d54 100644
--- a/src/librustc/middle/trans/debuginfo.rs
+++ b/src/librustc/middle/trans/debuginfo.rs
@@ -931,7 +931,7 @@ pub fn create_captured_var_metadata(bcx: Block,
 
     let variable_access = IndirectVariable {
         alloca: env_pointer,
-        address_operations: address_operations.slice_to(address_op_count)
+        address_operations: address_operations[..address_op_count]
     };
 
     declare_local(bcx,
diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs
index 2503fb2541b..e618e08f8a4 100644
--- a/src/librustc/middle/typeck/astconv.rs
+++ b/src/librustc/middle/typeck/astconv.rs
@@ -290,7 +290,7 @@ fn ast_path_substs<'tcx,AC,RS>(
         }
     }
 
-    for param in ty_param_defs.slice_from(supplied_ty_param_count).iter() {
+    for param in ty_param_defs[supplied_ty_param_count..].iter() {
         match param.default {
             Some(default) => {
                 // This is a default type parameter.
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index b0c0a8a571b..aa53773bddf 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -2271,10 +2271,10 @@ fn try_overloaded_slice(fcx: &FnCtxt,
         match fcx.tcx().lang_items.slice_mut_trait() {
             Some(trait_did) => {
                 let method_name = match (start_expr, end_expr) {
-                    (&Some(_), &Some(_)) => "slice_mut_",
-                    (&Some(_), &None) => "slice_from_mut_",
-                    (&None, &Some(_)) => "slice_to_mut_",
-                    (&None, &None) => "as_mut_slice_",
+                    (&Some(_), &Some(_)) => "slice_mut",
+                    (&Some(_), &None) => "slice_from_mut",
+                    (&None, &Some(_)) => "slice_to_mut",
+                    (&None, &None) => "as_mut_slice",
                 };
 
                 method::lookup_in_trait(fcx,
@@ -2296,10 +2296,10 @@ fn try_overloaded_slice(fcx: &FnCtxt,
         match fcx.tcx().lang_items.slice_trait() {
             Some(trait_did) => {
                 let method_name = match (start_expr, end_expr) {
-                    (&Some(_), &Some(_)) => "slice_",
-                    (&Some(_), &None) => "slice_from_",
-                    (&None, &Some(_)) => "slice_to_",
-                    (&None, &None) => "as_slice_",
+                    (&Some(_), &Some(_)) => "slice",
+                    (&Some(_), &None) => "slice_from",
+                    (&None, &Some(_)) => "slice_to",
+                    (&None, &None) => "as_slice",
                 };
 
                 method::lookup_in_trait(fcx,
@@ -3032,7 +3032,7 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
         };
 
         // Call the generic checker.
-        let args: Vec<_> = args.slice_from(1).iter().map(|x| x).collect();
+        let args: Vec<_> = args[1..].iter().map(|x| x).collect();
         let ret_ty = check_method_argument_types(fcx,
                                                  method_name.span,
                                                  fn_ty,
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
index 638aea10e37..5ca6d08720f 100644
--- a/src/librustc/util/ppaux.rs
+++ b/src/librustc/util/ppaux.rs
@@ -490,7 +490,7 @@ pub fn parameterized(cx: &ctxt,
         0
     };
 
-    for t in tps.slice_to(tps.len() - num_defaults).iter() {
+    for t in tps[..tps.len() - num_defaults].iter() {
         strs.push(ty_to_string(cx, *t))
     }
 
diff --git a/src/librustc_back/lib.rs b/src/librustc_back/lib.rs
index e48f9df7564..6486442deb8 100644
--- a/src/librustc_back/lib.rs
+++ b/src/librustc_back/lib.rs
@@ -31,7 +31,8 @@
       html_favicon_url = "http://www.rust-lang.org/favicon.ico",
       html_root_url = "http://doc.rust-lang.org/")]
 
-#![feature(globs, phase, macro_rules)]
+#![allow(unknown_features)]
+#![feature(globs, phase, macro_rules, slicing_syntax)]
 
 #[phase(plugin, link)]
 extern crate log;
diff --git a/src/librustc_back/sha2.rs b/src/librustc_back/sha2.rs
index 8f3dd18c69c..bf8d993964f 100644
--- a/src/librustc_back/sha2.rs
+++ b/src/librustc_back/sha2.rs
@@ -136,14 +136,14 @@ impl FixedBuffer for FixedBuffer64 {
             let buffer_remaining = size - self.buffer_idx;
             if input.len() >= buffer_remaining {
                     copy_memory(
-                        self.buffer.slice_mut(self.buffer_idx, size),
-                        input.slice_to(buffer_remaining));
+                        self.buffer[mut self.buffer_idx..size],
+                        input[..buffer_remaining]);
                 self.buffer_idx = 0;
                 func(self.buffer);
                 i += buffer_remaining;
             } else {
                 copy_memory(
-                    self.buffer.slice_mut(self.buffer_idx, self.buffer_idx + input.len()),
+                    self.buffer[mut self.buffer_idx..self.buffer_idx + input.len()],
                     input);
                 self.buffer_idx += input.len();
                 return;
@@ -153,7 +153,7 @@ impl FixedBuffer for FixedBuffer64 {
         // While we have at least a full buffer size chunk's worth of data, process that data
         // without copying it into the buffer
         while input.len() - i >= size {
-            func(input.slice(i, i + size));
+            func(input[i..i + size]);
             i += size;
         }
 
@@ -162,8 +162,8 @@ impl FixedBuffer for FixedBuffer64 {
         // be empty.
         let input_remaining = input.len() - i;
         copy_memory(
-            self.buffer.slice_mut(0, input_remaining),
-            input.slice_from(i));
+            self.buffer[mut ..input_remaining],
+            input[i..]);
         self.buffer_idx += input_remaining;
     }
 
@@ -173,19 +173,19 @@ impl FixedBuffer for FixedBuffer64 {
 
     fn zero_until(&mut self, idx: uint) {
         assert!(idx >= self.buffer_idx);
-        self.buffer.slice_mut(self.buffer_idx, idx).set_memory(0);
+        self.buffer[mut self.buffer_idx..idx].set_memory(0);
         self.buffer_idx = idx;
     }
 
     fn next<'s>(&'s mut self, len: uint) -> &'s mut [u8] {
         self.buffer_idx += len;
-        return self.buffer.slice_mut(self.buffer_idx - len, self.buffer_idx);
+        return self.buffer[mut self.buffer_idx - len..self.buffer_idx];
     }
 
     fn full_buffer<'s>(&'s mut self) -> &'s [u8] {
         assert!(self.buffer_idx == 64);
         self.buffer_idx = 0;
-        return self.buffer.slice_to(64);
+        return self.buffer[..64];
     }
 
     fn position(&self) -> uint { self.buffer_idx }
@@ -359,7 +359,7 @@ impl Engine256State {
              )
         )
 
-        read_u32v_be(w.slice_mut(0, 16), data);
+        read_u32v_be(w[mut 0..16], data);
 
         // Putting the message schedule inside the same loop as the round calculations allows for
         // the compiler to generate better code.
@@ -495,14 +495,14 @@ impl Digest for Sha256 {
     fn result(&mut self, out: &mut [u8]) {
         self.engine.finish();
 
-        write_u32_be(out.slice_mut(0, 4), self.engine.state.h0);
-        write_u32_be(out.slice_mut(4, 8), self.engine.state.h1);
-        write_u32_be(out.slice_mut(8, 12), self.engine.state.h2);
-        write_u32_be(out.slice_mut(12, 16), self.engine.state.h3);
-        write_u32_be(out.slice_mut(16, 20), self.engine.state.h4);
-        write_u32_be(out.slice_mut(20, 24), self.engine.state.h5);
-        write_u32_be(out.slice_mut(24, 28), self.engine.state.h6);
-        write_u32_be(out.slice_mut(28, 32), self.engine.state.h7);
+        write_u32_be(out[mut 0..4], self.engine.state.h0);
+        write_u32_be(out[mut 4..8], self.engine.state.h1);
+        write_u32_be(out[mut 8..12], self.engine.state.h2);
+        write_u32_be(out[mut 12..16], self.engine.state.h3);
+        write_u32_be(out[mut 16..20], self.engine.state.h4);
+        write_u32_be(out[mut 20..24], self.engine.state.h5);
+        write_u32_be(out[mut 24..28], self.engine.state.h6);
+        write_u32_be(out[mut 28..32], self.engine.state.h7);
     }
 
     fn reset(&mut self) {
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 054fbda7337..0b04536f054 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -698,7 +698,7 @@ impl Clean<Item> for ast::Method {
         let all_inputs = &self.pe_fn_decl().inputs;
         let inputs = match self.pe_explicit_self().node {
             ast::SelfStatic => all_inputs.as_slice(),
-            _ => all_inputs.slice_from(1)
+            _ => all_inputs[1..]
         };
         let decl = FnDecl {
             inputs: Arguments {
@@ -737,7 +737,7 @@ impl Clean<Item> for ast::TypeMethod {
     fn clean(&self, cx: &DocContext) -> Item {
         let inputs = match self.explicit_self.node {
             ast::SelfStatic => self.decl.inputs.as_slice(),
-            _ => self.decl.inputs.slice_from(1)
+            _ => self.decl.inputs[1..]
         };
         let decl = FnDecl {
             inputs: Arguments {
@@ -1009,7 +1009,7 @@ impl Clean<Item> for ty::Method {
                                                self.fty.sig.clone()),
             s => {
                 let sig = ty::FnSig {
-                    inputs: self.fty.sig.inputs.slice_from(1).to_vec(),
+                    inputs: self.fty.sig.inputs[1..].to_vec(),
                     ..self.fty.sig.clone()
                 };
                 let s = match s {
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index 947d9f05ae2..b52b34ff581 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -249,7 +249,7 @@ fn path(w: &mut fmt::Formatter, path: &clean::Path, print_all: bool,
         match rel_root {
             Some(root) => {
                 let mut root = String::from_str(root.as_slice());
-                for seg in path.segments.slice_to(amt).iter() {
+                for seg in path.segments[..amt].iter() {
                     if "super" == seg.name.as_slice() ||
                             "self" == seg.name.as_slice() {
                         try!(write!(w, "{}::", seg.name));
@@ -264,7 +264,7 @@ fn path(w: &mut fmt::Formatter, path: &clean::Path, print_all: bool,
                 }
             }
             None => {
-                for seg in path.segments.slice_to(amt).iter() {
+                for seg in path.segments[..amt].iter() {
                     try!(write!(w, "{}::", seg.name));
                 }
             }
@@ -275,7 +275,7 @@ fn path(w: &mut fmt::Formatter, path: &clean::Path, print_all: bool,
         // This is a documented path, link to it!
         Some((ref fqp, shortty)) if abs_root.is_some() => {
             let mut url = String::from_str(abs_root.unwrap().as_slice());
-            let to_link = fqp.slice_to(fqp.len() - 1);
+            let to_link = fqp[..fqp.len() - 1];
             for component in to_link.iter() {
                 url.push_str(component.as_slice());
                 url.push_str("/");
diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
index 8668e684c2d..f6ea0eea9db 100644
--- a/src/librustdoc/html/render.rs
+++ b/src/librustdoc/html/render.rs
@@ -394,7 +394,7 @@ fn build_index(krate: &clean::Crate, cache: &mut Cache) -> io::IoResult<String>
                     search_index.push(IndexItem {
                         ty: shortty(item),
                         name: item.name.clone().unwrap(),
-                        path: fqp.slice_to(fqp.len() - 1).connect("::"),
+                        path: fqp[..fqp.len() - 1].connect("::"),
                         desc: shorter(item.doc_value()).to_string(),
                         parent: Some(did),
                     });
@@ -549,7 +549,7 @@ fn write_shared(cx: &Context,
         };
 
         let mut mydst = dst.clone();
-        for part in remote_path.slice_to(remote_path.len() - 1).iter() {
+        for part in remote_path[..remote_path.len() - 1].iter() {
             mydst.push(part.as_slice());
             try!(mkdir(&mydst));
         }
@@ -829,7 +829,7 @@ impl DocFolder for Cache {
                     clean::StructFieldItem(..) |
                     clean::VariantItem(..) => {
                         ((Some(*self.parent_stack.last().unwrap()),
-                          Some(self.stack.slice_to(self.stack.len() - 1))),
+                          Some(self.stack[..self.stack.len() - 1])),
                           false)
                     }
                     clean::MethodItem(..) => {
@@ -840,13 +840,13 @@ impl DocFolder for Cache {
                             let did = *last;
                             let path = match self.paths.find(&did) {
                                 Some(&(_, item_type::Trait)) =>
-                                    Some(self.stack.slice_to(self.stack.len() - 1)),
+                                    Some(self.stack[..self.stack.len() - 1]),
                                 // The current stack not necessarily has correlation for
                                 // where the type was defined. On the other hand,
                                 // `paths` always has the right information if present.
                                 Some(&(ref fqp, item_type::Struct)) |
                                 Some(&(ref fqp, item_type::Enum)) =>
-                                    Some(fqp.slice_to(fqp.len() - 1)),
+                                    Some(fqp[..fqp.len() - 1]),
                                 Some(..) => Some(self.stack.as_slice()),
                                 None => None
                             };
@@ -1172,7 +1172,7 @@ impl Context {
                 let mut url = "../".repeat(cx.current.len());
                 match cache_key.get().unwrap().paths.find(&it.def_id) {
                     Some(&(ref names, _)) => {
-                        for name in names.slice_to(names.len() - 1).iter() {
+                        for name in names[..names.len() - 1].iter() {
                             url.push_str(name.as_slice());
                             url.push_str("/");
                         }
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 71d00e50af8..b46d8727b69 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -15,7 +15,8 @@
 #![crate_type = "dylib"]
 #![crate_type = "rlib"]
 
-#![feature(globs, struct_variant, managed_boxes, macro_rules, phase)]
+#![allow(unknown_features)]
+#![feature(globs, struct_variant, managed_boxes, macro_rules, phase, slicing_syntax)]
 
 extern crate arena;
 extern crate debug;
diff --git a/src/librustrt/lib.rs b/src/librustrt/lib.rs
index 72c7d89a3b9..1183b14fb4e 100644
--- a/src/librustrt/lib.rs
+++ b/src/librustrt/lib.rs
@@ -16,9 +16,10 @@
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/master/")]
 
+#![allow(unknown_features)]
 #![feature(macro_rules, phase, globs, thread_local, managed_boxes, asm)]
 #![feature(linkage, lang_items, unsafe_destructor, default_type_params)]
-#![feature(import_shadowing)]
+#![feature(import_shadowing, slicing_syntax)]
 #![no_std]
 #![experimental]
 
diff --git a/src/librustrt/unwind.rs b/src/librustrt/unwind.rs
index 1561f428ce5..f07e8ecc335 100644
--- a/src/librustrt/unwind.rs
+++ b/src/librustrt/unwind.rs
@@ -562,7 +562,7 @@ fn begin_unwind_inner(msg: Box<Any + Send>, file_line: &(&'static str, uint)) ->
     // MAX_CALLBACKS, so we're sure to clamp it as necessary.
     let callbacks = unsafe {
         let amt = CALLBACK_CNT.load(atomic::SeqCst);
-        CALLBACKS.slice_to(cmp::min(amt, MAX_CALLBACKS))
+        CALLBACKS[..cmp::min(amt, MAX_CALLBACKS)]
     };
     for cb in callbacks.iter() {
         match cb.load(atomic::SeqCst) {
diff --git a/src/librustrt/util.rs b/src/librustrt/util.rs
index 77e3e25eb0e..455df88963e 100644
--- a/src/librustrt/util.rs
+++ b/src/librustrt/util.rs
@@ -62,8 +62,8 @@ pub fn abort(args: &fmt::Arguments) -> ! {
     }
     impl<'a> FormatWriter for BufWriter<'a> {
         fn write(&mut self, bytes: &[u8]) -> fmt::Result {
-            let left = self.buf.slice_from_mut(self.pos);
-            let to_write = bytes.slice_to(cmp::min(bytes.len(), left.len()));
+            let left = self.buf[mut self.pos..];
+            let to_write = bytes[..cmp::min(bytes.len(), left.len())];
             slice::bytes::copy_memory(left, to_write);
             self.pos += to_write.len();
             Ok(())
@@ -74,7 +74,7 @@ pub fn abort(args: &fmt::Arguments) -> ! {
     let mut msg = [0u8, ..512];
     let mut w = BufWriter { buf: msg, pos: 0 };
     let _ = write!(&mut w, "{}", args);
-    let msg = str::from_utf8(w.buf.slice_to(w.pos)).unwrap_or("aborted");
+    let msg = str::from_utf8(w.buf[mut ..w.pos]).unwrap_or("aborted");
     let msg = if msg.is_empty() {"aborted"} else {msg};
 
     // Give some context to the message
diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs
index 3007e160bf8..7f329630e70 100644
--- a/src/libserialize/json.rs
+++ b/src/libserialize/json.rs
@@ -334,7 +334,7 @@ pub fn escape_bytes(wr: &mut io::Writer, bytes: &[u8]) -> Result<(), io::IoError
         };
 
         if start < i {
-            try!(wr.write(bytes.slice(start, i)));
+            try!(wr.write(bytes[start..i]));
         }
 
         try!(wr.write_str(escaped));
@@ -343,7 +343,7 @@ pub fn escape_bytes(wr: &mut io::Writer, bytes: &[u8]) -> Result<(), io::IoError
     }
 
     if start != bytes.len() {
-        try!(wr.write(bytes.slice_from(start)));
+        try!(wr.write(bytes[start..]));
     }
 
     wr.write_str("\"")
@@ -369,7 +369,7 @@ fn spaces(wr: &mut io::Writer, mut n: uint) -> Result<(), io::IoError> {
     }
 
     if n > 0 {
-        wr.write(buf.slice_to(n))
+        wr.write(buf[..n])
     } else {
         Ok(())
     }
@@ -1149,7 +1149,7 @@ impl Stack {
             InternalIndex(i) => { Index(i) }
             InternalKey(start, size) => {
                 Key(str::from_utf8(
-                    self.str_buffer.slice(start as uint, start as uint + size as uint)).unwrap())
+                    self.str_buffer[start as uint .. start as uint + size as uint]).unwrap())
             }
         }
     }
@@ -1191,7 +1191,7 @@ impl Stack {
             Some(&InternalIndex(i)) => Some(Index(i)),
             Some(&InternalKey(start, size)) => {
                 Some(Key(str::from_utf8(
-                    self.str_buffer.slice(start as uint, (start+size) as uint)
+                    self.str_buffer[start as uint .. (start+size) as uint]
                 ).unwrap()))
             }
         }
diff --git a/src/libserialize/lib.rs b/src/libserialize/lib.rs
index 5c35ad85233..8c2f3235322 100644
--- a/src/libserialize/lib.rs
+++ b/src/libserialize/lib.rs
@@ -23,7 +23,8 @@ Core encoding and decoding interfaces.
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/master/",
        html_playground_url = "http://play.rust-lang.org/")]
-#![feature(macro_rules, managed_boxes, default_type_params, phase)]
+#![allow(unknown_features)]
+#![feature(macro_rules, managed_boxes, default_type_params, phase, slicing_syntax)]
 
 // test harness access
 #[cfg(test)]
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index d9543a06b35..754b440b0de 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -90,10 +90,10 @@ impl<R: Reader> BufferedReader<R> {
 impl<R: Reader> Buffer for BufferedReader<R> {
     fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
         if self.pos == self.cap {
-            self.cap = try!(self.inner.read(self.buf.as_mut_slice()));
+            self.cap = try!(self.inner.read(self.buf[mut]));
             self.pos = 0;
         }
-        Ok(self.buf.slice(self.pos, self.cap))
+        Ok(self.buf[self.pos..self.cap])
     }
 
     fn consume(&mut self, amt: uint) {
@@ -107,7 +107,7 @@ impl<R: Reader> Reader for BufferedReader<R> {
         let nread = {
             let available = try!(self.fill_buf());
             let nread = cmp::min(available.len(), buf.len());
-            slice::bytes::copy_memory(buf, available.slice_to(nread));
+            slice::bytes::copy_memory(buf, available[..nread]);
             nread
         };
         self.pos += nread;
@@ -162,7 +162,7 @@ impl<W: Writer> BufferedWriter<W> {
 
     fn flush_buf(&mut self) -> IoResult<()> {
         if self.pos != 0 {
-            let ret = self.inner.as_mut().unwrap().write(self.buf.slice_to(self.pos));
+            let ret = self.inner.as_mut().unwrap().write(self.buf[..self.pos]);
             self.pos = 0;
             ret
         } else {
@@ -195,7 +195,7 @@ impl<W: Writer> Writer for BufferedWriter<W> {
         if buf.len() > self.buf.len() {
             self.inner.as_mut().unwrap().write(buf)
         } else {
-            let dst = self.buf.slice_from_mut(self.pos);
+            let dst = self.buf[mut self.pos..];
             slice::bytes::copy_memory(dst, buf);
             self.pos += buf.len();
             Ok(())
@@ -250,9 +250,9 @@ impl<W: Writer> Writer for LineBufferedWriter<W> {
     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
         match buf.iter().rposition(|&b| b == b'\n') {
             Some(i) => {
-                try!(self.inner.write(buf.slice_to(i + 1)));
+                try!(self.inner.write(buf[..i + 1]));
                 try!(self.inner.flush());
-                try!(self.inner.write(buf.slice_from(i + 1)));
+                try!(self.inner.write(buf[i + 1..]));
                 Ok(())
             }
             None => self.inner.write(buf),
diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs
index 0a969fc37c9..5bec131f222 100644
--- a/src/libstd/io/comm_adapters.rs
+++ b/src/libstd/io/comm_adapters.rs
@@ -15,8 +15,7 @@ use comm::{Sender, Receiver};
 use io;
 use option::{None, Option, Some};
 use result::{Ok, Err};
-use slice::{bytes, MutableSlice, ImmutableSlice, CloneableVector};
-use str::StrSlice;
+use slice::{bytes, CloneableVector};
 use super::{Reader, Writer, IoResult};
 use vec::Vec;
 
@@ -62,10 +61,10 @@ impl Reader for ChanReader {
         loop {
             match self.buf {
                 Some(ref prev) => {
-                    let dst = buf.slice_from_mut(num_read);
-                    let src = prev.slice_from(self.pos);
+                    let dst = buf[mut num_read..];
+                    let src = prev[self.pos..];
                     let count = cmp::min(dst.len(), src.len());
-                    bytes::copy_memory(dst, src.slice_to(count));
+                    bytes::copy_memory(dst, src[..count]);
                     num_read += count;
                     self.pos += count;
                 },
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index f777460e66a..66d20835fb2 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -485,7 +485,7 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
             Err(ref e) if e.kind == io::EndOfFile => { break }
             Err(e) => return update_err(Err(e), from, to)
         };
-        try!(writer.write(buf.slice_to(amt)));
+        try!(writer.write(buf[..amt]));
     }
 
     chmod(to, try!(update_err(from.stat(), from, to)).perm)
@@ -1014,7 +1014,7 @@ mod test {
             let mut read_buf = [0, .. 1028];
             let read_str = match check!(read_stream.read(read_buf)) {
                 -1|0 => fail!("shouldn't happen"),
-                n => str::from_utf8(read_buf.slice_to(n)).unwrap().to_string()
+                n => str::from_utf8(read_buf[..n]).unwrap().to_string()
             };
             assert_eq!(read_str.as_slice(), message);
         }
@@ -1061,11 +1061,11 @@ mod test {
         {
             let mut read_stream = File::open_mode(filename, Open, Read);
             {
-                let read_buf = read_mem.slice_mut(0, 4);
+                let read_buf = read_mem[mut 0..4];
                 check!(read_stream.read(read_buf));
             }
             {
-                let read_buf = read_mem.slice_mut(4, 8);
+                let read_buf = read_mem[mut 4..8];
                 check!(read_stream.read(read_buf));
             }
         }
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index c826bd16715..ca9692ee158 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -19,7 +19,7 @@ use result::{Err, Ok};
 use io;
 use io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult};
 use slice;
-use slice::{Slice, ImmutableSlice, MutableSlice};
+use slice::Slice;
 use vec::Vec;
 
 static BUF_CAPACITY: uint = 128;
@@ -146,8 +146,8 @@ impl Reader for MemReader {
 
         let write_len = min(buf.len(), self.buf.len() - self.pos);
         {
-            let input = self.buf.slice(self.pos, self.pos + write_len);
-            let output = buf.slice_mut(0, write_len);
+            let input = self.buf[self.pos.. self.pos + write_len];
+            let output = buf[mut ..write_len];
             assert_eq!(input.len(), output.len());
             slice::bytes::copy_memory(output, input);
         }
@@ -174,7 +174,7 @@ impl Buffer for MemReader {
     #[inline]
     fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
         if self.pos < self.buf.len() {
-            Ok(self.buf.slice_from(self.pos))
+            Ok(self.buf[self.pos..])
         } else {
             Err(io::standard_error(io::EndOfFile))
         }
@@ -232,7 +232,7 @@ impl<'a> Writer for BufWriter<'a> {
             })
         }
 
-        slice::bytes::copy_memory(self.buf.slice_from_mut(self.pos), buf);
+        slice::bytes::copy_memory(self.buf[mut self.pos..], buf);
         self.pos += buf.len();
         Ok(())
     }
@@ -292,8 +292,8 @@ impl<'a> Reader for BufReader<'a> {
 
         let write_len = min(buf.len(), self.buf.len() - self.pos);
         {
-            let input = self.buf.slice(self.pos, self.pos + write_len);
-            let output = buf.slice_mut(0, write_len);
+            let input = self.buf[self.pos.. self.pos + write_len];
+            let output = buf[mut ..write_len];
             assert_eq!(input.len(), output.len());
             slice::bytes::copy_memory(output, input);
         }
@@ -320,7 +320,7 @@ impl<'a> Buffer for BufReader<'a> {
     #[inline]
     fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
         if self.pos < self.buf.len() {
-            Ok(self.buf.slice_from(self.pos))
+            Ok(self.buf[self.pos..])
         } else {
             Err(io::standard_error(io::EndOfFile))
         }
@@ -427,7 +427,7 @@ mod test {
         assert_eq!(buf.as_slice(), b);
         assert_eq!(reader.read(buf), Ok(3));
         let b: &[_] = &[5, 6, 7];
-        assert_eq!(buf.slice(0, 3), b);
+        assert_eq!(buf[0..3], b);
         assert!(reader.read(buf).is_err());
         let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
         assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
@@ -454,7 +454,7 @@ mod test {
         assert_eq!(buf.as_slice(), b);
         assert_eq!(reader.read(buf), Ok(3));
         let b: &[_] = &[5, 6, 7];
-        assert_eq!(buf.slice(0, 3), b);
+        assert_eq!(buf[0..3], b);
         assert!(reader.read(buf).is_err());
         let mut reader = BufReader::new(in_buf.as_slice());
         assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
@@ -548,7 +548,7 @@ mod test {
         assert!(r.read_at_least(buf.len(), buf).is_ok());
         let b: &[_] = &[1, 2, 3];
         assert_eq!(buf.as_slice(), b);
-        assert!(r.read_at_least(0, buf.slice_to_mut(0)).is_ok());
+        assert!(r.read_at_least(0, buf[mut ..0]).is_ok());
         assert_eq!(buf.as_slice(), b);
         assert!(r.read_at_least(buf.len(), buf).is_ok());
         let b: &[_] = &[4, 5, 6];
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index b929e7c464d..9768539b23e 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -235,7 +235,7 @@ use os;
 use boxed::Box;
 use result::{Ok, Err, Result};
 use rt::rtio;
-use slice::{Slice, MutableSlice, ImmutableSlice};
+use slice::{Slice, ImmutableSlice};
 use str::{Str, StrSlice};
 use str;
 use string::String;
@@ -575,7 +575,7 @@ pub trait Reader {
         while read < min {
             let mut zeroes = 0;
             loop {
-                match self.read(buf.slice_from_mut(read)) {
+                match self.read(buf[mut read..]) {
                     Ok(0) => {
                         zeroes += 1;
                         if zeroes >= NO_PROGRESS_LIMIT {
@@ -1111,8 +1111,8 @@ pub trait Writer {
     #[inline]
     fn write_char(&mut self, c: char) -> IoResult<()> {
         let mut buf = [0u8, ..4];
-        let n = c.encode_utf8(buf.as_mut_slice()).unwrap_or(0);
-        self.write(buf.slice_to(n))
+        let n = c.encode_utf8(buf[mut]).unwrap_or(0);
+        self.write(buf[..n])
     }
 
     /// Write the result of passing n through `int::to_str_bytes`.
@@ -1496,7 +1496,7 @@ pub trait Buffer: Reader {
                 };
                 match available.iter().position(|&b| b == byte) {
                     Some(i) => {
-                        res.push_all(available.slice_to(i + 1));
+                        res.push_all(available[..i + 1]);
                         used = i + 1;
                         break
                     }
@@ -1528,14 +1528,14 @@ pub trait Buffer: Reader {
         {
             let mut start = 1;
             while start < width {
-                match try!(self.read(buf.slice_mut(start, width))) {
+                match try!(self.read(buf[mut start..width])) {
                     n if n == width - start => break,
                     n if n < width - start => { start += n; }
                     _ => return Err(standard_error(InvalidInput)),
                 }
             }
         }
-        match str::from_utf8(buf.slice_to(width)) {
+        match str::from_utf8(buf[..width]) {
             Some(s) => Ok(s.char_at(0)),
             None => Err(standard_error(InvalidInput))
         }
diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs
index 6eb7d1c02fb..5140159e4ea 100644
--- a/src/libstd/io/net/ip.rs
+++ b/src/libstd/io/net/ip.rs
@@ -21,7 +21,7 @@ use from_str::FromStr;
 use iter::Iterator;
 use option::{Option, None, Some};
 use str::StrSlice;
-use slice::{MutableCloneableSlice, ImmutableSlice, MutableSlice};
+use slice::{MutableCloneableSlice, MutableSlice};
 
 pub type Port = u16;
 
@@ -241,7 +241,7 @@ impl<'a> Parser<'a> {
             assert!(head.len() + tail.len() <= 8);
             let mut gs = [0u16, ..8];
             gs.clone_from_slice(head);
-            gs.slice_mut(8 - tail.len(), 8).clone_from_slice(tail);
+            gs[mut 8 - tail.len() .. 8].clone_from_slice(tail);
             Ipv6Addr(gs[0], gs[1], gs[2], gs[3], gs[4], gs[5], gs[6], gs[7])
         }
 
@@ -303,7 +303,7 @@ impl<'a> Parser<'a> {
 
         let mut tail = [0u16, ..8];
         let (tail_size, _) = read_groups(self, &mut tail, 8 - head_size);
-        Some(ipv6_addr_from_head_tail(head.slice(0, head_size), tail.slice(0, tail_size)))
+        Some(ipv6_addr_from_head_tail(head[..head_size], tail[..tail_size]))
     }
 
     fn read_ipv6_addr(&mut self) -> Option<IpAddr> {
diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs
index 3ba8765fc3e..b8fb187548c 100644
--- a/src/libstd/io/net/udp.rs
+++ b/src/libstd/io/net/udp.rs
@@ -35,26 +35,29 @@ use rt::rtio;
 ///
 /// ```rust,no_run
 /// # #![allow(unused_must_use)]
+/// #![feature(slicing_syntax)]
+///
 /// use std::io::net::udp::UdpSocket;
 /// use std::io::net::ip::{Ipv4Addr, SocketAddr};
+/// fn main() {
+///     let addr = SocketAddr { ip: Ipv4Addr(127, 0, 0, 1), port: 34254 };
+///     let mut socket = match UdpSocket::bind(addr) {
+///         Ok(s) => s,
+///         Err(e) => fail!("couldn't bind socket: {}", e),
+///     };
 ///
-/// let addr = SocketAddr { ip: Ipv4Addr(127, 0, 0, 1), port: 34254 };
-/// let mut socket = match UdpSocket::bind(addr) {
-///     Ok(s) => s,
-///     Err(e) => fail!("couldn't bind socket: {}", e),
-/// };
-///
-/// let mut buf = [0, ..10];
-/// match socket.recv_from(buf) {
-///     Ok((amt, src)) => {
-///         // Send a reply to the socket we received data from
-///         let buf = buf.slice_to_mut(amt);
-///         buf.reverse();
-///         socket.send_to(buf, src);
+///     let mut buf = [0, ..10];
+///     match socket.recv_from(buf) {
+///         Ok((amt, src)) => {
+///             // Send a reply to the socket we received data from
+///             let buf = buf[mut ..amt];
+///             buf.reverse();
+///             socket.send_to(buf, src);
+///         }
+///         Err(e) => println!("couldn't receive a datagram: {}", e)
 ///     }
-///     Err(e) => println!("couldn't receive a datagram: {}", e)
+///     drop(socket); // close the socket
 /// }
-/// drop(socket); // close the socket
 /// ```
 pub struct UdpSocket {
     obj: Box<RtioUdpSocket + Send>,
diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs
index 16ac8c4c265..820ae931f32 100644
--- a/src/libstd/io/util.rs
+++ b/src/libstd/io/util.rs
@@ -47,7 +47,7 @@ impl<R: Reader> Reader for LimitReader<R> {
         }
 
         let len = cmp::min(self.limit, buf.len());
-        let res = self.inner.read(buf.slice_to_mut(len));
+        let res = self.inner.read(buf[mut ..len]);
         match res {
             Ok(len) => self.limit -= len,
             _ => {}
@@ -59,7 +59,7 @@ impl<R: Reader> Reader for LimitReader<R> {
 impl<R: Buffer> Buffer for LimitReader<R> {
     fn fill_buf<'a>(&'a mut self) -> io::IoResult<&'a [u8]> {
         let amt = try!(self.inner.fill_buf());
-        let buf = amt.slice_to(cmp::min(amt.len(), self.limit));
+        let buf = amt[..cmp::min(amt.len(), self.limit)];
         if buf.len() == 0 {
             Err(io::standard_error(io::EndOfFile))
         } else {
@@ -216,7 +216,7 @@ impl<R: Reader, W: Writer> TeeReader<R, W> {
 impl<R: Reader, W: Writer> Reader for TeeReader<R, W> {
     fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
         self.reader.read(buf).and_then(|len| {
-            self.writer.write(buf.slice_to(len)).map(|()| len)
+            self.writer.write(buf[mut ..len]).map(|()| len)
         })
     }
 }
@@ -230,7 +230,7 @@ pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> io::IoResult<()> {
             Err(ref e) if e.kind == io::EndOfFile => return Ok(()),
             Err(e) => return Err(e),
         };
-        try!(w.write(buf.slice_to(len)));
+        try!(w.write(buf[..len]));
     }
 }
 
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index 7304871cf21..82de55efad6 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -105,9 +105,10 @@
        html_root_url = "http://doc.rust-lang.org/master/",
        html_playground_url = "http://play.rust-lang.org/")]
 
+#![allow(unknown_features)]
 #![feature(macro_rules, globs, managed_boxes, linkage)]
 #![feature(default_type_params, phase, lang_items, unsafe_destructor)]
-#![feature(import_shadowing)]
+#![feature(import_shadowing, slicing_syntax)]
 
 // Don't link to std. We are std.
 #![no_std]
diff --git a/src/libstd/num/i16.rs b/src/libstd/num/i16.rs
index f5b2f31a127..9e4cc06f0a2 100644
--- a/src/libstd/num/i16.rs
+++ b/src/libstd/num/i16.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::i16::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/i32.rs b/src/libstd/num/i32.rs
index 623a10725c8..54259fcad55 100644
--- a/src/libstd/num/i32.rs
+++ b/src/libstd/num/i32.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::i32::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/i64.rs b/src/libstd/num/i64.rs
index ffb1307908c..b5fe6825ca4 100644
--- a/src/libstd/num/i64.rs
+++ b/src/libstd/num/i64.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::i64::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/i8.rs b/src/libstd/num/i8.rs
index 4fbb7381238..7aa9a41e340 100644
--- a/src/libstd/num/i8.rs
+++ b/src/libstd/num/i8.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::i8::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/int.rs b/src/libstd/num/int.rs
index 7821306f5fc..74ee61634c6 100644
--- a/src/libstd/num/int.rs
+++ b/src/libstd/num/int.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::int::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs
index 3c01edf2339..62e609bb2e1 100644
--- a/src/libstd/num/int_macros.rs
+++ b/src/libstd/num/int_macros.rs
@@ -78,7 +78,7 @@ pub fn to_str_bytes<U>(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U {
         (write!(&mut wr, "{}", ::fmt::radix(n, radix as u8))).unwrap();
         wr.tell().unwrap() as uint
     };
-    f(buf.slice(0, amt))
+    f(buf[..amt])
 }
 
 #[deprecated = "use fmt::radix"]
diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs
index b15f334e233..f97bbe0dc8e 100644
--- a/src/libstd/num/strconv.rs
+++ b/src/libstd/num/strconv.rs
@@ -730,7 +730,7 @@ pub fn from_str_bytes_common<T:NumCast+Zero+One+PartialEq+PartialOrd+Div<T,T>+
         // parse remaining bytes as decimal integer,
         // skipping the exponent char
         let exp: Option<int> = from_str_bytes_common(
-            buf.slice(i+1, len), 10, true, false, false, ExpNone, false,
+            buf[i+1..len], 10, true, false, false, ExpNone, false,
             ignore_underscores);
 
         match exp {
diff --git a/src/libstd/num/u16.rs b/src/libstd/num/u16.rs
index 0f00f99e980..c141ecc9cba 100644
--- a/src/libstd/num/u16.rs
+++ b/src/libstd/num/u16.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::u16::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/u32.rs b/src/libstd/num/u32.rs
index e6c6bc377b7..8a8e2729a53 100644
--- a/src/libstd/num/u32.rs
+++ b/src/libstd/num/u32.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::u32::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/u64.rs b/src/libstd/num/u64.rs
index 7eb9e1a082f..1b4f8bc433f 100644
--- a/src/libstd/num/u64.rs
+++ b/src/libstd/num/u64.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::u64::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/u8.rs b/src/libstd/num/u8.rs
index 300dd3bcc01..28f22429235 100644
--- a/src/libstd/num/u8.rs
+++ b/src/libstd/num/u8.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::u8::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/uint.rs b/src/libstd/num/uint.rs
index 0adc22e3214..da328074453 100644
--- a/src/libstd/num/uint.rs
+++ b/src/libstd/num/uint.rs
@@ -17,7 +17,6 @@ use from_str::FromStr;
 use num::{ToStrRadix, FromStrRadix};
 use num::strconv;
 use option::Option;
-use slice::ImmutableSlice;
 use string::String;
 
 pub use core::uint::{BITS, BYTES, MIN, MAX};
diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs
index cfcaf0fa8da..a033308af16 100644
--- a/src/libstd/num/uint_macros.rs
+++ b/src/libstd/num/uint_macros.rs
@@ -79,7 +79,7 @@ pub fn to_str_bytes<U>(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U {
         (write!(&mut wr, "{}", ::fmt::radix(n, radix as u8))).unwrap();
         wr.tell().unwrap() as uint
     };
-    f(buf.slice(0, amt))
+    f(buf[..amt])
 }
 
 #[deprecated = "use fmt::radix"]
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index d904e657e40..c6948cccafe 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -144,7 +144,7 @@ pub mod windows {
     use option::{None, Option};
     use option;
     use os::TMPBUF_SZ;
-    use slice::{MutableSlice, ImmutableSlice};
+    use slice::MutableSlice;
     use string::String;
     use str::StrSlice;
     use vec::Vec;
diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs
index 16552daae36..63c81695aff 100644
--- a/src/libstd/path/mod.rs
+++ b/src/libstd/path/mod.rs
@@ -357,7 +357,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
                 match name.rposition_elem(&dot) {
                     None | Some(0) => name,
                     Some(1) if name == b".." => name,
-                    Some(pos) => name.slice_to(pos)
+                    Some(pos) => name[..pos]
                 }
             })
         }
@@ -404,7 +404,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
                 match name.rposition_elem(&dot) {
                     None | Some(0) => None,
                     Some(1) if name == b".." => None,
-                    Some(pos) => Some(name.slice_from(pos+1))
+                    Some(pos) => Some(name[pos+1..])
                 }
             }
         }
@@ -480,7 +480,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
             let extlen = extension.container_as_bytes().len();
             match (name.rposition_elem(&dot), extlen) {
                 (None, 0) | (Some(0), 0) => None,
-                (Some(idx), 0) => Some(name.slice_to(idx).to_vec()),
+                (Some(idx), 0) => Some(name[..idx].to_vec()),
                 (idx, extlen) => {
                     let idx = match idx {
                         None | Some(0) => name.len(),
@@ -489,7 +489,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
 
                     let mut v;
                     v = Vec::with_capacity(idx + extlen + 1);
-                    v.push_all(name.slice_to(idx));
+                    v.push_all(name[..idx]);
                     v.push(dot);
                     v.push_all(extension.container_as_bytes());
                     Some(v)
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index 9c4139853c5..3043c25f761 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -165,7 +165,7 @@ impl GenericPathUnsafe for Path {
             None => {
                 self.repr = Path::normalize(filename);
             }
-            Some(idx) if self.repr.slice_from(idx+1) == b".." => {
+            Some(idx) if self.repr[idx+1..] == b".." => {
                 let mut v = Vec::with_capacity(self.repr.len() + 1 + filename.len());
                 v.push_all(self.repr.as_slice());
                 v.push(SEP_BYTE);
@@ -175,7 +175,7 @@ impl GenericPathUnsafe for Path {
             }
             Some(idx) => {
                 let mut v = Vec::with_capacity(idx + 1 + filename.len());
-                v.push_all(self.repr.slice_to(idx+1));
+                v.push_all(self.repr[..idx+1]);
                 v.push_all(filename);
                 // FIXME: this is slow
                 self.repr = Path::normalize(v.as_slice());
@@ -216,9 +216,9 @@ impl GenericPath for Path {
         match self.sepidx {
             None if b".." == self.repr.as_slice() => self.repr.as_slice(),
             None => dot_static,
-            Some(0) => self.repr.slice_to(1),
-            Some(idx) if self.repr.slice_from(idx+1) == b".." => self.repr.as_slice(),
-            Some(idx) => self.repr.slice_to(idx)
+            Some(0) => self.repr[..1],
+            Some(idx) if self.repr[idx+1..] == b".." => self.repr.as_slice(),
+            Some(idx) => self.repr[..idx]
         }
     }
 
@@ -227,9 +227,9 @@ impl GenericPath for Path {
             None if b"." == self.repr.as_slice() ||
                 b".." == self.repr.as_slice() => None,
             None => Some(self.repr.as_slice()),
-            Some(idx) if self.repr.slice_from(idx+1) == b".." => None,
-            Some(0) if self.repr.slice_from(1).is_empty() => None,
-            Some(idx) => Some(self.repr.slice_from(idx+1))
+            Some(idx) if self.repr[idx+1..] == b".." => None,
+            Some(0) if self.repr[1..].is_empty() => None,
+            Some(idx) => Some(self.repr[idx+1..])
         }
     }
 
@@ -371,7 +371,7 @@ impl Path {
         // borrowck is being very picky
         let val = {
             let is_abs = !v.as_slice().is_empty() && v.as_slice()[0] == SEP_BYTE;
-            let v_ = if is_abs { v.as_slice().slice_from(1) } else { v.as_slice() };
+            let v_ = if is_abs { v.as_slice()[1..] } else { v.as_slice() };
             let comps = normalize_helper(v_, is_abs);
             match comps {
                 None => None,
@@ -410,7 +410,7 @@ impl Path {
     /// A path of "/" yields no components. A path of "." yields one component.
     pub fn components<'a>(&'a self) -> Components<'a> {
         let v = if self.repr[0] == SEP_BYTE {
-            self.repr.slice_from(1)
+            self.repr[1..]
         } else { self.repr.as_slice() };
         let mut ret = v.split(is_sep_byte);
         if v.is_empty() {
diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs
index 33f8713e1a1..e1925fc79d0 100644
--- a/src/libstd/rt/backtrace.rs
+++ b/src/libstd/rt/backtrace.rs
@@ -999,7 +999,7 @@ mod imp {
                 let bytes = cstr.as_bytes();
                 match cstr.as_str() {
                     Some(s) => try!(super::demangle(w, s)),
-                    None => try!(w.write(bytes.slice_to(bytes.len() - 1))),
+                    None => try!(w.write(bytes[..bytes.len()-1])),
                 }
             }
             try!(w.write(['\n' as u8]));
diff --git a/src/libsyntax/ast_map/mod.rs b/src/libsyntax/ast_map/mod.rs
index a5458461a8b..257bfc632d8 100644
--- a/src/libsyntax/ast_map/mod.rs
+++ b/src/libsyntax/ast_map/mod.rs
@@ -496,7 +496,7 @@ impl<'ast> Map<'ast> {
         NodesMatchingSuffix {
             map: self,
             item_name: parts.last().unwrap(),
-            in_which: parts.slice_to(parts.len() - 1),
+            in_which: parts[..parts.len() - 1],
             idx: 0,
         }
     }
diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs
index f33c768d647..6d063aef5a9 100644
--- a/src/libsyntax/diagnostic.rs
+++ b/src/libsyntax/diagnostic.rs
@@ -414,7 +414,7 @@ fn highlight_lines(err: &mut EmitterWriter,
     let mut elided = false;
     let mut display_lines = lines.lines.as_slice();
     if display_lines.len() > MAX_LINES {
-        display_lines = display_lines.slice(0u, MAX_LINES);
+        display_lines = display_lines[0u..MAX_LINES];
         elided = true;
     }
     // Print the offending lines
diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs
index ca6d488772c..38de2a9c284 100644
--- a/src/libsyntax/feature_gate.rs
+++ b/src/libsyntax/feature_gate.rs
@@ -70,6 +70,7 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("tuple_indexing", Active),
     ("associated_types", Active),
     ("visible_private_types", Active),
+    ("slicing_syntax", Active),
 
     ("if_let", Active),
 
@@ -362,6 +363,11 @@ impl<'a, 'v> Visitor<'v> for Context<'a> {
                 self.gate_feature("if_let", e.span,
                                   "`if let` syntax is experimental");
             }
+            ast::ExprSlice(..) => {
+                self.gate_feature("slicing_syntax",
+                                  e.span,
+                                  "slicing syntax is experimental");
+            }
             _ => {}
         }
         visit::walk_expr(self, e);
diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs
index a4271544146..64dedd45923 100644
--- a/src/libsyntax/lib.rs
+++ b/src/libsyntax/lib.rs
@@ -23,7 +23,8 @@
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/master/")]
 
-#![feature(macro_rules, globs, default_type_params, phase)]
+#![allow(unknown_features)]
+#![feature(macro_rules, globs, default_type_params, phase, slicing_syntax)]
 #![feature(quote, struct_variant, unsafe_destructor, import_shadowing)]
 #![allow(deprecated)]
 
diff --git a/src/libterm/lib.rs b/src/libterm/lib.rs
index 3fc631422d5..b05e0a4bff3 100644
--- a/src/libterm/lib.rs
+++ b/src/libterm/lib.rs
@@ -49,7 +49,8 @@
        html_root_url = "http://doc.rust-lang.org/master/",
        html_playground_url = "http://play.rust-lang.org/")]
 
-#![feature(macro_rules, phase)]
+#![allow(unknown_features)]
+#![feature(macro_rules, phase, slicing_syntax)]
 
 #![deny(missing_doc)]
 
diff --git a/src/libterm/terminfo/parser/compiled.rs b/src/libterm/terminfo/parser/compiled.rs
index f59a4465e1d..6b921144144 100644
--- a/src/libterm/terminfo/parser/compiled.rs
+++ b/src/libterm/terminfo/parser/compiled.rs
@@ -285,13 +285,13 @@ pub fn parse(file: &mut io::Reader, longnames: bool)
 
 
             // Find the offset of the NUL we want to go to
-            let nulpos = string_table.slice(offset as uint, string_table_bytes as uint)
+            let nulpos = string_table[offset as uint .. string_table_bytes as uint]
                 .iter().position(|&b| b == 0);
             match nulpos {
                 Some(len) => {
                     string_map.insert(name.to_string(),
-                                      string_table.slice(offset as uint,
-                                          offset as uint + len).to_vec())
+                                      string_table[offset as uint ..
+                                          offset as uint + len].to_vec())
                 },
                 None => {
                     return Err("invalid file: missing NUL in \
diff --git a/src/test/bench/shootout-fannkuch-redux.rs b/src/test/bench/shootout-fannkuch-redux.rs
index 5e812e500d6..b4292c2b050 100644
--- a/src/test/bench/shootout-fannkuch-redux.rs
+++ b/src/test/bench/shootout-fannkuch-redux.rs
@@ -38,6 +38,8 @@
 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 // OF THE POSSIBILITY OF SUCH DAMAGE.
 
+#![feature(slicing_syntax)]
+
 use std::{cmp, iter, mem};
 use std::sync::Future;
 
@@ -50,7 +52,7 @@ fn rotate(x: &mut [i32]) {
 
 fn next_permutation(perm: &mut [i32], count: &mut [i32]) {
     for i in range(1, perm.len()) {
-        rotate(perm.slice_to_mut(i + 1));
+        rotate(perm[mut ..i + 1]);
         let count_i = &mut count[i];
         if *count_i >= i as i32 {
             *count_i = 0;
@@ -99,7 +101,7 @@ impl Perm {
             let d = idx / self.fact[i] as i32;
             self.cnt[i] = d;
             idx %= self.fact[i] as i32;
-            for (place, val) in pp.iter_mut().zip(self.perm.p.slice_to(i + 1).iter()) {
+            for (place, val) in pp.iter_mut().zip(self.perm.p[..i+1].iter()) {
                 *place = (*val) as u8
             }
 
@@ -125,7 +127,7 @@ impl Perm {
 
 
 fn reverse(tperm: &mut [i32], mut k: uint) {
-    tperm.slice_to_mut(k).reverse()
+    tperm[mut ..k].reverse()
 }
 
 fn work(mut perm: Perm, n: uint, max: uint) -> (i32, i32) {
diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs
index b68404bdd72..b8af76ce17c 100644
--- a/src/test/bench/shootout-fasta-redux.rs
+++ b/src/test/bench/shootout-fasta-redux.rs
@@ -38,6 +38,8 @@
 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 // OF THE POSSIBILITY OF SUCH DAMAGE.
 
+#![feature(slicing_syntax)]
+
 use std::cmp::min;
 use std::io::{stdout, IoResult};
 use std::os;
@@ -124,8 +126,8 @@ impl<'a, W: Writer> RepeatFasta<'a, W> {
 
         copy_memory(buf.as_mut_slice(), alu);
         let buf_len = buf.len();
-        copy_memory(buf.slice_mut(alu_len, buf_len),
-                    alu.slice_to(LINE_LEN));
+        copy_memory(buf[mut alu_len..buf_len],
+                    alu[..LINE_LEN]);
 
         let mut pos = 0;
         let mut bytes;
@@ -201,7 +203,7 @@ impl<'a, W: Writer> RandomFasta<'a, W> {
         for i in range(0u, chars_left) {
             buf[i] = self.nextc();
         }
-        self.out.write(buf.slice_to(chars_left))
+        self.out.write(buf[..chars_left])
     }
 }
 
diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
index e5ddcac1e8f..7565525bc8c 100644
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -38,6 +38,8 @@
 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 // OF THE POSSIBILITY OF SUCH DAMAGE.
 
+#![feature(slicing_syntax)]
+
 use std::io;
 use std::io::{BufferedWriter, File};
 use std::cmp::min;
@@ -93,7 +95,7 @@ fn make_fasta<W: Writer, I: Iterator<u8>>(
         }
         n -= nb;
         line[nb] = '\n' as u8;
-        wr.write(line.slice_to(nb + 1));
+        wr.write(line[..nb+1]);
     }
 }
 
diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs
index f4d1cee5fb4..86c1bd82e9f 100644
--- a/src/test/bench/shootout-k-nucleotide-pipes.rs
+++ b/src/test/bench/shootout-k-nucleotide-pipes.rs
@@ -13,6 +13,8 @@
 
 // multi tasking k-nucleotide
 
+#![feature(slicing_syntax)]
+
 extern crate collections;
 
 use std::collections::HashMap;
@@ -97,11 +99,11 @@ fn windows_with_carry(bb: &[u8], nn: uint, it: |window: &[u8]|) -> Vec<u8> {
 
    let len = bb.len();
    while ii < len - (nn - 1u) {
-      it(bb.slice(ii, ii+nn));
+      it(bb[ii..ii+nn]);
       ii += 1u;
    }
 
-   return Vec::from_slice(bb.slice(len - (nn - 1u), len));
+   return Vec::from_slice(bb[len - (nn - 1u)..len]);
 }
 
 fn make_sequence_processor(sz: uint,
diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs
index cecc95354af..8c08fc4caa1 100644
--- a/src/test/bench/shootout-k-nucleotide.rs
+++ b/src/test/bench/shootout-k-nucleotide.rs
@@ -40,6 +40,8 @@
 
 // ignore-android see #10393 #13206
 
+#![feature(slicing_syntax)]
+
 use std::string::String;
 use std::slice;
 use std::sync::{Arc, Future};
@@ -240,14 +242,14 @@ fn generate_frequencies(mut input: &[u8], frame: uint) -> Table {
     // Pull first frame.
     for _ in range(0, frame) {
         code = code.push_char(input[0]);
-        input = input.slice_from(1);
+        input = input[1..];
     }
     frequencies.lookup(code, BumpCallback);
 
     while input.len() != 0 && input[0] != ('>' as u8) {
         code = code.rotate(input[0], frame);
         frequencies.lookup(code, BumpCallback);
-        input = input.slice_from(1);
+        input = input[1..];
     }
     frequencies
 }
diff --git a/src/test/bench/shootout-regex-dna.rs b/src/test/bench/shootout-regex-dna.rs
index 0adb80c2689..dccdafe9cf8 100644
--- a/src/test/bench/shootout-regex-dna.rs
+++ b/src/test/bench/shootout-regex-dna.rs
@@ -41,7 +41,7 @@
 // ignore-stage1
 // ignore-cross-compile #12102
 
-#![feature(macro_rules, phase)]
+#![feature(macro_rules, phase, slicing_syntax)]
 
 extern crate regex;
 #[phase(plugin)]extern crate regex_macros;
diff --git a/src/test/bench/shootout-reverse-complement.rs b/src/test/bench/shootout-reverse-complement.rs
index e522bcaf4db..e3fa6334f77 100644
--- a/src/test/bench/shootout-reverse-complement.rs
+++ b/src/test/bench/shootout-reverse-complement.rs
@@ -41,6 +41,8 @@
 // ignore-pretty very bad with line comments
 // ignore-android doesn't terminate?
 
+#![feature(slicing_syntax)]
+
 use std::iter::range_step;
 use std::io::{stdin, stdout, File};
 
@@ -81,7 +83,7 @@ fn main() {
             Some(c) => c
         };
         let len = seq.len();
-        let seq = seq.slice_mut(begin + 1, len - 1);
+        let seq = seq[mut begin+1..len-1];
 
         // arrange line breaks
         let len = seq.len();
diff --git a/src/test/compile-fail/issue-15730.rs b/src/test/compile-fail/issue-15730.rs
index 6cddd8ee939..c29e74af03c 100644
--- a/src/test/compile-fail/issue-15730.rs
+++ b/src/test/compile-fail/issue-15730.rs
@@ -8,8 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(slicing_syntax)]
+
 fn main() {
     let mut array = [1, 2, 3];
 //~^ ERROR cannot determine a type for this local variable: cannot determine the type of this integ
-    let pie_slice = array.slice(1, 2);
+    let pie_slice = array[1..2];
 }
diff --git a/src/test/compile-fail/slice-2.rs b/src/test/compile-fail/slice-2.rs
index fbfc438321c..63f79c808ae 100644
--- a/src/test/compile-fail/slice-2.rs
+++ b/src/test/compile-fail/slice-2.rs
@@ -10,6 +10,8 @@
 
 // Test that slicing syntax gives errors if we have not implemented the trait.
 
+#![feature(slicing_syntax)]
+
 struct Foo;
 
 fn main() {
diff --git a/src/test/compile-fail/slice-borrow.rs b/src/test/compile-fail/slice-borrow.rs
index 3d12511134f..00783b71ea1 100644
--- a/src/test/compile-fail/slice-borrow.rs
+++ b/src/test/compile-fail/slice-borrow.rs
@@ -10,6 +10,8 @@
 
 // Test slicing expressions doesn't defeat the borrow checker.
 
+#![feature(slicing_syntax)]
+
 fn main() {
     let y;
     {
diff --git a/src/test/compile-fail/slice-mut-2.rs b/src/test/compile-fail/slice-mut-2.rs
index 1176b637cec..09019448a67 100644
--- a/src/test/compile-fail/slice-mut-2.rs
+++ b/src/test/compile-fail/slice-mut-2.rs
@@ -10,6 +10,8 @@
 
 // Test mutability and slicing syntax.
 
+#![feature(slicing_syntax)]
+
 fn main() {
     let x: &[int] = &[1, 2, 3, 4, 5];
     // Can't mutably slice an immutable slice
diff --git a/src/test/compile-fail/slice-mut.rs b/src/test/compile-fail/slice-mut.rs
index 8cd7c4ed0bb..cbfa3ed85fd 100644
--- a/src/test/compile-fail/slice-mut.rs
+++ b/src/test/compile-fail/slice-mut.rs
@@ -10,6 +10,8 @@
 
 // Test mutability and slicing syntax.
 
+#![feature(slicing_syntax)]
+
 fn main() {
     let x: &[int] = &[1, 2, 3, 4, 5];
     // Immutable slices are not mutable.
diff --git a/src/test/debuginfo/vec-slices.rs b/src/test/debuginfo/vec-slices.rs
index ba8c4d249ce..67e621fe556 100644
--- a/src/test/debuginfo/vec-slices.rs
+++ b/src/test/debuginfo/vec-slices.rs
@@ -80,6 +80,7 @@
 // lldb-check:[...]$5 = &[AStruct { x: 10, y: 11, z: 12 }, AStruct { x: 13, y: 14, z: 15 }]
 
 #![allow(unused_variable)]
+#![feature(slicing_syntax)]
 
 struct AStruct {
     x: i16,
@@ -94,7 +95,7 @@ fn main() {
     let empty: &[i64] = &[];
     let singleton: &[i64] = &[1];
     let multiple: &[i64] = &[2, 3, 4, 5];
-    let slice_of_slice = multiple.slice(1,3);
+    let slice_of_slice = multiple[1..3];
 
     let padded_tuple: &[(i32, i16)] = &[(6, 7), (8, 9)];
 
diff --git a/src/test/run-pass/issue-3888-2.rs b/src/test/run-pass/issue-3888-2.rs
index c9f6733fa25..10add853ee7 100644
--- a/src/test/run-pass/issue-3888-2.rs
+++ b/src/test/run-pass/issue-3888-2.rs
@@ -8,8 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(slicing_syntax)]
+
 fn vec_peek<'r, T>(v: &'r [T]) -> &'r [T] {
-    v.slice(1, 5)
+    v[1..5]
 }
 
 pub fn main() {}
diff --git a/src/test/run-pass/issue-4464.rs b/src/test/run-pass/issue-4464.rs
index 822fda8a18e..f2c1a715b51 100644
--- a/src/test/run-pass/issue-4464.rs
+++ b/src/test/run-pass/issue-4464.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn broken(v: &[u8], i: uint, j: uint) -> &[u8] { v.slice(i, j) }
+#![feature(slicing_syntax)]
+
+fn broken(v: &[u8], i: uint, j: uint) -> &[u8] { v[i..j] }
 
 pub fn main() {}
diff --git a/src/test/run-pass/issue-8898.rs b/src/test/run-pass/issue-8898.rs
index dea352833f0..f2dcaa4a31e 100644
--- a/src/test/run-pass/issue-8898.rs
+++ b/src/test/run-pass/issue-8898.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(slicing_syntax)]
 
 extern crate debug;
 
@@ -21,7 +22,7 @@ pub fn main() {
     let abc = [1i, 2, 3];
     let tf = [true, false];
     let x  = [(), ()];
-    let slice = x.slice(0,1);
+    let slice = x[0..1];
     let z = box(GC) x;
 
     assert_repr_eq(abc, "[1, 2, 3]".to_string());
diff --git a/src/test/run-pass/slice-2.rs b/src/test/run-pass/slice-2.rs
index 3c0933a055c..768c28cb8de 100644
--- a/src/test/run-pass/slice-2.rs
+++ b/src/test/run-pass/slice-2.rs
@@ -10,6 +10,8 @@
 
 // Test slicing expressions on slices and Vecs.
 
+#![feature(slicing_syntax)]
+
 fn main() {
     let x: &[int] = &[1, 2, 3, 4, 5];
     let cmp: &[int] = &[1, 2, 3, 4, 5];
diff --git a/src/test/run-pass/slice-fail-1.rs b/src/test/run-pass/slice-fail-1.rs
index f6972023a72..b07cf595968 100644
--- a/src/test/run-pass/slice-fail-1.rs
+++ b/src/test/run-pass/slice-fail-1.rs
@@ -10,6 +10,8 @@
 
 // Test that is a slicing expr[..] fails, the correct cleanups happen.
 
+#![feature(slicing_syntax)]
+
 use std::task;
 
 struct Foo;
diff --git a/src/test/run-pass/slice-fail-2.rs b/src/test/run-pass/slice-fail-2.rs
index cbe65fcd83d..a2aecc1d5cd 100644
--- a/src/test/run-pass/slice-fail-2.rs
+++ b/src/test/run-pass/slice-fail-2.rs
@@ -10,6 +10,8 @@
 
 // Test that is a slicing expr[..] fails, the correct cleanups happen.
 
+#![feature(slicing_syntax)]
+
 use std::task;
 
 struct Foo;
diff --git a/src/test/run-pass/slice.rs b/src/test/run-pass/slice.rs
index 39feb075add..2b4251b4089 100644
--- a/src/test/run-pass/slice.rs
+++ b/src/test/run-pass/slice.rs
@@ -10,6 +10,8 @@
 
 // Test slicing sugar.
 
+#![feature(slicing_syntax)]
+
 extern crate core;
 use core::ops::{Slice,SliceMut};
 
@@ -18,38 +20,38 @@ static mut COUNT: uint = 0;
 struct Foo;
 
 impl Slice<Foo, Foo> for Foo {
-    fn as_slice_<'a>(&'a self) -> &'a Foo {
+    fn as_slice<'a>(&'a self) -> &'a Foo {
         unsafe { COUNT += 1; }
         self
     }
-    fn slice_from_<'a>(&'a self, _from: &Foo) -> &'a Foo {
+    fn slice_from<'a>(&'a self, _from: &Foo) -> &'a Foo {
         unsafe { COUNT += 1; }
         self
     }
-    fn slice_to_<'a>(&'a self, _to: &Foo) -> &'a Foo {
+    fn slice_to<'a>(&'a self, _to: &Foo) -> &'a Foo {
         unsafe { COUNT += 1; }
         self
     }
-    fn slice_<'a>(&'a self, _from: &Foo, _to: &Foo) -> &'a Foo {
+    fn slice<'a>(&'a self, _from: &Foo, _to: &Foo) -> &'a Foo {
         unsafe { COUNT += 1; }
         self
     }
 }
 
 impl SliceMut<Foo, Foo> for Foo {
-    fn as_mut_slice_<'a>(&'a mut self) -> &'a mut Foo {
+    fn as_mut_slice<'a>(&'a mut self) -> &'a mut Foo {
         unsafe { COUNT += 1; }
         self
     }
-    fn slice_from_mut_<'a>(&'a mut self, _from: &Foo) -> &'a mut Foo {
+    fn slice_from_mut<'a>(&'a mut self, _from: &Foo) -> &'a mut Foo {
         unsafe { COUNT += 1; }
         self
     }
-    fn slice_to_mut_<'a>(&'a mut self, _to: &Foo) -> &'a mut Foo {
+    fn slice_to_mut<'a>(&'a mut self, _to: &Foo) -> &'a mut Foo {
         unsafe { COUNT += 1; }
         self
     }
-    fn slice_mut_<'a>(&'a mut self, _from: &Foo, _to: &Foo) -> &'a mut Foo {
+    fn slice_mut<'a>(&'a mut self, _from: &Foo, _to: &Foo) -> &'a mut Foo {
         unsafe { COUNT += 1; }
         self
     }