libcore: Change `[const T]` to `const [T]` everywhere

24 files changed, 85 insertions, 259 deletions

diff --git a/src/libcore/at_vec.rs b/src/libcore/at_vec.rs
index dbc132899d9..9a8645723a4 100644
--- a/src/libcore/at_vec.rs
+++ b/src/libcore/at_vec.rs
@@ -38,7 +38,7 @@ pub mod rustrt {
 
 /// Returns the number of elements the vector can hold without reallocating
 #[inline(always)]
-pub fn capacity<T>(v: @[const T]) -> uint {
+pub fn capacity<T>(v: @[T]) -> uint {
     unsafe {
         let repr: **raw::VecRepr =
             ::cast::reinterpret_cast(&addr_of(&v));
@@ -60,7 +60,7 @@ pub fn capacity<T>(v: @[const T]) -> uint {
  */
 #[inline(always)]
 pub fn build_sized<A>(size: uint, builder: &fn(push: &fn(v: A))) -> @[A] {
-    let mut vec: @[const A] = @[];
+    let mut vec: @[A] = @[];
     unsafe { raw::reserve(&mut vec, size); }
     builder(|+x| unsafe { raw::push(&mut vec, x) });
     return unsafe { transmute(vec) };
@@ -102,7 +102,7 @@ pub fn build_sized_opt<A>(size: Option<uint>,
 
 // Appending
 #[inline(always)]
-pub fn append<T:Copy>(lhs: @[T], rhs: &[const T]) -> @[T] {
+pub fn append<T:Copy>(lhs: @[T], rhs: &const [T]) -> @[T] {
     do build_sized(lhs.len() + rhs.len()) |push| {
         for vec::each(lhs) |x| { push(*x); }
         for uint::range(0, rhs.len()) |i| { push(rhs[i]); }
@@ -174,9 +174,9 @@ pub mod traits {
     use kinds::Copy;
     use ops::Add;
 
-    impl<T:Copy> Add<&'self [const T],@[T]> for @[T] {
+    impl<T:Copy> Add<&'self const [T],@[T]> for @[T] {
         #[inline(always)]
-        fn add(&self, rhs: & &'self [const T]) -> @[T] {
+        fn add(&self, rhs: & &'self const [T]) -> @[T] {
             append(*self, (*rhs))
         }
     }
@@ -207,13 +207,13 @@ pub mod raw {
      * the vector is actually the specified size.
      */
     #[inline(always)]
-    pub unsafe fn set_len<T>(v: @[const T], new_len: uint) {
+    pub unsafe fn set_len<T>(v: @[T], new_len: uint) {
         let repr: **VecRepr = ::cast::reinterpret_cast(&addr_of(&v));
         (**repr).unboxed.fill = new_len * sys::size_of::<T>();
     }
 
     #[inline(always)]
-    pub unsafe fn push<T>(v: &mut @[const T], initval: T) {
+    pub unsafe fn push<T>(v: &mut @[T], initval: T) {
         let repr: **VecRepr = ::cast::reinterpret_cast(&v);
         let fill = (**repr).unboxed.fill;
         if (**repr).unboxed.alloc > fill {
@@ -225,7 +225,7 @@ pub mod raw {
     }
 
     #[inline(always)] // really pretty please
-    pub unsafe fn push_fast<T>(v: &mut @[const T], initval: T) {
+    pub unsafe fn push_fast<T>(v: &mut @[T], initval: T) {
         let repr: **VecRepr = ::cast::reinterpret_cast(&v);
         let fill = (**repr).unboxed.fill;
         (**repr).unboxed.fill += sys::size_of::<T>();
@@ -234,7 +234,7 @@ pub mod raw {
         move_val_init(&mut(*p), initval);
     }
 
-    pub unsafe fn push_slow<T>(v: &mut @[const T], initval: T) {
+    pub unsafe fn push_slow<T>(v: &mut @[T], initval: T) {
         reserve_at_least(&mut *v, v.len() + 1u);
         push_fast(v, initval);
     }
@@ -250,7 +250,7 @@ pub mod raw {
      * * v - A vector
      * * n - The number of elements to reserve space for
      */
-    pub unsafe fn reserve<T>(v: &mut @[const T], n: uint) {
+    pub unsafe fn reserve<T>(v: &mut @[T], n: uint) {
         // Only make the (slow) call into the runtime if we have to
         if capacity(*v) < n {
             let ptr: **VecRepr = transmute(v);
@@ -274,7 +274,7 @@ pub mod raw {
      * * v - A vector
      * * n - The number of elements to reserve space for
      */
-    pub unsafe fn reserve_at_least<T>(v: &mut @[const T], n: uint) {
+    pub unsafe fn reserve_at_least<T>(v: &mut @[T], n: uint) {
         reserve(v, uint::next_power_of_two(n));
     }
 
diff --git a/src/libcore/flate.rs b/src/libcore/flate.rs
index 2ddf9277096..d1647ea36fd 100644
--- a/src/libcore/flate.rs
+++ b/src/libcore/flate.rs
@@ -46,7 +46,7 @@ static lz_fast : c_int = 0x1;   // LZ with only one probe
 static lz_norm : c_int = 0x80;  // LZ with 128 probes, "normal"
 static lz_best : c_int = 0xfff; // LZ with 4095 probes, "best"
 
-pub fn deflate_bytes(bytes: &[const u8]) -> ~[u8] {
+pub fn deflate_bytes(bytes: &const [u8]) -> ~[u8] {
     do vec::as_const_buf(bytes) |b, len| {
         unsafe {
             let mut outsz : size_t = 0;
@@ -64,7 +64,7 @@ pub fn deflate_bytes(bytes: &[const u8]) -> ~[u8] {
     }
 }
 
-pub fn inflate_bytes(bytes: &[const u8]) -> ~[u8] {
+pub fn inflate_bytes(bytes: &const [u8]) -> ~[u8] {
     do vec::as_const_buf(bytes) |b, len| {
         unsafe {
             let mut outsz : size_t = 0;
diff --git a/src/libcore/hash.rs b/src/libcore/hash.rs
index 1bfa0e9522d..c1e9e658df0 100644
--- a/src/libcore/hash.rs
+++ b/src/libcore/hash.rs
@@ -65,7 +65,7 @@ impl<A:Hash> HashUtil for A {
 
 /// Streaming hash-functions should implement this.
 pub trait Streaming {
-    fn input(&self, (&[const u8]));
+    fn input(&self, (&const [u8]));
     // These can be refactored some when we have default methods.
     fn result_bytes(&self) -> ~[u8];
     fn result_str(&self) -> ~str;
@@ -221,7 +221,7 @@ impl io::Writer for SipState {
 
     // Methods for io::writer
     #[inline(always)]
-    fn write(&self, msg: &[const u8]) {
+    fn write(&self, msg: &const [u8]) {
 
         let length = msg.len();
         self.length += length;
@@ -299,7 +299,7 @@ impl io::Writer for SipState {
 impl Streaming for SipState {
 
     #[inline(always)]
-    fn input(&self, buf: &[const u8]) {
+    fn input(&self, buf: &const [u8]) {
         self.write(buf);
     }
 
diff --git a/src/libcore/io.rs b/src/libcore/io.rs
index fb305560ba3..2b66fdb38ab 100644
--- a/src/libcore/io.rs
+++ b/src/libcore/io.rs
@@ -667,7 +667,7 @@ pub enum WriterType { Screen, File }
 pub trait Writer {
 
     /// Write all of the given bytes.
-    fn write(&self, v: &[const u8]);
+    fn write(&self, v: &const [u8]);
 
     /// Move the current position within the stream. The second parameter
     /// determines the position that the first parameter is relative to.
@@ -684,7 +684,7 @@ pub trait Writer {
 }
 
 impl Writer for @Writer {
-    fn write(&self, v: &[const u8]) { self.write(v) }
+    fn write(&self, v: &const [u8]) { self.write(v) }
     fn seek(&self, a: int, b: SeekStyle) { self.seek(a, b) }
     fn tell(&self) -> uint { self.tell() }
     fn flush(&self) -> int { self.flush() }
@@ -692,7 +692,7 @@ impl Writer for @Writer {
 }
 
 impl<W:Writer,C> Writer for Wrapper<W, C> {
-    fn write(&self, bs: &[const u8]) { self.base.write(bs); }
+    fn write(&self, bs: &const [u8]) { self.base.write(bs); }
     fn seek(&self, off: int, style: SeekStyle) { self.base.seek(off, style); }
     fn tell(&self) -> uint { self.base.tell() }
     fn flush(&self) -> int { self.base.flush() }
@@ -700,7 +700,7 @@ impl<W:Writer,C> Writer for Wrapper<W, C> {
 }
 
 impl Writer for *libc::FILE {
-    fn write(&self, v: &[const u8]) {
+    fn write(&self, v: &const [u8]) {
         unsafe {
             do vec::as_const_buf(v) |vbuf, len| {
                 let nout = libc::fwrite(vbuf as *c_void,
@@ -750,7 +750,7 @@ pub fn FILE_writer(f: *libc::FILE, cleanup: bool) -> @Writer {
 }
 
 impl Writer for fd_t {
-    fn write(&self, v: &[const u8]) {
+    fn write(&self, v: &const [u8]) {
         unsafe {
             let mut count = 0u;
             do vec::as_const_buf(v) |vbuf, len| {
@@ -907,8 +907,10 @@ pub fn u64_to_be_bytes<T>(n: u64, size: uint,
     }
 }
 
-pub fn u64_from_be_bytes(data: &[const u8],
-                         start: uint, size: uint) -> u64 {
+pub fn u64_from_be_bytes(data: &const [u8],
+                         start: uint,
+                         size: uint)
+                      -> u64 {
     let mut sz = size;
     fail_unless!((sz <= 8u));
     let mut val = 0_u64;
@@ -1140,7 +1142,7 @@ pub struct BytesWriter {
 }
 
 impl Writer for BytesWriter {
-    fn write(&self, v: &[const u8]) {
+    fn write(&self, v: &const [u8]) {
         let v_len = v.len();
         let bytes_len = vec::uniq_len(&const self.bytes);
 
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index 0f393dee597..4539b373e70 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -44,7 +44,7 @@ Section: Creating a string
  *
  * Fails if invalid UTF-8
  */
-pub fn from_bytes(vv: &[const u8]) -> ~str {
+pub fn from_bytes(vv: &const [u8]) -> ~str {
     fail_unless!(is_utf8(vv));
     return unsafe { raw::from_bytes(vv) };
 }
@@ -1552,7 +1552,7 @@ Section: Misc
 */
 
 /// Determines if a vector of bytes contains valid UTF-8
-pub fn is_utf8(v: &[const u8]) -> bool {
+pub fn is_utf8(v: &const [u8]) -> bool {
     let mut i = 0u;
     let total = vec::len::<u8>(v);
     while i < total {
@@ -2099,7 +2099,7 @@ pub mod raw {
     }
 
     /// Converts a vector of bytes to a string.
-    pub unsafe fn from_bytes(v: &[const u8]) -> ~str {
+    pub unsafe fn from_bytes(v: &const [u8]) -> ~str {
         do vec::as_const_buf(v) |buf, len| {
             from_buf_len(buf, len)
         }
diff --git a/src/libcore/to_bytes.rs b/src/libcore/to_bytes.rs
index f379878c8eb..32b123979cd 100644
--- a/src/libcore/to_bytes.rs
+++ b/src/libcore/to_bytes.rs
@@ -19,7 +19,7 @@ use io::Writer;
 use option::{None, Option, Some};
 use str;
 
-pub type Cb = &'self fn(buf: &[const u8]) -> bool;
+pub type Cb = &'self fn(buf: &const [u8]) -> bool;
 
 /**
  * A trait to implement in order to make a type hashable;
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index 5c976756d13..afacffb92c9 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -47,12 +47,12 @@ pub mod rustrt {
 }
 
 /// Returns true if a vector contains no elements
-pub fn is_empty<T>(v: &[const T]) -> bool {
+pub fn is_empty<T>(v: &const [T]) -> bool {
     as_const_buf(v, |_p, len| len == 0u)
 }
 
 /// Returns true if two vectors have the same length
-pub fn same_length<T, U>(xs: &[const T], ys: &[const U]) -> bool {
+pub fn same_length<T, U>(xs: &const [T], ys: &const [U]) -> bool {
     xs.len() == ys.len()
 }
 
@@ -114,7 +114,7 @@ pub fn capacity<T>(v: &const ~[T]) -> uint {
 
 /// Returns the length of a vector
 #[inline(always)]
-pub fn len<T>(v: &[const T]) -> uint {
+pub fn len<T>(v: &const [T]) -> uint {
     as_const_buf(v, |_p, len| len)
 }
 
@@ -292,8 +292,8 @@ pub fn mut_slice<T>(v: &'r mut [T], start: uint, end: uint) -> &'r mut [T] {
 
 /// Return a slice that points into another slice.
 #[inline(always)]
-pub fn const_slice<T>(v: &'r [const T], start: uint, end: uint)
-                   -> &'r [const T] {
+pub fn const_slice<T>(v: &'r const [T], start: uint, end: uint)
+                   -> &'r const [T] {
     fail_unless!(start <= end);
     fail_unless!(end <= len(v));
     do as_const_buf(v) |p, _len| {
@@ -624,7 +624,7 @@ fn push_slow<T>(v: &mut ~[T], initval: T) {
 }
 
 #[inline(always)]
-pub fn push_all<T:Copy>(v: &mut ~[T], rhs: &[const T]) {
+pub fn push_all<T:Copy>(v: &mut ~[T], rhs: &const [T]) {
     let new_len = v.len() + rhs.len();
     reserve(&mut *v, new_len);
 
@@ -708,7 +708,7 @@ pub fn dedup<T:Eq>(v: &mut ~[T]) {
 
 // Appending
 #[inline(always)]
-pub fn append<T:Copy>(lhs: ~[T], rhs: &[const T]) -> ~[T] {
+pub fn append<T:Copy>(lhs: ~[T], rhs: &const [T]) -> ~[T] {
     let mut v = lhs;
     unsafe {
         v.push_all(rhs);
@@ -1242,7 +1242,7 @@ pub fn unzip<T,U>(v: ~[(T, U)]) -> (~[T], ~[U]) {
 /**
  * Convert two vectors to a vector of pairs, by reference. As zip().
  */
-pub fn zip_slice<T:Copy,U:Copy>(v: &[const T], u: &[const U])
+pub fn zip_slice<T:Copy,U:Copy>(v: &const [T], u: &const [U])
         -> ~[(T, U)] {
     let mut zipped = ~[];
     let sz = len(v);
@@ -1293,7 +1293,7 @@ pub fn reverse<T>(v: &mut [T]) {
 }
 
 /// Returns a vector with the order of elements reversed
-pub fn reversed<T:Copy>(v: &[const T]) -> ~[T] {
+pub fn reversed<T:Copy>(v: &const [T]) -> ~[T] {
     let mut rs: ~[T] = ~[];
     let mut i = len::<T>(v);
     if i == 0 { return (rs); } else { i -= 1; }
@@ -1345,7 +1345,7 @@ pub fn reversed<T:Copy>(v: &[const T]) -> ~[T] {
 #[inline(always)]
 pub fn each<T>(v: &'r [T], f: &fn(&'r T) -> bool) {
     //             ^^^^
-    // NB---this CANNOT be &[const T]!  The reason
+    // NB---this CANNOT be &const [T]!  The reason
     // is that you are passing it to `f()` using
     // an immutable.
 
@@ -1381,7 +1381,7 @@ pub fn each_mut<T>(v: &'r mut [T], f: &fn(elem: &'r mut T) -> bool) {
 /// Like `each()`, but for the case where you have a vector that *may or may
 /// not* have mutable contents.
 #[inline(always)]
-pub fn each_const<T>(v: &[const T], f: &fn(elem: &const T) -> bool) {
+pub fn each_const<T>(v: &const [T], f: &fn(elem: &const T) -> bool) {
     let mut i = 0;
     let n = v.len();
     while i < n {
@@ -1508,7 +1508,7 @@ pub fn as_imm_buf<T,U>(s: &[T],
                        /* NB---this CANNOT be const, see below */
                        f: &fn(*T, uint) -> U) -> U {
 
-    // NB---Do not change the type of s to `&[const T]`.  This is
+    // NB---Do not change the type of s to `&const [T]`.  This is
     // unsound.  The reason is that we are going to create immutable pointers
     // into `s` and pass them to `f()`, but in fact they are potentially
     // pointing at *mutable memory*.  Use `as_const_buf` or `as_mut_buf`
@@ -1524,7 +1524,7 @@ pub fn as_imm_buf<T,U>(s: &[T],
 
 /// Similar to `as_imm_buf` but passing a `*const T`
 #[inline(always)]
-pub fn as_const_buf<T,U>(s: &[const T], f: &fn(*const T, uint) -> U) -> U {
+pub fn as_const_buf<T,U>(s: &const [T], f: &fn(*const T, uint) -> U) -> U {
     unsafe {
         let v : *(*const T,uint) =
             ::cast::reinterpret_cast(&addr_of(&s));
@@ -1685,15 +1685,15 @@ pub mod traits {
     use ops::Add;
     use vec::append;
 
-    impl<T:Copy> Add<&'self [const T],~[T]> for ~[T] {
+    impl<T:Copy> Add<&'self const [T],~[T]> for ~[T] {
         #[inline(always)]
-        fn add(&self, rhs: & &'self [const T]) -> ~[T] {
+        fn add(&self, rhs: & &'self const [T]) -> ~[T] {
             append(copy *self, (*rhs))
         }
     }
 }
 
-impl<T> Container for &'self [const T] {
+impl<T> Container for &'self const [T] {
     /// Returns true if a vector contains no elements
     #[inline]
     fn is_empty(&const self) -> bool { is_empty(*self) }
@@ -1708,7 +1708,7 @@ pub trait CopyableVector<T> {
 }
 
 /// Extension methods for vectors
-impl<T: Copy> CopyableVector<T> for &'self [const T] {
+impl<T: Copy> CopyableVector<T> for &'self const [T] {
     /// Returns a copy of `v`.
     #[inline]
     fn to_owned(&self) -> ~[T] {
@@ -2041,14 +2041,14 @@ impl<T> Mutable for ~[T] {
 }
 
 pub trait OwnedCopyableVector<T:Copy> {
-    fn push_all(&mut self, rhs: &[const T]);
+    fn push_all(&mut self, rhs: &const [T]);
     fn grow(&mut self, n: uint, initval: &T);
     fn grow_set(&mut self, index: uint, initval: &T, val: T);
 }
 
 impl<T:Copy> OwnedCopyableVector<T> for ~[T] {
     #[inline]
-    fn push_all(&mut self, rhs: &[const T]) {
+    fn push_all(&mut self, rhs: &const [T]) {
         push_all(self, rhs);
     }
 
@@ -2146,7 +2146,7 @@ pub mod raw {
 
     /** see `to_ptr()` */
     #[inline(always)]
-    pub unsafe fn to_const_ptr<T>(v: &[const T]) -> *const T {
+    pub unsafe fn to_const_ptr<T>(v: &const [T]) -> *const T {
         let repr: **SliceRepr = ::cast::transmute(&v);
         ::cast::reinterpret_cast(&addr_of(&((**repr).data)))
     }
@@ -2190,7 +2190,7 @@ pub mod raw {
      * Unchecked vector indexing.
      */
     #[inline(always)]
-    pub unsafe fn get<T:Copy>(v: &[const T], i: uint) -> T {
+    pub unsafe fn get<T:Copy>(v: &const [T], i: uint) -> T {
         as_const_buf(v, |p, _len| *ptr::const_offset(p, i))
     }
 
@@ -2234,7 +2234,7 @@ pub mod raw {
       * may overlap.
       */
     #[inline(always)]
-    pub unsafe fn copy_memory<T>(dst: &mut [T], src: &[const T],
+    pub unsafe fn copy_memory<T>(dst: &mut [T], src: &const [T],
                                  count: uint) {
         fail_unless!(dst.len() >= count);
         fail_unless!(src.len() >= count);
@@ -2300,7 +2300,7 @@ pub mod bytes {
       * may overlap.
       */
     #[inline(always)]
-    pub fn copy_memory(dst: &mut [u8], src: &[const u8], count: uint) {
+    pub fn copy_memory(dst: &mut [u8], src: &const [u8], count: uint) {
         // Bound checks are done at vec::raw::copy_memory.
         unsafe { vec::raw::copy_memory(dst, src, count) }
     }
diff --git a/src/libstd/arena.rs b/src/libstd/arena.rs
index a26132d92ca..683e4a62975 100644
--- a/src/libstd/arena.rs
+++ b/src/libstd/arena.rs
@@ -101,7 +101,7 @@ impl Drop for Arena {
 }
 
 fn chunk(size: uint, is_pod: bool) -> Chunk {
-    let mut v: @[const u8] = @[];
+    let mut v: @[u8] = @[];
     unsafe { at_vec::raw::reserve(&mut v, size); }
     Chunk {
         data: unsafe { cast::transmute(v) },
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index c49f65d0f99..c1743c98c9b 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -972,7 +972,7 @@ impl io::Reader for TcpSocketBuf {
 
 /// Implementation of `io::Reader` trait for a buffered `net::tcp::TcpSocket`
 impl io::Writer for TcpSocketBuf {
-    pub fn write(&self, data: &[const u8]) {
+    pub fn write(&self, data: &const [u8]) {
         unsafe {
             let socket_data_ptr =
                 ptr::addr_of(&(*((*(self.data)).sock).socket_data));
diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs
index 64399defd54..b603e2eb1cc 100644
--- a/src/libstd/sha1.rs
+++ b/src/libstd/sha1.rs
@@ -35,7 +35,7 @@ use core::vec;
 /// The SHA-1 interface
 trait Sha1 {
     /// Provide message input as bytes
-    fn input(&mut self, &[const u8]);
+    fn input(&mut self, &const [u8]);
     /// Provide message input as string
     fn input_str(&mut self, &str);
     /**
@@ -73,7 +73,7 @@ pub fn sha1() -> @Sha1 {
           computed: bool,
           work_buf: @mut ~[u32]};
 
-    fn add_input(st: &mut Sha1State, msg: &[const u8]) {
+    fn add_input(st: &mut Sha1State, msg: &const [u8]) {
         fail_unless!((!st.computed));
         for vec::each_const(msg) |element| {
             st.msg_block[st.msg_block_idx] = *element;
@@ -241,7 +241,7 @@ pub fn sha1() -> @Sha1 {
             self.h[4] = 0xC3D2E1F0u32;
             self.computed = false;
         }
-        fn input(&mut self, msg: &[const u8]) { add_input(self, msg); }
+        fn input(&mut self, msg: &const [u8]) { add_input(self, msg); }
         fn input_str(&mut self, msg: &str) {
             let bs = str::to_bytes(msg);
             add_input(self, bs);
diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs
index 8a239e8b6d8..2d83c4bd9d0 100644
--- a/src/libstd/sort.rs
+++ b/src/libstd/sort.rs
@@ -24,12 +24,12 @@ type Le<T> = &'self fn(v1: &T, v2: &T) -> bool;
  * Has worst case O(n log n) performance, best case O(n), but
  * is not space efficient. This is a stable sort.
  */
-pub fn merge_sort<T:Copy>(v: &[const T], le: Le<T>) -> ~[T] {
+pub fn merge_sort<T:Copy>(v: &const [T], le: Le<T>) -> ~[T] {
     type Slice = (uint, uint);
 
     unsafe {return merge_sort_(v, (0u, len(v)), le);}
 
-    fn merge_sort_<T:Copy>(v: &[const T], slice: Slice, le: Le<T>)
+    fn merge_sort_<T:Copy>(v: &const [T], slice: Slice, le: Le<T>)
         -> ~[T] {
         let begin = slice.first();
         let end = slice.second();
@@ -290,8 +290,10 @@ fn count_run_ascending<T:Copy + Ord>(array: &mut [T]) -> uint {
     return run;
 }
 
-fn gallop_left<T:Copy + Ord>(key: &const T, array: &[const T],
-                            hint: uint) -> uint {
+fn gallop_left<T:Copy + Ord>(key: &const T,
+                             array: &const [T],
+                             hint: uint)
+                          -> uint {
     let size = array.len();
     fail_unless!(size != 0 && hint < size);
 
@@ -339,8 +341,10 @@ fn gallop_left<T:Copy + Ord>(key: &const T, array: &[const T],
     return ofs;
 }
 
-fn gallop_right<T:Copy + Ord>(key: &const T, array: &[const T],
-                            hint: uint) -> uint {
+fn gallop_right<T:Copy + Ord>(key: &const T,
+                              array: &const [T],
+                              hint: uint)
+                           -> uint {
     let size = array.len();
     fail_unless!(size != 0 && hint < size);
 
@@ -709,8 +713,11 @@ impl<T:Copy + Ord> MergeState<T> {
 }
 
 #[inline(always)]
-fn copy_vec<T:Copy>(dest: &mut [T], s1: uint,
-                    from: &[const T], s2: uint, len: uint) {
+fn copy_vec<T:Copy>(dest: &mut [T],
+                    s1: uint,
+                    from: &const [T],
+                    s2: uint,
+                    len: uint) {
     fail_unless!(s1+len <= dest.len() && s2+len <= from.len());
 
     let mut slice = ~[];
@@ -1022,7 +1029,7 @@ mod big_tests {
         tabulate_managed(low, high);
     }
 
-    fn multiplyVec<T:Copy>(arr: &[const T], num: uint) -> ~[T] {
+    fn multiplyVec<T:Copy>(arr: &const [T], num: uint) -> ~[T] {
         let size = arr.len();
         let res = do vec::from_fn(num) |i| {
             arr[i % size]
@@ -1038,7 +1045,7 @@ mod big_tests {
     }
 
     fn tabulate_unique(lo: uint, hi: uint) {
-        fn isSorted<T:Ord>(arr: &[const T]) {
+        fn isSorted<T:Ord>(arr: &const [T]) {
             for uint::range(0, arr.len()-1) |i| {
                 if arr[i] > arr[i+1] {
                     fail!(~"Array not sorted");
@@ -1110,7 +1117,7 @@ mod big_tests {
     }
 
     fn tabulate_managed(lo: uint, hi: uint) {
-        fn isSorted<T:Ord>(arr: &[const @T]) {
+        fn isSorted<T:Ord>(arr: &const [@T]) {
             for uint::range(0, arr.len()-1) |i| {
                 if arr[i] > arr[i+1] {
                     fail!(~"Array not sorted");
diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs
index ada5ff7be2f..1764ef48412 100644
--- a/src/test/bench/shootout-mandelbrot.rs
+++ b/src/test/bench/shootout-mandelbrot.rs
@@ -101,7 +101,7 @@ fn chanmb(i: uint, size: uint, depth: uint) -> Line
 struct Devnull();
 
 impl io::Writer for Devnull {
-    fn write(&self, _b: &[const u8]) {}
+    fn write(&self, _b: &const [u8]) {}
     fn seek(&self, _i: int, _s: io::SeekStyle) {}
     fn tell(&self) -> uint {0_u}
     fn flush(&self) -> int {0}
diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs
index 2b9a030fdf4..6e39b755b22 100644
--- a/src/test/bench/shootout-spectralnorm.rs
+++ b/src/test/bench/shootout-spectralnorm.rs
@@ -16,7 +16,7 @@ fn eval_A(i: uint, j: uint) -> float {
     1.0/(((i+j)*(i+j+1u)/2u+i+1u) as float)
 }
 
-fn eval_A_times_u(u: &[const float], Au: &mut [float]) {
+fn eval_A_times_u(u: &const [float], Au: &mut [float]) {
     let N = vec::len(u);
     let mut i = 0u;
     while i < N {
@@ -30,7 +30,7 @@ fn eval_A_times_u(u: &[const float], Au: &mut [float]) {
     }
 }
 
-fn eval_At_times_u(u: &[const float], Au: &mut [float]) {
+fn eval_At_times_u(u: &const [float], Au: &mut [float]) {
     let N = vec::len(u);
     let mut i = 0u;
     while i < N {
@@ -44,7 +44,7 @@ fn eval_At_times_u(u: &[const float], Au: &mut [float]) {
     }
 }
 
-fn eval_AtA_times_u(u: &[const float], AtAu: &mut [float]) {
+fn eval_AtA_times_u(u: &const [float], AtAu: &mut [float]) {
     let mut v = vec::from_elem(vec::len(u), 0.0);
     eval_A_times_u(u, v);
     eval_At_times_u(v, AtAu);
diff --git a/src/test/compile-fail/issue-2150.rs b/src/test/compile-fail/issue-2150.rs
index 3ab8f765ad5..9f2f9a855ed 100644
--- a/src/test/compile-fail/issue-2150.rs
+++ b/src/test/compile-fail/issue-2150.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn fail_len(v: ~[const int]) -> uint {
+fn fail_len(v: ~[int]) -> uint {
     let mut i = fail!();
     for v.each |x| { i += 1u; }
     //~^ WARNING unreachable statement
diff --git a/src/test/compile-fail/mutable-huh-vec-assign.rs b/src/test/compile-fail/mutable-huh-vec-assign.rs
deleted file mode 100644
index 83cfd240356..00000000000
--- a/src/test/compile-fail/mutable-huh-vec-assign.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn main() {
-    fn f(&&v: ~[const int]) {
-        // This shouldn't be possible
-        v[0] = 1 //~ ERROR assigning to const vec content
-    }
-
-    let v = ~[0];
-
-    f(v);
-}
diff --git a/src/test/compile-fail/tag-that-dare-not-speak-its-name.rs b/src/test/compile-fail/tag-that-dare-not-speak-its-name.rs
index a05d6a324de..af99c0e5f29 100644
--- a/src/test/compile-fail/tag-that-dare-not-speak-its-name.rs
+++ b/src/test/compile-fail/tag-that-dare-not-speak-its-name.rs
@@ -15,7 +15,7 @@
 
 extern mod core;
 
-fn last<T>(v: ~[const &T]) -> core::Option<T> {
+fn last<T>(v: ~[&T]) -> core::Option<T> {
     fail!();
 }
 
diff --git a/src/test/compile-fail/vec-add.rs b/src/test/compile-fail/vec-add.rs
index 0f51d34fc2f..f30a050211e 100644
--- a/src/test/compile-fail/vec-add.rs
+++ b/src/test/compile-fail/vec-add.rs
@@ -14,7 +14,7 @@
 // the right hand side in all cases. We are getting compiler errors
 // about this now, so I'm xfailing the test for now. -eholk
 
-fn add(i: ~[int], mut m: ~[int], c: ~[const int]) {
+fn add(i: ~[int], mut m: ~[int]) {
 
     // Check that:
     //  (1) vectors of any two mutabilities can be added
@@ -36,10 +36,6 @@ fn add(i: ~[int], mut m: ~[int], c: ~[const int]) {
        m + m,
        m);
 
-   add(i + c,
-       m + c,
-       c);
-
    add(m + ~[3], //~ ERROR mismatched types
        m + ~[3],
        m + ~[3]);
@@ -48,12 +44,6 @@ fn add(i: ~[int], mut m: ~[int], c: ~[const int]) {
        i + ~[3], //~ ERROR mismatched types
        i + ~[3]);
 
-   add(c + ~[3], //~ ERROR mismatched types
-                //~^ ERROR binary operation + cannot be applied
-       c + ~[3], //~ ERROR binary operation + cannot be applied
-                //~^ mismatched types
-       ~[3]);
-
    add(m + ~[3], //~ ERROR mismatched types
        m + ~[3],
        m + ~[3]);
@@ -62,12 +52,6 @@ fn add(i: ~[int], mut m: ~[int], c: ~[const int]) {
        i + ~[3], //~ ERROR mismatched types
        i + ~[3]);
 
-   add(c + ~[3], //~ ERROR binary operation + cannot be applied
-                    //~^ mismatched types
-       c + ~[3], //~ ERROR binary operation + cannot be applied
-                    //~^ mismatched types
-       ~[3]);
-
    add(m + i, //~ ERROR mismatched types
        m + i,
        m + i);
@@ -76,12 +60,6 @@ fn add(i: ~[int], mut m: ~[int], c: ~[const int]) {
        i + i, //~ ERROR mismatched types
        i + i);
 
-   add(c + i, //~ ERROR binary operation + cannot be applied
-              //~^ ERROR mismatched types
-       c + i, //~ ERROR binary operation + cannot be applied
-              //~^ ERROR mismatched types
-       i);
-
    add(m + m, //~ ERROR mismatched types
        m + m,
        m + m);
@@ -89,26 +67,6 @@ fn add(i: ~[int], mut m: ~[int], c: ~[const int]) {
    add(i + m,
        i + m, //~ ERROR mismatched types
        i + m);
-
-   add(c + m, //~ ERROR binary operation + cannot be applied
-              //~^ ERROR mismatched types
-       c + m, //~ ERROR binary operation + cannot be applied
-              //~^ ERROR mismatched types
-       m);
-
-   add(m + c, //~ ERROR mismatched types
-       m + c,
-       m + c);
-
-   add(i + c,
-       i + c, //~ ERROR mismatched types
-       i + c);
-
-   add(c + c, //~ ERROR binary operation + cannot be applied
-              //~^ ERROR mismatched types
-       c + c, //~ ERROR binary operation + cannot be applied
-              //~^ ERROR mismatched types
-       c);
 }
 
 fn main() {
diff --git a/src/test/compile-fail/vec-concat-bug.rs b/src/test/compile-fail/vec-concat-bug.rs
deleted file mode 100644
index 478e01ccd04..00000000000
--- a/src/test/compile-fail/vec-concat-bug.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn concat<T:Copy>(v: ~[const ~[const T]]) -> ~[T] {
-    let mut r = ~[];
-
-    // Earlier versions of our type checker accepted this:
-    vec::each(v, |inner: &~[T]| {
-        //~^ ERROR values differ in mutability
-        r += *inner; true
-    });
-
-    return r;
-}
-
-fn main() {}
diff --git a/src/test/run-pass/coerce-reborrow-imm-vec-arg.rs b/src/test/run-pass/coerce-reborrow-imm-vec-arg.rs
index ad5eb50ccef..3f12c0d6353 100644
--- a/src/test/run-pass/coerce-reborrow-imm-vec-arg.rs
+++ b/src/test/run-pass/coerce-reborrow-imm-vec-arg.rs
@@ -14,7 +14,7 @@ fn sum_imm(y: &[int]) -> int {
     sum(y)
 }
 
-fn sum_const(y: &[const int]) -> int {
+fn sum_const(y: &const [int]) -> int {
     sum(y)
 }
 
diff --git a/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs b/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs
index bf86472d900..7dcf49ef1ac 100644
--- a/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs
+++ b/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs
@@ -1,6 +1,6 @@
 // xfail-test
 
-fn foo(v: &[const uint]) -> ~[uint] {
+fn foo(v: &const [uint]) -> ~[uint] {
     v.to_vec()
 }
 
diff --git a/src/test/run-pass/impl-variance.rs b/src/test/run-pass/impl-variance.rs
deleted file mode 100644
index 31375edb5de..00000000000
--- a/src/test/run-pass/impl-variance.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-trait foo {
-    fn foo(&self) -> uint;
-}
-
-impl<T> foo for ~[const T] {
-    fn foo(&self) -> uint { vec::len(*self) }
-}
-
-pub fn main() {
-    let v = ~[const 0];
-    fail_unless!(v.foo() == 1u);
-    let v = ~[0];
-    fail_unless!(v.foo() == 1u);
-    let mut v = ~[0];
-    fail_unless!(v.foo() == 1u);
-}
diff --git a/src/test/run-pass/maybe-mutable.rs b/src/test/run-pass/maybe-mutable.rs
deleted file mode 100644
index 155046bcccc..00000000000
--- a/src/test/run-pass/maybe-mutable.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-
-
-
-// -*- rust -*-
-fn len(v: ~[const int]) -> uint {
-    let mut i = 0u;
-    while i < vec::len(v) { i += 1u; }
-    return i;
-}
-
-pub fn main() {
-    let v0 = ~[1, 2, 3, 4, 5];
-    debug!(len(v0));
-    let mut v1 = ~[1, 2, 3, 4, 5];
-    debug!(len(v1));
-}
diff --git a/src/test/run-pass/mutable-huh-variance-vec1.rs b/src/test/run-pass/mutable-huh-variance-vec1.rs
deleted file mode 100644
index 8db2705de2b..00000000000
--- a/src/test/run-pass/mutable-huh-variance-vec1.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// error-pattern: mismatched types
-
-pub fn main() {
-    let v = ~[~[0]];
-
-    // This is ok because the outer vec is covariant with respect
-    // to the inner vec. If the outer vec was mut then we
-    // couldn't do this.
-    fn f(&&v: ~[~[const int]]) {
-    }
-
-    f(v);
-}
diff --git a/src/test/run-pass/mutable-huh-variance-vec2.rs b/src/test/run-pass/mutable-huh-variance-vec2.rs
deleted file mode 100644
index 7c48744000d..00000000000
--- a/src/test/run-pass/mutable-huh-variance-vec2.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// error-pattern: mismatched types
-
-pub fn main() {
-    let v = ~[~[0]];
-
-    // This is ok because the outer vec is covariant with respect
-    // to the inner vec. If the outer vec was mut then we
-    // couldn't do this.
-    fn f(&&v: ~[const ~[const int]]) {
-    }
-
-    f(v);
-}