std: Remove uses of DVec

src/libstd/flatpipes.rs

@@ -452,12 +452,13 @@ pub mod flatteners {
 
     pub fn serialize_value<D: Encoder + FromWriter,
                            T: Encodable<D>>(val: &T) -> ~[u8] {
-        let bytes_writer = @BytesWriter();
+        let mut bytes_writer = BytesWriter();
-        let writer = bytes_writer as @Writer;
+        let writer = @bytes_writer as @Writer;
         let ser = FromWriter::from_writer(writer);
         val.encode(&ser);
-        let bytes = bytes_writer.bytes.check_out(|bytes| bytes);
+        let mut ret = ~[];
-        return bytes;
+        ret <-> bytes_writer.bytes;
+        return ret;
     }
 
     pub trait FromReader {

src/libstd/json.rs

@@ -27,7 +27,6 @@ use core::prelude::*;
 use core::hashmap::linear::LinearMap;
 use core::str;
 use core::to_str;
-use core::vec;
 
 /// Represents a json value
 pub enum Json {

src/libstd/sort.rs

@@ -11,7 +11,6 @@
 //! Sorting methods
 
 use core::cmp::{Eq, Ord};
-use core::dvec::DVec;
 use core::prelude::*;
 use core::util;
 use core::vec::{len, push};
@@ -189,7 +188,7 @@ pub fn tim_sort<T:Copy + Ord>(array: &mut [T]) {
         return;
     }
 
-    let ms = &MergeState();
+    let mut ms = MergeState();
     let min_run = min_run_length(size);
 
     let mut idx = 0;
@@ -392,66 +391,63 @@ struct RunState {
 }
 
 struct MergeState<T> {
-    mut min_gallop: uint,
+    min_gallop: uint,
-    runs: DVec<RunState>,
+    runs: ~[RunState],
 }
 
 // Fixme (#3853) Move into MergeState
 fn MergeState<T>() -> MergeState<T> {
     MergeState {
         min_gallop: MIN_GALLOP,
-        runs: DVec(),
+        runs: ~[],
     }
 }
 
-pub impl<T:Copy + Ord> MergeState<T> {
+impl<T:Copy + Ord> MergeState<T> {
-    fn push_run(&self, run_base: uint, run_len: uint) {
+    fn push_run(&mut self, run_base: uint, run_len: uint) {
         let tmp = RunState{base: run_base, len: run_len};
         self.runs.push(tmp);
     }
 
-    fn merge_at(&self, n: uint, array: &mut [T]) {
+    fn merge_at(&mut self, n: uint, array: &mut [T]) {
         let mut size = self.runs.len();
         fail_unless!(size >= 2);
         fail_unless!(n == size-2 || n == size-3);
 
-        do self.runs.borrow_mut |arr| {
+        let mut b1 = self.runs[n].base;
+        let mut l1 = self.runs[n].len;
+        let b2 = self.runs[n+1].base;
+        let l2 = self.runs[n+1].len;
 
-            let mut b1 = arr[n].base;
+        fail_unless!(l1 > 0 && l2 > 0);
-            let mut l1 = arr[n].len;
+        fail_unless!(b1 + l1 == b2);
-            let b2 = arr[n+1].base;
-            let l2 = arr[n+1].len;
 
-            fail_unless!(l1 > 0 && l2 > 0);
+        self.runs[n].len = l1 + l2;
-            fail_unless!(b1 + l1 == b2);
+        if n == size-3 {
+            self.runs[n+1].base = self.runs[n+2].base;
+            self.runs[n+1].len = self.runs[n+2].len;
+        }
 
-            arr[n].len = l1 + l2;
+        let slice = vec::mut_slice(array, b1, b1+l1);
-            if n == size-3 {
+        let k = gallop_right(&const array[b2], slice, 0);
-                arr[n+1].base = arr[n+2].base;
+        b1 += k;
-                arr[n+1].len = arr[n+2].len;
+        l1 -= k;
-            }
+        if l1 != 0 {
-
+            let slice = vec::mut_slice(array, b2, b2+l2);
-            let slice = vec::mut_slice(array, b1, b1+l1);
+            let l2 = gallop_left(
-            let k = gallop_right(&const array[b2], slice, 0);
+                &const array[b1+l1-1],slice,l2-1);
-            b1 += k;
+            if l2 > 0 {
-            l1 -= k;
+                if l1 <= l2 {
-            if l1 != 0 {
+                    self.merge_lo(array, b1, l1, b2, l2);
-                let slice = vec::mut_slice(array, b2, b2+l2);
+                } else {
-                let l2 = gallop_left(
+                    self.merge_hi(array, b1, l1, b2, l2);
-                    &const array[b1+l1-1],slice,l2-1);
-                if l2 > 0 {
-                    if l1 <= l2 {
-                        self.merge_lo(array, b1, l1, b2, l2);
-                    } else {
-                        self.merge_hi(array, b1, l1, b2, l2);
-                    }
                 }
             }
         }
         self.runs.pop();
     }
 
-    fn merge_lo(&self, array: &mut [T], base1: uint, len1: uint,
+    fn merge_lo(&mut self, array: &mut [T], base1: uint, len1: uint,
                 base2: uint, len2: uint) {
         fail_unless!(len1 != 0 && len2 != 0 && base1+len1 == base2);
 
@@ -554,7 +550,7 @@ pub impl<T:Copy + Ord> MergeState<T> {
         }
     }
 
-    fn merge_hi(&self, array: &mut [T], base1: uint, len1: uint,
+    fn merge_hi(&mut self, array: &mut [T], base1: uint, len1: uint,
                 base2: uint, len2: uint) {
         fail_unless!(len1 != 1 && len2 != 0 && base1 + len1 == base2);
 
@@ -672,32 +668,28 @@ pub impl<T:Copy + Ord> MergeState<T> {
         }
     }
 
-    fn merge_collapse(&self, array: &mut [T]) {
+    fn merge_collapse(&mut self, array: &mut [T]) {
         while self.runs.len() > 1 {
             let mut n = self.runs.len()-2;
-            let chk = do self.runs.borrow |arr| {
+            if n > 0 &&
-                if n > 0 && arr[n-1].len <= arr[n].len + arr[n+1].len {
+                self.runs[n-1].len <= self.runs[n].len + self.runs[n+1].len
-                    if arr[n-1].len < arr[n+1].len { n -= 1; }
+            {
-                    true
+                if self.runs[n-1].len < self.runs[n+1].len { n -= 1; }
-                } else if arr[n].len <= arr[n+1].len {
+            } else if self.runs[n].len <= self.runs[n+1].len {
-                    true
+                /* keep going */
-                } else {
+            } else {
-                    false
+                break;
-                }
+            }
-            };
-            if !chk { break; }
             self.merge_at(n, array);
         }
     }
 
-    fn merge_force_collapse(&self, array: &mut [T]) {
+    fn merge_force_collapse(&mut self, array: &mut [T]) {
         while self.runs.len() > 1 {
             let mut n = self.runs.len()-2;
             if n > 0 {
-                do self.runs.borrow |arr| {
+                if self.runs[n-1].len < self.runs[n+1].len {
-                    if arr[n-1].len < arr[n+1].len {
+                    n -= 1;
-                        n -= 1;
-                    }
                 }
             }
             self.merge_at(n, array);

src/test/run-pass/issue-5275.rs

@@ -0,0 +1,27 @@
+// 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 foo(self: &A) -> int {
+    if true {
+        fail!()
+    } else {
+        *bar(self.bar)
+    }
+}
+
+pub fn main() {}
+
+fn bar(_: &r/mut int) -> &r/int {
+    fail!()
+}
+
+struct A {
+  bar: @mut int,
+}