---

yaml
---
r: 147261
b: refs/heads/try2
c: ae66285
h: refs/heads/master
i:
  147259: ccc35e9
v: v3

Author: michaelwoerister

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 7b424974531b0ade62e6a26cce038abf5dac0723
+refs/heads/try2: ae6628573282855a9b93de266add64c69411b0b0
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/librustc/middle/dead.rs

@@ -107,8 +107,6 @@ impl MarkSymbolVisitor {
                 match item.node {
                     ast::item_fn(..)
                     | ast::item_ty(..)
-                    | ast::item_enum(..)
-                    | ast::item_struct(..)
                     | ast::item_static(..) => {
                         visit::walk_item(self, item, ());
                     }

branches/try2/src/librustc/middle/trans/debuginfo.rs

@@ -2128,7 +2128,8 @@ fn set_debug_location(cx: &mut CrateContext, debug_location: DebugLocation) {
     let metadata_node;
 
     match debug_location {
-        KnownLocation { scope, line, col } => {
+        KnownLocation { scope, line, .. } => {
+            let col = 0; // Always set the column to zero like Clang and GCC
             debug!("setting debug location to {} {}", line, col);
             let elements = [C_i32(line as i32), C_i32(col as i32), scope, ptr::null()];
             unsafe {

branches/try2/src/libstd/hashmap.rs

@@ -157,7 +157,8 @@ impl<K:Hash + Eq,V> HashMap<K, V> {
                                   vec::from_fn(new_capacity, |_| None));
 
         self.size = 0;
-        for bucket in old_buckets.move_iter() {
+        // move_rev_iter is more efficient
+        for bucket in old_buckets.move_rev_iter() {
             self.insert_opt_bucket(bucket);
         }
     }
@@ -476,7 +477,8 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
     /// pair out of the map in arbitrary order. The map cannot be used after
     /// calling this.
     pub fn move_iter(self) -> HashMapMoveIterator<K, V> {
-        HashMapMoveIterator {iter: self.buckets.move_iter()}
+        // `move_rev_iter` is more efficient than `move_iter` for vectors
+        HashMapMoveIterator {iter: self.buckets.move_rev_iter()}
     }
 }
 
@@ -530,7 +532,7 @@ pub struct HashMapMutIterator<'a, K, V> {
 
 /// HashMap move iterator
 pub struct HashMapMoveIterator<K, V> {
-    priv iter: vec::MoveIterator<Option<Bucket<K, V>>>,
+    priv iter: vec::MoveRevIterator<Option<Bucket<K, V>>>,
 }
 
 /// HashSet iterator
@@ -541,7 +543,7 @@ pub struct HashSetIterator<'a, K> {
 
 /// HashSet move iterator
 pub struct HashSetMoveIterator<K> {
-    priv iter: vec::MoveIterator<Option<Bucket<K, ()>>>,
+    priv iter: vec::MoveRevIterator<Option<Bucket<K, ()>>>,
 }
 
 impl<'a, K, V> Iterator<(&'a K, &'a V)> for HashMapIterator<'a, K, V> {
@@ -727,7 +729,8 @@ impl<T:Hash + Eq> HashSet<T> {
     /// of the set in arbitrary order. The set cannot be used after calling
     /// this.
     pub fn move_iter(self) -> HashSetMoveIterator<T> {
-        HashSetMoveIterator {iter: self.map.buckets.move_iter()}
+        // `move_rev_iter` is more efficient than `move_iter` for vectors
+        HashSetMoveIterator {iter: self.map.buckets.move_rev_iter()}
     }
 
     /// Visit the values representing the difference

branches/try2/src/libstd/vec.rs

@@ -102,21 +102,20 @@ There are a number of free functions that create or take vectors, for example:
 #[warn(non_camel_case_types)];
 
 use cast;
-use ops::Drop;
 use clone::{Clone, DeepClone};
 use container::{Container, Mutable};
 use cmp::{Eq, TotalOrd, Ordering, Less, Equal, Greater};
 use cmp;
 use default::Default;
 use iter::*;
-use libc::{c_char, c_void};
+use libc::c_void;
 use num::{Integer, CheckedAdd, Saturating};
 use option::{None, Option, Some};
 use ptr::to_unsafe_ptr;
 use ptr;
 use ptr::RawPtr;
-use rt::global_heap::{malloc_raw, realloc_raw, exchange_free};
-use rt::local_heap::local_free;
+use rt::global_heap::malloc_raw;
+use rt::global_heap::realloc_raw;
 use mem;
 use mem::size_of;
 use uint;
@@ -1326,6 +1325,9 @@ pub trait OwnedVector<T> {
     /// value out of the vector (from start to end). The vector cannot
     /// be used after calling this.
     ///
+    /// Note that this performs O(n) swaps, and so `move_rev_iter`
+    /// (which just calls `pop` repeatedly) is more efficient.
+    ///
     /// # Examples
     ///
     /// ```rust
@@ -1337,7 +1339,8 @@ pub trait OwnedVector<T> {
     /// ```
     fn move_iter(self) -> MoveIterator<T>;
     /// Creates a consuming iterator that moves out of the vector in
-    /// reverse order.
+    /// reverse order. Also see `move_iter`, however note that this
+    /// is more efficient.
     fn move_rev_iter(self) -> MoveRevIterator<T>;
 
     /**
@@ -1466,18 +1469,11 @@ pub trait OwnedVector<T> {
 }
 
 impl<T> OwnedVector<T> for ~[T] {
-    #[inline]
     fn move_iter(self) -> MoveIterator<T> {
-        unsafe {
-            let iter = cast::transmute(self.iter());
-            let ptr = cast::transmute(self);
-            MoveIterator { allocation: ptr, iter: iter }
-        }
+        MoveIterator { v: self, idx: 0 }
     }
-
-    #[inline]
     fn move_rev_iter(self) -> MoveRevIterator<T> {
-        self.move_iter().invert()
+        MoveRevIterator { v: self }
     }
 
     fn reserve(&mut self, n: uint) {
@@ -2664,54 +2660,58 @@ impl<'a, T> DoubleEndedIterator<&'a mut [T]> for MutChunkIter<'a, T> {
 }
 
 /// An iterator that moves out of a vector.
+#[deriving(Clone)]
 pub struct MoveIterator<T> {
-    priv allocation: *mut u8, // the block of memory allocated for the vector
-    priv iter: VecIterator<'static, T>
+    priv v: ~[T],
+    priv idx: uint,
 }
 
 impl<T> Iterator<T> for MoveIterator<T> {
     #[inline]
     fn next(&mut self) -> Option<T> {
-        unsafe {
-            self.iter.next().map(|x| ptr::read_ptr(x))
+        // this is peculiar, but is required for safety with respect
+        // to dtors. It traverses the first half of the vec, and
+        // removes them by swapping them with the last element (and
+        // popping), which results in the second half in reverse
+        // order, and so these can just be pop'd off. That is,
+        //
+        // [1,2,3,4,5] => 1, [5,2,3,4] => 2, [5,4,3] => 3, [5,4] => 4,
+        // [5] -> 5, []
+        let l = self.v.len();
+        if self.idx < l {
+            self.v.swap(self.idx, l - 1);
+            self.idx += 1;
         }
+
+        self.v.pop_opt()
     }
 
     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) {
-        self.iter.size_hint()
+        let l = self.v.len();
+        (l, Some(l))
     }
 }
 
-impl<T> DoubleEndedIterator<T> for MoveIterator<T> {
+/// An iterator that moves out of a vector in reverse order.
+#[deriving(Clone)]
+pub struct MoveRevIterator<T> {
+    priv v: ~[T]
+}
+
+impl<T> Iterator<T> for MoveRevIterator<T> {
     #[inline]
-    fn next_back(&mut self) -> Option<T> {
-        unsafe {
-            self.iter.next_back().map(|x| ptr::read_ptr(x))
-        }
+    fn next(&mut self) -> Option<T> {
+        self.v.pop_opt()
     }
-}
 
-#[unsafe_destructor]
-impl<T> Drop for MoveIterator<T> {
-    fn drop(&mut self) {
-        unsafe {
-            // destroy the remaining elements
-            for x in self.iter {
-                ptr::read_ptr(x);
-            }
-            if owns_managed::<T>() {
-                local_free(self.allocation as *u8 as *c_char)
-            } else {
-                exchange_free(self.allocation as *u8 as *c_char)
-            }
-        }
+    #[inline]
+    fn size_hint(&self) -> (uint, Option<uint>) {
+        let l = self.v.len();
+        (l, Some(l))
     }
 }
 
-/// An iterator that moves out of a vector in reverse order.
-pub type MoveRevIterator<T> = Invert<MoveIterator<T>>;
-
 impl<A> FromIterator<A> for ~[A] {
     fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> ~[A] {
         let (lower, _) = iterator.size_hint();

branches/try2/src/libsyntax/visit.rs

@@ -290,10 +290,6 @@ pub fn walk_variant<E:Clone, V:Visitor<E>>(visitor:&mut V,
                                      env.clone())
         }
     }
-    match variant.node.disr_expr {
-        Some(expr) => visitor.visit_expr(expr, env),
-        None => ()
-    }
 }
 
 pub fn skip_ty<E, V:Visitor<E>>(_: &mut V, _: &Ty, _: E) {

branches/try2/src/test/compile-fail/lint-dead-code-1.rs

@@ -27,7 +27,6 @@ static priv_static: int = 0; //~ ERROR: code is never used
 static used_static: int = 0;
 pub static used_static2: int = used_static;
 static USED_STATIC: int = 0;
-static STATIC_USED_IN_ENUM_DISCRIMINANT: uint = 10;
 
 pub type typ = ~UsedStruct4;
 pub struct PubStruct();
@@ -42,15 +41,8 @@ struct SemiUsedStruct;
 impl SemiUsedStruct {
     fn la_la_la() {}
 }
-struct StructUsedAsField;
-struct StructUsedInEnum;
-pub struct PubStruct2 {
-    struct_used_as_field: *StructUsedAsField
-}
 
 pub enum pub_enum { foo1, bar1 }
-pub enum pub_enum2 { a(~StructUsedInEnum) }
-pub enum pub_enum3 { Foo = STATIC_USED_IN_ENUM_DISCRIMINANT }
 enum priv_enum { foo2, bar2 } //~ ERROR: code is never used
 enum used_enum { foo3, bar3 }